Reuse variables for record updates

compiler-core/src/ast/typed.rs

···
     RecordUpdate {
         location: SrcSpan,
         type_: Arc<Type>,
-        record: Box<TypedAssignment>,
+        /// If the record is an expression that is not a variable we will need to assign to a
+        /// variable so it can be referred multiple times.
+        record_assignment: Option<Box<TypedAssignment>>,
         constructor: Box<Self>,
         args: Vec<CallArg<Self>>,
     },
···
                 .or_else(|| self.self_if_contains_location(byte_index)),
 
             Self::RecordUpdate {
-                record,
+                record_assignment: record,
                 constructor,
                 args,
                 ..
···
                 .iter()
                 .filter(|arg| arg.implicit.is_none())
                 .find_map(|arg| arg.find_node(byte_index, constructor, args))
-                .or_else(|| record.find_node(byte_index))
+                .or_else(|| record.as_ref().and_then(|r| r.find_node(byte_index)))
                 .or_else(|| self.self_if_contains_location(byte_index)),
         }
     }
···
                 .iter()
                 .find_map(|arg| arg.value.find_statement(byte_index)),
 
-            Self::RecordUpdate { record, args, .. } => args
+            Self::RecordUpdate {
+                record_assignment: record,
+                args,
+                ..
+            } => args
                 .iter()
                 .filter(|arg| arg.implicit.is_none())
                 .find_map(|arg| arg.find_statement(byte_index))
-                .or_else(|| record.value.find_statement(byte_index)),
+                .or_else(|| {
+                    record
+                        .as_ref()
+                        .and_then(|r| r.value.find_statement(byte_index))
+                }),
         }
     }
 

compiler-core/src/ast/visit.rs

···
         &mut self,
         location: &'ast SrcSpan,
         type_: &'ast Arc<Type>,
-        record: &'ast TypedAssignment,
+        record: &'ast Option<Box<TypedAssignment>>,
         constructor: &'ast TypedExpr,
         args: &'ast [TypedCallArg],
     ) {
···
         TypedExpr::RecordUpdate {
             location,
             type_,
-            record,
+            record_assignment: record,
             constructor,
             args,
         } => v.visit_typed_expr_record_update(location, type_, record, constructor, args),
···
     v: &mut V,
     _location: &'a SrcSpan,
     _type: &'a Arc<Type>,
-    record: &'a TypedAssignment,
+    record: &'a Option<Box<TypedAssignment>>,
     constructor: &'a TypedExpr,
     args: &'a [TypedCallArg],
 ) where
     V: Visit<'a> + ?Sized,
 {
     v.visit_typed_expr(constructor);
-    v.visit_typed_assignment(record);
+    if let Some(record) = record {
+        v.visit_typed_assignment(record);
+    }
     for arg in args {
         v.visit_typed_call_arg(arg);
     }

compiler-core/src/erlang.rs

···
 }
 
 fn record_update<'a>(
-    record: &'a TypedAssignment,
+    record: &'a Option<Box<TypedAssignment>>,
     constructor: &'a TypedExpr,
     args: &'a [TypedCallArg],
     env: &mut Env<'a>,
 ) -> Document<'a> {
     let vars = env.current_scope_vars.clone();
 
-    let document = docvec![
-        assignment(record, env, Position::NotTail),
-        ",",
-        line(),
-        call(constructor, args, env)
-    ];
+    let document = match record.as_ref() {
+        Some(record) => docvec![
+            assignment(record, env, Position::NotTail),
+            ",",
+            line(),
+            call(constructor, args, env)
+        ],
+        None => call(constructor, args, env),
+    };
 
     env.current_scope_vars = vars;
 
···
         TypedExpr::RecordAccess { record, index, .. } => tuple_index(record, index + 1, env),
 
         TypedExpr::RecordUpdate {
-            record,
+            record_assignment: record,
             constructor,
             args,
             ..

compiler-core/src/erlang/tests/snapshots/gleam_core__erlang__tests__echo__record_update_printed_by_echo_is_wrapped_in_begin_end_block.snap

···
     Wobble = {wobble, 1, <<"wobble"/utf8>>},
     echo(
         begin
-            _record = Wobble,
-            {wobble, 1, erlang:element(3, _record)}
+            {wobble, 1, erlang:element(3, Wobble)}
         end,
         6
     ).

compiler-core/src/erlang/tests/snapshots/gleam_core__erlang__tests__pipes__pipe_in_record_update.snap

···
 -file("project/test/my/mod.gleam", 9).
 -spec main(x()) -> x().
 main(X) ->
-    _record = X,
     {x,
         begin
             _pipe = 1,
             id(_pipe)
         end,
-        erlang:element(3, _record)}.
+        erlang:element(3, X)}.

