fix(codegen): DEPYLER-1168/1169 Call-Site Clone + Index Assignment

DEPYLER-1168: Call-Site Borrowing Heuristic
- Fixes E0382 "use of moved value" when variable passed to ownership-taking
  function is used again later in the same scope
- Added vars_used_later tracking to CodeGenContext
- Populate during statement iteration in func_gen.rs
- Insert .clone() at call site when variable is reused
- Hero example: normalize_data(dataset.clone()) preserves dataset

DEPYLER-1169: List Index Assignment
- Fixed list[i] = x generating vec.insert(i, x) instead of vec[i] = x
- insert() adds NEW element (shifts others), causing infinite growth
- Changed to proper index operator assignment
- Fixes bubble sort hang in data_analysis_combined

Verification:
- data_analysis_combined.py compiles and runs to completion
- Output: Mean, StdDev, Percentiles, Monte Carlo simulation
- Compile rate: 40.6% (130/320 files)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: noahgift

crates/depyler-core/src/cargo_toml_gen.rs

@@ -554,6 +554,7 @@ mod tests {
             type_query: None, // DEPYLER-1112
             last_external_call_return_type: None, // DEPYLER-1113
             type_overrides: std::collections::HashMap::new(), // DEPYLER-1101
+            vars_used_later: std::collections::HashSet::new(), // DEPYLER-1168
         };
 
         // Property: Calling extract_dependencies multiple times returns same result
@@ -723,6 +724,7 @@ mod tests {
             type_query: None, // DEPYLER-1112
             last_external_call_return_type: None, // DEPYLER-1113
             type_overrides: std::collections::HashMap::new(), // DEPYLER-1101
+            vars_used_later: std::collections::HashSet::new(), // DEPYLER-1168
         };
 
         let deps = extract_dependencies(&ctx);
@@ -889,6 +891,7 @@ mod tests {
             type_query: None, // DEPYLER-1112
             last_external_call_return_type: None, // DEPYLER-1113
             type_overrides: std::collections::HashMap::new(), // DEPYLER-1101
+            vars_used_later: std::collections::HashSet::new(), // DEPYLER-1168
         };
 
         let deps = extract_dependencies(&ctx);
@@ -1302,6 +1305,7 @@ mod tests {
             type_query: None, // DEPYLER-1112
             last_external_call_return_type: None, // DEPYLER-1113
             type_overrides: std::collections::HashMap::new(), // DEPYLER-1101
+            vars_used_later: std::collections::HashSet::new(), // DEPYLER-1168
         };
 
         let deps = extract_dependencies(&ctx);

crates/depyler-core/src/rust_gen.rs

@@ -2367,6 +2367,7 @@ fn generate_rust_file_internal(
         type_query: load_type_database(), // DEPYLER-1114: Auto-load Sovereign Type Database
         last_external_call_return_type: None, // DEPYLER-1113: External call return type
         type_overrides: HashMap::new(), // DEPYLER-1101: Oracle-learned type overrides
+        vars_used_later: HashSet::new(), // DEPYLER-1168: Call-site clone detection
     };
 
     // DEPYLER-1137: Enable DepylerValue enum when module aliases are present
@@ -5695,6 +5696,7 @@ mod tests {
             type_query: None, // DEPYLER-1112
             last_external_call_return_type: None, // DEPYLER-1113
             type_overrides: HashMap::new(), // DEPYLER-1101: Oracle-learned type overrides
+            vars_used_later: HashSet::new(), // DEPYLER-1168: Call-site clone detection
         }
     }
 

crates/depyler-core/src/rust_gen/context.rs

@@ -384,6 +384,12 @@ pub struct CodeGenContext<'a> {
     /// Maps variable name -> correct Type. Overrides inferred types during codegen.
     /// Populated by repair_file_types() in utol.rs via transpile_with_constraints().
     pub type_overrides: HashMap<String, Type>,
