Revert Erlang pattern matching change

Author: GearsDatapacks

compiler-core/src/erlang.rs

@@ -1232,49 +1232,22 @@ fn let_assert<'a>(
     };
 
     let mut guards = vec![];
-    let mut assignments = vec![];
-    let pattern_document = pattern::to_doc(pattern, &mut vars, env, &mut guards, &mut assignments);
+    let pattern_document = pattern::to_doc(pattern, &mut vars, env, &mut guards);
     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] => variable_value(variable),
+        [variable] => env.local_var_name(variable),
         variables => {
-            let variables = variables.iter().map(|name| variable_value(name));
+            let variables = variables
+                .iter()
+                .map(|variable| env.local_var_name(variable));
             docvec![
                 break_("{", "{"),
                 join(variables, break_(",", ", ")).nest(INDENT),
@@ -1338,10 +1311,7 @@ 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![];
-    let mut assignments = vec![];
-    pattern(pat, env, &mut guards, &mut assignments)
-        .append(" = ")
-        .append(body)
+    pattern(pat, env, &mut guards).append(" = ").append(body)
 }
 
 fn float<'a>(value: &str) -> Document<'a> {
@@ -1548,46 +1518,30 @@ 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, &mut assignments)
+                    pattern(p, env, &mut additional_guards)
                 } else {
                     tuple(
                         patterns
                             .iter()
-                            .map(|p| pattern(p, env, &mut additional_guards, &mut assignments)),
+                            .map(|p| pattern(p, env, &mut additional_guards)),
                     )
                 };
 
                 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(assignments)
-                    .append(line().append(then_doc.clone()).nest(INDENT).group())
+                patterns_doc.append(
+                    guard
+                        .append(" ->")
+                        .append(line().append(then_doc.clone()).nest(INDENT).group()),
+                )
             }),
         ";".to_doc().append(lines(2)),
     );

compiler-core/src/erlang/pattern.rs

@@ -6,40 +6,33 @@ use crate::analyse::Inferred;
 
 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, assignments)
+    to_doc(p, &mut vars, env, guards)
 }
 
 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, assignments)
+            print(p, vars, env, guards)
                 .append(" = ")
                 .append(env.next_local_var_name(name))
         }
 
         Pattern::List { elements, tail, .. } => {
-            pattern_list(elements, tail.as_deref(), vars, env, guards, assignments)
+            pattern_list(elements, tail.as_deref(), vars, env, guards)
         }
 
         Pattern::Discard { .. } => "_".to_doc(),
@@ -74,7 +67,7 @@ fn print<'a>(
             arguments: args,
             constructor: Inferred::Known(PatternConstructor { name, .. }),
             ..
-        } => tag_tuple_pattern(name, args, vars, env, guards, assignments),
+        } => tag_tuple_pattern(name, args, vars, env, guards),
 
         Pattern::Constructor {
             constructor: Inferred::Unknown,
@@ -83,16 +76,14 @@ fn print<'a>(
             panic!("Erlang generation performed with uninferred pattern constructor")
         }
 
-        Pattern::Tuple { elements, .. } => tuple(
-            elements
-                .iter()
-                .map(|p| print(p, vars, env, guards, assignments)),
-        ),
+        Pattern::Tuple { elements, .. } => {
+            tuple(elements.iter().map(|p| print(p, vars, env, guards)))
+        }
 
         Pattern::BitArray { segments, .. } => bit_array(
             segments
                 .iter()
-                .map(|s| pattern_segment(s, vars, env, guards, assignments)),
+                .map(|s| pattern_segment(&s.value, &s.options, vars, env, guards)),
         ),
 
         Pattern::StringPrefix {
@@ -156,9 +147,8 @@ 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, assignments)
+    print(p, vars, env, guards)
 }
 
 fn tag_tuple_pattern<'a>(
@@ -167,62 +157,39 @@ 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, assignments)),
-            ),
+            [atom_string(to_snake_case(name))]
+                .into_iter()
+                .chain(args.iter().map(|p| print(&p.value, vars, env, guards))),
         )
     }
 }
 
 fn pattern_segment<'a>(
-    segment: &'a TypedPatternBitArraySegment,
+    value: &'a TypedPattern,
+    options: &'a [BitArrayOption<TypedPattern>],
     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 = match value {
-        Pattern::String { .. } => true,
-        Pattern::Assign { pattern, .. } => pattern.is_string(),
-        Pattern::Int { .. }
-        | Pattern::Float { .. }
-        | Pattern::Variable { .. }
-        | Pattern::VarUsage { .. }
-        | Pattern::Discard { .. }
-        | Pattern::List { .. }
-        | Pattern::Constructor { .. }
-        | Pattern::Tuple { .. }
-        | Pattern::BitArray { .. }
-        | Pattern::StringPrefix { .. }
-        | Pattern::Invalid { .. } => false,
-    };
+    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(),
-            &mut assignments.borrow_mut(),
-        ),
+        | Pattern::Float { .. } => {
+            print(value, &mut vars.borrow_mut(), env, &mut guards.borrow_mut())
+        }
 
         Pattern::Assign { name, pattern, .. } => {
             vars.borrow_mut().push(name);
@@ -244,24 +211,16 @@ fn pattern_segment<'a>(
                     variable_name
                 }
 
-                // If we are assigning to a string which is UTF-16 or UTF-32, we cannot simply use
-                // variable patterns and guards like we do with other segments. Gleam strings are
-                // UTF-8 so we must anyway bind the correct value to the variable. We generate code
-                // that looks like this:
-                //
-                // ```erlang
-                // case X of
-                //   <<"Hello"/utf16>> ->
-                //     Message = <<"Hello"/utf8>>,
-                //     <clause body>
-                // end.
-                // ```
+                // Here we do the same as for floats and ints, but we must calculate the size of
+                // the string first, so we can correctly match the bit array segment then compare
+                // it afterwards.
                 Pattern::String { value, .. } => {
-                    assignments.borrow_mut().push(PatternAssignment {
-                        variable: name,
-                        value: string(value),
-                    });
-                    value.to_doc().surround("\"", "\"")
+                    guards.borrow_mut().push(docvec![
+                        variable_name.clone(),
+                        " =:= ",
+                        string(value)
+                    ]);
+                    docvec![variable_name, ":", string_length_utf8_bytes(value)]
                 }
 
                 // Doing a pattern such as `<<_ as a>>` is the same as just `<<a>>`, so we treat it
@@ -283,15 +242,14 @@ 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,
-        &segment.options,
+        options,
         size,
         unit,
         pattern_is_a_string_literal,
@@ -306,14 +264,13 @@ 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, assignments)),
+            .map(|element| print(element, vars, env, guards)),
         break_(",", ", "),
     );
-    let tail = tail.map(|tail| print(tail, vars, env, guards, assignments));
+    let tail = tail.map(|tail| print(tail, vars, env, guards));
     list(elements, tail)
 }