test: 补齐 Java21 原生差分与隐藏恢复判定

Author: loong10k

crates/codeguard-cli/tests/java_native_differential.rs

@@ -1,6 +1,7 @@
 #![cfg(all(feature = "wasm-precheck", unix))]
 
 use std::fs;
+use sha2::Digest;
 use std::path::Path;
 use std::process::Command;
 
@@ -42,7 +43,7 @@ fn corpus() -> [(&'static str, &'static str, bool); 13] {
     ]
 }
 
-fn candidate_is_valid(root: &Path, name: &str, source: &str) -> bool {
+fn candidate_report(root: &Path, name: &str, source: &str) -> serde_json::Value {
     let file = root.join(format!("{name}.java"));
     fs::write(&file, source).unwrap();
     let candidate = Command::new(env!("CARGO_BIN_EXE_codeguard"))
@@ -60,7 +61,21 @@ fn candidate_is_valid(root: &Path, name: &str, source: &str) -> bool {
         serde_json::Value::Null,
         "{name}: {report}"
     );
-    report["recoveries"].as_array().unwrap().is_empty()
+    report
+}
+
+fn candidate_classification(report: &serde_json::Value) -> Option<bool> {
+    if report["precheck"]["truncated_files"].as_u64().unwrap() != 0 {
+        None
+    } else {
+        Some(report["recoveries"].as_array().unwrap().is_empty())
+    }
+}
+
+#[test]
+fn hidden_java_recovery_is_unknown_instead_of_clean() {
+    let report = serde_json::json!({"precheck":{"truncated_files":1},"recoveries":[]});
+    assert_eq!(candidate_classification(&report), None);
 }
 
 #[test]
@@ -72,8 +87,8 @@ fn java_worker_preserves_native_labeled_syntax_corpus() {
     fs::create_dir_all(&root).unwrap();
     for (name, source, expected_valid) in corpus() {
         assert_eq!(
-            candidate_is_valid(&root, name, source),
-            expected_valid,
+            candidate_classification(&candidate_report(&root, name, source)),
+            Some(expected_valid),
             "{name}"
         );
     }
@@ -119,11 +134,115 @@ fn pinned_java_worker_matches_native_javac_on_syntax_corpus() {
         );
         assert_eq!(fs::read_to_string(&file).unwrap(), source);
         assert_eq!(
-            candidate_is_valid(&root, name, source),
-            native.status.success(),
+            candidate_classification(&candidate_report(&root, name, source)),
+            Some(native.status.success()),
             "{name}: javac={} worker classification differs",
             String::from_utf8_lossy(&native.stderr)
         );
     }
     fs::remove_dir_all(root).unwrap();
 }
