Add support for parsing template literals in patterns. (#326)

* Add support for parsing template literals in patterns.

* Add extra conversion test for template literals in pattern matching

Author: IwanKaramazow

src/res_ast_conversion.ml

@@ -355,6 +355,17 @@ let normalize =
       | Ppat_open ({txt = longidentOpen}, pattern) ->
         let p = rewritePpatOpen longidentOpen pattern in
         default_mapper.pat mapper p
+      | Ppat_constant (Pconst_string (txt, tag)) ->
+        let newTag = match tag with
+        (* transform {|abc|} into {js|abc|js}, because `template string` is interpreted as {js||js} *)
+        | Some "" -> Some "js"
+        | tag -> tag
+        in
+        let s = Parsetree.Pconst_string ((escapeTemplateLiteral txt), newTag) in
+        {p with
+          ppat_attributes = mapper.attributes mapper p.ppat_attributes;
+          ppat_desc = Ppat_constant s
+        }
       | _ ->
         default_mapper.pat mapper p
     end;

src/res_core.ml

@@ -109,6 +109,9 @@ Solution: directly use `concat`."
       "A labeled parameter starts with a `~`."
     else
       ("A labeled parameter starts with a `~`. Did you mean: `~" ^ name ^ "`?")
+
+  let stringInterpolationInPattern =
+    "String interpolation is not supported in pattern matching."
 end
 
 
@@ -903,6 +906,27 @@ let parseConstant p =
   Parser.next p;
   constant
 
+let parseTemplateConstant ~prefix (p : Parser.t) =
+  (* Arrived at the ` char *)
+  let startPos = p.startPos in
+  Parser.nextTemplateLiteralToken p;
+  match p.token with
+  | TemplateTail txt ->
+    Parser.next p;
+    let txt = if p.mode = ParseForTypeChecker then parseTemplateStringLiteral txt else txt in
+    Parsetree.Pconst_string (txt, prefix)
+  | _ ->
+    let rec skipTokens () =
+      Parser.next p;
+      match p.token with
+      | Backtick -> Parser.next p; ()
+      | _ -> skipTokens ()
+    in
+    skipTokens ();
+    Parser.err ~startPos ~endPos:p.prevEndPos p
+      (Diagnostics.message ErrorMessages.stringInterpolationInPattern);
+    Pconst_string ("", None)
+
 let parseCommaDelimitedRegion p ~grammar ~closing ~f =
   Parser.leaveBreadcrumb p grammar;
   let rec loop nodes =
@@ -1076,6 +1100,9 @@ let rec parsePattern ?(alias=true) ?(or_=true) p =
       | _ ->
         Ast_helper.Pat.constant ~loc:(mkLoc startPos p.prevEndPos) c
     end
+  | Backtick ->
+    let constant = parseTemplateConstant ~prefix:(Some "js") p in
+    Ast_helper.Pat.constant ~loc:(mkLoc startPos p.prevEndPos) constant
   | Lparen ->
     Parser.next p;
     begin match p.token with
@@ -1109,7 +1136,13 @@ let rec parsePattern ?(alias=true) ?(or_=true) p =
     let endPos = p.endPos in
     let loc = mkLoc startPos endPos in
     Parser.next p;
-    Ast_helper.Pat.var ~loc ~attrs (Location.mkloc ident loc)
+    begin match p.token with
+    | Backtick ->
+      let constant = parseTemplateConstant ~prefix:(Some ident) p in
+      Ast_helper.Pat.constant ~loc:(mkLoc startPos p.prevEndPos) constant
+    | _ ->
+      Ast_helper.Pat.var ~loc ~attrs (Location.mkloc ident loc)
+    end
   | Uident _ ->
     let constr = parseModuleLongIdent ~lowercase:false p in
     begin match p.Parser.token with

src/res_grammar.ml

@@ -136,7 +136,7 @@ let isSignatureItemStart = function
   | _ -> false
 
 let isAtomicPatternStart = function
-  | Token.Int _ | String _ | Character _
+  | Token.Int _ | String _ | Character _ | Backtick
   | Lparen | Lbracket | Lbrace
   | Underscore
   | Lident _ | Uident _ | List
@@ -196,7 +196,7 @@ let isStructureItemStart = function
   | _ -> false
 
 let isPatternStart = function
-  | Token.Int _ | Float _ | String _ | Character _ | True | False | Minus | Plus
+  | Token.Int _ | Float _ | String _ | Character _ | Backtick | True | False | Minus | Plus
   | Lparen | Lbracket | Lbrace | List
   | Underscore
   | Lident _ | Uident _ | Hash

tests/conversion/reason/__snapshots__/render.spec.js.snap

@@ -1583,6 +1583,15 @@ let x = \`/*https://www.apple.com*/\`
 let x = sql\`/*https://www.apple.com*/\`
 
 let x = \`\\\\\`https://\\\\\${appleWebsite}\\\\\`\`
+
+let var1 = \\"three\\"
+let var2 = \\"a string\\"
+
+switch (var1, var2) {
+| (\`3\`, \`a string\`) => Js.log(\\"worked\\")
+| (\` test with \\\\\` \\\\\${here} \\\\\`\`, _) => Js.log(\\"escapes \` and \${\\")
+| _ => Js.log(\\"didn't match\\")
+}
 "
 `;
 

tests/conversion/reason/string.re

@@ -27,3 +27,12 @@ let x = {|/*https://www.apple.com*/|};
 let x = {sql|/*https://www.apple.com*/|sql};
 
 let x = {js|`https://${appleWebsite}`|js};
+
+let var1 = "three"
+let var2 = "a string";
+
+switch (var1, var2) {
+| ({|3|}, {|a string|}) => Js.log("worked")
+| ({| test with ` ${here} `|}, _) => Js.log("escapes ` and ${")
+| _ => Js.log("didn't match")
+};

tests/parsing/errors/pattern/__snapshots__/parse.spec.js.snap

@@ -50,3 +50,45 @@ let 4 = for [%rescript.patternhole ] = 0 to 10 do Js.log \\"for\\" done
 
 ========================================================"
 `;
+
+exports[`templateLiteral.res 1`] = `
+"=====Parsetree==========================================
+let zeroCoord = \\"0.0\\"
+;;match l with | \\"\\" -> () | \\"\\" -> () | _ -> ()
+=====Errors=============================================
+
+  Syntax error!
+  parsing/errors/pattern/templateLiteral.res:4:3-27  
+  2 │ 
+  3 │ switch l {
+  4 │ | \`zero coord \${zeroCoord}\` => ()
+  5 │ | \`first coord \${zeroCoord} snd \${zeroCoord} \` => ()
+  6 │ | _ => ()
+  
+  String interpolation is not supported in pattern matching.
+
+
+  Syntax error!
+  parsing/errors/pattern/templateLiteral.res:5:33  
+  3 │ switch l {
+  4 │ | \`zero coord \${zeroCoord}\` => ()
+  5 │ | \`first coord \${zeroCoord} snd \${zeroCoord} \` => ()
+  6 │ | _ => ()
+  7 │ }
+  
+  Not sure what to do with this character.
+
+
+  Syntax error!
+  parsing/errors/pattern/templateLiteral.res:5:3-46  
+  3 │ switch l {
+  4 │ | \`zero coord \${zeroCoord}\` => ()
+  5 │ | \`first coord \${zeroCoord} snd \${zeroCoord} \` => ()
+  6 │ | _ => ()
+  7 │ }
+  
+  String interpolation is not supported in pattern matching.
+
+
+========================================================"
+`;

tests/parsing/errors/pattern/templateLiteral.res

@@ -0,0 +1,7 @@
+let zeroCoord = "0.0" 
+
+switch l {
+| `zero coord ${zeroCoord}` => ()
+| `first coord ${zeroCoord} snd ${zeroCoord} ` => ()
+| _ => ()
+}

tests/parsing/grammar/pattern/__snapshots__/parse.spec.js.snap

@@ -131,7 +131,23 @@ let (-1)..(-1.) = x
   | ((-3.14) : float) -> true
   | (lazy 5.678) -> true
   | exception 19.34 -> true
-  | _ -> false"
+  | _ -> false
+;;match literal with
+  | {js|literal|js} -> true
+  | ({js|literal1|js}, {js|literal2|js}) -> true
+  | [|{js|literal1|js};{js|literal2|js}|] -> true
+  | {js|literal1|js}::{js|literal2|js}::[] -> true
+  | { x = {js|literal1|js}; y = {js|literal2|js} } -> true
+  | Constructor ({js|literal1|js}, {js|literal2|js}) -> true
+  | \`Constuctor ({js|literal1|js}, {js|literal2|js}) -> true
+  | {js|literal|js} as x -> true
+  | {js|literal|js}|{js|literal|js} -> true
+  | ({js|literal|js} : string) -> true
+  | (lazy {js|literal|js}) -> true
+  | exception {js|literal|js} -> true
+  | _ -> false
+let {js|literal constant|js} = x
+;;for {js|literal constant|js} = 0 to 10 do () done"
 `;
 
 exports[`constraint.js 1`] = `

tests/parsing/grammar/pattern/constant.js

@@ -83,3 +83,23 @@ switch science {
 | exception 19.34 => true
 | _ => false
 }
+
+switch literal {
+| `literal` => true
+| (`literal1`, `literal2`) => true
+| [`literal1`, `literal2`] => true
+| list{`literal1`, `literal2`} => true
+| {x: `literal1`, y: `literal2`} => true
+| Constructor(`literal1`, `literal2`) => true
+| #Constuctor(`literal1`, `literal2`) => true
+| `literal` as x => true
+| `literal` | `literal` => true
+| (`literal` : string) => true
+| lazy `literal`  => true
+| exception `literal` => true
+| _ => false
+}
+
+let `literal constant` = x
+
+for `literal constant` in 0 to 10 { () }

tests/printer/pattern/__snapshots__/render.spec.js.snap

@@ -64,6 +64,28 @@ switch science {
     </div>
   }}
 </div>
+
+switch literal {
+| \`literal\` => true
+| (\`literal1\`, \`literal2\`) => true
+| [\`literal1\`, \`literal2\`] => true
+| list{\`literal1\`, \`literal2\`} => true
+| {x: \`literal1\`, y: \`literal2\`} => true
+| Constructor(\`literal1\`, \`literal2\`) => true
+| #Constuctor(\`literal1\`, \`literal2\`) => true
+| \`literal\` as x => true
+| \`literal\` | \`literal\` => true
+| (\`literal\`: string) => true
+| lazy \`literal\` => true
+| exception \`literal\` => true
+| _ => false
+}
+
+let \`literal constant\` = x
+
+for \`literal constant\` in 0 to 10 {
+  ()
+}
 "
 `;