Making Definitions thread-safe by replacing a bunch of vars with lazy vals.

1 files changed, 53 insertions, 58 deletions

diff --git a/src/compiler/scala/reflect/internal/Definitions.scala b/src/compiler/scala/reflect/internal/Definitions.scala
index a733f0d1ee..1386bce59a 100644
--- a/src/compiler/scala/reflect/internal/Definitions.scala
+++ b/src/compiler/scala/reflect/internal/Definitions.scala
@@ -609,7 +609,7 @@ trait Definitions extends reflect.api.StandardDefinitions {
     lazy val ValueTypeClass: Symbol = getClass(sn.ValueType)
     // System.MulticastDelegate
     lazy val DelegateClass: Symbol = getClass(sn.Delegate)
-    var Delegate_scalaCallers: List[Symbol] = List()
+    var Delegate_scalaCallers: List[Symbol] = List() // Syncnote: No protection necessary yet as only for .NET where reflection is not supported.
     // Symbol -> (Symbol, Type): scalaCaller -> (scalaMethodSym, DelegateType)
     // var Delegate_scalaCallerInfos: HashMap[Symbol, (Symbol, Type)] = _
     lazy val Delegate_scalaCallerTargets: mutable.HashMap[Symbol, Symbol] = mutable.HashMap()
@@ -629,31 +629,47 @@ trait Definitions extends reflect.api.StandardDefinitions {
         case _ => false
       })
     }
-
+    
     // members of class scala.Any
-    var Any_==          : Symbol = _
-    var Any_!=          : Symbol = _
-    var Any_equals      : Symbol = _
-    var Any_hashCode    : Symbol = _
-    var Any_toString    : Symbol = _
-    var Any_getClass    : Symbol = _
-    var Any_isInstanceOf: Symbol = _
-    var Any_asInstanceOf: Symbol = _
-    var Any_##          : Symbol = _
-
-    // members of class java.lang.{Object, String}
-    var Object_eq          : Symbol = _
-    var Object_ne          : Symbol = _
-    var Object_==          : Symbol = _
-    var Object_!=          : Symbol = _
-    var Object_##          : Symbol = _
-    var Object_synchronized: Symbol = _
+    lazy val Any_== = newMethod(AnyClass, nme.EQ, anyparam, booltype, FINAL)
+    lazy val Any_!= = newMethod(AnyClass, nme.NE, anyparam, booltype, FINAL)
+    lazy val Any_equals   = newMethod(AnyClass, nme.equals_, anyparam, booltype)
+    lazy val Any_hashCode = newMethod(AnyClass, nme.hashCode_, Nil, inttype)
+    lazy val Any_toString = newMethod(AnyClass, nme.toString_, Nil, stringtype)
+    lazy val Any_##       = newMethod(AnyClass, nme.HASHHASH, Nil, inttype, FINAL)
+
+    // Any_getClass requires special handling.  The return type is determined on
+    // a per-call-site basis as if the function being called were actually:
+    //
+    //    // Assuming `target.getClass()`
+    //    def getClass[T](target: T): Class[_ <: T]
+    //
+    // Since getClass is not actually a polymorphic method, this requires compiler
+    // participation.  At the "Any" level, the return type is Class[_] as it is in
+    // java.lang.Object.  Java also special cases the return type.
+    lazy val Any_getClass =
+      newMethod(AnyClass, nme.getClass_, Nil, getMember(ObjectClass, nme.getClass_).tpe.resultType, DEFERRED)
+    lazy val Any_isInstanceOf = newPolyMethod(
+       AnyClass, nme.isInstanceOf_, tparam => NullaryMethodType(booltype)) setFlag FINAL
+    lazy val Any_asInstanceOf = newPolyMethod(
+      AnyClass, nme.asInstanceOf_, tparam => NullaryMethodType(tparam.typeConstructor)) setFlag FINAL
+
+    // members of class java.lang.{ Object, String }
+    lazy val Object_## = newMethod(ObjectClass, nme.HASHHASH, Nil, inttype, FINAL)
+    lazy val Object_== = newMethod(ObjectClass, nme.EQ, anyrefparam, booltype, FINAL)
+    lazy val Object_!= = newMethod(ObjectClass, nme.NE, anyrefparam, booltype, FINAL)
+    lazy val Object_eq = newMethod(ObjectClass, nme.eq, anyrefparam, booltype, FINAL)
+    lazy val Object_ne = newMethod(ObjectClass, nme.ne, anyrefparam, booltype, FINAL)
+    lazy val Object_synchronized = newPolyMethodCon(
+      ObjectClass, nme.synchronized_,
+      tparam => msym => MethodType(msym.newSyntheticValueParams(List(tparam.typeConstructor)), tparam.typeConstructor)) setFlag FINAL
     lazy val Object_isInstanceOf = newPolyMethod(
       ObjectClass, newTermName("$isInstanceOf"),
       tparam => MethodType(List(), booltype)) setFlag (FINAL | SYNTHETIC)
     lazy val Object_asInstanceOf = newPolyMethod(
       ObjectClass, newTermName("$asInstanceOf"),
       tparam => MethodType(List(), tparam.typeConstructor)) setFlag (FINAL | SYNTHETIC)
