补充 Erlang 显式函数终止符结构初检

Author: loong10k

README.md

@@ -826,3 +826,6 @@ These additions describe the current source candidate; the public npm release is
 Standalone `lint <registered-language> FILE` now accepts every canonical registry ID. Existing native language adapters keep their original paths; other languages return `syntax_lint_feedback` with an explicit native-adapter gap and unknown configuration. WASM-enabled source builds additionally run matching bounded grammar candidates and reuse `.codeguard/` confirmation tasks with `--workspace ABS_ROOT`. This is partial syntax feedback, not native lint coverage or a new published npm capability.
 
 C/C++ source builds also accept explicit standalone native context: `codeguard lint c main.c --clang-tool /ABS/PATH/clang --standard c11 --format=json` (C++ uses `cpp`/`c++17`). This measured Apple Clang 21 profile reports original native rules and byte positions plus a reusable verification argv. It does not yet synchronize Clang tasks or replace project lint; unresolved preprocessor context remains incomplete.
+
+
+Explicit `grammar probe erlang FILE --format=json` now adds bounded direct-function-form termination candidates, separately from parser recovery. Literal punctuation and valid clause continuations are preserved; project/Hook/task integration and native precision acceptance remain open. See [acceptance](tests/acceptance/erlang-form-candidates.md).

README.zh-CN.md

@@ -809,3 +809,6 @@ JavaScript 回退候选已接入项目检查与确认编辑 Hook：重复顶层
 独立 `lint <注册表规范语言> FILE` 已接受全部规范语言ID：已有专用原生适配器保留原路径，其余输出 `syntax_lint_feedback`，明确原生适配缺口及配置未知。启用WASM的源码构建追加匹配的有界grammar候选，提供 `--workspace ABS_ROOT` 时复用 `.codeguard/` 原生确认任务。这是局部语法反馈，不代表原生lint全覆盖，也未更新公开npm能力。
 
 C/C++源码构建还支持明确的独立原生上下文：`codeguard lint c main.c --clang-tool /ABS/PATH/clang --standard c11 --format=json`（C++使用 `cpp`/`c++17`）。已实测Apple Clang21档案返回原生规则、字节位置及可复用复检argv；尚未同步Clang原生任务，不替代项目lint，预处理上下文未解析时保持未完成。
+
+
+显式 `grammar probe erlang FILE --format=json` 已补充直接函数form终止符候选，与原始解析恢复分开；字面量标点和合法子句续接不误判。项目/Hook/任务接线及原生精度验收仍开放，见[验收](tests/acceptance/erlang-form-candidates.md)。

crates/codeguard-adapters/src/erlang_form_rule.rs

@@ -0,0 +1,8 @@
+use sha2::{Digest, Sha256};
+const RULE: &[u8] = include_bytes!("../../../rulepacks/erlang/form_terminator.json");
+
+/// 固定Erlang直接函数form终止符规则摘要；不赋予原生或语言资格权威。
+#[must_use]
+pub fn erlang_form_rule_sha256() -> String {
+    format!("{:x}", Sha256::digest(RULE))
+}

crates/codeguard-adapters/src/lib.rs

