Make Stepper capture checked

Author: odersky

tests/pos-special/stdlib/collection/Stepper.scala

@@ -15,6 +15,7 @@ package scala.collection
 import java.util.function.{Consumer, DoubleConsumer, IntConsumer, LongConsumer}
 import java.util.{PrimitiveIterator, Spliterator, Iterator => JIterator}
 import java.{lang => jl}
+import language.experimental.captureChecking
 
 import scala.collection.Stepper.EfficientSplit
 
@@ -38,6 +39,8 @@ import scala.collection.Stepper.EfficientSplit
  * @tparam A the element type of the Stepper
  */
 trait Stepper[@specialized(Double, Int, Long) +A] {
+ this: Stepper[A]^ =>
+
  /** Check if there's an element available. */
  def hasStep: Boolean
 
@@ -183,9 +186,11 @@ object Stepper {
 
 /** A Stepper for arbitrary element types. See [[Stepper]]. */
 trait AnyStepper[+A] extends Stepper[A] {
+ this: AnyStepper[A]^ =>
+
  def trySplit(): AnyStepper[A]
 
- def spliterator[B >: A]: Spliterator[B] = new AnyStepper.AnyStepperSpliterator(this)
+ def spliterator[B >: A]: Spliterator[B]^{this} = new AnyStepper.AnyStepperSpliterator(this)
 
  def javaIterator[B >: A]: JIterator[B] = new JIterator[B] {
  def hasNext: Boolean = hasStep
@@ -194,10 +199,10 @@ trait AnyStepper[+A] extends Stepper[A] {
 }
 
 object AnyStepper {
- class AnyStepperSpliterator[A](s: AnyStepper[A]) extends Spliterator[A] {
+ class AnyStepperSpliterator[A](s: AnyStepper[A]^) extends Spliterator[A] {
  def tryAdvance(c: Consumer[_ >: A]): Boolean =
  if (s.hasStep) { c.accept(s.nextStep()); true } else false
- def trySplit(): Spliterator[A] = {
+ def trySplit(): Spliterator[A]^{this} = {
  val sp = s.trySplit()
  if (sp == null) null else sp.spliterator
  }
@@ -253,17 +258,19 @@ object AnyStepper {
 
 /** A Stepper for Ints. See [[Stepper]]. */
 trait IntStepper extends Stepper[Int] {
+ this: IntStepper^ =>
+
  def trySplit(): IntStepper
 
- def spliterator[B >: Int]: Spliterator.OfInt = new IntStepper.IntStepperSpliterator(this)
+ def spliterator[B >: Int]: Spliterator.OfInt^{this} = new IntStepper.IntStepperSpliterator(this)
 
  def javaIterator[B >: Int]: PrimitiveIterator.OfInt = new PrimitiveIterator.OfInt {
  def hasNext: Boolean = hasStep
  def nextInt(): Int = nextStep()
  }
 }
 object IntStepper {
- class IntStepperSpliterator(s: IntStepper) extends Spliterator.OfInt {
+ class IntStepperSpliterator(s: IntStepper^) extends Spliterator.OfInt {
  def tryAdvance(c: IntConsumer): Boolean =
  if (s.hasStep) { c.accept(s.nextStep()); true } else false
  // Override for efficiency: don't wrap the function and call the `tryAdvance` overload
@@ -272,7 +279,7 @@ object IntStepper {
  case _ => if (s.hasStep) { c.accept(jl.Integer.valueOf(s.nextStep())); true } else false
  }
  // override required for dotty#6152
- override def trySplit(): Spliterator.OfInt = {
+ override def trySplit(): Spliterator.OfInt^{this} = {
  val sp = s.trySplit()
  if (sp == null) null else sp.spliterator
  }
@@ -291,18 +298,19 @@ object IntStepper {
 
 /** A Stepper for Doubles. See [[Stepper]]. */
 trait DoubleStepper extends Stepper[Double] {
+ this: DoubleStepper^ =>
  def trySplit(): DoubleStepper
 
- def spliterator[B >: Double]: Spliterator.OfDouble = new DoubleStepper.DoubleStepperSpliterator(this)
+ def spliterator[B >: Double]: Spliterator.OfDouble^{this} = new DoubleStepper.DoubleStepperSpliterator(this)
 
- def javaIterator[B >: Double]: PrimitiveIterator.OfDouble = new PrimitiveIterator.OfDouble {
+ def javaIterator[B >: Double]: PrimitiveIterator.OfDouble^{this} = new PrimitiveIterator.OfDouble {
  def hasNext: Boolean = hasStep
  def nextDouble(): Double = nextStep()
  }
 }
 
 object DoubleStepper {
- class DoubleStepperSpliterator(s: DoubleStepper) extends Spliterator.OfDouble {
+ class DoubleStepperSpliterator(s: DoubleStepper^) extends Spliterator.OfDouble {
  def tryAdvance(c: DoubleConsumer): Boolean =
  if (s.hasStep) { c.accept(s.nextStep()); true } else false
  // Override for efficiency: don't wrap the function and call the `tryAdvance` overload
@@ -311,7 +319,7 @@ object DoubleStepper {
  case _ => if (s.hasStep) { c.accept(java.lang.Double.valueOf(s.nextStep())); true } else false
  }
  // override required for dotty#6152
- override def trySplit(): Spliterator.OfDouble = {
+ override def trySplit(): Spliterator.OfDouble^{this} = {
  val sp = s.trySplit()
  if (sp == null) null else sp.spliterator
  }
@@ -330,18 +338,20 @@ object DoubleStepper {
 
 /** A Stepper for Longs. See [[Stepper]]. */
 trait LongStepper extends Stepper[Long] {
- def trySplit(): LongStepper
+ this: LongStepper^ =>
+
+ def trySplit(): LongStepper^{this}
 
- def spliterator[B >: Long]: Spliterator.OfLong = new LongStepper.LongStepperSpliterator(this)
+ def spliterator[B >: Long]: Spliterator.OfLong^{this} = new LongStepper.LongStepperSpliterator(this)
 
- def javaIterator[B >: Long]: PrimitiveIterator.OfLong = new PrimitiveIterator.OfLong {
+ def javaIterator[B >: Long]: PrimitiveIterator.OfLong^{this} = new PrimitiveIterator.OfLong {
  def hasNext: Boolean = hasStep
  def nextLong(): Long = nextStep()
  }
 }
 
 object LongStepper {
- class LongStepperSpliterator(s: LongStepper) extends Spliterator.OfLong {
+ class LongStepperSpliterator(s: LongStepper^) extends Spliterator.OfLong {
  def tryAdvance(c: LongConsumer): Boolean =
  if (s.hasStep) { c.accept(s.nextStep()); true } else false
  // Override for efficiency: don't wrap the function and call the `tryAdvance` overload
@@ -350,7 +360,7 @@ object LongStepper {
  case _ => if (s.hasStep) { c.accept(java.lang.Long.valueOf(s.nextStep())); true } else false
  }
  // override required for dotty#6152
- override def trySplit(): Spliterator.OfLong = {
+ override def trySplit(): Spliterator.OfLong^{this} = {
  val sp = s.trySplit()
  if (sp == null) null else sp.spliterator
  }

tests/pos-special/stdlib/collection/StepperShape.scala

@@ -0,0 +1,115 @@
+/*
+ * Scala (https://www.scala-lang.org)
+ *
+ * Copyright EPFL and Lightbend, Inc.
+ *
+ * Licensed under Apache License 2.0
+ * (http://www.apache.org/licenses/LICENSE-2.0).
+ *
+ * See the NOTICE file distributed with this work for
+ * additional information regarding copyright ownership.
+ */
+
+package scala.collection
+
+import java.{lang => jl}
+
+import language.experimental.captureChecking
+import scala.collection.Stepper.EfficientSplit
+
+/** An implicit StepperShape instance is used in the [[IterableOnce.stepper]] to return a possibly
+ * specialized Stepper `S` according to the element type `T`.
+ */
+sealed trait StepperShape[-T, S <: Stepper[_]^] extends Pure {
+ /** Return the Int constant (as defined in the `StepperShape` companion object) for this `StepperShape`. */
+ def shape: StepperShape.Shape
+
+ /** Create an unboxing primitive sequential Stepper from a boxed `AnyStepper`.
+ * This is an identity operation for reference shapes. */
+ def seqUnbox(st: AnyStepper[T]): S
+
+ /** Create an unboxing primitive parallel (i.e. `with EfficientSplit`) Stepper from a boxed `AnyStepper`.
+ * This is an identity operation for reference shapes. */
+ def parUnbox(st: AnyStepper[T] with EfficientSplit): S with EfficientSplit
+}
+
+object StepperShape extends StepperShapeLowPriority1 {
+ class Shape private[StepperShape] (private val s: Int) extends AnyVal
+
+ // reference
+ val ReferenceShape = new Shape(0)
+
+ // primitive
+ val IntShape = new Shape(1)
+ val LongShape = new Shape(2)
+ val DoubleShape = new Shape(3)
+
+ // widening
+ val ByteShape = new Shape(4)
+ val ShortShape = new Shape(5)
+ val CharShape = new Shape(6)
+ val FloatShape = new Shape(7)
+
+ implicit val intStepperShape: StepperShape[Int, IntStepper] = new StepperShape[Int, IntStepper] {
+ def shape = IntShape
+ def seqUnbox(st: AnyStepper[Int]): IntStepper = new Stepper.UnboxingIntStepper(st)
+ def parUnbox(st: AnyStepper[Int] with EfficientSplit): IntStepper with EfficientSplit = new Stepper.UnboxingIntStepper(st) with EfficientSplit
+ }
+ implicit val jIntegerStepperShape: StepperShape[jl.Integer, IntStepper] = intStepperShape.asInstanceOf[StepperShape[jl.Integer, IntStepper]]
+
+ implicit val longStepperShape: StepperShape[Long, LongStepper] = new StepperShape[Long, LongStepper] {
+ def shape = LongShape
+ def seqUnbox(st: AnyStepper[Long]): LongStepper = new Stepper.UnboxingLongStepper(st)
+ def parUnbox(st: AnyStepper[Long] with EfficientSplit): LongStepper with EfficientSplit = new Stepper.UnboxingLongStepper(st) with EfficientSplit
+ }
+ implicit val jLongStepperShape: StepperShape[jl.Long, LongStepper] = longStepperShape.asInstanceOf[StepperShape[jl.Long, LongStepper]]
+
+ implicit val doubleStepperShape: StepperShape[Double, DoubleStepper] = new StepperShape[Double, DoubleStepper] {
+ def shape = DoubleShape
+ def seqUnbox(st: AnyStepper[Double]): DoubleStepper = new Stepper.UnboxingDoubleStepper(st)
+ def parUnbox(st: AnyStepper[Double] with EfficientSplit): DoubleStepper with EfficientSplit = new Stepper.UnboxingDoubleStepper(st) with EfficientSplit
+ }
+ implicit val jDoubleStepperShape: StepperShape[jl.Double, DoubleStepper] = doubleStepperShape.asInstanceOf[StepperShape[jl.Double, DoubleStepper]]
+
+ implicit val byteStepperShape: StepperShape[Byte, IntStepper] = new StepperShape[Byte, IntStepper] {
+ def shape = ByteShape
+ def seqUnbox(st: AnyStepper[Byte]): IntStepper = new Stepper.UnboxingByteStepper(st)
+ def parUnbox(st: AnyStepper[Byte] with EfficientSplit): IntStepper with EfficientSplit = new Stepper.UnboxingByteStepper(st) with EfficientSplit
+ }
+ implicit val jByteStepperShape: StepperShape[jl.Byte, IntStepper] = byteStepperShape.asInstanceOf[StepperShape[jl.Byte, IntStepper]]
+
+ implicit val shortStepperShape: StepperShape[Short, IntStepper] = new StepperShape[Short, IntStepper] {
+ def shape = ShortShape
+ def seqUnbox(st: AnyStepper[Short]): IntStepper = new Stepper.UnboxingShortStepper(st)
+ def parUnbox(st: AnyStepper[Short] with EfficientSplit): IntStepper with EfficientSplit = new Stepper.UnboxingShortStepper(st) with EfficientSplit
+ }
+ implicit val jShortStepperShape: StepperShape[jl.Short, IntStepper] = shortStepperShape.asInstanceOf[StepperShape[jl.Short, IntStepper]]
+
+ implicit val charStepperShape: StepperShape[Char, IntStepper] = new StepperShape[Char, IntStepper] {
+ def shape = CharShape
+ def seqUnbox(st: AnyStepper[Char]): IntStepper = new Stepper.UnboxingCharStepper(st)
+ def parUnbox(st: AnyStepper[Char] with EfficientSplit): IntStepper with EfficientSplit = new Stepper.UnboxingCharStepper(st) with EfficientSplit
+ }
+ implicit val jCharacterStepperShape: StepperShape[jl.Character, IntStepper] = charStepperShape.asInstanceOf[StepperShape[jl.Character, IntStepper]]
+
+ implicit val floatStepperShape: StepperShape[Float, DoubleStepper] = new StepperShape[Float, DoubleStepper] {
+ def shape = FloatShape
+ def seqUnbox(st: AnyStepper[Float]): DoubleStepper = new Stepper.UnboxingFloatStepper(st)
+ def parUnbox(st: AnyStepper[Float] with EfficientSplit): DoubleStepper with EfficientSplit = new Stepper.UnboxingFloatStepper(st) with EfficientSplit
+ }
+ implicit val jFloatStepperShape: StepperShape[jl.Float, DoubleStepper] = floatStepperShape.asInstanceOf[StepperShape[jl.Float, DoubleStepper]]
+}
+
+trait StepperShapeLowPriority1 extends StepperShapeLowPriority2 {
+ implicit def anyStepperShape[T]: StepperShape[T, AnyStepper[T]] = anyStepperShapePrototype.asInstanceOf[StepperShape[T, AnyStepper[T]]]
+}
+
+trait StepperShapeLowPriority2 {
+ implicit def baseStepperShape[T]: StepperShape[T, Stepper[T]] = anyStepperShapePrototype.asInstanceOf[StepperShape[T, Stepper[T]]]
+
+ protected val anyStepperShapePrototype: StepperShape[AnyRef, Stepper[AnyRef]] = new StepperShape[AnyRef, Stepper[AnyRef]] {
+ def shape = StepperShape.ReferenceShape
+ def seqUnbox(st: AnyStepper[AnyRef]): Stepper[AnyRef] = st
+ def parUnbox(st: AnyStepper[AnyRef] with EfficientSplit): Stepper[AnyRef] with EfficientSplit = st
+ }
+}