Parse applied constructor type arguments as trees

Co-authored-by: Kacper Korban <[email protected]>

Author: mbovel

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

@@ -1331,25 +1331,6 @@ object Parsers {
     */
     def qualId(): Tree = dotSelectors(termIdent())
 
-    /** Singleton    ::=  SimpleRef
-     *                 |  SimpleLiteral
-     *                 |  Singleton ‘.’ id
-     *                 |  Singleton ‘(’ Singletons ‘)’
-     *  -- not yet     |  Singleton ‘[’ Types ‘]’
-     */
-    def singleton(): Tree =
-      val res =
-        if isSimpleLiteral then simpleLiteral()
-        else dotSelectors(simpleRef())
-      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())))) // 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
      *                      |  [‘-’] floatingPointLiteral
      *                      |  booleanLiteral
@@ -2092,7 +2073,11 @@ object Parsers {
         val start = in.skipToken()
         typeBounds().withSpan(Span(start, in.lastOffset, start))
       else
-        singletonArgs(simpleType1())
+        val tpt = simpleType1()
+        if in.featureEnabled(Feature.modularity)  && in.token == LPAREN then
+          parArgumentExprss(wrapNew(tpt))
+        else
+          tpt
 
     /** SimpleType1      ::=  id
      *                     |  Singleton `.' id

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

@@ -1715,6 +1715,17 @@ 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) =
+    val Select(New(tpt), _) = tree.fun: @unchecked // Always wrapped in `New`, see `simpleType` in `Parsers`
+    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
+    if preciseTp frozen_=:= classTp then
+      report.warning(em"Blop blop")
+    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

@@ -2556,55 +2556,10 @@ 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 = {
-    val AppliedTypeTree(originalTpt, args) = 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
-      //     )
-      // }
-      def getArgs(t: Tree): List[List[Tree]] = t match
-        case AppliedTypeTree(base, args) => getArgs(base) :+ args
-        case _ => Nil
-
-      def instAll(t: Type, args: List[List[Tree]]): Type = (t.widenDealias, args) match
-        case (_, Nil) => t
-        case (t: MethodType, args :: rest) =>
-          val t1 = t.instantiate(args.map(_.tpe))
-          instAll(t1, rest)
-        case (_, args :: rest) =>
-          val t1 = t.appliedTo(args.map(_.tpe))
-          instAll(t1, rest)
-
-      constr.typeRef.underlying match
-        case mt: MethodOrPoly =>
-          val typedArgs = tree.args.map(a => (TypeTree(typedExpr(a).tpe)))
-          val preArgs = getArgs(tpt1)
-          TypeTree(instAll(mt, preArgs :+ typedArgs))
-    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 =>
-        return typedTermAppliedTypeTree(tree, tpt1)
-      case _ =>
-
     val tparams = tpt1.tpe.typeParams
      if tpt1.tpe.isError then
        val args1 = tree.args.mapconserve(typedType(_))
@@ -3556,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 type
+   *  @param pt          the expected result typ
    *  @param locked      the set of type variables of the current typer state that cannot be interpolated
    *                     at the present time
    */
@@ -3596,7 +3551,9 @@ 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 typedApply(tree, pt)
+            if (ctx.mode is Mode.Pattern) typedUnApply(tree, pt)
+            else if (ctx.mode is Mode.Type) typedAppliedConstructorType(tree)
+            else typedApply(tree, pt)
           case tree: untpd.This => typedThis(tree)
           case tree: untpd.Number => typedNumber(tree, pt)
           case tree: untpd.Literal => typedLiteral(tree)

tests/neg/applied_constructor_types.check

@@ -0,0 +1,21 @@
+-- [E006] Not Found Error: tests/neg/applied_constructors.scala:8:10 ---------------------------------------------------
+8 |  val v1: f(1) = f(1) // error
+  |          ^
+  |          Not found: type f
+  |
+  | longer explanation available when compiling with `-explain`
+Blop blop
+-- [E006] Not Found Error: tests/neg/applied_constructors.scala:9:10 ---------------------------------------------------
+9 |  val v2: id(1) = f(1) // error
+  |          ^^
+  |          Not found: type id - did you mean is?
+  |
+  | longer explanation available when compiling with `-explain`
+Blop blop
+-- [E006] Not Found Error: tests/neg/applied_constructors.scala:10:10 --------------------------------------------------
+10 |  val v3: idDependent(1) = f(1) // error
+   |          ^^^^^^^^^^^
+   |          Not found: type idDependent
+   |
+   | longer explanation available when compiling with `-explain`
+Blop blop

tests/neg/applied_constructor_types.scala

@@ -0,0 +1,10 @@
+import scala.language.experimental.modularity
+
+def f(x: Int): Int = x
+def id[T](x: T): T = x
+def idDependent(x: Any): x.type = x
+
+def test =
+  val v1: f(1) = f(1) // error
+  val v2: id(1) = f(1) // error
+  val v3: idDependent(1) = f(1) // error

tests/pos/applied_constructor_types.scala

@@ -0,0 +1,35 @@
+import scala.language.experimental.modularity
+
+class Box(tracked val v: Any)
+class C(tracked val x: Int)
+class NC(tracked val c: C)
+class NNC(tracked val c: NC)
+class F[A](tracked val a: Int)
+class G[A](tracked val a: A)
+class NF[A](tracked val f: F[A])
+
+object O:
+  val m: Int = 42
+
+  class InnerClass(tracked val x: Int)
+
+object Test extends App {
+  val c: C(42) = C(42)
+  val nc: NC(C(42)) = NC(C(42))
+  val nc1: NC(c) = NC(c)
+  val nnc: NNC(NC(C(42))) = NNC(NC(C(42)))
+  val f: F[Int](42) = F[Int](42)
+  val f2: F[Int](42) = F(42)
+  val f3: F(42) = F(42)
+  val g: G(42) = G(42)
+
+  val n: Int = 42
+  val c2: C(n) = C(n)
+  val c3: C(O.m) = C(O.m)
+
+  val box: Box(O.InnerClass(42)) = Box(O.InnerClass(42))
+  val box2: Box(O.InnerClass(n)) = Box(O.InnerClass(n))
+  val box3: Box(O.InnerClass(O.m)) = Box(O.InnerClass(O.m))
+  val box4: Box(n) = Box(O.InnerClass(n).x)
+  val box5: Box(O.m) = Box(O.InnerClass(O.m).x)
+}

tests/pos/applied_constructors.scala

@@ -0,0 +1 @@
+TODO

tests/warn/applied_constructor_types.check

@@ -0,0 +1,6 @@
+import scala.language.experimental.modularity
+
+class UnspecificBox(val v: Any)
+
+def test =
+  val v1: UnspecificBox(4) = UnspecificBox(4) // warn