Avoid repeating slices when aliasing constant values

Instead of taking a slice twice, if a segment pattern is written like
this: `1 as a`, we bind the `a` variable to the constant `1` directly
and avoid taking a second slice after performing the runtime check.

Author: giacomocavalieri

compiler-core/src/exhaustiveness.rs

@@ -286,18 +286,28 @@ impl Branch {
                         }
 
                         Some(test) => match test {
+                            // If we have `_ as a` we treat that as a regular variable
+                            // assignment.
+                            BitArrayTest::Match(MatchTest {
+                                value: BitArrayMatchedValue::Assign { name, value },
+                                read_action,
+                            }) if value.is_discard() => {
+                                *test = BitArrayTest::Match(MatchTest {
+                                    value: BitArrayMatchedValue::Variable(name.clone()),
+                                    read_action: read_action.clone(),
+                                });
+                                continue;
+                            }
+
                             // Just like regular assigns, those patterns are unrefutable
                             // and will become assignments in the branch's body.
                             BitArrayTest::Match(MatchTest {
                                 value: BitArrayMatchedValue::Assign { name, value },
                                 read_action,
                             }) => {
-                                let bit_array = check.var.clone();
-                                self.body.assign_bit_array_slice(
-                                    name.clone(),
-                                    bit_array,
-                                    read_action.clone(),
-                                );
+                                self.body
+                                    .assign_segment_constant_value(name.clone(), value.as_ref());
+
                                 // We will still need to check the aliased value!
                                 *test = BitArrayTest::Match(MatchTest {
                                     value: value.as_ref().clone(),
@@ -362,6 +372,14 @@ pub enum BoundValue {
     ///
     LiteralString(EcoString),
 
+    /// `let a = 123`
+    ///
+    LiteralInt(BigInt),
+
+    /// `let a = 12.2`
+    ///
+    LiteralFloat(EcoString),
+
     /// `let a = sliceAsInt(bit_array, 0, 16, ...)`
     ///
     BitArraySlice {
@@ -403,6 +421,21 @@ impl Body {
             },
         ))
     }
+
+    fn assign_segment_constant_value(&mut self, name: EcoString, value: &BitArrayMatchedValue) {
+        let value = match value {
+            BitArrayMatchedValue::LiteralFloat(value) => BoundValue::LiteralFloat(value.clone()),
+            BitArrayMatchedValue::LiteralInt(value) => BoundValue::LiteralInt(value.clone()),
+            BitArrayMatchedValue::LiteralString(value) => BoundValue::LiteralString(value.clone()),
+            BitArrayMatchedValue::Variable(_)
+            | BitArrayMatchedValue::Discard(_)
+            | BitArrayMatchedValue::Assign { .. } => {
+                panic!("aliased non constant value: {:#?}", value)
+            }
+        };
+
+        self.bindings.push((name, value))
+    }
 }
 
 /// A user defined pattern such as `Some((x, 10))`.
@@ -981,6 +1014,19 @@ pub enum BitArrayMatchedValue {
     },
 }
 
+impl BitArrayMatchedValue {
+    pub fn is_discard(&self) -> bool {
+        match self {
+            BitArrayMatchedValue::Discard(_) => true,
+            BitArrayMatchedValue::LiteralFloat(_)
+            | BitArrayMatchedValue::LiteralInt(_)
+            | BitArrayMatchedValue::LiteralString(_)
+            | BitArrayMatchedValue::Variable(_)
+            | BitArrayMatchedValue::Assign { .. } => false,
+        }
+    }
+}
+
 impl BitArrayTest {
     // TODO: for these tests we could also implement a more sophisticated
     // approach for `Match` tests. This is described in the linked paper as

compiler-core/src/javascript/decision.rs

@@ -820,6 +820,8 @@ impl<'generator, 'module, 'a> Variables<'generator, 'module, 'a> {
         let assigned_value = match value {
             BoundValue::Variable(variable) => self.get_value(variable).to_doc(),
             BoundValue::LiteralString(value) => string(value),
+            BoundValue::LiteralFloat(value) => float(value),
+            BoundValue::LiteralInt(value) => eco_string_int(eco_format!("{value}")),
             BoundValue::BitArraySlice {
                 bit_array,
                 read_action,

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

@@ -25,6 +25,6 @@ export function main() {
       { value: $ }
     )
   }
-  let pi = bitArraySliceToFloat($, 0, 64, true);
+  let pi = 3.14;
   return pi;
 }

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

@@ -25,6 +25,6 @@ export function main() {
       { value: $ }
     )
   }
-  let a = $.byteAt(0);
+  let a = 1;
   return a;
 }

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

@@ -0,0 +1,45 @@
+---
+source: compiler-core/src/javascript/tests/bit_arrays.rs
+expression: "\npub fn main() {\n let assert <<\"Hello, world!\" as message:utf8>> = <<\"Hello, world!\">>\n message\n}\n"
+---
+----- SOURCE CODE
+
+pub fn main() {
+ let assert <<"Hello, world!" as message:utf8>> = <<"Hello, world!">>
+ message
+}
+
+
+----- COMPILED JAVASCRIPT
+import { makeError, toBitArray, stringBits } from "../gleam.mjs";
+
+export function main() {
+  let $ = toBitArray([stringBits("Hello, world!")]);
+  if (
+    $.bitSize !== 64 ||
+    $.byteAt(0) !== 72 ||
+    $.byteAt(1) !== 101 ||
+    $.byteAt(2) !== 108 ||
+    $.byteAt(3) !== 108 ||
+    $.byteAt(4) !== 111 ||
+    $.byteAt(5) !== 44 ||
+    $.byteAt(6) !== 32 ||
+    $.byteAt(7) !== 119 ||
+    $.byteAt(8) !== 111 ||
+    $.byteAt(9) !== 114 ||
+    $.byteAt(10) !== 108 ||
+    $.byteAt(11) !== 100 ||
+    $.byteAt(12) !== 33
+  ) {
+    throw makeError(
+      "let_assert",
+      "my/mod",
+      3,
+      "main",
+      "Pattern match failed, no pattern matched the value.",
+      { value: $ }
+    )
+  }
+  let message = "Hello, world!";
+  return message;
+}

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

@@ -19,12 +19,12 @@ import { bitArraySliceToFloat } from "../gleam.mjs";
 export function go(x) {
   if (x.bitSize === 64) {
     if (bitArraySliceToFloat(x, 0, 64, true) === 3.14) {
-      let pi = bitArraySliceToFloat(x, 0, 64, true);
+      let pi = 3.14;
       return pi;
     } else {
       if (bitArraySliceToFloat(x, 0, 64, true) === 1.1) {
         if ((x.bitSize - 64) % 8 === 0) {
-          let pi = bitArraySliceToFloat(x, 0, 64, true);
+          let pi = 1.1;
           return pi;
         } else {
           return 1.1;
@@ -37,7 +37,7 @@ export function go(x) {
     if (x.bitSize >= 64) {
       if (bitArraySliceToFloat(x, 0, 64, true) === 1.1) {
         if ((x.bitSize - 64) % 8 === 0) {
-          let pi = bitArraySliceToFloat(x, 0, 64, true);
+          let pi = 1.1;
           return pi;
         } else {
           return 1.1;

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

@@ -17,12 +17,12 @@ pub fn go(x) {
 export function go(x) {
   if (x.bitSize === 8) {
     if (x.byteAt(0) === 1) {
-      let n = x.byteAt(0);
+      let n = 1;
       return n;
     } else {
       if (x.byteAt(0) === 2) {
         if ((x.bitSize - 8) % 8 === 0) {
-          let n = x.byteAt(0);
+          let n = 2;
           return n;
         } else {
           return 1;
@@ -35,7 +35,7 @@ export function go(x) {
     if (x.bitSize >= 8) {
       if (x.byteAt(0) === 2) {
         if ((x.bitSize - 8) % 8 === 0) {
-          let n = x.byteAt(0);
+          let n = 2;
           return n;
         } else {
           return 1;

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

@@ -0,0 +1,54 @@
+---
+source: compiler-core/src/javascript/tests/bit_arrays.rs
+expression: "\npub fn go(x) {\n case x {\n    <<\"Hello\" as message>>\n    | <<\"Jak\" as message, _:bytes>> -> message\n    _ -> \"wibble\"\n }\n}\n"
+---
+----- SOURCE CODE
+
+pub fn go(x) {
+ case x {
+    <<"Hello" as message>>
+    | <<"Jak" as message, _:bytes>> -> message
+    _ -> "wibble"
+ }
+}
+
+
+----- COMPILED JAVASCRIPT
+export function go(x) {
+  if (x.bitSize === 64) {
+    if (x.byteAt(0) === 72 &&
+      x.byteAt(1) === 101 &&
+      x.byteAt(2) === 108 &&
+      x.byteAt(3) === 108 &&
+      x.byteAt(4) === 111) {
+      let message = "Hello";
+      return message;
+    } else {
+      if (x.byteAt(0) === 74 && x.byteAt(1) === 97 && x.byteAt(2) === 107) {
+        if ((x.bitSize - 64) % 8 === 0) {
+          let message = "Jak";
+          return message;
+        } else {
+          return "wibble";
+        }
+      } else {
+        return "wibble";
+      }
+    }
+  } else {
+    if (x.bitSize >= 64) {
+      if (x.byteAt(0) === 74 && x.byteAt(1) === 97 && x.byteAt(2) === 107) {
+        if ((x.bitSize - 64) % 8 === 0) {
+          let message = "Jak";
+          return message;
+        } else {
+          return "wibble";
+        }
+      } else {
+        return "wibble";
+      }
+    } else {
+      return "wibble";
+    }
+  }
+}