transpiler: materialize local new_const consts via factories

Author: shuaimu

TODO.md

@@ -1209,7 +1209,23 @@ Work on tasks defined in TODO.md. Repeat the following steps, don’t stop until
                                 - `tests/transpile_tests/run_parity_matrix.sh --work-root /tmp/rusty-parity-matrix-27-10-2-1775515714 --keep-work-dirs`
                               - [x] *done* Guardrail check against wrong-approach section (`docs/rusty-cpp-transpiler.md` §11): maintained deterministic first-head discipline, recorded canonical matrix artifacts before opening the next implementation leaf, and avoided crate-specific rewrites/scripts.
                           - [ ] Leaf 4.15.4.3.3.3.3.3.27.11: Collapse the post-27.10.2 deterministic Stage D constexpr constructor/template family generically (starting with `ArrayVec<rusty::Vec<uint8_t>, 10>::new_const()` literal-type/copy fallout rooted at `runner.cpp:4293`), add fixture-agnostic regressions, then re-run full seven-crate matrix.
-                            - [ ] Leaf 4.15.4.3.3.3.3.3.27.11.1: Implement generic transpiler/runtime fixes for the first deterministic 27.10.2 head (no crate-specific scripts): align const-constructor/literal-surface lowering so non-literal container types are not forced into invalid `constexpr` materialization patterns while preserving valid const-generic behavior.
+                            - [x] *done* Leaf 4.15.4.3.3.3.3.3.27.11.1: Implement generic transpiler/runtime fixes for the first deterministic 27.10.2 head (no crate-specific scripts): align const-constructor/literal-surface lowering so non-literal container types are not forced into invalid `constexpr` materialization patterns while preserving valid const-generic behavior.
+                              - [x] *done* Scope/plan analysis for 27.11.1:
+                                - implementation size stayed under the <1000 LOC budget (small, shape-gated transpiler lowering + focused regressions), so no additional leaf decomposition was needed.
+                              - [x] *done* Implemented generic const-constructor materialization fix in `transpiler/src/codegen.rs`:
+                                - for block-local `const` items initialized by zero-arg `new_const()` constructor calls, emit factory-form local constants (`const auto NAME = []() -> Ty { return Ty::new_const(); };`) and lower path uses to `NAME()` so each use materializes a fresh value.
+                                - this avoids invalid C++ `constexpr` object requirements and const-lvalue copy constraints on non-literal/non-copyable payload types without introducing crate-specific rewrites.
+                              - [x] *done* Added focused fixture-agnostic transpiler regressions in `transpiler/src/codegen.rs`:
+                                - `test_leaf41543333333327111_local_new_const_uses_factory_materialization`
+                                - `test_leaf41543333333327111_local_scalar_const_stays_constexpr`
+                              - [x] *done* Re-probed `arrayvec` parity after 27.11.1 (`tests/transpile_tests/run_parity_matrix.sh --crate arrayvec --work-root /tmp/rusty-parity-matrix-27-11-1-1775516598 --keep-work-dirs`):
+                                - prior deterministic first hard error family at `runner.cpp:4293` (`constexpr ArrayVec<rusty::Vec<uint8_t>, 10> OF_U8 = ...::new_const()` literal/copy fallout) is removed from the first slot.
+                                - new deterministic Stage D first hard error now starts at `runner.cpp:4317` (`cannot convert Vec<int> to Vec<unsigned char>` in `test_arrayvec_const_constructible`), with adjacent downstream diagnostics continuing after that head.
+                                - canonical artifacts: `/tmp/rusty-parity-matrix-27-11-1-1775516598/arrayvec/{baseline.txt,build.log,run.log,matrix.log}`.
+                              - [x] *done* Verification for 27.11.1:
+                                - `cargo test -p rusty-cpp-transpiler`
+                                - `tests/transpile_tests/run_parity_matrix.sh --crate arrayvec --work-root /tmp/rusty-parity-matrix-27-11-1-1775516598 --keep-work-dirs`
+                              - [x] *done* Guardrail check against wrong-approach section (`docs/rusty-cpp-transpiler.md` §11): maintained deterministic first-head discipline, used shared AST-aware shape-gated lowering (no text patching / no blanket rewrites), and avoided crate-specific scripts.
                             - [ ] Leaf 4.15.4.3.3.3.3.3.27.11.2: Re-run full seven-crate parity matrix after 27.11.1, record first deterministic failure head with canonical artifacts, and update active-frontier docs/TODO status (or mark Leaf 4 complete if all seven pass).
       - [ ] Leaf 5: Verification matrix (required)
         - [x] *done* Add an integration parity matrix test that runs `parity-test --stop-after run` for `either`, `tap`, `cfg-if`, `take_mut`, `arrayvec`, `semver`, and `bitflags`

docs/rusty-cpp-transpiler.md

@@ -2439,8 +2439,22 @@ Active work items:
    - verification:
      - `tests/transpile_tests/run_parity_matrix.sh --work-root /tmp/rusty-parity-matrix-27-10-2-1775515714 --keep-work-dirs`
    - guardrail check against wrong-approach checklist (§11): maintained deterministic first-head discipline, recorded canonical matrix artifacts before opening the next implementation leaf, and introduced no crate-specific rewrites.
