Refactor some tuple methods

 - Move from Definitions to TypeUtils
 - Unify TypeUtils.tupleElementTypes and Definitions.tupleTypes. They do
   the same thing.

I'd like to move more things out of Definitions and into TypeUtils and SymUtils.
Then I'd like to move these files to the core package, and make their operations
accessible automatically by having the companion objects of Types and Symbols inherit
from them. This is a first step into that direction.

Author: odersky

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

@@ -1749,26 +1749,6 @@ class Definitions {
     else TypeOps.nestedPairs(elems)
   }
 
-  def tupleTypes(tp: Type, bound: Int = Int.MaxValue)(using Context): Option[List[Type]] = {
-    @tailrec def rec(tp: Type, acc: List[Type], bound: Int): Option[List[Type]] = tp.normalized.dealias match {
-      case _ if bound < 0 => Some(acc.reverse)
-      case tp: AppliedType if PairClass == tp.classSymbol => rec(tp.args(1), tp.args.head :: acc, bound - 1)
-      case tp: AppliedType if isTupleNType(tp) => Some(acc.reverse ::: tp.args)
-      case tp: TermRef if tp.symbol == defn.EmptyTupleModule => Some(acc.reverse)
-      case _ => None
-    }
-    rec(tp.stripTypeVar, Nil, bound)
-  }
-
-  def isSmallGenericTuple(tp: Type)(using Context): Boolean =
-    if tp.derivesFrom(defn.PairClass) && !defn.isTupleNType(tp.widenDealias) then
-      // If this is a generic tuple we need to cast it to make the TupleN/ members accessible.
-      // This works only for generic tuples of known size up to 22.
-      defn.tupleTypes(tp.widenTermRefExpr) match
-        case Some(elems) if elems.length <= Definitions.MaxTupleArity => true
-        case _ => false
-    else false
-
   def isProductSubType(tp: Type)(using Context): Boolean = tp.derivesFrom(ProductClass)
 
   /** Is `tp` (an alias) of either a scala.FunctionN or a scala.ContextFunctionN

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -235,7 +235,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
 
     def appliedText(tp: Type): Text = tp match
       case tp @ AppliedType(tycon, args) =>
-        tp.tupleElementTypes match
+        tp.tupleElementTypesUpTo(200, normalize = false) match
           case Some(types) if types.size >= 2 && !printDebug => toTextTuple(types)
           case _ =>
             val tsym = tycon.typeSymbol

compiler/src/dotty/tools/dotc/transform/TupleOptimizations.scala

@@ -10,9 +10,9 @@ import StdNames.*
 import Symbols.*
 import MegaPhase.*
 import Types.*
+import transform.TypeUtils.*
 import dotty.tools.dotc.ast.tpd
 
-
 /** Optimize generic operations on tuples */
 class TupleOptimizations extends MiniPhase with IdentityDenotTransformer {
   import tpd.*
@@ -33,7 +33,7 @@ class TupleOptimizations extends MiniPhase with IdentityDenotTransformer {
 
   private def transformTupleCons(tree: tpd.Apply)(using Context): Tree = {
     val head :: tail :: Nil = tree.args: @unchecked
-    defn.tupleTypes(tree.tpe.widenTermRefExpr.dealias) match {
+    tree.tpe.widenTermRefExpr.tupleElementTypes match {
       case Some(tpes) =>
         // Generate a the tuple directly with TupleN+1.apply
         val size = tpes.size
@@ -61,7 +61,7 @@ class TupleOptimizations extends MiniPhase with IdentityDenotTransformer {
 
   private def transformTupleTail(tree: tpd.Apply)(using Context): Tree = {
     val Apply(_, tup :: Nil) = tree: @unchecked
-    defn.tupleTypes(tup.tpe.widenTermRefExpr.dealias, MaxTupleArity + 1) match {
+    tup.tpe.widenTermRefExpr.tupleElementTypesUpTo(MaxTupleArity + 1) match {
       case Some(tpes) =>
         // Generate a the tuple directly with TupleN-1.apply
         val size = tpes.size
@@ -104,7 +104,7 @@ class TupleOptimizations extends MiniPhase with IdentityDenotTransformer {
 
   private def transformTupleConcat(tree: tpd.Apply)(using Context): Tree = {
     val Apply(_, self :: that :: Nil) = tree: @unchecked
-    (defn.tupleTypes(self.tpe.widenTermRefExpr.dealias), defn.tupleTypes(that.tpe.widenTermRefExpr.dealias)) match {
+    (self.tpe.widenTermRefExpr.tupleElementTypes, that.tpe.widenTermRefExpr.tupleElementTypes) match {
       case (Some(tpes1), Some(tpes2)) =>
         // Generate a the tuple directly with TupleN+M.apply
         val n = tpes1.size
@@ -139,7 +139,7 @@ class TupleOptimizations extends MiniPhase with IdentityDenotTransformer {
 
   private def transformTupleApply(tree: tpd.Apply)(using Context): Tree = {
     val Apply(_, tup :: nTree :: Nil) = tree: @unchecked
-    (defn.tupleTypes(tup.tpe.widenTermRefExpr.dealias), nTree.tpe) match {
+    (tup.tpe.widenTermRefExpr.tupleElementTypes, nTree.tpe) match {
       case (Some(tpes), nTpe: ConstantType) =>
         // Get the element directly with TupleM._n+1 or TupleXXL.productElement(n)
         val size = tpes.size
@@ -166,7 +166,7 @@ class TupleOptimizations extends MiniPhase with IdentityDenotTransformer {
 
   private def transformTupleToArray(tree: tpd.Apply)(using Context): Tree = {
     val Apply(_, tup :: Nil) = tree: @unchecked
-    defn.tupleTypes(tup.tpe.widen, MaxTupleArity) match {
+    tup.tpe.widen.tupleElementTypesUpTo(MaxTupleArity) match {
       case Some(tpes) =>
         val size = tpes.size
         if (size == 0)

compiler/src/dotty/tools/dotc/transform/TypeUtils.scala

@@ -45,22 +45,45 @@ object TypeUtils {
       case ps => ps.reduceLeft(AndType(_, _))
     }
 
-    /** The element types of this tuple type, which can be made up of EmptyTuple, TupleX and `*:` pairs */
-    def tupleElementTypes(using Context): Option[List[Type]] = self.dealias match {
-      case AppliedType(tycon, hd :: tl :: Nil) if tycon.isRef(defn.PairClass) =>
-        tl.tupleElementTypes.map(hd :: _)
-      case self: SingletonType =>
-        if self.termSymbol == defn.EmptyTupleModule then Some(Nil) else None
-      case AndType(tp1, tp2) =>
-        // We assume that we have the following property:
-        // (T1, T2, ..., Tn) & (U1, U2, ..., Un) = (T1 & U1, T2 & U2, ..., Tn & Un)
-        tp1.tupleElementTypes.zip(tp2.tupleElementTypes).map { case (t1, t2) => t1.intersect(t2) }
-      case OrType(tp1, tp2) =>
-        None // We can't combine the type of two tuples
-      case _ =>
-        if defn.isTupleClass(self.typeSymbol) then Some(self.dealias.argInfos)
-        else None
-    }
+    /** The element types of this tuple type, which can be made up of EmptyTuple, TupleX and `*:` pairs
+     */
+    def tupleElementTypes(using Context): Option[List[Type]] =
+      tupleElementTypesUpTo(Int.MaxValue)
+
+    /** The element types of this tuple type, which can be made up of EmptyTuple, TupleX and `*:` pairs
+     *  @param bound     The maximum number of elements that needs generating minus 1
+     *                   The generation will stop once more than bound elems have been generated
+     *  @param normalize If true, normalize and dealias at each step.
+     *                   If false, never normalize and dealias only to find *:
+     *                   and EmptyTuple types. This is useful for printing.
+     */
+    def tupleElementTypesUpTo(bound: Int, normalize: Boolean = true)(using Context): Option[List[Type]] =
+      def recur(tp: Type, bound: Int): Option[List[Type]] =
+        if bound < 0 then Some(Nil)
+        else (if normalize then tp.normalized else tp).dealias match
+          case AppliedType(tycon, hd :: tl :: Nil) if tycon.isRef(defn.PairClass) =>
+            recur(tl, bound - 1).map(hd :: _)
+          case tp: AppliedType if defn.isTupleNType(tp) && normalize =>
+            Some(tp.args)  // if normalize is set, use the dealiased tuple
+                           // otherwise rely on the default case below to print unaliased tuples.
+          case tp: SingletonType =>
+            if tp.termSymbol == defn.EmptyTupleModule then Some(Nil) else None
+          case _ =>
+            if defn.isTupleClass(tp.typeSymbol) && !normalize then Some(tp.dealias.argInfos)
+            else None
+      recur(self.stripTypeVar, bound)
+
+    /** Is this a generic tuple that would fit into the range 1..22,
+     *  but is not already an instance of one of Tuple1..22?
+     *  In this case we need to cast it to make the TupleN/ members accessible.
+     *  This works only for generic tuples of known size up to 22.
+     */
+    def isSmallGenericTuple(using Context): Boolean =
+      self.derivesFrom(defn.PairClass)
+      && !defn.isTupleNType(self.widenDealias)
+      && self.widenTermRefExpr.tupleElementTypesUpTo(Definitions.MaxTupleArity).match
+          case Some(elems) if elems.length <= Definitions.MaxTupleArity => true
+          case _ => false
 
     /** The `*:` equivalent of an instance of a Tuple class */
     def toNestedPairs(using Context): Type =

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

@@ -119,7 +119,7 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
             // TupledFunction[?, (...) => R]
             tupled.functionArgInfos match
               case tupledArgs :: funRet :: Nil =>
-                defn.tupleTypes(tupledArgs.dealias) match
+                tupledArgs.tupleElementTypes match
                   case Some(funArgs) if functionTypeEqual(tupled, funArgs, funRet, fun) =>
                     // TupledFunction[?, ((...funArgs...)) => funRet]
                     funArgs.size

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

@@ -707,8 +707,8 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
        // There's a second trial where we try to instantiate all type variables in `qual.tpe.widen`,
        // but that is done only after we search for extension methods or conversions.
       typedSelect(tree, pt, qual)
-    else if defn.isSmallGenericTuple(qual.tpe) then
-      val elems = defn.tupleTypes(qual.tpe.widenTermRefExpr).getOrElse(Nil)
+    else if qual.tpe.isSmallGenericTuple then
+      val elems = qual.tpe.widenTermRefExpr.tupleElementTypes.getOrElse(Nil)
       typedSelect(tree, pt, qual.cast(defn.tupleType(elems)))
     else
       val tree1 = tryExtensionOrConversion(
@@ -729,7 +729,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
             if checkedType1.exists then
               gadts.println(i"Member selection healed by GADT approximation")
               finish(tree1, qual1, checkedType1)
-            else if defn.isSmallGenericTuple(qual1.tpe) then
+            else if qual1.tpe.isSmallGenericTuple then
               gadts.println(i"Tuple member selection healed by GADT approximation")
               typedSelect(tree, pt, qual1)
             else