In instantiateToSubType, also infer the prefix of the approximated parent

Author: dwijnand

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

@@ -701,7 +701,7 @@ object TypeOps:
     // `this`. We perform the following operations to approximate the parameters:
     //
     // 1. Replace type parameters in T with tvars
-    // 2. Replace `A.this.C` with `A#C` (see tests/patmat/i12681.scala)
+    // 2. Replace non-class applied types with a tvar, bounded by its type constructor's underlying type
     //
     val approximateParent = new TypeMap {
       val boundTypeParams = util.HashMap[TypeRef, TypeVar]()
@@ -710,9 +710,6 @@ object TypeOps:
         case _: MatchType =>
           tp // break cycles
 
-        case ThisType(tref: TypeRef) if !tref.symbol.isStaticOwner =>
-          tref
-
         case tp: TypeRef if !tp.symbol.isClass =>
           def lo = LazyRef.of(apply(tp.underlying.loBound))
           def hi = LazyRef.of(apply(tp.underlying.hiBound))
@@ -789,9 +786,12 @@ object TypeOps:
       }
     }
 
-    val inferThisMap = new InferPrefixMap
-    val tvars = tp1.typeParams.map { tparam => newTypeVar(tparam.paramInfo.bounds) }
-    val protoTp1 = inferThisMap.apply(tp1).appliedTo(tvars)
+    def inferPrefix(tp: Type) =
+      val inferThisMap = new InferPrefixMap
+      val tvars = tp.typeParams.map(tparam => newTypeVar(tparam.paramInfo.bounds))
+      inferThisMap(tp).appliedTo(tvars)
+
+    val protoTp1 = inferPrefix(tp1)
 
     // If parent contains a reference to an abstract type, then we should
     // refine subtype checking to eliminate abstract types according to
@@ -809,7 +809,7 @@ object TypeOps:
 
     if (protoTp1 <:< tp2) instantiate()
     else {
-      val approxTp2 = approximateParent(tp2)
+      val approxTp2 = inferPrefix(approximateParent(tp2))
       if (protoTp1 <:< approxTp2 || parentQualify(protoTp1, approxTp2)) instantiate()
       else NoType
     }

tests/patmat/t6146.comb1.scala

@@ -0,0 +1,20 @@
+// Like the "tricksier" variantion in t6146, but less tricksy (less nesting)
+// but also with a non-Any type argument, and some invariant usage of the type.
+// Used to study why `case _: C.type =>` is considered unreachable
+// in the ordinal method object A synthesises.
+trait T[X] {
+  sealed trait A
+  object A {
+    case object B extends A
+  }
+
+  def give: X
+  def take(x: X): X
+}
+
+object O extends T[String] {
+  def give            = "O"
+  def take(x: String) = s"$x. Love, O."
+}
+
+case object C extends O.A