Wildcard capture goes wrong on nested wildcard

[scabug]

This should not compile; it should not be able to infer a T when calling onestep. We use that to throw a ClassCastException.

package forsomescope2

trait Magic[S] {
  def init: S
  def step(s: S): String
}

object Main extends App {
  def onestep[T](m: => Magic[T]) =
    m.step(m.init)

  def flip: () => Magic[_] = {
    var z = false
    () => {
      z = !z
      if (z) new Magic[Int] {
        def init = 0
        def step(s: Int) = (s - 1).toString
      } else new Magic[String] {
        def init = "hi"
        def step(s: String) = s.reverse
      }
    }
  }

  def boom = {
    val flipper = flip
    onestep(flipper())
  }
  boom
}

(scastie here) throws

java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Integer
	at scala.runtime.BoxesRunTime.unboxToInt(BoxesRunTime.java:101)
	at forsomescope2.Main$$anon$1.step(ForsomeScope.scala:16)
	at forsomescope2.Main$.onestep(ForsomeScope.scala:10)
	at forsomescope2.Main$.boom(ForsomeScope.scala:28)
	at forsomescope2.Main$.delayedEndpoint$forsomescope2$Main$1(ForsomeScope.scala:30)
	at forsomescope2.Main$delayedInit$body.apply(ForsomeScope.scala:8)

This doesn't apply to the Magic variant from #9410, except if you do the intermediate introduction of forSome, which is already introduced here.

[scabug]

Imported From: https://issues.scala-lang.org/browse/SI-9419?orig=1
Reporter: Stephen Compall (s11001001)
Affected Versions: 2.10.5, 2.11.7
See #9410

[dwijnand]

Still broken in Scala 3.

[SethTisue]

context: https://typelevel.org/blog/2015/07/30/values-never-change-types.html

[SethTisue]

Dale and I noticed that it isn't crucial to have an actual byname; you can change the reproducer to use () => Magic[T] instead of => Magic[T] and it still breaks in the same way.

(Regardless, we should test any proposed fix on both variants.)

[SethTisue]

I'm partial to this minimization (in Scala 3 syntax):

trait Magic[S]:
  def init: S
  def step(s: S): String

object IntMagic extends Magic[Int]:
  def init = 0
  def step(s: Int): String = (s - 1).toString

object StrMagic extends Magic[String]:
  def init = "hi"
  def step(s: String): String = s.reverse

object Main:
  def onestep[T](m: () => Magic[T]): String = m().step(m().init)
  val iter: Iterator[Magic[?]] = Iterator(IntMagic, StrMagic)
  def main(args: Array[String]): Unit =
    onestep(() => iter.next())

it's not fundamentally different. Just a bit easier to grasp, perhaps.

Magic is invariant and has methods with S in both covariant and contravariant positions, as is common when we want a runtime demonstration of compile-time unsoundness.

onestep(() => iter.next()) should not compile, as there no correct instantiation for T. (Recall that Iterator[Magic[?]] means Iterator[Magic[T] forSome { type T }], not Iterator[Magic[T]] forSome { type T }.)