Fix inline of unapply nodes

Author: OlivierBlanvillain

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

@@ -955,9 +955,10 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
           }
         val dummyArg = dummyTreeOfType(ownType)
         val unapplyApp = typedExpr(untpd.TypedSplice(Apply(unapplyFn, dummyArg :: Nil)))
-        val unapplyImplicits = unapplyApp match {
+        def unapplyImplicits(unapp: Tree = unapplyApp): List[Tree] = unapp match {
           case Apply(Apply(unapply, `dummyArg` :: Nil), args2) => assert(args2.nonEmpty); args2
           case Apply(unapply, `dummyArg` :: Nil) => Nil
+          case Inlined(u, _, _) => unapplyImplicits(u)
         }
 
         var argTypes = unapplyArgs(unapplyApp.tpe, unapplyFn, args, tree.pos)
@@ -981,7 +982,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
             List.fill(argTypes.length - args.length)(WildcardType)
         }
         val unapplyPatterns = (bunchedArgs, argTypes).zipped map (typed(_, _))
-        val result = assignType(cpy.UnApply(tree)(unapplyFn, unapplyImplicits, unapplyPatterns), ownType)
+        val result = assignType(cpy.UnApply(tree)(unapplyFn, unapplyImplicits(), unapplyPatterns), ownType)
         unapp.println(s"unapply patterns = $unapplyPatterns")
         if ((ownType eq selType) || ownType.isError) result
         else tryWithClassTag(Typed(result, TypeTree(ownType)), selType)

tests/pos/inline-i1773.scala

@@ -0,0 +1,14 @@
+object Test {
+  implicit class Foo(sc: StringContext) {
+    object q {
+      inline def unapply(arg: Any): Option[(Any, Any)] =
+        Some((sc.parts(0), sc.parts(1)))
+    }
+  }
+
+  def main(args: Array[String]): Unit = {
+    val q"class $name extends $parent" = new Object
+    println(name)
+    println(parent)
+  }
+}

tests/pos/inline-t9232a.scala

@@ -0,0 +1,11 @@
+final class Foo(val value: Int)
+
+object Foo {
+  inline def unapply(foo: Foo): Some[Int] = Some(foo.value)
+}
+
+object Test {
+  def transformTree(f: Foo): Any = f match {
+    case Foo(_) => ???
+  }
+}

tests/pos/inline-t9232b.scala

@@ -0,0 +1,23 @@
+final class Foo(val value: Int)
+
+object Foo {
+  inline def unapplySeq(foo: Foo): Some[Seq[Int]] = Some(List(foo.value))
+}
+
+sealed trait Tree
+case class Node1(foo: Foo) extends Tree
+case class Node2() extends Tree
+
+object Test {
+  def transformTree(tree: Tree): Any = tree match {
+    case Node1(Foo(_: _*)) => ???
+  }
+
+  def transformTree2(tree: Tree): Any = tree match {
+    case Node1(Foo(1, _: _*)) => ???
+  }
+
+  def transformTree3(tree: Tree): Any = tree match {
+    case Node1(Foo(x, _: _*)) => ???
+  }
+}