maintain the given order on step execution

Previously step execution disregarded the CLI order and this change executes the given
steps in the order specified on CLI.

For example, running `x $kind a b c` will execute `$kind` step for `a`, then `b`, then `c` crates
in the specified order.

Signed-off-by: onur-ozkan <[email protected]>

Author: onur-ozkan

src/bootstrap/src/core/builder.rs

@@ -1,6 +1,6 @@
 use std::any::{type_name, Any};
 use std::cell::{Cell, RefCell};
-use std::collections::BTreeSet;
+use std::collections::{BTreeSet, HashMap};
 use std::env;
 use std::ffi::{OsStr, OsString};
 use std::fmt::{Debug, Write};
@@ -265,23 +265,9 @@ impl PathSet {
         }
     }
 
-    /// Return all `TaskPath`s in `Self` that contain any of the `needles`, removing the
-    /// matched needles.
-    ///
-    /// This is used for `StepDescription::krate`, which passes all matching crates at once to
-    /// `Step::make_run`, rather than calling it many times with a single crate.
-    /// See `tests.rs` for examples.
-    fn intersection_removing_matches(&self, needles: &mut Vec<PathBuf>, module: Kind) -> PathSet {
-        let mut check = |p| {
-            for (i, n) in needles.iter().enumerate() {
-                let matched = Self::check(p, n, module);
-                if matched {
-                    needles.remove(i);
-                    return true;
-                }
-            }
-            false
-        };
+    /// Return all `TaskPath`s in `Self` that contain the `path`.
+    fn intersection_pathset(&self, path: &Path, module: Kind) -> PathSet {
+        let check = |p| Self::check(p, path, module);
         match self {
             PathSet::Set(set) => PathSet::Set(set.iter().filter(|&p| check(p)).cloned().collect()),
             PathSet::Suite(suite) => {
@@ -473,14 +459,39 @@ impl StepDescription {
             return;
         }
 
-        // Handle all PathSets.
-        for (desc, should_run) in v.iter().zip(&should_runs) {
-            let pathsets = should_run.pathset_for_paths_removing_matches(&mut paths, desc.kind);
-            if !pathsets.is_empty() {
-                desc.maybe_run(builder, pathsets);
+        // Special type that helps bootstrap to:
+        //     1. keep the given CLI order on step execution
+        //     2. keep all matching crates so we can pass them to `Step::make_run` at once,
+        //        rather than calling it many times with a single crate.
+        let mut steps_to_run: HashMap<PathBuf, (&StepDescription, Vec<PathSet>)> = HashMap::new();
+
+        // Handle all PathSets
+        for path in &paths {
+            for (desc, should_run) in v.iter().zip(&should_runs) {
+                let pathsets = should_run.resolve_pathsets(path, desc.kind);
+                if !pathsets.is_empty() {
+                    steps_to_run
+                        .entry(path.clone())
+                        .or_insert_with(|| (desc, Vec::new()))
+                        .1
+                        .extend(pathsets);
+                }
             }
         }
 
+        // Start given steps and remove them from `paths`.
+        paths.retain(|path| {
+            if let Some((desc, pathsets)) = steps_to_run.remove(path) {
+                desc.maybe_run(builder, pathsets);
+
+                false
+            } else {
+                true
+            }
+        });
+
+        assert!(steps_to_run.is_empty(), "Some steps did not executed.");
+
         if !paths.is_empty() {
             eprintln!("ERROR: no `{}` rules matched {:?}", builder.kind.as_str(), paths,);
             eprintln!(
@@ -632,23 +643,18 @@ impl<'a> ShouldRun<'a> {
         self
     }
 
-    /// Given a set of requested paths, return the subset which match the Step for this `ShouldRun`,
-    /// removing the matches from `paths`.
+    /// Return the subset from given `path` and `kind` which match the `Step` for this `ShouldRun`.
     ///
     /// NOTE: this returns multiple PathSets to allow for the possibility of multiple units of work
     /// within the same step. For example, `test::Crate` allows testing multiple crates in the same
     /// cargo invocation, which are put into separate sets because they aren't aliases.
     ///
     /// The reason we return PathSet instead of PathBuf is to allow for aliases that mean the same thing
     /// (for now, just `all_krates` and `paths`, but we may want to add an `aliases` function in the future?)
-    fn pathset_for_paths_removing_matches(
-        &self,
-        paths: &mut Vec<PathBuf>,
-        kind: Kind,
-    ) -> Vec<PathSet> {
+    fn resolve_pathsets(&self, path: &Path, kind: Kind) -> Vec<PathSet> {
         let mut sets = vec![];
         for pathset in &self.paths {
-            let subset = pathset.intersection_removing_matches(paths, kind);
+            let subset = pathset.intersection_pathset(path, kind);
             if subset != PathSet::empty() {
                 sets.push(subset);
             }