Fix compiler crash for UTF-codepoint segments on the JavaScript target

CHANGELOG.md

···
   "Extract variable" code action was used on a `use` expression.
   ([Surya Rose](https://github.com/GearsDatapacks))
 
+- Fixed a bug where the compiler would crash when using the `utf8_codepoint`
+  bit array segment on the JavaScript target.
+  ([Surya Rose](https://github.com/GearsDatapacks))
+
 ## v1.11.1 - 2025-06-05
 
 ### Compiler

compiler-core/src/bit_array.rs

···
 use num_bigint::BigInt;
 
 use crate::ast::{self, BitArrayOption, SrcSpan};
+use crate::build::Target;
 use crate::type_::Type;
 use std::sync::Arc;
 
···
 
 pub fn type_options_for_value<TypedValue>(
     input_options: &[BitArrayOption<TypedValue>],
+    target: Target,
 ) -> Result<Arc<Type>, Error>
 where
     TypedValue: GetLiteralValue,
 {
-    type_options(input_options, TypeOptionsMode::Expression, false)
+    type_options(input_options, TypeOptionsMode::Expression, false, target)
 }
 
 pub fn type_options_for_pattern<TypedValue>(
     input_options: &[BitArrayOption<TypedValue>],
     must_have_size: bool,
+    target: Target,
 ) -> Result<Arc<Type>, Error>
 where
     TypedValue: GetLiteralValue,
 {
-    type_options(input_options, TypeOptionsMode::Pattern, must_have_size)
+    type_options(
+        input_options,
+        TypeOptionsMode::Pattern,
+        must_have_size,
+        target,
+    )
 }
 
 struct SegmentOptionCategories<'a, T> {
···
     input_options: &[BitArrayOption<TypedValue>],
     mode: TypeOptionsMode,
     must_have_size: bool,
+    target: Target,
 ) -> Result<Arc<Type>, Error>
 where
     TypedValue: GetLiteralValue,
···
     // Basic category checking
     for option in input_options {
         match option {
+            Utf8Codepoint { .. } | Utf16Codepoint { .. } | Utf32Codepoint { .. }
+                if mode == TypeOptionsMode::Pattern && target == Target::JavaScript =>
+            {
+                return err(
+                    ErrorType::OptionNotSupportedForTarget {
+                        target,
+                        option: UnsupportedOption::UtfCodepointPattern,
+                    },
+                    option.location(),
+                );
+            }
+
             Bytes { .. }
             | Int { .. }
             | Float { .. }
···
                 } else {
                     categories.signed = Some(option);
                 }
+            }
+
+            Native { .. } if target == Target::JavaScript => {
+                return err(
+                    ErrorType::OptionNotSupportedForTarget {
+                        target,
+                        option: UnsupportedOption::NativeEndianness,
+                    },
+                    option.location(),
+                );
             }
 
             Big { .. } | Little { .. } | Native { .. } => {
···
 
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub enum ErrorType {
-    ConflictingEndiannessOptions { existing_endianness: EcoString },
-    ConflictingSignednessOptions { existing_signed: EcoString },
+    ConflictingEndiannessOptions {
+        existing_endianness: EcoString,
+    },
+    ConflictingSignednessOptions {
+        existing_signed: EcoString,
+    },
     ConflictingSizeOptions,
-    ConflictingTypeOptions { existing_type: EcoString },
+    ConflictingTypeOptions {
+        existing_type: EcoString,
+    },
     ConflictingUnitOptions,
     FloatWithSize,
     InvalidEndianness,
     OptionNotAllowedInValue,
     SegmentMustHaveSize,
-    SignednessUsedOnNonInt { type_: EcoString },
-    TypeDoesNotAllowSize { type_: EcoString },
-    TypeDoesNotAllowUnit { type_: EcoString },
+    SignednessUsedOnNonInt {
+        type_: EcoString,
+    },
+    TypeDoesNotAllowSize {
+        type_: EcoString,
+    },
+    TypeDoesNotAllowUnit {
+        type_: EcoString,
+    },
     UnitMustHaveSize,
     VariableUtfSegmentInPattern,
     ConstantSizeNotPositive,
+    OptionNotSupportedForTarget {
+        target: Target,
+        option: UnsupportedOption,
+    },
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub enum UnsupportedOption {
+    UtfCodepointPattern,
+    NativeEndianness,
 }

compiler-core/src/error.rs

···
 #![allow(clippy::unwrap_used, clippy::expect_used)]
+use crate::bit_array::UnsupportedOption;
 use crate::build::{Origin, Outcome, Runtime, Target};
 use crate::dependency::{PackageFetcher, ResolutionError};
 use crate::diagnostic::{Diagnostic, ExtraLabel, Label, Location};
···
                             bit_array::ErrorType::ConstantSizeNotPositive => {
                                 ("A constant size must be a positive number", vec![])
                             }
+                            bit_array::ErrorType::OptionNotSupportedForTarget {
+                                target,
+                                option: UnsupportedOption::NativeEndianness,
+                            } => (
+                                "Unsupported endianness",
+                                vec![
+                                    wrap_format!("The {target} target does not support the `native` endianness option.")
+                                ],
+                            ),
+                            bit_array::ErrorType::OptionNotSupportedForTarget {
+                                target,
+                                option: UnsupportedOption::UtfCodepointPattern,
+                            } => (
+                                "UTF-codepoint pattern matching is not supported",
+                                vec![
+                                    wrap_format!("The {target} target does not support UTF-codepoint pattern matching.")
+                                ],
+                            ),
                         };
                         extra.push("See: https://tour.gleam.run/data-types/bit-arrays/".into());
                         let text = extra.join("\n");

compiler-core/src/javascript/expression.rs

···
                 this.wrap_expression(&segment.value)
             })?;
 
-            if segment.has_native_option() {
-                return Err(Error::Unsupported {
-                    feature: "This bit array segment option".into(),
-                    location: segment.location,
-                });
-            }
-
             match segment.options.as_slice() {
                 // Int segment
                 _ if segment.type_.is_int() => {
···
         self.tracker.bit_array_literal_used = true;
         let segments_array = array(segments.iter().map(|segment| {
             let value = self.constant_expression(Context::Constant, &segment.value)?;
-
-            if segment.has_native_option() {
-                return Err(Error::Unsupported {
-                    feature: "This bit array segment option".into(),
-                    location: segment.location,
-                });
-            }
 
             match segment.options.as_slice() {
                 // Int segment

compiler-core/src/type_/expression.rs

···
 
         let options: Vec<_> = options.into_iter().map(infer_option).try_collect()?;
 
-        let type_ = bit_array::type_options_for_value(&options).map_err(|error| {
-            Error::BitArraySegmentError {
+        let type_ = bit_array::type_options_for_value(&options, self.environment.target).map_err(
+            |error| Error::BitArraySegmentError {
                 error: error.error,
                 location: error.location,
-            }
-        })?;
+            },
+        )?;
 
         // Track usage of the unaligned bit arrays feature on JavaScript so that
         // warnings can be emitted if the Gleam version constraint is too low

compiler-core/src/type_/pattern.rs

···
             .try_collect()
             .expect("The function always returns Ok");
 
-        let segment_type = match bit_array::type_options_for_pattern(&options, !is_last_segment) {
+        let segment_type = match bit_array::type_options_for_pattern(
+            &options,
+            !is_last_segment,
+            self.environment.target,
+        ) {
             Ok(type_) => type_,
             Err(error) => {
                 self.error(Error::BitArraySegmentError {

compiler-core/src/type_/tests/errors.rs

···
 use crate::{
-    assert_error, assert_internal_module_error, assert_module_error, assert_module_syntax_error,
+    assert_error, assert_internal_module_error, assert_js_module_error, assert_module_error,
+    assert_module_syntax_error,
 };
 
 #[test]
···
 "
     );
 }
+#[test]
+fn native_endianness_javascript_target() {
+    assert_js_module_error!(
+        "
+pub fn main() {
+  let assert <<a:native>> = <<10>>
+}
+"
+    );
+}
+
+#[test]
+fn utf8_codepoint_javascript_target() {
+    assert_js_module_error!(
+        "
+pub fn main() {
+  let assert <<a:utf8_codepoint>> = <<10>>
+}
+"
+    );
+}
+
+#[test]
+fn utf16_codepoint_javascript_target() {
+    assert_js_module_error!(
+        "
+pub fn main() {
+  let assert <<a:utf16_codepoint>> = <<10>>
+}
+"
+    );
+}
+
+#[test]
+fn utf32_codepoint_javascript_target() {
+    assert_js_module_error!(
+        "
+pub fn main() {
+  let assert <<a:utf32_codepoint>> = <<10>>
+}
+"
+    );
+}

compiler-core/src/type_/tests/snapshots/gleam_core__type___tests__errors__native_endianness_javascript_target.snap

···
+---
+source: compiler-core/src/type_/tests/errors.rs
+expression: "\npub fn main() {\n  let assert <<a:native>> = <<10>>\n}\n"
+---
+----- SOURCE CODE
+
+pub fn main() {
+  let assert <<a:native>> = <<10>>
+}
+
+
+----- ERROR
+error: Invalid bit array segment
+  ┌─ /src/one/two.gleam:3:18
+  │
+3 │   let assert <<a:native>> = <<10>>
+  │                  ^^^^^^ Unsupported endianness
+
+The javascript target does not support the `native` endianness option.
+See: https://tour.gleam.run/data-types/bit-arrays/

compiler-core/src/type_/tests/snapshots/gleam_core__type___tests__errors__utf16_codepoint_javascript_target.snap

···
+---
+source: compiler-core/src/type_/tests/errors.rs
+expression: "\npub fn main() {\n  let assert <<a:utf16_codepoint>> = <<10>>\n}\n"
+---
+----- SOURCE CODE
+
+pub fn main() {
+  let assert <<a:utf16_codepoint>> = <<10>>
+}
+
+
+----- ERROR
+error: Invalid bit array segment
+  ┌─ /src/one/two.gleam:3:18
+  │
+3 │   let assert <<a:utf16_codepoint>> = <<10>>
+  │                  ^^^^^^^^^^^^^^^ UTF-codepoint pattern matching is not supported
+
+The javascript target does not support UTF-codepoint pattern matching.
+See: https://tour.gleam.run/data-types/bit-arrays/

compiler-core/src/type_/tests/snapshots/gleam_core__type___tests__errors__utf32_codepoint_javascript_target.snap

···
+---
+source: compiler-core/src/type_/tests/errors.rs
+expression: "\npub fn main() {\n  let assert <<a:utf32_codepoint>> = <<10>>\n}\n"
+---
+----- SOURCE CODE
+
+pub fn main() {
+  let assert <<a:utf32_codepoint>> = <<10>>
+}
+
+
+----- ERROR
+error: Invalid bit array segment
+  ┌─ /src/one/two.gleam:3:18
+  │
+3 │   let assert <<a:utf32_codepoint>> = <<10>>
+  │                  ^^^^^^^^^^^^^^^ UTF-codepoint pattern matching is not supported
+
+The javascript target does not support UTF-codepoint pattern matching.
+See: https://tour.gleam.run/data-types/bit-arrays/

compiler-core/src/type_/tests/snapshots/gleam_core__type___tests__errors__utf8_codepoint_javascript_target.snap

···
+---
+source: compiler-core/src/type_/tests/errors.rs
+expression: "\npub fn main() {\n  let assert <<a:utf8_codepoint>> = <<10>>\n}\n"
+---
+----- SOURCE CODE
+
+pub fn main() {
+  let assert <<a:utf8_codepoint>> = <<10>>
+}
+
+
+----- ERROR
+error: Invalid bit array segment
+  ┌─ /src/one/two.gleam:3:18
+  │
+3 │   let assert <<a:utf8_codepoint>> = <<10>>
+  │                  ^^^^^^^^^^^^^^ UTF-codepoint pattern matching is not supported
+
+The javascript target does not support UTF-codepoint pattern matching.
+See: https://tour.gleam.run/data-types/bit-arrays/