Disambiguate given instances and parameters

Author: odersky

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -2307,9 +2307,59 @@ object Parsers {
     def paramClauses(ofClass: Boolean = false,
                      ofCaseClass: Boolean = false,
                      ofInstance: Boolean = false): List[List[ValDef]] = {
+
+     def followingIsParamClause: Boolean = {
+        val lookahead = in.lookaheadScanner
+        lookahead.nextToken()
+        paramIntroTokens.contains(lookahead.token) && {
+          lookahead.token != IDENTIFIER ||
+          lookahead.name == nme.inline || {
+            lookahead.nextToken()
+            lookahead.token == COLON
+          }
+        }
+      }
+
+      /** For given instance definitions we have a disambiguation problem:
+       *    given A as B
+       *    given C ...
+       *  Is the second line a parameter `given C` for the first `given` definition, or is it
+       *  a second `given` definition? We only know if we find a `for` or `as` in `...`
+       *  The same problem arises for
+       *    class A
+       *    given C ...
+       *  For method definitions we do not have this problem since a parameter clause
+       *  in a method definition is always followed by something else. So in
+       *    def m(...)
+       *    given C ...
+       *  we know that `given` must start a parameter list. It cannot be a new given` definition.
+       */
+      def followingIsInstanceDef =
+        (ofClass || ofInstance) && {
+          val lookahead = in.lookaheadScanner // skips newline on startup
+          lookahead.nextToken()  // skip the `given`
+          if (lookahead.token == IDENTIFIER || lookahead.token == BACKQUOTED_IDENT) {
+            lookahead.nextToken()
+            if (lookahead.token == LBRACKET) {
+              lookahead.nextToken()
+              var openBrackets = 1
+              while (openBrackets > 0 && lookahead.token != EOF) {
+                if (lookahead.token == LBRACKET) openBrackets += 1
+                else if (lookahead.token == RBRACKET) openBrackets -= 1
+                lookahead.nextToken()
+              }
+            }
+          }
+          lookahead.token == FOR ||
+          lookahead.token == IDENTIFIER && lookahead.name == nme.as
+        }
+
       def recur(firstClause: Boolean, nparams: Int, contextualOnly: Boolean): List[List[ValDef]] = {
         var initialMods = EmptyModifiers
+        val isNewLine = in.token == NEWLINE
         newLineOptWhenFollowedBy(LPAREN)
+        if (in.token == NEWLINE && in.next.token == GIVEN && !followingIsInstanceDef)
+          in.nextToken()
         if (in.token == GIVEN) {
           in.nextToken()
           initialMods |= Given
@@ -2318,22 +2368,10 @@ object Parsers {
           in.nextToken()
           initialMods |= Erased
         }
-        val isContextual = initialMods.is(Given)
+        val isGiven = initialMods.is(Given)
         newLineOptWhenFollowedBy(LPAREN)
-        def isParamClause: Boolean =
-          !isContextual || {
-            val lookahead = in.lookaheadScanner
-            lookahead.nextToken()
-            paramIntroTokens.contains(lookahead.token) && {
-              lookahead.token != IDENTIFIER ||
-              lookahead.name == nme.inline || {
-                lookahead.nextToken()
-                lookahead.token == COLON
-              }
-            }
-          }
-        if (in.token == LPAREN && isParamClause) {
-          if (contextualOnly && !isContextual)
+        if (in.token == LPAREN && (!isGiven || followingIsParamClause)) {
+          if (contextualOnly && !isGiven)
             if (ofInstance) syntaxError(em"parameters of instance definitions must come after `given'")
             else syntaxError(em"normal parameters cannot come after `given' clauses")
           val params = paramClause(
@@ -2342,15 +2380,15 @@ object Parsers {
               firstClause = firstClause,
               initialMods = initialMods)
           val lastClause = params.nonEmpty && params.head.mods.flags.is(Implicit)
-          params :: (if (lastClause) Nil else recur(firstClause = false, nparams + params.length, isContextual))
+          params :: (if (lastClause) Nil else recur(firstClause = false, nparams + params.length, isGiven))
         }
-        else if (isContextual) {
+        else if (isGiven) {
           val tps = commaSeparated(() => annotType())
           var counter = nparams
           def nextIdx = { counter += 1; counter }
           val paramFlags = if (ofClass) Private | Local | ParamAccessor else Param
           val params = tps.map(makeSyntheticParameter(nextIdx, _, paramFlags | Synthetic | Given))
-          params :: recur(firstClause = false, nparams + params.length, isContextual)
+          params :: recur(firstClause = false, nparams + params.length, isGiven)
         }
         else Nil
       }
@@ -2819,7 +2857,7 @@ object Parsers {
       val name = if (isIdent && (!newStyle || in.name != nme.as)) ident() else EmptyTermName
       val tparams = typeParamClauseOpt(ParamOwner.Def)
       val parents =
-        if (!newStyle && in.token == FOR || newStyle && isIdent(nme.as)) {
+        if (!newStyle && in.token == FOR || isIdent(nme.as)) { // for the moment, accept both `given for` and `given as`
           in.nextToken()
           tokenSeparated(COMMA, constrApp)
         }

tests/pos/i5978.scala

@@ -9,11 +9,11 @@ package p1 {
   object TextParser {
     given TP as TokenParser[Char, Position[CharSequence]] {}
 
-    def f given
-      TokenParser[Char, Position[CharSequence]] = ???
+    def f
+      given TokenParser[Char, Position[CharSequence]] = ???
 
-    given FromCharToken as Conversion[Char, Position[CharSequence]] given
-      (T: TokenParser[Char, Position[CharSequence]]) = ???
+    given FromCharToken as Conversion[Char, Position[CharSequence]]
+      given (T: TokenParser[Char, Position[CharSequence]]) = ???
   }
 
   object Testcase {
@@ -80,4 +80,12 @@ package p3 {
       }
     }
   }
+}
+package p4 {
+  class TC
+  given A as TC
+  given B[X[_], Y] as TC
+
+  given C as TC
+    given TC
 }