transpiler: fix let ref mut rvalue binding to emit owned value

When `let ref mut x = rvalue_expr;` binds a mutable reference to an
rvalue (like String::new()), emit `auto x = rvalue_expr;` (owned value)
instead of `auto& x = rvalue_expr;` (dangling reference to temporary).

Add is_rvalue_expr() helper that detects function calls, literals,
struct constructors, and other rvalue expressions. The ref_suffix
is suppressed when by_ref + mut + rvalue init.

Semver parity: 64 → 63 errors (1 fewer). Full matrix: 5/6 pass.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: shuaimu

TODO.md

@@ -2078,7 +2078,7 @@ Work on tasks defined in TODO.md. Repeat the following steps, don’t stop until
                                 - `cd /tmp/rusty-parity-matrix-27-45-2-20260407-1/arrayvec && timeout 30s ./runner --rusty-single-test rusty_test_test_retain`
                                 - `cd /tmp/rusty-parity-matrix-27-45-2-20260407-1/arrayvec && gdb -q ./runner -ex 'set args --rusty-single-test rusty_test_test_retain' -ex run -ex bt -ex quit`
                               - [x] *done* Guardrail check against wrong-approach section (`docs/rusty-cpp-transpiler.md` §11): maintained deterministic first-head + canonical-artifact workflow, kept fixes in shared transpiler/runtime surfaces, and introduced no crate-specific rewrites/scripts.
-                          - [ ] Leaf 4.15.4.4: Priority pivot (2026-04-07): close current `semver` and `bitflags` Stage D heads. **Status (2026-04-08)**: semver 437→64 (85% reduction), bitflags 951→433 (54% reduction). Arrayvec reached 51/51 (100%). Overall: **5/7 crates pass**.
+                          - [ ] Leaf 4.15.4.4: Priority pivot (2026-04-07): close current `semver` and `bitflags` Stage D heads. **Status (2026-04-08)**: semver 437→63 (86% reduction), bitflags 951→433 (54% reduction). Arrayvec reached 51/51 (100%). Overall: **5/7 crates pass**.
                             - [x] *done* Leaf 4.15.4.4.1: Collapse current `semver` Stage D formatter/runtime/type-surface head generically (starting with `std::move_only_function` unavailability and unresolved `NonNull` type surfaces), add fixture-agnostic regressions, then re-run `semver` parity.
                               - [x] *done* Plan/scope check: shared transpiler/runtime updates stayed well below the <1000 LOC guardrail and required no additional TODO decomposition.
                               - [x] *done* Implemented shared fixes (no crate-specific scripts):
@@ -2500,6 +2500,10 @@ Work on tasks defined in TODO.md. Repeat the following steps, don’t stop until
                               - [x] *done* Reordered `emit_file` to emit `ExternCrate` items before `emit_item_forward_decls`. This ensures forward declarations (like `namespace util { ... }` and `void test_*();`) appear AFTER `// extern crate` markers in the cppm output, so the parity runner's prelude-skip logic doesn't accidentally skip them.
                               - [x] *done* Semver errors: 75 → 64 (11 fewer, 15% reduction); eliminated all `prerelease`/`prerelease_err`/`build_metadata`/`assert_to_string`/`util` undeclared scope errors from the test_identifier target.
                               - [x] *done* Full matrix: 5/6 pass (either ✅, tap ✅, cfg-if ✅, take_mut ✅, arrayvec ✅); no regressions.
