Refinements to skolemizaton

compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala

@@ -459,9 +459,13 @@ class PlainPrinter(_ctx: Context) extends Printer {
         if (idx >= 0) selfRecName(idx + 1)
         else "{...}.this" // TODO move underlying type to an addendum, e.g. ... z3 ... where z3: ...
       case tp: SkolemType =>
-        if (homogenizedView) toText(tp.info)
-        else if (ctx.settings.XprintTypes.value) "<" ~ toText(tp.repr) ~ ":" ~ toText(tp.info) ~ ">"
-        else toText(tp.repr)
+        def reprStr = toText(tp.repr) ~ hashStr(tp)
+        if homogenizedView then
+          toText(tp.info)
+        else if ctx.settings.XprintTypes.value then
+          "<" ~ reprStr ~ ":" ~ toText(tp.info) ~ ">"
+        else
+          reprStr
     }
   }
 

compiler/src/dotty/tools/dotc/transform/patmat/Space.scala

@@ -570,7 +570,10 @@ object SpaceEngine {
     // Case unapplySeq:
     // 1. return the type `List[T]` where `T` is the element type of the unapplySeq return type `Seq[T]`
 
-    val resTp = wildApprox(ctx.typeAssigner.safeSubstMethodParams(mt, scrutineeTp :: Nil).finalResultType)
+    var resTp0 = mt.resultType
+    if mt.isResultDependent then
+      resTp0 = ctx.typeAssigner.safeSubstParam(resTp0, mt.paramRefs.head, scrutineeTp)
+    val resTp = wildApprox(resTp0).finalResultType
 
     val sig =
       if (resTp.isRef(defn.BooleanClass))

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

@@ -13,6 +13,7 @@ import Decorators._
 import config.Printers.{gadts, typr}
 import annotation.tailrec
 import reporting.*
+import TypeAssigner.skolemizeArgType
 import collection.mutable
 import scala.annotation.internal.sharable
 
@@ -853,7 +854,8 @@ trait Inferencing { this: Typer =>
           val arg = findArg(call)
           if !arg.isEmpty then
             var argType = arg.tpe.widenIfUnstable
-            if !argType.isSingleton then argType = SkolemType(argType)
+            if !argType.isSingleton then
+              argType = skolemizeArgType(argType, arg)
             argType <:< tvar
         case _ =>
   end constrainIfDependentParamRef

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

@@ -2245,8 +2245,9 @@ class Namer { typer: Typer =>
     // it would be erased to BoxedUnit.
     def dealiasIfUnit(tp: Type) = if (tp.isRef(defn.UnitClass)) defn.UnitType else tp
 
-    def cookedRhsType = dealiasIfUnit(rhsType).deskolemized
+    def cookedRhsType = dealiasIfUnit(rhsType)
     def lhsType = fullyDefinedType(cookedRhsType, "right-hand side", mdef.srcPos)
+      .deskolemized
     //if (sym.name.toString == "y") println(i"rhs = $rhsType, cooked = $cookedRhsType")
     if (inherited.exists)
       if sym.isInlineVal || isTracked then lhsType else inherited

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

@@ -12,6 +12,7 @@ import collection.mutable
 import reporting.*
 import Checking.{checkNoPrivateLeaks, checkNoWildcard}
 import cc.CaptureSet
+import util.Property
 import transform.Splicer
 
 trait TypeAssigner {
@@ -273,33 +274,32 @@ trait TypeAssigner {
   /** Substitute argument type `argType` for parameter `pref` in type `tp`,
    *  skolemizing the argument type if it is not stable and `pref` occurs in `tp`.
    */
-  def safeSubstParam(tp: Type, pref: ParamRef, argType: Type)(using Context): Type = {
+  def safeSubstParam(tp: Type, pref: ParamRef, argType: Type, arg: Tree | Null = null)(using Context): Type = {
     val tp1 = tp.substParam(pref, argType)
-    if ((tp1 eq tp) || argType.isStable) tp1
-    else tp.substParam(pref, SkolemType(argType.widen))
+    if (tp1 eq tp) || argType.isStable then tp1
+    else tp.substParam(pref, skolemizeArgType(argType.widen, arg))
   }
 
   /** Substitute types of all arguments `args` for corresponding `params` in `tp`.
    *  The number of parameters `params` may exceed the number of arguments.
    *  In this case, only the common prefix is substituted.
    */
-  def safeSubstParams(tp: Type, params: List[ParamRef], argTypes: List[Type])(using Context): Type = argTypes match {
-    case argType :: argTypes1 =>
-      val tp1 = safeSubstParam(tp, params.head, argType)
-      safeSubstParams(tp1, params.tail, argTypes1)
+  def safeSubstParams(tp: Type, params: List[ParamRef], args: List[Tree])(using Context): Type = args match
+    case arg :: args1 =>
+      val tp1 = safeSubstParam(tp, params.head, arg.tpe, arg)
+      safeSubstParams(tp1, params.tail, args1)
     case Nil =>
       tp
-  }
 
-  def safeSubstMethodParams(mt: MethodType, argTypes: List[Type])(using Context): Type =
-    if mt.isResultDependent then safeSubstParams(mt.resultType, mt.paramRefs, argTypes)
+  def safeSubstMethodParams(mt: MethodType, args: List[Tree])(using Context): Type =
+    if mt.isResultDependent then safeSubstParams(mt.resultType, mt.paramRefs, args)
     else mt.resultType
 
   def assignType(tree: untpd.Apply, fn: Tree, args: List[Tree])(using Context): Apply = {
     val ownType = fn.tpe.widen match {
       case fntpe: MethodType =>
         if fntpe.paramInfos.hasSameLengthAs(args) || ctx.phase.prev.relaxedTyping then
-          if fntpe.isResultDependent then safeSubstMethodParams(fntpe, args.tpes)
+          if fntpe.isResultDependent then safeSubstMethodParams(fntpe, args)
           else fntpe.resultType // fast path optimization
         else
           val erroringPhase =
@@ -570,6 +570,27 @@ trait TypeAssigner {
 }
 
 object TypeAssigner extends TypeAssigner:
+
+  /** An attachment on an argument in an application indicating that the argument's
+   *  type was converted to the given skolem type.
+   */
+  private val Skolemized = new Property.StickyKey[SkolemType]
+
+  /** A skolem type wrapping `argType`, associated with `arg` if it is non-null.
+   *  Skolem types for the same arguments with equal underlying `argType`s are re-used.
+   */
+  def skolemizeArgType(argType: Type, arg: tpd.Tree | Null)(using Context): Type =
+    if arg == null then
+      SkolemType(argType)
+    else
+      arg.getAttachment(Skolemized) match
+        case Some(sk @ SkolemType(tp)) if argType frozen_=:= tp =>
+          sk
+        case _ =>
+          val sk = SkolemType(argType)
+          arg.putAttachment(Skolemized, sk)
+          sk
+
   def seqLitType(tree: untpd.SeqLiteral, elemType: Type)(using Context) = tree match
     case tree: untpd.JavaSeqLiteral => defn.ArrayOf(elemType)
     case _ => if ctx.erasedTypes then defn.SeqType else defn.SeqType.appliedTo(elemType)

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

@@ -4355,7 +4355,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
             def inferArgsAfter(leading: Tree) =
               val formals2 =
                 if wtp.isParamDependent && leading.tpe.exists then
-                  formals1.mapconserve(f1 => safeSubstParam(f1, wtp.paramRefs(argIndex), leading.tpe))
+                  formals1.mapconserve(f1 => safeSubstParam(f1, wtp.paramRefs(argIndex), leading.tpe, leading))
                 else formals1
               implicitArgs(formals2, argIndex + 1, pt)
 

tests/pos/i23489.scala

@@ -0,0 +1,13 @@
+import scala.language.experimental.modularity
+
+class Box1[T <: Singleton](val x: T)
+class Box2[T : Singleton](x: => T)
+def id(x: Int): x.type = x
+def readInt(): Int = ???
+
+def Test = ()
+  val x = Box1(id(readInt()))
+
+  val _: Box1[? <: Int] = x
+
+  val y = Box2(id(readInt()))