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,22 @@ class Typer extends Namer
             if (bounds != null) sym.info = bounds
           }
           b
+        case t: UnApply if t.symbol.is(Inline) =>
+          val sym = t.symbol
+          val cls = ctx.newNormalizedClassSymbol(ctx.owner, tpnme.ANON_CLASS, Synthetic | Final, List(defn.ObjectType), coord = t.span)
+          val constr = ctx.newConstructor(cls, Synthetic, Nil, Nil).entered
+          val unappplySym = ctx.newSymbol(cls, sym.name.toTermName, Synthetic | Method, sym.info).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)
+          assert(t.implicits.isEmpty)
+          cpy.UnApply(t)(newFun, t.implicits, t.patterns)
         case t => t
       }
   }

compiler/test/dotc/pos-test-pickling.blacklist

@@ -12,6 +12,7 @@ reference
 scala-days-2019-slides
 i7048e.scala
 i8052.scala
+i8530.scala
 
 # Stale symbol: package object scala
 seqtype-cycle

compiler/test/dotc/run-test-pickling.blacklist

@@ -23,6 +23,7 @@ t10889
 macros-in-same-project1
 i5257.scala
 i7868.scala
+i8530.scala
 enum-java
 zero-arity-case-class.scala
 tuple-ops.scala

tests/neg/inine-unnapply.scala

@@ -0,0 +1,22 @@
+object MyBoooleanUnapply:
+  inline def unapply(x: Int): Boolean = true
+
+object MyOptionUnapply:
+  inline def unapply(x: Int): 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 =
+  5 match
+    case MyBoooleanUnapply() =>
+    case MyOptionUnapply(y) => println(y)
+    case MyPolyUnapply(a) =>
+    case MySeqUnapply(a, b) =>
+    case MyWhiteboxUnapply(x) => x: Int

tests/pos/i8530.scala

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

tests/pos/inine-unnapply.scala

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

tests/run-macros/i8530-2.check

@@ -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/App_2.scala

@@ -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)}