machine-dialect 0.1.0a1__py3-none-any.whl

machine_dialect/mir/tests/test_mir_validation.py

@@ -0,0 +1,378 @@
+"""Tests for MIR validation and verification."""
+
+from __future__ import annotations
+
+from machine_dialect.mir.basic_block import BasicBlock
+from machine_dialect.mir.mir_function import MIRFunction
+from machine_dialect.mir.mir_instructions import (
+    BinaryOp,
+    Call,
+    ConditionalJump,
+    Jump,
+    LoadConst,
+    Phi,
+    Return,
+)
+from machine_dialect.mir.mir_module import MIRModule
+from machine_dialect.mir.mir_types import MIRType
+from machine_dialect.mir.mir_validation import MIRValidator, validate_function, validate_module
+from machine_dialect.mir.mir_values import Constant, FunctionRef, Variable
+
+
+class TestMIRValidation:
+    """Test MIR validation and verification."""
+
+    def setup_method(self) -> None:
+        """Set up test fixtures."""
+        self.validator = MIRValidator()
+
+    def test_valid_module(self) -> None:
+        """Test validation of a valid module."""
+        # Create valid module
+        module = MIRModule("test_module")
+
+        # Add main function
+        main_func = MIRFunction("main", [], MIRType.EMPTY)
+        entry = BasicBlock("entry")
+        main_func.cfg.add_block(entry)
+        main_func.cfg.entry_block = entry
+        entry.add_instruction(Return((1, 1)))
+
+        module.add_function(main_func)
+        module.set_main_function("main")
+
+        # Should validate successfully
+        success, errors, _warnings = validate_module(module)
+        assert success
+        assert len(errors) == 0
+
+    def test_module_without_name(self) -> None:
+        """Test validation fails for module without name."""
+        module = MIRModule("")
+
+        success, errors, _warnings = validate_module(module)
+        assert not success
+        assert any("name" in error.lower() for error in errors)
+
+    def test_module_with_invalid_main(self) -> None:
+        """Test validation fails when main function doesn't exist."""
+        module = MIRModule("test")
+        module.set_main_function("nonexistent")
+
+        success, errors, _warnings = validate_module(module)
+        assert not success
+        assert any("main" in error.lower() and "not found" in error.lower() for error in errors)
+
+    def test_function_name_mismatch(self) -> None:
+        """Test validation fails when function name doesn't match."""
+        func = MIRFunction("foo", [], MIRType.EMPTY)
+        # Set up minimal valid CFG
+        from machine_dialect.mir.basic_block import BasicBlock
+
+        entry = BasicBlock("entry")
+        from machine_dialect.mir.mir_instructions import Return
+
+        entry.add_instruction(Return((1, 1)))
+        func.cfg.entry_block = entry
+        func.cfg.add_block(entry)
+
+        # Validate with different name
+        success, errors, _warnings = validate_function(func)
+        assert success  # Should pass when validating directly
+
+        # But fail when in module with wrong name
+        module = MIRModule("test")
+        module.functions["bar"] = func  # Wrong name in dict
+
+        success, errors, _warnings = validate_module(module)
+        assert not success
+        assert any("mismatch" in error.lower() for error in errors)
+
+    def test_duplicate_parameters(self) -> None:
+        """Test validation fails with duplicate parameter names."""
+        # Create function with duplicate parameters
+        param1 = Variable("x", MIRType.INT)
+        param2 = Variable("x", MIRType.INT)  # Duplicate name
+
+        func = MIRFunction("test", [param1, param2], MIRType.EMPTY)
+
+        success, errors, _warnings = validate_function(func)
+        assert not success
+        assert any("duplicate" in error.lower() for error in errors)
+
+    def test_cfg_without_entry(self) -> None:
+        """Test validation fails when CFG has no entry block."""
+        func = MIRFunction("test", [], MIRType.EMPTY)
+        # Don't set entry block
+
+        success, errors, _warnings = validate_function(func)
+        assert not success
+        assert any("entry" in error.lower() for error in errors)
+
+    def test_inconsistent_cfg_edges(self) -> None:
+        """Test validation fails with inconsistent CFG edges."""
+        func = MIRFunction("test", [], MIRType.EMPTY)
+
+        block1 = BasicBlock("block1")
+        block2 = BasicBlock("block2")
+
+        func.cfg.add_block(block1)
+        func.cfg.add_block(block2)
+        func.cfg.entry_block = block1
+
+        # Create inconsistent edge (only one direction)
+        block1.successors.append(block2)
+        # Don't add block1 to block2's predecessors
+
+        success, errors, _warnings = validate_function(func)
+        assert not success
+        assert any("inconsistent" in error.lower() for error in errors)
+
+    def test_unreachable_blocks_warning(self) -> None:
+        """Test validation warns about unreachable blocks."""
+        func = MIRFunction("test", [], MIRType.EMPTY)
+
+        entry = BasicBlock("entry")
+        unreachable = BasicBlock("unreachable")
+
+        func.cfg.add_block(entry)
+        func.cfg.add_block(unreachable)
+        func.cfg.entry_block = entry
+
+        entry.add_instruction(Return((1, 1)))
+
+        success, _errors, warnings = validate_function(func)
+        assert success  # Should still pass
+        assert any("unreachable" in warning.lower() for warning in warnings)
+
+    def test_invalid_binary_operator(self) -> None:
+        """Test validation fails with invalid binary operator."""
+        func = MIRFunction("test", [], MIRType.EMPTY)
+
+        entry = BasicBlock("entry")
+        func.cfg.add_block(entry)
+        func.cfg.entry_block = entry
+
+        # Create binary op with invalid operator
+        t1 = func.new_temp(MIRType.INT)
+        t2 = func.new_temp(MIRType.INT)
+        result = func.new_temp(MIRType.INT)
+
+        entry.add_instruction(BinaryOp(result, "invalid_op", t1, t2, (1, 1)))
+        entry.add_instruction(Return((1, 1)))
+
+        success, errors, _warnings = validate_function(func)
+        assert not success
+        assert any("invalid" in error.lower() and "operator" in error.lower() for error in errors)
+
+    def test_jump_to_nonexistent_block(self) -> None:
+        """Test validation fails with jump to nonexistent block."""
+        func = MIRFunction("test", [], MIRType.EMPTY)
+
+        entry = BasicBlock("entry")
+        func.cfg.add_block(entry)
+        func.cfg.entry_block = entry
+
+        # Jump to block that doesn't exist
+        entry.add_instruction(Jump("nonexistent", (1, 1)))
+
+        success, errors, _warnings = validate_function(func)
+        assert not success
+        assert any("not found" in error.lower() for error in errors)
+
+    def test_conditional_jump_validation(self) -> None:
+        """Test validation of conditional jumps."""
+        func = MIRFunction("test", [], MIRType.EMPTY)
+
+        entry = BasicBlock("entry")
+        then_block = BasicBlock("then")
+
+        func.cfg.add_block(entry)
+        func.cfg.add_block(then_block)
+        func.cfg.entry_block = entry
+
+        cond = func.new_temp(MIRType.BOOL)
+
+        # Invalid: false_label doesn't exist
+        entry.add_instruction(ConditionalJump(cond, "then", (1, 1), "nonexistent"))
+
+        success, errors, _warnings = validate_function(func)
+        assert not success
+        assert any("not found" in error.lower() for error in errors)
+
+    def test_phi_node_validation(self) -> None:
+        """Test validation of phi nodes."""
+        func = MIRFunction("test", [], MIRType.EMPTY)
+
+        # 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.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 terminators
+        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)))
+
+        # Add phi with wrong predecessor
+        result = func.new_temp(MIRType.INT)
+        val1 = Constant(1, MIRType.INT)
+        val2 = Constant(2, MIRType.INT)
+
+        # Invalid: "wrong_block" is not a predecessor
+        phi = Phi(result, [(val1, "then"), (val2, "wrong_block")], (1, 1))
+        merge.add_instruction(phi)
+        merge.add_instruction(Return((1, 1)))
+
+        success, errors, _warnings = validate_function(func)
+        assert not success
+        assert any("not a predecessor" in error.lower() for error in errors)
+
+    def test_phi_missing_predecessor_warning(self) -> None:
+        """Test warning for phi node missing predecessor."""
+        func = MIRFunction("test", [], MIRType.EMPTY)
+
+        # 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.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 terminators
+        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)))
+
+        # Phi missing value from "else"
+        result = func.new_temp(MIRType.INT)
+        val1 = Constant(1, MIRType.INT)
+        phi = Phi(result, [(val1, "then")], (1, 1))  # Missing "else"
+        merge.add_instruction(phi)
+        merge.add_instruction(Return((1, 1)))
+
+        success, _errors, warnings = validate_function(func)
+        assert success  # Should pass with warning
+        assert any("missing" in warning.lower() for warning in warnings)
+
+    def test_return_type_mismatch_warning(self) -> None:
+        """Test warning for return type mismatch."""
+        # Function that returns EMPTY but has return with value
+        func = MIRFunction("test", [], MIRType.EMPTY)
+
+        entry = BasicBlock("entry")
+        func.cfg.add_block(entry)
+        func.cfg.entry_block = entry
+
+        val = func.new_temp(MIRType.INT)
+        entry.add_instruction(Return((1, 1), val))
+
+        success, _errors, warnings = validate_function(func)
+        assert success  # Should pass with warning
+        assert any("return" in warning.lower() for warning in warnings)
+
+    def test_block_with_successors_but_no_terminator(self) -> None:
+        """Test warning for block with successors but no terminator."""
+        func = MIRFunction("test", [], MIRType.EMPTY)
+
+        block1 = BasicBlock("block1")
+        block2 = BasicBlock("block2")
+
+        func.cfg.add_block(block1)
+        func.cfg.add_block(block2)
+        func.cfg.entry_block = block1
+        func.cfg.connect(block1, block2)
+
+        # block1 has successor but no jump instruction
+        t = func.new_temp(MIRType.INT)
+        block1.add_instruction(LoadConst(t, 1, (1, 1)))
+        # No terminator!
+
+        block2.add_instruction(Return((1, 1)))
+
+        success, _errors, warnings = validate_function(func)
+        assert success  # Should pass with warning
+        assert any("terminator" in warning.lower() for warning in warnings)
+
+    def test_call_validation(self) -> None:
+        """Test validation of call instructions."""
+        func = MIRFunction("test", [], MIRType.EMPTY)
+
+        entry = BasicBlock("entry")
+        func.cfg.add_block(entry)
+        func.cfg.entry_block = entry
+
+        # Valid call
+        func_ref = FunctionRef("helper")
+        arg = func.new_temp(MIRType.INT)
+        result = func.new_temp(MIRType.INT)
+
+        entry.add_instruction(Call(result, func_ref, [arg], (1, 1)))
+        entry.add_instruction(Return((1, 1)))
+
+        success, _errors, _warnings = validate_function(func)
+        assert success
+
+    def test_complete_validation_integration(self) -> None:
+        """Test complete validation of a complex module."""
+        module = MIRModule("complex_module")
+
+        # Add multiple functions
+        main = MIRFunction("main", [], MIRType.EMPTY)
+        entry = BasicBlock("entry")
+        main.cfg.add_block(entry)
+        main.cfg.entry_block = entry
+
+        # Call helper function
+        helper_ref = FunctionRef("helper")
+        arg = Constant(42, MIRType.INT)
+        result = main.new_temp(MIRType.INT)
+        entry.add_instruction(Call(result, helper_ref, [arg], (1, 1)))
+        entry.add_instruction(Return((1, 1)))
+
+        # Add helper function
+        param = Variable("x", MIRType.INT)
+        helper = MIRFunction("helper", [param], MIRType.INT)
+
+        helper_entry = BasicBlock("entry")
+        helper.cfg.add_block(helper_entry)
+        helper.cfg.entry_block = helper_entry
+
+        # Double the parameter
+        doubled = helper.new_temp(MIRType.INT)
+        two = Constant(2, MIRType.INT)
+        helper_entry.add_instruction(BinaryOp(doubled, "*", param, two, (1, 1)))
+        helper_entry.add_instruction(Return((1, 1), doubled))
+
+        module.add_function(main)
+        module.add_function(helper)
+        module.set_main_function("main")
+
+        # Should validate successfully
+        success, errors, _warnings = validate_module(module)
+        assert success
+        assert len(errors) == 0

