More work on making reflection thread-safe.

7 files changed, 33 insertions, 25 deletions

diff --git a/src/compiler/scala/reflect/internal/AnnotationCheckers.scala b/src/compiler/scala/reflect/internal/AnnotationCheckers.scala
index 666c1d74cb..449b0ca0bc 100644
--- a/src/compiler/scala/reflect/internal/AnnotationCheckers.scala
+++ b/src/compiler/scala/reflect/internal/AnnotationCheckers.scala
@@ -49,6 +49,7 @@ trait AnnotationCheckers {
     def adaptAnnotations(tree: Tree, mode: Int, pt: Type): Tree = tree
   }
 
+  // Syncnote: Annotation checkers inaccessible to reflection, so no sync in var necessary.
   /** The list of annotation checkers that have been registered */
   private var annotationCheckers: List[AnnotationChecker] = Nil
 
diff --git a/src/compiler/scala/reflect/internal/AnnotationInfos.scala b/src/compiler/scala/reflect/internal/AnnotationInfos.scala
index 255e69c3c6..c3dde3e6d1 100644
--- a/src/compiler/scala/reflect/internal/AnnotationInfos.scala
+++ b/src/compiler/scala/reflect/internal/AnnotationInfos.scala
@@ -178,7 +178,7 @@ trait AnnotationInfos extends api.AnnotationInfos { self: SymbolTable =>
 
     private var rawpos: Position = NoPosition
     def pos = rawpos
-    def setPos(pos: Position): this.type = {
+    def setPos(pos: Position): this.type = { // Syncnote: Setpos inaccessible to reflection, so no sync in rawpos necessary.
       rawpos = pos
       this
     }
diff --git a/src/compiler/scala/reflect/internal/InfoTransformers.scala b/src/compiler/scala/reflect/internal/InfoTransformers.scala
index 9c54b1b4cd..96d9d8f076 100644
--- a/src/compiler/scala/reflect/internal/InfoTransformers.scala
+++ b/src/compiler/scala/reflect/internal/InfoTransformers.scala
@@ -9,6 +9,8 @@ package internal
 trait InfoTransformers {
   self: SymbolTable =>
 
+  /* Syncnote: This should not need to be protected, as reflection does not run in multiple phases.
+   */
   abstract class InfoTransformer {
     var prev: InfoTransformer = this
     var next: InfoTransformer = this
diff --git a/src/compiler/scala/reflect/runtime/ConversionUtil.scala b/src/compiler/scala/reflect/runtime/ConversionUtil.scala
index bd40200310..e75fd78590 100644
--- a/src/compiler/scala/reflect/runtime/ConversionUtil.scala
+++ b/src/compiler/scala/reflect/runtime/ConversionUtil.scala
@@ -17,36 +17,42 @@ trait ConversionUtil { self: SymbolTable =>
     private val toScalaMap = new HashMap[J, S]
     private val toJavaMap = new HashMap[S, J]
 
-    def enter(j: J, s: S) = {
+    def enter(j: J, s: S) = synchronized {
       debugInfo("cached: "+j+"/"+s)
       toScalaMap(j) = s
       toJavaMap(s) = j
     }
 
-    def toScala(key: J)(body: => S): S = toScalaMap get key match {
-      case Some(v) =>
-        v
-      case none =>
-        val result = body
-        enter(key, result)
-        result
+    def toScala(key: J)(body: => S): S = synchronized { 
+      toScalaMap get key match {
+        case Some(v) =>
+          v
+        case none =>
+          val result = body
+          enter(key, result)
+          result
+      }
     }
 
-    def toJava(key: S)(body: => J): J = toJavaMap get key match {
-      case Some(v) =>
-        v
-      case none =>
-        val result = body
-        enter(result, key)
-        result
+    def toJava(key: S)(body: => J): J = synchronized { 
+      toJavaMap get key match {
+        case Some(v) =>
+          v
+        case none =>
+          val result = body
+          enter(result, key)
+          result
+      }
     }
 
-    def toJavaOption(key: S)(body: => Option[J]): Option[J] = toJavaMap get key match {
-      case None =>
-        val result = body
-        for (value <- result) enter(value, key)
-        result
-      case some => some
+    def toJavaOption(key: S)(body: => Option[J]): Option[J] = synchronized {
+      toJavaMap get key match {
+        case None =>
+          val result = body
+          for (value <- result) enter(value, key)
+          result
+        case some => some
+      }
     }
   }
 
diff --git a/src/compiler/scala/reflect/runtime/JavaToScala.scala b/src/compiler/scala/reflect/runtime/JavaToScala.scala
index 61b03a9a29..6e4b6cef30 100644
--- a/src/compiler/scala/reflect/runtime/JavaToScala.scala
+++ b/src/compiler/scala/reflect/runtime/JavaToScala.scala
@@ -175,7 +175,7 @@ trait JavaToScala extends ConversionUtil { self: SymbolTable =>
       load(sym)
       completeRest()
     }
-    def completeRest(): Unit = {
+    def completeRest(): Unit = self.synchronized {
       val tparams = clazz.rawInfo.typeParams
 
       val parents = try {
diff --git a/src/compiler/scala/reflect/runtime/Loaders.scala b/src/compiler/scala/reflect/runtime/Loaders.scala
index 0a5a21de1e..4b35a5b37e 100644
--- a/src/compiler/scala/reflect/runtime/Loaders.scala
+++ b/src/compiler/scala/reflect/runtime/Loaders.scala
@@ -99,7 +99,7 @@ trait Loaders { self: SymbolTable =>
 
   class PackageScope(pkgClass: Symbol) extends Scope() with SynchronizedScope {
     assert(pkgClass.isType)
-    private var negatives = mutable.Set[Name]()
+    private val negatives = mutable.Set[Name]() // Syncnote: Performance only, so need not be protected.
     override def lookupEntry(name: Name): ScopeEntry = {
       val e = super.lookupEntry(name)
       if (e != null)
diff --git a/src/compiler/scala/reflect/runtime/SynchronizedOps.scala b/src/compiler/scala/reflect/runtime/SynchronizedOps.scala
index 98694c2ddf..72adbd4004 100644
--- a/src/compiler/scala/reflect/runtime/SynchronizedOps.scala
+++ b/src/compiler/scala/reflect/runtime/SynchronizedOps.scala
@@ -35,7 +35,6 @@ trait SynchronizedOps extends internal.SymbolTable
   
   override def newScope = new Scope() with SynchronizedScope
   override def newNestedScope(outer: Scope): Scope = new Scope(outer) with SynchronizedScope
-//  override def newScopeWith(elems: ScopeEntry): Scope = new Scope(elems) with SynchronizedScope
 
   trait SynchronizedScope extends Scope {
     override def isEmpty: Boolean = synchronized { super.isEmpty }