Add support for the tuple datatype

Author: tmdeveloper007

src/irx/builders/llvmliteir.py

@@ -1645,6 +1645,64 @@ def visit(self, node: astx.LiteralList) -> None:
             "are supported"
         )
 
+    @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*.
+
+        Tuples are heterogeneous and ordered, so they are modelled as a
+        literal struct rather than an array.
+        """
+        # 1) Lower every element
+        llvm_vals: list[ir.Value] = []
+        for elem in node.elements:
+            self.visit(elem)
+            v = self.result_stack.pop()
+            if v is 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
+        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
+
+        # 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)
+
+        i32 = ir.IntType(32)
+        for idx, v in enumerate(llvm_vals):
+            field_ptr = self._llvm.ir_builder.gep(
+                alloca,
+                [ir.Constant(i32, 0), ir.Constant(i32, idx)],
+                inbounds=True,
+            )
+            self._llvm.ir_builder.store(v, field_ptr)
+
+        self.result_stack.append(alloca)
+
     def _create_string_concat_function(self) -> ir.Function:
         """Create a string concatenation function."""
         func_name = "string_concat"