Fix checking ctx to carry correct modes

Author: noti0na1

compiler/src/dotty/tools/dotc/Compiler.scala

@@ -101,6 +101,7 @@ class Compiler {
          new TupleOptimizations,     // Optimize generic operations on tuples
          new LetOverApply,           // Lift blocks from receivers of applications
          new ArrayConstructors) ::   // Intercept creation of (non-generic) arrays and intrinsify.
+    List(new DropImports) ::         // Drop all (language-) imports
     List(new Erasure) ::             // Rewrite types to JVM model, erasing all type parameters, abstract types and refinements.
     List(new ElimErasedValueType,    // Expand erased value types to their underlying implmementation types
          new PureStats,              // Remove pure stats from blocks

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

@@ -0,0 +1,30 @@
+package dotty.tools.dotc
+package transform
+
+import ast.tpd
+import core.*
+import Contexts.*
+import MegaPhase.MiniPhase
+import Decorators.*
+
+/** This phase finally drops all (language-) imports.
+ *  Since some of the language imports change the subtyping,
+ *  we cannot check the trees before erasure. Therefore, this
+ *  phase should be the last phase before erasure.
+ */
+object DropImports:
+  val name: String = "dropImports"
+  val description: String = "drop all (language-) imports."
+
+class DropImports extends MiniPhase:
+  import tpd._
+
+  override def phaseName: String = DropImports.name
+
+  override def description: String = DropImports.description
+
+  override def isCheckable: Boolean = false
+
+  override def transformOther(tree: Tree)(using Context): Tree = tree match
+    case tree: Import => EmptyTree
+    case _ => tree

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

@@ -153,6 +153,7 @@ class Erasure extends Phase with DenotTransformer {
   override def checkPostCondition(tree: tpd.Tree)(using Context): Unit = {
     assertErased(tree)
     tree match {
+      case _: tpd.Import => assert(false, i"illegal tree: $tree")
       case res: tpd.This =>
         assert(!ExplicitOuter.referencesOuter(ctx.owner.lexicallyEnclosingClass, res),
           i"Reference to $res from ${ctx.owner.showLocated}")

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

@@ -6,6 +6,7 @@ import Symbols._, Types._, Contexts._, DenotTransformers._, Flags._
 import util.Spans._
 import SymUtils._
 import StdNames._, NameOps._
+import typer.Nullables
 
 class MixinOps(cls: ClassSymbol, thisPhase: DenotTransformer)(using Context) {
   import ast.tpd._
@@ -80,13 +81,20 @@ class MixinOps(cls: ClassSymbol, thisPhase: DenotTransformer)(using Context) {
     prefss =>
       val (targs, vargss) = splitArgs(prefss)
       val tapp = superRef(target).appliedToTypeTrees(targs)
-      vargss match
+      val rhs = vargss match
         case Nil | List(Nil) =>
           // Overriding is somewhat loose about `()T` vs `=> T`, so just pick
           // whichever makes sense for `target`
           tapp.ensureApplied
         case _ =>
           tapp.appliedToArgss(vargss)
+      if ctx.explicitNulls && target.is(JavaDefined) && !ctx.phase.erasedTypes then
+        // We may forward to a super Java member in resolveSuper phase.
+        // Since this is still before erasure, the type can be nullable
+        // and causes error during checking. So we need to enable
+        // unsafe-nulls to construct the rhs.
+        Block(Nullables.importUnsafeNulls :: Nil, rhs)
+      else rhs
 
   private def competingMethodsIterator(meth: Symbol): Iterator[Symbol] =
     cls.baseClasses.iterator

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

@@ -20,7 +20,6 @@ import Decorators.*
  *  The phase also replaces all expressions that appear in an erased context by
  *  default values. This is necessary so that subsequent checking phases such
  *  as IsInstanceOfChecker don't give false negatives.
- *  Finally, the phase drops (language-) imports.
  */
 class PruneErasedDefs extends MiniPhase with SymTransformer { thisTransform =>
   import tpd._
@@ -56,18 +55,10 @@ class PruneErasedDefs extends MiniPhase with SymTransformer { thisTransform =>
     checkErasedInExperimental(tree.symbol)
     tree
 
-  override def transformOther(tree: Tree)(using Context): Tree = tree match
-    case tree: Import => EmptyTree
-    case _ => tree
-
   def checkErasedInExperimental(sym: Symbol)(using Context): Unit =
     // Make an exception for Scala 2 experimental macros to allow dual Scala 2/3 macros under non experimental mode
     if sym.is(Erased, butNot = Macro) && sym != defn.Compiletime_erasedValue && !sym.isInExperimentalScope then
       Feature.checkExperimentalFeature("erased", sym.sourcePos)
-
-  override def checkPostCondition(tree: Tree)(using Context): Unit = tree match
-    case _: tpd.Import => assert(false, i"illegal tree: $tree")
-    case _ =>
 }
 
 object PruneErasedDefs {

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

@@ -134,7 +134,7 @@ class TreeChecker extends Phase with SymTransformer {
 
     val checkingCtx = ctx
         .fresh
-        .setMode(Mode.ImplicitsEnabled)
+        .addMode(Mode.ImplicitsEnabled)
         .setReporter(new ThrowingReporter(ctx.reporter))
 
     val checker = inContext(ctx) {

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

@@ -20,6 +20,10 @@ import ast.Trees.mods
 object Nullables:
   import ast.tpd._
 
+  def importUnsafeNulls(using Context): Import = Import(
+    ref(defn.LanguageModule),
+    List(untpd.ImportSelector(untpd.Ident(nme.unsafeNulls), EmptyTree, EmptyTree)))
+
   inline def unsafeNullsEnabled(using Context): Boolean =
     ctx.explicitNulls && !ctx.mode.is(Mode.SafeNulls)
 

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

@@ -1059,7 +1059,18 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     val (stats1, exprCtx) = withoutMode(Mode.Pattern) {
       typedBlockStats(tree.stats)
     }
-    val expr1 = typedExpr(tree.expr, pt.dropIfProto)(using exprCtx)
+    var expr1 = typedExpr(tree.expr, pt.dropIfProto)(using exprCtx)
+
+    // If unsafe nulls is enabled inside a block but not enabled outside
+    // and the type does not conform the expected type without unsafe nulls,
+    // we will cast the last expression to the expected type.
+    // See: tests/explicit-nulls/pos/unsafe-block.scala
+    if ctx.mode.is(Mode.SafeNulls)
+      && !exprCtx.mode.is(Mode.SafeNulls)
+      && pt.isValueType
+      && !inContext(exprCtx.addMode(Mode.SafeNulls))(expr1.tpe <:< pt) then
+      expr1 = expr1.cast(pt)
+
     ensureNoLocalRefs(
       cpy.Block(tree)(stats1, expr1)
         .withType(expr1.tpe)

tests/explicit-nulls/pos/unsafe-block.scala

@@ -0,0 +1,67 @@
+def trim(x: String | Null): String =
+  import scala.language.unsafeNulls
+  // The type of `x.trim()` is `String | Null`.
+  // Although `String | Null` conforms the expected type `String`,
+  // we still need to cast the expression to the expected type here,
+  // because outside the scope we don't have `unsafeNulls` anymore.
+  x.trim()
+
+class TestDefs:
+
+  def f1: String | Null = null
+  def f2: Array[String | Null] | Null = null
+  def f3: Array[String] | Null = null
+
+  def h1a: String =
+    import scala.language.unsafeNulls
+    f1
+
+  def h1b: String | Null =
+    import scala.language.unsafeNulls
+    f1
+
+  def h2a: Array[String] =
+    import scala.language.unsafeNulls
+    f2
+
+  def h2b: Array[String | Null] =
+    import scala.language.unsafeNulls
+    f2
+
+  def h3a: Array[String] =
+    import scala.language.unsafeNulls
+    f3
+
+  def h3b: Array[String | Null] =
+    import scala.language.unsafeNulls
+    f3
+
+class TestVals:
+
+  val f1: String | Null = null
+  val f2: Array[String | Null] | Null = null
+  val f3: Array[String] | Null = null
+
+  val h1a: String =
+    import scala.language.unsafeNulls
+    f1
+
+  val h1b: String | Null =
+    import scala.language.unsafeNulls
+    f1
+
+  val h2a: Array[String] =
+    import scala.language.unsafeNulls
+    f2
+
+  val h2b: Array[String | Null] =
+    import scala.language.unsafeNulls
+    f2
+
+  val h3a: Array[String] =
+    import scala.language.unsafeNulls
+    f3
+
+  val h3b: Array[String | Null] =
+    import scala.language.unsafeNulls
+    f3

tests/explicit-nulls/pos/unsafe-chain.scala

@@ -1,10 +1,21 @@
 import java.nio.file.FileSystems
 import java.util.ArrayList
 
-def directorySeparator: String =
-  import scala.language.unsafeNulls
-  FileSystems.getDefault().getSeparator()
+class A:
+
+  def directorySeparator: String =
+    import scala.language.unsafeNulls
+    FileSystems.getDefault().getSeparator()
+
+  def getFirstOfFirst(xs: ArrayList[ArrayList[ArrayList[String]]]): String =
+    import scala.language.unsafeNulls
+    xs.get(0).get(0).get(0)
 
-def getFirstOfFirst(xs: ArrayList[ArrayList[ArrayList[String]]]): String =
+class B:
   import scala.language.unsafeNulls
-  xs.get(0).get(0).get(0)
+
+  def directorySeparator: String =
+    FileSystems.getDefault().getSeparator()
+
+  def getFirstOfFirst(xs: ArrayList[ArrayList[ArrayList[String]]]): String =
+    xs.get(0).get(0).get(0)