Refactor: Drop isSubType parameter for override checking

Simplifies previous too convoluted logic.

Author: odersky

compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala

@@ -1574,36 +1574,13 @@ class CheckCaptures extends Recheck, SymTransformer:
     */
     def checkOverrides = new TreeTraverser:
       class OverridingPairsCheckerCC(clazz: ClassSymbol, self: Type, tree: Tree)(using Context) extends OverridingPairsChecker(clazz, self):
-        /** Check subtype with box adaptation.
-        *  This function is passed to RefChecks to check the compatibility of overriding pairs.
-        *  @param sym  symbol of the field definition that is being checked
-
-        override def checkSubType(actual: Type, expected: Type)(using Context): Boolean =
-          val expected1 = alignDependentFunction(addOuterRefs(expected, actual, tree.srcPos), actual.stripCapturing)
-          val actual1 =
-            val saved = curEnv
-            try
-              curEnv = Env(clazz, EnvKind.NestedInOwner, capturedVars(clazz), outer0 = curEnv)
-              val adapted =
-                adaptBoxed(actual, expected1, tree, covariant = true, alwaysConst = true)
-              actual match
-                case _: MethodType =>
-                  // We remove the capture set resulted from box adaptation for method types,
-                  // since class methods are always treated as pure, and their captured variables
-                  // are charged to the capture set of the class (which is already done during
-                  // box adaptation).
-                  adapted.stripCapturing
-                case _ => adapted
-            finally curEnv = saved
-          actual1 frozen_<:< expected1
-        */
 
         /** Omit the check if one of {overriding,overridden} was nnot capture checked */
         override def needsCheck(overriding: Symbol, overridden: Symbol)(using Context): Boolean =
           !setup.isPreCC(overriding) && !setup.isPreCC(overridden)
 
         /** Perform box adaptation for override checking */
-        override def adapt(member: Symbol, memberTp: Type, otherTp: Type)(using Context): Option[(Type, Type)] =
+        override def adaptOverridePair(member: Symbol, memberTp: Type, otherTp: Type)(using Context): Option[(Type, Type)] =
           if member.isType then
             memberTp match
               case TypeAlias(_) =>
@@ -1613,26 +1590,36 @@ class CheckCaptures extends Recheck, SymTransformer:
                     Some((memberTp, otherTp.unboxed))
                   case _ => None
               case _ => None
