Move applied constructor types under modularity

Author: KacperFKorban

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

@@ -1334,12 +1334,16 @@ object Parsers {
     /** Singleton    ::=  SimpleRef
      *                 |  SimpleLiteral
      *                 |  Singleton ‘.’ id
-     * -- not yet      |  Singleton ‘(’ Singletons ‘)’
+     *                 |  Singleton ‘(’ Singletons ‘)’
      * -- not yet      |  Singleton ‘[’ Types ‘]’
      */
     def singleton(): Tree =
-      if isSimpleLiteral then simpleLiteral()
-      else dotSelectors(simpleRef())
+      val res =
+        if isSimpleLiteral then simpleLiteral()
+        else dotSelectors(simpleRef())
+      if in.token == LPAREN then
+        AppliedTypeTree(res, inParens(commaSeparated(() => singleton())))
+      else res
 
     /** SimpleLiteral     ::=  [‘-’] integerLiteral
      *                      |  [‘-’] floatingPointLiteral
@@ -2051,7 +2055,7 @@ object Parsers {
     /**  SimpleType      ::=  SimpleLiteral
      *                     |  ‘?’ TypeBounds
      *                     |  SimpleType1
-     *                     |  SimpleType ‘(’ Singletons ‘)’  -- under language.experimental.dependent, checked in Typer
+     *                     |  SimpleType ‘(’ Singletons ‘)’  -- under language.experimental.modularity, checked in Typer
      *   Singletons      ::=  Singleton {‘,’ Singleton}
      */
     def simpleType(): Tree =
@@ -2084,7 +2088,7 @@ object Parsers {
         typeBounds().withSpan(Span(start, in.lastOffset, start))
       else
         def singletonArgs(t: Tree): Tree =
-          if in.token == LPAREN && in.featureEnabled(Feature.dependent)
+          if in.token == LPAREN && in.featureEnabled(Feature.modularity)
           then singletonArgs(AppliedTypeTree(t, inParensWithCommas(commaSeparated(singleton))))
           else t
         singletonArgs(simpleType1())

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

@@ -294,7 +294,7 @@ object ErrorReporting {
 
   def dependentMsg =
     """Term-dependent types are experimental,
-      |they must be enabled with a `experimental.dependent` language import or setting""".stripMargin.toMessage
+      |they must be enabled with a `experimental.modularity` language import or setting""".stripMargin.toMessage
 
   def err(using Context): Errors = new Errors
 }

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

@@ -2562,14 +2562,14 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
 
     tree.args match
       case arg :: _ if arg.isTerm =>
-        if Feature.dependentEnabled then
+        if Feature.enabled(Feature.modularity) then
           tpt1.tpe.typeSymbol.primaryConstructor.typeRef.underlying match
             case mt: MethodType =>
               return TypeTree(mt.instantiate(tree.args.map((typedExpr(_).tpe))))
         else
           return errorTree(tree, dependentMsg)
       case _ =>
-    
+
     val tparams = tpt1.tpe.typeParams
      if tpt1.tpe.isError then
        val args1 = tree.args.mapconserve(typedType(_))
@@ -2693,7 +2693,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     typeIndexedLambdaTypeTree(tree, tparams, body)
 
   def typedTermLambdaTypeTree(tree: untpd.TermLambdaTypeTree)(using Context): Tree =
-    if Feature.dependentEnabled then
+    if Feature.enabled(Feature.modularity) then
       errorTree(tree, em"Not yet implemented: (...) =>> ...")
     else
       errorTree(tree, dependentMsg)

tests/neg/deptypes.scala

@@ -8,4 +8,4 @@ type Tensor2[T](m: Int)(n: Int) = Matrix[T](m, n)   // error: not yet implemente
 
 val x: Vec[Int](10) = ???  // error: not yet implemented
 val n = 10
-type T = Vec[String](n)  // error: not yet implemented
+type T = Vec[String](n)  // error: not yet implemented

tests/pos/applied_constructors.scala

@@ -0,0 +1,9 @@
+import scala.language.experimental.modularity
+
+class C(tracked val x: Int)
+class D(tracked val c: C)
+
+object Test extends App {
+  val c: C(42) = C(42)
+  // val d: D(C(42)) = D(C(42))
+}