machine_dialect/mir/tests/test_mir_values.py

@@ -0,0 +1,168 @@
+"""Tests for MIR value representations."""
+
+from machine_dialect.mir.mir_types import MIRType
+from machine_dialect.mir.mir_values import Constant, FunctionRef, Temp, Variable
+
+
+class TestMIRValues:
+    """Test MIR value types."""
+
+    def setup_method(self) -> None:
+        """Reset temp counter before each test."""
+        Temp.reset_counter()
+
+    def test_temp_creation(self) -> None:
+        """Test temporary value creation."""
+        t1 = Temp(MIRType.INT)
+        t2 = Temp(MIRType.FLOAT)
+        t3 = Temp(MIRType.STRING, temp_id=10)
+
+        assert str(t1) == "t0"
+        assert str(t2) == "t1"
+        assert str(t3) == "t10"
+        assert t1.type == MIRType.INT
+        assert t2.type == MIRType.FLOAT
+        assert t3.type == MIRType.STRING
+
+    def test_temp_equality_and_hash(self) -> None:
+        """Test temporary equality and hashing."""
+        t1 = Temp(MIRType.INT, temp_id=5)
+        t2 = Temp(MIRType.FLOAT, temp_id=5)  # Same ID, different type
+        t3 = Temp(MIRType.INT, temp_id=6)
+
+        # Equality is based on ID only
+        assert t1 == t2
+        assert t1 != t3
+
+        # Can be used in sets/dicts
+        temp_set = {t1, t2, t3}
+        assert len(temp_set) == 2  # t1 and t2 are same
+
+    def test_temp_counter_reset(self) -> None:
+        """Test temporary counter reset."""
+        t1 = Temp(MIRType.INT)
+        assert t1.id == 0
+
+        Temp.reset_counter()
+        t2 = Temp(MIRType.INT)
+        assert t2.id == 0
+
+    def test_variable_creation(self) -> None:
+        """Test variable creation."""
+        v1 = Variable("x", MIRType.INT)
+        v2 = Variable("y", MIRType.STRING, version=1)
+        v3 = Variable("x", MIRType.INT, version=2)
+
+        assert str(v1) == "x"
+        assert str(v2) == "y.1"
+        assert str(v3) == "x.2"
+        assert v1.type == MIRType.INT
+        assert v2.type == MIRType.STRING
+
+    def test_variable_equality_and_hash(self) -> None:
+        """Test variable equality and hashing."""
+        v1 = Variable("x", MIRType.INT, version=1)
+        v2 = Variable("x", MIRType.INT, version=1)
+        v3 = Variable("x", MIRType.INT, version=2)
+        v4 = Variable("y", MIRType.INT, version=1)
+
+        assert v1 == v2
+        assert v1 != v3  # Different version
+        assert v1 != v4  # Different name
+
+        # Can be used in sets/dicts
+        var_set = {v1, v2, v3, v4}
+        assert len(var_set) == 3  # v1 and v2 are same
+
+    def test_variable_versioning(self) -> None:
+        """Test variable versioning for SSA."""
+        v1 = Variable("x", MIRType.INT, version=1)
+        v2 = v1.with_version(2)
+        v3 = v1.with_version(3)
+
+        assert v1.name == v2.name
+        assert v1.type == v2.type
+        assert v2.version == 2
+        assert v3.version == 3
+        assert str(v2) == "x.2"
+        assert str(v3) == "x.3"
+
+    def test_constant_creation(self) -> None:
+        """Test constant creation."""
+        c1 = Constant(42)
+        c2 = Constant(3.14)
+        c3 = Constant("hello")
+        c4 = Constant(True)
+        c5 = Constant(None)
+        c6 = Constant(100, MIRType.FLOAT)  # Explicit type
+
+        assert str(c1) == "42"
+        assert str(c2) == "3.14"
+        assert str(c3) == '"hello"'
+        assert str(c4) == "True"
+        assert str(c5) == "null"
+        assert str(c6) == "100"
+
+        assert c1.type == MIRType.INT
+        assert c2.type == MIRType.FLOAT
+        assert c3.type == MIRType.STRING
+        assert c4.type == MIRType.BOOL
+        assert c5.type == MIRType.EMPTY
+        assert c6.type == MIRType.FLOAT
+
+    def test_constant_equality_and_hash(self) -> None:
+        """Test constant equality and hashing."""
+        c1 = Constant(42, MIRType.INT)
+        c2 = Constant(42, MIRType.INT)
+        c3 = Constant(42, MIRType.FLOAT)  # Same value, different type
+        c4 = Constant(43, MIRType.INT)
+
+        assert c1 == c2
+        assert c1 != c3  # Different type
+        assert c1 != c4  # Different value
+
+        # Can be used in sets/dicts
+        const_set = {c1, c2, c3, c4}
+        assert len(const_set) == 3  # c1 and c2 are same
+
+    def test_function_ref_creation(self) -> None:
+        """Test function reference creation."""
+        f1 = FunctionRef("main")
+        f2 = FunctionRef("helper")
+
+        assert str(f1) == "@main"
+        assert str(f2) == "@helper"
+        assert f1.type == MIRType.FUNCTION
+        assert f1.name == "main"
+
+    def test_function_ref_equality_and_hash(self) -> None:
+        """Test function reference equality and hashing."""
+        f1 = FunctionRef("foo")
+        f2 = FunctionRef("foo")
+        f3 = FunctionRef("bar")
+
+        assert f1 == f2
+        assert f1 != f3
+
+        # Can be used in sets/dicts
+        func_set = {f1, f2, f3}
+        assert len(func_set) == 2  # f1 and f2 are same
+
+    def test_mixed_value_comparisons(self) -> None:
+        """Test that different value types are not equal."""
+        temp = Temp(MIRType.INT, temp_id=1)
+        var = Variable("t1", MIRType.INT)  # Same string repr
+        const = Constant(1, MIRType.INT)
+        func = FunctionRef("t1")
+
+        # All should be different despite similar representations
+        assert temp != var
+        assert temp != const
+        assert temp != func
+        assert var != const
+        assert var != func
+        assert const != func
+
+        # All can coexist in a set
+        value_set = {temp, var, const, func}
+        assert len(value_set) == 4