Small change

Author: noti0na1

compiler/src/dotty/tools/dotc/ast/tpd.scala

@@ -253,6 +253,8 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       case tp: MethodType =>
         val isParamDependent = tp.isParamDependent
         val previousParamRefs: ListBuffer[TermRef] =
+          // It is ok to assign `null` here.
+          // If `isParamDependent == false`, the value of `previousParamRefs` is not used.
           if isParamDependent then mutable.ListBuffer[TermRef]() else null.asInstanceOf
 
         def valueParam(name: TermName, origInfo: Type): TermSymbol =

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

@@ -160,7 +160,7 @@ object Constants {
             case TypeBounds(lo, hi) =>
               if (hi.classSymbol.isPrimitiveValueClass) hi //constrain further with high bound
               else classBound(lo)
-            case NoType => classBound(param.binder.paramInfos(param.paramNum).lo) // TODO
+            case NoType => classBound(param.binder.paramInfos(param.paramNum).lo)
             case inst => classBound(inst)
           }
         case pt => pt

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

@@ -322,7 +322,7 @@ object Contexts {
         related = SimpleIdentityMap.empty
         null
       else
-        related.nn.apply(key)
+        related.nn(key)
 
     private def withPhase(phase: Phase, pid: PhaseId): Context =
       util.Stats.record("Context.withPhase")

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

@@ -1215,7 +1215,7 @@ class Definitions {
         val patches = patchCls.info.decls.filter(patch =>
           !patch.isConstructor && !patch.isOneOf(PrivateOrSynthetic))
         for patch <- patches if !recurse(patch) do
-          val e: ScopeEntry | Null = scope.lookupEntry(patch.name)
+          val e = scope.lookupEntry(patch.name)
           if e != null then scope.unlink(e)
         for patch <- patches do
           patch.ensureCompleted()
@@ -1274,16 +1274,15 @@ class Definitions {
   @tu lazy val TupleType: Array[TypeRef] = mkArityArray("scala.Tuple", MaxTupleArity, 1)
 
   private class FunType(prefix: String):
-    private var classRefs: Array[TypeRef] = new Array(22)
+    private var classRefs: Array[TypeRef | Null] = new Array(22)
     def apply(n: Int): TypeRef =
       while n >= classRefs.length do
-        val classRefs1 = new Array[TypeRef](classRefs.length * 2)
+        val classRefs1 = new Array[TypeRef | Null](classRefs.length * 2)
         Array.copy(classRefs, 0, classRefs1, 0, classRefs.length)
         classRefs = classRefs1
-      val cr: TypeRef | Null = classRefs(n)
-      if cr == null then
+      if classRefs(n) == null then
         classRefs(n) = requiredClassRef(prefix + n.toString)
-      classRefs(n)
+      classRefs(n).nn
 
   private val erasedContextFunType = FunType("scala.ErasedContextFunction")
   private val contextFunType = FunType("scala.ContextFunction")
@@ -1822,15 +1821,15 @@ class Definitions {
 
   @tu lazy val reservedScalaClassNames: Set[Name] = syntheticScalaClasses.map(_.name).toSet
 
-  private var isDefnInitialized = false
+  private var isInitialized = false
 
   def init()(using Context): Unit = {
     this.initCtx = ctx
-    if (!isDefnInitialized) {
+    if (!isInitialized) {
       // force initialization of every symbol that is synthesized or hijacked by the compiler
       val forced = syntheticCoreClasses ++ syntheticCoreMethods ++ ScalaValueClasses() :+ JavaEnumClass
 
-      isDefnInitialized = true
+      isInitialized = true
     }
     addSyntheticSymbolsComments
   }

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

@@ -274,7 +274,8 @@ object Implicits:
    *  @param companionRefs   the companion objects in the implicit scope.
    */
   class OfTypeImplicits(tp: Type, override val companionRefs: TermRefSet)(initctx: Context) extends ImplicitRefs(initctx) {
-    // assert(initctx.typer != null)
+    // TODO: do we need this assert?
+    assert((initctx.typer: Typer | Null) != null)
     implicits.println(i"implicit scope of type $tp = ${companionRefs.showAsList}%, %")
     @threadUnsafe lazy val refs: List[ImplicitRef] = {
       val buf = new mutable.ListBuffer[TermRef]
@@ -1863,7 +1864,7 @@ sealed class TermRefSet(using Context):
     if !that.isEmpty then that.foreach(+=)
 
   def foreach[U](f: TermRef => U): Unit =
-    // TODO
+    // TODO: do we need to check sym == null?
     def handle(sym: TermSymbol | Null, prefixes: Type | List[Type] | Null): Unit =
       prefixes match
         case prefix: Type => f(TermRef(prefix, sym.uncheckedNN))

compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala

@@ -2799,7 +2799,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
     object SourceFile extends SourceFileModule {
       def current: SourceFile =
         val unit = ctx.compilationUnit
-        if unit == NoCompilationUnit then
+        if unit eq NoCompilationUnit then
           throw new java.lang.UnsupportedOperationException(
             "`reflect.SourceFile.current` cannot be called within the TASTy ispector")
         else unit.source