Remove the Vec<Job> from DependencyQueue

I... don't think this needed any more! Doing some digging looks like
this was originally added in 79768eb. That was so early it didn't even
use a PR and was almost 5 years ago. Since then we've had a huge number
of changes to the backend and `Unit` nowadays does all the deduplication
we need, so no need to store a `Vec` here and we can just have a mapping
of `Key` to `Job` and that's it.

Author: alexcrichton

src/cargo/core/compiler/job_queue.rs

@@ -32,24 +32,17 @@ use crate::util::{Progress, ProgressStyle};
 /// actual compilation step of each package. Packages enqueue units of work and
 /// then later on the entire graph is processed and compiled.
 pub struct JobQueue<'a, 'cfg> {
-    queue: DependencyQueue<Key<'a>, Vec<Job>>,
+    queue: DependencyQueue<Key<'a>, Job>,
     tx: Sender<Message<'a>>,
     rx: Receiver<Message<'a>>,
     active: Vec<Key<'a>>,
-    pending: HashMap<Key<'a>, PendingBuild>,
     compiled: HashSet<PackageId>,
     documented: HashSet<PackageId>,
     counts: HashMap<PackageId, usize>,
     is_release: bool,
     progress: Progress<'cfg>,
 }
 
-/// A helper structure for metadata about the state of a building package.
-struct PendingBuild {
-    /// The number of jobs currently active.
-    amt: usize,
-}
-
 #[derive(Clone, Copy, Eq, PartialEq, Hash)]
 struct Key<'a> {
     pkg: PackageId,
@@ -140,7 +133,6 @@ impl<'a, 'cfg> JobQueue<'a, 'cfg> {
             tx,
             rx,
             active: Vec::new(),
-            pending: HashMap::new(),
             compiled: HashSet::new(),
             documented: HashSet::new(),
             counts: HashMap::new(),
@@ -157,7 +149,7 @@ impl<'a, 'cfg> JobQueue<'a, 'cfg> {
     ) -> CargoResult<()> {
         let key = Key::new(unit);
         let deps = key.dependencies(cx)?;
-        self.queue.queue(&key, Vec::new(), &deps).push(job);
+        self.queue.queue(&key, job, &deps);
         *self.counts.entry(key.pkg).or_insert(0) += 1;
         Ok(())
     }
@@ -236,13 +228,10 @@ impl<'a, 'cfg> JobQueue<'a, 'cfg> {
             // possible that can run. Note that this is also the point where we
             // start requesting job tokens. Each job after the first needs to
             // request a token.
-            while let Some((key, jobs)) = self.queue.dequeue() {
-                self.pending.insert(key, PendingBuild { amt: jobs.len() });
-                for job in jobs {
-                    queue.push((key, job));
-                    if !self.active.is_empty() || !queue.is_empty() {
-                        jobserver_helper.request_token();
-                    }
+            while let Some((key, job)) = self.queue.dequeue() {
+                queue.push((key, job));
+                if !self.active.is_empty() || !queue.is_empty() {
+                    jobserver_helper.request_token();
                 }
             }
 
@@ -463,12 +452,7 @@ impl<'a, 'cfg> JobQueue<'a, 'cfg> {
         if key.mode.is_run_custom_build() && cx.bcx.show_warnings(key.pkg) {
             self.emit_warnings(None, &key, cx)?;
         }
-
-        let state = self.pending.get_mut(&key).unwrap();
-        state.amt -= 1;
-        if state.amt == 0 {
-            self.queue.finish(&key);
-        }
+        self.queue.finish(&key);
         Ok(())
     }
 

src/cargo/util/dependency_queue.rs

@@ -4,7 +4,6 @@
 //! This structure is used to store the dependency graph and dynamically update
 //! it to figure out when a dependency should be built.
 
-use std::collections::hash_map::Entry::{Occupied, Vacant};
 use std::collections::{HashMap, HashSet};
 use std::hash::Hash;
 
@@ -53,11 +52,8 @@ impl<K: Hash + Eq + Clone, V> DependencyQueue<K, V> {
     ///
     /// It is assumed that any dependencies of this package will eventually also
     /// be added to the dependency queue.
-    pub fn queue(&mut self, key: &K, value: V, dependencies: &[K]) -> &mut V {
-        let slot = match self.dep_map.entry(key.clone()) {
-            Occupied(v) => return &mut v.into_mut().1,
-            Vacant(v) => v,
-        };
+    pub fn queue(&mut self, key: &K, value: V, dependencies: &[K]) {
+        assert!(!self.dep_map.contains_key(key));
 
         let mut my_dependencies = HashSet::new();
         for dep in dependencies {
@@ -68,7 +64,7 @@ impl<K: Hash + Eq + Clone, V> DependencyQueue<K, V> {
                 .or_insert_with(HashSet::new);
             rev.insert(key.clone());
         }
-        &mut slot.insert((my_dependencies, value)).1
+        self.dep_map.insert(key.clone(), (my_dependencies, value));
     }
 
     /// All nodes have been added, calculate some internal metadata and prepare