remove pieces specific to old 2.12 HashMap implementation

I suppose we ought to replace this instead of just remove it?
but for now, I'm just trying to get the 2.13 community build green
for 2.13.0-M5

Author: SethTisue

src/main/java/scala/compat/java8/ScalaStreamSupport.java

@@ -32,43 +32,6 @@ public static <T> Stream<T> stream(scala.collection.IndexedSeq<T> coll) {
         return StreamSupport.stream(new StepsAnyIndexedSeq<T>((scala.collection.IndexedSeq)coll, 0, coll.length()), false);
     }
 
-    /** 
-     * Generates a Stream that traverses the keys of a scala.collection.immutable.HashMap.
-     * <p>
-     * Both sequential and parallel operations will be efficient.
-     *
-     * @param coll The immutable.HashMap to traverse
-     * @return     A Stream view of the collection which, by default, executes sequentially.
-     */
-    public static <K> Stream<K> streamKeys(scala.collection.immutable.HashMap<K, ? super Object> coll) {
-        return StreamSupport.stream(new StepsAnyImmHashMapKey<K, Object>(coll, 0, coll.size()), false);
-    }
-
-    /** 
-     * Generates a Stream that traverses the values of a scala.collection.immutable.HashMap.
-     * <p>
-     * Both sequential and parallel operations will be efficient.
-     *
-     * @param coll The immutable.HashMap to traverse
-     * @return     A Stream view of the collection which, by default, executes sequentially.
-     */
-    public static <V> Stream<V> streamValues(scala.collection.immutable.HashMap<? super Object, V> coll) {
-        return StreamSupport.stream(new StepsAnyImmHashMapValue<Object, V>(coll, 0, coll.size()), false);
-    }
-
-    /** 
-     * Generates a Stream that traverses the key-value pairs of a scala.collection.immutable.HashMap.
-     * The key-value pairs are presented as instances of scala.Tuple2.
-     * <p>
-     * Both sequential and parallel operations will be efficient.
-     *
-     * @param coll The immutable.HashMap to traverse
-     * @return     A Stream view of the collection which, by default, executes sequentially.
-     */
-    public static <K, V> Stream< scala.Tuple2<K, V> > stream(scala.collection.immutable.HashMap<K, V> coll) {
-        return StreamSupport.stream(new StepsAnyImmHashMap<K, V>(coll, 0, coll.size()), false);
-    }
-
     /** 
      * Generates a Stream that traverses a scala.collection.immutable.HashSet.
      * <p>
@@ -275,30 +238,6 @@ public static DoubleStream doubleStream(scala.collection.IndexedSeq<Double> coll
         return StreamSupport.doubleStream(new StepsDoubleIndexedSeq(coll, 0, coll.length()), false);
     }
 
-    /** 
-     * Generates a DoubleStream that traverses double-valued keys of a scala.collection.immutable.HashMap.
-     * <p>
-     * Both sequential and parallel operations will be efficient.
-     *
-     * @param coll The immutable.HashMap to traverse
-     * @return     A DoubleStream view of the collection which, by default, executes sequentially.
-     */
-    public static DoubleStream doubleStreamKeys(scala.collection.immutable.HashMap<Double, ? super Object> coll) {
-        return StreamSupport.doubleStream(new StepsDoubleImmHashMapKey(coll, 0, coll.size()), false);
-    }
-
-    /** 
-     * Generates a DoubleStream that traverses double-valued values of a scala.collection.immutable.HashMap.
-     * <p>
-     * Both sequential and parallel operations will be efficient.
-     *
-     * @param coll The immutable.HashMap to traverse
-     * @return     A DoubleStream view of the collection which, by default, executes sequentially.
-     */
-    public static DoubleStream doubleStreamValues(scala.collection.immutable.HashMap<? super Object, Double> coll) {
-        return StreamSupport.doubleStream(new StepsDoubleImmHashMapValue(coll, 0, coll.size()), false);
-    }
-
     /** 
      * Generates a DoubleStream that traverses a scala.collection.immutable.HashSet of Doubles.
      * <p>
@@ -511,30 +450,6 @@ public static IntStream intStream(scala.collection.IndexedSeq<Integer> coll) {
         return StreamSupport.intStream(new StepsIntIndexedSeq(coll, 0, coll.length()), false);
     }
 
-    /** 
-     * Generates a IntStream that traverses int-valued keys of a scala.collection.immutable.HashMap.
-     * <p>
-     * Both sequential and parallel operations will be efficient.
-     *
-     * @param coll The immutable.HashMap to traverse
-     * @return     A IntStream view of the collection which, by default, executes sequentially.
-     */
-    public static IntStream intStreamKeys(scala.collection.immutable.HashMap<Integer, ? super Object> coll) {
-        return StreamSupport.intStream(new StepsIntImmHashMapKey(coll, 0, coll.size()), false);
-    }
-
-    /** 
-     * Generates a IntStream that traverses int-valued values of a scala.collection.immutable.HashMap.
-     * <p>
-     * Both sequential and parallel operations will be efficient.
-     *
-     * @param coll The immutable.HashMap to traverse
-     * @return     A IntStream view of the collection which, by default, executes sequentially.
-     */
-    public static IntStream intStreamValues(scala.collection.immutable.HashMap<? super Object, Integer> coll) {
-        return StreamSupport.intStream(new StepsIntImmHashMapValue(coll, 0, coll.size()), false);
-    }
-
     /** 
      * Generates a IntStream that traverses a scala.collection.immutable.HashSet of Ints.
      * <p>
@@ -720,30 +635,6 @@ public static LongStream longStream(scala.collection.IndexedSeq<Long> coll) {
         return StreamSupport.longStream(new StepsLongIndexedSeq(coll, 0, coll.length()), false);
     }
 
-    /** 
-     * Generates a LongStream that traverses long-valued keys of a scala.collection.immutable.HashMap.
-     * <p>
-     * Both sequential and parallel operations will be efficient.
-     *
-     * @param coll The immutable.HashMap to traverse
-     * @return     A LongStream view of the collection which, by default, executes sequentially.
-     */
-    public static LongStream longStreamKeys(scala.collection.immutable.HashMap<Long, ? super Object> coll) {
-        return StreamSupport.longStream(new StepsLongImmHashMapKey(coll, 0, coll.size()), false);
-    }
-
-    /** 
-     * Generates a LongStream that traverses long-valued values of a scala.collection.immutable.HashMap.
-     * <p>
-     * Both sequential and parallel operations will be efficient.
-     *
-     * @param coll The immutable.HashMap to traverse
-     * @return     A LongStream view of the collection which, by default, executes sequentially.
-     */
-    public static LongStream longStreamValues(scala.collection.immutable.HashMap<? super Object, Long> coll) {
-        return StreamSupport.longStream(new StepsLongImmHashMapValue(coll, 0, coll.size()), false);
-    }
-
     /** 
      * Generates a LongStream that traverses a scala.collection.immutable.HashSet of Longs.
      * <p>

src/main/scala/scala/compat/java8/converterImpl/StepConverters.scala

@@ -31,8 +31,6 @@ trait Priority1StepConverters extends Priority2StepConverters {
     new RichHashSetCanStep[A](underlying)
   implicit def richIteratorCanStep[A](underlying: Iterator[A]): RichIteratorCanStep[A] =
     new RichIteratorCanStep(underlying)
-  implicit def richImmHashMapCanStep[K, V](underlying: collection.immutable.HashMap[K, V]): RichImmHashMapCanStep[K, V] =
-    new RichImmHashMapCanStep[K, V](underlying)
   implicit def richImmHashSetCanStep[A](underlying: collection.immutable.HashSet[A]): RichImmHashSetCanStep[A] =
     new RichImmHashSetCanStep[A](underlying)
   implicit def richNumericRangeCanStep[T](underlying: collection.immutable.NumericRange[T]): RichNumericRangeCanStep[T] =

src/main/scala/scala/compat/java8/converterImpl/StepsImmHashMap.scala

@@ -104,9 +104,6 @@ class StepConvertersTest {
     Okay( (ci.HashMap[String, String]("fish" -> "salmon"): ci.AbstractMap[String, String]).stepper )
     Okay( (ci.HashMap[String, String]("fish" -> "salmon"): ci.AbstractMap[String, String]).keyStepper )
     Okay( (ci.HashMap[String, String]("fish" -> "salmon"): ci.AbstractMap[String, String]).valueStepper )
-    good( ci.HashMap[String, String]("fish" -> "salmon").stepper )
-    good( ci.HashMap[String, String]("fish" -> "salmon").keyStepper )
-    good( ci.HashMap[String, String]("fish" -> "salmon").valueStepper )
     good( ci.HashSet[String]("salmon").stepper )
     good( ci.IndexedSeq[String]("salmon").stepper )
     Okay( ci.IntMap[String](123456 -> "salmon").stepper )
@@ -232,8 +229,6 @@ class StepConvertersTest {
     Okay( ci.::(3.14159, Nil).stepper )
     Okay( (ci.HashMap[Double, Double](2.718281828 -> 3.14159): ci.AbstractMap[Double, Double]).keyStepper )
     Okay( (ci.HashMap[Double, Double](2.718281828 -> 3.14159): ci.AbstractMap[Double, Double]).valueStepper )
-    good( ci.HashMap[Double, Double](2.718281828 -> 3.14159).keyStepper )
-    good( ci.HashMap[Double, Double](2.718281828 -> 3.14159).valueStepper )
     good( ci.HashSet[Double](3.14159).stepper )
     good( ci.IndexedSeq[Double](3.14159).stepper )
     Okay( ci.IntMap[Double](123456 -> 3.14159).valueStepper )
@@ -350,8 +345,6 @@ class StepConvertersTest {
     Okay( ci.::(654321, Nil).stepper )
     Okay( (ci.HashMap[Int, Int](0xDEEDED -> 654321): ci.AbstractMap[Int, Int]).keyStepper )
     Okay( (ci.HashMap[Int, Int](0xDEEDED -> 654321): ci.AbstractMap[Int, Int]).valueStepper )
-    good( ci.HashMap[Int, Int](0xDEEDED -> 654321).keyStepper )
-    good( ci.HashMap[Int, Int](0xDEEDED -> 654321).valueStepper )
     good( ci.HashSet[Int](654321).stepper )
     good( ci.IndexedSeq[Int](654321).stepper )
     Okay( ci.IntMap[Int](123456 -> 654321).keyStepper )
@@ -483,8 +476,6 @@ class StepConvertersTest {
     Okay( ci.::(0x123456789L, Nil).stepper )
     Okay( (ci.HashMap[Long, Long](1234567654321L -> 0x123456789L): ci.AbstractMap[Long, Long]).keyStepper )
     Okay( (ci.HashMap[Long, Long](1234567654321L -> 0x123456789L): ci.AbstractMap[Long, Long]).valueStepper )
-    good( ci.HashMap[Long, Long](1234567654321L -> 0x123456789L).keyStepper )
-    good( ci.HashMap[Long, Long](1234567654321L -> 0x123456789L).valueStepper )
     good( ci.HashSet[Long](0x123456789L).stepper )
     good( ci.IndexedSeq[Long](0x123456789L).stepper )
     Okay( ci.IntMap[Long](123456 -> 0x123456789L).valueStepper )