Fix typo and move logic ops to next line

Author: noti0na1

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

@@ -82,7 +82,7 @@ object NullOpsDecorator {
 
     /** Can we convert a tree with type `self` to type `pt` unsafely.
      */
-    def isUnsafelyConvertable(pt: Type, relaxedSubtype: Boolean = false)(using Context): Boolean =
+    def isUnsafelyConvertible(pt: Type, relaxedSubtype: Boolean = false)(using Context): Boolean =
       self.isUnsafelyNulltoAnyRef(pt) || self.isUnsafeSubtype(pt, relaxedSubtype)
   }
 }

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

@@ -151,8 +151,9 @@ object ErrorReporting {
         case _ => Nil
       if foundWithoutNull then
         i""".
-          |Since explicit-nulls is enabled, ${qualType.widen} could have null value during runtime.
-          |If you want to select ${tree.name} without checking the nullity,
+          |Since explicit-nulls is enabled, the selection is rejected because
+          |${qualType.widen} could be null at runtime.
+          |If you want to select ${tree.name} without checking for a null value,
           |insert a .nn before .${tree.name} or import scala.language.unsafeNulls."""
       else if qualType.derivesFrom(defn.DynamicClass) then
         "\npossible cause: maybe a wrong Dynamic method signature?"

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

@@ -306,8 +306,8 @@ object Implicits:
       val refs: List[ImplicitRef],
       val outerImplicits: ContextualImplicits,
       isImport: Boolean)(initctx: Context) extends ImplicitRefs(initctx) {
-    private val eligibleCache = EqHashMap[Type, List[Candidate]]()
-    private val eligibleCacheUnsafeNulls = EqHashMap[Type, List[Candidate]]()
+    private var eligibleCache: EqHashMap[Type, List[Candidate]] = null
+    private var eligibleCacheUnsafeNulls: EqHashMap[Type, List[Candidate]] = null
 
     /** The level increases if current context has a different owner or scope than
      *  the context of the next-outer ImplicitRefs. This is however disabled under
@@ -335,7 +335,19 @@ object Implicits:
 
     /** The implicit references that are eligible for type `tp`. */
     def eligible(tp: Type, enableUnsafeNulls: Boolean = false): List[Candidate] =
-      def searchWithCache(cache: EqHashMap[Type, List[Candidate]]) = {
+      if tp.hash == NotCached then
+        Stats.record(i"compute eligible not cached ${tp.getClass}")
+        Stats.record(i"compute eligible not cached")
+        computeEligible(tp, enableUnsafeNulls)
+      else
+        val cache = if enableUnsafeNulls then
+          if eligibleCacheUnsafeNulls == null then
+            eligibleCacheUnsafeNulls = EqHashMap[Type, List[Candidate]]()
+          eligibleCacheUnsafeNulls
+        else
+          if eligibleCache == null then
+            eligibleCache = EqHashMap[Type, List[Candidate]]()
+          eligibleCache
         val eligibles = cache.lookup(tp)
         if eligibles != null then
           Stats.record("cached eligible")
@@ -346,24 +358,16 @@ object Implicits:
           val result = computeEligible(tp, enableUnsafeNulls)
           cache(tp) = result
           result
-      }
-      if tp.hash == NotCached then
-        Stats.record(i"compute eligible not cached ${tp.getClass}")
-        Stats.record(i"compute eligible not cached")
-        computeEligible(tp, enableUnsafeNulls)
-      else if enableUnsafeNulls then
-        searchWithCache(eligibleCacheUnsafeNulls)
-      else
-        searchWithCache(eligibleCache)
 
     private def computeEligible(tp: Type, enableUnsafeNulls: Boolean): List[Candidate] = /*>|>*/ trace(i"computeEligible $tp in $refs%, %", implicitsDetailed) /*<|<*/ {
       if (monitored) record(s"check eligible refs in irefCtx", refs.length)
-      val c = if enableUnsafeNulls then ctx.addMode(Mode.UnsafeNullConversion) else ctx
-      val ownEligible = filterMatching(tp)(using c)
+      val ownEligible = inContext(if enableUnsafeNulls then ctx.addMode(Mode.UnsafeNullConversion) else ctx) {
+        filterMatching(tp)
+      }
       if (isOuterMost) ownEligible
-      else if ownEligible.isEmpty then outerImplicits.eligible(tp)
+      else if ownEligible.isEmpty then outerImplicits.eligible(tp, enableUnsafeNulls)
       else
-        val outerEligible = outerImplicits.eligible(tp)
+        val outerEligible = outerImplicits.eligible(tp, enableUnsafeNulls)
         if outerEligible.isEmpty then ownEligible
         else
           val shadowed = ownEligible.map(_.ref.implicitName).toSet
@@ -1310,7 +1314,7 @@ trait Implicits:
 
     /** All available implicits, without ranking */
     def allImplicits: Set[TermRef] = {
-      val contextuals = ctx.implicits.eligible(wildProto).map(tryImplicit(_, contextual = true))
+      val contextuals = ctx.implicits.eligible(wildProto, ctx.mode.is(Mode.UnsafeNullConversion)).map(tryImplicit(_, contextual = true))
       val inscope = implicitScope(wildProto).eligible.map(tryImplicit(_, contextual = false))
       (contextuals.toSet ++ inscope).collect {
         case success: SearchSuccess => success.ref

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

@@ -39,27 +39,29 @@ object ProtoTypes {
     def isCompatible(tp: Type, pt: Type)(using Context): Boolean =
       val tpw = tp.widenExpr
       val ptw = pt.widenExpr
-      (tpw relaxed_<:< ptw) ||
-        // If unsafeNulls is enabled, we relax the condition by
-        // striping all nulls from the types before subtype check.
-        Nullables.convertUnsafeNulls && tpw.isUnsafelyConvertable(ptw, true) ||
-        viewExists(tp, pt)
+      (tpw relaxed_<:< ptw)
+      // If unsafeNulls is enabled, we relax the condition by
+      // striping all nulls from the types before subtype check.
+      || Nullables.convertUnsafeNulls && tpw.isUnsafelyConvertible(ptw, true)
+      || viewExists(tp, pt)
 
     /** Like isCompatibe, but using a subtype comparison with necessary eithers
      *  that don't unnecessarily truncate the constraint space, returning false instead.
      */
     def necessarilyCompatible(tp: Type, pt: Type)(using Context): Boolean =
       val tpw = tp.widenExpr
       val ptw = pt.widenExpr
-      necessarySubType(tpw, ptw) || tpw.isValueSubType(ptw) ||
-      Nullables.convertUnsafeNulls && {
+      necessarySubType(tpw, ptw)
+      || tpw.isValueSubType(ptw)
+      || Nullables.convertUnsafeNulls && {
         // See comments in `isCompatible`
         val tpwsn = tpw.stripAllNulls
         val ptwsn = ptw.stripAllNulls
-        necessarySubType(tpwsn, ptwsn) || tpwsn.isValueSubType(ptwsn) ||
-          tpwsn.isUnsafelyNulltoAnyRef(ptwsn)
-      } ||
-      viewExists(tp, pt)
+        necessarySubType(tpwsn, ptwsn)
+        || tpwsn.isValueSubType(ptwsn)
+        || tpwsn.isUnsafelyNulltoAnyRef(ptwsn)
+      }
+      || viewExists(tp, pt)
 
     /** Test compatibility after normalization.
      *  Do this in a fresh typerstate unless `keepConstraint` is true.

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

@@ -3474,9 +3474,9 @@ class Typer extends Namer
           val pt1 = if ctx.explicitNulls then pt.stripNull else pt
           pt1 match {
             case SAMType(sam)
-            if wtp <:< sam.toFunctionType() ||
-              (Nullables.convertUnsafeNulls &&
-                wtp.stripAllNulls <:< sam.toFunctionType().stripAllNulls) =>
+            if wtp <:< sam.toFunctionType()
+              || (Nullables.convertUnsafeNulls
+                && wtp.stripAllNulls <:< sam.toFunctionType().stripAllNulls) =>
               // was ... && isFullyDefined(pt, ForceDegree.flipBottom)
               // but this prevents case blocks from implementing polymorphic partial functions,
               // since we do not know the result parameter a priori. Have to wait until the
@@ -3549,8 +3549,9 @@ class Typer extends Namer
 
       def tryUnsafeNullConver(fail: => Tree)(using Context): Tree =
         // If explicitNulls and unsafeNulls are enabled, and
-        if ctx.mode.is(Mode.UnsafeNullConversion) && pt.isValueType &&
-          treeTpe.isUnsafelyConvertable(pt)
+        if ctx.mode.is(Mode.UnsafeNullConversion)
+          && pt.isValueType
+          && treeTpe.isUnsafelyConvertible(pt)
         then tree.cast(pt)
         else fail
 
@@ -3573,8 +3574,8 @@ class Typer extends Namer
         if ctx.mode.is(Mode.ImplicitsEnabled) && tree.typeOpt.isValueType then
           if pt.isRef(defn.AnyValClass) || pt.isRef(defn.ObjectClass) then
             // We want to allow `null` to `AnyRef` if UnsafeNullConversion is enabled
-            if !(ctx.mode.is(Mode.UnsafeNullConversion) &&
-              treeTpe.isUnsafelyConvertable(pt)) then
+            if !(ctx.mode.is(Mode.UnsafeNullConversion)
+              && treeTpe.isUnsafelyConvertible(pt)) then
               report.error(em"the result of an implicit conversion must be more specific than $pt", tree.srcPos)
             tree.cast(pt)
           else

docs/docs/internals/explicit-nulls.md

@@ -35,7 +35,7 @@ There are some utility functions for nullable types in `NullOpsDecorator.scala`
   ones (as `stripNull` does).
 - `isNullableUnion` determines whether `this` is a nullable union.
 - `isNullableAfterErasure` determines whether `this` type can have `null` value after erasure.
-- `isUnsafelyConvertable` determines whether we can convert `this` type to `pt` unsafely if we ignore `Null` type.
+- `isUnsafelyConvertible` determines whether we can convert `this` type to `pt` unsafely if we ignore `Null` type.
 
 Within `Types.scala`, we also defined an extractor `OrNull` to extract the non-nullable part of a nullable unions .