-52. Current active next leaf is `Leaf 4.15.4.3.3.3.3.3.27.11.1`.
-   - focus: collapse the new post-27.10.2 first deterministic constexpr constructor/template head generically, then verify matrix-head movement.
+52. `Leaf 4.15.4.3.3.3.3.3.27.11.1` is complete.
+   - plan/scope check: fix stays under the small-change budget (<1000 LOC), so no extra leaf decomposition was needed.
+   - implemented generic local const-constructor materialization hardening in `transpiler/src/codegen.rs`:
+     - added shape-gated local-const detection for zero-arg `new_const()` constructor calls inside block scope,
+     - such local consts now emit as factory-form locals (`const auto NAME = []() -> Ty { return Ty::new_const(); };`) and path uses lower to `NAME()` to materialize fresh values per use.
+   - added fixture-agnostic transpiler regressions:
+     - `test_leaf41543333333327111_local_new_const_uses_factory_materialization`
+     - `test_leaf41543333333327111_local_scalar_const_stays_constexpr`
+   - single-crate reprobe (`tests/transpile_tests/run_parity_matrix.sh --crate arrayvec --work-root /tmp/rusty-parity-matrix-27-11-1-1775516598 --keep-work-dirs`) removed the prior deterministic first hard error at `runner.cpp:4293` (`constexpr ArrayVec<rusty::Vec<uint8_t>, 10> OF_U8 = ...::new_const()` non-literal/copy fallout).
+   - new deterministic first hard error now starts at `runner.cpp:4317` (`cannot convert Vec<int> to Vec<unsigned char>` in `test_arrayvec_const_constructible`), with canonical artifacts at `/tmp/rusty-parity-matrix-27-11-1-1775516598/arrayvec/{baseline.txt,build.log,run.log,matrix.log}`.
+   - verification:
+     - `cargo test -p rusty-cpp-transpiler`
+     - `tests/transpile_tests/run_parity_matrix.sh --crate arrayvec --work-root /tmp/rusty-parity-matrix-27-11-1-1775516598 --keep-work-dirs`
+   - guardrail check against wrong-approach checklist (§11): maintained deterministic first-head discipline, used shared AST-aware shape-gated lowering (no text patching / no blanket rewrites), and introduced no crate-specific scripts.
+53. Current active next leaf is `Leaf 4.15.4.3.3.3.3.3.27.11.2`.
+   - focus: re-run full seven-crate parity matrix after 27.11.1 and capture the next deterministic frontier (or close Leaf 4 if all pass).
 
 ### 10.7 Parity Harness and Matrix Command Reference
 

transpiler/src/codegen.rs

@@ -2943,6 +2943,26 @@ impl CodeGen {
         }
     }
 
+    fn is_local_new_const_constructor_call(&self, expr: &syn::Expr) -> bool {
+        if self.block_depth == 0 {
+            return false;
+        }
+        let syn::Expr::Call(call) = self.peel_paren_group_expr(expr) else {
+            return false;
+        };
+        if !call.args.is_empty() {
+            return false;
+        }
+        let syn::Expr::Path(path_expr) = self.peel_paren_group_expr(call.func.as_ref()) else {
+            return false;
+        };
+        path_expr
+            .path
+            .segments
+            .last()
+            .is_some_and(|seg| seg.ident == "new_const")
+    }
+
     fn emit_const(&mut self, c: &syn::ItemConst) {
         if self.is_rust_libtest_metadata_type(&c.ty) {
             let marker =
@@ -2954,6 +2974,25 @@ impl CodeGen {
             ));
             return;
         }
+        if self.is_local_new_const_constructor_call(&c.expr) {
+            let rust_name = c.ident.to_string();
+            let cpp_name = self.allocate_local_cpp_name(&rust_name);
+            self.register_local_binding(rust_name.clone(), Some((*c.ty).clone()));
+            self.record_local_const_binding(&rust_name, false);
+
+            let ty = self.map_type(&c.ty);
+            let expr = self.emit_expr_to_string_with_expected(&c.expr, Some(&c.ty));
+            self.writeln(&format!("const auto {} = []() -> {} {{", cpp_name, ty));
+            self.indent += 1;
+            self.writeln(&format!("return {};", expr));
+            self.indent -= 1;
+            self.writeln("};");
+
+            if let Some(scope) = self.local_cpp_bindings.last_mut() {
+                scope.insert(rust_name, format!("{}()", cpp_name));
+            }
+            return;
+        }
         let name = &c.ident;
         let ty = self.map_type(&c.ty);
         let expr = self.emit_expr_to_string_with_expected(&c.expr, Some(&c.ty));
@@ -17740,6 +17779,35 @@ mod tests {
         assert!(out.contains("constexpr int32_t MAX = 100;"));
     }
 
+    #[test]
+    fn test_leaf41543333333327111_local_new_const_uses_factory_materialization() {
+        let out = transpile_str(
+            r#"
+            fn f() {
+                const OF_U8: ArrayVec<Vec<u8>, 10> = ArrayVec::new_const();
+                let mut var = OF_U8;
+                var.push(Vec::new());
+            }
+            "#,
+        );
+        assert!(out.contains("const auto OF_U8 = []() -> ArrayVec<rusty::Vec<uint8_t>, 10> {"));
+        assert!(out.contains("auto var = OF_U8();"));
+        assert!(!out.contains("constexpr ArrayVec<rusty::Vec<uint8_t>, 10> OF_U8"));
+    }
+
+    #[test]
+    fn test_leaf41543333333327111_local_scalar_const_stays_constexpr() {
+        let out = transpile_str(
+            r#"
+            fn f() {
+                const N: usize = 4;
+                let _x = N;
+            }
+            "#,
+        );
+        assert!(out.contains("constexpr size_t N = 4;"));
+    }
+
     #[test]
     fn test_c_like_enum() {
         let out = transpile_str("enum Color { Red, Green, Blue }");