3 files changed, 14 insertions, 15 deletions
diff --git a/src/reflect/scala/reflect/internal/Scopes.scala b/src/reflect/scala/reflect/internal/Scopes.scala
index cf3f356daa..103f885ad4 100644
--- a/src/reflect/scala/reflect/internal/Scopes.scala
+++ b/src/reflect/scala/reflect/internal/Scopes.scala
@@ -48,22 +48,17 @@ trait Scopes extends api.Scopes { self: SymbolTable =>
    *  This is necessary because when run from reflection every scope needs to have a
    *  SynchronizedScope as mixin.
    */
-  class Scope protected[Scopes] (initElems: ScopeEntry = null, initFingerPrints: Long = 0L) extends ScopeApi with MemberScopeApi {
+  class Scope protected[Scopes]() extends ScopeApi with MemberScopeApi {
 
-    protected[Scopes] def this(base: Scope) = {
-      this(base.elems)
-      nestinglevel = base.nestinglevel + 1
-    }
-
-    private[scala] var elems: ScopeEntry = initElems
+    private[scala] var elems: ScopeEntry = _
 
     /** The number of times this scope is nested in another
      */
-    private var nestinglevel = 0
+    private[Scopes] var nestinglevel = 0
 
     /** the hash table
      */
-    private var hashtable: Array[ScopeEntry] = null
+    private[Scopes] var hashtable: Array[ScopeEntry] = null
 
     /** a cache for all elements, to be used by symbol iterator.
      */
@@ -84,8 +79,6 @@ trait Scopes extends api.Scopes { self: SymbolTable =>
      */
     private val MIN_HASH = 8
 
-    if (size >= MIN_HASH) createHash()
-
     /** Returns a new scope with the same content as this one. */
     def cloneScope: Scope = newScopeWith(this.toList: _*)
 
@@ -435,7 +428,14 @@ trait Scopes extends api.Scopes { self: SymbolTable =>
   }
 
   /** Create a new scope nested in another one with which it shares its elements */
-  def newNestedScope(outer: Scope): Scope = new Scope(outer)
+  final def newNestedScope(outer: Scope): Scope = {
+    val nested = newScope // not `new Scope`, we must allow the runtime reflection universe to mixin SynchronizedScopes!
+    nested.elems = outer.elems
+    nested.nestinglevel = outer.nestinglevel + 1
+    if (outer.hashtable ne null)
+      nested.hashtable = java.util.Arrays.copyOf(outer.hashtable, outer.hashtable.length)
+    nested
+  }
 
   /** Create a new scope with given initial elements */
   def newScopeWith(elems: Symbol*): Scope = {
diff --git a/src/reflect/scala/reflect/runtime/SymbolLoaders.scala b/src/reflect/scala/reflect/runtime/SymbolLoaders.scala
index c56bc28d90..7ba68b8733 100644
--- a/src/reflect/scala/reflect/runtime/SymbolLoaders.scala
+++ b/src/reflect/scala/reflect/runtime/SymbolLoaders.scala
@@ -91,7 +91,7 @@ private[reflect] trait SymbolLoaders { self: SymbolTable =>
   //
   // Short of significantly changing SymbolLoaders I see no other way than just
   // to slap a global lock on materialization in runtime reflection.
-  class PackageScope(pkgClass: Symbol) extends Scope(initFingerPrints = -1L) // disable fingerprinting as we do not know entries beforehand
+  class PackageScope(pkgClass: Symbol) extends Scope
       with SynchronizedScope {
     assert(pkgClass.isType)
 
diff --git a/src/reflect/scala/reflect/runtime/SynchronizedOps.scala b/src/reflect/scala/reflect/runtime/SynchronizedOps.scala
index c90901410a..4a8585d616 100644
--- a/src/reflect/scala/reflect/runtime/SynchronizedOps.scala
+++ b/src/reflect/scala/reflect/runtime/SynchronizedOps.scala
@@ -37,8 +37,7 @@ private[reflect] trait SynchronizedOps extends internal.SymbolTable
 
 // Scopes
 
-  override def newScope = new Scope() with SynchronizedScope
-  override def newNestedScope(outer: Scope): Scope = new Scope(outer) with SynchronizedScope
+  override def newScope = new Scope with SynchronizedScope
 
   trait SynchronizedScope extends Scope {
     // we can keep this lock fine-grained, because methods of Scope don't do anything extraordinary, which makes deadlocks impossible