Update doc and clean code

Author: noti0na1

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

@@ -400,16 +400,15 @@ class TypeApplications(val self: Type) extends AnyVal {
     case _ => if (self.isMatch) MatchAlias(self) else TypeAlias(self)
   }
 
-  /** Translate a type of the form From[T] to either To[T] or To[? <: T] (if `wildcardArg` is set).
-   *  Keep other types as they are.
+  /** Translate a type of the form From[T] to either To[T] or To[? <: T] (if `wildcardArg` is set). Keep other types as they are.
    *  `from` and `to` must be static classes, both with one type parameter, and the same variance.
    *  Do the same for by name types => From[T] and => To[T]
    */
-  def translateParameterized(from: ClassSymbol, to: ClassSymbol, wildcardArg: Boolean = false)(using Context): Type = self match
+  def translateParameterized(from: ClassSymbol, to: ClassSymbol, wildcardArg: Boolean = false)(using Context): Type = self match {
     case self @ ExprType(tp) =>
       self.derivedExprType(tp.translateParameterized(from, to))
     case _ =>
-      if self.derivesFrom(from) then
+      if (self.derivesFrom(from)) {
         def elemType(tp: Type): Type = tp.widenDealias match
           case tp: OrType =>
             if tp.tp1.isBottomType then elemType(tp.tp2)
@@ -420,12 +419,15 @@ class TypeApplications(val self: Type) extends AnyVal {
         val arg = elemType(self)
         val arg1 = if (wildcardArg) TypeBounds.upper(arg) else arg
         to.typeRef.appliedTo(arg1)
+      }
       else self
+  }
 
   /** If this is a repeated parameter `*T`, translate it to either `Seq[T]` or
    *  `Array[? <: T]` depending on the value of `toArray`.
    *  Additionally, if `translateWildcard` is true, a wildcard type
-   *  will be translated to `*<?>`. Other types are kept as-is.
+   *  will be translated to `*<?>`.
+   *  Other types are kept as-is.
    */
   def translateFromRepeated(toArray: Boolean, translateWildcard: Boolean = false)(using Context): Type =
     val seqClass = if (toArray) defn.ArrayClass else defn.SeqClass

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

@@ -12,7 +12,6 @@ import transform.TypeUtils._
 import transform.ContextFunctionResults._
 import unpickleScala2.Scala2Erasure
 import Decorators._
-import NullOpsDecorator._
 import Definitions.MaxImplementedFunctionArity
 import scala.annotation.tailrec
 
@@ -566,9 +565,6 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst
 
   private def eraseArray(tp: Type)(using Context) = {
     val defn.ArrayOf(elemtp) = tp
-    // println(elemtp.show)
-    // println(isUnboundedGeneric(elemtp))
-    // println()
     if (classify(elemtp).derivesFrom(defn.NullClass)) JavaArrayType(defn.ObjectType)
     else if (isUnboundedGeneric(elemtp) && !sourceLanguage.isJava) defn.ObjectType
     else JavaArrayType(erasureFn(sourceLanguage, semiEraseVCs = false, isConstructor, wildcardOK)(elemtp))

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

@@ -1084,6 +1084,10 @@ object Types {
      *
      *  (*) when matching with a Java method, we also regard Any and Object as equivalent
      *      parameter types.
+     *
+     *  Under explicit nulls, this function will always use unsafe-nulls semamtics to
+     *  check the types. This is because we are using a relaxed rule (ignoring `Null` types)
+     *  to check overriding Java methods.
      */
     def matches(that: Type)(using Context): Boolean = {
       record("matches")

docs/docs/internals/explicit-nulls.md

@@ -87,24 +87,14 @@ we don't have a type that is a supertype of `Null` and a subtype of `String`.
 Hence, when we read a type bound from Scala 2 Tasty or Scala 3 Tasty, the upper bound is nullified if the lower
 bound is exactly `Null`. The example above would become `class C[T >: Null <: String | Null]`.
 
-## Unsafe Nulls
+## Unsafe Nulls Feature and SafeNulls Mode
 
 The `unsafeNulls` language feature is currently disabled by default. It can be enabled by importing `scala.language.unsafeNulls` or using `-language:unsafeNulls`. The feature object is defined in `library/src/scalaShadowing/language.scala`. We can use `config.Feature.enabled(nme.unsafeNulls)` to check if this feature is enabled.
 
-The unsafe nulls conversion could happen if:
-1. the explicit nulls flag is enabled, and
-2. `unsafeNulls` language feature is enabled, or `UnsafeNullConversion` mode is in the context.
-
-The reason to use the `UnsafeNullConversion` mode is because the current context may not see the language feature. For example, implicit search could run in some different contexts.
+We use the `SafeNulls` mode to track `unsafeNulls`. If explicit nulls is enabled without `unsafeNulls`, there is a `SafeNulls` mode in the context; when `unsafeNulls` is enabled, `SafeNulls` mode will be removed from the context.
 
 Since we want to allow selecting member on nullable values, when searching a member of a type, the `| Null` part should be ignored. See `goOr` in `Types.scala`.
 
-During adapting, if the type of the tree is not a subtype of the expected type, the `adaptToSubType` in `Typer.scala` will run. The implicit search is invoked to find conversions for the tree. Since implicit search (finding candidates and trying to type the new tree) could run in some different contexts, we have to pass the `UnsafeNullConversion` mode to the search context.
-
-The SAM type conversion also happens in `adaptToSubType`. We need to strip `Null` from `pt` in order to get class information.
-
-We need to modify the overloading resolution as well. The `isCompatible` and `necessarilyCompatible` functions in `ProtoTypes.scala` are used to compare types for overloading resolution. When `unsafeNulls` is enabled, we need to strip all nulls from the type before comparison.
-
 ## Flow Typing
 
 As typing happens, we accumulate a set of `NotNullInfo`s in the `Context` (see