Continuation statements to omit braces (#1089)

This allows us to use multiple statements in a single statement position
without braces.

Current rules:

- no definitions allowed, when no braces are used(`def`) -- could
potentially be relaxed
- no sequencing of expressions (`expr; expr`) outside of braces

It should be fully backwards compatible for code that parsed before.
It accepts more programs and also changes the error message for one
failing test case.

Here is how it looks like (also see the added test)

```
def main() =
  with filesystem;
  val port = readInt();
  with network(port);
  println("Running!")
```

Author: b-studios

effekt/jvm/src/test/scala/effekt/ParserTests.scala

@@ -94,7 +94,7 @@ class ParserTests extends munit.FunSuite {
     parse(input, _.stmt())
 
   def parseStmts(input: String, positions: Positions = new Positions())(using munit.Location): Stmt =
-    parse(input, _.stmts())
+    parse(input, _.stmts(inBraces = true))
 
   def parseMatchPattern(input: String, positions: Positions = new Positions())(using munit.Location): MatchPattern =
     parse(input, _.matchPattern())

effekt/shared/src/main/scala/effekt/Parser.scala

@@ -233,46 +233,55 @@ class Parser(positions: Positions, tokens: Seq[Token], source: Source) {
   /**
    * Statements
    */
-  def stmts(): Stmt =
+  def stmts(inBraces: Boolean = false): Stmt =
     nonterminal:
       (peek.kind match {
-        case `val`  => valStmt()
-        case _ if isDefinition => DefStmt(definition(), semi() ~> stmts(), span())
-        case `with` => withStmt()
-        case `var`  => DefStmt(varDef(), semi() ~> stmts(), span())
+        case `{` => BlockStmt(braces { stmts(inBraces = true) }, span())
+        case `val`  => valStmt(inBraces)
+        case _ if isDefinition && inBraces => DefStmt(definition(), semi() ~> stmts(inBraces), span())
+        case _ if isDefinition => fail("Definitions are only allowed, when enclosed in braces.")
+        case `with` => withStmt(inBraces)
+        case `var`  => DefStmt(varDef(), semi() ~> stmts(inBraces), span())
         case `return` =>
-          val result = `return` ~> Return(expr() <~ maybeSemi(), span())
-          result
-        case `}` | `}$` => // Unexpected end of <STMTS> =>
+          // trailing semicolon only allowed when in braces
+          `return` ~> Return(expr() <~ (if inBraces then maybeSemi()), span())
+        case `}` | `}$` if inBraces => // Unexpected end of <STMTS> =>
           // insert a synthetic `return ()` into the block
           Return(UnitLit(span().emptyAfter.synthesized), span().emptyAfter.synthesized)
+        // for now we do not allow multiple expressions in single-statement mode.
+        // That is, we rule out
+        //     def foo() =
+        //       expr;
+        //       expr
+        case _ if !inBraces =>
+          Return(expr(), span())
         case _ =>
           val e = expr()
           semi()
           if returnPosition then Return(e, span())
-          else ExprStmt(e, stmts(), span())
+          else ExprStmt(e, stmts(inBraces), span())
       }) labelled "statements"
 
   // ATTENTION: here the grammar changed (we added `with val` to disambiguate)
   // with val <ID> (: <TYPE>)? = <EXPR>; <STMTS>
   // with val (<ID> (: <TYPE>)?...) = <EXPR>
   // with <EXPR>; <STMTS>
-  def withStmt(): Stmt = `with` ~> peek.kind match {
+  def withStmt(inBraces: Boolean): Stmt = `with` ~> peek.kind match {
     case `val` =>
       val params = (`val` ~> peek.kind match {
         case `(` => valueParamsOpt()
         case _ => List(valueParamOpt()) // TODO copy position
       })
-      desugarWith(params, Nil, `=` ~> expr(), semi() ~> stmts(), span())
+      desugarWith(params, Nil, `=` ~> expr(), semi() ~> stmts(inBraces), span())
 
     case `def` =>
       val params = (`def` ~> peek.kind match {
         case `{` => blockParamsOpt()
         case _ => List(blockParamOpt()) // TODO copy position
       })
-      desugarWith(Nil, params, `=` ~> expr(), semi() ~> stmts(), span())
+      desugarWith(Nil, params, `=` ~> expr(), semi() ~> stmts(inBraces), span())
 
-    case _ => desugarWith(Nil, Nil, expr(), semi() ~> stmts(), span())
+    case _ => desugarWith(Nil, Nil, expr(), semi() ~> stmts(inBraces), span())
   }
 
   def desugarWith(vparams: List[ValueParam], bparams: List[BlockParam], call: Term, body: Stmt, withSpan: Span): Stmt = call match {
@@ -320,11 +329,10 @@ class Parser(positions: Positions, tokens: Seq[Token], source: Source) {
   def stmt(): Stmt =
     nonterminal:
       {
-        if peek(`{`) then BlockStmt(braces { stmts() }, span())
+        if peek(`{`) then BlockStmt(braces { stmts(inBraces = true) }, span())
         else when(`return`) { Return(expr(), span()) } { Return(expr(), span()) }
       } labelled "statement"
 
-
   /**
    * Main entry point for the repl.
    */
@@ -467,7 +475,7 @@ class Parser(positions: Positions, tokens: Seq[Token], source: Source) {
     nonterminal:
       manyWhile(definition(), isDefinition)
 
-  def functionBody: Stmt = stmt() // TODO error context: "the body of a function definition"
+  def functionBody: Stmt = stmts() // TODO error context: "the body of a function definition"
 
   def valDef(): Def =
     nonterminal:
@@ -479,7 +487,7 @@ class Parser(positions: Positions, tokens: Seq[Token], source: Source) {
    * In statement position, val-definitions can also be destructing:
    *   i.e. val (l, r) = point(); ...
    */
-  def valStmt(): Stmt =
+  def valStmt(inBraces: Boolean): Stmt =
     nonterminal:
       val doc = maybeDocumentation()
       val startPos = pos()
@@ -493,21 +501,21 @@ class Parser(positions: Positions, tokens: Seq[Token], source: Source) {
           val binding = stmt()
           val endPos = pos()
           val valDef = ValDef(id, tpe, binding, doc, Span(source, startPos, endPos)).withRangeOf(startMarker, binding)
-          DefStmt(valDef, { semi(); stmts() }, span())
+          DefStmt(valDef, { semi(); stmts(inBraces) }, span())
       }
       def matchLhs() =
         maybeDocumentation() ~ (`val` ~> matchPattern()) ~ manyWhile(`and` ~> matchGuard(), `and`) <~ `=` match {
           case doc ~ AnyPattern(id, _) ~ Nil =>
             val binding = stmt()
             val endPos = pos()
             val valDef = ValDef(id, None, binding, doc, Span(source, startPos, endPos)).withRangeOf(startMarker, binding)
-            DefStmt(valDef, { semi(); stmts() }, span())
+            DefStmt(valDef, { semi(); stmts(inBraces) }, span())
           case doc ~ p ~ guards =>
             // matches do not support doc comments, so we ignore `doc`
             val sc = expr()
             val endPos = pos()
             val default = when(`else`) { Some(stmt()) } { None }
-            val body = semi() ~> stmts()
+            val body = semi() ~> stmts(inBraces)
             val clause = MatchClause(p, guards, body, Span(source, p.span.from, sc.span.to)).withRangeOf(p, sc)
             val matching = Match(List(sc), List(clause), default, Span(source, startPos, endPos, Synthesized)).withRangeOf(startMarker, sc)
             Return(matching, span().synthesized)
@@ -536,7 +544,7 @@ class Parser(positions: Positions, tokens: Seq[Token], source: Source) {
       else
         // [...](<PARAM>...) {...} `=` <STMT>>
         val (tps, vps, bps) = params()
-        FunDef(id, tps, vps, bps, maybeReturnAnnotation(), `=` ~> stmt(), doc, span())
+        FunDef(id, tps, vps, bps, maybeReturnAnnotation(), `=` ~> stmts(), doc, span())
 
 
   // right now: data type definitions (should be renamed to `data`) and type aliases
@@ -691,7 +699,7 @@ class Parser(positions: Positions, tokens: Seq[Token], source: Source) {
     nonterminal:
       peek.kind match {
         case _: Ident => (peek(1).kind match {
-          case `{` => ExternBody.EffektExternBody(featureFlag(), `{` ~> stmts() <~ `}`, span())
+          case `{` => ExternBody.EffektExternBody(featureFlag(), `{` ~> stmts(inBraces = true) <~ `}`, span())
           case _ => ExternBody.StringExternBody(maybeFeatureFlag(), template(), span())
         }) labelled "extern body (string or block)"
         case _ => ExternBody.StringExternBody(maybeFeatureFlag(), template(), span())
@@ -793,14 +801,14 @@ class Parser(positions: Positions, tokens: Seq[Token], source: Source) {
   def ifExpr(): Term =
     nonterminal:
       If(`if` ~> parens { matchGuards().unspan },
-        stmt(),
-        when(`else`) { stmt() } { Return(UnitLit(span().emptyAfter), span().emptyAfter) }, span())
+        stmts(),
+        when(`else`) { stmts() } { Return(UnitLit(span().emptyAfter), span().emptyAfter) }, span())
 
   def whileExpr(): Term =
     nonterminal:
       While(`while` ~> parens { matchGuards().unspan },
-        stmt(),
-        when(`else`) { Some(stmt()) } { None },
+        stmts(),
+        when(`else`) { Some(stmts()) } { None },
         span())
 
   def doExpr(): Term =
@@ -838,7 +846,7 @@ class Parser(positions: Positions, tokens: Seq[Token], source: Source) {
   // TODO deprecate
   def funExpr(): Term =
     nonterminal:
-      val blockLiteral = `fun` ~> BlockLiteral(Nil, valueParams().unspan, Nil, braces { stmts() }, span())
+      val blockLiteral = `fun` ~> BlockLiteral(Nil, valueParams().unspan, Nil, braces { stmts(inBraces = true) }, span())
       Box(Maybe.None(Span(source, pos(), pos(), Synthesized)), blockLiteral, blockLiteral.span.synthesized)
 
   def unboxExpr(): Term =
@@ -920,9 +928,7 @@ class Parser(positions: Positions, tokens: Seq[Token], source: Source) {
       MatchClause(
         pattern,
         manyWhile(`and` ~> matchGuard(), `and`),
-        // allow a statement enclosed in braces or without braces
-        // both is allowed since match clauses are already delimited by `case`
-        `=>` ~> (if (peek(`{`)) { stmt() } else { stmts() }),
+        `=>` ~> stmts(inBraces = true),
         span()
       )
 
@@ -1145,10 +1151,10 @@ class Parser(positions: Positions, tokens: Seq[Token], source: Source) {
           case _ =>
             // { (x: Int) => ... }
             backtrack { lambdaParams() <~ `=>` } map {
-              case (tps, vps, bps) => BlockLiteral(tps, vps, bps, stmts(), Span.missing(source)) : BlockLiteral
+              case (tps, vps, bps) => BlockLiteral(tps, vps, bps, stmts(inBraces = true), Span.missing(source)) : BlockLiteral
             } getOrElse {
               // { <STMTS> }
-              BlockLiteral(Nil, Nil, Nil, stmts(), Span.missing(source)) : BlockLiteral
+              BlockLiteral(Nil, Nil, Nil, stmts(inBraces = true), Span.missing(source)) : BlockLiteral
             }
         }
       }
@@ -1221,7 +1227,7 @@ class Parser(positions: Positions, tokens: Seq[Token], source: Source) {
       peek.kind match {
         case `<>` => `<>` ~> Hole(IdDef("hole", span().synthesized), Template(Nil, Nil), span())
         case `<{` => {
-          val s = `<{` ~> stmts() <~ `}>`
+          val s = `<{` ~> stmts(inBraces = true) <~ `}>`
           Hole(IdDef("hole", span().synthesized), Template(Nil, List(s)), span())
         }
         case _: HoleStr => {
@@ -1235,7 +1241,7 @@ class Parser(positions: Positions, tokens: Seq[Token], source: Source) {
   def holeTemplate(): Template[Stmt] =
     nonterminal:
       val first = holeString()
-      val (s, strs) = manyWhile((`${` ~> stmts() <~ `}$`, holeString()), `${`).unzip
+      val (s, strs) = manyWhile((`${` ~> stmts(inBraces = true) <~ `}$`, holeString()), `${`).unzip
       Template(first :: strs, s)
 
   def holeString(): String =

examples/neg/no_continuation_defs.effekt

@@ -0,0 +1,2 @@
+def foo() =
+  def bar() = 42 // ERROR enclosed in braces

examples/pos/confusing_statements.check

@@ -0,0 +1,3 @@
+doing something
+doing something
+doing something

examples/pos/confusing_statements.effekt

@@ -0,0 +1,13 @@
+def compute(): Unit = println("doing something")
+
+/// Prints "doing something" three times, since
+/// the second `compute()` is NOT part of `bar`.
+/// The language is NOT indentation senstive!
+def main() = {
+  def bar() =
+    compute(); // <--- this is part of bar!
+    compute()  // <--- this is part of main, not bar!
+
+  bar();
+  bar()
+}

examples/pos/multistatement.check

@@ -0,0 +1,5 @@
+Open files
+Open port 8080
+Running!
+Close port
+Close files

examples/pos/multistatement.effekt

@@ -0,0 +1,17 @@
+def filesystem { p: => Unit }: Unit = {
+  println("Open files")
+  p()
+  println("Close files")
+}
+def network(port: Int) { p: => Unit }: Unit = {
+  println("Open port " ++ port.show)
+  p()
+  println("Close port")
+}
+def readInt(): Int = 8080
+
+def main() =
+  with filesystem;
+  val port = readInt();
+  with network(port);
+  println("Running!")