+    lazy val String_+ = newMethod(StringClass, nme.raw.PLUS, anyparam, stringtype, FINAL)
 
     def Object_getClass  = getMember(ObjectClass, nme.getClass_)
     def Object_clone     = getMember(ObjectClass, nme.clone_)
@@ -664,7 +680,6 @@ trait Definitions extends reflect.api.StandardDefinitions {
     def Object_hashCode  = getMember(ObjectClass, nme.hashCode_)
     def Object_toString  = getMember(ObjectClass, nme.toString_)
 
-    var String_+           : Symbol = _
 
     // boxed classes
     lazy val ObjectRefClass         = getRequiredClass("scala.runtime.ObjectRef")
@@ -940,43 +955,7 @@ trait Definitions extends reflect.api.StandardDefinitions {
 
       RootClass.info.decls enter EmptyPackage
       RootClass.info.decls enter RootPackage
-
-      // members of class scala.Any
-      Any_== = newMethod(AnyClass, nme.EQ, anyparam, booltype, FINAL)
-      Any_!= = newMethod(AnyClass, nme.NE, anyparam, booltype, FINAL)
-      Any_equals   = newMethod(AnyClass, nme.equals_, anyparam, booltype)
-      Any_hashCode = newMethod(AnyClass, nme.hashCode_, Nil, inttype)
-      Any_toString = newMethod(AnyClass, nme.toString_, Nil, stringtype)
-      Any_##       = newMethod(AnyClass, nme.HASHHASH, Nil, inttype, FINAL)
-
-      // Any_getClass requires special handling.  The return type is determined on
-      // a per-call-site basis as if the function being called were actually:
-      //
-      //    // Assuming `target.getClass()`
-      //    def getClass[T](target: T): Class[_ <: T]
-      //
-      // Since getClass is not actually a polymorphic method, this requires compiler
-      // participation.  At the "Any" level, the return type is Class[_] as it is in
-      // java.lang.Object.  Java also special cases the return type.
-      Any_getClass =
-        newMethod(AnyClass, nme.getClass_, Nil, getMember(ObjectClass, nme.getClass_).tpe.resultType, DEFERRED)
-      Any_isInstanceOf = newPolyMethod(
-        AnyClass, nme.isInstanceOf_, tparam => NullaryMethodType(booltype)) setFlag FINAL
-      Any_asInstanceOf = newPolyMethod(
-        AnyClass, nme.asInstanceOf_, tparam => NullaryMethodType(tparam.typeConstructor)) setFlag FINAL
-
-      // members of class java.lang.{ Object, String }
-      Object_## = newMethod(ObjectClass, nme.HASHHASH, Nil, inttype, FINAL)
-      Object_== = newMethod(ObjectClass, nme.EQ, anyrefparam, booltype, FINAL)
-      Object_!= = newMethod(ObjectClass, nme.NE, anyrefparam, booltype, FINAL)
-      Object_eq = newMethod(ObjectClass, nme.eq, anyrefparam, booltype, FINAL)
-      Object_ne = newMethod(ObjectClass, nme.ne, anyrefparam, booltype, FINAL)
-      Object_synchronized = newPolyMethodCon(
-        ObjectClass, nme.synchronized_,
-        tparam => msym => MethodType(msym.newSyntheticValueParams(List(tparam.typeConstructor)), tparam.typeConstructor)) setFlag FINAL
-
-      String_+ = newMethod(StringClass, nme.raw.PLUS, anyparam, stringtype, FINAL)
-
+      
       val forced = List( // force initialization of every symbol that is entered as a side effect
         AnnotationDefaultAttr, // #2264
         RepeatedParamClass,
@@ -989,8 +968,24 @@ trait Definitions extends reflect.api.StandardDefinitions {
         NothingClass,
         SingletonClass,
         EqualsPatternClass,
+        Any_==,
+        Any_!=,
+        Any_equals,
+        Any_hashCode,
+        Any_toString,
+        Any_getClass,
+        Any_isInstanceOf,
+        Any_asInstanceOf,
+        Any_##,
+        Object_eq,
+        Object_ne,
+        Object_==,
+        Object_!=,
+        Object_##,
+        Object_synchronized,
         Object_isInstanceOf,
-        Object_asInstanceOf
+        Object_asInstanceOf,
+        String_+
       )
 
       /** Removing the anyref parent they acquire from having a source file.