Replace usages of isInstanceOf[MatchAlias] by isMatchAlias

Author: EugeneFlesselle

Diff for: compiler/src/dotty/tools/dotc/core/TypeComparer.scala

@@ -1375,7 +1375,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
        *    tp1 <:< app2   using isSubType (this might instantiate params in tp2)
        */
       def compareLower(tycon2bounds: TypeBounds, tyconIsTypeRef: Boolean): Boolean =
-        if ((tycon2bounds.lo `eq` tycon2bounds.hi) && !tycon2bounds.isInstanceOf[MatchAlias])
+        if ((tycon2bounds.lo `eq` tycon2bounds.hi) && !tycon2bounds.isMatchAlias)
           if (tyconIsTypeRef) recur(tp1, tp2.superTypeNormalized) && recordGadtUsageIf(MatchType.thatReducesUsingGadt(tp2))
           else isSubApproxHi(tp1, tycon2bounds.lo.applyIfParameterized(args2))
         else

Diff for: compiler/src/dotty/tools/dotc/core/Types.scala

@@ -456,13 +456,15 @@ object Types extends TypeUtils {
     /** Is this a MethodType for which the parameters will not be used? */
     def hasErasedParams(using Context): Boolean = false
 
-    /** Is this a match type or a higher-kinded abstraction of one?
-     */
+    /** Is this a match type or a higher-kinded abstraction of one? */
     def isMatch(using Context): Boolean = stripped match
       case tp: MatchType => true
       case tp: HKTypeLambda => tp.resType.isMatch
       case _ => false
 
+    /** Does this application expand to a match type? */
+    def isMatchAlias(using Context): Boolean = underlyingMatchType.exists
+
     def underlyingMatchType(using Context): Type = stripped match {
       case tp: MatchType => tp
       case tp: HKTypeLambda => tp.resType.underlyingMatchType
@@ -4611,19 +4613,6 @@ object Types extends TypeUtils {
         NoType
     }
 
-    /** Does this application expand to a match type? */
-    def isMatchAlias(using Context): Boolean = tycon.stripTypeVar match
-      case tycon: TypeRef =>
-        tycon.info match
-          case AliasingBounds(alias) =>
-            alias.underlyingMatchType.exists
-            /* This is the only true case since anything other than
-             * a TypeRef of an alias with an underlying match type
-             * should have been already reduced by `appliedTo` in the TypeAssigner.
-             */
-          case _ => false
-      case _ => false
-
     /** Is this an unreducible application to wildcard arguments?
      *  This is the case if tycon is higher-kinded. This means
      *  it is a subtype of a hk-lambda, but not a match alias.

Diff for: compiler/src/dotty/tools/dotc/typer/Implicits.scala

@@ -622,7 +622,7 @@ trait ImplicitRunInfo:
     sym.isClass && !isExcluded(sym)
     || sym.isOpaqueAlias
     || sym.is(Deferred, butNot = Param)
-    || sym.info.isInstanceOf[MatchAlias]
+    || sym.info.isMatchAlias
 
   private def computeIScope(rootTp: Type): OfTypeImplicits =