-          else
-            val expected1 = alignDependentFunction(addOuterRefs(otherTp, memberTp, tree.srcPos), memberTp.stripCapturing)
-            val actual1 =
-              val saved = curEnv
-              try
-                curEnv = Env(clazz, EnvKind.NestedInOwner, capturedVars(clazz), outer0 = curEnv)
-                val adapted =
-                  adaptBoxed(memberTp, expected1, tree, covariant = true, alwaysConst = true)
-                memberTp match
-                  case _: MethodType =>
-                    // We remove the capture set resulted from box adaptation for method types,
-                    // since class methods are always treated as pure, and their captured variables
-                    // are charged to the capture set of the class (which is already done during
-                    // box adaptation).
-                    adapted.stripCapturing
-                  case _ => adapted
-              finally curEnv = saved
-            if (actual1 eq memberTp) && (expected1 eq otherTp) then None
-            else Some((actual1, expected1))
-        end adapt
+          else memberTp match
+            case memberTp @ ExprType(memberRes) =>
+              adaptOverridePair(member, memberRes, otherTp) match
+                case Some((mres, otp)) => Some((memberTp.derivedExprType(mres), otp))
+                case None => None
+            case _ => otherTp match
+              case otherTp @ ExprType(otherRes) =>
+                adaptOverridePair(member, memberTp, otherRes) match
+                  case Some((mtp, ores)) => Some((mtp, otherTp.derivedExprType(ores)))
+                  case None => None
+              case _ =>
+                val expected1 = alignDependentFunction(addOuterRefs(otherTp, memberTp, tree.srcPos), memberTp.stripCapturing)
+                val actual1 =
+                  val saved = curEnv
+                  try
+                    curEnv = Env(clazz, EnvKind.NestedInOwner, capturedVars(clazz), outer0 = curEnv)
+                    val adapted =
+                      adaptBoxed(memberTp, expected1, tree, covariant = true, alwaysConst = true)
+                    memberTp match
+                      case _: MethodType =>
+                        // We remove the capture set resulted from box adaptation for method types,
+                        // since class methods are always treated as pure, and their captured variables
+                        // are charged to the capture set of the class (which is already done during
+                        // box adaptation).
+                        adapted.stripCapturing
+                      case _ => adapted
+                  finally curEnv = saved
+                if (actual1 eq memberTp) && (expected1 eq otherTp) then None
+                else Some((actual1, expected1))
+        end adaptOverridePair
 
         override def checkInheritedTraitParameters: Boolean = false
 

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -1167,10 +1167,9 @@ object Types extends TypeUtils {
      *
      *  @param isSubType      a function used for checking subtype relationships.
      */
-    final def overrides(that: Type, matchLoosely: => Boolean, checkClassInfo: Boolean = true,
-                        isSubType: (Type, Type) => Context ?=> Boolean = (tp1, tp2) => tp1 frozen_<:< tp2)(using Context): Boolean = {
+    final def overrides(that: Type, matchLoosely: => Boolean, checkClassInfo: Boolean = true)(using Context): Boolean = {
       !checkClassInfo && this.isInstanceOf[ClassInfo]
-      || isSubType(this.widenExpr, that.widenExpr)
+      || (this.widenExpr frozen_<:< that.widenExpr)
       || matchLoosely && {
         val this1 = this.widenNullaryMethod
         val that1 = that.widenNullaryMethod

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

@@ -210,8 +210,7 @@ object OverridingPairs:
    *  @param isSubType  A function to be used for checking subtype relationships
    *                    between term fields.
    */
-  def isOverridingPair(member: Symbol, memberTp: Type, other: Symbol, otherTp: Type, fallBack: => Boolean = false,
-                       isSubType: (Type, Type) => Context ?=> Boolean = (tp1, tp2) => tp1 frozen_<:< tp2)(using Context): Boolean =
+  def isOverridingPair(member: Symbol, memberTp: Type, other: Symbol, otherTp: Type, fallBack: => Boolean = false)(using Context): Boolean =
     if member.isType then // intersection of bounds to refined types must be nonempty
       memberTp.bounds.hi.hasSameKindAs(otherTp.bounds.hi)
       && (
@@ -227,6 +226,6 @@ object OverridingPairs:
       )
     else
       member.name.is(DefaultGetterName) // default getters are not checked for compatibility
-      || memberTp.overrides(otherTp, member.matchNullaryLoosely || other.matchNullaryLoosely || fallBack, isSubType = isSubType)
+      || memberTp.overrides(otherTp, member.matchNullaryLoosely || other.matchNullaryLoosely || fallBack)
 
 end OverridingPairs

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

@@ -242,12 +242,6 @@ object RefChecks {
       && (inLinearizationOrder(sym1, sym2, parent) || parent.is(JavaDefined))
       && !sym2.is(AbsOverride)
 
-    /** Checks the subtype relationship tp1 <:< tp2.
-     *  It is passed to the `checkOverride` operation in `checkAll`, to be used for
-     *  compatibility checking.
-     */
-    def checkSubType(tp1: Type, tp2: Type)(using Context): Boolean = tp1 frozen_<:< tp2
-
     /** A hook that allows to omit override checks between `overriding` and `overridden`.
      *  Overridden in capture checking to handle non-capture checked classes leniently.
      */
@@ -258,16 +252,14 @@ object RefChecks {
      *  Note: we return an Option result to avoid a tuple allocation in the normal case
      *  where no adaptation is necessary.
      */
-    def adapt(member: Symbol, memberTp: Type, otherTp: Type)(using Context): Option[(Type, Type)] = None
+    def adaptOverridePair(member: Symbol, memberTp: Type, otherTp: Type)(using Context): Option[(Type, Type)] = None
 
     protected def additionalChecks(overriding: Symbol, overridden: Symbol)(using Context): Unit = ()
 
-    private val subtypeChecker: (Type, Type) => Context ?=> Boolean = this.checkSubType
-
-    def checkAll(checkOverride: ((Type, Type) => Context ?=> Boolean, Symbol, Symbol) => Unit) =
+    def checkAll(checkOverride: (Symbol, Symbol) => Unit) =
       while hasNext do
         if needsCheck(overriding, overridden) then
-          checkOverride(subtypeChecker, overriding, overridden)
+          checkOverride(overriding, overridden)
           additionalChecks(overriding, overridden)
         next()
 
@@ -282,7 +274,7 @@ object RefChecks {
         if dcl.is(Deferred) then
           for other <- dcl.allOverriddenSymbols do
             if !other.is(Deferred) then
-              checkOverride(subtypeChecker, dcl, other)
+              checkOverride(dcl, other)
     end checkAll
 
     // Disabled for capture checking since traits can get different parameter refinements
@@ -435,7 +427,7 @@ object RefChecks {
     /* Check that all conditions for overriding `other` by `member`
      * of class `clazz` are met.
      */
-    def checkOverride(checkSubType: (Type, Type) => Context ?=> Boolean, member: Symbol, other: Symbol): Unit =
+    def checkOverride(member: Symbol, other: Symbol): Unit =
       def memberType(self: Type) =
         if (member.isClass) TypeAlias(member.typeRef.etaExpand)
         else self.memberInfo(member)
@@ -444,7 +436,7 @@ object RefChecks {
 
       var memberTp = memberType(self)
       var otherTp = otherType(self)
-      checker.adapt(member, memberTp, otherTp) match
+      checker.adaptOverridePair(member, memberTp, otherTp) match
         case Some((mtp, otp)) =>
           memberTp = mtp
           otherTp = otp
@@ -463,8 +455,8 @@ object RefChecks {
           isOverridingPair(member, memberTp, other, otherTp,
             fallBack = warnOnMigration(
               overrideErrorMsg("no longer has compatible type"),
-              (if (member.owner == clazz) member else clazz).srcPos, version = `3.0`),
-            isSubType = checkSubType)
+              (if member.owner == clazz then member else clazz).srcPos,
+              version = `3.0`))
         catch case ex: MissingType =>
           // can happen when called with upwardsSelf as qualifier of memberTp and otherTp,
           // because in that case we might access types that are not members of the qualifier.
@@ -647,7 +639,7 @@ object RefChecks {
            && {
               var memberTpUp = memberType(upwardsSelf)
               var otherTpUp = otherType(upwardsSelf)
-              checker.adapt(member, memberTpUp, otherTpUp) match
+              checker.adaptOverridePair(member, memberTpUp, otherTpUp) match
                 case Some((mtp, otp)) =>
                   memberTpUp = mtp
                   otherTpUp = otp