Backport "used derived types to type arguments of dependent function type" to LTS (#20970)

Backports #19838 to the LTS branch.

PR submitted by the release tooling.
[skip ci]

Author: WojciechMazur

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -61,6 +61,15 @@ class TreeUnpickler(reader: TastyReader,
   /** A map from addresses of definition entries to the symbols they define */
   private val symAtAddr  = new mutable.HashMap[Addr, Symbol]
 
+  private def addrOfSymbol(sym: Symbol): Option[Addr] = symAtAddr.iterator.collectFirst {
+    case (addr, s) if s == sym => addr
+  }
+
+  private def locatedSymbol(sym: Symbol)(using Context): String =
+    addrOfSymbol(sym) match
+      case Some(addr) => i"local $sym @ ${addr.index}"
+      case None => i"external $sym"
+
   /** A temporary map from addresses of definition entries to the trees they define.
    *  Used to remember trees of symbols that are created by a completion. Emptied
    *  once the tree is inlined into a larger tree.
@@ -275,7 +284,7 @@ class TreeUnpickler(reader: TastyReader,
     /** The symbol defined by current definition */
     def symbolAtCurrent()(using Context): Symbol = symAtAddr.get(currentAddr) match {
       case Some(sym) =>
-        assert(ctx.owner == sym.owner, i"owner discrepancy for $sym, expected: ${ctx.owner}, found: ${sym.owner}")
+        assert(ctx.owner == sym.owner, i"owner discrepancy for ${locatedSymbol(sym)}, expected: ${locatedSymbol(ctx.owner)}, found: ${locatedSymbol(sym.owner)}")
         sym
       case None =>
         createSymbol()

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

@@ -1439,14 +1439,14 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           if isErasedClass then arg.withAddedFlags(Erased) else arg
         }
         return typedDependent(newParams)
-      val resTpt = TypeTree(mt.nonDependentResultApprox).withSpan(body.span)
-      val typeArgs = appDef.termParamss.head.map(_.tpt) :+ resTpt
       val core =
         if mt.hasErasedParams then TypeTree(defn.ErasedFunctionClass.typeRef)
         else
+          val resTpt = TypeTree(mt.nonDependentResultApprox).withSpan(body.span)
+          val paramTpts = appDef.termParamss.head.map(p => TypeTree(p.tpt.tpe).withSpan(p.tpt.span))
           val funSym = defn.FunctionSymbol(numArgs, isContextual, isImpure)
           val tycon = TypeTree(funSym.typeRef)
-          AppliedTypeTree(tycon, typeArgs)
+          AppliedTypeTree(tycon, paramTpts :+ resTpt)
       RefinedTypeTree(core, List(appDef), ctx.owner.asClass)
     end typedDependent
 

tests/pos/i19629.scala

@@ -0,0 +1,10 @@
+trait CP[A,B]
+trait TypeEqK[F[_], G[_]]
+
+trait Knit[CP[_, _], F[_]] {
+  type Res
+
+  def visit[R](
+    caseInFst: [F1[_], Y] => (k: Knit[CP, F1]) => (ev: TypeEqK[F, [x] =>> CP[F1[x], Y]]) => R
+  ): R
+}

tests/run/i19629/Test_2.scala

@@ -0,0 +1,12 @@
+
+class Container[Y1, G[_]]:
+  lazy val outer: Knit[CP, G] = new:
+    type Res = Y1
+    def visit[R](caseInFst: [F1[_], Y] => (k: Knit[CP, F1]) => (ev: TypeEqK[G, [x] =>> CP[F1[x], Y]]) => R): R =
+      caseInFst[G, Res](outer)(new TypeEqK[G, [x] =>> CP[G[x], Res]] {})
+
+@main def Test =
+  val knit = new Container[Unit, Option].outer
+  val res = knit.visit:
+    [F1[_], Y] => (k: Knit[CP, F1]) => (ev: TypeEqK[Option, [x] =>> CP[F1[x], Y]]) => 42
+  assert(res == 42)

tests/run/i19629/lib_1.scala

@@ -0,0 +1,10 @@
+trait CP[A,B]
+trait TypeEqK[F[_], G[_]]
+
+trait Knit[CP[_, _], F[_]] {
+  type Res
+
+  def visit[R](
+    caseInFst: [F1[_], Y] => (k: Knit[CP, F1]) => (ev: TypeEqK[F, [x] =>> CP[F1[x], Y]]) => R
+  ): R
+}