1 files changed, 29 insertions, 30 deletions
diff --git a/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala b/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala
index f4f089931e..717b4e672e 100644
--- a/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala
@@ -29,6 +29,7 @@ abstract class SuperAccessors extends transform.Transform with transform.TypingT
     IntClass, UnitClass, ByNameParamClass, Any_asInstanceOf,
     Any_isInstanceOf, Object_isInstanceOf, Object_##, Object_==, Object_!=
   }
+  import analyzer.{ restrictionError }
 
   /** the following two members override abstract members in Transform */
   val phaseName: String = "superaccessors"
@@ -419,37 +420,35 @@ abstract class SuperAccessors extends transform.Transform with transform.TypingT
      * classes, this has to be signaled as error.
      */
     private def needsProtectedAccessor(sym: Symbol, pos: Position): Boolean = {
-      def errorRestriction(msg: String) {
-        unit.error(pos, "Implementation restriction: " + msg)
+      val clazz = currentOwner.enclClass
+      def accessibleThroughSubclassing =
+        validCurrentOwner && clazz.thisSym.isSubClass(sym.owner) && !clazz.isTrait
+
+      val isCandidate = (
+           sym.isProtected
+        && sym.isJavaDefined
+        && !sym.definedInPackage
+        && !accessibleThroughSubclassing
+        && (sym.owner.enclosingPackageClass != currentOwner.enclosingPackageClass)
+        && (sym.owner.enclosingPackageClass == sym.accessBoundary(sym.owner).enclosingPackageClass)
+      )
+      val host = hostForAccessorOf(sym, clazz)
+      def isSelfType = (host.thisSym != host) && {
+        if (host.thisSym.tpe.typeSymbol.isJavaDefined)
+          restrictionError(pos, unit,
+            "%s accesses protected %s from self type %s.".format(clazz, sym, host.thisSym.tpe)
+          )
+        true
       }
-
-      def accessibleThroughSubclassing: Boolean =
-        (validCurrentOwner
-            && currentOwner.enclClass.thisSym.isSubClass(sym.owner)
-            && !currentOwner.enclClass.isTrait)
-
-      val res = /* settings.debug.value && */
-      ((sym hasFlag PROTECTED)
-       && sym.hasFlag(JAVA)
-       && !sym.owner.isPackageClass
-       && !accessibleThroughSubclassing
-       && (sym.owner.enclosingPackageClass != currentOwner.enclosingPackageClass)
-       && (sym.owner.enclosingPackageClass == sym.accessBoundary(sym.owner).enclosingPackageClass))
-
-      if (res) {
-        val host = hostForAccessorOf(sym, currentOwner.enclClass)
-        // bug #1393 - as things stand now the "host" could be a package.
-        if (host.isPackageClass) false
-        else if (host.thisSym != host) {
-          if (host.thisSym.tpe.typeSymbol.hasFlag(JAVA))
-            errorRestriction("%s accesses protected %s from self type %s.".format(currentOwner.enclClass, sym, host.thisSym.tpe))
-          false
-        } else if (host.isTrait && sym.hasFlag(JAVA)) {
-            errorRestriction(("%s accesses protected %s inside a concrete trait method. " +
-                    "Add an accessor in a class extending %s to work around this bug.").format(currentOwner.enclClass, sym, sym.enclClass))
-            false
-        } else res
-      } else res
+      def isJavaProtected = host.isTrait && sym.isJavaDefined && {
+        restrictionError(pos, unit,
+          "%s accesses protected %s inside a concrete trait method. " +
+          "Add an accessor in a class extending %s to work around this bug." .
+            format(clazz, sym, sym.enclClass)
+        )
+        true
+      }
+      isCandidate && !host.isPackageClass && !isSelfType && !isJavaProtected
     }
 
     /** Return the innermost enclosing class C of referencingClass for which either