Reformat all source with Black. (#176)
diff --git a/compiler/front_end/constraints_test.py b/compiler/front_end/constraints_test.py
index eac1232..4f4df7e 100644
--- a/compiler/front_end/constraints_test.py
+++ b/compiler/front_end/constraints_test.py
@@ -25,819 +25,1291 @@
def _make_ir_from_emb(emb_text, name="m.emb"):
- ir, unused_debug_info, errors = glue.parse_emboss_file(
- name,
- test_util.dict_file_reader({name: emb_text}),
- stop_before_step="check_constraints")
- assert not errors, repr(errors)
- return ir
+ ir, unused_debug_info, errors = glue.parse_emboss_file(
+ name,
+ test_util.dict_file_reader({name: emb_text}),
+ stop_before_step="check_constraints",
+ )
+ assert not errors, repr(errors)
+ return ir
class ConstraintsTest(unittest.TestCase):
- """Tests constraints.check_constraints and helpers."""
+ """Tests constraints.check_constraints and helpers."""
- def test_error_on_missing_inner_array_size(self):
- ir = _make_ir_from_emb("struct Foo:\n"
- " 0 [+1] UInt:8[][1] one_byte\n")
- # There is a latent issue here where the source location reported in this
- # error is using a default value of 0:0. An issue is filed at
- # https://github.com/google/emboss/issues/153 for further investigation.
- # In the meantime we use `ir_data_utils.reader` to mimic this legacy
- # behavior.
- error_array = ir_data_utils.reader(
- ir.module[0].type[0].structure.field[0].type.array_type)
- self.assertEqual([[
- error.error(
- "m.emb",
- error_array.base_type.array_type.element_count.source_location,
- "Array dimensions can only be omitted for the outermost dimension.")
- ]], error.filter_errors(constraints.check_constraints(ir)))
+ def test_error_on_missing_inner_array_size(self):
+ ir = _make_ir_from_emb("struct Foo:\n" " 0 [+1] UInt:8[][1] one_byte\n")
+ # There is a latent issue here where the source location reported in this
+ # error is using a default value of 0:0. An issue is filed at
+ # https://github.com/google/emboss/issues/153 for further investigation.
+ # In the meantime we use `ir_data_utils.reader` to mimic this legacy
+ # behavior.
+ error_array = ir_data_utils.reader(
+ ir.module[0].type[0].structure.field[0].type.array_type
+ )
+ self.assertEqual(
+ [
+ [
+ error.error(
+ "m.emb",
+ error_array.base_type.array_type.element_count.source_location,
+ "Array dimensions can only be omitted for the outermost dimension.",
+ )
+ ]
+ ],
+ error.filter_errors(constraints.check_constraints(ir)),
+ )
- def test_no_error_on_ok_array_size(self):
- ir = _make_ir_from_emb("struct Foo:\n"
- " 0 [+1] UInt:8[1][1] one_byte\n")
- self.assertEqual([], constraints.check_constraints(ir))
+ def test_no_error_on_ok_array_size(self):
+ ir = _make_ir_from_emb("struct Foo:\n" " 0 [+1] UInt:8[1][1] one_byte\n")
+ self.assertEqual([], constraints.check_constraints(ir))
- def test_no_error_on_ok_missing_outer_array_size(self):
- ir = _make_ir_from_emb("struct Foo:\n"
- " 0 [+1] UInt:8[1][] one_byte\n")
- self.assertEqual([], constraints.check_constraints(ir))
+ def test_no_error_on_ok_missing_outer_array_size(self):
+ ir = _make_ir_from_emb("struct Foo:\n" " 0 [+1] UInt:8[1][] one_byte\n")
+ self.assertEqual([], constraints.check_constraints(ir))
- def test_no_error_on_dynamically_sized_struct_in_dynamically_sized_field(
- self):
- ir = _make_ir_from_emb("struct Foo:\n"
- " 0 [+1] UInt size\n"
- " 1 [+size] Bar bar\n"
- "struct Bar:\n"
- " 0 [+1] UInt size\n"
- " 1 [+size] UInt:8[] payload\n")
- self.assertEqual([], constraints.check_constraints(ir))
+ def test_no_error_on_dynamically_sized_struct_in_dynamically_sized_field(self):
+ ir = _make_ir_from_emb(
+ "struct Foo:\n"
+ " 0 [+1] UInt size\n"
+ " 1 [+size] Bar bar\n"
+ "struct Bar:\n"
+ " 0 [+1] UInt size\n"
+ " 1 [+size] UInt:8[] payload\n"
+ )
+ self.assertEqual([], constraints.check_constraints(ir))
- def test_no_error_on_dynamically_sized_struct_in_statically_sized_field(self):
- ir = _make_ir_from_emb("struct Foo:\n"
- " 0 [+10] Bar bar\n"
- "struct Bar:\n"
- " 0 [+1] UInt size\n"
- " 1 [+size] UInt:8[] payload\n")
- self.assertEqual([], constraints.check_constraints(ir))
+ def test_no_error_on_dynamically_sized_struct_in_statically_sized_field(self):
+ ir = _make_ir_from_emb(
+ "struct Foo:\n"
+ " 0 [+10] Bar bar\n"
+ "struct Bar:\n"
+ " 0 [+1] UInt size\n"
+ " 1 [+size] UInt:8[] payload\n"
+ )
+ self.assertEqual([], constraints.check_constraints(ir))
- def test_no_error_non_fixed_size_outer_array_dimension(self):
- ir = _make_ir_from_emb("struct Foo:\n"
- " 0 [+1] UInt size\n"
- " 1 [+size] UInt:8[1][size-1] one_byte\n")
- self.assertEqual([], constraints.check_constraints(ir))
+ def test_no_error_non_fixed_size_outer_array_dimension(self):
+ ir = _make_ir_from_emb(
+ "struct Foo:\n"
+ " 0 [+1] UInt size\n"
+ " 1 [+size] UInt:8[1][size-1] one_byte\n"
+ )
+ self.assertEqual([], constraints.check_constraints(ir))
- def test_error_non_fixed_size_inner_array_dimension(self):
- ir = _make_ir_from_emb("struct Foo:\n"
- " 0 [+1] UInt size\n"
- " 1 [+size] UInt:8[size-1][1] one_byte\n")
- error_array = ir.module[0].type[0].structure.field[1].type.array_type
- self.assertEqual([[
- error.error(
- "m.emb",
- error_array.base_type.array_type.element_count.source_location,
- "Inner array dimensions must be constant.")
- ]], error.filter_errors(constraints.check_constraints(ir)))
+ def test_error_non_fixed_size_inner_array_dimension(self):
+ ir = _make_ir_from_emb(
+ "struct Foo:\n"
+ " 0 [+1] UInt size\n"
+ " 1 [+size] UInt:8[size-1][1] one_byte\n"
+ )
+ error_array = ir.module[0].type[0].structure.field[1].type.array_type
+ self.assertEqual(
+ [
+ [
+ error.error(
+ "m.emb",
+ error_array.base_type.array_type.element_count.source_location,
+ "Inner array dimensions must be constant.",
+ )
+ ]
+ ],
+ error.filter_errors(constraints.check_constraints(ir)),
+ )
- def test_error_non_constant_inner_array_dimensions(self):
- ir = _make_ir_from_emb("struct Foo:\n"
- " 0 [+1] Bar[1] one_byte\n"
- # There is no dynamically-sized byte-oriented type in
- # the Prelude, so this test has to make its own.
- "external Bar:\n"
- " [is_integer: true]\n"
- " [addressable_unit_size: 8]\n")
- error_array = ir.module[0].type[0].structure.field[0].type.array_type
- self.assertEqual([[
- error.error(
- "m.emb", error_array.base_type.atomic_type.source_location,
- "Array elements must be fixed size.")
- ]], error.filter_errors(constraints.check_constraints(ir)))
+ def test_error_non_constant_inner_array_dimensions(self):
+ ir = _make_ir_from_emb(
+ "struct Foo:\n"
+ " 0 [+1] Bar[1] one_byte\n"
+ # There is no dynamically-sized byte-oriented type in
+ # the Prelude, so this test has to make its own.
+ "external Bar:\n"
+ " [is_integer: true]\n"
+ " [addressable_unit_size: 8]\n"
+ )
+ error_array = ir.module[0].type[0].structure.field[0].type.array_type
+ self.assertEqual(
+ [
+ [
+ error.error(
+ "m.emb",
+ error_array.base_type.atomic_type.source_location,
+ "Array elements must be fixed size.",
+ )
+ ]
+ ],
+ error.filter_errors(constraints.check_constraints(ir)),
+ )
- def test_error_dynamically_sized_array_elements(self):
- ir = _make_ir_from_emb('[$default byte_order: "LittleEndian"]\n'
- "struct Foo:\n"
- " 0 [+1] Bar[1] bar\n"
- "struct Bar:\n"
- " 0 [+1] UInt size\n"
- " 1 [+size] UInt:8[] payload\n")
- error_array = ir.module[0].type[0].structure.field[0].type.array_type
- self.assertEqual([[
- error.error(
- "m.emb", error_array.base_type.atomic_type.source_location,
- "Array elements must be fixed size.")
- ]], error.filter_errors(constraints.check_constraints(ir)))
+ def test_error_dynamically_sized_array_elements(self):
+ ir = _make_ir_from_emb(
+ '[$default byte_order: "LittleEndian"]\n'
+ "struct Foo:\n"
+ " 0 [+1] Bar[1] bar\n"
+ "struct Bar:\n"
+ " 0 [+1] UInt size\n"
+ " 1 [+size] UInt:8[] payload\n"
+ )
+ error_array = ir.module[0].type[0].structure.field[0].type.array_type
+ self.assertEqual(
+ [
+ [
+ error.error(
+ "m.emb",
+ error_array.base_type.atomic_type.source_location,
+ "Array elements must be fixed size.",
+ )
+ ]
+ ],
+ error.filter_errors(constraints.check_constraints(ir)),
+ )
- def test_field_too_small_for_type(self):
- ir = _make_ir_from_emb('[$default byte_order: "LittleEndian"]\n'
- "struct Foo:\n"
- " 0 [+1] Bar bar\n"
- "struct Bar:\n"
- " 0 [+2] UInt value\n")
- error_type = ir.module[0].type[0].structure.field[0].type
- self.assertEqual([[
- error.error(
- "m.emb", error_type.source_location,
- "Fixed-size type 'Bar' cannot be placed in field of size 8 bits; "
- "requires 16 bits.")
- ]], error.filter_errors(constraints.check_constraints(ir)))
+ def test_field_too_small_for_type(self):
+ ir = _make_ir_from_emb(
+ '[$default byte_order: "LittleEndian"]\n'
+ "struct Foo:\n"
+ " 0 [+1] Bar bar\n"
+ "struct Bar:\n"
+ " 0 [+2] UInt value\n"
+ )
+ error_type = ir.module[0].type[0].structure.field[0].type
+ self.assertEqual(
+ [
+ [
+ error.error(
+ "m.emb",
+ error_type.source_location,
+ "Fixed-size type 'Bar' cannot be placed in field of size 8 bits; "
+ "requires 16 bits.",
+ )
+ ]
+ ],
+ error.filter_errors(constraints.check_constraints(ir)),
+ )
- def test_dynamically_sized_field_always_too_small_for_type(self):
- ir = _make_ir_from_emb('[$default byte_order: "LittleEndian"]\n'
- "struct Foo:\n"
- " 0 [+1] bits:\n"
- " 0 [+1] UInt x\n"
- " 0 [+x] Bar bar\n"
- "struct Bar:\n"
- " 0 [+2] UInt value\n")
- error_type = ir.module[0].type[0].structure.field[2].type
- self.assertEqual([[
- error.error(
- "m.emb", error_type.source_location,
- "Field of maximum size 8 bits cannot hold fixed-size type 'Bar', "
- "which requires 16 bits.")
- ]], error.filter_errors(constraints.check_constraints(ir)))
+ def test_dynamically_sized_field_always_too_small_for_type(self):
+ ir = _make_ir_from_emb(
+ '[$default byte_order: "LittleEndian"]\n'
+ "struct Foo:\n"
+ " 0 [+1] bits:\n"
+ " 0 [+1] UInt x\n"
+ " 0 [+x] Bar bar\n"
+ "struct Bar:\n"
+ " 0 [+2] UInt value\n"
+ )
+ error_type = ir.module[0].type[0].structure.field[2].type
+ self.assertEqual(
+ [
+ [
+ error.error(
+ "m.emb",
+ error_type.source_location,
+ "Field of maximum size 8 bits cannot hold fixed-size type 'Bar', "
+ "which requires 16 bits.",
+ )
+ ]
+ ],
+ error.filter_errors(constraints.check_constraints(ir)),
+ )
- def test_struct_field_too_big_for_type(self):
- ir = _make_ir_from_emb("struct Foo:\n"
- " 0 [+2] Byte double_byte\n"
- "struct Byte:\n"
- " 0 [+1] UInt b\n")
- error_type = ir.module[0].type[0].structure.field[0].type
- self.assertEqual([[
- error.error(
- "m.emb", error_type.source_location,
- "Fixed-size type 'Byte' cannot be placed in field of size 16 bits; "
- "requires 8 bits.")
- ]], error.filter_errors(constraints.check_constraints(ir)))
+ def test_struct_field_too_big_for_type(self):
+ ir = _make_ir_from_emb(
+ "struct Foo:\n"
+ " 0 [+2] Byte double_byte\n"
+ "struct Byte:\n"
+ " 0 [+1] UInt b\n"
+ )
+ error_type = ir.module[0].type[0].structure.field[0].type
+ self.assertEqual(
+ [
+ [
+ error.error(
+ "m.emb",
+ error_type.source_location,
+ "Fixed-size type 'Byte' cannot be placed in field of size 16 bits; "
+ "requires 8 bits.",
+ )
+ ]
+ ],
+ error.filter_errors(constraints.check_constraints(ir)),
+ )
- def test_bits_field_too_big_for_type(self):
- ir = _make_ir_from_emb("struct Foo:\n"
- " 0 [+9] UInt uint72\n"
- ' [byte_order: "LittleEndian"]\n')
- error_field = ir.module[0].type[0].structure.field[0]
- uint_type = ir_util.find_object(error_field.type.atomic_type.reference, ir)
- uint_requirements = ir_util.get_attribute(uint_type.attribute,
- attributes.STATIC_REQUIREMENTS)
- self.assertEqual([[
- error.error("m.emb", error_field.source_location,
- "Requirements of UInt not met."),
- error.note("", uint_requirements.source_location,
- "Requirements specified here."),
- ]], error.filter_errors(constraints.check_constraints(ir)))
+ def test_bits_field_too_big_for_type(self):
+ ir = _make_ir_from_emb(
+ "struct Foo:\n"
+ " 0 [+9] UInt uint72\n"
+ ' [byte_order: "LittleEndian"]\n'
+ )
+ error_field = ir.module[0].type[0].structure.field[0]
+ uint_type = ir_util.find_object(error_field.type.atomic_type.reference, ir)
+ uint_requirements = ir_util.get_attribute(
+ uint_type.attribute, attributes.STATIC_REQUIREMENTS
+ )
+ self.assertEqual(
+ [
+ [
+ error.error(
+ "m.emb",
+ error_field.source_location,
+ "Requirements of UInt not met.",
+ ),
+ error.note(
+ "",
+ uint_requirements.source_location,
+ "Requirements specified here.",
+ ),
+ ]
+ ],
+ error.filter_errors(constraints.check_constraints(ir)),
+ )
- def test_field_type_not_allowed_in_bits(self):
- ir = _make_ir_from_emb('[$default byte_order: "LittleEndian"]\n'
- "bits Foo:\n"
- " 0 [+16] Bar bar\n"
- "external Bar:\n"
- " [addressable_unit_size: 8]\n")
- error_type = ir.module[0].type[0].structure.field[0].type
- self.assertEqual([[
- error.error(
- "m.emb", error_type.source_location,
- "Byte-oriented type 'Bar' cannot be used in a bits field.")
- ]], error.filter_errors(constraints.check_constraints(ir)))
+ def test_field_type_not_allowed_in_bits(self):
+ ir = _make_ir_from_emb(
+ '[$default byte_order: "LittleEndian"]\n'
+ "bits Foo:\n"
+ " 0 [+16] Bar bar\n"
+ "external Bar:\n"
+ " [addressable_unit_size: 8]\n"
+ )
+ error_type = ir.module[0].type[0].structure.field[0].type
+ self.assertEqual(
+ [
+ [
+ error.error(
+ "m.emb",
+ error_type.source_location,
+ "Byte-oriented type 'Bar' cannot be used in a bits field.",
+ )
+ ]
+ ],
+ error.filter_errors(constraints.check_constraints(ir)),
+ )
- def test_arrays_allowed_in_bits(self):
- ir = _make_ir_from_emb("bits Foo:\n"
- " 0 [+16] Flag[16] bar\n")
- self.assertEqual([], constraints.check_constraints(ir))
+ def test_arrays_allowed_in_bits(self):
+ ir = _make_ir_from_emb("bits Foo:\n" " 0 [+16] Flag[16] bar\n")
+ self.assertEqual([], constraints.check_constraints(ir))
- def test_oversized_anonymous_bit_field(self):
- ir = _make_ir_from_emb('[$default byte_order: "LittleEndian"]\n'
- "struct Foo:\n"
- " 0 [+4] bits:\n"
- " 0 [+8] UInt field\n")
- self.assertEqual([], constraints.check_constraints(ir))
+ def test_oversized_anonymous_bit_field(self):
+ ir = _make_ir_from_emb(
+ '[$default byte_order: "LittleEndian"]\n'
+ "struct Foo:\n"
+ " 0 [+4] bits:\n"
+ " 0 [+8] UInt field\n"
+ )
+ self.assertEqual([], constraints.check_constraints(ir))
- def test_undersized_anonymous_bit_field(self):
- ir = _make_ir_from_emb('[$default byte_order: "LittleEndian"]\n'
- "struct Foo:\n"
- " 0 [+1] bits:\n"
- " 0 [+32] UInt field\n")
- error_type = ir.module[0].type[0].structure.field[0].type
- self.assertEqual([[
- error.error(
- "m.emb", error_type.source_location,
- "Fixed-size anonymous type cannot be placed in field of size 8 "
- "bits; requires 32 bits.")
- ]], error.filter_errors(constraints.check_constraints(ir)))
+ def test_undersized_anonymous_bit_field(self):
+ ir = _make_ir_from_emb(
+ '[$default byte_order: "LittleEndian"]\n'
+ "struct Foo:\n"
+ " 0 [+1] bits:\n"
+ " 0 [+32] UInt field\n"
+ )
+ error_type = ir.module[0].type[0].structure.field[0].type
+ self.assertEqual(
+ [
+ [
+ error.error(
+ "m.emb",
+ error_type.source_location,
+ "Fixed-size anonymous type cannot be placed in field of size 8 "
+ "bits; requires 32 bits.",
+ )
+ ]
+ ],
+ error.filter_errors(constraints.check_constraints(ir)),
+ )
- def test_reserved_field_name(self):
- ir = _make_ir_from_emb('[$default byte_order: "LittleEndian"]\n'
- "struct Foo:\n"
- " 0 [+8] UInt restrict\n")
- error_name = ir.module[0].type[0].structure.field[0].name.name
- self.assertEqual([[
- error.error(
- "m.emb", error_name.source_location,
- "C reserved word may not be used as a field name.")
- ]], error.filter_errors(constraints.check_constraints(ir)))
+ def test_reserved_field_name(self):
+ ir = _make_ir_from_emb(
+ '[$default byte_order: "LittleEndian"]\n'
+ "struct Foo:\n"
+ " 0 [+8] UInt restrict\n"
+ )
+ error_name = ir.module[0].type[0].structure.field[0].name.name
+ self.assertEqual(
+ [
+ [
+ error.error(
+ "m.emb",
+ error_name.source_location,
+ "C reserved word may not be used as a field name.",
+ )
+ ]
+ ],
+ error.filter_errors(constraints.check_constraints(ir)),
+ )
- def test_reserved_type_name(self):
- ir = _make_ir_from_emb("struct False:\n"
- " 0 [+1] UInt foo\n")
- error_name = ir.module[0].type[0].name.name
- self.assertEqual([[
- error.error(
- "m.emb", error_name.source_location,
- "Python 3 reserved word may not be used as a type name.")
- ]], error.filter_errors(constraints.check_constraints(ir)))
+ def test_reserved_type_name(self):
+ ir = _make_ir_from_emb("struct False:\n" " 0 [+1] UInt foo\n")
+ error_name = ir.module[0].type[0].name.name
+ self.assertEqual(
+ [
+ [
+ error.error(
+ "m.emb",
+ error_name.source_location,
+ "Python 3 reserved word may not be used as a type name.",
+ )
+ ]
+ ],
+ error.filter_errors(constraints.check_constraints(ir)),
+ )
- def test_reserved_enum_name(self):
- ir = _make_ir_from_emb("enum Foo:\n"
- " NULL = 1\n")
- error_name = ir.module[0].type[0].enumeration.value[0].name.name
- self.assertEqual([[
- error.error(
- "m.emb", error_name.source_location,
- "C reserved word may not be used as an enum name.")
- ]], error.filter_errors(constraints.check_constraints(ir)))
+ def test_reserved_enum_name(self):
+ ir = _make_ir_from_emb("enum Foo:\n" " NULL = 1\n")
+ error_name = ir.module[0].type[0].enumeration.value[0].name.name
+ self.assertEqual(
+ [
+ [
+ error.error(
+ "m.emb",
+ error_name.source_location,
+ "C reserved word may not be used as an enum name.",
+ )
+ ]
+ ],
+ error.filter_errors(constraints.check_constraints(ir)),
+ )
- def test_bits_type_in_struct_array(self):
- ir = _make_ir_from_emb('[$default byte_order: "LittleEndian"]\n'
- "struct Foo:\n"
- " 0 [+10] UInt:8[10] array\n")
- self.assertEqual([], constraints.check_constraints(ir))
+ def test_bits_type_in_struct_array(self):
+ ir = _make_ir_from_emb(
+ '[$default byte_order: "LittleEndian"]\n'
+ "struct Foo:\n"
+ " 0 [+10] UInt:8[10] array\n"
+ )
+ self.assertEqual([], constraints.check_constraints(ir))
- def test_bits_type_in_bits_array(self):
- ir = _make_ir_from_emb("bits Foo:\n"
- " 0 [+10] UInt:8[10] array\n")
- self.assertEqual([], constraints.check_constraints(ir))
+ def test_bits_type_in_bits_array(self):
+ ir = _make_ir_from_emb("bits Foo:\n" " 0 [+10] UInt:8[10] array\n")
+ self.assertEqual([], constraints.check_constraints(ir))
- def test_explicit_size_too_small(self):
- ir = _make_ir_from_emb("bits Foo:\n"
- " 0 [+0] UInt:0 zero_bit\n")
- error_field = ir.module[0].type[0].structure.field[0]
- uint_type = ir_util.find_object(error_field.type.atomic_type.reference, ir)
- uint_requirements = ir_util.get_attribute(uint_type.attribute,
- attributes.STATIC_REQUIREMENTS)
- self.assertEqual([[
- error.error("m.emb", error_field.source_location,
- "Requirements of UInt not met."),
- error.note("", uint_requirements.source_location,
- "Requirements specified here."),
- ]], error.filter_errors(constraints.check_constraints(ir)))
+ def test_explicit_size_too_small(self):
+ ir = _make_ir_from_emb("bits Foo:\n" " 0 [+0] UInt:0 zero_bit\n")
+ error_field = ir.module[0].type[0].structure.field[0]
+ uint_type = ir_util.find_object(error_field.type.atomic_type.reference, ir)
+ uint_requirements = ir_util.get_attribute(
+ uint_type.attribute, attributes.STATIC_REQUIREMENTS
+ )
+ self.assertEqual(
+ [
+ [
+ error.error(
+ "m.emb",
+ error_field.source_location,
+ "Requirements of UInt not met.",
+ ),
+ error.note(
+ "",
+ uint_requirements.source_location,
+ "Requirements specified here.",
+ ),
+ ]
+ ],
+ error.filter_errors(constraints.check_constraints(ir)),
+ )
- def test_explicit_enumeration_size_too_small(self):
- ir = _make_ir_from_emb('[$default byte_order: "BigEndian"]\n'
- "bits Foo:\n"
- " 0 [+0] Bar:0 zero_bit\n"
- "enum Bar:\n"
- " BAZ = 0\n")
- error_type = ir.module[0].type[0].structure.field[0].type
- self.assertEqual([[
- error.error("m.emb", error_type.source_location,
- "Enumeration type 'Bar' cannot be 0 bits; type 'Bar' "
- "must be between 1 and 64 bits, inclusive."),
- ]], error.filter_errors(constraints.check_constraints(ir)))
+ def test_explicit_enumeration_size_too_small(self):
+ ir = _make_ir_from_emb(
+ '[$default byte_order: "BigEndian"]\n'
+ "bits Foo:\n"
+ " 0 [+0] Bar:0 zero_bit\n"
+ "enum Bar:\n"
+ " BAZ = 0\n"
+ )
+ error_type = ir.module[0].type[0].structure.field[0].type
+ self.assertEqual(
+ [
+ [
+ error.error(
+ "m.emb",
+ error_type.source_location,
+ "Enumeration type 'Bar' cannot be 0 bits; type 'Bar' "
+ "must be between 1 and 64 bits, inclusive.",
+ ),
+ ]
+ ],
+ error.filter_errors(constraints.check_constraints(ir)),
+ )
- def test_explicit_size_too_big_for_field(self):
- ir = _make_ir_from_emb("bits Foo:\n"
- " 0 [+8] UInt:32 thirty_two_bit\n")
- error_type = ir.module[0].type[0].structure.field[0].type
- self.assertEqual([[
- error.error(
- "m.emb", error_type.source_location,
- "Fixed-size type 'UInt:32' cannot be placed in field of size 8 "
- "bits; requires 32 bits.")
- ]], error.filter_errors(constraints.check_constraints(ir)))
+ def test_explicit_size_too_big_for_field(self):
+ ir = _make_ir_from_emb("bits Foo:\n" " 0 [+8] UInt:32 thirty_two_bit\n")
+ error_type = ir.module[0].type[0].structure.field[0].type
+ self.assertEqual(
+ [
+ [
+ error.error(
+ "m.emb",
+ error_type.source_location,
+ "Fixed-size type 'UInt:32' cannot be placed in field of size 8 "
+ "bits; requires 32 bits.",
+ )
+ ]
+ ],
+ error.filter_errors(constraints.check_constraints(ir)),
+ )
- def test_explicit_size_too_small_for_field(self):
- ir = _make_ir_from_emb("bits Foo:\n"
- " 0 [+64] UInt:32 thirty_two_bit\n")
- error_type = ir.module[0].type[0].structure.field[0].type
- self.assertEqual([[
- error.error("m.emb", error_type.source_location,
- "Fixed-size type 'UInt:32' cannot be placed in field of "
- "size 64 bits; requires 32 bits.")
- ]], error.filter_errors(constraints.check_constraints(ir)))
+ def test_explicit_size_too_small_for_field(self):
+ ir = _make_ir_from_emb("bits Foo:\n" " 0 [+64] UInt:32 thirty_two_bit\n")
+ error_type = ir.module[0].type[0].structure.field[0].type
+ self.assertEqual(
+ [
+ [
+ error.error(
+ "m.emb",
+ error_type.source_location,
+ "Fixed-size type 'UInt:32' cannot be placed in field of "
+ "size 64 bits; requires 32 bits.",
+ )
+ ]
+ ],
+ error.filter_errors(constraints.check_constraints(ir)),
+ )
- def test_explicit_size_too_big(self):
- ir = _make_ir_from_emb("struct Foo:\n"
- " 0 [+16] UInt:128 one_twenty_eight_bit\n"
- ' [byte_order: "LittleEndian"]\n')
- error_field = ir.module[0].type[0].structure.field[0]
- uint_type = ir_util.find_object(error_field.type.atomic_type.reference, ir)
- uint_requirements = ir_util.get_attribute(uint_type.attribute,
- attributes.STATIC_REQUIREMENTS)
- self.assertEqual([[
- error.error("m.emb", error_field.source_location,
- "Requirements of UInt not met."),
- error.note("", uint_requirements.source_location,
- "Requirements specified here."),
- ]], error.filter_errors(constraints.check_constraints(ir)))
+ def test_explicit_size_too_big(self):
+ ir = _make_ir_from_emb(
+ "struct Foo:\n"
+ " 0 [+16] UInt:128 one_twenty_eight_bit\n"
+ ' [byte_order: "LittleEndian"]\n'
+ )
+ error_field = ir.module[0].type[0].structure.field[0]
+ uint_type = ir_util.find_object(error_field.type.atomic_type.reference, ir)
+ uint_requirements = ir_util.get_attribute(
+ uint_type.attribute, attributes.STATIC_REQUIREMENTS
+ )
+ self.assertEqual(
+ [
+ [
+ error.error(
+ "m.emb",
+ error_field.source_location,
+ "Requirements of UInt not met.",
+ ),
+ error.note(
+ "",
+ uint_requirements.source_location,
+ "Requirements specified here.",
+ ),
+ ]
+ ],
+ error.filter_errors(constraints.check_constraints(ir)),
+ )
- def test_explicit_enumeration_size_too_big(self):
- ir = _make_ir_from_emb('[$default byte_order: "BigEndian"]\n'
- "struct Foo:\n"
- " 0 [+9] Bar seventy_two_bit\n"
- "enum Bar:\n"
- " BAZ = 0\n")
- error_type = ir.module[0].type[0].structure.field[0].type
- self.assertEqual([[
- error.error("m.emb", error_type.source_location,
- "Enumeration type 'Bar' cannot be 72 bits; type 'Bar' " +
- "must be between 1 and 64 bits, inclusive."),
- ]], error.filter_errors(constraints.check_constraints(ir)))
+ def test_explicit_enumeration_size_too_big(self):
+ ir = _make_ir_from_emb(
+ '[$default byte_order: "BigEndian"]\n'
+ "struct Foo:\n"
+ " 0 [+9] Bar seventy_two_bit\n"
+ "enum Bar:\n"
+ " BAZ = 0\n"
+ )
+ error_type = ir.module[0].type[0].structure.field[0].type
+ self.assertEqual(
+ [
+ [
+ error.error(
+ "m.emb",
+ error_type.source_location,
+ "Enumeration type 'Bar' cannot be 72 bits; type 'Bar' "
+ + "must be between 1 and 64 bits, inclusive.",
+ ),
+ ]
+ ],
+ error.filter_errors(constraints.check_constraints(ir)),
+ )
- def test_explicit_enumeration_size_too_big_for_small_enum(self):
- ir = _make_ir_from_emb('[$default byte_order: "BigEndian"]\n'
- "struct Foo:\n"
- " 0 [+8] Bar sixty_four_bit\n"
- "enum Bar:\n"
- " [maximum_bits: 63]\n"
- " BAZ = 0\n")
- error_type = ir.module[0].type[0].structure.field[0].type
- self.assertEqual([[
- error.error("m.emb", error_type.source_location,
- "Enumeration type 'Bar' cannot be 64 bits; type 'Bar' " +
- "must be between 1 and 63 bits, inclusive."),
- ]], error.filter_errors(constraints.check_constraints(ir)))
+ def test_explicit_enumeration_size_too_big_for_small_enum(self):
+ ir = _make_ir_from_emb(
+ '[$default byte_order: "BigEndian"]\n'
+ "struct Foo:\n"
+ " 0 [+8] Bar sixty_four_bit\n"
+ "enum Bar:\n"
+ " [maximum_bits: 63]\n"
+ " BAZ = 0\n"
+ )
+ error_type = ir.module[0].type[0].structure.field[0].type
+ self.assertEqual(
+ [
+ [
+ error.error(
+ "m.emb",
+ error_type.source_location,
+ "Enumeration type 'Bar' cannot be 64 bits; type 'Bar' "
+ + "must be between 1 and 63 bits, inclusive.",
+ ),
+ ]
+ ],
+ error.filter_errors(constraints.check_constraints(ir)),
+ )
- def test_explicit_size_on_fixed_size_type(self):
- ir = _make_ir_from_emb("struct Foo:\n"
- " 0 [+1] Byte:8 one_byte\n"
- "struct Byte:\n"
- " 0 [+1] UInt b\n")
- self.assertEqual([], constraints.check_constraints(ir))
+ def test_explicit_size_on_fixed_size_type(self):
+ ir = _make_ir_from_emb(
+ "struct Foo:\n"
+ " 0 [+1] Byte:8 one_byte\n"
+ "struct Byte:\n"
+ " 0 [+1] UInt b\n"
+ )
+ self.assertEqual([], constraints.check_constraints(ir))
- def test_explicit_size_too_small_on_fixed_size_type(self):
- ir = _make_ir_from_emb("struct Foo:\n"
- " 0 [+0] Byte:0 null_byte\n"
- "struct Byte:\n"
- " 0 [+1] UInt b\n")
- error_type = ir.module[0].type[0].structure.field[0].type
- self.assertEqual([[
- error.error(
- "m.emb", error_type.size_in_bits.source_location,
- "Explicit size of 0 bits does not match fixed size (8 bits) of "
- "type 'Byte'."),
- error.note("m.emb", ir.module[0].type[1].source_location,
- "Size specified here."),
- ]], error.filter_errors(constraints.check_constraints(ir)))
+ def test_explicit_size_too_small_on_fixed_size_type(self):
+ ir = _make_ir_from_emb(
+ "struct Foo:\n"
+ " 0 [+0] Byte:0 null_byte\n"
+ "struct Byte:\n"
+ " 0 [+1] UInt b\n"
+ )
+ error_type = ir.module[0].type[0].structure.field[0].type
+ self.assertEqual(
+ [
+ [
+ error.error(
+ "m.emb",
+ error_type.size_in_bits.source_location,
+ "Explicit size of 0 bits does not match fixed size (8 bits) of "
+ "type 'Byte'.",
+ ),
+ error.note(
+ "m.emb",
+ ir.module[0].type[1].source_location,
+ "Size specified here.",
+ ),
+ ]
+ ],
+ error.filter_errors(constraints.check_constraints(ir)),
+ )
- def test_explicit_size_too_big_on_fixed_size_type(self):
- ir = _make_ir_from_emb("struct Foo:\n"
- " 0 [+2] Byte:16 double_byte\n"
- "struct Byte:\n"
- " 0 [+1] UInt b\n")
- error_type = ir.module[0].type[0].structure.field[0].type
- self.assertEqual([[
- error.error(
- "m.emb", error_type.size_in_bits.source_location,
- "Explicit size of 16 bits does not match fixed size (8 bits) of "
- "type 'Byte'."),
- error.note(
- "m.emb", ir.module[0].type[1].source_location,
- "Size specified here."),
- ]], error.filter_errors(constraints.check_constraints(ir)))
+ def test_explicit_size_too_big_on_fixed_size_type(self):
+ ir = _make_ir_from_emb(
+ "struct Foo:\n"
+ " 0 [+2] Byte:16 double_byte\n"
+ "struct Byte:\n"
+ " 0 [+1] UInt b\n"
+ )
+ error_type = ir.module[0].type[0].structure.field[0].type
+ self.assertEqual(
+ [
+ [
+ error.error(
+ "m.emb",
+ error_type.size_in_bits.source_location,
+ "Explicit size of 16 bits does not match fixed size (8 bits) of "
+ "type 'Byte'.",
+ ),
+ error.note(
+ "m.emb",
+ ir.module[0].type[1].source_location,
+ "Size specified here.",
+ ),
+ ]
+ ],
+ error.filter_errors(constraints.check_constraints(ir)),
+ )
- def test_explicit_size_ignored_on_variable_size_type(self):
- ir = _make_ir_from_emb('[$default byte_order: "LittleEndian"]\n'
- "struct Foo:\n"
- " 0 [+1] UInt n\n"
- " 1 [+n] UInt:8[] d\n"
- "struct Bar:\n"
- " 0 [+10] Foo:80 foo\n")
- self.assertEqual([], constraints.check_constraints(ir))
+ def test_explicit_size_ignored_on_variable_size_type(self):
+ ir = _make_ir_from_emb(
+ '[$default byte_order: "LittleEndian"]\n'
+ "struct Foo:\n"
+ " 0 [+1] UInt n\n"
+ " 1 [+n] UInt:8[] d\n"
+ "struct Bar:\n"
+ " 0 [+10] Foo:80 foo\n"
+ )
+ self.assertEqual([], constraints.check_constraints(ir))
- def test_fixed_size_type_in_dynamically_sized_field(self):
- ir = _make_ir_from_emb("struct Foo:\n"
- " 0 [+1] UInt bar\n"
- " 0 [+bar] Byte one_byte\n"
- "struct Byte:\n"
- " 0 [+1] UInt b\n")
- self.assertEqual([], constraints.check_constraints(ir))
+ def test_fixed_size_type_in_dynamically_sized_field(self):
+ ir = _make_ir_from_emb(
+ "struct Foo:\n"
+ " 0 [+1] UInt bar\n"
+ " 0 [+bar] Byte one_byte\n"
+ "struct Byte:\n"
+ " 0 [+1] UInt b\n"
+ )
+ self.assertEqual([], constraints.check_constraints(ir))
- def test_enum_in_dynamically_sized_field(self):
- ir = _make_ir_from_emb('[$default byte_order: "BigEndian"]\n'
- "struct Foo:\n"
- " 0 [+1] UInt bar\n"
- " 0 [+bar] Baz baz\n"
- "enum Baz:\n"
- " QUX = 0\n")
- error_type = ir.module[0].type[0].structure.field[1].type
- self.assertEqual(
- [[
- error.error("m.emb", error_type.source_location,
+ def test_enum_in_dynamically_sized_field(self):
+ ir = _make_ir_from_emb(
+ '[$default byte_order: "BigEndian"]\n'
+ "struct Foo:\n"
+ " 0 [+1] UInt bar\n"
+ " 0 [+bar] Baz baz\n"
+ "enum Baz:\n"
+ " QUX = 0\n"
+ )
+ error_type = ir.module[0].type[0].structure.field[1].type
+ self.assertEqual(
+ [
+ [
+ error.error(
+ "m.emb",
+ error_type.source_location,
"Enumeration type 'Baz' cannot be placed in a "
- "dynamically-sized field.")
- ]],
- error.filter_errors(constraints.check_constraints(ir)))
+ "dynamically-sized field.",
+ )
+ ]
+ ],
+ error.filter_errors(constraints.check_constraints(ir)),
+ )
- def test_enum_value_too_high(self):
- ir = _make_ir_from_emb('[$default byte_order: "LittleEndian"]\n'
- "enum Foo:\n"
- " HIGH = 0x1_0000_0000_0000_0000\n")
- error_value = ir.module[0].type[0].enumeration.value[0].value
- self.assertEqual([
- [error.error(
- "m.emb", error_value.source_location,
- # TODO(bolms): Try to print numbers like 2**64 in hex? (I.e., if a
- # number is a round number in hex, but not in decimal, print in
- # hex?)
- "Value 18446744073709551616 is out of range for 64-bit unsigned " +
- "enumeration.")]
- ], constraints.check_constraints(ir))
+ def test_enum_value_too_high(self):
+ ir = _make_ir_from_emb(
+ '[$default byte_order: "LittleEndian"]\n'
+ "enum Foo:\n"
+ " HIGH = 0x1_0000_0000_0000_0000\n"
+ )
+ error_value = ir.module[0].type[0].enumeration.value[0].value
+ self.assertEqual(
+ [
+ [
+ error.error(
+ "m.emb",
+ error_value.source_location,
+ # TODO(bolms): Try to print numbers like 2**64 in hex? (I.e., if a
+ # number is a round number in hex, but not in decimal, print in
+ # hex?)
+ "Value 18446744073709551616 is out of range for 64-bit unsigned "
+ + "enumeration.",
+ )
+ ]
+ ],
+ constraints.check_constraints(ir),
+ )
- def test_enum_value_too_low(self):
- ir = _make_ir_from_emb('[$default byte_order: "LittleEndian"]\n'
- "enum Foo:\n"
- " LOW = -0x8000_0000_0000_0001\n")
- error_value = ir.module[0].type[0].enumeration.value[0].value
- self.assertEqual([
- [error.error(
- "m.emb", error_value.source_location,
- "Value -9223372036854775809 is out of range for 64-bit signed " +
- "enumeration.")]
- ], constraints.check_constraints(ir))
+ def test_enum_value_too_low(self):
+ ir = _make_ir_from_emb(
+ '[$default byte_order: "LittleEndian"]\n'
+ "enum Foo:\n"
+ " LOW = -0x8000_0000_0000_0001\n"
+ )
+ error_value = ir.module[0].type[0].enumeration.value[0].value
+ self.assertEqual(
+ [
+ [
+ error.error(
+ "m.emb",
+ error_value.source_location,
+ "Value -9223372036854775809 is out of range for 64-bit signed "
+ + "enumeration.",
+ )
+ ]
+ ],
+ constraints.check_constraints(ir),
+ )
- def test_enum_value_too_wide(self):
- ir = _make_ir_from_emb('[$default byte_order: "LittleEndian"]\n'
- "enum Foo:\n"
- " LOW = -1\n"
- " HIGH = 0x8000_0000_0000_0000\n")
- error_value = ir.module[0].type[0].enumeration.value[1].value
- self.assertEqual([[
- error.error(
- "m.emb", error_value.source_location,
- "Value 9223372036854775808 is out of range for 64-bit signed " +
- "enumeration.")
- ]], error.filter_errors(constraints.check_constraints(ir)))
+ def test_enum_value_too_wide(self):
+ ir = _make_ir_from_emb(
+ '[$default byte_order: "LittleEndian"]\n'
+ "enum Foo:\n"
+ " LOW = -1\n"
+ " HIGH = 0x8000_0000_0000_0000\n"
+ )
+ error_value = ir.module[0].type[0].enumeration.value[1].value
+ self.assertEqual(
+ [
+ [
+ error.error(
+ "m.emb",
+ error_value.source_location,
+ "Value 9223372036854775808 is out of range for 64-bit signed "
+ + "enumeration.",
+ )
+ ]
+ ],
+ error.filter_errors(constraints.check_constraints(ir)),
+ )
- def test_enum_value_too_wide_unsigned_error_message(self):
- ir = _make_ir_from_emb('[$default byte_order: "LittleEndian"]\n'
- "enum Foo:\n"
- " LOW = -2\n"
- " LOW2 = -1\n"
- " HIGH = 0x8000_0000_0000_0000\n")
- error_value = ir.module[0].type[0].enumeration.value[2].value
- self.assertEqual([[
- error.error(
- "m.emb", error_value.source_location,
- "Value 9223372036854775808 is out of range for 64-bit signed " +
- "enumeration.")
- ]], error.filter_errors(constraints.check_constraints(ir)))
+ def test_enum_value_too_wide_unsigned_error_message(self):
+ ir = _make_ir_from_emb(
+ '[$default byte_order: "LittleEndian"]\n'
+ "enum Foo:\n"
+ " LOW = -2\n"
+ " LOW2 = -1\n"
+ " HIGH = 0x8000_0000_0000_0000\n"
+ )
+ error_value = ir.module[0].type[0].enumeration.value[2].value
+ self.assertEqual(
+ [
+ [
+ error.error(
+ "m.emb",
+ error_value.source_location,
+ "Value 9223372036854775808 is out of range for 64-bit signed "
+ + "enumeration.",
+ )
+ ]
+ ],
+ error.filter_errors(constraints.check_constraints(ir)),
+ )
- def test_enum_value_too_wide_small_size_error_message(self):
- ir = _make_ir_from_emb('[$default byte_order: "LittleEndian"]\n'
- "enum Foo:\n"
- " [maximum_bits: 8]\n"
- " HIGH = 0x100\n")
- error_value = ir.module[0].type[0].enumeration.value[0].value
- self.assertEqual([[
- error.error(
- "m.emb", error_value.source_location,
- "Value 256 is out of range for 8-bit unsigned enumeration.")
- ]], error.filter_errors(constraints.check_constraints(ir)))
+ def test_enum_value_too_wide_small_size_error_message(self):
+ ir = _make_ir_from_emb(
+ '[$default byte_order: "LittleEndian"]\n'
+ "enum Foo:\n"
+ " [maximum_bits: 8]\n"
+ " HIGH = 0x100\n"
+ )
+ error_value = ir.module[0].type[0].enumeration.value[0].value
+ self.assertEqual(
+ [
+ [
+ error.error(
+ "m.emb",
+ error_value.source_location,
+ "Value 256 is out of range for 8-bit unsigned enumeration.",
+ )
+ ]
+ ],
+ error.filter_errors(constraints.check_constraints(ir)),
+ )
- def test_enum_value_too_wide_small_size_signed_error_message(self):
- ir = _make_ir_from_emb('[$default byte_order: "LittleEndian"]\n'
- "enum Foo:\n"
- " [maximum_bits: 8]\n"
- " [is_signed: true]\n"
- " HIGH = 0x80\n")
- error_value = ir.module[0].type[0].enumeration.value[0].value
- self.assertEqual([[
- error.error(
- "m.emb", error_value.source_location,
- "Value 128 is out of range for 8-bit signed enumeration.")
- ]], error.filter_errors(constraints.check_constraints(ir)))
+ def test_enum_value_too_wide_small_size_signed_error_message(self):
+ ir = _make_ir_from_emb(
+ '[$default byte_order: "LittleEndian"]\n'
+ "enum Foo:\n"
+ " [maximum_bits: 8]\n"
+ " [is_signed: true]\n"
+ " HIGH = 0x80\n"
+ )
+ error_value = ir.module[0].type[0].enumeration.value[0].value
+ self.assertEqual(
+ [
+ [
+ error.error(
+ "m.emb",
+ error_value.source_location,
+ "Value 128 is out of range for 8-bit signed enumeration.",
+ )
+ ]
+ ],
+ error.filter_errors(constraints.check_constraints(ir)),
+ )
- def test_enum_value_too_wide_multiple(self):
- ir = _make_ir_from_emb('[$default byte_order: "LittleEndian"]\n'
- "enum Foo:\n"
- " LOW = -2\n"
- " LOW2 = -1\n"
- " HIGH = 0x8000_0000_0000_0000\n"
- " HIGH2 = 0x8000_0000_0000_0001\n")
- error_value = ir.module[0].type[0].enumeration.value[2].value
- error_value2 = ir.module[0].type[0].enumeration.value[3].value
- self.assertEqual([
- [error.error(
- "m.emb", error_value.source_location,
- "Value 9223372036854775808 is out of range for 64-bit signed " +
- "enumeration.")],
- [error.error(
- "m.emb", error_value2.source_location,
- "Value 9223372036854775809 is out of range for 64-bit signed " +
- "enumeration.")]
- ], error.filter_errors(constraints.check_constraints(ir)))
+ def test_enum_value_too_wide_multiple(self):
+ ir = _make_ir_from_emb(
+ '[$default byte_order: "LittleEndian"]\n'
+ "enum Foo:\n"
+ " LOW = -2\n"
+ " LOW2 = -1\n"
+ " HIGH = 0x8000_0000_0000_0000\n"
+ " HIGH2 = 0x8000_0000_0000_0001\n"
+ )
+ error_value = ir.module[0].type[0].enumeration.value[2].value
+ error_value2 = ir.module[0].type[0].enumeration.value[3].value
+ self.assertEqual(
+ [
+ [
+ error.error(
+ "m.emb",
+ error_value.source_location,
+ "Value 9223372036854775808 is out of range for 64-bit signed "
+ + "enumeration.",
+ )
+ ],
+ [
+ error.error(
+ "m.emb",
+ error_value2.source_location,
+ "Value 9223372036854775809 is out of range for 64-bit signed "
+ + "enumeration.",
+ )
+ ],
+ ],
+ error.filter_errors(constraints.check_constraints(ir)),
+ )
- def test_enum_value_too_wide_multiple_signed_error_message(self):
- ir = _make_ir_from_emb('[$default byte_order: "LittleEndian"]\n'
- "enum Foo:\n"
- " LOW = -3\n"
- " LOW2 = -2\n"
- " LOW3 = -1\n"
- " HIGH = 0x8000_0000_0000_0000\n"
- " HIGH2 = 0x8000_0000_0000_0001\n")
- error_value = ir.module[0].type[0].enumeration.value[3].value
- error_value2 = ir.module[0].type[0].enumeration.value[4].value
- self.assertEqual([
- [error.error(
- "m.emb", error_value.source_location,
- "Value 9223372036854775808 is out of range for 64-bit signed "
- "enumeration.")],
- [error.error(
- "m.emb", error_value2.source_location,
- "Value 9223372036854775809 is out of range for 64-bit signed "
- "enumeration.")]
- ], error.filter_errors(constraints.check_constraints(ir)))
+ def test_enum_value_too_wide_multiple_signed_error_message(self):
+ ir = _make_ir_from_emb(
+ '[$default byte_order: "LittleEndian"]\n'
+ "enum Foo:\n"
+ " LOW = -3\n"
+ " LOW2 = -2\n"
+ " LOW3 = -1\n"
+ " HIGH = 0x8000_0000_0000_0000\n"
+ " HIGH2 = 0x8000_0000_0000_0001\n"
+ )
+ error_value = ir.module[0].type[0].enumeration.value[3].value
+ error_value2 = ir.module[0].type[0].enumeration.value[4].value
+ self.assertEqual(
+ [
+ [
+ error.error(
+ "m.emb",
+ error_value.source_location,
+ "Value 9223372036854775808 is out of range for 64-bit signed "
+ "enumeration.",
+ )
+ ],
+ [
+ error.error(
+ "m.emb",
+ error_value2.source_location,
+ "Value 9223372036854775809 is out of range for 64-bit signed "
+ "enumeration.",
+ )
+ ],
+ ],
+ error.filter_errors(constraints.check_constraints(ir)),
+ )
- def test_enum_value_mixed_error_message(self):
- ir = _make_ir_from_emb('[$default byte_order: "LittleEndian"]\n'
- "enum Foo:\n"
- " LOW = -1\n"
- " HIGH = 0x8000_0000_0000_0000\n"
- " HIGH2 = 0x1_0000_0000_0000_0000\n")
- error_value1 = ir.module[0].type[0].enumeration.value[1].value
- error_value2 = ir.module[0].type[0].enumeration.value[2].value
- self.assertEqual([
- [error.error(
- "m.emb", error_value1.source_location,
- "Value 9223372036854775808 is out of range for 64-bit signed " +
- "enumeration.")],
- [error.error(
- "m.emb", error_value2.source_location,
- "Value 18446744073709551616 is out of range for 64-bit signed " +
- "enumeration.")]
- ], error.filter_errors(constraints.check_constraints(ir)))
+ def test_enum_value_mixed_error_message(self):
+ ir = _make_ir_from_emb(
+ '[$default byte_order: "LittleEndian"]\n'
+ "enum Foo:\n"
+ " LOW = -1\n"
+ " HIGH = 0x8000_0000_0000_0000\n"
+ " HIGH2 = 0x1_0000_0000_0000_0000\n"
+ )
+ error_value1 = ir.module[0].type[0].enumeration.value[1].value
+ error_value2 = ir.module[0].type[0].enumeration.value[2].value
+ self.assertEqual(
+ [
+ [
+ error.error(
+ "m.emb",
+ error_value1.source_location,
+ "Value 9223372036854775808 is out of range for 64-bit signed "
+ + "enumeration.",
+ )
+ ],
+ [
+ error.error(
+ "m.emb",
+ error_value2.source_location,
+ "Value 18446744073709551616 is out of range for 64-bit signed "
+ + "enumeration.",
+ )
+ ],
+ ],
+ error.filter_errors(constraints.check_constraints(ir)),
+ )
- def test_enum_value_explicitly_signed_error_message(self):
- ir = _make_ir_from_emb('[$default byte_order: "LittleEndian"]\n'
- "enum Foo:\n"
- " [is_signed: true]\n"
- " HIGH = 0x8000_0000_0000_0000\n"
- " HIGH2 = 0x1_0000_0000_0000_0000\n")
- error_value0 = ir.module[0].type[0].enumeration.value[0].value
- error_value1 = ir.module[0].type[0].enumeration.value[1].value
- self.assertEqual([
- [error.error(
- "m.emb", error_value0.source_location,
- "Value 9223372036854775808 is out of range for 64-bit signed " +
- "enumeration.")],
- [error.error(
- "m.emb", error_value1.source_location,
- "Value 18446744073709551616 is out of range for 64-bit signed " +
- "enumeration.")]
- ], error.filter_errors(constraints.check_constraints(ir)))
+ def test_enum_value_explicitly_signed_error_message(self):
+ ir = _make_ir_from_emb(
+ '[$default byte_order: "LittleEndian"]\n'
+ "enum Foo:\n"
+ " [is_signed: true]\n"
+ " HIGH = 0x8000_0000_0000_0000\n"
+ " HIGH2 = 0x1_0000_0000_0000_0000\n"
+ )
+ error_value0 = ir.module[0].type[0].enumeration.value[0].value
+ error_value1 = ir.module[0].type[0].enumeration.value[1].value
+ self.assertEqual(
+ [
+ [
+ error.error(
+ "m.emb",
+ error_value0.source_location,
+ "Value 9223372036854775808 is out of range for 64-bit signed "
+ + "enumeration.",
+ )
+ ],
+ [
+ error.error(
+ "m.emb",
+ error_value1.source_location,
+ "Value 18446744073709551616 is out of range for 64-bit signed "
+ + "enumeration.",
+ )
+ ],
+ ],
+ error.filter_errors(constraints.check_constraints(ir)),
+ )
- def test_enum_value_explicitly_unsigned_error_message(self):
- ir = _make_ir_from_emb('[$default byte_order: "LittleEndian"]\n'
- "enum Foo:\n"
- " [is_signed: false]\n"
- " LOW = -1\n"
- " HIGH = 0x8000_0000_0000_0000\n"
- " HIGH2 = 0x1_0000_0000_0000_0000\n")
- error_value0 = ir.module[0].type[0].enumeration.value[0].value
- error_value2 = ir.module[0].type[0].enumeration.value[2].value
- self.assertEqual([
- [error.error(
- "m.emb", error_value0.source_location,
- "Value -1 is out of range for 64-bit unsigned enumeration.")],
- [error.error(
- "m.emb", error_value2.source_location,
- "Value 18446744073709551616 is out of range for 64-bit unsigned " +
- "enumeration.")]
- ], error.filter_errors(constraints.check_constraints(ir)))
+ def test_enum_value_explicitly_unsigned_error_message(self):
+ ir = _make_ir_from_emb(
+ '[$default byte_order: "LittleEndian"]\n'
+ "enum Foo:\n"
+ " [is_signed: false]\n"
+ " LOW = -1\n"
+ " HIGH = 0x8000_0000_0000_0000\n"
+ " HIGH2 = 0x1_0000_0000_0000_0000\n"
+ )
+ error_value0 = ir.module[0].type[0].enumeration.value[0].value
+ error_value2 = ir.module[0].type[0].enumeration.value[2].value
+ self.assertEqual(
+ [
+ [
+ error.error(
+ "m.emb",
+ error_value0.source_location,
+ "Value -1 is out of range for 64-bit unsigned enumeration.",
+ )
+ ],
+ [
+ error.error(
+ "m.emb",
+ error_value2.source_location,
+ "Value 18446744073709551616 is out of range for 64-bit unsigned "
+ + "enumeration.",
+ )
+ ],
+ ],
+ error.filter_errors(constraints.check_constraints(ir)),
+ )
- def test_explicit_non_byte_size_array_element(self):
- ir = _make_ir_from_emb('[$default byte_order: "LittleEndian"]\n'
- "struct Foo:\n"
- " 0 [+2] UInt:4[4] nibbles\n")
- error_type = ir.module[0].type[0].structure.field[0].type.array_type
- self.assertEqual([
- [error.error(
- "m.emb", error_type.base_type.source_location,
- "Array elements in structs must have sizes which are a multiple of "
- "8 bits.")]
- ], error.filter_errors(constraints.check_constraints(ir)))
+ def test_explicit_non_byte_size_array_element(self):
+ ir = _make_ir_from_emb(
+ '[$default byte_order: "LittleEndian"]\n'
+ "struct Foo:\n"
+ " 0 [+2] UInt:4[4] nibbles\n"
+ )
+ error_type = ir.module[0].type[0].structure.field[0].type.array_type
+ self.assertEqual(
+ [
+ [
+ error.error(
+ "m.emb",
+ error_type.base_type.source_location,
+ "Array elements in structs must have sizes which are a multiple of "
+ "8 bits.",
+ )
+ ]
+ ],
+ error.filter_errors(constraints.check_constraints(ir)),
+ )
- def test_implicit_non_byte_size_array_element(self):
- ir = _make_ir_from_emb('[$default byte_order: "LittleEndian"]\n'
- "bits Nibble:\n"
- " 0 [+4] UInt nibble\n"
- "struct Foo:\n"
- " 0 [+2] Nibble[4] nibbles\n")
- error_type = ir.module[0].type[1].structure.field[0].type.array_type
- self.assertEqual([
- [error.error(
- "m.emb", error_type.base_type.source_location,
- "Array elements in structs must have sizes which are a multiple of "
- "8 bits.")]
- ], error.filter_errors(constraints.check_constraints(ir)))
+ def test_implicit_non_byte_size_array_element(self):
+ ir = _make_ir_from_emb(
+ '[$default byte_order: "LittleEndian"]\n'
+ "bits Nibble:\n"
+ " 0 [+4] UInt nibble\n"
+ "struct Foo:\n"
+ " 0 [+2] Nibble[4] nibbles\n"
+ )
+ error_type = ir.module[0].type[1].structure.field[0].type.array_type
+ self.assertEqual(
+ [
+ [
+ error.error(
+ "m.emb",
+ error_type.base_type.source_location,
+ "Array elements in structs must have sizes which are a multiple of "
+ "8 bits.",
+ )
+ ]
+ ],
+ error.filter_errors(constraints.check_constraints(ir)),
+ )
- def test_bits_must_be_fixed_size(self):
- ir = _make_ir_from_emb("bits Dynamic:\n"
- " 0 [+3] UInt x\n"
- " 3 [+3 * x] UInt:3[x] a\n")
- error_type = ir.module[0].type[0]
- self.assertEqual([
- [error.error("m.emb", error_type.source_location,
- "`bits` types must be fixed size.")]
- ], error.filter_errors(constraints.check_constraints(ir)))
+ def test_bits_must_be_fixed_size(self):
+ ir = _make_ir_from_emb(
+ "bits Dynamic:\n"
+ " 0 [+3] UInt x\n"
+ " 3 [+3 * x] UInt:3[x] a\n"
+ )
+ error_type = ir.module[0].type[0]
+ self.assertEqual(
+ [
+ [
+ error.error(
+ "m.emb",
+ error_type.source_location,
+ "`bits` types must be fixed size.",
+ )
+ ]
+ ],
+ error.filter_errors(constraints.check_constraints(ir)),
+ )
- def test_bits_must_be_small(self):
- ir = _make_ir_from_emb("bits Big:\n"
- " 0 [+64] UInt x\n"
- " 64 [+1] UInt y\n")
- error_type = ir.module[0].type[0]
- self.assertEqual([
- [error.error("m.emb", error_type.source_location,
- "`bits` types must be 64 bits or smaller.")]
- ], error.filter_errors(constraints.check_constraints(ir)))
+ def test_bits_must_be_small(self):
+ ir = _make_ir_from_emb(
+ "bits Big:\n" " 0 [+64] UInt x\n" " 64 [+1] UInt y\n"
+ )
+ error_type = ir.module[0].type[0]
+ self.assertEqual(
+ [
+ [
+ error.error(
+ "m.emb",
+ error_type.source_location,
+ "`bits` types must be 64 bits or smaller.",
+ )
+ ]
+ ],
+ error.filter_errors(constraints.check_constraints(ir)),
+ )
- def test_constant_expressions_must_be_small(self):
- ir = _make_ir_from_emb('[$default byte_order: "LittleEndian"]\n'
- "struct Foo:\n"
- " 0 [+8] UInt x\n"
- " if x < 0x1_0000_0000_0000_0000:\n"
- " 8 [+1] UInt y\n")
- condition = ir.module[0].type[0].structure.field[1].existence_condition
- error_location = condition.function.args[1].source_location
- self.assertEqual([
- [error.error(
- "m.emb", error_location,
- "Constant value {} of expression cannot fit in a 64-bit signed or "
- "unsigned integer.".format(2**64))]
- ], error.filter_errors(constraints.check_constraints(ir)))
+ def test_constant_expressions_must_be_small(self):
+ ir = _make_ir_from_emb(
+ '[$default byte_order: "LittleEndian"]\n'
+ "struct Foo:\n"
+ " 0 [+8] UInt x\n"
+ " if x < 0x1_0000_0000_0000_0000:\n"
+ " 8 [+1] UInt y\n"
+ )
+ condition = ir.module[0].type[0].structure.field[1].existence_condition
+ error_location = condition.function.args[1].source_location
+ self.assertEqual(
+ [
+ [
+ error.error(
+ "m.emb",
+ error_location,
+ "Constant value {} of expression cannot fit in a 64-bit signed or "
+ "unsigned integer.".format(2**64),
+ )
+ ]
+ ],
+ error.filter_errors(constraints.check_constraints(ir)),
+ )
- def test_variable_expression_out_of_range_for_uint64(self):
- ir = _make_ir_from_emb('[$default byte_order: "LittleEndian"]\n'
- "struct Foo:\n"
- " 0 [+8] UInt x\n"
- " if x + 1 < 0xffff_ffff_ffff_ffff:\n"
- " 8 [+1] UInt y\n")
- condition = ir.module[0].type[0].structure.field[1].existence_condition
- error_location = condition.function.args[0].source_location
- self.assertEqual([
- [error.error(
- "m.emb", error_location,
- "Potential range of expression is {} to {}, which cannot fit in a "
- "64-bit signed or unsigned integer.".format(1, 2**64))]
- ], error.filter_errors(constraints.check_constraints(ir)))
+ def test_variable_expression_out_of_range_for_uint64(self):
+ ir = _make_ir_from_emb(
+ '[$default byte_order: "LittleEndian"]\n'
+ "struct Foo:\n"
+ " 0 [+8] UInt x\n"
+ " if x + 1 < 0xffff_ffff_ffff_ffff:\n"
+ " 8 [+1] UInt y\n"
+ )
+ condition = ir.module[0].type[0].structure.field[1].existence_condition
+ error_location = condition.function.args[0].source_location
+ self.assertEqual(
+ [
+ [
+ error.error(
+ "m.emb",
+ error_location,
+ "Potential range of expression is {} to {}, which cannot fit in a "
+ "64-bit signed or unsigned integer.".format(1, 2**64),
+ )
+ ]
+ ],
+ error.filter_errors(constraints.check_constraints(ir)),
+ )
- def test_variable_expression_out_of_range_for_int64(self):
- ir = _make_ir_from_emb('[$default byte_order: "LittleEndian"]\n'
- "struct Foo:\n"
- " 0 [+8] UInt x\n"
- " if x - 0x8000_0000_0000_0001 < 0:\n"
- " 8 [+1] UInt y\n")
- condition = ir.module[0].type[0].structure.field[1].existence_condition
- error_location = condition.function.args[0].source_location
- self.assertEqual([
- [error.error(
- "m.emb", error_location,
- "Potential range of expression is {} to {}, which cannot fit in a "
- "64-bit signed or unsigned integer.".format(-(2**63) - 1,
- 2**63 - 2))]
- ], error.filter_errors(constraints.check_constraints(ir)))
+ def test_variable_expression_out_of_range_for_int64(self):
+ ir = _make_ir_from_emb(
+ '[$default byte_order: "LittleEndian"]\n'
+ "struct Foo:\n"
+ " 0 [+8] UInt x\n"
+ " if x - 0x8000_0000_0000_0001 < 0:\n"
+ " 8 [+1] UInt y\n"
+ )
+ condition = ir.module[0].type[0].structure.field[1].existence_condition
+ error_location = condition.function.args[0].source_location
+ self.assertEqual(
+ [
+ [
+ error.error(
+ "m.emb",
+ error_location,
+ "Potential range of expression is {} to {}, which cannot fit in a "
+ "64-bit signed or unsigned integer.".format(
+ -(2**63) - 1, 2**63 - 2
+ ),
+ )
+ ]
+ ],
+ error.filter_errors(constraints.check_constraints(ir)),
+ )
- def test_requires_expression_out_of_range_for_uint64(self):
- ir = _make_ir_from_emb('[$default byte_order: "LittleEndian"]\n'
- "struct Foo:\n"
- " 0 [+8] UInt x\n"
- " [requires: this * 2 < 0x1_0000]\n")
- attribute_list = ir.module[0].type[0].structure.field[0].attribute
- error_arg = attribute_list[0].value.expression.function.args[0]
- error_location = error_arg.source_location
- self.assertEqual(
- [[
- error.error(
- "m.emb", error_location,
- "Potential range of expression is {} to {}, which cannot fit "
- "in a 64-bit signed or unsigned integer.".format(0, 2**65-2))
- ]],
- error.filter_errors(constraints.check_constraints(ir)))
+ def test_requires_expression_out_of_range_for_uint64(self):
+ ir = _make_ir_from_emb(
+ '[$default byte_order: "LittleEndian"]\n'
+ "struct Foo:\n"
+ " 0 [+8] UInt x\n"
+ " [requires: this * 2 < 0x1_0000]\n"
+ )
+ attribute_list = ir.module[0].type[0].structure.field[0].attribute
+ error_arg = attribute_list[0].value.expression.function.args[0]
+ error_location = error_arg.source_location
+ self.assertEqual(
+ [
+ [
+ error.error(
+ "m.emb",
+ error_location,
+ "Potential range of expression is {} to {}, which cannot fit "
+ "in a 64-bit signed or unsigned integer.".format(0, 2**65 - 2),
+ )
+ ]
+ ],
+ error.filter_errors(constraints.check_constraints(ir)),
+ )
- def test_arguments_require_different_signedness_64_bits(self):
- ir = _make_ir_from_emb(
- '[$default byte_order: "LittleEndian"]\n'
- "struct Foo:\n"
- " 0 [+1] UInt x\n"
- # Left side requires uint64, right side requires int64.
- " if (x + 0x8000_0000_0000_0000) + (x - 0x7fff_ffff_ffff_ffff) < 10:\n"
- " 1 [+1] UInt y\n")
- condition = ir.module[0].type[0].structure.field[1].existence_condition
- error_expression = condition.function.args[0]
- error_location = error_expression.source_location
- arg0_location = error_expression.function.args[0].source_location
- arg1_location = error_expression.function.args[1].source_location
- self.assertEqual([
- [error.error(
- "m.emb", error_location,
- "Either all arguments to '+' and its result must fit in a 64-bit "
- "unsigned integer, or all must fit in a 64-bit signed integer."),
- error.note("m.emb", arg0_location,
- "Requires unsigned 64-bit integer."),
- error.note("m.emb", arg1_location,
- "Requires signed 64-bit integer.")]
- ], error.filter_errors(constraints.check_constraints(ir)))
+ def test_arguments_require_different_signedness_64_bits(self):
+ ir = _make_ir_from_emb(
+ '[$default byte_order: "LittleEndian"]\n'
+ "struct Foo:\n"
+ " 0 [+1] UInt x\n"
+ # Left side requires uint64, right side requires int64.
+ " if (x + 0x8000_0000_0000_0000) + (x - 0x7fff_ffff_ffff_ffff) < 10:\n"
+ " 1 [+1] UInt y\n"
+ )
+ condition = ir.module[0].type[0].structure.field[1].existence_condition
+ error_expression = condition.function.args[0]
+ error_location = error_expression.source_location
+ arg0_location = error_expression.function.args[0].source_location
+ arg1_location = error_expression.function.args[1].source_location
+ self.assertEqual(
+ [
+ [
+ error.error(
+ "m.emb",
+ error_location,
+ "Either all arguments to '+' and its result must fit in a 64-bit "
+ "unsigned integer, or all must fit in a 64-bit signed integer.",
+ ),
+ error.note(
+ "m.emb", arg0_location, "Requires unsigned 64-bit integer."
+ ),
+ error.note(
+ "m.emb", arg1_location, "Requires signed 64-bit integer."
+ ),
+ ]
+ ],
+ error.filter_errors(constraints.check_constraints(ir)),
+ )
- def test_return_value_requires_different_signedness_from_arguments(self):
- ir = _make_ir_from_emb(
- '[$default byte_order: "LittleEndian"]\n'
- "struct Foo:\n"
- " 0 [+1] UInt x\n"
- # Both arguments require uint64; result fits in int64.
- " if (x + 0x7fff_ffff_ffff_ffff) - 0x8000_0000_0000_0000 < 10:\n"
- " 1 [+1] UInt y\n")
- condition = ir.module[0].type[0].structure.field[1].existence_condition
- error_expression = condition.function.args[0]
- error_location = error_expression.source_location
- arg0_location = error_expression.function.args[0].source_location
- arg1_location = error_expression.function.args[1].source_location
- self.assertEqual([
- [error.error(
- "m.emb", error_location,
- "Either all arguments to '-' and its result must fit in a 64-bit "
- "unsigned integer, or all must fit in a 64-bit signed integer."),
- error.note("m.emb", arg0_location,
- "Requires unsigned 64-bit integer."),
- error.note("m.emb", arg1_location,
- "Requires unsigned 64-bit integer."),
- error.note("m.emb", error_location,
- "Requires signed 64-bit integer.")]
- ], error.filter_errors(constraints.check_constraints(ir)))
+ def test_return_value_requires_different_signedness_from_arguments(self):
+ ir = _make_ir_from_emb(
+ '[$default byte_order: "LittleEndian"]\n'
+ "struct Foo:\n"
+ " 0 [+1] UInt x\n"
+ # Both arguments require uint64; result fits in int64.
+ " if (x + 0x7fff_ffff_ffff_ffff) - 0x8000_0000_0000_0000 < 10:\n"
+ " 1 [+1] UInt y\n"
+ )
+ condition = ir.module[0].type[0].structure.field[1].existence_condition
+ error_expression = condition.function.args[0]
+ error_location = error_expression.source_location
+ arg0_location = error_expression.function.args[0].source_location
+ arg1_location = error_expression.function.args[1].source_location
+ self.assertEqual(
+ [
+ [
+ error.error(
+ "m.emb",
+ error_location,
+ "Either all arguments to '-' and its result must fit in a 64-bit "
+ "unsigned integer, or all must fit in a 64-bit signed integer.",
+ ),
+ error.note(
+ "m.emb", arg0_location, "Requires unsigned 64-bit integer."
+ ),
+ error.note(
+ "m.emb", arg1_location, "Requires unsigned 64-bit integer."
+ ),
+ error.note(
+ "m.emb", error_location, "Requires signed 64-bit integer."
+ ),
+ ]
+ ],
+ error.filter_errors(constraints.check_constraints(ir)),
+ )
- def test_return_value_requires_different_signedness_from_one_argument(self):
- ir = _make_ir_from_emb(
- '[$default byte_order: "LittleEndian"]\n'
- "struct Foo:\n"
- " 0 [+1] UInt x\n"
- # One argument requires uint64; result fits in int64.
- " if (x + 0x7fff_ffff_ffff_fff0) - 0x7fff_ffff_ffff_ffff < 10:\n"
- " 1 [+1] UInt y\n")
- condition = ir.module[0].type[0].structure.field[1].existence_condition
- error_expression = condition.function.args[0]
- error_location = error_expression.source_location
- arg0_location = error_expression.function.args[0].source_location
- self.assertEqual([
- [error.error(
- "m.emb", error_location,
- "Either all arguments to '-' and its result must fit in a 64-bit "
- "unsigned integer, or all must fit in a 64-bit signed integer."),
- error.note("m.emb", arg0_location,
- "Requires unsigned 64-bit integer."),
- error.note("m.emb", error_location,
- "Requires signed 64-bit integer.")]
- ], error.filter_errors(constraints.check_constraints(ir)))
+ def test_return_value_requires_different_signedness_from_one_argument(self):
+ ir = _make_ir_from_emb(
+ '[$default byte_order: "LittleEndian"]\n'
+ "struct Foo:\n"
+ " 0 [+1] UInt x\n"
+ # One argument requires uint64; result fits in int64.
+ " if (x + 0x7fff_ffff_ffff_fff0) - 0x7fff_ffff_ffff_ffff < 10:\n"
+ " 1 [+1] UInt y\n"
+ )
+ condition = ir.module[0].type[0].structure.field[1].existence_condition
+ error_expression = condition.function.args[0]
+ error_location = error_expression.source_location
+ arg0_location = error_expression.function.args[0].source_location
+ self.assertEqual(
+ [
+ [
+ error.error(
+ "m.emb",
+ error_location,
+ "Either all arguments to '-' and its result must fit in a 64-bit "
+ "unsigned integer, or all must fit in a 64-bit signed integer.",
+ ),
+ error.note(
+ "m.emb", arg0_location, "Requires unsigned 64-bit integer."
+ ),
+ error.note(
+ "m.emb", error_location, "Requires signed 64-bit integer."
+ ),
+ ]
+ ],
+ error.filter_errors(constraints.check_constraints(ir)),
+ )
- def test_checks_constancy_of_constant_references(self):
- ir = _make_ir_from_emb("struct Foo:\n"
- " 0 [+1] UInt x\n"
- " let y = x\n"
- " let z = Foo.y\n")
- error_expression = ir.module[0].type[0].structure.field[2].read_transform
- error_location = error_expression.source_location
- note_field = ir.module[0].type[0].structure.field[1]
- note_location = note_field.source_location
- self.assertEqual([
- [error.error("m.emb", error_location,
- "Static references must refer to constants."),
- error.note("m.emb", note_location, "y is not constant.")]
- ], error.filter_errors(constraints.check_constraints(ir)))
+ def test_checks_constancy_of_constant_references(self):
+ ir = _make_ir_from_emb(
+ "struct Foo:\n" " 0 [+1] UInt x\n" " let y = x\n" " let z = Foo.y\n"
+ )
+ error_expression = ir.module[0].type[0].structure.field[2].read_transform
+ error_location = error_expression.source_location
+ note_field = ir.module[0].type[0].structure.field[1]
+ note_location = note_field.source_location
+ self.assertEqual(
+ [
+ [
+ error.error(
+ "m.emb",
+ error_location,
+ "Static references must refer to constants.",
+ ),
+ error.note("m.emb", note_location, "y is not constant."),
+ ]
+ ],
+ error.filter_errors(constraints.check_constraints(ir)),
+ )
- def test_checks_for_explicit_size_on_parameters(self):
- ir = _make_ir_from_emb("struct Foo(y: UInt):\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,
- "Integer range of parameter must not be unbounded; it "
- "must fit in a 64-bit signed or unsigned integer.")]],
- error.filter_errors(constraints.check_constraints(ir)))
+ def test_checks_for_explicit_size_on_parameters(self):
+ ir = _make_ir_from_emb("struct Foo(y: UInt):\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,
+ "Integer range of parameter must not be unbounded; it "
+ "must fit in a 64-bit signed or unsigned integer.",
+ )
+ ]
+ ],
+ error.filter_errors(constraints.check_constraints(ir)),
+ )
- def test_checks_for_correct_explicit_size_on_parameters(self):
- ir = _make_ir_from_emb("struct Foo(y: UInt:300):\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,
- "Potential range of parameter is 0 to {}, which cannot "
- "fit in a 64-bit signed or unsigned integer.".format(
- 2**300-1))]],
- error.filter_errors(constraints.check_constraints(ir)))
+ def test_checks_for_correct_explicit_size_on_parameters(self):
+ ir = _make_ir_from_emb("struct Foo(y: UInt:300):\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,
+ "Potential range of parameter is 0 to {}, which cannot "
+ "fit in a 64-bit signed or unsigned integer.".format(
+ 2**300 - 1
+ ),
+ )
+ ]
+ ],
+ error.filter_errors(constraints.check_constraints(ir)),
+ )
- def test_checks_for_explicit_enum_size_on_parameters(self):
- ir = _make_ir_from_emb("struct Foo(y: Bar:8):\n"
- " 0 [+1] UInt x\n"
- "enum Bar:\n"
- " QUX = 1\n")
- error_parameter = ir.module[0].type[0].runtime_parameter[0]
- error_size = error_parameter.physical_type_alias.size_in_bits
- error_location = error_size.source_location
- self.assertEqual(
- [[error.error(
- "m.emb", error_location,
- "Parameters with enum type may not have explicit size.")]],
- error.filter_errors(constraints.check_constraints(ir)))
+ def test_checks_for_explicit_enum_size_on_parameters(self):
+ ir = _make_ir_from_emb(
+ "struct Foo(y: Bar:8):\n" " 0 [+1] UInt x\n" "enum Bar:\n" " QUX = 1\n"
+ )
+ error_parameter = ir.module[0].type[0].runtime_parameter[0]
+ error_size = error_parameter.physical_type_alias.size_in_bits
+ error_location = error_size.source_location
+ self.assertEqual(
+ [
+ [
+ error.error(
+ "m.emb",
+ error_location,
+ "Parameters with enum type may not have explicit size.",
+ )
+ ]
+ ],
+ error.filter_errors(constraints.check_constraints(ir)),
+ )
if __name__ == "__main__":
- unittest.main()
+ unittest.main()
