Clean code

Author: noti0na1

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

@@ -823,9 +823,8 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
    *  tree must be reachable from come tree stored in an enclosing context.
    */
   def definingStats(sym: Symbol)(using Context): List[Tree] =
-    val unit = ctx.compilationUnit
-    if (!sym.span.exists || (ctx eq NoContext) || (unit eq NoCompilationUnit)) Nil
-    else defPath(sym, unit.tpdTree) match {
+    if (!sym.span.exists || (ctx eq NoContext) || (ctx.compilationUnit eq NoCompilationUnit)) Nil
+    else defPath(sym, ctx.compilationUnit.tpdTree) match {
       case defn :: encl :: _ =>
         def verify(stats: List[Tree]) =
           if (stats exists (definedSym(_) == sym)) stats else Nil

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

@@ -10,7 +10,6 @@ import util.{SrcPos, NoSourcePosition}
 import SourceVersion._
 import reporting.Message
 import NameKinds.QualifiedName
-import typer.ImportInfo
 
 object Feature:
 

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

@@ -270,8 +270,8 @@ object Contexts {
      *  the declarations of the current class.
      */
     def effectiveScope(using Context): Scope =
-      val co: Symbol | Null = owner
-      if co != null && co.isClass then co.asClass.unforcedDecls
+      val myOwner: Symbol | Null = owner
+      if myOwner != null && myOwner.isClass then myOwner.asClass.unforcedDecls
       else scope
 
     def nestingLevel: Int = effectiveScope.nestingLevel

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

@@ -51,7 +51,7 @@ object OrderingConstraint {
     def update(prev: OrderingConstraint, current: OrderingConstraint,
         poly: TypeLambda, idx: Int, entry: T)(using Context): OrderingConstraint = {
       var es = entries(current, poly)
-      // TODO: invest why flow typing is not working on `es`
+      // TODO: investigate why flow typing is not working on `es`
       if (es != null && (es.nn(idx) eq entry)) current
       else {
         val result =

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

@@ -18,9 +18,7 @@ class TypeError(msg: String) extends Exception(msg) {
   def this() = this("")
   final def toMessage(using Context): Message =
     withMode(Mode.Printing)(produceMessage)
-  def produceMessage(using Context): Message =
-    val msg: String = super.getMessage.uncheckedNN
-    msg
+  def produceMessage(using Context): Message = super.getMessage.nn
   override def getMessage: String = super.getMessage.nn
 }
 

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

@@ -4511,8 +4511,8 @@ object Types {
     def paramName: binder.ThisName = binder.paramNames(paramNum)
 
     override def underlying(using Context): Type = {
+      // TODO: update paramInfos's type to nullable
       val infos: List[Type] | Null = binder.paramInfos
-      // TODO
       if (infos == null) NoType // this can happen if the referenced generic type is not initialized yet
       else infos(paramNum)
     }

compiler/src/dotty/tools/dotc/interactive/InteractiveDriver.scala

@@ -164,8 +164,8 @@ class InteractiveDriver(val settings: List[String]) extends Driver {
 
       run.compileSources(List(source))
       run.printSummary()
-      val ctxrun = ctx.run.nn
-      val unit = if ctxrun.units.nonEmpty then ctxrun.units.head else ctxrun.suspendedUnits.head
+      val ctxRun = ctx.run.nn
+      val unit = if ctxRun.units.nonEmpty then ctxRun.units.head else ctxRun.suspendedUnits.head
       val t = unit.tpdTree
       cleanup(t)
       myOpenedTrees(uri) = topLevelTrees(t, source)

compiler/src/dotty/tools/dotc/reporting/StoreReporter.scala

@@ -24,21 +24,21 @@ class StoreReporter(outer: Reporter | Null = Reporter.NoReporter, fromTyperState
   def doReport(dia: Diagnostic)(using Context): Unit = {
     typr.println(s">>>> StoredError: ${dia.message}") // !!! DEBUG
     if (infos == null) infos = new mutable.ListBuffer
-    infos.nn += dia
+    infos.uncheckedNN += dia
   }
 
   override def hasUnreportedErrors: Boolean =
-    outer != null && infos != null && infos.nn.exists(_.isInstanceOf[Error])
+    outer != null && infos != null && infos.uncheckedNN.exists(_.isInstanceOf[Error])
 
   override def hasStickyErrors: Boolean =
-    infos != null && infos.nn.exists(_.isInstanceOf[StickyError])
+    infos != null && infos.uncheckedNN.exists(_.isInstanceOf[StickyError])
 
   override def removeBufferedMessages(using Context): List[Diagnostic] =
-    if (infos != null) try infos.nn.toList finally infos = null
+    if (infos != null) try infos.uncheckedNN.toList finally infos = null
     else Nil
 
   override def pendingMessages(using Context): List[Diagnostic] =
-    if (infos != null) infos.nn.toList else Nil
+    if (infos != null) infos.uncheckedNN.toList else Nil
 
   override def errorsReported: Boolean = hasErrors || (outer != null && outer.errorsReported)
 

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

@@ -383,7 +383,7 @@ object ProtoTypes {
             targ = arg.withType(WildcardType)
           case _ =>
             targ = typerFn(arg)
-            // TODO: invest why flow typing is not working on `targ`
+            // TODO: investigate why flow typing is not working on `targ`
             if ctx.reporter.hasUnreportedErrors then
               if hasInnerErrors(targ.nn) then
                 state.errorArgs += arg

compiler/src/dotty/tools/dotc/util/WeakHashSet.scala

@@ -163,40 +163,46 @@ abstract class WeakHashSet[A <: AnyRef](initialCapacity: Int = 8, loadFactor: Do
     elem
   }
 
-  def put(elem: A): A = {
-    Stats.record(statsItem("put"))
-    removeStaleEntries()
-    val h = hash(elem)
-    val bucket = index(h)
-    val oldHead = table(bucket)
+  // TODO: remove the `case null` when we can enable explicit nulls in regular compiling,
+  // since the type `A <: AnyRef` of `elem` can ensure the value is not null.
+  def put(elem: A): A = (elem: A | Null) match {
+    case null => throw new NullPointerException("WeakHashSet cannot hold nulls")
+    case _    =>
+      Stats.record(statsItem("put"))
+      removeStaleEntries()
+      val h = hash(elem)
+      val bucket = index(h)
+      val oldHead = table(bucket)
 
-    @tailrec
-    def linkedListLoop(entry: Entry[A] | Null): A = entry match {
-      case null                    => addEntryAt(bucket, elem, h, oldHead)
-      case _                       =>
-        val entryElem = entry.get
-        if entryElem != null && isEqual(elem, entryElem) then entryElem.uncheckedNN
-        else linkedListLoop(entry.tail)
-    }
+      @tailrec
+      def linkedListLoop(entry: Entry[A] | Null): A = entry match {
+        case null                    => addEntryAt(bucket, elem, h, oldHead)
+        case _                       =>
+          val entryElem = entry.get
+          if entryElem != null && isEqual(elem, entryElem) then entryElem.uncheckedNN
+          else linkedListLoop(entry.tail)
+      }
 
-    linkedListLoop(oldHead)
+      linkedListLoop(oldHead)
   }
 
   def +=(elem: A): Unit = put(elem)
 
-  def -=(elem: A): Unit = {
-    Stats.record(statsItem("-="))
-    removeStaleEntries()
-    val bucket = index(hash(elem))
+  def -=(elem: A): Unit = (elem: A | Null) match {
+    case null =>
+    case _ =>
+      Stats.record(statsItem("-="))
+      removeStaleEntries()
+      val bucket = index(hash(elem))
 
-    @tailrec
-    def linkedListLoop(prevEntry: Entry[A] | Null, entry: Entry[A] | Null): Unit =
-      if entry != null then
-        val entryElem = entry.get
-        if entryElem != null && isEqual(elem, entryElem) then remove(bucket, prevEntry, entry)
-        else linkedListLoop(entry, entry.tail)
+      @tailrec
+      def linkedListLoop(prevEntry: Entry[A] | Null, entry: Entry[A] | Null): Unit =
+        if entry != null then
+          val entryElem = entry.get
+          if entryElem != null && isEqual(elem, entryElem) then remove(bucket, prevEntry, entry)
+          else linkedListLoop(entry, entry.tail)
 
-    linkedListLoop(null, table(bucket))
+      linkedListLoop(null, table(bucket))
   }
 
   def clear(): Unit = {
@@ -255,14 +261,13 @@ abstract class WeakHashSet[A <: AnyRef](initialCapacity: Int = 8, loadFactor: Do
       }
 
       def next(): A =
-        if (lookaheadelement == null)
+        if lookaheadelement == null then
           throw new IndexOutOfBoundsException("next on an empty iterator")
-        else {
+        else
           val result = lookaheadelement.nn
           lookaheadelement = null
           entry = entry.nn.tail
           result
-        }
     }
   }