ingot init fixes

Author: Grant Wuerker

crates/common/src/dependencies/graph.rs

@@ -26,6 +26,11 @@ impl DependencyGraph {
         self.node_map(db).contains_key(url)
     }
 
+    /// Returns all URLs in the dependency graph.
+    pub fn all_urls(&self, db: &dyn InputDb) -> Vec<Url> {
+        self.node_map(db).keys().cloned().collect()
+    }
+
     /// Returns a subgraph containing all cyclic nodes and all nodes that lead to cycles.
     ///
     /// This method identifies strongly connected components (SCCs) in the graph and returns

crates/common/src/lib.rs

@@ -9,6 +9,7 @@ pub mod urlext;
 
 use dependencies::DependencyGraph;
 use file::Workspace;
+pub use tracing;
 
 #[salsa::db]
 // Each database must implement InputDb explicitly with its own storage mechanism
@@ -49,6 +50,7 @@ macro_rules! impl_db_default {
             $db_type: $crate::core::HasBuiltinCore,
         {
             fn default() -> Self {
+                $crate::tracing::info!("Initializing database");
                 let mut db = Self {
                     storage: salsa::Storage::default(),
                     index: None,

crates/driver/src/lib.rs

@@ -37,6 +37,12 @@ pub fn ingot_graph_resolver<'a>() -> IngotGraphResolver<'a> {
 
 pub fn init_ingot(db: &mut DriverDataBase, ingot_url: &Url) -> Vec<IngotInitDiagnostics> {
     tracing::info!(target: "resolver", "Starting workspace ingot resolution for: {}", ingot_url);
+
+    // Log the dependency graph URLs for debugging (before resolution)
+    let urls = db.graph().all_urls(db);
+    let urls_display: Vec<_> = urls.iter().map(|url| url.to_string()).collect();
+    tracing::info!(target: "resolver", "Dependency graph URL set (before resolution): {}", urls_display.join(", "));
+
     let mut diagnostics: Vec<IngotInitDiagnostics> = {
         let mut handler = InputHandler::from_db(db, ingot_url.clone());
         let mut ingot_graph_resolver = ingot_graph_resolver();
@@ -75,6 +81,11 @@ pub fn init_ingot(db: &mut DriverDataBase, ingot_url: &Url) -> Vec<IngotInitDiag
         all_diagnostics
     };
 
+    // Log the dependency graph URLs for debugging (after resolution)
+    let urls = db.graph().all_urls(db);
+    let urls_display: Vec<_> = urls.iter().map(|url| url.to_string()).collect();
+    tracing::info!(target: "resolver", "Dependency graph URL set (after resolution): {}", urls_display.join(", "));
+
     // Check for cycles after graph resolution (now that handler is dropped)
     let cyclic_subgraph = db.graph().cyclic_subgraph(db);
 

crates/language-server/src/backend/db.rs

@@ -12,6 +12,8 @@ impl Backend {
     pub fn new(client: ClientSocket) -> Self {
         let db = DriverDataBase::default();
 
+        tracing::info!("Initializing backend");
+
         let workers = tokio::runtime::Builder::new_multi_thread()
             .worker_threads(1)
             .enable_all()

crates/language-server/src/backend/mod.rs

@@ -55,6 +55,8 @@ async fn discover_and_load_ingots(
     backend: &mut Backend,
     root_path: &std::path::Path,
 ) -> Result<(), ResponseError> {
+    info!(target: "resolver", "workspace content {}", backend.db.workspace().all_files(&backend.db).len());
+
     // Find all fe.toml files in the workspace
     let pattern = format!("{}/**/fe.toml", root_path.to_string_lossy());
     let config_paths = glob::glob(&pattern)
@@ -103,6 +105,8 @@ async fn discover_and_load_ingots(
         }
     }
 
+    info!(target: "resolver", "workspace content 2 {}", backend.db.workspace().all_files(&backend.db).len());
+
     Ok(())
 }
 
@@ -255,6 +259,27 @@ pub async fn handle_file_change(
                     .db
                     .workspace()
                     .update(&mut backend.db, url.clone(), contents);
+
+                // If this is a .fe file, check if its ingot is loaded
+                if path.extension().and_then(|s| s.to_str()) == Some("fe") {
+                    // Walk up to find fe.toml
+                    let mut current = path.parent();
+                    while let Some(dir) = current {
+                        let fe_toml = dir.join("fe.toml");
+                        if fe_toml.exists() {
+                            // Found ingot root, check if it's loaded
+                            if let Ok(ingot_url) = Url::from_directory_path(dir) {
+                                let loaded_ingots = backend.db.graph().all_urls(&backend.db);
+                                if !loaded_ingots.contains(&ingot_url) {
+                                    info!("Ingot not loaded, initializing: {:?}", dir);
+                                    load_ingot_files(backend, dir).await?;
+                                }
+                            }
+                            break;
+                        }
+                        current = dir.parent();
+                    }
+                }
             }
         }
         ChangeKind::Create => {

crates/language-server/src/functionality/handlers.rs

@@ -33,6 +33,7 @@ use async_lsp::client_monitor::ClientProcessMonitorLayer;
 use std::sync::Arc;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use tower::ServiceBuilder;
+use tracing_subscriber::fmt::time;
 
 #[tokio::main]
 async fn main() {
@@ -59,7 +60,9 @@ async fn main() {
 async fn start_stdio_server() {
     let (server, client) = async_lsp::MainLoop::new_server(|client| {
         let tracing_layer = TracingLayer::default();
-        let lsp_service = setup(client.clone(), "LSP actor".to_string());
+
+        let pid = std::process::id();
+        let lsp_service = setup(client.clone(), format!("LSP actor {}", pid));
         ServiceBuilder::new()
             .layer(LifecycleLayer::default())
             .layer(CatchUnwindLayer::default())

crates/language-server/src/main.rs

@@ -0,0 +1,3 @@
+[ingot]
+name = "ingot_a"
+version = "0.1.0"

crates/language-server/test_files/dependency_reresolution/ingot_a/fe.toml

@@ -0,0 +1 @@
+pub fn a() -> u256 { 1 }

crates/language-server/test_files/dependency_reresolution/ingot_a/src/lib.fe

@@ -0,0 +1,6 @@
+[ingot]
+name = "ingot_b"
+version = "0.1.0"
+
+[dependencies]
+ingot_a = { path = "../ingot_a" }