Allow tuple literals to extend beyond 22

Author: odersky

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -815,6 +815,23 @@ object desugar {
       makeOp(right, left, Position(op.pos.start, right.pos.end))
   }
 
+  /** Translate tuple expressions of arity <= 22
+   *
+   *     ()             ==>   ()
+   *     (t)            ==>   t
+   *     (t1, ..., tN)  ==>   TupleN(t1, ..., tN)
+   */
+  def smallTuple(tree: Tuple)(implicit ctx: Context): Tree = {
+    val ts = tree.trees
+    val arity = ts.length
+    assert(arity <= Definitions.MaxTupleArity)
+    def tupleTypeRef = defn.TupleType(arity)
+    if (arity == 1) ts.head
+    else if (ctx.mode is Mode.Type) AppliedTypeTree(ref(tupleTypeRef), ts)
+    else if (arity == 0) unitLiteral
+    else Apply(ref(tupleTypeRef.classSymbol.companionModule.termRef), ts)
+  }
+
   /** Make closure corresponding to function.
    *      params => body
    *  ==>
@@ -1141,16 +1158,6 @@ object desugar {
       case PrefixOp(op, t) =>
         val nspace = if (ctx.mode.is(Mode.Type)) tpnme else nme
         Select(t, nspace.UNARY_PREFIX ++ op.name)
-      case Tuple(ts) =>
-        val arity = ts.length
-        def tupleTypeRef = defn.TupleType(arity)
-        if (arity > Definitions.MaxTupleArity) {
-          ctx.error(TupleTooLong(ts), tree.pos)
-          unitLiteral
-        } else if (arity == 1) ts.head
-        else if (ctx.mode is Mode.Type) AppliedTypeTree(ref(tupleTypeRef), ts)
-        else if (arity == 0) unitLiteral
-        else Apply(ref(tupleTypeRef.classSymbol.companionModule.termRef), ts)
       case WhileDo(cond, body) =>
         // { <label> def while$(): Unit = if (cond) { body; while$() } ; while$() }
         val call = Apply(Ident(nme.WHILE_PREFIX), Nil).withPos(tree.pos)

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

@@ -251,14 +251,13 @@ trait ConstraintHandling {
     }
   }
 
-  /** The instance type of `param` in the current constraint (which contains `param`).
-   *  If `fromBelow` is true, the instance type is the lub of the parameter's
-   *  lower bounds; otherwise it is the glb of its upper bounds. However,
-   *  a lower bound instantiation can be a singleton type only if the upper bound
-   *  is also a singleton type.
+  /** Widen inferred type `tp` with upper bound `bound`, according to the following rules:
+   *   1. If `tp` is a singleton type, yet `bound` is not a singleton type, nor a subtype
+   *      of `scala.Singleton`, widen `tp`.
+   *   2. If `tp` is a union type, yet upper bound is not a union type,
+   *      approximate the union type from above by an intersection of all common base types.
    */
