Reduce allocations when loading packages from classpath

This is a port of the following PR in scalac:

scala/scala#8927

Author: liufengyun

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

@@ -23,24 +23,27 @@ trait PackageEntry {
 }
 
 private[dotty] case class ClassFileEntryImpl(file: AbstractFile) extends ClassFileEntry {
-  override def name: String = FileUtils.stripClassExtension(file.name) // class name
+  final def fileName: String = file.name
+  def name: String = FileUtils.stripClassExtension(file.name) // class name
 
-  override def binary: Option[AbstractFile] = Some(file)
-  override def source: Option[AbstractFile] = None
+  def binary: Option[AbstractFile] = Some(file)
+  def source: Option[AbstractFile] = None
 }
 
 private[dotty] case class SourceFileEntryImpl(file: AbstractFile) extends SourceFileEntry {
-  override def name: String = FileUtils.stripSourceExtension(file.name)
+  final def fileName: String = file.name
+  def name: String = FileUtils.stripSourceExtension(file.name)
 
-  override def binary: Option[AbstractFile] = None
-  override def source: Option[AbstractFile] = Some(file)
+  def binary: Option[AbstractFile] = None
+  def source: Option[AbstractFile] = Some(file)
 }
 
 private[dotty] case class ClassAndSourceFilesEntry(classFile: AbstractFile, srcFile: AbstractFile) extends ClassRepresentation {
-  override def name: String = FileUtils.stripClassExtension(classFile.name)
+  final def fileName: String = classFile.name
+  def name: String = FileUtils.stripClassExtension(classFile.name)
 
-  override def binary: Option[AbstractFile] = Some(classFile)
-  override def source: Option[AbstractFile] = Some(srcFile)
+  def binary: Option[AbstractFile] = Some(classFile)
+  def source: Option[AbstractFile] = Some(srcFile)
 }
 
 private[dotty] case class PackageEntryImpl(name: String) extends PackageEntry

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

