Rename isTupleType to isTupleNType

to make explicit tthe fact that it does not cover `Tuple`, `EmptyTuple`, `NonEmptyTuple` and `*:`.

Author: nicolasstucki

compiler/src/dotty/tools/dotc/ast/CheckTrees.scala.disabled

@@ -217,7 +217,7 @@ object CheckTrees {
                 optionArg.argTypesHi match {
                   case Nil =>
                     optionArg :: Nil
-                  case tupleArgs if defn.isTupleType(optionArg) =>
+                  case tupleArgs if defn.isTupleNType(optionArg) =>
                     tupleArgs
                 }
               case _ =>

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

@@ -1466,7 +1466,7 @@ class Definitions {
    *
    * @return true if the dealiased type of `self` is `TupleN[T1, T2, ..., Tn]`
    */
-  def isTupleType(tp: Type)(using Context): Boolean = {
+  def isTupleNType(tp: Type)(using Context): Boolean = {
     val arity = tp.dealias.argInfos.length
     arity <= MaxTupleArity && TupleType(arity) != null && tp.isRef(TupleType(arity).symbol)
   }

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

@@ -1180,7 +1180,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
                 compareLower(info2, tyconIsTypeRef = true)
               case info2: ClassInfo =>
                 tycon2.name.startsWith("Tuple") &&
-                  defn.isTupleType(tp2) && recur(tp1, tp2.toNestedPairs) ||
+                  defn.isTupleNType(tp2) && recur(tp1, tp2.toNestedPairs) ||
                 tryBaseType(info2.cls)
               case _ =>
                 fourthTry
@@ -2620,9 +2620,9 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
         fullyInstantiated(tp2) && !tp1.classSymbols.exists(_.derivesFrom(tp2.symbol))
       case (tp1: TypeRef, tp2: TermRef) if isEnumValue(tp2) =>
         fullyInstantiated(tp1) && !tp2.classSymbols.exists(_.derivesFrom(tp1.symbol))
-      case (tp1: Type, tp2: Type) if defn.isTupleType(tp1) =>
+      case (tp1: Type, tp2: Type) if defn.isTupleNType(tp1) =>
         provablyDisjoint(tp1.toNestedPairs, tp2)
-      case (tp1: Type, tp2: Type) if defn.isTupleType(tp2) =>
+      case (tp1: Type, tp2: Type) if defn.isTupleNType(tp2) =>
         provablyDisjoint(tp1, tp2.toNestedPairs)
       case (tp1: TypeProxy, tp2: TypeProxy) =>
         provablyDisjoint(tp1.superType, tp2) || provablyDisjoint(tp1, tp2.superType)

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

@@ -147,7 +147,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       changePrec(GlobalPrec) {
         val argStr: Text =
           if args.length == 2
-             && !defn.isTupleType(args.head)
+             && !defn.isTupleNType(args.head)
              && !isGiven && !isErased
           then
             atPrec(InfixPrec) { argText(args.head) }

compiler/src/dotty/tools/dotc/transform/patmat/Space.scala

@@ -771,7 +771,7 @@ class SpaceEngine(using Context) extends SpaceLogic {
 
         val sym = tp.classSymbol
 
-        if (ctx.definitions.isTupleType(tp))
+        if (ctx.definitions.isTupleNType(tp))
           params(tp).map(_ => "_").mkString("(", ", ", ")")
         else if (scalaListType.isRef(sym))
           if (flattenList) "_*" else "_: List"
@@ -785,7 +785,7 @@ class SpaceEngine(using Context) extends SpaceLogic {
         else if (decomposed) "_: " + showType(tp, showTypeArgs = true)
         else "_"
       case Prod(tp, fun, params) =>
-        if (ctx.definitions.isTupleType(tp))
+        if (ctx.definitions.isTupleNType(tp))
           "(" + params.map(doShow(_)).mkString(", ") + ")"
         else if (tp.isRef(scalaConsType.symbol))
           if (flattenList) params.map(doShow(_, flattenList)).filter(_.nonEmpty).mkString(", ")

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

@@ -1363,7 +1363,7 @@ trait Applications extends Compatibility {
         for (argType <- argTypes) assert(!isBounds(argType), unapplyApp.tpe.show)
         val bunchedArgs = argTypes match {
           case argType :: Nil =>
-            if (args.lengthCompare(1) > 0 && Feature.autoTuplingEnabled && defn.isTupleType(argType)) untpd.Tuple(args) :: Nil
+            if (args.lengthCompare(1) > 0 && Feature.autoTuplingEnabled && defn.isTupleNType(argType)) untpd.Tuple(args) :: Nil
             else args
           case _ => args
         }

compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala

@@ -1694,8 +1694,8 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
           val tpNoRefinement = self.dropDependentRefinement
           tpNoRefinement != self
           && dotc.core.Symbols.defn.isNonRefinedFunction(tpNoRefinement)
-        def isTupleType: Boolean =
-          dotc.core.Symbols.defn.isTupleType(self)
+        def isTupleNType: Boolean =
+          dotc.core.Symbols.defn.isTupleNType(self)
         def select(sym: Symbol): TypeRepr = self.select(sym)
         def appliedTo(targ: TypeRepr): TypeRepr =
           dotc.core.Types.decorateTypeApplications(self).appliedTo(targ)

library/src/scala/quoted/Quotes.scala

@@ -2477,7 +2477,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
          *
          * @return true if the dealiased type of `self` is `TupleN[T1, T2, ..., Tn]`
          */
-        def isTupleType: Boolean
+        def isTupleNType: Boolean
 
         /** The type <this . sym>, reduced if possible */
         def select(sym: Symbol): TypeRepr

scaladoc/src/dotty/tools/scaladoc/tasty/SyntheticSupport.scala

@@ -14,7 +14,7 @@ object SyntheticsSupport:
       import dotty.tools.dotc
       given ctx: dotc.core.Contexts.Context = quotes.asInstanceOf[scala.quoted.runtime.impl.QuotesImpl].ctx
       val tpe = rtpe.asInstanceOf[dotc.core.Types.Type]
-      ctx.definitions.isTupleType(tpe)
+      ctx.definitions.isTupleNType(tpe)
 
     private def hackIsCompiletimeAppliedType(rtpe: reflect.TypeRepr): Boolean =
       import dotty.tools.dotc