Cache C for-in iterable expressions

Author: code5717

CHANGELOG.md

@@ -52,6 +52,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Fallthrough handling**
   - `fall` now fails closed with a semantic diagnostic, and both backends raise codegen errors if a `FALL` node reaches them.
 
+- **C backend iteration**
+  - `for-in` and indexed `for-in` now cache array/slice iterable expressions before loop lowering so side-effectful iterables are evaluated once.
+
 - **Semantic and preprocessing correctness**
   - `defer` now traverses its parsed `statement` payload in both type checking and semantic validation.
   - `ret` semantic validation now traverses the parser's `value` payload.

MISSING_FEATURES.md

@@ -31,6 +31,7 @@
 17. Local file-based imports now fail closed during semantic analysis instead of swallowing module loading failures.
 18. Zig unsupported expression fallbacks now fail as compiler-side codegen errors instead of generated `@compileError` expressions.
 19. `fall` now fails closed with a semantic error instead of being ignored or reaching backend output.
+20. C backend `for-in` lowering now caches array/slice iterable expressions so side-effectful iterables are evaluated once.
 
 ---
 

RELEASE_READINESS_REVIEW.md

@@ -48,6 +48,8 @@ not factually provable from local tests alone.
   build.
 - GitHub release workflow now creates a draft release for `v*` tags with Python
   package artifacts, docs site archive, and release example artifacts.
+- C backend `for-in` lowering now caches iterable expressions before loop
+  length and element access.
 - GitHub Pages deploy now uses `npm ci` with `site/package-lock.json`.
 - README, SPEC, release docs, status docs, and agent docs describe the same
   release commands.

TODO.md

@@ -25,9 +25,9 @@ These are bugs and schema mismatches in already-implemented features.
   Files: `src/backends/zig.py`
   Notes: unsupported expression nodes now raise `CodegenError` during A7 compilation.
 
-- [ ] Stop C slice/iteration lowering from re-evaluating side-effectful expressions.
+- [x] Stop C slice/iteration lowering from re-evaluating side-effectful expressions.
   Files: `src/backends/c.py`
-  Notes: `for-in` and sub-slice lowering reuse the iterable expression multiple times, duplicating side effects.
+  Notes: `for-in` and indexed `for-in` now cache array/slice iterable expressions in a generated local before loop length and element access.
 
 - [x] Reject non-iterables in `for-in` and indexed `for-in` during type checking.
   Files: `src/passes/type_checker.py`

src/backends/c.py

@@ -776,12 +776,19 @@ def _visit_for_in(self, node: ASTNode) -> None:
 
         iterable_expr = self._emit_expr(node.iterable)
         iterable_type = self._type_map.get(id(node.iterable)) if node.iterable else None
+        cache_name = self._unique_name("__a7_iter")
+        cache_type = self._iterable_cache_type(iterable_type)
         elem_type = self._iterable_element_type(iterable_type)
-        length_expr = self._iterable_length_expr(node.iterable, iterable_expr, iterable_type)
+        length_expr = self._iterable_length_expr(node.iterable, cache_name, iterable_type)
 
         idx_name = self._unique_name("__a7_i")
         iter_name = self._sanitize_name(node.iterator or "item")
 
