implement using fun.tpe

Author: gorilskij

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

@@ -207,36 +207,13 @@ object Inliner {
     val cls = newNormalizedClassSymbol(ctx.owner, tpnme.ANON_CLASS, Synthetic | Final, List(defn.ObjectType), coord = sym.coord)
     val constr = newConstructor(cls, Synthetic, Nil, Nil, coord = sym.coord).entered
 
-    val (targs1, targs2) = fun match
-      // extension [T] (x: X) def unapply[U](y: Y)
-      case TypeApply(Apply(TypeApply(_, targs1), _), targs2) => (targs1, targs2)
-      // def unapply[U](y: Y)
-      case TypeApply(_, targs) => (targs, Nil)
-      // extension [T] (x: X) def unapply(y: Y)
-      case Apply(TypeApply(_, targs1), _) => (targs1, Nil)
-      // def unapply(y: Y)
-      case _ => (Nil, Nil)
-
-    def extensionInfo(info: Type, targs: List[Tree]): Type =
-      info match
-        case MethodTpe(_, _, rt: PolyType) => rt.instantiate(targs.map(_.tpe))
-        case MethodTpe(_, _, rt) => rt
-        case info => info
-
-    val unapplyInfo = sym.info match
-      case pt: PolyType =>
-        val info = pt.instantiate(targs1.map(_.tpe))
-        if sym.flags.is(ExtensionMethod) then extensionInfo(info, targs2) else info
-      case info =>
-        if sym.flags.is(ExtensionMethod) then extensionInfo(info, targs1) else info
-
-    val unappplySym = newSymbol(cls, sym.name.toTermName, Synthetic | Method, unapplyInfo, coord = sym.coord).entered
-    val unapply = DefDef(unappplySym, argss =>
-      inlineCall(fun.appliedToArgss(argss).withSpan(unapp.span))(using ctx.withOwner(unappplySym))
+    val unapplySym = newSymbol(cls, sym.name.toTermName, Synthetic | Method, fun.tpe.widen, coord = sym.coord).entered
+    val unapply = DefDef(unapplySym, argss =>
+      inlineCall(fun.appliedToArgss(argss).withSpan(unapp.span))(using ctx.withOwner(unapplySym))
     )
     val cdef = ClassDef(cls, DefDef(constr), List(unapply))
     val newUnapply = Block(cdef :: Nil, New(cls.typeRef, Nil))
-    val newFun = newUnapply.select(unappplySym).withSpan(unapp.span)
+    val newFun = newUnapply.select(unapplySym).withSpan(unapp.span)
     cpy.UnApply(unapp)(newFun, implicits, patterns)
   }