Question

我正在尝试创建一个Scala宏，它定义一个Class参数，并根据作为参数提供的Class的实现来修改它所附加的类。

//Simple class with a few arguments
class A(a: String, b: String)

//Definition of this class should be modified based on class definition of A
@parameterized(classOf[A])
class B

我设法创建了一个能够从注释中提取参数的简单宏，从而生成一个TypeName对象，该对象包含完整类名的字符串表示。

现在的问题是我需要从宏实现中访问A的定义（具体来说，我想看看构造函数的参数是什么）。

有没有办法以某种方式访问/创建TypeTag [A]？有没有办法可以访问A类的AST？

为了说明我想要实现的目标，这就是我目前的宏定义：

object parameterizedMacro {
  def impl(c: Context)(annottees: c.Expr[Any]*): c.Expr[Any] = {
    import c.universe._
    import Flag._      

    //Extract the parameter type which was provided as an argument (rather hacky way of getting this info)
    val parameterType = c.macroApplication match {
      case Apply(Select(Apply(_, List(
          TypeApply(Ident(TermName("classOf")), List(Ident(TypeName(parameterType))))
      )) , _), _) => parameterType
      case _ =>
        sys.error("Could not match @parameterized arguments. Was a class provided?")
    }

   //Should generate method list based on the code of parameterType
   val methods = ???

   val result = {
      annottees.map(_.tree).toList match {
        case q"object $name extends ..$parents { ..$body }" :: Nil =>
          q"""
            object $name extends ..$parents {
              ..${methods}
              ..$body
             }
          """
        case q"class $name (..$args) extends ..$parents { ..$body }" :: Nil =>
           q"""
             class $name (..$args) extends ..$parents {
              ..${methods}
               ..$body
             }
          """
      }
    }

    c.Expr[Any](result)
  }
}

Answer 1

我花了很多试验和错误，因为我没有设法找到关于各种课程的大量文档，但我最终设法实现了我想要做的事情。

要获取参数，我最终必须将完全限定名称放在注释中而不是原始TypeOf[Name]。

@parameterized(the.fully.qualified.Name)

然后我可以使用

val parameterType = c.macroApplication match {
      case Apply(Select(Apply(_, List(
          parameterType 
      )) , _), _) => parameterType
      case _ =>
        error("Could not match @parameterized arguments. Was a class provided?")
    }
val fullClassName = parameterType.toString()

使用原始帖子中提到的TypeOf对我不起作用，因为我没有设法从TypeApply获得正确的完全限定名称。这并没有真正使整个事情变得不安全，因为在编译时检查了所有东西，但它确实看起来不像标准的Scala。

获得完全限定名后，我可以使用Universe的镜像（The documentation on mirrors helped here）来获取ClassSymbol，从中可以获取类构造函数参数：

val constructorArguments = {
  val clazz = c.mirror.staticClass(fullClassName)            //Get ClassSymbol
  val clazzInfo = clazz.info                                 //Turn ClassSymbol into Type
  val constructor = clazzInfo.member(termNames.CONSTRUCTOR)  //Get constructor member Symbol
  val constructorMethod = constructor.asMethod               //Turn into MethodSymbol
  val parametersList = constructorMethod.paramLists          //Finally extract list of parameters

  if (parametersList.size != 1)
    error("Expected only a single constructor in " + fullClassName)

  val parameters = parametersList.head

  for (parameter <- parameters) yield {
    val term = parameter.asTerm //parameter is a term
    (term.name.toString, term.typeSignature)
  }
}

从scala宏

1 个答案: