compiler/front_end/constraints_test.py

# 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 constraints.py."""

import unittest
from compiler.front_end import attributes
from compiler.front_end import constraints
from compiler.front_end import glue
from compiler.util import error
from compiler.util import ir_data_utils
from compiler.util import ir_util
from compiler.util import test_util


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


class ConstraintsTest(unittest.TestCase):
    """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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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,
                        "Enumeration type 'Baz' cannot be placed in a "
                        "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_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_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_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_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_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_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_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_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_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_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_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_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_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()