Avoid loosing denotations of named types during integrate

compiler/src/dotty/tools/dotc/ast/tpd.scala

@@ -842,14 +842,6 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       Closure(tree: Tree)(env, meth, tpt)
   }
 
-  // This is a more fault-tolerant copier that does not cause errors when
-  // function types in applications are undefined.
-  // This was called `Inliner.InlineCopier` before 3.6.3.
-  class ConservativeTreeCopier() extends TypedTreeCopier:
-    override def Apply(tree: Tree)(fun: Tree, args: List[Tree])(using Context): Apply =
-      if fun.tpe.widen.exists then super.Apply(tree)(fun, args)
-      else untpd.cpy.Apply(tree)(fun, args).withTypeUnchecked(tree.tpe)
-
   override def skipTransform(tree: Tree)(using Context): Boolean = tree.tpe.isError
 
   implicit class TreeOps[ThisTree <: tpd.Tree](private val tree: ThisTree) extends AnyVal {

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

@@ -3823,9 +3823,35 @@ object Types extends TypeUtils {
     def integrate(tparams: List[ParamInfo], tp: Type)(using Context): Type =
       (tparams: @unchecked) match {
         case LambdaParam(lam, _) :: _ => tp.subst(lam, this) // This is where the precondition is necessary.
-        case params: List[Symbol @unchecked] => tp.subst(params, paramRefs)
+        case params: List[Symbol @unchecked] => IntegrateMap(params, paramRefs)(tp)
       }
 
+    /** A map that replaces references to symbols in `params` by the types in
+     *  `paramRefs`.
+     *
+     *  It is similar to [[Substituters#subst]] but avoids reloading denotations
+     *  of named types by overriding `derivedSelect`.
+     *
+     *  This is needed because during integration, [[TermParamRef]]s refer to a
+     *  [[LambdaType]] that is not yet fully constructed, in particular for wich
+     *  `paramInfos` is `null`. In that case all [[TermParamRef]]s have
+     *  [[NoType]] as underlying type. Reloading denotions of selections
+     *  involving such [[TermParamRef]]s in [[NamedType#withPrefix]] could then
+     *  result in a [[NoDenotation]], which would make later disambiguation of
+     *  overloads impossible. See `tests/pos/annot-17242.scala` for example.
+     */
+    private class IntegrateMap(params: List[Symbol], paramRefs: List[Type])(using Context) extends TypeMap:
+      override def apply(tp: Type) =
+        tp match
+          case tp: NamedType if params.contains(tp.symbol) => paramRefs(params.indexOf(tp.symbol))
+          case _: BoundType | _: ThisType => tp
+          case _ => mapOver(tp)
+
+      override def derivedSelect(tp: NamedType, pre: Type): Type =
+        if tp.prefix eq pre then tp
+        else if tp.symbol.exists then NamedType(pre, tp.name, tp.denot.asSeenFrom(pre))
+        else NamedType(pre, tp.name)
+
     final def derivedLambdaType(paramNames: List[ThisName] = this.paramNames,
                           paramInfos: List[PInfo] = this.paramInfos,
                           resType: Type = this.resType)(using Context): This =
@@ -6310,14 +6336,7 @@ object Types extends TypeUtils {
       }
     }
 
-    private def treeTypeMap = new TreeTypeMap(
-      typeMap = this,
-      // Using `ConservativeTreeCopier` is needed when copying dependent annoted
-      // types, where we can refer to a previous parameter represented as
-      // `TermParamRef` that has no underlying type yet.
-      // See tests/pos/annot-17242.scala.
-      cpy = ConservativeTreeCopier()
-    )
+    private def treeTypeMap = new TreeTypeMap(typeMap = this)
 
     def mapOver(syms: List[Symbol]): List[Symbol] = mapSymbols(syms, treeTypeMap)
 

compiler/src/dotty/tools/dotc/inlines/Inliner.scala

@@ -96,6 +96,15 @@ object Inliner:
     }
   end isElideableExpr
 
+  // InlineCopier is a more fault-tolerant copier that does not cause errors when
+  // function types in applications are undefined. This is necessary since we copy at
+  // the same time as establishing the proper context in which the copied tree should
+  // be evaluated. This matters for opaque types, see neg/i14653.scala.
+  private class InlineCopier() extends TypedTreeCopier:
+    override def Apply(tree: Tree)(fun: Tree, args: List[Tree])(using Context): Apply =
+      if fun.tpe.widen.exists then super.Apply(tree)(fun, args)
+      else untpd.cpy.Apply(tree)(fun, args).withTypeUnchecked(tree.tpe)
+
   // InlinerMap is a TreeTypeMap with special treatment for inlined arguments:
   // They are generally left alone (not mapped further, and if they wrap a type
   // the type Inlined wrapper gets dropped.
@@ -108,13 +117,7 @@ object Inliner:
       substFrom: List[Symbol],
       substTo: List[Symbol])(using Context)
     extends TreeTypeMap(
-      typeMap, treeMap, oldOwners, newOwners, substFrom, substTo,
-      // It is necessary to use the `ConservativeTreeCopier` since we copy at
-      // the same time as establishing the proper context in which the copied
-      // tree should be evaluated. This matters for opaque types, see
-      // neg/i14653.scala.
-      ConservativeTreeCopier()
-    ):
+      typeMap, treeMap, oldOwners, newOwners, substFrom, substTo, InlineCopier()):
 
     override def transform(tree: Tree)(using Context): Tree =
       tree match

tests/neg/i12448.scala

@@ -1,5 +1,5 @@
 object Main {
   def mkArray[T <: A]: T#AType // error // error
-  mkArray[Array] // was: "assertion failed: invalid prefix HKTypeLambda..." // error
-  val x = mkArray[Array] // error
+  mkArray[Array]
+  val x = mkArray[Array]
 }

tests/pos/annot-17242.scala

@@ -1,5 +1,3 @@
-// See also tests/pos/annot-21595.scala
-
 class local(predicate: Int) extends annotation.StaticAnnotation
 
 def failing1(x: Int, z: Int @local(x + x)) = ()