Improve treatment of tuples

Author: odersky

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

@@ -1170,7 +1170,9 @@ class Definitions {
   }
 
   def tupleType(elems: List[Type]): Type = {
-    TupleType(elems.size).appliedTo(elems)
+    val arity = elems.length
+    if (arity <= MaxTupleArity && TupleType(arity) != null) TupleType(arity).appliedTo(elems)
+    else TypeOps.nestedPairs(elems)
   }
 
   def isProductSubType(tp: Type)(implicit ctx: Context): Boolean =
@@ -1263,8 +1265,9 @@ class Definitions {
   def adjustForTuple(cls: ClassSymbol, tparams: List[TypeSymbol], parents: List[Type]): List[Type] = {
     def syntheticParent(tparams: List[TypeSymbol]): Type =
       if (tparams.isEmpty) TupleTypeRef
-      else (tparams :\ (UnitType: Type)) ((tparam, tail) => PairType.appliedTo(tparam.typeRef, tail))
-    if (isTupleClass(cls) || cls == UnitClass) parents :+ syntheticParent(tparams) else parents
+      else TypeOps.nestedPairs(tparams.map(_.typeRef))
+    if (isTupleClass(cls) || cls == UnitClass) parents :+ syntheticParent(tparams)
+    else parents
   }
 
   // ----- primitive value class machinery ------------------------------------------

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

@@ -570,6 +570,6 @@ object TypeOps {
 
   // TODO: Move other typeops here. It's a bit weird that they are a part of `ctx`
 
-  def tupleOf(ts: List[Type])(implicit ctx: Context): Type =
+  def nestedPairs(ts: List[Type])(implicit ctx: Context): Type =
     (ts :\ (defn.UnitType: Type))(defn.PairType.appliedTo(_, _))
 }

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

@@ -179,7 +179,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         val cls = tycon.typeSymbol
         if (tycon.isRepeatedParam) return toTextLocal(args.head) ~ "*"
         if (defn.isFunctionClass(cls)) return toTextFunction(args, cls.name.isImplicitFunction, cls.name.isErasedFunction)
-        if (tp.tupleArity >= 2) return toTextTuple(tp.tupleElementTypes)
+        if (tp.tupleArity >= 2 && !ctx.settings.YprintDebug.value) return toTextTuple(tp.tupleElementTypes)
         if (isInfixType(tp)) {
           val l :: r :: Nil = args
           val opName = tyconName(tycon)

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

@@ -50,6 +50,6 @@ object TypeUtils {
 
     /** The `*:` equivalent of an instance of a Tuple class */
     def toNestedPairs(implicit ctx: Context): Type =
-      TypeOps.tupleOf(tupleElementTypes)
+      TypeOps.nestedPairs(tupleElementTypes)
   }
 }

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

@@ -78,14 +78,14 @@ trait Deriving { this: Typer =>
           case _ =>
             (sym.termRef, Nil)
         }
-      val elemShape = TypeOps.tupleOf(elems)
+      val elemShape = TypeOps.nestedPairs(elems)
       defn.ShapeCaseType.appliedTo(constr, elemShape)
     }
 
     /** The shape of `cls` if `cls` is sealed */
     private def sealedShape: Type = {
       val cases = children.map(caseShape).filter(_.exists)
-      val casesShape = TypeOps.tupleOf(cases)
+      val casesShape = TypeOps.nestedPairs(cases)
       defn.ShapeCasesType.appliedTo(casesShape)
     }
 

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

@@ -1919,7 +1919,7 @@ class Typer extends Namer
         else {
           val elemTpes = (elems, pts).zipped.map((elem, pt) =>
             ctx.typeComparer.widenInferred(elem.tpe, pt))
-          val resTpe = TypeOps.tupleOf(elemTpes)
+          val resTpe = TypeOps.nestedPairs(elemTpes)
           app1.cast(resTpe)
         }
       }
@@ -1942,13 +1942,15 @@ class Typer extends Namer
           val quotedPt = if (exprPt.exists) exprPt.argTypesHi.head else defn.AnyType
           val quoted1 = typedExpr(quoted, quotedPt)(quoteContext.addMode(Mode.QuotedPattern))
           val (shape, splices) = splitQuotePattern(quoted1)
-          val splicePat = typed(untpd.Tuple(splices.map(untpd.TypedSplice(_))).withSpan(quoted.span))
-          val patType = TypeOps.tupleOf(splices.tpes.map(_.widen))
+          val patType = defn.tupleType(splices.tpes.map(_.widen))
+          val splicePat = typed(untpd.Tuple(splices.map(untpd.TypedSplice(_))).withSpan(quoted.span), patType)
           UnApply(
-            ref(defn.QuotedMatcher_unapplyR).appliedToType(patType),
-            ref(defn.InternalQuoted_exprQuoteR).appliedToType(shape.tpe).appliedTo(shape) :: givenReflection :: Nil,
-            splicePat :: Nil,
-            pt)
+            fun = ref(defn.QuotedMatcher_unapplyR).appliedToType(patType),
+            implicits =
+              ref(defn.InternalQuoted_exprQuoteR).appliedToType(shape.tpe).appliedTo(shape) ::
+              givenReflection :: Nil,
+            patterns = splicePat :: Nil,
+            proto = pt)
         }
         else
           typedApply(untpd.Apply(untpd.ref(defn.InternalQuoted_exprQuoteR), quoted), pt)(quoteContext).withSpan(tree.span)

tests/pos/quotedPatterns.scala

@@ -3,11 +3,17 @@ object Test {
   val x = '{1 + 2}
 
   def f(x: Int) = x
+  def g(x: Int, y: Int) = x * y
 
   val res: quoted.Expr[Int] = x match {
     case '{1 + 2} => '{0}
     case '{f($y)} => y
-    //case '{ 1 + ($y: Int)} => y  // currently gives an unreachable case error
+    case '{g($y, $z)} => '{$y * $z}
+    case '{ 1 + ($y: Int)} => y
+      // currently gives an unreachable case warning
+      // but only when used in conjunction with the others.
+      // I believe this is because implicit arguments are not taken
+      // into account when checking whether we have already seen an `unapply` before.
     case _ => '{1}
   }
 }