Make sure to reject variable sized string segment patterns

With aliases now supported in bit array segments analysis was not
updated to reject aliases that ended up being the same as a variable
length string pattern: `_ as a:utf8` should be rejected just like
`a:utf8` is.

Author: giacomocavalieri

compiler-core/src/ast.rs

@@ -2374,6 +2374,28 @@ impl Endianness {
     }
 }
 
+impl<Type> BitArraySegment<Pattern<Type>, Type> {
+    /// Returns the value of the pattern unwrapping any assign pattern.
+    ///
+    pub fn value_unwrapping_assign(&self) -> &Pattern<Type> {
+        match self.value.as_ref() {
+            Pattern::Assign { pattern, .. } => pattern,
+            Pattern::Int { .. }
+            | Pattern::Float { .. }
+            | Pattern::String { .. }
+            | Pattern::Variable { .. }
+            | Pattern::VarUsage { .. }
+            | Pattern::Discard { .. }
+            | Pattern::List { .. }
+            | Pattern::Constructor { .. }
+            | Pattern::Tuple { .. }
+            | Pattern::BitArray { .. }
+            | Pattern::StringPrefix { .. }
+            | Pattern::Invalid { .. } => self.value.as_ref(),
+        }
+    }
+}
+
 impl<Value> BitArraySegment<Value, Arc<Type>> {
     #[must_use]
     pub fn has_native_option(&self) -> bool {

compiler-core/src/type_/pattern.rs

@@ -8,7 +8,7 @@ use num_bigint::BigInt;
 ///
 use super::*;
 use crate::{
-    analyse::{Inferred, name::check_name_case},
+    analyse::{self, Inferred, name::check_name_case},
     ast::{
         AssignName, BitArrayOption, ImplicitCallArgOrigin, Layer, UntypedPatternBitArraySegment,
     },
@@ -290,7 +290,7 @@ impl<'a, 'b> PatternTyper<'a, 'b> {
         // implicitly considered utf-8 encoded strings, while floats are
         // implicitly given the float type option.
         if !segment.has_type_option() {
-            match segment.value.as_ref() {
+            match segment.value_unwrapping_assign() {
                 Pattern::String { location, .. } => {
                     self.track_feature_usage(FeatureKind::UnannotatedUtf8StringSegment, *location);
                     segment.options.push(BitArrayOption::Utf8 {
@@ -312,8 +312,8 @@ impl<'a, 'b> PatternTyper<'a, 'b> {
         let options: Vec<_> = segment
             .options
             .into_iter()
-            .map(|o| {
-                crate::analyse::infer_bit_array_option(o, |value, type_| {
+            .map(|option| {
+                analyse::infer_bit_array_option(option, |value, type_| {
                     Ok(self.unify(value, type_, None))
                 })
             })
@@ -369,6 +369,13 @@ impl<'a, 'b> PatternTyper<'a, 'b> {
         }
 
         let type_ = match segment.value.deref() {
+            Pattern::Assign { pattern, .. } if pattern.is_discard() && segment_type.is_string() => {
+                self.error(Error::BitArraySegmentError {
+                    error: bit_array::ErrorType::VariableUtfSegmentInPattern,
+                    location: segment.location,
+                });
+                self.environment.new_unbound_var()
+            }
             Pattern::Variable { .. } if segment_type.is_string() => {
                 self.error(Error::BitArraySegmentError {
                     error: bit_array::ErrorType::VariableUtfSegmentInPattern,

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

@@ -164,6 +164,16 @@ fn bit_array_segment_type_does_not_allow_size_utf32() {
     assert_error!("case <<1>> { <<1:utf32-size(5)>> -> 1 }");
 }
 
+#[test]
+fn bit_array_segment_type_does_not_allow_variable_string() {
+    assert_error!("case <<>> { <<a:utf8>> -> 1 _ -> 2 }");
+}
+
+#[test]
+fn bit_array_segment_type_does_not_allow_aliased_variable_string() {
+    assert_error!("case <<>> { <<_ as a:utf8>> -> 1 _ -> 2 }");
+}
+
 #[test]
 fn bit_array_segment_unit_no_size() {
     assert_error!("let x = <<1:unit(5)>> x");

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

@@ -0,0 +1,16 @@
+---
+source: compiler-core/src/type_/tests/errors.rs
+expression: "case <<>> { <<_ as a:utf8>> -> 1 _ -> 2 }"
+---
+----- SOURCE CODE
+case <<>> { <<_ as a:utf8>> -> 1 _ -> 2 }
+
+----- ERROR
+error: Invalid bit array segment
+  ┌─ /src/one/two.gleam:1:15
+  │
+1 │ case <<>> { <<_ as a:utf8>> -> 1 _ -> 2 }
+  │               ^^^^^^^^^^^ This cannot be a variable
+
+Hint: in patterns utf8, utf16, and utf32  must be an exact string.
+See: https://tour.gleam.run/data-types/bit-arrays/

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

@@ -0,0 +1,16 @@
+---
+source: compiler-core/src/type_/tests/errors.rs
+expression: "case <<>> { <<a:utf8>> -> 1 _ -> 2 }"
+---
+----- SOURCE CODE
+case <<>> { <<a:utf8>> -> 1 _ -> 2 }
+
+----- ERROR
+error: Invalid bit array segment
+  ┌─ /src/one/two.gleam:1:15
+  │
+1 │ case <<>> { <<a:utf8>> -> 1 _ -> 2 }
+  │               ^^^^^^ This cannot be a variable
+
+Hint: in patterns utf8, utf16, and utf32  must be an exact string.
+See: https://tour.gleam.run/data-types/bit-arrays/