Error for UTF-16 and UTF-32 assignments

Author: GearsDatapacks

compiler-core/src/ast.rs

@@ -2401,7 +2401,7 @@ impl<Type> BitArraySegment<Pattern<Type>, Type> {
     }
 }
 
-impl<Value> BitArraySegment<Value, Arc<Type>> {
+impl<Value, Type> BitArraySegment<Value, Type> {
     #[must_use]
     pub fn has_native_option(&self) -> bool {
         self.options

compiler-core/src/error.rs

@@ -3684,6 +3684,25 @@ at once, which is not possible in bit arrays."),
                         extra_labels: vec![],
                     }),
                 },
+
+                TypeError::NonUtf8StringAssignmentInBitArray { location } => Diagnostic {
+                    title: "Non UTF-8 string assignment".to_string(),
+                    text:wrap("This pattern assigns a non UTF-8 string to a \
+variable in a bit array. This is planned to be supported in the future, but we are \
+unsure of the desired behaviour. Please go to https://github.com/gleam-lang/gleam/issues/4566 \
+and explain your usecase for this pattern, and how you would expect it to behave."),
+                    hint: None,
+                    level: Level::Error,
+                    location: Some(Location {
+                        label: Label {
+                            text: None,
+                            span: *location,
+                        },
+                        path: path.clone(),
+                        src: src.clone(),
+                        extra_labels: vec![],
+                    }),
+                },
             }
         }).collect_vec(),
 

compiler-core/src/type_/error.rs

@@ -633,6 +633,10 @@ pub enum Error {
     DoubleVariableAssignmentInBitArray {
         location: SrcSpan,
     },
+
+    NonUtf8StringAssignmentInBitArray {
+        location: SrcSpan,
+    },
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -1136,7 +1140,8 @@ impl Error {
             | Error::FloatOperatorOnInts { location, .. }
             | Error::IntOperatorOnFloats { location, .. }
             | Error::StringConcatenationWithAddInt { location }
-            | Error::DoubleVariableAssignmentInBitArray { location } => location.start,
+            | Error::DoubleVariableAssignmentInBitArray { location }
+            | Error::NonUtf8StringAssignmentInBitArray { location } => location.start,
 
             Error::UnknownLabels { unknown, .. } => {
                 unknown.iter().map(|(_, s)| s.start).min().unwrap_or(0)

compiler-core/src/type_/pattern.rs

@@ -423,6 +423,8 @@ impl<'a, 'b> PatternTyper<'a, 'b> {
             }
         }
 
+        let has_non_utf8_string_option = segment.has_utf16_option() || segment.has_utf32_option();
+
         let options: Vec<_> = segment
             .options
             .into_iter()
@@ -517,6 +519,11 @@ impl<'a, 'b> PatternTyper<'a, 'b> {
                     location: *location,
                 });
             }
+            Pattern::Assign { location, .. } if has_non_utf8_string_option => {
+                self.error(Error::NonUtf8StringAssignmentInBitArray {
+                    location: *location,
+                });
+            }
             _ => {}
         };
 

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

@@ -3120,3 +3120,8 @@ fn bit_array_using_pattern_variables() {
 fn bit_array_using_pattern_variables_from_other_bit_array() {
     assert_error!("let assert #(<<a>>, <<b:size(a)>>) = #(<<2>>, <<2:2>>)");
 }
+
+#[test]
+fn non_utf8_string_assignment() {
+    assert_error!(r#"let assert <<"Hello" as message:utf16>> = <<>>"#);
+}

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

@@ -0,0 +1,19 @@
+---
+source: compiler-core/src/type_/tests/errors.rs
+expression: "let assert <<\"Hello\" as message:utf16>> = <<>>"
+---
+----- SOURCE CODE
+let assert <<"Hello" as message:utf16>> = <<>>
+
+----- ERROR
+error: Non UTF-8 string assignment
+  ┌─ /src/one/two.gleam:1:25
+  │
+1 │ let assert <<"Hello" as message:utf16>> = <<>>
+  │                         ^^^^^^^
+
+This pattern assigns a non UTF-8 string to a variable in a bit array. This
+is planned to be supported in the future, but we are unsure of the desired
+behaviour. Please go to https://github.com/gleam-lang/gleam/issues/4566 and
+explain your usecase for this pattern, and how you would expect it to
+behave.