use an enum to store file extensions,

This caches common file extensions, while still being extensible.
Also fixes many operations with unexpected behavior (manipulation of
file extensions where toLowerCase behaves differently with certain locales.)

Author: bishabosha

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

@@ -28,13 +28,16 @@ class CompilationUnit protected (val source: SourceFile, val info: CompilationUn
   var tpdTree: tpd.Tree = tpd.EmptyTree
 
   /** Is this the compilation unit of a Java file */
-  def isJava: Boolean = source.file.name.endsWith(".java")
+  def isJava: Boolean = source.file.ext.isJava
 
   /** Is this the compilation unit of a Java file, or TASTy derived from a Java file */
-  def typedAsJava = isJava || {
-    val infoNN = info
-    infoNN != null && infoNN.tastyInfo.exists(_.attributes.isJava)
-  }
+  def typedAsJava =
+    val ext = source.file.ext
+    ext.isJavaOrTasty && (ext.isJava || tastyInfo.exists(_.attributes.isJava))
+
+  def tastyInfo: Option[TastyInfo] =
+    val local = info
+    if local == null then None else local.tastyInfo
 
 
   /** The source version for this unit, as determined by a language import */

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

@@ -6,7 +6,7 @@ import core.Comments.{ContextDoc, ContextDocstrings}
 import core.Contexts.*
 import core.{MacroClassLoader, TypeError}
 import dotty.tools.dotc.ast.Positioned
-import dotty.tools.io.AbstractFile
+import dotty.tools.io.{AbstractFile, FileExtension}
 import reporting.*
 import core.Decorators.*
 import config.Feature
@@ -97,9 +97,9 @@ class Driver {
           if !file.exists then
             report.error(em"File does not exist: ${file.path}")
             None
-          else file.extension match
-            case "jar" => Some(file.path)
-            case "tasty" =>
+          else file.ext match
+            case FileExtension.Jar => Some(file.path)
+            case FileExtension.Tasty =>
               TastyFileUtil.getClassPath(file) match
                 case Some(classpath) => Some(classpath)
                 case _ =>

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

@@ -6,6 +6,7 @@ package dotty.tools.dotc.classpath
 import dotty.tools.dotc.classpath.FileUtils.isTasty
 import dotty.tools.io.AbstractFile
 import dotty.tools.io.ClassRepresentation
+import dotty.tools.io.FileExtension
 
 case class ClassPathEntries(packages: scala.collection.Seq[PackageEntry], classesAndSources: scala.collection.Seq[ClassRepresentation]) {
   def toTuple: (scala.collection.Seq[PackageEntry], scala.collection.Seq[ClassRepresentation]) = (packages, classesAndSources)
@@ -52,7 +53,7 @@ sealed trait BinaryFileEntry extends ClassRepresentation {
 object BinaryFileEntry {
   def apply(file: AbstractFile): BinaryFileEntry =
     if file.isTasty then
-      if file.resolveSiblingWithExtension("class") != null then TastyWithClassFileEntry(file)
+      if file.resolveSiblingWithExtension(FileExtension.Class) != null then TastyWithClassFileEntry(file)
       else StandaloneTastyFileEntry(file)
     else
       ClassFileEntry(file)

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

@@ -285,7 +285,7 @@ case class DirectoryClassPath(dir: JFile) extends JFileDirectoryLookup[BinaryFil
   protected def createFileEntry(file: AbstractFile): BinaryFileEntry = BinaryFileEntry(file)
 
   protected def isMatchingFile(f: JFile): Boolean =
-    f.isTasty || (f.isClass && f.classToTasty.isEmpty)
+    f.isTasty || (f.isClass && !f.hasSiblingTasty)
 
   private[dotty] def classes(inPackage: PackageName): Seq[BinaryFileEntry] = files(inPackage)
 }

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

@@ -17,49 +17,52 @@ object FileUtils {
   extension (file: AbstractFile) {
     def isPackage: Boolean = file.isDirectory && mayBeValidPackage(file.name)
 
-    def isClass: Boolean = !file.isDirectory && hasClassExtension && !file.name.endsWith("$class.class")
-      // FIXME: drop last condition when we stop being compatible with Scala 2.11
+    def isClass: Boolean = !file.isDirectory && hasClassExtension
 
-    def hasClassExtension: Boolean = file.hasExtension("class")
+    def hasClassExtension: Boolean = file.ext.isClass
 
-    def hasTastyExtension: Boolean = file.hasExtension("tasty")
+    def hasTastyExtension: Boolean = file.ext.isTasty
 
     def isTasty: Boolean = !file.isDirectory && hasTastyExtension
 
     def isScalaBinary: Boolean = file.isClass || file.isTasty
 
-    def isScalaOrJavaSource: Boolean = !file.isDirectory && (file.hasExtension("scala") || file.hasExtension("java"))
+    def isScalaOrJavaSource: Boolean = !file.isDirectory && file.ext.isScalaOrJava
 
     // TODO do we need to check also other files using ZipMagicNumber like in scala.tools.nsc.io.Jar.isJarOrZip?
-    def isJarOrZip: Boolean = file.hasExtension("jar") || file.hasExtension("zip")
+    def isJarOrZip: Boolean = file.ext.isJarOrZip
 
     /**
      * Safe method returning a sequence containing one URL representing this file, when underlying file exists,
      * and returning given default value in other case
      */
     def toURLs(default: => Seq[URL] = Seq.empty): Seq[URL] = if (file.file == null) default else Seq(file.toURL)
 
-    /** Returns the tasty file associated with this class file */
-    def classToTasty: Option[AbstractFile] =
-      assert(file.isClass, s"non-class: $file")
-      val tastyName = classNameToTasty(file.name)
-      Option(file.resolveSibling(tastyName))
+    /**
+     * Returns if there is an existing sibling `.tasty` file.
+     */
+    def hasSiblingTasty: Boolean =
+      assert(file.hasClassExtension, s"non-class: $file")
+      file.resolveSibling(classNameToTasty(file.name)) != null
   }
 
   extension (file: JFile) {
     def isPackage: Boolean = file.isDirectory && mayBeValidPackage(file.getName)
 
-    def isClass: Boolean = file.isFile && file.getName.endsWith(SUFFIX_CLASS) && !file.getName.endsWith("$class.class")
-    // FIXME: drop last condition when we stop being compatible with Scala 2.11
+    def isClass: Boolean = file.isFile && hasClassExtension
+
+    def hasClassExtension: Boolean = file.getName.endsWith(SUFFIX_CLASS)
 
     def isTasty: Boolean = file.isFile && file.getName.endsWith(SUFFIX_TASTY)
 
-    /** Returns the tasty file associated with this class file */
-    def classToTasty: Option[JFile] =
-      assert(file.isClass, s"non-class: $file")
-      val tastyName = classNameToTasty(file.getName.stripSuffix(".class"))
-      val tastyPath = file.toPath.resolveSibling(tastyName)
-      if java.nio.file.Files.exists(tastyPath) then Some(tastyPath.toFile) else None
+    /**
+     * Returns if there is an existing sibling `.tasty` file.
+     */
+    def hasSiblingTasty: Boolean =
+      assert(file.hasClassExtension, s"non-class: $file")
+      val path = file.toPath
+      val tastyPath = path.resolveSibling(classNameToTasty(file.getName))
+      java.nio.file.Files.exists(tastyPath)
 
   }
 

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

@@ -51,5 +51,5 @@ case class VirtualDirectoryClassPath(dir: VirtualDirectory) extends ClassPath wi
   protected def createFileEntry(file: AbstractFile): BinaryFileEntry = BinaryFileEntry(file)
 
   protected def isMatchingFile(f: AbstractFile): Boolean =
-    f.isTasty || (f.isClass && f.classToTasty.isEmpty)
+    f.isTasty || (f.isClass && !f.hasSiblingTasty)
 }

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

@@ -53,7 +53,7 @@ object ZipAndJarClassPathFactory extends ZipAndJarFileLookupFactory {
     override protected def createFileEntry(file: FileZipArchive#Entry): BinaryFileEntry = BinaryFileEntry(file)
 
     override protected def isRequiredFileType(file: AbstractFile): Boolean =
-      file.isTasty || (file.isClass && file.classToTasty.isEmpty)
+      file.isTasty || (file.isClass && !file.hasSiblingTasty)
   }
 
   /**

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

@@ -64,7 +64,7 @@ object Settings:
 
   @unshared
   val settingCharacters = "[a-zA-Z0-9_\\-]*".r
-  def validateSettingString(name: String): Unit = 
+  def validateSettingString(name: String): Unit =
     assert(settingCharacters.matches(name), s"Setting string $name contains invalid characters")
 
 
@@ -83,7 +83,7 @@ object Settings:
     deprecationMsg: Option[String] = None,
     // kept only for -Ykind-projector option compatibility
     legacyArgs: Boolean = false)(private[Settings] val idx: Int) {
-  
+
     validateSettingString(prefix.getOrElse(name))
     aliases.foreach(validateSettingString)
     assert(name.startsWith(s"-${category.prefixLetter}"), s"Setting $name does not start with category -$category")
@@ -92,7 +92,7 @@ object Settings:
     // Example: -opt Main.scala would be interpreted as -opt:Main.scala, and the source file would be ignored.
     assert(!(summon[ClassTag[T]] == ListTag && ignoreInvalidArgs), s"Ignoring invalid args is not supported for multivalue settings: $name")
 
-    val allFullNames: List[String] = s"$name" :: s"-$name" :: aliases  
+    val allFullNames: List[String] = s"$name" :: s"-$name" :: aliases
 
     def valueIn(state: SettingsState): T = state.value(idx).asInstanceOf[T]
 
@@ -105,7 +105,7 @@ object Settings:
     def isMultivalue: Boolean = summon[ClassTag[T]] == ListTag
 
     def acceptsNoArg: Boolean = summon[ClassTag[T]] == BooleanTag || summon[ClassTag[T]] == OptionTag || choices.exists(_.contains(""))
-    
+
     def legalChoices: String =
       choices match {
         case Some(xs) if xs.isEmpty => ""
@@ -168,17 +168,17 @@ object Settings:
               update(x, args)
         catch case _: NumberFormatException =>
           fail(s"$argValue is not an integer argument for $name", args)
-        
-      def setOutput(argValue: String, args: List[String]) = 
+
+      def setOutput(argValue: String, args: List[String]) =
         val path = Directory(argValue)
-        val isJar = path.extension == "jar"
+        val isJar = path.ext.isJar
         if (!isJar && !path.isDirectory)
           fail(s"'$argValue' does not exist or is not a directory or .jar file", args)
         else {
           val output = if (isJar) JarArchive.create(path) else new PlainDirectory(path)
           update(output, args)
         }
-      
+
       def setVersion(argValue: String, args: List[String]) =
         ScalaVersion.parse(argValue) match {
           case Success(v) => update(v, args)
@@ -193,7 +193,7 @@ object Settings:
           case _ => update(strings, args)
 
 
-      def doSet(argRest: String) = 
+      def doSet(argRest: String) =
         ((summon[ClassTag[T]], args): @unchecked) match {
           case (BooleanTag, _) =>
             setBoolean(argRest, args)
@@ -224,16 +224,16 @@ object Settings:
           case _ =>
             missingArg
 
-      def matches(argName: String): Boolean = 
+      def matches(argName: String): Boolean =
         (allFullNames).exists(_ == argName.takeWhile(_ != ':')) || prefix.exists(arg.startsWith)
 
-      def argValRest: String = 
+      def argValRest: String =
         if(prefix.isEmpty) arg.dropWhile(_ != ':').drop(1) else arg.drop(prefix.get.length)
-      
-      if matches(arg) then 
+
+      if matches(arg) then
         if deprecationMsg.isDefined then
           warn(s"Option $name is deprecated: ${deprecationMsg.get}", args)
-        else 
+        else
           doSet(argValRest)
       else
         state
@@ -375,7 +375,7 @@ object Settings:
 
     def OptionSetting[T: ClassTag](category: SettingCategory, name: String, descr: String, aliases: List[String] = Nil): Setting[Option[T]] =
       publish(Setting(category, prependName(name), descr, None, propertyClass = Some(summon[ClassTag[T]].runtimeClass), aliases = aliases))
-    
+
     def DeprecatedSetting(category: SettingCategory, name: String, descr: String, deprecationMsg: String): Setting[Boolean] =
       publish(Setting(category, prependName(name), descr, false, deprecationMsg = Some(deprecationMsg)))
   }

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

@@ -7,7 +7,7 @@ import java.nio.channels.ClosedByInterruptException
 
 import scala.util.control.NonFatal
 
-import dotty.tools.dotc.classpath.FileUtils.isTasty
+import dotty.tools.dotc.classpath.FileUtils.hasTastyExtension
 import dotty.tools.io.{ ClassPath, ClassRepresentation, AbstractFile }
 import dotty.tools.backend.jvm.DottyBackendInterface.symExtensions
 
@@ -198,7 +198,7 @@ object SymbolLoaders {
         enterToplevelsFromSource(owner, nameOf(classRep), src)
       case (Some(bin), _) =>
         val completer =
-          if bin.isTasty then ctx.platform.newTastyLoader(bin)
+          if bin.hasTastyExtension then ctx.platform.newTastyLoader(bin)
           else ctx.platform.newClassLoader(bin)
         enterClassAndModule(owner, nameOf(classRep), completer)
     }

compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala

@@ -23,7 +23,7 @@ import scala.annotation.switch
 import typer.Checking.checkNonCyclic
 import io.{AbstractFile, ZipArchive}
 import scala.util.control.NonFatal
-import dotty.tools.dotc.classpath.FileUtils.classToTasty
+import dotty.tools.dotc.classpath.FileUtils.hasSiblingTasty
 
 import scala.compiletime.uninitialized
 
@@ -1143,7 +1143,7 @@ class ClassfileParser(
 
       if (scan(tpnme.TASTYATTR)) {
         val hint =
-          if classfile.classToTasty.isDefined then "This is likely a bug in the compiler. Please report."
+          if classfile.hasSiblingTasty then "This is likely a bug in the compiler. Please report."
           else "This `.tasty` file is missing. Try cleaning the project to fix this issue."
         report.error(s"Loading Scala 3 binary from $classfile. It should have been loaded from `.tasty` file. $hint", NoSourcePosition)
         return None