+
+/// 本轮新增的Java21样本与既有固定回归语料分开统计，不授予grammar资格。
+#[test]
+#[ignore = "requires explicit existing javac 21 via CODEGUARD_JAVAC_BIN"]
+fn java21_language_forms_match_existing_native_compiler() {
+    let javac = std::env::var("CODEGUARD_JAVAC_BIN").unwrap();
+    let tool_bytes = fs::read(&javac).unwrap();
+    let tool_sha256 = format!("{:x}", sha2::Sha256::digest(&tool_bytes));
+    let version = Command::new(&javac).arg("-version").output().unwrap();
+    assert!(version.status.success());
+    assert!(String::from_utf8_lossy(&version.stdout).starts_with("javac 21."));
+    let root = std::env::temp_dir().canonicalize().unwrap().join(format!(
+        "codeguard-java21-differential-{}",
+        std::process::id()
+    ));
+    fs::create_dir_all(&root).unwrap();
+    let cases = [
+        (
+            "pattern_switch",
+            "class C { int f(Object o) { return switch(o) { case String s -> s.length(); case Integer i -> i; default -> 0; }; } }",
+            true,
+        ),
+        (
+            "guarded_switch",
+            "class C { int f(Object o) { return switch(o) { case String s when s.isEmpty() -> 0; case String s -> 1; default -> 2; }; } }",
+            true,
+        ),
+        (
+            "record_pattern",
+            "record P(int x, int y) {} class C { int f(Object o) { return o instanceof P(int x, int y) ? x + y : 0; } }",
+            true,
+        ),
+        (
+            "sealed_record",
+            "sealed interface S permits P {} record P(int x) implements S {}",
+            true,
+        ),
+        (
+            "text_block",
+            "class C { String s = \"\"\"\nhello\n\"\"\"; }",
+            true,
+        ),
+        (
+            "missing_guard",
+            "class C { int f(Object o) { return switch(o) { case String s when -> 0; default -> 2; }; } }",
+            false,
+        ),
+        (
+            "missing_record_parameter_type",
+            "record P(int x) {} class C { boolean f(Object o) { return o instanceof P(x); } }",
+            false,
+        ),
+        (
+            "missing_switch_arrow",
+            "class C { int f(Object o) { return switch(o) { case String s s.length(); default -> 0; }; } }",
+            false,
+        ),
+    ];
+    let mut observations = Vec::new();
+    for (name, source, expected_valid) in cases {
+        let file = root.join(format!("{name}.java"));
+        fs::write(&file, source).unwrap();
+        let out = root.join(format!("out-{name}"));
+        fs::create_dir_all(&out).unwrap();
+        let native = Command::new(&javac)
+            .args(["--release", "21", "-proc:none", "-Xlint:none", "-d"])
+            .arg(&out)
+            .arg(&file)
+            .output()
+            .unwrap();
+        assert!(
+            matches!(native.status.code(), Some(0 | 1)),
+            "{name}: {native:?}"
+        );
+        assert_eq!(
+            native.status.success(),
+            expected_valid,
+            "{name}: {}",
+            String::from_utf8_lossy(&native.stderr)
+        );
+        let candidate = candidate_report(&root, name, source);
+        let classification = candidate_classification(&candidate);
+        observations.push(serde_json::json!({"case":name,"source_sha256":format!("{:x}",sha2::Sha256::digest(source.as_bytes())),"native_valid":native.status.success(),"candidate_valid":classification,"candidate":candidate}));
+        assert_eq!(fs::read_to_string(&file).unwrap(), source);
+    }
+    assert_eq!(
+        fs::read(&javac).unwrap(),
+        tool_bytes,
+        "native compiler changed during oracle execution"
+    );
+    if let Ok(path) = std::env::var("CODEGUARD_JAVA21_REPORT") {
+        fs::write(path, serde_json::to_vec_pretty(&serde_json::json!({"schema_version":"0.1.0","scope":"java21_new_local_cases","native_tool_sha256":tool_sha256,"native_version":String::from_utf8_lossy(&version.stdout),"independent_holdout":false,"grammar_qualified":false,"delivery_decision":"not_evaluated","observations":observations})).unwrap()).unwrap();
+    }
+    fs::remove_dir_all(root).unwrap();
+    let disagreements: Vec<_> = observations
+        .iter()
+        .filter(|r| r["candidate_valid"].is_boolean() && r["candidate_valid"] != r["native_valid"])
+        .map(|r| r["case"].clone())
+        .collect();
+    assert!(
+        disagreements.is_empty(),
+        "Java21 decidable differences: {disagreements:?}"
+    );
+}

docs/Codeguard-Grammar-Evaluation.md

@@ -157,3 +157,7 @@ Go candidate-task rechecks now accept `--go-tool /absolute/sdk/bin/go` and invok
 ### Native-first Go lint with missing-tool candidates
 
 Source-built `codeguard lint go . --format json` prefers explicit `--go-tool`, then executable Go from absolute caller PATH entries. Selected tool/version/execution failures remain native failures. When no native tool exists, the built-in WASM produces bounded whole-file recovery and structure candidates. Candidates or incomplete prechecks require a project-appropriate native tool; zero candidates in the completely observed bounded scope only recommend preparation. Native obligations remain incomplete and exit3 is retained. Builds without WASM report that capability gap. Repeated lint/check reuse the confirmation task; adding a package declaration does not close it. Public npm0.1.4 is unchanged. See [limited acceptance](../tests/acceptance/go-lint-fallback.md).
