nx to index

Author: alshdavid

crates/atlaspack/src/requests/asset_graph_request.rs

@@ -52,8 +52,8 @@ struct AssetGraphBuilder {
   request_context: RunRequestContext,
   sender: ResultSender,
   receiver: ResultReceiver,
-  request_id_to_asset_nx: HashMap<u64, NodeIndex>,
-  request_id_to_dependency_nx: HashMap<u64, NodeIndex>,
+  request_id_to_asset_index: HashMap<u64, NodeIndex>,
+  request_id_to_dependency_index: HashMap<u64, NodeIndex>,
   waiting_asset_requests: HashMap<u64, HashSet<NodeIndex>>,
 }
 
@@ -62,14 +62,14 @@ impl AssetGraphBuilder {
     let (sender, receiver) = channel();
 
     AssetGraphBuilder {
-      request_id_to_dependency_nx: HashMap::new(),
+      request_id_to_dependency_index: HashMap::new(),
       graph: AssetGraph::new(),
       visited: HashSet::new(),
       work_count: 0,
       request_context,
       sender,
       receiver,
-      request_id_to_asset_nx: HashMap::new(),
+      request_id_to_asset_index: HashMap::new(),
       waiting_asset_requests: HashMap::new(),
     }
   }
@@ -138,16 +138,19 @@ impl AssetGraphBuilder {
   }
 
   fn handle_path_result(&mut self, result: PathRequestOutput, request_id: u64) {
-    let dependency_nx = *self
-      .request_id_to_dependency_nx
+    let dependency_index = *self
+      .request_id_to_dependency_index
       .get(&request_id)
       .expect("Missing node index for request id {request_id}");
 
     let DependencyNode {
       dependency,
       requested_symbols,
       state,
-    } = &mut self.graph.get_dependency_node_mut(&dependency_nx).unwrap();
+    } = &mut self
+      .graph
+      .get_dependency_node_mut(&dependency_index)
+      .unwrap();
 
     let asset_request = match result {
       PathRequestOutput::Resolved {
@@ -186,16 +189,18 @@ impl AssetGraphBuilder {
     let id = asset_request.id();
 
     if self.visited.insert(id) {
-      self.request_id_to_dependency_nx.insert(id, dependency_nx);
+      self
+        .request_id_to_dependency_index
+        .insert(id, dependency_index);
       self.work_count += 1;
       let _ = self
         .request_context
         .queue_request(asset_request, self.sender.clone());
-    } else if let Some(asset_node_index) = self.request_id_to_asset_nx.get(&id) {
+    } else if let Some(asset_node_index) = self.request_id_to_asset_index.get(&id) {
       // We have already completed this AssetRequest so we can connect the
       // Dependency to the Asset immediately
-      self.graph.add_edge(&dependency_nx, asset_node_index);
-      self.propagate_requested_symbols(*asset_node_index, dependency_nx);
+      self.graph.add_edge(&dependency_index, asset_node_index);
+      self.propagate_requested_symbols(*asset_node_index, dependency_index);
     } else {
       // The AssetRequest has already been kicked off but is yet to
       // complete. Register this Dependency to be connected once it
@@ -204,9 +209,9 @@ impl AssetGraphBuilder {
         .waiting_asset_requests
         .entry(id)
         .and_modify(|nodes| {
-          nodes.insert(dependency_nx);
+          nodes.insert(dependency_index);
         })
-        .or_insert_with(|| HashSet::from([dependency_nx]));
+        .or_insert_with(|| HashSet::from([dependency_index]));
     }
   }
 
@@ -233,19 +238,23 @@ impl AssetGraphBuilder {
       discovered_assets,
       dependencies,
     } = result;
-    let incoming_dependency_nx = *self
-      .request_id_to_dependency_nx
+    let incoming_dependency_index = *self
+      .request_id_to_dependency_index
       .get(&request_id)
       .expect("Missing node index for request id {request_id}");
 
     // Connect the incoming DependencyNode to the new AssetNode
-    let asset_nx = self.graph.add_asset(asset.clone());
+    let asset_index = self.graph.add_asset(asset.clone());
 
-    self.graph.add_edge(&incoming_dependency_nx, &asset_nx);
+    self
+      .graph
+      .add_edge(&incoming_dependency_index, &asset_index);
 
-    self.request_id_to_asset_nx.insert(request_id, asset_nx);
+    self
+      .request_id_to_asset_index
+      .insert(request_id, asset_index);
 
-    let root_asset = (&asset, asset_nx);
+    let root_asset = (&asset, asset_index);
     let mut added_discovered_assets: HashMap<String, NodeIndex> = HashMap::new();
 
     // Attach the "direct" discovered assets to the graph
@@ -255,7 +264,7 @@ impl AssetGraphBuilder {
 
       self
         .graph
-        .add_edge(&incoming_dependency_nx, &asset_node_index);
+        .add_edge(&incoming_dependency_index, &asset_node_index);
 
       self.add_asset_dependencies(
         &discovered_asset.dependencies,
@@ -264,25 +273,25 @@ impl AssetGraphBuilder {
         &mut added_discovered_assets,
         root_asset,
       );
-      self.propagate_requested_symbols(asset_node_index, incoming_dependency_nx);
+      self.propagate_requested_symbols(asset_node_index, incoming_dependency_index);
     }
 
     self.add_asset_dependencies(
       &dependencies,
       &discovered_assets,
-      asset_nx,
+      asset_index,
       &mut added_discovered_assets,
       root_asset,
     );
 
-    self.propagate_requested_symbols(asset_nx, incoming_dependency_nx);
+    self.propagate_requested_symbols(asset_index, incoming_dependency_index);
 
     // Connect any previously discovered Dependencies that were waiting
     // for this AssetNode to be created
     if let Some(waiting) = self.waiting_asset_requests.remove(&request_id) {
       for dep in waiting {
-        self.graph.add_edge(&dep, &asset_nx);
-        self.propagate_requested_symbols(asset_nx, dep);
+        self.graph.add_edge(&dep, &asset_index);
+        self.propagate_requested_symbols(asset_index, dep);
       }
     }
   }
@@ -388,13 +397,13 @@ impl AssetGraphBuilder {
       &mut self.graph,
       asset_node_index,
       incoming_dep_node_index,
-      &mut |dependency_nx, dependency| {
+      &mut |dependency_index, dependency| {
         Self::on_undeferred(
-          &mut self.request_id_to_dependency_nx,
+          &mut self.request_id_to_dependency_index,
           &mut self.work_count,
           &mut self.request_context,
           &self.sender,
-          dependency_nx,
+          dependency_index,
           dependency,
         );
       },
@@ -415,7 +424,7 @@ impl AssetGraphBuilder {
         dependency: Arc::new(dependency),
       };
       self
-        .request_id_to_dependency_nx
+        .request_id_to_dependency_index
         .insert(request.id(), dep_node);
       self.work_count += 1;
       let _ = self
@@ -430,18 +439,18 @@ impl AssetGraphBuilder {
   /// Once they do have symbols in use, this callback will re-trigger resolution/transformation
   /// for those files.
   fn on_undeferred(
-    request_id_to_asset_nx: &mut HashMap<u64, NodeIndex>,
+    request_id_to_asset_index: &mut HashMap<u64, NodeIndex>,
     work_count: &mut u32,
     request_context: &mut RunRequestContext,
     sender: &ResultSender,
-    dependency_nx: NodeIndex,
+    dependency_index: NodeIndex,
     dependency: Arc<Dependency>,
   ) {
     let request = PathRequest {
       dependency: dependency.clone(),
     };
 
-    request_id_to_asset_nx.insert(request.id(), dependency_nx);
+    request_id_to_asset_index.insert(request.id(), dependency_index);
     tracing::debug!(
       "queueing a path request from on_undeferred, {}",
       dependency.specifier