Skip unparseable Java versions in FindJavaVersion instead of reporting -1 (#1125)

* Skip unparseable Java versions in FindJavaVersion instead of reporting -1

A JavaVersion marker whose source/target compatibility cannot be parsed
reports a major version of -1. FindJavaVersion stringified that straight
into the data table, so repositories surfaced a bogus -1 row. Worse, the
lower() reduction keeps the lowest version per repository, and -1 sorts
below every real version, so a single module with an undetermined version
dragged the whole repository's reported version to -1.

Skip markers whose source or target major version is negative: they carry
no usable version, so they neither emit a -1 row nor mask the real
versions of sibling modules. When no module has a parseable version the
repository simply contributes no row.

* Drop FindJavaVersion all-unknown test that asserts an absent data table

When the recipe emits no rows the JavaVersionTable is absent rather than
present-but-empty, so the dataTable assertion throws. The skip behavior is
already covered by unknownVersionMarkersAreSkipped.

Author: timtebeek

src/main/java/org/openrewrite/java/migrate/search/FindJavaVersion.java

@@ -58,6 +58,17 @@ public Tree preVisit(Tree tree, ExecutionContext ctx) {
                 if (tree instanceof JavaSourceFile) {
                     Markers markers = tree.getMarkers();
                     markers.findFirst(JavaVersion.class).ifPresent(jv -> {
+                        int sourceVersion = jv.getMajorVersion();
+                        int targetVersion = jv.getMajorReleaseVersion();
+                        // A JavaVersion whose source/target compatibility could not be parsed reports -1
+                        // (for example a build that sets the version only through a Java toolchain, or an
+                        // unresolved property placeholder). -1 is not a real Java version, and because it
+                        // sorts below every real version it would win the lower() reduction and mask the
+                        // actual versions of every other module in the repository, so skip it entirely.
+                        if (sourceVersion < 0 || targetVersion < 0) {
+                            return;
+                        }
+
                         // Prefer the git origin as the dedup key: every module in a multi-module repo
                         // shares one GitProvenance, so they collapse to a single row. Fall back to the
                         // JavaProject UUID (one row per module) when no git provenance is available,
@@ -72,8 +83,8 @@ public Tree preVisit(Tree tree, ExecutionContext ctx) {
                                         .orElseGet(() -> "version:" + jv.getId()));
 
                         JavaVersionTable.Row candidate = new JavaVersionTable.Row(
-                                Integer.toString(jv.getMajorVersion()),
-                                Integer.toString(jv.getMajorReleaseVersion()));
+                                Integer.toString(sourceVersion),
+                                Integer.toString(targetVersion));
                         acc.merge(key, candidate, FindJavaVersion::lower);
                     });
                 }

src/test/java/org/openrewrite/java/migrate/search/FindJavaVersionTest.java

@@ -143,6 +143,39 @@ class C {
         );
     }
 
+    @Test
+    void unknownVersionMarkersAreSkipped() {
+        // A JavaVersion whose source/target compatibility cannot be parsed reports -1 (for example a
+        // build configured solely through a Java toolchain or an unresolved property). Such markers
+        // must not contribute a "-1" row, nor drag the reported version of sibling modules down: -1
+        // sorts below every real version and would otherwise win the lower() reduction.
+        var git = gitProvenance("https://github.com/example/toolchain.git");
+        var known = new JavaProject(randomId(), "known-module", null);
+        var unknown = new JavaProject(randomId(), "unknown-module", null);
+        var java17 = new JavaVersion(randomId(), "Sam", "Shelter", "17", "17");
+        var unparseable = new JavaVersion(randomId(), "Sam", "Shelter", "", "");
+        rewriteRun(
+          spec -> spec.dataTable(JavaVersionTable.Row.class, rows ->
+            assertThat(rows).containsExactly(
+              new JavaVersionTable.Row("17", "17")
+            )),
+          //language=java
+          java(
+            """
+              class Known {
+              }
+              """,
+            spec -> spec.markers(git, known, java17)),
+          //language=java
+          java(
+            """
+              class Unknown {
+              }
+              """,
+            spec -> spec.markers(git, unknown, unparseable))
+        );
+    }
+
     @Test
     void withoutGitProvenanceFallsBackToPerProject() {
         // When no GitProvenance is available (local non-git source trees, some test setups),