Support inline unapply extension methods

Fixes the computation of the inline unapply temporary unanimous unapply placeholder.

Fixes #8577
Fixes #15188

Author: gorilskij

compiler/src/dotty/tools/dotc/inlines/Inlines.scala

@@ -199,14 +199,7 @@ object Inlines:
     var unapplySym1: Symbol = NoSymbol // created from within AnonClass() and used afterwards
 
     val newUnapply = AnonClass(ctx.owner, List(defn.ObjectType), sym.coord) { cls =>
-      val targs = fun match
-        case TypeApply(_, targs) => targs
-        case _ => Nil
-      val unapplyInfo = sym.info match
-        case info: PolyType => info.instantiate(targs.map(_.tpe))
-        case info => info
-
-      val unapplySym = newSymbol(cls, sym.name.toTermName, Synthetic | Method, unapplyInfo, coord = sym.coord).entered
+      val unapplySym = newSymbol(cls, sym.name.toTermName, Synthetic | Method, fun.tpe.widen, coord = sym.coord).entered
       val unapply = DefDef(unapplySym.asTerm, argss =>
         inlineCall(fun.appliedToArgss(argss).withSpan(unapp.span))(using ctx.withOwner(unapplySym))
       )

tests/pos-macros/i8577a/Macro_1.scala

@@ -0,0 +1,11 @@
+package i8577
+
+import scala.quoted._
+
+object Macro:
+  opaque type StrCtx = StringContext
+  def apply(ctx: StringContext): StrCtx = ctx
+  def unapply(ctx: StrCtx): Option[StringContext] = Some(ctx)
+
+def implUnapply(sc: Expr[Macro.StrCtx], input: Expr[Int])(using Quotes): Expr[Option[Seq[Int]]] =
+  '{ Some(Seq(${input})) }

tests/pos-macros/i8577a/Main_2.scala

@@ -0,0 +1,9 @@
+package i8577
+
+def main: Unit =
+  extension (ctx: StringContext) def mac: Macro.StrCtx = Macro(ctx)
+  extension (inline ctx: Macro.StrCtx) inline def unapplySeq(inline input: Int): Option[Seq[Int]] =
+    ${ implUnapply('ctx, 'input) }
+
+  val mac"$x" = 1
+  assert(x == 1)

tests/pos-macros/i8577b/Macro_1.scala

@@ -0,0 +1,11 @@
+package i8577
+
+import scala.quoted._
+
+object Macro:
+  opaque type StrCtx = StringContext
+  def apply(ctx: StringContext): StrCtx = ctx
+  def unapply(ctx: StrCtx): Option[StringContext] = Some(ctx)
+
+def implUnapply[U](sc: Expr[Macro.StrCtx], input: Expr[U])(using Type[U])(using Quotes): Expr[Option[Seq[U]]] =
+  '{ Some(Seq(${input})) }

tests/pos-macros/i8577b/Main_2.scala

@@ -0,0 +1,9 @@
+package i8577
+
+def main: Unit =
+  extension (ctx: StringContext) def mac: Macro.StrCtx = Macro(ctx)
+  extension (inline ctx: Macro.StrCtx) inline def unapplySeq[U](inline input: U): Option[Seq[U]] =
+    ${ implUnapply('ctx, 'input) }
+
+  val mac"$x" = 1
+  assert(x == 1)

tests/pos-macros/i8577c/Macro_1.scala

@@ -0,0 +1,11 @@
+package i8577
+
+import scala.quoted._
+
+object Macro:
+  opaque type StrCtx = StringContext
+  def apply(ctx: StringContext): StrCtx = ctx
+  def unapply(ctx: StrCtx): Option[StringContext] = Some(ctx)
+
+def implUnapply[T](sc: Expr[Macro.StrCtx], input: Expr[T])(using Type[T])(using Quotes): Expr[Option[Seq[T]]] =
+  '{ Some(Seq(${input})) }

tests/pos-macros/i8577c/Main_2.scala

@@ -0,0 +1,9 @@
+package i8577
+
+def main: Unit =
+  extension (ctx: StringContext) def mac: Macro.StrCtx = Macro(ctx)
+  extension [T] (inline ctx: Macro.StrCtx) inline def unapplySeq(inline input: T): Option[Seq[T]] =
+    ${ implUnapply('ctx, 'input) }
+
+  val mac"$x" = 1
+  assert(x == 1)

tests/pos-macros/i8577d/Macro_1.scala

@@ -0,0 +1,11 @@
+package i8577
+
+import scala.quoted._
+
+object Macro:
+  opaque type StrCtx = StringContext
+  def apply(ctx: StringContext): StrCtx = ctx
+  def unapply(ctx: StrCtx): Option[StringContext] = Some(ctx)
+
+def implUnapply[T](sc: Expr[Macro.StrCtx], input: Expr[T])(using Type[T])(using Quotes): Expr[Option[Seq[T]]] =
+  '{ Some(Seq(${input})) }

tests/pos-macros/i8577d/Main_2.scala

@@ -0,0 +1,9 @@
+package i8577
+
+def main: Unit =
+  extension (ctx: StringContext) def mac: Macro.StrCtx = Macro(ctx)
+  extension [T] (inline ctx: Macro.StrCtx) inline def unapplySeq[U](inline input: T): Option[Seq[T]] =
+    ${ implUnapply('ctx, 'input) }
+
+  val mac"$x" = 1
+  assert(x == 1)

tests/pos-macros/i8577e/Macro_1.scala

@@ -0,0 +1,11 @@
+package i8577
+
+import scala.quoted._
+
+object Macro:
+  opaque type StrCtx = StringContext
+  def apply(ctx: StringContext): StrCtx = ctx
+  def unapply(ctx: StrCtx): Option[StringContext] = Some(ctx)
+
+def implUnapply[T, U](sc: Expr[Macro.StrCtx], input: Expr[U])(using Type[U])(using Quotes): Expr[Option[Seq[U]]] =
+  '{ Some(Seq(${input})) }

tests/pos-macros/i8577e/Main_2.scala

@@ -0,0 +1,9 @@
+package i8577
+
+def main: Unit =
+  extension (ctx: StringContext) def mac: Macro.StrCtx = Macro(ctx)
+  extension [T] (inline ctx: Macro.StrCtx) inline def unapplySeq[U](inline input: U): Option[Seq[U]] =
+    ${ implUnapply('ctx, 'input) }
+
+  val mac"$x" = 1
+  assert(x == 1)

tests/pos-macros/i8577f/Macro_1.scala

@@ -0,0 +1,11 @@
+package i8577
+
+import scala.quoted._
+
+object Macro:
+  opaque type StrCtx = StringContext
+  def apply(ctx: StringContext): StrCtx = ctx
+  def unapply(ctx: StrCtx): Option[StringContext] = Some(ctx)
+
+def implUnapply[T, U](sc: Expr[Macro.StrCtx], input: Expr[(T, U)])(using Type[T], Type[U])(using Quotes): Expr[Option[Seq[(T, U)]]] =
+  '{ Some(Seq(${input})) }

tests/pos-macros/i8577f/Main_2.scala

@@ -0,0 +1,12 @@
+package i8577
+
+def main: Unit =
+  extension (ctx: StringContext) def mac: Macro.StrCtx = Macro(ctx)
+  extension [T] (inline ctx: Macro.StrCtx) inline def unapplySeq[U](inline input: (T, U)): Option[Seq[(T, U)]] =
+    ${ implUnapply('ctx, 'input) }
+
+  val mac"$x" = (1, 2)
+  assert(x == (1, 2))
+
+  val mac"$y" = (1, "a")
+  assert(y == (1, "a"))

tests/pos-macros/i8577g/Macro_1.scala

@@ -0,0 +1,11 @@
+package i8577
+
+import scala.quoted._
+
+object Macro:
+  opaque type StrCtx = StringContext
+  def apply(ctx: StringContext): StrCtx = ctx
+  def unapply(ctx: StrCtx): Option[StringContext] = Some(ctx)
+
+def implUnapply[T, U](sc: Expr[Macro.StrCtx], input: Expr[T | U])(using Type[T], Type[U])(using Quotes): Expr[Option[Seq[T | U]]] =
+  '{ Some(Seq(${input})) }

tests/pos-macros/i8577g/Main_2.scala

@@ -0,0 +1,9 @@
+package i8577
+
+def main: Unit =
+  extension (ctx: StringContext) def mac: Macro.StrCtx = Macro(ctx)
+  extension [T] (inline ctx: Macro.StrCtx) inline def unapplySeq[U](inline input: T | U): Option[Seq[T | U]] =
+    ${ implUnapply('ctx, 'input) }
+
+  val mac"$x" = 1
+  assert(x == 1)

tests/pos-macros/i8577h/Macro_1.scala

@@ -0,0 +1,11 @@
+package i8577
+
+import scala.quoted._
+
+object Macro:
+  opaque type StrCtx = StringContext
+  def apply(ctx: StringContext): StrCtx = ctx
+  def unapply(ctx: StrCtx): Option[StringContext] = Some(ctx)
+
+def implUnapply[T, U](sc: Expr[Macro.StrCtx], input: Expr[T | U])(using Type[T], Type[U])(using Quotes): Expr[Option[Seq[T | U]]] =
+  '{ Some(Seq(${input})) }

tests/pos-macros/i8577h/Main_2.scala

@@ -0,0 +1,9 @@
+package i8577
+
+def main: Unit =
+  extension (ctx: StringContext) def mac: Macro.StrCtx = Macro(ctx)
+  extension [T] (inline ctx: Macro.StrCtx) inline def unapplySeq[U](inline input: U | T): Option[Seq[T | U]] =
+    ${ implUnapply('ctx, 'input) }
+
+  val mac"$x" = 1
+  assert(x == 1)

tests/pos/i15188.scala

@@ -0,0 +1,9 @@
+object O
+
+extension [T] (ctx: O.type) inline def unapplySeq(input: T): Option[Seq[T]] = Some(Seq(input))
+
+@main
+def Main = {
+  val O(x) = 3
+  println(s"x: $x")
+}

tests/pos/i15188b.scala

@@ -0,0 +1,8 @@
+class C
+
+extension (ctx: C) inline def unapply(input: String): Option[String] = Some("hi")
+
+@main def run = {
+  val O = new C
+  val O(x) = "3"
+}

tests/run/i8577a.scala

@@ -0,0 +1,15 @@
+import scala.quoted._
+
+object Macro:
+  opaque type StrCtx = StringContext
+  def apply(ctx: StringContext): StrCtx = ctx
+  def unapply(ctx: StrCtx): Option[StringContext] = Some(ctx)
+
+extension (ctx: StringContext) def mac: Macro.StrCtx = Macro(ctx)
+extension (inline ctx: Macro.StrCtx) inline def unapplySeq(inline input: Int): Option[Seq[Int]] =
+  Some(Seq(input))
+
+@main def Test: Unit =
+  val mac"$x" = 1
+  val y: Int = x
+  assert(x == 1)

tests/run/i8577b.scala

@@ -0,0 +1,15 @@
+import scala.quoted._
+
+object Macro:
+  opaque type StrCtx = StringContext
+  def apply(ctx: StringContext): StrCtx = ctx
+  def unapply(ctx: StrCtx): Option[StringContext] = Some(ctx)
+
+extension (ctx: StringContext) def mac: Macro.StrCtx = Macro(ctx)
+extension (inline ctx: Macro.StrCtx) inline def unapplySeq[U](inline input: U): Option[Seq[U]] =
+  Some(Seq(input))
+
+@main def Test: Unit =
+  val mac"$x" = 1
+  val y: Int = x
+  assert(x == 1)

tests/run/i8577c.scala

@@ -0,0 +1,15 @@
+import scala.quoted._
+
+object Macro:
+  opaque type StrCtx = StringContext
+  def apply(ctx: StringContext): StrCtx = ctx
+  def unapply(ctx: StrCtx): Option[StringContext] = Some(ctx)
+
+extension (ctx: StringContext) def mac: Macro.StrCtx = Macro(ctx)
+extension [T] (inline ctx: Macro.StrCtx) inline def unapplySeq(inline input: T): Option[Seq[T]] =
+  Some(Seq(input))
+
+@main def Test: Unit =
+  val mac"$x" = 1
+  val y: Int = x
+  assert(x == 1)

tests/run/i8577d.scala

@@ -0,0 +1,15 @@
+import scala.quoted._
+
+object Macro:
+  opaque type StrCtx = StringContext
+  def apply(ctx: StringContext): StrCtx = ctx
+  def unapply(ctx: StrCtx): Option[StringContext] = Some(ctx)
+
+extension (ctx: StringContext) def mac: Macro.StrCtx = Macro(ctx)
+extension [T] (inline ctx: Macro.StrCtx) inline def unapplySeq[U](inline input: T): Option[Seq[T]] =
+  Some(Seq(input))
+
+@main def Test: Unit =
+  val mac"$x" = 1
+  val y: Int = x
+  assert(x == 1)

tests/run/i8577e.scala

@@ -0,0 +1,19 @@
+import scala.quoted._
+
+object Macro:
+  opaque type StrCtx = StringContext
+  def apply(ctx: StringContext): StrCtx = ctx
+  def unapply(ctx: StrCtx): Option[StringContext] = Some(ctx)
+
+extension (ctx: StringContext) def mac: Macro.StrCtx = Macro(ctx)
+extension [T] (inline ctx: Macro.StrCtx) inline def unapplySeq[U](inline input: (T, U)): Option[Seq[(T, U)]] =
+  Some(Seq(input))
+
+@main def Test: Unit =
+  val mac"$x" = (1, 2)
+  val x2: (Int, Int) = x
+  assert(x == (1, 2))
+
+  val mac"$y" = (1, "a")
+  val y2: (Int, String) = y
+  assert(y == (1, "a"))

tests/run/i8577f.scala

@@ -0,0 +1,15 @@
+import scala.quoted._
+
+object Macro:
+  opaque type StrCtx = StringContext
+  def apply(ctx: StringContext): StrCtx = ctx
+  def unapply(ctx: StrCtx): Option[StringContext] = Some(ctx)
+
+@main def Test: Unit =
+  extension (ctx: StringContext) def mac: Macro.StrCtx = Macro(ctx)
+  extension (inline ctx: Macro.StrCtx) inline def unapplySeq[U](inline input: U): Option[Seq[U]] =
+    Some(Seq(input))
+
+  val mac"$x" = 1
+  val y: Int = x
+  assert(x == 1)

tests/run/i8577g.scala

@@ -0,0 +1,15 @@
+import scala.quoted._
+
+object Macro:
+  opaque type StrCtx = StringContext
+  def apply(ctx: StringContext): StrCtx = ctx
+  def unapply(ctx: StrCtx): Option[StringContext] = Some(ctx)
+
+extension (ctx: StringContext) def mac: Macro.StrCtx = Macro(ctx)
+extension [T] (inline ctx: Macro.StrCtx) inline def unapplySeq[U](inline input: T | U): Option[Seq[T | U]] =
+  Some(Seq(input))
+
+@main def Test: Unit =
+  val mac"$x" = 1
+  val y: Int = x
+  assert(x == 1)

tests/run/i8577h.scala

@@ -0,0 +1,15 @@
+import scala.quoted._
+
+object Macro:
+  opaque type StrCtx = StringContext
+  def apply(ctx: StringContext): StrCtx = ctx
+  def unapply(ctx: StrCtx): Option[StringContext] = Some(ctx)
+
+extension (ctx: StringContext) def mac: Macro.StrCtx = Macro(ctx)
+extension [T] (inline ctx: Macro.StrCtx) inline def unapplySeq[U](inline input: U | T): Option[Seq[T | U]] =
+  Some(Seq(input))
+
+@main def Test: Unit =
+  val mac"$x" = 1
+  val y: Int = x
+  assert(x == 1)

tests/run/i8577i.scala

@@ -0,0 +1,16 @@
+import scala.quoted._
+
+object Macro:
+  opaque type StrCtx = StringContext
+  def apply(ctx: StringContext): StrCtx = ctx
+  def unapply(ctx: StrCtx): Option[StringContext] = Some(ctx)
+
+extension (ctx: StringContext) def mac: Macro.StrCtx = Macro(ctx)
+extension (inline ctx: Macro.StrCtx) transparent inline def unapplySeq(inline input: String): Option[Seq[Any]] =
+  Some(Seq(123))
+
+@main def Test: Unit =
+  "abc" match
+    case mac"$x" =>
+      val y: Int = x
+      assert(x == 123)