Unify qualified-reference resolution: witness type sources and alias validation

crates/allium-parser/src/lib.rs

@@ -8,7 +8,8 @@ pub mod span;
 pub use analysis::{
     analyze, analyze_with_cross_module, analyze_with_external_refs, analyse,
     analyse_with_cross_module, analyse_with_external_refs, collect_all_referenced_idents,
-    collect_declared_names, collect_entity_field_schemas, collect_qualified_references,
+    collect_declared_names, collect_entity_field_schemas, collect_entity_status_schemas,
+    collect_qualified_references,
     collect_referenced_trigger_names, collect_reverse_contributions, collect_trigger_outputs,
     AmbiguousImports, ReverseContributions,
 };

crates/allium/src/main.rs

@@ -210,6 +210,10 @@ struct CrossModuleContext {
     /// creations, provides and witnessed transitions). Keyed by the imported
     /// (target) module, aggregated across all its importers in the check set.
     reverse_contributions: HashMap<PathBuf, ReverseContributions>,
+    /// Per-file: imported entity name → its declared status values, flattened
+    /// across every `use` alias whose target is in the check set. Lets the
+    /// importer's conflict pass attribute a rule to an imported entity.
+    imported_entity_statuses: HashMap<PathBuf, HashMap<String, HashSet<String>>>,
 }
 
 /// Shared loop for commands that process multiple .allium files.
