Add jep513 module: flexible constructor bodies on JDK 25 and 27

Runnable sources, broken examples and captured transcripts for the ankurm.com JEP 513 article, including the JDK 25 vs 27 compiler wording differences.

Co-Authored-By: Claude Sonnet 5 <[email protected]>
Claude-Session: https://claude.ai/code/session_01TF9JWFvJSNm6HVzswzZU5a

jep513/broken/AssignFieldWithInitializer.java

@@ -0,0 +1,8 @@
+class Parent { Parent() {} }
+class AssignFieldWithInitializer extends Parent {
+    int size = 10;            // has an initializer, which runs AFTER super()
+    AssignFieldWithInitializer() {
+        this.size = 20;       // assignment in the prologue
+        super();
+    }
+}

jep513/broken/AssignInheritedField.java

@@ -0,0 +1,7 @@
+class Parent { int shared; Parent() {} }
+class AssignInheritedField extends Parent {
+    AssignInheritedField() {
+        this.shared = 7;      // a field the SUPERCLASS declares
+        super();
+    }
+}

jep513/broken/CallMethodBeforeSuper.java

@@ -0,0 +1,8 @@
+class Parent { Parent(int x) {} }
+class CallMethodBeforeSuper extends Parent {
+    int compute() { return 42; }
+    CallMethodBeforeSuper() {
+        int v = compute();    // instance method call before super()
+        super(v);
+    }
+}

jep513/broken/InnerOuterThis.java

@@ -0,0 +1,7 @@
+class Base { Base(Runnable r) {} }
+class InnerOuterThis extends Base {
+    int x = 3;
+    InnerOuterThis() {
+        super(() -> IO.println(x));   // lambda capturing this.x inside the super(...) arguments
+    }
+}

jep513/broken/NewInnerBeforeSuper.java

@@ -0,0 +1,8 @@
+class Parent { Parent(Object o) {} }
+class NewInnerBeforeSuper extends Parent {
+    class Inner {}
+    NewInnerBeforeSuper() {
+        Inner i = new Inner();   // an inner class instance needs an enclosing this
+        super(i);
+    }
+}

jep513/broken/OnJdk21.java

@@ -0,0 +1,14 @@
+// Written with System.out so that JDK 21 can compile it: the ONLY thing wrong with it on 21 is the statement before super(...).
+public class OnJdk21 {
+    static class Person { Person(String n) {} }
+    static class Employee extends Person {
+        Employee(String name, int salary) {
+            if (salary < 0) throw new IllegalArgumentException("negative");
+            super(name.strip());
+        }
+    }
+    public static void main(String[] args) {
+        new Employee(" a ", 1);
+        System.out.println("constructed");
+    }
+}

jep513/broken/PassThisBeforeSuper.java

@@ -0,0 +1,7 @@
+class Parent { Parent(Object o) {} }
+class PassThisBeforeSuper extends Parent {
+    PassThisBeforeSuper() {
+        Object self = this;   // 'this' escapes before super()
+        super(self);
+    }
+}

jep513/broken/ReadFieldBeforeSuper.java

@@ -0,0 +1,8 @@
+class Parent { Parent(int x) {} }
+class ReadFieldBeforeSuper extends Parent {
+    int size = 10;
+    ReadFieldBeforeSuper() {
+        int copy = size;      // reads this.size before super()
+        super(copy);
+    }
+}

jep513/broken/ReadFinalBeforeAssign.java

@@ -0,0 +1,9 @@
+class Parent { Parent() {} }
+class ReadFinalBeforeAssign extends Parent {
+    final String label;
+    ReadFinalBeforeAssign(String s) {
+        String t = this.label;   // reading a field, even a final one, in the prologue
+        this.label = s;
+        super();
+    }
+}

jep513/broken/ReturnBeforeSuper.java

@@ -0,0 +1,7 @@
+class Parent { Parent(int x) {} }
+class ReturnBeforeSuper extends Parent {
+    ReturnBeforeSuper(int x) {
+        if (x < 0) return;    // cannot return before the super call has completed
+        super(x);
+    }
+}

jep513/broken/SuperInBranch.java

@@ -0,0 +1,6 @@
+class Parent { Parent(int x) {} }
+class SuperInBranch extends Parent {
+    SuperInBranch(boolean big) {
+        if (big) super(100); else super(1);   // super(...) must appear once, at top level of the constructor body
+    }
+}

jep513/broken/TwoSuperCalls.java

@@ -0,0 +1,7 @@
+class Parent { Parent(int x) {} Parent() {} }
+class TwoSuperCalls extends Parent {
+    TwoSuperCalls() {
+        super(1);
+        super();              // a second explicit constructor call
+    }
+}