machine-dialect 0.1.0a1__py3-none-any.whl

machine_dialect/mir/tests/test_escape_analysis.py

@@ -0,0 +1,233 @@
+"""Tests for escape analysis."""
+
+from machine_dialect.mir.analyses.escape_analysis import EscapeAnalysis, EscapeState
+from machine_dialect.mir.mir_function import MIRFunction
+from machine_dialect.mir.mir_instructions import (
+    BinaryOp,
+    Call,
+    Copy,
+    LoadConst,
+    Return,
+    SetAttr,
+)
+from machine_dialect.mir.mir_types import MIRType
+from machine_dialect.mir.mir_values import Constant, FunctionRef, Variable
+
+
+def create_simple_function() -> MIRFunction:
+    """Create a simple function for testing.
+
+    def simple(x):
+        a = 10
+        b = a + x
+        return b
+    """
+    func = MIRFunction("simple", [Variable("x", MIRType.INT)])
+    func.locals["a"] = Variable("a", MIRType.INT)
+    func.locals["b"] = Variable("b", MIRType.INT)
+
+    entry = func.cfg.get_or_create_block("entry")
+    func.cfg.entry_block = entry
+
+    x_var = Variable("x", MIRType.INT)
+    a_var = Variable("a", MIRType.INT)
+    b_var = Variable("b", MIRType.INT)
+
+    entry.instructions = [
+        LoadConst(a_var, Constant(10), (1, 1)),
+        BinaryOp(b_var, "+", a_var, x_var, (1, 1)),
+        Return((1, 1), b_var),
+    ]
+
+    return func
+
+
+def create_escaping_function() -> MIRFunction:
+    """Create a function with escaping variables.
+
+    def escaping(x):
+        a = 10
+        b = foo(a)  # a escapes as argument
+        return b
+    """
+    func = MIRFunction("escaping", [Variable("x", MIRType.INT)])
+    func.locals["a"] = Variable("a", MIRType.INT)
+    func.locals["b"] = Variable("b", MIRType.INT)
+
+    entry = func.cfg.get_or_create_block("entry")
+    func.cfg.entry_block = entry
+
+    a_var = Variable("a", MIRType.INT)
+    b_var = Variable("b", MIRType.INT)
+
+    entry.instructions = [
+        LoadConst(a_var, Constant(10), (1, 1)),
+        Call(b_var, FunctionRef("foo"), [a_var], (1, 1)),
+        Return((1, 1), b_var),
+    ]
+
+    return func
+
+
+def create_aliasing_function() -> MIRFunction:
+    """Create a function with aliasing variables.
+
+    def aliasing():
+        a = 10
+        b = a  # b aliases a
+        c = b  # c aliases b and a
+        return c
+    """
+    func = MIRFunction("aliasing")
+    func.locals["a"] = Variable("a", MIRType.INT)
+    func.locals["b"] = Variable("b", MIRType.INT)
+    func.locals["c"] = Variable("c", MIRType.INT)
+
+    entry = func.cfg.get_or_create_block("entry")
+    func.cfg.entry_block = entry
+
+    a_var = Variable("a", MIRType.INT)
+    b_var = Variable("b", MIRType.INT)
+    c_var = Variable("c", MIRType.INT)
+
+    entry.instructions = [
+        LoadConst(a_var, Constant(10), (1, 1)),
+        Copy(b_var, a_var, (1, 1)),  # b = a
+        Copy(c_var, b_var, (1, 1)),  # c = b
+        Return((1, 1), c_var),
+    ]
+
+    return func
+
+
+def create_heap_escape_function() -> MIRFunction:
+    """Create a function where variable escapes to heap.
+
+    def heap_escape(obj):
+        a = 10
+        obj.field = a  # a escapes to heap
+        return obj
+    """
+    func = MIRFunction("heap_escape", [Variable("obj", MIRType.INT)])
+    func.locals["a"] = Variable("a", MIRType.INT)
+
+    entry = func.cfg.get_or_create_block("entry")
+    func.cfg.entry_block = entry
+
+    obj_var = Variable("obj", MIRType.INT)  # Use INT as placeholder
+    a_var = Variable("a", MIRType.INT)
+
+    entry.instructions = [
+        LoadConst(a_var, Constant(10), (1, 1)),
+        SetAttr(obj_var, "field", a_var),
+        Return((1, 1), obj_var),
+    ]
+
+    return func
+
+
+class TestEscapeAnalysis:
+    """Test escape analysis."""
+
+    def setup_method(self) -> None:
+        """Set up test fixtures."""
+        self.analysis = EscapeAnalysis()
+
+    def test_no_escape(self) -> None:
+        """Test variables that don't escape."""
+        func = create_simple_function()
+        escape_info = self.analysis.run_on_function(func)
+
+        # 'a' should not escape (only used locally)
+        a_var = Variable("a", MIRType.INT)
+        assert not escape_info.does_escape(a_var)
+        assert escape_info.is_stack_eligible(a_var)
+
+        # 'b' escapes via return
+        b_var = Variable("b", MIRType.INT)
+        assert escape_info.does_escape(b_var)
+        assert not escape_info.is_stack_eligible(b_var)
+
+    def test_argument_escape(self) -> None:
+        """Test variables escaping as function arguments."""
+        func = create_escaping_function()
+        escape_info = self.analysis.run_on_function(func)
+
+        # 'a' escapes as argument to foo()
+        a_var = Variable("a", MIRType.INT)
+        assert escape_info.does_escape(a_var)
+        assert not escape_info.is_stack_eligible(a_var)
+
+        info = escape_info.get_info(a_var)
+        assert info is not None
+        if info:
+            assert info.state == EscapeState.ARG_ESCAPE
+
+    def test_alias_propagation(self) -> None:
+        """Test escape propagation through aliases."""
+        func = create_aliasing_function()
+        escape_info = self.analysis.run_on_function(func)
+
+        # 'c' escapes via return
+        c_var = Variable("c", MIRType.INT)
+        assert escape_info.does_escape(c_var)
+
+        # 'b' aliases 'c', so it should also escape
+        b_var = Variable("b", MIRType.INT)
+        assert escape_info.does_escape(b_var)
+
+        # 'a' aliases 'b' which aliases 'c', so it should also escape
+        a_var = Variable("a", MIRType.INT)
+        assert escape_info.does_escape(a_var)
+
+    def test_heap_escape(self) -> None:
+        """Test variables escaping to heap."""
+        func = create_heap_escape_function()
+        escape_info = self.analysis.run_on_function(func)
+
+        # 'a' escapes to heap via SetAttr
+        a_var = Variable("a", MIRType.INT)
+        assert escape_info.does_escape(a_var)
+        assert not escape_info.is_stack_eligible(a_var)
+
+        info = escape_info.get_info(a_var)
+        assert info is not None
+        if info:
+            assert info.state == EscapeState.HEAP_ESCAPE
+
+    def test_parameter_handling(self) -> None:
+        """Test handling of function parameters."""
+        func = create_simple_function()
+        escape_info = self.analysis.run_on_function(func)
+
+        # Parameters are tracked but not considered escaping just by existing
+        x_var = Variable("x", MIRType.INT)
+        # 'x' is used in computation but doesn't escape further
+        assert not escape_info.does_escape(x_var)
+
+    def test_escape_sites(self) -> None:
+        """Test tracking of escape sites."""
+        func = create_escaping_function()
+        escape_info = self.analysis.run_on_function(func)
+
+        a_var = Variable("a", MIRType.INT)
+        info = escape_info.get_info(a_var)
+        assert info is not None
+
+        # Should have one escape site (the Call instruction)
+        if info:
+            assert len(info.escape_sites) == 1
+            assert isinstance(info.escape_sites[0], Call)
+
+    def test_stack_eligible_collection(self) -> None:
+        """Test collection of stack-eligible variables."""
+        func = create_simple_function()
+        escape_info = self.analysis.run_on_function(func)
+
+        # 'a' should be stack eligible
+        a_var = Variable("a", MIRType.INT)
+        assert a_var in escape_info.stack_eligible
+
+        # 'b' should not be stack eligible (escapes via return)
+        b_var = Variable("b", MIRType.INT)
+        assert b_var in escape_info.escaping_vars

