rename PathSet -> StepSelectors

Author: jyn514

src/bootstrap/src/core/build_steps/test.rs

@@ -41,7 +41,7 @@ use crate::utils::helpers::{
     linker_args, linker_flags, t, target_supports_cranelift_backend, up_to_date,
 };
 use crate::utils::render_tests::{add_flags_and_try_run_tests, try_run_tests};
-use crate::{CLang, CodegenBackendKind, DocTests, GitRepo, Mode, PathSet, envify};
+use crate::{CLang, CodegenBackendKind, DocTests, GitRepo, Mode, StepSelectors, envify};
 
 mod compiletest;
 
@@ -1697,15 +1697,15 @@ impl Step for Coverage {
         // determine which modes to run in.
         for path in &run.paths {
             match path {
-                PathSet::Set(_) => {
+                StepSelectors::Set(_) => {
                     for &mode in Self::ALL_MODES {
                         if path.assert_single_path().path == Path::new(mode.as_str()) {
                             modes.push(mode);
                             break;
                         }
                     }
                 }
-                PathSet::TestSuite(_) => {
+                StepSelectors::TestSuite(_) => {
                     modes.extend_from_slice(Self::ALL_MODES);
                     break;
                 }

src/bootstrap/src/core/builder/mod.rs

@@ -71,7 +71,8 @@ pub struct Builder<'a> {
     /// executed to be logged instead. Used by snapshot tests of command-line
     /// paths-to-steps handling.
     #[expect(clippy::type_complexity)]
-    log_cli_step_for_tests: Option<Box<dyn Fn(&StepDescription, &[PathSet], &[TargetSelection])>>,
+    log_cli_step_for_tests:
+        Option<Box<dyn Fn(&StepDescription, &[StepSelectors], &[TargetSelection])>>,
 }
 
 impl Deref for Builder<'_> {
@@ -242,7 +243,7 @@ impl StepMetadata {
 pub struct RunConfig<'a> {
     pub builder: &'a Builder<'a>,
     pub target: TargetSelection,
-    pub paths: Vec<PathSet>,
+    pub paths: Vec<StepSelectors>,
 }
 
 impl RunConfig<'_> {
@@ -349,7 +350,7 @@ impl Debug for StepSelection {
 
 /// Collection of paths used to match a task rule.
 #[derive(Debug, Clone, PartialOrd, Ord, PartialEq, Eq)]
-pub enum PathSet {
+pub enum StepSelectors {
     /// A collection of individual paths or aliases.
     ///
     /// These are generally matched as a path suffix. For example, a
@@ -370,21 +371,21 @@ pub enum PathSet {
     TestSuite(StepSelection),
 }
 
-impl PathSet {
-    fn empty() -> PathSet {
-        PathSet::Set(BTreeSet::new())
+impl StepSelectors {
+    fn empty() -> StepSelectors {
+        StepSelectors::Set(BTreeSet::new())
     }
 
-    fn one<P: Into<PathBuf>>(path: P, kind: Kind) -> PathSet {
+    fn one<P: Into<PathBuf>>(path: P, kind: Kind) -> StepSelectors {
         let mut set = BTreeSet::new();
         set.insert(StepSelection { path: path.into(), kind: Some(kind) });
-        PathSet::Set(set)
+        StepSelectors::Set(set)
     }
 
     fn has(&self, needle: &Path, module: Kind) -> bool {
         match self {
-            PathSet::Set(set) => set.iter().any(|p| Self::check(p, needle, module)),
-            PathSet::TestSuite(suite) => Self::check(suite, needle, module),
+            StepSelectors::Set(set) => set.iter().any(|p| Self::check(p, needle, module)),
+            StepSelectors::TestSuite(suite) => Self::check(suite, needle, module),
         }
     }
 
@@ -403,7 +404,7 @@ impl PathSet {
     /// 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 [CLIStepPath], module: Kind) -> PathSet {
+    fn intersection_removing_matches(&self, needles: &mut [CLIStepPath], module: Kind) -> StepSelectors {
         let mut check = |p| {
             let mut result = false;
             for n in needles.iter_mut() {
@@ -416,12 +417,12 @@ impl PathSet {
             result
         };
         match self {
-            PathSet::Set(set) => PathSet::Set(set.iter().filter(|&p| check(p)).cloned().collect()),
-            PathSet::TestSuite(suite) => {
+            StepSelectors::Set(set) => StepSelectors::Set(set.iter().filter(|&p| check(p)).cloned().collect()),
+            StepSelectors::TestSuite(suite) => {
                 if check(suite) {
                     self.clone()
                 } else {
-                    PathSet::empty()
+                    StepSelectors::empty()
                 }
             }
         }
@@ -433,11 +434,11 @@ impl PathSet {
     #[track_caller]
     pub fn assert_single_path(&self) -> &StepSelection {
         match self {
-            PathSet::Set(set) => {
+            StepSelectors::Set(set) => {
                 assert_eq!(set.len(), 1, "called assert_single_path on multiple paths");
                 set.iter().next().unwrap()
             }
-            PathSet::TestSuite(_) => unreachable!("called assert_single_path on a Suite path"),
+            StepSelectors::TestSuite(_) => unreachable!("called assert_single_path on a Suite path"),
         }
     }
 }
@@ -454,7 +455,7 @@ impl StepDescription {
         }
     }
 
-    fn maybe_run(&self, builder: &Builder<'_>, mut pathsets: Vec<PathSet>) {
+    fn maybe_run(&self, builder: &Builder<'_>, mut pathsets: Vec<StepSelectors>) {
         pathsets.retain(|set| !self.is_excluded(builder, set));
 
         if pathsets.is_empty() {
@@ -477,7 +478,7 @@ impl StepDescription {
         }
     }
 
-    fn is_excluded(&self, builder: &Builder<'_>, pathset: &PathSet) -> bool {
+    fn is_excluded(&self, builder: &Builder<'_>, pathset: &StepSelectors) -> bool {
         if builder.config.skip.iter().any(|e| pathset.has(e, builder.kind)) {
             if !matches!(builder.config.get_dry_run(), DryRun::SelfCheck) {
                 println!("Skipping {pathset:?} because it is excluded");
@@ -510,7 +511,7 @@ pub struct ShouldRun<'a> {
     kind: Kind,
 
     // use a BTreeSet to maintain sort order
-    paths: BTreeSet<PathSet>,
+    paths: BTreeSet<StepSelectors>,
 }
 
 impl<'a> ShouldRun<'a> {
@@ -535,7 +536,7 @@ impl<'a> ShouldRun<'a> {
     pub(crate) fn crates(mut self, crates: Vec<&Crate>) -> Self {
         for krate in crates {
             let path = krate.local_path(self.builder);
-            self.paths.insert(PathSet::one(path, self.kind));
+            self.paths.insert(StepSelectors::one(path, self.kind));
         }
         self
     }
@@ -549,7 +550,7 @@ impl<'a> ShouldRun<'a> {
             self.kind == Kind::Setup || !self.builder.src.join(alias).exists(),
             "use `builder.path()` for real paths: {alias}"
         );
-        self.paths.insert(PathSet::Set(
+        self.paths.insert(StepSelectors::Set(
             std::iter::once(StepSelection { path: alias.into(), kind: Some(self.kind) }).collect(),
         ));
         self
@@ -574,7 +575,7 @@ impl<'a> ShouldRun<'a> {
     pub fn paths(mut self, paths: &[&str]) -> Self {
         let submodules_paths = self.builder.submodule_paths();
 
-        self.paths.insert(PathSet::Set(
+        self.paths.insert(StepSelectors::Set(
             paths
                 .iter()
                 .map(|p| {
@@ -594,21 +595,21 @@ impl<'a> ShouldRun<'a> {
     }
 
     /// Handles individual files (not directories) within a test suite.
-    fn is_suite_path(&self, requested_path: &Path) -> Option<&PathSet> {
+    fn is_suite_path(&self, requested_path: &Path) -> Option<&StepSelectors> {
         self.paths.iter().find(|pathset| match pathset {
-            PathSet::TestSuite(suite) => requested_path.starts_with(&suite.path),
-            PathSet::Set(_) => false,
+            StepSelectors::TestSuite(suite) => requested_path.starts_with(&suite.path),
+            StepSelectors::Set(_) => false,
         })
     }
 
     pub fn suite_path(mut self, suite: &str) -> Self {
-        self.paths.insert(PathSet::TestSuite(StepSelection { path: suite.into(), kind: Some(self.kind) }));
+        self.paths.insert(StepSelectors::TestSuite(StepSelection { path: suite.into(), kind: Some(self.kind) }));
         self
     }
 
     // allows being more explicit about why should_run in Step returns the value passed to it
     pub fn never(mut self) -> ShouldRun<'a> {
-        self.paths.insert(PathSet::empty());
+        self.paths.insert(StepSelectors::empty());
         self
     }
 
@@ -625,11 +626,11 @@ impl<'a> ShouldRun<'a> {
         &self,
         paths: &mut [CLIStepPath],
         kind: Kind,
-    ) -> Vec<PathSet> {
+    ) -> Vec<StepSelectors> {
         let mut sets = vec![];
         for pathset in &self.paths {
             let subset = pathset.intersection_removing_matches(paths, kind);
-            if subset != PathSet::empty() {
+            if subset != StepSelectors::empty() {
                 sets.push(subset);
             }
         }
@@ -1062,12 +1063,12 @@ impl<'a> Builder<'a> {
         };
         for pathset in should_run.paths {
             match pathset {
-                PathSet::Set(set) => {
+                StepSelectors::Set(set) => {
                     for path in set {
                         add_path(&path.path);
                     }
                 }
-                PathSet::TestSuite(path) => {
+                StepSelectors::TestSuite(path) => {
                     add_path(&path.path.join("..."));
                 }
             }
@@ -1653,7 +1654,7 @@ Alternatively, you can set `build.local-rebuild=true` and use a stage0 compiler
             if should_run.paths.iter().any(|s| s.has(path, desc.kind))
                 && !desc.is_excluded(
                     self,
-                    &PathSet::TestSuite(StepSelection { path: path.clone(), kind: Some(desc.kind) }),
+                    &StepSelectors::TestSuite(StepSelection { path: path.clone(), kind: Some(desc.kind) }),
                 )
             {
                 return true;

src/bootstrap/src/core/builder/selectors.rs

@@ -5,7 +5,7 @@
 use std::fmt::{self, Debug};
 use std::path::PathBuf;
 
-use crate::core::builder::{Builder, Kind, PathSet, ShouldRun, StepDescription};
+use crate::core::builder::{Builder, Kind, StepSelectors, ShouldRun, StepDescription};
 
 #[cfg(test)]
 mod tests;
@@ -99,7 +99,7 @@ struct StepExtra<'a> {
 struct StepToRun<'a> {
     sort_index: usize,
     desc: &'a StepDescription,
-    pathsets: Vec<PathSet>,
+    pathsets: Vec<StepSelectors>,
 }
 
 pub(crate) fn match_paths_to_steps_and_run(

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

@@ -83,7 +83,7 @@ fn test_invalid() {
 #[test]
 fn test_intersection() {
     let set = |paths: &[&str]| {
-        PathSet::Set(paths.into_iter().map(|p| TaskPath { path: p.into(), kind: None }).collect())
+        StepSelectors::Set(paths.into_iter().map(|p| StepSelection { selector: p.into(), kind: None }).collect())
     };
     let library_set = set(&["library/core", "library/alloc", "library/std"]);
     let mut command_paths = vec![
@@ -106,7 +106,7 @@ fn test_intersection() {
 #[test]
 fn test_resolve_parent_and_subpaths() {
     let set = |paths: &[&str]| {
-        PathSet::Set(paths.into_iter().map(|p| TaskPath { path: p.into(), kind: None }).collect())
+        StepSelectors::Set(paths.into_iter().map(|p| StepSelection { selector: p.into(), kind: None }).collect())
     };
 
     let mut command_paths = vec![

src/bootstrap/src/lib.rs

@@ -42,9 +42,9 @@ use crate::utils::helpers::{self, dir_is_empty, exe, libdir, set_file_times, spl
 mod core;
 mod utils;
 
-pub use core::builder::PathSet;
 #[cfg(feature = "tracing")]
 pub use core::builder::STEP_SPAN_TARGET;
+pub use core::builder::StepSelectors;
 pub use core::config::flags::{Flags, Subcommand};
 pub use core::config::{ChangeId, Config};