Mark some more lazy vals as @ThreadUnsafe

Author: smarter

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/dotc/core/Types.scala

@@ -35,6 +35,7 @@ import reporting.trace
 import java.lang.ref.WeakReference
 
 import scala.annotation.internal.sharable
+import scala.annotation.threadUnsafe
 
 object Types {
 
@@ -3324,7 +3325,7 @@ object Types {
 
     def newParamRef(n: Int): TypeParamRef = new TypeParamRefImpl(this, n)
 
-    lazy val typeParams: List[LambdaParam] =
+    @threadUnsafe lazy val typeParams: List[LambdaParam] =
       paramNames.indices.toList.map(new LambdaParam(this, _))
 
     def derivedLambdaAbstraction(paramNames: List[TypeName], paramInfos: List[TypeBounds], resType: Type)(implicit ctx: Context): Type =

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

@@ -31,7 +31,7 @@ import reporting.trace
 import Constants.{Constant, IntTag, LongTag}
 import dotty.tools.dotc.reporting.diagnostic.messages.{UnapplyInvalidReturnType, NotAnExtractor, UnapplyInvalidNumberOfArguments}
 import Denotations.SingleDenotation
-import annotation.constructorOnly
+import annotation.{constructorOnly, threadUnsafe}
 
 object Applications {
   import tpd._
@@ -310,13 +310,13 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
     /** The function's type after widening and instantiating polytypes
      *  with TypeParamRefs in constraint set
      */
-    lazy val methType: Type = liftedFunType.widen match {
+    @threadUnsafe lazy val methType: Type = liftedFunType.widen match {
       case funType: MethodType => funType
       case funType: PolyType => constrained(funType).resultType
       case tp => tp //was: funType
     }
 
-    lazy val liftedFunType: Type =
+    @threadUnsafe lazy val liftedFunType: Type =
       if (needLiftFun) {
         liftFun()
         normalizedFun.tpe
@@ -326,7 +326,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
     /** The arguments re-ordered so that each named argument matches the
      *  same-named formal parameter.
      */
-    lazy val orderedArgs: List[Arg] =
+    @threadUnsafe lazy val orderedArgs: List[Arg] =
       if (hasNamedArg(args))
         reorder(args.asInstanceOf[List[untpd.Tree]]).asInstanceOf[List[Arg]]
       else
@@ -617,7 +617,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
     def fail(msg: => Message): Unit =
       ok = false
     def appPos: SourcePosition = NoSourcePosition
-    lazy val normalizedFun:   Tree = ref(methRef)
+    @threadUnsafe lazy val normalizedFun:   Tree = ref(methRef)
     init()
   }
 

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

@@ -36,6 +36,7 @@ import reporting.trace
 import annotation.tailrec
 
 import scala.annotation.internal.sharable
+import scala.annotation.threadUnsafe
 
 /** Implicit resolution */
 object Implicits {
@@ -228,14 +229,14 @@ object Implicits {
    */
   class OfTypeImplicits(tp: Type, val companionRefs: TermRefSet)(initctx: Context) extends ImplicitRefs(initctx) {
     assert(initctx.typer != null)
-    lazy val refs: List[ImplicitRef] = {
+    @threadUnsafe lazy val refs: List[ImplicitRef] = {
       val buf = new mutable.ListBuffer[TermRef]
       for (companion <- companionRefs) buf ++= companion.implicitMembers(ImplicitOrImpliedOrGiven)
       buf.toList
     }
 
     /** The candidates that are eligible for expected type `tp` */
-    lazy val eligible: List[Candidate] =
+    @threadUnsafe lazy val eligible: List[Candidate] =
       /*>|>*/ track("eligible in tpe") /*<|<*/ {
         /*>|>*/ trace(i"eligible($tp), companions = ${companionRefs.toList}%, %", implicitsDetailed, show = true) /*<|<*/ {
           if (refs.nonEmpty && monitored) record(s"check eligible refs in tpe", refs.length)
@@ -1113,7 +1114,7 @@ trait Implicits { self: Typer =>
     private def isCoherent = pt.isRef(defn.EqlClass)
 
     /** The expected type for the searched implicit */
-    lazy val fullProto: Type = implicitProto(pt, identity)
+    @threadUnsafe lazy val fullProto: Type = implicitProto(pt, identity)
 
     /** The expected type where parameters and uninstantiated typevars are replaced by wildcard types */
     val wildProto: Type = implicitProto(pt, wildApprox(_))