Drop per run on wrappedArrays and function classes

Author: odersky

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

@@ -141,8 +141,8 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
   val externalEqualsNumObject: Symbol = defn.BoxesRunTimeModule.requiredMethod(nme.equalsNumObject)
   val externalEquals: Symbol = defn.BoxesRunTimeModule.info.decl(nme.equals_).suchThat(toDenot(_).info.firstParamTypes.size == 2).symbol
   val MaxFunctionArity: Int = Definitions.MaxImplementedFunctionArity
-  val FunctionClass: Array[Symbol] = defn.FunctionClassPerRun()
-  val AbstractFunctionClass: Array[Symbol] = defn.AbstractFunctionClassPerRun()
+  val FunctionClass: Array[Symbol] = defn.FunctionClass
+  val AbstractFunctionClass: Array[Symbol] = defn.AbstractFunctionClass
   val PartialFunctionClass: Symbol = defn.PartialFunctionClass
   val AbstractPartialFunctionClass: Symbol = defn.AbstractPartialFunctionClass
   val String_valueOf: Symbol = defn.String_valueOf_Object

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

@@ -399,10 +399,10 @@ class Definitions {
   def getWrapVarargsArrayModule: Symbol = if (isNewCollections) ScalaRuntimeModule else ScalaPredefModule
 
   // The set of all wrap{X, Ref}Array methods, where X is a value type
-  val WrapArrayMethods: PerRun[collection.Set[Symbol]] = new PerRun({ implicit ctx =>
+  @threadUnsafe lazy val WrapArrayMethods: collection.Set[Symbol] = {
     val methodNames = ScalaValueTypes.map(ast.tpd.wrapArrayMethodName) + nme.wrapRefArray
     methodNames.map(getWrapVarargsArrayModule.requiredMethod(_))
-  })
+  }
 
   @threadUnsafe lazy val NilModule: Symbol = ctx.requiredModule("scala.collection.immutable.Nil")
 
@@ -878,11 +878,10 @@ class Definitions {
 
   // ----- Symbol sets ---------------------------------------------------
 
-  @threadUnsafe lazy val AbstractFunctionType: Array[TypeRef] = mkArityArray("scala.runtime.AbstractFunction", MaxImplementedFunctionArity, 0)
-  val AbstractFunctionClassPerRun: PerRun[Array[Symbol]] = new PerRun(implicit ctx => AbstractFunctionType.map(_.symbol.asClass))
-  def AbstractFunctionClass(n: Int)(implicit ctx: Context): Symbol = AbstractFunctionClassPerRun()(ctx)(n)
-  @threadUnsafe private lazy val ImplementedFunctionType = mkArityArray("scala.Function", MaxImplementedFunctionArity, 0)
-  def FunctionClassPerRun: PerRun[Array[Symbol]] = new PerRun(implicit ctx => ImplementedFunctionType.map(_.symbol.asClass))
+  @threadUnsafe lazy val AbstractFunctionClass: Array[Symbol] =
+    mkArityArray("scala.runtime.AbstractFunction", MaxImplementedFunctionArity, 0).map(_.symbol.asClass)
+  @threadUnsafe lazy val FunctionClass: Array[Symbol] =
+    mkArityArray("scala.Function", MaxImplementedFunctionArity, 0).map(_.symbol.asClass)
 
   val LazyHolder: PerRun[Map[Symbol, Symbol]] = new PerRun({ implicit ctx =>
     def holderImpl(holderType: String) = ctx.requiredClass("scala.runtime." + holderType)
@@ -909,15 +908,15 @@ class Definitions {
     else if (isErased)
       ctx.requiredClass("scala.ErasedFunction" + n.toString)
     else if (n <= MaxImplementedFunctionArity)
-      FunctionClassPerRun()(ctx)(n)
+      FunctionClass(n)
     else
       ctx.requiredClass("scala.Function" + n.toString)
 
-    @threadUnsafe lazy val Function0_apply: Symbol = ImplementedFunctionType(0).symbol.requiredMethod(nme.apply)
+    @threadUnsafe lazy val Function0_apply: Symbol = FunctionClass(0).requiredMethod(nme.apply)
 
   def FunctionType(n: Int, isContextual: Boolean = false, isErased: Boolean = false)(implicit ctx: Context): TypeRef =
-    if (n <= MaxImplementedFunctionArity && (!isContextual || ctx.erasedTypes) && !isErased) ImplementedFunctionType(n)
-    else FunctionClass(n, isContextual, isErased).typeRef
+    if (n <= MaxImplementedFunctionArity && (!isContextual || ctx.erasedTypes) && !isErased) FunctionClass(n).typeRef
+    else FunctionClass(n, isContextual, isErased).typeRef // !!!align with FunctionClass?
 
   lazy val PolyFunctionClass = ctx.requiredClass("scala.PolyFunction")
   def PolyFunctionType = PolyFunctionClass.typeRef

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

@@ -26,11 +26,11 @@ class ArrayApply extends MiniPhase {
     if (tree.symbol.name == nme.apply && tree.symbol.owner == defn.ArrayModule.moduleClass) { // Is `Array.apply`
       tree.args match {
         case StripAscription(Apply(wrapRefArrayMeth, (seqLit: tpd.JavaSeqLiteral) :: Nil)) :: ct :: Nil
-            if defn.WrapArrayMethods().contains(wrapRefArrayMeth.symbol) && elideClassTag(ct) =>
+            if defn.WrapArrayMethods.contains(wrapRefArrayMeth.symbol) && elideClassTag(ct) =>
           seqLit
 
         case elem0 :: StripAscription(Apply(wrapRefArrayMeth, (seqLit: tpd.JavaSeqLiteral) :: Nil)) :: Nil
-            if defn.WrapArrayMethods().contains(wrapRefArrayMeth.symbol) =>
+            if defn.WrapArrayMethods.contains(wrapRefArrayMeth.symbol) =>
           tpd.JavaSeqLiteral(elem0 :: seqLit.elems, seqLit.elemtpt)
 
         case _ =>

compiler/src/dotty/tools/dotc/typer/Checking.scala

@@ -822,7 +822,7 @@ trait Checking {
             checkInlineConformant(expr, isFinal, what)
           case SeqLiteral(elems, _) =>
             elems.foreach(elem => checkInlineConformant(elem, isFinal, what))
-          case Apply(fn, List(arg)) if defn.WrapArrayMethods().contains(fn.symbol) =>
+          case Apply(fn, List(arg)) if defn.WrapArrayMethods.contains(fn.symbol) =>
             checkInlineConformant(arg, isFinal, what)
           case _ =>
             def isCaseClassApply(sym: Symbol): Boolean =