Fix Erlang UTF-16 and UTF-32 pattern matching

Author: GearsDatapacks

compiler-core/src/erlang.rs

@@ -1232,22 +1232,49 @@ fn let_assert<'a>(
     };
 
     let mut guards = vec![];
-    let pattern_document = pattern::to_doc(pattern, &mut vars, env, &mut guards);
+    let mut assignments = vec![];
+    let pattern_document = pattern::to_doc(pattern, &mut vars, env, &mut guards, &mut assignments);
     let clause_guard = optional_clause_guard(None, guards, env);
 
     let message = match message {
         Some(message) => expr(message, env),
         None => string("Pattern match failed, no pattern matched the value."),
     };
 
+    let mut variable_value = |name| {
+        for assignment in assignments.iter() {
+            // If we are compiling a pattern match such as the following:
+            // ```gleam
+            // let assert <<"Hello" as m:utf16>> = x
+            // ```
+            //
+            // We could do the same thing as we do in `case` expressions:
+            // ```erlang
+            // M@2 = case X of
+            //   <<M:10/binary>> when M =:= <<"Hello"/utf16>> ->
+            //     M@1 = <<"Hello"/utf8>>,
+            //     M@1;
+            //   _ -> erlang:error(...)
+            // end
+            // ```
+            //
+            // However, since we are always immediately returning the value
+            // assigned to this temporary variable, it is simpler to just return
+            // the value itself, rather then assigning then returning.
+            //
+            if assignment.variable == name {
+                return assignment.value.clone();
+            }
+        }
+        env.local_var_name(name)
+    };
+
     let value = match vars.as_slice() {
         _ if is_tail => subject.clone(),
         [] => "nil".to_doc(),
-        [variable] => env.local_var_name(variable),
+        [variable] => variable_value(variable),
         variables => {
-            let variables = variables
-                .iter()
-                .map(|variable| env.local_var_name(variable));
+            let variables = variables.iter().map(|name| variable_value(name));
             docvec![
                 break_("{", "{"),
                 join(variables, break_(",", ", ")).nest(INDENT),
@@ -1311,7 +1338,10 @@ fn let_assert<'a>(
 fn let_<'a>(value: &'a TypedExpr, pat: &'a TypedPattern, env: &mut Env<'a>) -> Document<'a> {
     let body = maybe_block_expr(value, env).group();
     let mut guards = vec![];
-    pattern(pat, env, &mut guards).append(" = ").append(body)
+    let mut assignments = vec![];
+    pattern(pat, env, &mut guards, &mut assignments)
+        .append(" = ")
+        .append(body)
 }
 
 fn float<'a>(value: &str) -> Document<'a> {
@@ -1518,30 +1548,46 @@ fn clause<'a>(clause: &'a TypedClause, env: &mut Env<'a>) -> Document<'a> {
             .chain(alternative_patterns)
             .map(|patterns| {
                 let mut additional_guards = vec![];
+                let mut assignments = vec![];
                 env.erl_function_scope_vars = initial_erlang_vars.clone();
 
                 let patterns_doc = if patterns.len() == 1 {
                     let p = patterns.first().expect("Single pattern clause printing");
-                    pattern(p, env, &mut additional_guards)
+                    pattern(p, env, &mut additional_guards, &mut assignments)
                 } else {
                     tuple(
                         patterns
                             .iter()
-                            .map(|p| pattern(p, env, &mut additional_guards)),
+                            .map(|p| pattern(p, env, &mut additional_guards, &mut assignments)),
                     )
                 };
 
                 let guard = optional_clause_guard(guard.as_ref(), additional_guards, env);
+
+                let assignments = assignments
+                    .into_iter()
+                    .map(|assignment| {
+                        docvec![
+                            line(),
+                            env.next_local_var_name(assignment.variable),
+                            " = ",
+                            assignment.value,
+                            ","
+                        ]
+                        .nest(INDENT)
+                    })
+                    .collect_vec();
+
                 if then_doc.is_none() {
                     then_doc = Some(clause_consequence(then, env));
                     end_erlang_vars = env.erl_function_scope_vars.clone();
                 }
 
-                patterns_doc.append(
-                    guard
-                        .append(" ->")
-                        .append(line().append(then_doc.clone()).nest(INDENT).group()),
-                )
+                patterns_doc
+                    .append(guard)
+                    .append(" ->")
+                    .append(assignments)
+                    .append(line().append(then_doc.clone()).nest(INDENT).group())
             }),
         ";".to_doc().append(lines(2)),
     );

compiler-core/src/erlang/pattern.rs

@@ -9,33 +9,40 @@ use crate::{
 
 use super::*;
 
+pub(super) struct PatternAssignment<'a> {
+    pub variable: &'a EcoString,
+    pub value: Document<'a>,
+}
+
 pub(super) fn pattern<'a>(
     p: &'a TypedPattern,
     env: &mut Env<'a>,
     guards: &mut Vec<Document<'a>>,
+    assignments: &mut Vec<PatternAssignment<'a>>,
 ) -> Document<'a> {
     let mut vars = vec![];
-    to_doc(p, &mut vars, env, guards)
+    to_doc(p, &mut vars, env, guards, assignments)
 }
 
 fn print<'a>(
     p: &'a TypedPattern,
     vars: &mut Vec<&'a str>,
     env: &mut Env<'a>,
     guards: &mut Vec<Document<'a>>,
