Change ctx.importInfo to nullable

Author: noti0na1

compiler/src/dotty/tools/dotc/config/Feature.scala

@@ -51,7 +51,7 @@ object Feature:
    */
   def enabledByImport(feature: TermName)(using Context): Boolean =
     //atPhase(typerPhase) {
-      val info: ImportInfo | Null = ctx.importInfo
+      val info = ctx.importInfo
       info != null && info.featureImported(feature)
     //}
 

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

@@ -52,7 +52,7 @@ object Contexts {
   private val (runLoc,              store6) = store5.newLocation[Run | Null]()
   private val (profilerLoc,         store7) = store6.newLocation[Profiler]()
   private val (notNullInfosLoc,     store8) = store7.newLocation[List[NotNullInfo]]()
-  private val (importInfoLoc,       store9) = store8.newLocation[ImportInfo]()
+  private val (importInfoLoc,       store9) = store8.newLocation[ImportInfo | Null]()
   private val (typeAssignerLoc,    store10) = store9.newLocation[TypeAssigner](TypeAssigner)
 
   private val initialStore = store10
@@ -233,10 +233,10 @@ object Contexts {
     def profiler: Profiler = store(profilerLoc)
 
     /** The paths currently known to be not null */
-    def notNullInfos = store(notNullInfosLoc)
+    def notNullInfos: List[NotNullInfo] = store(notNullInfosLoc)
 
     /** The currently active import info */
-    def importInfo = store(importInfoLoc)
+    def importInfo: ImportInfo | Null = store(importInfoLoc)
 
     /** The current type assigner or typer */
     def typeAssigner: TypeAssigner = store(typeAssignerLoc)
@@ -252,12 +252,12 @@ object Contexts {
               catch {
                 case ex: CyclicReference => Nil
               }
-            else if (isImportContext) importInfo.importedImplicits
+            else if (isImportContext) importInfo.nn.importedImplicits
             else if (isNonEmptyScopeContext) scope.implicitDecls
             else Nil
           val outerImplicits =
-            if (isImportContext && importInfo.unimported.exists)
-              outer.implicits exclude importInfo.unimported
+            if (isImportContext && importInfo.nn.unimported.exists)
+              outer.implicits exclude importInfo.nn.unimported
             else
               outer.implicits
           if (implicitRefs.isEmpty) outerImplicits
@@ -401,7 +401,7 @@ object Contexts {
     def isImportContext: Boolean =
       (this ne NoContext)
       && (outer ne NoContext)
-      && (this.importInfo ne outer.importInfo)
+      && (this.importInfo nen outer.importInfo)
 
     /** Is this a context that introduces a non-empty scope? */
     def isNonEmptyScopeContext: Boolean =
@@ -563,7 +563,7 @@ object Contexts {
 
     override def toString: String =
       def iinfo(using Context) =
-        val info: ImportInfo | Null = ctx.importInfo
+        val info = ctx.importInfo
         if (info == null) "" else i"${info.selectors}%, %"
       def cinfo(using Context) =
         val core = s"  owner = ${ctx.owner}, scope = ${ctx.scope}, import = $iinfo"

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

@@ -384,7 +384,7 @@ object Implicits:
       if (this == NoContext.implicits) this
       else {
         val outerExcluded = outerImplicits.uncheckedNN exclude root
-        if (irefCtx.importInfo.site.termSymbol == root) outerExcluded
+        if (irefCtx.importInfo.nn.site.termSymbol == root) outerExcluded
         else if (outerExcluded eqn outerImplicits) this
         else new ContextualImplicits(refs, outerExcluded, isImport)(irefCtx)
       }

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

@@ -218,9 +218,9 @@ class ImportInfo(symf: Context ?=> Symbol,
           case Some(bv) => bv
           case None =>
             var c = ctx.outer
-            while c.importInfo eq ctx.importInfo do c = c.outer
-            // TODO: Do we need to change importInfo to nullable?
-            ((c.importInfo: ImportInfo | Null) != null) && c.importInfo.featureImported(feature)(using c)
+            while c.importInfo eqn ctx.importInfo do c = c.outer
+            val cinfo = c.importInfo
+            (cinfo != null) && cinfo.featureImported(feature)(using c)
       )
     featureCache(feature).nn
 

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

@@ -123,8 +123,8 @@ trait ImportSuggestions:
               .filter(lookInside(_))
               .flatMap(sym => rootsIn(sym.termRef))
         val imported =
-          if ctx.importInfo eq ctx.outer.importInfo then Nil
-          else ctx.importInfo.importSym.info match
+          if ctx.importInfo eqn ctx.outer.importInfo then Nil
+          else ctx.importInfo.nn.importSym.info match
             case ImportType(expr) => rootsOnPath(expr.tpe)
             case _ => Nil
         defined ++ imported ++ recur(using ctx.outer)

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

@@ -429,12 +429,12 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           if result.exists then result
           else {  // find import
             val outer = ctx.outer
-            val curImport: ImportInfo | Null = ctx.importInfo
+            val curImport = ctx.importInfo
             def updateUnimported() =
               if (curImport.nn.unimported ne NoSymbol) unimported += curImport.nn.unimported
             if (curOwner.is(Package) && curImport != null && curImport.isRootImport && previous.exists)
               previous // no more conflicts possible in this case
-            else if (isPossibleImport(NamedImport) && (curImport.uncheckedNN ne outer.importInfo)) {
+            else if (isPossibleImport(NamedImport) && (curImport nen outer.importInfo)) {
               val namedImp = namedImportRef(curImport.uncheckedNN)
               if (namedImp.exists)
                 recurAndCheckNewOrShadowed(namedImp, NamedImport, ctx)(using outer)

compiler/test/dotty/tools/dotc/interactive/CustomCompletionTests.scala

@@ -43,7 +43,7 @@ class CustomCompletionTests extends DottyTest:
       given ctx: Context = run.runContext.withSource(file)
       val unit = CompilationUnit(file)
       ctx
-        .run
+        .run.nn
         .compileUnits(unit :: Nil, ctx)
 
       // ignoring compilation errors here - the input code