@@ -434,3 +434,6 @@ pub use cfquery_projection_rule::{cfquery_projection_rule_sha256, cfquery_projec
 
 mod clang_sarif;
 pub use clang_sarif::parse_clang_stdin_sarif;
+
+mod erlang_form_rule;
+pub use erlang_form_rule::erlang_form_rule_sha256;

crates/codeguard-cli/src/grammar_probe_command.rs

@@ -1,6 +1,9 @@
 //! 显式单文件候选语法观察；不将未经验收的 grammar 结果变为 lint 结论。
 
-use crate::syntax_worker_runner::{run_syntax_worker_candidate, run_syntax_worker_binding_candidate};
+use crate::syntax_worker_runner::{
+    run_syntax_worker_candidate, run_syntax_worker_binding_candidate,
+    run_syntax_worker_form_candidate,
+};
 use codeguard_adapters::bundled_grammar_candidate;
 use serde_json::json;
 use std::path::PathBuf;
@@ -42,6 +45,8 @@ pub fn run(args: &[String]) -> ExitCode {
     };
     let runner = if language == "javascript" {
         run_syntax_worker_binding_candidate
+    } else if language == "erlang" {
+        run_syntax_worker_form_candidate
     } else {
         run_syntax_worker_candidate
     };
@@ -75,7 +80,9 @@ pub fn run(args: &[String]) -> ExitCode {
                 }
             });
             if !observation.structural_observations.is_empty() {
-                report["schema_version"] = json!(if language == "javascript" {
+                report["schema_version"] = json!(if language == "erlang" {
+                    "0.7.0"
+                } else if language == "javascript" {
                     "0.6.0"
                 } else if language == "cfquery" {
                     "0.4.0"
@@ -90,6 +97,9 @@ pub fn run(args: &[String]) -> ExitCode {
                 if language == "javascript" {
                     report["structural_rule_scope"] = json!("direct_simple_lexical_names_only");
                 }
+                if language == "erlang" {
+                    report["source_scope"] = json!("direct_function_forms");
+                }
                 if language == "go" {
                     report["source_scope"] = json!("whole_file");
                 }
@@ -99,7 +109,7 @@ pub fn run(args: &[String]) -> ExitCode {
                 report["structural_observations"] = json!(observation.structural_observations);
             }
             if observation.parser_error_location_unavailable {
-                if report["schema_version"] != "0.6.0" {
+                if report["schema_version"] != "0.6.0" && report["schema_version"] != "0.7.0" {
                     report["schema_version"] = json!("0.5.0");
                 }
                 report["parser_error_location_unavailable"] = json!(true);

crates/codeguard-cli/src/syntax_worker_command.rs

@@ -21,6 +21,9 @@ pub fn run(args: &[String]) -> ExitCode {
         [language, option] if language == "javascript" && option == "--direct-bindings" => {
             (language, true)
         }
+        [language, option] if language == "erlang" && option == "--form-terminators" => {
+            (language, true)
+        }
         _ => {
             eprintln!("语法工作进程参数无效");
             return ExitCode::from(2);
@@ -76,7 +79,7 @@ fn observe(language: &str, source: &[u8], bindings: bool) -> Result<SyntaxWorker
     let scanned = scan_wasm_recoveries(&tree, MAX_RECOVERIES)?;
     let mut structural_observations = Vec::new();
     let mut structural_truncated = false;
-    if bindings {
+    if bindings && language == "javascript" {
         let kinds = codeguard_adapters::javascript_binding_node_kinds()?;
         let scanned_bindings = codeguard_runtime::scan_wasm_sibling_bindings(
             &tree,
@@ -194,6 +197,34 @@ fn observe(language: &str, source: &[u8], bindings: bool) -> Result<SyntaxWorker
             });
         }
     }
+    if bindings && language == "erlang" && tree.root_node().kind() == "source_file" {
+        let (facts, truncated) = codeguard_runtime::scan_wasm_form_terminators(
+            &tree,
+            "fun_decl",
+            MAX_RECOVERIES,
+            200_000,
+        )?;
+        structural_truncated |= truncated;
+        for fact in facts {
+            if scanned.recoveries.len() + structural_observations.len() == MAX_RECOVERIES {
+                structural_truncated = true;
+                break;
+            }
+            structural_observations.push(crate::syntax_worker_structure::SyntaxWorkerStructure {
+                basis: "codeguard_structure_rule".into(),
+                rule_id: "codeguard.erlang.form_terminator".into(),
+                rule_version: "1.0.0".into(),
+                rule_sha256: codeguard_adapters::erlang_form_rule_sha256(),
+                parent_syntax_kind: fact.parent_syntax_kind,
+                start_byte: fact.start_byte,
+                end_byte: fact.end_byte,
+                start_row: fact.start_row,
+                start_column_byte: fact.start_column_byte,
+                end_row: fact.end_row,
+                end_column_byte: fact.end_column_byte,
+            });
+        }
+    }
     let recoveries = scanned
         .recoveries
         .into_iter()
@@ -210,20 +241,23 @@ fn observe(language: &str, source: &[u8], bindings: bool) -> Result<SyntaxWorker
         })
         .collect();
     Ok(SyntaxWorkerEnvelope {
-        schema_version: if bindings && !structural_observations.is_empty() {
-            "1.5.0"
-        } else if scanned.parser_error_location_unavailable {
-            "1.4.0"
-        } else if structural_observations.is_empty() {
-            "1.0.0"
-        } else if language == "cfquery" {
-            "1.3.0"
-        } else if language == "go" {
-            "1.2.0"
-        } else {
-            "1.1.0"
-        }
-        .into(),
+        schema_version:
+            if bindings && language == "erlang" && !structural_observations.is_empty() {
+                "1.6.0"
+            } else if bindings && !structural_observations.is_empty() {
+                "1.5.0"
+            } else if scanned.parser_error_location_unavailable {
+                "1.4.0"
+            } else if structural_observations.is_empty() {
+                "1.0.0"
+            } else if language == "cfquery" {
+                "1.3.0"
+            } else if language == "go" {
+                "1.2.0"
+            } else {
+                "1.1.0"
+            }
+            .into(),
         report_type: "syntax_worker_candidate".into(),
         language: language.into(),
         grammar_sha256: asset.sha256.clone(),

crates/codeguard-cli/src/syntax_worker_envelope.rs

@@ -20,12 +20,12 @@ pub struct SyntaxWorkerEnvelope {
     pub source_sha256: String,
     /// 恢复节点或遍历预算是否截断。
     pub truncated: bool,
-    /// 1.4/1.5明确记录不可定位的解析树错误；更旧版本不得携带该字段。
+    /// 1.4/1.5/1.6明确记录不可定位的解析树错误；更旧版本不得携带该字段。
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub parser_error_location_unavailable: Option<bool>,
     /// ERROR/MISSING 恢复锚点。
     pub recoveries: Vec<SyntaxWorkerRecovery>,
-    /// Python1.1、Go1.2、CFQuery1.3及显式JavaScript1.5结构观察；1.0中不存在。
+    /// Python1.1、Go1.2、CFQuery1.3及显式JavaScript1.5/Erlang1.6结构观察；1.0中不存在。
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
     pub structural_observations: Vec<crate::syntax_worker_structure::SyntaxWorkerStructure>,
 }

crates/codeguard-cli/src/syntax_worker_runner.rs

@@ -62,6 +62,30 @@ pub fn run_syntax_worker_binding_candidate(
     )
 }
 
+/// 显式观察Erlang直接form终止符；输入为冻结源码、固定语言和共享预算。
+/// 返回仅需原生确认的结构候选，项目级接线须使用相容报告协议。
+pub fn run_syntax_worker_form_candidate(
+    executable: &Path,
+    language: &str,
+    relative_path: &str,
+    source: &[u8],
+    deadline: Instant,
+    cancelled: &AtomicBool,
+) -> Result<SyntaxWorkerCandidateObservation, String> {
+    if language != "erlang" {
+        return Err("syntax_form_language_invalid".into());
+    }
+    run_candidate(
+        executable,
+        language,
+        relative_path,
+        source,
+        deadline,
+        cancelled,
+        true,
+    )
+}
+
 fn run_candidate(
     executable: &Path,
     language: &str,
@@ -81,7 +105,11 @@ fn run_candidate(
     let expected_sha = format!("{:x}", Sha256::digest(source));
     let mut args = vec![OsString::from("__syntax-worker"), OsString::from(language)];
     if bindings {
-        args.push(OsString::from("--direct-bindings"));
+        args.push(OsString::from(if language == "erlang" {
+            "--form-terminators"
+        } else {
+            "--direct-bindings"
+        }));
     }
     let spec = ProcessSpec {
         executable: executable.to_path_buf(),
@@ -107,16 +135,18 @@ fn run_candidate(
     if value["schema_version"] == "1.0.0" && value.get("structural_observations").is_some() {
         return Err("syntax_worker_version_fields_mismatch".into());
     }
-    if !matches!(value["schema_version"].as_str(), Some("1.4.0" | "1.5.0"))
-        && value.get("parser_error_location_unavailable").is_some()
+    if !matches!(
+        value["schema_version"].as_str(),
+        Some("1.4.0" | "1.5.0" | "1.6.0")
+    ) && value.get("parser_error_location_unavailable").is_some()
     {
         return Err("syntax_worker_version_fields_mismatch".into());
     }
     let report: SyntaxWorkerEnvelope =
         serde_json::from_value(value).map_err(|_| "syntax_worker_report_invalid")?;
     if !matches!(
         report.schema_version.as_str(),
-        "1.0.0" | "1.1.0" | "1.2.0" | "1.3.0" | "1.4.0" | "1.5.0"
+        "1.0.0" | "1.1.0" | "1.2.0" | "1.3.0" | "1.4.0" | "1.5.0" | "1.6.0"
     ) || (report.schema_version == "1.0.0" && !report.structural_observations.is_empty())
         || (report.schema_version == "1.1.0"
             && (language != "python" || report.structural_observations.is_empty()))
@@ -128,10 +158,15 @@ fn run_candidate(
             && (report.parser_error_location_unavailable != Some(true) || !report.truncated))
         || (report.schema_version == "1.5.0"
             && (!bindings || language != "javascript" || report.structural_observations.is_empty()))
+        || (report.schema_version == "1.6.0"
+            && (!bindings || language != "erlang" || report.structural_observations.is_empty()))
+        || (language == "erlang"
+            && !report.structural_observations.is_empty()
+            && report.schema_version != "1.6.0")
         || (language == "javascript"
             && !report.structural_observations.is_empty()
             && report.schema_version != "1.5.0")
-        || (report.schema_version == "1.5.0"
+        || (matches!(report.schema_version.as_str(), "1.5.0" | "1.6.0")
             && report
                 .parser_error_location_unavailable
                 .is_some_and(|flag| !flag || !report.truncated))

crates/codeguard-cli/src/syntax_worker_structure.rs

@@ -38,6 +38,14 @@ impl SyntaxWorkerStructure {
                     && self.parent_syntax_kind == "program"
                     && self.start_byte < self.end_byte
             }
+            "erlang" => {
+                self.rule_id == "codeguard.erlang.form_terminator"
+                    && self.rule_sha256 == codeguard_adapters::erlang_form_rule_sha256()
+                    && self.parent_syntax_kind == "fun_decl"
+                    && source
+                        .get(self.start_byte..self.end_byte)
+                        .is_some_and(|span| span.is_empty() || span == b";")
+            }
             "python" => {
                 self.rule_id == "codeguard.python.required_suite"
                     && self.rule_sha256 == codeguard_adapters::python_suite_rule_sha256()

crates/codeguard-cli/tests/erlang_form_candidates.rs

@@ -0,0 +1,71 @@
+#![cfg(all(feature = "wasm-precheck", unix))]
+use serde_json::Value;
+use std::{fs, process::Command};
+
+#[test]
+fn original_erlang_forms_preserve_legal_continuations_and_detect_missing_terminators() {
+    let cases: Value = serde_json::from_str(include_str!(
+        "../../../tests/fixtures/erlang_source_forms.json"
+    ))
+    .unwrap();
+    let root = std::env::temp_dir()
+        .canonicalize()
+        .unwrap()
+        .join(format!("cg-erlang-form-candidates-{}", std::process::id()));
+    fs::create_dir(&root).unwrap();
+    let mut reports = Vec::new();
+    for case in cases.as_array().unwrap() {
+        let path = root.join(format!("{}.erl", case["name"].as_str().unwrap()));
+        fs::write(&path, case["source"].as_str().unwrap()).unwrap();
+        let output = Command::new(env!("CARGO_BIN_EXE_codeguard"))
+            .args(["grammar", "probe", "erlang"])
+            .arg(&path)
+            .arg("--format=json")
+            .output()
+            .unwrap();
+        assert_eq!(output.status.code(), Some(3));
+        let report: Value = serde_json::from_slice(&output.stdout).unwrap();
+        let candidates = report["structural_observations"]
+            .as_array()
+            .map_or(0, Vec::len);
+        if case["valid"] == true {
+            assert_eq!(candidates, 0, "legal form {:?}: {report}", case["name"]);
+        } else if case["name"] != "bare_expression" && case["name"] != "bare_call" {
+            assert!(
+                candidates > 0,
+                "missing terminator {:?}: {report}",
+                case["name"]
+            );
+            assert_eq!(report["schema_version"], "0.7.0");
+            assert_eq!(
+                report["structural_observations"][0]["rule_id"],
+                "codeguard.erlang.form_terminator"
+            );
+        }
+        if case["name"] == "bare_expression" || case["name"] == "bare_call" {
+            assert!(
+                report["recoveries"]
+                    .as_array()
+                    .is_some_and(|rows| !rows.is_empty()),
+                "bare form lost parser recovery: {report}"
+            );
+        }
+        assert_eq!(
+            report["grammar_qualified"], false,
+            "case {:?}: {report}",
+            case["name"]
+        );
+        assert_eq!(report["native"]["status"], "not_run");
+        assert_eq!(report["delivery_decision"], "not_evaluated");
+        assert_eq!(
+            fs::read_to_string(&path).unwrap(),
+            case["source"].as_str().unwrap()
+        );
+        reports
+            .push(serde_json::json!({"name":case["name"],"valid":case["valid"],"report":report}));
+    }
+    if let Ok(path) = std::env::var("CODEGUARD_ERLANG_FORM_REPORTS") {
+        fs::write(path, serde_json::to_vec_pretty(&reports).unwrap()).unwrap();
+    }
+    fs::remove_dir_all(root).unwrap();
+}