New annotation on inline accessors

scala.annottation.internal.Accessed indicates which symbol is accessed by an inline
accessor.

Author: odersky

compiler/src/dotty/tools/dotc/core/Annotations.scala

@@ -146,11 +146,26 @@ object Annotations {
     def deferredResolve(atp: Type, args: List[Tree])(implicit ctx: Context): Annotation =
       deferred(atp.classSymbol, implicit ctx => resolveConstructor(atp, args))
 
-    def makeAlias(sym: TermSymbol)(implicit ctx: Context) =
-      apply(defn.AliasAnnot, List(
-        ref(TermRef(sym.owner.thisType, sym.name, sym))))
+    class TermRefAnnotExtractor(annotFn: Context => Symbol) {
 
-    /** Extractor for child annotations */
+      def apply(sym: TermSymbol)(implicit ctx: Context): Annotation =
+      	Annotation(annotFn(ctx).typeRef, List(ref(TermRef(sym.owner.thisType, sym.name, sym))))
+
+      def unapply(ann: Annotation)(implicit ctx: Context): Option[Symbol] =
+        if (ann.symbol == annotFn(ctx)) {
+          val ast.Trees.Apply(fn, arg :: Nil) = ann.tree
+          Some(arg.symbol)
+        }
+        else None
+    }
+
+    /** Extractor for "accessed" annotations */
+    object Accessed extends TermRefAnnotExtractor(implicit ctx => defn.AccessedAnnot)
+
+    /** Extractor for "aliased" annotations */
+    object Alias extends TermRefAnnotExtractor(implicit ctx => defn.AliasAnnot)
+
+    /** Extractor for "child" annotations */
     object Child {
 
       /** A deferred annotation to the result of a given child computation */

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -692,6 +692,8 @@ class Definitions {
   // Annotation classes
   lazy val AliasAnnotType = ctx.requiredClassRef("scala.annotation.internal.Alias")
   def AliasAnnot(implicit ctx: Context) = AliasAnnotType.symbol.asClass
+  lazy val AccessedAnnotType = ctx.requiredClassRef("scala.annotation.internal.Accessed")
+  def AccessedAnnot(implicit ctx: Context) = AccessedAnnotType.symbol.asClass
   lazy val AnnotationDefaultAnnotType = ctx.requiredClassRef("scala.annotation.internal.AnnotationDefault")
   def AnnotationDefaultAnnot(implicit ctx: Context) = AnnotationDefaultAnnotType.symbol.asClass
   lazy val BodyAnnotType = ctx.requiredClassRef("scala.annotation.internal.Body")

compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala

@@ -578,7 +578,7 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
                 }
               }
               val alias = readDisambiguatedSymbolRef(disambiguate).asTerm
-              denot.addAnnotation(Annotation.makeAlias(alias))
+              denot.addAnnotation(Annotation.Alias(alias))
             }
         }
         // println(s"unpickled ${denot.debugString}, info = ${denot.info}") !!! DEBUG

library/src/scala/annotation/internal/Accessed.scala

@@ -0,0 +1,8 @@
+package scala.annotation.internal
+
+import scala.annotation.Annotation
+
+/** An annotation to record the method accessed by an inline accessor.
+ *  @param aliased  A TermRef pointing to the accessed method
+ */
+class Accessed(aliased: Any) extends Annotation