编写模式匹配宏

Question

I need some help writing a macro that produces a pattern match.

This is as far as I got:

import scala.reflect.macros.Context
import language.experimental.macros

trait JsValue

object SealedTraitFormat {
  def writesImpl[A: c.WeakTypeTag](c: Context)(value: c.Expr[A]): c.Expr[JsValue] = {
    val aTpeW   = c.weakTypeOf[A]
    val aClazz  = aTpeW.typeSymbol.asClass
    require(aClazz.isSealed, s"Type $aTpeW is not sealed")
    val subs    = aClazz.knownDirectSubclasses
    require(subs.nonEmpty  , s"Type $aTpeW does not have known direct subclasses")
    import c.universe._

    val cases = subs.toList.map { sub =>
      val pat   = Bind(newTermName("x"), Typed(Ident("_"),
        c.reifyRuntimeClass(sub.asClass.toType)))
      val body  = Ident("???") // TODO
      CaseDef(pat, body)
    }
    val m = Match(value.tree, cases)
    c.Expr[JsValue](m)
  }
}
trait SealedTraitFormat[A] {
  def writes(value: A): JsValue = macro SealedTraitFormat.writesImpl[A]
}

Here is an example:

sealed trait Foo
case class Bar() extends Foo
case class Baz() extends Foo

object FooFmt extends SealedTraitFormat[Foo] {
  val test = writes(Bar())
}

The current error is:

[warn] .../FooTest.scala:8: fruitless type test: a value of type play.api.libs.json.Bar cannot also be a Class[play.api.libs.json.Bar]
[warn]   val test = writes(Bar())
[warn]                    ^
[error] .../FooTest.scala:8: pattern type is incompatible with expected type;
[error]  found   : Class[play.api.libs.json.Bar](classOf[play.api.libs.json.Bar])
[error]  required: play.api.libs.json.Bar
[error]   val test = writes(Bar())
[error]                    ^

(note that play.api.libs.json is my package, so that's correct). I'm not sure what to make of this error...

---

The expanded macro should look like this

def writes(value: Foo): JsValue = value match {
  case x: Bar => ???
  case x: Baz => ???
}

It appears to me, that it probably looks like case x: Class[Bar] => ??? now. So my guess is I need to use reifyType instead of reifyRuntimeClass . Basically, how do I get the tree from a Type ?

Answer 1

The following seems to work, or at least compile:

val cases = subs.toList.map { sub =>
  val pat   = Bind(newTermName("x"), Typed(Ident("_"), Ident(sub.asClass)))
  val body  = reify(???).tree  // TODO
  CaseDef(pat, body)
}