Simplify the type member extractor logic.

And improve the error message on selecting a class member of an
unstable prefix.

Author: sjrd

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

@@ -3363,29 +3363,15 @@ class TrackingTypeComparer(initctx: Context) extends TypeComparer(initctx) {
             stableScrut.member(typeMemberName) match
               case denot: SingleDenotation if denot.exists =>
                 val info = denot.info match
-                  case TypeAlias(alias) => alias
-                  case info             => info // Notably, RealTypeBounds, which will eventually give a MatchResult.NoInstances
+                  case TypeAlias(alias)                => alias              // Extract the alias
+                  case ClassInfo(prefix, cls, _, _, _) => prefix.select(cls) // Re-select the class from the prefix
+                  case info => info // Notably, RealTypeBounds, which will eventually give a MatchResult.NoInstances
                 val infoRefersToSkolem = stableScrut.isInstanceOf[SkolemType] && stableScrut.occursIn(info)
-                if infoRefersToSkolem && info.isInstanceOf[ClassInfo] then
-                  /* We would like to create a `RealTypeBounds(info, info)` to get a `MatchResult.NoInstances`
-                   * but that is not allowed for `ClassInfo`. So instead we return `false`, which will result
-                   * in a `MatchResult.Stuck` instead.
-                   */
-                  false
-                else
-                  val info1 = info match
-                    case ClassInfo(prefix, cls, _, _, _) =>
-                      // Re-select the class from the prefix
-                      prefix.select(cls)
-                    case info: TypeBounds =>
-                      // Will already trigger a MatchResult.NoInstances
-                      info
-                    case _ if infoRefersToSkolem =>
-                      // Explicitly trigger a MatchResult.NoInstances
-                      RealTypeBounds(info, info)
-                    case _ =>
-                      info
-                  rec(capture, info1, variance = 0, scrutIsWidenedAbstract)
+                val info1 = info match
+                  case info: TypeBounds        => info                       // Will already trigger a MatchResult.NoInstances
+                  case _ if infoRefersToSkolem => RealTypeBounds(info, info) // Explicitly trigger a MatchResult.NoInstances
+                  case _                       => info                       // We have a match
+                rec(capture, info1, variance = 0, scrutIsWidenedAbstract)
               case _ =>
                 false
       end rec

tests/neg/match-type-enumeration-value-hack.check

@@ -7,5 +7,7 @@
    |
    |                                          trying to reduce  EnumValue[Suit]
    |                                          failed since selector Suit
-   |                                          does not match  case EnumValueAux[t] => t
-   |                                          and cannot be shown to be disjoint from it either.
+   |                                          does not uniquely determine parameter t in
+   |                                            case EnumValueAux[t] => t
+   |                                          The computed bounds for the parameter are:
+   |                                            t >: ?1.Value <: ?1.Value