让静态发现保留共享后缀的语言歧义

Author: loong10k

crates/codeguard-cli/src/check_command.rs

@@ -1474,7 +1474,7 @@ pub fn run(args: &[String]) -> ExitCode {
     let syntax_candidates = json!({
         "status":"not_run","reason":"binary_without_wasm_precheck","execution_phase":"after_native",
         "authority":"candidate_unqualified","delivery_decision":"incomplete",
-        "source_file_count":discovery.languages.values().map(|item| item.source_files.len()).sum::<usize>(),
+        "source_file_count":discovery.languages.values().map(|item| item.source_files.len()).sum::<usize>() + discovery.ambiguous_source_files.len(),
         "skipped_count":0,"unrouted_count":0,"native_preferred_count":0,"observations":[],
         "next_action":"使用包含固定语法资产的发行包运行候选初检，并完成适用原生检查"
     });

crates/codeguard-cli/src/check_syntax_candidates.rs

@@ -39,6 +39,9 @@ pub fn observe(
             paths.extend(evidence.source_files.iter());
         }
     }
+    if !java_only {
+        paths.extend(discovery.ambiguous_source_files.iter());
+    }
     let source_file_count = paths.len();
     let mut observations = Vec::new();
     let mut skipped_count = 0;

crates/codeguard-cli/src/discovery.rs

@@ -44,6 +44,8 @@ pub struct DiscoveryReport {
     pub root: String,
     pub observation_complete: bool,
     pub languages: BTreeMap<String, LanguageEvidence>,
+    /// 后缀不足以判定语言的源码；仍须进入候选范围的未路由计数。
+    pub(crate) ambiguous_source_files: BTreeSet<String>,
     pub build_roots: BTreeMap<String, BTreeSet<String>>,
     pub declared_versions: BTreeMap<String, String>,
     /// 与同次清单字节摘要绑定的 Maven 直接模块声明。
@@ -147,6 +149,7 @@ pub fn discover<P: ObservationPort>(
         root: root.to_string_lossy().into_owned(),
         observation_complete: true,
         languages: BTreeMap::new(),
+        ambiguous_source_files: BTreeSet::new(),
         build_roots: BTreeMap::new(),
         declared_versions: BTreeMap::new(),
         maven_module_models: BTreeMap::new(),
@@ -406,6 +409,31 @@ fn observe_file<P: ObservationPort>(
             }
         }
     }
+    if name.ends_with(".sc") {
+        report.ambiguous_source_files.insert(relative.into());
+        report
+            .unknown_conditions
+            .push(format!("ambiguous_language_suffix:{relative}"));
+        return;
+    }
+    if name.ends_with(".m") {
+        match observation.read_bounded(path, 1024 * 1024) {
+            Ok(source) if crate::source_language_hint::has_objc_marker(&source) => {}
+            Ok(_) => {
+                report.ambiguous_source_files.insert(relative.into());
+                report
+                    .unknown_conditions
+                    .push(format!("ambiguous_language_suffix:{relative}"));
+                return;
+            }
+            Err(_) => {
+                report.observation_complete = false;
+                report.blocked_paths.push(relative.into());
+                report.ambiguous_source_files.insert(relative.into());
+                return;
+            }
+        }
+    }
     for language in &registry.languages {
         if language
             .extensions

crates/codeguard-cli/src/grammar_route.rs

@@ -1,5 +1,7 @@
 //! 按源码后缀和明确的嵌入边界选择候选 grammar；不推断项目语言版本。
 
+use crate::source_language_hint::has_objc_marker;
+
 /// 一段可独立解析的候选源码；嵌入片段的位置相对于原文件的字节起点。
 #[derive(Clone, Debug)]
 pub struct GrammarRoute<'a> {
@@ -95,30 +97,6 @@ pub fn route_source<'a>(relative_path: &str, source: &'a [u8]) -> Vec<GrammarRou
     routes
 }
 
