Read Spoon compliance level from the project's pom.xml (#352)

## Problem
`CommandLineLauncher` sets Spoon's compliance level to 8, so any Java 9+
syntax fails to compile and LiquidJava verifies a broken model with only
a generic warning ("Java compilation encountered issues"). E.g. `var n =
5;` is read as a variable of class `testSuite.var` (`Sorts testSuite.var
and Int are incompatible`), and `try (r)` (Java 9 resource reference)
does not parse, which blocks the second reproducer of #334.

## Change
- New `ComplianceLevel` reads the level from the
`maven.compiler.release` (or `maven.compiler.source`) property of the
nearest `pom.xml` of each verified path, walking up to enclosing poms,
using the existing `maven-model` dependency. `1.8` is read as `8`; with
several paths the highest level wins.
- Defaults to **19** when no pom declares it, and caps at **19**: the
highest level Spoon 10.4.2's JDT (3.33) accepts (`20` throws
`Unrecognized option : -20`). The cap is silent (the level is printed
with `--debug`), since e.g. `liquidjava-example` declares 20 and a
warning would show up on every run.
- New test `CorrectModernJavaSyntax` (`var`, `try (r)`, switch
expression): fails at level 8, passes now.
- Unit tests `TestComplianceLevel` (reads the pom, caps).

Not read (falls back to 19): the compiler plugin's
`<release>`/`<source>` config, parents outside the enclosing
directories, Gradle builds. Upgrading to Spoon 11.5 (levels up to 26) is
in #363.

## Testing
`mvn test`: 369/369 pass.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

Author: CatarinaGamboa

liquidjava-example/src/main/java/testSuite/CorrectModernJavaSyntax.java

@@ -0,0 +1,32 @@
+package testSuite;
+
+import java.io.StringReader;
+
+import liquidjava.specification.Refinement;
+
+@SuppressWarnings("unused")
+public class CorrectModernJavaSyntax {
+
+    // local variable type inference (Java 10)
+    void localVar() {
+        var n = 5;
+        @Refinement("_ > 0")
+        int p = n;
+    }
+
+    // resource reference in try-with-resources (Java 9)
+    void resourceReference() throws Exception {
+        StringReader reader = new StringReader("a");
+        try (reader) {
+            reader.read();
+        }
+    }
+
+    // switch expression (Java 14)
+    int switchExpression(int k) {
+        return switch (k) {
+            case 0 -> 1;
+            default -> 2;
+        };
+    }
+}

liquidjava-verifier/src/main/java/liquidjava/api/CommandLineLauncher.java

@@ -3,6 +3,7 @@
 import java.io.File;
 import java.util.Arrays;
 
+import liquidjava.diagnostics.DebugLog;
 import liquidjava.diagnostics.Diagnostics;
 import liquidjava.diagnostics.errors.CustomError;
 import liquidjava.diagnostics.warnings.CustomWarning;
@@ -70,7 +71,10 @@ public static void launch(String... paths) {
         env.setSourceClasspath(
                 new String[] { new File(Refinement.class.getProtectionDomain().getCodeSource().getLocation().getFile())
                         .getAbsolutePath() });
-        env.setComplianceLevel(8);
+        int complianceLevel = ComplianceLevel.resolve(paths);
+        if (DebugLog.enabled())
+            System.out.println("Java compliance level: " + complianceLevel);
+        env.setComplianceLevel(complianceLevel);
 
         boolean buildSuccess = launcher.getModelBuilder().build();
         if (!buildSuccess && (env.getErrorCount() > 0 || env.getWarningCount() > 0)) {

liquidjava-verifier/src/main/java/liquidjava/api/ComplianceLevel.java

@@ -0,0 +1,42 @@
+package liquidjava.api;
+
+import java.io.File;
+import java.io.FileReader;
+import java.util.Arrays;
+import java.util.Optional;
+import java.util.Properties;
+
+import org.apache.maven.model.io.xpp3.MavenXpp3Reader;
+
+/**
+ * Java compliance level used by Spoon, read from the {@code maven.compiler.release} or {@code maven.compiler.source}
+ * property of the nearest {@code pom.xml} of the verified paths
+ */
+public final class ComplianceLevel {
+
+    /** Highest level accepted by Spoon 10.4.2 (JDT 3.33), also used when no pom declares one */
+    public static final int MAX_SUPPORTED = 19;
+
+    public static int resolve(String... paths) {
+        return Arrays.stream(paths).map(path -> fromPom(new File(path).getAbsoluteFile())).flatMap(Optional::stream)
+                .max(Integer::compare).map(level -> Math.min(level, MAX_SUPPORTED)).orElse(MAX_SUPPORTED);
+    }
+
+    private static Optional<Integer> fromPom(File path) {
+        for (File dir = path; dir != null; dir = dir.getParentFile()) {
+            File pom = new File(dir, "pom.xml");
+            if (!pom.isFile())
+                continue;
+            try (FileReader reader = new FileReader(pom)) {
+                Properties properties = new MavenXpp3Reader().read(reader).getProperties();
+                String version = properties.getProperty("maven.compiler.release",
+                        properties.getProperty("maven.compiler.source"));
+                if (version != null)
+                    return Optional.of(Integer.parseInt(version.trim().replaceFirst("^1\\.", "")));
+            } catch (Exception ignored) {
+                // unreadable pom or non-numeric version: keep searching enclosing poms
+            }
+        }
+        return Optional.empty();
+    }
+}

liquidjava-verifier/src/test/java/liquidjava/api/tests/TestComplianceLevel.java

@@ -0,0 +1,35 @@
+package liquidjava.api.tests;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import liquidjava.api.ComplianceLevel;
+
+class TestComplianceLevel {
+
+    @TempDir
+    Path project;
+
+    private int resolveWithRelease(String release) throws IOException {
+        Files.writeString(project.resolve("pom.xml"),
+                "<project><modelVersion>4.0.0</modelVersion><properties><maven.compiler.release>" + release
+                        + "</maven.compiler.release></properties></project>");
+        return ComplianceLevel.resolve(Files.createDirectories(project.resolve("src")).toString());
+    }
+
+    @Test
+    void readsLevelFromPom() throws IOException {
+        assertEquals(8, resolveWithRelease("1.8"));
+    }
+
+    @Test
+    void capsAtMaxSupported() throws IOException {
+        assertEquals(ComplianceLevel.MAX_SUPPORTED, resolveWithRelease("30"));
+    }
+}