+    assignments: &mut Vec<PatternAssignment<'a>>,
 ) -> Document<'a> {
     match p {
         Pattern::Assign {
             name, pattern: p, ..
         } => {
             vars.push(name);
-            print(p, vars, env, guards)
+            print(p, vars, env, guards, assignments)
                 .append(" = ")
                 .append(env.next_local_var_name(name))
         }
 
         Pattern::List { elements, tail, .. } => {
-            pattern_list(elements, tail.as_deref(), vars, env, guards)
+            pattern_list(elements, tail.as_deref(), vars, env, guards, assignments)
         }
 
         Pattern::Discard { .. } => "_".to_doc(),
@@ -70,7 +77,7 @@ fn print<'a>(
             arguments: args,
             constructor: Inferred::Known(PatternConstructor { name, .. }),
             ..
-        } => tag_tuple_pattern(name, args, vars, env, guards),
+        } => tag_tuple_pattern(name, args, vars, env, guards, assignments),
 
         Pattern::Constructor {
             constructor: Inferred::Unknown,
@@ -79,14 +86,16 @@ fn print<'a>(
             panic!("Erlang generation performed with uninferred pattern constructor")
         }
 
-        Pattern::Tuple { elements, .. } => {
-            tuple(elements.iter().map(|p| print(p, vars, env, guards)))
-        }
+        Pattern::Tuple { elements, .. } => tuple(
+            elements
+                .iter()
+                .map(|p| print(p, vars, env, guards, assignments)),
+        ),
 
         Pattern::BitArray { segments, .. } => bit_array(
             segments
                 .iter()
-                .map(|s| pattern_segment(&s.value, &s.options, vars, env, guards)),
+                .map(|s| pattern_segment(s, vars, env, guards, assignments)),
         ),
 
         Pattern::StringPrefix {
@@ -150,8 +159,9 @@ pub(super) fn to_doc<'a>(
     vars: &mut Vec<&'a str>,
     env: &mut Env<'a>,
     guards: &mut Vec<Document<'a>>,
+    assignments: &mut Vec<PatternAssignment<'a>>,
 ) -> Document<'a> {
-    print(p, vars, env, guards)
+    print(p, vars, env, guards, assignments)
 }
 
 fn tag_tuple_pattern<'a>(
@@ -160,39 +170,48 @@ fn tag_tuple_pattern<'a>(
     vars: &mut Vec<&'a str>,
     env: &mut Env<'a>,
     guards: &mut Vec<Document<'a>>,
+    assignments: &mut Vec<PatternAssignment<'a>>,
 ) -> Document<'a> {
     if args.is_empty() {
         atom_string(to_snake_case(name))
     } else {
         tuple(
-            [atom_string(to_snake_case(name))]
-                .into_iter()
-                .chain(args.iter().map(|p| print(&p.value, vars, env, guards))),
+            [atom_string(to_snake_case(name))].into_iter().chain(
+                args.iter()
+                    .map(|p| print(&p.value, vars, env, guards, assignments)),
+            ),
         )
     }
 }
 
 fn pattern_segment<'a>(