+
+## 2026-10-06 Java21 native comparison
+
+Java differential acceptance now checks truncated_files before treating empty recoveries as clean; hidden recovery remains unknown. The original13 cases retain their javac21/release17 comparison. A separate release21 group covers pattern switch, guards, record patterns, sealed records, text blocks and three syntax errors: actual3TP/5TN/0FP/0FN/0unknown. These are author-created local cases (independent_holdout=false), not independent qualification or additions to the fixed358-case metrics. Native-tool and source digests bind the evidence. See [acceptance](../tests/acceptance/java21-native-differential.md).

docs/Codeguard-Grammar-Evaluation.zh_CN.md

@@ -169,3 +169,7 @@ Go候选任务复检现接受 `--go-tool /absolute/sdk/bin/go`，对冻结整文
 ### Go统一lint的原生优先与缺工具初检
 
 源码版 `codeguard lint go . --format json` 优先显式 `--go-tool`，否则查找调用方绝对PATH中的Go。工具已选择但版本/执行失败时保留原生故障；真正缺工具时，内置WASM做有界整文件初检，保留恢复和独立结构候选。候选或初检未完成要求准备项目适用原生工具；完整有界范围的零候选只推荐准备，原生义务仍未完成，退出码继续3。默认不含WASM的构建明确报告能力缺失。重复lint与check复用确认任务，补声明不自动关闭。公开npm0.1.4未更新。见[局部验收](../tests/acceptance/go-lint-fallback.md)。
+
+## 2026-10-06 Java21原生增量对照
+
+Java差分验收先核对truncated_files，隐藏恢复保留unknown，避免空recoveries误计为干净。原13例仍用javac21按release17对照；新增8例单独按release21执行，含模式switch/guard/record pattern/sealed/text block及三个语法错误，实际3TP/5TN/0FP/0FN/0unknown。新增组是本轮作者样本，independent_holdout=false，不提升grammar资格或混入固定358例。原生工具和源码摘要随证据绑定。见 [验收](../tests/acceptance/java21-native-differential.md)。

openspec/changes/introduce-rust-codeguard-cli/tasks.md

@@ -1887,3 +1887,10 @@ next/task show在已核验当前原生零诊断、原grammar引用及同一源
 - [x] 修复check java的P3C准备简报与聚合0.38 schema不兼容，并验证完整实际输出及拒绝反例（新增0.58，历史协议保留；见p3c-preparation-aggregate-schema验收）。
 
 见 [验收](../../../tests/acceptance/maven-javadoc-task-recheck.md)。110通过/0失败/22条件忽略；真实Maven新工作台、复杂项目、可信关闭/复发与实际宿主未完成，6.x/9.x父任务仍开放。
+
+## 2026-10-06 Java差分验收分类与Java21版本组
+
+- [x] Java原生差分将截断/隐藏恢复保留unknown，空recoveries不独立证明干净；原13例原生对照继续通过。
+- [x] 用既有javac21新增Java21语法8例原生对照，绑定工具和源码摘要，单独统计3TP/5TN；作者语料不当作独立盲测，不提升32grammar资格。
+
+见 tests/acceptance/java21-native-differential.md。Java目标4通过/0失败/0忽略；独立holdout、既有六项争议、全语言及真实宿主父任务继续开放。

openspec/changes/introduce-rust-codeguard-cli/verification.md

@@ -2512,3 +2512,7 @@ WASM CLI全目标Clippy -D warnings、定向rustfmt、分层、OpenSpec strict
 ## 2026-10-06 P3C配置准备简报聚合协议修复
 
 完整实际0.38聚合schema拒绝P3C配置准备简报，目标0.58版本测试先失败。新增0.58及限定blocker/检查器/原因/review-project-policy/固定重扫参数的封闭schema，修复Java选择原因码遗漏，保留历史协议。四目标57通过/0失败/10条件忽略；完整实际聚合与两处简报通过，六篡改与旧消费者拒绝符合预期。CLI严格Clippy、分层/OpenSpec strict通过。局部验收 tests/acceptance/p3c-preparation-aggregate-schema.md；不代替全部P3C分支、原生执行、宿主或完整目标。
