Use flexible types in dotty

compiler/src/dotty/tools/MainGenericCompiler.scala

@@ -1,7 +1,5 @@
 package dotty.tools
 
-import scala.language.unsafeNulls
-
 import scala.annotation.tailrec
 import scala.io.Source
 import scala.util.Try

compiler/src/dotty/tools/MainGenericRunner.scala

@@ -1,7 +1,5 @@
 package dotty.tools
 
-import scala.language.unsafeNulls
-
 import scala.annotation.tailrec
 import scala.io.Source
 import scala.util.Try

compiler/src/dotty/tools/backend/jvm/AsmUtils.scala

@@ -2,8 +2,6 @@ package dotty.tools
 package backend
 package jvm
 
-import scala.language.unsafeNulls
-
 import scala.tools.asm.tree.{AbstractInsnNode}
 import java.io.PrintWriter
 import scala.tools.asm.util.{TraceClassVisitor, TraceMethodVisitor, Textifier}

compiler/src/dotty/tools/backend/jvm/ClassfileWriters.scala

@@ -18,8 +18,6 @@ import dotty.tools.io.PlainFile.toPlainFile
 import BTypes.InternalName
 import dotty.tools.io.JarArchive
 
-import scala.language.unsafeNulls
-
 /** !!! This file is now copied in `dotty.tools.io.FileWriters` in a more general way that does not rely upon
  * `PostProcessorFrontendAccess`, this should probably be changed to wrap that class instead.
  *
@@ -54,11 +52,11 @@ class ClassfileWriters(frontendAccess: PostProcessorFrontendAccess) {
     def close(): Unit
 
     protected def classRelativePath(className: InternalName, suffix: String = ".class"): String =
-      className.replace('.', '/').nn + suffix
+      className.replace('.', '/') + suffix
   }
 
   object ClassfileWriter {
-    private def getDirectory(dir: String): Path = Paths.get(dir).nn
+    private def getDirectory(dir: String): Path = Paths.get(dir)
 
     def apply(): ClassfileWriter = {
       val jarManifestMainClass: Option[String] = compilerSettings.mainClass.orElse {
@@ -137,7 +135,7 @@ class ClassfileWriters(frontendAccess: PostProcessorFrontendAccess) {
         new JarEntryWriter(jarFile, jarManifestMainClass, jarCompressionLevel)
       }
       else if (file.isVirtual) new VirtualFileWriter(file)
-      else if (file.isDirectory) new DirEntryWriter(file.file.toPath.nn)
+      else if (file.isDirectory) new DirEntryWriter(file.file.nn.toPath)
       else throw new IllegalStateException(s"don't know how to handle an output of $file [${file.getClass}]")
   }
 
@@ -151,7 +149,7 @@ class ClassfileWriters(frontendAccess: PostProcessorFrontendAccess) {
     val jarWriter: JarOutputStream = {
       import scala.util.Properties.*
       val manifest = new Manifest
-      val attrs = manifest.getMainAttributes.nn
+      val attrs = manifest.getMainAttributes
       attrs.put(MANIFEST_VERSION, "1.0")
       attrs.put(ScalaCompilerVersion, versionNumberString)
       mainClass.foreach(c => attrs.put(MAIN_CLASS, c))
@@ -184,7 +182,7 @@ class ClassfileWriters(frontendAccess: PostProcessorFrontendAccess) {
       // important detail here, even on Windows, Zinc expects the separator within the jar
       // to be the system default, (even if in the actual jar file the entry always uses '/').
       // see https://github.com/sbt/zinc/blob/dcddc1f9cfe542d738582c43f4840e17c053ce81/internal/compiler-bridge/src/main/scala/xsbt/JarUtils.scala#L47
-      val pathInJar = 
+      val pathInJar =
         if File.separatorChar == '/' then relativePath
         else relativePath.replace('/', File.separatorChar)
       PlainFile.toPlainFile(Paths.get(s"${file.absolutePath}!$pathInJar"))
@@ -293,5 +291,5 @@ class ClassfileWriters(frontendAccess: PostProcessorFrontendAccess) {
   }
 
   /** Can't output a file due to the state of the file system. */
