machine-dialect 0.1.0a1__py3-none-any.whl

machine_dialect/mir/tests/test_mir_printer.py

@@ -0,0 +1,387 @@
+"""Tests for MIR printer and dumper."""
+
+from __future__ import annotations
+
+import io
+
+from machine_dialect.mir.basic_block import BasicBlock
+from machine_dialect.mir.mir_function import MIRFunction
+from machine_dialect.mir.mir_instructions import (
+    Assert,
+    BinaryOp,
+    ConditionalJump,
+    Copy,
+    GetAttr,
+    Jump,
+    LoadConst,
+    LoadVar,
+    Phi,
+    Print,
+    Return,
+    Scope,
+    Select,
+    SetAttr,
+    StoreVar,
+    UnaryOp,
+)
+from machine_dialect.mir.mir_module import MIRModule
+from machine_dialect.mir.mir_printer import (
+    dump_mir_function,
+    dump_mir_module,
+    export_cfg_dot,
+)
+from machine_dialect.mir.mir_types import MIRType
+from machine_dialect.mir.mir_values import Constant, Variable
+
+
+class TestMIRPrinter:
+    """Test MIR text printer."""
+
+    def test_print_empty_module(self) -> None:
+        """Test printing empty module."""
+        module = MIRModule("empty_module")
+
+        output = dump_mir_module(module)
+
+        assert "Module: empty_module" in output
+
+    def test_print_module_with_functions(self) -> None:
+        """Test printing module with multiple functions."""
+        module = MIRModule("test_module")
+
+        # Add main function
+        main = MIRFunction("main", [], MIRType.EMPTY)
+        entry = BasicBlock("entry")
+        main.cfg.add_block(entry)
+        main.cfg.set_entry_block(entry)
+        entry.add_instruction(Return((1, 1)))
+
+        # Add helper function with parameters
+        param = Variable("x", MIRType.INT)
+        helper = MIRFunction("helper", [param], MIRType.INT)
+        helper_entry = BasicBlock("entry")
+        helper.cfg.add_block(helper_entry)
+        helper.cfg.set_entry_block(helper_entry)
+        helper_entry.add_instruction(Return((1, 1), param))
+
+        module.add_function(main)
+        module.add_function(helper)
+        module.set_main_function("main")
+
+        output = dump_mir_module(module)
+
+        assert "Module: test_module" in output
+        assert "Function main()" in output
+        assert "Function helper(x: INT)" in output
+        assert "Main: main" in output
+
+    def test_print_function_with_locals(self) -> None:
+        """Test printing function with local variables."""
+        func = MIRFunction("test", [], MIRType.EMPTY)
+
+        # Add locals
+        x = Variable("x", MIRType.INT)
+        y = Variable("y", MIRType.FLOAT)
+        func.add_local(x)
+        func.add_local(y)
+
+        # Add temporaries
+        func.new_temp(MIRType.BOOL)
+        func.new_temp(MIRType.STRING)
+
+        entry = BasicBlock("entry")
+        func.cfg.add_block(entry)
+        func.cfg.set_entry_block(entry)
+        entry.add_instruction(Return((1, 1)))
+
+        output = dump_mir_function(func)
+
+        assert "Locals:" in output
+        assert "x: INT" in output
+        assert "y: FLOAT" in output
+        assert "Temporaries:" in output
+
+    def test_print_basic_block(self) -> None:
+        """Test printing basic blocks with predecessors and successors."""
+        func = MIRFunction("test", [], MIRType.EMPTY)
+
+        # Create blocks
+        entry = BasicBlock("entry")
+        block1 = BasicBlock("block1")
+        exit_block = BasicBlock("exit")
+
+        func.cfg.add_block(entry)
+        func.cfg.add_block(block1)
+        func.cfg.add_block(exit_block)
+        func.cfg.set_entry_block(entry)
+
+        func.cfg.connect(entry, block1)
+        func.cfg.connect(block1, exit_block)
+
+        # Add instructions
+        entry.add_instruction(Jump("block1", (1, 1)))
+        block1.add_instruction(Jump("exit", (1, 1)))
+        exit_block.add_instruction(Return((1, 1)))
+
+        output = dump_mir_function(func)
+
+        assert "entry:" in output
+        assert "block1: (preds: entry)" in output
+        assert "exit: (preds: block1)" in output
+        assert "// successors: block1" in output
+
+    def test_print_all_instruction_types(self) -> None:
+        """Test printing all instruction types."""
+        func = MIRFunction("test", [], MIRType.EMPTY)
+        entry = BasicBlock("entry")
+        func.cfg.add_block(entry)
+        func.cfg.set_entry_block(entry)
+
+        # Create various values
+        x = Variable("x", MIRType.INT)
+        y = Variable("y", MIRType.INT)
+        t1 = func.new_temp(MIRType.INT)
+        t2 = func.new_temp(MIRType.BOOL)
+        Constant(42, MIRType.INT)
+
+        # Add various instructions
+        entry.add_instruction(LoadConst(t1, 42, (1, 1)))
+        entry.add_instruction(StoreVar(x, t1, (1, 1)))
+        entry.add_instruction(LoadVar(t1, x, (1, 1)))
+        entry.add_instruction(Copy(y, x, (1, 1)))
+        entry.add_instruction(BinaryOp(t1, "+", x, y, (1, 1)))
+        entry.add_instruction(UnaryOp(t1, "-", x, (1, 1)))
+        entry.add_instruction(Print(x, (1, 1)))
+        entry.add_instruction(Assert(t2, (1, 1), "check failed"))
+        entry.add_instruction(Scope((1, 1), is_begin=True))
+        entry.add_instruction(Scope((1, 1), is_begin=False))
+        entry.add_instruction(Select(t1, t2, x, y, (1, 1)))
+
+        # Object operations
+        obj = func.new_temp(MIRType.UNKNOWN)
+        entry.add_instruction(GetAttr(t1, obj, "field"))
+        entry.add_instruction(SetAttr(obj, "field", t1))
+
+        # Control flow
+        entry.add_instruction(Jump("next", (1, 1)))
+
+        output = dump_mir_function(func)
+
+        # Check various instruction formats
+        assert "const" in output
+        assert "store" in output
+        assert "load" in output
+        assert "print" in output
+        assert "assert" in output
+        assert "begin_scope" in output
+        assert "end_scope" in output
+        assert "select" in output
+        assert ".field" in output
+        assert "goto" in output
+
+    def test_print_phi_nodes(self) -> None:
+        """Test printing phi nodes."""
+        func = MIRFunction("test", [], MIRType.INT)
+
+        # Create diamond CFG
+        entry = BasicBlock("entry")
+        then_block = BasicBlock("then")
+        else_block = BasicBlock("else")
+        merge = BasicBlock("merge")
+
+        func.cfg.add_block(entry)
+        func.cfg.add_block(then_block)
+        func.cfg.add_block(else_block)
+        func.cfg.add_block(merge)
+        func.cfg.set_entry_block(entry)
+
+        func.cfg.connect(entry, then_block)
+        func.cfg.connect(entry, else_block)
+        func.cfg.connect(then_block, merge)
+        func.cfg.connect(else_block, merge)
+
+        # Add phi node
+        result = func.new_temp(MIRType.INT)
+        val1 = Constant(1, MIRType.INT)
+        val2 = Constant(2, MIRType.INT)
+        phi = Phi(result, [(val1, "then"), (val2, "else")], (1, 1))
+
+        merge.add_instruction(phi)
+        merge.add_instruction(Return((1, 1), result))
+
+        output = dump_mir_function(func)
+
+        assert "φ(" in output
+        assert "1:then" in output
+        assert "2:else" in output
+
+    def test_print_value_formatting(self) -> None:
+        """Test formatting of different value types."""
+        func = MIRFunction("test", [], MIRType.EMPTY)
+        entry = BasicBlock("entry")
+        func.cfg.add_block(entry)
+        func.cfg.set_entry_block(entry)
+
+        # Test different constant types
+        entry.add_instruction(LoadConst(func.new_temp(MIRType.INT), 42, (1, 1)))
+        entry.add_instruction(LoadConst(func.new_temp(MIRType.STRING), "hello", (1, 1)))
+        entry.add_instruction(LoadConst(func.new_temp(MIRType.BOOL), True, (1, 1)))
+        entry.add_instruction(LoadConst(func.new_temp(MIRType.BOOL), False, (1, 1)))
+        entry.add_instruction(LoadConst(func.new_temp(MIRType.EMPTY), None, (1, 1)))
+
+        output = dump_mir_function(func)
+
+        assert "42" in output
+        assert '"hello"' in output
+        assert "true" in output
+        assert "false" in output
+        assert "null" in output
+
+    def test_custom_output_stream(self) -> None:
+        """Test printing to custom output stream."""
+        func = MIRFunction("test", [], MIRType.EMPTY)
+        entry = BasicBlock("entry")
+        func.cfg.add_block(entry)
+        func.cfg.set_entry_block(entry)
+        entry.add_instruction(Return((1, 1)))
+
+        # Print to custom stream
+        output_stream = io.StringIO()
+        dump_mir_function(func, output_stream)
+
+        output = output_stream.getvalue()
+        assert "Function test" in output
+
+
+class TestMIRDotExporter:
+    """Test MIR DOT format exporter."""
+
+    def test_export_simple_cfg(self) -> None:
+        """Test exporting simple CFG to DOT."""
+        func = MIRFunction("test", [], MIRType.EMPTY)
+
+        entry = BasicBlock("entry")
+        exit_block = BasicBlock("exit")
+
+        func.cfg.add_block(entry)
+        func.cfg.add_block(exit_block)
+        func.cfg.set_entry_block(entry)
+        func.cfg.connect(entry, exit_block)
+
+        entry.add_instruction(Jump("exit", (1, 1)))
+        exit_block.add_instruction(Return((1, 1)))
+
+        dot = export_cfg_dot(func)
+
+        assert 'digraph "test"' in dot
+        assert "entry" in dot
+        assert "exit" in dot
+        assert "->" in dot
+
+    def test_export_diamond_cfg(self) -> None:
+        """Test exporting diamond CFG with conditional branches."""
+        func = MIRFunction("test", [], MIRType.EMPTY)
+
+        # Create diamond
+        entry = BasicBlock("entry")
+        then_block = BasicBlock("then")
+        else_block = BasicBlock("else")
+        merge = BasicBlock("merge")
+
+        func.cfg.add_block(entry)
+        func.cfg.add_block(then_block)
+        func.cfg.add_block(else_block)
+        func.cfg.add_block(merge)
+        func.cfg.set_entry_block(entry)
+
+        func.cfg.connect(entry, then_block)
+        func.cfg.connect(entry, else_block)
+        func.cfg.connect(then_block, merge)
+        func.cfg.connect(else_block, merge)
+
+        # Add conditional jump
+        cond = func.new_temp(MIRType.BOOL)
+        entry.add_instruction(ConditionalJump(cond, "then", (1, 1), "else"))
+        then_block.add_instruction(Jump("merge", (1, 1)))
+        else_block.add_instruction(Jump("merge", (1, 1)))
+        merge.add_instruction(Return((1, 1)))
+
+        dot = export_cfg_dot(func)
+
+        # Check for labeled edges
+        assert '[label="true"]' in dot
+        assert '[label="false"]' in dot
+
+        # Check entry block is marked differently
+        assert "lightgreen" in dot  # Entry block color
+
+    def test_export_with_many_instructions(self) -> None:
+        """Test exporting blocks with many instructions."""
+        func = MIRFunction("test", [], MIRType.EMPTY)
+
+        entry = BasicBlock("entry")
+        func.cfg.add_block(entry)
+        func.cfg.set_entry_block(entry)
+
+        # Add many instructions
+        for i in range(10):
+            t = func.new_temp(MIRType.INT)
+            entry.add_instruction(LoadConst(t, i, (1, 1)))
+
+        entry.add_instruction(Return((1, 1)))
+
+        dot = export_cfg_dot(func)
+
+        # Should truncate and show count
+        assert "more)" in dot
+
+    def test_export_loop_cfg(self) -> None:
+        """Test exporting CFG with loop (back edge)."""
+        func = MIRFunction("test", [], MIRType.EMPTY)
+
+        entry = BasicBlock("entry")
+        loop_header = BasicBlock("loop_header")
+        loop_body = BasicBlock("loop_body")
+        exit_block = BasicBlock("exit")
+
+        func.cfg.add_block(entry)
+        func.cfg.add_block(loop_header)
+        func.cfg.add_block(loop_body)
+        func.cfg.add_block(exit_block)
+        func.cfg.set_entry_block(entry)
+
+        func.cfg.connect(entry, loop_header)
+        func.cfg.connect(loop_header, loop_body)
+        func.cfg.connect(loop_header, exit_block)
+        func.cfg.connect(loop_body, loop_header)  # Back edge
+
+        entry.add_instruction(Jump("loop_header", (1, 1)))
+
+        cond = func.new_temp(MIRType.BOOL)
+        loop_header.add_instruction(ConditionalJump(cond, "loop_body", (1, 1), "exit"))
+
+        loop_body.add_instruction(Jump("loop_header", (1, 1)))
+        exit_block.add_instruction(Return((1, 1)))
+
+        dot = export_cfg_dot(func)
+
+        # Check all edges exist
+        assert dot.count("->") >= 4  # At least 4 edges
+
+    def test_export_escapes_quotes(self) -> None:
+        """Test that quotes in instructions are properly escaped."""
+        func = MIRFunction("test", [], MIRType.EMPTY)
+
+        entry = BasicBlock("entry")
+        func.cfg.add_block(entry)
+        func.cfg.set_entry_block(entry)
+
+        # Add instruction with quotes
+        t = func.new_temp(MIRType.STRING)
+        entry.add_instruction(LoadConst(t, 'string with "quotes"', (1, 1)))
+        entry.add_instruction(Return((1, 1)))
+
+        dot = export_cfg_dot(func)
+
+        # Should escape quotes properly
+        assert '\\"' in dot

