def test_stringify_type(self):
fake_span = self.fake_span
m = self.m
number_5 = ast.Number(m, fake_span, '5')
number_2 = ast.Number(m, fake_span, '2')
number_3 = ast.Number(m, fake_span, '3')
bits_token = Token(value=Keyword.BITS, span=fake_span)
type_ = ast_helpers.make_builtin_type_annotation(
m, fake_span, bits_token, (number_5, ))
self.assertEqual('bits[5]', str(type_))
type_ = ast_helpers.make_builtin_type_annotation(
m, fake_span, Token(value=Keyword.U32, span=fake_span),
(number_5, ))
self.assertEqual('u32[5]', str(type_))
# "no-volume" bits array.
# TODO(leary): 2020-08-24 delete bits in favor of uN
type_ = ast_helpers.make_builtin_type_annotation(
m, fake_span, bits_token, ())
self.assertEqual('bits', str(type_))
# TypeRef with dims.
my_type_tok = Token(TokenKind.IDENTIFIER,
value='MyType',
span=fake_span)
name_def = ast.NameDef(m, fake_span, 'MyType')
type_def = ast.TypeDef(m, fake_span, name_def, type_, public=False)
type_ref = ast.TypeRef(m, fake_span, my_type_tok.value, type_def)
type_ = ast_helpers.make_type_ref_type_annotation(
m, fake_span, type_ref, (number_2, number_3))
self.assertEqual('MyType[2][3]', str(type_))
def test_type_annotation_properties(self):
m = self.m
fake_span = self.fake_span
number_5 = ast.Number(m, fake_span, '5')
number_2 = ast.Number(m, fake_span, '2')
number_3 = ast.Number(m, fake_span, '3')
bits_token = Token(value=Keyword.BITS, span=fake_span)
un_token = Token(value=Keyword.UN, span=fake_span)
u32_token = Token(value=Keyword.U32, span=fake_span)
type_ = ast_helpers.make_builtin_type_annotation(
m, fake_span, bits_token, (number_5, ))
self.assertEqual('bits[5]', str(type_))
type_ = ast_helpers.make_builtin_type_annotation(
m, fake_span, bits_token, (number_5, number_2))
self.assertIsInstance(type_, ast.ArrayTypeAnnotation)
self.assertEqual('bits[5][2]', str(type_))
type_ = ast_helpers.make_builtin_type_annotation(
m, fake_span, u32_token, ())
self.assertEqual('u32', str(type_))
type_ = ast_helpers.make_builtin_type_annotation(
m, fake_span, u32_token, (number_3, ))
self.assertIsInstance(type_, ast.ArrayTypeAnnotation)
self.assertEqual('u32[3]', str(type_))
type_ = ast_helpers.make_builtin_type_annotation(
m, fake_span, un_token, (number_2, ))
self.assertEqual('uN[2]', str(type_))
type_ = ast_helpers.make_builtin_type_annotation(
m, fake_span, un_token, (number_2, number_3))
self.assertIsInstance(type_, ast.ArrayTypeAnnotation)
self.assertEqual('uN[2][3]', str(type_))
# TODO(leary): 2020-08-24 delete bits in favor of uN
# "no-volume" bits array.
type_ = ast_helpers.make_builtin_type_annotation(
m, fake_span, bits_token, ())
self.assertEqual('bits', str(type_))
# TypeRef with dims.
name_def = ast.NameDef(m, fake_span, 'MyType')
type_def = ast.TypeDef(m, fake_span, name_def, type_, public=False)
type_ref = ast.TypeRef(m, fake_span, 'MyType', type_def)
type_ = ast_helpers.make_type_ref_type_annotation(
m, fake_span, type_ref, (number_2, number_3))
self.assertIsInstance(type_, ast.ArrayTypeAnnotation)
self.assertEqual('MyType[2][3]', str(type_))
type_ = ast.TupleTypeAnnotation(
m, fake_span,
(ast_helpers.make_builtin_type_annotation(m, fake_span, bits_token,
(number_5, )),
ast_helpers.make_builtin_type_annotation(m, fake_span, bits_token,
(number_2, ))))
self.assertIsInstance(type_, ast.TupleTypeAnnotation)
self.assertEqual('(bits[5], bits[2])', str(type_))
def test_array_of_numbers(self):
m = ast.Module('test')
n0 = ast.Number(m, self.fake_span, '42')
n1 = ast.Number(m, self.fake_span, '64')
a = ast.Array(m, self.fake_span, [n0, n1], False)
collector = Collector()
cpp_ast_visitor.visit(a, collector)
self.assertEqual(collector.visited, [n0, n1, a])
def _make_number(self, value: int,
type_: Optional[ast.TypeAnnotation]) -> ast.Number:
"""Creates a number AST node with value 'value' of type 'type_'."""
if self._is_builtin_bool(type_):
assert 0 <= value <= 1, value
return ast.Number(self.m, self.fake_span, 'true' if value else 'false',
ast.NumberKind.BOOL, type_)
return ast.Number(self.m, self.fake_span, hex(value), ast.NumberKind.OTHER,
type_)
def test_simple_number(self):
m = ast.Module('test')
n = ast.Number(m, self.fake_span, '42')
self.assertEmpty(n.children)
collector = Collector()
cpp_ast_visitor.visit(n, collector)
self.assertEqual(collector.visited, [n])
def test_module_with_constant(self):
m = cpp_ast.Module('test')
name_def = cpp_ast.NameDef(m, self.fake_span, 'MOL')
number = cpp_ast.Number(m, self.fake_span, '42')
constant_def = cpp_ast.Constant(m, name_def, number)
m.add_top(constant_def)
self.assertEqual(str(m), 'const MOL = 42;')
def test_visit_match_multi_pattern(self):
fake_pos = self.fake_pos
fake_span = Span(fake_pos, fake_pos)
m = self.m
e = ast.Number(m, fake_span, u'0xf00')
p0 = ast.NameDefTree(m, fake_span, e)
p1 = ast.NameDefTree(m, fake_span, e)
arm = ast.MatchArm(m, fake_span, patterns=(p0, p1), expr=e)
c = _Collector()
visit(arm, c)
self.assertEqual(c.collected, [e, e, e])
def test_binop(self):
m = cpp_ast.Module('test')
ft = cpp_ast.Number(m, self.fake_span, '42')
sf = cpp_ast.Number(m, self.fake_span, '64')
add = cpp_ast.Binop(m, self.fake_span, cpp_ast.BinopKind.ADD, ft, sf)
self.assertEqual(str(add), '(42) + (64)')
def five(self) -> ast.Number:
return ast.Number(self.m, self.fake_span, '5')
def test_binary_number_with_underscores(self):
fake_pos = self.fake_pos
fake_span = Span(fake_pos, fake_pos)
n = ast.Number(self.m, fake_span, u'0b1_0_0_1')
self.assertEqual(9, ast_helpers.get_value_as_int(n))
def test_hex_number_with_underscores(self):
fake_pos = self.fake_pos
fake_span = Span(fake_pos, fake_pos)
n = ast.Number(self.m, fake_span, '0xf_abcde_1234')
self.assertEqual(0xfabcde1234, ast_helpers.get_value_as_int(n))
def test_unicode_hex_number(self):
fake_pos = self.fake_pos
fake_span = Span(fake_pos, fake_pos)
n = ast.Number(self.m, fake_span, u'0xf00')
self.assertEqual(0xf00, ast_helpers.get_value_as_int(n))
