Finish typer

Author: noti0na1

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

@@ -2,6 +2,8 @@ package dotty.tools
 package dotc
 package core
 
+// import scala.language.{unsafeNulls => _}
+
 import scala.io.Codec
 import util.NameTransformer
 import printing.{Showable, Texts, Printer}

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

@@ -345,7 +345,7 @@ object Implicits:
       if monitored then record(s"check uncached eligible refs in irefCtx", refs.length)
       val ownEligible = filterMatching(tp)
       if isOuterMost then ownEligible
-      else combineEligibles(ownEligible, outerImplicits.uncachedEligible(tp))
+      else combineEligibles(ownEligible, outerImplicits.nn.uncachedEligible(tp))
 
     /** The implicit references that are eligible for type `tp`. */
     def eligible(tp: Type): List[Candidate] =

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

@@ -1,6 +1,8 @@
 package dotty.tools.dotc
 package typer
 
+import scala.language.{unsafeNulls => _}
+
 import core.Contexts._
 import ast.tpd._
 

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

@@ -2,6 +2,8 @@ package dotty.tools
 package dotc
 package typer
 
+import scala.language.{unsafeNulls => _}
+
 import core._
 import ast._
 import Trees._, StdNames._, Scopes._, Denotations._, NamerOps._, ContextOps._