+                            - [x] *done* Leaf 4.15.4.4.55: Fix `let ref mut` rvalue binding to emit owned value instead of reference.
+                              - [x] *done* `let ref mut x = rvalue_expr;` now emits `auto x = rvalue_expr;` (owned) instead of `auto& x = rvalue_expr;` (dangling ref to temporary). Added `is_rvalue_expr()` helper for detection.
+                              - [x] *done* Semver errors: 64 → 63 (1 fewer); eliminated `cannot bind non-const lvalue reference to rvalue` error from `let ref mut string = String::new()`.
+                              - [x] *done* Full matrix: 5/6 pass; no regressions.
                           - [ ] Leaf 4.15.4.3.3.3.3.3.27.46: [Deferred by 4.15.4.4 priority pivot] Collapse the post-27.45.2 deterministic Stage E `test_retain` assertion-abort family generically (starting with abort immediately after `test_pop_at PASSED`, next scheduled wrapper `rusty_test_test_retain` at `runner.cpp:4840`, and failing assertion surface in `test_retain` at `runner.cpp:3133-3136`), add fixture-agnostic regressions, then re-run full seven-crate matrix.
                             - [x] *done* Leaf 4.15.4.3.3.3.3.3.27.46.1: Fix `as_mut_ptr()` type inference fallback: use current scope's type parameter (e.g., `T`) instead of `u8` when pointee type can't be recovered from receiver context. Fixes `retain` function using `uint8_t*` arithmetic instead of `T*`, causing wrong element stride and assertion failure.
                               - [x] *done* Arrayvec: `test_retain` now PASSES. 37/37 discovered-and-reached tests pass. Remaining 14 undiscovered tests crash from `free(): double free` during expected-panic exception unwinding (separate issue).

transpiler/src/codegen.rs

@@ -8497,8 +8497,21 @@ impl CodeGen {
                     || inferred_binding_ty
                         .as_ref()
                         .is_some_and(|ty| Self::is_mut_raw_pointer_type(ty));
-                // `let ref r = expr` → `const auto& r = expr;` (reference binding)
-                let ref_suffix = if pat_ident.by_ref.is_some() { "&" } else { "" };
+                // `let ref r = expr` → `const auto& r = expr;` (reference binding).
+                // Exception: `let ref mut r = rvalue_expr;` — when the init is
+                // an rvalue (e.g., function call), binding a mutable reference
+                // to it is invalid in C++. Emit as owned value instead.
+                let ref_suffix = if pat_ident.by_ref.is_some()
+                    && !(is_mut
+                        && local
+                            .init
+                            .as_ref()
+                            .is_some_and(|init| self.is_rvalue_expr(&init.expr)))
+                {
+                    "&"
+                } else {
+                    ""
+                };
                 let decl_type = if qualifier == "const " && mut_raw_ptr_binding && type_str.contains('*')
                 {
                     format!("{} const", type_str)
@@ -18354,6 +18367,26 @@ impl CodeGen {
         matches!(expr, syn::Expr::Reference(_))
     }
 
+    /// Check if an expression is an rvalue (temporary/function-call result)
+    /// rather than an lvalue (variable/field access).
+    fn is_rvalue_expr(&self, expr: &syn::Expr) -> bool {
+        matches!(
+            expr,
+            syn::Expr::Call(_)
+                | syn::Expr::MethodCall(_)
+                | syn::Expr::Lit(_)
+                | syn::Expr::Struct(_)
+                | syn::Expr::Tuple(_)
+                | syn::Expr::Array(_)
+                | syn::Expr::Binary(_)
+                | syn::Expr::Unary(_)
+                | syn::Expr::If(_)
+                | syn::Expr::Match(_)
+                | syn::Expr::Block(_)
+                | syn::Expr::Closure(_)
+        )
+    }
+
     /// Extract the inner expression from a reference expression, as a string.
     fn extract_ref_inner(&self, expr: &syn::Expr) -> String {
         if let syn::Expr::Reference(r) = expr {
@@ -32495,4 +32528,28 @@ mod tests {
             "should not have constexpr self-referential const inside struct\nGot: {out}"
         );
     }
+
+    #[test]
+    fn test_leaf4154455_ref_mut_rvalue_emits_owned_local() {
+        // `let ref mut string = String::new();` should emit an owned local,
+        // not a reference to a temporary.
+        let out = transpile_str(
+            r#"
+            fn f() {
+                let ref mut string = String::new();
+                string.push('x');
+            }
+            "#,
+        );
+        // Should NOT contain `auto& string = ` (reference to temporary)
+        assert!(
+            !out.contains("auto& string"),
+            "ref mut binding to rvalue should emit owned local, not reference\nGot: {out}"
+        );
+        // Should contain `auto string = ` (owned value)
+        assert!(
+            out.contains("auto string"),
+            "ref mut binding to rvalue should emit 'auto string ='\nGot: {out}"
+        );
+    }
 }