Properly refine type of inlined unapply pattern (#18292)

Fixes #17525

Author: nicolasstucki

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

@@ -4,7 +4,7 @@ package inlines
 
 import ast.*, core.*
 import Flags.*, Symbols.*, Types.*, Decorators.*, Constants.*, Contexts.*
-import StdNames.tpnme
+import StdNames.{tpnme, nme}
 import transform.SymUtils._
 import typer.*
 import NameKinds.BodyRetainerName
@@ -189,28 +189,33 @@ object Inlines:
  // transforms the patterns into terms, the `inlinePatterns` phase removes this anonymous class by β-reducing
  // the call to the `unapply`.
 
- val UnApply(fun, trailingImplicits, patterns) = unapp
-
- val sym = unapp.symbol
-
- var unapplySym1: Symbol = NoSymbol // created from within AnonClass() and used afterwards
+ val fun = unapp.fun
+ val sym = fun.symbol
 
  val newUnapply = AnonClass(ctx.owner, List(defn.ObjectType), sym.coord) { cls =>
  // `fun` is a partially applied method that contains all type applications of the method.
  // The methodic type `fun.tpe.widen` is the type of the function starting from the scrutinee argument
  // and its type parameters are instantiated.
- val unapplySym = newSymbol(cls, sym.name.toTermName, Synthetic | Method, fun.tpe.widen, coord = sym.coord).entered
- val unapply = DefDef(unapplySym.asTerm, argss =>
- val body = fun.appliedToArgss(argss).withSpan(unapp.span)
- if body.symbol.is(Transparent) then inlineCall(body)(using ctx.withOwner(unapplySym))
- else body
- )
- unapplySym1 = unapplySym
- List(unapply)
+ val unapplyInfo = fun.tpe.widen
+ val unapplySym = newSymbol(cls, sym.name.toTermName, Synthetic | Method, unapplyInfo, coord = sym.coord).entered
+
+ val unapply = DefDef(unapplySym.asTerm, argss => fun.appliedToArgss(argss).withSpan(unapp.span))
+
+ if sym.is(Transparent) then
+ // Inline the body and refine the type of the unapply method
+ val inlinedBody = inlineCall(unapply.rhs)(using ctx.withOwner(unapplySym))
+ val refinedResultType = inlinedBody.tpe.widen
+ def refinedResult(info: Type): Type = info match
+ case info: LambdaType => info.newLikeThis(info.paramNames, info.paramInfos, refinedResult(info.resultType))
+ case _ => refinedResultType
+ unapplySym.info = refinedResult(unapplyInfo)
+ List(cpy.DefDef(unapply)(tpt = TypeTree(refinedResultType), rhs = inlinedBody))
+ else
+ List(unapply)
  }
 
- val newFun = newUnapply.select(unapplySym1).withSpan(unapp.span)
- cpy.UnApply(unapp)(newFun, trailingImplicits, patterns)
+ val newFun = newUnapply.select(sym.name).withSpan(unapp.span)
+ cpy.UnApply(unapp)(fun = newFun)
  end inlinedUnapply
 
  /** For a retained inline method, another method that keeps track of

tests/pos/i17525.scala

@@ -0,0 +1,5 @@
+object Extract {
+ transparent inline def unapply(value: String): Option[Tuple] = Some((1, "two"))
+}
+def fail(): Unit = "" match { case Extract(a, b) => f(a, b) }
+def f(n: Int, s: String): Unit = ()