small optimisation

Author: bishabosha

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

@@ -49,13 +49,12 @@ object Types {
   implicit def eqType: CanEqual[Type, Type] = CanEqual.derived
 
   object GenericTupleType:
-    def unapply(tp: Type)(using Context): Option[List[Type]] = tp match
-      case tp @ AppliedType(r: TypeRef, _) if r.symbol == defn.PairClass && tp.tupleArity(relaxEmptyTuple = true) > 0 =>
-        Some(tp.tupleElementTypes)
-      case AppliedType(r: TypeRef, args) if defn.isTupleClass(r.symbol) =>
-        Some(args)
-      case _ =>
-        None
+    def unapply(tp: AppliedType)(using Context): Option[List[Type]] =
+      tp.tycon match
+        case TypeRef(_, cls: ClassSymbol) if tp.tupleArity(relaxEmptyTuple = true) > 0 => // avoid type aliases
+          Some(tp.tupleElementTypes)
+        case _ =>
+          None
 
   /** Main class representing types.
    *

compiler/src/dotty/tools/dotc/typer/Synthesizer.scala

@@ -298,13 +298,6 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
         n == m
       case _ => this.asClass eq that.asClass // class equality otherwise
 
-    def isSub(that: MirrorSource)(using Context): Boolean = (this.arity, that.arity) match
-      case (n, m) if n > 0 || m > 0 =>
-        // we shortcut when at least one was a tuple.
-        // This protects us from comparing classes for two TupleXXL with different arities.
-        n == m
-      case _ => this.asClass isSubClass that.asClass
-
     def asClass(using Context): Symbol = this match
       case ClassSymbol(cls) => cls
       case GenericTuple(arity, _) =>
@@ -375,9 +368,11 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
       val mirroredClass = msrc.asClass
       val accessors = mirroredClass.caseAccessors.filterNot(_.isAllOf(PrivateLocal))
       val elemLabels = accessors.map(acc => ConstantType(Constant(acc.name.toString)))
-      val nestedPairs = msrc match
-        case MirrorSource.GenericTuple(_, args) => TypeOps.nestedPairs(args)
-        case _ => TypeOps.nestedPairs(accessors.map(mirroredType.resultType.memberInfo(_).widenExpr))
+      val (arity, nestedPairs) = msrc match
+        case MirrorSource.GenericTuple(arity, args) =>
+          (Some(arity), TypeOps.nestedPairs(args))
+        case MirrorSource.ClassSymbol(cls) =>
+          (None, TypeOps.nestedPairs(accessors.map(mirroredType.resultType.memberInfo(_).widenExpr)))
       val (monoType, elemsType) = mirroredType match
         case mirroredType: HKTypeLambda =>
           (mkMirroredMonoType(mirroredType), mirroredType.derivedLambdaType(resType = nestedPairs))
@@ -392,11 +387,7 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
           .refinedWith(tpnme.MirroredElemLabels, TypeAlias(elemsLabels))
       val mirrorRef =
         if mirroredClass.useCompanionAsProductMirror then companionPath(mirroredType, span)
-        else
-          val arity = msrc match
-            case MirrorSource.GenericTuple(arity, _) => Some(arity)
-            case _ => None
-          anonymousMirror(monoType, ExtendsProductMirror, arity, span)
+        else anonymousMirror(monoType, ExtendsProductMirror, arity, span)
       withNoErrors(mirrorRef.cast(mirrorType))
     end makeProductMirror