ingot file resolution diagnostics

Author: Grant Wuerker

crates/driver/src/lib.rs

@@ -15,18 +15,28 @@ pub use db::DriverDataBase;
 use common::config::Config;
 use hir::hir_def::TopLevelMod;
 use resolver::{
-    files::{File, FilesResolutionDiagnostic, FilesResolutionError, FilesResolver},
-    graph::{DiGraph, GraphResolutionHandler, GraphResolver},
-    ingot::ingot_graph_resolver,
+    files::{FilesResource, FilesResolutionDiagnostic, FilesResolutionError, FilesResolver},
+    graph::{DiGraph, GraphResolutionHandler, GraphResolver, GraphResolverImpl},
     ResolutionHandler, Resolver,
 };
 use url::Url;
 
+pub type CheckIngotGraphResolver<'a> = GraphResolverImpl<FilesResolver, InputHandler<'a>, EdgeWeight>;
+
+pub fn check_ingot_graph_resolver<'a>() -> CheckIngotGraphResolver<'a> {
+    let files_resolver = FilesResolver::new()
+        .with_required_file("fe.toml")
+        .with_required_directory("src")
+        .with_required_file("src/lib.fe")
+        .with_pattern("src/**/*.fe");
+    GraphResolverImpl::new(files_resolver)
+}
+
 pub fn init_ingot(db: &mut DriverDataBase, ingot_url: &Url) -> Vec<IngotInitDiagnostics> {
     tracing::trace!(target: "resolver", "Starting workspace ingot resolution for: {}", ingot_url);
     let mut diagnostics: Vec<IngotInitDiagnostics> = {
-        let mut handler = InputHandler::from_db(db);
-        let mut ingot_graph_resolver = ingot_graph_resolver::<InputHandler>();
+        let mut handler = InputHandler::from_db(db, ingot_url.clone());
+        let mut ingot_graph_resolver = check_ingot_graph_resolver();
 
         // Handle resolution errors gracefully instead of panicking
         if let Err(err) = ingot_graph_resolver.graph_resolve(&mut handler, ingot_url) {
@@ -115,6 +125,10 @@ pub enum IngotInitDiagnostics {
         ingot_url: Url,
         diagnostic: common::config::ConfigDiagnostic,
     },
+    MissingRootFile {
+        ingot_url: Url,
+        is_main_ingot: bool,
+    },
 }
 
 impl std::fmt::Display for IngotInitDiagnostics {
@@ -165,6 +179,13 @@ impl std::fmt::Display for IngotInitDiagnostics {
             } => {
                 write!(f, "there are issues with the local fe.toml file {ingot_url}fe.toml\n  {diagnostic}")
             }
+            IngotInitDiagnostics::MissingRootFile { ingot_url, is_main_ingot } => {
+                if *is_main_ingot {
+                    write!(f, "Missing root file (src/lib.fe) in current ingot: {ingot_url}")
+                } else {
+                    write!(f, "Missing root file (src/lib.fe) in dependency: {ingot_url}")
+                }
+            }
         }
     }
 }
@@ -173,25 +194,28 @@ pub struct InputHandler<'a> {
     pub db: &'a mut dyn InputDb,
     pub join_edges: Vec<JoinEdge>,
     pub diagnostics: Vec<IngotInitDiagnostics>,
