# Copyright 2019 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""Tests for ...emboss.front_end.write_inference."""

import unittest
from compiler.front_end import glue
from compiler.front_end import write_inference
from compiler.util import ir_data
from compiler.util import test_util


class WriteInferenceTest(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="set_write_methods")
    assert not errors, errors
    return ir

  def test_adds_physical_write_method(self):
    ir = self._make_ir("struct Foo:\n"
                       "  0 [+1]  UInt  x\n")
    self.assertEqual([], write_inference.set_write_methods(ir))
    self.assertTrue(
        ir.module[0].type[0].structure.field[0].write_method.physical)

  def test_adds_read_only_write_method_to_non_alias_virtual(self):
    ir = self._make_ir("struct Foo:\n"
                       "  let x = 5\n")
    self.assertEqual([], write_inference.set_write_methods(ir))
    self.assertTrue(
        ir.module[0].type[0].structure.field[0].write_method.read_only)

  def test_adds_alias_write_method_to_alias_of_physical_field(self):
    ir = self._make_ir("struct Foo:\n"
                       "  let x = y\n"
                       "  0 [+1]  UInt  y\n")
    self.assertEqual([], write_inference.set_write_methods(ir))
    field = ir.module[0].type[0].structure.field[0]
    self.assertTrue(field.write_method.HasField("alias"))
    self.assertEqual(
        "y", field.write_method.alias.path[0].canonical_name.object_path[-1])

  def test_adds_alias_write_method_to_alias_of_alias_of_physical_field(self):
    ir = self._make_ir("struct Foo:\n"
                       "  let x = z\n"
                       "  let z = y\n"
                       "  0 [+1]  UInt  y\n")
    self.assertEqual([], write_inference.set_write_methods(ir))
    field = ir.module[0].type[0].structure.field[0]
    self.assertTrue(field.write_method.HasField("alias"))
    self.assertEqual(
        "z", field.write_method.alias.path[0].canonical_name.object_path[-1])

  def test_adds_read_only_write_method_to_alias_of_read_only(self):
    ir = self._make_ir("struct Foo:\n"
                       "  let x = y\n"
                       "  let y = 5\n")
    self.assertEqual([], write_inference.set_write_methods(ir))
    field = ir.module[0].type[0].structure.field[0]
    self.assertTrue(field.write_method.read_only)

  def test_adds_read_only_write_method_to_alias_of_alias_of_read_only(self):
    ir = self._make_ir("struct Foo:\n"
                       "  let x = z\n"
                       "  let z = y\n"
                       "  let y = 5\n")
    self.assertEqual([], write_inference.set_write_methods(ir))
    field = ir.module[0].type[0].structure.field[0]
    self.assertTrue(field.write_method.read_only)

  def test_adds_read_only_write_method_to_alias_of_parameter(self):
    ir = self._make_ir("struct Foo(x: UInt:8):\n"
                       "  let y = x\n")
    self.assertEqual([], write_inference.set_write_methods(ir))
    field = ir.module[0].type[0].structure.field[0]
    self.assertTrue(field.write_method.read_only)

  def test_adds_transform_write_method_to_base_value_field(self):
    ir = self._make_ir("struct Foo:\n"
                       "  0 [+1]  UInt  x\n"
                       "  let y = x + 50\n")
    self.assertEqual([], write_inference.set_write_methods(ir))
    field = ir.module[0].type[0].structure.field[1]
    transform = field.write_method.transform
    self.assertTrue(transform)
    self.assertEqual(
        "x",
        transform.destination.path[0].canonical_name.object_path[-1])
    self.assertEqual(ir_data.FunctionMapping.SUBTRACTION,
                     transform.function_body.function.function)
    arg0, arg1 = transform.function_body.function.args
    self.assertEqual("$logical_value",
                     arg0.builtin_reference.canonical_name.object_path[0])
    self.assertEqual("50", arg1.constant.value)

  def test_adds_transform_write_method_to_negative_base_value_field(self):
    ir = self._make_ir("struct Foo:\n"
                       "  0 [+1]  UInt  x\n"
                       "  let y = x - 50\n")
    self.assertEqual([], write_inference.set_write_methods(ir))
    field = ir.module[0].type[0].structure.field[1]
    transform = field.write_method.transform
    self.assertTrue(transform)
    self.assertEqual(
        "x",
        transform.destination.path[0].canonical_name.object_path[-1])
    self.assertEqual(ir_data.FunctionMapping.ADDITION,
                     transform.function_body.function.function)
    arg0, arg1 = transform.function_body.function.args
    self.assertEqual("$logical_value",
                     arg0.builtin_reference.canonical_name.object_path[0])
    self.assertEqual("50", arg1.constant.value)

  def test_adds_transform_write_method_to_reversed_base_value_field(self):
    ir = self._make_ir("struct Foo:\n"
                       "  0 [+1]  UInt  x\n"
                       "  let y = 50 + x\n")
    self.assertEqual([], write_inference.set_write_methods(ir))
    field = ir.module[0].type[0].structure.field[1]
    transform = field.write_method.transform
    self.assertTrue(transform)
    self.assertEqual(
        "x",
        transform.destination.path[0].canonical_name.object_path[-1])
    self.assertEqual(ir_data.FunctionMapping.SUBTRACTION,
                     transform.function_body.function.function)
    arg0, arg1 = transform.function_body.function.args
    self.assertEqual("$logical_value",
                     arg0.builtin_reference.canonical_name.object_path[0])
    self.assertEqual("50", arg1.constant.value)

  def test_adds_transform_write_method_to_reversed_negative_base_value_field(
      self):
    ir = self._make_ir("struct Foo:\n"
                       "  0 [+1]  UInt  x\n"
                       "  let y = 50 - x\n")
    self.assertEqual([], write_inference.set_write_methods(ir))
    field = ir.module[0].type[0].structure.field[1]
    transform = field.write_method.transform
    self.assertTrue(transform)
    self.assertEqual(
        "x",
        transform.destination.path[0].canonical_name.object_path[-1])
    self.assertEqual(ir_data.FunctionMapping.SUBTRACTION,
                     transform.function_body.function.function)
    arg0, arg1 = transform.function_body.function.args
    self.assertEqual("50", arg0.constant.value)
    self.assertEqual("$logical_value",
                     arg1.builtin_reference.canonical_name.object_path[0])

  def test_adds_transform_write_method_to_nested_invertible_field(self):
    ir = self._make_ir("struct Foo:\n"
                       "  0 [+1]  UInt  x\n"
                       "  let y = 30 + (50 - x)\n")
    self.assertEqual([], write_inference.set_write_methods(ir))
    field = ir.module[0].type[0].structure.field[1]
    transform = field.write_method.transform
    self.assertTrue(transform)
    self.assertEqual(
        "x",
        transform.destination.path[0].canonical_name.object_path[-1])
    self.assertEqual(ir_data.FunctionMapping.SUBTRACTION,
                     transform.function_body.function.function)
    arg0, arg1 = transform.function_body.function.args
    self.assertEqual("50", arg0.constant.value)
    self.assertEqual(ir_data.FunctionMapping.SUBTRACTION, arg1.function.function)
    arg10, arg11 = arg1.function.args
    self.assertEqual("$logical_value",
                     arg10.builtin_reference.canonical_name.object_path[0])
    self.assertEqual("30", arg11.constant.value)

  def test_does_not_add_transform_write_method_for_parameter_target(self):
    ir = self._make_ir("struct Foo(x: UInt:8):\n"
                       "  let y = 50 + x\n")
    self.assertEqual([], write_inference.set_write_methods(ir))
    field = ir.module[0].type[0].structure.field[0]
    self.assertEqual("read_only", field.write_method.WhichOneof("method"))

  def test_adds_transform_write_method_with_complex_auxiliary_subexpression(
      self):
    ir = self._make_ir("struct Foo:\n"
                       "  0 [+1]  UInt  x\n"
                       "  let y = x - $max(Foo.$size_in_bytes, Foo.z)\n"
                       "  let z = 500\n")
    self.assertEqual([], write_inference.set_write_methods(ir))
    field = ir.module[0].type[0].structure.field[1]
    transform = field.write_method.transform
    self.assertTrue(transform)
    self.assertEqual(
        "x",
        transform.destination.path[0].canonical_name.object_path[-1])
    self.assertEqual(ir_data.FunctionMapping.ADDITION,
                     transform.function_body.function.function)
    args = transform.function_body.function.args
    self.assertEqual("$logical_value",
                     args[0].builtin_reference.canonical_name.object_path[0])
    self.assertEqual(field.read_transform.function.args[1], args[1])


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