Explicitly null check the stdlib (#23566)

The PR enables explicit nulls for stdlib. The detailed review guide is
at: #23566 (comment)

Author: noti0na1

compiler/src/dotty/tools/MainGenericCompiler.scala

@@ -131,9 +131,9 @@ object MainGenericCompiler {
       val tStopAtLvl="-XX:TieredStopAtLevel=1"
       println(s"ignoring deprecated -Oshort flag, please add `-J$addTC` and `-J$tStopAtLvl` flags manually")
       process(tail, settings)
-    case javaOption(stripped) :: tail =>
+    case javaOption(stripped: String) :: tail =>
       process(tail, settings.withJavaArgs(stripped))
-    case javaPropOption(opt, value) :: tail =>
+    case javaPropOption(opt: String, value: String) :: tail =>
       process(tail, settings.withJavaProps(opt -> value))
     case arg :: tail =>
       process(tail, settings.withResidualArgs(arg))

compiler/src/dotty/tools/MainGenericRunner.scala

@@ -143,7 +143,7 @@ object MainGenericRunner {
       processArgs(tail, settings.noSave)
     case "-with-compiler" :: tail =>
       processArgs(tail, settings.withCompiler)
-    case (o @ javaOption(striped)) :: tail =>
+    case (o @ javaOption(striped: String)) :: tail =>
       processArgs(tail, settings.withJavaArgs(striped).withScalaArgs(o))
     case (o @ scalaOption(_*)) :: tail =>
       val remainingArgs = CommandLineParser.expandArg(o) ++ tail

compiler/src/dotty/tools/backend/sjs/JSDefinitions.scala

@@ -289,15 +289,15 @@ final class JSDefinitions()(using Context) {
     @threadUnsafe lazy val EnumerationClass = requiredClass("scala.Enumeration")
       @threadUnsafe lazy val Enumeration_Value_NoArg = EnumerationClass.requiredValue(nmeValue)
       @threadUnsafe lazy val Enumeration_Value_IntArg = EnumerationClass.requiredMethod(nmeValue, List(defn.IntType))
-      @threadUnsafe lazy val Enumeration_Value_StringArg = EnumerationClass.requiredMethod(nmeValue, List(defn.StringType))
-      @threadUnsafe lazy val Enumeration_Value_IntStringArg = EnumerationClass.requiredMethod(nmeValue, List(defn.IntType, defn.StringType))
+      @threadUnsafe lazy val Enumeration_Value_StringArg = EnumerationClass.requiredMethod(nmeValue, List(OrNull(defn.StringType)))
+      @threadUnsafe lazy val Enumeration_Value_IntStringArg = EnumerationClass.requiredMethod(nmeValue, List(defn.IntType, OrNull(defn.StringType)))
       @threadUnsafe lazy val Enumeration_nextName = EnumerationClass.requiredMethod(termName("nextName"))
 
     @threadUnsafe lazy val EnumerationValClass = EnumerationClass.requiredClass("Val")
       @threadUnsafe lazy val Enumeration_Val_NoArg = EnumerationValClass.requiredMethod(nme.CONSTRUCTOR, Nil)
       @threadUnsafe lazy val Enumeration_Val_IntArg = EnumerationValClass.requiredMethod(nme.CONSTRUCTOR, List(defn.IntType))
-      @threadUnsafe lazy val Enumeration_Val_StringArg = EnumerationValClass.requiredMethod(nme.CONSTRUCTOR, List(defn.StringType))
-      @threadUnsafe lazy val Enumeration_Val_IntStringArg = EnumerationValClass.requiredMethod(nme.CONSTRUCTOR, List(defn.IntType, defn.StringType))
+      @threadUnsafe lazy val Enumeration_Val_StringArg = EnumerationValClass.requiredMethod(nme.CONSTRUCTOR, List(OrNull(defn.StringType)))
+      @threadUnsafe lazy val Enumeration_Val_IntStringArg = EnumerationValClass.requiredMethod(nme.CONSTRUCTOR, List(defn.IntType, OrNull(defn.StringType)))
 
     def isValueMethod(sym: Symbol)(using Context): Boolean =
       sym.name == nmeValue && sym.owner == EnumerationClass

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

@@ -404,7 +404,7 @@ object Comments {
       val raw = ctx.docCtx.flatMap(_.docstring(sym).map(_.raw)).getOrElse("")
       defs(sym) ++= defines(raw).map { str =>
         val start = skipWhitespace(str, "@define".length)
-        val (key, Trim(value)) = str.splitAt(skipVariable(str, start)): @unchecked
+        val (key, Trim(value: String)) = str.splitAt(skipVariable(str, start)): @unchecked
         variableName(key.drop(start)) -> value.replaceAll("\\s+\\*+$", "")
       }
     }

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

@@ -3000,7 +3000,7 @@ class MissingImplicitArgument(
       val idx = paramNames.indexOf(name)
       if (idx >= 0) Some(i"${args(idx)}") else None
     """\$\{\s*([^}\s]+)\s*\}""".r.replaceAllIn(raw, (_: Regex.Match) match
-      case Regex.Groups(v) => quoteReplacement(translate(v).getOrElse("?" + v)).nn
+      case Regex.Groups(v: String) => quoteReplacement(translate(v).getOrElse("?" + v)).nn
     )
 
   /** @param rawMsg           Message template with variables, e.g. "Variable A is ${A}"

compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala

@@ -382,7 +382,7 @@ object Scala3:
   object LocalSymbol:
 
     def unapply(symbolInfo: SymbolInformation): Option[Int] = symbolInfo.symbol match
-      case locals(ints) =>
+      case locals(ints: String) =>
         val bi = BigInt(ints)
         if bi.isValidInt then
           Some(bi.toInt)

compiler/src/dotty/tools/repl/ParseResult.scala

@@ -180,7 +180,7 @@ object ParseResult {
     val sourceCode = source.content().mkString
     sourceCode match {
       case "" => Newline
-      case CommandExtract(cmd, arg) => {
+      case CommandExtract(cmd: String, arg: String) => {
         val matchingCommands = commands.filter((command, _) => command.startsWith(cmd))
         matchingCommands match {
           case Nil => UnknownCommand(cmd)

compiler/src/dotty/tools/scripting/Main.scala

@@ -78,7 +78,7 @@ object Main:
       writer.close()
   end writeJarfile
 
-  def pathsep = sys.props("path.separator")
+  def pathsep: String = sys.props("path.separator").nn
 
   extension(path: String) {
     // Normalize path separator, convert relative path to absolute
@@ -102,4 +102,4 @@ object Main:
     def secondChar: String = path.take(2).drop(1).mkString("")
   }
 
-  lazy val userDir = sys.props("user.dir").norm
+  lazy val userDir: String = sys.props("user.dir").nn.norm

compiler/src/dotty/tools/scripting/Util.scala

@@ -56,7 +56,7 @@ object Util:
     end match
   end detectMainClassAndMethod
 
-  def pathsep = sys.props("path.separator")
+  def pathsep: String = sys.props("path.separator").nn
 
 end Util
 

compiler/test/dotty/tools/debug/DebugStepAssert.scala

@@ -49,17 +49,17 @@ private[debug] object DebugStepAssert:
       given location: CheckFileLocation = CheckFileLocation(checkFile, allLines.size - lines.size + 1)
       lines match
         case Nil => acc.reverse
-        case break(className , lineStr) :: tail =>
+        case break(className: String, lineStr: String) :: tail =>
           val breakpointLine = lineStr.toInt
           val step = DebugStepAssert(Break(className, breakpointLine), checkClassAndLine(className, breakpointLine))
           loop(tail, step :: acc)
-        case step(pattern) :: tail =>
+        case step(pattern: String) :: tail =>
           val step = DebugStepAssert(Step, checkLineOrMethod(pattern))
           loop(tail, step :: acc)
-        case next(pattern) :: tail =>
+        case next(pattern: String) :: tail =>
           val step = DebugStepAssert(Next, checkLineOrMethod(pattern))
           loop(tail, step :: acc)
-        case eval(expr) :: tail0 =>
+        case eval(expr: String) :: tail0 =>
           val (assertion, tail1) = parseEvalAssertion(tail0)
           val step = DebugStepAssert(Eval(expr), assertion)
           loop(tail1, step :: acc)
@@ -78,8 +78,8 @@ private[debug] object DebugStepAssert:
       lines match
         case Nil => throw new Exception(s"Missing result or error")
         case trailing() :: tail => parseEvalAssertion(tail)
-        case result(expected) :: tail => (checkResult(expected), tail)
-        case error(expected) :: tail => (checkError(Seq(expected)), tail)
+        case result(expected: String) :: tail => (checkResult(expected), tail)
+        case error(expected: String) :: tail => (checkError(Seq(expected)), tail)
         case multiLineError() :: tail0 =>
           val (expected, tail1) = tail0.span(_.startsWith("  "))
           (checkError(expected.map(_.stripPrefix("  "))), tail1)