Initialization checker doesn't catch uninitialized object call

[smarter]

When running the following code with -Ycheck-init, no warning or error is emitted:

class Foo(val opposite: Foo)
case object A extends Foo(B)
case object B extends Foo(A)
object Test {
  def main(args: Array[String]): Unit = {
    println(A.opposite)
    println(B.opposite)
  }
}

But A ends being used when it's uninitialized:

B
null

I'm not sure if this is a bug or outside the scope of safe initialization?

[liufengyun]

Generally, static fields are out of the scope of the checker, as that would require global analysis. However, in this special case, there is room to improve the checker, if it treats the compilation unit as inside a class.

For example, if we wrap the code in a class, the checker will be able to detect initialization problems:

class CompilationUnit {
  class Foo(val opposite: Foo)
  case object A extends Foo(B)
  case object B extends Foo(A)
  A
}

Given the code above, the code new CompilationUnit will run forever, thus it's correct for the checker to not issue any warning. There are several possible enhancement:

• treats the compilation unit as inside a class
• check possible non-termination in the initialization of lazy fields

Another subtle issue is with the following code: accessing CompilationUnit will not run forever,
and an uninitialized field is accessed.

object CompilationUnit {
  class Foo(val opposite: Foo)
  case object A extends Foo(B)
  case object B extends Foo(A)
  A
}

I think it will be more consistent to make the initialization behavior of object CompilationUnit and class CompilationUnit consistent in language semantics and compiler implementation.