clean code

Author: noti0na1

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

@@ -7,15 +7,13 @@ import Periods._
 import Symbols._
 import Types._
 import Scopes._
-import StdNames.nme
 import Names.Name
 import Denotations.Denotation
 import typer.Typer
 import typer.ImportInfo._
 import Decorators._
 import io.{AbstractFile, PlainFile, VirtualFile}
 import Phases.unfusedPhases
-import config.Feature
 
 import util._
 import reporting.Reporter

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

@@ -10,12 +10,10 @@ import core._
 import util.Spans._, Types._, Contexts._, Constants._, Names._, Flags._, NameOps._
 import Symbols._, StdNames._, Annotations._, Trees._, Symbols._
 import Decorators._, DenotTransformers._
-import Phases._
 import collection.{immutable, mutable}
 import util.{Property, SourceFile, NoSource}
 import NameKinds.{TempResultName, OuterSelectName}
 import typer.ConstFold
-import typer.Nullables
 
 import scala.annotation.tailrec
 import scala.io.Codec
@@ -471,7 +469,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
 
   /** The wrapped array method name for an array of type elemtp */
   def wrapArrayMethodName(elemtp: Type)(using Context): TermName = {
-    val elemCls = atPhase(erasurePhase.next) { elemtp.classSymbol }
+    val elemCls = elemtp.classSymbol
     if (elemCls.isPrimitiveValueClass) nme.wrapXArray(elemCls.name)
     else if (elemCls.derivesFrom(defn.ObjectClass) && !elemCls.isNotRuntimeClass) nme.wrapRefArray
     else nme.genericWrapArray

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

@@ -211,4 +211,4 @@ class CheckRealizable(using Context) {
     else
       Realizable
   }
-}
+}

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

@@ -20,7 +20,6 @@ import Nullables._
 import Implicits.ContextualImplicits
 import config.Settings._
 import config.Config
-import config.Feature
 import reporting._
 import io.{AbstractFile, NoAbstractFile, PlainFile, Path}
 import scala.io.Codec
@@ -29,6 +28,7 @@ import printing._
 import config.{JavaPlatform, SJSPlatform, Platform, ScalaSettings}
 import classfile.ReusableDataReader
 import StdNames.nme
+
 import scala.annotation.internal.sharable
 
 import DenotTransformers.DenotTransformer

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

@@ -1218,7 +1218,8 @@ class Definitions {
     idx == name.length || name(idx).isDigit && digitsOnlyAfter(name, idx + 1)
 
   def isBottomClass(cls: Symbol): Boolean =
-    if ctx.explicitNulls && !ctx.phase.erasedTypes then cls == NothingClass
+    if ctx.mode.is(Mode.SafeNulls) && !ctx.phase.erasedTypes
+    then cls == NothingClass
     else isBottomClassAfterErasure(cls)
 
   def isBottomClassAfterErasure(cls: Symbol): Boolean = cls == NothingClass || cls == NullClass

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

@@ -127,10 +127,4 @@ object Mode {
    *  This mode forces expansion of inline calls in those positions even during typing.
    */
   val ForceInline: Mode = newMode(29, "ForceInline")
-
-  /** Should we use Unsafe Nulls SubTyping in TypeComparer?
-   *  If this mode is in the Context, `Null` is considered as a
-   *  subtype of all reference type.
-   */
-  val UnsafeNullsSubType: Mode = newMode(30, "UnsafeNullsSubType")
 }

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

@@ -761,11 +761,7 @@ 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 =>
-                if ctx.explicitNulls && ctx.mode.is(Mode.UnsafeNullsSubType) then
-                  tp.symbol.isNullableClassAfterErasure
-                else
-                  tp.symbol.isNullableClass
+              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)

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

@@ -797,11 +797,9 @@ class Typer extends Namer
         // A sequence argument `xs: _*` can be either a `Seq[T]` or an `Array[_ <: T]`,
         // irrespective of whether the method we're calling is a Java or Scala method,
         // so the expected type is the union `Seq[T] | Array[_ <: T]`.
-        // If unsafe nulls is enabled, the expected type is `Seq[T | Null] | Array[_ <: T | Null] | Null`.
-        val unsafeNulls = Nullables.unsafeNullsEnabled
         val ptArg =
           // FIXME(#8680): Quoted patterns do not support Array repeated arguments
-          if (ctx.mode.is(Mode.QuotedPattern))
+          if ctx.mode.is(Mode.QuotedPattern) then
             pt.translateFromRepeated(toArray = false, translateWildcard = true)
           else
             pt.translateFromRepeated(toArray = false, translateWildcard = true)
@@ -815,7 +813,7 @@ class Typer extends Namer
               // We need to make sure its type is no longer nullable
               expr0.castToNonNullable
           else expr0
-        val fromCls = if expr1.tpe.stripNull.derivesFrom(defn.ArrayClass)
+        val fromCls = if expr1.tpe.derivesFrom(defn.ArrayClass)
           then defn.ArrayClass else defn.SeqClass
         val tpt1 = TypeTree(expr1.tpe.widen.translateToRepeated(fromCls)).withSpan(tree.tpt.span)
         assignType(cpy.Typed(tree)(expr1, tpt1), tpt1)
@@ -3866,4 +3864,4 @@ class Typer extends Namer
           EmptyTree
     else typedExpr(call, defn.AnyType)
 
-}
+}