TODO: makeNotPrivate in explicitOuter???

this messes with finding the setter for a getter in a trait,
as somehow the getter is made not-private, but not the setter...

we'll try another approach: link setters & getters symbolically
using the referenced field -- what could possibly go wrong?

Author: adriaanm

src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala

@@ -157,7 +157,7 @@ abstract class ExplicitOuter extends InfoTransform
         if (hasOuterField(clazz)) //2
           decls1 enter newOuterField(clazz)
       }
-      if (!clazz.isTrait && !parents.isEmpty) {
+      if (!clazz.isTrait && !parents.isEmpty) { // 4
         for (mc <- clazz.mixinClasses) {
           val mixinOuterAcc: Symbol = exitingExplicitOuter(outerAccessor(mc))
           if (mixinOuterAcc != NoSymbol) {
@@ -264,7 +264,12 @@ abstract class ExplicitOuter extends InfoTransform
     }
   }
 
-  /** <p>
+  /** TODO: Revise this.... We shouldn't use makeNotPrivate until all subsequent phases are able to resolve symbolically
+    * (e.g., if we name mangle a getter, we can no longer look up the setter unless its name is also name mangled)
+    * We also shouldn't be messing with privacy that's unrelated to outer accessors.
+    * Since traits are now compiled to java interfaces, protected has the same applicability as for classes.
+    *
+    * <p>
    *    The phase performs the following transformations on terms:
    *  </p>
    *  <ol>
@@ -411,8 +416,12 @@ abstract class ExplicitOuter extends InfoTransform
           else atPos(tree.pos)(outerPath(outerValue, currentClass.outerClass, sym)) // (5)
 
         case Select(qual, name) =>
-          // make not private symbol accessed from inner classes, as well as
+          // TODO: move this to the end of the pipeline, as it breaks member lookup
+          //       (e.g., getter <> setter correlation is by name, but we could use the referenced field for that...?)
+          //
+          // symbols accessed from inner classes, as well as
           // symbols accessed from @inline methods
+          // are made not-private (name mangling to emulate privacy)
           //
           // See SI-6552 for an example of why `sym.owner.enclMethod hasAnnotation ScalaInlineClass`
           // is not suitable; if we make a method-local class non-private, it mangles outer pointer names.
@@ -422,10 +431,12 @@ abstract class ExplicitOuter extends InfoTransform
           if ((currentClass != sym.owner || enclMethodIsInline) && !sym.isMethodWithExtension)
             sym.makeNotPrivate(sym.owner)
 
-          val qsym = qual.tpe.widen.typeSymbol
-          if (sym.isProtected && //(4)
-              (qsym.isTrait || !(qual.isInstanceOf[Super] || (qsym isSubClass currentClass))))
+          //(4)
+          if (sym.isProtected &&
+              !qual.isInstanceOf[Super] &&
+              !(qual.tpe.widen.typeSymbol isSubClass currentClass))
             sym setFlag notPROTECTED
+
           super.transform(tree)
 
         case Apply(sel @ Select(qual, nme.CONSTRUCTOR), args) if isInner(sel.symbol.owner) =>