Refinement: Make scheme work also if arguments are duplicated

The new scheme works also if argument trees are not unique. Instead of storing
skolem types directly in attachment of arguments, we store a map from arguments
to their skolems in the enclosing application node. But we check then that the
same argument tree does not appear several times in an application. If it does
appear several times, we don't generate the map.

Furthermore, we are also safe if the whole application tree is used several times,
since for each call we generate new skolems and store them in the map. So different
calls get different skolems.

Author: odersky

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

@@ -573,7 +573,7 @@ object SpaceEngine {
     var resTp0 = mt.resultType
     if mt.isResultDependent then
       resTp0 = ctx.typeAssigner.safeSubstParam(resTp0, mt.paramRefs.head, scrutineeTp)
-    val resTp = wildApprox(resTp0).finalResultType
+    val resTp = wildApprox(resTp0.finalResultType)
 
     val sig =
       if (resTp.isRef(defn.BooleanClass))

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

@@ -13,7 +13,7 @@ import Decorators._
 import config.Printers.{gadts, typr}
 import annotation.tailrec
 import reporting.*
-import TypeAssigner.skolemizeArgType
+import TypeAssigner.SkolemizedArgs
 import collection.mutable
 import scala.annotation.internal.sharable
 
@@ -840,23 +840,33 @@ trait Inferencing { this: Typer =>
     if tvar.origin.paramName.is(NameKinds.DepParamName) then
       representedParamRef(tvar.origin) match
         case ref: TermParamRef =>
-          def findArg(tree: Tree)(using Context): Tree = tree match
-            case Apply(fn, args) =>
+          def findArg(tree: Tree)(using Context): Option[(Tree, Apply)] = tree match
+            case app @ Apply(fn, args) =>
               if fn.tpe.widen eq ref.binder then
-                if ref.paramNum < args.length then args(ref.paramNum)
-                else EmptyTree
+                if ref.paramNum < args.length then Some((args(ref.paramNum), app))
+                else None
               else findArg(fn)
             case TypeApply(fn, _) => findArg(fn)
             case Block(_, expr) => findArg(expr)
             case Inlined(_, _, expr) => findArg(expr)
-            case _ => EmptyTree
-
-          val arg = findArg(call)
-          if !arg.isEmpty then
-            var argType = arg.tpe.widenIfUnstable
-            if !argType.isSingleton then
-              argType = skolemizeArgType(argType, arg)
-            argType <:< tvar
+            case _ => None
+
+          findArg(call) match
+            case Some((arg, app)) =>
+              var argType = arg.tpe.widenIfUnstable
+              if !argType.isSingleton then
+                argType = app.getAttachment(SkolemizedArgs) match
+                  case Some(mapping) =>
+                    mapping.get(arg) match
+                      case Some(sk @ SkolemType(at)) =>
+                        assert(argType frozen_=:= at)
+                        sk
+                      case _ =>
+                        SkolemType(argType)
+                  case _ =>
+                    SkolemType(argType)
+              argType <:< tvar
+            case _ =>
         case _ =>
   end constrainIfDependentParamRef
 }

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

@@ -271,35 +271,43 @@ trait TypeAssigner {
     untpd.cpy.Super(tree)(qual, tree.mix)
       .withType(superType(qual.tpe, tree.mix, mixinClass, tree.srcPos))
 
+  private type SkolemBuffer = mutable.ListBuffer[(Tree, SkolemType)]
+
   /** Substitute argument type `argType` for parameter `pref` in type `tp`,
    *  skolemizing the argument type if it is not stable and `pref` occurs in `tp`.
+   *  If skolemization happens the new SkolemType is passed to `recordSkolem`
+   *  provided the latter is non-null.
    */
-  def safeSubstParam(tp: Type, pref: ParamRef, argType: Type, arg: Tree | Null = null)(using Context): Type = {
+  def safeSubstParam(tp: Type, pref: ParamRef, argType: Type,
+      recordSkolem: (SkolemType => Unit) | Null = null)(using Context): Type =
     val tp1 = tp.substParam(pref, argType)
     if (tp1 eq tp) || argType.isStable then tp1
-    else tp.substParam(pref, skolemizeArgType(argType.widen, arg))
-  }
+    else
+      val narrowed = SkolemType(argType.widen)
+      if recordSkolem != null then recordSkolem(narrowed)
+      tp.substParam(pref, narrowed)
 
   /** 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.
+   *  Skolems generated by `safeSubstParam` are stored in `skolems`.
    */
-  def safeSubstParams(tp: Type, params: List[ParamRef], args: List[Tree])(using Context): Type = args match
+  private def safeSubstParams(tp: Type, params: List[ParamRef],
+      args: List[Tree], skolems: SkolemBuffer)(using Context): Type = args match
     case arg :: args1 =>
-      val tp1 = safeSubstParam(tp, params.head, arg.tpe, arg)
-      safeSubstParams(tp1, params.tail, args1)
+      val tp1 = safeSubstParam(tp, params.head, arg.tpe, sk => skolems += ((arg, sk)))
+      safeSubstParams(tp1, params.tail, args1, skolems)
     case Nil =>
       tp
 
-  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 = {
+    var skolems: SkolemBuffer | Null = null
     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)
+          if fntpe.isResultDependent then
+            skolems = new mutable.ListBuffer()
+            safeSubstParams(fntpe.resultType, fntpe.paramRefs, args, skolems.nn)
           else fntpe.resultType // fast path optimization
         else
           val erroringPhase =
@@ -312,7 +320,13 @@ trait TypeAssigner {
         if (ctx.settings.Ydebug.value) new FatalError("").printStackTrace()
         errorType(err.takesNoParamsMsg(fn, ""), tree.srcPos)
     }
-    ConstFold.Apply(tree.withType(ownType))
+    val app = tree.withType(ownType)
+    if skolems != null
+        && skolems.nn.nonEmpty  // @notional why is `.nn` needed here?
+        && skolems.nn.size == skolems.nn.toSet.size // each skolemized argument is unique
+    then
+      app.putAttachment(SkolemizedArgs, skolems.nn.toMap)
+    ConstFold.Apply(app)
   }
 
   def assignType(tree: untpd.TypeApply, fn: Tree, args: List[Tree])(using Context): TypeApply = {
@@ -571,25 +585,10 @@ 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.
+  /** An attachment on an application indicating a map from arguments to the skolem types
+   *  that were created in safeSubstParams.
    */
-  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
+  private[typer] val SkolemizedArgs = new Property.Key[Map[tpd.Tree, SkolemType]]
 
   def seqLitType(tree: untpd.SeqLiteral, elemType: Type)(using Context) = tree match
     case tree: untpd.JavaSeqLiteral => defn.ArrayOf(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, leading))
+                  formals1.mapconserve(f1 => safeSubstParam(f1, wtp.paramRefs(argIndex), leading.tpe))
                 else formals1
               implicitArgs(formals2, argIndex + 1, pt)