-    value: &'a TypedPattern,
-    options: &'a [BitArrayOption<TypedPattern>],
+    segment: &'a TypedPatternBitArraySegment,
     vars: &mut Vec<&'a str>,
     env: &mut Env<'a>,
     guards: &mut Vec<Document<'a>>,
+    assignments: &mut Vec<PatternAssignment<'a>>,
 ) -> Document<'a> {
+    let value = segment.value.as_ref();
+
     let pattern_is_a_string_literal = matches!(value, Pattern::String { .. });
     let pattern_is_a_discard = matches!(value, Pattern::Discard { .. });
 
     let vars = RefCell::new(vars);
     let guards = RefCell::new(guards);
+    let assignments = RefCell::new(assignments);
 
     let create_document = |env: &mut Env<'a>| match value {
         Pattern::String { value, .. } => value.to_doc().surround("\"", "\""),
         Pattern::Discard { .. }
         | Pattern::Variable { .. }
         | Pattern::Int { .. }
-        | Pattern::Float { .. } => {
-            print(value, &mut vars.borrow_mut(), env, &mut guards.borrow_mut())
-        }
+        | Pattern::Float { .. } => print(
+            value,
+            &mut vars.borrow_mut(),
+            env,
+            &mut guards.borrow_mut(),
+            &mut assignments.borrow_mut(),
+        ),
 
         Pattern::Assign { name, pattern, .. } => {
             vars.borrow_mut().push(name);
@@ -219,18 +238,38 @@ fn pattern_segment<'a>(
                 // it afterwards.
                 Pattern::String { value, .. } => {
                     let escaped = convert_string_escape_chars(value);
-                    let (utf_option, string_length) = if options
-                        .iter()
-                        .any(|option| matches!(option, BitArrayOption::Utf16 { .. }))
-                    {
+                    let (utf_option, string_length) = if segment.has_utf16_option() {
+                        assignments.borrow_mut().push(PatternAssignment {
+                            variable: name,
+                            value: string(value),
+                        });
+
+                        let option = if segment.has_native_option() {
+                            "utf16-native"
+                        } else if segment.endianness().is_big() {
+                            "utf16"
+                        } else {
+                            "utf16-little"
+                        };
+
                         // Each UTF-16 codepoint is 2 bytes
-                        ("utf16", length_utf16(&escaped) * 2)
-                    } else if options
-                        .iter()
-                        .any(|option| matches!(option, BitArrayOption::Utf32 { .. }))
-                    {
+                        (option, length_utf16(&escaped) * 2)
+                    } else if segment.has_utf32_option() {
+                        assignments.borrow_mut().push(PatternAssignment {
+                            variable: name,
+                            value: string(value),
+                        });
+
+                        let option = if segment.has_native_option() {
+                            "utf32-native"
+                        } else if segment.endianness().is_big() {
+                            "utf32"
+                        } else {
+                            "utf32-little"
+                        };
+
                         // Each UTF-32 codepoint is 4 bytes
-                        ("utf32", length_utf32(&escaped) * 4)
+                        (option, length_utf32(&escaped) * 4)
                     } else {
                         ("utf8", escaped.len())
                     };
@@ -266,14 +305,15 @@ fn pattern_segment<'a>(
             &mut vars.borrow_mut(),
             env,
             &mut guards.borrow_mut(),
+            &mut assignments.borrow_mut(),
         )))
     };
 
     let unit = |value: &'a u8| Some(eco_format!("unit:{value}").to_doc());
 
     bit_array_segment(
         create_document,
-        options,
+        &segment.options,
         size,
         unit,
         pattern_is_a_string_literal,
@@ -288,13 +328,14 @@ fn pattern_list<'a>(
     vars: &mut Vec<&'a str>,
     env: &mut Env<'a>,
     guards: &mut Vec<Document<'a>>,
+    assignments: &mut Vec<PatternAssignment<'a>>,
 ) -> Document<'a> {
     let elements = join(
         elements
             .iter()
-            .map(|element| print(element, vars, env, guards)),
+            .map(|element| print(element, vars, env, guards, assignments)),
         break_(",", ", "),
     );
-    let tail = tail.map(|tail| print(tail, vars, env, guards));
+    let tail = tail.map(|tail| print(tail, vars, env, guards, assignments));
     list(elements, tail)
 }