Extract applied constructors logic to a separate function

Author: KacperFKorban

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

@@ -1324,7 +1324,7 @@ object Parsers {
      *                 |  SimpleLiteral
      *                 |  Singleton ‘.’ id
      *                 |  Singleton ‘(’ Singletons ‘)’
-     *                 |  Singleton ‘[’ Types ‘]’
+     *  -- not yet     |  Singleton ‘[’ Types ‘]’
      */
     def singleton(): Tree =
       val res =
@@ -1335,8 +1335,8 @@ object Parsers {
     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 if in.token == LBRACKET && in.featureEnabled(Feature.modularity) then
+      //   singletonArgs(AppliedTypeTree(t, inBrackets(commaSeparated(() => typ())))) // should this be marked in a different way, so that we know that it is a type application, and not a term application?
       else t
 
     /** SimpleLiteral     ::=  [‘-’] integerLiteral

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

@@ -2514,23 +2514,37 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     assignType(cpy.RefinedTypeTree(tree)(tpt1, refinements1), tpt1, refinements1, refineCls)
   }
 
+  /** Type applied dependent class constructors in type positions */
+  private def typedTermAppliedTypeTree(tree: untpd.AppliedTypeTree, tpt1: Tree)(using Context): Tree = {
+    if Feature.enabled(Feature.modularity) then
+      val constr =
+        if tpt1.tpe.typeSymbol.primaryConstructor.exists then
+          tpt1.tpe.typeSymbol.primaryConstructor
+        else
+          tpt1.tpe.typeSymbol.companionClass.primaryConstructor
+      // TODO(kπ)       vvvvvvv   Might want to take the first term list? or all term lists? depends on the rest of the logic.
+      constr.paramSymss.flatten.foreach { p =>
+        if p.isTerm && !p.flags.is(Tracked) then
+          report.error(
+            em"""The constructor parameter `${p.name}` of `${tpt1.tpe}` is not tracked.
+                |Only tracked parameters are allowed in dependent constructor applications.""",
+            tree.srcPos
+          )
+      }
+      constr.typeRef.underlying match
+        case mt: MethodOrPoly =>
+          TypeTree(mt.instantiate(tree.args.map((typedExpr(_).tpe))))
+    else
+      errorTree(tree, dependentMsg)
+  }
+
   def typedAppliedTypeTree(tree: untpd.AppliedTypeTree)(using Context): Tree = {
     val tpt1 = withoutMode(Mode.Pattern):
       typed(tree.tpt, AnyTypeConstructorProto)
 
     tree.args match
       case arg :: _ if arg.isTerm =>
-        if Feature.enabled(Feature.modularity) then
-          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)
+        return typedTermAppliedTypeTree(tree, tpt1)
       case _ =>
 
     val tparams = tpt1.tpe.typeParams

tests/pos/applied_constructors.scala

@@ -4,11 +4,13 @@ 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)
+class F[A](tracked val a: Int)
+class G[A](tracked val a: A)
 
 object Test extends App {
   val c: C(42) = 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)
+  // val f: F[Int](42) = F[Int](42)
+  // val g: G(42) = G(42)
 }