use an enum to store file extensions

bishabosha · bishabosha · commit 69d94d8b2261 · 2023-11-28T13:42:40.000+01:00
diff --git a/compiler/src/dotty/tools/dotc/Driver.scala b/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
@@ -98,9 +98,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 _ =>
diff --git a/compiler/src/dotty/tools/dotc/classpath/DirectoryClassPath.scala b/compiler/src/dotty/tools/dotc/classpath/DirectoryClassPath.scala
@@ -284,7 +284,7 @@ case class DirectoryClassPath(dir: JFile) extends JFileDirectoryLookup[ClassFile
 
   protected def createFileEntry(file: AbstractFile): ClassFileEntryImpl = ClassFileEntryImpl(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[ClassFileEntry] = files(inPackage)
 }
diff --git a/compiler/src/dotty/tools/dotc/classpath/FileUtils.scala b/compiler/src/dotty/tools/dotc/classpath/FileUtils.scala
@@ -8,7 +8,7 @@ import scala.language.unsafeNulls
 
 import java.io.{File => JFile, FileFilter}
 import java.net.URL
-import dotty.tools.io.AbstractFile
+import dotty.tools.io.{AbstractFile, FileExtension}
 
 /**
  * Common methods related to Java files and abstract files used in the context of classpath
@@ -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.hasExtension(FileExtension.Class)
 
-    def hasTastyExtension: Boolean = file.hasExtension("tasty")
+    def hasTastyExtension: Boolean = file.hasExtension(FileExtension.Tasty)
 
     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.hasExtension(FileExtension.Scala) || file.hasExtension(FileExtension.Java))
 
     // 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)
 
   }
 
diff --git a/compiler/src/dotty/tools/dotc/classpath/VirtualDirectoryClassPath.scala b/compiler/src/dotty/tools/dotc/classpath/VirtualDirectoryClassPath.scala
@@ -50,5 +50,5 @@ case class VirtualDirectoryClassPath(dir: VirtualDirectory) extends ClassPath wi
 
   protected def createFileEntry(file: AbstractFile): ClassFileEntryImpl = ClassFileEntryImpl(file)
   protected def isMatchingFile(f: AbstractFile): Boolean =
-    f.isTasty || (f.isClass && f.classToTasty.isEmpty)
+    f.isTasty || (f.isClass && !f.hasSiblingTasty)
 }
diff --git a/compiler/src/dotty/tools/dotc/classpath/ZipAndJarFileLookupFactory.scala b/compiler/src/dotty/tools/dotc/classpath/ZipAndJarFileLookupFactory.scala
@@ -52,7 +52,7 @@ object ZipAndJarClassPathFactory extends ZipAndJarFileLookupFactory {
 
     override protected def createFileEntry(file: FileZipArchive#Entry): ClassFileEntryImpl = ClassFileEntryImpl(file)
     override protected def isRequiredFileType(file: AbstractFile): Boolean =
-      file.isTasty || (file.isClass && file.classToTasty.isEmpty)
+      file.isTasty || (file.isClass && !file.hasSiblingTasty)
   }
 
   /**
diff --git a/compiler/src/dotty/tools/dotc/config/Settings.scala b/compiler/src/dotty/tools/dotc/config/Settings.scala
@@ -5,7 +5,7 @@ import scala.language.unsafeNulls
 
 import core.Contexts.*
 
-import dotty.tools.io.{AbstractFile, Directory, JarArchive, PlainDirectory}
+import dotty.tools.io.{AbstractFile, Directory, JarArchive, PlainDirectory, FileExtension}
 
 import annotation.tailrec
 import collection.mutable.ArrayBuffer
@@ -162,7 +162,7 @@ object Settings:
           else setString(arg2, args2)
         case (OutputTag, arg :: args) =>
           val path = Directory(arg)
-          val isJar = path.extension == "jar"
+          val isJar = path.ext == FileExtension.Jar
           if (!isJar && !path.isDirectory)
             fail(s"'$arg' does not exist or is not a directory or .jar file", args)
           else {
diff --git a/compiler/src/dotty/tools/dotc/core/SymbolLoaders.scala b/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)
     }
diff --git a/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala b/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
 
@@ -1142,7 +1142,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
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TastyPrinter.scala b/compiler/src/dotty/tools/dotc/core/tasty/TastyPrinter.scala
@@ -12,6 +12,7 @@ import util.Spans.offsetToInt
 import dotty.tools.tasty.TastyFormat.{ASTsSection, PositionsSection, CommentsSection, AttributesSection}
 import java.nio.file.{Files, Paths}
 import dotty.tools.io.{JarArchive, Path}
+import dotty.tools.dotc.classpath.FileUtils.hasTastyExtension
 
 object TastyPrinter:
 
@@ -47,7 +48,7 @@ object TastyPrinter:
       else if arg.endsWith(".jar") then
         val jar = JarArchive.open(Path(arg), create = false)
         try
-          for file <- jar.iterator() if file.name.endsWith(".tasty") do
+          for file <- jar.iterator() if file.hasTastyExtension do
             printTasty(s"$arg ${file.path}", file.toByteArray)
         finally jar.close()
       else
diff --git a/compiler/src/dotty/tools/dotc/fromtasty/Debug.scala b/compiler/src/dotty/tools/dotc/fromtasty/Debug.scala
@@ -6,7 +6,7 @@ import scala.language.unsafeNulls
 
 import scala.util.control.NonFatal
 
-import dotty.tools.io.Directory
+import dotty.tools.io.{Directory, FileExtension}
 
 import java.io.{File => JFile}
 import java.nio.file.{Files, Paths}
@@ -40,7 +40,7 @@ object Debug {
 
     val tastyFiles =
       Directory(fromSourcesOut).walk
-        .filter(x => x.isFile && "tasty".equalsIgnoreCase(x.extension))
+        .filter(x => x.isFile && x.ext == FileExtension.Tasty)
         .map(_.toString)
         .toList
 
diff --git a/compiler/src/dotty/tools/dotc/fromtasty/TASTYRun.scala b/compiler/src/dotty/tools/dotc/fromtasty/TASTYRun.scala
@@ -4,7 +4,7 @@ package fromtasty
 
 import scala.language.unsafeNulls
 
-import io.{JarArchive, AbstractFile, Path}
+import io.{JarArchive, AbstractFile, Path, FileExtension}
 import core.Contexts.*
 import core.Decorators.em
 import java.io.File
@@ -19,14 +19,14 @@ class TASTYRun(comp: Compiler, ictx: Context) extends Run(comp, ictx) {
     val fromTastyIgnoreList = ctx.settings.YfromTastyIgnoreList.value.toSet
     // Resolve class names of tasty and jar files
     val classNames = files.flatMap { file =>
-      file.extension match
-        case "jar" =>
+      file.ext match
+        case FileExtension.Jar =>
           JarArchive.open(Path(file.path), create = false).allFileNames()
             .map(_.stripPrefix(File.separator)) // change paths from absolute to relative
-            .filter(e => Path.extension(e) == "tasty" && !fromTastyIgnoreList(e))
+            .filter(e => Path.fileExtension(e) == FileExtension.Tasty && !fromTastyIgnoreList(e))
             .map(e => e.stripSuffix(".tasty").replace(File.separator, "."))
             .toList
-        case "tasty" => TastyFileUtil.getClassName(file)
+        case FileExtension.Tasty => TastyFileUtil.getClassName(file)
         case _ =>
           report.error(em"File extension is not `tasty` or `jar`: ${file.path}")
           Nil
diff --git a/compiler/src/dotty/tools/dotc/fromtasty/TastyFileUtil.scala b/compiler/src/dotty/tools/dotc/fromtasty/TastyFileUtil.scala
@@ -5,7 +5,8 @@ import scala.language.unsafeNulls
 
 import dotty.tools.dotc.core.tasty.TastyClassName
 import dotty.tools.dotc.core.StdNames.nme.EMPTY_PACKAGE
-import dotty.tools.io.AbstractFile
+import dotty.tools.io.{AbstractFile, FileExtension}
+import dotty.tools.dotc.classpath.FileUtils.hasTastyExtension
 
 object TastyFileUtil {
   /** Get the class path of a tasty file
@@ -34,7 +35,7 @@ object TastyFileUtil {
    */
   def getClassName(file: AbstractFile): Option[String] = {
     assert(file.exists)
-    assert(file.extension == "tasty")
+    assert(file.hasTastyExtension)
     val bytes = file.toByteArray
     val names = new TastyClassName(bytes).readName()
     names.map { case (packageName, className) =>
diff --git a/compiler/src/dotty/tools/dotc/sbt/ExtractAPI.scala b/compiler/src/dotty/tools/dotc/sbt/ExtractAPI.scala
@@ -18,7 +18,7 @@ import Names.*
 import NameOps.*
 import inlines.Inlines
 import transform.ValueClasses
-import dotty.tools.io.File
+import dotty.tools.io.{File, FileExtension}
 import java.io.PrintWriter
 
 
@@ -76,7 +76,7 @@ class ExtractAPI extends Phase {
 
     if (ctx.settings.YdumpSbtInc.value) {
       // Append to existing file that should have been created by ExtractDependencies
-      val pw = new PrintWriter(File(sourceFile.file.jpath).changeExtension("inc").toFile
+      val pw = new PrintWriter(File(sourceFile.file.jpath).changeExtension(FileExtension.Inc).toFile
         .bufferedWriter(append = true), true)
       try {
         classes.foreach(source => pw.println(DefaultShowAPI(source)))
diff --git a/compiler/src/dotty/tools/dotc/sbt/ExtractDependencies.scala b/compiler/src/dotty/tools/dotc/sbt/ExtractDependencies.scala
@@ -8,7 +8,7 @@ import java.nio.file.Path
 import java.util.{Arrays, EnumSet}
 
 import dotty.tools.dotc.ast.tpd
-import dotty.tools.dotc.classpath.FileUtils.{isTasty, hasClassExtension, hasTastyExtension}
+import dotty.tools.dotc.classpath.FileUtils.{hasClassExtension, hasTastyExtension}
 import dotty.tools.dotc.core.Contexts.*
 import dotty.tools.dotc.core.Decorators.*
 import dotty.tools.dotc.core.Flags.*
@@ -21,7 +21,7 @@ import dotty.tools.dotc.core.Types.*
 
 import dotty.tools.dotc.util.{SrcPos, NoSourcePosition}
 import dotty.tools.io
-import dotty.tools.io.{AbstractFile, PlainFile, ZipArchive, NoAbstractFile}
+import dotty.tools.io.{AbstractFile, PlainFile, ZipArchive, NoAbstractFile, FileExtension}
 import xsbti.UseScope
 import xsbti.api.DependencyContext
 import xsbti.api.DependencyContext.*
@@ -84,7 +84,7 @@ class ExtractDependencies extends Phase {
       Arrays.sort(deps)
       Arrays.sort(names)
 
-      val pw = io.File(unit.source.file.jpath).changeExtension("inc").toFile.printWriter()
+      val pw = io.File(unit.source.file.jpath).changeExtension(FileExtension.Inc).toFile.printWriter()
       // val pw = Console.out
       try {
         pw.println("Used Names:")
@@ -495,7 +495,7 @@ class DependencyRecorder {
     if depFile != null then {
       // Cannot ignore inheritance relationship coming from the same source (see sbt/zinc#417)
       def allowLocal = depCtx == DependencyByInheritance || depCtx == LocalDependencyByInheritance
-      val isTasty = depFile.hasTastyExtension
+      val isTastyOrSig = depFile.hasTastyExtension
 
       def processExternalDependency() = {
         val binaryClassName = depClass.binaryClassName
@@ -506,13 +506,13 @@ class DependencyRecorder {
                 binaryDependency(zip.jpath, binaryClassName)
               case _ =>
           case pf: PlainFile => // The dependency comes from a class file, Zinc handles JRT filesystem
-            binaryDependency(if isTasty then cachedSiblingClass(pf) else pf.jpath, binaryClassName)
+            binaryDependency(if isTastyOrSig then cachedSiblingClass(pf) else pf.jpath, binaryClassName)
           case _ =>
             internalError(s"Ignoring dependency $depFile of unknown class ${depFile.getClass}}", fromClass.srcPos)
         }
       }
 
-      if isTasty || depFile.hasClassExtension then
+      if isTastyOrSig || depFile.hasClassExtension then
         processExternalDependency()
       else if allowLocal || depFile != sourceFile.file then
         // We cannot ignore dependencies coming from the same source file because
diff --git a/compiler/src/dotty/tools/dotc/util/EnumFlags.scala b/compiler/src/dotty/tools/dotc/util/EnumFlags.scala
@@ -0,0 +1,14 @@
+package dotty.tools.dotc.util
+
+object EnumFlags:
+
+  opaque type FlagSet[E <: reflect.Enum] = Int
+
+  object FlagSet:
+
+    extension [E <: reflect.Enum](set: FlagSet[E])
+      def is(flag: E): Boolean = (set & (1 << flag.ordinal)) != 0
+      def |(flag: E): FlagSet[E] = (set | (1 << flag.ordinal))
+
+    def empty[E <: reflect.Enum]: FlagSet[E] =
+      0
diff --git a/compiler/src/dotty/tools/io/AbstractFile.scala b/compiler/src/dotty/tools/io/AbstractFile.scala
@@ -97,11 +97,18 @@ abstract class AbstractFile extends Iterable[AbstractFile] {
   /** Returns the path of this abstract file in a canonical form. */
   def canonicalPath: String = if (jpath == null) path else jpath.normalize.toString
 
-  /** Checks extension case insensitively. TODO: change to enum */
+  /** Checks extension case insensitively. */
+  def hasExtension(other: FileExtension): Boolean = ext == other
+
+  /** Checks extension case insensitively. */
+  @deprecated("use overload with FileExtension")
   def hasExtension(other: String): Boolean = extension == other.toLowerCase
 
-  /** Returns the extension of this abstract file. TODO: store as an enum to avoid costly comparisons */
-  val extension: String = Path.extension(name)
+  /** Returns the extension of this abstract file. */
+  val ext: FileExtension = Path.fileExtension(name)
+
+  /** Returns the extension of this abstract file as a String. */
+  def extension: String = ext.toLowerCase
 
   /** The absolute file, if this is a relative file. */
   def absolute: AbstractFile
@@ -129,7 +136,7 @@ abstract class AbstractFile extends Iterable[AbstractFile] {
   }
 
   /** Does this abstract file represent something which can contain classfiles? */
-  def isClassContainer: Boolean = isDirectory || (jpath != null && (extension == "jar" || extension == "zip"))
+  def isClassContainer: Boolean = isDirectory || (jpath != null && ext.isJarOrZip)
 
   /** Create a file on disk, if one does not exist already. */
   def create(): Unit
diff --git a/compiler/src/dotty/tools/io/File.scala b/compiler/src/dotty/tools/io/File.scala
@@ -40,7 +40,7 @@ object File {
 class File(jpath: JPath)(implicit constructorCodec: Codec) extends Path(jpath) with Streamable.Chars {
   override val creationCodec: io.Codec = constructorCodec
 
-  override def addExtension(ext: String): File = super.addExtension(ext).toFile
+  override def addExtension(ext: FileExtension): File = super.addExtension(ext).toFile
   override def toAbsolute: File = if (isAbsolute) this else super.toAbsolute.toFile
   override def toDirectory: Directory = new Directory(jpath)
   override def toFile: File = this
diff --git a/compiler/src/dotty/tools/io/FileExtension.scala b/compiler/src/dotty/tools/io/FileExtension.scala
diff --git a/compiler/src/dotty/tools/io/Jar.scala b/compiler/src/dotty/tools/io/Jar.scala
diff --git a/compiler/src/dotty/tools/io/JarArchive.scala b/compiler/src/dotty/tools/io/JarArchive.scala
diff --git a/compiler/src/dotty/tools/io/Path.scala b/compiler/src/dotty/tools/io/Path.scala

Original file line number	Diff line number	Diff line change
`@@ -284,7 +284,7 @@ case class DirectoryClassPath(dir: JFile) extends JFileDirectoryLookup[ClassFile`
`284`	`284`
`285`	`285`	`protected def createFileEntry(file: AbstractFile): ClassFileEntryImpl = ClassFileEntryImpl(file)`
`286`	`286`	`protected def isMatchingFile(f: JFile): Boolean =`
`287`		`- f.isTasty \|\| (f.isClass && f.classToTasty.isEmpty)`
	`287`	`+ f.isTasty \|\| (f.isClass && !f.hasSiblingTasty)`
`288`	`288`
`289`	`289`	`private[dotty] def classes(inPackage: PackageName): Seq[ClassFileEntry] = files(inPackage)`
`290`	`290`	`}`
Original file line number	Diff line number	Diff line change
`@@ -50,5 +50,5 @@ case class VirtualDirectoryClassPath(dir: VirtualDirectory) extends ClassPath wi`
`50`	`50`
`51`	`51`	`protected def createFileEntry(file: AbstractFile): ClassFileEntryImpl = ClassFileEntryImpl(file)`
`52`	`52`	`protected def isMatchingFile(f: AbstractFile): Boolean =`
`53`		`- f.isTasty \|\| (f.isClass && f.classToTasty.isEmpty)`
	`53`	`+ f.isTasty \|\| (f.isClass && !f.hasSiblingTasty)`
`54`	`54`	`}`
Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,7 @@ object ZipAndJarClassPathFactory extends ZipAndJarFileLookupFactory {`
`52`	`52`
`53`	`53`	`override protected def createFileEntry(file: FileZipArchive#Entry): ClassFileEntryImpl = ClassFileEntryImpl(file)`
`54`	`54`	`override protected def isRequiredFileType(file: AbstractFile): Boolean =`
`55`		`- file.isTasty \|\| (file.isClass && file.classToTasty.isEmpty)`
	`55`	`+ file.isTasty \|\| (file.isClass && !file.hasSiblingTasty)`
`56`	`56`	`}`
`57`	`57`
`58`	`58`	`/**`