Eliminate remaining PerRun datastructures

Author: odersky

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

@@ -154,11 +154,11 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
   @threadUnsafe lazy val AnnotationRetentionRuntimeAttr: TermSymbol = ctx.requiredClass("java.lang.annotation.RetentionPolicy").linkedClass.requiredValue("RUNTIME")
   @threadUnsafe lazy val JavaAnnotationClass: ClassSymbol = ctx.requiredClass("java.lang.annotation.Annotation")
 
-  def boxMethods: Map[Symbol, Symbol] = defn.ScalaValueClasses().map{x => // @darkdimius Are you sure this should be a def?
+  def boxMethods: Map[Symbol, Symbol] = defn.ScalaValueClasses.map{x => // @darkdimius Are you sure this should be a def?
     (x, Erasure.Boxing.boxMethod(x.asClass))
   }.toMap
   def unboxMethods: Map[Symbol, Symbol] =
-    defn.ScalaValueClasses().map(x => (x, Erasure.Boxing.unboxMethod(x.asClass))).toMap
+    defn.ScalaValueClasses.map(x => (x, Erasure.Boxing.unboxMethod(x.asClass))).toMap
 
   override def isSyntheticArrayConstructor(s: Symbol): Boolean = {
     s eq defn.newArrayMethod

compiler/src/dotty/tools/backend/sjs/JSCodeGen.scala

@@ -2696,7 +2696,7 @@ class JSCodeGen()(implicit ctx: Context) {
 
   private object WrapArray {
     lazy val isWrapArray: Set[Symbol] = {
-      val names0 = defn.ScalaValueClasses().map(sym => nme.wrapXArray(sym.name))
+      val names0 = defn.ScalaValueClasses.map(sym => nme.wrapXArray(sym.name))
       val names1 = names0 ++ Set(nme.wrapRefArray, nme.genericWrapArray)
       val names2 = names1.map(defn.ScalaPredefModule.requiredMethod(_))
       names2.toSet

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

@@ -883,7 +883,7 @@ class Definitions {
   @threadUnsafe lazy val FunctionClass: Array[Symbol] =
     mkArityArray("scala.Function", MaxImplementedFunctionArity, 0).map(_.symbol.asClass)
 
-  val LazyHolder: PerRun[Map[Symbol, Symbol]] = new PerRun({ implicit ctx =>
+  @threadUnsafe lazy val LazyHolder: Map[Symbol, Symbol] = {
     def holderImpl(holderType: String) = ctx.requiredClass("scala.runtime." + holderType)
     Map[Symbol, Symbol](
       IntClass     -> holderImpl("LazyInt"),
@@ -896,7 +896,7 @@ class Definitions {
       ShortClass   -> holderImpl("LazyShort")
     )
     .withDefaultValue(holderImpl("LazyRef"))
-  })
+  }
 
   @threadUnsafe lazy val TupleType: Array[TypeRef] = mkArityArray("scala.Tuple", MaxTupleArity, 1)
 
@@ -1108,39 +1108,28 @@ class Definitions {
     isNonRefinedFunction(tp.dropDependentRefinement)
 
   // Specialized type parameters defined for scala.Function{0,1,2}.
-  @threadUnsafe lazy val Function1SpecializedParamTypes: collection.Set[TypeRef] =
-    Set(IntType, LongType, FloatType, DoubleType)
-  @threadUnsafe lazy val Function2SpecializedParamTypes: collection.Set[TypeRef] =
-    Set(IntType, LongType, DoubleType)
-  @threadUnsafe lazy val Function0SpecializedReturnTypes: collection.Set[TypeRef] =
-    ScalaNumericValueTypeList.toSet + UnitType + BooleanType
-  @threadUnsafe lazy val Function1SpecializedReturnTypes: collection.Set[TypeRef] =
-    Set(UnitType, BooleanType, IntType, FloatType, LongType, DoubleType)
-  @threadUnsafe lazy val Function2SpecializedReturnTypes: collection.Set[TypeRef] =
-    Function1SpecializedReturnTypes
-
-  @threadUnsafe lazy val Function1SpecializedParamClasses: PerRun[collection.Set[Symbol]] =
-    new PerRun(implicit ctx => Function1SpecializedParamTypes.map(_.symbol))
-  @threadUnsafe lazy val Function2SpecializedParamClasses: PerRun[collection.Set[Symbol]] =
-    new PerRun(implicit ctx => Function2SpecializedParamTypes.map(_.symbol))
-  @threadUnsafe lazy val Function0SpecializedReturnClasses: PerRun[collection.Set[Symbol]] =
-    new PerRun(implicit ctx => Function0SpecializedReturnTypes.map(_.symbol))
-  @threadUnsafe lazy val Function1SpecializedReturnClasses: PerRun[collection.Set[Symbol]] =
-    new PerRun(implicit ctx => Function1SpecializedReturnTypes.map(_.symbol))
-  @threadUnsafe lazy val Function2SpecializedReturnClasses: PerRun[collection.Set[Symbol]] =
-    new PerRun(implicit ctx => Function2SpecializedReturnTypes.map(_.symbol))
+  @threadUnsafe lazy val Function1SpecializedParamClasses: collection.Set[Symbol] =
+    Set(IntType, LongType, FloatType, DoubleType).map(_.symbol)
+  @threadUnsafe lazy val Function2SpecializedParamClasses: collection.Set[Symbol] =
+    Set(IntType, LongType, DoubleType).map(_.symbol)
+  @threadUnsafe lazy val Function0SpecializedReturnClasses: collection.Set[Symbol] =
+    (ScalaNumericValueTypeList.toSet + UnitType + BooleanType).map(_.symbol)
+  @threadUnsafe lazy val Function1SpecializedReturnClasses: collection.Set[Symbol] =
+    Set(UnitType, BooleanType, IntType, FloatType, LongType, DoubleType).map(_.symbol)
+  @threadUnsafe lazy val Function2SpecializedReturnClasses: collection.Set[Symbol] =
+    Function1SpecializedReturnClasses
 
   def isSpecializableFunction(cls: ClassSymbol, paramTypes: List[Type], retType: Type)(implicit ctx: Context): Boolean =
     paramTypes.length <= 2 && cls.derivesFrom(FunctionClass(paramTypes.length)) && (paramTypes match {
       case Nil =>
-        Function0SpecializedReturnClasses().contains(retType.typeSymbol)
+        Function0SpecializedReturnClasses.contains(retType.typeSymbol)
       case List(paramType0) =>
-        Function1SpecializedParamClasses().contains(paramType0.typeSymbol) &&
-        Function1SpecializedReturnClasses().contains(retType.typeSymbol)
+        Function1SpecializedParamClasses.contains(paramType0.typeSymbol) &&
+        Function1SpecializedReturnClasses.contains(retType.typeSymbol)
       case List(paramType0, paramType1) =>
-        Function2SpecializedParamClasses().contains(paramType0.typeSymbol) &&
-        Function2SpecializedParamClasses().contains(paramType1.typeSymbol) &&
-        Function2SpecializedReturnClasses().contains(retType.typeSymbol)
+        Function2SpecializedParamClasses.contains(paramType0.typeSymbol) &&
+        Function2SpecializedParamClasses.contains(paramType1.typeSymbol) &&
+        Function2SpecializedReturnClasses.contains(retType.typeSymbol)
       case _ =>
         false
     })
@@ -1188,31 +1177,17 @@ class Definitions {
 
   // ----- primitive value class machinery ------------------------------------------
 
-  /** This class would also be obviated by the implicit function type design */
-  class PerRun[T](generate: Context => T) {
-    private[this] var current: RunId = NoRunId
-    private[this] var cached: T = _
-    def apply()(implicit ctx: Context): T = {
-      if (current != ctx.runId) {
-        cached = generate(ctx)
-        current = ctx.runId
-      }
-      cached
-    }
-  }
-
   @threadUnsafe lazy val ScalaNumericValueTypeList: List[TypeRef] = List(
     ByteType, ShortType, CharType, IntType, LongType, FloatType, DoubleType)
 
   @threadUnsafe private lazy val ScalaNumericValueTypes: collection.Set[TypeRef] = ScalaNumericValueTypeList.toSet
   @threadUnsafe private lazy val ScalaValueTypes: collection.Set[TypeRef] = ScalaNumericValueTypes + UnitType + BooleanType
 
-  val ScalaNumericValueClasses: PerRun[collection.Set[Symbol]] = new PerRun(implicit ctx => ScalaNumericValueTypes.map(_.symbol))
-  val ScalaValueClasses: PerRun[collection.Set[Symbol]]        = new PerRun(implicit ctx => ScalaValueTypes.map(_.symbol))
+  @threadUnsafe lazy val ScalaNumericValueClasses: collection.Set[Symbol] = ScalaNumericValueTypes.map(_.symbol)
+  @threadUnsafe lazy val ScalaValueClasses: collection.Set[Symbol]        = ScalaValueTypes.map(_.symbol)
 
-  val ScalaBoxedClasses: PerRun[collection.Set[Symbol]] = new PerRun(implicit ctx =>
+  @threadUnsafe lazy val ScalaBoxedClasses: collection.Set[Symbol] =
     Set(BoxedByteClass, BoxedShortClass, BoxedCharClass, BoxedIntClass, BoxedLongClass, BoxedFloatClass, BoxedDoubleClass, BoxedUnitClass, BoxedBooleanClass)
-  )
 
   private val valueTypeEnc = mutable.Map[TypeName, PrimitiveClassEnc]()
   private val typeTags = mutable.Map[TypeName, Name]().withDefaultValue(nme.specializedTypeNames.Object)
@@ -1314,7 +1289,7 @@ class Definitions {
         ScalaPackageClass.enter(m)
 
       // force initialization of every symbol that is synthesized or hijacked by the compiler
-      val forced = syntheticCoreClasses ++ syntheticCoreMethods ++ ScalaValueClasses() :+ JavaEnumClass
+      val forced = syntheticCoreClasses ++ syntheticCoreMethods ++ ScalaValueClasses :+ JavaEnumClass
 
       isInitialized = true
     }

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

@@ -600,11 +600,11 @@ object SymDenotations {
 
     /** Is symbol a primitive value class? */
     def isPrimitiveValueClass(implicit ctx: Context): Boolean =
-      maybeOwner == defn.ScalaPackageClass && defn.ScalaValueClasses().contains(symbol)
+      maybeOwner == defn.ScalaPackageClass && defn.ScalaValueClasses.contains(symbol)
 
     /** Is symbol a primitive numeric value class? */
     def isNumericValueClass(implicit ctx: Context): Boolean =
-      maybeOwner == defn.ScalaPackageClass && defn.ScalaNumericValueClasses().contains(symbol)
+      maybeOwner == defn.ScalaPackageClass && defn.ScalaNumericValueClasses.contains(symbol)
 
     /** Is symbol a class for which no runtime representation exists? */
     def isNotRuntimeClass(implicit ctx: Context): Boolean = defn.NotRuntimeClasses contains symbol

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

@@ -51,7 +51,7 @@ class ArrayApply extends MiniPhase {
         case _: Literal => true // ClassTag.apply(classOf[XYZ])
         case rc: RefTree if rc.name == nme.TYPE_ =>
           // ClassTag.apply(java.lang.XYZ.Type)
-          defn.ScalaBoxedClasses().contains(rc.symbol.maybeOwner.companionClass)
+          defn.ScalaBoxedClasses.contains(rc.symbol.maybeOwner.companionClass)
         case _ => false
       }
     case Apply(ctm: RefTree, _) if ctm.symbol.maybeOwner.companionModule == defn.ClassTagModule =>

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

@@ -32,7 +32,7 @@ class CapturedVars extends MiniPhase with IdentityDenotTransformer { thisPhase =
   private class RefInfo(implicit ctx: Context) {
     /** The classes for which a Ref type exists. */
     val refClassKeys: collection.Set[Symbol] =
-      defn.ScalaNumericValueClasses() + defn.BooleanClass + defn.ObjectClass
+      defn.ScalaNumericValueClasses + defn.BooleanClass + defn.ObjectClass
 
     val refClass: Map[Symbol, Symbol] =
       refClassKeys.map(rc => rc -> ctx.requiredClass(s"scala.runtime.${rc.name}Ref")).toMap

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

@@ -176,7 +176,7 @@ object Erasure {
      */
     private def safelyRemovableUnboxArg(tree: Tree)(implicit ctx: Context): Tree = tree match {
       case Apply(fn, arg :: Nil)
-      if isUnbox(fn.symbol) && defn.ScalaBoxedClasses().contains(arg.tpe.widen.typeSymbol) =>
+      if isUnbox(fn.symbol) && defn.ScalaBoxedClasses.contains(arg.tpe.widen.typeSymbol) =>
         arg
       case _ =>
         EmptyTree

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

@@ -91,7 +91,7 @@ class InterceptedMethods extends MiniPhase {
               List(qual, typer.resolveClassTag(tree.pos, qual.tpe.widen))))
           }*/
          */
-      case t if t.name == nme.getClass_ && defn.ScalaValueClasses().contains(t.owner) =>
+      case t if t.name == nme.getClass_ && defn.ScalaValueClasses.contains(t.owner) =>
           // if we got here then we're trying to send a primitive getClass method to either
           // a) an Any, in which cage Object_getClass works because Any erases to object. Or
           //

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

@@ -146,7 +146,7 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
 
     // val x$lzy = new scala.runtime.LazyInt()
     val holderName = LazyLocalName.fresh(xname)
-    val holderImpl = defn.LazyHolder()(ctx)(tpe.typeSymbol)
+    val holderImpl = defn.LazyHolder(tpe.typeSymbol)
     val holderSymbol = ctx.newSymbol(x.symbol.owner, holderName, containerFlags, holderImpl.typeRef, coord = x.span)
     val holderTree = ValDef(holderSymbol, New(holderImpl.typeRef, Nil))