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,7 +241,7 @@ 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)
+    if (inlined.name == nme.unapplySeq) // TODO support
       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,25 @@ class Typer extends Namer
             if (bounds != null) sym.info = bounds
           }
           b
+        case t: UnApply if t.symbol.is(Inline) =>
+          def inlinedFun(lamTpe: MethodType, unappRef: Tree) = {
+            def body(scrutinee: Tree): Tree =
+              val call = unappRef.appliedTo(scrutinee).withSpan(t.span)
+              Inliner.inlineCall(call)
+            val fun = tpd.Lambda(lamTpe, args => body(args.head)).withSpan(t.span)
+            assert(t.implicits.isEmpty)
+            cpy.UnApply(t)(fun, t.implicits, t.patterns)
+          }
+          t.symbol.info match
+            case mt: MethodType =>
+              inlinedFun(mt, ref(t.symbol))
+            case mt: PolyType =>
+              val TypeApply(_, targs) = t.fun
+              val lamTpe = mt.resultType.substParams(mt, targs.map(_.tpe)).asInstanceOf[MethodType]
+              inlinedFun(lamTpe, ref(t.symbol).appliedToTypeTrees(targs))
+            case _ =>
+              ctx.error(em"Could not inline $t", t.sourcePos)
+              t
         case t => t
       }
   }

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 MyOptionUnapply(y) => println(y)
+    case MyBoooleanUnapply() =>
+    case MyPolyUnapply(a) =>
+    // case MySeqUnapply(a, b) =>
+    case MyWhiteboxUnapply(x) => x: Int