Optimize overrides check

Author: noti0na1

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

@@ -20,7 +20,7 @@ import Denotations._
 import Periods._
 import CheckRealizable._
 import Variances.{Variance, varianceFromInt, varianceToInt, setStructuralVariances, Invariant}
-import typer.Nullables
+import typer.Nullables.useUnsafeNullsSubTypeIf
 import util.Stats._
 import util.SimpleIdentitySet
 import ast.tpd._
@@ -1002,17 +1002,19 @@ object Types {
      *  @param matchLoosely   if true the types `=> T` and `()T` are seen as overriding each other.
      *  @param checkClassInfo if true we check that ClassInfos are within bounds of abstract types
      */
-    final def overrides(that: Type, matchLoosely: => Boolean, checkClassInfo: Boolean = true)(using Context): Boolean = {
+    final def overrides(that: Type, matchLoosely: => Boolean,
+      checkClassInfo: Boolean = true, relaxedNulls: Boolean = false)(using Context): Boolean = {
       def widenNullary(tp: Type) = tp match {
         case tp @ MethodType(Nil) => tp.resultType
         case _ => tp
       }
       !checkClassInfo && this.isInstanceOf[ClassInfo]
-      || (this.widenExpr frozen_<:< that.widenExpr)
+      || useUnsafeNullsSubTypeIf(relaxedNulls)(this.widenExpr frozen_<:< that.widenExpr)
       || matchLoosely && {
            val this1 = widenNullary(this)
            val that1 = widenNullary(that)
-           ((this1 `ne` this) || (that1 `ne` that)) && this1.overrides(that1, false, checkClassInfo)
+           ((this1 `ne` this) || (that1 `ne` that)) 
+           && this1.overrides(that1, false, checkClassInfo, relaxedNulls)
          }
     }
 
@@ -1034,7 +1036,7 @@ object Types {
      */
     def matches(that: Type)(using Context): Boolean = {
       record("matches")
-      Nullables.useUnsafeNullsSubTypeIf(ctx.explicitNulls)(
+      useUnsafeNullsSubTypeIf(ctx.explicitNulls)(
         TypeComparer.matchesType(this, that, relaxed = !ctx.phase.erasedTypes))
     }
 

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

@@ -252,10 +252,9 @@ object RefChecks {
         else
           member.name.is(DefaultGetterName) // default getters are not checked for compatibility
           || memberTp.overrides(otherTp,
-              member.matchNullaryLoosely || other.matchNullaryLoosely || fallBack)
-          // releaxed override check for explicit nulls
-          || (ctx.explicitNulls && (member.is(JavaDefined) || other.is(JavaDefined)) &&
-              memberTp.stripAllNulls.overrides(otherTp.stripAllNulls, true))
+              member.matchNullaryLoosely || other.matchNullaryLoosely || fallBack,
+              // releaxed override check for explicit nulls
+              relaxedNulls = ctx.explicitNulls && (member.is(JavaDefined) || other.is(JavaDefined)))
       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.