-// `.m` 也用于 MATLAB；只在源码具有 Objective-C 专属词法标记时自动解析。
-// `.sc` 同时用于 Scala 脚本与 SuperCollider，缺少项目上下文时不猜测。
-fn has_objc_marker(source: &[u8]) -> bool {
-    let markers: &[&[u8]] = &[
-        b"@interface".as_slice(),
-        b"@implementation",
-        b"@protocol",
-        b"@class",
-        b"@property",
-        b"@synthesize",
-        b"@autoreleasepool",
-        b"#import",
-    ];
-    source.split(|byte| *byte == b'\n').any(|line| {
-        let line = line.trim_ascii_start();
-        markers.iter().any(|marker| {
-            line.starts_with(marker)
-                && line.get(marker.len()).is_some_and(|next| {
-                    next.is_ascii_whitespace() || matches!(next, b'(' | b'{' | b'<' | b'"')
-                })
-        })
-    })
-}
-
 fn find_bytes(haystack: &[u8], needle: &[u8]) -> Option<usize> {
     haystack
         .windows(needle.len())

crates/codeguard-cli/src/lib.rs

@@ -178,6 +178,7 @@ pub mod rustdoc_repair_brief;
 #[cfg(unix)]
 pub(crate) mod rustdoc_task_recheck;
 pub mod sarif_feedback;
+mod source_language_hint;
 #[cfg(feature = "wasm-precheck")]
 mod syntax_worker_candidate_observation;
 #[cfg(feature = "wasm-precheck")]

crates/codeguard-cli/src/source_language_hint.rs

@@ -0,0 +1,25 @@
+//! 只读语言候选证据；供默认发现与可选 WASM 路由共用。
+
+/// 识别 `.m` 源码行首的 Objective-C 专属词法标记。
+/// 参数为有界原始源码；返回值仅是语言候选证据，不证明语法或项目配置。
+pub(crate) fn has_objc_marker(source: &[u8]) -> bool {
+    let markers: &[&[u8]] = &[
+        b"@interface".as_slice(),
+        b"@implementation",
+        b"@protocol",
+        b"@class",
+        b"@property",
+        b"@synthesize",
+        b"@autoreleasepool",
+        b"#import",
+    ];
+    source.split(|byte| *byte == b'\n').any(|line| {
+        let line = line.trim_ascii_start();
+        markers.iter().any(|marker| {
+            line.starts_with(marker)
+                && line.get(marker.len()).is_some_and(|next| {
+                    next.is_ascii_whitespace() || matches!(next, b'(' | b'{' | b'<' | b'"')
+                })
+        })
+    })
+}

crates/codeguard-cli/tests/check_all_grammar_candidates.rs

@@ -112,6 +112,17 @@ fn check_all_routes_distinct_dialects_after_native_without_claiming_clean() {
     assert!(!observations.iter().any(|item| item["path"] == "plot.m"));
     assert!(!observations.iter().any(|item| item["path"] == "synth.sc"));
     assert_eq!(report["syntax_candidates"]["unrouted_count"], 2);
+    let unknown = report["discovery"]["unknown_conditions"]
+        .as_array()
+        .unwrap();
+    for path in ["plot.m", "synth.sc"] {
+        assert!(
+            unknown
+                .iter()
+                .any(|item| item == &format!("ambiguous_language_suffix:{path}")),
+            "{path}: {unknown:?}"
+        );
+    }
     assert_eq!(
         observations
             .iter()
@@ -132,6 +143,37 @@ fn check_all_routes_distinct_dialects_after_native_without_claiming_clean() {
     );
 }
 
+#[test]
+fn ambiguous_only_project_remains_an_explicit_unrouted_scope() {
+    let root = std::env::temp_dir()
+        .canonicalize()
+        .unwrap()
+        .join(format!("codeguard-ambiguous-only-{}", std::process::id()));
+    fs::create_dir_all(&root).unwrap();
+    fs::write(root.join("plot.m"), "plot(1:3);\n").unwrap();
+    fs::write(root.join("synth.sc"), "{ SinOsc.ar(440) }.play;\n").unwrap();
+    let output = Command::new(env!("CARGO_BIN_EXE_codeguard"))
+        .args(["check", "all"])
+        .arg(&root)
+        .args(["--format=json", "--timeout", "30s"])
+        .output()
+        .unwrap();
+    fs::remove_dir_all(&root).unwrap();
+    assert_eq!(output.status.code(), Some(3));
+    let report: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap();
+    assert_eq!(report["syntax_candidates"]["source_file_count"], 2);
+    assert_eq!(report["syntax_candidates"]["unrouted_count"], 2);
+    assert_eq!(report["syntax_candidates"]["status"], "not_run");
+    assert_eq!(report["syntax_candidates"]["reason"], "unrouted_source");
+    assert_eq!(report["delivery_decision"], "incomplete");
+    assert!(
+        report["syntax_candidates"]["observations"]
+            .as_array()
+            .unwrap()
+            .is_empty()
+    );
+}
+
 #[test]
 fn check_all_invokes_all_32_pinned_candidates_across_bounded_projects() {
     let root = std::env::temp_dir().canonicalize().unwrap().join(format!(

crates/codeguard-cli/tests/detect_cli.rs

@@ -7,6 +7,44 @@ use std::sync::atomic::{AtomicU64, Ordering};
 
 static NEXT: AtomicU64 = AtomicU64::new(0);
 
+#[test]
+fn detect_keeps_shared_m_and_sc_suffixes_ambiguous_without_false_languages() {
+    let project = TempProject::new();
+    fs::write(
+        project.0.join("plot.m"),
+        "title('@interface Foo');\nplot(1:3);\n",
+    )
+    .unwrap();
+    fs::write(project.0.join("synth.sc"), "{ SinOsc.ar(440) }.play;\n").unwrap();
+    fs::write(
+        project.0.join("model.m"),
+        "@interface Model : NSObject\n@end\n",
+    )
+    .unwrap();
+    fs::write(project.0.join("main.scala"), "object Main {}\n").unwrap();
+    let report = detect_json(&project);
+    let languages = report["languages"].as_array().unwrap();
+    let objc = languages.iter().find(|item| item["id"] == "objc").unwrap();
+    let scala = languages.iter().find(|item| item["id"] == "scala").unwrap();
+    assert_eq!(objc["source_files"], serde_json::json!(["model.m"]));
+    assert_eq!(scala["source_files"], serde_json::json!(["main.scala"]));
+    assert!(report["observation_complete"].as_bool().unwrap());
+    assert!(
+        report["unknown_conditions"]
+            .as_array()
+            .unwrap()
+            .iter()
+            .any(|item| item == "ambiguous_language_suffix:plot.m")
+    );
+    assert!(
+        report["unknown_conditions"]
+            .as_array()
+            .unwrap()
+            .iter()
+            .any(|item| item == "ambiguous_language_suffix:synth.sc")
+    );
+}
+
 struct TempProject(PathBuf);
 
 impl TempProject {

docs/Codeguard-Technical-Design.md

@@ -212,7 +212,7 @@ The source-built `check all` now adds a narrower actual project report: native a
 }
 ```
 
-The actual report also includes native results, source/grammar digests, fragment offsets, bounded file-relative recovery anchors, skipped counts and unresolved obligations. A complete `<cfquery>` tag body is an embedded candidate; ordinary SQL or ambiguous C/C++ headers are not guessed. Automatic `.m` routing requires an Objective-C line marker, while `.sc` is left unresolved because SuperCollider shares that suffix; the static language inventory and per-file unresolved diagnostics still need improvement. Four bounded 32-grammar CLI fixtures took about 54 seconds on this Mac; a single 31-file Linux run completed 26/32 within 90 seconds; language-version corpora, native differential checks, task synchronization, host delivery and package release are still open.
+The actual report also includes native results, source/grammar digests, fragment offsets, bounded file-relative recovery anchors, skipped counts and unresolved obligations. A complete `<cfquery>` tag body is an embedded candidate; ordinary SQL or ambiguous C/C++ headers are not guessed. Automatic `.m` routing requires an Objective-C line marker, while `.sc` is left unresolved because SuperCollider shares that suffix. Read-only discovery now uses the same bounded `.m` evidence and records unresolved shared-suffix paths in `unknown_conditions`; `check all` retains them in its unrouted count. Project-level dialect evidence and structured per-file ambiguity reporting still need work. Four bounded 32-grammar CLI fixtures took about 54 seconds on this Mac; a single 31-file Linux run completed 26/32 within 90 seconds; language-version corpora, native differential checks, task synchronization, host delivery and package release are still open.
 
 The opt-in CLI build first checks for a local ESLint 10 package and a single ordinary flat config on single-file TypeScript requests without explicit native context. With an executable Node resolved from `PATH`, it invokes the existing bounded native version/report probe; without Node it reports the preparation gap rather than running WASM first. Only when no project-local ESLint package is observed does the CLI emit [ESLint feedback 0.3.0](../schemas/eslint-local-feedback-v0.3.schema.json) for `.ts/.mts/.cts` or [0.4.0](../schemas/eslint-local-feedback-v0.4.schema.json) for `.tsx`. TSX uses its own pinned grammar. Candidate prechecks preserve `native=not_run` and `delivery=not_evaluated`, and remain incomplete even with zero recoveries. An ambiguous config, untrusted local path or invalid package identity remains a setup blocker and does not trigger WASM; a partial explicit context also retains its existing path. This is a single-file slice, not project script equivalence, per-module orchestration or automatic host feedback; see the [native-first acceptance](../tests/acceptance/native-first-eslint-candidate.md).
 

docs/Codeguard-Technical-Design.zh_CN.md

@@ -212,7 +212,7 @@ flowchart LR
 }
 ```
 
-实际报告还包含原生结果、源码与 grammar 摘要、片段偏移、有界原文件恢复坐标、未执行数量和未解决义务。完整 `<cfquery>` 标签体可作嵌入候选；普通 SQL 和有歧义的 C/C++ 头文件不猜测。自动 `.m` 路由要求 Objective-C 行首标记，`.sc` 与 SuperCollider 共用后缀，缺少项目证据时保持未解析；静态语言库存及逐文件未解析诊断仍待完善。本机四批 32 份 grammar 的 CLI 样例约 54 秒；Linux 单次 31 文件检查在 90 秒内完成 26/32；语言版本语料、原生差分对照、任务同步、宿主交付和发行包验收仍待完成。
+实际报告还包含原生结果、源码与 grammar 摘要、片段偏移、有界原文件恢复坐标、未执行数量和未解决义务。完整 `<cfquery>` 标签体可作嵌入候选；普通 SQL 和有歧义的 C/C++ 头文件不猜测。自动 `.m` 路由要求 Objective-C 行首标记，`.sc` 与 SuperCollider 共用后缀，缺少项目证据时保持未解析。只读发现现在使用相同的有界 `.m` 证据，把共享后缀的未判定路径记入 `unknown_conditions`；`check all` 仍将其计入未路由数量。项目级方言依据及逐文件结构化歧义报告仍待完善。本机四批 32 份 grammar 的 CLI 样例约 54 秒；Linux 单次 31 文件检查在 90 秒内完成 26/32；语言版本语料、原生差分对照、任务同步、宿主交付和发行包验收仍待完成。
 
 可选特性构建的 CLI 在无显式原生上下文的 TypeScript 单文件请求中，先核对本地 ESLint 10 包及唯一普通 flat config。若从 `PATH` 解析到可执行 Node，就调用既有有界原生版本与报告探针；缺 Node 时报告准备缺口，不让 WASM 抢跑。仅未观察到本地 ESLint 包时，`.ts/.mts/.cts` 输出 [ESLint 反馈 0.3.0](../schemas/eslint-local-feedback-v0.3.schema.json)，`.tsx` 用独立 grammar 输出 [0.4.0](../schemas/eslint-local-feedback-v0.4.schema.json)。候选初检保留 `native=not_run`、`delivery=not_evaluated`，即使零恢复节点也保持未完成。配置选择歧义、本地路径不可信或包身份损坏时保留环境阻塞而不启动 WASM；部分显式上下文也沿用原路径。该增量不证明项目脚本参数等价、逐模块调度或宿主对话交付，见[原生优先局部验收](../tests/acceptance/native-first-eslint-candidate.md)。