import scala.annotation.experimental

@main
@experimental
def main: Unit =
  val xs: List[String] =
    List("a", "b", "c")

  println(headOption(xs)) // headOption is a macro returning a polymorphic function

[error] -- Error: /Users/tomas/tmp/poly-fun-synth/use.scala:9:10 -----------------------
[error]  9 |  println(headOption(xs))
[error]    |          ^^^^^^^^^^
[error]    |`PolyFunction` marker trait is reserved for compiler generated refinements
[error]    |----------------------------------------------------------------------------
[error]    |Inline stack trace
[error]    |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
[error]    |This location contains code that was inlined from defns.scala:43
[error] 43 |    List(TypeTree.of[Object], TypeTree.of[PolyFunction])
[error]    |                                                       ^
[error]     ----------------------------------------------------------------------------
[error] one error found
[error] (Compile / compileIncremental) Compilation failed

import scala.annotation.experimental
import scala.quoted.*

/** Shorthand for `quotes.reflect`. */
private transparent inline def qr(using Quotes): quotes.reflect.type =
  quotes.reflect

// Not my actual use, as here the number and kinds of type args are statically known.
// But it does show my use of PolyFunction that stopped working.
@experimental
transparent inline def headOption: [A] => List[A] => Option[A] =
  ${ headOptionImpl }

@experimental
private def headOptionImpl(using Quotes): Expr[[A] => List[A] => Option[A]] =
  import quotes.reflect.*

  polyFun(
    tParamNames  = List("A"),
    tParamBounds = _ => List(TypeBounds.empty),
    vParamNames  = List("as"),
    vParamTypes  = tparams => List(TypeRepr.of[List].appliedTo(tparams.head)),
    returnType   = tparams => TypeRepr.of[Option].appliedTo(tparams.head),
    body         = (targs, args) => {
      val List(targ) = targs
      val List(as) = args
      Select.unique(as, "headOption")
    },
  ).asExprOf[[A] => List[A] => Option[A]]

@experimental
private def polyFun(using Quotes)(
  tParamNames: List[String],
  tParamBounds: qr.PolyType => List[qr.TypeBounds],
  vParamNames: List[String],
  vParamTypes: List[qr.TypeRepr] => List[qr.TypeRepr],
  returnType: List[qr.TypeRepr] => qr.TypeRepr,
  body: (List[qr.TypeRepr], List[qr.Term]) => qr.Term,
): qr.Term = {
  import qr.*

  val parents =
    List(TypeTree.of[Object], TypeTree.of[PolyFunction])

  val clsSym =
    Symbol.newClass(
      Symbol.spliceOwner,
      name = "$anon",
      parents = parents.map(_.tpe),
      decls = cls => List(
        Symbol.newMethod(
          cls,
          "apply",
          polyFunApplyMethodType(tParamNames, tParamBounds, vParamNames, vParamTypes, returnType),
        ),
      ),
      selfType = None,
    )

  val applySym =
    clsSym.declaredMethod("apply").head

  val applyDef =
    DefDef(
      applySym,
      argss => {
        val List(targs, args) = argss
        val typeArgs: List[TypeRepr] = targs.map(_.asInstanceOf[TypeTree].tpe)
        val valArgs: List[Term] = args.map(_.asExpr.asTerm)
        Some(body(typeArgs, valArgs))
      },
    )

  val clsDef = ClassDef(clsSym, parents, List(applyDef))
  val newCls = Apply(Select(New(TypeIdent(clsSym)), clsSym.primaryConstructor), args = Nil)

  Block(
    List(clsDef),
    newCls,
  )
}

private def polyFunApplyMethodType(using Quotes)(
  tParamNames: List[String],
  tParamBounds: qr.PolyType => List[qr.TypeBounds],
  vParamNames: List[String],
  vParamTypes: List[qr.TypeRepr] => List[qr.TypeRepr],
  returnType: List[qr.TypeRepr] => qr.TypeRepr,
): qr.PolyType = {
  import qr.*

  extension (pt: PolyType)
    def params(n: Int): List[TypeRepr] =
      List.range(0, n).map(pt.param(_))

  val nTypeParams = tParamNames.length

  PolyType(tParamNames)(
    tParamBounds,
    pt => MethodType(
      vParamNames,
    )(
      mt => vParamTypes(pt.params(nTypeParams)),
      mt => returnType(pt.params(nTypeParams)),
    ),
  )
}