Remove unnecessary assignments for blocks when the value is unused

Author: GearsDatapacks

CHANGELOG.md

@@ -143,6 +143,10 @@
 
   ([Surya Rose](https://github.com/GearsDatapacks))
 
+- The code generated for blocks on the JavaScript target has been improved and
+  is now smaller in certain cases.
+  ([Surya Rose](https://github.com/GearsDatapacks))
+
 ### Build tool
 
 - New projects are generated using OTP28 on GitHub Actions.

compiler-core/src/javascript/decision.rs

@@ -718,7 +718,7 @@ pub fn let_<'a>(
     ];
 
     match scope_position {
-        expression::Position::NotTail(_ordering) => doc,
+        expression::Position::Expression(_) | expression::Position::Statement => doc,
         expression::Position::Tail => docvec![doc, line(), "return ", assignment_name, ";"],
         expression::Position::Assign(variable) => {
             docvec![doc, line(), variable, " = ", assignment_name, ";"]

compiler-core/src/javascript/expression.rs

@@ -15,8 +15,15 @@ use std::sync::Arc;
 
 #[derive(Debug, Clone)]
 pub enum Position {
+    /// We are compiling the last expression in a function, meaning that it should
+    /// use `return` to return the value it produces from the function.
     Tail,
-    NotTail(Ordering),
+    /// We are inside a function, but the value of this expression isn't being
+    /// used, so we don't need to do anything with the returned value.
+    Statement,
+    /// The value of this expression needs to be used inside another expression,
+    /// so we need to use the value that is returned by this expression.
+    Expression(Ordering),
     /// We are compiling an expression inside a block, meaning we must assign
     /// to the `_block` variable at the end of the scope, because blocks are not
     /// expressions in JS.
@@ -38,8 +45,8 @@ impl Position {
     #[must_use]
     pub fn ordering(&self) -> Ordering {
         match self {
-            Self::NotTail(ordering) => *ordering,
-            Self::Tail | Self::Assign(_) => Ordering::Loose,
+            Self::Expression(ordering) => *ordering,
+            Self::Tail | Self::Assign(_) | Self::Statement => Ordering::Loose,
         }
     }
 }
@@ -518,7 +525,7 @@ impl<'module, 'a> Generator<'module, 'a> {
     pub fn wrap_return(&mut self, document: Document<'a>) -> Document<'a> {
         match &self.scope_position {
             Position::Tail => docvec!["return ", document, ";"],
-            Position::NotTail(_) => document,
+            Position::Expression(_) | Position::Statement => document,
             Position::Assign(name) => docvec![name.clone(), " = ", document, ";"],
         }
     }
@@ -536,10 +543,12 @@ impl<'module, 'a> Generator<'module, 'a> {
     {
         let new_ordering = ordering.unwrap_or(self.scope_position.ordering());
 
-        let function_position =
-            std::mem::replace(&mut self.function_position, Position::NotTail(new_ordering));
+        let function_position = std::mem::replace(
+            &mut self.function_position,
+            Position::Expression(new_ordering),
+        );
         let scope_position =
-            std::mem::replace(&mut self.scope_position, Position::NotTail(new_ordering));
+            std::mem::replace(&mut self.scope_position, Position::Expression(new_ordering));
 
         let result = compile(self);
 
@@ -562,7 +571,7 @@ impl<'module, 'a> Generator<'module, 'a> {
                     record_assignment: Some(_),
                     ..
                 },
-                Position::NotTail(Ordering::Loose),
+                Position::Expression(Ordering::Loose),
             ) => self.wrap_block(|this| this.expression(expression)),
             (
                 TypedExpr::Panic { .. }
@@ -574,7 +583,7 @@ impl<'module, 'a> Generator<'module, 'a> {
                     record_assignment: Some(_),
                     ..
                 },
-                Position::NotTail(Ordering::Strict),
+                Position::Expression(Ordering::Strict),
             ) => self.immediately_invoked_function_expression(expression, |this, expr| {
                 this.expression(expr)
             }),
@@ -597,8 +606,8 @@ impl<'module, 'a> Generator<'module, 'a> {
         match &self.scope_position {
             // Here the document is a return statement: `return <expr>;`
             // or an assignment: `_block = <expr>;`
-            Position::Tail | Position::Assign(_) => document,
-            Position::NotTail(_) => docvec!["(", document, ")"],
+            Position::Tail | Position::Assign(_) | Position::Statement => document,
+            Position::Expression(_) => docvec!["(", document, ")"],
         }
     }
 
@@ -644,7 +653,7 @@ impl<'module, 'a> Generator<'module, 'a> {
         );
         let function_position = std::mem::replace(
             &mut self.function_position,
-            Position::NotTail(Ordering::Strict),
+            Position::Expression(Ordering::Strict),
         );
 
         // Generate the expression
@@ -774,12 +783,14 @@ impl<'module, 'a> Generator<'module, 'a> {
             }
         }
         match &self.scope_position {
-            Position::Tail | Position::Assign(_) => self.block_document(statements),
-            Position::NotTail(Ordering::Strict) => self
+            Position::Tail | Position::Assign(_) | Position::Statement => {
+                self.block_document(statements)
+            }
+            Position::Expression(Ordering::Strict) => self
                 .immediately_invoked_function_expression(statements, |this, statements| {
                     this.statements(statements)
                 }),
-            Position::NotTail(Ordering::Loose) => self.wrap_block(|this| {
+            Position::Expression(Ordering::Loose) => self.wrap_block(|this| {
                 // Save previous scope
                 let current_scope_vars = this.current_scope_vars.clone();
 
@@ -806,11 +817,16 @@ impl<'module, 'a> Generator<'module, 'a> {
         let mut documents = Vec::with_capacity(count * 3);
         for (i, statement) in statements.iter().enumerate() {
             if i + 1 < count {
-                documents.push(
-                    self.not_in_tail_position(Some(Ordering::Loose), |this| {
-                        this.statement(statement)
-                    }),
-                );
+                let function_position =
+                    std::mem::replace(&mut self.function_position, Position::Statement);
+                let scope_position =
+                    std::mem::replace(&mut self.scope_position, Position::Statement);
+
+                documents.push(self.statement(statement));
+
+                self.function_position = function_position;
+                self.scope_position = scope_position;
+
                 if requires_semicolon(statement) {
                     documents.push(";".to_doc());
                 }
@@ -845,7 +861,7 @@ impl<'module, 'a> Generator<'module, 'a> {
         let js_name = self.next_local_var(name);
         let assignment = docvec!["let ", js_name.clone(), " = ", subject, ";"];
         let assignment = match &self.scope_position {
-            Position::NotTail(_) => assignment,
+            Position::Expression(_) | Position::Statement => assignment,
             Position::Tail => docvec![assignment, line(), "return ", js_name, ";"],
             Position::Assign(block_variable) => docvec![
                 assignment,
@@ -900,7 +916,7 @@ impl<'module, 'a> Generator<'module, 'a> {
         });
 
         match &self.scope_position {
-            Position::NotTail(_) => check,
+            Position::Expression(_) | Position::Statement => check,
             Position::Tail | Position::Assign(_) => {
                 docvec![check, line(), self.wrap_return("undefined".to_doc())]
             }

compiler-core/src/javascript/tests/blocks.rs

@@ -344,3 +344,27 @@ pub fn main() {
 "#
     )
 }
+
+#[test]
+fn blocks_whose_values_are_unused_do_not_generate_assignments() {
+    // There's no point generating `_block` assignments here, as the values
+    // would be unused.
+    assert_js!(
+        "
+pub fn main() {
+  {
+    let x = 10
+    echo x
+  }
+
+  {
+    let a = 1
+    let b = 2
+    a + b
+  }
+
+  Nil
+}
+"
+    );
+}

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

@@ -1,8 +1,6 @@
 ---
 source: compiler-core/src/javascript/tests/blocks.rs
-assertion_line: 172
 expression: "\npub fn b() {\n  {\n    fn(cb) { cb(1) }\n  }\n  {\n    fn(cb) { cb(2) }\n  }\n  3\n}\n"
-snapshot_kind: text
 ---
 ----- SOURCE CODE
 
@@ -19,7 +17,7 @@ pub fn b() {
 
 ----- COMPILED JAVASCRIPT
 export function b() {
-  ((cb) => { return cb(1); });
-  ((cb) => { return cb(2); });
+  (cb) => { return cb(1); };
+  (cb) => { return cb(2); };
   return 3;
 }

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

@@ -0,0 +1,49 @@
+---
+source: compiler-core/src/javascript/tests/blocks.rs
+expression: "\npub fn main() {\n  {\n    let x = 10\n    echo x\n  }\n\n  {\n    let a = 1\n    let b = 2\n    a + b\n  }\n\n  Nil\n}\n"
+---
+----- SOURCE CODE
+
+pub fn main() {
+  {
+    let x = 10
+    echo x
+  }
+
+  {
+    let a = 1
+    let b = 2
+    a + b
+  }
+
+  Nil
+}
+
+
+----- COMPILED JAVASCRIPT
+import * as $stdlib$dict from "../../gleam_stdlib/dict.mjs";
+import {
+  Empty as $Empty,
+  NonEmpty as $NonEmpty,
+  CustomType as $CustomType,
+  bitArraySlice,
+  bitArraySliceToInt,
+  BitArray as $BitArray,
+  List as $List,
+  UtfCodepoint as $UtfCodepoint,
+} from "../gleam.mjs";
+
+export function main() {
+  {
+    let x = 10;
+    echo(x, undefined, "src/module.gleam", 5)
+  };
+  {
+    let a = 1;
+    let b = 2;
+    a + b
+  };
+  return undefined;
+}
+
+// ...omitted code from `templates/echo.mjs`...

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

@@ -1,8 +1,6 @@
 ---
 source: compiler-core/src/javascript/tests/blocks.rs
-assertion_line: 75
 expression: "\npub fn go() {\n  let x = {\n    1\n    {\n      2\n      3\n    }\n    4\n  }\n  x\n}\n"
-snapshot_kind: text
 ---
 ----- SOURCE CODE
 
@@ -24,12 +22,10 @@ export function go() {
   let _block;
   {
     1;
-    let _block$1;
     {
       2;
-      _block$1 = 3;
-    }
-    _block$1;
+      3
+    };
     _block = 4;
   }
   let x = _block;