@@ -682,10 +682,13 @@ class Definitions {
   @tu lazy val NonLocalReturnControlClass: ClassSymbol = requiredClass("scala.runtime.NonLocalReturnControl")
   @tu lazy val SelectableClass: ClassSymbol = requiredClass("scala.Selectable")
 
+  @tu lazy val ReflectPackageVal: TermSymbol = requiredPackage("scala.reflect")
+  @tu lazy val ReflectPackageClass: ClassSymbol = ReflectPackageVal.moduleClass.asClass
+  @tu lazy val ReflectPackageModuleClass: Symbol = requiredPackage("scala.reflect.package").moduleClass
+
   @tu lazy val ClassTagClass: ClassSymbol = requiredClass("scala.reflect.ClassTag")
   @tu lazy val ClassTagModule: Symbol = ClassTagClass.companionModule
     @tu lazy val ClassTagModule_apply: Symbol = ClassTagModule.requiredMethod(nme.apply)
-  @tu lazy val ReflectPackageClass: Symbol = requiredPackage("scala.reflect.package").moduleClass
 
 
   @tu lazy val QuotedExprClass: ClassSymbol = requiredClass("scala.quoted.Expr")

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

@@ -4,24 +4,31 @@ package core
 
 import java.io.{IOException, File}
 import java.nio.channels.ClosedByInterruptException
+
 import scala.compat.Platform.currentTime
+import scala.util.control.NonFatal
+
 import dotty.tools.io.{ ClassPath, ClassRepresentation, AbstractFile }
+
+import dotty.tools.backend.jvm.DottyBackendInterface.symExtensions
+
 import config.Config
 import Contexts._, Symbols._, Flags._, SymDenotations._, Types._, Scopes._, Names._
 import NameOps._
-import StdNames.str
+import StdNames._
 import Decorators._
 import classfile.ClassfileParser
-import util.Stats
 import Decorators._
-import scala.util.control.NonFatal
+
+import util.Stats
+import reporting.trace
+
 import ast.Trees._
+import ast.desugar
+
 import parsing.JavaParsers.OutlineJavaParser
 import parsing.Parsers.OutlineParser
-import reporting.trace
-import ast.desugar
 
-import dotty.tools.backend.jvm.DottyBackendInterface.symExtensions
 
 object SymbolLoaders {
   import ast.untpd._
@@ -178,27 +185,37 @@ object SymbolLoaders {
    *  Note: We do a name-base comparison here because the method is called before we even
    *  have ReflectPackage defined.
    */
-  def binaryOnly(owner: Symbol, name: String)(using Context): Boolean =
-    name == "package" &&
-      (owner.fullName.toString == "scala" || owner.fullName.toString == "scala.reflect")
+  def binaryOnly(owner: Symbol, name: TermName)(using Context): Boolean =
+    name == nme.PACKAGEkw &&
+      (owner == defn.ScalaPackageClass || owner == defn.ReflectPackageClass)
 
   /** Initialize toplevel class and module symbols in `owner` from class path representation `classRep`
    */
   def initializeFromClassPath(owner: Symbol, classRep: ClassRepresentation)(using Context): Unit =
     ((classRep.binary, classRep.source): @unchecked) match {
-      case (Some(bin), Some(src)) if needCompile(bin, src) && !binaryOnly(owner, classRep.name) =>
+      case (Some(bin), Some(src)) if needCompile(bin, src) && !binaryOnly(owner, nameOf(classRep)) =>
         if (ctx.settings.verbose.value) report.inform("[symloader] picked up newer source file for " + src.path)
-        enterToplevelsFromSource(owner, classRep.name, src)
+        enterToplevelsFromSource(owner, nameOf(classRep), src)
       case (None, Some(src)) =>
         if (ctx.settings.verbose.value) report.inform("[symloader] no class, picked up source file for " + src.path)
-        enterToplevelsFromSource(owner, classRep.name, src)
+        enterToplevelsFromSource(owner, nameOf(classRep), src)
       case (Some(bin), _) =>
-        enterClassAndModule(owner, classRep.name, ctx.platform.newClassLoader(bin))
+        enterClassAndModule(owner, nameOf(classRep), ctx.platform.newClassLoader(bin))
     }
 
   def needCompile(bin: AbstractFile, src: AbstractFile): Boolean =
     src.lastModified >= bin.lastModified
 
+  private def nameOf(classRep: ClassRepresentation): TermName = {
+    while(true) {
+      val len = classRep.nameChars(nameCharBuffer)
+      if (len == -1) nameCharBuffer = new Array[Char](nameCharBuffer.length * 2)
+      else return termName(nameCharBuffer, 0, len)
+    }
+    throw new IllegalStateException()
+  }
+  private var nameCharBuffer = new Array[Char](256)
+
   /** Load contents of a package
    */
   class PackageLoader(_sourceModule: TermSymbol, classPath: ClassPath)

compiler/src/dotty/tools/dotc/transform/PostTyper.scala

@@ -151,7 +151,7 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
             if !sym.owner.unforcedDecls.exists(p => !p.isScala2Macro && p.name == sym.name && p.signature == sym.signature)
                // Allow scala.reflect.materializeClassTag to be able to compile scala/reflect/package.scala
                // This should be removed on Scala 3.1
-               && sym.owner != defn.ReflectPackageClass
+               && sym.owner != defn.ReflectPackageModuleClass
             then
               report.error("No Scala 3 implementation found for this Scala 2 macro.", tree.srcPos)
         case _ =>

compiler/src/dotty/tools/io/ClassPath.scala

@@ -170,9 +170,22 @@ object ClassPath {
 }
 
 trait ClassRepresentation {
+  def fileName: String
   def name: String
   def binary: Option[AbstractFile]
   def source: Option[AbstractFile]
+
+  /** Low level way to extract the entry name without allocation. */
+  final def nameChars(buffer: Array[Char]): Int = {
+    val ix = fileName.lastIndexOf('.')
+    val nameLength = if (ix < 0) fileName.length else ix
+    if (nameLength > buffer.length)
+      -1
+    else {
+      fileName.getChars(0, nameLength, buffer, 0)
+      nameLength
+    }
+  }
 }
 
 @deprecated("shim for sbt's compiler interface", since = "2.12.0")