Fix overriing check with FromJavaObject

Author: noti0na1

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

@@ -1505,12 +1505,33 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
             false
         }
 
+        // This & will try to preserve the FromJavaObjects type in upper bounds
+        // For example, (? <: FromJavaObjects | Null) & (? <: Any),
+        // we want to get (? <: FromJavaObjects | Null) intead of (? <: Any),
+        // because we may check FromJavaObjects | Null <:< Object | Null later.
+        def bounds_&(tp1: TypeBounds, tp2: TypeBounds) =
+          if tp1.hi.containsFromJavaObject
+            && (tp1.hi frozen_<:< tp2.hi)
+            && (tp2.lo frozen_<:< tp1.lo) then
+            // FromJavaObject in tp1.hi guarantees tp2.hi <:< tp1.hi
+            // prefer tp1 if FromJavaObject is in its hi
+            tp1
+          else if tp2.hi.containsFromJavaObject
+            && (tp2.hi frozen_<:< tp1.hi)
+            && (tp1.lo frozen_<:< tp2.lo) then
+            // Similarly, prefer tp2 if FromJavaObject is in its hi
+            tp2
+          else
+            // Use regular & to solve other cases
+            tp1 & tp2
+
         def isSubArg(arg1: Type, arg2: Type): Boolean = arg2 match {
           case arg2: TypeBounds =>
             val arg1norm = arg1 match {
               case arg1: TypeBounds =>
                 tparam match {
-                  case tparam: Symbol => arg1 & paramBounds(tparam)
+                  case tparam: Symbol =>
+                    bounds_&(arg1, paramBounds(tparam))
                   case _ => arg1 // This case can only arise when a hk-type is illegally instantiated with a wildcard
                 }
               case _ => arg1

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

@@ -301,6 +301,11 @@ object Types {
 
     def isFromJavaObject(using Context): Boolean = typeSymbol eq defn.FromJavaObjectSymbol
 
+    def containsFromJavaObject(using Context): Boolean = this match
+      case tp: OrType => tp.tp1.containsFromJavaObject || tp.tp2.containsFromJavaObject
+      case tp: AndType => tp.tp1.containsFromJavaObject && tp.tp2.containsFromJavaObject
+      case _ => isFromJavaObject
+
     /** True iff `symd` is a denotation of a class type parameter and the reference
      *  `<pre> . <symd>` is an actual argument reference, i.e. `pre` is not the
      *  ThisType of `symd`'s owner, or a reference to `symd`'s owner.'
@@ -4933,6 +4938,8 @@ object Types {
     }
 
     def & (that: TypeBounds)(using Context): TypeBounds =
+      // if ((that.lo frozen_<:< this.lo) && (this.hi frozen_<:< that.hi)) this
+      // else if ((this.lo frozen_<:< that.lo) && (that.hi frozen_<:< this.hi)) that
       if ((this.lo frozen_<:< that.lo) && (that.hi frozen_<:< this.hi)) that
       else if ((that.lo frozen_<:< this.lo) && (this.hi frozen_<:< that.hi)) this
       else TypeBounds(this.lo | that.lo, this.hi & that.hi)

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

@@ -107,7 +107,14 @@ object ResolveSuper {
         // of the superaccessor's type, see i5433.scala for an example where this matters
         val otherTp = other.asSeenFrom(base.typeRef).info
         val accTp = acc.asSeenFrom(base.typeRef).info
-        if (!(otherTp.overrides(accTp, matchLoosely = true)))
+        // Since the super class can be Java defined,
+        // we use releaxed overriding check for explicit nulls if one of the symbols is Java defined.
+        // This forces `Null` being a subtype of reference types during override checking.
+        val relaxedCtxForNulls =
+        if ctx.explicitNulls && (sym.is(JavaDefined) || acc.is(JavaDefined)) then
+          ctx.retractMode(Mode.SafeNulls)
+        else ctx
+        if (!(otherTp.overrides(accTp, matchLoosely = true)(using relaxedCtxForNulls)))
           report.error(IllegalSuperAccessor(base, memberName, targetName, acc, accTp, other.symbol, otherTp), base.srcPos)
 
       bcs = bcs.tail