Handle type member extractors as specced match types.

Author: sjrd

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

@@ -3362,6 +3362,29 @@ class TrackingTypeComparer(initctx: Context) extends TypeComparer(initctx) {
                 rec(argPattern, ConstantType(Constant(scrutValue - 1)), variance, scrutIsWidenedAbstract)
               case _ =>
                 false
+
+          case MatchTypeCasePattern.TypeMemberExtractor(typeMemberName, capture) =>
+            val stableScrut: SingletonType = scrut match
+              case scrut: SingletonType => scrut
+              case _                    => SkolemType(scrut)
+            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 _ =>
+                false
       end rec
 
       def matchArgs(argPatterns: List[MatchTypeCasePattern], args: List[Type], tparams: List[TypeParamInfo], scrutIsWidenedAbstract: Boolean): Boolean =

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

@@ -5094,6 +5094,7 @@ object Types extends TypeUtils {
     case BaseTypeTest(classType: TypeRef, argPatterns: List[MatchTypeCasePattern], needsConcreteScrut: Boolean)
     case CompileTimeS(argPattern: MatchTypeCasePattern)
     case AbstractTypeConstructor(tycon: Type, argPatterns: List[MatchTypeCasePattern])
+    case TypeMemberExtractor(typeMemberName: TypeName, capture: Capture)
 
     def isTypeTest: Boolean =
       this.isInstanceOf[TypeTest]
@@ -5187,12 +5188,45 @@ object Types extends TypeUtils {
                 MatchTypeCasePattern.CompileTimeS(argPattern)
             else
               tycon.info match
-                case _: RealTypeBounds => recAbstractTypeConstructor(pat)
-                case _                 => null
+                case _: RealTypeBounds =>
+                  recAbstractTypeConstructor(pat)
+                case TypeAlias(tl @ HKTypeLambda(onlyParam :: Nil, resType: RefinedType)) =>
+                  /* Unlike for eta-expanded classes, the typer does not automatically
+                   * dealias poly type aliases to refined types. So we have to give them
+                   * a chance here.
+                   * We are quite specific about the shape of type aliases that we are willing
+                   * to dealias this way, because we must not dealias arbitrary type constructors
+                   * that could refine the bounds of the captures; those would amount of
+                   * type-test + capture combos, which are out of the specced match types.
+                   */
+                  rec(pat.superType, variance)
+                case _ =>
+                  null
 
           case pat @ AppliedType(tycon: TypeParamRef, _) if variance == 1 =>
             recAbstractTypeConstructor(pat)
 
+          case pat @ RefinedType(parent, refinedName: TypeName, TypeAlias(alias @ TypeParamRef(binder, num)))
+              if variance == 1 && (binder eq caseLambda) =>
+            parent.member(refinedName) match
+              case refinedMember: SingleDenotation if refinedMember.exists =>
+                // Check that the bounds of the capture contain the bounds of the inherited member
+                val refinedMemberBounds = refinedMember.info
+                val captureBounds = caseLambda.paramInfos(num)
+                if captureBounds.contains(refinedMemberBounds) then
+                  /* In this case, we know that any member we eventually find during reduction
+                   * will have bounds that fit in the bounds of the capture. Therefore, no
+                   * type-test + capture combo is necessary, and we can apply the specced match types.
+                   */
+                  val capture = rec(alias, variance = 0).asInstanceOf[MatchTypeCasePattern.Capture]
+                  MatchTypeCasePattern.TypeMemberExtractor(refinedName, capture)
+                else
+                  // Otherwise, a type-test + capture combo might be necessary, and we are out of spec
+                  null
+              case _ =>
+                // If the member does not refine a member of the `parent`, we are out of spec
+                null
+
           case _ =>
             MatchTypeCasePattern.TypeTest(pat)
       end rec

tests/pos/i17395-spec.scala

@@ -0,0 +1,29 @@
+trait TC[T]
+
+object TC {
+  def optionTCForPart[T](implicit tc: TC[ExtractPart[T]]): TC[Option[ExtractPart[T]]] = new TC[Option[ExtractPart[T]]] {}
+}
+
+trait ThingWithPart {
+  type Part
+}
+
+type ExtractPart[T] = T match {
+  case PartField[t] => t
+}
+type PartField[T] = ThingWithPart { type Part = T }
+
+class ValuePartHolder extends ThingWithPart {
+  type Part = Value
+}
+
+class Value
+object Value {
+  implicit val tcValue: TC[Value] = new {}
+}
+
+@main def main(): Unit = {
+//  import Value.tcValue // explicit import works around the issue, but shouldn't be necessary
+  val tc = TC.optionTCForPart[ValuePartHolder]
+  println(tc)
+}