Move implementation into TypeApplications etaExpandWithAsf

Author: dwijnand

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

@@ -321,6 +321,22 @@ class TypeApplications(val self: Type) extends AnyVal {
     }
   }
 
+  // Like `target.etaExpand(target.typeParams)`
+  // except call `asSeenFrom` to fix class type parameter bounds
+  // e.g. in pos/i18569:
+  // given prefix `M2.type` and symbol `trait F`
+  // the result of `prefix.select(sym)` is `M2.F`
+  // however F's type parameter T is `<: M1#A` rather than `<: M2.A`
+  // so add a call to `asSeenFrom` with prefix `M2.type` and owner `trait M1`
+  def etaExpandWithAsf(prefix: Type, owner: Symbol)(using Context): Type =
+    val tparams = self.typeParams
+    HKTypeLambda(tparams.map(_.paramName))(
+      tl => tparams.map {
+        case p: Symbol => HKTypeLambda.toPInfo(tl.integrate(tparams, p.info.asSeenFrom(prefix, owner)))
+        case p         => HKTypeLambda.toPInfo(tl.integrate(tparams, p.paramInfo))
+      },
+      tl => tl.integrate(tparams, self.appliedTo(tparams.map(_.paramRef))))
+
   /** Maps [Ts] => C[Ts] to C */
   def etaCollapse(using Context): Type = self match
     case EtaExpansion(classType) => classType

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

@@ -1196,22 +1196,8 @@ class Namer { typer: Typer =>
             if mbr.isType then
               val forwarderName = checkNoConflict(alias.toTypeName, isPrivate = false, span)
               var target = pathType.select(sym)
-              val tparams = target.typeParams
-              if tparams.nonEmpty then
-                // like `target = target.etaExpand(target.typeParams)`
-                // except call `asSeenFrom` to fix class type parameter bounds
-                // e.g. in pos/i18569:
-                // `Test#F` should have `M2.A` or `Test.A` as bounds, not `M1#A`.
-                target = HKTypeLambda(tparams.map(_.paramName))(
-                  tl => tparams.map {
-                    case p: Symbol =>
-                      val info = p.info.asSeenFrom(pathType, sym.owner)
-                      HKTypeLambda.toPInfo(tl.integrate(tparams, info))
-                    case p =>
-                      val info = p.paramInfo
-                      HKTypeLambda.toPInfo(tl.integrate(tparams, info))
-                  },
-                  tl => tl.integrate(tparams, target.appliedTo(tparams.map(_.paramRef))))
+              if target.typeParams.nonEmpty then
+                target = target.etaExpandWithAsf(pathType, sym.owner)
               newSymbol(
                 cls, forwarderName,
                 Exported | Final,