feat: unify LiteralTuple representation to always use alloca and add function-context guard

Author: tmdeveloper007

src/irx/builders/llvmliteir.py

@@ -1652,16 +1652,23 @@ def visit(self, node: astx.LiteralList) -> None:
             "are supported"
         )
 
+    def _ensure_function_context(self) -> None:
+        """Ensure tuple lowering occurs inside a function."""
+        if self._llvm.ir_builder.function is None:
+            raise RuntimeError(
+                "LiteralTuple must be lowered inside a function"
+            )
+
     @dispatch  # type: ignore[no-redef]
     def visit(self, node: astx.LiteralTuple) -> None:
         """Lower a LiteralTuple to LLVM IR.
 
         Representation
         --------------
-        - Empty tuple           -> constant ``{}`` (empty literal struct).
-        - All-constant elements -> constant literal struct ``{T0, T1, …}``.
-        - Otherwise             -> alloca of the struct in the function
-          entry block with each field stored; pushes the *pointer*.
+        Always materialises an ``alloca`` in the function entry block and
+        stores each element.  The *pointer* is pushed onto the result
+        stack, giving downstream code a uniform aggregate representation
+        (GEP + load) regardless of whether elements are constant.
 
         Tuples are heterogeneous and ordered, so they are modelled as a
         literal struct rather than an array.
@@ -1675,38 +1682,29 @@ def visit(self, node: astx.LiteralTuple) -> None:
                 raise Exception("LiteralTuple: failed to lower an element.")
             llvm_vals.append(v)
 
-        n = len(llvm_vals)
-
-        # 2) Empty tuple -> constant {} (empty struct)
-        if n == 0:
-            struct_ty = ir.LiteralStructType([])
-            self.result_stack.append(ir.Constant(struct_ty, []))
-            return
-
-        # 3) Build the struct type from element value types
+        # 2) Build the struct type from element value types
         elem_tys = [v.type for v in llvm_vals]
         struct_ty = ir.LiteralStructType(elem_tys)
 
-        # 4) All-constant fast path -> constant struct
-        if all(isinstance(v, ir.Constant) for v in llvm_vals):
-            self.result_stack.append(ir.Constant(struct_ty, llvm_vals))
-            return
+        # 3) Guard: must be inside a function to use alloca
+        self._ensure_function_context()
 
-        # 5) Non-constant path: alloca + store each field
-        entry_bb = self._llvm.ir_builder.function.entry_basic_block
-        cur_bb = self._llvm.ir_builder.block
-        self._llvm.ir_builder.position_at_start(entry_bb)
-        alloca = self._llvm.ir_builder.alloca(struct_ty, name="tuple.lit")
-        self._llvm.ir_builder.position_at_end(cur_bb)
+        # 4) Alloca in the entry block, store each element, push pointer
+        builder = self._llvm.ir_builder
+        entry_bb = builder.function.entry_basic_block
+        cur_bb = builder.block
+        builder.position_at_start(entry_bb)
+        alloca = builder.alloca(struct_ty, name="tuple.lit")
+        builder.position_at_end(cur_bb)
 
         i32 = ir.IntType(32)
         for idx, v in enumerate(llvm_vals):
-            field_ptr = self._llvm.ir_builder.gep(
+            field_ptr = builder.gep(
                 alloca,
                 [ir.Constant(i32, 0), ir.Constant(i32, idx)],
                 inbounds=True,
             )
-            self._llvm.ir_builder.store(v, field_ptr)
+            builder.store(v, field_ptr)
 
         self.result_stack.append(alloca)
 

tests/test_literal_tuple.py

@@ -14,22 +14,44 @@
 HAS_LITERAL_TUPLE = hasattr(astx, "LiteralTuple")
 
 
+def _assert_unpacked_literal_struct(alloca: ir.AllocaInstr) -> None:
+    """Assert alloca points to an unpacked literal struct."""
+    assert isinstance(alloca, ir.AllocaInstr)
+    pointee = alloca.type.pointee
+    assert isinstance(pointee, ir.LiteralStructType)
+    assert not pointee.packed
+
+
+def _assert_empty_stack(visitor: LLVMLiteIRVisitor) -> None:
+    """Assert translator result stack is empty after evaluation."""
+    assert len(visitor.result_stack) == 0
+
+
+def _setup_function_context(visitor: LLVMLiteIRVisitor) -> None:
+    """Create a dummy function so the visitor can emit alloca instructions."""
+    fn_ty = ir.FunctionType(ir.VoidType(), [])
+    fn = ir.Function(visitor._llvm.module, fn_ty, "test_tuple_fn")
+    bb = fn.append_basic_block("entry")
+    visitor._llvm.ir_builder.position_at_end(bb)
+
+
 @pytest.mark.skipif(
     not HAS_LITERAL_TUPLE, reason="astx.LiteralTuple not available"
 )
 @pytest.mark.parametrize("builder_class", [LLVMLiteIR])
 def test_literal_tuple_empty(builder_class: Type[Builder]) -> None:
-    """Empty tuple lowers to constant {} (empty literal struct)."""
+    """Empty tuple lowers to alloca of {} (empty literal struct)."""
     builder = builder_class()
     visitor = cast(LLVMLiteIRVisitor, builder.translator)
     visitor.result_stack.clear()
+    _setup_function_context(visitor)
 
     visitor.visit(astx.LiteralTuple(elements=()))
-    const = visitor.result_stack.pop()
+    result = visitor.result_stack.pop()
 
-    assert isinstance(const, ir.Constant)
-    assert isinstance(const.type, ir.LiteralStructType)
-    assert len(const.type.elements) == 0
+    _assert_unpacked_literal_struct(result)
+    assert len(result.type.pointee.elements) == 0
+    _assert_empty_stack(visitor)
 
 
 @pytest.mark.skipif(
@@ -39,10 +61,11 @@ def test_literal_tuple_empty(builder_class: Type[Builder]) -> None:
 def test_literal_tuple_homogeneous_ints(
     builder_class: Type[Builder],
 ) -> None:
-    """Homogeneous integer constants lower to constant struct."""
+    """Homogeneous integer constants lower to alloca of struct."""
     builder = builder_class()
     visitor = cast(LLVMLiteIRVisitor, builder.translator)
     visitor.result_stack.clear()
+    _setup_function_context(visitor)
 
     visitor.visit(
         astx.LiteralTuple(
@@ -53,16 +76,17 @@ def test_literal_tuple_homogeneous_ints(
             )
         )
     )
-    const = visitor.result_stack.pop()
+    result = visitor.result_stack.pop()
 
-    assert isinstance(const, ir.Constant)
-    assert isinstance(const.type, ir.LiteralStructType)
+    _assert_unpacked_literal_struct(result)
     elem_count = 3
-    assert len(const.type.elements) == elem_count
+    pointee = result.type.pointee
+    assert len(pointee.elements) == elem_count
     assert all(
         isinstance(t, ir.IntType) and t.width == 32  # noqa: PLR2004
-        for t in const.type.elements
+        for t in pointee.elements
     )
+    _assert_empty_stack(visitor)
 
 
 @pytest.mark.skipif(
@@ -72,10 +96,11 @@ def test_literal_tuple_homogeneous_ints(
 def test_literal_tuple_heterogeneous(
     builder_class: Type[Builder],
 ) -> None:
-    """Heterogeneous tuple (int, float) lowers to constant struct."""
+    """Heterogeneous tuple (int, float) lowers to alloca of struct."""
     builder = builder_class()
     visitor = cast(LLVMLiteIRVisitor, builder.translator)
     visitor.result_stack.clear()
+    _setup_function_context(visitor)
 
     visitor.visit(
         astx.LiteralTuple(
@@ -85,14 +110,16 @@ def test_literal_tuple_heterogeneous(
             )
         )
     )
-    const = visitor.result_stack.pop()
+    result = visitor.result_stack.pop()
 
-    assert isinstance(const, ir.Constant)
-    assert isinstance(const.type, ir.LiteralStructType)
+    _assert_unpacked_literal_struct(result)
     elem_count = 2
-    assert len(const.type.elements) == elem_count
-    assert isinstance(const.type.elements[0], ir.IntType)
-    assert isinstance(const.type.elements[1], ir.FloatType)
+    pointee = result.type.pointee
+    assert len(pointee.elements) == elem_count
+    assert isinstance(pointee.elements[0], ir.IntType)
+    assert isinstance(pointee.elements[1], ir.FloatType)
+    assert pointee.elements[1] == ir.FloatType()
+    _assert_empty_stack(visitor)
 
 
 @pytest.mark.skipif(
@@ -102,15 +129,17 @@ def test_literal_tuple_heterogeneous(
 def test_literal_tuple_single_element(
     builder_class: Type[Builder],
 ) -> None:
-    """Single-element tuple lowers to constant struct {i32}."""
+    """Single-element tuple lowers to alloca of struct {i32}."""
     builder = builder_class()
     visitor = cast(LLVMLiteIRVisitor, builder.translator)
     visitor.result_stack.clear()
+    _setup_function_context(visitor)
 
     visitor.visit(astx.LiteralTuple(elements=(astx.LiteralInt32(42),)))
-    const = visitor.result_stack.pop()
+    result = visitor.result_stack.pop()
 
-    assert isinstance(const, ir.Constant)
-    assert isinstance(const.type, ir.LiteralStructType)
-    assert len(const.type.elements) == 1
-    assert isinstance(const.type.elements[0], ir.IntType)
+    _assert_unpacked_literal_struct(result)
+    pointee = result.type.pointee
+    assert len(pointee.elements) == 1
+    assert isinstance(pointee.elements[0], ir.IntType)
+    _assert_empty_stack(visitor)