+    pub main_ingot_url: Url,
 }
 
 impl<'a> InputHandler<'a> {
-    pub fn from_db(db: &'a mut dyn InputDb) -> Self {
+    pub fn from_db(db: &'a mut dyn InputDb, main_ingot_url: Url) -> Self {
         Self {
             db,
             join_edges: vec![],
             diagnostics: vec![],
+            main_ingot_url,
         }
     }
 }
 
 impl<'a> ResolutionHandler<FilesResolver> for InputHandler<'a> {
     type Item = Vec<(Url, EdgeWeight)>;
 
-    fn handle_resolution(&mut self, ingot_url: &Url, files: Vec<File>) -> Self::Item {
+    fn handle_resolution(&mut self, ingot_url: &Url, resource: FilesResource) -> Self::Item {
         let mut config = None;
 
-        for file in files {
+
+        for file in resource.files {
             if file.path.ends_with("fe.toml") {
                 self.db.workspace().touch(
                     self.db,
@@ -231,6 +255,8 @@ impl<'a> ResolutionHandler<FilesResolver> for InputHandler<'a> {
                     });
             }
 
+            // Missing src/lib.fe file is now handled by the FilesResolver diagnostics
+
             // let weights: HashSet<Url> = self.db.graph().node_weights().cloned().collect();
 
             config
@@ -259,10 +285,7 @@ impl<'a> ResolutionHandler<FilesResolver> for InputHandler<'a> {
                 })
                 .collect()
         } else {
-            // No fe.toml file found - record this as a diagnostic
-            self.diagnostics.push(IngotInitDiagnostics::MissingFeToml {
-                ingot_url: ingot_url.clone(),
-            });
+            // No fe.toml file found - this will be reported by the FilesResolver as a diagnostic
             vec![]
         }
     }

crates/fe/src/tree.rs

@@ -3,14 +3,15 @@ use std::collections::{HashMap, HashSet};
 use camino::Utf8PathBuf;
 use common::{config::Config, graph::EdgeWeight, urlext::canonical_url};
 use resolver::{
-    graph::{petgraph, DiGraph, GraphResolver, NodeIndex},
-    ingot::BasicIngotNodeHandler,
+    files::{FilesResource, FilesResolver},
+    graph::{petgraph, DiGraph, GraphResolver, GraphResolutionHandler, NodeIndex},
+    ResolutionHandler,
 };
 use url::Url;
 
 pub fn print_tree(path: &Utf8PathBuf) {
-    let mut graph_resolver = resolver::ingot::basic_ingot_graph_resolver();
-    let mut node_handler = BasicIngotNodeHandler::default();
+    let mut graph_resolver = basic_ingot_graph_resolver();
+    let mut node_handler = TreeIngotNodeHandler::default();
     let ingot_url = match canonical_url(path) {
         Ok(url) => url,
         Err(_) => {
@@ -21,12 +22,36 @@ pub fn print_tree(path: &Utf8PathBuf) {
 
     match graph_resolver.graph_resolve(&mut node_handler, &ingot_url) {
         Ok(ingot_graph) => {
+            // Report diagnostics from graph resolution first
+            let graph_diagnostics = graph_resolver.take_diagnostics();
+            for diagnostic in &graph_diagnostics {
+                eprintln!("⚠️  {}", diagnostic);
+            }
+
+            // Report diagnostics from node handler
+            let node_diagnostics = node_handler.diagnostics();
+            for diagnostic in node_diagnostics {
+                eprintln!("⚠️  {}", diagnostic);
+            }
+
+            // Print tree after diagnostics
             print!(
                 "{}",
                 print_tree_impl(&ingot_graph, &ingot_url, &node_handler.configs)
             );
         }
         Err(err) => {
+            // Even if resolution failed, show available diagnostics first
+            let graph_diagnostics = graph_resolver.take_diagnostics();
+            for diagnostic in &graph_diagnostics {
+                eprintln!("⚠️  {}", diagnostic);
+            }
+
+            let node_diagnostics = node_handler.diagnostics();
+            for diagnostic in node_diagnostics {
+                eprintln!("⚠️  {}", diagnostic);
+            }
+
             println!("❌ Failed to resolve dependency tree: {err}");
         }
     }
@@ -199,3 +224,97 @@ fn find_cycle_nodes<N, E>(graph: &DiGraph<N, E>) -> HashSet<NodeIndex> {
     }
     cycles
 }
+
+// Tree-specific ingot resolution types and functions
+
+pub type TreeIngotGraphResolver = resolver::graph::GraphResolverImpl<FilesResolver, TreeIngotNodeHandler, EdgeWeight>;
+
+pub fn basic_ingot_graph_resolver() -> TreeIngotGraphResolver {
+    let files_resolver = FilesResolver::new()
+        .with_required_file("fe.toml");
+    resolver::graph::GraphResolverImpl::new(files_resolver)
+}
+
+#[derive(Debug)]
+pub enum IngotResolutionDiagnostic {
+    ConfigParseWarning(Url, String),
+}
+
+impl std::fmt::Display for IngotResolutionDiagnostic {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            IngotResolutionDiagnostic::ConfigParseWarning(url, msg) => {
+                write!(f, "Warning parsing config at {url}: {msg}")
+            }
+        }
+    }
+}
+
+#[derive(Default)]
+pub struct TreeIngotNodeHandler {
+    pub configs: HashMap<Url, Config>,
+    pub diagnostics: Vec<IngotResolutionDiagnostic>,
+}
+
+impl TreeIngotNodeHandler {
+    pub fn diagnostics(&self) -> &[IngotResolutionDiagnostic] {
+        &self.diagnostics
+    }
+}
+
+impl ResolutionHandler<FilesResolver> for TreeIngotNodeHandler {
+    type Item = Vec<(Url, EdgeWeight)>;
+
+    fn handle_resolution(&mut self, ingot_url: &Url, resource: FilesResource) -> Self::Item {
+        tracing::trace!(target: "resolver", "Handling ingot resolution for: {}", ingot_url);
+        
+        // Look for fe.toml file
+        if let Some(config_file) = resource.files.iter().find(|f| f.path.file_name() == Some("fe.toml")) {
+            match Config::parse(&config_file.content) {
+                Ok(config) => {
+                    tracing::trace!(target: "resolver", "Successfully parsed config for ingot: {}", ingot_url);
+                    self.configs.insert(ingot_url.clone(), config.clone());
+                    let dependencies = config
+                        .based_dependencies(ingot_url)
+                        .into_iter()
+                        .map(|based_dependency| {
+                            tracing::trace!(target: "resolver", "Found dependency: {} -> {}", ingot_url, based_dependency.url);
+                            (
+                                based_dependency.url,
+                                EdgeWeight {
+                                    alias: based_dependency.alias,
+                                    arguments: based_dependency.parameters,
+                                },
+                            )
+                        })
+                        .collect();
+                    dependencies
+                }
+                Err(err) => {
+                    tracing::warn!(target: "resolver", "Failed to parse config for ingot {}: {}", ingot_url, err);
+                    self.diagnostics
+                        .push(IngotResolutionDiagnostic::ConfigParseWarning(
+                            ingot_url.clone(),
+                            err.to_string(),
+                        ));
+                    vec![]
+                }
+            }
+        } else {
+            // This case should not happen since we require fe.toml, but handle it gracefully
+            vec![]
+        }
+    }
+}
+
+impl GraphResolutionHandler<Url, DiGraph<Url, EdgeWeight>> for TreeIngotNodeHandler {
+    type Item = DiGraph<Url, EdgeWeight>;
+
+    fn handle_graph_resolution(
+        &mut self,
+        _ingot_url: &Url,
+        graph: DiGraph<Url, EdgeWeight>,
+    ) -> Self::Item {
+        graph
+    }
+}

crates/fe/tests/fixtures/cli_output/ingots/missing_dep/missing_dep.snap

@@ -3,8 +3,6 @@ source: crates/fe/tests/cli_output.rs
 expression: output
 ---
 === STDERR ===
-there are issues with the local fe.toml file file://<project>/crates/fe/tests/fixtures/cli_output/ingots/missing_dep/fe.toml
-  dependencies are not yet supported
-Failed to resolve ingot dependency 'file://<project>/crates/fe/tests/fixtures/cli_output/ingots/nonexistent/': File URL does not exist: file://<project>/crates/fe/tests/fixtures/cli_output/ingots/nonexistent/
+Failed to resolve ingot dependency 'file://<project>/crates/fe/tests/fixtures/cli_output/ingots/nonexistent/': Directory does not exist: file://<project>/crates/fe/tests/fixtures/cli_output/ingots/nonexistent/
 
 === EXIT CODE: 1 ===

crates/fe/tests/fixtures/cli_output/ingots/missing_src/missing_src.snap

@@ -1,9 +1,9 @@
 ---
 source: crates/fe/tests/cli_output.rs
-assertion_line: 78
 expression: output
 ---
 === STDERR ===
-source files resolution error: `src` folder does not exist in the ingot directory
+File resolution error: Missing required directory 'src' in ingot at file://<project>/crates/fe/tests/fixtures/cli_output/ingots/missing_src/
+File resolution error: Missing required file 'src/lib.fe' in ingot at file://<project>/crates/fe/tests/fixtures/cli_output/ingots/missing_src/
 
 === EXIT CODE: 1 ===