fix(codegen): emit faithful Rust/C, don't run t27c optimizer on source backends (#1455)

t27c's AST optimizer corrupts the SOURCE-LEVEL output of the Rust and C
backends: a reassigned mutable local (`var x = 0; ... x = a;`) loses its
declaration while its uses remain (E0425), and `let` locals are const-inlined.
This is the 2609-site E0425 wave observed downstream in gHashTag/tri-net.

Root cause: compile_rust / compile_c ran `optimize(&mut ast, default)` (const
prop + the unconditional copy-prop / dead-store passes) before emitting SOURCE
code. Those passes are meant for a lowering target, not for human/rustc-facing
source; rustc and the C compiler optimize the emitted code far more reliably.

Fix: drop the `optimize()` call from compile_rust and compile_c and emit
faithfully from the parsed AST. Verilog/Zig keep their own pipelines.

Effect on the test suite (was 1491 passed / 3 failed at HEAD):
- test_let_binding_emitted_rust_1401  now PASSES (was failing)
- test_let_binding_emitted_c_1401     now PASSES (was failing)
- new test_two_reassigned_locals_survive_1455  PASSES
- 1494 passed / 1 failed; the remaining failure (let_binding_is_lowered_1401,
  Verilog HIR path, does not call optimize) is pre-existing and untouched here.

Downstream (gHashTag/tri-net): regenerating gen/rust with this t27c drops the
E0425 wave from 2609 to 0; residual errors there are separate codegen bugs
(bare `Vec<>` without a generic arg, a few type mismatches) tracked separately.

FROZEN_HASH re-sealed (M5) for the compiler.rs change.

phi^2 + phi^-2 = 3

Author: deborahnelson8788726

bootstrap/src/compiler.rs

@@ -6183,8 +6183,10 @@ impl Compiler {
     pub fn compile_c(source: &str) -> Result<String, String> {
         let lexer = Lexer::new(source);
         let mut parser = Parser::new(lexer);
-        let mut ast = parser.parse()?;
-        optimize(&mut ast, &OptConfig::default());
+        let ast = parser.parse()?;
+        // Emit FAITHFUL C from the AST; the C compiler optimizes downstream. See
+        // the note on compile_rust: t27c's optimizer drops reassigned locals and
+        // const-inlines `let`, corrupting the source-level output. Fixes #1455.
         let mut codegen = CCodegen::new();
         codegen.gen_c(&ast);
         Ok(codegen.into_string())
@@ -6193,8 +6195,15 @@ impl Compiler {
     pub fn compile_rust(source: &str) -> Result<String, String> {
         let lexer = Lexer::new(source);
         let mut parser = Parser::new(lexer);
-        let mut ast = parser.parse()?;
-        optimize(&mut ast, &OptConfig::default());
+        let ast = parser.parse()?;
+        // Emit FAITHFUL Rust from the AST. Do NOT run t27c's own optimizer on the
+        // Rust backend: several of its passes (const-propagation and the
+        // unconditional copy-propagation / dead-store passes) corrupt a
+        // reassigned mutable local -- e.g. `var x = 0; ... x = a;` loses its
+        // declaration while its uses remain, producing E0425. rustc/LLVM optimize
+        // the emitted code far more reliably, so faithful codegen is both correct
+        // and sufficient here. Verilog/Zig/C backends keep their own pipelines.
+        // Fixes gHashTag/t27#1455.
         let mut codegen = RustCodegen::new();
         codegen.gen_rust(&ast);
         Ok(codegen.into_string())
@@ -22530,6 +22539,21 @@ mod tests_phase40_coverage {
         );
     }
 
+    // #1455 regression: two consecutive reassigned locals must BOTH survive.
+    // The optimizer used to drop the first declaration (and const-inline `let`),
+    // leaving `x` undeclared while its uses remained (E0425). Faithful codegen
+    // on the Rust backend emits both `let mut` bindings.
+    #[test]
+    fn test_two_reassigned_locals_survive_1455() {
+        let code = "module M { pub fn f(a: u32) -> u32 { var x = 0; var y = 1; if (a > x) { x = a; y = 2; } return y; } }";
+        let out = Compiler::compile_rust(code).expect("compile should succeed");
+        assert!(
+            out.contains("let mut x = 0") && out.contains("let mut y = 1"),
+            "a reassigned local was dropped from Rust output: {}",
+            out
+        );
+    }
+
     // #1401 regression (C emitter shares the same lexer/parser root cause):
     // the `let` local must appear as a typed C declaration.
     #[test]

bootstrap/stage0/FROZEN_HASH

@@ -1 +1 @@
-197d6eb5a40bed62ae806cb09c14fbde4d2664ed7cc6991c1e3bfa60983706ff  bootstrap/src/compiler.rs
+6eb632b838e907f160934965972f408839d8bb2916e0447c0c1bade5bda98b18  bootstrap/src/compiler.rs