Manually inline extension method

core-macros/src/main/scala/sbt/internal/util/appmacro/Cont.scala

@@ -255,7 +255,8 @@ trait Cont:
           inputBuf += Input(tpe, qual, replacement, freshName("q"))
           oldTree
         }
-      val tx = transformWrappers(expr.asTerm, record, Symbol.spliceOwner)
+      val inlined = inlineExtensionProxy(expr.asTerm)
+      val tx = transformWrappers(inlined, record, Symbol.spliceOwner)
       val tr = makeApp(inner(tx), inputBuf.toList)
       tr
 end Cont

core-macros/src/main/scala/sbt/internal/util/appmacro/ContextUtil.scala

@@ -4,6 +4,7 @@ import sbt.internal.util.Types.Id
 import scala.compiletime.summonInline
 import scala.quoted.*
 import scala.reflect.TypeTest
+import scala.collection.mutable
 
 trait ContextUtil[C <: Quotes & scala.Singleton](val qctx: C):
   import qctx.reflect.*
@@ -56,11 +57,40 @@ trait ContextUtil[C <: Quotes & scala.Singleton](val qctx: C):
       val qual: Term,
       val term: Term,
       val name: String
-  )
+  ):
+    override def toString: String =
+      s"Input($tpe, $qual, $term, $name)"
 
   trait TermTransform[F[_]]:
     def apply(in: Term): Term
   end TermTransform
 
   def idTransform[F[_]]: TermTransform[F] = in => in
+
+  /**
+   * {
+   *  val in$proxy264: sbt.Def.Initialize[sbt.Task[sbt.ForkOptions]] = sbt.Defaults.forkOptionsTask
+   *  (foo.bar[sbt.ForkOptions](in$proxy264): sbt.ForkOptions)
+   * }
+   *
+   * @param tree
+   * @return
+   */
+  def inlineExtensionProxy(tree: Term): Term =
+    val rhss: mutable.Map[String, Term] = mutable.Map.empty
+    object refTransformer extends TreeMap:
+      override def transformStatement(tree: Statement)(owner: Symbol): Statement =
+        tree match
+          case ValDef(name, tpe, Some(body)) if name.contains("$proxy") =>
+            rhss(name) = body
+            ValDef.copy(tree)(name, tpe, None)
+          case _ =>
+            super.transformStatement(tree)(owner)
+
+      override def transformTerm(tree: Term)(owner: Symbol): Term =
+        tree match
+          case Ident(name) if rhss.contains(name) => rhss(name)
+          case _                                  => super.transformTerm(tree)(owner)
+    end refTransformer
+    refTransformer.transformTerm(tree)(Symbol.spliceOwner)
 end ContextUtil