Extend synchronized scope in newTermName

Just noted that the previous scope might have been too small.
We compute the bucket index with the table size before going into the
synchronized. But that might mean we see a stale table size.
Let's see what this gives us.

Author: odersky

src/dotty/tools/dotc/core/Names.scala

@@ -240,64 +240,61 @@ object Names {
   /** Create a term name from the characters in cs[offset..offset+len-1].
    *  Assume they are already encoded.
    */
-  def termName(cs: Array[Char], offset: Int, len: Int): TermName = {
+  def termName(cs: Array[Char], offset: Int, len: Int): TermName = synchronized {
     util.Stats.record("termName")
     val h = hashValue(cs, offset, len) & (table.size - 1)
 
-    synchronized {
-
-      /** Make sure the capacity of the character array is at least `n` */
-      def ensureCapacity(n: Int) =
-        if (n > chrs.length) {
-          val newchrs = new Array[Char](chrs.length * 2)
-          chrs.copyToArray(newchrs)
-          chrs = newchrs
-        }
-
-      /** Enter characters into chrs array. */
-      def enterChars(): Unit = {
-        ensureCapacity(nc + len)
-        var i = 0
-        while (i < len) {
-          chrs(nc + i) = cs(offset + i)
-          i += 1
-        }
-        nc += len
+    /** Make sure the capacity of the character array is at least `n` */
+    def ensureCapacity(n: Int) =
+      if (n > chrs.length) {
+        val newchrs = new Array[Char](chrs.length * 2)
+        chrs.copyToArray(newchrs)
+        chrs = newchrs
       }
 
-      /** Rehash chain of names */
-      def rehash(name: TermName): Unit =
-        if (name != null) {
-          val oldNext = name.next
-          val h = hashValue(chrs, name.start, name.length) & (table.size - 1)
-          name.next = table(h)
-          table(h) = name
-          rehash(oldNext)
-        }
+    /** Enter characters into chrs array. */
+    def enterChars(): Unit = {
+      ensureCapacity(nc + len)
+      var i = 0
+      while (i < len) {
+        chrs(nc + i) = cs(offset + i)
+        i += 1
+      }
+      nc += len
+    }
 
-      /** Make sure the hash table is large enough for the given load factor */
-      def incTableSize() = {
-        size += 1
-        if (size.toDouble / table.size > fillFactor) {
-          val oldTable = table
-          table = new Array[TermName](table.size * 2)
-          for (i <- 0 until oldTable.size) rehash(oldTable(i))
-        }
+    /** Rehash chain of names */
+    def rehash(name: TermName): Unit =
+      if (name != null) {
+        val oldNext = name.next
+        val h = hashValue(chrs, name.start, name.length) & (table.size - 1)
+        name.next = table(h)
+        table(h) = name
+        rehash(oldNext)
       }
 
-      val next = table(h)
-      var name = next
-      while (name ne null) {
-        if (name.length == len && equals(name.start, cs, offset, len))
-          return name
-        name = name.next
+    /** Make sure the hash table is large enough for the given load factor */
+    def incTableSize() = {
+      size += 1
+      if (size.toDouble / table.size > fillFactor) {
+        val oldTable = table
+        table = new Array[TermName](table.size * 2)
+        for (i <- 0 until oldTable.size) rehash(oldTable(i))
       }
-      name = new TermName(nc, len, next)
-      enterChars()
-      table(h) = name
-      incTableSize()
-      name
     }
+
+    val next = table(h)
+    var name = next
+    while (name ne null) {
+      if (name.length == len && equals(name.start, cs, offset, len))
+        return name
+      name = name.next
+    }
+    name = new TermName(nc, len, next)
+    enterChars()
+    table(h) = name
+    incTableSize()
+    name
   }
 
   /** Create a type name from the characters in cs[offset..offset+len-1].