machine_dialect/mir/tests/test_mir_types.py

@@ -0,0 +1,123 @@
+"""Tests for MIR type system."""
+
+from machine_dialect.mir.mir_types import (
+    MIRType,
+    coerce_types,
+    get_binary_op_result_type,
+    get_unary_op_result_type,
+    infer_type,
+    is_comparable_type,
+    is_numeric_type,
+)
+
+
+class TestMIRTypes:
+    """Test MIR type system functionality."""
+
+    def test_type_string_representation(self) -> None:
+        """Test string representation of types."""
+        assert str(MIRType.INT) == "int"
+        assert str(MIRType.FLOAT) == "float"
+        assert str(MIRType.STRING) == "string"
+        assert str(MIRType.BOOL) == "bool"
+        assert str(MIRType.EMPTY) == "empty"
+        assert str(MIRType.FUNCTION) == "function"
+
+    def test_infer_type(self) -> None:
+        """Test type inference from Python values."""
+        # Primitives
+        assert infer_type(42) == MIRType.INT
+        assert infer_type(3.14) == MIRType.FLOAT
+        assert infer_type("hello") == MIRType.STRING
+        assert infer_type(True) == MIRType.BOOL
+        assert infer_type(False) == MIRType.BOOL
+        assert infer_type(None) == MIRType.EMPTY
+
+        # URLs
+        assert infer_type("http://example.com") == MIRType.URL
+        assert infer_type("https://example.com") == MIRType.URL
+        assert infer_type("ftp://example.com") == MIRType.URL
+        assert infer_type("file:///path/to/file") == MIRType.URL
+
+        # Unknown types
+        assert infer_type([1, 2, 3]) == MIRType.UNKNOWN
+        assert infer_type({"key": "value"}) == MIRType.UNKNOWN
+
+    def test_is_numeric_type(self) -> None:
+        """Test numeric type checking."""
+        assert is_numeric_type(MIRType.INT)
+        assert is_numeric_type(MIRType.FLOAT)
+        assert not is_numeric_type(MIRType.STRING)
+        assert not is_numeric_type(MIRType.BOOL)
+        assert not is_numeric_type(MIRType.EMPTY)
+
+    def test_is_comparable_type(self) -> None:
+        """Test comparable type checking."""
+        assert is_comparable_type(MIRType.INT)
+        assert is_comparable_type(MIRType.FLOAT)
+        assert is_comparable_type(MIRType.STRING)
+        assert is_comparable_type(MIRType.BOOL)
+        assert not is_comparable_type(MIRType.EMPTY)
+        assert not is_comparable_type(MIRType.FUNCTION)
+
+    def test_coerce_types(self) -> None:
+        """Test type coercion rules."""
+        # Same types - no coercion
+        assert coerce_types(MIRType.INT, MIRType.INT) == MIRType.INT
+        assert coerce_types(MIRType.STRING, MIRType.STRING) == MIRType.STRING
+
+        # Numeric coercion
+        assert coerce_types(MIRType.INT, MIRType.FLOAT) == MIRType.FLOAT
+        assert coerce_types(MIRType.FLOAT, MIRType.INT) == MIRType.FLOAT
+
+        # String concatenation
+        assert coerce_types(MIRType.STRING, MIRType.INT) == MIRType.STRING
+        assert coerce_types(MIRType.BOOL, MIRType.STRING) == MIRType.STRING
+
+        # Invalid coercion
+        assert coerce_types(MIRType.INT, MIRType.BOOL) is None
+        assert coerce_types(MIRType.FUNCTION, MIRType.EMPTY) is None
+
+    def test_get_binary_op_result_type(self) -> None:
+        """Test binary operation result type inference."""
+        # Comparison operators always return bool
+        assert get_binary_op_result_type("==", MIRType.INT, MIRType.INT) == MIRType.BOOL
+        assert get_binary_op_result_type("!=", MIRType.STRING, MIRType.STRING) == MIRType.BOOL
+        assert get_binary_op_result_type(">", MIRType.FLOAT, MIRType.INT) == MIRType.BOOL
+        assert get_binary_op_result_type("<=", MIRType.INT, MIRType.FLOAT) == MIRType.BOOL
+
+        # Logical operators return bool
+        assert get_binary_op_result_type("and", MIRType.BOOL, MIRType.BOOL) == MIRType.BOOL
+        assert get_binary_op_result_type("or", MIRType.BOOL, MIRType.BOOL) == MIRType.BOOL
+
+        # Arithmetic operators
+        assert get_binary_op_result_type("+", MIRType.INT, MIRType.INT) == MIRType.INT
+        assert get_binary_op_result_type("-", MIRType.FLOAT, MIRType.FLOAT) == MIRType.FLOAT
+        assert get_binary_op_result_type("*", MIRType.INT, MIRType.FLOAT) == MIRType.FLOAT
+        assert get_binary_op_result_type("/", MIRType.INT, MIRType.INT) == MIRType.INT
+        assert get_binary_op_result_type("**", MIRType.FLOAT, MIRType.INT) == MIRType.FLOAT
+
+        # String concatenation
+        assert get_binary_op_result_type("+", MIRType.STRING, MIRType.INT) == MIRType.STRING
+
+        # Error cases
+        assert get_binary_op_result_type("+", MIRType.BOOL, MIRType.FUNCTION) == MIRType.ERROR
+
+        # Unknown operator
+        assert get_binary_op_result_type("unknown", MIRType.INT, MIRType.INT) == MIRType.UNKNOWN
+
+    def test_get_unary_op_result_type(self) -> None:
+        """Test unary operation result type inference."""
+        # Negation
+        assert get_unary_op_result_type("-", MIRType.INT) == MIRType.INT
+        assert get_unary_op_result_type("-", MIRType.FLOAT) == MIRType.FLOAT
+        assert get_unary_op_result_type("-", MIRType.STRING) == MIRType.ERROR
+        assert get_unary_op_result_type("-", MIRType.BOOL) == MIRType.ERROR
+
+        # Logical not
+        assert get_unary_op_result_type("not", MIRType.BOOL) == MIRType.BOOL
+        assert get_unary_op_result_type("not", MIRType.INT) == MIRType.BOOL
+        assert get_unary_op_result_type("not", MIRType.STRING) == MIRType.BOOL
+
+        # Unknown operator
+        assert get_unary_op_result_type("unknown", MIRType.INT) == MIRType.UNKNOWN

