Extracting Type Parameters from Expressions

[Zeimyth]

I am attempting to process a varargs of expressions in a macro. The expressions all follow a very similar pattern--calling a function with a type parameter--and largely only differ meaningfully in the exact type parameter that they use. I want to process each expression individually in my macro, and I need to extract the type parameter in order to do this in a useful manner.

Given an expression such that expr.show results in:

MyObject.apply[StaticallyKnownType](parameterThatIsntOfThatType)(OtherObject.implicitWithTypeParameterThatMatchesStaticallyKnownType)

how do I extract StaticallyKnownType? Ideally, I would like to end up with a Type[StaticallyKnownType].

[nicolasstucki]

Could you provide a small self-contained example?

By Type[StaticallyKnownType] do you mean scala.quoted.Type[StaticallyKnownType]?

[Zeimyth]

It's tricky to share a very minimal example, because doing this only really makes sense with a lot of context, but here's a relatively small example.

Printer.scala:

case class Simple(a: Int)

object Simple {

  implicit val simplePrinter: PrinterFor[Simple] = PrinterMacro[Simple](PrinterLine[Int]("a"))
}

trait PrinterFor[T] {
  def print(data: T): String
}

object PrinterFor {

  implicit val intPrinter: PrinterFor[Int] = new PrinterFor[Int] {
    def print(data: Int): String = s"$data"
  }
}

object PrinterExample {

  def print[T : PrinterFor](data: T): String = summon[PrinterFor[T]].print(data)

  def main(args: Array[String]): Unit = {
    val simple = Simple(0)
    println(PrinterExample.print(simple))
  }
}

Macro.scala:

case class PrinterLine[T: PrinterFor](name: String)

object PrinterMacro {

  import scala.compiletime.*
  import scala.quoted.*

  inline def apply[T](inline lines: PrinterLine[?]*): PrinterFor[T] = ${ macroImpl('lines) }

  private[this] def macroImpl[T](lines: Expr[Seq[PrinterLine[?]]])(using t: Type[T])(using Quotes): Expr[PrinterFor[T]] = {
    import quotes.reflect.*

    val lineFuncExpr: Seq[Expr[T => String]] = Varargs.unapply(lines).map { lines =>
      lines.map { lineExpr =>
        // This is the part I can't figure out vvvvvvvvvvvvvvvvvvv
        lineExpr match {
          case '{
            type a
            PrinterLine.apply[a]($name: String)($printerFor: PrinterFor[a.Underlying]) } =>
              generatePrintExpr[a, T](Type.of[a], name, printerFor)
        }
        // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
      }
    }

    throw new Exception(s"(TODO) Varargs.unapply: ${lines.show}")
  }

  private[this] def generatePrintExpr[A, T](
    a: Type[A],
    name: Expr[String],
    printerFor: Expr[PrinterFor[A]]
  )(using t: Type[T]
  )(using _a: Type[A]
  )(using Quotes
  ): Expr[T => String] = {
    import quotes.reflect.*

    val dataTypeRepr: TypeRepr = TypeRepr.of[T]
    val dataCaseFields: List[Symbol] = dataTypeRepr.typeSymbol.caseFields
    val dataFieldOfName: Symbol = dataTypeRepr.typeSymbol.declaredField(name.valueOrError)

    val symbolOfName: Option[Symbol] = dataCaseFields.find(_ == dataFieldOfName)

    symbolOfName.map { symbol =>
      '{
        (data: T) => $name + ":" + PrinterExample.print[A](${'{data}.asTerm.select(symbol).asExprOf[A]})(using ${printerFor})
      }
    }.getOrElse {
      throw new Exception(s"Unable to find case class field ${name.valueOrError} on type $dataTypeRepr.show")
    }
  }
}

This doesn't compile right now because I still can't figure out the syntax to extract the type a. If I hard-code a to be Int in the macro, then things work perfectly. However, I want this macro to not need to have the type hard-coded. Furthermore, I want this macro to be flexible enough to work even when it is invoked like

object Simple {

  implicit val simplePrinter: PrinterFor[Simple] = PrinterMacro[Simple](
    PrinterLine[Int]("a"),
    PrinterLine[String]("b"),
    PrinterLine[Long]("c"),
  )
}

[nicolasstucki]

I'm missing the definition of the class Simple and PrinterLine.

It also seems that what you may need is

-            PrinterLine.apply[a]($name: String)($printerFor: PrinterFor[a.Underlying]) } =>
+            PrinterLine.apply[a]($name: String)($printerFor: PrinterFor[`a`]) } =>

[Zeimyth]

Oh, sorry! Apparently the markdown editor ate those two definitions because I put them on the same line as the opening triple-quotes. They're there now, both at the top of their respective files.

Changing a.Underlying to a in backticks doesn't immediately fix things:

[error] 19 |            PrinterLine.apply[a]($name: String)($printerFor: PrinterFor[`a`]) } =>
[error]    |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[error]    |                               Found:    PrinterFor[a]
[error]    |                               Required: PrinterFor[a$given1.Underlying]
[error] one error found

[Zeimyth]

@nicolasstucki Bumping this thread. I know you have been busy, but so far it seems like you might be the only one around who can help with this issue, and it is still blocking my upgrade to Scala 3. I wanted to make sure this hadn't been forgotten. :)

[nicolasstucki]

Looking at it again, it seems that I missed something. It should be

        // This is the part I can't figure out vvvvvvvvvvvvvvvvvvv
        lineExpr match {
          case '{
            type a
-            PrinterLine.apply[a]($name: String)($printerFor: PrinterFor[a.Underlying]) } =>
+            PrinterLine.apply[`a`]($name: String)($printerFor: PrinterFor[`a`]) } =>
              generatePrintExpr[a, T](Type.of[a], name, printerFor)
        }
        // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Furthermore it seems that it should be enough to do

  case '{ PrinterLine.apply[a]($name)($printerFor) } =>

Type inference should be able to set the correct types for name and printerFor.