Make lazy vals thread-safe by default

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

@@ -3,6 +3,7 @@ package backend
 package jvm
 
 import scala.tools.asm
+import scala.annotation.threadUnsafe
 
 /**
  * This class mainly contains the method classBTypeFromSymbol, which extracts the necessary
@@ -30,14 +31,14 @@ class BTypesFromSymbols[I <: BackendInterface](val int: I) extends BTypes {
     coreBTypes.setBTypes(new CoreBTypes[this.type](this))
   }
 
-  protected lazy val classBTypeFromInternalNameMap = {
+  @threadUnsafe protected lazy val classBTypeFromInternalNameMap = {
     perRunCaches.recordCache(collection.concurrent.TrieMap.empty[String, ClassBType])
   }
 
   /**
    * Cache for the method classBTypeFromSymbol.
    */
-  private lazy val convertedClasses = perRunCaches.newMap[Symbol, ClassBType]()
+  @threadUnsafe private lazy val convertedClasses = perRunCaches.newMap[Symbol, ClassBType]()
 
   /**
    * The ClassBType for a class symbol `sym`.

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

@@ -8,7 +8,6 @@ import dotty.tools.io.AbstractFile
 import scala.language.implicitConversions
 import scala.tools.asm
 
-
 /* Interface to abstract over frontend inside backend.
  * Intended to be implemented by both scalac and dotc
  */

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

@@ -8,6 +8,7 @@ import dotty.tools.dotc.transform.{Erasure, GenericSignatures}
 import dotty.tools.dotc.transform.SymUtils._
 import java.io.{File => _}
 
+import scala.annotation.threadUnsafe
 import scala.collection.generic.Clearable
 import scala.collection.mutable
 import scala.reflect.ClassTag
@@ -104,8 +105,8 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
   val nme_EQEQ_LOCAL_VAR: Name = StdNames.nme.EQEQ_LOCAL_VAR
 
    // require LambdaMetafactory: scalac uses getClassIfDefined, but we need those always.
-  override lazy val LambdaMetaFactory: ClassSymbol = ctx.requiredClass("java.lang.invoke.LambdaMetafactory")
-  override lazy val MethodHandle: ClassSymbol      = ctx.requiredClass("java.lang.invoke.MethodHandle")
+  @threadUnsafe override lazy val LambdaMetaFactory: ClassSymbol = ctx.requiredClass("java.lang.invoke.LambdaMetafactory")
+  @threadUnsafe override lazy val MethodHandle: ClassSymbol      = ctx.requiredClass("java.lang.invoke.MethodHandle")
 
   val nme_valueOf: Name = StdNames.nme.valueOf
   val nme_apply: TermName = StdNames.nme.apply
@@ -145,13 +146,13 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
   val PartialFunctionClass: Symbol = defn.PartialFunctionClass
   val AbstractPartialFunctionClass: Symbol = defn.AbstractPartialFunctionClass
   val String_valueOf: Symbol = defn.String_valueOf_Object
-  lazy val Predef_classOf: Symbol = defn.ScalaPredefModule.requiredMethod(nme.classOf)
+  @threadUnsafe lazy val Predef_classOf: Symbol = defn.ScalaPredefModule.requiredMethod(nme.classOf)
 
-  lazy val AnnotationRetentionAttr: ClassSymbol = ctx.requiredClass("java.lang.annotation.Retention")
-  lazy val AnnotationRetentionSourceAttr: TermSymbol = ctx.requiredClass("java.lang.annotation.RetentionPolicy").linkedClass.requiredValue("SOURCE")
-  lazy val AnnotationRetentionClassAttr: TermSymbol = ctx.requiredClass("java.lang.annotation.RetentionPolicy").linkedClass.requiredValue("CLASS")
-  lazy val AnnotationRetentionRuntimeAttr: TermSymbol = ctx.requiredClass("java.lang.annotation.RetentionPolicy").linkedClass.requiredValue("RUNTIME")
-  lazy val JavaAnnotationClass: ClassSymbol = ctx.requiredClass("java.lang.annotation.Annotation")
+  @threadUnsafe lazy val AnnotationRetentionAttr: ClassSymbol = ctx.requiredClass("java.lang.annotation.Retention")
+  @threadUnsafe lazy val AnnotationRetentionSourceAttr: TermSymbol = ctx.requiredClass("java.lang.annotation.RetentionPolicy").linkedClass.requiredValue("SOURCE")
+  @threadUnsafe lazy val AnnotationRetentionClassAttr: TermSymbol = ctx.requiredClass("java.lang.annotation.RetentionPolicy").linkedClass.requiredValue("CLASS")
+  @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?
     (x, Erasure.Boxing.boxMethod(x.asClass))

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

@@ -14,6 +14,7 @@ import Names.TermName, StdNames._
 import Types.{JavaArrayType, UnspecifiedErrorType, Type}
 import Symbols.{Symbol, NoSymbol}
 
+import scala.annotation.threadUnsafe
 import scala.collection.immutable
 
 
@@ -37,7 +38,7 @@ import scala.collection.immutable
 class DottyPrimitives(ctx: Context) {
   import dotty.tools.backend.ScalaPrimitivesOps._
 
-  private lazy val primitives: immutable.Map[Symbol, Int] = init
+  @threadUnsafe private lazy val primitives: immutable.Map[Symbol, Int] = init
 
   /** Return the code for the given symbol. */
   def getPrimitive(sym: Symbol): Int = {