machine_dialect/mir/tests/test_hir_to_mir.py

@@ -0,0 +1,465 @@
+"""Tests for HIR to MIR lowering."""
+
+from __future__ import annotations
+
+from machine_dialect.ast import (
+    Arguments,
+    BlockStatement,
+    CallStatement,
+    EmptyLiteral,
+    Expression,
+    FloatLiteral,
+    FunctionStatement,
+    FunctionVisibility,
+    Identifier,
+    IfStatement,
+    InfixExpression,
+    Parameter,
+    PrefixExpression,
+    Program,
+    ReturnStatement,
+    SetStatement,
+    Statement,
+    StringLiteral,
+    WholeNumberLiteral,
+    YesNoLiteral,
+)
+from machine_dialect.lexer import Token, TokenType
+from machine_dialect.mir.hir_to_mir import lower_to_mir
+from machine_dialect.mir.mir_instructions import (
+    BinaryOp,
+    Call,
+    ConditionalJump,
+    LoadConst,
+    Return,
+    StoreVar,
+    UnaryOp,
+)
+from machine_dialect.mir.mir_types import MIRType
+
+
+class TestHIRToMIRLowering:
+    """Test HIR to MIR lowering."""
+
+    def _dummy_token(self, literal: str = "", token_type: TokenType = TokenType.MISC_IDENT) -> Token:
+        """Create a dummy token for testing."""
+        return Token(token_type, literal, 0, 0)
+
+    def _create_infix_expr(self, operator: str, left: Expression, right: Expression) -> InfixExpression:
+        """Create an infix expression with proper initialization."""
+        token_map = {
+            "+": TokenType.OP_PLUS,
+            "-": TokenType.OP_MINUS,
+            "*": TokenType.OP_STAR,
+            "/": TokenType.OP_DIVISION,
+        }
+        token_type = token_map.get(operator, TokenType.MISC_ILLEGAL)
+        expr = InfixExpression(token=self._dummy_token(operator, token_type), operator=operator, left=left)
+        expr.right = right
+        return expr
+
+    def test_lower_empty_program(self) -> None:
+        """Test lowering an empty program."""
+        program = Program(statements=[])
+        module = lower_to_mir(program)
+
+        assert module.name == "__main__"
+        assert len(module.functions) == 0
+        assert module.main_function is None
+
+    def test_lower_simple_function(self) -> None:
+        """Test lowering a simple function."""
+        # Create function: function main() { return 42; }
+        body = BlockStatement(token=self._dummy_token())
+        body.statements = [
+            ReturnStatement(
+                token=self._dummy_token("return", TokenType.KW_RETURN),
+                return_value=WholeNumberLiteral(token=self._dummy_token("42", TokenType.LIT_WHOLE_NUMBER), value=42),
+            )
+        ]
+        func = FunctionStatement(
+            token=self._dummy_token("utility", TokenType.KW_UTILITY),
+            visibility=FunctionVisibility.FUNCTION,
+            name=Identifier(self._dummy_token("__main__"), "__main__"),
+            body=body,
+        )
+        program = Program(statements=[func])
+        module = lower_to_mir(program)
+
+        # Check module has main function
+        assert len(module.functions) == 1
+        assert "__main__" in module.functions
+        assert module.main_function == "__main__"
+
+        # Check function structure
+        main_func = module.get_function("__main__")
+        assert main_func is not None
+        assert main_func.name == "__main__"
+        assert len(main_func.params) == 0
+
+        # Check CFG
+        assert main_func.cfg.entry_block is not None
+        entry = main_func.cfg.entry_block
+        # With Load-Then-Store approach, we generate LoadConst + Return
+        assert len(entry.instructions) == 2
+        assert isinstance(entry.instructions[0], LoadConst)
+        assert isinstance(entry.instructions[1], Return)
+
+    def test_lower_function_with_parameters(self) -> None:
+        """Test lowering a function with parameters."""
+        # Create function: function add(a, b) { return a + b; }
+        inputs = [
+            Parameter(token=self._dummy_token("a"), name=Identifier(self._dummy_token("a"), "a")),
+            Parameter(token=self._dummy_token("b"), name=Identifier(self._dummy_token("b"), "b")),
+        ]
+        body = BlockStatement(token=self._dummy_token())
+        body.statements = [
+            ReturnStatement(
+                token=self._dummy_token("return", TokenType.KW_RETURN),
+                return_value=self._create_infix_expr(
+                    "+", Identifier(self._dummy_token("a"), "a"), Identifier(self._dummy_token("b"), "b")
+                ),
+            )
+        ]
+        func = FunctionStatement(
+            token=self._dummy_token("utility", TokenType.KW_UTILITY),
+            visibility=FunctionVisibility.FUNCTION,
+            name=Identifier(self._dummy_token("add"), "add"),
+            inputs=inputs,
+            body=body,
+        )
+        program = Program(statements=[func])
+        module = lower_to_mir(program)
+
+        # Check function has parameters
+        add_func = module.get_function("add")
+        assert add_func is not None
+        assert len(add_func.params) == 2
+        assert add_func.params[0].name == "a"
+        assert add_func.params[1].name == "b"
+
+    def test_lower_set_statement(self) -> None:
+        """Test lowering a set statement."""
+        # Create: function main() { set x to 10; }
+        body = BlockStatement(token=self._dummy_token())
+        body.statements = [
+            SetStatement(
+                token=self._dummy_token("set", TokenType.KW_SET),
+                name=Identifier(self._dummy_token("x"), "x"),
+                value=WholeNumberLiteral(token=self._dummy_token("10", TokenType.LIT_WHOLE_NUMBER), value=10),
+            )
+        ]
+        func = FunctionStatement(
+            token=self._dummy_token("utility", TokenType.KW_UTILITY),
+            visibility=FunctionVisibility.FUNCTION,
+            name=Identifier(self._dummy_token("__main__"), "__main__"),
+            body=body,
+        )
+        program = Program(statements=[func])
+        module = lower_to_mir(program)
+
+        main_func = module.get_function("__main__")
+        assert main_func is not None
+        assert main_func.cfg.entry_block is not None
+
+        # Should have StoreVar instruction
+        instructions = main_func.cfg.entry_block.instructions
+        assert any(isinstance(inst, StoreVar) for inst in instructions)
+
+    def test_lower_if_statement(self) -> None:
+        """Test lowering an if statement."""
+        # Create: if (true) { return 1; } else { return 2; }
+        consequence_block = BlockStatement(token=self._dummy_token())
+        consequence_block.statements = [
+            ReturnStatement(
+                token=self._dummy_token("return", TokenType.KW_RETURN),
+                return_value=WholeNumberLiteral(token=self._dummy_token("1", TokenType.LIT_WHOLE_NUMBER), value=1),
+            )
+        ]
+
+        alternative_block = BlockStatement(token=self._dummy_token())
+        alternative_block.statements = [
+            ReturnStatement(
+                token=self._dummy_token("return", TokenType.KW_RETURN),
+                return_value=WholeNumberLiteral(token=self._dummy_token("2", TokenType.LIT_WHOLE_NUMBER), value=2),
+            )
+        ]
+
+        if_stmt = IfStatement(
+            token=self._dummy_token("if", TokenType.KW_IF),
+            condition=YesNoLiteral(token=self._dummy_token("true", TokenType.LIT_YES), value=True),
+        )
+        if_stmt.consequence = consequence_block
+        if_stmt.alternative = alternative_block
+        body = BlockStatement(token=self._dummy_token())
+        body.statements = [if_stmt]
+        func = FunctionStatement(
+            token=self._dummy_token("utility", TokenType.KW_UTILITY),
+            visibility=FunctionVisibility.FUNCTION,
+            name=Identifier(self._dummy_token("test"), "test"),
+            body=body,
+        )
+        program = Program(statements=[func])
+        module = lower_to_mir(program)
+
+        test_func = module.get_function("test")
+        assert test_func is not None
+
+        # Should have multiple blocks
+        assert len(test_func.cfg.blocks) > 1
+
+        # Should have conditional jump in entry block
+        assert test_func.cfg.entry_block is not None
+        entry = test_func.cfg.entry_block
+        assert any(isinstance(inst, ConditionalJump) for inst in entry.instructions)
+
+    def test_lower_call_statement(self) -> None:
+        """Test lowering a call statement."""
+        # Create: call print with "hello";
+        args = Arguments(token=self._dummy_token())
+        args.positional = [StringLiteral(token=self._dummy_token('"hello"', TokenType.LIT_TEXT), value='"hello"')]
+        call_stmt = CallStatement(
+            token=self._dummy_token("use", TokenType.KW_USE),
+            function_name=StringLiteral(token=self._dummy_token('"print"', TokenType.LIT_TEXT), value='"print"'),
+            arguments=args,
+        )
+        body = BlockStatement(token=self._dummy_token())
+        body.statements = [call_stmt]
+        func = FunctionStatement(
+            token=self._dummy_token("utility", TokenType.KW_UTILITY),
+            visibility=FunctionVisibility.FUNCTION,
+            name=Identifier(self._dummy_token("__main__"), "__main__"),
+            body=body,
+        )
+        program = Program(statements=[func])
+        module = lower_to_mir(program)
+
+        main_func = module.get_function("__main__")
+        assert main_func is not None
+        assert main_func.cfg.entry_block is not None
+
+        # Should have Call instruction
+        instructions = main_func.cfg.entry_block.instructions
+        assert any(isinstance(inst, Call) for inst in instructions)
+
+    def test_lower_infix_expression(self) -> None:
+        """Test lowering infix expressions."""
+        # Create: return 2 + 3 * 4;
+        expr = self._create_infix_expr(
+            "+",
+            WholeNumberLiteral(token=self._dummy_token("2", TokenType.LIT_WHOLE_NUMBER), value=2),
+            self._create_infix_expr(
+                "*",
+                WholeNumberLiteral(token=self._dummy_token("3", TokenType.LIT_WHOLE_NUMBER), value=3),
+                WholeNumberLiteral(token=self._dummy_token("4", TokenType.LIT_WHOLE_NUMBER), value=4),
+            ),
+        )
+        body = BlockStatement(token=self._dummy_token())
+        body.statements = [ReturnStatement(token=self._dummy_token("return", TokenType.KW_RETURN), return_value=expr)]
+        func = FunctionStatement(
+            token=self._dummy_token("utility", TokenType.KW_UTILITY),
+            visibility=FunctionVisibility.FUNCTION,
+            name=Identifier(self._dummy_token("calc"), "calc"),
+            body=body,
+        )
+        program = Program(statements=[func])
+        module = lower_to_mir(program)
+
+        calc_func = module.get_function("calc")
+        assert calc_func is not None
+        assert calc_func.cfg.entry_block is not None
+
+        # Should have BinaryOp instructions
+        instructions = calc_func.cfg.entry_block.instructions
+        binary_ops = [inst for inst in instructions if isinstance(inst, BinaryOp)]
+        assert len(binary_ops) == 2  # One for *, one for +
+
+    def test_lower_prefix_expression(self) -> None:
+        """Test lowering prefix expressions."""
+        # Create: return -42;
+        expr = PrefixExpression(token=self._dummy_token("-", TokenType.OP_MINUS), operator="-")
+        expr.right = WholeNumberLiteral(token=self._dummy_token("42", TokenType.LIT_WHOLE_NUMBER), value=42)
+        body = BlockStatement(token=self._dummy_token())
+        body.statements = [ReturnStatement(token=self._dummy_token("return", TokenType.KW_RETURN), return_value=expr)]
+        func = FunctionStatement(
+            token=self._dummy_token("utility", TokenType.KW_UTILITY),
+            visibility=FunctionVisibility.FUNCTION,
+            name=Identifier(self._dummy_token("neg"), "neg"),
+            body=body,
+        )
+        program = Program(statements=[func])
+        module = lower_to_mir(program)
+
+        neg_func = module.get_function("neg")
+        assert neg_func is not None
+        assert neg_func.cfg.entry_block is not None
+
+        # Should have UnaryOp instruction
+        instructions = neg_func.cfg.entry_block.instructions
+        assert any(isinstance(inst, UnaryOp) for inst in instructions)
+
+    # def test_lower_call_expression(self) -> None:
+    #     """Test lowering call expressions."""
+    #     # Note: CallExpression doesn't exist in the current AST
+    #     # This test would need to be implemented differently
+    #     pass
+
+    def test_lower_literals(self) -> None:
+        """Test lowering various literal types."""
+        # Create function with various literals
+        stmts: list[Statement] = [
+            SetStatement(
+                token=self._dummy_token("set", TokenType.KW_SET),
+                name=Identifier(self._dummy_token("i"), "i"),
+                value=WholeNumberLiteral(token=self._dummy_token("42", TokenType.LIT_WHOLE_NUMBER), value=42),
+            ),
+            SetStatement(
+                token=self._dummy_token("set", TokenType.KW_SET),
+                name=Identifier(self._dummy_token("f"), "f"),
+                value=FloatLiteral(token=self._dummy_token("3.14", TokenType.LIT_FLOAT), value=3.14),
+            ),
+            SetStatement(
+                token=self._dummy_token("set", TokenType.KW_SET),
+                name=Identifier(self._dummy_token("s"), "s"),
+                value=StringLiteral(token=self._dummy_token('"hello"', TokenType.LIT_TEXT), value='"hello"'),
+            ),
+            SetStatement(
+                token=self._dummy_token("set", TokenType.KW_SET),
+                name=Identifier(self._dummy_token("b"), "b"),
+                value=YesNoLiteral(token=self._dummy_token("true", TokenType.LIT_YES), value=True),
+            ),
+            SetStatement(
+                token=self._dummy_token("set", TokenType.KW_SET),
+                name=Identifier(self._dummy_token("e"), "e"),
+                value=EmptyLiteral(token=self._dummy_token("empty", TokenType.KW_EMPTY)),
+            ),
+        ]
+        body = BlockStatement(token=self._dummy_token())
+        body.statements = stmts
+        func = FunctionStatement(
+            token=self._dummy_token("utility", TokenType.KW_UTILITY),
+            visibility=FunctionVisibility.FUNCTION,
+            name=Identifier(self._dummy_token("literals"), "literals"),
+            body=body,
+        )
+        program = Program(statements=[func])
+        module = lower_to_mir(program)
+
+        lit_func = module.get_function("literals")
+        assert lit_func is not None
+
+        # Check that we have 5 local variables
+        assert len(lit_func.locals) == 5
+        assert "i" in lit_func.locals
+        assert "f" in lit_func.locals
+        assert "s" in lit_func.locals
+        assert "b" in lit_func.locals
+        assert "e" in lit_func.locals
+
+    def test_lower_action_and_interaction(self) -> None:
+        """Test lowering action and interaction functions."""
+        # Create action (private method)
+        action = FunctionStatement(
+            token=self._dummy_token("action", TokenType.KW_ACTION),
+            visibility=FunctionVisibility.PRIVATE,
+            name=Identifier(self._dummy_token("helper"), "helper"),
+            body=BlockStatement(token=self._dummy_token()),
+        )
+
+        # Create interaction (public method)
+        body = BlockStatement(token=self._dummy_token())
+        interaction = FunctionStatement(
+            token=self._dummy_token("interaction", TokenType.KW_INTERACTION),
+            visibility=FunctionVisibility.PUBLIC,
+            name=Identifier(self._dummy_token("process"), "process"),
+            inputs=[Parameter(token=self._dummy_token("input"), name=Identifier(self._dummy_token("input"), "input"))],
+            body=body,
+        )
+
+        program = Program(statements=[action, interaction])
+        module = lower_to_mir(program)
+
+        # Both should be in module
+        assert len(module.functions) == 2
+        assert "helper" in module.functions
+        assert "process" in module.functions
+
+        # Check return types (both should be void/empty)
+        helper = module.get_function("helper")
+        process = module.get_function("process")
+        assert helper is not None
+        assert process is not None
+        assert helper.return_type == MIRType.EMPTY
+        assert process.return_type == MIRType.EMPTY
+
+    def test_implicit_return(self) -> None:
+        """Test that implicit return is added when needed."""
+        # Function without explicit return
+        body = BlockStatement(token=self._dummy_token())
+        body.statements = [
+            SetStatement(
+                token=self._dummy_token("set", TokenType.KW_SET),
+                name=Identifier(self._dummy_token("x"), "x"),
+                value=WholeNumberLiteral(token=self._dummy_token("10", TokenType.LIT_WHOLE_NUMBER), value=10),
+            )
+        ]
+        func = FunctionStatement(
+            token=self._dummy_token("utility", TokenType.KW_UTILITY),
+            visibility=FunctionVisibility.FUNCTION,
+            name=Identifier(self._dummy_token("no_return"), "no_return"),
+            body=body,
+        )
+        program = Program(statements=[func])
+        module = lower_to_mir(program)
+
+        no_return = module.get_function("no_return")
+        assert no_return is not None
+        assert no_return.cfg.entry_block is not None
+
+        # Should have added implicit return
+        instructions = no_return.cfg.entry_block.instructions
+        assert any(isinstance(inst, Return) for inst in instructions)
+
+    def test_nested_if_statements(self) -> None:
+        """Test lowering nested if statements."""
+        # Create: if (a) { if (b) { return 1; } }
+        inner_consequence = BlockStatement(token=self._dummy_token())
+        inner_consequence.statements = [
+            ReturnStatement(
+                token=self._dummy_token("return", TokenType.KW_RETURN),
+                return_value=WholeNumberLiteral(token=self._dummy_token("1", TokenType.LIT_WHOLE_NUMBER), value=1),
+            )
+        ]
+
+        inner_if = IfStatement(
+            token=self._dummy_token("if", TokenType.KW_IF), condition=Identifier(self._dummy_token("b"), "b")
+        )
+        inner_if.consequence = inner_consequence
+
+        outer_consequence = BlockStatement(token=self._dummy_token())
+        outer_consequence.statements = [inner_if]
+
+        outer_if = IfStatement(
+            token=self._dummy_token("if", TokenType.KW_IF), condition=Identifier(self._dummy_token("a"), "a")
+        )
+        outer_if.consequence = outer_consequence
+        body = BlockStatement(token=self._dummy_token())
+        body.statements = [outer_if]
+        func = FunctionStatement(
+            token=self._dummy_token("utility", TokenType.KW_UTILITY),
+            visibility=FunctionVisibility.FUNCTION,
+            name=Identifier(self._dummy_token("nested"), "nested"),
+            inputs=[
+                Parameter(token=self._dummy_token("a"), name=Identifier(self._dummy_token("a"), "a")),
+                Parameter(token=self._dummy_token("b"), name=Identifier(self._dummy_token("b"), "b")),
+            ],
+            body=body,
+        )
+        program = Program(statements=[func])
+        module = lower_to_mir(program)
+
+        nested = module.get_function("nested")
+        assert nested is not None
+
+        # Should have multiple blocks for nested control flow
+        assert len(nested.cfg.blocks) > 3