Allow to reduce type member extractors when the member is a class.

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

@@ -3371,19 +3371,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
-                if info.isInstanceOf[ClassInfo] then
-                  /* The member is not an alias (we'll get Stuck instead of NoInstances,
-                   * which is not ideal, but we cannot make a RealTypeBounds of ClassInfo).
-                   */
-                  false
-                else
-                  val infoRefersToSkolem = stableScrut.isInstanceOf[SkolemType] && stableScrut.occursIn(info)
-                  val info1 =
-                    if infoRefersToSkolem && !info.isInstanceOf[TypeBounds] then RealTypeBounds(info, info) // to trigger a MatchResult.NoInstances
-                    else info
-                  rec(capture, info1, variance = 0, scrutIsWidenedAbstract)
+                  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)
+                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

@@ -0,0 +1,13 @@
+-- [E172] Type Error: tests/neg/match-type-enumeration-value-hack.scala:11:40 ------------------------------------------
+11 |  summon[Suit#Value =:= EnumValue[Suit]] // error
+   |                                        ^
+   |                                        Cannot prove that Suit#Value =:= EnumValue[Suit].
+   |
+   |                                        Note: a match type could not be fully reduced:
+   |
+   |                                          trying to reduce  EnumValue[Suit]
+   |                                          failed since selector Suit
+   |                                          does not uniquely determine parameter t in
+   |                                            case EnumValueAux[t] => t
+   |                                          The computed bounds for the parameter are:
+   |                                            t >: ?1.Value <: ?1.Value

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

@@ -0,0 +1,12 @@
+type EnumValueAux[A] = ({ type Value }) { type Value = A }
+
+type EnumValue[E <: Enumeration] = E match
+  case EnumValueAux[t] => t
+
+// A class extending Enumeration does not yet define a concrete enumeration
+class Suit extends Enumeration:
+  val Hearts, Diamonds, Clubs, Spades = Val()
+
+object Test:
+  summon[Suit#Value =:= EnumValue[Suit]] // error
+end Test

tests/pos/match-type-enumeration-value-hack.scala

@@ -0,0 +1,11 @@
+type EnumValueAux[A] = ({ type Value }) { type Value = A }
+
+type EnumValue[E <: Enumeration] = E match
+  case EnumValueAux[t] => t
+
+object Suit extends Enumeration:
+  val Hearts, Diamonds, Clubs, Spades = Val()
+
+object Test:
+  summon[Suit.Value =:= EnumValue[Suit.type]]
+end Test