Merge pull request #5748 from dotty-staging/try-optimize-1

Reduce some allocations

Author: odersky

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

@@ -477,7 +477,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
     // unrelated change.
        ctx.base.settings.YnoGenericSig.value
     || sym.is(Flags.Artifact)
-    || sym.is(Flags.allOf(Flags.Method, Flags.Lifted))
+    || sym.is(Flags.LiftedMethod)
     || sym.is(Flags.Bridge)
   )
 

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

@@ -97,6 +97,7 @@ class Compiler {
     List(new Constructors,           // Collect initialization code in primary constructors
                                         // Note: constructors changes decls in transformTemplate, no InfoTransformers should be added after it
          new FunctionalInterfaces,   // Rewrites closures to implement @specialized types of Functions.
+         new Instrumentation,     // Count closure allocations under -Yinstrument-closures
          new GetClass) ::            // Rewrites getClass calls on primitive types.
     List(new LinkScala2Impls,        // Redirect calls to trait methods defined by Scala 2.x, so that they now go to their implementations
          new LambdaLift,             // Lifts out nested functions to class scope, storing free variables in environments

compiler/src/dotty/tools/dotc/ast/Positioned.scala

@@ -51,8 +51,12 @@ abstract class Positioned(implicit @constructorOnly src: SourceFile) extends Pro
     else {
       val newpd: this.type =
         if (mySpan.isSynthetic) {
-          if (!mySpan.exists && span.exists)
+          if (!mySpan.exists && span.exists) {
             envelope(source, span.startPos) // fill in children spans
+            () // Note: the `()` is there to prevent some inefficient code from being generated.
+               // Without it we get an allocation of a span here since the result type of the `if`
+               // is `Any`, the lub of `Span` and `Unit`.
+          }
           this
         }
         else cloneIn(source)

compiler/src/dotty/tools/dotc/ast/tpd.scala

@@ -978,7 +978,10 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   }
 
   implicit class ListOfTreeDecorator(val xs: List[tpd.Tree]) extends AnyVal {
-    def tpes: List[Type] = xs map (_.tpe)
+    def tpes: List[Type] = xs match {
+      case x :: xs1 => x.tpe :: xs1.tpes
+      case nil => Nil
+    }
   }
 
   /** A trait for loaders that compute trees. Currently implemented just by DottyUnpickler. */

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

@@ -149,6 +149,9 @@ class ScalaSettings extends Settings.SettingGroup {
 
   val YnoDecodeStacktraces: Setting[Boolean] = BooleanSetting("-Yno-decode-stacktraces", "Show raw StackOverflow stacktraces, instead of decoding them into triggering operations.")
 
+  val YinstrumentClosures: Setting[Boolean] = BooleanSetting("-Yinstrument-closures", "Add instrumentation code that counts closure creations.")
+  val YinstrumentAllocations: Setting[Boolean] = BooleanSetting("-Yinstrument-allocations", "Add instrumentation code that counts allocations.")
+
   /** Dottydoc specific settings */
   val siteRoot: Setting[String] = StringSetting(
     "-siteroot",

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

@@ -151,18 +151,21 @@ object Decorators {
    *  exact meaning of "contains" here.
    */
   implicit class PhaseListDecorator(val names: List[String]) extends AnyVal {
-    def containsPhase(phase: Phase): Boolean = phase match {
-      case phase: MegaPhase => phase.miniPhases.exists(containsPhase)
-      case _ =>
-        names exists { name =>
-          name == "all" || {
-            val strippedName = name.stripSuffix("+")
-            val logNextPhase = name != strippedName
-            phase.phaseName.startsWith(strippedName) ||
-              (logNextPhase && phase.prev.phaseName.startsWith(strippedName))
-          }
+    def containsPhase(phase: Phase): Boolean =
+      names.nonEmpty && {
+        phase match {
+          case phase: MegaPhase => phase.miniPhases.exists(containsPhase)
+          case _ =>
+            names exists { name =>
+              name == "all" || {
+                val strippedName = name.stripSuffix("+")
+                val logNextPhase = name != strippedName
+                phase.phaseName.startsWith(strippedName) ||
+                  (logNextPhase && phase.prev.phaseName.startsWith(strippedName))
+              }
+            }
         }
-    }
+      }
   }
 
   implicit class genericDeco[T](val x: T) extends AnyVal {

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

@@ -732,6 +732,9 @@ class Definitions {
   lazy val ValueOfType: TypeRef = ctx.requiredClassRef("scala.ValueOf")
   def ValueOfClass(implicit ctx: Context): ClassSymbol = ValueOfType.symbol.asClass
 
+  lazy val StatsModule = ctx.requiredModule("dotty.tools.dotc.util.Stats")
+    def Stats_doRecord(implicit ctx: Context): TermSymbol = StatsModule.requiredMethod("doRecord")
+
   lazy val XMLTopScopeModuleRef: TermRef = ctx.requiredModuleRef("scala.xml.TopScope")
 
   lazy val TupleTypeRef: TypeRef = ctx.requiredClassRef("scala.Tuple")

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

@@ -701,6 +701,8 @@ object Flags {
   /** Labeled protected[this] */
   final val ProtectedLocal: FlagConjunction = allOf(Protected, Local)
 
+  final val LiftedMethod: FlagConjunction = allOf(Lifted, Method)
+
   /** Java symbol which is `protected` and `static` */
   final val StaticProtected: FlagConjunction = allOf(JavaDefined, Protected, JavaStatic)
 

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

@@ -12,6 +12,9 @@ case class Mode(val bits: Int) extends AnyVal {
 
   override def toString: String =
     (0 until 31).filter(i => (bits & (1 << i)) != 0).map(modeName).mkString("Mode(", ",", ")")
+
+  def ==(that: Mode): Boolean = this.bits == that.bits
+  def !=(that: Mode): Boolean = this.bits != that.bits
 }
 
 object Mode {

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

@@ -570,7 +570,7 @@ object Names {
    */
   def termName(cs: Array[Char], offset: Int, len: Int): SimpleName = synchronized {
     util.Stats.record("termName")
-    val h = hashValue(cs, offset, len) & (table.size - 1)
+    val h = hashValue(cs, offset, len) & (table.length - 1)
 
     /** Make sure the capacity of the character array is at least `n` */
     def ensureCapacity(n: Int) =