added simple annotation filter to RPCs

Author: ghik

commons-annotations/src/main/scala/com/avsystem/commons/rpc/rpcAnnotations.scala

@@ -325,7 +325,7 @@ final class tried extends RawMethodAnnotation
   *
   * @tparam BaseTag base type for tags that can be used on real RPC methods
   * @param defaultTag default tag value assumed for untagged methods
-  */
+  **/
 final class methodTag[BaseTag <: RpcTag](val defaultTag: BaseTag = null) extends RawRpcAnnotation
 
 /**
@@ -383,6 +383,17 @@ final class paramTag[BaseTag <: RpcTag](val defaultTag: BaseTag = null) extends
 final class tagged[Tag <: RpcTag](val whenUntagged: Tag = null)
   extends RawMethodAnnotation with RawParamAnnotation
 
+/**
+  * Filter applied on raw methods or parameters which tells the macro engine that this raw method or parameter may
+  * only match real methods or parameters annotated with at least one annotation of given type `A` (or any subtype).
+  *
+  * This is similar to [[tagged]] but simplier. Tagging lets you explicitly specify all possible tag types and provide
+  * default/fallback tags when no tag is present.
+  *
+  * @tparam A type of annotation required to be present on real method or parameter
+  */
+final class annotated[A <: StaticAnnotation] extends RawRpcAnnotation
+
 /**
   * Raw parameters annotated as `@auxiliary` match real parameters without "consuming" them. This means that
   * real parameters matched by an auxiliary raw parameter must also be matched by some non-auxiliary raw parameter.

commons-core/src/test/scala/com/avsystem/commons/rpc/NewRawRpc.scala

@@ -22,6 +22,8 @@ case class renamed(int: Int, name: String) extends DummyParamTag {
 
 case class suchMeta(intMeta: Int, strMeta: String) extends StaticAnnotation
 
+class filter extends StaticAnnotation
+
 sealed trait RestMethod extends RpcTag
 case class POST() extends RestMethod with AnnotationAggregate {
   @rpcNamePrefix("POST_") type Implied
@@ -38,7 +40,7 @@ case class GetterInvocation(
 @methodTag[RestMethod]
 @paramTag[DummyParamTag]
 trait NewRawRpc {
-  def doSomething(arg: Double): String
+  @annotated[filter] def doSomething(@annotated[filter] arg: Double): String
   @optional def doSomethingElse(arg: Double): String
 
   @multi

commons-core/src/test/scala/com/avsystem/commons/rpc/NewRpcMetadataTest.scala

@@ -13,7 +13,7 @@ trait SomeBase {
 }
 
 trait TestApi extends SomeBase {
-  def doSomething(double: Double): String
+  @filter def doSomething(@filter double: Double): String
   def doSomethingElse(double: Double): String
   def varargsMethod(krap: String, dubl: Double)(czy: Boolean, @renamed(42, "nejm") ints: Int*): Future[Unit]
   def defaultValueMethod(@td int: Int = 0, @whenAbsent(difolt) bul: Boolean): Future[Unit]

commons-macros/src/main/scala/com/avsystem/commons/macros/rpc/RpcMacros.scala

@@ -44,6 +44,7 @@ abstract class RpcMacroCommons(ctx: blackbox.Context) extends AbstractMacroCommo
   val TaggedAT: Type = getType(tq"$RpcPackage.tagged[_]")
   val WhenUntaggedArg: Symbol = TaggedAT.member(TermName("whenUntagged"))
   val RpcTagAT: Type = getType(tq"$RpcPackage.RpcTag")
+  val AnnotatedAT: Type = getType(tq"$RpcPackage.annotated[_]")
   val RpcImplicitsSym: Symbol = getType(tq"$RpcPackage.RpcImplicitsProvider").member(TermName("implicits"))
   val TypedMetadataType: Type = getType(tq"$RpcPackage.TypedMetadata[_]")
   val MetadataParamStrategyType: Type = getType(tq"$RpcPackage.MetadataParamStrategy")

commons-macros/src/main/scala/com/avsystem/commons/macros/rpc/RpcMappings.scala

@@ -25,9 +25,10 @@ trait RpcMappings { this: RpcMacroCommons with RpcSymbols =>
             fallbackTag <- rawSymbol.matchTag(realMethod)
             matchedMethod = MatchedMethod(realMethod, fallbackTag)
             _ <- rawSymbol.matchName(matchedMethod)
+            _ <- rawSymbol.matchFilters(matchedMethod)
             methodMapping <- createMapping(rawSymbol, matchedMethod)
           } yield methodMapping
-          mappingRes match {
+          mappingRes.mapFailure(msg => s"${rawSymbol.shortDescription} ${rawSymbol.nameStr} did not match: $msg") match {
             case Ok(m) => Some(m)
             case f: Fail => findMethodMapping(f :: errorsAcc, rawSymbolsRest)
           }
@@ -73,12 +74,12 @@ trait RpcMappings { this: RpcMacroCommons with RpcSymbols =>
       def loop(): Res[B] =
         if (it.hasNext) {
           val real = it.next()
-          raw.matchTag(real) match {
-            case Ok(fallbackTag) =>
+          raw.matchRealParam(matchedMethod, real) match {
+            case Ok(matchedParam) =>
               if (!raw.auxiliary) {
                 it.remove()
               }
-              matcher(MatchedParam(real, fallbackTag, matchedMethod))
+              matcher(matchedParam)
             case Fail(_) => loop()
           }
         } else Fail(s"${raw.shortDescription} ${raw.pathStr} was not matched by real parameter")
@@ -90,9 +91,9 @@ trait RpcMappings { this: RpcMacroCommons with RpcSymbols =>
       def loop(): Option[B] =
         if (it.hasNext) {
           val real = it.next()
-          raw.matchTag(real) match {
-            case Ok(fallbackTag) =>
-              val res = matcher(MatchedParam(real, fallbackTag, matchedMethod)).toOption
+          raw.matchRealParam(matchedMethod, real) match {
+            case Ok(matchedParam) =>
+              val res = matcher(matchedParam).toOption
               if (!raw.auxiliary) {
                 res.foreach(_ => it.remove())
               }
@@ -108,12 +109,12 @@ trait RpcMappings { this: RpcMacroCommons with RpcSymbols =>
       def loop(result: ListBuffer[B]): Res[List[B]] =
         if (it.hasNext) {
           val real = it.next()
-          raw.matchTag(real) match {
-            case Ok(fallbackTag) =>
+          raw.matchRealParam(matchedMethod, real) match {
+            case Ok(matchedParam) =>
               if (!raw.auxiliary) {
                 it.remove()
               }
-              matcher(MatchedParam(real, fallbackTag, matchedMethod), result.size) match {
+              matcher(matchedParam, result.size) match {
                 case Ok(b) =>
                   result += b
                   loop(result)

commons-macros/src/main/scala/com/avsystem/commons/macros/rpc/RpcSymbols.scala

@@ -211,6 +211,15 @@ trait RpcSymbols { this: RpcMacroCommons =>
       if (realTagTpe <:< requiredTag) Ok(fallbackTagUsed)
       else Fail(s"it does not accept ${realRpcSymbol.shortDescription}s tagged with $realTagTpe")
     }
+
+    lazy val requiredAnnots: List[Type] =
+      allAnnotations(symbol, AnnotatedAT).map(_.tpe.dealias.typeArgs.head)
+
+    def matchFilters(realSymbol: MatchedRealSymbol[RealRpcSymbol]): Res[Unit] =
+      Res.traverse(requiredAnnots) { annotTpe =>
+        if (realSymbol.annot(annotTpe).nonEmpty) Ok(())
+        else Fail(s"no annotation of type $annotTpe found on ${realSymbol.real.shortDescription}")
+      }.map(_ => ())
   }
 
   sealed trait RealRpcSymbol extends RpcSymbol
@@ -321,6 +330,12 @@ trait RpcSymbols { this: RpcMacroCommons =>
       annot(AuxiliaryAT).nonEmpty
 
     def cannotMapClue: String
+
+    def matchRealParam(matchedMethod: MatchedMethod, realParam: RealParam): Res[MatchedParam] = for {
+      fallbackTag <- matchTag(realParam)
+      matchedParam = MatchedParam(realParam, fallbackTag, matchedMethod)
+      _ <- matchFilters(matchedParam)
+    } yield matchedParam
   }
 
   object RawParam {