super constructor implicitly materialized self-annotations

Author: ghik

commons-core/src/main/scala/com/avsystem/commons/misc/AnnotationOf.scala

@@ -15,3 +15,26 @@ case class AnnotationsOf[A, T](annots: List[A]) extends AnyVal
 object AnnotationsOf {
   implicit def materialize[A, T]: AnnotationsOf[A, T] = macro macros.misc.MiscMacros.annotationsOf[A, T]
 }
+
+final class HasAnnotation[A, T]
+object HasAnnotation {
+  private[this] val reusable = new HasAnnotation
+  def create[A, T]: HasAnnotation[A, T] = reusable.asInstanceOf
+
+  implicit def materialize[A, T]: AnnotationsOf[A, T] = macro macros.misc.MiscMacros.hasAnnotation[A, T]
+}
+
+case class SelfAnnotation[A](annot: A) extends AnyVal
+object SelfAnnotation {
+  implicit def materialize[A]: SelfAnnotation[A] = macro macros.misc.MiscMacros.selfAnnotation[A]
+}
+
+case class SelfOptAnnotation[A](annotOpt: Opt[A])
+object SelfOptAnnotationOf {
+  implicit def materialize[A]: SelfOptAnnotation[A] = macro macros.misc.MiscMacros.selfOptAnnotation[A]
+}
+
+case class SelfAnnotations[A](annots: List[A]) extends AnyVal
+object SelfAnnotations {
+  implicit def materialize[A]: SelfAnnotations[A] = macro macros.misc.MiscMacros.selfAnnotations[A]
+}

commons-core/src/test/scala/com/avsystem/commons/misc/AnnotationOfTest.scala

@@ -6,16 +6,25 @@ import org.scalatest.FunSuite
 
 import scala.annotation.StaticAnnotation
 
