Don't approximate a type using Nothing as prefix

Approximate range(Nothing, hi) to Nothing & hi instead of Nothing. This avoids
creating TypeRefs with a Nothing prefix which manifest themselves down the line
with an error like:

    Cannot resolve reference to type path.type.AbsMember.
    The classfile defining the type might be missing from the classpath.
         val z1 = transition(di).ext(1) // error
                            ^
Due to a MissingType thrown from TypeErasure#sigName

Fixes #23530

Author: smarter

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

@@ -6482,9 +6482,24 @@ object Types extends TypeUtils {
   abstract class ApproximatingTypeMap(using Context) extends TypeMap { thisMap =>
 
     protected def range(lo: Type, hi: Type): Type =
-      if (variance > 0) hi
-      else if (variance < 0) lo
-      else if (lo `eq` hi) lo
+      if variance > 0 then hi
+      else if variance < 0 then
+        if lo eq defn.NothingType then
+          // Approximate by Nothing & hi instead of just Nothing, in case the
+          // approximated type is used as the prefix of another type (this would
+          // lead to a type with a `NoDenotation` denot and a possible
+          // MissingType in `TypeErasure#sigName`).
+          //
+          // Note that we cannot simply check for a `Nothing` prefix in
+          // `derivedSelect`, because the substitution might be done lazily (for
+          // example if Nothing is the type of a parameter being depended on in
+          // a MethodType)
+          //
+          // Test case in tests/pos/i23530.scala
+          AndType(lo, hi)
+        else
+          lo
+      else if lo `eq` hi then lo
       else Range(lower(lo), upper(hi))
 
     protected def emptyRange = range(defn.NothingType, defn.AnyType)

tests/pos/i23530.scala

@@ -0,0 +1,18 @@
+trait TestContainer:
+  trait TestPath:
+    type AbsMember
+
+  extension (path: TestPath)
+    infix def ext(color: path.AbsMember): Unit = ???
+    infix def ext(other: Int): Unit = ???
+
+object Repro:
+  val dc2: TestContainer = ???
+  import dc2.TestPath
+
+  def transition(path: TestPath)(using DummyImplicit): TestPath = ???
+
+  def test: Unit =
+    val di: TestPath = ???
+    // error
+    val z1 = transition(di).ext(1)