Fix #8530: Support inline unapply

Author: nicolasstucki

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

@@ -241,8 +241,6 @@ object PrepareInlineable {
       ctx.error(em"Implementation restriction: No inline methods allowed where opaque type aliases are in scope", inlined.sourcePos)
     if (ctx.outer.inInlineMethod)
       ctx.error(ex"Implementation restriction: nested inline methods are not supported", inlined.sourcePos)
-    if (inlined.name.isUnapplyName)
-      ctx.error(em"Implementation restriction: inline ${inlined.name} methods are not supported", inlined.sourcePos)
 
     if (inlined.is(Macro) && !ctx.isAfterTyper) {
 

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

@@ -1255,6 +1255,24 @@ class Typer extends Namer
             if (bounds != null) sym.info = bounds
           }
           b
+        case t: UnApply if t.symbol.is(Inline) =>
+          // An inline unapply `P.unapply` in a plattern `P(x1,x2,...)` is transformed into
+          // `{ class $anon { def unapply(x1: T1, x2: T2, ...): R = P.unapply(x1, x2, ...) }; new $anon }.unapply`
+          // and the call `P.unapply(x1, x2, ...)` is inlined.
+          val sym = t.symbol
+          val cls = ctx.newNormalizedClassSymbol(ctx.owner, tpnme.ANON_CLASS, Synthetic | Final, List(defn.ObjectType), coord = sym.coord)
+          val constr = ctx.newConstructor(cls, Synthetic, Nil, Nil, coord = sym.coord).entered
+          val unappplySym = ctx.newSymbol(cls, sym.name.toTermName, Synthetic | Method, sym.info, coord = sym.coord).entered
+          val unapply = polyDefDef(unappplySym, targs => argss =>
+            Inliner.inlineCall(ref(sym).appliedToTypes(targs).appliedToArgss(argss).withSpan(t.span))
+          )
+          val cdef = ClassDef(cls, DefDef(constr), List(unapply))
+          val newUnapply = Block(cdef :: Nil, New(cls.typeRef, Nil))
+          val targs = t.fun match
+            case TypeApply(_, targs) => targs
+            case _ => Nil
+          val newFun = newUnapply.select(unappplySym).appliedToTypeTrees(targs).withSpan(t.span)
+          cpy.UnApply(t)(newFun, t.implicits, t.patterns)
         case t => t
       }
   }

tests/neg/inine-unnapply.scala

@@ -0,0 +1,26 @@
+object MyBoooleanUnapply:
+  inline def unapply(x: Int): Boolean = true
+
+object MyOptionUnapply:
+  inline def unapply(x: Int): Option[Long] = Some(x)
+
+object MyUnapplyImplicits:
+  inline def unapply(x: Int)(using DummyImplicit): Option[Long] = Some(x)
+
+object MyPolyUnapply:
+  inline def unapply[T](x: T): Option[T] = Some(x)
+
+object MySeqUnapply:
+  inline def unapplySeq(x: Int): Seq[Int] = Seq(x, x)
+
+object MyWhiteboxUnapply:
+  inline def unapply(x: Int) <: Option[Any] = Some(x)
+
+def test: Unit =
+  val x = 5 match
+    case MyBoooleanUnapply() =>
+    case MyOptionUnapply(y) => y: Long
+    case MyUnapplyImplicits(y) => y: Long
+    case MyPolyUnapply(a) => a: Int
+    case MySeqUnapply(a, b) => (a: Int, b: Int)
+    case MyWhiteboxUnapply(x) => x: Int

tests/neg/inline-unapply.scala

@@ -0,0 +1,5 @@
+
+object Foo {
+  inline def unapply(x: Any): Boolean = ???
+  inline def unapplySeq(x: Any): Seq[Any] = ???
+}

tests/pos/i8530.scala

@@ -0,0 +1,15 @@
+object Test {
+
+  class C(val x: Int, val y: Int)
+
+  inline def unapply(c: C): Some[(Int, Int)] = Some((c.x, c.y))
+
+}
+object Test2 {
+
+  class C(x: Int, y: Int)
+
+  inline def unapply(c: C): Option[(Int, Int)] = inline c match {
+    case x: C => Some((1, 1))
+  }
+}

tests/pos/inine-unnapply.scala

@@ -0,0 +1 @@
+foo

tests/pos/inline-unapply.scala

@@ -0,0 +1,12 @@
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    0 match
+      case Succ(n) => ???
+      case _ =>
+
+    2 match
+      case Succ(n) => assert(n == 1)
+  }
+
+}

tests/run-macros/i8530-2.check

@@ -0,0 +1,8 @@
+import scala.quoted._
+
+object Succ:
+
+  inline def unapply(n: Int): Option[Int] = ${ impl('n) }
+
+  private def impl(n: Expr[Int])(using QuoteContext): Expr[Option[Int]] =
+    '{ if $n == 0 then None else Some($n - 1)}