Scala宏中泛型类型的编译错误

Question

I am trying to write a macro that implicitly materializes Play Formatter instances when they are required:

class FormattableImpl(override val c: whitebox.Context) extends Utils(c) {
    import c.universe._

    def materializeFormatImpl[T : c.WeakTypeTag]: c.Expr[play.api.libs.json.Format[T]] = {
        val tpe = implicitly[c.WeakTypeTag[T]].tpe
        val x = c.Expr[play.api.libs.json.Format[T]](q" com.ubookr.macros.Json.format[$tpe] ")
        println(show(x))
        x
    }
}

object Format {
    implicit def materializeFormat[T]: play.api.libs.json.Format[T] = macro FormattableImpl.materializeFormatImpl[T]
}

This works just fine for non-parameterized types (eg.

case class Apple(id: Long, name: String)
val x = materializeFormat[Apple]

).

It also works for collections

val xx = materializeFormat[Seq[Apple]]

When I try to use it for my own parameterized type, however, it loses the value of the type parameter:

case class Proxy[+T](id: Long, name: String)
val xxx = materializeFormat[Proxy[Apple]]

which responds with

[error] package.scala:112: type mismatch;
[error]  found   : play.api.libs.json.OFormat[com.ubookr.macros.Proxy[Nothing]]
[error]  required: play.api.libs.json.Format[com.ubookr.macros.Proxy[Apple]]
[error] Note: com.ubookr.macros.Proxy[Nothing] <: com.ubookr.macros.Proxy[Apple], but trait Format is invariant in type A.
[error] You may wish to define A as +A instead. (SLS 4.5)
[error]     val xxx: Any = com.ubookr.macros.Format.materializeFormat[Proxy[Apple]]
[error]

This makes sense because WeakTypeTag doesn't know about T. My first question is why does this work correctly with Seq??

However, I came up with what I think should be a feasible workaround:

def materializeProxy[T]: play.api.libs.json.Format[Proxy[T] = macro FormattableImpl.materializeProxyImpl[T]

where the implementation of materializeProxyImpl is

def materializeProxyImpl[T : c.WeakTypeTag]: c.Expr[play.api.libs.json.Format[Proxy[T]]] = materializeFormatImpl[Proxy[T]]

the println in materializeFormatImpl now correctly shows the actual value of parameter type t:

Expr[play.api.libs.json.Format[com.ubookr.macros.Proxy[Apple]]](com.ubookr.macros.Json.format[com.ubookr.macros.Proxy[Apple]])

but I am still getting the same error immediately after:

[error] package.scala:112: type mismatch;
[error]  found   : play.api.libs.json.OFormat[com.ubookr.macros.Proxy[Nothing]]
[error]  required: play.api.libs.json.Format[com.ubookr.macros.Proxy[Apple]]
[error] Note: com.ubookr.macros.Proxy[Nothing] <: com.ubookr.macros.Proxy[Apple], but trait Format is invariant in type A.
[error] You may wish to define A as +A instead. (SLS 4.5)
[error]     val xxx: Any = Format.materializeProxy[Apple]
[error]

I have tried changing the type annotation on both materializeProxy and materializeProxyImpl to Any and Tree respectively, but the syntax error still occurs, which suggests to me that the type mismatch is happening somewhere internal to the macro engine.

Am I doing something wrong? Or is this a bug in the macro engine?

Answer 1

It seems that the play json macro implementation didn't expect generic case classes. It was outputting

(
     (JsPath \ "id").format[Long] and
     (JsPath \ "name").format[String]
)(Proxy.apply, unlift(Proxy.unapply)

I amended the play macro so that it outputs

(
     (JsPath \ "id").format[Long] and
     (JsPath \ "name").format[String]
)(Proxy.apply[Apple], unlift(Proxy.unapply[Apple])

and now it works as expected.