Merge chnages from other PRs

Author: noti0na1

compiler/src/dotty/tools/dotc/ast/TreeMapWithImplicits.scala

@@ -50,13 +50,7 @@ class TreeMapWithImplicits extends tpd.TreeMapWithPreciseStatContexts {
   override def transform(tree: Tree)(using Context): Tree = {
     try tree match {
       case Block(stats, expr) =>
-        inContext(nestedScopeCtx(stats)) {
-          if stats.exists(_.isInstanceOf[Import]) then
-            // need to transform stats and expr together to account for import visibility
-            val stats1 = transformStats(stats :+ expr, ctx.owner)
-            cpy.Block(tree)(stats1.init, stats1.last)
-          else super.transform(tree)
-        }
+        super.transform(tree)(using nestedScopeCtx(stats))
       case tree: DefDef =>
         inContext(localCtx(tree)) {
           cpy.DefDef(tree)(

compiler/src/dotty/tools/dotc/ast/tpd.scala

@@ -1201,6 +1201,13 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
    *    - imports are reflected in the contexts of subsequent statements
    */
   class TreeMapWithPreciseStatContexts(cpy: TreeCopier = tpd.cpy) extends TreeMap(cpy):
+    override def transform(tree: Tree)(using Context): Tree = tree match
+      case Block(stats, expr) =>
+        val stats1 = transformStats(stats :+ expr, ctx.owner)
+        cpy.Block(tree)(stats1.init, stats1.last)
+      case _ =>
+        super.transform(tree)
+
     override def transformStats(trees: List[Tree], exprOwner: Symbol)(using Context): List[Tree] =
       trees.mapStatements(exprOwner, transform(_))
 

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

@@ -126,4 +126,9 @@ object Mode {
    *  This mode forces expansion of inline calls in those positions even during typing.
    */
   val ForceInline: Mode = newMode(29, "ForceInline")
+
+  /** This mode is enabled when we check Java overriding in explicit nulls.
+   *  Type `Null` becomes a bottom type in TypeComparer.
+   */
+  val RelaxedOverriding: Mode = newMode(30, "RelaxedOverriding")
 }

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

@@ -1,8 +1,6 @@
 package dotty.tools.dotc
 package core
 
-import scala.language.{unsafeNulls => _}
-
 import ast.Trees._
 import Contexts._
 import Symbols.defn
@@ -11,43 +9,6 @@ import Types._
 /** Defines operations on nullable types and tree. */
 object NullOpsDecorator:
 
-  private class StripNullsMap(isDeep: Boolean)(using Context) extends TypeMap:
-    def strip(tp: Type): Type = tp match
-      case tp @ OrType(lhs, rhs) =>
-        val llhs = this(lhs)
-        val rrhs = this(rhs)
-        if rrhs.isNullType then llhs
-        else if llhs.isNullType then rrhs
-        else derivedOrType(tp, llhs, rrhs)
-      case tp @ AndType(tp1, tp2) =>
-        // We cannot `tp.derivedAndType(strip(tp1), strip(tp2))` directly,
-        // since `stripNull((A | Null) & B)` would produce the wrong
-        // result `(A & B) | Null`.
-        val tp1s = this(tp1)
-        val tp2s = this(tp2)
-        if isDeep || (tp1s ne tp1) && (tp2s ne tp2) then
-          derivedAndType(tp, tp1s, tp2s)
-        else tp
-      case tp: TypeBounds =>
-        mapOver(tp)
-      case _ => tp
-
-    def stripOver(tp: Type): Type = tp match
-      case appTp @ AppliedType(tycon, targs) =>
-        derivedAppliedType(appTp, tycon, targs.map(this))
-      case ptp: PolyType =>
-        derivedLambdaType(ptp)(ptp.paramInfos, this(ptp.resType))
-      case mtp: MethodType =>
-        mapOver(mtp)
-      case _ => strip(tp)
-
-    override def apply(tp: Type): Type =
-      val tpw = tp.widenDealias
-      val tpws = if isDeep then stripOver(tpw) else strip(tpw)
-      if tpws ne tpw then tpws else tp
-
-  end StripNullsMap
-
   extension (self: Type)
     /** Syntactically strips the nullability from this type.
      *  If the type is `T1 | ... | Tn`, and `Ti` references to `Null`,
@@ -56,22 +17,38 @@ object NullOpsDecorator:
      *  The type will not be changed if explicit-nulls is not enabled.
      */
     def stripNull(using Context): Type = {
-      if ctx.explicitNulls then new StripNullsMap(false)(self) else self
+      def strip(tp: Type): Type =
+        val tpWiden = tp.widenDealias
+        val tpStripped = tpWiden match {
+          case tp @ OrType(lhs, rhs) =>
+            val llhs = strip(lhs)
+            val rrhs = strip(rhs)
+            if rrhs.isNullType then llhs
+            else if llhs.isNullType then rrhs
+            else tp.derivedOrType(llhs, rrhs)
+          case tp @ AndType(tp1, tp2) =>
+            // We cannot `tp.derivedAndType(strip(tp1), strip(tp2))` directly,
+            // since `stripNull((A | Null) & B)` would produce the wrong
+            // result `(A & B) | Null`.
+            val tp1s = strip(tp1)
+            val tp2s = strip(tp2)
+            if (tp1s ne tp1) && (tp2s ne tp2) then
+              tp.derivedAndType(tp1s, tp2s)
+            else tp
+          case tp @ TypeBounds(lo, hi) =>
+            tp.derivedTypeBounds(strip(lo), strip(hi))
+          case tp => tp
+        }
+        if tpStripped ne tpWiden then tpStripped else tp
+
+      if ctx.explicitNulls then strip(self) else self
     }
 
     /** Is self (after widening and dealiasing) a type of the form `T | Null`? */
     def isNullableUnion(using Context): Boolean = {
       val stripped = self.stripNull
       stripped ne self
     }
-
-    /** Strips nulls from this type deeply.
-     *  Compaired to `stripNull`, `stripNullsDeep` will apply `stripNull` to
-     *  each member of function types as well.
-     */
-    def stripNullsDeep(using Context): Type =
-      if ctx.explicitNulls then new StripNullsMap(true)(self) else self
-
   end extension
 
   import ast.tpd._

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

@@ -769,13 +769,20 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
 
             isSubType(hi1, tp2, approx.addLow) || compareGADT || tryLiftedToThis1
           case _ =>
-            def isNullable(tp: Type): Boolean = tp.widenDealias match {
-              case tp: TypeRef => tp.symbol.isNullableClass
-              case tp: RefinedOrRecType => isNullable(tp.parent)
-              case tp: AppliedType => isNullable(tp.tycon)
-              case AndType(tp1, tp2) => isNullable(tp1) && isNullable(tp2)
-              case OrType(tp1, tp2) => isNullable(tp1) || isNullable(tp2)
-              case _ => false
+            // `Mode.RelaxedOverriding` is only enabled when checking Java overriding
+            // in explicit nulls, and `Null` becomes a bottom type, which allows
+            // `T | Null` being a subtype of `T`.
+            // A type varibale `T` from Java is translated to `T >: Nothing <: Any`.
+            // However, `null` can always be a value of `T` for Java side.
+            // So the best solution here is to let `Null` be bottom type temporarily.
+            def isNullable(tp: Type): Boolean = ctx.mode.is(Mode.RelaxedOverriding) || {
+              tp.widenDealias match
+                case tp: TypeRef => tp.symbol.isNullableClass
+                case tp: RefinedOrRecType => isNullable(tp.parent)
+                case tp: AppliedType => isNullable(tp.tycon)
+                case AndType(tp1, tp2) => isNullable(tp1) && isNullable(tp2)
+                case OrType(tp1, tp2) => isNullable(tp1) || isNullable(tp2)
+                case _ => false
             }
             val sym1 = tp1.symbol
             (sym1 eq NothingClass) && tp2.isValueTypeOrLambda ||

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

@@ -1115,10 +1115,10 @@ object Types {
      */
     def matches(that: Type)(using Context): Boolean = {
       record("matches")
-      val thisTp1 = this.stripNullsDeep
-      val thatTp1 = that.stripNullsDeep
-      withoutMode(Mode.SafeNulls)(
-        TypeComparer.matchesType(thisTp1, thatTp1, relaxed = !ctx.phase.erasedTypes))
+      val overrideCtx = if ctx.explicitNulls
+        then ctx.retractMode(Mode.SafeNulls).addMode(Mode.RelaxedOverriding)
+        else ctx
+      TypeComparer.matchesType(this, that, relaxed = !ctx.phase.erasedTypes)(using overrideCtx)
     }
 
     /** This is the same as `matches` except that it also matches => T with T and

compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala

@@ -50,9 +50,6 @@ class PlainPrinter(_ctx: Context) extends Printer {
       tp match {
         case tp: ThisType if tp.cls.is(Package) && !tp.cls.isEffectiveRoot =>
           requiredPackage(tp.cls.fullName).termRef
-        case tp: TypeRef =>
-          val tp1 = tp.dealiasKeepAnnots
-          if tp1 ne tp then homogenize(tp1) else tp
         case tp: TypeVar if tp.isInstantiated =>
           homogenize(tp.instanceOpt)
         case AndType(tp1, tp2) =>
@@ -63,9 +60,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
         if !ctx.mode.is(Mode.Type) && annot.symbol == defn.UncheckedVarianceAnnot =>
           homogenize(parent)
         case tp: SkolemType =>
-          // println(tp.info)
-          // println(tp.info.widen)
-          homogenize(tp.info)
+          homogenize(tp.info.dealiasKeepAnnots)
         case tp: LazyRef =>
           homogenize(tp.ref)
         case tp @ AppliedType(tycon, args) =>

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

@@ -218,20 +218,13 @@ object OverridingPairs:
             }
       )
     else
-      def matchNullaryLoosely = member.matchNullaryLoosely || other.matchNullaryLoosely || fallBack
-      // default getters are not checked for compatibility
-      member.name.is(DefaultGetterName) || {
-        if ctx.explicitNulls && (member.is(JavaDefined) || other.is(JavaDefined)) then
-          // releaxed override check for explicit nulls if one of the symbols is Java defined,
-          // force `Null` being a subtype of reference types during override checking.
-          // `stripNullsDeep` is used here because we may encounter type parameters
-          // (`T | Null` is not a subtype of `T` even if we retract Mode.SafeNulls).
-          val memberTp1 = memberTp.stripNullsDeep
-          val otherTp1 = otherTp.stripNullsDeep
-          withoutMode(Mode.SafeNulls)(
-             memberTp1.overrides(otherTp1, matchNullaryLoosely))
-        else
-          memberTp.overrides(otherTp, matchNullaryLoosely)
-      }
+      // releaxed override check for explicit nulls if one of the symbols is Java defined,
+      // force `Null` being a bottom types during override checking.
+      val overrideCtx = if ctx.explicitNulls && (member.is(JavaDefined) || other.is(JavaDefined))
+        then ctx.retractMode(Mode.SafeNulls).addMode(Mode.RelaxedOverriding) else ctx
+      member.name.is(DefaultGetterName) // default getters are not checked for compatibility
+      || memberTp.overrides(otherTp,
+            member.matchNullaryLoosely || other.matchNullaryLoosely || fallBack
+          )(using overrideCtx)
 
 end OverridingPairs

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

@@ -115,16 +115,11 @@ object ResolveSuper {
         val accTp = acc.asSeenFrom(base.typeRef).info
         // 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 overridesSuper = if ctx.explicitNulls && (sym.is(JavaDefined) || acc.is(JavaDefined)) then
-          val otherTp1 = otherTp.stripNullsDeep
-          val accTp1 = accTp.stripNullsDeep
-          withoutMode(Mode.SafeNulls)(otherTp1.overrides(accTp1, matchLoosely = true))
-        else
-          otherTp.overrides(accTp, matchLoosely = true)
-        if !overridesSuper then
+        // This forces `Null` being a bottom type during override checking.
+        val overrideCtx = if ctx.explicitNulls && (sym.is(JavaDefined) || acc.is(JavaDefined))
+          then ctx.retractMode(Mode.SafeNulls).addMode(Mode.RelaxedOverriding) else ctx
+        if !otherTp.overrides(accTp, matchLoosely = true)(using overrideCtx) then
           report.error(IllegalSuperAccessor(base, memberName, targetName, acc, accTp, other.symbol, otherTp), base.srcPos)
-
       bcs = bcs.tail
     }
     assert(sym.exists, i"cannot rebind $acc, ${acc.targetName} $memberName")