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/Contexts.scala

@@ -89,6 +89,16 @@ object Contexts {
   inline def withoutMode[T](mode: Mode)(inline op: Context ?=> T)(using ctx: Context): T =
     inMode(ctx.mode &~ mode)(op)
 
+  private[dotc] inline def withNameBuffer(inline op: Array[Char] => Int)(using ctx: Context): Names.TermName = {
+    val base = ctx.base
+    var len = op(base.nameCharBuffer)
+    while(len == -1) {
+      base.nameCharBuffer = new Array[Char](base.nameCharBuffer.length * 2)
+      len = op(base.nameCharBuffer)
+    }
+    Names.termName(base.nameCharBuffer, 0, len)
+  }
+
   /** A context is passed basically everywhere in dotc.
    *  This is convenient but carries the risk of captured contexts in
    *  objects that turn into space leaks. To combat this risk, here are some
@@ -894,6 +904,8 @@ object Contexts {
     private[Contexts] val comparers = new mutable.ArrayBuffer[TypeComparer]
     private[Contexts] var comparersInUse: Int = 0
 
+    private[dotc] var nameCharBuffer = new Array[Char](256)
+
     def reset(): Unit = {
       for ((_, set) <- uniqueSets) set.clear()
       errorTypeMsg.clear()

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

@@ -682,10 +682,10 @@ class Definitions {
   @tu lazy val NonLocalReturnControlClass: ClassSymbol = requiredClass("scala.runtime.NonLocalReturnControl")
   @tu lazy val SelectableClass: ClassSymbol = requiredClass("scala.Selectable")
 
+  @tu lazy val ReflectPackageClass: 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,29 @@ 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 config.Config
+import dotty.tools.backend.jvm.DottyBackendInterface.symExtensions
+
 import Contexts._, Symbols._, Flags._, SymDenotations._, Types._, Scopes._, Names._
 import NameOps._
-import StdNames.str
-import Decorators._
+import StdNames._
 import classfile.ClassfileParser
-import util.Stats
 import Decorators._
-import scala.util.control.NonFatal
+
+import util.Stats
+import reporting.trace
+import config.Config
+
 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 +183,30 @@ 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" &&
+  def binaryOnly(owner: Symbol, name: TermName)(using Context): Boolean =
+    name == nme.PACKAGEkw &&
       (owner.fullName.toString == "scala" || owner.fullName.toString == "scala.reflect")
 
   /** 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)(using Context): TermName =
+    withNameBuffer(classRep.nameChars)
+
   /** Load contents of a package
    */
   class PackageLoader(_sourceModule: TermSymbol, classPath: ClassPath)

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")