dotnet · TD5 · Sep 5, 2018 · Sep 5, 2018 · Sep 5, 2018 · Sep 5, 2018
diff --git a/src/buildfromsource/FSharp.Compiler.Private/FSComp.fs b/src/buildfromsource/FSharp.Compiler.Private/FSComp.fs
diff --git a/src/buildfromsource/FSharp.Compiler.Private/FSComp.resx b/src/buildfromsource/FSharp.Compiler.Private/FSComp.resx
diff --git a/src/fsharp/CompileOps.fs b/src/fsharp/CompileOps.fs
@@ -1004,6 +1004,8 @@ let OutputPhasedErrorR (os: StringBuilder) (err: PhasedDiagnostic) (canSuggestNa
               | Parser.TOKEN_OLET(_) -> getErrorString("Parser.TOKEN.OLET")
               | Parser.TOKEN_OBINDER 
               | Parser.TOKEN_BINDER -> getErrorString("Parser.TOKEN.BINDER")
+              | Parser.TOKEN_OAND_BANG 
+              | Parser.TOKEN_AND_BANG -> getErrorString("Parser.TOKEN.AND.BANG")
               | Parser.TOKEN_ODO -> getErrorString("Parser.TOKEN.ODO")
               | Parser.TOKEN_OWITH -> getErrorString("Parser.TOKEN.OWITH")
               | Parser.TOKEN_OFUNCTION -> getErrorString("Parser.TOKEN.OFUNCTION")

diff --git a/src/fsharp/FSComp.txt b/src/fsharp/FSComp.txt
@@ -1466,6 +1466,11 @@ notAFunctionButMaybeDeclaration,"This value is not a function and cannot be appl
 3251,chkNoFirstClassNameOf,"Using the 'nameof' operator as a first-class function value is not permitted."
 3300,chkInvalidFunctionParameterType,"The parameter '%s' has an invalid type '%s'. This is not permitted by the rules of Common IL."
 3301,chkInvalidFunctionReturnType,"The function or method has an invalid return type '%s'. This is not permitted by the rules of Common IL."
+3343,tcApplicativeComputationExpressionNotImmediatelyTerminatedWithReturn,"Expecting 'and!', 'anduse!' or 'return' but saw something else. Applicative computation expressions must be of the form 'let! <pat1> = <expr2> and! <pat2> = <expr2> and! ... and! <patN> = <exprN> return <exprBody>'."
+3344,tcInvalidAndUseBangBinding,"Pattern matching is not allowed on the left-hand side of the equals. 'use! ... anduse! ...' bindings must be of the form 'use! <var> = <expr>' or 'anduse! <var> = <expr>'."
+3345,tcInvalidKeywordInsteadOfReturnInApplicativeComputationExpression,"'%s' is not valid in this position in an applicative computation expression. Did you mean 'return' instead?"
+3346,parsNoBodyInApplicativeComputationExpression,"No body given after the applicative bindings. Expected a 'return' to terminate this applicative computation expression."
+3347,tcMoreAfterReturnInApplicativeComputationExpression,"Saw unexpected expression sequenced after 'return'. Applicative computation expressions must be terminated with a single 'return'."
 useSdkRefs,"Use reference assemblies for .NET framework references when available (Enabled by default)."
 fSharpBannerVersion,"%s for F# %s"
 nativeResourceFormatError,"Stream does not begin with a null resource and is not in '.RES' format."

diff --git a/src/fsharp/FSStrings.resx b/src/fsharp/FSStrings.resx
@@ -561,6 +561,9 @@
   <data name="Parser.TOKEN.AND" xml:space="preserve">
     <value>keyword 'and'</value>
   </data>
+  !<data name="Parser.TOKEN.AND.BANG" xml:space="preserve">
+    <value>keyword 'and!'</value>
+  </data>
   <data name="Parser.TOKEN.AS" xml:space="preserve">
     <value>keyword 'as'</value>
   </data>

diff --git a/src/fsharp/LexFilter.fs b/src/fsharp/LexFilter.fs
@@ -1737,6 +1737,13 @@ type LexFilterImpl (lightSyntaxStatus: LightSyntaxStatus, compilingFsLib, lexer,
             pushCtxt tokenTup (CtxtLetDecl(blockLet, tokenStartPos))
             returnToken tokenLexbufState (if blockLet then OBINDER b else token)
 
+        //  and!  ... ~~~> CtxtLetDecl 
+        | AND_BANG isUse, (ctxt :: _) -> 
+            let blockLet = match ctxt with CtxtSeqBlock _ -> true | _ -> false
+            if debug then dprintf "AND!: entering CtxtLetDecl(blockLet=%b), awaiting EQUALS to go to CtxtSeqBlock (%a)\n" blockLet outputPos tokenStartPos
+            pushCtxt tokenTup (CtxtLetDecl(blockLet,tokenStartPos))
+            returnToken tokenLexbufState (if blockLet then OAND_BANG isUse else token)
+
         | (VAL | STATIC | ABSTRACT | MEMBER | OVERRIDE | DEFAULT), ctxtStack when thereIsACtxtMemberBodyOnTheStackAndWeShouldPopStackForUpcomingMember ctxtStack -> 
             if debug then dprintf "STATIC/MEMBER/OVERRIDE/DEFAULT: already inside CtxtMemberBody, popping all that context before starting next member...\n"
             // save this token, we'll consume it again later...

diff --git a/src/fsharp/TypeChecker.fs b/src/fsharp/TypeChecker.fs
diff --git a/src/fsharp/ast.fs b/src/fsharp/ast.fs
@@ -766,12 +766,16 @@ and
     /// Computation expressions only
     | YieldOrReturnFrom of (bool * bool) * expr: SynExpr * range: range
 
-    /// SynExpr.LetOrUseBang (spBind, isUse, isFromSource, pat, rhsExpr, bodyExpr, mWholeExpr).
+    /// SynExpr.LetOrUseAndBang (spBind, isUse, isFromSource, pat, rhsExpr, mLetBangExpr, [(andBangSpBind, andBangIsUse, andBangIsFromSource, andBangPat, andBangRhsExpr, mAndBangExpr)], bodyExpr).
     ///
     /// F# syntax: let! pat = expr in expr
     /// F# syntax: use! pat = expr in expr
+    /// F# syntax: let! pat = expr and! ... and! ... and! pat = expr in expr
+    /// F# syntax: use! pat = expr and! ... and! ... and! pat = expr in expr
+    /// F# syntax: let! pat = expr anduse! ... and! ... and! pat = expr in expr
+    /// F# syntax: use! pat = expr and! ... anduse! ... and! pat = expr in expr
     /// Computation expressions only
-    | LetOrUseBang of bindSeqPoint: SequencePointInfoForBinding * isUse: bool * isFromSource: bool * SynPat * SynExpr * SynExpr * range: range
+    | LetOrUseBang of bindSeqPoint: SequencePointInfoForBinding * isUse: bool * isFromSource: bool * SynPat * rhs:SynExpr * range:range * andBangs:(SequencePointInfoForBinding * bool * bool * SynPat * SynExpr * range) list * body:SynExpr
 
     /// F# syntax: match! expr with pat1 -> expr | ... | patN -> exprN
     | MatchBang of  matchSeqPoint: SequencePointInfoForBinding * expr: SynExpr * clauses: SynMatchClause list * range: range (* bool indicates if this is an exception match in a computation expression which throws unmatched exceptions *)
@@ -2484,6 +2488,6 @@ let rec synExprContainsError inpExpr =
 
           | SynExpr.MatchBang (_, e, cl, _) ->
               walkExpr e || walkMatchClauses cl
-          | SynExpr.LetOrUseBang  (_, _, _, _, e1, e2, _) ->
-              walkExpr e1 || walkExpr e2
+          | SynExpr.LetOrUseBang  (rhs=e1;body=e2;andBangs=es) ->
+              walkExpr e1 || walkExprs [ for (_,_,_,_,e,_) in es do yield e ] || walkExpr e2
     walkExpr inpExpr
diff --git a/src/fsharp/lex.fsl b/src/fsharp/lex.fsl
@@ -233,10 +233,14 @@ rule token args skip = parse
      { YIELD_BANG(false) } 
  | "match!"
      { MATCH_BANG }
+ | "and!"
+     { AND_BANG(false) }
+ | "anduse!"
+     { AND_BANG(true) }
  | ident '!' 
      { let tok = Keywords.KeywordOrIdentifierToken args lexbuf (lexemeTrimRight lexbuf 1) 
        match tok with 
-       | LET _ -> BINDER (lexemeTrimRight lexbuf 1) 
+       | LET _ -> BINDER (lexemeTrimRight lexbuf 1)
        | _ -> fail args lexbuf (FSComp.SR.lexIdentEndInMarkReserved("!")) (Keywords.KeywordOrIdentifierToken args lexbuf (lexeme lexbuf)) } 
  | ident ('#')  
      { fail args lexbuf (FSComp.SR.lexIdentEndInMarkReserved("#")) (Keywords.KeywordOrIdentifierToken args lexbuf (lexeme lexbuf)) }

diff --git a/src/fsharp/pars.fsy b/src/fsharp/pars.fsy
@@ -189,7 +189,7 @@ let rangeOfLongIdent(lid:LongIdent) =
 %token <char> CHAR
 %token <System.Decimal> DECIMAL 
 %token <(string * string)> BIGNUM
-%token <bool> LET YIELD YIELD_BANG 
+%token <bool> LET YIELD YIELD_BANG AND_BANG
 %token <bool> LESS GREATER /* here the bool indicates if the tokens are part of a type application or type parameter declaration, e.g. C<int>, detected by the lex filter */
 %token <string> PERCENT_OP BINDER 
 %token <string * bool> LQUOTE RQUOTE  RQUOTE_DOT 
@@ -218,6 +218,7 @@ let rangeOfLongIdent(lid:LongIdent) =
 /* for offside rule */
 %token <bool> OLET      /* LexFilter #light converts 'LET' tokens to 'OLET' when starting (CtxtLetDecl(blockLet=true)) */
 %token <string> OBINDER /* LexFilter #light converts 'BINDER' tokens to 'OBINDER' when starting (CtxtLetDecl(blockLet=true)) */
+%token <bool> OAND_BANG /* LexFilter #light converts 'AND_BANG' tokens to 'OAND_BANG' when starting (CtxtLetDecl(blockLet=true)) */
 %token ODO              /* LexFilter #light converts 'DO' tokens to 'ODO' */
 %token ODO_BANG         /* LexFilter #light converts 'DO_BANG' tokens to 'ODO_BANG' */
 %token OTHEN            /* LexFilter #light converts 'THEN' tokens to 'OTHEN' */
@@ -453,6 +454,7 @@ let rangeOfLongIdent(lid:LongIdent) =
 %nonassoc paren_pat_attribs
 %left OR BAR_BAR JOIN_IN
 %left AND   /* check */
+%left AND_BANG   /* check */
 %left  AMP AMP_AMP 
 %nonassoc pat_conj
 %nonassoc expr_not
@@ -3044,6 +3046,48 @@ recover:
    | error { debugPrint("recovering via error"); true }  
    | EOF { debugPrint("recovering via EOF"); false }
 
+binders:
+  | BINDER headBindingPattern EQUALS typedSeqExprBlock IN opt_OBLOCKSEP morebinders typedSeqExprBlock %prec expr_let
+     { let spBind = SequencePointAtBinding(rhs2 parseState 1 5)
+       let m = unionRanges (rhs parseState 1) $8.Range
+       SynExpr.LetOrUseBang(spBind,($1 = "use"),true,$2,$4,m,$7,$8) }
+
+  | OBINDER headBindingPattern EQUALS typedSeqExprBlock hardwhiteDefnBindingsTerminator opt_OBLOCKSEP morebinders typedSeqExprBlock %prec expr_let
+     { $5 (if $1 = "use" then "use!" else "let!") (rhs parseState 1)  // report unterminated error
+       let spBind = SequencePointAtBinding(unionRanges (rhs parseState 1) $4.Range)
+       let m = unionRanges (rhs parseState 1) $8.Range
+       SynExpr.LetOrUseBang(spBind,($1 = "use"),true,$2,$4,m,$7,$8) }
+
+  | OBINDER headBindingPattern EQUALS typedSeqExprBlock hardwhiteDefnBindingsTerminator opt_OBLOCKSEP morebinders error %prec expr_let
+     { // error recovery that allows intellisense when writing incomplete computation expressions
+       let spBind = SequencePointAtBinding(unionRanges (rhs parseState 1) $4.Range)
+       let mAll = unionRanges (rhs parseState 1) (rhs parseState 7) // TODO Check this range
+       let m = $4.Range.EndRange // zero-width range
+       SynExpr.LetOrUseBang(spBind,($1 = "use"),true,$2,$4, mAll, $7, SynExpr.ImplicitZero m) }
+
+  | OBINDER headBindingPattern EQUALS typedSeqExprBlock hardwhiteDefnBindingsTerminator opt_OBLOCKSEP error %prec expr_let 
+     { // error recovery that allows intellisense when writing incomplete computation expressions 
+       let spBind = SequencePointAtBinding(unionRanges (rhs parseState 1) $4.Range) 
+       let mAll = unionRanges (rhs parseState 1) (rhs parseState 7)
+       let m = $4.Range.EndRange // zero-width range
+       SynExpr.LetOrUseBang(spBind,($1 = "use"),true,$2,$4, mAll, [], SynExpr.ImplicitZero m) }
+
+morebinders:
+  | AND_BANG headBindingPattern EQUALS typedSeqExprBlock IN morebinders %prec expr_let /* TODO Check precedence */
+     { let spBind = SequencePointAtBinding(rhs2 parseState 1 5) (* TODO Pretty sure this is wrong *)
+       let m = rhs parseState 1 (* TODO Pretty sure this is wrong *)
+       (spBind,$1,true,$2,$4,m) :: $6 }
+
+  | OAND_BANG headBindingPattern EQUALS typedSeqExprBlock hardwhiteDefnBindingsTerminator opt_OBLOCKSEP morebinders %prec expr_let
+     { $5 (if $1 then "anduse!" else "and!") (rhs parseState 1)  // report unterminated error
+       let spBind = SequencePointAtBinding(rhs2 parseState 1 5) (* TODO Pretty sure this is wrong *)
+       let m = rhs parseState 1 (* TODO Pretty sure this is wrong *)
+       (spBind,$1,true,$2,$4,m) :: $7 }
+
+  /* TODO What if there's an error halfway through the list of and! bindings? Probably okay since each and! is out of scope of the other */
+
+  | %prec prec_no_more_attr_bindings /* TODO Make a prec_no_more_andbang_bindings or something */
+      { [] }
 
 declExpr:
   | defnBindings IN typedSeqExpr  %prec expr_let 
@@ -3337,27 +3381,12 @@ declExpr:
   | YIELD_BANG declExpr
      { SynExpr.YieldOrReturnFrom (($1,not $1), $2, unionRanges (rhs parseState 1) $2.Range) } 
 
-  | BINDER headBindingPattern EQUALS typedSeqExprBlock IN opt_OBLOCKSEP typedSeqExprBlock %prec expr_let 
-     { let spBind = SequencePointAtBinding(rhs2 parseState 1 5)
-       let m = unionRanges (rhs parseState 1) $7.Range
-       SynExpr.LetOrUseBang (spBind,($1 = "use"),true,$2,$4,$7,m) }
-
-  | OBINDER headBindingPattern EQUALS typedSeqExprBlock hardwhiteDefnBindingsTerminator opt_OBLOCKSEP typedSeqExprBlock %prec expr_let 
-     { $5 (if $1 = "use" then "use!" else "let!") (rhs parseState 1)  // report unterminated error 
-       let spBind = SequencePointAtBinding(unionRanges (rhs parseState 1) $4.Range)
-       let m = unionRanges (rhs parseState 1) $7.Range
-       SynExpr.LetOrUseBang (spBind,($1 = "use"),true,$2,$4,$7,m) }
-
-  | OBINDER headBindingPattern EQUALS typedSeqExprBlock hardwhiteDefnBindingsTerminator opt_OBLOCKSEP error %prec expr_let 
-     { // error recovery that allows intellisense when writing incomplete computation expressions 
-       let spBind = SequencePointAtBinding(unionRanges (rhs parseState 1) $4.Range) 
-       let mAll = unionRanges (rhs parseState 1) (rhs parseState 7)
-       let m = $4.Range.EndRange // zero-width range
-       SynExpr.LetOrUseBang (spBind,($1 = "use"),true,$2,$4, SynExpr.ImplicitZero m, mAll) }
+  | binders
+     { $1 }
 
   | DO_BANG typedSeqExpr IN opt_OBLOCKSEP typedSeqExprBlock %prec expr_let 
      { let spBind = NoSequencePointAtDoBinding
-       SynExpr.LetOrUseBang (spBind,false,true,SynPat.Const(SynConst.Unit,$2.Range),$2,$5, unionRanges (rhs parseState 1) $5.Range) }
+       SynExpr.LetOrUseBang(spBind,false,true,SynPat.Const(SynConst.Unit,$2.Range),$2, unionRanges (rhs parseState 1) $5.Range, [], $5) }
 
   | ODO_BANG typedSeqExprBlock hardwhiteDefnBindingsTerminator %prec expr_let 
      { SynExpr.DoBang ($2, unionRanges (rhs parseState 1) $2.Range) }

diff --git a/src/fsharp/service/ServiceAssemblyContent.fs b/src/fsharp/service/ServiceAssemblyContent.fs
@@ -705,9 +705,13 @@ module ParsedInput =
                 addLongIdentWithDots ident
                 List.iter walkExpr [e1; e2; e3]
             | SynExpr.JoinIn (e1, _, e2, _) -> List.iter walkExpr [e1; e2]
-            | SynExpr.LetOrUseBang (_, _, _, pat, e1, e2, _) ->
+            | SynExpr.LetOrUseBang (_, _, _, pat, e1, _, es, e2) ->
                 walkPat pat
-                List.iter walkExpr [e1; e2]
+                walkExpr e1
+                for (_,_,_,patAndBang,eAndBang,_) in es do
+                    walkPat patAndBang
+                    walkExpr eAndBang
+                walkExpr e2
             | SynExpr.TraitCall (ts, sign, e, _) ->
                 List.iter walkTypar ts
                 walkMemberSig sign

diff --git a/src/fsharp/service/ServiceInterfaceStubGenerator.fs b/src/fsharp/service/ServiceInterfaceStubGenerator.fs
@@ -896,8 +896,14 @@ module InterfaceStubGenerator =
                 | SynExpr.DoBang (synExpr, _range) -> 
                     walkExpr synExpr
 
-                | SynExpr.LetOrUseBang (_sequencePointInfoForBinding, _, _, _synPat, synExpr1, synExpr2, _range) -> 
-                    List.tryPick walkExpr [synExpr1; synExpr2]
+                | SynExpr.LetOrUseBang (_sequencePointInfoForBinding, _, _, _synPat, synExpr1, _range, synExprAndBangs, synExpr2) -> 
+                    [
+                        yield synExpr1
+                        for (_,_,_,_,eAndBang,_) in synExprAndBangs do
+                            yield eAndBang
+                        yield synExpr2
+                    ]
+                    |> List.tryPick walkExpr
 
                 | SynExpr.LibraryOnlyILAssembly _
                 | SynExpr.LibraryOnlyStaticOptimization _ 

diff --git a/src/fsharp/service/ServiceLexing.fs b/src/fsharp/service/ServiceLexing.fs
@@ -260,14 +260,14 @@ module internal TokenClassifications =
         | MEMBER | STATIC | NAMESPACE
         | OASSERT | OLAZY | ODECLEND | OBLOCKSEP | OEND | OBLOCKBEGIN | ORIGHT_BLOCK_END
         | OBLOCKEND | OBLOCKEND_COMING_SOON | OBLOCKEND_IS_HERE | OTHEN | OELSE | OLET(_)
-        | OBINDER _ | BINDER _ | ODO | OWITH | OFUNCTION | OFUN | ORESET | ODUMMY _ | DO_BANG
+        | OBINDER _ | OAND_BANG _ | BINDER _ | ODO | OWITH | OFUNCTION | OFUN | ORESET | ODUMMY _ | DO_BANG
         | ODO_BANG | YIELD _ | YIELD_BANG  _ | OINTERFACE_MEMBER
         | ELIF | RARROW | LARROW | SIG | STRUCT
         | UPCAST   | DOWNCAST   | NULL   | RESERVED    | MODULE    | AND    | AS   | ASSERT   | ASR
         | DOWNTO   | EXCEPTION   | FALSE   | FOR   | FUN   | FUNCTION
         | FINALLY   | LAZY   | MATCH  | MATCH_BANG  | MUTABLE   | NEW   | OF    | OPEN   | OR | VOID | EXTERN
         | INTERFACE | REC   | TO   | TRUE   | TRY   | TYPE   |  VAL   | INLINE   | WHEN  | WHILE   | WITH
-        | IF | THEN  | ELSE | DO | DONE | LET(_) | IN (*| NAMESPACE*) | CONST
+        | IF | THEN  | ELSE | DO | DONE | LET(_) | AND_BANG(_) | IN (*| NAMESPACE*) | CONST
         | HIGH_PRECEDENCE_PAREN_APP | FIXED
         | HIGH_PRECEDENCE_BRACK_APP
         | TYPE_COMING_SOON | TYPE_IS_HERE | MODULE_COMING_SOON | MODULE_IS_HERE ->

diff --git a/src/fsharp/service/ServiceParseTreeWalk.fs b/src/fsharp/service/ServiceParseTreeWalk.fs
@@ -473,10 +473,16 @@ module public AstTraversal =
                 | SynExpr.ImplicitZero (_range) -> None
                 | SynExpr.YieldOrReturn (_, synExpr, _range) -> traverseSynExpr synExpr
                 | SynExpr.YieldOrReturnFrom (_, synExpr, _range) -> traverseSynExpr synExpr
-                | SynExpr.LetOrUseBang (_sequencePointInfoForBinding, _, _, synPat, synExpr, synExpr2, _range) -> 
-                    [dive synPat synPat.Range traversePat
-                     dive synExpr synExpr.Range traverseSynExpr
-                     dive synExpr2 synExpr2.Range traverseSynExpr]
+                | SynExpr.LetOrUseBang(_sequencePointInfoForBinding, _, _, synPat, synExpr, _range, andBangSynExprs, synExpr2) -> 
+                    [
+                        yield dive synPat synPat.Range traversePat
+                        yield dive synExpr synExpr.Range traverseSynExpr
+                        yield!
+                            [ for (_,_,_,andBangSynPat,andBangSynExpr,_) in andBangSynExprs do
+                                yield (dive andBangSynPat andBangSynPat.Range traversePat)
+                                yield (dive andBangSynExpr andBangSynExpr.Range traverseSynExpr)]
+                        yield dive synExpr2 synExpr2.Range traverseSynExpr
+                    ]
                     |> pick expr
                 | SynExpr.MatchBang (_sequencePointInfoForBinding, synExpr, synMatchClauseList, _range) -> 
                     [yield dive synExpr synExpr.Range traverseSynExpr

diff --git a/src/fsharp/service/ServiceStructure.fs b/src/fsharp/service/ServiceStructure.fs
@@ -164,7 +164,7 @@ module Structure =
             | Attribute           -> "Attribute"
             | Interface           -> "Interface"
             | HashDirective       -> "HashDirective"
-            | LetOrUseBang        -> "LetOrUseBang"
+            | LetOrUseBang   -> "LetOrUseBang"
             | TypeExtension       -> "TypeExtension"
             | YieldOrReturn       -> "YieldOrReturn"
             | YieldOrReturnBang   -> "YieldOrReturnBang"
@@ -245,14 +245,21 @@ module Structure =
             | SynExpr.DoBang (e, r) ->
                 rcheck Scope.Do Collapse.Below r <| Range.modStart 3 r
                 parseExpr e
-            | SynExpr.LetOrUseBang (_, _, _, pat, e1, e2, _) ->
-                // for `let!` or `use!` the pattern begins at the end of the keyword so that
-                // this scope can be used without adjustment if there is no `=` on the same line
-                // if there is an `=` the range will be adjusted during the tooltip creation
-                let r = Range.endToEnd pat.Range e1.Range
-                rcheck Scope.LetOrUseBang Collapse.Below r r
-                parseExpr e1
-                parseExpr e2
+            | SynExpr.LetOrUseBang (_,_,_,pat,eLet,_,es,eBody) ->
+                [
+                    yield eLet
+                    yield! [ for (_,_,_,_,eAndBang,_) in es do yield eAndBang ]
+                ]
+                |> List.iter (fun e ->
+                    // for `let!`, `use!`, `and!` or `anduse!` the pattern begins at the end of the
+                    // keyword so that this scope can be used without adjustment if there is no `=`
+                    // on the same line. If there is an `=` the range will be adjusted during the
+                    // tooltip creation
+                    let r = Range.endToEnd pat.Range e.Range
+                    rcheck Scope.LetOrUseBang Collapse.Below r r
+                    parseExpr e
+                )
+                parseExpr eBody
             | SynExpr.For (_, _, _, _, _, e, r)
             | SynExpr.ForEach (_, _, _, _, _, e, r) ->
                 rcheck Scope.For Collapse.Below r r