machine_dialect/mir/tests/test_mir_types_enhanced.py

@@ -0,0 +1,132 @@
+"""Tests for enhanced MIR type system."""
+
+from machine_dialect.mir.mir_types import (
+    MIRType,
+    MIRUnionType,
+    can_cast,
+    is_assignable,
+)
+from machine_dialect.mir.mir_values import Constant, Temp, Variable
+
+
+class TestEnhancedTypeSystem:
+    """Test enhanced MIR type system functionality."""
+
+    def test_can_cast_same_type(self) -> None:
+        """Test that same types can be cast to each other."""
+        assert can_cast(MIRType.INT, MIRType.INT)
+        assert can_cast(MIRType.STRING, MIRType.STRING)
+        assert can_cast(MIRType.BOOL, MIRType.BOOL)
+
+    def test_can_cast_numeric(self) -> None:
+        """Test numeric type casting."""
+        assert can_cast(MIRType.INT, MIRType.FLOAT)
+        assert can_cast(MIRType.FLOAT, MIRType.INT)
+
+    def test_can_cast_bool_numeric(self) -> None:
+        """Test bool to numeric casting."""
+        assert can_cast(MIRType.BOOL, MIRType.INT)
+        assert can_cast(MIRType.BOOL, MIRType.FLOAT)
+        assert can_cast(MIRType.INT, MIRType.BOOL)
+        assert can_cast(MIRType.FLOAT, MIRType.BOOL)
+
+    def test_can_cast_to_string(self) -> None:
+        """Test that all types can be cast to string."""
+        assert can_cast(MIRType.INT, MIRType.STRING)
+        assert can_cast(MIRType.FLOAT, MIRType.STRING)
+        assert can_cast(MIRType.BOOL, MIRType.STRING)
+        assert can_cast(MIRType.EMPTY, MIRType.STRING)
+
+    def test_can_cast_empty(self) -> None:
+        """Test that empty (null) can be cast to any type."""
+        assert can_cast(MIRType.EMPTY, MIRType.INT)
+        assert can_cast(MIRType.EMPTY, MIRType.FLOAT)
+        assert can_cast(MIRType.EMPTY, MIRType.STRING)
+        assert can_cast(MIRType.EMPTY, MIRType.BOOL)
+
+    def test_cannot_cast_invalid(self) -> None:
+        """Test invalid casts."""
+        assert not can_cast(MIRType.STRING, MIRType.INT)
+        assert not can_cast(MIRType.STRING, MIRType.FLOAT)
+        assert not can_cast(MIRType.STRING, MIRType.BOOL)
+
+    def test_is_assignable_single_types(self) -> None:
+        """Test assignment compatibility for single types."""
+        assert is_assignable(MIRType.INT, MIRType.INT)
+        assert is_assignable(MIRType.INT, MIRType.FLOAT)
+        assert is_assignable(MIRType.EMPTY, MIRType.INT)
+        assert not is_assignable(MIRType.STRING, MIRType.INT)
+
+    def test_is_assignable_union_to_single(self) -> None:
+        """Test assigning union type to single type."""
+        union = MIRUnionType([MIRType.INT, MIRType.FLOAT])
+        # Union of numeric types CAN be assigned to bool (all members can cast)
+        assert is_assignable(union, MIRType.BOOL)
+        # Individual numeric types can be cast to string
+        assert is_assignable(union, MIRType.STRING)
+
+        # Union with non-castable type
+        union2 = MIRUnionType([MIRType.STRING, MIRType.URL])
+        assert not is_assignable(union2, MIRType.INT)  # String can't cast to int
+
+    def test_is_assignable_single_to_union(self) -> None:
+        """Test assigning single type to union type."""
+        union = MIRUnionType([MIRType.INT, MIRType.STRING])
+        assert is_assignable(MIRType.INT, union)
+        assert is_assignable(MIRType.STRING, union)
+        assert is_assignable(MIRType.EMPTY, union)  # Empty can be assigned to any
+        assert is_assignable(MIRType.FLOAT, union)  # Float can cast to INT in union
+
+    def test_is_assignable_union_to_union(self) -> None:
+        """Test assigning union type to union type."""
+        union1 = MIRUnionType([MIRType.INT, MIRType.FLOAT])
+        union2 = MIRUnionType([MIRType.INT, MIRType.FLOAT, MIRType.STRING])
+        assert is_assignable(union1, union2)  # Subset is assignable
+        assert not is_assignable(union2, union1)  # Superset is not
+
+    def test_variable_with_union_type(self) -> None:
+        """Test creating variables with union types."""
+        union = MIRUnionType([MIRType.INT, MIRType.STRING])
+        var = Variable("x", union)
+
+        # Check that union type is properly stored
+        assert var.union_type == union
+        assert var.type == MIRType.UNKNOWN  # Base type is unknown for unions
+
+    def test_temp_with_union_type(self) -> None:
+        """Test creating temporaries with union types."""
+        union = MIRUnionType([MIRType.FLOAT, MIRType.BOOL])
+        temp = Temp(union, 42)
+
+        # Check that union type is properly stored
+        assert temp.union_type == union
+        assert temp.type == MIRType.UNKNOWN  # Base type is unknown for unions
+        assert temp.id == 42
+
+    def test_constant_type_tracking(self) -> None:
+        """Test that constants properly track their types."""
+        int_const = Constant(42, MIRType.INT)
+        assert int_const.type == MIRType.INT
+        assert int_const.union_type is None
+
+        str_const = Constant("hello", MIRType.STRING)
+        assert str_const.type == MIRType.STRING
+        assert str_const.union_type is None
+
+    def test_union_type_equality(self) -> None:
+        """Test union type equality checking."""
+        union1 = MIRUnionType([MIRType.INT, MIRType.STRING])
+        union2 = MIRUnionType([MIRType.STRING, MIRType.INT])  # Different order
+        union3 = MIRUnionType([MIRType.INT, MIRType.FLOAT])
+
+        assert union1 == union2  # Order doesn't matter
+        assert union1 != union3  # Different types
+
+    def test_union_type_contains(self) -> None:
+        """Test union type contains method."""
+        union = MIRUnionType([MIRType.INT, MIRType.STRING, MIRType.BOOL])
+        assert union.contains(MIRType.INT)
+        assert union.contains(MIRType.STRING)
+        assert union.contains(MIRType.BOOL)
+        assert not union.contains(MIRType.FLOAT)
+        assert not union.contains(MIRType.EMPTY)