misc

Author: Grant Wuerker

crates/common/src/dependencies/graph.rs

@@ -1,102 +1,161 @@
+use std::collections::{HashMap, HashSet};
+
 use petgraph::graph::{DiGraph, NodeIndex};
 use petgraph::visit::{Dfs, EdgeRef};
 use salsa::Setter;
-use smol_str::SmolStr;
-use std::collections::HashMap;
 use url::Url;
 
-use super::DependencyArguments;
+use super::{DependencyAlias, DependencyArguments, RemoteFiles};
 use crate::InputDb;
 
+type EdgeWeight = (DependencyAlias, DependencyArguments);
+
 #[salsa::input]
 #[derive(Debug)]
 pub struct DependencyGraph {
-    graph: DiGraph<Url, (SmolStr, DependencyArguments)>,
-    node_map: HashMap<Url, NodeIndex>,
+    local_graph: DiGraph<Url, EdgeWeight>,
+    local_node_map: HashMap<Url, NodeIndex>,
+    remote_graph: DiGraph<Url, EdgeWeight>,
+    remote_node_map: HashMap<Url, NodeIndex>,
+    remote_sets: HashMap<Url, Vec<Url>>,
+    git_locations: HashMap<Url, RemoteFiles>,
+    reverse_git_map: HashMap<RemoteFiles, Url>,
 }
 
 #[salsa::tracked]
 impl DependencyGraph {
     pub fn default(db: &dyn InputDb) -> Self {
-        DependencyGraph::new(db, DiGraph::new(), HashMap::new())
+        DependencyGraph::new(
+            db,
+            DiGraph::new(),
+            HashMap::new(),
+            DiGraph::new(),
+            HashMap::new(),
+            HashMap::new(),
+            HashMap::new(),
+            HashMap::new(),
+        )
+    }
+
+    fn allocate_node(
+        graph: &mut DiGraph<Url, EdgeWeight>,
+        node_map: &mut HashMap<Url, NodeIndex>,
+        url: &Url,
+    ) -> NodeIndex {
+        if let Some(&idx) = node_map.get(url) {
+            idx
+        } else {
+            let idx = graph.add_node(url.clone());
+            node_map.insert(url.clone(), idx);
+            idx
+        }
     }
 
-    /// Returns true if the given URL exists as a node in the dependency graph.
-    pub fn contains_url(&self, db: &dyn InputDb, url: &Url) -> bool {
-        self.node_map(db).contains_key(url)
+    pub fn ensure_local_node(&self, db: &mut dyn InputDb, url: &Url) {
+        if self.local_node_map(db).contains_key(url) {
+            return;
+        }
+        let mut graph = self.local_graph(db);
+        let mut node_map = self.local_node_map(db);
+        Self::allocate_node(&mut graph, &mut node_map, url);
+        self.set_local_graph(db).to(graph);
+        self.set_local_node_map(db).to(node_map);
+    }
+
+    pub fn contains_local_url(&self, db: &dyn InputDb, url: &Url) -> bool {
+        self.local_node_map(db).contains_key(url)
+    }
+
+    pub fn add_local_dependency(
+        &self,
+        db: &mut dyn InputDb,
+        source: &Url,
+        target: &Url,
+        alias: DependencyAlias,
+        arguments: DependencyArguments,
+    ) {
+        let mut graph = self.local_graph(db);
+        let mut node_map = self.local_node_map(db);
+        let source_idx = Self::allocate_node(&mut graph, &mut node_map, source);
+        let target_idx = Self::allocate_node(&mut graph, &mut node_map, target);
+        graph.add_edge(source_idx, target_idx, (alias, arguments));
+        self.set_local_graph(db).to(graph);
+        self.set_local_node_map(db).to(node_map);
     }
 
-    /// 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
-    /// a subgraph that includes:
-    /// - All nodes that are part of multi-node cycles
-    /// - All nodes that have paths leading to cyclic nodes
-    ///
-    /// Returns an empty graph if no cycles are detected.
-    pub fn cyclic_subgraph(
+    pub fn add_remote_dependency(
         &self,
-        db: &dyn InputDb,
-    ) -> DiGraph<Url, (SmolStr, DependencyArguments)> {
+        db: &mut dyn InputDb,
+        source: &Url,
+        target: &Url,
+        alias: DependencyAlias,
+        arguments: DependencyArguments,
+    ) {
+        let mut graph = self.remote_graph(db);
+        let mut node_map = self.remote_node_map(db);
+        let source_idx = Self::allocate_node(&mut graph, &mut node_map, source);
+        let target_idx = Self::allocate_node(&mut graph, &mut node_map, target);
+        graph.add_edge(source_idx, target_idx, (alias, arguments));
+        self.set_remote_graph(db).to(graph);
+        self.set_remote_node_map(db).to(node_map);
+    }
+
+    pub fn ensure_remote_node(&self, db: &mut dyn InputDb, url: &Url) {
+        if self.remote_node_map(db).contains_key(url) {
+            return;
+        }
+        let mut graph = self.remote_graph(db);
+        let mut node_map = self.remote_node_map(db);
+        Self::allocate_node(&mut graph, &mut node_map, url);
+        self.set_remote_graph(db).to(graph);
+        self.set_remote_node_map(db).to(node_map);
+    }
+
+    pub fn cyclic_subgraph(&self, db: &dyn InputDb) -> DiGraph<Url, EdgeWeight> {
         use petgraph::algo::tarjan_scc;
-        use std::collections::VecDeque;
 
-        let graph = self.graph(db);
+        let graph = self.local_graph(db);
         let sccs = tarjan_scc(&graph);
 
-        // Find actual cyclic nodes (multi-node SCCs only)
-        let mut cyclic_nodes = std::collections::HashSet::new();
+        let mut cyclic_nodes = HashSet::new();
         for scc in sccs {
             if scc.len() > 1 {
-                // Multi-node SCC = actual cycle
                 for node_idx in scc {
                     cyclic_nodes.insert(node_idx);
                 }
             }
         }
 
-        // If no cycles, return empty graph
         if cyclic_nodes.is_empty() {
             return DiGraph::new();
         }
 
-        // Use reverse DFS from cyclic nodes to find all predecessors
         let mut nodes_to_include = cyclic_nodes.clone();
-        let mut visited = std::collections::HashSet::new();
-        let mut queue = VecDeque::new();
+        let mut visited = HashSet::new();
+        let mut queue: Vec<NodeIndex> = cyclic_nodes.iter().copied().collect();
 
-        // Start from all cyclic nodes and work backwards
-        for &cyclic_node in &cyclic_nodes {
-            queue.push_back(cyclic_node);
-        }
-
-        while let Some(current) = queue.pop_front() {
-            if visited.contains(&current) {
+        while let Some(current) = queue.pop() {
+            if !visited.insert(current) {
                 continue;
             }
-            visited.insert(current);
             nodes_to_include.insert(current);
 
-            // Add all predecessors (nodes that point to current)
             for pred in graph.node_indices() {
                 if graph.find_edge(pred, current).is_some() && !visited.contains(&pred) {
-                    queue.push_back(pred);
+                    queue.push(pred);
                 }
             }
         }
 
-        // Build subgraph with all nodes that lead to cycles
         let mut subgraph = DiGraph::new();
         let mut node_map = HashMap::new();
 
-        // Add nodes
         for &node_idx in &nodes_to_include {
             let url = &graph[node_idx];
             let new_idx = subgraph.add_node(url.clone());
             node_map.insert(node_idx, new_idx);
         }
 
-        // Add edges between included nodes
         for edge in graph.edge_references() {
             if let (Some(&from_new), Some(&to_new)) =
                 (node_map.get(&edge.source()), node_map.get(&edge.target()))
@@ -108,68 +167,58 @@ impl DependencyGraph {
         subgraph
     }
 
-    /// Adds a dependency edge from one URL to another.
-    ///
-    /// Creates nodes for both URLs if they don't already exist in the graph,
-    /// then adds a directed edge from `source` to `target` with the given
-    /// alias and arguments.
-    pub fn add_dependency(
-        &self,
-        db: &mut dyn InputDb,
-        source: &Url,
-        target: &Url,
-        alias: SmolStr,
-        arguments: DependencyArguments,
-    ) {
-        let mut graph = self.graph(db);
-        let mut node_map = self.node_map(db);
-
-        // Add nodes if they don't exist
-        let source_node = if let Some(&node) = node_map.get(source) {
-            node
-        } else {
-            let node = graph.add_node(source.clone());
-            node_map.insert(source.clone(), node);
-            node
-        };
-
-        let target_node = if let Some(&node) = node_map.get(target) {
-            node
-        } else {
-            let node = graph.add_node(target.clone());
-            node_map.insert(target.clone(), node);
-            node
-        };
-
-        // Add the edge
-        graph.add_edge(source_node, target_node, (alias, arguments));
-
-        // Update the graph state
-        self.set_graph(db).to(graph);
-        self.set_node_map(db).to(node_map);
-    }
-
-    /// Returns all transitive dependencies of the given URL.
-    ///
-    /// This performs a depth-first search to find all URLs that are reachable
-    /// from the given URL through the dependency graph, excluding the URL itself.
     pub fn dependency_urls(&self, db: &dyn InputDb, url: &Url) -> Vec<Url> {
-        let node_map = self.node_map(db);
-        let graph = self.graph(db);
+        let node_map = self.local_node_map(db);
+        let graph = self.local_graph(db);
 
         if let Some(&root) = node_map.get(url) {
             let mut dfs = Dfs::new(&graph, root);
             let mut visited = Vec::new();
-
             while let Some(node) = dfs.next(&graph) {
                 if node != root {
                     visited.push(graph[node].clone());
                 }
             }
-
             visited
         } else {
             Vec::new()
         }
     }
+
+    pub fn add_remote_set(&self, db: &mut dyn InputDb, local_url: &Url, remote_root: Url) {
+        self.ensure_remote_node(db, &remote_root);
+        let mut sets = self.remote_sets(db);
+        sets.entry(local_url.clone()).or_default().push(remote_root);
+        self.set_remote_sets(db).to(sets);
+    }
+
+    pub fn remote_sets_for(&self, db: &dyn InputDb, local_url: &Url) -> Vec<Url> {
+        self.remote_sets(db)
+            .get(local_url)
+            .cloned()
+            .unwrap_or_default()
+    }
+
+    pub fn register_remote_checkout(
+        &self,
+        db: &mut dyn InputDb,
+        local_url: Url,
+        remote: RemoteFiles,
+    ) {
+        let mut git_map = self.git_locations(db);
+        git_map.insert(local_url.clone(), remote.clone());
+        self.set_git_locations(db).to(git_map);
+
+        let mut reverse = self.reverse_git_map(db);
+        reverse.insert(remote, local_url);
+        self.set_reverse_git_map(db).to(reverse);
+    }
+
+    pub fn remote_git_for_local(&self, db: &dyn InputDb, local_url: &Url) -> Option<RemoteFiles> {
+        self.git_locations(db).get(local_url).cloned()
+    }
+
+    pub fn local_for_remote_git(&self, db: &dyn InputDb, remote: &RemoteFiles) -> Option<Url> {
+        self.reverse_git_map(db).get(remote).cloned()
+    }
 }

crates/common/src/dependencies/mod.rs

@@ -12,6 +12,8 @@ pub struct DependencyArguments {
     pub version: Option<Version>,
 }
 
+pub type DependencyAlias = SmolStr;
+
 /// Metadata describing a git checkout on disk. This can later become an enum if
 /// we support multiple remote transport mechanisms.
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]

crates/common/src/file/workspace.rs

@@ -3,7 +3,7 @@ use radix_immutable::{StringPrefixView, StringTrie, Trie};
 use salsa::Setter;
 use url::Url;
 
-use crate::{InputDb, dependencies::RemoteFiles, file::File, indexmap::IndexMap};
+use crate::{InputDb, file::File, indexmap::IndexMap};
 
 #[derive(Debug)]
 pub enum InputIndexError {
@@ -15,13 +15,12 @@ pub enum InputIndexError {
 pub struct Workspace {
     files: StringTrie<Url, File>,
     paths: IndexMap<File, Url>,
-    remote_git: IndexMap<Url, RemoteFiles>,
 }
 
 #[salsa::tracked]
 impl Workspace {
     pub fn default(db: &dyn InputDb) -> Self {
-        Workspace::new(db, Trie::new(), IndexMap::default(), IndexMap::default())
+        Workspace::new(db, Trie::new(), IndexMap::default())
     }
     pub(crate) fn set(
         &self,
@@ -107,26 +106,6 @@ impl Workspace {
     pub fn all_files(&self, db: &dyn InputDb) -> StringTrie<Url, File> {
         self.files(db)
     }
-
-    pub fn register_remote_git(&self, db: &mut dyn InputDb, local_url: Url, remote: RemoteFiles) {
-        let mut map = self.remote_git(db);
-        map.insert(local_url, remote);
-        self.set_remote_git(db).to(map);
-    }
-
-    pub fn remote_git_for_local(&self, db: &dyn InputDb, local_url: &Url) -> Option<RemoteFiles> {
-        self.remote_git(db).get(local_url).cloned()
-    }
-
-    pub fn local_for_remote_git(&self, db: &dyn InputDb, remote: &RemoteFiles) -> Option<Url> {
-        self.remote_git(db).iter().find_map(|(url, stored)| {
-            if stored == remote {
-                Some(url.clone())
-            } else {
-                None
-            }
-        })
-    }
 }
 
 #[cfg(test)]

crates/common/src/ingot.rs

@@ -139,14 +139,14 @@ impl<'db> Ingot<'db> {
     #[salsa::tracked]
     pub fn dependencies(self, db: &'db dyn InputDb) -> Vec<(SmolStr, Url)> {
         let base_url = self.base(db);
-        let workspace = db.workspace();
         let mut deps = match self.config(db) {
             Some(config) => config
                 .dependencies(&base_url)
                 .into_iter()
                 .map(|dependency| {
                     let url = match &dependency.location {
-                        DependencyLocation::Remote(remote) => workspace
+                        DependencyLocation::Remote(remote) => db
+                            .dependency_graph()
                             .local_for_remote_git(db, remote)
                             .unwrap_or_else(|| remote.source.clone()),
                         DependencyLocation::Local(local) => local.url.clone(),