Remove extra block wrapping

compiler-core/src/erlang.rs

···
 
 fn needs_begin_end_wrapping(expression: &TypedExpr) -> bool {
     match expression {
-        TypedExpr::RecordUpdate { .. } | TypedExpr::Pipeline { .. } => true,
+        // Record updates are 1 expression if there's no assignment, multiple otherwise.
+        TypedExpr::RecordUpdate {
+            record_assignment, ..
+        } => record_assignment.is_some(),
+
+        TypedExpr::Pipeline { .. } => true,
 
         TypedExpr::Int { .. }
         | TypedExpr::Float { .. }

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

···
 -spec main() -> wobble().
 main() ->
     Wobble = {wobble, 1, <<"wobble"/utf8>>},
-    echo(
-        begin
-            {wobble, 1, erlang:element(3, Wobble)}
-        end,
-        6
-    ).
+    echo({wobble, 1, erlang:element(3, Wobble)}, 6).
 
 % ...omitted code from `templates/echo.erl`...

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

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

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

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

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

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

compiler-core/src/javascript/expression.rs

···
                 | TypedExpr::Todo { .. }
                 | TypedExpr::Case { .. }
                 | TypedExpr::Pipeline { .. }
-                | TypedExpr::RecordUpdate { .. },
+                | TypedExpr::RecordUpdate {
+                    record_assignment: Some(_),
+                    ..
+                },
                 Position::NotTail(Ordering::Loose),
             ) => self.wrap_block(|this| this.expression(expression)),
             (
···
                 | TypedExpr::Todo { .. }
                 | TypedExpr::Case { .. }
                 | TypedExpr::Pipeline { .. }
-                | TypedExpr::RecordUpdate { .. },
+                | TypedExpr::RecordUpdate {
+                    record_assignment: Some(_),
+                    ..
+                },
                 Position::NotTail(Ordering::Strict),
             ) => self.immediately_invoked_function_expression(expression, |this, expr| {
                 this.expression(expr)

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

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

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

···
 
 export function main() {
   let a = new Thing(undefined);
-  let _block;
-  _block = new Thing(undefined);
-  let b = _block;
+  let b = new Thing(undefined);
   return b.constructor$;
 }

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

···
 
 export function main() {
   let a = new Thing(undefined);
-  let _block;
-  _block = new Thing(undefined);
-  let b = _block;
+  let b = new Thing(undefined);
   return b.then$;
 }