Diagnose references through a use path that resolves nowhere (#92)

Author: yenda

crates/allium-parser/src/analysis.rs

@@ -119,6 +119,7 @@ pub fn analyze_with_cross_module(
     ambiguous_imports: &AmbiguousImports,
     reverse: &ReverseContributions,
     imported_referenced_triggers: &HashMap<String, HashSet<String>>,
+    missing_use_paths: &HashSet<String>,
 ) -> Vec<Diagnostic> {
     let mut ctx = Ctx::new(
         module,
@@ -130,6 +131,7 @@ pub fn analyze_with_cross_module(
     ctx.imported_entity_fields = Some(imported_entity_fields);
     ctx.reverse_contributions = Some(reverse);
     ctx.imported_referenced_triggers = Some(imported_referenced_triggers);
+    ctx.missing_use_paths = Some(missing_use_paths);
     run_checks(ctx, source)
 }
 
@@ -207,6 +209,7 @@ pub fn analyse_with_cross_module(
     reverse: &ReverseContributions,
     imported_referenced_triggers: &HashMap<String, HashSet<String>>,
     imported_entity_statuses: &HashMap<String, HashSet<String>>,
+    missing_use_paths: &HashSet<String>,
 ) -> crate::diagnostic::AnalyseResult {
     let diagnostics = analyze_with_cross_module(
         module,
@@ -218,6 +221,7 @@ pub fn analyse_with_cross_module(
         ambiguous_imports,
         reverse,
         imported_referenced_triggers,
+        missing_use_paths,
     );
     let findings = find_process_issues(
         module,
@@ -421,6 +425,12 @@ struct Ctx<'a> {
     /// entities and triggers. `None` in single-file mode (and effectively empty
     /// when no importer references this module).
     reverse_contributions: Option<&'a ReverseContributions>,
+    /// Multi-file mode only: `use` path strings that resolve neither to a file
+    /// in the check set nor to a file on disk — a broken import, as opposed to
+    /// an out-of-set one. References through an alias bound to such a path are
+    /// diagnosed rather than left unknowable. `None` in single-file mode and
+    /// for callers without filesystem access (they behave as before).
+    missing_use_paths: Option<&'a HashSet<String>>,
     diagnostics: Vec<Diagnostic>,
     findings: Vec<crate::diagnostic::Finding>,
 }
@@ -442,6 +452,7 @@ impl<'a> Ctx<'a> {
             imported_entity_fields: None,
             imported_referenced_triggers: None,
             reverse_contributions: None,
+            missing_use_paths: None,
             diagnostics: Vec::new(),
             findings: Vec::new(),
         }
@@ -5981,6 +5992,30 @@ impl Ctx<'_> {
             })
             .collect();
 
+        // Aliases whose use path resolves neither in the check set nor on
+        // disk: the import is broken, not merely out of set. References
+        // through such an alias resolve against nothing, so each one is
+        // diagnosed — independent of the use-line unresolvedPath warning,
+        // which a per-line allium-ignore can suppress.
+        let broken_alias_paths: HashMap<&str, &str> = match self.missing_use_paths {
+            Some(missing) => self
+                .module
+                .declarations
+                .iter()
+                .filter_map(|d| match d {
+                    Decl::Use(u) => {
+                        let path = u.path.text();
+                        let alias = u.alias.as_ref()?;
+                        missing
+                            .get(&path)
+                            .map(|p| (alias.name.as_str(), p.as_str()))
+                    }
+                    _ => None,
+                })
+                .collect(),
+            None => HashMap::new(),
+        };
+
         let mut refs = collect_qref_nodes(self.module);
         // A `default alias/Type` reference's qualifier sits on the declaration,
         // not inside its value expression, so add it explicitly.
@@ -6009,6 +6044,17 @@ impl Ctx<'_> {
                     )
                     .with_code("allium.reference.undefinedImportedAlias"),
                 );
+            } else if let Some(path) = broken_alias_paths.get(r.qualifier) {
+                self.push(
+                    Diagnostic::warning(
+                        r.span,
+                        format!(
+                            "Reference '{}/{}' goes through use path \"{}\", which does not resolve to a file in the check set or on disk.",
+                            r.qualifier, r.name, path
+                        ),
+                    )
+                    .with_code("allium.reference.unresolvedImport"),
+                );
             } else if let Some(offered) = self
                 .imported_referenced_triggers
                 .and_then(|m| m.get(r.qualifier))
@@ -7597,6 +7643,7 @@ mod tests {
             &AmbiguousImports::default(),
             &ReverseContributions::default(),
             &HashMap::new(),
+            &HashSet::new(),
         )
     }
 
