| # Copyright 2019 Google LLC |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # https://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| |
| """Tests for emboss.front_end.symbol_resolver.""" |
| |
| import unittest |
| from compiler.front_end import glue |
| from compiler.front_end import symbol_resolver |
| from compiler.util import error |
| from compiler.util import test_util |
| |
| _HAPPY_EMB = """ |
| struct Foo: |
| 0 [+4] UInt uint_field |
| 4 [+4] Bar bar_field |
| 8 [+16] UInt[4] array_field |
| |
| struct Bar: |
| 0 [+4] Qux bar |
| |
| enum Qux: |
| ABC = 1 |
| DEF = 2 |
| |
| struct FieldRef: |
| n-4 [+n] UInt:8[n] data |
| offset-4 [+offset] UInt:8[offset] data2 |
| 0 [+4] UInt offset (n) |
| |
| struct VoidLength: |
| 0 [+10] UInt:8[] ten_bytes |
| |
| enum Quux: |
| ABC = 1 |
| DEF = ABC |
| |
| struct UsesParameter(x: UInt:8): |
| 0 [+x] UInt:8[] block |
| """ |
| |
| |
| class ResolveSymbolsTest(unittest.TestCase): |
| """Tests for symbol_resolver.resolve_symbols().""" |
| |
| def _construct_ir_multiple(self, file_dict, primary_emb_name): |
| ir, unused_debug_info, errors = glue.parse_emboss_file( |
| primary_emb_name, |
| test_util.dict_file_reader(file_dict), |
| stop_before_step="resolve_symbols") |
| assert not errors |
| return ir |
| |
| def _construct_ir(self, emb_text, name="happy.emb"): |
| return self._construct_ir_multiple({name: emb_text}, name) |
| |
| def test_struct_field_atomic_type_resolution(self): |
| ir = self._construct_ir(_HAPPY_EMB) |
| self.assertEqual([], symbol_resolver.resolve_symbols(ir)) |
| struct_ir = ir.module[0].type[0].structure |
| atomic_field1_reference = struct_ir.field[0].type.atomic_type.reference |
| self.assertEqual(atomic_field1_reference.canonical_name.object_path, ["UInt" |
| ]) |
| self.assertEqual(atomic_field1_reference.canonical_name.module_file, "") |
| atomic_field2_reference = struct_ir.field[1].type.atomic_type.reference |
| self.assertEqual(atomic_field2_reference.canonical_name.object_path, ["Bar" |
| ]) |
| self.assertEqual(atomic_field2_reference.canonical_name.module_file, |
| "happy.emb") |
| |
| def test_struct_field_enum_type_resolution(self): |
| ir = self._construct_ir(_HAPPY_EMB) |
| self.assertEqual([], symbol_resolver.resolve_symbols(ir)) |
| struct_ir = ir.module[0].type[1].structure |
| atomic_field_reference = struct_ir.field[0].type.atomic_type.reference |
| self.assertEqual(atomic_field_reference.canonical_name.object_path, ["Qux"]) |
| self.assertEqual(atomic_field_reference.canonical_name.module_file, |
| "happy.emb") |
| |
| def test_struct_field_array_type_resolution(self): |
| ir = self._construct_ir(_HAPPY_EMB) |
| self.assertEqual([], symbol_resolver.resolve_symbols(ir)) |
| array_field_type = ir.module[0].type[0].structure.field[2].type.array_type |
| array_field_reference = array_field_type.base_type.atomic_type.reference |
| self.assertEqual(array_field_reference.canonical_name.object_path, ["UInt"]) |
| self.assertEqual(array_field_reference.canonical_name.module_file, "") |
| |
| def test_inner_type_resolution(self): |
| ir = self._construct_ir(_HAPPY_EMB) |
| self.assertEqual([], symbol_resolver.resolve_symbols(ir)) |
| array_field_type = ir.module[0].type[0].structure.field[2].type.array_type |
| array_field_reference = array_field_type.base_type.atomic_type.reference |
| self.assertEqual(array_field_reference.canonical_name.object_path, ["UInt"]) |
| self.assertEqual(array_field_reference.canonical_name.module_file, "") |
| |
| def test_struct_field_resolution_in_expression_in_location(self): |
| ir = self._construct_ir(_HAPPY_EMB) |
| self.assertEqual([], symbol_resolver.resolve_symbols(ir)) |
| struct_ir = ir.module[0].type[3].structure |
| field0_loc = struct_ir.field[0].location |
| abbreviation_reference = field0_loc.size.field_reference.path[0] |
| self.assertEqual(abbreviation_reference.canonical_name.object_path, |
| ["FieldRef", "offset"]) |
| self.assertEqual(abbreviation_reference.canonical_name.module_file, |
| "happy.emb") |
| field0_start_left = field0_loc.start.function.args[0] |
| nested_abbreviation_reference = field0_start_left.field_reference.path[0] |
| self.assertEqual(nested_abbreviation_reference.canonical_name.object_path, |
| ["FieldRef", "offset"]) |
| self.assertEqual(nested_abbreviation_reference.canonical_name.module_file, |
| "happy.emb") |
| field1_loc = struct_ir.field[1].location |
| direct_reference = field1_loc.size.field_reference.path[0] |
| self.assertEqual(direct_reference.canonical_name.object_path, ["FieldRef", |
| "offset"]) |
| self.assertEqual(direct_reference.canonical_name.module_file, "happy.emb") |
| field1_start_left = field1_loc.start.function.args[0] |
| nested_direct_reference = field1_start_left.field_reference.path[0] |
| self.assertEqual(nested_direct_reference.canonical_name.object_path, |
| ["FieldRef", "offset"]) |
| self.assertEqual(nested_direct_reference.canonical_name.module_file, |
| "happy.emb") |
| |
| def test_struct_field_resolution_in_expression_in_array_length(self): |
| ir = self._construct_ir(_HAPPY_EMB) |
| self.assertEqual([], symbol_resolver.resolve_symbols(ir)) |
| struct_ir = ir.module[0].type[3].structure |
| field0_array_type = struct_ir.field[0].type.array_type |
| field0_array_element_count = field0_array_type.element_count |
| abbreviation_reference = field0_array_element_count.field_reference.path[0] |
| self.assertEqual(abbreviation_reference.canonical_name.object_path, |
| ["FieldRef", "offset"]) |
| self.assertEqual(abbreviation_reference.canonical_name.module_file, |
| "happy.emb") |
| field1_array_type = struct_ir.field[1].type.array_type |
| direct_reference = field1_array_type.element_count.field_reference.path[0] |
| self.assertEqual(direct_reference.canonical_name.object_path, ["FieldRef", |
| "offset"]) |
| self.assertEqual(direct_reference.canonical_name.module_file, "happy.emb") |
| |
| def test_struct_parameter_resolution(self): |
| ir = self._construct_ir(_HAPPY_EMB) |
| self.assertEqual([], symbol_resolver.resolve_symbols(ir)) |
| struct_ir = ir.module[0].type[6].structure |
| size_ir = struct_ir.field[0].location.size |
| self.assertTrue(size_ir.HasField("field_reference")) |
| self.assertEqual(size_ir.field_reference.path[0].canonical_name.object_path, |
| ["UsesParameter", "x"]) |
| |
| def test_enum_value_resolution_in_expression_in_enum_field(self): |
| ir = self._construct_ir(_HAPPY_EMB) |
| self.assertEqual([], symbol_resolver.resolve_symbols(ir)) |
| enum_ir = ir.module[0].type[5].enumeration |
| value_reference = enum_ir.value[1].value.constant_reference |
| self.assertEqual(value_reference.canonical_name.object_path, |
| ["Quux", "ABC"]) |
| self.assertEqual(value_reference.canonical_name.module_file, "happy.emb") |
| |
| def test_symbol_resolution_in_expression_in_void_array_length(self): |
| ir = self._construct_ir(_HAPPY_EMB) |
| self.assertEqual([], symbol_resolver.resolve_symbols(ir)) |
| struct_ir = ir.module[0].type[4].structure |
| array_type = struct_ir.field[0].type.array_type |
| # The symbol resolver should ignore void fields. |
| self.assertEqual("automatic", array_type.WhichOneof("size")) |
| |
| def test_name_definitions_have_correct_canonical_names(self): |
| ir = self._construct_ir(_HAPPY_EMB) |
| self.assertEqual([], symbol_resolver.resolve_symbols(ir)) |
| foo_name = ir.module[0].type[0].name |
| self.assertEqual(foo_name.canonical_name.object_path, ["Foo"]) |
| self.assertEqual(foo_name.canonical_name.module_file, "happy.emb") |
| uint_field_name = ir.module[0].type[0].structure.field[0].name |
| self.assertEqual(uint_field_name.canonical_name.object_path, ["Foo", |
| "uint_field"]) |
| self.assertEqual(uint_field_name.canonical_name.module_file, "happy.emb") |
| foo_name = ir.module[0].type[2].name |
| self.assertEqual(foo_name.canonical_name.object_path, ["Qux"]) |
| self.assertEqual(foo_name.canonical_name.module_file, "happy.emb") |
| |
| def test_duplicate_type_name(self): |
| ir = self._construct_ir("struct Foo:\n" |
| " 0 [+4] UInt field\n" |
| "struct Foo:\n" |
| " 0 [+4] UInt bar\n", "duplicate_type.emb") |
| errors = error.filter_errors(symbol_resolver.resolve_symbols(ir)) |
| self.assertEqual([ |
| [error.error("duplicate_type.emb", |
| ir.module[0].type[1].name.source_location, |
| "Duplicate name 'Foo'"), |
| error.note("duplicate_type.emb", |
| ir.module[0].type[0].name.source_location, |
| "Original definition")] |
| ], errors) |
| |
| def test_duplicate_field_name_in_struct(self): |
| ir = self._construct_ir("struct Foo:\n" |
| " 0 [+4] UInt field\n" |
| " 4 [+4] UInt field\n", "duplicate_field.emb") |
| errors = error.filter_errors(symbol_resolver.resolve_symbols(ir)) |
| struct = ir.module[0].type[0].structure |
| self.assertEqual([[ |
| error.error("duplicate_field.emb", |
| struct.field[1].name.source_location, |
| "Duplicate name 'field'"), |
| error.note("duplicate_field.emb", |
| struct.field[0].name.source_location, |
| "Original definition") |
| ]], errors) |
| |
| def test_duplicate_abbreviation_in_struct(self): |
| ir = self._construct_ir("struct Foo:\n" |
| " 0 [+4] UInt field1 (f)\n" |
| " 4 [+4] UInt field2 (f)\n", |
| "duplicate_field.emb") |
| errors = error.filter_errors(symbol_resolver.resolve_symbols(ir)) |
| struct = ir.module[0].type[0].structure |
| self.assertEqual([[ |
| error.error("duplicate_field.emb", |
| struct.field[1].abbreviation.source_location, |
| "Duplicate name 'f'"), |
| error.note("duplicate_field.emb", |
| struct.field[0].abbreviation.source_location, |
| "Original definition") |
| ]], errors) |
| |
| def test_abbreviation_duplicates_field_name_in_struct(self): |
| ir = self._construct_ir("struct Foo:\n" |
| " 0 [+4] UInt field\n" |
| " 4 [+4] UInt field2 (field)\n", |
| "duplicate_field.emb") |
| errors = error.filter_errors(symbol_resolver.resolve_symbols(ir)) |
| struct = ir.module[0].type[0].structure |
| self.assertEqual([[ |
| error.error("duplicate_field.emb", |
| struct.field[1].abbreviation.source_location, |
| "Duplicate name 'field'"), |
| error.note("duplicate_field.emb", |
| struct.field[0].name.source_location, |
| "Original definition") |
| ]], errors) |
| |
| def test_field_name_duplicates_abbreviation_in_struct(self): |
| ir = self._construct_ir("struct Foo:\n" |
| " 0 [+4] UInt field (field2)\n" |
| " 4 [+4] UInt field2\n", "duplicate_field.emb") |
| errors = error.filter_errors(symbol_resolver.resolve_symbols(ir)) |
| struct = ir.module[0].type[0].structure |
| self.assertEqual([[ |
| error.error("duplicate_field.emb", |
| struct.field[1].name.source_location, |
| "Duplicate name 'field2'"), |
| error.note("duplicate_field.emb", |
| struct.field[0].abbreviation.source_location, |
| "Original definition") |
| ]], errors) |
| |
| def test_duplicate_value_name_in_enum(self): |
| ir = self._construct_ir("enum Foo:\n" |
| " BAR = 1\n" |
| " BAR = 1\n", "duplicate_enum.emb") |
| errors = error.filter_errors(symbol_resolver.resolve_symbols(ir)) |
| self.assertEqual([[ |
| error.error( |
| "duplicate_enum.emb", |
| ir.module[0].type[0].enumeration.value[1].name.source_location, |
| "Duplicate name 'BAR'"), |
| error.note( |
| "duplicate_enum.emb", |
| ir.module[0].type[0].enumeration.value[0].name.source_location, |
| "Original definition") |
| ]], errors) |
| |
| def test_ambiguous_name(self): |
| # struct UInt will be ambiguous with the external UInt in the prelude. |
| ir = self._construct_ir("struct UInt:\n" |
| " 0 [+4] Int:8[4] field\n" |
| "struct Foo:\n" |
| " 0 [+4] UInt bar\n", "ambiguous.emb") |
| errors = error.filter_errors(symbol_resolver.resolve_symbols(ir)) |
| # Find the UInt definition in the prelude. |
| for type_ir in ir.module[1].type: |
| if type_ir.name.name.text == "UInt": |
| prelude_uint = type_ir |
| break |
| ambiguous_type_ir = ir.module[0].type[1].structure.field[0].type.atomic_type |
| self.assertEqual([[ |
| error.error("ambiguous.emb", |
| ambiguous_type_ir.reference.source_name[0].source_location, |
| "Ambiguous name 'UInt'"), error.note( |
| "", prelude_uint.name.source_location, |
| "Possible resolution"), |
| error.note("ambiguous.emb", ir.module[0].type[0].name.source_location, |
| "Possible resolution") |
| ]], errors) |
| |
| def test_missing_name(self): |
| ir = self._construct_ir("struct Foo:\n" |
| " 0 [+4] Bar field\n", |
| "missing.emb") |
| errors = error.filter_errors(symbol_resolver.resolve_symbols(ir)) |
| missing_type_ir = ir.module[0].type[0].structure.field[0].type.atomic_type |
| self.assertEqual([ |
| [error.error("missing.emb", |
| missing_type_ir.reference.source_name[0].source_location, |
| "No candidate for 'Bar'")] |
| ], errors) |
| |
| def test_missing_leading_name(self): |
| ir = self._construct_ir("struct Foo:\n" |
| " 0 [+Num.FOUR] UInt field\n", "missing.emb") |
| errors = error.filter_errors(symbol_resolver.resolve_symbols(ir)) |
| missing_expr_ir = ir.module[0].type[0].structure.field[0].location.size |
| self.assertEqual([ |
| [error.error( |
| "missing.emb", |
| missing_expr_ir.constant_reference.source_name[0].source_location, |
| "No candidate for 'Num'")] |
| ], errors) |
| |
| def test_missing_trailing_name(self): |
| ir = self._construct_ir("struct Foo:\n" |
| " 0 [+Num.FOUR] UInt field\n" |
| "enum Num:\n" |
| " THREE = 3\n", "missing.emb") |
| errors = error.filter_errors(symbol_resolver.resolve_symbols(ir)) |
| missing_expr_ir = ir.module[0].type[0].structure.field[0].location.size |
| self.assertEqual([ |
| [error.error( |
| "missing.emb", |
| missing_expr_ir.constant_reference.source_name[1].source_location, |
| "No candidate for 'FOUR'")] |
| ], errors) |
| |
| def test_missing_middle_name(self): |
| ir = self._construct_ir("struct Foo:\n" |
| " 0 [+Num.NaN.FOUR] UInt field\n" |
| "enum Num:\n" |
| " FOUR = 4\n", "missing.emb") |
| errors = error.filter_errors(symbol_resolver.resolve_symbols(ir)) |
| missing_expr_ir = ir.module[0].type[0].structure.field[0].location.size |
| self.assertEqual([ |
| [error.error( |
| "missing.emb", |
| missing_expr_ir.constant_reference.source_name[1].source_location, |
| "No candidate for 'NaN'")] |
| ], errors) |
| |
| def test_inner_resolution(self): |
| ir = self._construct_ir( |
| "struct OuterStruct:\n" |
| "\n" |
| " struct InnerStruct2:\n" |
| " 0 [+1] InnerStruct.InnerEnum inner_enum\n" |
| "\n" |
| " struct InnerStruct:\n" |
| " enum InnerEnum:\n" |
| " ONE = 1\n" |
| "\n" |
| " 0 [+1] InnerEnum inner_enum\n" |
| "\n" |
| " 0 [+InnerStruct.InnerEnum.ONE] InnerStruct.InnerEnum inner_enum\n", |
| "nested.emb") |
| errors = symbol_resolver.resolve_symbols(ir) |
| self.assertFalse(errors) |
| outer_struct = ir.module[0].type[0] |
| inner_struct = outer_struct.subtype[1] |
| inner_struct_2 = outer_struct.subtype[0] |
| inner_enum = inner_struct.subtype[0] |
| self.assertEqual(["OuterStruct", "InnerStruct"], |
| list(inner_struct.name.canonical_name.object_path)) |
| self.assertEqual(["OuterStruct", "InnerStruct", "InnerEnum"], |
| list(inner_enum.name.canonical_name.object_path)) |
| self.assertEqual(["OuterStruct", "InnerStruct2"], |
| list(inner_struct_2.name.canonical_name.object_path)) |
| outer_field = outer_struct.structure.field[0] |
| outer_field_end_ref = outer_field.location.size.constant_reference |
| self.assertEqual( |
| ["OuterStruct", "InnerStruct", "InnerEnum", "ONE"], list( |
| outer_field_end_ref.canonical_name.object_path)) |
| self.assertEqual( |
| ["OuterStruct", "InnerStruct", "InnerEnum"], |
| list(outer_field.type.atomic_type.reference.canonical_name.object_path)) |
| inner_field_2_type = inner_struct_2.structure.field[0].type.atomic_type |
| self.assertEqual( |
| ["OuterStruct", "InnerStruct", "InnerEnum" |
| ], list(inner_field_2_type.reference.canonical_name.object_path)) |
| |
| def test_resolution_against_anonymous_bits(self): |
| ir = self._construct_ir("struct Struct:\n" |
| " 0 [+1] bits:\n" |
| " 7 [+1] Flag last_packet\n" |
| " 5 [+2] enum inline_inner_enum:\n" |
| " AA = 0\n" |
| " BB = 1\n" |
| " CC = 2\n" |
| " DD = 3\n" |
| " 0 [+5] UInt header_size (h)\n" |
| " 0 [+h] UInt:8[] header_bytes\n" |
| "\n" |
| "struct Struct2:\n" |
| " 0 [+1] Struct.InlineInnerEnum value\n", |
| "anonymity.emb") |
| errors = symbol_resolver.resolve_symbols(ir) |
| self.assertFalse(errors) |
| struct1 = ir.module[0].type[0] |
| struct1_bits_field = struct1.structure.field[0] |
| struct1_bits_field_type = struct1_bits_field.type.atomic_type.reference |
| struct1_byte_field = struct1.structure.field[4] |
| inner_bits = struct1.subtype[0] |
| inner_enum = struct1.subtype[1] |
| self.assertTrue(inner_bits.HasField("structure")) |
| self.assertTrue(inner_enum.HasField("enumeration")) |
| self.assertTrue(inner_bits.name.is_anonymous) |
| self.assertFalse(inner_enum.name.is_anonymous) |
| self.assertEqual(["Struct", "InlineInnerEnum"], |
| list(inner_enum.name.canonical_name.object_path)) |
| self.assertEqual( |
| ["Struct", "InlineInnerEnum", "AA"], |
| list(inner_enum.enumeration.value[0].name.canonical_name.object_path)) |
| self.assertEqual( |
| list(inner_bits.name.canonical_name.object_path), |
| list(struct1_bits_field_type.canonical_name.object_path)) |
| self.assertEqual(2, len(inner_bits.name.canonical_name.object_path)) |
| self.assertEqual( |
| ["Struct", "header_size"], |
| list(struct1_byte_field.location.size.field_reference.path[0]. |
| canonical_name.object_path)) |
| |
| def test_duplicate_name_in_different_inline_bits(self): |
| ir = self._construct_ir( |
| "struct Struct:\n" |
| " 0 [+1] bits:\n" |
| " 7 [+1] Flag a\n" |
| " 1 [+1] bits:\n" |
| " 0 [+1] Flag a\n", "duplicate_in_anon.emb") |
| errors = error.filter_errors(symbol_resolver.resolve_symbols(ir)) |
| supertype = ir.module[0].type[0] |
| self.assertEqual([[ |
| error.error( |
| "duplicate_in_anon.emb", |
| supertype.structure.field[3].name.source_location, |
| "Duplicate name 'a'"), |
| error.note( |
| "duplicate_in_anon.emb", |
| supertype.structure.field[1].name.source_location, |
| "Original definition") |
| ]], errors) |
| |
| def test_duplicate_name_in_same_inline_bits(self): |
| ir = self._construct_ir( |
| "struct Struct:\n" |
| " 0 [+1] bits:\n" |
| " 7 [+1] Flag a\n" |
| " 0 [+1] Flag a\n", "duplicate_in_anon.emb") |
| errors = symbol_resolver.resolve_symbols(ir) |
| supertype = ir.module[0].type[0] |
| self.assertEqual([[ |
| error.error( |
| "duplicate_in_anon.emb", |
| supertype.structure.field[2].name.source_location, |
| "Duplicate name 'a'"), |
| error.note( |
| "duplicate_in_anon.emb", |
| supertype.structure.field[1].name.source_location, |
| "Original definition") |
| ]], error.filter_errors(errors)) |
| |
| def test_import_type_resolution(self): |
| importer = ('import "ed.emb" as ed\n' |
| "struct Ff:\n" |
| " 0 [+1] ed.Gg gg\n") |
| imported = ("struct Gg:\n" |
| " 0 [+1] UInt qq\n") |
| ir = self._construct_ir_multiple({"ed.emb": imported, "er.emb": importer}, |
| "er.emb") |
| errors = symbol_resolver.resolve_symbols(ir) |
| self.assertEqual([], errors) |
| |
| def test_duplicate_import_name(self): |
| importer = ('import "ed.emb" as ed\n' |
| 'import "ed.emb" as ed\n' |
| "struct Ff:\n" |
| " 0 [+1] ed.Gg gg\n") |
| imported = ("struct Gg:\n" |
| " 0 [+1] UInt qq\n") |
| ir = self._construct_ir_multiple({"ed.emb": imported, "er.emb": importer}, |
| "er.emb") |
| errors = symbol_resolver.resolve_symbols(ir) |
| # Note: the error is on import[2] duplicating import[1] because the implicit |
| # prelude import is import[0]. |
| self.assertEqual([ |
| [error.error("er.emb", |
| ir.module[0].foreign_import[2].local_name.source_location, |
| "Duplicate name 'ed'"), |
| error.note("er.emb", |
| ir.module[0].foreign_import[1].local_name.source_location, |
| "Original definition")] |
| ], errors) |
| |
| def test_import_enum_resolution(self): |
| importer = ('import "ed.emb" as ed\n' |
| "struct Ff:\n" |
| " if ed.Gg.GG == ed.Gg.GG:\n" |
| " 0 [+1] UInt gg\n") |
| imported = ("enum Gg:\n" |
| " GG = 0\n") |
| ir = self._construct_ir_multiple({"ed.emb": imported, "er.emb": importer}, |
| "er.emb") |
| errors = symbol_resolver.resolve_symbols(ir) |
| self.assertEqual([], errors) |
| |
| def test_that_double_import_names_are_syntactically_invalid(self): |
| # There are currently no checks in resolve_symbols that it is not possible |
| # to get to symbols imported by another module, because it is syntactically |
| # invalid. This may change in the future, in which case this test should be |
| # fixed by adding an explicit check to resolve_symbols and checking the |
| # error message here. |
| importer = ('import "ed.emb" as ed\n' |
| "struct Ff:\n" |
| " 0 [+1] ed.ed2.Gg gg\n") |
| imported = 'import "ed2.emb" as ed2\n' |
| imported2 = ("struct Gg:\n" |
| " 0 [+1] UInt qq\n") |
| unused_ir, unused_debug_info, errors = glue.parse_emboss_file( |
| "er.emb", |
| test_util.dict_file_reader({"ed.emb": imported, |
| "ed2.emb": imported2, |
| "er.emb": importer}), |
| stop_before_step="resolve_symbols") |
| assert errors |
| |
| def test_no_error_when_inline_name_aliases_outer_name(self): |
| # The inline enum's complete type should be Foo.Foo. During parsing, the |
| # name is set to just "Foo", but symbol resolution should a) select the |
| # correct Foo, and b) not complain that multiple Foos could match. |
| ir = self._construct_ir( |
| "struct Foo:\n" |
| " 0 [+1] enum foo:\n" |
| " BAR = 0\n") |
| errors = symbol_resolver.resolve_symbols(ir) |
| self.assertEqual([], errors) |
| field = ir.module[0].type[0].structure.field[0] |
| self.assertEqual( |
| ["Foo", "Foo"], |
| list(field.type.atomic_type.reference.canonical_name.object_path)) |
| |
| def test_no_error_when_inline_name_in_anonymous_bits_aliases_outer_name(self): |
| # There is an extra layer of complexity when an inline type appears inside |
| # of an inline bits. |
| ir = self._construct_ir( |
| "struct Foo:\n" |
| " 0 [+1] bits:\n" |
| " 0 [+4] enum foo:\n" |
| " BAR = 0\n") |
| errors = symbol_resolver.resolve_symbols(ir) |
| self.assertEqual([], error.filter_errors(errors)) |
| field = ir.module[0].type[0].subtype[0].structure.field[0] |
| self.assertEqual( |
| ["Foo", "Foo"], |
| list(field.type.atomic_type.reference.canonical_name.object_path)) |
| |
| |
| class ResolveFieldReferencesTest(unittest.TestCase): |
| """Tests for symbol_resolver.resolve_field_references().""" |
| |
| def _construct_ir_multiple(self, file_dict, primary_emb_name): |
| ir, unused_debug_info, errors = glue.parse_emboss_file( |
| primary_emb_name, |
| test_util.dict_file_reader(file_dict), |
| stop_before_step="resolve_field_references") |
| assert not errors |
| return ir |
| |
| def _construct_ir(self, emb_text, name="happy.emb"): |
| return self._construct_ir_multiple({name: emb_text}, name) |
| |
| def test_subfield_resolution(self): |
| ir = self._construct_ir( |
| "struct Ff:\n" |
| " 0 [+1] Gg gg\n" |
| " 1 [+gg.qq] UInt:8[] data\n" |
| "struct Gg:\n" |
| " 0 [+1] UInt qq\n", "subfield.emb") |
| errors = symbol_resolver.resolve_field_references(ir) |
| self.assertFalse(errors) |
| ff = ir.module[0].type[0] |
| location_end_path = ff.structure.field[1].location.size.field_reference.path |
| self.assertEqual(["Ff", "gg"], |
| list(location_end_path[0].canonical_name.object_path)) |
| self.assertEqual(["Gg", "qq"], |
| list(location_end_path[1].canonical_name.object_path)) |
| |
| def test_aliased_subfield_resolution(self): |
| ir = self._construct_ir( |
| "struct Ff:\n" |
| " 0 [+1] Gg real_gg\n" |
| " 1 [+gg.qq] UInt:8[] data\n" |
| " let gg = real_gg\n" |
| "struct Gg:\n" |
| " 0 [+1] UInt real_qq\n" |
| " let qq = real_qq", "subfield.emb") |
| errors = symbol_resolver.resolve_field_references(ir) |
| self.assertFalse(errors) |
| ff = ir.module[0].type[0] |
| location_end_path = ff.structure.field[1].location.size.field_reference.path |
| self.assertEqual(["Ff", "gg"], |
| list(location_end_path[0].canonical_name.object_path)) |
| self.assertEqual(["Gg", "qq"], |
| list(location_end_path[1].canonical_name.object_path)) |
| |
| def test_aliased_aliased_subfield_resolution(self): |
| ir = self._construct_ir( |
| "struct Ff:\n" |
| " 0 [+1] Gg really_real_gg\n" |
| " 1 [+gg.qq] UInt:8[] data\n" |
| " let gg = real_gg\n" |
| " let real_gg = really_real_gg\n" |
| "struct Gg:\n" |
| " 0 [+1] UInt qq\n", "subfield.emb") |
| errors = symbol_resolver.resolve_field_references(ir) |
| self.assertFalse(errors) |
| ff = ir.module[0].type[0] |
| location_end_path = ff.structure.field[1].location.size.field_reference.path |
| self.assertEqual(["Ff", "gg"], |
| list(location_end_path[0].canonical_name.object_path)) |
| self.assertEqual(["Gg", "qq"], |
| list(location_end_path[1].canonical_name.object_path)) |
| |
| def test_subfield_resolution_fails(self): |
| ir = self._construct_ir( |
| "struct Ff:\n" |
| " 0 [+1] Gg gg\n" |
| " 1 [+gg.rr] UInt:8[] data\n" |
| "struct Gg:\n" |
| " 0 [+1] UInt qq\n", "subfield.emb") |
| errors = error.filter_errors(symbol_resolver.resolve_field_references(ir)) |
| self.assertEqual([ |
| [error.error("subfield.emb", ir.module[0].type[0].structure.field[ |
| 1].location.size.field_reference.path[1].source_name[ |
| 0].source_location, "No candidate for 'rr'")] |
| ], errors) |
| |
| def test_subfield_resolution_failure_shortcuts_further_resolution(self): |
| ir = self._construct_ir( |
| "struct Ff:\n" |
| " 0 [+1] Gg gg\n" |
| " 1 [+gg.rr.qq] UInt:8[] data\n" |
| "struct Gg:\n" |
| " 0 [+1] UInt qq\n", "subfield.emb") |
| errors = error.filter_errors(symbol_resolver.resolve_field_references(ir)) |
| self.assertEqual([ |
| [error.error("subfield.emb", ir.module[0].type[0].structure.field[ |
| 1].location.size.field_reference.path[1].source_name[ |
| 0].source_location, "No candidate for 'rr'")] |
| ], errors) |
| |
| def test_subfield_resolution_failure_with_aliased_name(self): |
| ir = self._construct_ir( |
| "struct Ff:\n" |
| " 0 [+1] Gg gg\n" |
| " 1 [+gg.gg] UInt:8[] data\n" |
| "struct Gg:\n" |
| " 0 [+1] UInt qq\n", "subfield.emb") |
| errors = error.filter_errors(symbol_resolver.resolve_field_references(ir)) |
| self.assertEqual([ |
| [error.error("subfield.emb", ir.module[0].type[0].structure.field[ |
| 1].location.size.field_reference.path[1].source_name[ |
| 0].source_location, "No candidate for 'gg'")] |
| ], errors) |
| |
| def test_subfield_resolution_failure_with_array(self): |
| ir = self._construct_ir( |
| "struct Ff:\n" |
| " 0 [+1] Gg[1] gg\n" |
| " 1 [+gg.qq] UInt:8[] data\n" |
| "struct Gg:\n" |
| " 0 [+1] UInt qq\n", "subfield.emb") |
| errors = error.filter_errors(symbol_resolver.resolve_field_references(ir)) |
| self.assertEqual([ |
| [error.error("subfield.emb", ir.module[0].type[0].structure.field[ |
| 1].location.size.field_reference.path[0].source_name[ |
| 0].source_location, "Cannot access member of array 'gg'")] |
| ], errors) |
| |
| def test_subfield_resolution_failure_with_int(self): |
| ir = self._construct_ir( |
| "struct Ff:\n" |
| " 0 [+1] UInt gg_source\n" |
| " 1 [+gg.qq] UInt:8[] data\n" |
| " let gg = gg_source + 1\n", |
| "subfield.emb") |
| errors = error.filter_errors(symbol_resolver.resolve_field_references(ir)) |
| error_field = ir.module[0].type[0].structure.field[1] |
| error_reference = error_field.location.size.field_reference |
| error_location = error_reference.path[0].source_name[0].source_location |
| self.assertEqual([ |
| [error.error("subfield.emb", error_location, |
| "Cannot access member of noncomposite field 'gg'")] |
| ], errors) |
| |
| def test_subfield_resolution_failure_with_int_no_cascade(self): |
| ir = self._construct_ir( |
| "struct Ff:\n" |
| " 0 [+1] UInt gg_source\n" |
| " 1 [+qqx] UInt:8[] data\n" |
| " let gg = gg_source + 1\n" |
| " let yy = gg.no_field\n" |
| " let qqx = yy.x\n" |
| " let qqy = yy.y\n", |
| "subfield.emb") |
| errors = error.filter_errors(symbol_resolver.resolve_field_references(ir)) |
| error_field = ir.module[0].type[0].structure.field[3] |
| error_reference = error_field.read_transform.field_reference |
| error_location = error_reference.path[0].source_name[0].source_location |
| self.assertEqual([ |
| [error.error("subfield.emb", error_location, |
| "Cannot access member of noncomposite field 'gg'")] |
| ], errors) |
| |
| def test_subfield_resolution_failure_with_abbreviation(self): |
| ir = self._construct_ir( |
| "struct Ff:\n" |
| " 0 [+1] Gg gg\n" |
| " 1 [+gg.q] UInt:8[] data\n" |
| "struct Gg:\n" |
| " 0 [+1] UInt qq (q)\n", "subfield.emb") |
| errors = error.filter_errors(symbol_resolver.resolve_field_references(ir)) |
| self.assertEqual([ |
| # TODO(bolms): Make the error message clearer, in this case. |
| [error.error("subfield.emb", ir.module[0].type[0].structure.field[ |
| 1].location.size.field_reference.path[1].source_name[ |
| 0].source_location, "No candidate for 'q'")] |
| ], errors) |
| |
| |
| if __name__ == "__main__": |
| unittest.main() |
