def test_import_as(self):
program = """
import thing as other
"""
m = ast.Module('test')
bindings = parser.Bindings(None)
fparse = lambda p, bindings: p.parse_module(bindings)
m = self._parse_internal(program, bindings, fparse)
self.assertIsInstance(m.top[0], ast.Import)
fake_pos = Pos(self.fake_filename, 0, 0)
fake_span = Span(fake_pos, fake_pos)
self.assertIsInstance(bindings.resolve_node(m, 'other', fake_span),
ast.Import)
self.assertIsNone(bindings.resolve_node_or_none(m, 'thing'), None)
def test_bindings_stack(self):
m = ast.Module('test')
top = parser.Bindings(None)
leaf0 = parser.Bindings(top)
leaf1 = parser.Bindings(top)
a = ast.BuiltinNameDef(m, 'a')
b = ast.BuiltinNameDef(m, 'b')
c = ast.BuiltinNameDef(m, 'c')
top.add('a', a)
leaf0.add('b', b)
leaf1.add('c', c)
pos = Pos(self.fake_filename, lineno=0, colno=0)
span = Span(pos, pos)
self.assertEqual(leaf0.resolve(m, 'a', span), a)
self.assertEqual(leaf1.resolve(m, 'a', span), a)
self.assertEqual(top.resolve(m, 'a', span), a)
with self.assertRaises(CppParseError):
top.resolve(m, 'b', span)
with self.assertRaises(CppParseError):
leaf1.resolve(m, 'b', span)
with self.assertRaises(CppParseError):
leaf0.resolve(m, 'c', span)
self.assertEqual(leaf0.resolve(m, 'b', span), b)
self.assertEqual(leaf1.resolve(m, 'c', span), c)
def _parse_internal(
self, program: Text, bindings: Optional[parser.Bindings],
fparse: Callable[[parser.Parser, parser.Bindings],
TypeVar('T')]
) -> TypeVar('T'):
with fakefs_test_util.scoped_fakefs(self.fake_filename, program):
s = scanner.Scanner(self.fake_filename, program)
b = bindings or parser.Bindings(None)
try:
e = fparse(parser.Parser(s, 'test_module'), b)
except parser.CppParseError as e:
parser_helpers.pprint_positional_error(e)
raise
self.assertTrue(s.at_eof())
return e
def test_logical_operator_binding(self):
m = ast.Module('test')
b = parser.Bindings(None)
b.add('a', ast.BuiltinNameDef(m, 'a'))
b.add('b', ast.BuiltinNameDef(m, 'b'))
b.add('c', ast.BuiltinNameDef(m, 'c'))
e = self.parse_expression('!a || !b && c', bindings=b)
# This should group as:
# ((!a) || ((!b) && c))
self.assertTrue(e.kind, ast.BinopKind.LOGICAL_OR)
self.assertTrue(e.lhs.kind, ast.UnopKind.INV)
self.assertTrue(e.rhs.kind, ast.BinopKind.LOGICAL_AND)
self.assertEqual(e.rhs.lhs.kind, ast.UnopKind.INV)
self.assertIsInstance(e.rhs.rhs, ast.NameRef)
self.assertEqual(e.rhs.rhs.identifier, 'c')
def test_logical_equality(self):
m = ast.Module('test')
b = parser.Bindings(None)
b.add('a', ast.BuiltinNameDef(m, 'a'))
b.add('b', ast.BuiltinNameDef(m, 'b'))
b.add('f', ast.BuiltinNameDef(m, 'f'))
e = self.parse_expression('a ^ !b == f()', bindings=b)
# This should group as:
# ((a) ^ (!b)) == (f())
self.assertEqual(e.kind, ast.BinopKind.EQ)
self.assertTrue(e.lhs.kind, ast.BinopKind.XOR)
self.assertTrue(e.lhs.rhs.kind, ast.UnopKind.INV)
self.assertIsInstance(e.rhs, ast.Invocation)
self.assertIsInstance(e.rhs.callee, ast.NameRef)
self.assertEqual(e.rhs.callee.identifier, 'f')
def test_for_freevars(self):
program = """for (i, accum): (u32, u32) in range(4) {
let new_accum: u32 = accum + i + j;
new_accum
}(u32:0)"""
m = ast.Module('test')
b = parser.Bindings(None)
b.add('range', ast.BuiltinNameDef(m, 'range'))
b.add('j', ast.BuiltinNameDef(m, 'j'))
e = self.parse_expression(program, bindings=b)
self.assertIsInstance(e, ast.For)
self.assertEqual(e.span.start,
Pos(self.fake_filename, lineno=0, colno=3))
freevars = e.get_free_variables(e.span.start)
self.assertCountEqual(freevars.keys(), ['j', 'range'])
def test_bad_enum_ref(self):
program = """
enum MyEnum : u1 {
FOO = 0
}
fn my_fun() -> MyEnum {
FOO // Should be qualified as MyEnum::FOO!
}
"""
bindings = parser.Bindings(None)
fparse = lambda p, bindings: p.parse_module(bindings)
with self.assertRaises(CppParseError) as cm:
self._parse_internal(program, bindings, fparse)
self.assertIn('Cannot find a definition for name: \'FOO\'',
str(cm.exception))
def test_for(self):
program = textwrap.dedent("""
let accum: u32 = 0;
let accum: u32 = for (i, accum): (u32, u32) in range(4) {
let new_accum: u32 = accum + i;
new_accum
}(accum);
accum
""")
m = ast.Module('test')
b = parser.Bindings(None)
b.add('range', ast.BuiltinNameDef(m, 'range'))
e = self.parse_expression(program, bindings=b)
self.assertIsInstance(e, ast.Let)
self.assertIsInstance(e.body, ast.Let)
self.assertIsInstance(e.body.rhs, ast.For)
for_ = e.body.rhs
self.assertIsInstance(for_.init, ast.NameRef)
self.assertIsNot(for_.init.name_def, for_.names.tree[1].get_leaf())
def test_parse_name_def_tree(self):
text = 'let (a, (b, (c, d), e), f) = x; a'
m = ast.Module('test')
bindings = parser.Bindings()
bindings.add('x', ast.BuiltinNameDef(m, 'x'))
let = self.parse_expression(text, bindings)
self.assertIsInstance(let, ast.Let)
ndt = let.name_def_tree
self.assertIsInstance(ndt, ast.NameDefTree)
self.assertLen(ndt.tree, 3)
self.assertIsInstance(ndt.tree[0], ast.NameDefTree)
self.assertTrue(ndt.tree[0].is_leaf())
self.assertIsInstance(ndt.tree[2], ast.NameDefTree)
self.assertTrue(ndt.tree[2].is_leaf())
self.assertEqual(
ndt.tree[0].span,
Span(Pos(self.fake_filename, 0, 5), Pos(self.fake_filename, 0, 6)))
self.assertEqual(
ndt.tree[2].span,
Span(Pos(self.fake_filename, 0, 24), Pos(self.fake_filename, 0, 25)))
self.assertNotEqual(ndt.tree[2].span, ndt.tree[0].span)
def test_constant_array(self):
b = parser.Bindings(None)
e = self.parse_expression('u32[2]:[u32:0, u32:1]', bindings=b)
self.assertIsInstance(e, ast.ConstantArray)
