def get_attr_fe_type(typ):
"""
Get the Numba type of member *struct_attr* in *typ*.
"""
model = default_manager.lookup(typ)
if not isinstance(model, StructModel):
raise TypeError("make_struct_attribute_wrapper() needs a type "
"with a StructModel, but got %s" % (model, ))
return model.get_member_fe_type(struct_attr)
def test_arrays(self):
@njit(debug=True)
def foo():
a = np.ones((2, 3), dtype=np.float64)
return a
metadata = self._get_metadata(foo, sig=())
metadata_definition_map = self._get_metadata_map(metadata)
for k, v in metadata_definition_map.items():
if 'DILocalVariable(name: "a"' in v:
lvar = metadata_definition_map[k]
break
else:
assert 0, "missing DILocalVariable 'a'"
type_marker = re.match('.*type: (![0-9]+).*', lvar).groups()[0]
type_decl = metadata_definition_map[type_marker]
# check type
self.assertIn("!DICompositeType(tag: DW_TAG_structure_type", type_decl)
# check name encoding
self.assertIn(f'name: "{str(types.float64[:, ::1])}', type_decl)
# pop out the "elements" of the composite type
match_elements = re.compile(r'.*elements: (![0-9]+),.*')
elem_matches = match_elements.match(type_decl).groups()
self.assertEqual(len(elem_matches), 1)
elem_match = elem_matches[0]
# The match should be something like, it's the elements from an array
# data model.
# !{!35, !36, !37, !39, !40, !43, !45}'
struct_markers = metadata_definition_map[elem_match]
struct_pattern = '!{' + '(![0-9]+), ' * 6 + '(![0-9]+)}'
match_struct = re.compile(struct_pattern)
struct_member_matches = match_struct.match(struct_markers).groups()
self.assertIsNotNone(struct_member_matches is not None)
data_model = default_manager.lookup(types.float64[:, ::1])
self.assertEqual(len(struct_member_matches), len(data_model._fields))
ptr_size = types.intp.bitwidth
ptr_re = (r'!DIDerivedType\(tag: DW_TAG_pointer_type, '
rf'baseType: ![0-9]+, size: {ptr_size}\)')
int_re = (rf'!DIBasicType\(name: "int{ptr_size}", size: {ptr_size}, '
r'encoding: DW_ATE_signed\)')
utuple_re = (r'!DICompositeType\(tag: DW_TAG_array_type, '
rf'name: "UniTuple\(int{ptr_size} x 2\) '
rf'\(\[2 x i{ptr_size}\]\)", baseType: ![0-9]+, '
rf'size: {2 * ptr_size}, elements: ![0-9]+, '
rf'identifier: "\[2 x i{ptr_size}\]"\)')
expected = {
'meminfo': ptr_re,
'parent': ptr_re,
'nitems': int_re,
'itemsize': int_re,
'data': ptr_re,
'shape': utuple_re,
'strides': utuple_re
}
# look for `baseType: <>` for the type
base_type_pattern = r'!DIDerivedType\(.*, baseType: (![0-9]+),.*'
base_type_matcher = re.compile(base_type_pattern)
for ix, field in enumerate(data_model._fields):
derived_type = metadata_definition_map[struct_member_matches[ix]]
self.assertIn("DIDerivedType", derived_type)
self.assertIn(f'name: "{field}"', derived_type)
base_type_match = base_type_matcher.match(derived_type)
base_type_matches = base_type_match.groups()
self.assertEqual(len(base_type_matches), 1)
base_type_marker = base_type_matches[0]
data_type = metadata_definition_map[base_type_marker]
self.assertRegex(data_type, expected[field])