Add java25 samples from PMD

Author: adangel

java-regression-tests-1.0.0-SNAPSHOT.jar

@@ -7,7 +7,7 @@
     <packaging>jar</packaging>
 
     <properties>
-        <maven.compiler.release>22</maven.compiler.release>
+        <maven.compiler.release>25</maven.compiler.release>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <!-- fixing the build timestamp of the jar so that the jar file only changes, if content changes.
              the actual timestamp is irrelevant. -->

pom.xml

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: BSD-3-Clause
+package net.sourceforge.pmd.java.regression.tests.java25;
+
+import module java.base;
+import module java.desktop;
+
+import java.util.List;
+
+/**
+ * @see <a href="https://openjdk.org/jeps/511">JEP 511: Module Import Declarations</a> (Java 25)
+ */
+public class Jep511_ModuleImportDeclarations {
+    public static void main(String[] args) {
+        File f = new File(".");
+        List<File> myList = new ArrayList<>();
+        myList.add(f);
+        System.out.println("myList = " + myList);
+    }
+}

src/main/java/net/sourceforge/pmd/java/regression/tests/java25/Jep511_ModuleImportDeclarations.java

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: BSD-3-Clause
+
+// explicit imports are possible as well (although not really needed in this example)
+import java.util.Arrays;
+import java.util.stream.Collectors;
+
+import static java.lang.IO.println;
+
+/**
+ * @see <a href="https://openjdk.org/jeps/512">JEP 512: Compact Source Files and Instance Main Methods</a> (Java 25)
+ */
+
+// Top-level members are interpreted as members of the implicit class (methods and fields)
+String greetingField = "Hello, World! (Field)";
+String greeting() {
+    return "Hello, World! (Method)";
+}
+String greetingText2 = Arrays.asList("Hello", "World!", "(with imports)").stream().collect(Collectors.joining(", "));
+
+void main() {
+    System.out.println(greetingField);
+    IO.println(greeting()); // java.lang.IO.println via qualifier
+    println(greetingText2); // java.lang.IO.println via static import
+
+    // java.lang.IO.readln
+    String name = IO.readln("Please enter your name: ");
+    IO.print("Pleased to meet you, ");
+    println(name);
+
+    // java.util.List is automatically available via implicit "import module java.base"
+    var authors = List.of("James", "Bill", "Guy", "Alex", "Dan", "Gavin");
+    for (var authorName : authors) {
+        println(authorName + ": " + authorName.length());
+    }
+}

src/main/java/net/sourceforge/pmd/java/regression/tests/java25/Jep512_CompactSourceFilesAndInstanceMainMethodsAfterJava23.java

@@ -0,0 +1,97 @@
+// SPDX-License-Identifier: BSD-3-Clause
+package net.sourceforge.pmd.java.regression.tests.java25;
+
+import java.math.BigInteger;
+import java.security.cert.Certificate;
+import java.security.interfaces.DSAPublicKey;
+import java.security.interfaces.RSAKey;
+
+/**
+ * @see <a href="https://openjdk.org/jeps/513">JEP 513: Flexible Constructor Bodies</a> (Java 25)
+ */
+public class Jep513_FlexibleConstructorBodies {
+
+    // Example: Validating superclass constructor arguments
+    public class PositiveBigInteger extends BigInteger {
+        public PositiveBigInteger(long value) {
+            if (value <= 0) throw new IllegalArgumentException("value must be positive");
+            super(String.valueOf(value));
+        }
+    }
+
+    // Example: Preparing superclass constructor arguments
+    public class Super {
+        public Super(byte[] bytes) {}
+    }
+    public class Sub extends Super {
+        public Sub(Certificate certificate) {
+            var publicKey = certificate.getPublicKey();
+            if (publicKey == null) throw new NullPointerException();
+            byte[] certBytes = switch (publicKey) {
+                case RSAKey rsaKey -> rsaKey.getModulus().toByteArray();
+                case DSAPublicKey dsaKey -> dsaKey.getY().toByteArray();
+                default -> new byte[0];
+            };
+            super(certBytes);
+        }
+    }
+
+    // Example: Sharing superclass constructor arguments
+    public class C {
+        private final int i;
+        public C(int i) {
+            this.i = i;
+        }
+    }
+    public class Super2 {
+        private final C x;
+        private final C y;
+        public Super2(C x, C y) {
+            this.x = x;
+            this.y = y;
+        }
+    }
+    public class Sub2 extends Super2 {
+        public Sub2(int i) {
+            var x = new C(i);
+            super(x, x);
+        }
+    }
+
+    // Using enclosing instances in early construction contexts
+    class Outer {
+        int i;
+        void hello() { System.out.println("Hello"); }
+
+        class Inner {
+            int j;
+
+            Inner() {
+                var x = i;             // OK - implicitly refers to field of enclosing instance
+                var y = Outer.this.i;  // OK - explicitly refers to field of enclosing instance
+                hello();               // OK - implicitly refers to method of enclosing instance
+                Outer.this.hello();    // OK - explicitly refers to method of enclosing instance
+                super();
+            }
+        }
+    }
+
+    // Early assignment to fields
+    class Super3 {
+        Super3() { overriddenMethod(); }
+        void overriddenMethod() { System.out.println("hello"); }
+    }
+    class Sub3 extends Super3 {
+        final int x;
+
+        Sub3(int x) {
+            this.x = x;    // Initialize the field
+            super();       // Then invoke the Super constructor explicitly
+        }
+
+        @Override
+        void overriddenMethod() { System.out.println(x); }
+    }
+
+
+}