Turn wrappers into value classes and make them final

Author: szeiger

src/main/scala/scala/compat/java8/PrimitiveIteratorConversions.scala

@@ -96,13 +96,13 @@ object PrimitiveIteratorConverters {
   }
 
   /** Provides conversions from Java `Iterator` to manually specialized `PrimitiveIterator` variants, when available */
-  implicit class RichJavaIteratorToPrimitives[A](val underlying: JIterator[A]) extends AnyVal {
+  implicit final class RichJavaIteratorToPrimitives[A](private val underlying: JIterator[A]) extends AnyVal {
     /** Wraps this `java.util.Iterator` as a manually specialized variant, if possible */
     def asPrimitive[That](implicit specOp: SpecializerOfIterators[A, That]): That = specOp.fromJava(underlying)
   }
 
   /** Provides conversions from Scala `Iterator` to manually specialized `PrimitiveIterator` variants, when available */
-  implicit class RichIteratorToPrimitives[A](val underlying: Iterator[A]) extends AnyVal {
+  implicit final class RichIteratorToPrimitives[A](private val underlying: Iterator[A]) extends AnyVal {
     /** Wraps this `scala.collection.Iterator` as a manually specialized `java.util.PrimitiveIterator` variant, if possible */
     def asPrimitive[That](implicit specOp: SpecializerOfIterators[A, That]): That = specOp.fromScala(underlying)
   }

src/main/scala/scala/compat/java8/SpliteratorConverters.scala

@@ -17,13 +17,13 @@ package SpliteratorConverters {
 
 
 package object SpliteratorConverters extends SpliteratorConverters.Priority2SpliteratorConverters {
-  implicit class SpliteratorOfDoubleToStepper(private val underlying: Spliterator.OfDouble) extends AnyVal {
+  implicit final class SpliteratorOfDoubleToStepper(private val underlying: Spliterator.OfDouble) extends AnyVal {
     def stepper: DoubleStepper = Stepper.ofSpliterator(underlying)
   }
-  implicit class SpliteratorOfIntToStepper(private val underlying: Spliterator.OfInt) extends AnyVal {
+  implicit final class SpliteratorOfIntToStepper(private val underlying: Spliterator.OfInt) extends AnyVal {
     def stepper: IntStepper = Stepper.ofSpliterator(underlying)
   }
-  implicit class SpliteratorOfLongToStepper(private val underlying: Spliterator.OfLong) extends AnyVal {
+  implicit final class SpliteratorOfLongToStepper(private val underlying: Spliterator.OfLong) extends AnyVal {
     def stepper: LongStepper = Stepper.ofSpliterator(underlying)
   }
 }

src/main/scala/scala/compat/java8/StreamConverters.scala

@@ -208,25 +208,25 @@ extends Priority1StreamConverters
 with converterImpl.Priority1StepConverters
 with converterImpl.Priority1AccumulatorConverters
 {
-  implicit class EnrichDoubleArrayWithStream(a: Array[Double])   
-  extends MakesSequentialStream[java.lang.Double, DoubleStream] with MakesParallelStream[java.lang.Double, DoubleStream] {
+  implicit final class EnrichDoubleArrayWithStream(private val a: Array[Double])
+  extends AnyVal with MakesSequentialStream[java.lang.Double, DoubleStream] with MakesParallelStream[java.lang.Double, DoubleStream] {
     def seqStream: DoubleStream = java.util.Arrays.stream(a)
     def parStream: DoubleStream = seqStream.parallel
   }
 
-  implicit class EnrichIntArrayWithStream(a: Array[Int])   
-  extends MakesSequentialStream[java.lang.Integer, IntStream] with MakesParallelStream[java.lang.Integer, IntStream] {
+  implicit final class EnrichIntArrayWithStream(private val a: Array[Int])
+  extends AnyVal with MakesSequentialStream[java.lang.Integer, IntStream] with MakesParallelStream[java.lang.Integer, IntStream] {
     def seqStream: IntStream = java.util.Arrays.stream(a)
     def parStream: IntStream = seqStream.parallel
   }
 
-  implicit class EnrichLongArrayWithStream(a: Array[Long])   
-  extends MakesSequentialStream[java.lang.Long, LongStream] with MakesParallelStream[java.lang.Long, LongStream] {
+  implicit final class EnrichLongArrayWithStream(private val a: Array[Long])
+  extends AnyVal with MakesSequentialStream[java.lang.Long, LongStream] with MakesParallelStream[java.lang.Long, LongStream] {
     def seqStream: LongStream = java.util.Arrays.stream(a)
     def parStream: LongStream = seqStream.parallel
   }
 
-  implicit val primitiveAccumulateDoubleStream = new PrimitiveStreamAccumulator[Stream[Double], DoubleAccumulator] { 
+  implicit val primitiveAccumulateDoubleStream = new PrimitiveStreamAccumulator[Stream[Double], DoubleAccumulator] {
     def streamAccumulate(stream: Stream[Double]): DoubleAccumulator = 
       stream.collect(DoubleAccumulator.supplier, DoubleAccumulator.boxedAdder, DoubleAccumulator.merger)
   }
@@ -274,7 +274,7 @@ with converterImpl.Priority1AccumulatorConverters
   implicit val primitiveUnboxLongStream2 =
     primitiveUnboxLongStream.asInstanceOf[PrimitiveStreamUnboxer[java.lang.Long, LongStream]]
 
-  implicit class RichDoubleStream(stream: DoubleStream) {
+  implicit final class RichDoubleStream(private val stream: DoubleStream) extends AnyVal {
     def accumulate = stream.collect(DoubleAccumulator.supplier, DoubleAccumulator.adder, DoubleAccumulator.merger)
 
     def toScala[Coll[_]](implicit cbf: collection.generic.CanBuildFrom[Nothing, Double, Coll[Double]]): Coll[Double] = {
@@ -287,7 +287,7 @@ with converterImpl.Priority1AccumulatorConverters
     }
   }
 
-  implicit class RichIntStream(stream: IntStream) {
+  implicit final class RichIntStream(private val stream: IntStream) extends AnyVal {
     def accumulate = stream.collect(IntAccumulator.supplier, IntAccumulator.adder, IntAccumulator.merger)
 
     def toScala[Coll[_]](implicit cbf: collection.generic.CanBuildFrom[Nothing, Int, Coll[Int]]): Coll[Int] = {
@@ -300,7 +300,7 @@ with converterImpl.Priority1AccumulatorConverters
     }
   }
 
-  implicit class RichLongStream(stream: LongStream) {
+  implicit final class RichLongStream(private val stream: LongStream) extends AnyVal {
     def accumulate = stream.collect(LongAccumulator.supplier, LongAccumulator.adder, LongAccumulator.merger)
 
     def toScala[Coll[_]](implicit cbf: collection.generic.CanBuildFrom[Nothing, Long, Coll[Long]]): Coll[Long] = {