-  def instanceType(param: TypeParamRef, fromBelow: Boolean): Type = {
-    def upperBound = constraint.fullUpperBound(param)
+  def widenInferred(tp: Type, bound: Type): Type = {
     def isMultiSingleton(tp: Type): Boolean = tp.stripAnnots match {
       case tp: SingletonType => true
       case AndType(tp1, tp2) => isMultiSingleton(tp1) | isMultiSingleton(tp2)
@@ -268,39 +267,32 @@ trait ConstraintHandling {
       case tp: TypeParamRef => isMultiSingleton(bounds(tp).hi)
       case _ => false
     }
-    def isFullyDefined(tp: Type): Boolean = tp match {
-      case tp: TypeVar => tp.isInstantiated && isFullyDefined(tp.instanceOpt)
-      case tp: TypeProxy => isFullyDefined(tp.underlying)
-      case tp: AndType => isFullyDefined(tp.tp1) && isFullyDefined(tp.tp2)
-      case tp: OrType  => isFullyDefined(tp.tp1) && isFullyDefined(tp.tp2)
-      case _ => true
-    }
     def isOrType(tp: Type): Boolean = tp.dealias match {
       case tp: OrType => true
       case tp: RefinedOrRecType => isOrType(tp.parent)
       case AndType(tp1, tp2) => isOrType(tp1) | isOrType(tp2)
       case WildcardType(bounds: TypeBounds) => isOrType(bounds.hi)
       case _ => false
     }
+    def widenOr(tp: Type) =
+      if (isOrType(tp) && !isOrType(bound)) tp.widenUnion
+      else tp
+    def widenSingle(tp: Type) =
+      if (isMultiSingleton(tp) && !isMultiSingleton(bound) &&
+          !isSubTypeWhenFrozen(bound, defn.SingletonType)) tp.widen
+      else tp
+    widenOr(widenSingle(tp))
+  }
 
-    // First, solve the constraint.
-    var inst = approximation(param, fromBelow).simplified
-
-    // Then, approximate by (1.) - (3.) and simplify as follows.
-    // 1. If instance is from below and is a singleton type, yet upper bound is
-    // not a singleton type or a subtype of `scala.Singleton`, widen the
-    // instance.
-    if (fromBelow && isMultiSingleton(inst) && !isMultiSingleton(upperBound)
-        && !isSubTypeWhenFrozen(upperBound, defn.SingletonType))
-      inst = inst.widen
-
-    // 2. If instance is from below and is a fully-defined union type, yet upper bound
-    // is not a union type, approximate the union type from above by an intersection
-    // of all common base types.
-    if (fromBelow && isOrType(inst) && !isOrType(upperBound))
-      inst = inst.widenUnion
-
-    inst
+  /** The instance type of `param` in the current constraint (which contains `param`).
+   *  If `fromBelow` is true, the instance type is the lub of the parameter's
+   *  lower bounds; otherwise it is the glb of its upper bounds. However,
+   *  a lower bound instantiation can be a singleton type only if the upper bound
+   *  is also a singleton type.
+   */
+  def instanceType(param: TypeParamRef, fromBelow: Boolean): Type = {
+    val inst = approximation(param, fromBelow).simplified
+    if (fromBelow) widenInferred(inst, constraint.fullUpperBound(param)) else inst
   }
 
   /** Constraint `c1` subsumes constraint `c2`, if under `c2` as constraint we have

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

@@ -710,6 +710,10 @@ class Definitions {
   def PairClass(implicit ctx: Context) = PairType.symbol.asClass
   lazy val TupleXXLType = ctx.requiredClassRef("scala.TupleXXL")
   def TupleXXLClass(implicit ctx: Context) = TupleXXLType.symbol.asClass
+  def TupleXXLModule(implicit ctx: Context) = TupleXXLClass.companionModule
+
+    def TupleXXL_apply(implicit ctx: Context) =
+      TupleXXLModule.info.member(nme.apply).requiredSymbol(_.info.isVarArgsMethod)
 
   // Annotation base classes
   lazy val AnnotationType              = ctx.requiredClassRef("scala.annotation.Annotation")

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

@@ -9,6 +9,7 @@ import Uniques.unique
 import dotc.transform.ExplicitOuter._
 import dotc.transform.ValueClasses._
 import util.DotClass
+import transform.TypeUtils._
 import Definitions.MaxImplementedFunctionArity
 import scala.annotation.tailrec
 
@@ -457,16 +458,7 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
   }
 
   private def erasePair(tp: Type)(implicit ctx: Context): Type = {
-    def tupleArity(tp: Type): Int = tp.dealias match {
-      case AppliedType(tycon, _ :: tl :: Nil) if tycon.isRef(defn.PairClass) =>
-        val arity = tupleArity(tl)
-        if (arity < 0) arity else arity + 1
-      case tp1 =>
-        if (tp1.isRef(defn.UnitClass)) 0
-        else if (defn.isTupleClass(tp1.classSymbol)) tp1.dealias.argInfos.length
-        else -1
-    }
-    val arity = tupleArity(tp)
+    val arity = tp.tupleArity
     if (arity < 0) defn.ObjectType
     else if (arity <= Definitions.MaxTupleArity) defn.TupleType(arity)
     else defn.TupleXXLType

compiler/src/dotty/tools/dotc/core/tasty/TastyFormat.scala

@@ -211,6 +211,7 @@ Standard-Section: "ASTs" TopLevelStat*
                   TYPEDSPLICE Length splice_Term
                   FUNCTION    Length body_Term arg_Term*
                   INFIXOP     Length op_NameRef left_Term right_Term
+                  TUPLE       Length elem_Term*
                   PATDEF      Length type_Term rhs_Term pattern_Term* Modifier*
                   EMPTYTYPETREE
 
@@ -438,6 +439,7 @@ object TastyFormat {
   final val FUNCTION = 201
   final val INFIXOP = 202
   final val PATDEF = 203
+  final val TUPLE = 204
 
   def methodType(isImplicit: Boolean = false, isErased: Boolean = false) = {
     val implicitOffset = if (isImplicit) 1 else 0
@@ -657,6 +659,7 @@ object TastyFormat {
     case TYPEDSPLICE => "TYPEDSPLICE"
     case FUNCTION => "FUNCTION"
     case INFIXOP => "INFIXOP"
+    case TUPLE => "TUPLE"
     case PATDEF => "PATDEF"
   }
 

compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala

@@ -853,6 +853,9 @@ class TreePickler(pickler: TastyPickler) {
       case untpd.InfixOp(l, op, r) =>
         writeByte(INFIXOP)
         withLength { pickleUntyped(l); pickleUntyped(op); pickleUntyped(r) }
+      case untpd.Tuple(elems) =>
+        writeByte(TUPLE)
+        withLength { elems.foreach(pickleUntyped) }
       case untpd.PatDef(mods, pats, tpt, rhs) =>
         writeByte(PATDEF)
         withLength {

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -1385,6 +1385,8 @@ class TreeUnpickler(reader: TastyReader,
             untpd.Function(params, body)
           case INFIXOP =>
             untpd.InfixOp(readUntyped(), readIdent(), readUntyped())
+          case TUPLE =>
+            untpd.Tuple(until(end)(readUntyped()))
           case PATDEF =>
             val tpt = readUntyped()
             val rhs = readUntyped()

compiler/src/dotty/tools/dotc/reporting/diagnostic/messages.scala

@@ -490,22 +490,6 @@ object messages {
     }
   }
 
-  case class TupleTooLong(ts: List[untpd.Tree])(implicit ctx: Context)
-  extends Message(TupleTooLongID) {
-    import Definitions.MaxTupleArity
-    val kind = "Syntax"
-    val msg = hl"""A ${"tuple"} cannot have more than ${MaxTupleArity} members"""
-
-    val explanation = {
-      val members = ts.map(_.showSummary).grouped(MaxTupleArity)
-      val nestedRepresentation = members.map(_.mkString(", ")).mkString(")(")
-      hl"""|This restriction will be removed in the future.
-           |Currently it is possible to use nested tuples when more than $MaxTupleArity are needed, for example:
-           |
-           |((${nestedRepresentation}))"""
-    }
-  }
-
   case class RepeatedModifier(modifier: String)(implicit ctx:Context)
   extends Message(RepeatedModifierID) {
     val kind = "Syntax"

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

@@ -149,15 +149,19 @@ object TypeTestsCasts {
         def derivedTree(expr1: Tree, sym: Symbol, tp: Type) =
           cpy.TypeApply(tree)(expr1.select(sym).withPos(expr.pos), List(TypeTree(tp)))
 
-        def foundCls = expr.tpe.widen.classSymbol
+        def effectiveClass(tp: Type): Symbol =
+          if (tp.isRef(defn.PairClass)) effectiveClass(erasure(tp))
+          else tp.classSymbol
+
+        def foundCls = effectiveClass(expr.tpe.widen)
         // println(i"ta $tree, found = $foundCls")
 
         def inMatch =
           fun.symbol == defn.Any_typeTest ||  // new scheme
           expr.symbol.is(Case)                // old scheme
 
         def transformIsInstanceOf(expr:Tree, testType: Type, flagUnrelated: Boolean): Tree = {
-          def testCls = testType.classSymbol
+          def testCls = effectiveClass(testType.widen)
 
           def unreachable(why: => String) =
             if (flagUnrelated)

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

@@ -27,5 +27,28 @@ object TypeUtils {
       case self: MethodicType => self
       case _ => if (ctx.erasedTypes) MethodType(Nil, self) else ExprType(self)
     }
+
+    /** The arity of this tuple type, which can be made up of Unit, TupleX and `*:` pairs,
+     *  or -1 if this is not a tuple type.
+     */
+    def tupleArity(implicit ctx: Context): Int = self match {
+      case AppliedType(tycon, _ :: tl :: Nil) if tycon.isRef(defn.PairClass) =>
+        val arity = tl.tupleArity
+        if (arity < 0) arity else arity + 1
+      case tp1 =>
+        if (tp1.isRef(defn.UnitClass)) 0
+        else if (defn.isTupleClass(tp1.classSymbol)) tp1.dealias.argInfos.length
+        else -1
+    }
+
+    /** The element types of this tuple type, which can be made up of Unit, TupleX and `*:` pairs */
+    def tupleElementTypes(implicit ctx: Context): List[Type] = self match {
+      case AppliedType(tycon, hd :: tl :: Nil) if tycon.isRef(defn.PairClass) =>
+        hd :: tl.tupleElementTypes
+      case tp1 =>
+        if (tp1.isRef(defn.UnitClass)) Nil
+        else if (defn.isTupleClass(tp1.classSymbol)) tp1.dealias.argInfos
+        else throw new AssertionError("not a tuple")
+    }
   }
 }