compiler-core/src/erlang/tests/snapshots/gleam_core__erlang__tests__records__nested_record_update.snap

···
 -spec main() -> wibble().
 main() ->
     Base = {wibble, 1, {wobble, 2, 3}, 4},
-    _record = Base,
     {wibble,
-        erlang:element(2, _record),
+        erlang:element(2, Base),
         begin
-            _record@1 = erlang:element(3, Base),
-            {wobble, erlang:element(2, _record@1), 5}
+            _record = erlang:element(3, Base),
+            {wobble, erlang:element(2, _record), 5}
         end,
-        erlang:element(4, _record)}.
+        erlang:element(4, Base)}.

compiler-core/src/erlang/tests/snapshots/gleam_core__erlang__tests__records__nested_record_update_with_blocks.snap

···
 -file("project/test/my/mod.gleam", 5).
 -spec main(a()) -> a().
 main(A) ->
-    _record = A,
     {a,
         begin
-            _record@1 = erlang:element(2, A),
+            _record = erlang:element(2, A),
             {b,
                 begin
-                    _record@2 = erlang:element(2, erlang:element(2, A)),
+                    _record@1 = erlang:element(2, erlang:element(2, A)),
                     {c, 0}
                 end}
         end}.

compiler-core/src/erlang/tests/snapshots/gleam_core__erlang__tests__records__record_updates.snap

···
 main() ->
     P = {person, <<"Quinn"/utf8>>, 27},
     New_p = begin
-        _record = P,
-        {person, erlang:element(2, _record), 28}
+        {person, erlang:element(2, P), 28}
     end,
     New_p.

compiler-core/src/erlang/tests/snapshots/gleam_core__erlang__tests__records__record_updates1.snap

···
 main() ->
     P = {person, <<"Quinn"/utf8>>, 27},
     New_p = begin
-        _record = P,
-        {person, erlang:element(2, _record), erlang:element(3, P) + 1}
+        {person, erlang:element(2, P), erlang:element(3, P) + 1}
     end,
     New_p.

compiler-core/src/erlang/tests/snapshots/gleam_core__erlang__tests__records__record_updates2.snap

···
 main() ->
     P = {person, <<"Quinn"/utf8>>, 27},
     New_p = begin
-        _record = P,
         {person, <<"Riley"/utf8>>, 28}
     end,
     New_p.

compiler-core/src/javascript/expression.rs

