Allow types applied to terms in syntax and parser

Author: odersky

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

@@ -783,7 +783,8 @@ object Parsers {
                 refinedTypeRest(
                   withTypeRest(
                     annotTypeRest(
-                      simpleTypeRest(tuple)))))
+                      appliedTypeRest(
+                        simpleTypeRest(tuple))))))
             }
           }
         }
@@ -846,14 +847,20 @@ object Parsers {
       }
       else t
 
-    /** AnnotType ::= SimpleType {Annotation}
+    /** AnnotType ::= AppliedType {Annotation}
      */
-    def annotType(): Tree = annotTypeRest(simpleType())
+    def annotType(): Tree = annotTypeRest(appliedType())
 
     def annotTypeRest(t: Tree): Tree =
       if (in.token == AT) annotTypeRest(atPos(startOffset(t)) { Annotated(t, annot()) })
       else t
 
+    /** AppiedType ::= SimpleType {ParArgumentExprs}
+     */
+    def appliedType(): Tree = appliedTypeRest(simpleType())
+
+    def appliedTypeRest(t: Tree) = parArgumentExprss(t)
+
     /** SimpleType       ::=  SimpleType TypeArgs
      *                     |  SimpleType `#' id
      *                     |  StableId
@@ -2312,11 +2319,11 @@ object Parsers {
 
 /* -------- TEMPLATES ------------------------------------------- */
 
-    /** ConstrApp         ::=  SimpleType {ParArgumentExprs}
+    /** ConstrApp         ::=  SimpleType {Annotation} {ParArgumentExprs}
      */
     val constrApp = () => {
       // Using Ident(nme.ERROR) to avoid causing cascade errors on non-user-written code
-      val t = checkWildcard(annotType(), fallbackTree = Ident(nme.ERROR))
+      val t = checkWildcard(annotTypeRest(simpleType()), fallbackTree = Ident(nme.ERROR))
       if (in.token == LPAREN) parArgumentExprss(wrapNew(t))
       else t
     }

docs/docs/internals/syntax.md

@@ -128,7 +128,8 @@ TypedFunParam     ::=  id ‘:’ Type
 InfixType         ::=  RefinedType {id [nl] RefinedType}                        InfixOp(t1, op, t2)
 RefinedType       ::=  WithType {[nl] Refinement}                               RefinedTypeTree(t, ds)
 WithType          ::=  AnnotType {‘with’ AnnotType}                             (deprecated)
-AnnotType         ::=  SimpleType {Annotation}                                  Annotated(t, annot)
+AnnotType         ::=  AppliedType {Annotation}                                 Annotated(t, annot)
+AppliedType       ::=  SimpleType {ParArgumentExprs}                            Apply(t, args)
 SimpleType        ::=  SimpleType TypeArgs                                      AppliedTypeTree(t, args)
                     |  SimpleType ‘#’ id                                        Select(t, name)
                     |  StableId
@@ -337,7 +338,7 @@ EnumDef           ::=  id ClassConstr [‘extends’ [ConstrApps]] EnumBody
 TemplateOpt       ::=  [‘extends’ Template | [nl] TemplateBody]
 Template          ::=  ConstrApps [TemplateBody] | TemplateBody                 Template(constr, parents, self, stats)
 ConstrApps        ::=  ConstrApp {‘with’ ConstrApp}
-ConstrApp         ::=  AnnotType {ArgumentExprs}                                Apply(tp, args)
+ConstrApp         ::=  SimpleType {Annotation} {ParArgumentExprs}               Apply(tp, args)
 ConstrExpr        ::=  SelfInvocation
                     |  ConstrBlock
 SelfInvocation    ::=  ‘this’ ArgumentExprs {ArgumentExprs}