+
+## 2026-10-06 Java差分隐藏恢复与Java21增量对照
+
+Java验收分类器先检查truncated_files，隐藏恢复不计作干净。现有JDK21.0.12.1对原13例release17和新增8例release21实际差分均一致；新增组3TP/5TN/0FP/0FN/0unknown，作者样本independent_holdout=false，与358固定回归不混计。整个Java目标4通过/0失败/0忽略；目标特性Clippy、diff/OpenSpec验证见对应验收与证据。未运行Erlang草稿或完整WASM/358回放，未安装/下载工具，资格和整体目标仍未完成。

tests/acceptance/evidence/java21-native-differential-2026-10-06.json

@@ -0,0 +1,87 @@
+{
+  "delivery_decision": "not_evaluated",
+  "grammar_qualified": false,
+  "independent_holdout": false,
+  "native_tool_sha256": "f9b046eb45d522f6e41d0b7eef03d4a1d0f898e0b54f1eac0a1b254be81d0e36",
+  "native_version": "javac 21.0.12.1\n",
+  "schema_version": "0.1.0",
+  "scope": "java21_new_local_cases",
+  "observations": [
+    {
+      "case": "pattern_switch",
+      "source_sha256": "7cff38df8d68315bc79af1147df3a612703cd8379a065c9c5f3f1e1c848fbad0",
+      "native_valid": true,
+      "candidate_valid": true,
+      "candidate_report_sha256": "da60a866f6a3eca50c79e58bd32c04bef20e44dbf1e653bbef11c004dace0f3b"
+    },
+    {
+      "case": "guarded_switch",
+      "source_sha256": "a9aa35d2e450397b94864ca9f84fa9cb08b63d05d396fe9bdc9f75e0cc91cf03",
+      "native_valid": true,
+      "candidate_valid": true,
+      "candidate_report_sha256": "5783d9c3539830f2f8a025e3ddef31ffb403dbdc04d26e4caf2bb1694667ae90"
+    },
+    {
+      "case": "record_pattern",
+      "source_sha256": "daa326a9f452f3ffa0f0fbfa0effefde9d41b2af0a736c4a11e59c5509a7f3f3",
+      "native_valid": true,
+      "candidate_valid": true,
+      "candidate_report_sha256": "32678be9e5e901dd2769903b1e70707916e6f085e414869c6b78e58fbd5165d8"
+    },
+    {
+      "case": "sealed_record",
+      "source_sha256": "914ba8be2750d45b3c1eaea1720b23d7fdbdb0f1252d10ef3e50838c758de27b",
+      "native_valid": true,
+      "candidate_valid": true,
+      "candidate_report_sha256": "a2df8d26bfa8d1239ed1c5954893a5f9ec04a23b10a84fb41558f62cc8d1c615"
+    },
+    {
+      "case": "text_block",
+      "source_sha256": "1d48239dbc78baafcc7554ff7c16758feed86ba75fae4f0e05c1723c92604145",
+      "native_valid": true,
+      "candidate_valid": true,
+      "candidate_report_sha256": "db81166cbdc1d41b3fef852bd3e174c6997bb0105d4286744acf3815dd039f69"
+    },
+    {
+      "case": "missing_guard",
+      "source_sha256": "61eb96df16c9d6b42aec9e07ce656a127b7c2658ad451aae3307a21709a170c1",
+      "native_valid": false,
+      "candidate_valid": false,
+      "candidate_report_sha256": "4b8c219a5e578d042fa48dd7733f5c87c3c69b95b83d2f336020afde69fd34af"
+    },
+    {
+      "case": "missing_record_parameter_type",
+      "source_sha256": "97ebf921f8c089fe01a329e275af683fa78eac2903dbc22eb1a312cf49574de7",
+      "native_valid": false,
+      "candidate_valid": false,
+      "candidate_report_sha256": "3de80c9512c7c694be24147466a1eb51ad3698024e20d844c372733ca9d44045"
+    },
+    {
+      "case": "missing_switch_arrow",
+      "source_sha256": "6b92578733f6c9150f13fd2dbabc641bbb59bf626c8ff54d0858c07b2cf9427a",
+      "native_valid": false,
+      "candidate_valid": false,
+      "candidate_report_sha256": "c778312e404252f9ad08bfc09c0630b3ff28369a7908081ebc3fc111bb94aab1"
+    }
+  ],
+  "source_sha256": "02f223ed7f786163ffd7034c0e88247b92cedf80b1e2ff3ac5e6f6ea1d774c11",
+  "raw_report_sha256": "9d3a53ae5cdb591bda2a95713a854e627551e1a08492f0c4886ff9866f4c96f8",
+  "logs_sha256": {
+    "cg-java-native-recovery-classification.log": "be447ba7f5ebb2268587daebc5a38c9c48479874fa8298d4cd72c29ca76c3683",
+    "cg-java21-native-new-cases.log": "eec0c7208969f34613c88bab650f8f1b3135b457fb5d8070849733b7b8fc1eb4",
+    "cg-java-native-current-final.log": "3c38d39fec3e34d0ea42ce631788167dfc470289a90a92de210b2bdb22b75c9c",
+    "cg-java-native-clippy.log": "7816be6d8b455bec1730c6a157aa750cb2310e6195ee15d56f30cd41355f6147"
+  },
+  "tests": {
+    "passed": 4,
+    "failed": 0,
+    "ignored": 0
+  },
+  "java21_counts": {
+    "tp": 3,
+    "tn": 5,
+    "fp": 0,
+    "fn": 0,
+    "unknown": 0
+  }
+}

