Allow given in constructor applications

Author: odersky

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

@@ -575,22 +575,26 @@ object Parsers {
           }
           else recur(operand())
         }
-        else if (in.token == GIVEN) {
+        else if (in.token == GIVEN && !isType) {
           val top1 = reduceStack(base, top, minInfixPrec, leftAssoc = true, nme.WITHkw, isType)
           assert(opStack `eq` base)
-          val app = atSpan(startOffset(top1), in.offset) {
-            in.nextToken()
-            val args = if (in.token == LPAREN) parArgumentExprs() else operand() :: Nil
-            Apply(top, args)
-          }
-          app.pushAttachment(ApplyGiven, ())
-          recur(app)
+          recur(applyGiven(top1, operand))
         }
         else reduceStack(base, top, minPrec, leftAssoc = true, in.name, isType)
 
       recur(first)
     }
 
+    def applyGiven(t: Tree, operand: () => Tree): Tree = {
+      val app = atSpan(startOffset(t), in.offset) {
+        in.nextToken()
+        val args = if (in.token == LPAREN) parArgumentExprs() else operand() :: Nil
+        Apply(t, args)
+      }
+      app.pushAttachment(ApplyGiven, ())
+      app
+    }
+
 /* -------- IDENTIFIERS AND LITERALS ------------------------------------------- */
 
     /** Accept identifier and return its name as a term name. */
@@ -2710,13 +2714,43 @@ object Parsers {
 
 /* -------- TEMPLATES ------------------------------------------- */
 
-    /** ConstrApp         ::=  SimpleType {ParArgumentExprs}
+    /** SimpleConstrApp  ::=  AnnotType {ParArgumentExprs}
+     *  ConstrApp        ::=  SimpleConstrApp
+     *                     |  ‘(’ SimpleConstrApp {‘given’ (PrefixExpr | ParArgumentExprs)} ‘)’
      */
     val constrApp: () => Tree = () => {
-      // Using Ident(nme.ERROR) to avoid causing cascade errors on non-user-written code
-      val t = rejectWildcardType(annotType(), fallbackTree = Ident(nme.ERROR))
-      if (in.token == LPAREN) parArgumentExprss(wrapNew(t))
-      else t
+
+      def isAnnotType(t: Tree) = t match {
+        case _: Ident
+           | _: Select
+           | _: AppliedTypeTree
+           | _: Tuple
+           | _: Parens
+           | _: RefinedTypeTree
+           | _: SingletonTypeTree
+           | _: TypSplice
+           | _: Annotated => true
+        case _ => false
+      }
+
+      def givenArgs(t: Tree): Tree = {
+        if (in.token == GIVEN) givenArgs(applyGiven(t, prefixExpr)) else t
+      }
+
+      if (in.token == LPAREN)
+        inParens {
+          val t = toplevelTyp()
+          if (isAnnotType(t))
+            if (in.token == LPAREN) givenArgs(parArgumentExprss(wrapNew(t)))
+            else if (in.token == GIVEN) givenArgs(wrapNew(t))
+            else t
+          else Parens(t)
+        }
+      else {
+        val t = rejectWildcardType(annotType(), fallbackTree = Ident(nme.ERROR))
+          // Using Ident(nme.ERROR) to avoid causing cascade errors on non-user-written code
+        if (in.token == LPAREN) parArgumentExprss(wrapNew(t)) else t
+      }
     }
 
     /** ConstrApps ::=  ConstrApp {‘with’ ConstrApp}  (to be deprecated in 3.1)

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -2591,6 +2591,8 @@ class Typer extends Namer
             tree
         else if (wtp.isContextual)
           adaptNoArgs(wtp)  // insert arguments implicitly
+        else if (tree.symbol.isPrimaryConstructor && tree.symbol.info.firstParamTypes.isEmpty)
+          readapt(tree.appliedToNone) // insert () to primary constructors
         else
           errorTree(tree, em"Missing arguments for $methodStr")
       case _ => tryInsertApplyOrImplicit(tree, pt, locked) {

tests/neg/parser-stability-25.scala

@@ -11,5 +11,5 @@ class D extends (Int => 1) {
 }
 
 class Wrap(x: Int)
-class E extends (Wrap)( // error
+class E extends (Wrap)( // error // error
 // error

tests/pos/given-constrapps.scala

@@ -0,0 +1,29 @@
+class TC
+val tc = TC()
+class C given (x: TC) {
+  assert(x eq tc)
+}
+class C2(n: Int) given (x: TC) given List[TC] {
+  assert(x eq tc)
+  the[List[TC]].foreach(t => assert(t eq tc))
+
+  def this() given TC given List[TC] = this(1)
+}
+
+class D extends (C given tc)
+class D2 extends (C2(1) given tc given Nil)
+
+class Foo given TC {
+  assert(the[TC] != null)
+}
+
+object Test extends App {
+  new (C given tc)
+  new (C() given tc)
+  new (C given tc) {}
+  new (C2(1) given tc given List(tc))
+  new (C2(1) given tc given List(tc)) {}
+  new (C2() given tc given List(tc))
+  def foo given TC = ()
+  foo given tc
+}