@@ -7646,6 +7693,7 @@ mod tests {
             &ambiguous,
             &ReverseContributions::default(),
             &HashMap::new(),
+            &HashSet::new(),
         )
     }
 
@@ -8228,7 +8276,7 @@ surface AccountManagement {
         let input = format!("-- allium: 3\n{src}");
         let result = parse(&input);
         let resolved: HashSet<String> = ["./core.allium".to_string()].into_iter().collect();
-        let ds = analyze_with_cross_module(&result.module, &input, &HashSet::new(), &resolved, &HashMap::new(), &HashMap::new(), &AmbiguousImports::default(), &ReverseContributions::default(), &HashMap::new());
+        let ds = analyze_with_cross_module(&result.module, &input, &HashSet::new(), &resolved, &HashMap::new(), &HashMap::new(), &AmbiguousImports::default(), &ReverseContributions::default(), &HashMap::new(), &HashSet::new());
         assert!(!has_code(&ds, "allium.use.unresolvedPath"));
     }
 
@@ -8239,7 +8287,7 @@ surface AccountManagement {
         let result = parse(&input);
         // Only "./other.allium" is resolved — "./missing.allium" is not.
         let resolved: HashSet<String> = ["./other.allium".to_string()].into_iter().collect();
-        let ds = analyze_with_cross_module(&result.module, &input, &HashSet::new(), &resolved, &HashMap::new(), &HashMap::new(), &AmbiguousImports::default(), &ReverseContributions::default(), &HashMap::new());
+        let ds = analyze_with_cross_module(&result.module, &input, &HashSet::new(), &resolved, &HashMap::new(), &HashMap::new(), &AmbiguousImports::default(), &ReverseContributions::default(), &HashMap::new(), &HashSet::new());
         assert!(has_code(&ds, "allium.use.unresolvedPath"));
     }
 
@@ -8260,7 +8308,7 @@ surface AccountManagement {
         let src = "use \"./missing.allium\" as missing\n\nentity Handler {\n  x: String\n}\n";
         let input = format!("-- allium: 3\n{src}");
         let result = parse(&input);
-        let ds = analyze_with_cross_module(&result.module, &input, &HashSet::new(), &HashSet::new(), &HashMap::new(), &HashMap::new(), &AmbiguousImports::default(), &ReverseContributions::default(), &HashMap::new());
+        let ds = analyze_with_cross_module(&result.module, &input, &HashSet::new(), &HashSet::new(), &HashMap::new(), &HashMap::new(), &AmbiguousImports::default(), &ReverseContributions::default(), &HashMap::new(), &HashSet::new());
         assert!(has_code(&ds, "allium.use.unresolvedPath"));
     }
 
@@ -8270,7 +8318,7 @@ surface AccountManagement {
         let input = format!("-- allium: 3\n{src}");
         let result = parse(&input);
         let resolved: HashSet<String> = ["./other.allium".to_string()].into_iter().collect();
-        let ds = analyze_with_cross_module(&result.module, &input, &HashSet::new(), &resolved, &HashMap::new(), &HashMap::new(), &AmbiguousImports::default(), &ReverseContributions::default(), &HashMap::new());
+        let ds = analyze_with_cross_module(&result.module, &input, &HashSet::new(), &resolved, &HashMap::new(), &HashMap::new(), &AmbiguousImports::default(), &ReverseContributions::default(), &HashMap::new(), &HashSet::new());
         let diag = ds.iter().find(|d| d.code == Some("allium.use.unresolvedPath")).unwrap();
         assert!(diag.message.contains("nowhere.allium"), "message should name the path: {}", diag.message);
     }
@@ -8281,7 +8329,7 @@ surface AccountManagement {
         let input = format!("-- allium: 3\n{src}");
         let result = parse(&input);
         let resolved: HashSet<String> = ["./other.allium".to_string()].into_iter().collect();
-        let ds = analyze_with_cross_module(&result.module, &input, &HashSet::new(), &resolved, &HashMap::new(), &HashMap::new(), &AmbiguousImports::default(), &ReverseContributions::default(), &HashMap::new());
+        let ds = analyze_with_cross_module(&result.module, &input, &HashSet::new(), &resolved, &HashMap::new(), &HashMap::new(), &AmbiguousImports::default(), &ReverseContributions::default(), &HashMap::new(), &HashSet::new());
         assert!(!has_code(&ds, "allium.use.unresolvedPath"));
     }
 
