Parse iflet expressions

Author: tomgasson

src/napkin_core.ml

@@ -3014,7 +3014,7 @@ and parseElseBranch p =
   Parser.expect Rbrace p;
   blockExpr;
 
-and parseIfBody startPos p =
+and parseIfCore startPos p =
   let conditionExpr = parseIfCondition p in
   let thenExpr = parseIfBranch p in
   let elseExpr = match p.Parser.token with
@@ -3040,6 +3040,49 @@ and parseIfBody startPos p =
   let loc = mkLoc startPos p.prevEndPos in
   Ast_helper.Exp.ifthenelse ~loc conditionExpr thenExpr elseExpr
 
+and parseIfLet startPos p =
+  let pattern = parsePattern p in
+  Parser.expect Equal p;
+  let conditionExpr = parseIfCondition p in
+  let guard = parsePatternGuard p in
+  let thenExpr = parseIfBranch p in
+  let elseExpr = match p.Parser.token with
+  | Else ->
+    Parser.endRegion p;
+    Parser.leaveBreadcrumb p Grammar.ElseBranch;
+    Parser.next p;
+    Parser.beginRegion p;
+    let startPos = p.Parser.startPos in
+    let elseExpr = match p.token with
+    | If ->
+      Parser.next p;
+      parseIfBody startPos p
+    | _ ->
+      parseElseBranch p
+    in
+    Parser.eatBreadcrumb p;
+    Parser.endRegion p;
+    elseExpr
+  | _ ->
+    Parser.endRegion p;
+    let startPos = p.Parser.startPos in
+    let loc = mkLoc startPos p.prevEndPos in
+    Ast_helper.Exp.construct ~loc (Location.mkloc (Longident.Lident "()") loc) None
+  in
+  let loc = mkLoc startPos p.prevEndPos in
+  Ast_helper.Exp.match_ ~loc conditionExpr [
+    Ast_helper.Exp.case pattern ?guard thenExpr;
+    Ast_helper.Exp.case (Ast_helper.Pat.any ()) elseExpr;
+  ]
+
+and parseIfBody startPos p =
+  match p.Parser.token with
+    | Let ->
+      Parser.next p;
+      parseIfLet startPos p
+    | _ ->
+      parseIfCore startPos p
+
 and parseIfExpression p =
   Parser.beginRegion p;
   Parser.leaveBreadcrumb p Grammar.ExprIf;

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

@@ -503,7 +503,45 @@ let ifElseIfThen =
   if foo = bar
   then f ()
   else if foo = bar2 then f1 () else if foo = bar3 then f2 () else f3 ()
-let x = (if true then 1 else 2) + (if false then 2 else 3)"
+let x = (if true then 1 else 2) + (if false then 2 else 3)
+;;match foo () with | Some x -> doSomethingWithX x | _ -> ()
+;;match foo () with | Some x -> doSomethingWithX x | _ -> doSomethingElse ()
+;;match foo () with
+  | Some x -> doSomethingWithX x
+  | _ ->
+      (match bar () with
+       | Some y -> doSomethingWithY y
+       | _ -> doSomethingElse ())
+;;match foo () with
+  | Some x -> doSomethingWithX x
+  | _ -> if n > 10 then doSomethingWithForN () else doSomethingElse ()
+;;if n > 10
+  then doSomethingWithForN ()
+  else
+    (match foo () with
+     | Some x -> doSomethingWithX x
+     | _ -> doSomethingElse ())
+;;if n > 10
+  then ((doSomethingWithForN ())[@aa ])
+  else
+    (match ((foo ())[@dd ]) with
+     | ((Some ((x)[@cc ]))[@bb ]) -> ((doSomethingWithY x)[@ee ])
+     | _ -> ((doSomethingElse ())[@ff ]))
+;;match foo () with | Some x when x > 10 -> doSomethingWithX x | _ -> ()
+;;match foo () with
+  | Some x when x > 10 -> doSomethingWithX x
+  | _ ->
+      (match bar () with
+       | Some y when y > 10 -> doSomethingWithY y
+       | _ ->
+           (match baz () with
+            | Some z when z > 10 -> doSomethingWithZ z
+            | _ -> ()))
+;;match foo () with
+  | Some (Thing (With { many = Internal [|Components;q|] })) as p when
+      isValid q -> doSomethingWithE e
+  | _ -> ()
+let a = match foo () with | Some x when x > 10 -> x | _ -> 123"
 `;
 
 exports[`infix.js 1`] = `

tests/parsing/grammar/expressions/if.js

@@ -14,7 +14,7 @@ let ifThenElse = if foo {
    lala
 } else {
   doStuff(x, y, z,)
-} 
+}
 
 let ifElseIfThen =
   if foo == bar {
@@ -28,3 +28,82 @@ let ifElseIfThen =
   }
 
 let x = if true { 1 } else { 2 } + if false { 2 } else { 3 }
+
+// Basic
+if let Some(x) = foo() {
+    doSomethingWithX(x)
+}
+
+// Else branch
+if let Some(x) = foo(){
+    doSomethingWithX(x)
+} else {
+    doSomethingElse()
+}
+
+// Else-if support
+if let Some(x) = foo(){
+    doSomethingWithX(x)
+} else if let Some(y) = bar(){
+    doSomethingWithY(y)
+} else {
+    doSomethingElse()
+}
+
+// Mixed conditions, pattern start
+if let Some(x) = foo(){
+    doSomethingWithX(x)
+} else if n > 10 {
+    doSomethingWithForN()
+} else {
+    doSomethingElse()
+}
+
+// Mixed conditions, condition start
+if n > 10 {
+    doSomethingWithForN()
+} else if let Some(x) = foo() {
+    doSomethingWithX(x)
+} else {
+    doSomethingElse()
+}
+
+// Maintains attrs correctly
+if n > 10 {
+    @aa
+    doSomethingWithForN()
+} else if let @bb Some(@cc x) = @dd foo() {
+    @ee
+    doSomethingWithY(x)
+} else {
+    @ff
+    doSomethingElse()
+}
+
+// pattern guards are allowed
+if let Some(x) = foo() when x > 10 {
+    doSomethingWithX(x)
+}
+
+if let Some(x) = foo() when x > 10 {
+    doSomethingWithX(x)
+} else if let Some(y) = bar() when y > 10 {
+    doSomethingWithY(y)
+} else if let Some(z) = baz() when z > 10 {
+    doSomethingWithZ(z)
+}
+
+
+// full destructioning
+if let Some(Thing(With({
+  many: Internal([Components, q]),
+}))) as p = foo() when isValid(q) {
+  doSomethingWithE(e)
+}
+
+
+let a = if let Some(x) = foo() when x > 10 {
+    x
+} else {
+    123
+}