-class genann[T](val value: T) extends StaticAnnotation
-class genagg[T](value: T) extends AnnotationAggregate {
+case class genann[T](value: T) extends StaticAnnotation
+case class genagg[T](value: T) extends AnnotationAggregate {
   @genann(value) type Implied
 }
 
 @genagg(42)
 class Subject
 
+abstract class SelfAnnots(implicit val annots: SelfAnnotations[genann[_]])
+@genagg(42) @genann("fuu") class Klass extends SelfAnnots
+@genagg(42) @genann("fuu") object Objekt extends SelfAnnots
+
 class AnnotationOfTest extends FunSuite {
   test("aggregate with generic") {
     assert(AnnotationOf.materialize[genann[Int], Subject].annot.value == 42)
   }
+
+  test("self annotations") {
+    assert(new Klass().annots.annots == List(genann(42), genann("fuu")))
+    assert(Objekt.annots.annots == List(genann(42), genann("fuu")))
+  }
 }

commons-macros/src/main/scala/com/avsystem/commons/macros/MacroCommons.scala

@@ -346,7 +346,7 @@ trait MacroCommons { bundle =>
 
   def mkMacroGenerated(companionTpe: Type, tpe: Type, baseMaterialize: Tree): Tree = {
     def fail() =
-      abort(s"invocation of this macro is allowed only to be passed as super constructor parameter of an object")
+      abort(s"${c.macroApplication.symbol} can only be used in super constructor argument of an object")
 
     val ownerConstr = c.internal.enclosingOwner
     if (!ownerConstr.isConstructor) {

commons-macros/src/main/scala/com/avsystem/commons/macros/misc/MiscMacros.scala

@@ -482,11 +482,11 @@ class MiscMacros(ctx: blackbox.Context) extends AbstractMacroCommons(ctx) {
       """
   }
 
-  def assertLocal(tpe: Type): Type = {
-    if (tpe.typeSymbol.pos.source != c.enclosingPosition.source) {
-      abort(s"Macro inspection of $tpe can only be done in the same source file where that type is defined")
+  def assertLocal(sym: Symbol): Symbol = {
+    if (sym.pos.source != c.enclosingPosition.source) {
+      abort(s"Macro inspection of $sym can only be done in the same source file where it is defined")
     }
-    tpe
+    sym
   }
 
   def safeAnnotTree(annot: Annot): Tree = {
@@ -496,28 +496,77 @@ class MiscMacros(ctx: blackbox.Context) extends AbstractMacroCommons(ctx) {
     c.untypecheck(annot.tree)
   }
 
+  def classSymbol(sym: Symbol): ClassSymbol = {
+    if (sym.isClass) sym.asClass
+    else abort(s"$sym is not a class")
+  }
+
   def annotationOf[A: WeakTypeTag, T: WeakTypeTag]: Tree = instrument {
-    val atpe = weakTypeOf[A].dealias
-    val tpe = assertLocal(weakTypeOf[T].dealias)
-    val annot = findAnnotation(tpe.typeSymbol, atpe)
-      .getOrElse(abort(s"No annotation of type $atpe found on $tpe"))
+    val atpe = weakTypeOf[A]
+    val tpe = weakTypeOf[T]
+    val sym = assertLocal(classSymbol(tpe.dealias.typeSymbol))
+    val annot = findAnnotation(sym, atpe)
+      .getOrElse(abort(s"No annotation of type $atpe found on $sym"))
     q"$MiscPkg.AnnotationOf(${safeAnnotTree(annot)})"
   }
 
   def optAnnotationOf[A: WeakTypeTag, T: WeakTypeTag]: Tree = instrument {
-    val atpe = weakTypeOf[A].dealias
-    val tpe = assertLocal(weakTypeOf[T].dealias)
-    val annotTree = findAnnotation(tpe.typeSymbol, atpe)
+    val atpe = weakTypeOf[A]
+    val tpe = weakTypeOf[T]
+    val sym = assertLocal(classSymbol(tpe.dealias.typeSymbol))
+    val annotTree = findAnnotation(sym, atpe)
       .fold[Tree](q"$MiscPkg.Opt.Empty")(a => q"$MiscPkg.Opt(${safeAnnotTree(a)})")
     q"$MiscPkg.OptAnnotationOf($annotTree)"
   }
 
   def annotationsOf[A: WeakTypeTag, T: WeakTypeTag]: Tree = instrument {
-    val atpe = weakTypeOf[A].dealias
-    val tpe = assertLocal(weakTypeOf[T].dealias)
-    val annots = allAnnotations(tpe.typeSymbol, atpe).map(safeAnnotTree)
+    val atpe = weakTypeOf[A]
+    val tpe = weakTypeOf[T]
+    val sym = assertLocal(classSymbol(tpe.dealias.typeSymbol))
+    val annots = allAnnotations(sym, atpe).map(safeAnnotTree)
     q"$MiscPkg.AnnotationsOf($ListObj(..$annots))"
   }
+
+  def hasAnnotation[A: WeakTypeTag, T: WeakTypeTag]: Tree = instrument {
+    val atpe = weakTypeOf[A]
+    val tpe = weakTypeOf[T]
+    val sym = assertLocal(classSymbol(tpe.dealias.typeSymbol))
+    if (findAnnotation(sym, atpe).nonEmpty)
+      q"$MiscPkg.HasAnnotation.create[$atpe, $tpe]"
+    else
+      abort(s"No annotation of type $atpe found on $sym")
+  }
+
+  def classBeingConstructed: Symbol = {
+    val ownerConstr = c.internal.enclosingOwner
+    if (!ownerConstr.isConstructor) {
+      abort(s"${c.macroApplication.symbol} can only be used as super constructor argument")
+    }
+    classSymbol(ownerConstr.owner)
+  }
+
+  def selfAnnotation[A: WeakTypeTag]: Tree = instrument {
+    val atpe = weakTypeOf[A]
+    val sym = classBeingConstructed
+    val annot = findAnnotation(sym, atpe)
+      .getOrElse(abort(s"No annotation of type $atpe found on $sym"))
+    q"$MiscPkg.SelfAnnotation(${safeAnnotTree(annot)})"
+  }
+
+  def selfOptAnnotation[A: WeakTypeTag]: Tree = instrument {
+    val atpe = weakTypeOf[A]
+    val sym = classBeingConstructed
+    val annotTree = findAnnotation(sym, atpe)
+      .fold[Tree](q"$MiscPkg.Opt.Empty")(a => q"$MiscPkg.Opt(${safeAnnotTree(a)})")
+    q"$MiscPkg.SelfOptAnnotation($annotTree)"
+  }
+
+  def selfAnnotations[A: WeakTypeTag]: Tree = instrument {
+    val atpe = weakTypeOf[A]
+    val sym = classBeingConstructed
+    val annots = allAnnotations(sym, atpe).map(safeAnnotTree)
+    q"$MiscPkg.SelfAnnotations($ListObj(..$annots))"
+  }
 }
 
 class WhiteMiscMacros(ctx: whitebox.Context) extends AbstractMacroCommons(ctx) {