@@ -8291,7 +8339,7 @@ surface AccountManagement {
         let input = format!("-- allium: 3\n{src}");
         let result = parse(&input);
         let resolved: HashSet<String> = ["./found.allium".to_string()].into_iter().collect();
-        let ds = analyze_with_cross_module(&result.module, &input, &HashSet::new(), &resolved, &HashMap::new(), &HashMap::new(), &AmbiguousImports::default(), &ReverseContributions::default(), &HashMap::new());
+        let ds = analyze_with_cross_module(&result.module, &input, &HashSet::new(), &resolved, &HashMap::new(), &HashMap::new(), &AmbiguousImports::default(), &ReverseContributions::default(), &HashMap::new(), &HashSet::new());
         let unresolved: Vec<_> = ds.iter()
             .filter(|d| d.code == Some("allium.use.unresolvedPath"))
             .collect();

crates/allium/src/main.rs

@@ -222,6 +222,10 @@ struct CrossModuleContext {
     /// 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>>>,
+    /// Per-file: use path strings that resolve neither to a file in the check
+    /// set nor to a file on disk — broken imports, as opposed to out-of-set
+    /// ones. References through their aliases are diagnosed per reference.
+    missing_use_paths: HashMap<PathBuf, HashSet<String>>,
 }
 
 /// Shared loop for commands that process multiple .allium files.
@@ -232,7 +236,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>>, &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>>, &HashSet<String>) -> FileResult,
 ) -> ExitCode {
     let files = resolve_files(args);
     if files.is_empty() {
@@ -278,7 +282,8 @@ fn run_multi_file(
         let reverse = ctx.reverse_contributions.get(&key).unwrap_or(&no_reverse);
         let referenced = ctx.imported_referenced_triggers.get(&key).cloned().unwrap_or_default();
         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);
+        let missing = ctx.missing_use_paths.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, &missing);
 
         if file_result.has_issues {
             any_issues = true;
@@ -387,6 +392,7 @@ fn build_cross_module_context(parsed: &[ParsedFile]) -> CrossModuleContext {
     let mut imported_entity_statuses: HashMap<PathBuf, HashMap<String, HashSet<String>>> =
         HashMap::new();
     let mut ambiguous_imports: HashMap<PathBuf, AmbiguousImports> = HashMap::new();
+    let mut missing_use_paths: HashMap<PathBuf, HashSet<String>> = HashMap::new();
 
     for pf in parsed {
         // For bare filenames (no directory component), parent() returns "".
@@ -396,10 +402,14 @@ fn build_cross_module_context(parsed: &[ParsedFile]) -> CrossModuleContext {
         let file_key = canonical_key(&pf.path);
 
         // Collect use declarations: alias → use-path string, and resolve each
-        // against the check set. Also build alias → canonical target key.
+        // against the check set. Also build alias → canonical target key, and
+        // note paths that resolve neither in the check set nor on disk — a
+        // broken import, distinct from an on-disk file merely outside a
+        // narrower check set (a single-file check of one member of a pair).
         let mut aliases: HashMap<&str, String> = HashMap::new();
         let mut alias_targets: HashMap<&str, PathBuf> = HashMap::new();
         let mut resolved_for_file: HashSet<String> = HashSet::new();
+        let mut missing_for_file: HashSet<String> = HashSet::new();
 
         for d in &pf.result.module.declarations {
             if let allium_parser::ast::Decl::Use(u) = d {
@@ -409,6 +419,12 @@ fn build_cross_module_context(parsed: &[ParsedFile]) -> CrossModuleContext {
 
                 if check_set.contains(&target_key) {
                     resolved_for_file.insert(path_text.clone());
+                } else if path_text.ends_with(".allium") && !target.exists() {
+                    // Only local file references (ending .allium) can be
+                    // broken. Registry coordinates (`github.com/org/spec/sha`)
+                    // are immutable remote references that are not expected on
+                    // disk; they stay out-of-set, never broken.
+                    missing_for_file.insert(path_text.clone());
                 }
 
                 if let Some(alias) = &u.alias {
@@ -417,6 +433,7 @@ fn build_cross_module_context(parsed: &[ParsedFile]) -> CrossModuleContext {
                 }
             }
         }
+        missing_use_paths.insert(file_key.clone(), missing_for_file);
 
         // 0. Reverse contributions — for each alias resolving to a module in the
         //    check set, the contributions this importer makes back to it
@@ -573,6 +590,7 @@ fn build_cross_module_context(parsed: &[ParsedFile]) -> CrossModuleContext {
         ambiguous_imports,
         reverse_contributions,
         imported_entity_statuses,
+        missing_use_paths,
     }
 }
 
@@ -586,10 +604,10 @@ 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, _imported_entity_statuses| {
+    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, missing_use_paths| {
         // `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 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, missing_use_paths);
         let diagnostics: Vec<serde_json::Value> = result
             .diagnostics
             .iter()
@@ -604,8 +622,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, 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);
+    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, missing_use_paths| {
+        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, missing_use_paths);
         let diagnostics: Vec<serde_json::Value> = result
             .diagnostics
             .iter()