Run ignoredDeferred less often

RefChecks would invoke ignoreDeferred each time we hit an abstract member in a base class of a
checked class, which means almost all of the time. ignoreDeferred would in turn do time travel
to post-erasure. This causes inefficiencies because of compiler-context switches. It also exposed
the problem in i8425 that was fixed by the last commit.

The concrete failure for i8425 does go away with the change in this commit. However, the fix
in the last commit is still necessary since explicit outer/erasure races are a general problem
that could come back.

Author: odersky

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

@@ -472,7 +472,7 @@ object RefChecks {
             }
         }
 
-       def ignoreDeferred(mbr: Symbol) =
+      def ignoreDeferred(mbr: Symbol) =
         mbr.isType
         || mbr.isSuperAccessor // not yet synthesized
         || mbr.is(JavaDefined) && hasJavaErasedOverriding(mbr)
@@ -619,15 +619,16 @@ object RefChecks {
       // (3) is violated but not (2).
       def checkNoAbstractDecls(bc: Symbol): Unit = {
         for (decl <- bc.info.decls)
-          if (decl.is(Deferred) && !ignoreDeferred(decl)) {
+          if (decl.is(Deferred)) {
             val impl = decl.matchingMember(clazz.thisType)
-            if (impl == NoSymbol || (decl.owner isSubClass impl.owner)) {
+            if (impl == NoSymbol || decl.owner.isSubClass(impl.owner))
+               && !ignoreDeferred(decl)
+            then
               val impl1 = clazz.thisType.nonPrivateMember(decl.name) // DEBUG
               ctx.log(i"${impl1}: ${impl1.info}") // DEBUG
               ctx.log(i"${clazz.thisType.memberInfo(decl)}") // DEBUG
               abstractClassError(false, "there is a deferred declaration of " + infoString(decl) +
                 " which is not implemented in a subclass" + err.abstractVarMessage(decl))
-            }
           }
         if (bc.asClass.superClass.is(Abstract))
           checkNoAbstractDecls(bc.asClass.superClass)