cleaner way to extract class or tuple proxy

bishabosha · bishabosha · commit 0b90f35a18f5 · 2022-05-23T15:39:40.000+02:00
diff --git a/compiler/src/dotty/tools/dotc/core/TypeErasure.scala b/compiler/src/dotty/tools/dotc/core/TypeErasure.scala
@@ -689,7 +689,9 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst
   }
 
   private def erasePair(tp: Type)(using Context): Type = {
-    val arity = tp.tupleArity
+    // NOTE: `tupleArity` does not consider TypeRef(EmptyTuple$) equivalent to EmptyTuple.type,
+    // we fix this for printers, but type erasure should be preserved.
+    val arity = tp.tupleArity()
     if (arity < 0) defn.ProductClass.typeRef
     else if (arity <= Definitions.MaxTupleArity) defn.TupleType(arity).nn
     else defn.TupleXXLClass.typeRef
diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
@@ -40,13 +40,71 @@ import scala.annotation.internal.sharable
 import scala.annotation.threadUnsafe
 
 import dotty.tools.dotc.transform.SymUtils._
+import dotty.tools.dotc.transform.TypeUtils.*
 
 object Types {
 
   @sharable private var nextId = 0
 
   implicit def eqType: CanEqual[Type, Type] = CanEqual.derived
 
+  object GenericTupleType:
+    def unapply(tp: Type)(using Context): Option[List[Type]] = tp match
+      case tp @ AppliedType(ref: TypeRef, _)
+      if ref.isRef(defn.PairClass) && tp.tupleArity(relaxEmptyTuple = true) > 0 =>
+        Some(tp.tupleElementTypes)
+      case _ => None
+
+  enum ClassOrTuple:
+    case ClassSymbol(cls: Symbol)
+    case GenericTuple(tuplArity: Int, tpArgs: List[Type])
+    case NoClass
+
+    def isGenericTuple: Boolean = this.isInstanceOf[GenericTuple]
+
+    private var _asClass: Symbol | Null = null
+
+    /** tuple arity, works for TupleN classes and generic tuples */
+    final def arity(using Context): Int = this match
+      case GenericTuple(arity, _) => arity
+      case ClassSymbol(cls) =>
+        if defn.isTupleClass(cls) then
+          cls.typeParams.length
+        else
+          -1
+      case NoClass => -1
+
+    def equiv(that: ClassOrTuple)(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 eq that.asClass // class equality otherwise
+
+    def isSub(that: ClassOrTuple)(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 =
+      val local = _asClass
+      if local == null then
+        val res = this match
+          case ClassSymbol(cls) => cls
+          case GenericTuple(arity, _) =>
+            if arity <= Definitions.MaxTupleArity then defn.TupleType(arity).nn.classSymbol
+            else defn.TupleXXLClass
+          case NoClass => NoSymbol
+        _asClass = res
+        res
+      else local
+  object ClassOrTuple:
+    def tuple(tps: List[Type]): ClassOrTuple = ClassOrTuple.GenericTuple(tps.size, tps)
+
+  end ClassOrTuple
+
   /** Main class representing types.
    *
    *  The principal subclasses and sub-objects are as follows:
@@ -491,6 +549,8 @@ object Types {
     /** The least class or trait of which this type is a subtype or parameterized
      *  instance, or NoSymbol if none exists (either because this type is not a
      *  value type, or because superclasses are ambiguous).
+     *
+     *  If modified, update [[underlyingClassOrTuple]] as well.
      */
     final def classSymbol(using Context): Symbol = this match
       case tp: TypeRef =>
@@ -524,6 +584,41 @@ object Types {
       case _ =>
         NoSymbol
 
+    /** Follows [[classSymbol]], but also escapes generic tuples to a proxy representing their class and type arguments.
+     */
+    final def underlyingClassOrTuple(using Context): ClassOrTuple = this match
+      case tp: TypeRef =>
+        val sym = tp.symbol
+        if (sym.isClass) ClassOrTuple.ClassSymbol(sym) else tp.superType.underlyingClassOrTuple
+      case GenericTupleType(args) => ClassOrTuple.tuple(args)
+      case tp: TypeProxy =>
+        tp.underlying.underlyingClassOrTuple
+      case tp: ClassInfo =>
+        ClassOrTuple.ClassSymbol(tp.cls)
+      case AndType(l, r) =>
+        val lsym = l.underlyingClassOrTuple
+        val rsym = r.underlyingClassOrTuple
+        if (lsym isSub rsym) lsym
+        else if (rsym isSub lsym) rsym
+        else ClassOrTuple.NoClass
+      case tp: OrType =>
+        if tp.tp1.hasClassSymbol(defn.NothingClass) then
+          tp.tp2.underlyingClassOrTuple
+        else if tp.tp2.hasClassSymbol(defn.NothingClass) then
+          tp.tp1.underlyingClassOrTuple
+        else
+          def tp1Null = tp.tp1.hasClassSymbol(defn.NullClass)
+          def tp2Null = tp.tp2.hasClassSymbol(defn.NullClass)
+          if ctx.erasedTypes && (tp1Null || tp2Null) then
+            val otherSide = if tp1Null then tp.tp2.underlyingClassOrTuple else tp.tp1.underlyingClassOrTuple
+            if otherSide.asClass.isValueClass then ClassOrTuple.ClassSymbol(defn.AnyClass) else otherSide
+          else
+            tp.join.underlyingClassOrTuple
+      case _: JavaArrayType =>
+        ClassOrTuple.ClassSymbol(defn.ArrayClass)
+      case _ =>
+        ClassOrTuple.NoClass
+
     /** The least (wrt <:<) set of symbols satisfying the `include` predicate of which this type is a subtype
      */
     final def parentSymbols(include: Symbol => Boolean)(using Context): List[Symbol] = this match {
diff --git a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -218,7 +218,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         val cls = tycon.typeSymbol
         if tycon.isRepeatedParam then toTextLocal(args.head) ~ "*"
         else if defn.isFunctionClass(cls) then toTextFunction(args, cls.name.isContextFunction, cls.name.isErasedFunction)
-        else if tp.tupleArity >= 2 && !printDebug then toTextTuple(tp.tupleElementTypes)
+        else if tp.tupleArity(relaxEmptyTuple = true) >= 2 && !printDebug then toTextTuple(tp.tupleElementTypes)
         else if isInfixType(tp) then
           val l :: r :: Nil = args: @unchecked
           val opName = tyconName(tycon)
diff --git a/compiler/src/dotty/tools/dotc/transform/GenericSignatures.scala b/compiler/src/dotty/tools/dotc/transform/GenericSignatures.scala
@@ -248,7 +248,7 @@ object GenericSignatures {
               case _ => jsig(elemtp)
 
         case RefOrAppliedType(sym, pre, args) =>
-          if (sym == defn.PairClass && tp.tupleArity > Definitions.MaxTupleArity)
+          if (sym == defn.PairClass && tp.tupleArity() > Definitions.MaxTupleArity)
             jsig(defn.TupleXXLClass.typeRef)
           else if (isTypeParameterInSig(sym, sym0)) {
             assert(!sym.isAliasType, "Unexpected alias type: " + sym)
diff --git a/compiler/src/dotty/tools/dotc/transform/TypeUtils.scala b/compiler/src/dotty/tools/dotc/transform/TypeUtils.scala
@@ -51,14 +51,16 @@ object TypeUtils {
 
     /** The arity of this tuple type, which can be made up of EmptyTuple, TupleX and `*:` pairs,
      *  or -1 if this is not a tuple type.
+     *
+     *  @param relaxEmptyTuple if true then TypeRef(EmptyTuple$) =:= EmptyTuple.type
      */
-    def tupleArity(using Context): Int = self match {
+    def tupleArity(relaxEmptyTuple: Boolean = false)(using Context): Int = self match {
       case AppliedType(tycon, _ :: tl :: Nil) if tycon.isRef(defn.PairClass) =>
-        val arity = tl.tupleArity
+        val arity = tl.tupleArity()
         if (arity < 0) arity else arity + 1
       case self: SingletonType =>
         if self.termSymbol == defn.EmptyTupleModule then 0 else -1
-      case self: TypeRef if self.classSymbol == defn.EmptyTupleModule.moduleClass =>
+      case self: TypeRef if relaxEmptyTuple && self.classSymbol == defn.EmptyTupleModule.moduleClass =>
         0
       case self if defn.isTupleClass(self.classSymbol) =>
         self.dealias.argInfos.length
diff --git a/compiler/src/dotty/tools/dotc/typer/Synthesizer.scala b/compiler/src/dotty/tools/dotc/typer/Synthesizer.scala
@@ -281,34 +281,17 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
 
   private def productMirror(mirroredType: Type, formal: Type, span: Span)(using Context): TreeWithErrors =
 
-    var isSafeGenericTuple = Option.empty[(Symbol, List[Type])]
-
-    /** do all parts match the class symbol? Or can we extract a generic tuple type out? */
-    def acceptable(tp: Type, cls: Symbol): Boolean =
-      var genericTupleParts = List.empty[(Symbol, List[Type])]
-
-      def acceptableGenericTuple(tp: AppliedType): Boolean =
-        val tupleArgs = tp.tupleElementTypes
-        val arity = tupleArgs.size
-        val isOk = arity <= Definitions.MaxTupleArity
-        if isOk then
-          genericTupleParts ::= {
-            val cls = defn.TupleType(arity).nn.classSymbol
-            (cls, tupleArgs)
-          }
-        isOk
-
-      def inner(tp: Type, cls: Symbol): Boolean = tp match
-        case tp: HKTypeLambda if tp.resultType.isInstanceOf[HKTypeLambda] => false
-        case tp @ AppliedType(cons: TypeRef, _) if cons.isRef(defn.PairClass) => acceptableGenericTuple(tp)
-        case tp: TypeProxy    => inner(tp.underlying, cls)
-        case OrType(tp1, tp2) => inner(tp1, cls) && inner(tp2, cls)
-        case _                => tp.classSymbol eq cls
+    extension (clsOrTuple: ClassOrTuple) def isGenericProd(using Context) =
+      clsOrTuple.isGenericTuple || clsOrTuple.asClass.isGenericProduct && canAccessCtor(clsOrTuple.asClass)
 
-      val classPartsMatch = inner(tp, cls)
-      classPartsMatch && genericTupleParts.map((cls, _) => cls).distinct.sizeIs <= 1 &&
-        { isSafeGenericTuple = genericTupleParts.headOption ; true }
-    end acceptable
+    /** do all parts match the class symbol? */
+    def acceptable(tp: Type, clsOrTuple: ClassOrTuple): Boolean = tp match
+      case tp: HKTypeLambda if tp.resultType.isInstanceOf[HKTypeLambda] => false
+      case OrType(tp1, tp2) => acceptable(tp1, clsOrTuple) && acceptable(tp2, clsOrTuple)
+      case GenericTupleType(args) if args.size <= Definitions.MaxTupleArity =>
+        ClassOrTuple.tuple(args).equiv(clsOrTuple)
+      case tp: TypeProxy    => acceptable(tp.underlying, clsOrTuple)
+      case _                => tp.underlyingClassOrTuple.equiv(clsOrTuple)
 
     /** for a case class, if it will have an anonymous mirror,
      *  check that its constructor can be accessed
@@ -326,13 +309,13 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
     def genAnonyousMirror(cls: Symbol): Boolean =
       cls.is(Scala2x) || cls.linkedClass.is(Case)
 
-    def makeProductMirror(cls: Symbol): TreeWithErrors =
-      val mirroredClass = isSafeGenericTuple.fold(cls)((cls, _) => cls)
+    def makeProductMirror(clsOrTuple: ClassOrTuple): TreeWithErrors =
+      val mirroredClass = clsOrTuple.asClass
       val accessors = mirroredClass.caseAccessors.filterNot(_.isAllOf(PrivateLocal))
       val elemLabels = accessors.map(acc => ConstantType(Constant(acc.name.toString)))
-      val nestedPairs = isSafeGenericTuple.map((_, tps) => TypeOps.nestedPairs(tps)).getOrElse {
-        TypeOps.nestedPairs(accessors.map(mirroredType.resultType.memberInfo(_).widenExpr))
-      }
+      val nestedPairs = clsOrTuple match
+        case ClassOrTuple.GenericTuple(_, args) => TypeOps.nestedPairs(args)
+        case _ => TypeOps.nestedPairs(accessors.map(mirroredType.resultType.memberInfo(_).widenExpr))
       val (monoType, elemsType) = mirroredType match
         case mirroredType: HKTypeLambda =>
           (mkMirroredMonoType(mirroredType), mirroredType.derivedLambdaType(resType = nestedPairs))
@@ -342,25 +325,30 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
       checkRefinement(formal, tpnme.MirroredElemTypes, elemsType, span)
       checkRefinement(formal, tpnme.MirroredElemLabels, elemsLabels, span)
       val mirrorType =
-        mirrorCore(defn.Mirror_ProductClass, monoType, mirroredType, cls.name, formal)
+        mirrorCore(defn.Mirror_ProductClass, monoType, mirroredType, mirroredClass.name, formal)
           .refinedWith(tpnme.MirroredElemTypes, TypeAlias(elemsType))
           .refinedWith(tpnme.MirroredElemLabels, TypeAlias(elemsLabels))
       val mirrorRef =
         if genAnonyousMirror(mirroredClass) then
-          anonymousMirror(monoType, ExtendsProductMirror, isSafeGenericTuple.map(_(1).size), span)
+          val arity = clsOrTuple match
+            case ClassOrTuple.GenericTuple(arity, _) => Some(arity)
+            case _ => None
+          anonymousMirror(monoType, ExtendsProductMirror, arity, span)
         else companionPath(mirroredType, span)
       withNoErrors(mirrorRef.cast(mirrorType))
     end makeProductMirror
 
-    def getError(cls: Symbol): String =
+    def getError(clsOrTuple: ClassOrTuple): String =
       val reason =
-        if !cls.isGenericProduct then
-          i"because ${cls.whyNotGenericProduct}"
-        else if !canAccessCtor(cls) then
-          i"because the constructor of $cls is innaccessible from the calling scope."
+        if !clsOrTuple.isGenericTuple then
+          if !clsOrTuple.asClass.isGenericProduct then
+            i"because ${clsOrTuple.asClass.whyNotGenericProduct}"
+          else if !canAccessCtor(clsOrTuple.asClass) then
+            i"because the constructor of ${clsOrTuple.asClass} is innaccessible from the calling scope."
+          else ""
         else
           ""
-      i"$cls is not a generic product $reason"
+      i"${clsOrTuple.asClass} is not a generic product $reason"
     end getError
 
     mirroredType match
@@ -378,13 +366,11 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
             val mirrorType = mirrorCore(defn.Mirror_SingletonClass, mirroredType, mirroredType, module.name, formal)
             withNoErrors(modulePath.cast(mirrorType))
         else
-          val cls = mirroredType.classSymbol
-          if acceptable(mirroredType, cls)
-            && isSafeGenericTuple.isDefined || (cls.isGenericProduct && canAccessCtor(cls))
-          then
-            makeProductMirror(cls)
+          val clsOrTuple = mirroredType.underlyingClassOrTuple
+          if acceptable(mirroredType, clsOrTuple) && clsOrTuple.isGenericProd then
+            makeProductMirror(clsOrTuple)
           else
-            (EmptyTree, List(getError(cls)))
+            (EmptyTree, List(getError(clsOrTuple)))
   end productMirror
 
   private def sumMirror(mirroredType: Type, formal: Type, span: Span)(using Context): TreeWithErrors =
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -2766,7 +2766,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       typed(desugar.smallTuple(tree).withSpan(tree.span), pt)
     else {
       val pts =
-        if (arity == pt.tupleArity) pt.tupleElementTypes
+        if (arity == pt.tupleArity()) pt.tupleElementTypes
         else List.fill(arity)(defn.AnyType)
       val elems = tree.trees.lazyZip(pts).map(
         if ctx.mode.is(Mode.Type) then typedType(_, _, mapPatternBounds = true)
