Factor out commonalities between RefChecks and Bridges cursors

Author: odersky

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

@@ -18,26 +18,23 @@ class Bridges(root: ClassSymbol, thisPhase: DenotTransformer)(using Context) {
   private val preErasureCtx = ctx.withPhase(erasurePhase)
   private lazy val elimErasedCtx = ctx.withPhase(elimErasedValueTypePhase.next)
 
-  private class BridgesCursor(using Context) extends OverridingPairs.Cursor(root) {
+  private class BridgesCursor(using Context) extends OverridingPairs.PreErasureCursor(root):
 
     override def isSubParent(parent: Symbol, bc: Symbol)(using Context) =
       true
       	// Never consider a bridge if there is a superclass that would contain it
       	// See run/t2857.scala for a test that would break with a VerifyError otherwise.
 
-    /** Only use the superclass of `root` as a parent class. This means
-     *  overriding pairs that have a common implementation in a trait parent
-     *  are also counted. This is necessary because we generate bridge methods
-     *  only in classes, never in traits.
-     */
     override def parents = Array(root.superClass)
+      // Only use the superclass of `root` as a parent class. This means
+      // overriding pairs that have a common implementation in a trait parent
+      // are also counted. This is necessary because we generate bridge methods
+      // only in classes, never in traits.
 
     override def exclude(sym: Symbol) =
       !sym.isOneOf(MethodOrModule) || super.exclude(sym)
 
-    override def canBeHandledByParent(sym1: Symbol, sym2: Symbol, parent: Symbol): Boolean =
-      OverridingPairs.isOverridingPair(sym1, sym2, parent.thisType)
-  }
+  end BridgesCursor
 
   val site = root.thisType
 

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

@@ -168,6 +168,34 @@ object OverridingPairs:
     next()
   end Cursor
 
+  /** A cursor to be used before erasure (i.e. in RefChecks and for bridge construction).
+   *  It differs from a general cursor in imposing two additional conditions when an overriding
+   *  pair can be ignored since it is already handled in a parent class:
+   *   1. The two symbols must also override each other when seen as members of
+   *      the common parent class.  See neg/i12828.scala for an example where this matters.
+   *   2. The overriding symbol appears before the overridden symbol in the linearization
+   *      of the parent class. See neg/i5094.scala for an example where this matters.
+   */
+  class PreErasureCursor(base: Symbol)(using Context) extends Cursor(base):
+
+    private def inLinearizationOrder(sym1: Symbol, sym2: Symbol, parent: Symbol): Boolean =
+      val owner1 = sym1.owner
+      val owner2 = sym2.owner
+      def precedesIn(bcs: List[ClassSymbol]): Boolean = (bcs: @unchecked) match
+        case bc :: bcs1 =>
+          if owner1 eq bc then true
+          else if owner2 eq bc then false
+          else precedesIn(bcs1)
+        case _ =>
+          false
+      precedesIn(parent.asClass.baseClasses)
+
+    override def canBeHandledByParent(sym1: Symbol, sym2: Symbol, parent: Symbol): Boolean =
+      OverridingPairs.isOverridingPair(sym1, sym2, parent.thisType)
+      && inLinearizationOrder(sym1, sym2, parent)
+
+  end PreErasureCursor
+
   /** Is this `sym1` considered an override of `sym2` (or vice versa) if both are
    *  seen as members of `site`?
    *  We declare a match if either we have a full match including matching names

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

@@ -469,33 +469,10 @@ object RefChecks {
           }*/
     }
 
-    val opc = new OverridingPairs.Cursor(clazz):
+    val opc = new OverridingPairs.PreErasureCursor(clazz):
       override def matches(sym1: Symbol, sym2: Symbol): Boolean =
         isOverridingPair(sym1, sym2, self)
 
-      private def inLinearizationOrder(sym1: Symbol, sym2: Symbol, parent: Symbol): Boolean =
-        val owner1 = sym1.owner
-        val owner2 = sym2.owner
-        def precedesIn(bcs: List[ClassSymbol]): Boolean = (bcs: @unchecked) match
-          case bc :: bcs1 =>
-            if owner1 eq bc then true
-            else if owner2 eq bc then false
-            else precedesIn(bcs1)
-          case _ =>
-            false
-        precedesIn(parent.asClass.baseClasses)
-
-      // We can exclude pairs safely from checking only under two additional conditions
-      //   - their signatures also match in the parent class.
-      //     See neg/i12828.scala for an example where this matters.
-      //   - They overriding/overridden appear in linearization order.
-      //     See neg/i5094.scala for an example where this matters.
-      override def canBeHandledByParent(sym1: Symbol, sym2: Symbol, parent: Symbol): Boolean =
-        isOverridingPair(sym1, sym2, parent.thisType)
-         .showing(i"already handled ${sym1.showLocated}: ${sym1.asSeenFrom(parent.thisType).signature}, ${sym2.showLocated}: ${sym2.asSeenFrom(parent.thisType).signature} = $result", refcheck)
-        && inLinearizationOrder(sym1, sym2, parent)
-    end opc
-
     while opc.hasNext do
       checkOverride(opc.overriding, opc.overridden)
       opc.next()