Scala编译时间宏，根据（父）类型过滤参数列表

Question

我有一个需要大量参数的方法/构造函数。 我当然可以使用scala宏提取表示这些参数类型的Tree。

但是我找不到如何将这棵树转换为“有用”的东西，即我可以得到它的父类型，检查它是否是原始类型，等等。

可以说我有一个具体的类型C ，如果要从C继承的所有参数或它们都是Seq[C]子类型。

对于一些上下文：

case cd@q"$mods class $tpname[..$tparams] $ctorMods(...$paramss) extends { ..$_ } with ..$_ { $self => ..$stats }" :: tail =>

    // extract everything that is subtype of C or Seq[C]
    val cs = paramss.head.map {
        case q"$mods val $name: $tpt = $default" => ???
    }

宏中的所有内容都应进行类型检查，对吗？ 那么$ tpt应该有一个“类型”吗？ 我如何获得它，我又能得到什么？

Answer 1

这是我确定类型是否从Iterable而不是从Map继承，以及类型是否从Map继承的方法

val iterableType = typeOf[Iterable[_]].typeSymbol
val mapType = typeOf[Map[_, _]].typeSymbol

def isIterable(tpe: Type): Boolean = tpe.baseClasses.contains(iterableType) && !isMap(tpe)
def isMap(tpe: Type): Boolean = tpe.baseClasses.contains(mapType)

我在例如类的主要构造函数中的字段上使用它：

// tpe is a Type
val fields = tpe.declarations.collectFirst {
  case m: MethodSymbol if m.isPrimaryConstructor => m
}.get.paramss.head

val iterableFields = fields.filter(f => isIterable(f.typeSignature))
val mapFields = fields.filter(f => isMap(f.typeSignature))

Answer 2

我没有在愤怒中使用它们，但是看起来您正在使用宏注释。

不，您会得到未键入的注释。

http://docs.scala-lang.org/overviews/macros/annotations.html

宏注释者是无类型的，因此我们可以更改其签名

给定客户：

package thingy

class C

@testThing class Thingy(val c: C, i: Int) { def j = 2*i }

object Test extends App {
  Console println Thingy(42).stuff
}

然后宏实现看到：

val t = (annottees map (c typecheck _.tree)) match {
  case q"$mods class $tpname[..$tparams] $ctorMods(...$paramss) extends { ..$_ } with ..$_ { $self => ..$stats }" :: _ =>
    val p @ q"$mods val $name: ${tpt: Type} = $default" = paramss.head.head
    Console println showRaw(tpt)
    Console println tpt.baseClasses
    toEmit
}

在对树进行显式类型检查并在提取中对类型进行注释的位置：

case q"val $name: ${tpt: Type} = ???" =>

我意识到我的annotee拼写与官方文档有所不同。 我只是不知道为什么它应该与奉献者有所不同。

这是玩具骨架代码，供其他初学者使用：

package thingy

import scala.annotation.StaticAnnotation
import scala.language.experimental.macros
import scala.reflect.macros.whitebox.Context

class testThing extends StaticAnnotation {
  def macroTransform(annottees: Any*): Any = macro testThing.impl
}

object testThing {
  def impl(c: Context)(annottees: c.Expr[Any]*): c.Expr[Any] = {
    import c.universe._
    val toEmit = q"""{
class Thingy(i: Int) {
  def stuff = println(i)
}

object Thingy {
  def apply(x: Int) = new Thingy(x)
}
()
}"""
    def dummy = Literal(Constant(()))
    //val t = (annottees map (_.tree)) match {
    val t = (annottees map (c typecheck _.tree)) match {
      case Nil =>
        c.abort(c.enclosingPosition, "No test target")
        dummy
      case q"$mods class $tpname[..$tparams] $ctorMods(...$paramss) extends { ..$_ } with ..$_ { $self => ..$stats }" :: _ =>
        //val p @ q"$mods val $name: $tpt = $default" = paramss.head.head
        val p @ q"$mods val $name: ${tpt: Type} = $default" = paramss.head.head
        Console println showRaw(tpt)
        Console println tpt.baseClasses
        toEmit
/*
      case (classDeclaration: ClassDef) :: Nil =>
        println("No companion provided")
        toEmit
      case (classDeclaration: ClassDef) :: (companionDeclaration: ModuleDef) :: Nil =>
        println("Companion provided")
        toEmit
*/
      case _ => c.abort(c.enclosingPosition, "Invalid test target")
        dummy
    }
    c.Expr[Any](t)
  }
}