Use a map instead of an annotation to keep track of accessors

Reverted: New annotation on inline accessors
(reverted from commit 9cde3dd)

Also: Fix accessor definition to work for accesses to members of superclasses.

Author: odersky

compiler/src/dotty/tools/dotc/CompilationUnit.scala

@@ -1,10 +1,11 @@
 package dotty.tools
 package dotc
 
-import dotty.tools.dotc.core.Types.Type // Do not remove me #3383
+import core.Types.Type // Do not remove me #3383
 import util.SourceFile
 import ast.{tpd, untpd}
-import dotty.tools.dotc.ast.tpd.{ Tree, TreeTraverser }
+import tpd.{ Tree, TreeTraverser }
+import typer.Inliner.InlineAccessors
 import dotty.tools.dotc.core.Contexts.Context
 import dotty.tools.dotc.core.SymDenotations.ClassDenotation
 import dotty.tools.dotc.core.Symbols._
@@ -27,6 +28,9 @@ class CompilationUnit(val source: SourceFile) {
    *  is used in phase ReifyQuotes in order to avoid traversing a quote-less tree.
    */
   var containsQuotesOrSplices: Boolean = false
+
+  /** A structure containing a temporary map for generating inline accessors */
+  val inlineAccessors = new InlineAccessors
 }
 
 object CompilationUnit {

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

@@ -146,26 +146,11 @@ object Annotations {
     def deferredResolve(atp: Type, args: List[Tree])(implicit ctx: Context): Annotation =
       deferred(atp.classSymbol, implicit ctx => resolveConstructor(atp, args))
 
-    class TermRefAnnotExtractor(annotFn: Context => Symbol) {
+    def makeAlias(sym: TermSymbol)(implicit ctx: Context) =
+      apply(defn.AliasAnnot, List(
+        ref(TermRef(sym.owner.thisType, sym.name, sym))))
 
-      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 */
+    /** 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,8 +692,6 @@ 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.Alias(alias))
+              denot.addAnnotation(Annotation.makeAlias(alias))
             }
         }
         // println(s"unpickled ${denot.debugString}, info = ${denot.info}") !!! DEBUG

compiler/src/dotty/tools/dotc/transform/AccessProxies.scala

@@ -15,32 +15,36 @@ import ast.Trees._
 import util.Property
 import util.Positions.Position
 
+/** A utility class for generating access proxies. Currently used for
+ *  inline accessors and protected accessors.
+ */
 abstract class AccessProxies {
   import ast.tpd._
 
   def getterName: ClassifiedNameKind
   def setterName: ClassifiedNameKind
 
+  /** accessor -> accessed */
+  private val accessedBy = newMutableSymbolMap[Symbol]
+
   /** The accessor definitions that need to be added to class `cls`
-   *  As a side-effect, this method removes the `Accessed` annotations from
-   *  the accessor symbols. So a second call of the same method will yield the empty list.
+   *  As a side-effect, this method removes entries from the `accessedBy` map.
+   *  So a second call of the same method will yield the empty list.
    */
-  private def accessorDefs(cls: Symbol)(implicit ctx: Context): List[DefDef] =
-    for {
-      accessor <- cls.info.decls.filter(sym => sym.name.is(getterName) || sym.name.is(setterName))
-      Annotation.Accessed(accessed) <- accessor.getAnnotation(defn.AccessedAnnot)
-    }
-    yield polyDefDef(accessor.asTerm, tps => argss => {
-      accessor.removeAnnotation(defn.AccessedAnnot)
-      val rhs =
-        if (accessor.name.is(setterName) &&
-            argss.nonEmpty && argss.head.nonEmpty) // defensive conditions
-          ref(accessed).becomes(argss.head.head)
-        else
-          ref(accessed).appliedToTypes(tps).appliedToArgss(argss)
-      rhs.withPos(accessed.pos)
-    })
+  private def accessorDefs(cls: Symbol)(implicit ctx: Context): Iterator[DefDef] =
+    for (accessor <- cls.info.decls.iterator; accessed <- accessedBy.remove(accessor)) yield
+      polyDefDef(accessor.asTerm, tps => argss => {
+        val accessRef = ref(TermRef(cls.thisType, accessed))
+        val rhs =
+          if (accessor.name.is(setterName) &&
+              argss.nonEmpty && argss.head.nonEmpty) // defensive conditions
+            accessRef.becomes(argss.head.head)
+          else
+            accessRef.appliedToTypes(tps).appliedToArgss(argss)
+        rhs.withPos(accessed.pos)
+      })
 
+  /** Add all needed accessors to the `body` of class `cls` */
   def addAccessorDefs(cls: Symbol, body: List[Tree])(implicit ctx: Context): List[Tree] = {
     val accDefs = accessorDefs(cls)
     if (accDefs.isEmpty) body else body ++ accDefs
@@ -67,10 +71,7 @@ abstract class AccessProxies {
       def nameKind = if (onLHS) setterName else getterName
       val accessed = reference.symbol.asTerm
 
-      def refersToAccessed(sym: Symbol) = sym.getAnnotation(defn.AccessedAnnot) match {
-        case Some(Annotation.Accessed(sym)) => sym `eq` accessed
-        case _ => false
-      }
+      def refersToAccessed(sym: Symbol) = accessedBy.get(sym) == Some(accessed)
 
       val accessorInfo =
         if (onLHS) MethodType(accessed.info :: Nil, defn.UnitType)
@@ -80,7 +81,7 @@ abstract class AccessProxies {
         accessed.owner.info.decl(accessorName).suchThat(refersToAccessed).symbol
           .orElse {
             val acc = newAccessorSymbol(accessed, accessorName, accessorInfo)
-            acc.addAnnotation(Annotation.Accessed(accessed))
+            accessedBy(acc) = accessed
             acc
           }
 

compiler/src/dotty/tools/dotc/typer/Inliner.scala

@@ -31,7 +31,7 @@ import util.Positions.Position
 object Inliner {
   import tpd._
 
-  object InlineAccessors extends AccessProxies {
+  class InlineAccessors extends AccessProxies {
     def getterName = InlineGetterName
     def setterName = InlineSetterName
 
@@ -95,7 +95,7 @@ object Inliner {
           sym.updateAnnotation(LazyBodyAnnotation { _ =>
             implicit val ctx = inlineCtx
             val body = treeExpr(ctx)
-            if (ctx.reporter.hasErrors) body else InlineAccessors.makeInlineable(body)
+            if (ctx.reporter.hasErrors) body else ctx.compilationUnit.inlineAccessors.makeInlineable(body)
           })
         }
     }

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -1562,7 +1562,7 @@ class Typer extends Namer
   }
 
   protected def addAccessorDefs(cls: Symbol, body: List[Tree])(implicit ctx: Context): List[Tree] =
-    Inliner.InlineAccessors.addAccessorDefs(cls, body)
+    ctx.compilationUnit.inlineAccessors.addAccessorDefs(cls, body)
 
   /** Ensure that the first type in a list of parent types Ps points to a non-trait class.
    *  If that's not already the case, add one. The added class type CT is determined as follows.

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

@@ -0,0 +1,22 @@
+package P {
+  class C {
+    protected def f(): Int = 22
+  }
+}
+
+package Q {
+  class D extends P.C {
+    class Inner {
+      inline def g() = f()
+    }
+  }
+}
+
+object Test extends App {
+  import Q._
+
+  val d = new D
+  val i = new d.Inner
+  val x = i.g()
+  assert(x == 22)
+}