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 <work@onurozkan.dev>

Author: onur-ozkan

src/bootstrap/src/core/builder.rs

@@ -191,6 +191,7 @@ pub fn crate_description(crates: &[impl AsRef<str>]) -> String {
     descr
 }
 
+#[derive(PartialEq)]
 struct StepDescription {
     default: bool,
     only_hosts: bool,
@@ -265,23 +266,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,12 +460,35 @@ 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: Vec<(&StepDescription, Vec<PathSet>)> = vec![];
+
+        // Start given steps and remove them from `paths`.
+        paths.retain(|path| {
+            for (desc, should_run) in v.iter().zip(&should_runs) {
+                let pathsets = should_run.resolve_pathsets(path, desc.kind);
+                if !pathsets.is_empty() {
+                    if let Some((_, paths)) =
+                        steps_to_run.iter_mut().find(|(step_desc, _)| *step_desc == desc)
+                    {
+                        paths.extend(pathsets);
+                    } else {
+                        steps_to_run.push((desc, pathsets));
+                    }
+
+                    return false;
+                }
             }
+
+            true
+        });
+
+        // Execute steps
+        for (desc, pathsets) in steps_to_run {
+            desc.maybe_run(builder, pathsets);
         }
 
         if !paths.is_empty() {
@@ -632,23 +642,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);
             }

src/bootstrap/src/core/builder/tests.rs

@@ -122,14 +122,15 @@ fn test_intersection() {
         PathSet::Set(paths.into_iter().map(|p| TaskPath { path: p.into(), kind: None }).collect())
     };
     let library_set = set(&["library/core", "library/alloc", "library/std"]);
-    let mut command_paths = vec![
-        PathBuf::from("library/core"),
-        PathBuf::from("library/alloc"),
-        PathBuf::from("library/stdarch"),
-    ];
-    let subset = library_set.intersection_removing_matches(&mut command_paths, Kind::Build);
-    assert_eq!(subset, set(&["library/core", "library/alloc"]),);
-    assert_eq!(command_paths, vec![PathBuf::from("library/stdarch")]);
+
+    let subset = library_set.intersection_pathset(&PathBuf::from("alloc"), Kind::Build);
+    assert_eq!(subset, set(&["library/alloc"]));
+
+    let subset = library_set.intersection_pathset(&PathBuf::from("library/std"), Kind::Build);
+    assert_eq!(subset, set(&["library/std"]));
+
+    let subset = library_set.intersection_pathset(&PathBuf::from("invalid"), Kind::Build);
+    assert_eq!(subset, set(&[]));
 }
 
 #[test]