+
+    /// DEPYLER-1168: Track variables that are used after the current statement
+    /// When a function takes ownership of a parameter and the argument variable is used
+    /// later in the same scope, we need to insert .clone() at the call site.
+    /// Populated during statement iteration in stmt_gen.rs.
+    pub vars_used_later: HashSet<String>,
 }
 
 impl<'a> CodeGenContext<'a> {
@@ -781,6 +787,7 @@ pub mod test_helpers {
             type_query: None, // DEPYLER-1112
             last_external_call_return_type: None, // DEPYLER-1113
             type_overrides: HashMap::new(), // DEPYLER-1101
+            vars_used_later: HashSet::new(), // DEPYLER-1168
         }
     }
 }

crates/depyler-core/src/rust_gen/expr_gen.rs

@@ -4779,6 +4779,27 @@ impl<'a, 'b> ExpressionConverter<'a, 'b> {
                             }
                         }
 
+                        // DEPYLER-1168: Call-site clone insertion for variables used later
+                        // When a function takes ownership (doesn't borrow) and the argument
+                        // variable is used again later in the same scope, we need to clone it.
+                        // This prevents E0382 "use of moved value" errors.
+                        if let HirExpr::Var(var_name) = hir_arg {
+                            // Only clone if:
+                            // 1. Variable is used later in the same scope
+                            // 2. Variable type is clonable (List, Dict, Set, String, Custom types)
+                            let used_later = self.ctx.vars_used_later.contains(var_name);
+                            let is_clonable_type = self.ctx.var_types.get(var_name)
+                                .map(|ty| matches!(ty,
+                                    Type::List(_) | Type::Dict(_, _) | Type::Set(_) |
+                                    Type::String | Type::Tuple(_) | Type::Custom(_)
+                                ))
+                                .unwrap_or(false);
+
+                            if used_later && is_clonable_type {
+                                return parse_quote! { #arg_expr.clone() };
+                            }
+                        }
+
                         arg_expr.clone()
                     }
                 })

crates/depyler-core/src/rust_gen/func_gen.rs

@@ -800,6 +800,17 @@ pub(crate) fn codegen_function_body(
         // Mark final statement for idiomatic expression-based return
         // (only if it's not a FunctionDef, as those are assignments not returns)
         ctx.is_final_statement = i == body_len - 1 && !matches!(stmt, HirStmt::FunctionDef { .. });
+
+        // DEPYLER-1168: Populate vars_used_later for call-site clone detection
+        // Before processing each statement, compute which variables are used in remaining statements
+        ctx.vars_used_later.clear();
+        let remaining_stmts = &func.body[i + 1..];
+        for var_name in ctx.var_types.keys() {
+            if is_var_used_in_remaining_stmts(var_name, remaining_stmts) {
+                ctx.vars_used_later.insert(var_name.clone());
+            }
+        }
+
         let tokens = stmt.to_rust_tokens(ctx)?;
         body_stmts.push(tokens);
     }

crates/depyler-core/src/rust_gen/stmt_gen.rs

@@ -4826,9 +4826,11 @@ pub(crate) fn codegen_assign_index(
     if indices.is_empty() {
         // Simple assignment: d[k] = v OR list[i] = x
         if is_numeric_index {
-            // DEPYLER-0314: Vec.insert(index as usize, value)
-            // Wrap in parentheses to ensure correct operator precedence
-            Ok(quote! { #base_expr.insert((#final_index) as usize, #final_value_expr); })
+            // DEPYLER-1169: List index assignment uses index operator, NOT insert()
+            // Python: list[i] = x → replaces element at index i
+            // Rust: vec[i] = x → replaces element at index i
+            // WRONG: vec.insert(i, x) → inserts NEW element, shifts others (causes bugs!)
+            Ok(quote! { #base_expr[(#final_index) as usize] = #final_value_expr; })
         } else if needs_as_object_mut {
             // DEPYLER-0449: serde_json::Value needs .as_object_mut() for insert
             // DEPYLER-0473: Clone key to avoid move-after-use errors