-  class FileConflictException(msg: String, cause: Throwable = null) extends IOException(msg, cause)
+  class FileConflictException(msg: String, cause: Throwable | Null = null) extends IOException(msg, cause)
 }

compiler/src/dotty/tools/backend/jvm/PostProcessor.scala

@@ -36,7 +36,7 @@ class PostProcessor(val frontendAccess: PostProcessorFrontendAccess, val bTypes:
         setInnerClasses(classNode)
         serializeClass(classNode)
       catch
-        case e: java.lang.RuntimeException if e.getMessage != null && e.getMessage.nn.contains("too large!") =>
+        case e: java.lang.RuntimeException if e.getMessage != null && e.getMessage.contains("too large!") =>
           backendReporting.error(em"Could not write class $internalName because it exceeds JVM code size limits. ${e.getMessage}")
           null
         case ex: Throwable =>
@@ -58,8 +58,8 @@ class PostProcessor(val frontendAccess: PostProcessorFrontendAccess, val bTypes:
   }
 
   private def warnCaseInsensitiveOverwrite(clazz: GeneratedClass) = {
-    val name = clazz.classNode.name.nn
-    val lowerCaseJavaName = name.nn.toLowerCase
+    val name = clazz.classNode.name
+    val lowerCaseJavaName = name.toLowerCase
     val clsPos = clazz.position
     caseInsensitively.putIfAbsent(lowerCaseJavaName, (name, clsPos)) match {
       case null => ()

compiler/src/dotty/tools/dotc/Bench.scala

@@ -30,7 +30,7 @@ object Bench extends Driver:
       println(s"time elapsed: ${times(curRun)}ms")
       if ctx.settings.Xprompt.value || waitAfter == curRun + 1 then
         print("hit <return> to continue >")
-        System.in.nn.read()
+        System.in.read()
     reporter
 
   def extractNumArg(args: Array[String], name: String, default: Int = 1): (Int, Array[String]) = {

compiler/src/dotty/tools/dotc/Driver.scala

@@ -38,7 +38,7 @@ class Driver {
         finish(compiler, run)
       catch
         case ex: FatalError =>
-          report.error(ex.getMessage.nn) // signals that we should fail compilation.
+          report.error(ex.getMessage) // signals that we should fail compilation.
         case ex: Throwable if ctx.usedBestEffortTasty =>
           report.bestEffortError(ex, "Some best-effort tasty files were not able to be read.")
           throw ex
@@ -117,7 +117,7 @@ class Driver {
         .distinct
       val ctx1 = ctx.fresh
       val fullClassPath =
-        (newEntries :+ ctx.settings.classpath.value).mkString(java.io.File.pathSeparator.nn)
+        (newEntries :+ ctx.settings.classpath.value).mkString(java.io.File.pathSeparator)
       ctx1.setSetting(ctx1.settings.classpath, fullClassPath)
     else ctx
 

compiler/src/dotty/tools/dotc/Run.scala

@@ -236,7 +236,7 @@ extends ImplicitRunInfo, ConstraintRunInfo, cc.CaptureRunInfo {
     try
       trackProgress(_.cancel())
     finally
-      Thread.currentThread().nn.interrupt()
+      Thread.currentThread().interrupt()
 
   private def doAdvancePhase(currentPhase: Phase, wasRan: Boolean)(using Context): Unit =
     trackProgress: progress =>

compiler/src/dotty/tools/dotc/cc/CaptureSet.scala

@@ -777,8 +777,8 @@ object CaptureSet:
   extends Var(owner, initialElems):
 
     // For debugging: A trace where a set was created. Note that logically it would make more
-    // sense to place this variable in BiMapped, but that runs afoul of the initializatuon checker.
-    // val stack = if debugSets && this.isInstanceOf[BiMapped] then (new Throwable).getStackTrace().nn.take(20) else null
+    // sense to place this variable in Mapped, but that runs afoul of the initialization checker.
+    // val stack = if debugSets && this.isInstanceOf[Mapped] then (new Throwable).getStackTrace().take(20) else null
 
     /** The variable from which this variable is derived */
     def source: Var

compiler/src/dotty/tools/dotc/classpath/AggregateClassPath.scala

@@ -4,8 +4,6 @@
 package dotty.tools
 package dotc.classpath
 
-import scala.language.unsafeNulls
-
 import java.net.URL
 import scala.collection.mutable.ArrayBuffer
 import scala.collection.immutable.ArraySeq

compiler/src/dotty/tools/dotc/classpath/ClassPathFactory.scala

@@ -67,7 +67,7 @@ class ClassPathFactory {
         for
           file <- files
           a <- ClassPath.expandManifestPath(file.absolutePath)
-          path = java.nio.file.Paths.get(a.toURI()).nn
+          path = java.nio.file.Paths.get(a.toURI())
           if Files.exists(path)
         yield
           newClassPath(AbstractFile.getFile(path))
@@ -82,7 +82,7 @@ class ClassPathFactory {
     if (file.isJarOrZip)
       ZipAndJarSourcePathFactory.create(file)
     else if (file.isDirectory)
-      new DirectorySourcePath(file.file)
+      new DirectorySourcePath(file.file.nn)
     else
       sys.error(s"Unsupported sourcepath element: $file")
 }
@@ -94,7 +94,7 @@ object ClassPathFactory {
       if (file.isJarOrZip)
         ZipAndJarClassPathFactory.create(file)
       else if (file.isDirectory)
-        new DirectoryClassPath(file.file)
+        new DirectoryClassPath(file.file.nn)
       else
         sys.error(s"Unsupported classpath element: $file")
   }

compiler/src/dotty/tools/dotc/classpath/DirectoryClassPath.scala

@@ -3,8 +3,6 @@
  */
 package dotty.tools.dotc.classpath
 
-import scala.language.unsafeNulls
-
 import java.io.{File => JFile}
 import java.net.{URI, URL}
 import java.nio.file.{FileSystems, Files}
@@ -119,7 +117,7 @@ trait JFileDirectoryLookup[FileEntryType <: ClassRepresentation] extends Directo
   protected def toAbstractFile(f: JFile): AbstractFile = f.toPath.toPlainFile
   protected def isPackage(f: JFile): Boolean = f.isPackage
 
-  assert(dir != null, "Directory file in DirectoryFileLookup cannot be null")
+  assert(dir.asInstanceOf[JFile | Null] != null, "Directory file in DirectoryFileLookup cannot be null")
 
   def asURLs: Seq[URL] = Seq(dir.toURI.toURL)
   def asClassPathStrings: Seq[String] = Seq(dir.getPath)
@@ -216,7 +214,7 @@ final class JrtClassPath(fs: java.nio.file.FileSystem) extends ClassPath with No
 final class CtSymClassPath(ctSym: java.nio.file.Path, release: Int) extends ClassPath with NoSourcePaths {
   import java.nio.file.Path, java.nio.file.*
 
-  private val fileSystem: FileSystem = FileSystems.newFileSystem(ctSym, null: ClassLoader)
+  private val fileSystem: FileSystem = FileSystems.newFileSystem(ctSym, null.asInstanceOf[ClassLoader])
   private val root: Path = fileSystem.getRootDirectories.iterator.next
   private val roots = Files.newDirectoryStream(root).iterator.asScala.toList
 

compiler/src/dotty/tools/dotc/classpath/FileUtils.scala

@@ -4,8 +4,6 @@
 package dotty.tools
 package dotc.classpath
 
-import scala.language.unsafeNulls
-
 import java.io.{File => JFile, FileFilter}
 import java.net.URL
 import dotty.tools.io.AbstractFile

compiler/src/dotty/tools/dotc/classpath/VirtualDirectoryClassPath.scala

@@ -11,8 +11,8 @@ case class VirtualDirectoryClassPath(dir: VirtualDirectory) extends ClassPath wi
   type F = AbstractFile
 
   // From AbstractFileClassLoader
-  private final def lookupPath(base: AbstractFile)(pathParts: Seq[String], directory: Boolean): AbstractFile = {
-    var file: AbstractFile = base
+  private final def lookupPath(base: AbstractFile)(pathParts: Seq[String], directory: Boolean): AbstractFile | Null = {
+    var file: AbstractFile | Null = base
     val dirParts = pathParts.init.iterator
     while (dirParts.hasNext) {
       val dirPart = dirParts.next

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

@@ -114,12 +114,12 @@ object CommandLineParser:
   def expandArg(arg: String): List[String] =
     val path = Paths.get(arg.stripPrefix("@"))
     if !Files.exists(path) then
-      System.err.nn.println(s"Argument file ${path.nn.getFileName} could not be found")
+      System.err.println(s"Argument file ${path.getFileName} could not be found")
       Nil
     else
       def stripComment(s: String) = s.indexOf('#') match { case -1 => s case i => s.substring(0, i) }
-      val lines = Files.readAllLines(path).nn
-      val params = lines.asScala.map(stripComment).filter(!_.nn.isEmpty).mkString(" ")
+      val lines = Files.readAllLines(path)
+      val params = lines.asScala.map(stripComment).filter(!_.isEmpty).mkString(" ")
       tokenize(params)
 
   class ParseException(msg: String) extends RuntimeException(msg)

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

@@ -5,7 +5,7 @@ import core.Contexts.{Context, ctx}
 object Printers {
 
   class Printer {
-    def println(msg: => String): Unit = System.out.nn.println(msg)
+    def println(msg: => String): Unit = System.out.println(msg)
   }
 
   object noPrinter extends Printer {

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

@@ -1,7 +1,6 @@
 package dotty.tools.dotc
 package config
 
-import scala.language.unsafeNulls
 import dotty.tools.dotc.config.PathResolver.Defaults
 import dotty.tools.dotc.config.Settings.{Setting, SettingGroup, SettingCategory, Deprecation}
 import dotty.tools.dotc.config.SourceVersion

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

@@ -4,7 +4,6 @@ package config
 import Settings.Setting.ChoiceWithHelp
 import dotty.tools.backend.jvm.BackendUtils.classfileVersionMap
 import dotty.tools.io.{AbstractFile, Directory, JDK9Reflectors, PlainDirectory, NoAbstractFile}
-import scala.language.unsafeNulls
 
 object ScalaSettingsProperties:
 

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

@@ -3,8 +3,6 @@
 package dotty.tools
 package dotc.config
 
-import scala.language.unsafeNulls
-
 import scala.annotation.internal.sharable
 import scala.util.{Try, Success, Failure}
 
@@ -82,20 +80,20 @@ case class SpecificScalaVersion(major: Int, minor: Int, rev: Int, build: ScalaBu
        "The minor and revision parts are optional."
     ))
 
-    def toInt(s: String) = s match {
+    def toInt(s: String | Null) = s match {
       case null | "" => 0
-      case _ => s.toInt
+      case _ => s.nn.toInt
     }
 
     def isInt(s: String) = Try(toInt(s)).isSuccess
 
     import ScalaBuild.*
 
-    def toBuild(s: String) = s match {
+    def toBuild(s: String | Null) = s match {
       case null | "FINAL" => Final
       case s if (s.toUpperCase.startsWith("RC") && isInt(s.substring(2))) => RC(toInt(s.substring(2)))
       case s if (s.toUpperCase.startsWith("M") && isInt(s.substring(1))) => Milestone(toInt(s.substring(1)))
-      case _ => Development(s)
+      case _ => Development(s.nn)
     }
 
     try versionString match {

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

@@ -1,8 +1,6 @@
 package dotty.tools.dotc
 package config
 
-import scala.language.unsafeNulls
-
 import core.Contexts.*
 
 import dotty.tools.io.{AbstractFile, Directory, JarArchive, PlainDirectory}

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

@@ -2,8 +2,6 @@ package dotty.tools
 package dotc
 package core
 
-import scala.language.unsafeNulls
-
 import ast.{ untpd, tpd }
 import Symbols.*, Contexts.*
 import util.{SourceFile, ReadOnlyMap}

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

@@ -51,7 +51,7 @@ object Decorators {
         if name.length != 0 then name.getChars(0, name.length, chars, s.length)
         termName(chars, 0, len)
       case name: TypeName => s.concat(name.toTermName)
-      case _ => termName(s.concat(name.toString).nn)
+      case _ => termName(s.concat(name.toString))
 
     def indented(width: Int): String =
       val padding = " " * width
@@ -289,10 +289,10 @@ object Decorators {
           case NonFatal(ex)
           if !ctx.settings.YshowPrintErrors.value =>
             s"... (cannot display due to ${ex.className} ${ex.getMessage}) ..."
-      case _ => String.valueOf(x).nn
+      case _ => String.valueOf(x)
 
     /** Returns the simple class name of `x`. */
-    def className: String = if x == null then "<null>" else x.getClass.getSimpleName.nn
+    def className: String = if x == null then "<null>" else x.getClass.getSimpleName
 
   extension [T](x: T)
     def assertingErrorsReported(using Context): T = {

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

@@ -19,8 +19,6 @@ object MacroClassLoader {
     ctx.setProperty(MacroClassLoaderKey, makeMacroClassLoader(using ctx))
 
   private def makeMacroClassLoader(using Context): ClassLoader = trace("new macro class loader") {
-    import scala.language.unsafeNulls
-
     val entries = ClassPath.expandPath(ctx.settings.classpath.value, expandStar=true)
     val urls = entries.map(cp => java.nio.file.Paths.get(cp).toUri.toURL).toArray
     val out = Option(ctx.settings.outputDir.value.toURL) // to find classes in case of suspended compilation

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

@@ -15,7 +15,7 @@ import nme.*
 object NameOps {
 
   object compactify {
-    lazy val md5: MessageDigest = MessageDigest.getInstance("MD5").nn
+    lazy val md5: MessageDigest = MessageDigest.getInstance("MD5")
 
     inline val CLASSFILE_NAME_CHAR_LIMIT = 240
 
@@ -43,9 +43,9 @@ object NameOps {
         val suffix = s.takeRight(edge)
 
         val cs = s.toArray
-        val bytes = Codec.toUTF8(CharBuffer.wrap(cs).nn)
+        val bytes = Codec.toUTF8(CharBuffer.wrap(cs))
         md5.update(bytes)
-        val md5chars = md5.digest().nn.map(b => (b & 0xFF).toHexString).mkString
+        val md5chars = md5.digest().map(b => (b & 0xFF).toHexString).mkString
 
         prefix + marker + md5chars + marker + suffix
       }

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

@@ -393,7 +393,7 @@ object Names {
             // because asserts are caught in exception handlers which might
             // cause other failures. In that case the first, important failure
             // is lost.
-            System.err.nn.println("Backend should not call Name#toString, Name#mangledString should be used instead.")
+            System.err.println("Backend should not call Name#toString, Name#mangledString should be used instead.")
             Thread.dumpStack()
             assert(false)
           }
@@ -404,8 +404,8 @@ object Names {
      *  from GenBCode or it also contains one of the allowed methods below.
      */
     private def toStringOK = {
-      val trace: Array[StackTraceElement] = Thread.currentThread.nn.getStackTrace.asInstanceOf[Array[StackTraceElement]]
-      !trace.exists(_.getClassName.nn.endsWith("GenBCode")) ||
+      val trace: Array[StackTraceElement] = Thread.currentThread.getStackTrace.asInstanceOf[Array[StackTraceElement]]
+      !trace.exists(_.getClassName.endsWith("GenBCode")) ||
       trace.exists(elem =>
           List(
               "mangledString",