Add ctx.explicitNulls helper method to context

Author: abeln

compiler/src/dotty/tools/backend/jvm/scalaPrimitives.scala

@@ -156,7 +156,7 @@ class DottyPrimitives(ctx: Context) {
     addPrimitive(defn.Any_##, HASH)
 
     // java.lang.Object
-    if (ctx.settings.YexplicitNulls.value) {
+    if (ctx.explicitNulls) {
       // scala.RefEq
       addPrimitive(defn.RefEq_eq, ID)
       addPrimitive(defn.RefEq_ne, NI)

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

@@ -427,6 +427,9 @@ object Contexts {
     def useColors: Boolean =
       base.settings.color.value == "always"
 
+    /** Is the explicit nulls option set? */
+    def explicitNulls: Boolean = base.settings.YexplicitNulls.value
+
     protected def init(outer: Context, origin: Context): this.type = {
       util.Stats.record("Context.fresh")
       _outer = outer

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

@@ -286,11 +286,7 @@ class Definitions {
   lazy val ObjectClass: ClassSymbol = {
     val cls = ctx.requiredClass("java.lang.Object")
     assert(!cls.isCompleted, "race for completing java.lang.Object")
-    val parents = if (ctx.settings.YexplicitNulls.value) {
-      AnyType :: RefEqType :: Nil
-    } else {
-      AnyType :: Nil
-    }
+    val parents = if (ctx.explicitNulls) AnyType :: RefEqType :: Nil else AnyType :: Nil
     cls.info = ClassInfo(cls.owner.thisType, cls, parents, newScope)
     cls.setFlag(NoInits)
 
@@ -309,12 +305,12 @@ class Definitions {
   def AnyRefType: TypeRef = AnyRefAlias.typeRef
 
     // TODO(abeln): modify usage sites to use `RefEq_eq/ne` once we migrate to explicit nulls?
-    lazy val Object_eq: TermSymbol = if (ctx.settings.YexplicitNulls.value) {
+    lazy val Object_eq: TermSymbol = if (ctx.explicitNulls) {
       RefEq_eq
     } else {
       enterMethod(ObjectClass, nme.eq, methOfAnyRef(BooleanType), Final)
     }
-    lazy val Object_ne: TermSymbol = if (ctx.settings.YexplicitNulls.value) {
+    lazy val Object_ne: TermSymbol = if (ctx.explicitNulls) {
       RefEq_ne
     } else {
       enterMethod(ObjectClass, nme.ne, methOfAnyRef(BooleanType), Final)
@@ -353,7 +349,7 @@ class Definitions {
 
   /** Method representing a throw */
   lazy val throwMethod: TermSymbol = {
-    val argTpe = if (ctx.settings.YexplicitNulls.value) {
+    val argTpe = if (ctx.explicitNulls) {
       OrType(ThrowableType, NullType)
     } else {
       ThrowableType
@@ -372,30 +368,30 @@ class Definitions {
    *  `RefEq` is just a marker trait and there's no corresponding class file, since it gets erased to `Object`.
    */
   lazy val RefEqClass: ClassSymbol = {
-    assert(ctx.settings.YexplicitNulls.value)
+    assert(ctx.explicitNulls)
     enterCompleteClassSymbol(ScalaPackageClass, tpnme.RefEq, Trait, AnyClass.typeRef :: Nil)
   }
   def RefEqType: TypeRef = {
-    assert(ctx.settings.YexplicitNulls.value)
+    assert(ctx.explicitNulls)
     RefEqClass.typeRef
   }
 
     lazy val RefEq_eq: TermSymbol = {
-      assert(ctx.settings.YexplicitNulls.value)
+      assert(ctx.explicitNulls)
       enterMethod(RefEqClass, nme.eq, MethodType(List(RefEqType), BooleanType), Final)
     }
     lazy val RefEq_ne: TermSymbol = {
-      assert(ctx.settings.YexplicitNulls.value)
+      assert(ctx.explicitNulls)
       enterMethod(RefEqClass, nme.ne, MethodType(List(RefEqType), BooleanType), Final)
     }
 
     def RefEqMethods: List[TermSymbol] = {
-      assert(ctx.settings.YexplicitNulls.value)
+      assert(ctx.explicitNulls)
       List(RefEq_eq, RefEq_ne)
     }
 
   lazy val NullClass: ClassSymbol = {
-    val parents = if (ctx.settings.YexplicitNulls.value) {
+    val parents = if (ctx.explicitNulls) {
       List(AnyType, RefEqType)
     } else {
       List(ObjectType)
@@ -416,11 +412,11 @@ class Definitions {
    *  ```
    */
   lazy val JavaNullAlias: TypeSymbol = {
-    assert(ctx.settings.YexplicitNulls.value)
+    assert(ctx.explicitNulls)
     enterAliasType(tpnme.JavaNull, NullType)
   }
   def JavaNullAliasType: TypeRef = {
-    assert(ctx.settings.YexplicitNulls.value)
+    assert(ctx.explicitNulls)
     JavaNullAlias.typeRef
   }
 
@@ -661,14 +657,14 @@ class Definitions {
   lazy val ClassCastExceptionClass: ClassSymbol   = ctx.requiredClass("java.lang.ClassCastException")
     lazy val ClassCastExceptionClass_stringConstructor: TermSymbol  = ClassCastExceptionClass.info.member(nme.CONSTRUCTOR).suchThat(_.info.firstParamTypes match {
       case List(pt) =>
-        val pt1 = if (ctx.settings.YexplicitNulls.value) pt.stripNull else pt
+        val pt1 = if (ctx.explicitNulls) pt.stripNull else pt
         pt1 isRef StringClass
       case _ => false
     }).symbol.asTerm
   lazy val ArithmeticExceptionClass: ClassSymbol  = ctx.requiredClass("java.lang.ArithmeticException")
     lazy val ArithmeticExceptionClass_stringConstructor: TermSymbol  = ArithmeticExceptionClass.info.member(nme.CONSTRUCTOR).suchThat(_.info.firstParamTypes match {
       case List(pt) =>
-        val pt1 = if (ctx.settings.YexplicitNulls.value) pt.stripNull else pt
+        val pt1 = if (ctx.explicitNulls) pt.stripNull else pt
         pt1 isRef StringClass
       case _ => false
     }).symbol.asTerm
@@ -1123,7 +1119,7 @@ class Definitions {
       name.drop(prefix.length).forall(_.isDigit))
 
   def isBottomClass(cls: Symbol): Boolean = {
-    if (ctx.settings.YexplicitNulls.value && !ctx.phase.erasedTypes) cls == NothingClass
+    if (ctx.explicitNulls && !ctx.phase.erasedTypes) cls == NothingClass
     else isBottomClassAfterErasure(cls)
   }
 
@@ -1132,7 +1128,7 @@ class Definitions {
   }
 
   def isBottomType(tp: Type): Boolean = {
-    if (ctx.settings.YexplicitNulls.value && !ctx.phase.erasedTypes) tp.derivesFrom(NothingClass)
+    if (ctx.explicitNulls && !ctx.phase.erasedTypes) tp.derivesFrom(NothingClass)
     else isBottomTypeAfterErasure(tp)
   }
 
@@ -1254,7 +1250,7 @@ class Definitions {
 
   lazy val NotRuntimeClasses: Set[Symbol] = {
     val classes: Set[Symbol] = Set(AnyClass, AnyValClass, NullClass, NothingClass)
-    if (ctx.settings.YexplicitNulls.value) {
+    if (ctx.explicitNulls) {
       classes + RefEqClass
     } else {
       classes
@@ -1462,7 +1458,7 @@ class Definitions {
         .updated(SingletonClass, ObjectClass)
         .updated(TupleClass, ObjectClass)
         .updated(NonEmptyTupleClass, ProductClass)
-    if (ctx.settings.YexplicitNulls.value) {
+    if (ctx.explicitNulls) {
       idMap.updated(RefEqClass, ObjectClass)
     } else {
       idMap
@@ -1487,7 +1483,7 @@ class Definitions {
       SingletonClass,
       EqualsPatternClass)
 
-    if (ctx.settings.YexplicitNulls.value) synth ++ List(JavaNullAlias, RefEqClass)
+    if (ctx.explicitNulls) synth ++ List(JavaNullAlias, RefEqClass)
     else synth
   }
 
@@ -1498,7 +1494,7 @@ class Definitions {
   /** Lists core methods that don't have underlying bytecode, but are synthesized on-the-fly in every reflection universe */
   lazy val syntheticCoreMethods: List[TermSymbol] = {
     val methods = AnyMethods ++ ObjectMethods ++ List(String_+, throwMethod)
-    if (ctx.settings.YexplicitNulls.value) {
+    if (ctx.explicitNulls) {
       methods ++ RefEqMethods
     } else {
       methods

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

@@ -26,7 +26,7 @@ object FlowTyper {
    *  If the precision of the type can't be improved, then returns the type unchanged.
    */
   def refineType(tpe: Type)(implicit ctx: Context): Type = {
-    assert(ctx.settings.YexplicitNulls.value)
+    assert(ctx.explicitNulls)
     tpe match {
       case tref: TermRef if ctx.flowFacts.contains(tref) =>
         NonNullTermRef.fromTermRef(tref)
@@ -98,7 +98,7 @@ object FlowTyper {
    *   NN(cond,      _)     = {} otherwise
    */
   def inferFromCond(cond: Tree)(implicit ctx: Context): Inferred = {
-    assert(ctx.settings.YexplicitNulls.value)
+    assert(ctx.explicitNulls)
     /** Combine two sets of facts according to `op`. */
     def combine(lhs: Inferred, op: Name, rhs: Inferred): Inferred = {
       op match {
@@ -176,7 +176,7 @@ object FlowTyper {
    *  ```
    */
   def inferWithinCond(cond: Tree)(implicit ctx: Context): FlowFacts = {
-    assert(ctx.settings.YexplicitNulls.value)
+    assert(ctx.explicitNulls)
     cond match {
       case Select(lhs, op) if op == nme.ZAND || op == nme.ZOR =>
         val Inferred(ifTrue, ifFalse) = inferFromCond(lhs)
@@ -223,7 +223,7 @@ object FlowTyper {
         s.tpe.isBottomType
     }
 
-    assert(ctx.settings.YexplicitNulls.value)
+    assert(ctx.explicitNulls)
     stat match {
       case If(cond, thenExpr, elseExpr) =>
         val Inferred(ifTrue, ifFalse) = inferFromCond(cond)

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

@@ -44,7 +44,7 @@ object JavaNullInterop {
    *  But the selection can throw an NPE if the returned value is `null`.
    */
   def nullifyMember(sym: Symbol, tp: Type)(implicit ctx: Context): Type = {
-    assert(ctx.settings.YexplicitNulls.value)
+    assert(ctx.explicitNulls)
     assert(sym.is(JavaDefined), "can only nullify java-defined members")
 
     // A list of members that are special-cased.

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

@@ -690,7 +690,7 @@ object SymDenotations {
 
     /** Is this symbol a class of which `null` is a value? */
     final def isNullableClass(implicit ctx: Context): Boolean = {
-      if (ctx.settings.YexplicitNulls.value && !ctx.phase.erasedTypes) {
+      if (ctx.explicitNulls && !ctx.phase.erasedTypes) {
         symbol == defn.NullClass || symbol == defn.AnyClass
       } else {
         isNullableClassAfterErasure

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

@@ -353,7 +353,7 @@ object Types {
 
     /** Is this (after widening and dealiasing) a type of the form `T | Null`? */
     def isNullableUnion(implicit ctx: Context): Boolean = {
-      assert(ctx.settings.YexplicitNulls.value)
+      assert(ctx.explicitNulls)
       this.widenDealias.normNullableUnion match {
         case OrType(_, right) => right.isNullType
         case _ => false
@@ -362,7 +362,7 @@ object Types {
 
     /** Is this type exactly `JavaNull` (no vars, aliases, refinements etc allowed)? */
     def isJavaNullType(implicit ctx: Context): Boolean = {
-      assert(ctx.settings.YexplicitNulls.value)
+      assert(ctx.explicitNulls)
       // We can't do `this == defn.JavaNull` because when trees are unpickled new references
       // to `JavaNull` could be created that are different from `defn.JavaNull`.
       // Instead, we compare the symbol.
@@ -371,7 +371,7 @@ object Types {
 
     /** Is this (after widening and dealiasing) a type of the form `T | JavaNull`? */
     def isJavaNullableUnion(implicit ctx: Context): Boolean = {
-      assert(ctx.settings.YexplicitNulls.value)
+      assert(ctx.explicitNulls)
       def peelOff(tpe: Type): Boolean = tpe match {
         case OrType(left, right) =>
           right.isJavaNullType || right.isNullType && peelOff(left)
@@ -401,7 +401,7 @@ object Types {
      *  e.g. `Null | (T1 | Null) | T2` => `T1 | T2 | Null | Null`
      */
     def normNullableUnion(implicit ctx: Context): Type = {
-      assert(ctx.settings.YexplicitNulls.value)
+      assert(ctx.explicitNulls)
       def split(tp: Type, nonNull: List[Type], nll: List[Type]): (List[Type], List[Type]) = {
         tp match {
           case OrType(left, right) =>
@@ -420,7 +420,7 @@ object Types {
 
     /** Strips types according to `stripPred` from a nullable union. */
     private def stripNullWithPred(stripPred: Type => Boolean)(implicit ctx: Context): Type = {
-      assert(ctx.settings.YexplicitNulls.value)
+      assert(ctx.explicitNulls)
       def strip(tp: Type, changed: Boolean): (Type, Boolean) = {
         tp match {
           case OrType(left, right) if right.isNullType =>
@@ -445,13 +445,13 @@ object Types {
      *  If this type isn't (syntactically) nullable, then returns the type unchanged.
      */
     def stripNull(implicit ctx: Context): Type = {
-      assert(ctx.settings.YexplicitNulls.value)
+      assert(ctx.explicitNulls)
       stripNullWithPred(_.isNullType)
     }
 
     /** Like `stripNull`, but removes only the `JavaNull`s. */
     def stripJavaNull(implicit ctx: Context): Type = {
-      assert(ctx.settings.YexplicitNulls.value)
+      assert(ctx.explicitNulls)
       stripNullWithPred(_.isJavaNullType)
     }
 
@@ -461,7 +461,7 @@ object Types {
      *  If no `JavaNull` unions are found within the type, then returns the input type unchanged.
      */
     def stripAllJavaNull(implicit ctx: Context): Type = {
-      assert(ctx.settings.YexplicitNulls.value)
+      assert(ctx.explicitNulls)
       var diff = false
       object RemoveNulls extends TypeMap {
         override def apply(tp: Type): Type = tp match {
@@ -477,7 +477,7 @@ object Types {
 
     /** Injects this type into a union with `JavaNull`. */
     def toJavaNullableUnion(implicit ctx: Context): Type = {
-      assert(ctx.settings.YexplicitNulls.value)
+      assert(ctx.explicitNulls)
       if (this.isJavaNullableUnion) this
       else OrType(this, defn.JavaNullAliasType)
     }
@@ -563,7 +563,7 @@ object Types {
         val rsym = r.classSymbol
         if (lsym isSubClass rsym) rsym
         else if (rsym isSubClass lsym) lsym
-        else if (ctx.settings.YexplicitNulls.value && this.isNullableUnion) {
+        else if (ctx.explicitNulls && this.isNullableUnion) {
           val OrType(left, _) = this.normNullableUnion
           // If `left` is a reference type, then the class LUB of `left | Null` is `RefEq`.
           // This is another one-of case that keeps this method sound, but not complete.
@@ -728,7 +728,7 @@ object Types {
         case AndType(l, r) =>
           goAnd(l, r)
         case tp: OrType =>
-          if (ctx.settings.YexplicitNulls.value && tp.isJavaNullableUnion) {
+          if (ctx.explicitNulls && tp.isJavaNullableUnion) {
             // Selecting `name` from a type `T|JavaNull` is like selecting `name` from `T`.
             // This can throw at runtime, but we trade soundness for usability.
             // We need to strip `JavaNull` from both the type and the prefix so that
@@ -1192,7 +1192,7 @@ object Types {
      */
     def widenUnion(implicit ctx: Context): Type = this match {
       case OrType(tp1, tp2) =>
-        if (ctx.settings.YexplicitNulls.value && isNullableUnion) {
+        if (ctx.explicitNulls && isNullableUnion) {
           // Don't widen `T|Null`, since otherwise we wouldn't be able to infer nullable unions.
           val OrType(leftTpe, nullTpe) = normNullableUnion
           OrType(leftTpe.widenUnion, nullTpe)
@@ -1981,7 +1981,7 @@ object Types {
 
       def finish(d: Denotation): Denotation = {
         if (d.exists) {
-          val d1 = if (ctx.settings.YexplicitNulls.value && this.isInstanceOf[NonNullTermRef]) {
+          val d1 = if (ctx.explicitNulls && this.isInstanceOf[NonNullTermRef]) {
             // If the denotation is computed for the first time, or if it's ever updated, make sure
             // that the `info` is non-null.
             d.mapInfo(_.stripNull)
@@ -2467,7 +2467,7 @@ object Types {
 
     /** Create a `TermRef` that's just like `tref`, but whose `info` is always non-null. */
     def fromTermRef(tref: TermRef)(implicit ctx: Context): NonNullTermRef = {
-      assert(ctx.settings.YexplicitNulls.value)
+      assert(ctx.explicitNulls)
       val denot = tref.denot.mapInfo(_.stripNull)
       val nn = new NonNullTermRef(tref.prefix, denot.symbol)
       // We need to set the non-null denotation directly because normally the "non-nullable" denotations

compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala

@@ -270,7 +270,7 @@ class ClassfileParser(
         if ((denot is Flags.Method) && (jflags & JAVA_ACC_VARARGS) != 0)
           denot.info = arrayToRepeated(denot.info)
 
-        if (ctx.settings.YexplicitNulls.value) {
+        if (ctx.explicitNulls) {
           denot.info = JavaNullInterop.nullifyMember(denot.symbol, denot.info)
         }
 

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

@@ -59,7 +59,7 @@ class Erasure extends Phase with DenotTransformer {
             if (!decl.isConstructor) extendedScope.enter(decl)
         }
         addDecls(defn.AnyClass)
-        if (ctx.settings.YexplicitNulls.value) {
+        if (ctx.explicitNulls) {
           addDecls(defn.RefEqClass)
         }
         ref.copySymDenotation(
@@ -75,7 +75,7 @@ class Erasure extends Phase with DenotTransformer {
         else oldSymbol
         val oldOwner = ref.owner
         val newOwner = {
-          val shouldBeObject = if (ctx.settings.YexplicitNulls.value) {
+          val shouldBeObject = if (ctx.explicitNulls) {
             (oldOwner eq defn.AnyClass) || (oldOwner eq defn.RefEqClass)
           } else {
             oldOwner eq defn.AnyClass

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

@@ -50,7 +50,7 @@ class FirstTransform extends MiniPhase with InfoTransformer { thisPhase =>
   override def checkPostCondition(tree: Tree)(implicit ctx: Context): Unit = {
     tree match {
       case Select(qual, name) if !name.is(OuterSelectName) && tree.symbol.exists =>
-        val qualTpe = if (ctx.settings.YexplicitNulls.value) {
+        val qualTpe = if (ctx.explicitNulls) {
           // `JavaNull` is already special-cased in the Typer, but needs to be handled here as well.
           // We need `stripAllJavaNull` and not `stripJavaNull` because of the following case:
           //