Review changes for applied constructor types

Author: KacperFKorban

compiler/src/dotty/tools/dotc/core/NamerOps.scala

@@ -39,14 +39,12 @@ object NamerOps:
    */
   extension (tp: Type)
     def separateRefinements(cls: ClassSymbol, refinements: mutable.LinkedHashMap[Name, Type] | Null)(using Context): Type =
-      val widenSkolemsMap = new TypeMap:
-        def apply(tp: Type) = mapOver(tp.widenSkolem)
       tp match
         case RefinedType(tp1, rname, rinfo) =>
           try tp1.separateRefinements(cls, refinements)
           finally
             if refinements != null then
-              val rinfo1 = widenSkolemsMap(rinfo)
+              val rinfo1 = rinfo.widenSkolems
               refinements(rname) = refinements.get(rname) match
                 case Some(tp) => tp & rinfo1
                 case None => rinfo1

compiler/src/dotty/tools/dotc/core/TypeUtils.scala

@@ -53,6 +53,11 @@ class TypeUtils:
       case ps => ps.reduceLeft(AndType(_, _))
     }
 
+    def widenSkolems(using Context): Type =
+      val widenSkolemsMap = new TypeMap:
+        def apply(tp: Type) = mapOver(tp.widenSkolem)
+      widenSkolemsMap(self)
+
     /** The element types of this tuple type, which can be made up of EmptyTuple, TupleX and `*:` pairs
      */
     def tupleElementTypes(using Context): Option[List[Type]] =
@@ -134,7 +139,7 @@ class TypeUtils:
           case t => throw TypeError(em"Malformed NamedTuple: names must be string types, but $t was found.")
         val values = vals.tupleElementTypesUpTo(bound, normalize).getOrElse(Nil)
         names.zip(values)
-        
+
       (if normalize then self.normalized else self).dealias match
         // for desugaring and printer, ignore derived types to avoid infinite recursion in NamedTuple.unapply
         case defn.NamedTupleDirect(nmes, vals) => extractNamesTypes(nmes, vals)

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