@@ -528,7 +530,7 @@ class Namer { typer: Typer =>
      *  body and derived clause of the synthetic module class `fromCls`.
      */
     def mergeModuleClass(mdef: Tree, modCls: TypeDef, fromCls: TypeDef): TypeDef = {
-      var res: TypeDef = null
+      var res: TypeDef | Null = null
       val Thicket(trees) = expanded(mdef)
       val merged = trees.map { tree =>
         if (tree == modCls) {
@@ -541,16 +543,16 @@ class Namer { typer: Typer =>
           if (fromTempl.derived.nonEmpty) {
             if (modTempl.derived.nonEmpty)
               report.error(em"a class and its companion cannot both have `derives` clauses", mdef.srcPos)
-            res.putAttachment(desugar.DerivingCompanion, fromTempl.srcPos.startPos)
+            res.uncheckedNN.putAttachment(desugar.DerivingCompanion, fromTempl.srcPos.startPos)
           }
-          res
+          res.uncheckedNN
         }
         else tree
       }
 
       mdef.putAttachment(ExpandedTree, Thicket(merged))
 
-      res
+      res.nn
     }
 
     /** Merge `fromCls` of `fromStat` into `toCls` of `toStat`
@@ -792,7 +794,7 @@ class Namer { typer: Typer =>
       if (Config.showCompletions && ctx.typerState != creationContext.typerState) {
         def levels(c: Context): Int =
           if (c.typerState eq creationContext.typerState) 0
-          else if (c.typerState == null) -1
+          else if ((c.typerState: TyperState | Null) == null) -1
           else if (c.outer.typerState == c.typerState) levels(c.outer)
           else levels(c.outer) + 1
         println(s"!!!completing ${denot.symbol.showLocated} in buried typerState, gap = ${levels(ctx)}")
@@ -812,13 +814,13 @@ class Namer { typer: Typer =>
             completer.complete(denot)
     }
 
-    private var completedTypeParamSyms: List[TypeSymbol] = null
+    private var completedTypeParamSyms: List[TypeSymbol] | Null = null
 
     def setCompletedTypeParams(tparams: List[TypeSymbol]) =
       completedTypeParamSyms = tparams
 
     override def completerTypeParams(sym: Symbol)(using Context): List[TypeSymbol] =
-      if completedTypeParamSyms != null then completedTypeParamSyms
+      if completedTypeParamSyms != null then completedTypeParamSyms.uncheckedNN
       else Nil
 
     protected def addAnnotations(sym: Symbol): Unit = original match {
@@ -920,8 +922,8 @@ class Namer { typer: Typer =>
 
   class TypeDefCompleter(original: TypeDef)(ictx: Context)
   extends Completer(original)(ictx) with TypeParamsCompleter {
-    private var myTypeParams: List[TypeSymbol] = null
-    private var nestedCtx: Context = null
+    private var myTypeParams: List[TypeSymbol] | Null = null
+    private var nestedCtx: Context | Null = null
     assert(!original.isClassDef)
 
     /** If completion of the owner of the to be completed symbol has not yet started,
@@ -942,7 +944,7 @@ class Namer { typer: Typer =>
       if myTypeParams == null then
         //println(i"completing type params of $sym in ${sym.owner}")
         nestedCtx = localContext(sym).setNewScope
-        given Context = nestedCtx
+        given Context = nestedCtx.uncheckedNN
 
         def typeParamTrees(tdef: Tree): List[TypeDef] = tdef match
           case TypeDef(_, original) =>
@@ -957,12 +959,12 @@ class Namer { typer: Typer =>
         myTypeParams = tparams.map(symbolOfTree(_).asType)
         for param <- tparams do typedAheadExpr(param)
       end if
-      myTypeParams
+      myTypeParams.uncheckedNN
     end completerTypeParams
 
     override final def typeSig(sym: Symbol): Type =
       val tparamSyms = completerTypeParams(sym)(using ictx)
-      given ctx: Context = nestedCtx
+      given ctx: Context = nestedCtx.nn
 
       def abstracted(tp: TypeBounds): TypeBounds =
         HKTypeLambda.boundsFromParams(tparamSyms, tp)
@@ -1051,7 +1053,7 @@ class Namer { typer: Typer =>
     private var localCtx: Context = _
 
     /** info to be used temporarily while completing the class, to avoid cyclic references. */
-    private var tempInfo: TempClassInfo = _
+    private var tempInfo: TempClassInfo | Null = null
 
     val TypeDef(name, impl @ Template(constr, _, self, _)) = original
 
@@ -1401,7 +1403,7 @@ class Namer { typer: Typer =>
       end addUsingTraits
 
       completeConstructor(denot)
-      denot.info = tempInfo
+      denot.info = tempInfo.nn
 
       val parentTypes = defn.adjustForTuple(cls, cls.typeParams,
         defn.adjustForBoxedUnit(cls,
@@ -1422,7 +1424,7 @@ class Namer { typer: Typer =>
         original.putAttachment(AttachedDeriver, deriver)
       }
 
-      denot.info = tempInfo.finalized(parentTypes)
+      denot.info = tempInfo.nn.finalized(parentTypes)
       tempInfo = null // The temporary info can now be garbage-collected
 
       Checking.checkWellFormed(cls)

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

@@ -2,6 +2,8 @@ package dotty.tools
 package dotc
 package typer
 
+import scala.language.{unsafeNulls => _}
+
 import dotty.tools.dotc.ast.{Trees, tpd, untpd}
 import Trees._
 import core._

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

@@ -2,6 +2,8 @@ package dotty.tools
 package dotc
 package typer
 
+import scala.language.{unsafeNulls => _}
+
 import core._
 import ast._
 import Contexts._, Types._, Denotations._, Names._, StdNames._, NameOps._, Symbols._
@@ -357,10 +359,10 @@ object ProtoTypes {
             targ = arg.withType(WildcardType)
           case _ =>
             targ = typerFn(arg)
-            if (!ctx.reporter.hasUnreportedErrors)
-              state.typedArg = state.typedArg.updated(arg, targ)
+            if (!ctx.reporter.hasUnreportedErrors && targ != null)
+              state.typedArg = state.typedArg.updated(arg, targ.uncheckedNN)
         }
-      targ
+      targ.nn
     }
 
     /** The typed arguments. This takes any arguments already typed using
@@ -770,7 +772,7 @@ object ProtoTypes {
   /** Approximate occurrences of parameter types and uninstantiated typevars
    *  by wildcard types.
    */
-  private def wildApprox(tp: Type, theMap: WildApproxMap, seen: Set[TypeParamRef], internal: Set[TypeLambda])(using Context): Type = tp match {
+  private def wildApprox(tp: Type, theMap: WildApproxMap | Null, seen: Set[TypeParamRef], internal: Set[TypeLambda])(using Context): Type = tp match {
     case tp: NamedType => // default case, inlined for speed
       val isPatternBoundTypeRef = tp.isInstanceOf[TypeRef] && tp.symbol.isPatternBound
       if (isPatternBoundTypeRef) WildcardType(tp.underlying.bounds)

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

@@ -1,6 +1,8 @@
 package dotty.tools.dotc
 package typer
 
+import scala.language.{unsafeNulls => _}
+
 import dotty.tools.dotc.ast._
 import dotty.tools.dotc.ast.Trees._
 import dotty.tools.dotc.config.Feature._

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

@@ -1,6 +1,8 @@
 package dotty.tools.dotc
 package typer
 
+import scala.language.{unsafeNulls => _}
+
 import core._
 import Contexts._
 import Types._

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

@@ -2,6 +2,8 @@ package dotty.tools
 package dotc
 package typer
 
+import scala.language.{unsafeNulls => _}
+
 import transform._
 import core._
 import Symbols._, Types._, Contexts._, Flags._, Names._, NameOps._, NameKinds._
@@ -981,7 +983,7 @@ object RefChecks {
           val msg = annot.argumentConstant(0).get.stringValue
           report.warning(SymbolChangedSemanticsInVersion(sym, symVersion, msg), pos)
         case Failure(ex) =>
-          report.warning(SymbolHasUnparsableVersionNumber(sym, ex.getMessage), pos)
+          report.warning(SymbolHasUnparsableVersionNumber(sym, ex.getMessage.nn), pos)
         case _ =>
 
   /** Check that a deprecated val or def does not override a
@@ -1182,9 +1184,9 @@ object RefChecks {
       val matches = referencePattern.findAllIn(s)
       for reference <- matches do
         val referenceOffset = matches.start
-        val prefixlessReference = reference.replaceFirst("""\$\{\s*""", "")
+        val prefixlessReference = reference.replaceFirst("""\$\{\s*""", "").nn
         val variableOffset = referenceOffset + reference.length - prefixlessReference.length
-        val variableName = prefixlessReference.replaceFirst("""\s*\}""", "")
+        val variableName = prefixlessReference.replaceFirst("""\s*\}""", "").nn
         f(variableName, variableOffset)
 
   end checkImplicitNotFoundAnnotation

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

@@ -2,6 +2,8 @@ package dotty.tools
 package dotc
 package typer
 
+import scala.language.{unsafeNulls => _}
+
 import core._
 import util.Spans.Span
 import Contexts._