| # 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 front_end.type_check.""" |
| |
| import unittest |
| from compiler.front_end import glue |
| from compiler.front_end import test_util |
| from compiler.front_end import type_check |
| from compiler.util import error |
| |
| |
| class TypeAnnotationTest(unittest.TestCase): |
| |
| def _make_ir(self, emb_text): |
| ir, unused_debug_info, errors = glue.parse_emboss_file( |
| "m.emb", |
| test_util.dict_file_reader({"m.emb": emb_text}), |
| stop_before_step="annotate_types") |
| assert not errors, errors |
| return ir |
| |
| def test_adds_integer_constant_type(self): |
| ir = self._make_ir("struct Foo:\n" |
| " 0 [+1] UInt x\n" |
| " 1 [+1] UInt:8[] y\n") |
| self.assertEqual([], type_check.annotate_types(ir)) |
| expression = ir.module[0].type[0].structure.field[1].location.size |
| self.assertEqual(expression.type.WhichOneof("type"), "integer") |
| |
| def test_adds_boolean_constant_type(self): |
| ir = self._make_ir("struct Foo:\n" |
| " 0 [+1] UInt x\n" |
| " 1 [+true] UInt:8[] y\n") |
| self.assertEqual([], error.filter_errors(type_check.annotate_types(ir)), |
| ir.to_json(indent=2)) |
| expression = ir.module[0].type[0].structure.field[1].location.size |
| self.assertEqual(expression.type.WhichOneof("type"), "boolean") |
| |
| def test_adds_enum_constant_type(self): |
| ir = self._make_ir("struct Foo:\n" |
| " 0 [+Enum.VALUE] UInt x\n" |
| "enum Enum:\n" |
| " VALUE = 1\n") |
| self.assertEqual([], error.filter_errors(type_check.annotate_types(ir))) |
| expression = ir.module[0].type[0].structure.field[0].location.size |
| self.assertEqual(expression.type.WhichOneof("type"), "enumeration") |
| enum_type_name = expression.type.enumeration.name.canonical_name |
| self.assertEqual(enum_type_name.module_file, "m.emb") |
| self.assertEqual(enum_type_name.object_path[0], "Enum") |
| |
| def test_adds_enum_field_type(self): |
| ir = self._make_ir("struct Foo:\n" |
| " 0 [+1] Enum x\n" |
| " 1 [+x] UInt y\n" |
| "enum Enum:\n" |
| " VALUE = 1\n") |
| self.assertEqual([], error.filter_errors(type_check.annotate_types(ir))) |
| expression = ir.module[0].type[0].structure.field[1].location.size |
| self.assertEqual(expression.type.WhichOneof("type"), "enumeration") |
| enum_type_name = expression.type.enumeration.name.canonical_name |
| self.assertEqual(enum_type_name.module_file, "m.emb") |
| self.assertEqual(enum_type_name.object_path[0], "Enum") |
| |
| def test_adds_integer_operation_types(self): |
| ir = self._make_ir("struct Foo:\n" |
| " 0 [+1] UInt x\n" |
| " 1 [+1+1] UInt:8[] y\n") |
| self.assertEqual([], type_check.annotate_types(ir)) |
| expression = ir.module[0].type[0].structure.field[1].location.size |
| self.assertEqual(expression.type.WhichOneof("type"), "integer") |
| self.assertEqual(expression.function.args[0].type.WhichOneof("type"), |
| "integer") |
| self.assertEqual(expression.function.args[1].type.WhichOneof("type"), |
| "integer") |
| |
| def test_adds_enum_operation_type(self): |
| ir = self._make_ir("struct Foo:\n" |
| " 0 [+1] UInt x\n" |
| " 1 [+Enum.VAL==Enum.VAL] UInt:8[] y\n" |
| "enum Enum:\n" |
| " VAL = 1\n") |
| self.assertEqual([], error.filter_errors(type_check.annotate_types(ir))) |
| expression = ir.module[0].type[0].structure.field[1].location.size |
| self.assertEqual(expression.type.WhichOneof("type"), "boolean") |
| self.assertEqual(expression.function.args[0].type.WhichOneof("type"), |
| "enumeration") |
| self.assertEqual(expression.function.args[1].type.WhichOneof("type"), |
| "enumeration") |
| |
| def test_adds_integer_field_type(self): |
| ir = self._make_ir("struct Foo:\n" |
| " 0 [+1] UInt x\n" |
| " 1 [+x] UInt:8[] y\n") |
| self.assertEqual([], type_check.annotate_types(ir)) |
| expression = ir.module[0].type[0].structure.field[1].location.size |
| self.assertEqual(expression.type.WhichOneof("type"), "integer") |
| |
| def test_adds_opaque_field_type(self): |
| ir = self._make_ir("struct Foo:\n" |
| " 0 [+1] Bar x\n" |
| " 1 [+x] UInt:8[] y\n" |
| "struct Bar:\n" |
| " 0 [+1] UInt z\n") |
| self.assertEqual([], error.filter_errors(type_check.annotate_types(ir))) |
| expression = ir.module[0].type[0].structure.field[1].location.size |
| self.assertEqual(expression.type.WhichOneof("type"), "opaque") |
| |
| def test_adds_opaque_field_type_for_array(self): |
| ir = self._make_ir("struct Foo:\n" |
| " 0 [+1] UInt:8[] x\n" |
| " 1 [+x] UInt:8[] y\n") |
| self.assertEqual([], error.filter_errors(type_check.annotate_types(ir))) |
| expression = ir.module[0].type[0].structure.field[1].location.size |
| self.assertEqual(expression.type.WhichOneof("type"), "opaque") |
| |
| def test_error_on_bad_plus_operand_types(self): |
| ir = self._make_ir("struct Foo:\n" |
| " 0 [+1] UInt x\n" |
| " 1 [+1+true] UInt:8[] y\n") |
| expression = ir.module[0].type[0].structure.field[1].location.size |
| self.assertEqual([ |
| [error.error("m.emb", expression.function.args[1].source_location, |
| "Right argument of operator '+' must be an integer.")] |
| ], error.filter_errors(type_check.annotate_types(ir))) |
| |
| def test_error_on_bad_minus_operand_types(self): |
| ir = self._make_ir("struct Foo:\n" |
| " 0 [+1] UInt x\n" |
| " 1 [+1-true] UInt:8[] y\n") |
| expression = ir.module[0].type[0].structure.field[1].location.size |
| self.assertEqual([ |
| [error.error("m.emb", expression.function.args[1].source_location, |
| "Right argument of operator '-' must be an integer.")] |
| ], error.filter_errors(type_check.annotate_types(ir))) |
| |
| def test_error_on_bad_times_operand_types(self): |
| ir = self._make_ir("struct Foo:\n" |
| " 0 [+1] UInt x\n" |
| " 1 [+1*true] UInt:8[] y\n") |
| expression = ir.module[0].type[0].structure.field[1].location.size |
| self.assertEqual([ |
| [error.error("m.emb", expression.function.args[1].source_location, |
| "Right argument of operator '*' must be an integer.")] |
| ], error.filter_errors(type_check.annotate_types(ir))) |
| |
| def test_error_on_bad_equality_left_operand(self): |
| ir = self._make_ir("struct Foo:\n" |
| " 0 [+1] UInt:8[] x\n" |
| " 1 [+x==x] UInt:8[] y\n") |
| expression = ir.module[0].type[0].structure.field[1].location.size |
| self.assertEqual([ |
| [error.error("m.emb", expression.function.args[0].source_location, |
| "Left argument of operator '==' must be an integer, " |
| "boolean, or enum.")] |
| ], error.filter_errors(type_check.annotate_types(ir))) |
| |
| def test_error_on_bad_equality_right_operand(self): |
| ir = self._make_ir("struct Foo:\n" |
| " 0 [+1] UInt:8[] x\n" |
| " 1 [+1==x] UInt:8[] y\n") |
| expression = ir.module[0].type[0].structure.field[1].location.size |
| self.assertEqual([ |
| [error.error("m.emb", expression.source_location, |
| "Both arguments of operator '==' must have the same " |
| "type.")] |
| ], error.filter_errors(type_check.annotate_types(ir))) |
| |
| def test_error_on_equality_mismatched_operands_int_bool(self): |
| ir = self._make_ir("struct Foo:\n" |
| " 0 [+1] UInt x\n" |
| " 1 [+1==true] UInt:8[] y\n") |
| expression = ir.module[0].type[0].structure.field[1].location.size |
| self.assertEqual([ |
| [error.error("m.emb", expression.source_location, |
| "Both arguments of operator '==' must have the same " |
| "type.")] |
| ], error.filter_errors(type_check.annotate_types(ir))) |
| |
| def test_error_on_equality_mismatched_operands_bool_int(self): |
| ir = self._make_ir("struct Foo:\n" |
| " 0 [+1] UInt x\n" |
| " 1 [+true==1] UInt:8[] y\n") |
| expression = ir.module[0].type[0].structure.field[1].location.size |
| self.assertEqual([ |
| [error.error("m.emb", expression.source_location, |
| "Both arguments of operator '==' must have the same " |
| "type.")] |
| ], error.filter_errors(type_check.annotate_types(ir))) |
| |
| def test_error_on_equality_mismatched_operands_enum_enum(self): |
| ir = self._make_ir("struct Foo:\n" |
| " 0 [+1] UInt x\n" |
| " 1 [+Bar.BAR==Baz.BAZ] UInt:8[] y\n" |
| "enum Bar:\n" |
| " BAR = 1\n" |
| "enum Baz:\n" |
| " BAZ = 1\n") |
| expression = ir.module[0].type[0].structure.field[1].location.size |
| self.assertEqual([ |
| [error.error("m.emb", expression.source_location, |
| "Both arguments of operator '==' must have the same " |
| "type.")] |
| ], error.filter_errors(type_check.annotate_types(ir))) |
| |
| def test_error_on_bad_choice_condition_operand(self): |
| ir = self._make_ir("struct Foo:\n" |
| " 0 [+1] UInt:8[] x\n" |
| " 1 [+5 ? 0 : 1] UInt:8[] y\n") |
| expression = ir.module[0].type[0].structure.field[1].location.size |
| condition_arg = expression.function.args[0] |
| self.assertEqual([ |
| [error.error("m.emb", condition_arg.source_location, |
| "Condition of operator '?:' must be a boolean.")] |
| ], error.filter_errors(type_check.annotate_types(ir))) |
| |
| def test_error_on_bad_choice_if_true_operand(self): |
| ir = self._make_ir("struct Foo:\n" |
| " 0 [+1] UInt:8[] x\n" |
| " 1 [+true ? x : x] UInt:8[] y\n") |
| expression = ir.module[0].type[0].structure.field[1].location.size |
| if_true_arg = expression.function.args[1] |
| self.assertEqual([ |
| [error.error("m.emb", if_true_arg.source_location, |
| "If-true clause of operator '?:' must be an integer, " |
| "boolean, or enum.")] |
| ], error.filter_errors(type_check.annotate_types(ir))) |
| |
| def test_choice_of_bools(self): |
| ir = self._make_ir("struct Foo:\n" |
| " 0 [+1] UInt:8[] x\n" |
| " 1 [+true ? true : false] UInt:8[] y\n") |
| expression = ir.module[0].type[0].structure.field[1].location.size |
| self.assertEqual([], error.filter_errors(type_check.annotate_types(ir))) |
| self.assertEqual("boolean", expression.type.WhichOneof("type")) |
| |
| def test_choice_of_integers(self): |
| ir = self._make_ir("struct Foo:\n" |
| " 0 [+1] UInt:8[] x\n" |
| " 1 [+true ? 0 : 100] UInt:8[] y\n") |
| expression = ir.module[0].type[0].structure.field[1].location.size |
| self.assertEqual([], type_check.annotate_types(ir)) |
| self.assertEqual("integer", expression.type.WhichOneof("type")) |
| |
| def test_choice_of_enums(self): |
| ir = self._make_ir("struct Foo:\n" |
| " 0 [+1] enum xx:\n" |
| " XX = 1\n" |
| " YY = 1\n" |
| " 1 [+true ? Xx.XX : Xx.YY] UInt:8[] y\n") |
| expression = ir.module[0].type[0].structure.field[1].location.size |
| self.assertEqual([], error.filter_errors(type_check.annotate_types(ir))) |
| self.assertEqual("enumeration", expression.type.WhichOneof("type")) |
| self.assertFalse(expression.type.enumeration.HasField("value")) |
| self.assertEqual( |
| "m.emb", expression.type.enumeration.name.canonical_name.module_file) |
| self.assertEqual( |
| "Foo", expression.type.enumeration.name.canonical_name.object_path[0]) |
| self.assertEqual( |
| "Xx", expression.type.enumeration.name.canonical_name.object_path[1]) |
| |
| def test_error_on_bad_choice_mismatched_operands(self): |
| ir = self._make_ir("struct Foo:\n" |
| " 0 [+1] UInt:8[] x\n" |
| " 1 [+true ? 0 : true] UInt:8[] y\n") |
| expression = ir.module[0].type[0].structure.field[1].location.size |
| self.assertEqual([ |
| [error.error("m.emb", expression.source_location, |
| "The if-true and if-false clauses of operator '?:' must " |
| "have the same type.")] |
| ], error.filter_errors(type_check.annotate_types(ir))) |
| |
| def test_error_on_bad_choice_mismatched_enum_operands(self): |
| ir = self._make_ir("struct Foo:\n" |
| " 0 [+1] UInt:8[] x\n" |
| " 1 [+true ? Baz.BAZ : Bar.BAR] UInt:8[] y\n" |
| "enum Bar:\n" |
| " BAR = 1\n" |
| "enum Baz:\n" |
| " BAZ = 1\n") |
| expression = ir.module[0].type[0].structure.field[1].location.size |
| self.assertEqual([ |
| [error.error("m.emb", expression.source_location, |
| "The if-true and if-false clauses of operator '?:' must " |
| "have the same type.")] |
| ], error.filter_errors(type_check.annotate_types(ir))) |
| |
| def test_error_on_bad_left_operand_type(self): |
| ir = self._make_ir("struct Foo:\n" |
| " 0 [+1] UInt x\n" |
| " 1 [+true+1] UInt:8[] y\n") |
| expression = ir.module[0].type[0].structure.field[1].location.size |
| self.assertEqual([ |
| [error.error("m.emb", expression.function.args[0].source_location, |
| "Left argument of operator '+' must be an integer.")] |
| ], error.filter_errors(type_check.annotate_types(ir))) |
| |
| def test_error_on_opaque_operand_type(self): |
| ir = self._make_ir("struct Foo:\n" |
| " 0 [+1] UInt:8[] x\n" |
| " 1 [+x+1] UInt:8[] y\n") |
| expression = ir.module[0].type[0].structure.field[1].location.size |
| self.assertEqual([ |
| [error.error("m.emb", expression.function.args[0].source_location, |
| "Left argument of operator '+' must be an integer.")] |
| ], error.filter_errors(type_check.annotate_types(ir))) |
| |
| def test_error_on_bad_left_comparison_operand_type(self): |
| ir = self._make_ir("struct Foo:\n" |
| " 0 [+1] UInt x\n" |
| " 1 [+true<1] UInt:8[] y\n") |
| expression = ir.module[0].type[0].structure.field[1].location.size |
| self.assertEqual([ |
| [error.error("m.emb", expression.function.args[0].source_location, |
| "Left argument of operator '<' must be an integer.")] |
| ], error.filter_errors(type_check.annotate_types(ir))) |
| |
| def test_error_on_bad_right_comparison_operand_type(self): |
| ir = self._make_ir("struct Foo:\n" |
| " 0 [+1] UInt x\n" |
| " 1 [+1>=true] UInt:8[] y\n") |
| expression = ir.module[0].type[0].structure.field[1].location.size |
| self.assertEqual([ |
| [error.error("m.emb", expression.function.args[1].source_location, |
| "Right argument of operator '>=' must be an integer.")] |
| ], error.filter_errors(type_check.annotate_types(ir))) |
| |
| def test_error_on_bad_boolean_operand_type(self): |
| ir = self._make_ir("struct Foo:\n" |
| " 0 [+1] UInt x\n" |
| " 1 [+1&&true] UInt:8[] y\n") |
| expression = ir.module[0].type[0].structure.field[1].location.size |
| self.assertEqual([ |
| [error.error("m.emb", expression.function.args[0].source_location, |
| "Left argument of operator '&&' must be a boolean.")] |
| ], error.filter_errors(type_check.annotate_types(ir))) |
| |
| def test_max_return_type(self): |
| ir = self._make_ir("struct Foo:\n" |
| " $max(1, 2, 3) [+1] UInt:8[] x\n") |
| expression = ir.module[0].type[0].structure.field[0].location.start |
| self.assertEqual([], type_check.annotate_types(ir)) |
| self.assertEqual("integer", expression.type.WhichOneof("type")) |
| |
| def test_error_on_bad_max_argument(self): |
| ir = self._make_ir("struct Foo:\n" |
| " $max(Bar.XX) [+1] UInt:8[] x\n" |
| "enum Bar:\n" |
| " XX = 0\n") |
| expression = ir.module[0].type[0].structure.field[0].location.start |
| self.assertEqual([ |
| [error.error("m.emb", expression.function.args[0].source_location, |
| "Argument 0 of function '$max' must be an integer.")] |
| ], error.filter_errors(type_check.annotate_types(ir))) |
| |
| def test_error_on_no_max_argument(self): |
| ir = self._make_ir("struct Foo:\n" |
| " $max() [+1] UInt:8[] x\n") |
| expression = ir.module[0].type[0].structure.field[0].location.start |
| self.assertEqual([ |
| [error.error("m.emb", expression.source_location, |
| "Function '$max' requires at least 1 argument.")] |
| ], error.filter_errors(type_check.annotate_types(ir))) |
| |
| def test_upper_bound_return_type(self): |
| ir = self._make_ir("struct Foo:\n" |
| " $upper_bound(3) [+1] UInt:8[] x\n") |
| expression = ir.module[0].type[0].structure.field[0].location.start |
| self.assertEqual([], type_check.annotate_types(ir)) |
| self.assertEqual("integer", expression.type.WhichOneof("type")) |
| |
| def test_upper_bound_too_few_arguments(self): |
| ir = self._make_ir("struct Foo:\n" |
| " $upper_bound() [+1] UInt:8[] x\n") |
| expression = ir.module[0].type[0].structure.field[0].location.start |
| self.assertEqual([ |
| [error.error("m.emb", expression.source_location, |
| "Function '$upper_bound' requires exactly 1 argument.")] |
| ], error.filter_errors(type_check.annotate_types(ir))) |
| |
| def test_upper_bound_too_many_arguments(self): |
| ir = self._make_ir("struct Foo:\n" |
| " $upper_bound(1, 2) [+1] UInt:8[] x\n") |
| expression = ir.module[0].type[0].structure.field[0].location.start |
| self.assertEqual([ |
| [error.error("m.emb", expression.source_location, |
| "Function '$upper_bound' requires exactly 1 argument.")] |
| ], error.filter_errors(type_check.annotate_types(ir))) |
| |
| def test_upper_bound_wrong_argument_type(self): |
| ir = self._make_ir("struct Foo:\n" |
| " $upper_bound(Bar.XX) [+1] UInt:8[] x\n" |
| "enum Bar:\n" |
| " XX = 0\n") |
| expression = ir.module[0].type[0].structure.field[0].location.start |
| self.assertEqual([ |
| [error.error( |
| "m.emb", expression.function.args[0].source_location, |
| "Argument 0 of function '$upper_bound' must be an integer.")] |
| ], error.filter_errors(type_check.annotate_types(ir))) |
| |
| def test_lower_bound_return_type(self): |
| ir = self._make_ir("struct Foo:\n" |
| " $lower_bound(3) [+1] UInt:8[] x\n") |
| expression = ir.module[0].type[0].structure.field[0].location.start |
| self.assertEqual([], type_check.annotate_types(ir)) |
| self.assertEqual("integer", expression.type.WhichOneof("type")) |
| |
| def test_lower_bound_too_few_arguments(self): |
| ir = self._make_ir("struct Foo:\n" |
| " $lower_bound() [+1] UInt:8[] x\n") |
| expression = ir.module[0].type[0].structure.field[0].location.start |
| self.assertEqual([ |
| [error.error("m.emb", expression.source_location, |
| "Function '$lower_bound' requires exactly 1 argument.")] |
| ], error.filter_errors(type_check.annotate_types(ir))) |
| |
| def test_lower_bound_too_many_arguments(self): |
| ir = self._make_ir("struct Foo:\n" |
| " $lower_bound(1, 2) [+1] UInt:8[] x\n") |
| expression = ir.module[0].type[0].structure.field[0].location.start |
| self.assertEqual([ |
| [error.error("m.emb", expression.source_location, |
| "Function '$lower_bound' requires exactly 1 argument.")] |
| ], error.filter_errors(type_check.annotate_types(ir))) |
| |
| def test_lower_bound_wrong_argument_type(self): |
| ir = self._make_ir("struct Foo:\n" |
| " $lower_bound(Bar.XX) [+1] UInt:8[] x\n" |
| "enum Bar:\n" |
| " XX = 0\n") |
| expression = ir.module[0].type[0].structure.field[0].location.start |
| self.assertEqual([ |
| [error.error( |
| "m.emb", expression.function.args[0].source_location, |
| "Argument 0 of function '$lower_bound' must be an integer.")] |
| ], error.filter_errors(type_check.annotate_types(ir))) |
| |
| def test_error_static_reference_to_physical_field(self): |
| ir = self._make_ir("struct Foo:\n" |
| " 0 [+1] UInt x\n" |
| " let y = Foo.x\n") |
| static_ref = ir.module[0].type[0].structure.field[1].read_transform |
| physical_field = ir.module[0].type[0].structure.field[0] |
| self.assertEqual([ |
| [error.error("m.emb", static_ref.source_location, |
| "Static references to physical fields are not allowed."), |
| error.note("m.emb", physical_field.source_location, |
| "x is a physical field.")] |
| ], type_check.annotate_types(ir)) |
| |
| def test_error_on_non_field_argument_to_has(self): |
| ir = self._make_ir("struct Foo:\n" |
| " if $present(0):\n" |
| " 0 [+1] UInt x\n") |
| expression = ir.module[0].type[0].structure.field[0].existence_condition |
| self.assertEqual([ |
| [error.error("m.emb", expression.function.args[0].source_location, |
| "Argument 0 of function '$present' must be a field.")] |
| ], error.filter_errors(type_check.annotate_types(ir))) |
| |
| def test_error_on_no_argument_has(self): |
| ir = self._make_ir("struct Foo:\n" |
| " if $present():\n" |
| " 0 [+1] UInt x\n") |
| expression = ir.module[0].type[0].structure.field[0].existence_condition |
| self.assertEqual([ |
| [error.error("m.emb", expression.source_location, |
| "Function '$present' requires exactly 1 argument.")] |
| ], error.filter_errors(type_check.annotate_types(ir))) |
| |
| def test_error_on_too_many_argument_has(self): |
| ir = self._make_ir("struct Foo:\n" |
| " if $present(y, y):\n" |
| " 0 [+1] UInt x\n" |
| " 1 [+1] UInt y\n") |
| expression = ir.module[0].type[0].structure.field[0].existence_condition |
| self.assertEqual([ |
| [error.error("m.emb", expression.source_location, |
| "Function '$present' requires exactly 1 argument.")] |
| ], error.filter_errors(type_check.annotate_types(ir))) |
| |
| def test_checks_that_parameters_are_atomic_types(self): |
| ir = self._make_ir("struct Foo(y: UInt:8[1]):\n" |
| " 0 [+1] UInt x\n") |
| error_parameter = ir.module[0].type[0].runtime_parameter[0] |
| error_location = error_parameter.physical_type_alias.source_location |
| self.assertEqual( |
| [[error.error("m.emb", error_location, |
| "Parameters cannot be arrays.")]], |
| error.filter_errors(type_check.annotate_types(ir))) |
| |
| |
| class TypeCheckTest(unittest.TestCase): |
| |
| def _make_ir(self, emb_text): |
| ir, unused_debug_info, errors = glue.parse_emboss_file( |
| "m.emb", |
| test_util.dict_file_reader({"m.emb": emb_text}), |
| stop_before_step="check_types") |
| assert not errors, errors |
| return ir |
| |
| def test_error_on_opaque_type_in_field_start(self): |
| ir = self._make_ir("struct Foo:\n" |
| " 0 [+1] UInt:8[] x\n" |
| " x [+10] UInt:8[] y\n") |
| expression = ir.module[0].type[0].structure.field[1].location.start |
| self.assertEqual([ |
| [error.error("m.emb", expression.source_location, |
| "Start of field must be an integer.")] |
| ], type_check.check_types(ir)) |
| |
| def test_error_on_boolean_type_in_field_start(self): |
| ir = self._make_ir("struct Foo:\n" |
| " 0 [+1] UInt:8[] x\n" |
| " true [+10] UInt:8[] y\n") |
| expression = ir.module[0].type[0].structure.field[1].location.start |
| self.assertEqual([ |
| [error.error("m.emb", expression.source_location, |
| "Start of field must be an integer.")] |
| ], type_check.check_types(ir)) |
| |
| def test_error_on_opaque_type_in_field_size(self): |
| ir = self._make_ir("struct Foo:\n" |
| " 0 [+1] UInt:8[] x\n" |
| " 1 [+x] UInt:8[] y\n") |
| expression = ir.module[0].type[0].structure.field[1].location.size |
| self.assertEqual([ |
| [error.error("m.emb", expression.source_location, |
| "Size of field must be an integer.")] |
| ], type_check.check_types(ir)) |
| |
| def test_error_on_boolean_type_in_field_size(self): |
| ir = self._make_ir("struct Foo:\n" |
| " 0 [+1] UInt:8[] x\n" |
| " 1 [+true] UInt:8[] y\n") |
| expression = ir.module[0].type[0].structure.field[1].location.size |
| self.assertEqual([ |
| [error.error("m.emb", expression.source_location, |
| "Size of field must be an integer.")] |
| ], type_check.check_types(ir)) |
| |
| def test_error_on_opaque_type_in_array_size(self): |
| ir = self._make_ir("struct Foo:\n" |
| " 0 [+1] UInt:8[] x\n" |
| " 1 [+9] UInt:8[x] y\n") |
| expression = (ir.module[0].type[0].structure.field[1].type.array_type. |
| element_count) |
| self.assertEqual([ |
| [error.error("m.emb", expression.source_location, |
| "Array size must be an integer.")] |
| ], type_check.check_types(ir)) |
| |
| def test_error_on_boolean_type_in_array_size(self): |
| ir = self._make_ir("struct Foo:\n" |
| " 0 [+1] UInt:8[] x\n" |
| " 1 [+9] UInt:8[true] y\n") |
| expression = (ir.module[0].type[0].structure.field[1].type.array_type. |
| element_count) |
| self.assertEqual([ |
| [error.error("m.emb", expression.source_location, |
| "Array size must be an integer.")] |
| ], type_check.check_types(ir)) |
| |
| def test_error_on_integer_type_in_existence_condition(self): |
| ir = self._make_ir("struct Foo:\n" |
| " 0 [+1] UInt:8[] x\n" |
| " if 1:\n" |
| " 1 [+9] UInt:8[] y\n") |
| expression = ir.module[0].type[0].structure.field[1].existence_condition |
| self.assertEqual([ |
| [error.error("m.emb", expression.source_location, |
| "Existence condition must be a boolean.")] |
| ], type_check.check_types(ir)) |
| |
| def test_error_on_non_integer_non_enum_parameter(self): |
| ir = self._make_ir("struct Foo(f: Flag):\n" |
| " 0 [+1] UInt:8[] x\n") |
| parameter = ir.module[0].type[0].runtime_parameter[0] |
| self.assertEqual( |
| [[error.error("m.emb", parameter.physical_type_alias.source_location, |
| "Runtime parameters must be integer or enum.")]], |
| type_check.check_types(ir)) |
| |
| def test_error_on_failure_to_pass_parameter(self): |
| ir = self._make_ir("struct Foo:\n" |
| " 0 [+1] Bar b\n" |
| "struct Bar(f: UInt:6):\n" |
| " 0 [+1] UInt:8[] x\n") |
| type_ir = ir.module[0].type[0].structure.field[0].type |
| bar = ir.module[0].type[1] |
| self.assertEqual( |
| [[ |
| error.error("m.emb", type_ir.source_location, |
| "Type Bar requires 1 parameter; 0 parameters given."), |
| error.note("m.emb", bar.source_location, |
| "Definition of type Bar.") |
| ]], |
| type_check.check_types(ir)) |
| |
| def test_error_on_passing_unneeded_parameter(self): |
| ir = self._make_ir("struct Foo:\n" |
| " 0 [+1] Bar(1) b\n" |
| "struct Bar:\n" |
| " 0 [+1] UInt:8[] x\n") |
| type_ir = ir.module[0].type[0].structure.field[0].type |
| bar = ir.module[0].type[1] |
| self.assertEqual( |
| [[ |
| error.error("m.emb", type_ir.source_location, |
| "Type Bar requires 0 parameters; 1 parameter given."), |
| error.note("m.emb", bar.source_location, |
| "Definition of type Bar.") |
| ]], |
| type_check.check_types(ir)) |
| |
| def test_error_on_passing_wrong_parameter_type(self): |
| ir = self._make_ir("struct Foo:\n" |
| " 0 [+1] Bar(1) b\n" |
| "enum Baz:\n" |
| " QUX = 1\n" |
| "struct Bar(n: Baz):\n" |
| " 0 [+1] UInt:8[] x\n") |
| type_ir = ir.module[0].type[0].structure.field[0].type |
| usage_parameter_ir = type_ir.atomic_type.runtime_parameter[0] |
| source_parameter_ir = ir.module[0].type[2].runtime_parameter[0] |
| self.assertEqual( |
| [[ |
| error.error("m.emb", usage_parameter_ir.source_location, |
| "Parameter 0 of type Bar must be Baz, not integer."), |
| error.note("m.emb", source_parameter_ir.source_location, |
| "Parameter 0 of Bar.") |
| ]], |
| type_check.check_types(ir)) |
| |
| |
| if __name__ == "__main__": |
| unittest.main() |
