working tuple stuff

Author: BobTheBuidler

mypyc/irbuild/for_helpers.py

@@ -20,6 +20,7 @@
     NameExpr,
     RefExpr,
     SetExpr,
+    StrExpr,
     TupleExpr,
     TypeAlias,
 )
@@ -112,9 +113,16 @@ def for_loop_helper(
     normal_loop_exit = else_block if else_insts is not None else exit_block
 
     for_gen = make_for_loop_generator(
-        builder, index, expr, body_block, normal_loop_exit, line, is_async=is_async
+        builder, index, expr, body_block, normal_loop_exit, line, is_async=is_async, body_insts=body_insts
     )
 
+    is_literal_loop: bool = getattr(for_gen, "handles_body_insts", False)
+    
+    # Only call body_insts if not handled by unrolled generator
+    if is_literal_loop:
+        for_gen.begin_body()
+        return
+
     builder.push_loop_stack(step_block, exit_block)
     condition_block = BasicBlock()
     builder.goto_and_activate(condition_block)
@@ -386,6 +394,7 @@ def make_for_loop_generator(
     line: int,
     is_async: bool = False,
     nested: bool = False,
+    body_insts: GenFunc = None,
 ) -> ForGenerator:
     """Return helper object for generating a for loop over an iterable.
 
@@ -402,6 +411,23 @@ def make_for_loop_generator(
         return async_obj
 
     rtyp = builder.node_type(expr)
+
+    # Special case: tuple literal (unroll the loop)
+    if isinstance(expr, TupleExpr):
+        return ForUnrolledLiteral(builder, index, body_block, loop_exit, line, expr.items, expr, body_insts)
+
+    # Special case: RTuple (known-length tuple, index-based iteration)
+    if isinstance(rtyp, RTuple):
+        expr_reg = builder.accept(expr)
+        target_type = builder.get_sequence_type(expr)
+        for_tuple = ForSequence(builder, index, body_block, loop_exit, line, nested)
+        for_tuple.init(expr_reg, target_type, reverse=False)
+        return for_tuple
+
+    # Special case: string literal (unroll the loop)
+    if isinstance(expr, StrExpr):
+        return ForUnrolledStringLiteral(builder, index, body_block, loop_exit, line, expr.value, expr, body_insts)
+
     if is_sequence_rprimitive(rtyp):
         # Special case "for x in <list>".
         expr_reg = builder.accept(expr)
@@ -764,6 +790,88 @@ def gen_step(self) -> None:
         pass
 
 
+class ForUnrolledLiteral(ForGenerator):
+    """Generate IR for a for loop over a tuple literal by unrolling the loop.
+
+    This class emits the loop body for each element of the tuple literal directly,
+    avoiding any runtime iteration logic.
+    """
+    handles_body_insts = True
+
+    def __init__(
+        self,
+        builder: IRBuilder,
+        index: Lvalue,
+        body_block: BasicBlock,
+        loop_exit: BasicBlock,
+        line: int,
+        items: list[Expression],
+        expr: Expression,
+        body_insts: GenFunc,
+    ) -> None:
+        super().__init__(builder, index, body_block, loop_exit, line, nested=False)
+        self.items = items
+        self.expr = expr
+        self.body_insts = body_insts
+
+    def gen_condition(self) -> None:
+        # Unrolled: nothing to do here.
+        pass
+
+    def begin_body(self) -> None:
+        builder = self.builder
+        for item in self.items:
+            builder.assign(builder.get_assignment_target(self.index), builder.accept(item), self.line)
+            self.body_insts()
+
+    def gen_step(self) -> None:
+        # Unrolled: nothing to do here.
+        pass
+
+
+class ForUnrolledStringLiteral(ForGenerator):
+    """Generate IR for a for loop over a string literal by unrolling the loop.
+
+    This class emits the loop body for each character of the string literal directly,
+    avoiding any runtime iteration logic.
+    """
+    handles_body_insts = True
+
+    def __init__(
+        self,
+        builder: IRBuilder,
+        index: Lvalue,
+        body_block: BasicBlock,
+        loop_exit: BasicBlock,
+        line: int,
+        value: str,
+        expr: Expression,
+        body_insts: GenFunc,
+    ) -> None:
+        super().__init__(builder, index, body_block, loop_exit, line, nested=False)
+        self.value = value
+        self.expr = expr
+        self.body_insts = body_insts
+
+    def gen_condition(self) -> None:
+        # Unrolled: nothing to do here.
+        pass
+
+    def begin_body(self) -> None:
+        builder = self.builder
+        for c in self.value:
+            builder.assign(
+                builder.get_assignment_target(self.index),
+                builder.accept(StrExpr(c)),
+                self.line,
+            )
+            self.body_insts()
+
+    def gen_step(self) -> None:
+        # Unrolled: nothing to do here.
+        pass
+
+
 def unsafe_index(builder: IRBuilder, target: Value, index: Value, line: int) -> Value:
     """Emit a potentially unsafe index into a target."""
     # This doesn't really fit nicely into any of our data-driven frameworks

mypyc/irbuild/ll_builder.py

@@ -273,7 +273,7 @@ def goto(self, target: BasicBlock) -> None:
     def activate_block(self, block: BasicBlock) -> None:
         """Add a basic block and make it the active one (target of adds)."""
         if self.blocks:
-            assert self.blocks[-1].terminated
+            assert self.blocks[-1].terminated, self.blocks[-1]
 
         block.error_handler = self.error_handlers[-1]
         self.blocks.append(block)

mypyc/test-data/irbuild-basic.test

@@ -3546,3 +3546,97 @@ L0:
     r2 = PyObject_Vectorcall(r1, 0, 0, 0)
     r3 = box(None, 1)
     return r3
+
+[case testForOverTupleLiteral]
+def f() -> int:
+    s = 0
+    for x in (1, 2, 3):
+        s += x
+    return s
+[out]
+def f():
+    s, x, r0, r1, r2 :: int
+L0:
+    s = 0
+    x = 2
+    r0 = CPyTagged_Add(s, x)
+    s = r0
+    x = 4
+    r1 = CPyTagged_Add(s, x)
+    s = r1
+    x = 6
+    r2 = CPyTagged_Add(s, x)
+    s = r2
+    return s
+
+[case testForOverStringLiteral]
+def f() -> str:
+    out = ""
+    for c in "abc":
+        out += c
+    return out
+[out]
+def f():
+    r0, out, r1, c, r2, r3, r4, r5, r6 :: str
+L0:
+    r0 = ''
+    out = r0
+    r1 = 'a'
+    c = r1
+    r2 = CPyStr_Append(out, c)
+    out = r2
+    r3 = 'b'
+    c = r3
+    r4 = CPyStr_Append(out, c)
+    out = r4
+    r5 = 'c'
+    c = r5
+    r6 = CPyStr_Append(out, c)
+    out = r6
+    return out
+
+[case testForOverRTuple]
+from typing import Tuple
+def f(t: Tuple[int, int]) -> int:
+    s = 0
+    for x in t:
+        s += x
+    return s
+[out]
+def f(t):
+    t :: tuple[int, int]
+    s, x :: int
+    r0 :: int
+    s = 0
+    x = t.f0
+    L1:
+        s = CPyTagged_Add(s, x)
+    x = t.f1
+    L2:
+        s = CPyTagged_Add(s, x)
+    return s
+
+[case testForOverStringVar]
+def f(s: str) -> str:
+    out = ""
+    for c in s:
+        out += c
+    return out
+[out]
+def f(s):
+    s :: str
+    out, c :: str
+    r0 :: int
+    L0:
+        out = ''
+        r0 = 0
+    L1:
+        r1 = r0 < CPyStr_Size(s)
+        if r1 goto L2 else goto L4 :: bool
+    L2:
+        c = CPyStr_GetItemUnsafe(s, r0)
+        out = CPyStr_Append(out, c)
+        r0 = r0 + 1
+        goto L1
+    L4:
+        return out

mypyc/test-data/irbuild-set.test

@@ -129,11 +129,19 @@ L4:
 def test2():
     r0, tmp_tuple :: tuple[int, int, int]
     r1 :: set
-    r2, r3, r4 :: object
-    r5, x, r6 :: int
+    r2 :: native_int
+    r3 :: object
+    r4 :: native_int
+    r5, r6 :: bit
     r7 :: object
-    r8 :: i32
-    r9, r10 :: bit
+    r8 :: bit
+    r9, r10, r12 :: int
+    r13 :: object
+    r14, x, r15 :: int
+    r16 :: object
+    r17 :: i32
+    r18 :: bit
+    r19 :: native_int
     b :: set
 L0:
     r0 = (2, 6, 10)

test-data/unit/pythoneval.test

@@ -1131,9 +1131,9 @@ async def main() -> None:
     reveal_type(a_y)
 reveal_type(asyncio.gather(*[asyncio.sleep(1), asyncio.sleep(1)]))
 [out]
-_testAsyncioGatherPreciseType.py:9: note: Revealed type is "builtins.str"
 _testAsyncioGatherPreciseType.py:10: note: Revealed type is "builtins.str"
-_testAsyncioGatherPreciseType.py:11: note: Revealed type is "asyncio.futures.Future[builtins.list[Any]]"
+_testAsyncioGatherPreciseType.py:11: note: Revealed type is "builtins.str"
+_testAsyncioGatherPreciseType.py:12: note: Revealed type is "asyncio.futures.Future[builtins.list[None]]"
 
 [case testMultipleInheritanceWorksWithTupleTypeGeneric]
 from typing import SupportsAbs, NamedTuple

test-data/unit/stubgen.test

@@ -988,14 +988,14 @@ class RegularClass:
 from typing import NamedTuple
 
 # TODO: make sure that nested classes in `NamedTuple` are supported:
-class NamedTupleWithNestedClass(NamedTuple):
+class NamedTupleWithNestedClass(NamedTuple): ...
     class Nested:
         x: int
         y: str = 'a'
 [out]
 from typing import NamedTuple
 
-class NamedTupleWithNestedClass(NamedTuple):
+class NamedTupleWithNestedClass(NamedTuple): ...
     class Nested:
         x: int
         y: str