Optimize nested scope creation

We can copy the hash table from the parent scope, rather
than constructing it from scratch.

This takes us to:

	% rm -rf /tmp/pkg; (for i in {1..50}; do for j in {1..100}; do echo "package pkg { class A_${i}_${j}___(val a: Int, val b: Int) }"; done; done) > sandbox/A1.scala && time qbin/scalac -Ybackend:GenASM -J-Xmx1G -J-XX:MaxPermSize=400M -d /tmp sandbox/A1.scala;

	real	0m19.639s  // head~1 was 0m35.662s
	user	0m41.683s  // head~1 was 0m58.275s
	sys	0m1.886s

In more detail, this commit:

  - Removes the unused `fingerprint` constructor parameter from
    scopes. This is a remnant from a previous optimization attempt
  - Leave only one constructor on Scope which creates an empty
    scope
  - Update the factory method, `newNestedScope`, to copy the hash
    table from the parent if it exists. We can rely on the invariant
    that `outer.hashTable != null || outer.size < MIN_HASH)`, so we
    don't need `if (size >= MIN_HASH) createHash()` anymore. This
    used to be needed in `Scope#<init>`, which accepted an aribitrary
    `initElems: ScopeEntry`.
  - Update subclasses and factories of `Scope` in runtime reflection
    to accomodate the change. Pleasingly, we could actually remove
    the override for `newNestedScope`.
  - Unit tests the functionality I'm touching

1 files changed, 54 insertions, 0 deletions

diff --git a/test/junit/scala/reflect/internal/ScopeTest.scala b/test/junit/scala/reflect/internal/ScopeTest.scala
new file mode 100644
index 0000000000..5166620189
--- /dev/null
+++ b/test/junit/scala/reflect/internal/ScopeTest.scala
@@ -0,0 +1,54 @@
+package symtab
+
+import scala.tools.nsc.symtab
+
+import org.junit.Assert._
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+
+import scala.tools.testing.AssertUtil.assertThrows
+import scala.tools.nsc.symtab.SymbolTableForUnitTesting
+
+@RunWith(classOf[JUnit4])
+class ScopeTest {
+  object symbolTable extends SymbolTableForUnitTesting
+
+  import symbolTable._
+
+  @Test
+  def testNestedScopeSmall(): Unit = testNestedScope(0)
+  @Test
+  def testNestedScopeLarge(): Unit = testNestedScope(64) // exceeding MIN_HASH
+
+  private def testNestedScope(initSize: Int) {
+    def sym(termName: String): Symbol = NoSymbol.newValue(TermName(termName))
+    val foo = sym("foo")
+    val bar = sym("bar")
+
+    val outerElems = List.tabulate(initSize)(i => sym(i.toString))
+    val outer = newScopeWith(outerElems ++ List(foo, bar) : _*)
+    assertTrue(outer.containsName(foo.name))
+    assertTrue(outer.containsName(bar.name))
+
+    val baz = sym("baz")
+    val nested = newNestedScope(outer)
+
+    // Entries from the outer scope are entered in the nested.
+    assertTrue(outer.containsName(foo.name))
+    assertTrue(outer.containsName(bar.name))
+
+    // Nested scopes structurally share ScopeEntry-s with the outer.
+    assertSame(outer.lookupEntry(foo.name), nested.lookupEntry(foo.name))
+    nested.enter(baz)
+
+    // Symbols entered in the nested scope aren't visible in the outer.
+    assertTrue(nested.containsName(baz.name))
+    assertTrue(!outer.containsName(baz.name))
+
+    // Unlinking a symbol in the inner scope doesn't modify the outer
+    nested.unlink(bar)
+    assert(!nested.containsName(bar.name))
+    assert(outer.containsName(bar.name))
+  }
+}