Added sanity check to to catch empty host parameter in ./x.py test --host=''

src/bootstrap/builder.rs

@@ -284,18 +284,23 @@ impl StepDescription {
         }
     }
 
-    fn maybe_run(&self, builder: &Builder<'_>, pathsets: Vec<PathSet>) {
+    fn maybe_run(&self, builder: &Builder<'_>, pathsets: Vec<PathSet>) -> Option<()> {
         if pathsets.iter().any(|set| self.is_excluded(builder, set)) {
-            return;
+            return Some(());
         }
 
         // Determine the targets participating in this rule.
         let targets = if self.only_hosts { &builder.hosts } else { &builder.targets };
+        if targets.is_empty() && self.only_hosts {
+            return None;
+        }
 
         for target in targets {
             let run = RunConfig { builder, paths: pathsets.clone(), target: *target };
             (self.make_run)(run);
         }
+
+        Some(())
     }
 
     fn is_excluded(&self, builder: &Builder<'_>, pathset: &PathSet) -> bool {
@@ -328,10 +333,12 @@ impl StepDescription {
             );
         }
 
+        let mut hosts_check = Vec::new();
         if paths.is_empty() || builder.config.include_default_paths {
             for (desc, should_run) in v.iter().zip(&should_runs) {
                 if desc.default && should_run.is_really_default() {
-                    desc.maybe_run(builder, should_run.paths.iter().cloned().collect());
+                    hosts_check
+                        .push(desc.maybe_run(builder, should_run.paths.iter().cloned().collect()));
                 }
             }
         }
@@ -345,7 +352,7 @@ impl StepDescription {
         paths.retain(|path| {
             for (desc, should_run) in v.iter().zip(&should_runs) {
                 if let Some(suite) = should_run.is_suite_path(&path) {
-                    desc.maybe_run(builder, vec![suite.clone()]);
+                    hosts_check.push(desc.maybe_run(builder, vec![suite.clone()]));
                     return false;
                 }
             }
@@ -360,10 +367,19 @@ impl StepDescription {
         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);
+                hosts_check.push(desc.maybe_run(builder, pathsets));
             }
         }
 
+        // sanity checks on hosts
+        if !hosts_check.contains(&Some(())) {
+            eprintln!(
+                "`x.py {}` run with empty `host` parameter. Either set it or leave it out for default value.",
+                builder.kind.as_str()
+            );
+            crate::detail_exit(1);
+        }
+
         if !paths.is_empty() {
             eprintln!("error: no `{}` rules matched {:?}", builder.kind.as_str(), paths,);
             eprintln!(

src/bootstrap/builder/tests.rs

@@ -116,6 +116,16 @@ fn test_exclude() {
     assert!(cache.contains::<test::RustdocUi>());
 }
 
+#[test]
+fn test_with_empty_host_and_empty_target() {
+    let config = configure("test", &[], &[]);
+    let cache = run_build(&[], config);
+
+    assert!(!cache.contains::<test::Tidy>());
+    assert!(!cache.contains::<test::Cargotest>());
+    assert!(!cache.contains::<test::RustdocUi>());
+}
+
 #[test]
 fn test_exclude_kind() {
     let path = PathBuf::from("src/tools/cargotest");
@@ -430,6 +440,16 @@ mod dist {
         );
     }
 
+    #[test]
+    fn dist_with_empty_host_and_empty_target() {
+        let config = configure(&[], &[]);
+        let mut cache = run_build(&[], config);
+
+        assert!(cache.all::<dist::Docs>().is_empty());
+        assert!(cache.all::<dist::Mingw>().is_empty());
+        assert!(cache.all::<dist::Std>().is_empty());
+    }
+
     #[test]
     fn dist_with_same_targets_and_hosts() {
         let mut cache = run_build(&[], configure(&["A", "B"], &["A", "B"]));
@@ -541,6 +561,18 @@ mod dist {
         );
     }
 
+    #[test]
+    fn build_with_empty_host_and_empty_target() {
+        let config = configure(&[], &[]);
+        let build = Build::new(config);
+        let mut builder = Builder::new(&build);
+        builder.run_step_descriptions(&Builder::get_step_descriptions(Kind::Build), &[]);
+
+        assert!(builder.cache.all::<compile::Std>().is_empty());
+        assert!(builder.cache.all::<compile::Assemble>().is_empty());
+        assert!(builder.cache.all::<compile::Rustc>().is_empty());
+    }
+
     #[test]
     fn test_with_no_doc_stage0() {
         let mut config = configure(&["A"], &["A"]);