@@ -2040,7 +2040,7 @@ object Parsers {
     /**  SimpleType      ::=  SimpleLiteral
      *                     |  ‘?’ TypeBounds
      *                     |  SimpleType1
-     *                     |  SimpleType ‘(’ Singletons ‘)’  -- under language.experimental.modularity, checked in Typer
+     *                     |  SimpleType ‘(’ Singletons ‘)’
      *   Singletons      ::=  Singleton {‘,’ Singleton}
      */
     def simpleType(): Tree =

compiler/src/dotty/tools/dotc/reporting/messages.scala

@@ -3475,6 +3475,6 @@ final class PointlessAppliedConstructorType(tpt: untpd.Tree, args: List[untpd.Tr
 final class OnlyFullyDependentAppliedConstructorType()(using Context)
   extends TypeMsg(OnlyFullyDependentAppliedConstructorTypeID):
   override protected def msg(using Context): String =
-    i"Applied constructor type can only be used with classes that only have tracked parameters"
+    i"Applied constructor type can only be used with classes where all parameters in the first parameter list are tracked"
 
   override protected def explain(using Context): String = ""

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

@@ -1282,6 +1282,10 @@ trait Applications extends Compatibility {
         }
       else {
         val app = tree.fun match
+          case _ if ctx.mode.is(Mode.Type) && Feature.enabled(Feature.modularity) && !ctx.isAfterTyper =>
+            untpd.methPart(tree.fun) match
+              case Select(nw @ New(_), _) => typedAppliedConstructorType(nw, tree.args, tree)
+              case _ => realApply
           case untpd.TypeApply(_: untpd.SplicePattern, _) if Feature.quotedPatternsWithPolymorphicFunctionsEnabled =>
             typedAppliedSpliceWithTypes(tree, pt)
           case _: untpd.SplicePattern => typedAppliedSplice(tree, pt)
@@ -1715,22 +1719,27 @@ trait Applications extends Compatibility {
   def typedUnApply(tree: untpd.UnApply, selType: Type)(using Context): UnApply =
     throw new UnsupportedOperationException("cannot type check an UnApply node")
 
-  def typedAppliedConstructorType(tree: untpd.Apply)(using Context) = untpd.methPart(tree) match
-      case Select(New(tpt), _) =>
-        val tree1 = typedExpr(tree)
-        val widenSkolemsMap = new TypeMap:
-          def apply(tp: Type) = mapOver(tp.widenSkolem)
-        val preciseTp = widenSkolemsMap(tree1.tpe)
-        val classTp = typedType(tpt).tpe
-        def classSymbolHasOnlyTrackedParameters =
-          classTp.classSymbol.primaryConstructor.paramSymss.flatten.filter(_.isTerm).forall(_.is(Tracked))
-        if !preciseTp.isError && !classSymbolHasOnlyTrackedParameters then
-          report.warning(OnlyFullyDependentAppliedConstructorType(), tree.srcPos)
-        if !preciseTp.isError && (preciseTp frozen_=:= classTp) then
-          report.warning(PointlessAppliedConstructorType(tpt, tree.args, classTp), tree.srcPos)
-        TypeTree(preciseTp)
-      case _ =>
-        throw TypeError(em"Unexpected applied constructor type: $tree")
+  /** Typecheck an applied constructor type – An Apply node in Type mode.
+   *  This expands to the type this term would have if it were typed as an expression.
+   *
+   * e.g.
+   * ```scala
+   * // class C(tracked val v: Any)
+   * val c: C(42) = ???
+   * ```
+   */
+  def typedAppliedConstructorType(nw: untpd.New, args: List[untpd.Tree], tree: untpd.Apply)(using Context) =
+    val tree1 = typedExpr(tree)
+    val preciseTp = tree1.tpe.widenSkolems
+    val classTp = typedType(nw.tpt).tpe
+    def classSymbolHasOnlyTrackedParameters =
+      !classTp.classSymbol.primaryConstructor.paramSymss.nestedExists: param =>
+        param.isTerm && !param.is(Tracked)
+    if !preciseTp.isError && !classSymbolHasOnlyTrackedParameters then
+      report.warning(OnlyFullyDependentAppliedConstructorType(), tree.srcPos)
+    if !preciseTp.isError && (preciseTp frozen_=:= classTp) then
+      report.warning(PointlessAppliedConstructorType(nw.tpt, args, classTp), tree.srcPos)
+    TypeTree(preciseTp)
 
   /** Is given method reference applicable to argument trees `args`?
    *  @param  resultType   The expected result type of the application

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

@@ -3511,7 +3511,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
 
   /** Typecheck tree without adapting it, returning a typed tree.
    *  @param initTree    the untyped tree
-   *  @param pt          the expected result typ
+   *  @param pt          the expected result type
    *  @param locked      the set of type variables of the current typer state that cannot be interpolated
    *                     at the present time
    */
@@ -3551,9 +3551,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
 
         def typedUnnamed(tree: untpd.Tree): Tree = tree match {
           case tree: untpd.Apply =>
-            if (ctx.mode is Mode.Pattern) typedUnApply(tree, pt)
-            else if (Feature.enabled(modularity) && ctx.mode.is(Mode.Type) && !ctx.isAfterTyper) typedAppliedConstructorType(tree)
-            else typedApply(tree, pt)
+            if (ctx.mode is Mode.Pattern) typedUnApply(tree, pt) else typedApply(tree, pt)
           case tree: untpd.This => typedThis(tree)
           case tree: untpd.Number => typedNumber(tree, pt)
           case tree: untpd.Literal => typedLiteral(tree)

docs/_docs/reference/experimental/modularity.md

@@ -224,6 +224,16 @@ SimpleType        ::=  SimpleLiteral
 
 A `SimpleType` can now optionally be followed by `ParArgumentExprs`.
 
+The arguments are used to typecheck the whole type, as if it was a normal
+constructor application. For classes with `tracked` parameters this will mean
+that the resulting type will have a refinement for each `tracked` parameter.
+
+For example, given the following class definition:
+```scala
+class Person(tracked val name: String, tracked val age: Int)
+```
+**Type** `Person("Kasia", 27)` will be translated to `Person { val name: "Kasia"; val age: 27 }`.
+
 ## Allow Class Parents to be Refined Types
 
 Since `tracked` parameters create refinements in constructor types,

tests/warn/applied_constructor_types.check

@@ -1,4 +1,4 @@
--- [E209] Type Warning: tests/warn/applied_constructor_types.scala:6:10 ------------------------------------------------
+-- [E211] Type Warning: tests/warn/applied_constructor_types.scala:6:10 ------------------------------------------------
 6 |  val v1: UnspecificBox(4) = UnspecificBox(4) // warn
   |          ^^^^^^^^^^^^^^^^
-  |          Applied constructor type can only be used with classes that only have tracked parameters
+  |Applied constructor type can only be used with classes where all parameters in the first parameter list are tracked