# 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 expression_bounds."""

import unittest
from compiler.front_end import expression_bounds
from compiler.front_end import glue
from compiler.util import test_util


class ComputeConstantsTest(unittest.TestCase):

  def _make_ir(self, emb_text):
    ir, unused_debug_info, errors = glue.parse_emboss_file(
        "m.emb",
        test_util.dict_file_reader({"m.emb": emb_text}),
        stop_before_step="compute_constants")
    assert not errors, errors
    return ir

  def test_constant_integer(self):
    ir = self._make_ir("struct Foo:\n"
                       "  10 [+1]  UInt  x\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    start = ir.module[0].type[0].structure.field[0].location.start
    self.assertEqual("10", start.type.integer.minimum_value)
    self.assertEqual("10", start.type.integer.maximum_value)
    self.assertEqual("10", start.type.integer.modular_value)
    self.assertEqual("infinity", start.type.integer.modulus)

  def test_boolean_constant(self):
    ir = self._make_ir("struct Foo:\n"
                       "  if true:\n"
                       "    0 [+1]  UInt  x\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    expression = ir.module[0].type[0].structure.field[0].existence_condition
    self.assertTrue(expression.type.boolean.HasField("value"))
    self.assertTrue(expression.type.boolean.value)

  def test_constant_equality(self):
    ir = self._make_ir("struct Foo:\n"
                       "  if 5 == 5:\n"
                       "    0 [+1]  UInt  x\n"
                       "  if 5 == 6:\n"
                       "    0 [+1]  UInt  y\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    structure = ir.module[0].type[0].structure
    true_condition = structure.field[0].existence_condition
    false_condition = structure.field[1].existence_condition
    self.assertTrue(true_condition.type.boolean.HasField("value"))
    self.assertTrue(true_condition.type.boolean.value)
    self.assertTrue(false_condition.type.boolean.HasField("value"))
    self.assertFalse(false_condition.type.boolean.value)

  def test_constant_inequality(self):
    ir = self._make_ir("struct Foo:\n"
                       "  if 5 != 5:\n"
                       "    0 [+1]  UInt  x\n"
                       "  if 5 != 6:\n"
                       "    0 [+1]  UInt  y\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    structure = ir.module[0].type[0].structure
    false_condition = structure.field[0].existence_condition
    true_condition = structure.field[1].existence_condition
    self.assertTrue(false_condition.type.boolean.HasField("value"))
    self.assertFalse(false_condition.type.boolean.value)
    self.assertTrue(true_condition.type.boolean.HasField("value"))
    self.assertTrue(true_condition.type.boolean.value)

  def test_constant_less_than(self):
    ir = self._make_ir("struct Foo:\n"
                       "  if 5 < 4:\n"
                       "    0 [+1]  UInt  x\n"
                       "  if 5 < 5:\n"
                       "    0 [+1]  UInt  y\n"
                       "  if 5 < 6:\n"
                       "    0 [+1]  UInt  z\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    structure = ir.module[0].type[0].structure
    greater_than_condition = structure.field[0].existence_condition
    equal_condition = structure.field[1].existence_condition
    less_than_condition = structure.field[2].existence_condition
    self.assertTrue(greater_than_condition.type.boolean.HasField("value"))
    self.assertFalse(greater_than_condition.type.boolean.value)
    self.assertTrue(equal_condition.type.boolean.HasField("value"))
    self.assertFalse(equal_condition.type.boolean.value)
    self.assertTrue(less_than_condition.type.boolean.HasField("value"))
    self.assertTrue(less_than_condition.type.boolean.value)

  def test_constant_less_than_or_equal(self):
    ir = self._make_ir("struct Foo:\n"
                       "  if 5 <= 4:\n"
                       "    0 [+1]  UInt  x\n"
                       "  if 5 <= 5:\n"
                       "    0 [+1]  UInt  y\n"
                       "  if 5 <= 6:\n"
                       "    0 [+1]  UInt  z\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    structure = ir.module[0].type[0].structure
    greater_than_condition = structure.field[0].existence_condition
    equal_condition = structure.field[1].existence_condition
    less_than_condition = structure.field[2].existence_condition
    self.assertTrue(greater_than_condition.type.boolean.HasField("value"))
    self.assertFalse(greater_than_condition.type.boolean.value)
    self.assertTrue(equal_condition.type.boolean.HasField("value"))
    self.assertTrue(equal_condition.type.boolean.value)
    self.assertTrue(less_than_condition.type.boolean.HasField("value"))
    self.assertTrue(less_than_condition.type.boolean.value)

  def test_constant_greater_than(self):
    ir = self._make_ir("struct Foo:\n"
                       "  if 5 > 4:\n"
                       "    0 [+1]  UInt  x\n"
                       "  if 5 > 5:\n"
                       "    0 [+1]  UInt  y\n"
                       "  if 5 > 6:\n"
                       "    0 [+1]  UInt  z\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    structure = ir.module[0].type[0].structure
    greater_than_condition = structure.field[0].existence_condition
    equal_condition = structure.field[1].existence_condition
    less_than_condition = structure.field[2].existence_condition
    self.assertTrue(greater_than_condition.type.boolean.HasField("value"))
    self.assertTrue(greater_than_condition.type.boolean.value)
    self.assertTrue(equal_condition.type.boolean.HasField("value"))
    self.assertFalse(equal_condition.type.boolean.value)
    self.assertTrue(less_than_condition.type.boolean.HasField("value"))
    self.assertFalse(less_than_condition.type.boolean.value)

  def test_constant_greater_than_or_equal(self):
    ir = self._make_ir("struct Foo:\n"
                       "  if 5 >= 4:\n"
                       "    0 [+1]  UInt  x\n"
                       "  if 5 >= 5:\n"
                       "    0 [+1]  UInt  y\n"
                       "  if 5 >= 6:\n"
                       "    0 [+1]  UInt  z\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    structure = ir.module[0].type[0].structure
    greater_than_condition = structure.field[0].existence_condition
    equal_condition = structure.field[1].existence_condition
    less_than_condition = structure.field[2].existence_condition
    self.assertTrue(greater_than_condition.type.boolean.HasField("value"))
    self.assertTrue(greater_than_condition.type.boolean.value)
    self.assertTrue(equal_condition.type.boolean.HasField("value"))
    self.assertTrue(equal_condition.type.boolean.value)
    self.assertTrue(less_than_condition.type.boolean.HasField("value"))
    self.assertFalse(less_than_condition.type.boolean.value)

  def test_constant_and(self):
    ir = self._make_ir("struct Foo:\n"
                       "  if false && false:\n"
                       "    0 [+1]  UInt  x\n"
                       "  if true && false:\n"
                       "    0 [+1]  UInt  y\n"
                       "  if false && true:\n"
                       "    0 [+1]  UInt  z\n"
                       "  if true && true:\n"
                       "    0 [+1]  UInt  w\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    structure = ir.module[0].type[0].structure
    false_false_condition = structure.field[0].existence_condition
    true_false_condition = structure.field[1].existence_condition
    false_true_condition = structure.field[2].existence_condition
    true_true_condition = structure.field[3].existence_condition
    self.assertTrue(false_false_condition.type.boolean.HasField("value"))
    self.assertFalse(false_false_condition.type.boolean.value)
    self.assertTrue(true_false_condition.type.boolean.HasField("value"))
    self.assertFalse(true_false_condition.type.boolean.value)
    self.assertTrue(false_true_condition.type.boolean.HasField("value"))
    self.assertFalse(false_true_condition.type.boolean.value)
    self.assertTrue(true_true_condition.type.boolean.HasField("value"))
    self.assertTrue(true_true_condition.type.boolean.value)

  def test_constant_or(self):
    ir = self._make_ir("struct Foo:\n"
                       "  if false || false:\n"
                       "    0 [+1]  UInt  x\n"
                       "  if true || false:\n"
                       "    0 [+1]  UInt  y\n"
                       "  if false || true:\n"
                       "    0 [+1]  UInt  z\n"
                       "  if true || true:\n"
                       "    0 [+1]  UInt  w\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    structure = ir.module[0].type[0].structure
    false_false_condition = structure.field[0].existence_condition
    true_false_condition = structure.field[1].existence_condition
    false_true_condition = structure.field[2].existence_condition
    true_true_condition = structure.field[3].existence_condition
    self.assertTrue(false_false_condition.type.boolean.HasField("value"))
    self.assertFalse(false_false_condition.type.boolean.value)
    self.assertTrue(true_false_condition.type.boolean.HasField("value"))
    self.assertTrue(true_false_condition.type.boolean.value)
    self.assertTrue(false_true_condition.type.boolean.HasField("value"))
    self.assertTrue(false_true_condition.type.boolean.value)
    self.assertTrue(true_true_condition.type.boolean.HasField("value"))
    self.assertTrue(true_true_condition.type.boolean.value)

  def test_enum_constant(self):
    ir = self._make_ir("struct Foo:\n"
                       "  if Bar.QUX == Bar.QUX:\n"
                       "    0 [+1]  Bar  x\n"
                       "enum Bar:\n"
                       "  QUX = 12\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    condition = ir.module[0].type[0].structure.field[0].existence_condition
    left = condition.function.args[0]
    self.assertEqual("12", left.type.enumeration.value)

  def test_non_constant_field_reference(self):
    ir = self._make_ir("struct Foo:\n"
                       "  y [+1]  UInt  x\n"
                       "  0 [+1]  UInt  y\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    start = ir.module[0].type[0].structure.field[0].location.start
    self.assertEqual("0", start.type.integer.minimum_value)
    self.assertEqual("255", start.type.integer.maximum_value)
    self.assertEqual("0", start.type.integer.modular_value)
    self.assertEqual("1", start.type.integer.modulus)

  def test_field_reference_bounds_are_uncomputable(self):
    # Variable-sized UInt/Int/Bcd should not cause an error here: they are
    # handled in the constraints pass.
    ir = self._make_ir("struct Foo:\n"
                       "  0 [+1]  UInt  x\n"
                       "  0 [+x]  UInt  y\n"
                       "  y [+1]  UInt  z\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))

  def test_field_references_references_bounds_are_uncomputable(self):
    ir = self._make_ir("struct Foo:\n"
                       "  0 [+1]  UInt  x\n"
                       "  0 [+x]  UInt  y\n"
                       "  0 [+y]  UInt  z\n"
                       "  z [+1]  UInt  q\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))

  def test_non_constant_equality(self):
    ir = self._make_ir("struct Foo:\n"
                       "  if 5 == y:\n"
                       "    0 [+1]  UInt  x\n"
                       "  0 [+1]  UInt  y\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    structure = ir.module[0].type[0].structure
    condition = structure.field[0].existence_condition
    self.assertFalse(condition.type.boolean.HasField("value"))

  def test_constant_addition(self):
    ir = self._make_ir("struct Foo:\n"
                       "  7+5 [+1]  UInt  x\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    start = ir.module[0].type[0].structure.field[0].location.start
    self.assertEqual("12", start.type.integer.minimum_value)
    self.assertEqual("12", start.type.integer.maximum_value)
    self.assertEqual("12", start.type.integer.modular_value)
    self.assertEqual("infinity", start.type.integer.modulus)
    self.assertEqual("7", start.function.args[0].type.integer.minimum_value)
    self.assertEqual("7", start.function.args[0].type.integer.maximum_value)
    self.assertEqual("7", start.function.args[0].type.integer.modular_value)
    self.assertEqual("infinity", start.type.integer.modulus)
    self.assertEqual("5", start.function.args[1].type.integer.minimum_value)
    self.assertEqual("5", start.function.args[1].type.integer.maximum_value)
    self.assertEqual("5", start.function.args[1].type.integer.modular_value)
    self.assertEqual("infinity", start.type.integer.modulus)

  def test_constant_subtraction(self):
    ir = self._make_ir("struct Foo:\n"
                       "  7-5 [+1]  UInt  x\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    start = ir.module[0].type[0].structure.field[0].location.start
    self.assertEqual("2", start.type.integer.minimum_value)
    self.assertEqual("2", start.type.integer.maximum_value)
    self.assertEqual("2", start.type.integer.modular_value)
    self.assertEqual("infinity", start.type.integer.modulus)
    self.assertEqual("7", start.function.args[0].type.integer.minimum_value)
    self.assertEqual("7", start.function.args[0].type.integer.maximum_value)
    self.assertEqual("7", start.function.args[0].type.integer.modular_value)
    self.assertEqual("infinity", start.type.integer.modulus)
    self.assertEqual("5", start.function.args[1].type.integer.minimum_value)
    self.assertEqual("5", start.function.args[1].type.integer.maximum_value)
    self.assertEqual("5", start.function.args[1].type.integer.modular_value)
    self.assertEqual("infinity", start.type.integer.modulus)

  def test_constant_multiplication(self):
    ir = self._make_ir("struct Foo:\n"
                       "  7*5 [+1]  UInt  x\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    start = ir.module[0].type[0].structure.field[0].location.start
    self.assertEqual("35", start.type.integer.minimum_value)
    self.assertEqual("35", start.type.integer.maximum_value)
    self.assertEqual("35", start.type.integer.modular_value)
    self.assertEqual("infinity", start.type.integer.modulus)
    self.assertEqual("7", start.function.args[0].type.integer.minimum_value)
    self.assertEqual("7", start.function.args[0].type.integer.maximum_value)
    self.assertEqual("7", start.function.args[0].type.integer.modular_value)
    self.assertEqual("infinity", start.type.integer.modulus)
    self.assertEqual("5", start.function.args[1].type.integer.minimum_value)
    self.assertEqual("5", start.function.args[1].type.integer.maximum_value)
    self.assertEqual("5", start.function.args[1].type.integer.modular_value)
    self.assertEqual("infinity", start.type.integer.modulus)

  def test_nested_constant_expression(self):
    ir = self._make_ir("struct Foo:\n"
                       "  if 7*(3+1) == 28:\n"
                       "    0 [+1]  UInt  x\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    condition = ir.module[0].type[0].structure.field[0].existence_condition
    self.assertTrue(condition.type.boolean.value)
    condition_left = condition.function.args[0]
    self.assertEqual("28", condition_left.type.integer.minimum_value)
    self.assertEqual("28", condition_left.type.integer.maximum_value)
    self.assertEqual("28", condition_left.type.integer.modular_value)
    self.assertEqual("infinity", condition_left.type.integer.modulus)
    condition_left_left = condition_left.function.args[0]
    self.assertEqual("7", condition_left_left.type.integer.minimum_value)
    self.assertEqual("7", condition_left_left.type.integer.maximum_value)
    self.assertEqual("7", condition_left_left.type.integer.modular_value)
    self.assertEqual("infinity", condition_left_left.type.integer.modulus)
    condition_left_right = condition_left.function.args[1]
    self.assertEqual("4", condition_left_right.type.integer.minimum_value)
    self.assertEqual("4", condition_left_right.type.integer.maximum_value)
    self.assertEqual("4", condition_left_right.type.integer.modular_value)
    self.assertEqual("infinity", condition_left_right.type.integer.modulus)
    condition_left_right_left = condition_left_right.function.args[0]
    self.assertEqual("3", condition_left_right_left.type.integer.minimum_value)
    self.assertEqual("3", condition_left_right_left.type.integer.maximum_value)
    self.assertEqual("3", condition_left_right_left.type.integer.modular_value)
    self.assertEqual("infinity", condition_left_right_left.type.integer.modulus)
    condition_left_right_right = condition_left_right.function.args[1]
    self.assertEqual("1", condition_left_right_right.type.integer.minimum_value)
    self.assertEqual("1", condition_left_right_right.type.integer.maximum_value)
    self.assertEqual("1", condition_left_right_right.type.integer.modular_value)
    self.assertEqual("infinity",
                     condition_left_right_right.type.integer.modulus)

  def test_constant_plus_non_constant(self):
    ir = self._make_ir("struct Foo:\n"
                       "  0       [+1]  UInt  x\n"
                       "  5+(4*x) [+1]  UInt  y\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    y_start = ir.module[0].type[0].structure.field[1].location.start
    self.assertEqual("4", y_start.type.integer.modulus)
    self.assertEqual("1", y_start.type.integer.modular_value)
    self.assertEqual("5", y_start.type.integer.minimum_value)
    self.assertEqual("1025", y_start.type.integer.maximum_value)

  def test_constant_minus_non_constant(self):
    ir = self._make_ir("struct Foo:\n"
                       "  0       [+1]  UInt  x\n"
                       "  5-(4*x) [+1]  UInt  y\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    y_start = ir.module[0].type[0].structure.field[1].location.start
    self.assertEqual("4", y_start.type.integer.modulus)
    self.assertEqual("1", y_start.type.integer.modular_value)
    self.assertEqual("-1015", y_start.type.integer.minimum_value)
    self.assertEqual("5", y_start.type.integer.maximum_value)

  def test_non_constant_minus_constant(self):
    ir = self._make_ir("struct Foo:\n"
                       "  0       [+1]  UInt  x\n"
                       "  (4*x)-5 [+1]  UInt  y\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    y_start = ir.module[0].type[0].structure.field[1].location.start
    self.assertEqual(str((4 * 0) - 5), y_start.type.integer.minimum_value)
    self.assertEqual(str((4 * 255) - 5), y_start.type.integer.maximum_value)
    self.assertEqual("4", y_start.type.integer.modulus)
    self.assertEqual("3", y_start.type.integer.modular_value)

  def test_non_constant_plus_non_constant(self):
    ir = self._make_ir("struct Foo:\n"
                       "  0             [+1]  UInt  x\n"
                       "  1             [+1]  UInt  y\n"
                       "  (4*x)+(6*y+3) [+1]  UInt  z\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    z_start = ir.module[0].type[0].structure.field[2].location.start
    self.assertEqual("3", z_start.type.integer.minimum_value)
    self.assertEqual(str(4 * 255 + 6 * 255 + 3),
                     z_start.type.integer.maximum_value)
    self.assertEqual("2", z_start.type.integer.modulus)
    self.assertEqual("1", z_start.type.integer.modular_value)

  def test_non_constant_minus_non_constant(self):
    ir = self._make_ir("struct Foo:\n"
                       "  0            [+1]  UInt  x\n"
                       "  1            [+1]  UInt  y\n"
                       "  (x*3)-(y*3)  [+1]  UInt  z\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    z_start = ir.module[0].type[0].structure.field[2].location.start
    self.assertEqual("3", z_start.type.integer.modulus)
    self.assertEqual("0", z_start.type.integer.modular_value)
    self.assertEqual(str(-3 * 255), z_start.type.integer.minimum_value)
    self.assertEqual(str(3 * 255), z_start.type.integer.maximum_value)

  def test_non_constant_times_constant(self):
    ir = self._make_ir("struct Foo:\n"
                       "  0         [+1]  UInt  x\n"
                       "  (4*x+1)*5 [+1]  UInt  y\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    y_start = ir.module[0].type[0].structure.field[1].location.start
    self.assertEqual("20", y_start.type.integer.modulus)
    self.assertEqual("5", y_start.type.integer.modular_value)
    self.assertEqual("5", y_start.type.integer.minimum_value)
    self.assertEqual(str((4 * 255 + 1) * 5), y_start.type.integer.maximum_value)

  def test_non_constant_times_negative_constant(self):
    ir = self._make_ir("struct Foo:\n"
                       "  0          [+1]  UInt  x\n"
                       "  (4*x+1)*-5 [+1]  UInt  y\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    y_start = ir.module[0].type[0].structure.field[1].location.start
    self.assertEqual("20", y_start.type.integer.modulus)
    self.assertEqual("15", y_start.type.integer.modular_value)
    self.assertEqual(str((4 * 255 + 1) * -5),
                     y_start.type.integer.minimum_value)
    self.assertEqual("-5", y_start.type.integer.maximum_value)

  def test_non_constant_times_zero(self):
    ir = self._make_ir("struct Foo:\n"
                       "  0         [+1]  UInt  x\n"
                       "  (4*x+1)*0 [+1]  UInt  y\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    y_start = ir.module[0].type[0].structure.field[1].location.start
    self.assertEqual("infinity", y_start.type.integer.modulus)
    self.assertEqual("0", y_start.type.integer.modular_value)
    self.assertEqual("0", y_start.type.integer.minimum_value)
    self.assertEqual("0", y_start.type.integer.maximum_value)

  def test_non_constant_times_non_constant_shared_modulus(self):
    ir = self._make_ir("struct Foo:\n"
                       "  0               [+1]  UInt  x\n"
                       "  1               [+1]  UInt  y\n"
                       "  (4*x+3)*(4*y+3) [+1]  UInt  z\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    z_start = ir.module[0].type[0].structure.field[2].location.start
    self.assertEqual("4", z_start.type.integer.modulus)
    self.assertEqual("1", z_start.type.integer.modular_value)
    self.assertEqual("9", z_start.type.integer.minimum_value)
    self.assertEqual(str((4 * 255 + 3)**2), z_start.type.integer.maximum_value)

  def test_non_constant_times_non_constant_congruent_to_zero(self):
    ir = self._make_ir("struct Foo:\n"
                       "  0           [+1]  UInt  x\n"
                       "  1           [+1]  UInt  y\n"
                       "  (4*x)*(4*y) [+1]  UInt  z\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    z_start = ir.module[0].type[0].structure.field[2].location.start
    self.assertEqual("16", z_start.type.integer.modulus)
    self.assertEqual("0", z_start.type.integer.modular_value)
    self.assertEqual("0", z_start.type.integer.minimum_value)
    self.assertEqual(str((4 * 255)**2), z_start.type.integer.maximum_value)

  def test_non_constant_times_non_constant_partially_shared_modulus(self):
    ir = self._make_ir("struct Foo:\n"
                       "  0               [+1]  UInt  x\n"
                       "  1               [+1]  UInt  y\n"
                       "  (4*x+3)*(8*y+3) [+1]  UInt  z\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    z_start = ir.module[0].type[0].structure.field[2].location.start
    self.assertEqual("4", z_start.type.integer.modulus)
    self.assertEqual("1", z_start.type.integer.modular_value)
    self.assertEqual("9", z_start.type.integer.minimum_value)
    self.assertEqual(str((4 * 255 + 3) * (8 * 255 + 3)),
                     z_start.type.integer.maximum_value)

  def test_non_constant_times_non_constant_full_complexity(self):
    ir = self._make_ir("struct Foo:\n"
                       "  0                  [+1]  UInt  x\n"
                       "  1                  [+1]  UInt  y\n"
                       "  (12*x+9)*(40*y+15) [+1]  UInt  z\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    z_start = ir.module[0].type[0].structure.field[2].location.start
    self.assertEqual("60", z_start.type.integer.modulus)
    self.assertEqual("15", z_start.type.integer.modular_value)
    self.assertEqual(str(9 * 15), z_start.type.integer.minimum_value)
    self.assertEqual(str((12 * 255 + 9) * (40 * 255 + 15)),
                     z_start.type.integer.maximum_value)

  def test_signed_non_constant_times_signed_non_constant_full_complexity(self):
    ir = self._make_ir("struct Foo:\n"
                       "  0                  [+1]  Int  x\n"
                       "  1                  [+1]  Int  y\n"
                       "  (12*x+9)*(40*y+15) [+1]  Int  z\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    z_start = ir.module[0].type[0].structure.field[2].location.start
    self.assertEqual("60", z_start.type.integer.modulus)
    self.assertEqual("15", z_start.type.integer.modular_value)
    # Max x/min y is slightly lower than min x/max y (-7825965 vs -7780065).
    self.assertEqual(str((12 * 127 + 9) * (40 * -128 + 15)),
                     z_start.type.integer.minimum_value)
    # Max x/max y is slightly higher than min x/min y (7810635 vs 7795335).
    self.assertEqual(str((12 * 127 + 9) * (40 * 127 + 15)),
                     z_start.type.integer.maximum_value)

  def test_non_constant_times_non_constant_flipped_min_max(self):
    ir = self._make_ir("struct Foo:\n"
                       "  0             [+1]  UInt  x\n"
                       "  1             [+1]  UInt  y\n"
                       "  (-x*3)*(y*3)  [+1]  UInt  z\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    z_start = ir.module[0].type[0].structure.field[2].location.start
    self.assertEqual("9", z_start.type.integer.modulus)
    self.assertEqual("0", z_start.type.integer.modular_value)
    self.assertEqual(str(-((3 * 255)**2)), z_start.type.integer.minimum_value)
    self.assertEqual("0", z_start.type.integer.maximum_value)

  # Currently, only `$static_size_in_bits` has an infinite bound, so all of the
  # examples below use `$static_size_in_bits`.  Unfortunately, this also means
  # that these tests rely on the fact that Emboss doesn't try to do any term
  # rewriting or smart correlation between the arguments of various operators:
  # for example, several tests rely on `$static_size_in_bits -
  # $static_size_in_bits` having the range `-infinity` to `infinity`, when a
  # trivial term rewrite would turn that expression into `0`.
  #
  # Unbounded expressions are only allowed at compile-time anyway, so these
  # tests cover some fairly unlikely uses of the Emboss expression language.
  def test_unbounded_plus_constant(self):
    ir = self._make_ir("external Foo:\n"
                       "  [requires: $static_size_in_bits + 2 > 0]\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    expr = ir.module[0].type[0].attribute[0].value.expression.function.args[0]
    self.assertEqual("1", expr.type.integer.modulus)
    self.assertEqual("0", expr.type.integer.modular_value)
    self.assertEqual("2", expr.type.integer.minimum_value)
    self.assertEqual("infinity", expr.type.integer.maximum_value)

  def test_negative_unbounded_plus_constant(self):
    ir = self._make_ir("external Foo:\n"
                       "  [requires: -$static_size_in_bits + 2 > 0]\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    expr = ir.module[0].type[0].attribute[0].value.expression.function.args[0]
    self.assertEqual("1", expr.type.integer.modulus)
    self.assertEqual("0", expr.type.integer.modular_value)
    self.assertEqual("-infinity", expr.type.integer.minimum_value)
    self.assertEqual("2", expr.type.integer.maximum_value)

  def test_negative_unbounded_plus_unbounded(self):
    ir = self._make_ir(
        "external Foo:\n"
        "  [requires: -$static_size_in_bits + $static_size_in_bits > 0]\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    expr = ir.module[0].type[0].attribute[0].value.expression.function.args[0]
    self.assertEqual("1", expr.type.integer.modulus)
    self.assertEqual("0", expr.type.integer.modular_value)
    self.assertEqual("-infinity", expr.type.integer.minimum_value)
    self.assertEqual("infinity", expr.type.integer.maximum_value)

  def test_unbounded_minus_unbounded(self):
    ir = self._make_ir(
        "external Foo:\n"
        "  [requires: $static_size_in_bits - $static_size_in_bits > 0]\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    expr = ir.module[0].type[0].attribute[0].value.expression.function.args[0]
    self.assertEqual("1", expr.type.integer.modulus)
    self.assertEqual("0", expr.type.integer.modular_value)
    self.assertEqual("-infinity", expr.type.integer.minimum_value)
    self.assertEqual("infinity", expr.type.integer.maximum_value)

  def test_unbounded_minus_negative_unbounded(self):
    ir = self._make_ir(
        "external Foo:\n"
        "  [requires: $static_size_in_bits - -$static_size_in_bits > 0]\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    expr = ir.module[0].type[0].attribute[0].value.expression.function.args[0]
    self.assertEqual("1", expr.type.integer.modulus)
    self.assertEqual("0", expr.type.integer.modular_value)
    self.assertEqual("0", expr.type.integer.minimum_value)
    self.assertEqual("infinity", expr.type.integer.maximum_value)

  def test_unbounded_times_constant(self):
    ir = self._make_ir("external Foo:\n"
                       "  [requires: ($static_size_in_bits + 1) * 2 > 0]\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    expr = ir.module[0].type[0].attribute[0].value.expression.function.args[0]
    self.assertEqual("2", expr.type.integer.modulus)
    self.assertEqual("0", expr.type.integer.modular_value)
    self.assertEqual("2", expr.type.integer.minimum_value)
    self.assertEqual("infinity", expr.type.integer.maximum_value)

  def test_unbounded_times_negative_constant(self):
    ir = self._make_ir("external Foo:\n"
                       "  [requires: ($static_size_in_bits + 1) * -2 > 0]\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    expr = ir.module[0].type[0].attribute[0].value.expression.function.args[0]
    self.assertEqual("2", expr.type.integer.modulus)
    self.assertEqual("0", expr.type.integer.modular_value)
    self.assertEqual("-infinity", expr.type.integer.minimum_value)
    self.assertEqual("-2", expr.type.integer.maximum_value)

  def test_unbounded_times_negative_zero(self):
    ir = self._make_ir("external Foo:\n"
                       "  [requires: ($static_size_in_bits + 1) * 0 > 0]\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    expr = ir.module[0].type[0].attribute[0].value.expression.function.args[0]
    self.assertEqual("infinity", expr.type.integer.modulus)
    self.assertEqual("0", expr.type.integer.modular_value)
    self.assertEqual("0", expr.type.integer.minimum_value)
    self.assertEqual("0", expr.type.integer.maximum_value)

  def test_negative_unbounded_times_constant(self):
    ir = self._make_ir("external Foo:\n"
                       "  [requires: (-$static_size_in_bits + 1) * 2 > 0]\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    expr = ir.module[0].type[0].attribute[0].value.expression.function.args[0]
    self.assertEqual("2", expr.type.integer.modulus)
    self.assertEqual("0", expr.type.integer.modular_value)
    self.assertEqual("-infinity", expr.type.integer.minimum_value)
    self.assertEqual("2", expr.type.integer.maximum_value)

  def test_double_unbounded_minus_unbounded(self):
    ir = self._make_ir(
        "external Foo:\n"
        "  [requires: 2 * $static_size_in_bits - $static_size_in_bits > 0]\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    expr = ir.module[0].type[0].attribute[0].value.expression.function.args[0]
    self.assertEqual("1", expr.type.integer.modulus)
    self.assertEqual("0", expr.type.integer.modular_value)
    self.assertEqual("-infinity", expr.type.integer.minimum_value)
    self.assertEqual("infinity", expr.type.integer.maximum_value)

  def test_double_unbounded_times_negative_unbounded(self):
    ir = self._make_ir(
        "external Foo:\n"
        "  [requires: 2 * $static_size_in_bits * -$static_size_in_bits > 0]\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    expr = ir.module[0].type[0].attribute[0].value.expression.function.args[0]
    self.assertEqual("2", expr.type.integer.modulus)
    self.assertEqual("0", expr.type.integer.modular_value)
    self.assertEqual("-infinity", expr.type.integer.minimum_value)
    self.assertEqual("0", expr.type.integer.maximum_value)

  def test_upper_bound_of_field(self):
    ir = self._make_ir("struct Foo:\n"
                       "  0 [+1]  Int  x\n"
                       "  let u = $upper_bound(x)\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    u_type = ir.module[0].type[0].structure.field[1].read_transform.type
    self.assertEqual("infinity", u_type.integer.modulus)
    self.assertEqual("127", u_type.integer.maximum_value)
    self.assertEqual("127", u_type.integer.minimum_value)
    self.assertEqual("127", u_type.integer.modular_value)

  def test_lower_bound_of_field(self):
    ir = self._make_ir("struct Foo:\n"
                       "  0 [+1]  Int  x\n"
                       "  let l = $lower_bound(x)\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    l_type = ir.module[0].type[0].structure.field[1].read_transform.type
    self.assertEqual("infinity", l_type.integer.modulus)
    self.assertEqual("-128", l_type.integer.maximum_value)
    self.assertEqual("-128", l_type.integer.minimum_value)
    self.assertEqual("-128", l_type.integer.modular_value)

  def test_upper_bound_of_max(self):
    ir = self._make_ir("struct Foo:\n"
                       "  0 [+1]  Int   x\n"
                       "  1 [+1]  UInt  y\n"
                       "  let u = $upper_bound($max(x, y))\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    u_type = ir.module[0].type[0].structure.field[2].read_transform.type
    self.assertEqual("infinity", u_type.integer.modulus)
    self.assertEqual("255", u_type.integer.maximum_value)
    self.assertEqual("255", u_type.integer.minimum_value)
    self.assertEqual("255", u_type.integer.modular_value)

  def test_lower_bound_of_max(self):
    ir = self._make_ir("struct Foo:\n"
                       "  0 [+1]  Int  x\n"
                       "  1 [+1]  UInt  y\n"
                       "  let l = $lower_bound($max(x, y))\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    l_type = ir.module[0].type[0].structure.field[2].read_transform.type
    self.assertEqual("infinity", l_type.integer.modulus)
    self.assertEqual("0", l_type.integer.maximum_value)
    self.assertEqual("0", l_type.integer.minimum_value)
    self.assertEqual("0", l_type.integer.modular_value)

  def test_double_unbounded_both_ends_times_negative_unbounded(self):
    ir = self._make_ir(
        "external Foo:\n"
        "  [requires: (2 * ($static_size_in_bits - $static_size_in_bits) + 1) "
        "             * -$static_size_in_bits > 0]\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    expr = ir.module[0].type[0].attribute[0].value.expression.function.args[0]
    self.assertEqual("1", expr.type.integer.modulus)
    self.assertEqual("0", expr.type.integer.modular_value)
    self.assertEqual("-infinity", expr.type.integer.minimum_value)
    self.assertEqual("infinity", expr.type.integer.maximum_value)

  def test_choice_two_non_constant_integers(self):
    cases = [
        # t % 12 == 7 and f % 20 == 15 ==> r % 4 == 3
        (12, 7, 20, 15, 4, 3, -128 * 20 + 15, 127 * 20 + 15),
        # t % 24 == 15 and f % 12 == 7 ==> r % 4 == 3
        (24, 15, 12, 7, 4, 3, -128 * 24 + 15, 127 * 24 + 15),
        # t % 20 == 15 and f % 20 == 10 ==> r % 5 == 0
        (20, 15, 20, 10, 5, 0, -128 * 20 + 10, 127 * 20 + 15),
        # t % 20 == 16 and f % 20 == 11 ==> r % 5 == 1
        (20, 16, 20, 11, 5, 1, -128 * 20 + 11, 127 * 20 + 16),
    ]
    for (t_mod, t_val, f_mod, f_val, r_mod, r_val, r_min, r_max) in cases:
      ir = self._make_ir("struct Foo:\n"
                         "  0 [+1]    UInt  x\n"
                         "  1 [+1]    Int   y\n"
                         "  if (x == 0 ? y * {} + {} : y * {} + {}) == 0:\n"
                         "    1 [+1]  UInt  z\n".format(
                             t_mod, t_val, f_mod, f_val))
      self.assertEqual([], expression_bounds.compute_constants(ir))
      field = ir.module[0].type[0].structure.field[2]
      expr = field.existence_condition.function.args[0]
      self.assertEqual(str(r_mod), expr.type.integer.modulus)
      self.assertEqual(str(r_val), expr.type.integer.modular_value)
      self.assertEqual(str(r_min), expr.type.integer.minimum_value)
      self.assertEqual(str(r_max), expr.type.integer.maximum_value)

  def test_choice_one_non_constant_integer(self):
    cases = [
        # t == 35 and f % 20 == 15 ==> res % 20 == 15
        (35, 20, 15, 20, 15, -128 * 20 + 15, 127 * 20 + 15),
        # t == 200035 and f % 20 == 15 ==> res % 20 == 15
        (200035, 20, 15, 20, 15, -128 * 20 + 15, 200035),
        # t == 21 and f % 20 == 16 ==> res % 5 == 1
        (21, 20, 16, 5, 1, -128 * 20 + 16, 127 * 20 + 16),
    ]
    for (t_val, f_mod, f_val, r_mod, r_val, r_min, r_max) in cases:
      ir = self._make_ir("struct Foo:\n"
                         "  0 [+1]    UInt  x\n"
                         "  1 [+1]    Int   y\n"
                         "  if (x == 0 ? {0} : y * {1} + {2}) == 0:\n"
                         "    1 [+1]  UInt  z\n"
                         "  if (x == 0 ? y * {1} + {2} : {0}) == 0:\n"
                         "    1 [+1]  UInt  q\n".format(t_val, f_mod, f_val))
      self.assertEqual([], expression_bounds.compute_constants(ir))
      field_constant_true = ir.module[0].type[0].structure.field[2]
      constant_true = field_constant_true.existence_condition.function.args[0]
      field_constant_false = ir.module[0].type[0].structure.field[3]
      constant_false = field_constant_false.existence_condition.function.args[0]
      self.assertEqual(str(r_mod), constant_true.type.integer.modulus)
      self.assertEqual(str(r_val), constant_true.type.integer.modular_value)
      self.assertEqual(str(r_min), constant_true.type.integer.minimum_value)
      self.assertEqual(str(r_max), constant_true.type.integer.maximum_value)
      self.assertEqual(str(r_mod), constant_false.type.integer.modulus)
      self.assertEqual(str(r_val), constant_false.type.integer.modular_value)
      self.assertEqual(str(r_min), constant_false.type.integer.minimum_value)
      self.assertEqual(str(r_max), constant_false.type.integer.maximum_value)

  def test_choice_two_constant_integers(self):
    cases = [
        # t == 10 and f == 7 ==> res % 3 == 1
        (10, 7, 3, 1, 7, 10),
        # t == 4 and f == 4 ==> res == 4
        (4, 4, "infinity", 4, 4, 4),
    ]
    for (t_val, f_val, r_mod, r_val, r_min, r_max) in cases:
      ir = self._make_ir("struct Foo:\n"
                         "  0 [+1]    UInt  x\n"
                         "  1 [+1]    Int   y\n"
                         "  if (x == 0 ? {} : {}) == 0:\n"
                         "    1 [+1]  UInt  z\n".format(t_val, f_val))
      self.assertEqual([], expression_bounds.compute_constants(ir))
      field_constant_true = ir.module[0].type[0].structure.field[2]
      constant_true = field_constant_true.existence_condition.function.args[0]
      self.assertEqual(str(r_mod), constant_true.type.integer.modulus)
      self.assertEqual(str(r_val), constant_true.type.integer.modular_value)
      self.assertEqual(str(r_min), constant_true.type.integer.minimum_value)
      self.assertEqual(str(r_max), constant_true.type.integer.maximum_value)

  def test_constant_true_has(self):
    ir = self._make_ir("struct Foo:\n"
                       "  if $present(x):\n"
                       "    1 [+1]  UInt  q\n"
                       "  0 [+1]    UInt  x\n"
                       "  if x > 10:\n"
                       "    1 [+1]  Int   y\n"
                       "  if false:\n"
                       "    2 [+1]  Int   z\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    field = ir.module[0].type[0].structure.field[0]
    has_func = field.existence_condition
    self.assertTrue(has_func.type.boolean.value)

  def test_constant_false_has(self):
    ir = self._make_ir("struct Foo:\n"
                       "  if $present(z):\n"
                       "    1 [+1]  UInt  q\n"
                       "  0 [+1]    UInt  x\n"
                       "  if x > 10:\n"
                       "    1 [+1]  Int   y\n"
                       "  if false:\n"
                       "    2 [+1]  Int   z\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    field = ir.module[0].type[0].structure.field[0]
    has_func = field.existence_condition
    self.assertTrue(has_func.type.boolean.HasField("value"))
    self.assertFalse(has_func.type.boolean.value)

  def test_variable_has(self):
    ir = self._make_ir("struct Foo:\n"
                       "  if $present(y):\n"
                       "    1 [+1]  UInt  q\n"
                       "  0 [+1]    UInt  x\n"
                       "  if x > 10:\n"
                       "    1 [+1]  Int   y\n"
                       "  if false:\n"
                       "    2 [+1]  Int   z\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    field = ir.module[0].type[0].structure.field[0]
    has_func = field.existence_condition
    self.assertFalse(has_func.type.boolean.HasField("value"))

  def test_max_of_constants(self):
    ir = self._make_ir("struct Foo:\n"
                       "  0 [+1]    UInt  x\n"
                       "  1 [+1]    Int   y\n"
                       "  if $max(0, 1, 2) == 0:\n"
                       "    1 [+1]  UInt  z\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    field = ir.module[0].type[0].structure.field[2]
    max_func = field.existence_condition.function.args[0]
    self.assertEqual("infinity", max_func.type.integer.modulus)
    self.assertEqual("2", max_func.type.integer.modular_value)
    self.assertEqual("2", max_func.type.integer.minimum_value)
    self.assertEqual("2", max_func.type.integer.maximum_value)

  def test_max_dominated_by_constant(self):
    ir = self._make_ir("struct Foo:\n"
                       "  0 [+1]    UInt  x\n"
                       "  1 [+1]    Int   y\n"
                       "  if $max(x, y, 255) == 0:\n"
                       "    1 [+1]  UInt  z\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    field = ir.module[0].type[0].structure.field[2]
    max_func = field.existence_condition.function.args[0]
    self.assertEqual("infinity", max_func.type.integer.modulus)
    self.assertEqual("255", max_func.type.integer.modular_value)
    self.assertEqual("255", max_func.type.integer.minimum_value)
    self.assertEqual("255", max_func.type.integer.maximum_value)

  def test_max_of_variables(self):
    ir = self._make_ir("struct Foo:\n"
                       "  0 [+1]    UInt  x\n"
                       "  1 [+1]    Int   y\n"
                       "  if $max(x, y) == 0:\n"
                       "    1 [+1]  UInt  z\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    field = ir.module[0].type[0].structure.field[2]
    max_func = field.existence_condition.function.args[0]
    self.assertEqual("1", max_func.type.integer.modulus)
    self.assertEqual("0", max_func.type.integer.modular_value)
    self.assertEqual("0", max_func.type.integer.minimum_value)
    self.assertEqual("255", max_func.type.integer.maximum_value)

  def test_max_of_variables_with_shared_modulus(self):
    ir = self._make_ir("struct Foo:\n"
                       "  0 [+1]    UInt  x\n"
                       "  1 [+1]    Int   y\n"
                       "  if $max(x * 8 + 5, y * 4 + 3) == 0:\n"
                       "    1 [+1]  UInt  z\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    field = ir.module[0].type[0].structure.field[2]
    max_func = field.existence_condition.function.args[0]
    self.assertEqual("2", max_func.type.integer.modulus)
    self.assertEqual("1", max_func.type.integer.modular_value)
    self.assertEqual("5", max_func.type.integer.minimum_value)
    self.assertEqual("2045", max_func.type.integer.maximum_value)

  def test_max_of_three_variables(self):
    ir = self._make_ir("struct Foo:\n"
                       "  0 [+1]    UInt  x\n"
                       "  1 [+1]    Int   y\n"
                       "  2 [+2]    Int   z\n"
                       "  if $max(x, y, z) == 0:\n"
                       "    1 [+1]  UInt  q\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    field = ir.module[0].type[0].structure.field[3]
    max_func = field.existence_condition.function.args[0]
    self.assertEqual("1", max_func.type.integer.modulus)
    self.assertEqual("0", max_func.type.integer.modular_value)
    self.assertEqual("0", max_func.type.integer.minimum_value)
    self.assertEqual("32767", max_func.type.integer.maximum_value)

  def test_max_of_one_variable(self):
    ir = self._make_ir("struct Foo:\n"
                       "  0 [+1]    UInt  x\n"
                       "  1 [+1]    Int   y\n"
                       "  2 [+2]    Int   z\n"
                       "  if $max(x * 2 + 3) == 0:\n"
                       "    1 [+1]  UInt  q\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    field = ir.module[0].type[0].structure.field[3]
    max_func = field.existence_condition.function.args[0]
    self.assertEqual("2", max_func.type.integer.modulus)
    self.assertEqual("1", max_func.type.integer.modular_value)
    self.assertEqual("3", max_func.type.integer.minimum_value)
    self.assertEqual("513", max_func.type.integer.maximum_value)

  def test_max_of_one_variable_and_one_constant(self):
    ir = self._make_ir("struct Foo:\n"
                       "  0 [+1]    UInt  x\n"
                       "  1 [+1]    Int   y\n"
                       "  2 [+2]    Int   z\n"
                       "  if $max(x * 2 + 3, 311) == 0:\n"
                       "    1 [+1]  UInt  q\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    field = ir.module[0].type[0].structure.field[3]
    max_func = field.existence_condition.function.args[0]
    self.assertEqual("2", max_func.type.integer.modulus)
    self.assertEqual("1", max_func.type.integer.modular_value)
    self.assertEqual("311", max_func.type.integer.minimum_value)
    self.assertEqual("513", max_func.type.integer.maximum_value)

  def test_choice_non_integer_arguments(self):
    ir = self._make_ir("struct Foo:\n"
                       "  0 [+1]    UInt  x\n"
                       "  if x == 0 ? false : true:\n"
                       "    1 [+1]  UInt  y\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    expr = ir.module[0].type[0].structure.field[1].existence_condition
    self.assertEqual("boolean", expr.type.WhichOneof("type"))
    self.assertFalse(expr.type.boolean.HasField("value"))

  def test_uint_value_range_for_explicit_size(self):
    ir = self._make_ir("struct Foo:\n"
                       "  0 [+1]  UInt     x\n"
                       "  1 [+x]  UInt:16  y\n"
                       "  y [+1]  UInt     z\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    z_start = ir.module[0].type[0].structure.field[2].location.start
    self.assertEqual("1", z_start.type.integer.modulus)
    self.assertEqual("0", z_start.type.integer.modular_value)
    self.assertEqual("0", z_start.type.integer.minimum_value)
    self.assertEqual("65535", z_start.type.integer.maximum_value)

  def test_uint_value_ranges(self):
    cases = [
        (1, 1),
        (2, 3),
        (3, 7),
        (4, 15),
        (8, 255),
        (12, 4095),
        (15, 32767),
        (16, 65535),
        (32, 4294967295),
        (48, 281474976710655),
        (64, 18446744073709551615),
    ]
    for bits, upper in cases:
      ir = self._make_ir("struct Foo:\n"
                         "  0   [+8]   bits:\n"
                         "    0 [+{}]  UInt  x\n"
                         "  x   [+1]   UInt  z\n".format(bits))
      self.assertEqual([], expression_bounds.compute_constants(ir))
      z_start = ir.module[0].type[0].structure.field[2].location.start
      self.assertEqual("1", z_start.type.integer.modulus)
      self.assertEqual("0", z_start.type.integer.modular_value)
      self.assertEqual("0", z_start.type.integer.minimum_value)
      self.assertEqual(str(upper), z_start.type.integer.maximum_value)

  def test_int_value_ranges(self):
    cases = [
        (1, -1, 0),
        (2, -2, 1),
        (3, -4, 3),
        (4, -8, 7),
        (8, -128, 127),
        (12, -2048, 2047),
        (15, -16384, 16383),
        (16, -32768, 32767),
        (32, -2147483648, 2147483647),
        (48, -140737488355328, 140737488355327),
        (64, -9223372036854775808, 9223372036854775807),
    ]
    for bits, lower, upper in cases:
      ir = self._make_ir("struct Foo:\n"
                         "  0   [+8]   bits:\n"
                         "    0 [+{}]  Int   x\n"
                         "  x   [+1]   UInt  z\n".format(bits))
      self.assertEqual([], expression_bounds.compute_constants(ir))
      z_start = ir.module[0].type[0].structure.field[2].location.start
      self.assertEqual("1", z_start.type.integer.modulus)
      self.assertEqual("0", z_start.type.integer.modular_value)
      self.assertEqual(str(lower), z_start.type.integer.minimum_value)
      self.assertEqual(str(upper), z_start.type.integer.maximum_value)

  def test_bcd_value_ranges(self):
    cases = [
        (1, 1),
        (2, 3),
        (3, 7),
        (4, 9),
        (8, 99),
        (12, 999),
        (15, 7999),
        (16, 9999),
        (32, 99999999),
        (48, 999999999999),
        (64, 9999999999999999),
    ]
    for bits, upper in cases:
      ir = self._make_ir("struct Foo:\n"
                         "  0   [+8]   bits:\n"
                         "    0 [+{}]  Bcd   x\n"
                         "  x   [+1]   UInt  z\n".format(bits))
      self.assertEqual([], expression_bounds.compute_constants(ir))
      z_start = ir.module[0].type[0].structure.field[2].location.start
      self.assertEqual("1", z_start.type.integer.modulus)
      self.assertEqual("0", z_start.type.integer.modular_value)
      self.assertEqual("0", z_start.type.integer.minimum_value)
      self.assertEqual(str(upper), z_start.type.integer.maximum_value)

  def test_virtual_field_bounds(self):
    ir = self._make_ir("struct Foo:\n"
                       "  0 [+1]  UInt     x\n"
                       "  let y = x + 10\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    field_y = ir.module[0].type[0].structure.field[1]
    self.assertEqual("1", field_y.read_transform.type.integer.modulus)
    self.assertEqual("0", field_y.read_transform.type.integer.modular_value)
    self.assertEqual("10", field_y.read_transform.type.integer.minimum_value)
    self.assertEqual("265", field_y.read_transform.type.integer.maximum_value)

  def test_virtual_field_bounds_copied(self):
    ir = self._make_ir("struct Foo:\n"
                       "  let z = y + 100\n"
                       "  let y = x + 10\n"
                       "  0 [+1]  UInt     x\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    field_z = ir.module[0].type[0].structure.field[0]
    self.assertEqual("1", field_z.read_transform.type.integer.modulus)
    self.assertEqual("0", field_z.read_transform.type.integer.modular_value)
    self.assertEqual("110", field_z.read_transform.type.integer.minimum_value)
    self.assertEqual("365", field_z.read_transform.type.integer.maximum_value)
    y_reference = field_z.read_transform.function.args[0]
    self.assertEqual("1", y_reference.type.integer.modulus)
    self.assertEqual("0", y_reference.type.integer.modular_value)
    self.assertEqual("10", y_reference.type.integer.minimum_value)
    self.assertEqual("265", y_reference.type.integer.maximum_value)

  def test_constant_reference_to_virtual_bounds_copied(self):
    ir = self._make_ir("struct Foo:\n"
                       "  let ten = Bar.ten\n"
                       "  let truth = Bar.truth\n"
                       "struct Bar:\n"
                       "  let ten = 10\n"
                       "  let truth = true\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    field_ten = ir.module[0].type[0].structure.field[0]
    self.assertEqual("infinity", field_ten.read_transform.type.integer.modulus)
    self.assertEqual("10", field_ten.read_transform.type.integer.modular_value)
    self.assertEqual("10", field_ten.read_transform.type.integer.minimum_value)
    self.assertEqual("10", field_ten.read_transform.type.integer.maximum_value)
    field_truth = ir.module[0].type[0].structure.field[1]
    self.assertTrue(field_truth.read_transform.type.boolean.value)

  def test_forward_reference_to_reference_to_enum_correctly_calculated(self):
    ir = self._make_ir("struct Foo:\n"
                       "  let ten = Bar.TEN\n"
                       "enum Bar:\n"
                       "  TEN = TEN2\n"
                       "  TEN2 = 5 + 5\n")
    self.assertEqual([], expression_bounds.compute_constants(ir))
    field_ten = ir.module[0].type[0].structure.field[0]
    self.assertEqual("10", field_ten.read_transform.type.enumeration.value)


class InfinityAugmentedArithmeticTest(unittest.TestCase):

  # TODO(bolms): Will there ever be any situations where all elements of the arg
  # to _min would be "infinity"?
  def test_min_of_infinities(self):
    self.assertEqual("infinity",
                     expression_bounds._min(["infinity", "infinity"]))

  # TODO(bolms): Will there ever be any situations where all elements of the arg
  # to _max would be "-infinity"?
  def test_max_of_negative_infinities(self):
    self.assertEqual("-infinity",
                     expression_bounds._max(["-infinity", "-infinity"]))

  def test_shared_modular_value_of_identical_modulus_and_value(self):
    self.assertEqual((10, 8),
                     expression_bounds._shared_modular_value((10, 8), (10, 8)))

  def test_shared_modular_value_of_identical_modulus(self):
    self.assertEqual((5, 3),
                     expression_bounds._shared_modular_value((10, 8), (10, 3)))

  def test_shared_modular_value_of_identical_value(self):
    self.assertEqual((6, 2),
                     expression_bounds._shared_modular_value((18, 2), (12, 2)))

  def test_shared_modular_value_of_different_arguments(self):
    self.assertEqual((7, 4),
                     expression_bounds._shared_modular_value((21, 11), (14, 4)))

  def test_shared_modular_value_of_infinity_and_non(self):
    self.assertEqual((7, 4),
                     expression_bounds._shared_modular_value(("infinity", 25),
                                                             (14, 4)))

  def test_shared_modular_value_of_infinity_and_infinity(self):
    self.assertEqual((14, 5),
                     expression_bounds._shared_modular_value(("infinity", 19),
                                                             ("infinity", 5)))

  def test_shared_modular_value_of_infinity_and_identical_value(self):
    self.assertEqual(("infinity", 5),
                     expression_bounds._shared_modular_value(("infinity", 5),
                                                             ("infinity", 5)))


if __name__ == "__main__":
  unittest.main()