···
 
             TypedExpr::RecordAccess { record, label, .. } => self.record_access(record, label),
             TypedExpr::RecordUpdate {
-                record,
+                record_assignment: record,
                 constructor,
                 args,
                 ..
···
 
     fn record_update(
         &mut self,
-        record: &'a TypedAssignment,
+        record: &'a Option<Box<TypedAssignment>>,
         constructor: &'a TypedExpr,
         args: &'a [TypedCallArg],
     ) -> Output<'a> {
-        Ok(docvec![
-            self.not_in_tail_position(None, |this| this.assignment(record))?,
-            line(),
-            self.call(constructor, args)?,
-        ])
+        match record.as_ref() {
+            Some(record) => Ok(docvec![
+                self.not_in_tail_position(None, |this| this.assignment(record))?,
+                line(),
+                self.call(constructor, args)?,
+            ]),
+            None => self.call(constructor, args),
+        }
     }
 
     fn tuple_index(&mut self, tuple: &'a TypedExpr, index: u64) -> Output<'a> {

compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__case__record_update_in_pipeline_in_case_clause.snap

···
   let $ = x.wibble;
   if ($ === 1) {
     let _block;
-    let _record = x;
-    _block = new Wibble(4, _record.wobble);
+    _block = new Wibble(4, x.wobble);
     let _pipe = _block;
     return identity(_pipe);
   } else {
     let $1 = x.wobble;
     if ($1 === 3) {
       let _block;
-      let _record = x;
-      _block = new Wibble(_record.wibble, 10);
+      _block = new Wibble(x.wibble, 10);
       let _pipe = _block;
       return identity(_pipe);
     } else {

compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__custom_types__custom_type_with_named_fields.snap

···
 }
 
 export function update(cat) {
-  let _record = cat;
-  new Cat("Sid", _record.cuteness)
-  let _record$1 = cat;
-  new Cat(
-    "Bartholemew Wonder Puss the Fourth !!!!!!!!!!!!!!!!",
-    _record$1.cuteness,
-  )
-  let _record$2 = new_cat();
-  new Cat("Molly", _record$2.cuteness)
+  new Cat("Sid", cat.cuteness)
+  new Cat("Bartholemew Wonder Puss the Fourth !!!!!!!!!!!!!!!!", cat.cuteness)
+  let _record = new_cat();
+  new Cat("Molly", _record.cuteness)
   let box = new Box(cat);
-  let _record$3 = box.occupant;
-  return new Cat(_record$3.name, box.occupant.cuteness + 1);
+  let _record$1 = box.occupant;
+  return new Cat(_record$1.name, box.occupant.cuteness + 1);
 }
 
 export const felix = /* @__PURE__ */ new Cat("Felix", 12);

compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__custom_types__record_with_field_named_constructor.snap

···
 ---
 source: compiler-core/src/javascript/tests/custom_types.rs
+assertion_line: 605
 expression: "\npub type Thing {\n  Thing(constructor: Nil)\n}\n\npub fn main() {\n  let a = Thing(constructor: Nil)\n  let b = Thing(..a, constructor: Nil)\n  b.constructor\n}\n"
+snapshot_kind: text
 ---
 ----- SOURCE CODE
 
···
 export function main() {
   let a = new Thing(undefined);
   let _block;
-  let _record = a;
   _block = new Thing(undefined);
   let b = _block;
   return b.constructor$;

compiler-core/src/javascript/tests/snapshots/gleam_core__javascript__tests__custom_types__record_with_field_named_then.snap

···
 ---
 source: compiler-core/src/javascript/tests/custom_types.rs
+assertion_line: 622
 expression: "\npub type Thing {\n  Thing(then: Nil)\n}\n\npub fn main() {\n  let a = Thing(then: Nil)\n  let b = Thing(..a, then: Nil)\n  b.then\n}\n"
+snapshot_kind: text
 ---
 ----- SOURCE CODE
 
···
 export function main() {
   let a = new Thing(undefined);
   let _block;
-  let _record = a;
   _block = new Thing(undefined);
   let b = _block;
   return b.then$;

compiler-core/src/type_/expression.rs

···
         let record_location = record.location();
         let record_type = record.type_();
 
-        // We create an Assignment for the old record expression and will use a Var expression
-        // to refer back to it while constructing the arguments.
-        let record_assignment = Assignment {
-            location: record_location,
-            pattern: Pattern::Variable {
+        let (record_var, record_assignment) = if record.is_var() {
+            (record, None)
+        } else {
+            // We create an Assignment for the old record expression and will use a Var expression
+            // to refer back to it while constructing the arguments.
+            let record_assignment = Assignment {
                 location: record_location,
-                name: RECORD_UPDATE_VARIABLE.into(),
-                type_: record_type.clone(),
-                origin: VariableOrigin::generated(),
-            },
-            annotation: None,
-            compiled_case: CompiledCase::failure(),
-            kind: AssignmentKind::Generated,
-            value: record,
-        };
-
-        let record_var = TypedExpr::Var {
-            location: record_location,
-            constructor: ValueConstructor {
-                publicity: Publicity::Private,
-                deprecation: Deprecation::NotDeprecated,
-                type_: record_type,
-                variant: ValueConstructorVariant::LocalVariable {
+                pattern: Pattern::Variable {
                     location: record_location,
+                    name: RECORD_UPDATE_VARIABLE.into(),
+                    type_: record_type.clone(),
                     origin: VariableOrigin::generated(),
                 },
-            },
-            name: RECORD_UPDATE_VARIABLE.into(),
+                annotation: None,
+                compiled_case: CompiledCase::failure(),
+                kind: AssignmentKind::Generated,
+                value: record,
+            };
+
+            let record_var = TypedExpr::Var {
+                location: record_location,
+                constructor: ValueConstructor {
+                    publicity: Publicity::Private,
+                    deprecation: Deprecation::NotDeprecated,
+                    type_: record_type,
+                    variant: ValueConstructorVariant::LocalVariable {
+                        location: record_location,
+                        origin: VariableOrigin::generated(),
+                    },
+                },
+                name: RECORD_UPDATE_VARIABLE.into(),
+            };
+            (record_var, Some(Box::new(record_assignment)))
         };
 
         // infer the fields of the variant we want to update
···
         Ok(TypedExpr::RecordUpdate {
             location,
             type_: variant.retn,
-            record: Box::new(record_assignment),
+            record_assignment,
             constructor: Box::new(typed_constructor),
             args,
         })