wip: resolve ambiguities in a way that works in Scala 2 as well

Author: SethTisue

core/src/main/scala/scala/collection/parallel/mutable/ParHashMap.scala

@@ -169,11 +169,11 @@ extends scala.collection.parallel.BucketCombiner[(K, V), ParHashMap[K, V], Defau
    with scala.collection.mutable.HashTable.HashUtils[K]
 {
   private val nonmasklen = ParHashMapCombiner.nonmasklength
-  private val seedvalue = 27
+  private val seed = 27
 
   def addOne(elem: (K, V)) = {
     sz += 1
-    val hc = improve(elemHashCode(elem._1), seedvalue)
+    val hc = improve(elemHashCode(elem._1), seed)
     val pos = (hc >>> nonmasklen)
     if (buckets(pos) eq null) {
       // initialize bucket
@@ -186,7 +186,7 @@ extends scala.collection.parallel.BucketCombiner[(K, V), ParHashMap[K, V], Defau
 
   def result(): ParHashMap[K, V] = if (size >= (ParHashMapCombiner.numblocks * sizeMapBucketSize)) { // 1024
     // construct table
-    val table = new AddingHashTable(size, tableLoadFactor, seedvalue)
+    val table = new AddingHashTable(size, tableLoadFactor, seed)
     val bucks = buckets.map(b => if (b ne null) b.headPtr else null)
     val insertcount = combinerTaskSupport.executeAndWaitResult(new FillBlocks(bucks, table, 0, bucks.length))
     table.setSize(insertcount)
@@ -229,7 +229,7 @@ extends scala.collection.parallel.BucketCombiner[(K, V), ParHashMap[K, V], Defau
     _loadFactor = lf
     table = new Array[HashEntry[K, DefaultEntry[K, V]]](capacity(sizeForThreshold(_loadFactor, numelems)))
     tableSize = 0
-    super[HashTable].seedvalue = _seedvalue
+    seedvalue = _seedvalue
     threshold = newThreshold(_loadFactor, table.length)
     sizeMapInit(table.length)
     def setSize(sz: Int) = tableSize = sz

core/src/main/scala/scala/collection/parallel/mutable/ParHashSet.scala

@@ -126,12 +126,12 @@ extends scala.collection.parallel.BucketCombiner[T, ParHashSet[T], AnyRef, ParHa
 with scala.collection.mutable.FlatHashTable.HashUtils[T] {
 //self: EnvironmentPassingCombiner[T, ParHashSet[T]] =>
   private val nonmasklen = ParHashSetCombiner.nonmasklength
-  private val seedvalue = 27
+  private val seed = 27
 
   def addOne(elem: T) = {
     val entry = elemToEntry(elem)
     sz += 1
-    val hc = improve(entry.hashCode, seedvalue)
+    val hc = improve(entry.hashCode, seed)
     val pos = hc >>> nonmasklen
     if (buckets(pos) eq null) {
       // initialize bucket
@@ -149,7 +149,7 @@ with scala.collection.mutable.FlatHashTable.HashUtils[T] {
 
   private def parPopulate: FlatHashTable.Contents[T] = {
     // construct it in parallel
-    val table = new AddingFlatHashTable(size, tableLoadFactor, seedvalue)
+    val table = new AddingFlatHashTable(size, tableLoadFactor, seed)
     val (inserted, leftovers) = combinerTaskSupport.executeAndWaitResult(new FillBlocks(buckets, table, 0, buckets.length))
     var leftinserts = 0
     for (entry <- leftovers) leftinserts += table.insertEntry(0, table.tableLength, entry)
@@ -162,7 +162,7 @@ with scala.collection.mutable.FlatHashTable.HashUtils[T] {
     // TODO parallelize by keeping separate size maps and merging them
     val tbl = new FlatHashTable[T] {
       sizeMapInit(table.length)
-      super[FlatHashTable].seedvalue = ParHashSetCombiner.this.seedvalue
+      seedvalue = seed
       for {
         buffer <- buckets
         if buffer ne null
@@ -184,7 +184,7 @@ with scala.collection.mutable.FlatHashTable.HashUtils[T] {
     table = new Array[AnyRef](capacity(FlatHashTable.sizeForThreshold(numelems, _loadFactor)))
     tableSize = 0
     threshold = FlatHashTable.newThreshold(_loadFactor, table.length)
-    super[FlatHashTable].seedvalue = inseedvalue
+    seedvalue = inseedvalue
     sizeMapInit(table.length)
 
     override def toString = "AFHT(%s)".format(table.length)