Fix scala#8530: Support inline unapply

Author: nicolasstucki

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

@@ -378,10 +378,16 @@ object PatternMatcher {
             // This plan will never execute because it'll be guarded by a `NonNullTest`.
             ResultPlan(tpd.Throw(tpd.nullLiteral))
           else {
-            val mt @ MethodType(_) = extractor.tpe.widen
-            var unapp = extractor.appliedTo(ref(scrutinee).ensureConforms(mt.paramInfos.head))
-            if (implicits.nonEmpty) unapp = unapp.appliedToArgs(implicits)
-            unapplyPlan(unapp, args)
+            extractor.tpe.widen match
+              case mt @ MethodType(_) =>
+                var unapp = extractor.appliedTo(ref(scrutinee).ensureConforms(mt.paramInfos.head))
+                if (implicits.nonEmpty) unapp = unapp.appliedToArgs(implicits)
+                unapplyPlan(unapp, args)
+              case app: AppliedType =>
+                // TODO optimize away the lambda
+                var unapp = extractor.select(nme.apply).appliedTo(ref(scrutinee).ensureConforms(app.argInfos.head))
+                if (implicits.nonEmpty) unapp = unapp.appliedToArgs(implicits)
+                unapplyPlan(unapp, args)
           }
           if (scrutinee.info.isNotNull || nonNull(scrutinee)) unappPlan
           else TestPlan(NonNullTest, scrutinee, tree.span, unappPlan)

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

@@ -1,5 +1,5 @@
 
 object Foo {
-  inline def unapply(x: Any): Boolean = ??? // error: Implementation restriction: inline unapply methods are not supported
+  inline def unapply(x: Any): Boolean = ???
   inline def unapplySeq(x: Any): Seq[Any] = ??? // error: Implementation restriction: inline unapplySeq methods are not supported
 }

tests/pos/i8530.scala

@@ -0,0 +1,24 @@
+
+
+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/run/i8530.check

@@ -0,0 +1,5 @@
+MyBoooleanUnapply
+2
+3
+(4,5)
+5

tests/run/i8530.scala

@@ -0,0 +1,35 @@
+
+
+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 + 1)
+
+object MyWhiteboxUnapply:
+  inline def unapply(x: Int) <: Option[Any] = Some(x)
+
+
+@main def Test =
+  1 match
+    case MyBoooleanUnapply() => println("MyBoooleanUnapply")
+
+  2 match
+    case MyOptionUnapply(y) => println(y)
+
+  3 match
+    case MyPolyUnapply(a) => println(a)
+
+  4 match
+    case MySeqUnapply(a, b) => println((a, b))
+
+  5 match
+    case MyWhiteboxUnapply(x) => println(x: Int)
+
+end Test