Revert SI-6240 synchronization for runtime reflection

This commit reverts #2083:
  - 387b2590db runtime reflection: death from thousand threads
  - 73d079fb38 removes the assertion in missingHook
  - f4dd56ca5d synchronizes names
  - dd148de5a8 synchronizes pendingVolatiles
  - 4cbb9357c5 synchronizes toolboxes
  - 07bcb6176a SI-7045 reflection now auto-initializes selfType
  - bebd62d566 optimizes Scala reflection GIL
  - 735634f1d6 initializes lazy vals and inner objects in advance
  - 5b37cfb19a introduces GIL to Scala reflection
  - 981da8edfc cleans up initialization of runtime reflection
  - b2c2493b22 reflection no longer uses atPhase and friends
  - a9dca512d8 synchronizes symbols
  - 0262941b3c removes the crazy extraneous log
  - 21d5d3820b moves Symbol#SymbolKind to Symbols

1 files changed, 23 insertions, 29 deletions

diff --git a/src/compiler/scala/tools/reflect/ToolBoxFactory.scala b/src/compiler/scala/tools/reflect/ToolBoxFactory.scala
index 93fafda463..c05c59d5ff 100644
--- a/src/compiler/scala/tools/reflect/ToolBoxFactory.scala
+++ b/src/compiler/scala/tools/reflect/ToolBoxFactory.scala
@@ -352,19 +352,15 @@ abstract class ToolBoxFactory[U <: JavaUniverse](val u: U) { factorySelf =>
     lazy val importer = compiler.mkImporter(u)
     lazy val exporter = importer.reverse
 
-    private[this] val toolBoxLock = new Object
-
-    def typeCheck(tree: u.Tree, expectedType: u.Type, silent: Boolean = false, withImplicitViewsDisabled: Boolean = false, withMacrosDisabled: Boolean = false): u.Tree = toolBoxLock.synchronized {
-      compiler.withCleanupCaches {
-        if (compiler.settings.verbose.value) println("importing "+tree+", expectedType = "+expectedType)
-        var ctree: compiler.Tree = importer.importTree(tree)
-        var cexpectedType: compiler.Type = importer.importType(expectedType)
-
-        if (compiler.settings.verbose.value) println("typing "+ctree+", expectedType = "+expectedType)
-        val ttree: compiler.Tree = compiler.typeCheck(ctree, cexpectedType, silent = silent, withImplicitViewsDisabled = withImplicitViewsDisabled, withMacrosDisabled = withMacrosDisabled)
-        val uttree = exporter.importTree(ttree)
-        uttree
-      }
+    def typeCheck(tree: u.Tree, expectedType: u.Type, silent: Boolean = false, withImplicitViewsDisabled: Boolean = false, withMacrosDisabled: Boolean = false): u.Tree = compiler.withCleanupCaches {
+      if (compiler.settings.verbose.value) println("importing "+tree+", expectedType = "+expectedType)
+      var ctree: compiler.Tree = importer.importTree(tree)
+      var cexpectedType: compiler.Type = importer.importType(expectedType)
+
+      if (compiler.settings.verbose.value) println("typing "+ctree+", expectedType = "+expectedType)
+      val ttree: compiler.Tree = compiler.typeCheck(ctree, cexpectedType, silent = silent, withImplicitViewsDisabled = withImplicitViewsDisabled, withMacrosDisabled = withMacrosDisabled)
+      val uttree = exporter.importTree(ttree)
+      uttree
     }
 
     def inferImplicitValue(pt: u.Type, silent: Boolean = true, withMacrosDisabled: Boolean = false, pos: u.Position = u.NoPosition): u.Tree = {
@@ -376,28 +372,26 @@ abstract class ToolBoxFactory[U <: JavaUniverse](val u: U) { factorySelf =>
       inferImplicit(tree, viewTpe, isView = true, silent = silent, withMacrosDisabled = withMacrosDisabled, pos = pos)
     }
 
-    private def inferImplicit(tree: u.Tree, pt: u.Type, isView: Boolean, silent: Boolean, withMacrosDisabled: Boolean, pos: u.Position): u.Tree = toolBoxLock.synchronized {
-      compiler.withCleanupCaches {
-        if (compiler.settings.verbose.value) println("importing "+pt, ", tree = "+tree+", pos = "+pos)
-        var ctree: compiler.Tree = importer.importTree(tree)
-        var cpt: compiler.Type = importer.importType(pt)
-        var cpos: compiler.Position = importer.importPosition(pos)
-
-        if (compiler.settings.verbose.value) println("inferring implicit %s of type %s, macros = %s".format(if (isView) "view" else "value", pt, !withMacrosDisabled))
-        val itree: compiler.Tree = compiler.inferImplicit(ctree, cpt, isView = isView, silent = silent, withMacrosDisabled = withMacrosDisabled, pos = cpos)
-        val uitree = exporter.importTree(itree)
-        uitree
-      }
+    private def inferImplicit(tree: u.Tree, pt: u.Type, isView: Boolean, silent: Boolean, withMacrosDisabled: Boolean, pos: u.Position): u.Tree = compiler.withCleanupCaches {
+      if (compiler.settings.verbose.value) println("importing "+pt, ", tree = "+tree+", pos = "+pos)
+      var ctree: compiler.Tree = importer.importTree(tree)
+      var cpt: compiler.Type = importer.importType(pt)
+      var cpos: compiler.Position = importer.importPosition(pos)
+
+      if (compiler.settings.verbose.value) println("inferring implicit %s of type %s, macros = %s".format(if (isView) "view" else "value", pt, !withMacrosDisabled))
+      val itree: compiler.Tree = compiler.inferImplicit(ctree, cpt, isView = isView, silent = silent, withMacrosDisabled = withMacrosDisabled, pos = cpos)
+      val uitree = exporter.importTree(itree)
+      uitree
     }
 
-    def resetAllAttrs(tree: u.Tree): u.Tree = toolBoxLock.synchronized {
+    def resetAllAttrs(tree: u.Tree): u.Tree = {
       val ctree: compiler.Tree = importer.importTree(tree)
       val ttree: compiler.Tree = compiler.resetAllAttrs(ctree)
       val uttree = exporter.importTree(ttree)
       uttree
     }
 
-    def resetLocalAttrs(tree: u.Tree): u.Tree = toolBoxLock.synchronized {
+    def resetLocalAttrs(tree: u.Tree): u.Tree = {
       val ctree: compiler.Tree = importer.importTree(tree)
       val ttree: compiler.Tree = compiler.resetLocalAttrs(ctree)
       val uttree = exporter.importTree(ttree)
@@ -407,14 +401,14 @@ abstract class ToolBoxFactory[U <: JavaUniverse](val u: U) { factorySelf =>
     def showAttributed(tree: u.Tree, printTypes: Boolean = true, printIds: Boolean = true, printKinds: Boolean = false): String =
       compiler.showAttributed(importer.importTree(tree), printTypes, printIds, printKinds)
 
-    def parse(code: String): u.Tree = toolBoxLock.synchronized {
+    def parse(code: String): u.Tree = {
       if (compiler.settings.verbose.value) println("parsing "+code)
       val ctree: compiler.Tree = compiler.parse(code)
       val utree = exporter.importTree(ctree)
       utree
     }
 
-    def compile(tree: u.Tree): () => Any = toolBoxLock.synchronized {
+    def compile(tree: u.Tree): () => Any = {
       if (compiler.settings.verbose.value) println("importing "+tree)
       var ctree: compiler.Tree = importer.importTree(tree)