diff --git a/compiler/src/dotty/tools/dotc/ast/Desugar.scala b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
index 3b27999cad35..1104ecb9230e 100644
--- a/compiler/src/dotty/tools/dotc/ast/Desugar.scala
+++ b/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)
diff --git a/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala b/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
index 91d1db303082..5587be82333d 100644
--- a/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
+++ b/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
@@ -716,6 +716,19 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
         Nil
     }
 
+  /** If `tree` is an instance of `TupleN[...](e1, ..., eN)`, the arguments `e1, ..., eN`
+   *  otherwise the empty list.
+   */
+  def tupleArgs(tree: Tree)(implicit ctx: Context): List[Tree] = tree match {
+    case Block(Nil, expr) => tupleArgs(expr)
+    case Inlined(_, Nil, expr) => tupleArgs(expr)
+    case Apply(fn, args)
+    if fn.symbol.name == nme.apply &&
+        fn.symbol.owner.is(Module) &&
+        defn.isTupleClass(fn.symbol.owner.companionClass) => args
+    case _ => Nil
+  }
+
   /** The qualifier part of a Select or Ident.
    *  For an Ident, this is the `This` of the current class.
    */
diff --git a/compiler/src/dotty/tools/dotc/core/ConstraintHandling.scala b/compiler/src/dotty/tools/dotc/core/ConstraintHandling.scala
index 16c9d4056138..2a9843394c9d 100644
--- a/compiler/src/dotty/tools/dotc/core/ConstraintHandling.scala
+++ b/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,13 +267,6 @@ 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)
@@ -282,25 +274,25 @@ trait ConstraintHandling {
       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
diff --git a/compiler/src/dotty/tools/dotc/core/Definitions.scala b/compiler/src/dotty/tools/dotc/core/Definitions.scala
index e744e1c08d66..0483f699fc3d 100644
--- a/compiler/src/dotty/tools/dotc/core/Definitions.scala
+++ b/compiler/src/dotty/tools/dotc/core/Definitions.scala
@@ -706,6 +706,18 @@ class Definitions {
 
   lazy val XMLTopScopeModuleRef = ctx.requiredModuleRef("scala.xml.TopScope")
 
+  lazy val TupleTypeRef = ctx.requiredClassRef("scala.Tuple")
+  def TupleClass(implicit ctx: Context) = TupleTypeRef.symbol.asClass
+
+  lazy val PairType = ctx.requiredClassRef("scala.*:")
+  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")
   def AnnotationClass(implicit ctx: Context) = AnnotationType.symbol.asClass
@@ -880,7 +892,7 @@ class Definitions {
   private lazy val ImplementedFunctionType = mkArityArray("scala.Function", MaxImplementedFunctionArity, 0)
   def FunctionClassPerRun = new PerRun[Array[Symbol]](implicit ctx => ImplementedFunctionType.map(_.symbol.asClass))
 
-  lazy val TupleType = mkArityArray("scala.Tuple", MaxTupleArity, 2)
+  lazy val TupleType = mkArityArray("scala.Tuple", MaxTupleArity, 1)
 
   def FunctionClass(n: Int, isImplicit: Boolean = false, isErased: Boolean = false)(implicit ctx: Context) =
     if (isImplicit && isErased)
@@ -901,8 +913,6 @@ class Definitions {
     if (n <= MaxImplementedFunctionArity && (!isImplicit || ctx.erasedTypes) && !isErased) ImplementedFunctionType(n)
     else FunctionClass(n, isImplicit, isErased).typeRef
 
-  private lazy val TupleTypes: Set[TypeRef] = TupleType.toSet
-
   /** If `cls` is a class in the scala package, its name, otherwise EmptyTypeName */
   def scalaClassName(cls: Symbol)(implicit ctx: Context): TypeName =
     if (cls.isClass && cls.owner == ScalaPackageClass) cls.asClass.name else EmptyTypeName
@@ -1127,6 +1137,10 @@ class Definitions {
   def isErasedFunctionType(tp: Type)(implicit ctx: Context) =
     isFunctionType(tp) && tp.dealias.typeSymbol.name.isErasedFunction
 
+  /** A whitelist of Scala-2 classes that are known to be pure */
+  def isAssuredNoInits(sym: Symbol) =
+    (sym `eq` SomeClass) || isTupleClass(sym)
+
   // ----- primitive value class machinery ------------------------------------------
 
   /** This class would also be obviated by the implicit function type design */
@@ -1199,6 +1213,8 @@ class Definitions {
   def isValueSubClass(sym1: Symbol, sym2: Symbol) =
     valueTypeEnc(sym2.asClass.name) % valueTypeEnc(sym1.asClass.name) == 0
 
+  lazy val erasedToObject = Set[Symbol](AnyClass, AnyValClass, TupleClass, SingletonClass)
+
   // ----- Initialization ---------------------------------------------------
 
   /** Lists core classes that don't have underlying bytecode, but are synthesized on-the-fly in every reflection universe */
@@ -1226,6 +1242,27 @@ class Definitions {
 
   private[this] var isInitialized = false
 
+  /** Add a `Tuple` as a parent to `Unit`.
+   *  Add the right `*:` instance as a parent to Tuple1..Tuple22
+   */
+  def fixTupleCompleter(cls: ClassSymbol): Unit = cls.infoOrCompleter match {
+    case completer: LazyType =>
+      cls.info = new LazyType {
+        def syntheticParent(tparams: List[TypeSymbol]): Type =
+          if (tparams.isEmpty) TupleTypeRef
+          else (tparams :\ (UnitType: Type)) ((tparam, tail) => PairType.appliedTo(tparam.typeRef, tail))
+        override def complete(denot: SymDenotation)(implicit ctx: Context) = {
+          completer.complete(denot)
+          denot.info match {
+            case info: ClassInfo =>
+              denot.info = info.derivedClassInfo(
+                classParents = info.classParents :+ syntheticParent(cls.typeParams))
+          }
+        }
+      }
+    case _ =>
+  }
+
   def init()(implicit ctx: Context) = {
     this.ctx = ctx
     if (!isInitialized) {
@@ -1243,6 +1280,10 @@ class Definitions {
       // force initialization of every symbol that is synthesized or hijacked by the compiler
       val forced = syntheticCoreClasses ++ syntheticCoreMethods ++ ScalaValueClasses()
 
+      fixTupleCompleter(UnitClass)
+      for (i <- 1 to MaxTupleArity)
+        fixTupleCompleter(TupleType(i).symbol.asClass)
+
       isInitialized = true
     }
   }
diff --git a/compiler/src/dotty/tools/dotc/core/SymDenotations.scala b/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
index 8dad726672af..60ad2eddcba8 100644
--- a/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
+++ b/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
@@ -596,7 +596,8 @@ object SymDenotations {
      *  initaliazion code?
      */
     def isNoInitsClass(implicit ctx: Context) =
-      isClass && asClass.baseClasses.forall(_.is(NoInits))
+      isClass &&
+      (asClass.baseClasses.forall(_.is(NoInits)) || defn.isAssuredNoInits(symbol))
 
     /** Is this a "real" method? A real method is a method which is:
      *  - not an accessor
diff --git a/compiler/src/dotty/tools/dotc/core/TypeErasure.scala b/compiler/src/dotty/tools/dotc/core/TypeErasure.scala
index be59b0eb8849..252d84638787 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeErasure.scala
+++ b/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
 
@@ -33,6 +34,9 @@ import scala.annotation.tailrec
  */
 object TypeErasure {
 
+  private def erasureDependsOnArgs(tp: Type)(implicit ctx: Context) =
+    tp.isRef(defn.ArrayClass) || tp.isRef(defn.PairClass)
+
   /** A predicate that tests whether a type is a legal erased type. Only asInstanceOf and
    *  isInstanceOf may have types that do not satisfy the predicate.
    *  ErasedValueType is considered an erased type because it is valid after Erasure (it is
@@ -44,7 +48,8 @@ object TypeErasure {
     case tp: TypeRef =>
       val sym = tp.symbol
       sym.isClass &&
-      sym != defn.AnyClass && sym != defn.ArrayClass &&
+      !erasureDependsOnArgs(tp) &&
+      !defn.erasedToObject.contains(sym) &&
       !defn.isSyntheticFunctionClass(sym)
     case _: TermRef =>
       true
@@ -280,10 +285,8 @@ object TypeErasure {
 
           // Pick the last minimum to prioritise classes over traits
           minimums.lastOption match {
-            case Some(lub) if lub != defn.AnyClass && lub != defn.AnyValClass =>
-              lub.typeRef
-            case _ => // Any/AnyVal only exist before erasure
-              defn.ObjectType
+            case Some(lub) => valueErasure(lub.typeRef)
+            case _ => defn.ObjectType
           }
       }
   }
@@ -354,7 +357,7 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
    *      - otherwise, if T is a type parameter coming from Java, []Object
    *      - otherwise, Object
    *   - For a term ref p.x, the type <noprefix> # x.
-   *   - For a typeref scala.Any, scala.AnyVal or scala.Singleton: |java.lang.Object|
+   *   - For a typeref scala.Any, scala.AnyVal, scala.Singleton, scala.Tuple, or scala.*: : |java.lang.Object|
    *   - For a typeref scala.Unit, |scala.runtime.BoxedUnit|.
    *   - For a typeref scala.FunctionN, where N > MaxImplementedFunctionArity, scala.FunctionXXL
    *   - For a typeref scala.ImplicitFunctionN, | scala.FunctionN |
@@ -390,6 +393,7 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
       else eraseNormalClassRef(tp)
     case tp: AppliedType =>
       if (tp.tycon.isRef(defn.ArrayClass)) eraseArray(tp)
+      else if (tp.tycon.isRef(defn.PairClass)) erasePair(tp)
       else if (tp.isRepeatedParam) apply(tp.underlyingIfRepeated(isJava))
       else apply(tp.superType)
     case _: TermRef | _: ThisType =>
@@ -420,9 +424,13 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
     case tp @ ClassInfo(pre, cls, parents, decls, _) =>
       if (cls is Package) tp
       else {
+        def eraseParent(tp: Type) = tp.dealias match {
+          case tp: AppliedType if tp.tycon.isRef(defn.PairClass) => defn.ObjectType
+          case _ => apply(tp)
+        }
         val erasedParents: List[Type] =
           if ((cls eq defn.ObjectClass) || cls.isPrimitiveValueClass) Nil
-          else parents.mapConserve(apply) match {
+          else parents.mapConserve(eraseParent) match {
             case tr :: trs1 =>
               assert(!tr.classSymbol.is(Trait), cls)
               val tr1 = if (cls is Trait) defn.ObjectType else tr
@@ -450,6 +458,13 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
     else JavaArrayType(arrayErasure(elemtp))
   }
 
+  private def erasePair(tp: Type)(implicit ctx: Context): Type = {
+    val arity = tp.tupleArity
+    if (arity < 0) defn.ObjectType
+    else if (arity <= Definitions.MaxTupleArity) defn.TupleType(arity)
+    else defn.TupleXXLType
+  }
+
   /** The erasure of a symbol's info. This is different from `apply` in the way `ExprType`s and
    *  `PolyType`s are treated. `eraseInfo` maps them them to method types, whereas `apply` maps them
    *  to the underlying type.
@@ -492,7 +507,7 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
       // constructor method should not be semi-erased.
       else if (isConstructor && isDerivedValueClass(sym)) eraseNormalClassRef(tp)
       else this(tp)
-    case AppliedType(tycon, _) if !(tycon isRef defn.ArrayClass) =>
+    case AppliedType(tycon, _) if !erasureDependsOnArgs(tycon) =>
       eraseResult(tycon)
     case _ =>
       this(tp)
@@ -500,7 +515,7 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
 
   private def normalizeClass(cls: ClassSymbol)(implicit ctx: Context): ClassSymbol = {
     if (cls.owner == defn.ScalaPackageClass) {
-      if (cls == defn.AnyClass || cls == defn.AnyValClass || cls == defn.SingletonClass)
+      if (defn.erasedToObject.contains(cls))
         return defn.ObjectClass
       if (cls == defn.UnitClass)
         return defn.BoxedUnitClass
@@ -534,7 +549,7 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
           normalizeClass(sym.asClass).fullName.asTypeName
       case tp: AppliedType =>
         sigName(
-          if (tp.tycon.isRef(defn.ArrayClass)) this(tp)
+          if (erasureDependsOnArgs(tp.tycon)) this(tp)
           else if (tp.tycon.typeSymbol.isClass) tp.underlying
           else tp.superType)
       case ErasedValueType(_, underlying) =>
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TastyFormat.scala b/compiler/src/dotty/tools/dotc/core/tasty/TastyFormat.scala
index b79228b4224f..f14f0c76019a 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TastyFormat.scala
+++ b/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
 
@@ -437,6 +438,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
@@ -656,6 +658,7 @@ object TastyFormat {
     case TYPEDSPLICE => "TYPEDSPLICE"
     case FUNCTION => "FUNCTION"
     case INFIXOP => "INFIXOP"
+    case TUPLE => "TUPLE"
     case PATDEF => "PATDEF"
   }
 
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
index 51b410020217..3df4dca3f33d 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
+++ b/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 {
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
index 40cfba553bcd..767edd9a6a84 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
+++ b/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()
diff --git a/compiler/src/dotty/tools/dotc/reporting/diagnostic/messages.scala b/compiler/src/dotty/tools/dotc/reporting/diagnostic/messages.scala
index 0380dd208276..2eb33834aa13 100644
--- a/compiler/src/dotty/tools/dotc/reporting/diagnostic/messages.scala
+++ b/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"
diff --git a/compiler/src/dotty/tools/dotc/transform/Erasure.scala b/compiler/src/dotty/tools/dotc/transform/Erasure.scala
index 69bded663ee5..41dd824027d2 100644
--- a/compiler/src/dotty/tools/dotc/transform/Erasure.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Erasure.scala
@@ -135,12 +135,15 @@ class Erasure extends Phase with DenotTransformer {
       }
   }
 
-  def assertErased(tp: Type, tree: tpd.Tree = tpd.EmptyTree)(implicit ctx: Context): Unit =
-    if (tp.typeSymbol == defn.ArrayClass &&
-        ctx.compilationUnit.source.file.name == "Array.scala") {} // ok
-    else
-      assert(isErasedType(tp),
+  def assertErased(tp: Type, tree: tpd.Tree = tpd.EmptyTree)(implicit ctx: Context): Unit = {
+    def isAllowed(cls: Symbol, sourceName: String) =
+      tp.typeSymbol == cls && ctx.compilationUnit.source.file.name == sourceName
+    assert(isErasedType(tp) ||
+           isAllowed(defn.ArrayClass, "Array.scala") ||
+           isAllowed(defn.TupleClass, "Tuple.scala") ||
+           isAllowed(defn.PairClass, "Tuple.scala"),
         i"The type $tp - ${tp.toString} of class ${tp.getClass} of tree $tree : ${tree.tpe} / ${tree.getClass} is illegal after erasure, phase = ${ctx.phase.prev}")
+  }
 }
 
 object Erasure {
@@ -376,7 +379,7 @@ object Erasure {
      *  on selections `e.m`, where `OT` is the type of the owner of `m` and `ET`
      *  is the erased type of the selection's original qualifier expression.
      *
-     *      e.m1 -> e.m2          if `m1` is a member of Any or AnyVal and `m2` is
+     *      e.m1 -> e.m2          if `m1` is a member of a class that erases to Object and `m2` is
      *                            the same-named member in Object.
      *      e.m -> box(e).m       if `e` is primitive and `m` is a member or a reference class
      *                            or `e` has an erased value class type.
@@ -396,7 +399,7 @@ object Erasure {
 
       def mapOwner(sym: Symbol): Symbol = {
         def recur(owner: Symbol): Symbol =
-          if ((owner eq defn.AnyClass) || (owner eq defn.AnyValClass)) {
+          if (defn.erasedToObject.contains(owner)) {
             assert(sym.isConstructor, s"${sym.showLocated}")
             defn.ObjectClass
           } else if (defn.isSyntheticFunctionClass(owner))
diff --git a/compiler/src/dotty/tools/dotc/transform/GenericSignatures.scala b/compiler/src/dotty/tools/dotc/transform/GenericSignatures.scala
index 276e45a9eac8..dce23de8f09d 100644
--- a/compiler/src/dotty/tools/dotc/transform/GenericSignatures.scala
+++ b/compiler/src/dotty/tools/dotc/transform/GenericSignatures.scala
@@ -4,6 +4,7 @@ package transform
 
 import core.Annotations.Annotation
 import core.Contexts.Context
+import core.Definitions
 import core.Flags._
 import core.Names.Name
 import core.Symbols._
@@ -191,6 +192,8 @@ object GenericSignatures {
               args.foreach(jsig(_))
             }
           }
+          else if (sym == defn.PairClass && tp.tupleArity > Definitions.MaxTupleArity)
+            jsig(defn.TupleXXLType)
           else if (isTypeParameterInSig(sym, sym0)) {
             assert(!sym.isAliasType, "Unexpected alias type: " + sym)
             typeParamSig(sym.name.lastPart)
diff --git a/compiler/src/dotty/tools/dotc/transform/PostTyper.scala b/compiler/src/dotty/tools/dotc/transform/PostTyper.scala
index d12420f1313b..e89daa24de95 100644
--- a/compiler/src/dotty/tools/dotc/transform/PostTyper.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PostTyper.scala
@@ -178,7 +178,8 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
 
     private object dropInlines extends TreeMap {
       override def transform(tree: Tree)(implicit ctx: Context): Tree = tree match {
-        case Inlined(call, _, _) => Typed(call, TypeTree(tree.tpe))
+        case Inlined(call, _, _) =>
+          cpy.Inlined(tree)(call, Nil, Typed(ref(defn.Predef_undefined), TypeTree(tree.tpe)))
         case _ => super.transform(tree)
       }
     }
diff --git a/compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala b/compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala
index 1bffe1372586..da67a64e60ad 100644
--- a/compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala
+++ b/compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala
@@ -149,7 +149,11 @@ 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 =
@@ -157,7 +161,7 @@ object TypeTestsCasts {
           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)
diff --git a/compiler/src/dotty/tools/dotc/transform/TypeUtils.scala b/compiler/src/dotty/tools/dotc/transform/TypeUtils.scala
index b7eb024b0f4d..f32b9df793e8 100644
--- a/compiler/src/dotty/tools/dotc/transform/TypeUtils.scala
+++ b/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")
+    }
   }
 }
diff --git a/compiler/src/dotty/tools/dotc/typer/Applications.scala b/compiler/src/dotty/tools/dotc/typer/Applications.scala
index 34e4fa1375cc..bce6fb03d7eb 100644
--- a/compiler/src/dotty/tools/dotc/typer/Applications.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Applications.scala
@@ -935,6 +935,9 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
       else trySelectUnapply(qual1)(_ => notAnExtractor(sel))
     }
 
+    if (unapplyFn.symbol.isRewriteMethod)
+      checkInRewriteContext("implementation restriction: call to rewrite unapply", tree.pos)
+
     /** Add a `Bind` node for each `bound` symbol in a type application `unapp` */
     def addBinders(unapp: Tree, bound: List[Symbol]) = unapp match {
       case TypeApply(fn, args) =>
diff --git a/compiler/src/dotty/tools/dotc/typer/Inliner.scala b/compiler/src/dotty/tools/dotc/typer/Inliner.scala
index ed09a387f7dd..5f4b1d5a76b9 100644
--- a/compiler/src/dotty/tools/dotc/typer/Inliner.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Inliner.scala
@@ -132,7 +132,7 @@ object Inliner {
         tree,
         i"""|Maximal number of successive inlines (${ctx.settings.XmaxInlines.value}) exceeded,
             |Maybe this is caused by a recursive rewrite method?
-            |You can use -Xmax:inlines to change the limit.""",
+            |You can use -Xmax-inlines to change the limit.""",
         (tree :: enclosingInlineds).last.pos
       )
   }
@@ -463,29 +463,35 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
      *             - the class `C`
      *             - the arguments `args`
      *             - any bindings that wrap the instance creation
+     *             - whether the instance creation is precomputed or by-name
      */
     private object NewInstance {
-      def unapply(tree: Tree)(implicit ctx: Context): Option[(Symbol, List[Tree], List[Tree])] = {
+      def unapply(tree: Tree)(implicit ctx: Context): Option[(Symbol, List[Tree], List[Tree], Boolean)] = {
         def unapplyLet(bindings: List[Tree], expr: Tree) =
           unapply(expr) map {
-            case (cls, reduced, prefix) => (cls, reduced, bindings ::: prefix)
+            case (cls, reduced, prefix, precomputed) => (cls, reduced, bindings ::: prefix, precomputed)
           }
         tree match {
           case Apply(fn, args) =>
             fn match {
               case Select(New(tpt), nme.CONSTRUCTOR) =>
-                Some((tpt.tpe.classSymbol, args, Nil))
+                Some((tpt.tpe.classSymbol, args, Nil, false))
               case TypeApply(Select(New(tpt), nme.CONSTRUCTOR), _) =>
-                Some((tpt.tpe.classSymbol, args, Nil))
+                Some((tpt.tpe.classSymbol, args, Nil, false))
               case _ =>
                 val meth = fn.symbol
                 if (meth.name == nme.apply &&
                     meth.flags.is(Synthetic) &&
-                    meth.owner.linkedClass.is(Case)) Some(meth.owner.linkedClass, args, Nil)
+                    meth.owner.linkedClass.is(Case))
+                  Some(meth.owner.linkedClass, args, Nil, false)
                 else None
             }
           case Ident(_) =>
-            inlineBindings.get(tree.symbol).flatMap(unapply)
+            for {
+              binding <- inlineBindings.get(tree.symbol)
+              (cls, reduced, prefix, precomputed) <- unapply(binding)
+            }
+            yield (cls, reduced, prefix, precomputed || binding.isInstanceOf[ValDef])
           case Inlined(_, bindings, expansion) =>
             unapplyLet(bindings, expansion)
           case Block(stats, expr) if isPureExpr(tree) =>
@@ -498,13 +504,13 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
 
     /** If `tree` is equivalent to `new C(args).x` where class `C` does not have
      *  initialization code and `x` is a parameter corresponding to one of the
-     *  arguments `args`, the corresponding argument, prefixed by the evaluation
-     *  of impure arguments, otherwise `tree` itself.
+     *  arguments `args`, the corresponding argument, otherwise `tree` itself.
+     *  Side effects of original arguments need to be preserved.
      */
     def reduceProjection(tree: Tree)(implicit ctx: Context): Tree = {
       if (ctx.debug) inlining.println(i"try reduce projection $tree")
       tree match {
-        case Select(NewInstance(cls, args, prefix), field) if cls.isNoInitsClass =>
+        case Select(NewInstance(cls, args, prefix, precomputed), field) if cls.isNoInitsClass =>
           def matches(param: Symbol, selection: Symbol): Boolean =
             param == selection || {
               selection.name match {
@@ -516,17 +522,25 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
             }
           val idx = cls.asClass.paramAccessors.indexWhere(matches(_, tree.symbol))
           if (idx >= 0 && idx < args.length) {
-            def collectImpure(from: Int, end: Int) =
-              (from until end).filterNot(i => isPureExpr(args(i))).toList.map(args)
-            val leading = collectImpure(0, idx)
-            val trailing = collectImpure(idx + 1, args.length)
+            def finish(arg: Tree) =
+              new TreeTypeMap().transform(arg) // make sure local bindings in argument have fresh symbols
+                .reporting(res => i"projecting $tree -> $res", inlining)
             val arg = args(idx)
-            val argInPlace =
-              if (trailing.isEmpty) arg
-              else letBindUnless(TreeInfo.Pure, arg)(seq(trailing, _))
-            val fullArg = seq(prefix, seq(leading, argInPlace))
-            new TreeTypeMap().transform(fullArg) // make sure local bindings in argument have fresh symbols
-              .reporting(res => i"projecting $tree -> $res", inlining)
+            if (precomputed)
+              if (isPureExpr(arg)) finish(arg)
+              else tree // nothing we can do here, projection would duplicate side effect
+            else {
+              // newInstance is evaluated in place, need to reflect side effects of
+              // arguments in the order they were written originally
+              def collectImpure(from: Int, end: Int) =
+                (from until end).filterNot(i => isPureExpr(args(i))).toList.map(args)
+              val leading = collectImpure(0, idx)
+              val trailing = collectImpure(idx + 1, args.length)
+              val argInPlace =
+                if (trailing.isEmpty) arg
+                else letBindUnless(TreeInfo.Pure, arg)(seq(trailing, _))
+              finish(seq(prefix, seq(leading, argInPlace)))
+            }
           }
           else tree
         case Block(stats, expr) if stats.forall(isPureBinding) =>
@@ -718,21 +732,34 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
           case UnApply(unapp, _, pats) =>
             unapp.tpe.widen match {
               case mt: MethodType if mt.paramInfos.length == 1 =>
+
+                def reduceSubPatterns(pats: List[Tree], selectors: List[Tree]): Boolean = (pats, selectors) match {
+                  case (Nil, Nil) => true
+                  case (pat :: pats1, selector :: selectors1) =>
+                    val elem = newBinding(RewriteBinderName.fresh(), Synthetic, selector)
+                    reducePattern(bindingsBuf, elem.termRef, pat) &&
+                    reduceSubPatterns(pats1, selectors1)
+                  case _ => false
+                }
+
                 val paramType = mt.paramInfos.head
                 val paramCls = paramType.classSymbol
-                paramCls.is(Case) && unapp.symbol.is(Synthetic) && scrut <:< paramType && {
+                if (paramCls.is(Case) && unapp.symbol.is(Synthetic) && scrut <:< paramType) {
                   val caseAccessors =
                     if (paramCls.is(Scala2x)) paramCls.caseAccessors.filter(_.is(Method))
                     else paramCls.asClass.paramAccessors
-                  var subOK = caseAccessors.length == pats.length
-                  for ((pat, accessor) <- (pats, caseAccessors).zipped)
-                    subOK = subOK && {
-                      val rhs = constToLiteral(reduceProjection(ref(scrut).select(accessor).ensureApplied))
-                      val elem = newBinding(RewriteBinderName.fresh(), Synthetic, rhs)
-                      reducePattern(bindingsBuf, elem.termRef, pat)
-                    }
-                  subOK
+                  val selectors =
+                    for (accessor <- caseAccessors)
+                    yield constToLiteral(reduceProjection(ref(scrut).select(accessor).ensureApplied))
+                  caseAccessors.length == pats.length && reduceSubPatterns(pats, selectors)
+                }
+                else if (unapp.symbol.isRewriteMethod) {
+                  val app = untpd.Apply(untpd.TypedSplice(unapp), untpd.ref(scrut))
+                  val app1 = typer.typedExpr(app)
+                  val args = tupleArgs(app1)
+                  args.nonEmpty && reduceSubPatterns(pats, args)
                 }
+                else false
               case _ =>
                 false
             }
diff --git a/compiler/src/dotty/tools/dotc/typer/PrepareInlineable.scala b/compiler/src/dotty/tools/dotc/typer/PrepareInlineable.scala
index d98096c63f3b..b60585a40457 100644
--- a/compiler/src/dotty/tools/dotc/typer/PrepareInlineable.scala
+++ b/compiler/src/dotty/tools/dotc/typer/PrepareInlineable.scala
@@ -243,6 +243,8 @@ object PrepareInlineable {
             val typedBody =
               if (ctx.reporter.hasErrors) rawBody
               else ctx.compilationUnit.inlineAccessors.makeInlineable(rawBody)
+            if (inlined.isRewriteMethod)
+              checkRewriteMethod(inlined, typedBody)
             val inlineableBody = addReferences(inlined, originalBody, typedBody)
             inlining.println(i"Body to inline for $inlined: $inlineableBody")
             inlineableBody
@@ -251,6 +253,15 @@ object PrepareInlineable {
     }
   }
 
+  def checkRewriteMethod(inlined: Symbol, body: Tree)(implicit ctx: Context) = {
+    if (ctx.outer.inRewriteMethod)
+      ctx.error(ex"implementation restriction: nested rewrite methods are not supported", inlined.pos)
+    if (inlined.name == nme.unapply && tupleArgs(body).isEmpty)
+      ctx.warning(
+        em"rewrite unapply method can be rewritten only if its right hand side is a tuple (e1, ..., eN)",
+        body.pos)
+  }
+
   /** Tweak untyped tree `original` so that all external references are typed
    *  and it reflects the changes in the corresponding typed tree `typed` that
    *  make `typed` inlineable. Concretely:
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 6be9008ca0dc..bf9c173ba3ab 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -37,6 +37,7 @@ import config.Printers.{gadts, typr}
 import rewrites.Rewrites.patch
 import NavigateAST._
 import transform.SymUtils._
+import transform.TypeUtils._
 import reporting.trace
 import config.Config
 
@@ -1523,9 +1524,10 @@ class Typer extends Namer
     def typedParent(tree: untpd.Tree): Tree = {
       var result = if (tree.isType) typedType(tree)(superCtx) else typedExpr(tree)(superCtx)
       val psym = result.tpe.dealias.typeSymbol
-      if (seenParents.contains(psym) && !cls.isRefinementClass)
-        ctx.error(i"$psym is extended twice", tree.pos)
-      seenParents += psym
+      if (seenParents.contains(psym) && !cls.isRefinementClass) {
+        if (!ctx.isAfterTyper) ctx.error(i"$psym is extended twice", tree.pos)
+      }
+      else seenParents += psym
       if (tree.isType) {
         if (psym.is(Trait) && !cls.is(Trait) && !cls.superClass.isSubClass(psym))
           result = maybeCall(result, psym, psym.primaryConstructor.info)
@@ -1766,6 +1768,37 @@ class Typer extends Namer
     }
   }
 
+  /** Translate tuples of all arities */
+  def typedTuple(tree: untpd.Tuple, pt: Type)(implicit ctx: Context) = {
+    val elems = tree.trees
+    val arity = elems.length
+    if (arity <= Definitions.MaxTupleArity)
+      typed(desugar.smallTuple(tree).withPos(tree.pos), pt)
+    else {
+      val pts =
+        if (arity == pt.tupleArity) pt.tupleElementTypes
+        else elems.map(_ => defn.AnyType)
+      val elems1 = (tree.trees, pts).zipped.map(typed(_, _))
+      if (ctx.mode.is(Mode.Type))
+        (elems1 :\ (TypeTree(defn.UnitType): Tree))((elemTpt, elemTpts) =>
+          AppliedTypeTree(TypeTree(defn.PairType), List(elemTpt, elemTpts)))
+          .withPos(tree.pos)
+      else {
+        val tupleXXLobj = untpd.ref(defn.TupleXXLModule.termRef)
+        val app = untpd.cpy.Apply(tree)(tupleXXLobj, elems1.map(untpd.TypedSplice(_)))
+          .withPos(tree.pos)
+        val app1 = typed(app, pt)
+        if (ctx.mode.is(Mode.Pattern)) app1
+        else {
+          val elemTpes = (elems, pts).zipped.map((elem, pt) =>
+            ctx.typeComparer.widenInferred(elem.tpe, pt))
+          val resTpe = (elemTpes :\ (defn.UnitType: Type))(defn.PairType.appliedTo(_, _))
+          app1.asInstance(resTpe)
+        }
+      }
+    }
+  }
+
   /** Retrieve symbol attached to given tree */
   protected def retrieveSym(tree: untpd.Tree)(implicit ctx: Context) = tree.removeAttachment(SymOfTree) match {
     case Some(sym) =>
@@ -1851,6 +1884,7 @@ class Typer extends Namer
           case tree: untpd.Annotated => typedAnnotated(tree, pt)
           case tree: untpd.TypedSplice => typedTypedSplice(tree)
           case tree: untpd.UnApply => typedUnApply(tree, pt)
+          case tree: untpd.Tuple => typedTuple(tree, pt)
           case tree: untpd.DependentTypeTree => typed(untpd.TypeTree().withPos(tree.pos), pt)
           case tree: untpd.InfixOp if ctx.mode.isExpr => typedInfixOp(tree, pt)
           case tree @ untpd.PostfixOp(qual, Ident(nme.WILDCARD)) => typedAsFunction(tree, pt)
diff --git a/compiler/test/dotc/pos-test-pickling.blacklist b/compiler/test/dotc/pos-test-pickling.blacklist
index 35867a32d31a..e3b97557b42a 100644
--- a/compiler/test/dotc/pos-test-pickling.blacklist
+++ b/compiler/test/dotc/pos-test-pickling.blacklist
@@ -33,6 +33,7 @@ i4125.scala
 i4167
 i4586.scala
 i4734
+i4758
 implicit-dep.scala
 inline-access-levels
 macro-with-array
@@ -65,6 +66,7 @@ t5504
 t6028
 t6976
 t7264
+t7426.scala
 t7532b
 t8062
 typeclass-encoding2.scala
diff --git a/compiler/test/dotc/run-test-pickling.blacklist b/compiler/test/dotc/run-test-pickling.blacklist
index 42607d1c408f..021e69c2eaca 100644
--- a/compiler/test/dotc/run-test-pickling.blacklist
+++ b/compiler/test/dotc/run-test-pickling.blacklist
@@ -75,6 +75,7 @@ transparentAccess
 transparentByName.scala
 transparentForeach.scala
 transparentPower
+tuples1.scala
 Tuple.scala
 TupleAbstract.scala
 typelevel-numeric.scala
diff --git a/compiler/test/dotty/tools/dotc/CompilationTests.scala b/compiler/test/dotty/tools/dotc/CompilationTests.scala
index 5fcca127e27f..005c95099377 100644
--- a/compiler/test/dotty/tools/dotc/CompilationTests.scala
+++ b/compiler/test/dotty/tools/dotc/CompilationTests.scala
@@ -211,8 +211,11 @@ class CompilationTests extends ParallelTesting {
       Array("-Ycheck-reentrant", "-Yemit-tasty-in-class")
     )
 
+    val libraryDirs = List(Paths.get("library/src"), Paths.get("library/src-scala3"))
+    val librarySources = libraryDirs.flatMap(d => sources(Files.walk(d)))
+
     val lib =
-      compileDir("library/src",
+      compileList("src", librarySources,
         defaultOptions.and("-Ycheck-reentrant", "-strict", "-priorityclasspath", defaultOutputDir))(libGroup)
 
     val compilerDir = Paths.get("compiler/src")
diff --git a/library/src-scala2/scala/Tuple.scala b/library/src-scala2/scala/Tuple.scala
new file mode 100644
index 000000000000..7c981cc592ea
--- /dev/null
+++ b/library/src-scala2/scala/Tuple.scala
@@ -0,0 +1,10 @@
+package scala
+import annotation.showAsInfix
+
+sealed trait Tuple extends Any
+object Tuple
+
+@showAsInfix
+sealed class *:[+H, +T <: Tuple] extends Tuple
+
+object *:
\ No newline at end of file
diff --git a/library/src-scala3/scala/Tuple.scala b/library/src-scala3/scala/Tuple.scala
new file mode 100644
index 000000000000..f058ec07d43a
--- /dev/null
+++ b/library/src-scala3/scala/Tuple.scala
@@ -0,0 +1,258 @@
+package scala
+import annotation.showAsInfix
+import typelevel._
+
+sealed trait Tuple extends Any {
+  import Tuple._
+  rewrite def toArray: Array[Object] = rewrite _size(this) match {
+    case 0 =>
+      $emptyArray
+    case 1 =>
+      val t = asInstanceOf[Tuple1[Object]]
+      Array(t._1)
+    case 2 =>
+      val t = asInstanceOf[Tuple2[Object, Object]]
+      Array(t._1, t._2)
+    case 3 =>
+      val t = asInstanceOf[Tuple3[Object, Object, Object]]
+      Array(t._1, t._2, t._3)
+    case 4 =>
+      val t = asInstanceOf[Tuple4[Object, Object, Object, Object]]
+      Array(t._1, t._2, t._3, t._4)
+    case n if n <= $MaxSpecialized =>
+      $toArray(this, n)
+    case n =>
+      asInstanceOf[TupleXXL].elems
+  }
+
+  rewrite def *: [H] (x: H): Tuple = {
+    erased val resTpe = Typed(_pair(x, this))
+    rewrite _size(this) match {
+      case 0 =>
+        Tuple1(x).asInstanceOf[resTpe.Type]
+      case 1 =>
+        Tuple2(x, asInstanceOf[Tuple1[_]]._1).asInstanceOf[resTpe.Type]
+      case 2 =>
+        val t = asInstanceOf[Tuple2[_, _]]
+        Tuple3(x, t._1, t._2).asInstanceOf[resTpe.Type]
+      case 3 =>
+        val t = asInstanceOf[Tuple3[_, _, _]]
+        Tuple4(x, t._1, t._2, t._3).asInstanceOf[resTpe.Type]
+      case 4 =>
+        val t = asInstanceOf[Tuple4[_, _, _, _]]
+        Tuple5(x, t._1, t._2, t._3, t._4).asInstanceOf[resTpe.Type]
+      case n =>
+        fromArray[resTpe.Type]($consArray(x, toArray))
+    }
+  }
+
+  rewrite def ++(that: Tuple): Tuple = {
+    erased val resTpe = Typed(_concat(this, that))
+    rewrite _size(this) match {
+      case 0 =>
+        that
+      case 1 =>
+        if (_size(that) == 0) this
+        else (asInstanceOf[Tuple1[_]]._1 *: that).asInstanceOf[resTpe.Type]
+      case 2 =>
+        val t = asInstanceOf[Tuple2[_, _]]
+        rewrite _size(that) match {
+          case 0 => this
+          case 1 =>
+            val u = that.asInstanceOf[Tuple1[_]]
+            Tuple3(t._1, t._2, u._1).asInstanceOf[resTpe.Type]
+          case 2 =>
+            val u = that.asInstanceOf[Tuple2[_, _]]
+            Tuple4(t._1, t._2, u._1, u._2).asInstanceOf[resTpe.Type]
+          case _ =>
+            genericConcat[resTpe.Type](this, that)
+        }
+      case 3 =>
+        val t = asInstanceOf[Tuple3[_, _, _]]
+        rewrite _size(that) match {
+          case 0 => this
+          case 1 =>
+            val u = that.asInstanceOf[Tuple1[_]]
+            Tuple4(t._1, t._2, t._3, u._1).asInstanceOf[resTpe.Type]
+          case _ =>
+            genericConcat[resTpe.Type](this, that)
+        }
+      case _ =>
+        if (_size(that) == 0) this
+        else genericConcat[resTpe.Type](this, that)
+    }
+  }
+
+  rewrite def genericConcat[T <: Tuple](xs: Tuple, ys: Tuple): Tuple =
+    fromArray[T](xs.toArray ++ ys.toArray)
+}
+
+object Tuple {
+  transparent val $MaxSpecialized = 22
+
+  val $emptyArray = Array[Object]()
+
+  def $toArray(xs: Tuple, n: Int) = {
+    val arr = new Array[Object](n)
+    var i = 0
+    var it = xs.asInstanceOf[Product].productIterator
+    while (i < n) {
+      arr(i) = it.next().asInstanceOf[Object]
+      i += 1
+    }
+    arr
+  }
+
+  def $consArray[H](x: H, elems: Array[Object]): Array[Object] = {
+    val elems1 = new Array[Object](elems.length + 1)
+    elems1(0) = x.asInstanceOf[Object]
+    Array.copy(elems, 0, elems1, 1, elems.length)
+    elems1
+  }
+
+  private[scala] rewrite def _pair[H, T <: Tuple] (x: H, xs: T): Tuple =
+    erasedValue[H *: T]
+
+  private[scala] rewrite def _size(xs: Tuple): Int =
+    rewrite xs match {
+      case _: Unit => 0
+      case _: (_ *: xs1) => _size(erasedValue[xs1]) + 1
+    }
+
+  private[scala] rewrite def _head(xs: Tuple): Any = rewrite xs match {
+    case _: (x *: _) => erasedValue[x]
+  }
+
+  private[scala] rewrite def _tail(xs: Tuple): Tuple = rewrite xs match {
+    case _: (_ *: xs1) => erasedValue[xs1]
+  }
+
+  private[scala] rewrite def _index(xs: Tuple, n: Int): Any = rewrite xs match {
+    case _: (x *: _)   if n == 0 => erasedValue[x]
+    case _: (_ *: xs1) if n > 0  => _index(erasedValue[xs1], n - 1)
+  }
+
+  private[scala] rewrite def _concat(xs: Tuple, ys: Tuple): Tuple = rewrite xs match {
+    case _: Unit => ys
+    case _: (x1 *: xs1) => _pair(erasedValue[x1], _concat(erasedValue[xs1], ys))
+  }
+
+  rewrite def fromArray[T <: Tuple](xs: Array[Object]): T =
+    rewrite _size(erasedValue[T]) match {
+      case 0  => ().asInstanceOf[T]
+      case 1  => Tuple1(xs(0)).asInstanceOf[T]
+      case 2  => Tuple2(xs(0), xs(1)).asInstanceOf[T]
+      case 3  => Tuple3(xs(0), xs(1), xs(2)).asInstanceOf[T]
+      case 4  => Tuple4(xs(0), xs(1), xs(2), xs(3)).asInstanceOf[T]
+      case 5  => Tuple5(xs(0), xs(1), xs(2), xs(3), xs(4)).asInstanceOf[T]
+      case 6  => Tuple6(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5)).asInstanceOf[T]
+      case 7  => Tuple7(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6)).asInstanceOf[T]
+      case 8  => Tuple8(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7)).asInstanceOf[T]
+      case 9  => Tuple9(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8)).asInstanceOf[T]
+      case 10 => Tuple10(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9)).asInstanceOf[T]
+      case 11 => Tuple11(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9), xs(10)).asInstanceOf[T]
+      case 12 => Tuple12(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9), xs(10), xs(11)).asInstanceOf[T]
+      case 13 => Tuple13(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9), xs(10), xs(11), xs(12)).asInstanceOf[T]
+      case 14 => Tuple14(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9), xs(10), xs(11), xs(12), xs(13)).asInstanceOf[T]
+      case 15 => Tuple15(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9), xs(10), xs(11), xs(12), xs(13), xs(14)).asInstanceOf[T]
+      case 16 => Tuple16(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9), xs(10), xs(11), xs(12), xs(13), xs(14), xs(15)).asInstanceOf[T]
+      case 17 => Tuple17(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9), xs(10), xs(11), xs(12), xs(13), xs(14), xs(15), xs(16)).asInstanceOf[T]
+      case 18 => Tuple18(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9), xs(10), xs(11), xs(12), xs(13), xs(14), xs(15), xs(16), xs(17)).asInstanceOf[T]
+      case 19 => Tuple19(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9), xs(10), xs(11), xs(12), xs(13), xs(14), xs(15), xs(16), xs(17), xs(18)).asInstanceOf[T]
+      case 20 => Tuple20(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9), xs(10), xs(11), xs(12), xs(13), xs(14), xs(15), xs(16), xs(17), xs(18), xs(19)).asInstanceOf[T]
+      case 21 => Tuple21(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9), xs(10), xs(11), xs(12), xs(13), xs(14), xs(15), xs(16), xs(17), xs(18), xs(19), xs(20)).asInstanceOf[T]
+      case 22 => Tuple22(xs(0), xs(1), xs(2), xs(3), xs(4), xs(5), xs(6), xs(7), xs(8), xs(9), xs(10), xs(11), xs(12), xs(13), xs(14), xs(15), xs(16), xs(17), xs(18), xs(19), xs(20), xs(21)).asInstanceOf[T]
+      case _ => TupleXXL(xs).asInstanceOf[T]
+    }
+}
+
+@showAsInfix
+sealed class *:[+H, +T <: Tuple] extends Tuple {
+  import Tuple._
+
+  rewrite def head: Any = {
+    erased val resTpe = Typed(_head(this))
+    val resVal = rewrite _size(this) match {
+      case 1 =>
+        val t = asInstanceOf[Tuple1[_]]
+        t._1
+      case 2 =>
+        val t = asInstanceOf[Tuple2[_, _]]
+        t._1
+      case 3 =>
+        val t = asInstanceOf[Tuple3[_, _, _]]
+        t._1
+      case 4 =>
+        val t = asInstanceOf[Tuple4[_, _, _, _]]
+        t._1
+      case n if n > 4 && n <= $MaxSpecialized =>
+        asInstanceOf[Product].productElement(0)
+      case n if n > $MaxSpecialized =>
+        val t = asInstanceOf[TupleXXL]
+        t.elems(0)
+    }
+    resVal.asInstanceOf[resTpe.Type]
+  }
+
+  rewrite def tail: Tuple = {
+    erased val resTpe = Typed(_tail(this))
+    rewrite _size(this) match {
+      case 1 =>
+        ()
+      case 2 =>
+        val t = asInstanceOf[Tuple2[_, _]]
+        Tuple1(t._2).asInstanceOf[resTpe.Type]
+      case 3 =>
+        val t = asInstanceOf[Tuple3[_, _, _]]
+        Tuple2(t._2, t._3).asInstanceOf[resTpe.Type]
+      case 4 =>
+        val t = asInstanceOf[Tuple4[_, _, _, _]]
+        Tuple3(t._2, t._3, t._4).asInstanceOf[resTpe.Type]
+      case 5 =>
+        val t = asInstanceOf[Tuple5[_, _, _, _, _]]
+        Tuple4(t._2, t._3, t._4, t._5).asInstanceOf[resTpe.Type]
+      case n if n > 5 =>
+        fromArray[resTpe.Type](toArray.tail)
+    }
+  }
+
+  rewrite def apply(n: Int): Any = {
+    erased val resTpe = Typed(_index(this, n))
+    rewrite _size(this) match {
+      case 1 =>
+        val t = asInstanceOf[Tuple1[_]]
+        rewrite n match {
+          case 0 => t._1.asInstanceOf[resTpe.Type]
+        }
+      case 2 =>
+        val t = asInstanceOf[Tuple2[_, _]]
+        rewrite n match {
+          case 0 => t._1.asInstanceOf[resTpe.Type]
+          case 1 => t._2.asInstanceOf[resTpe.Type]
+        }
+      case 3 =>
+        val t = asInstanceOf[Tuple3[_, _, _]]
+        rewrite n match {
+          case 0 => t._1.asInstanceOf[resTpe.Type]
+          case 1 => t._2.asInstanceOf[resTpe.Type]
+          case 2 => t._3.asInstanceOf[resTpe.Type]
+        }
+      case 4 =>
+        val t = asInstanceOf[Tuple4[_, _, _, _]]
+        rewrite n match {
+          case 0 => t._1.asInstanceOf[resTpe.Type]
+          case 1 => t._2.asInstanceOf[resTpe.Type]
+          case 2 => t._3.asInstanceOf[resTpe.Type]
+          case 3 => t._4.asInstanceOf[resTpe.Type]
+        }
+      case s if s > 4 && s <= $MaxSpecialized && n >= 0 && n < s =>
+        asInstanceOf[Product].productElement(n).asInstanceOf[resTpe.Type]
+      case s if s > $MaxSpecialized && n >= 0 && n < s =>
+        asInstanceOf[TupleXXL].elems(n).asInstanceOf[resTpe.Type]
+    }
+  }
+}
+
+object *: {
+  rewrite def unapply[H, T <: Tuple](x: H *: T) = (x.head, x.tail)
+}
diff --git a/library/src-scala3/scala/typelevel/package.scala b/library/src-scala3/scala/typelevel/package.scala
new file mode 100644
index 000000000000..17220ab3187c
--- /dev/null
+++ b/library/src-scala3/scala/typelevel/package.scala
@@ -0,0 +1,6 @@
+package scala
+
+package object typelevel {
+  erased def erasedValue[T]: T = ???
+  case class Typed[T](val value: T) { type Type = T }
+}
\ No newline at end of file
diff --git a/library/src/scala/TupleXXL.scala b/library/src/scala/TupleXXL.scala
new file mode 100644
index 000000000000..48a1410574f0
--- /dev/null
+++ b/library/src/scala/TupleXXL.scala
@@ -0,0 +1,17 @@
+package scala
+import java.util.Arrays.{deepEquals, deepHashCode}
+
+final class TupleXXL private (es: Array[Object]) {
+  override def toString = elems.mkString("(", ",", ")")
+  override def hashCode = getClass.hashCode * 41 + deepHashCode(elems)
+  override def equals(that: Any) = that match {
+    case that: TupleXXL => deepEquals(this.elems, that.elems)
+    case _ => false
+  }
+  def elems: Array[Object] = es
+}
+object TupleXXL {
+  def apply(elems: Array[Object]) = new TupleXXL(elems.clone)
+  def apply(elems: Any*) = new TupleXXL(elems.asInstanceOf[Seq[Object]].toArray)
+  def unapplySeq(x: TupleXXL): Option[Seq[Any]] = Some(x.elems.toSeq)
+}
diff --git a/library/src/scala/forceInline.scala b/library/src/scala/forceInline.scala
index 08eb0e59462a..577ec48606e6 100644
--- a/library/src/scala/forceInline.scala
+++ b/library/src/scala/forceInline.scala
@@ -1,6 +1,7 @@
 package scala
 
-/** An annotation on methods that is equivalent to Dotty `inline` modifier.
+/** An annotation on methods that is equivalent to Dotty `rewrite` modifier,
+ *  except that it does not imply `erased`.
  *
  *  The annotation should be used instead of the `inline` modifier in code
  *  that needs to cross compile between Scala 2 and Dotty.
diff --git a/project/Build.scala b/project/Build.scala
index 6e9deefbb3d0..60f909a826b7 100644
--- a/project/Build.scala
+++ b/project/Build.scala
@@ -749,7 +749,17 @@ object Build {
 
   // Settings shared between dotty-library and dotty-library-bootstrapped
   lazy val dottyLibrarySettings = Seq(
-      libraryDependencies += "org.scala-lang" % "scala-library" % scalacVersion
+    libraryDependencies += "org.scala-lang" % "scala-library" % scalacVersion,
+    // Add version-specific source directories:
+    // - files in src-scala3 will only be compiled by dotty
+    // - files in src-scala2 will only be compiled by scalac
+    unmanagedSourceDirectories in Compile += {
+      val baseDir = baseDirectory.value
+      if (isDotty.value)
+        baseDir / "src-scala3"
+      else
+        baseDir / "src-scala2"
+    }
   )
 
   lazy val `dotty-library` = project.in(file("library")).asDottyLibrary(NonBootstrapped)
diff --git a/tests/run/i4803d.check b/tests/disabled/run/i4803d.check
similarity index 100%
rename from tests/run/i4803d.check
rename to tests/disabled/run/i4803d.check
diff --git a/tests/run/i4803d/App_2.scala b/tests/disabled/run/i4803d/App_2.scala
similarity index 100%
rename from tests/run/i4803d/App_2.scala
rename to tests/disabled/run/i4803d/App_2.scala
diff --git a/tests/run/i4803d/Macro_1.scala b/tests/disabled/run/i4803d/Macro_1.scala
similarity index 100%
rename from tests/run/i4803d/Macro_1.scala
rename to tests/disabled/run/i4803d/Macro_1.scala
diff --git a/tests/neg/nested-rewrites.scala b/tests/neg/nested-rewrites.scala
new file mode 100644
index 000000000000..b8728b37dcde
--- /dev/null
+++ b/tests/neg/nested-rewrites.scala
@@ -0,0 +1,53 @@
+object Test {
+
+  rewrite def f1(x: Int) = {
+    rewrite def g(x: Int) = x // error: implementation restriction: nested rewrite methods are not supported
+    g(x)
+  }
+
+  rewrite def f2(x: Int) = {
+    object o {
+      rewrite def g(x: Int) = x // error: implementation restriction: nested rewrite methods are not supported
+    }
+    o.g(x)
+  }
+}
+object Test0 {
+
+  def f(x: Int) = {
+    rewrite def g(x: Int) = rewrite x match {
+      case 0 => 0
+    }
+    g(0)
+    transparent val Y = 0
+    g(Y)
+
+    rewrite def h(x: Int) = rewrite x match {
+      case Y => 0
+    }
+    h(0)
+  }
+
+  f(0)
+
+}
+
+object Test1 {
+
+  erased rewrite def f(x: Int) = {
+    erased rewrite def g(x: Int) = rewrite x match { // error: implementation restriction: nested rewrite methods are not supported
+      case 0 => 0
+    }
+    g(0)
+    transparent val Y = 0
+    g(Y)
+
+    rewrite def h(x: Int) = rewrite x match { // error: implementation restriction: nested rewrite methods are not supported
+      case Y => 0
+    }
+    h(0)
+  }
+
+  f(0)
+
+}
\ No newline at end of file
diff --git a/tests/neg/tuple-patterns.scala b/tests/neg/tuple-patterns.scala
new file mode 100644
index 000000000000..fd255d27714c
--- /dev/null
+++ b/tests/neg/tuple-patterns.scala
@@ -0,0 +1,8 @@
+object Test {
+  (1, 2) match {
+    case (1, x, 3) => println(x) // error: unreachable
+  }
+  "A" match {
+    case (1, 2, y) => println(y) // error: unreachable
+  }
+}
diff --git a/tests/neg/tuple-patterns2.scala b/tests/neg/tuple-patterns2.scala
new file mode 100644
index 000000000000..7c81d8a5e2e6
--- /dev/null
+++ b/tests/neg/tuple-patterns2.scala
@@ -0,0 +1,5 @@
+object Test {
+  (1, 2) match {
+    case x *: xs =>  // error: call to rewrite unapply
+  }
+}
diff --git a/tests/pos/transparent-nested.scala b/tests/pos/transparent-nested.scala
deleted file mode 100644
index 64446160f13c..000000000000
--- a/tests/pos/transparent-nested.scala
+++ /dev/null
@@ -1,39 +0,0 @@
-object Test0 {
-
-  def f(x: Int) = {
-    rewrite def g(x: Int) = rewrite x match {
-      case 0 => 0
-    }
-    g(0)
-    transparent val Y = 0
-    g(Y)
-
-    rewrite def h(x: Int) = rewrite x match {
-      case Y => 0
-    }
-    h(0)
-  }
-
-  f(0)
-
-}
-
-object Test1 {
-
-  erased rewrite def f(x: Int) = {
-    erased rewrite def g(x: Int) = rewrite x match {
-      case 0 => 0
-    }
-    g(0)
-    transparent val Y = 0
-    g(Y)
-
-    rewrite def h(x: Int) = rewrite x match {
-      case Y => 0
-    }
-    h(0)
-  }
-
-  f(0)
-
-}
\ No newline at end of file
diff --git a/tests/run/Tuple.scala b/tests/run/Tuple.scala
index 84a540b617e0..72e6f000286f 100644
--- a/tests/run/Tuple.scala
+++ b/tests/run/Tuple.scala
@@ -75,7 +75,6 @@ object Tuple {
   val e4c: Int = conc1(1)
   val e5c: Int = conc2(0)
   val e6c: Double = conc2(4)
-
 }
 
 object Test extends App
\ No newline at end of file
diff --git a/tests/run/tuple-patterns.check b/tests/run/tuple-patterns.check
new file mode 100644
index 000000000000..4aacb5183367
--- /dev/null
+++ b/tests/run/tuple-patterns.check
@@ -0,0 +1,9 @@
+2
+2
+3
+1
+10
+23
+1
+10
+23
diff --git a/tests/run/tuple-patterns.scala b/tests/run/tuple-patterns.scala
new file mode 100644
index 000000000000..2147fb6d7f44
--- /dev/null
+++ b/tests/run/tuple-patterns.scala
@@ -0,0 +1,40 @@
+object Test extends App {
+  (1, 2) match {
+    case (1, x) => println(x)
+  }
+  val x: Any = (1, 2)
+  x match {
+    case (1, x) => println(x)
+  }
+
+  //final class tuple2[+A, +B](_1: A, _2: B)
+
+  final class TupleXXL1 private (es: Array[Object]) {
+    override def toString = elems.mkString("(", ",", ")")
+    def elems: Array[Object] = es
+  }
+  object TupleXXL1 {
+    def apply(elems: Array[Object]) = new TupleXXL1(elems.clone)
+    def apply(elems: Any*) = new TupleXXL1(elems.asInstanceOf[Seq[Object]].toArray)
+    def unapplySeq(x: TupleXXL1): Option[Seq[Any]] = Some(x.elems.toSeq)
+  }
+
+  val x3 = TupleXXL1(1, 2, 3)
+  x3 match {
+    case TupleXXL1(x1, x2, x3) => println(x3)
+  }
+
+  val x23 = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23)
+  x23 match {
+    case (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23) =>
+      println(x1)
+      println(x10)
+      println(x23)
+  }
+  (x23: Any) match {
+    case (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23) =>
+      println(x1)
+      println(x10)
+      println(x23)
+  }
+}
diff --git a/tests/run/tuples1.check b/tests/run/tuples1.check
new file mode 100644
index 000000000000..db564031fb7e
--- /dev/null
+++ b/tests/run/tuples1.check
@@ -0,0 +1,39 @@
+()
+(1)
+(A,1)
+(2,A,1)
+(B,2,A,1)
+(3,B,2,A,1)
+(C,3,B,2,A,1)
+(4,C,3,B,2,A,1)
+(D,4,C,3,B,2,A,1)
+h1 = 1
+h2 = A
+h7 = 4
+h8 = D
+t1 = ()
+t2 = (1)
+t7 = (C,3,B,2,A,1)
+t8 = (4,C,3,B,2,A,1)
+a1_0 = 1
+a2_0 = A
+a3_1 = A
+a4_3 = 1
+a6_4 = A
+a8_0 = D
+c0_0 = ()
+c0_1 = (1)
+c1_0 = (1)
+c0_4 = (B,2,A,1)
+c4_0 = (B,2,A,1)
+c1_1 = (1,1)
+c1_8 = (1,D,4,C,3,B,2,A,1)
+c2_1 = (A,1,1)
+c2_2 = (A,1,A,1)
+c2_3 = (A,1,2,A,1)
+c3_3 = (2,A,1,2,A,1)
+(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23)
+276
+(A,1) -> A, (1)
+(A,1) -> A, 1, ()
+(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23) -> 1, 2, (3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23)
diff --git a/tests/run/tuples1.scala b/tests/run/tuples1.scala
new file mode 100644
index 000000000000..3ba09dd116fa
--- /dev/null
+++ b/tests/run/tuples1.scala
@@ -0,0 +1,75 @@
+object Test extends App {
+  val x0 = (); println(x0)
+  val x1 = 1 *: x0; println(x1)
+  val x2 = ("A", 1); println(x2)
+  val x3 = 2 *: x2; println(x3)
+  val x4 = "B" *: x3; println(x4)
+  val x5 = 3 *: x4; println(x5)
+  val x6 = "C" *: x5; println(x6)
+  val x7 = 4 *: x6; println(x7)
+  val x8 = "D" *: x7; println(x8)
+  val h1 = x1.head; val h1c: Int = h1; println(s"h1 = $h1")
+  val h2 = x2.head; val h2c: String = h2; println(s"h2 = $h2")
+  val h7 = x7.head; val h7c: Int = h7; println(s"h7 = $h7")
+  val h8 = x8.head; val h8c: String = h8; println(s"h8 = $h8")
+  val t1 = x1.tail; val t1c: Unit = t1; println(s"t1 = $t1")
+  val t2 = x2.tail; val t2c: Int *: Unit = t2; println(s"t2 = $t2")
+  val t7 = x7.tail; val t7c: String *: Int *: Unit = t7.tail.tail.tail.tail; println(s"t7 = $t7")
+  val t8 = x8.tail; val t8c: Int = t8(6); println(s"t8 = $t8")
+  val a1_0 = x1(0); val a1_0c: Int = a1_0; println(s"a1_0 = $a1_0")
+  val a2_0 = x2(0); val a2_0c: String = a2_0; println(s"a2_0 = $a2_0")
+  val a3_1 = x3(1); val a3_1c: String = a3_1; println(s"a3_1 = $a3_1")
+  val a4_3 = x4(3); val a4_3c: Int = a4_3; println(s"a4_3 = $a4_3")
+  val a6_4 = x6(4); val a6_4c: String = a6_4; println(s"a6_4 = $a6_4")
+  val a8_0 = x8(0); val a8_0c: String = a8_0; println(s"a8_0 = $a8_0")
+  val c0_0 = x0 ++ x0; val c0_0c: Unit = c0_0; println(s"c0_0 = $c0_0")
+  val c0_1 = x0 ++ x1; val c0_1c: Int *: Unit = c0_1c; println(s"c0_1 = $c0_1")
+  val c1_0 = x1 ++ x0; val c1_0c: Int *: Unit = c1_0c; println(s"c1_0 = $c1_0")
+  val c0_4 = x0 ++ x4; val c0_4c: String *: Int *: String *: Int *: Unit = c0_4; println(s"c0_4 = $c0_4")
+  val c4_0 = x4 ++ x0; val c4_0c: String *: Int *: String *: Int *: Unit = c4_0; println(s"c4_0 = $c4_0")
+  val c1_1 = x1 ++ x1; val c1_1c: Int *: Int *: Unit = c1_1; println(s"c1_1 = $c1_1")
+  val c1_8 = x1 ++ x8; val c1_8c: Int *: String *: Int *: String *: Int *: String *: Int *: String *: Int *: Unit = c1_8; println(s"c1_8 = $c1_8")
+  val c2_1 = x2 ++ x1; val c2_1c: String *: Int *: Int *: Unit = c2_1; println(s"c2_1 = $c2_1")
+  val c2_2 = x2 ++ x2; val c2_2c: String *: Int *: String *: Int *: Unit = c2_2; println(s"c2_2 = $c2_2")
+  val c2_3 = x2 ++ x3; val c2_3c: String *: Int *: Int *: String *: Int *: Unit = c2_3; println(s"c2_3 = $c2_3")
+  val c3_3 = x3 ++ x3; val c3_3c: Int *: String *: Int *: Int *: String *: Int *: Unit = c3_3; println(s"c3_3 = $c3_3")
+
+  val x23 = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23)
+  type T23 = (Int, Int, Int, Int, Int,
+              Int, Int, Int, Int, Int,
+              Int, Int, Int, Int, Int,
+              Int, Int, Int, Int, Int,
+              Int, Int, Int)
+  val x23c: T23 = x23
+  println(x23)
+  assert(x23(0) == 1)
+  assert(x23(22) == 23)
+
+  x23 match {
+    case (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23) =>
+      println(x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10 + x11 + x12 + x13 + x14 + x15 + x16 + x17 + x18 + x19 + x20 + x21 + x22 + x23)
+  }
+  rewrite def decompose1 = rewrite x2 match { case x *: xs => (x, xs) }
+  rewrite def decompose2 = rewrite x2 match { case x *: y *: xs => (x, y, xs) }
+  rewrite def decompose3 = rewrite x23 match { case x *: y *: xs => (x, y, xs) }
+
+  { val (x, xs) = decompose1
+    val xc: String = x
+    val xsc: Int *: Unit = xs
+    println(s"$x2 -> $x, $xs")
+  }
+
+  { val (x, y, xs) = decompose2
+    val xc: String = x
+    val yc: Int = y
+    val xsc: Unit = xs
+    println(s"$x2 -> $x, $y, $xs")
+  }
+
+  { val (x, y, xs) = decompose3
+    val xc: Int = x
+    val yc: Int = y
+    val xsc: Unit = xs
+    println(s"$x23 -> $x, $y, $xs")
+  }
+}
\ No newline at end of file