Scalameta:识别特定的注解

Question

我想使用scalameta注释宏在Scala中自动生成REST API模型。具体地说，给定：

@Resource case class User(
@get               id            : Int,
@get @post @patch  name          : String,
@get @post         email         : String,
                   registeredOn  : Long
)

我想生成：

object User {
  case class Get(id: Int, name: String, email: String)
  case class Post(name: String, email: String)
  case class Patch(name: Option[String])
}

trait UserRepo {
  def getAll: Seq[User.Get]
  def get(id: Int): User.Get
  def create(request: User.Post): User.Get
  def replace(id: Int, request: User.Put): User.Get
  def update(id: Int, request: User.Patch): User.Get
  def delete(id: Int): User.Get
}

我有一些东西在这里工作：https://github.com/pathikrit/metarest

具体来说，我就是这样做的：

import scala.collection.immutable.Seq
import scala.collection.mutable
import scala.annotation.{StaticAnnotation, compileTimeOnly}
import scala.meta._

class get extends StaticAnnotation
class put extends StaticAnnotation
class post extends StaticAnnotation
class patch extends StaticAnnotation

@compileTimeOnly("@metarest.Resource not expanded")
class Resource extends StaticAnnotation {
  inline def apply(defn: Any): Any = meta {
    val (cls: Defn.Class, companion: Defn.Object) = defn match {
      case Term.Block(Seq(cls: Defn.Class, companion: Defn.Object)) => (cls, companion)
      case cls: Defn.Class => (cls, q"object ${Term.Name(cls.name.value)} {}")
      case _ => abort("@metarest.Resource must annotate a class")
    }

    val paramsWithAnnotation = for {
      Term.Param(mods, name, decltype, default) <- cls.ctor.paramss.flatten
      seenMods = mutable.Set.empty[String]
      modifier <- mods if seenMods.add(modifier.toString)
      (tpe, defArg) <- modifier match {
        case mod"@get" | mod"@put" | mod"@post" => Some(decltype -> default)
        case mod"@patch" =>
          val optDeclType = decltype.collect({case tpe: Type => targ"Option[$tpe]"})
          val defaultArg = default match {
            case Some(term) => q"Some($term)"
            case None => q"None"
          }
          Some(optDeclType -> Some(defaultArg))
        case _ => None
      }
    } yield modifier -> Term.Param(Nil, name, tpe, defArg)

    val models = paramsWithAnnotation
      .groupBy(_._1.toString)
      .map({case (verb, pairs) =>
        val className = Type.Name(verb.stripPrefix("@").capitalize)
        val classParams = pairs.map(_._2)
        q"case class $className[..${cls.tparams}] (..$classParams)"
      })

    val newCompanion = companion.copy(
      templ = companion.templ.copy(stats = Some(
        companion.templ.stats.getOrElse(Nil) ++ models
      ))
    )

    Term.Block(Seq(cls, newCompanion))
  }
}

我对下面的代码片段不满意：

   modifier match {
     case mod"@get" | mod"@put" | mod"@post" => ...
     case mod"@patch" => ...
     case _ => None
   }

上面的代码对我拥有的注解进行“字符串”模式匹配。有没有什么办法可以重用我必须对这些进行模式匹配的确切注释：

class get extends StaticAnnotation
class put extends StaticAnnotation
class post extends StaticAnnotation
class patch extends StaticAnnotation

Answer 1

可以使用一个使用一些运行时反射的mod@get提取器来替换get()字符串类型的注释(在编译时)。此外，假设我们还希望允许用户使用@metarest.get或@_root_.metarest.get完全限定批注

下面的所有代码示例都假定为import scala.meta._。@get、@metarest.get和@_root_.metarest.get的树形结构是

@ mod"@get".structure
res4: String = """ Mod.Annot(Ctor.Ref.Name("get"))
"""
@ mod"@metarest.get".structure
res5: String = """
Mod.Annot(Ctor.Ref.Select(Term.Name("metarest"), Ctor.Ref.Name("get")))
"""
@ mod"@_root_.metarest.get".structure
res6: String = """
Mod.Annot(Ctor.Ref.Select(Term.Select(Term.Name("_root_"), Term.Name("metarest")), Ctor.Ref.Name("get")))
"""

选择器可以是Ctor.Ref.Select或Term.Select，名称可以是Term.Name或Ctor.Ref.Name。

让我们首先创建一个自定义选择器提取器

object Select {
  def unapply(tree: Tree): Option[(Term, Name)] = tree match {
    case Term.Select(a, b) => Some(a -> b)
    case Ctor.Ref.Select(a, b) => Some(a -> b)
    case _ => None
  }
}

然后创建一些辅助实用程序

object ParamAnnotation {
  /* isSuffix(c, a.b.c) // true
   * isSuffix(b.c, a.b.c) // true
   * isSuffix(a.b.c, a.b.c) // true
   * isSuffix(_root_.a.b.c, a.b.c) // true
   * isSuffix(d.c, a.b.c) // false
   */
  def isSuffix(maybeSuffix: Term, fullName: Term): Boolean =
    (maybeSuffix, fullName) match {
      case (a: Name, b: Name) => a.value == b.value
      case (Select(q"_root_", a), b: Name) => a.value == b.value
      case (a: Name, Select(_, b)) => a.value == b.value
      case (Select(aRest, a), Select(bRest, b)) =>
        a.value == b.value && isSuffix(aRest, bRest)
      case _ => false
    }

  // Returns true if `mod` matches the tree structure of `@T`
  def modMatchesType[T: ClassTag](mod: Mod): Boolean = mod match {
    case Mod.Annot(term: Term.Ref) =>
      isSuffix(term, termRefForType[T])
    case _ => false
  }

  // Parses `T.getClass.getName` into a Term.Ref
  // Uses runtime reflection, but this happens only at compile time.
  def termRefForType[T](implicit ev: ClassTag[T]): Term.Ref =
    ev.runtimeClass.getName.parse[Term].get.asInstanceOf[Term.Ref]
}

有了这个设置，我们就可以使用unapply布尔提取器向get定义添加一个配套对象

class get extends StaticAnnotation
object get {
  def unapply(mod: Mod): Boolean = ParamAnnotation.modMatchesType[get](mod)
}

对post和put执行相同的操作，现在我们可以编写

// before
case mod"@get" | mod"@put" | mod"@post" => Some(decltype -> default)
// after
case get() | put() | post() => Some(decltype -> default)

请注意，如果用户在导入时重命名(例如get )，则此方法仍然不起作用

import metarest.{get => GET}

如果注解不符合您的期望，我建议中止

// before
case _ => None
// after
case unexpected => abort("Unexpected modifier $unexpected. Expected one of: put, get post")

PS。object get { def unapply(mod: Mod): Boolean = ... }部件是一些@ParamAnnotation宏批注(例如@ParamAnnotion class get extends StaticAnnotation )可以生成的样板