+        self._write_indent()
+        self.output.write("{\n")
+        self.indent()
+        self._write_indent()
+        self.output.write(f"{cache_type} {cache_name} = {iterable_expr};\n")
         self._write_indent()
         self.output.write(
             f"for (size_t {idx_name} = 0; {idx_name} < {length_expr}; ++{idx_name}) "
@@ -791,7 +798,7 @@ def _visit_for_in(self, node: ASTNode) -> None:
         self._defer_scopes.append([])
         self._write_indent()
         self.output.write(
-            f"{elem_type} {iter_name} = {self._emit_iterable_element_expr(node.iterable, iterable_expr, iterable_type, idx_name)};\n"
+            f"{elem_type} {iter_name} = {self._emit_iterable_element_expr(node.iterable, cache_name, iterable_type, idx_name)};\n"
         )
 
         marker = len(self._defer_scopes) - 1
@@ -808,6 +815,9 @@ def _visit_for_in(self, node: ASTNode) -> None:
         self.dedent()
         self._write_indent()
         self.output.write("}\n")
+        self.dedent()
+        self._write_indent()
+        self.output.write("}\n")
 
     def _visit_for_in_indexed(self, node: ASTNode) -> None:
         if node.label:
@@ -816,13 +826,20 @@ def _visit_for_in_indexed(self, node: ASTNode) -> None:
 
         iterable_expr = self._emit_expr(node.iterable)
         iterable_type = self._type_map.get(id(node.iterable)) if node.iterable else None
+        cache_name = self._unique_name("__a7_iter")
+        cache_type = self._iterable_cache_type(iterable_type)
         elem_type = self._iterable_element_type(iterable_type)
-        length_expr = self._iterable_length_expr(node.iterable, iterable_expr, iterable_type)
+        length_expr = self._iterable_length_expr(node.iterable, cache_name, iterable_type)
 
         idx_name = self._unique_name("__a7_i")
         index_var = self._sanitize_name(node.index_var or "index")
         iter_name = self._sanitize_name(node.iterator or "item")
 
+        self._write_indent()
+        self.output.write("{\n")
+        self.indent()
+        self._write_indent()
+        self.output.write(f"{cache_type} {cache_name} = {iterable_expr};\n")
         self._write_indent()
         self.output.write(
             f"for (size_t {idx_name} = 0; {idx_name} < {length_expr}; ++{idx_name}) "
@@ -834,7 +851,7 @@ def _visit_for_in_indexed(self, node: ASTNode) -> None:
         self.output.write(f"size_t {index_var} = {idx_name};\n")
         self._write_indent()
         self.output.write(
-            f"{elem_type} {iter_name} = {self._emit_iterable_element_expr(node.iterable, iterable_expr, iterable_type, idx_name)};\n"
+            f"{elem_type} {iter_name} = {self._emit_iterable_element_expr(node.iterable, cache_name, iterable_type, idx_name)};\n"
         )
 
         marker = len(self._defer_scopes) - 1
@@ -851,6 +868,9 @@ def _visit_for_in_indexed(self, node: ASTNode) -> None:
         self.dedent()
         self._write_indent()
         self.output.write("}\n")
+        self.dedent()
+        self._write_indent()
+        self.output.write("}\n")
 
     def _visit_match(self, node: ASTNode) -> None:
         expr = self._emit_expr(node.expression) if node.expression else "0"
@@ -1720,14 +1740,18 @@ def _visit_labeled_for_in(self, node: ASTNode, *, indexed: bool) -> None:
         idx_name = self._unique_name("__a7_i")
         iterable_expr = self._emit_expr(node.iterable)
         iterable_type = self._type_map.get(id(node.iterable)) if node.iterable else None
+        cache_name = self._unique_name("__a7_iter")
+        cache_type = self._iterable_cache_type(iterable_type)
         elem_type = self._iterable_element_type(iterable_type)
-        length_expr = self._iterable_length_expr(node.iterable, iterable_expr, iterable_type)
+        length_expr = self._iterable_length_expr(node.iterable, cache_name, iterable_type)
         iter_name = self._sanitize_name(node.iterator or "item")
 
         self._write_indent()
         self.output.write("{\n")
         self.indent()
         self._write_indent()
+        self.output.write(f"{cache_type} {cache_name} = {iterable_expr};\n")
+        self._write_indent()
         self.output.write(f"size_t {idx_name} = 0;\n")
         self._write_indent()
         self.output.write(f"{cond_label}:\n")
@@ -1743,7 +1767,7 @@ def _visit_labeled_for_in(self, node: ASTNode, *, indexed: bool) -> None:
             self.output.write(f"size_t {index_var} = {idx_name};\n")
         self._write_indent()
         self.output.write(
-            f"{elem_type} {iter_name} = {self._emit_iterable_element_expr(node.iterable, iterable_expr, iterable_type, idx_name)};\n"
+            f"{elem_type} {iter_name} = {self._emit_iterable_element_expr(node.iterable, cache_name, iterable_type, idx_name)};\n"
         )
         marker = len(self._defer_scopes) - 1
         self._push_loop_frame(
@@ -1836,6 +1860,17 @@ def _emit_iterable_element_expr(
             return f"({iterable_expr}).data[{idx_name}]"
         return f"{iterable_expr}[{idx_name}]"
 
+    def _iterable_cache_type(self, iterable_type) -> str:
+        if isinstance(iterable_type, SliceType):
+            return self._semantic_type_to_c(iterable_type) or "void*"
+        if isinstance(iterable_type, ArrayType):
+            elem = self._semantic_type_to_c(iterable_type.element_type) or "int32_t"
+            return f"{elem}*"
+        raise CodegenError(
+            "C backend: for-in iteration currently requires an array or slice value",
+            None,
+        )
+
     def _iterable_element_type(self, iterable_type) -> str:
         if isinstance(iterable_type, ArrayType):
             return self._semantic_type_to_c(iterable_type.element_type) or "int32_t"

test/test_codegen_c.py

@@ -161,6 +161,35 @@ def test_generated_c_supports_slice_expr_index_and_for_in(tmp_path: Path) -> Non
     assert result.stdout.strip() == "11 12"
 
 
+@pytest.mark.skipif(not has_zig(), reason="zig not installed")
+def test_generated_c_for_in_caches_side_effectful_slice_iterable(tmp_path: Path) -> None:
+    result = build_and_run_c(
+        """
+io :: import "std/io"
+
+calls := 0
+
+make_tail :: fn(arr: [4]i32) []i32 {
+    calls += 1
+    ret arr[1..4]
+}
+
+main :: fn() {
+    arr: [4]i32 = [1, 2, 3, 4]
+    total := 0
+    for x in make_tail(arr) {
+        total += x
+    }
+    io.println("{} {}", total, calls)
+}
+""",
+        tmp_path,
+    )
+
+    assert result.returncode == 0, result.stdout + result.stderr
+    assert result.stdout.strip() == "9 1"
+
+
 @pytest.mark.skipif(not has_zig(), reason="zig not installed")
 def test_generated_c_honors_labeled_break_and_continue(tmp_path: Path) -> None:
     result = build_and_run_c(