Move EfficientSubstep up in inheritance hierarchy

Author: szeiger

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

@@ -11,7 +11,9 @@ import Stepper._
   * is used as a signal to look for more entries in the array.  (This also
   * allows a subclass to traverse a sublist by updating `currentEntry`.)
   */
-private[java8] abstract class AbstractStepsLikeGapped[Sub >: Null, Semi <: Sub](protected val underlying: Array[AnyRef], protected var i0: Int, protected var iN: Int) {
+private[java8] abstract class AbstractStepsLikeGapped[Sub >: Null, Semi <: Sub](protected val underlying: Array[AnyRef], protected var i0: Int, protected var iN: Int)
+  extends EfficientSubstep {
+
   protected var currentEntry: AnyRef = null
   def semiclone(half: Int): Semi
   def characteristics(): Int = Ordered
@@ -37,7 +39,6 @@ private[java8] abstract class AbstractStepsLikeGapped[Sub >: Null, Semi <: Sub](
 private[java8] abstract class StepsLikeGapped[A, STA >: Null <: StepsLikeGapped[A, _]](_underlying: Array[AnyRef], _i0: Int, _iN: Int)
   extends AbstractStepsLikeGapped[AnyStepper[A], STA](_underlying, _i0, _iN)
   with AnyStepper[A]
-  with EfficientSubstep
 {}
 
 /** Abstracts the process of stepping through an incompletely filled array of `AnyRefs`
@@ -47,7 +48,6 @@ private[java8] abstract class StepsLikeGapped[A, STA >: Null <: StepsLikeGapped[
 private[java8] abstract class StepsDoubleLikeGapped[STD >: Null <: StepsDoubleLikeGapped[_]](_underlying: Array[AnyRef], _i0: Int, _iN: Int)
   extends AbstractStepsLikeGapped[DoubleStepper, STD](_underlying, _i0, _iN)
   with DoubleStepper
-  with EfficientSubstep
 {}
 
 /** Abstracts the process of stepping through an incompletely filled array of `AnyRefs`
@@ -57,7 +57,6 @@ private[java8] abstract class StepsDoubleLikeGapped[STD >: Null <: StepsDoubleLi
 private[java8] abstract class StepsIntLikeGapped[STI >: Null <: StepsIntLikeGapped[_]](_underlying: Array[AnyRef], _i0: Int, _iN: Int)
   extends AbstractStepsLikeGapped[IntStepper, STI](_underlying, _i0, _iN)
   with IntStepper
-  with EfficientSubstep
 {}
 
 /** Abstracts the process of stepping through an incompletely filled array of `AnyRefs`
@@ -67,5 +66,4 @@ private[java8] abstract class StepsIntLikeGapped[STI >: Null <: StepsIntLikeGapp
 private[java8] abstract class StepsLongLikeGapped[STL >: Null <: StepsLongLikeGapped[_]](_underlying: Array[AnyRef], _i0: Int, _iN: Int)
   extends AbstractStepsLikeGapped[LongStepper, STL](_underlying, _i0, _iN)
   with LongStepper 
-  with EfficientSubstep
 {}

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

@@ -6,7 +6,9 @@ import scala.compat.java8.collectionImpl._
 import Stepper._
 
 /** Abstracts all the generic operations of stepping over an indexable collection */
-private[java8] abstract class AbstractStepsLikeIndexed[Sub >: Null, Semi <: Sub](protected var i0: Int, protected var iN: Int) {
+private[java8] abstract class AbstractStepsLikeIndexed[Sub >: Null, Semi <: Sub](protected var i0: Int, protected var iN: Int)
+  extends EfficientSubstep {
+
   def semiclone(half: Int): Semi
   def characteristics(): Int = Ordered + Sized + SubSized
   def estimateSize(): Long = iN - i0
@@ -26,26 +28,22 @@ private[java8] abstract class AbstractStepsLikeIndexed[Sub >: Null, Semi <: Sub]
 private[java8] abstract class StepsLikeIndexed[A, STA >: Null <: StepsLikeIndexed[A, _]](_i0: Int, _iN: Int)
   extends AbstractStepsLikeIndexed[AnyStepper[A], STA](_i0, _iN)
   with AnyStepper[A]
-  with EfficientSubstep
 {}
 
 /** Abstracts the operation of stepping over an indexable collection of Doubles */
 private[java8] abstract class StepsDoubleLikeIndexed[STD >: Null <: StepsDoubleLikeIndexed[_]](_i0: Int, _iN: Int)
   extends AbstractStepsLikeIndexed[DoubleStepper, STD](_i0, _iN)
   with DoubleStepper
-  with EfficientSubstep
 {}
 
 /** Abstracts the operation of stepping over an indexable collection of Ints */
 private[java8] abstract class StepsIntLikeIndexed[STI >: Null <: StepsIntLikeIndexed[_]](_i0: Int, _iN: Int)
   extends AbstractStepsLikeIndexed[IntStepper, STI](_i0, _iN)
   with IntStepper
-  with EfficientSubstep
 {}
 
 /** Abstracts the operation of stepping over an indexable collection of Longs */
 private[java8] abstract class StepsLongLikeIndexed[STL >: Null <: StepsLongLikeIndexed[_]](_i0: Int, _iN: Int)
   extends AbstractStepsLikeIndexed[LongStepper, STL](_i0, _iN)
   with LongStepper
-  with EfficientSubstep
 {}

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

@@ -9,7 +9,9 @@ import Stepper._
   * `next` must update `i` but not `i0` so that later splitting steps can keep track of whether the
   * collection needs some sort of modification before transmission to the subclass.
   */
-private[java8] abstract class AbstractStepsLikeSliced[Coll, Sub >: Null, Semi <: Sub](protected var underlying: Coll, protected var i: Int, protected var iN: Int) {
+private[java8] abstract class AbstractStepsLikeSliced[Coll, Sub >: Null, Semi <: Sub](protected var underlying: Coll, protected var i: Int, protected var iN: Int)
+  extends EfficientSubstep {
+
   protected var i0: Int = i
   def semiclone(halfHint: Int): Semi  // Must really do all the work for both this and cloned collection!
   def characteristics(): Int = Ordered
@@ -21,26 +23,22 @@ private[java8] abstract class AbstractStepsLikeSliced[Coll, Sub >: Null, Semi <:
 private[java8] abstract class StepsLikeSliced[A, AA, STA >: Null <: StepsLikeSliced[A, AA, _]](_underlying: AA, _i0: Int, _iN: Int)
   extends AbstractStepsLikeSliced[AA, AnyStepper[A], STA](_underlying, _i0, _iN)
   with AnyStepper[A]
-  with EfficientSubstep
 {}
 
 /** Abstracts the operation of stepping over a collection of Doubles that can be efficiently sliced or otherwise subdivided */
 private[java8] abstract class StepsDoubleLikeSliced[AA, STA >: Null <: StepsDoubleLikeSliced[AA, STA]](_underlying: AA, _i0: Int, _iN: Int)
   extends AbstractStepsLikeSliced[AA, DoubleStepper, STA](_underlying, _i0, _iN)
   with DoubleStepper
-  with EfficientSubstep
 {}
 
 /** Abstracts the operation of stepping over a collection of Ints that can be efficiently sliced or otherwise subdivided */
 private[java8] abstract class StepsIntLikeSliced[AA, STA >: Null <: StepsIntLikeSliced[AA, STA]](_underlying: AA, _i0: Int, _iN: Int)
   extends AbstractStepsLikeSliced[AA, IntStepper, STA](_underlying, _i0, _iN)
   with IntStepper
-  with EfficientSubstep
 {}
 
 /** Abstracts the operation of stepping over a collection of Longs that can be efficiently sliced or otherwise subdivided */
 private[java8] abstract class StepsLongLikeSliced[AA, STA >: Null <: StepsLongLikeSliced[AA, STA]](_underlying: AA, _i0: Int, _iN: Int)
   extends AbstractStepsLikeSliced[AA, LongStepper, STA](_underlying, _i0, _iN)
   with LongStepper
-  with EfficientSubstep
 {}