@@ -220,7 +224,7 @@ struct CrossModuleContext {
 fn run_multi_file(
     command: &str,
     args: &[String],
-    analyse_file: impl Fn(&Path, &str, &allium_parser::ParseResult, &SourceMap, &HashSet<String>, &HashSet<String>, &HashMap<String, HashSet<String>>, &HashMap<String, HashMap<String, HashSet<String>>>, &AmbiguousImports, &ReverseContributions, &HashMap<String, HashSet<String>>) -> FileResult,
+    analyse_file: impl Fn(&Path, &str, &allium_parser::ParseResult, &SourceMap, &HashSet<String>, &HashSet<String>, &HashMap<String, HashSet<String>>, &HashMap<String, HashMap<String, HashSet<String>>>, &AmbiguousImports, &ReverseContributions, &HashMap<String, HashSet<String>>, &HashMap<String, HashSet<String>>) -> FileResult,
 ) -> ExitCode {
     let files = resolve_files(args);
     if files.is_empty() {
@@ -265,7 +269,8 @@ fn run_multi_file(
         let ambiguous = ctx.ambiguous_imports.get(&key).unwrap_or(&no_ambiguity);
         let reverse = ctx.reverse_contributions.get(&key).unwrap_or(&no_reverse);
         let referenced = ctx.imported_referenced_triggers.get(&key).cloned().unwrap_or_default();
-        let file_result = analyse_file(&pf.path, &pf.source, &pf.result, &source_map, &refs, &use_paths, &imports, &imported_fields, ambiguous, reverse, &referenced);
+        let imported_statuses = ctx.imported_entity_statuses.get(&key).cloned().unwrap_or_default();
+        let file_result = analyse_file(&pf.path, &pf.source, &pf.result, &source_map, &refs, &use_paths, &imports, &imported_fields, ambiguous, reverse, &referenced, &imported_statuses);
 
         if file_result.has_issues {
             any_issues = true;
@@ -329,6 +334,18 @@ fn build_cross_module_context(parsed: &[ParsedFile]) -> CrossModuleContext {
         })
         .collect();
 
+    // Each file's entity → status-values schema, so an importer's conflict pass
+    // can attribute a rule to an imported entity by the statuses it references.
+    let entity_status_outputs: HashMap<PathBuf, HashMap<String, HashSet<String>>> = parsed
+        .iter()
+        .map(|pf| {
+            (
+                canonical_key(&pf.path),
+                allium_parser::collect_entity_status_schemas(&pf.result.module),
+            )
+        })
+        .collect();
+
     // Pre-compute every trigger name each file references (provides, emits or
     // listens for), so an importing file can validate a qualified `provides:`
     // entry against the aliased module (#72).
@@ -359,6 +376,8 @@ fn build_cross_module_context(parsed: &[ParsedFile]) -> CrossModuleContext {
         PathBuf,
         HashMap<String, HashMap<String, HashSet<String>>>,
     > = HashMap::new();
+    let mut imported_entity_statuses: HashMap<PathBuf, HashMap<String, HashSet<String>>> =
+        HashMap::new();
     let mut ambiguous_imports: HashMap<PathBuf, AmbiguousImports> = HashMap::new();
 
     for pf in parsed {
@@ -472,6 +491,22 @@ fn build_cross_module_context(parsed: &[ParsedFile]) -> CrossModuleContext {
         }
         imported_entity_fields.insert(file_key.clone(), imported_fields_for_file);
 
+        // 3c. Imported entity status vocabularies, flattened across aliases to
+        //     entity name → status values, so the importer's conflict pass can
+        //     attribute a rule to an imported entity by the statuses it uses.
+        let mut imported_statuses_for_file: HashMap<String, HashSet<String>> = HashMap::new();
+        for target_key in alias_targets.values() {
+            if let Some(statuses) = entity_status_outputs.get(target_key) {
+                for (entity, values) in statuses {
+                    imported_statuses_for_file
+                        .entry(entity.clone())
+                        .or_default()
+                        .extend(values.iter().cloned());
+                }
+            }
+        }
+        imported_entity_statuses.insert(file_key.clone(), imported_statuses_for_file);
+
         // 4. Ambiguous imports — names declared, and triggers provided or
         //    emitted, by more than one distinct imported file. Keyed by
         //    distinct target so that two aliases for the same file are not
@@ -529,6 +564,7 @@ fn build_cross_module_context(parsed: &[ParsedFile]) -> CrossModuleContext {
         imported_referenced_triggers,
         ambiguous_imports,
         reverse_contributions,
+        imported_entity_statuses,
     }
 }
 
@@ -542,7 +578,9 @@ fn canonical_key(path: &Path) -> PathBuf {
 }
 
 fn cmd_check(args: &[String]) -> ExitCode {
-    run_multi_file("check", args, |path, source, result, source_map, external_refs, resolved_use_paths, imported_triggers, imported_entity_fields, ambiguous_imports, reverse, referenced_triggers| {
+    run_multi_file("check", args, |path, source, result, source_map, external_refs, resolved_use_paths, imported_triggers, imported_entity_fields, ambiguous_imports, reverse, referenced_triggers, _imported_entity_statuses| {
+        // `check` emits diagnostics only, not findings, so it needs no imported
+        // status vocabulary (conflicts are findings, surfaced by `analyse`).
         let analysis = allium_parser::analyze_with_cross_module(&result.module, source, external_refs, resolved_use_paths, imported_triggers, imported_entity_fields, ambiguous_imports, reverse, referenced_triggers);
         let diagnostics: Vec<serde_json::Value> = result
             .diagnostics
@@ -558,8 +596,8 @@ fn cmd_check(args: &[String]) -> ExitCode {
 }
 
 fn cmd_analyse(args: &[String]) -> ExitCode {
-    run_multi_file("analyse", args, |path, source, result, source_map, external_refs, resolved_use_paths, imported_triggers, imported_entity_fields, ambiguous_imports, reverse, referenced_triggers| {
-        let analyse_result = allium_parser::analyse_with_cross_module(&result.module, source, external_refs, resolved_use_paths, imported_triggers, imported_entity_fields, ambiguous_imports, reverse, referenced_triggers);
+    run_multi_file("analyse", args, |path, source, result, source_map, external_refs, resolved_use_paths, imported_triggers, imported_entity_fields, ambiguous_imports, reverse, referenced_triggers, imported_entity_statuses| {
+        let analyse_result = allium_parser::analyse_with_cross_module(&result.module, source, external_refs, resolved_use_paths, imported_triggers, imported_entity_fields, ambiguous_imports, reverse, referenced_triggers, imported_entity_statuses);
         let diagnostics: Vec<serde_json::Value> = result
             .diagnostics
             .iter()

crates/allium/tests/cli_smoke.rs

@@ -0,0 +1,87 @@
+//! End-to-end smoke tests for the `check`/`analyse`/`parse` commands: run the
+//! real binary on a written-out spec and assert the exit-code and output-shape
+//! contract. These guard the CLI surface itself (JSON envelope, exit codes),
+//! which the in-process analyser tests never exercise.
+
+use std::fs;
+use std::process::Command;
+
+fn allium() -> Command {
+    Command::new(env!("CARGO_BIN_EXE_allium"))
+}
+
+/// A throwaway spec file under the OS temp dir, removed on drop.
+struct SpecFile {
+    path: std::path::PathBuf,
+}
+impl SpecFile {
+    fn new(tag: &str, content: &str) -> Self {
+        let path = std::env::temp_dir().join(format!(
+            "allium-smoke-{tag}-{}.allium",
+            std::process::id()
+        ));
+        fs::write(&path, content).unwrap();
+        Self { path }
+    }
+    fn arg(&self) -> String {
+        self.path.to_string_lossy().into_owned()
+    }
+}
+impl Drop for SpecFile {
+    fn drop(&mut self) {
+        let _ = fs::remove_file(&self.path);
+    }
+}
+
+const VALID: &str = "-- allium: 3\n\n\
+    entity Job {\n    status: pending | done\n    transitions status { pending -> done  terminal: done }\n}\n\n\
+    rule CreateJob {\n    when: JobRequested()\n    ensures: Job.created(status: pending)\n}\n\n\
+    rule Finish {\n    when: j: Job.status becomes pending\n    ensures: j.status = done\n}\n\n\
+    surface JobIntake {\n    provides:\n        JobRequested()\n}\n";
+
+// References an undeclared entity `Ghost`, which is an error-severity diagnostic.
+const BROKEN: &str = "-- allium: 3\n\n\
+    rule R {\n    when: Go()\n    ensures: Ghost.created(status: pending)\n}\n";
+
+#[test]
+fn check_valid_spec_exits_zero_with_empty_reports() {
+    let spec = SpecFile::new("valid", VALID);
+    let out = allium().arg("check").arg(spec.arg()).output().expect("spawn allium");
+    assert!(out.status.success(), "expected exit 0, got {:?}", out.status);
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    assert!(stdout.contains("\"command\": \"check\""), "missing command envelope: {stdout}");
+    assert!(stdout.contains("\"diagnostics\": []"), "expected no diagnostics: {stdout}");
+    assert!(stdout.contains("\"findings\": []"), "expected no findings: {stdout}");
+}
+
+#[test]
+fn check_spec_with_error_exits_one_and_names_the_offender() {
+    let spec = SpecFile::new("broken", BROKEN);
+    let out = allium().arg("check").arg(spec.arg()).output().expect("spawn allium");
+    assert_eq!(out.status.code(), Some(1), "an error-severity diagnostic should exit 1");
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    assert!(stdout.contains("allium.rule.undefinedTypeReference"), "expected the type-ref error: {stdout}");
+    assert!(stdout.contains("\"severity\": \"error\""), "expected an error severity: {stdout}");
+    assert!(stdout.contains("Ghost"), "diagnostic should name the offending reference: {stdout}");
+}
+
+#[test]
+fn analyse_valid_spec_emits_the_json_envelope() {
+    let spec = SpecFile::new("analyse", VALID);
+    let out = allium().arg("analyse").arg(spec.arg()).output().expect("spawn allium");
+    assert!(out.status.success(), "expected exit 0, got {:?}", out.status);
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    for key in ["\"command\"", "\"diagnostics\"", "\"findings\""] {
+        assert!(stdout.contains(key), "analyse output missing {key}: {stdout}");
+    }
+    // Output must be a single well-formed JSON document.
+    serde_json::from_str::<serde_json::Value>(stdout.trim())
+        .expect("analyse stdout should be valid JSON");
+}
+
+#[test]
+fn parse_valid_spec_exits_zero() {
+    let spec = SpecFile::new("parse", VALID);
+    let out = allium().arg("parse").arg(spec.arg()).output().expect("spawn allium");
+    assert!(out.status.success(), "expected exit 0 on a well-formed spec, got {:?}", out.status);
+}

crates/allium/tests/cross_module_lifecycle.rs

@@ -970,23 +970,23 @@ fn prop_malformed_provides_entry_is_anchored() {
 
         let ok_diags = run_case("ok", &ok);
         assert!(
-            !ok_diags.iter().any(|d| d.code == "allium.provides.undefinedImportedAlias"
-                || d.code == "allium.provides.unknownTrigger"),
+            !ok_diags.iter().any(|d| d.code == "allium.reference.undefinedImportedAlias"
+                || d.code == "allium.reference.unknownName"),
             "seed {seed}: well-formed provides drew a resolution diagnostic.\n{:?}",
             ok_diags.iter().map(|d| (&d.code, &d.message)).collect::<Vec<_>>()
         );
 
         let alias_diags = run_case("badalias", &bad_alias);
         assert!(
-            alias_diags.iter().any(|d| d.code == "allium.provides.undefinedImportedAlias"
+            alias_diags.iter().any(|d| d.code == "allium.reference.undefinedImportedAlias"
                 && d.message.contains("nosuch")),
             "seed {seed}: a bad provides alias must be anchored.\n{:?}",
             alias_diags.iter().map(|d| (&d.code, &d.message)).collect::<Vec<_>>()
         );
 
         let trigger_diags = run_case("badtrigger", &bad_trigger);
         assert!(
-            trigger_diags.iter().any(|d| d.code == "allium.provides.unknownTrigger"
+            trigger_diags.iter().any(|d| d.code == "allium.reference.unknownName"
                 && d.message.contains(&absent)),
             "seed {seed}: a bad provides trigger must be anchored.\n{:?}",
             trigger_diags.iter().map(|d| (&d.code, &d.message)).collect::<Vec<_>>()