metadata constructors can now apply filters

Author: ghik

commons-macros/src/main/scala/com/avsystem/commons/macros/meta/AdtMetadataMacros.scala

@@ -158,6 +158,7 @@ class AdtMetadataMacros(ctx: blackbox.Context) extends AbstractMacroCommons(ctx)
 
     def tryMaterializeFor(adtSymbol: AdtSymbol): Res[Tree] =
       for {
+        _ <- matchFilters(adtSymbol)
         _ <- if (paramMdParams.isEmpty) Ok(()) else adtSymbol match {
           case _: AdtClass => Ok(())
           case _ => Fail(s"${adtSymbol.nameStr} is not a case class or case class like type")
@@ -212,13 +213,19 @@ class AdtMetadataMacros(ctx: blackbox.Context) extends AbstractMacroCommons(ctx)
     def allowListedMulti: Boolean = true
 
     val auxiliary: Boolean =
-      findAnnotation(symbol, AuxiliaryAT).nonEmpty
+      annot(AuxiliaryAT).nonEmpty
 
     private def metadataTree(adtParam: AdtParam, indexInRaw: Int): Option[Res[Tree]] =
       Some(MatchedAdtParam(adtParam, this, indexInRaw)).filter(m => matchFilters(m).isOk).map { matched =>
         val result = for {
           mdType <- actualMetadataType(arity.collectedType, adtParam.actualType, "parameter type", verbatim = false)
-          tree <- materializeOneOf(mdType)(t => new AdtParamMetadataConstructor(t, None).tryMaterializeFor(matched))
+          tree <- materializeOneOf(mdType) { t =>
+            val constructor = new AdtParamMetadataConstructor(t, None)
+            for {
+              _ <- constructor.matchFilters(matched)
+              tree <- constructor.tryMaterializeFor(matched)
+            } yield tree
+          }
         } yield tree
         result.mapFailure(msg => s"${adtParam.problemStr}: cannot map it to $shortDescription $pathStr: $msg")
       }

commons-macros/src/main/scala/com/avsystem/commons/macros/meta/MacroMetadatas.scala

@@ -82,17 +82,16 @@ trait MacroMetadatas extends MacroSymbols {
   }
 
   abstract class MetadataConstructor(val ownerType: Type, val atParam: Option[CompositeParam])
-    extends MacroMethod { this: MetadataConstructor =>
+    extends MacroMethod with FilteringSymbol {
 
     lazy val symbol: Symbol =
       primaryConstructor(ownerType, atParam)
 
-    lazy val allowIncomplete: Boolean =
-      findAnnotation(ownerType.typeSymbol, AllowIncompleteAT).nonEmpty
+    override def annotationSource: Symbol =
+      ownerType.typeSymbol
 
-    // fallback to annotations on the class itself
-    def annot(tpe: Type): Option[Annot] =
-      findAnnotation(symbol, tpe) orElse findAnnotation(ownerType.typeSymbol, tpe)
+    lazy val allowIncomplete: Boolean =
+      annot(AllowIncompleteAT).nonEmpty
 
     def shortDescription = "metadata class"
     def description = s"$shortDescription $ownerType"
@@ -163,7 +162,7 @@ trait MacroMetadatas extends MacroSymbols {
     def allowNamedMulti: Boolean = false
     def allowListedMulti: Boolean = false
 
-    val checked: Boolean = findAnnotation(symbol, CheckedAT).nonEmpty
+    val checked: Boolean = annot(CheckedAT).nonEmpty
 
     def tryMaterializeFor(matchedSymbol: MatchedSymbol): Res[Tree] =
       arity match {
@@ -206,7 +205,7 @@ trait MacroMetadatas extends MacroSymbols {
         case ParamArity.Optional(_) =>
           Ok(mkOptional(matchedSymbol.annot(annotTpe).map(validatedAnnotTree)))
         case ParamArity.Multi(_, _) =>
-          Ok(mkMulti(matchedSymbol.allAnnots(annotTpe).map(validatedAnnotTree)))
+          Ok(mkMulti(matchedSymbol.annots(annotTpe).map(validatedAnnotTree)))
       }
     }
   }
@@ -219,7 +218,7 @@ trait MacroMetadatas extends MacroSymbols {
     }
 
     def tryMaterializeFor(matchedSymbol: MatchedSymbol): Res[Tree] =
-      Ok(q"${matchedSymbol.allAnnots(annotTpe).nonEmpty}")
+      Ok(q"${matchedSymbol.annots(annotTpe).nonEmpty}")
   }
 
   class ReifiedNameParam(owner: MetadataConstructor, symbol: Symbol, useRawName: Boolean)

commons-macros/src/main/scala/com/avsystem/commons/macros/meta/MacroSymbols.scala

@@ -41,7 +41,7 @@ trait MacroSymbols extends MacroCommons {
   object ParamArity {
     def fromAnnotation(param: ArityParam, allowListedMulti: Boolean, allowNamedMulti: Boolean): ParamArity = {
 
-      val at = findAnnotation(param.symbol, RpcArityAT).fold(SingleArityAT)(_.tpe)
+      val at = param.annot(RpcArityAT).fold(SingleArityAT)(_.tpe)
       if (at <:< SingleArityAT) ParamArity.Single(param.actualType)
       else if (at <:< OptionalArityAT) {
         val optionLikeType = typeOfCachedImplicit(param.optionLike)
@@ -75,7 +75,7 @@ trait MacroSymbols extends MacroCommons {
   sealed abstract class MethodArity(val verbatimByDefault: Boolean) extends Arity
   object MethodArity {
     def fromAnnotation(method: MacroMethod): MethodArity = {
-      val at = findAnnotation(method.symbol, RpcArityAT).fold(SingleArityAT)(_.tpe)
+      val at = method.annot(RpcArityAT).fold(SingleArityAT)(_.tpe)
       if (at <:< SingleArityAT) Single
       else if (at <:< OptionalArityAT) Optional
       else if (at <:< MultiArityAT) Multi
@@ -89,6 +89,7 @@ trait MacroSymbols extends MacroCommons {
 
   abstract class MacroSymbol {
     def symbol: Symbol
+    def annotationSource: Symbol = symbol
     def pos: Position = symbol.pos
     def seenFrom: Type
     def shortDescription: String
@@ -98,14 +99,20 @@ trait MacroSymbols extends MacroCommons {
     def reportProblem(msg: String, detailPos: Position = NoPosition): Nothing =
       abortAt(s"$problemStr: $msg", if (detailPos != NoPosition) detailPos else pos)
 
+    def annot(tpe: Type, fallback: List[Tree] = Nil): Option[Annot] =
+      findAnnotation(annotationSource, tpe, seenFrom, withInherited = true, fallback)
+
+    def annots(tpe: Type, fallback: List[Tree] = Nil): List[Annot] =
+      allAnnotations(annotationSource, tpe, seenFrom, withInherited = true, fallback)
+
     def infer(tpt: Tree): TermName =
       infer(getType(tpt))
 
     def infer(tpe: Type, forSym: MacroSymbol = this, clue: String = ""): TermName =
       inferCachedImplicit(tpe, s"${forSym.problemStr}: $clue", forSym.pos)
 
     val name: TermName = symbol.name.toTermName
-    val safeName: TermName = c.freshName(symbol.name.toTermName)
+    val safeName: TermName = c.freshName(name)
     val nameStr: String = name.decodedName.toString
     val encodedNameStr: String = name.encodedName.toString
 
@@ -166,7 +173,7 @@ trait MacroSymbols extends MacroCommons {
 
   trait FilteringSymbol extends MacroSymbol {
     lazy val requiredAnnots: List[Type] =
-      allAnnotations(symbol, AnnotatedAT).map(_.tpe.dealias.typeArgs.head)
+      annots(AnnotatedAT).map(_.tpe.dealias.typeArgs.head)
 
     def matchFilters(realSymbol: MatchedSymbol): Res[Unit] =
       Res.traverse(requiredAnnots) { annotTpe =>
@@ -188,9 +195,6 @@ trait MacroSymbols extends MacroCommons {
     def baseTagTpe: Type
     def fallbackTag: FallbackTag
 
-    def annot(tpe: Type): Option[Annot] =
-      findAnnotation(symbol, tpe, seenFrom)
-
     def tagAnnot(tpe: Type): Option[Annot] =
       annot(tpe)
 
@@ -218,7 +222,7 @@ trait MacroSymbols extends MacroCommons {
 
     // returns fallback tag tree only IF it was necessary
     def matchTag(realSymbol: MacroSymbol): Res[FallbackTag] = {
-      val tagAnnot = findAnnotation(realSymbol.symbol, baseTagTpe, realSymbol.seenFrom)
+      val tagAnnot = realSymbol.annot(baseTagTpe)
       val fallbackTagUsed = if (tagAnnot.isEmpty) whenUntaggedTag orElse fallbackTag else FallbackTag.Empty
       val realTagTpe = tagAnnot.map(_.tpe).getOrElse(NoType) orElse fallbackTagUsed.annotTree.tpe orElse baseTagTpe
 
@@ -269,9 +273,10 @@ trait MacroSymbols extends MacroCommons {
     def fallbackTagUsed: FallbackTag = FallbackTag.Empty
 
     def annot(tpe: Type): Option[Annot] =
-      findAnnotation(real.symbol, tpe, real.seenFrom, fallback = fallbackTagUsed.asList)
-    def allAnnots(tpe: Type): List[Annot] =
-      allAnnotations(real.symbol, tpe, real.seenFrom, fallback = fallbackTagUsed.asList)
+      real.annot(tpe, fallbackTagUsed.asList)
+
+    def annots(tpe: Type): List[Annot] =
+      real.annots(tpe, fallbackTagUsed.asList)
   }
 
   trait SelfMatchedSymbol extends MacroSymbol with MatchedSymbol {

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

@@ -3,6 +3,7 @@ package macros.rpc
 
 import com.avsystem.commons.macros.AbstractMacroCommons
 import com.avsystem.commons.macros.meta.MacroSymbols
+import com.avsystem.commons.macros.misc.Res
 
 import scala.reflect.macros.blackbox
 
@@ -98,7 +99,13 @@ class RpcMacros(ctx: blackbox.Context) extends RpcMacroCommons(ctx)
     val realRpc = RealRpcTrait(weakTypeOf[Real].dealias)
     val metadataTpe = c.macroApplication.tpe.dealias
     val constructor = new RpcTraitMetadataConstructor(metadataTpe, None)
-    guardedMetadata(metadataTpe, realRpc.tpe)(
-      constructor.tryMaterializeFor(realRpc, constructor.methodMappings(realRpc)).getOrElse(abort))
+    
+    def materialize: Res[Tree] = for {
+      _ <- constructor.matchFilters(realRpc)
+      methodMappings = constructor.methodMappings(realRpc)
+      tree <- constructor.tryMaterializeFor(realRpc, methodMappings)
+    } yield tree
+
+    guardedMetadata(metadataTpe, realRpc.tpe)(materialize.getOrElse(abort))
   }
 }

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

@@ -33,6 +33,7 @@ trait RpcMetadatas extends MacroMetadatas { this: RpcMacroCommons with RpcSymbol
       tree <- materializeOneOf(mdType) { t =>
         val constructor = new MethodMetadataConstructor(t, this, None)
         for {
+          _ <- constructor.matchFilters(matchedMethod)
           paramMappings <- constructor.paramMappings(matchedMethod)
           tree <- constructor.tryMaterializeFor(matchedMethod, paramMappings)
         } yield tree
@@ -59,8 +60,13 @@ trait RpcMetadatas extends MacroMetadatas { this: RpcMacroCommons with RpcSymbol
       val realParam = matchedParam.real
       val result = for {
         mdType <- actualMetadataType(arity.collectedType, realParam.actualType, "parameter type", verbatim)
-        tree <- materializeOneOf(mdType)(t =>
-          new ParamMetadataConstructor(t, None, indexInRaw).tryMaterializeFor(matchedParam))
+        tree <- materializeOneOf(mdType) { t =>
+          val constructor = new ParamMetadataConstructor(t, None, indexInRaw)
+          for {
+            _ <- constructor.matchFilters(matchedParam)
+            tree <- constructor.tryMaterializeFor(matchedParam)
+          } yield tree
+        }
       } yield tree
       result.mapFailure(msg => s"${realParam.problemStr}: $cannotMapClue: $msg")
     }
@@ -89,9 +95,6 @@ trait RpcMetadatas extends MacroMetadatas { this: RpcMacroCommons with RpcSymbol
     def baseTagTpe: Type = NothingTpe
     def fallbackTag: FallbackTag = FallbackTag.Empty
 
-    override def annot(tpe: Type): Option[Annot] =
-      super[MetadataConstructor].annot(tpe)
-
     val (baseMethodTag, fallbackMethodTag) =
       annot(MethodTagAT).map(tagSpec).getOrElse((NothingTpe, FallbackTag.Empty))
     val (baseParamTag, fallbackParamTag) =
@@ -113,7 +116,10 @@ trait RpcMetadatas extends MacroMetadatas { this: RpcMacroCommons with RpcSymbol
       )(_.mappingFor(_)).groupBy(_.mdParam)
     }
 
-    def tryMaterializeFor(rpc: RealRpcTrait, methodMappings: Map[MethodMetadataParam, List[MethodMetadataMapping]]): Res[Tree] =
+    def tryMaterializeFor(
+      rpc: RealRpcTrait,
+      methodMappings: Map[MethodMetadataParam, List[MethodMetadataMapping]]
+    ): Res[Tree] =
       tryMaterialize(MatchedRpcTrait(rpc)) { case mmp: MethodMetadataParam =>
         val mappings = methodMappings.getOrElse(mmp, Nil)
         mmp.arity match {

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

@@ -15,7 +15,7 @@ trait RpcSymbols extends MacroSymbols { this: RpcMacroCommons =>
     def overloaded: Boolean
 
     val rawName: String = {
-      val prefixes = allAnnotations(real.symbol, RpcNamePrefixAT, fallback = fallbackTagUsed.asList)
+      val prefixes = real.annots(RpcNamePrefixAT, fallback = fallbackTagUsed.asList)
         .filter(a => overloaded || !a.findArg[Boolean](RpcNameOverloadedOnlyArg, false))
         .map(_.findArg[String](RpcNamePrefixArg))
       prefixes.mkString("", "", real.rpcName)
@@ -83,7 +83,7 @@ trait RpcSymbols extends MacroSymbols { this: RpcMacroCommons =>
 
   trait RealRpcSymbol extends MacroSymbol {
     val rpcName: String =
-      findAnnotation(symbol, RpcNameAT).fold(nameStr)(_.findArg[String](RpcNameArg))
+      annot(RpcNameAT).fold(nameStr)(_.findArg[String](RpcNameArg))
   }
 
   abstract class RpcTrait(val symbol: Symbol) extends MacroSymbol {
@@ -295,7 +295,7 @@ trait RpcSymbols extends MacroSymbols { this: RpcMacroCommons =>
       tpe.members.sorted.iterator.filter(m => m.isTerm && m.isAbstract).map(RawMethod(this, _)).toList
   }
 
-  case class RealRpcTrait(tpe: Type) extends RpcTrait(tpe.typeSymbol) with RealRpcSymbol {
+  case class RealRpcTrait(tpe: Type) extends RpcTrait(tpe.typeSymbol) with RealRpcSymbol with SelfMatchedSymbol {
     def shortDescription = "real RPC"
     def description = s"$shortDescription $tpe"