Support nested constructor applications as types

Author: KacperFKorban

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

@@ -1324,15 +1324,20 @@ object Parsers {
      *                 |  SimpleLiteral
      *                 |  Singleton ‘.’ id
      *                 |  Singleton ‘(’ Singletons ‘)’
-     * -- not yet      |  Singleton ‘[’ Types ‘]’
+     *                 |  Singleton ‘[’ Types ‘]’
      */
     def singleton(): Tree =
       val res =
         if isSimpleLiteral then simpleLiteral()
         else dotSelectors(simpleRef())
-      if in.token == LPAREN then
-        AppliedTypeTree(res, inParens(commaSeparated(() => singleton())))
-      else res
+      singletonArgs(res)
+
+    def singletonArgs(t: Tree): Tree =
+      if in.token == LPAREN && in.featureEnabled(Feature.modularity) then
+        singletonArgs(AppliedTypeTree(t, inParensWithCommas(commaSeparated(singleton))))
+      else if in.token == LBRACKET && in.featureEnabled(Feature.modularity) then
+        singletonArgs(AppliedTypeTree(t, inBrackets(commaSeparated(() => typ()))))
+      else t
 
     /** SimpleLiteral     ::=  [‘-’] integerLiteral
      *                      |  [‘-’] floatingPointLiteral
@@ -2054,10 +2059,6 @@ object Parsers {
         val start = in.skipToken()
         typeBounds().withSpan(Span(start, in.lastOffset, start))
       else
-        def singletonArgs(t: Tree): Tree =
-          if in.token == LPAREN && in.featureEnabled(Feature.modularity)
-          then singletonArgs(AppliedTypeTree(t, inParensWithCommas(commaSeparated(singleton))))
-          else t
         singletonArgs(simpleType1())
 
     /** SimpleType1      ::=  id

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

@@ -2521,8 +2521,13 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     tree.args match
       case arg :: _ if arg.isTerm =>
         if Feature.enabled(Feature.modularity) then
-          tpt1.tpe.typeSymbol.primaryConstructor.typeRef.underlying match
-            case mt: MethodType =>
+          val constr =
+            if tpt1.tpe.typeSymbol.primaryConstructor.exists then
+              tpt1.tpe.typeSymbol.primaryConstructor
+            else
+              tpt1.tpe.typeSymbol.companionClass.primaryConstructor
+          constr.typeRef.underlying match
+            case mt: MethodOrPoly =>
               return TypeTree(mt.instantiate(tree.args.map((typedExpr(_).tpe))))
         else
           return errorTree(tree, dependentMsg)

tests/pos/applied_constructors.scala

@@ -1,9 +1,14 @@
 import scala.language.experimental.modularity
+import scala.language.future
 
 class C(tracked val x: Int)
 class D(tracked val c: C)
+class E(tracked val c: D)
+class F[A](tracked val a: A)
 
 object Test extends App {
   val c: C(42) = C(42)
-  // val d: D(C(42)) = D(C(42))
+  val d: D(C(42)) = D(C(42))
+  val e: E(D(C(42))) = E(D(C(42)))
+  // val f: F[Int](42) = F(42)
 }