Get things compiling

compiler/can/src/pattern.rs

@@ -4,7 +4,7 @@ use crate::num::{finish_parsing_base, finish_parsing_float, finish_parsing_int};
 use crate::scope::Scope;
 use roc_module::ident::{Ident, Lowercase, TagName};
 use roc_module::symbol::Symbol;
-use roc_parse::ast;
+use roc_parse::ast::{self, StrLiteral, StrSegment};
 use roc_parse::pattern::PatternType;
 use roc_problem::can::{MalformedPatternProblem, Problem, RuntimeError};
 use roc_region::all::{Located, Region};
@@ -230,16 +230,8 @@ pub fn canonicalize_pattern<'a>(
             ptype => unsupported_pattern(env, ptype, region),
         },
 
-        StrLiteral(string) => match pattern_type {
-            WhenBranch => {
-                // TODO report whether string was malformed
-                Pattern::StrLiteral((*string).into())
-            }
-            ptype => unsupported_pattern(env, ptype, region),
-        },
-
-        BlockStrLiteral(_lines) => match pattern_type {
-            WhenBranch => todo!("TODO block string literal pattern"),
+        StrLiteral(literal) => match pattern_type {
+            WhenBranch => flatten_str_literal(literal),
             ptype => unsupported_pattern(env, ptype, region),
         },
 
@@ -473,3 +465,38 @@ fn add_bindings_from_patterns(
         | UnsupportedPattern(_) => (),
     }
 }
+
+fn flatten_str_literal(literal: &StrLiteral<'_>) -> Pattern {
+    use ast::StrLiteral::*;
+
+    match literal {
+        PlainLine(str_slice) => Pattern::StrLiteral((*str_slice).into()),
+        LineWithEscapes(segments) => flatten_str_lines(&[segments]),
+        Block(lines) => flatten_str_lines(lines),
+    }
+}
+
+fn flatten_str_lines(lines: &[&[StrSegment<'_>]]) -> Pattern {
+    use StrSegment::*;
+
+    let mut buf = String::new();
+
+    for line in lines {
+        for segment in line.iter() {
+            match segment {
+                Plaintext(string) => {
+                    buf.push_str(string);
+                }
+                Unicode(loc_digits) => {
+                    todo!("parse unicode digits {:?}", loc_digits);
+                }
+                Interpolated { region, .. } => {
+                    return Pattern::UnsupportedPattern(region.clone());
+                }
+                EscapedChar(ch) => buf.push(*ch),
+            }
+        }
+    }
+
+    Pattern::StrLiteral(buf.into())
+}