Allow zero-length bit array segments on JS

We were checking for a positive number, when we should be checking for non-negative instead.

Author: sbergen

CHANGELOG.md

@@ -65,6 +65,10 @@
   JavaScript target.
   ([Surya Rose](https://github.com/GearsDatapacks))
 
+- Fixed a bug where a zero-length segment of a bit array would never match
+  in a case expression on the JavaScript target.
+  ([Sakari Bergen](https://github.com/sbergen))
+
 ## v1.11.0-rc1 - 2025-05-15
 
 ### Compiler

compiler-core/src/exhaustiveness.rs

@@ -875,7 +875,7 @@ pub enum BitArrayTest {
     CatchAllIsBytes {
         size_so_far: Offset,
     },
-    VariableIsPositive {
+    VariableIsNotNegative {
         variable: VariableUsage,
     },
 }
@@ -893,7 +893,7 @@ impl BitArrayTest {
 
     pub(crate) fn referenced_segment_patterns(&self) -> Vec<(&EcoString, &ReadAction)> {
         match self {
-            BitArrayTest::VariableIsPositive { variable } => match variable {
+            BitArrayTest::VariableIsNotNegative { variable } => match variable {
                 VariableUsage::PatternSegment(segment_value, read_action) => {
                     vec![(segment_value, read_action)]
                 }
@@ -2801,17 +2801,18 @@ impl CaseToCompile {
             let segment_size = segment_size(segment, &pattern_variables, None);
 
             // If we're reading a variable number of bits we need to make sure
-            // that that variable is positive!
+            // that that variable is not negative!
             if let ReadSize::VariableBits { variable, .. } = &segment_size {
                 match variable.as_ref() {
-                    // If the size variable comes from reading an unsigned number
-                    // we know that it must be positive! So we can skip checking it.
+                    // If the size variable comes from reading an unsigned
+                    // number we know that it can't be negative! So we can skip
+                    // checking it.
                     VariableUsage::PatternSegment(_, read_action) if !read_action.signed => (),
 
-                    // Otherwise we must make sure that the variable has a positive
-                    // size.
+                    // Otherwise we must make sure that the read size is not
+                    // negative.
                     VariableUsage::PatternSegment(..) | VariableUsage::OutsideVariable(_) => tests
-                        .push_back(BitArrayTest::VariableIsPositive {
+                        .push_back(BitArrayTest::VariableIsNotNegative {
                             variable: variable.as_ref().clone(),
                         }),
                 }

compiler-core/src/javascript/decision.rs

@@ -1061,11 +1061,11 @@ impl<'generator, 'module, 'a> Variables<'generator, 'module, 'a> {
                     }
                 }
 
-                BitArrayTest::VariableIsPositive { variable } => {
+                BitArrayTest::VariableIsNotNegative { variable } => {
                     if negation.is_negated() {
-                        docvec![self.local_var(variable.name()), " <= 0"]
+                        docvec![self.local_var(variable.name()), " < 0"]
                     } else {
-                        docvec![self.local_var(variable.name()), " > 0"]
+                        docvec![self.local_var(variable.name()), " >= 0"]
                     }
                 }
 

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

@@ -18,7 +18,7 @@ import { bitArraySliceToFloat } from "../gleam.mjs";
 
 function go(x) {
   let size = 3;
-  if (size > 0) {
+  if (size >= 0) {
     if (x.bitSize === size * 2) {
       if (bitArraySliceToFloat(x, 0, size * 2, true) === 1.3) {
         return 1;

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

@@ -18,7 +18,7 @@ import { bitArraySliceToInt } from "../gleam.mjs";
 
 function go(x) {
   let size = 3;
-  if (size > 0) {
+  if (size >= 0) {
     if (x.bitSize === size * 2) {
       if (bitArraySliceToInt(x, 0, size * 2, true, false) === 1) {
         return 1;

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

@@ -18,7 +18,7 @@ import { bitArraySlice } from "../gleam.mjs";
 
 function go(x) {
   let n = 16;
-  if (n > 0) {
+  if (n >= 0) {
     if (x.bitSize === n) {
       let a = bitArraySlice(x, 0, n);
       return a;

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

@@ -18,7 +18,7 @@ import { bitArraySlice } from "../gleam.mjs";
 
 function go(x) {
   let n = 3;
-  if (n > 0) {
+  if (n >= 0) {
     if (x.bitSize === n * 8) {
       let a = bitArraySlice(x, 0, n * 8);
       return a;

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

@@ -18,7 +18,7 @@ import { bitArraySliceToInt } from "../gleam.mjs";
 
 function go(x) {
   let n = 16;
-  if (n > 0) {
+  if (n >= 0) {
     if (x.bitSize === n) {
       let a = bitArraySliceToInt(x, 0, n, true, false);
       return a;

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

@@ -18,7 +18,7 @@ import { bitArraySliceToInt } from "../gleam.mjs";
 
 function go(x) {
   let n = 8;
-  if (n > 0) {
+  if (n >= 0) {
     if (x.bitSize >= n) {
       if (x.bitSize === 8 + n) {
         if (bitArraySliceToInt(x, n, n + 8, true, false) === 21) {

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

@@ -20,7 +20,7 @@ import { bitArraySliceToInt } from "../gleam.mjs";
 function go(x) {
   let n = 16;
   let n$1 = 5;
-  if (n$1 > 0) {
+  if (n$1 >= 0) {
     if (x.bitSize === n$1) {
       let a = bitArraySliceToInt(x, 0, n$1, true, false);
       return a;