typechecker: Optimisation for avoiding unneeded assignment to temporaries

Author: robryanx

selfhost/typechecker.jakt

@@ -7316,7 +7316,6 @@ struct Typechecker {
         safety_mode: SafetyMode
     ) throws -> [CheckedStatement] {
         match lhs {
-            // Simple variable assignment
             Var => {
                 let assign_stmt = ParsedStatement::Expression(
                     expr: ParsedExpression::BinaryOp(
@@ -7330,11 +7329,50 @@ struct Typechecker {
                 let checked_assign = .typecheck_statement(assign_stmt, scope_id, safety_mode)
                 return [checked_assign]
             }
-
-            // Nested tuple assignment - handle recursively
             JaktTuple(values) => {
-                // Create a temporary variable for the nested tuple RHS
-                let nested_tmp_name = format("__jakt_nested_tuple_tmp{}", .temp_var_count)
+                // Optimization: If all elements are simple variables, we can
+                // avoid introducing an intermediate temporary and directly index
+                // into the parent tuple expression (chaining IndexedTuple expressions).
+                mut no_nesting = true
+                for v in values {
+                    match v {
+                        Var => {},
+                        else => {
+                            no_nesting = false
+                            break
+                        }
+                    }
+                }
+
+                if no_nesting {
+                    mut direct_assignments: [CheckedStatement] = []
+                    for i in 0..values.size() {
+                        let nested_lhs = values[i]
+                        let nested_rhs = ParsedExpression::IndexedTuple(
+                            expr: rhs,
+                            index: i,
+                            is_optional: false,
+                            span: nested_lhs.span()
+                        )
+
+                        // Build assignment: nested_lhs = rhs.get<i>()
+                        let assign_stmt = ParsedStatement::Expression(
+                            expr: ParsedExpression::BinaryOp(
+                                lhs: nested_lhs,
+                                op: BinaryOperator::Assign,
+                                rhs: nested_rhs,
+                                span: nested_lhs.span()
+                            )
+                            span: nested_lhs.span()
+                        )
+                        let checked_assign = .typecheck_statement(assign_stmt, scope_id, safety_mode)
+                        direct_assignments.push(checked_assign)
+                    }
+                    return direct_assignments
+                }
+
+                // else: introduce an intermediate temporary for the nested tuple RHS
+                let nested_tmp_name = format("__jakt_tuple_assign_tmp{}", .temp_var_count)
                 .temp_var_count++
 
                 let nested_tmp_decl = ParsedVarDecl(
@@ -7372,8 +7410,6 @@ struct Typechecker {
 
                 return nested_assignments
             }
-
-            // Other expressions - not allowed in tuple destructuring
             else => {
                 .error("Left-hand side of tuple assignment must be variables or nested tuples", lhs.span())
                 return []