Polishings

Author: odersky

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

@@ -58,33 +58,38 @@ abstract class AccessProxies {
     def needsAccessor(sym: Symbol)(implicit ctx: Context): Boolean
 
     /** A fresh accessor symbol */
-    def newAccessorSymbol(owner: Symbol, name: TermName, info: Type, pos: Position)(implicit ctx: Context): TermSymbol = {
+    private def newAccessorSymbol(owner: Symbol, name: TermName, info: Type, pos: Position)(implicit ctx: Context): TermSymbol = {
       val sym = ctx.newSymbol(owner, name, Synthetic | Method, info, coord = pos).entered
       if (sym.allOverriddenSymbols.exists(!_.is(Deferred))) sym.setFlag(Override)
       sym
     }
 
+    /** An accessor symbol, create a fresh one unless one exists already */
+    private def accessorSymbol(owner: Symbol, accessorName: TermName, accessorInfo: Type, accessed: Symbol)(implicit ctx: Context) = {
+      def refersToAccessed(sym: Symbol) = accessedBy.get(sym) == Some(accessed)
+      owner.info.decl(accessorName).suchThat(refersToAccessed).symbol.orElse {
+        val acc = newAccessorSymbol(owner, accessorName, accessorInfo, accessed.pos)
+        accessedBy(acc) = accessed
+        acc
+      }
+    }
+
+    /** Rewire reference to refer to `accessor` symbol */
     private def rewire(reference: RefTree, accessor: Symbol)(implicit ctx: Context): Tree = {
       reference match {
         case Select(qual, _) => qual.select(accessor)
         case Ident(name) => ref(accessor)
       }
     }.withPos(reference.pos)
 
-    private def isAccessor(sym: Symbol, accessed: Symbol) = accessedBy.get(sym) == Some(accessed)
-
+    /** Given a reference to a getter accessor, the corresponding setter reference */
     def useSetter(getterRef: RefTree)(implicit ctx: Context): Tree = {
       val getter = getterRef.symbol
       val accessed = accessedBy(getter)
       val accessedName = accessed.name.asTermName
       val setterName = accessorNameKind(accessedName.setterName)
-      val setter =
-        getter.owner.info.decl(setterName).suchThat(isAccessor(_, accessed)).symbol.orElse {
-          val setterInfo = MethodType(getter.info.widenExpr :: Nil, defn.UnitType)
-          val setter = newAccessorSymbol(getter.owner, setterName, setterInfo, getter.pos)
-          accessedBy(setter) = accessed
-          setter
-        }
+      val setterInfo = MethodType(getter.info.widenExpr :: Nil, defn.UnitType)
+      val setter = accessorSymbol(getter.owner, setterName, setterInfo, accessed)
       rewire(getterRef, setter)
     }
 
@@ -94,12 +99,8 @@ abstract class AccessProxies {
       *  @param reference    The original reference to the non-public symbol
       *  @param onLHS        The reference is on the left-hand side of an assignment
       */
-    def useAccessor(reference: RefTree, onLHS: Boolean)(implicit ctx: Context): Tree = {
-      assert(!onLHS)
-
+    def useAccessor(reference: RefTree)(implicit ctx: Context): Tree = {
       val accessed = reference.symbol.asTerm
-
-
       var accessorClass = hostForAccessorOf(accessed: Symbol)
       if (!accessorClass.exists) {
         val curCls = ctx.owner.enclosingClass
@@ -108,23 +109,10 @@ abstract class AccessProxies {
           reference.pos)
         accessorClass = curCls
       }
-
-      val accessorName = accessorNameKind(
-        if (onLHS) accessed.name.setterName else accessed.name)
-
-
-      val accessor =
-        accessorClass.info.decl(accessorName).suchThat(isAccessor(_, accessed)).symbol.orElse {
-          val accessorRawInfo =
-            if (onLHS) MethodType(accessed.info :: Nil, defn.UnitType)
-            else accessed.info.ensureMethodic
-          val accessorInfo =
-            accessorRawInfo.asSeenFrom(accessorClass.thisType, accessed.owner)
-
-          val acc = newAccessorSymbol(accessorClass, accessorName, accessorInfo, accessed.pos)
-          accessedBy(acc) = accessed
-          acc
-        }
+      val accessorName = accessorNameKind(accessed.name)
+      val accessorInfo =
+        accessed.info.ensureMethodic.asSeenFrom(accessorClass.thisType, accessed.owner)
+      val accessor = accessorSymbol(accessorClass, accessorName, accessorInfo, accessed)
       rewire(reference, accessor)
     }
 
@@ -135,15 +123,16 @@ abstract class AccessProxies {
           ctx.error("Implementation restriction: cannot use private constructors in inline methods", tree.pos)
           tree // TODO: create a proper accessor for the private constructor
         }
-        else useAccessor(tree, onLHS = false)
-      case Assign(lhs: RefTree, rhs) if needsAccessor(lhs.symbol) =>
-        cpy.Apply(tree)(useAccessor(lhs, onLHS = true), List(rhs))
+        else useAccessor(tree)
       case _ =>
         tree
     }
   }
 }
 object AccessProxies {
+  /** Where an accessor for the `accessed` symbol should be placed.
+   *  This is the closest enclosing class that has `accessed` as a member.
+   */
   def hostForAccessorOf(accessed: Symbol)(implicit ctx: Context): Symbol =
     ctx.owner.ownersIterator.findSymbol(_.derivesFrom(accessed.owner))
 }