Inline transparent implicit parameters when typing Unapply trees

We needed to delay the inlining of the transparent inline when typing
the unapply function application. We used the NoInline mode, but this
also stopped the inlining of the arguments of the unapply. To fix this
we introduce a new mode, NoInlineUnapply, which is used to delay only
the inlining of the unapply method and not the implicit arguments.

Fixes #19623

Author: nicolasstucki

compiler/src/dotty/tools/dotc/core/Mode.scala

@@ -122,6 +122,9 @@ object Mode {
 
   val PatternOrTypeBits: Mode = Pattern | Type
 
+  /** Skip inlining of unapply methods. */
+  val NoInlineUnapply: Mode = newMode(18, "NoInlineUnapply")
+
   /** We are elaborating the fully qualified name of a package clause.
    *  In this case, identifiers should never be imported.
    */

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

@@ -5,6 +5,7 @@ package inlines
 import ast.*, core.*
 import Flags.*, Symbols.*, Types.*, Decorators.*, Constants.*, Contexts.*
 import StdNames.{tpnme, nme}
+import NameOps.*
 import typer.*
 import NameKinds.BodyRetainerName
 import SymDenotations.SymDenotation
@@ -64,6 +65,7 @@ object Inlines:
       && !ctx.typer.hasInliningErrors
       && !ctx.base.stopInlining
       && !ctx.mode.is(Mode.NoInline)
+      && !(ctx.mode.is(Mode.NoInlineUnapply) && tree.symbol.name.isUnapplyName)
   }
 
   private def needsTransparentInlining(tree: Tree)(using Context): Boolean =

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

@@ -1492,7 +1492,7 @@ trait Applications extends Compatibility {
 
         val dummyArg = dummyTreeOfType(ownType)
         val (newUnapplyFn, unapplyApp) =
-          val unapplyAppCall = withMode(Mode.NoInline):
+          val unapplyAppCall = withMode(Mode.NoInlineUnapply):
             typedExpr(untpd.TypedSplice(Apply(unapplyFn, dummyArg :: Nil)))
           inlinedUnapplyFnAndApp(dummyArg, unapplyAppCall)