Fix implicit cache

Author: noti0na1

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

@@ -300,6 +300,7 @@ object Implicits:
    */
   class ContextualImplicits(val refs: List[ImplicitRef], val outerImplicits: ContextualImplicits)(initctx: Context) extends ImplicitRefs(initctx) {
     private val eligibleCache = EqHashMap[Type, List[Candidate]]()
+    private val eligibleCacheUnsafeNulls = EqHashMap[Type, List[Candidate]]()
 
     /** 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
@@ -324,24 +325,26 @@ object Implicits:
 
     /** The implicit references that are eligible for type `tp`. */
     def eligible(tp: Type, enableUnsafeNulls: Boolean = false): List[Candidate] =
-      if (tp.hash == NotCached)
-        Stats.record(i"compute eligible not cached ${tp.getClass}")
-        Stats.record(i"compute eligible not cached")
-        computeEligible(tp, enableUnsafeNulls)
-      else {
-        val eligibles = eligibleCache.lookup(tp)
-        if (eligibles != null) {
+      def searchWithCache(cache: EqHashMap[Type, List[Candidate]]) = {
+        val eligibles = cache.lookup(tp)
+        if eligibles != null then
           Stats.record("cached eligible")
           eligibles
-        }
-        else if (irefCtx eq NoContext) Nil
-        else {
+        else if irefCtx eq NoContext then Nil
+        else
           Stats.record(i"compute eligible cached")
           val result = computeEligible(tp, enableUnsafeNulls)
-          eligibleCache(tp) = result
+          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)

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

@@ -3548,18 +3548,7 @@ class Typer extends Namer
               report.error(em"the result of an implicit conversion must be more specific than $pt", tree.srcPos)
             tree.cast(pt)
           else
-            // TODO: we don't need to second time search, need to modify Implicits more
-            def normalSearch =
-              searchTree(tree)(failure => tryUnsafeNullConver(cannotFind(failure)))
-            treeTpe match {
-              case OrNull(tpe1) if ctx.mode.is(Mode.UnsafeNullConversion) =>
-                // If the type of the tree is nullable, and unsafeNullConversion is enabled,
-                // then we search the tree without the `Null` type first.
-                // If this fails, we search the original tree.
-                searchTree(tree.cast(tpe1)) { _ => normalSearch }
-              case _ =>
-                normalSearch
-            }
+            searchTree(tree)(failure => tryUnsafeNullConver(cannotFind(failure)))
         else tryUnsafeNullConver(recover(NoMatchingImplicits))
       }
     }

docs/docs/internals/explicit-nulls.md

@@ -94,12 +94,7 @@ The reason to use the `UnsafeNullConversion` mode is because the current 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. If `unsafeNulls` is enabled, we use the new search scheme:
-1. If the `tree.tpe` is nullable, we strip `Null` from the tree then search.
-2. If the `tree.tpe` is not nullable or the last step fails, we search on the tree directly.
-3. If the last step fails, we try to cast tree to `pt` if the two types `isUnsafelyConvertable`.
-
-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.
+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.
 

tests/explicit-nulls/neg/unsafe-scope.scala

@@ -6,8 +6,10 @@ class S {
 
     val x: String = s // error
     val xs: Array[String | Null] = s // error
+
     {
       import scala.language.unsafeNulls
+      // ensure the previous search cache is not used here
       val y: String = s
       val ys: Array[String | Null] = s
     }