I don't think it's intended to be legal to expose any instance before its
<init> method has been called.  In this case you are exposing the instance
before the super-class's <init> has been called, which is essentially the same
idea.  I can't find a /specific/ prohibition against it, but the general drift
of section 4.9.4 makes it pretty clear that it won't be tolerated.

I'm curious about why you are wanting to do this ?

Presumably because the verifier treats the value in local 0 as being of the
"special" type representing an uninitialised instance (as described in the same
section) until the call to the superclass's <init> method.  Hence the
assignment to the static field cannot satisfy the type checking if it occurs
before the super <init>.

BTW, and FWIW, the last but one opcode:

has no effect.

   -- chris

I just got the same error, but this time in code that was compiled by Sun's
javac tool.  I wrote a program to test some things about overriding classes
and methods, at the same time experimenting with 68000-style arithmetic.
The program is this:

public class TestMethod
{
public static void main(String[] args)
{
 System.out.println("(-1) + (-1) = " + new I32(-1).addX(new I32(-1)));
}
}
abstract class I
{
abstract I.X startCascade();
abstract I add(I a);
abstract I.X addX(I a);

static interface X
{
 byte getCarry();
 I stopCascade();
}
}
class I32 extends I
{
int i;
I32(int i) {
 this.i = i;
}
I.X startCascade() {
 return new X(i);
}
I32 add(I32 a) {
 return new I32(i + a.i);
}
I add(I a) {
 if (a instanceof I32)
  return add((I32)a);
 return null;
}
I32.X addX(I32 a) {
 long s = (long) this.i + a.i;
 return new I32.X((byte) (s >> 32), (int) s);
}
I.X addX(I a) {
 if (a instanceof I32)
  return addX((I32)a);
 return null;
}
public String toString() {
 return String.valueOf(i);
}

class X extends I32 implements I.X
{
 byte carry;
 X(byte c, int i) {
  super(i);
  carry = c;
 }
 X(int i) {
  this((byte) 0, i);
 }
 public byte getCarry() {
  return carry;
 }
 public I stopCascade() {
  return I32.this;
 }
 public String toString() {
  return String.valueOf((long) carry << 32 + i);
 }
}
}

As I said, javac compiles this without problems.  But when I try to run it,
the following is printed:

java.lang.VerifyError: (class: I32$X, method: <init> signature: (LI32;I)V)
Expecting to find object/array on stack
at I32.addX(TestMethod.java:39)
at TestMethod.main(TestMethod.java:5)
Exception in thread "main"

As expected, the compiler inserts a private final I32 this$0 field into
I32$X and prepends an I32 reference to the I32$X constructor argument list.
Also, nothing in the bytecode looks abnormal to me, after a first glance.
Nonetheless, the compiler should produce valid code, or an error message.

What is going on?