Fix comprehension scope not inheriting enclosing function's symtable

When a comprehension with a lambda creates a synthetic scope via enter_scope(), the new scope got an empty symtable. This meant variables from the enclosing function (e.g. parameters used as the comprehension's iterable) were not accessible, causing UnboundLocalError at runtime. Fix by copying the parent symtable into the comprehension scope. Since the comprehension is inlined (same basic blocks and registers), the parent's register references remain valid.
python · p-sawicki · Mar 18, 2026 · Mar 12, 2026 · Mar 12, 2026 · Mar 12, 2026
commit dedeba66bb666dd1e21709627e2df389cd6f4f79
diff --git a/mypyc/irbuild/builder.py b/mypyc/irbuild/builder.py
@@ -1273,7 +1273,11 @@ def enter_scope(self, fn_info: FuncInfo) -> Iterator[None]:
         so that the closure machinery sees a scope boundary.
         """
         self.builders.append(self.builder)
-        self.symtables.append({})
+        # Copy the parent symtable so variables from the enclosing scope
+        # (e.g. function parameters used as the comprehension iterable)
+        # remain accessible. The comprehension is inlined (same basic blocks
+        # and registers), so the parent's register references are still valid.
+        self.symtables.append(dict(self.symtables[-1]))
         self.runtime_args.append([])
         self.fn_info = fn_info
         self.fn_infos.append(self.fn_info)

diff --git a/mypyc/test-data/run-functions.test b/mypyc/test-data/run-functions.test
@@ -1472,3 +1472,23 @@ assert Foo.A["b"]() == "b"
 def test_generator_with_lambda_default() -> None:
     result = list((lambda i=i: i * 2) for i in range(4))
     assert [f() for f in result] == [0, 2, 4, 6]
+
+[case testLambdaInComprehensionWithParamIterable]
+# Lambda inside comprehension where the iterable is a function parameter.
+# The comprehension scope must be able to read variables from the enclosing
+# function scope (not just the comprehension's own env class).
+from typing import List, Callable
+
+def transform(items: List[int]) -> List[Callable[[], int]]:
+    return [(lambda i=i: i * 2) for i in items]  # type: ignore[misc]
+
+def uses_multiple_params(items: List[str], sep: str) -> List[Callable[[], str]]:
+    return [(lambda s=s: s + sep) for s in items]  # type: ignore[misc]
+
+def test_param_iterable() -> None:
+    funcs = transform([1, 2, 3])
+    assert [f() for f in funcs] == [2, 4, 6]
+
+def test_multiple_params() -> None:
+    funcs = uses_multiple_params(["a", "b"], "!")
+    assert [f() for f in funcs] == ["a!", "b!"]