在scala Intellij工作表中彼此依赖的两个val的初始化？

Question

The results below are ALL within Intellij IDEA Scala Worksheet but standard scala REPL seems consistent therefore this might due to the wrapping of the worksheet .

There is a puzzle here on scala puzzlers site.

object XY {
  object X {
    val value: Int = Y.value + 1
  }
  object Y {
    val value: Int = X.value + 1
  }
}

println(if (math.random > 0.5) XY.X.value else XY.Y.value)

The mentioned correct answer is 2 (for scala 2.10.0?). However inside Intellij worksheet (scala 2.11.7) it emits a stackoverflowError.

Also, as mentioned in the spec

The object definition defines a single object (or: module) conforming to the template tt. It is roughly equivalent to the following definition of a lazy value

Indeed below would also give a stackoverflowError.

lazy val x: Int = y + 1
lazy val y: Int = x + 1

---

Here are a few other observations.

Case 1

object XXX {
  val x: Int = y + 1
  lazy val y: Int = x + 1
}
s"XXX x=${XXX.x} y=${XXX.y}"
// XXX x=2 y=1

Case 2

val x: Int = y + 1
s"plain x=$x"
lazy val y: Int = x + 1
s"plain y=$y"
// stackoverflowError

Case 3

object XXX {
  val x: Int = y + 1
  lazy val y: Int = x + 1
}
s"XXX x=${XXX.x} y=${XXX.y}"

val x: Int = y + 1
s"plain x=$x"
lazy val y: Int = x + 1
s"plain y=$y"
//  XXX x=2 y=1
// NO output any longer for subsequent scripts

Is it a known Intellij scala plugin bug?

Answer 1

On Scala 2.11.8 I get no error, I'm going to guess this is related to something else in your setup. The link you gave gives a pretty good explanation why this works - it basically boils down to JVM initialization magic, specifically:

The VM takes notice that the initialization of object X is already running and returns the current value of X.value which is zero (the default value for Int fields), so no stack overflow at runtime.

Yet there is no reason for this magic to also apply to

lazy val x: Int = y + 1
lazy val y: Int = x + 1

which rightly is a stack overflow.

Case 1

Here there are no surprises - this is just the usual case of the default value of fields being 0 before initialization. During the initialization of x (which happens first), the initialization of y is triggered and it uses the current value of x (which defaults to 0 since x hasn't been initialized yet) and calculates y = 0 + 1 = 1 . Then, we return to initializing x , and calculate x = 1 + 1 = 2 .

Case 2

This is a bit ugly because this code needs to be inside of something to compile (an object, a class, a function, a method, SOMETHING!). Inside a class or an object, the reasoning above applies (and this is what happens in the Scala REPL since it basically just runs bare code inside of objects).

On the other hand, if you put this in a function or method it shouldn't compile at all, since you have a forward reference. It should fail with something like:

error: forward reference extends over definition of value x
   val x: Int = y + 1
                ^

I'd say Intellij IDEA Scala Worksheet is not handling this properly.

Case 3

I can't say anything about this. I've covered the expected Scala outputs for this in the previous cases - this all depends on how the code is being wrapped (in an object/class or method/function). Again, Intellij IDEA Scala Worksheet seems to not be working.