tests/acceptance/java21-native-differential.md

@@ -0,0 +1,13 @@
+# Java 原生差分截断判定与 Java21 增量样本
+
+对应 introduce-rust-codeguard-cli 的14.17/14.19及12.11局部验收。Java差分测试此前只按recoveries是否为空判定合法，可能把隐藏/截断恢复误计为TN。测试分类器现在先读取truncated_files，非零保留unknown，不将空恢复转为干净；反例验证unknown结果。这是验收分类修正，产品仍保持未完成，不改grammar或发行资格。
+
+显式使用本机Microsoft JDK21.0.12.1的javac，原13例语料继续通过原生对照（8合法、5语法错误，--release17）；新增独立登记的Java21版本组8例（--release21）包含模式switch、when guard、record pattern、sealed record、text block五个合法样本，以及缺guard表达式、缺record参数类型、缺switch箭头三个语法错误。实际javac与WASM可判定结果全部一致，新增组3TP/5TN/0FP/0FN/0unknown。两组不与固定358例或其它工具指标混合。
+
+新增组由本轮作者编写，independent_holdout=false，不是独立第三方盲测。原生编译器字节在运行前后核对，报告绑定版本及摘要，每例绑定源码摘要和原grammar报告。不下载工具。新增组不含注解处理器或外部依赖，javac禁止注解处理；结果不覆盖完整Java语义或全部语言版本。
+
+```bash
+CODEGUARD_JAVAC_BIN=/absolute/jdk21/bin/javac CODEGUARD_JAVA21_REPORT=/private/local-report.json cargo test --offline --locked -p codeguard-cli --features wasm-precheck --test java_native_differential -- --include-ignored --test-threads=1
+```
+
+整个Java差分目标4项通过（基础worker、原13例原生、隐藏恢复分类、新8例原生）。没有运行用户Erlang草稿或全WASM套件，没有重放358例或重建grammar。所有32 grammar资格仍未完成，既有六项争议和独立holdout/真实宿主/多平台继续开放。