Too eager "super constructor cannot be passed a self reference"

[scabug]

The checking for self references being passed to (or being used in) super constructor calls is too eager:

scala> class Foo(f: Int => String)
defined class Foo

scala> object Bar extends Foo(i => Bar.baz(i)) { def baz(i: Int): String = "" }
<console>:8: error: super constructor cannot be passed a self reference unless parameter is declared by-name
       object Bar extends Foo(i => Bar.baz(i)) { def baz(i: Int): String = "" }

Ok, so let's use by-name parameters:

scala> class Foo(f: => Int)
defined class Foo

scala> object Bar extends Foo(Bar.i) { val i = 12 }
<console>:8: error: super constructor cannot be passed a self reference unless parameter is declared by-name
       object Bar extends Foo(Bar.i) { val i = 12 }

[scabug]

Imported From: https://issues.scala-lang.org/browse/SI-7666?orig=1
Reporter: @jrudolph
Affected Versions: 2.9.2, 2.10.2

[scabug]

@jrudolph said:
I think the original intention for adding this check was #473. However, I don't think the original fix for the VerifyError is the right one and with later additions it didn't get better.

The original failing code was this:

class Foo(x: Foo)
object Voop extends Foo(Voop)

is not required to end up in a VerifyError:

Here's a somewhat equivalent Java version which compiles but which shows "Called with null" when run, the expected and hard to avoid initialization problem:

class Foo {
  Foo(Foo outer) {
    System.out.println("Called with "+outer);
  }
}

class Voop extends Foo {
  static final Voop theInstance;
  static {
    theInstance = new Voop();
  }
  String i = "test";

  Voop() {
    super(Voop.theInstance);
  }
}

public class Test {

  public static void main(String[] args) {
    System.out.println(Voop.theInstance);
  }
}

IMO, the original fix should have been targeted at avoiding the VerifyError and nothing else.

Then, there still remains the initialization problem which you can also get now by circumventing the check with a simple added indirection:

class Foo(f: Foo) {
  println(f)
}

object Redirector {
  def voop = Voop
}

object Voop extends Foo(Redirector.voop)

object Test extends App {
  Voop
}

Catching those initialization errors then seems to be similar to catching all the other initialization problems (and similarly hard).