Drop redundant computations

Avoiding parents in superclasses was done twice. We drop the second
computation, which is less efficient than the first.

Author: odersky

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

@@ -360,27 +360,6 @@ object RefChecks {
 
       //Console.println(infoString(member) + " overrides " + infoString(other) + " in " + clazz);//DEBUG
 
-      // return if we already checked this combination elsewhere
-      if (member.owner != clazz) {
-        def deferredCheck = member.is(Deferred) || !other.is(Deferred)
-        def subOther(s: Symbol) = s derivesFrom other.owner
-        def subMember(s: Symbol) = s derivesFrom member.owner
-
-        if (subOther(member.owner) && deferredCheck)
-          //Console.println(infoString(member) + " shadows1 " + infoString(other) " in " + clazz);//DEBUG
-          return
-        val parentSymbols = clazz.info.parents.map(_.typeSymbol)
-        def matchIn(parent: Symbol): Boolean = considerMatching(member, other, parent.thisType)
-        if parentSymbols.exists(p =>
-          subOther(p) && subMember(p) && deferredCheck && matchIn(p))
-        then
-          //Console.println(infoString(member) + " shadows2 " + infoString(other) + " in " + clazz);//DEBUG
-          return
-        if parentSymbols.forall(p => subOther(p) == subMember(p) && matchIn(p)) then
-          //Console.println(infoString(member) + " shadows " + infoString(other) + " in " + clazz);//DEBUG
-          return
-      }
-
       /* Is the intersection between given two lists of overridden symbols empty? */
       def intersectionIsEmpty(syms1: Iterator[Symbol], syms2: Iterator[Symbol]) = {
         val set2 = syms2.toSet
@@ -508,21 +487,27 @@ object RefChecks {
      *    - matching names and types, but different target names
      */
     def considerMatching(sym1: Symbol, sym2: Symbol, self: Type): Boolean =
-      !(sym1.owner.is(JavaDefined, butNot = Trait) && sym2.owner.is(JavaDefined, butNot = Trait)) && // javac already handles these checks
-        (sym1.isType || {
-          val sd1 = sym1.asSeenFrom(self)
-          val sd2 = sym2.asSeenFrom(self)
-          sd1.matchesLoosely(sd2)
+      if     sym1.owner.is(JavaDefined, butNot = Trait)
+          && sym2.owner.is(JavaDefined, butNot = Trait)
+      then false // javac already handles these checks
+      else if sym1.isType then true
+      else
+        val sd1 = sym1.asSeenFrom(self)
+        val sd2 = sym2.asSeenFrom(self)
+        sd1.matchesLoosely(sd2)
           && (sym1.hasTargetName(sym2.targetName)
              || compatibleTypes(sym1, sd1.info, sym2, sd2.info))
-        })
 
     val opc = new OverridingPairs.Cursor(clazz):
       override def matches(sym1: Symbol, sym2: Symbol): Boolean =
         considerMatching(sym1, sym2, self)
+
+      // We can exclude pairs safely from checking only of they also matched in
+      // the parent class. See neg/i12828.scala for an example where this matters.
       override def canBeHandledByParent(sym1: Symbol, sym2: Symbol, parentType: Type): Boolean =
         considerMatching(sym1, sym2, parentType)
          .showing(i"already handled ${sym1.showLocated}: ${sym1.asSeenFrom(parentType).signature}, ${sym2.showLocated}: ${sym2.asSeenFrom(parentType).signature} = $result", refcheck)
+    end opc
 
     while opc.hasNext do
       checkOverride(opc.overriding, opc.overridden)