Re-enable explicit nulls in compiler

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/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/dotc/transform/localopt/FormatChecker.scala

@@ -126,7 +126,9 @@ class TypedFormatChecker(partsElems: List[Tree], parts: List[String], args: List
     def at(g: SpecGroup): Int = descriptor.start(g.ordinal)
     def end(g: SpecGroup): Int = descriptor.end(g.ordinal)
     def offset(g: SpecGroup, i: Int = 0): Int = at(g) + i
-    def group(g: SpecGroup): Option[String] = Option(descriptor.group(g.ordinal))
+    def group(g: SpecGroup): Option[String] =
+      // Unable to use @experimental fromNullable now
+      Option(descriptor.group(g.ordinal)).asInstanceOf[Option[String]]
     def stringOf(g: SpecGroup): String = group(g).getOrElse("")
     def intOf(g: SpecGroup): Option[Int] = group(g).map(_.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/StringDriver.scala

@@ -31,7 +31,7 @@ class StringDriver(compilerArgs: Array[String], scalaSource: String) extends Dri
           try
             val classpath = s"${ctx.settings.classpath.value}${pathsep}${sys.props("java.class.path")}"
             val classpathEntries: Seq[Path] = ClassPath.expandPath(classpath, expandStar=true).map { Paths.get(_) }
-            sys.props("java.class.path") = classpathEntries.map(_.toString).mkString(pathsep)
+            sys.props("java.class.path") = classpathEntries.map(_.toString).mkString(pathsep.nn)
             detectMainClassAndMethod(outDir, classpathEntries, scalaSource) match
               case Right((mainClass, mainMethod)) =>
                 mainMethod.invoke(null, Array.empty[String])

library/src/scala/Predef.scala

@@ -517,7 +517,7 @@ object Predef extends LowPriorityImplicits {
   @inline implicit def floatArrayOps(xs: Array[Float]): ArrayOps[Float]       = new ArrayOps(xs)
   @inline implicit def intArrayOps(xs: Array[Int]): ArrayOps[Int]             = new ArrayOps(xs)
   @inline implicit def longArrayOps(xs: Array[Long]): ArrayOps[Long]          = new ArrayOps(xs)
-  @inline implicit def refArrayOps[T <: AnyRef](xs: Array[T]): ArrayOps[T]    = new ArrayOps(xs)
+  @inline implicit def refArrayOps[T <: AnyRef | Null](xs: Array[T]): ArrayOps[T]    = new ArrayOps(xs)
   @inline implicit def shortArrayOps(xs: Array[Short]): ArrayOps[Short]       = new ArrayOps(xs)
   @inline implicit def unitArrayOps(xs: Array[Unit]): ArrayOps[Unit]          = new ArrayOps(xs)