Support a limited form of rewrite unapplys

Currently only unapplys that return a tuple are supported.

Author: odersky

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.
    */

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

@@ -732,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
             }

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,13 @@ object PrepareInlineable {
     }
   }
 
+  def checkRewriteMethod(inlined: Symbol, body: Tree)(implicit ctx: Context) = {
+    if (inlined.name == nme.unapply && tupleArgs(body).isEmpty)
+      ctx.warning(
+        em"rewrite unapply method can be rewritten only if its tight 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:

library/src-scala3/scala/Tuple.scala

@@ -254,5 +254,5 @@ sealed class *:[+H, +T <: Tuple] extends Tuple {
 }
 
 object *: {
-  rewrite def unapply[H, T <: Tuple](x: H *: T) = Some((x.head, x.tail))
+  rewrite def unapply[H, T <: Tuple](x: H *: T) = (x.head, x.tail)
 }

tests/run/tuples1.check

@@ -32,5 +32,8 @@ 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)
-276
 (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)

tests/run/tuples1.scala

@@ -41,11 +41,35 @@ object Test extends App {
               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)
   }
-  println(x23)
-  assert(x23(0) == 1)
-  assert(x23(22) == 23)
-}
+  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")
+  }
+}