Auto merge of #4182 - matklad:simplify, r=alexcrichton

Simplify inferred binary names

Fix for rust-lang/rust#42365, which probably breaks other stuff :(

Author: bors

src/cargo/util/toml.rs

@@ -1415,12 +1415,9 @@ fn normalize(package_root: &Path,
 
     if let Some(ref lib) = *lib {
         lib_target(&mut ret, lib);
-        bin_targets(&mut ret, bins,
-                    &mut |bin| inferred_bin_path(bin, package_root, true, bins.len()));
-    } else if bins.len() > 0 {
-        bin_targets(&mut ret, bins,
-                    &mut |bin| inferred_bin_path(bin, package_root, false, bins.len()));
     }
+    bin_targets(&mut ret, bins,
+                &mut |bin| inferred_bin_path(bin, lib.is_some(), package_root, bins.len()));
 
 
     if let Some(custom_build) = custom_build {
@@ -1443,32 +1440,9 @@ fn normalize(package_root: &Path,
 }
 
 fn inferred_bin_path(bin: &TomlBinTarget,
+                     has_lib: bool,
                      package_root: &Path,
-                     lib: bool,
                      bin_len: usize) -> PathBuf {
-    // we have a lib with multiple bins, so the bins are expected to be located
-    // inside src/bin
-    if lib && bin_len > 1 {
-        return Path::new("src").join("bin").join(&format!("{}.rs", bin.name()))
-                    .to_path_buf()
-    }
-
-    // we have a lib with one bin, so it's either src/main.rs, src/bin/foo.rs or
-    // src/bin/main.rs
-    if lib && bin_len == 1 {
-        let path = Path::new("src").join(&format!("main.rs"));
-        if package_root.join(&path).exists() {
-            return path.to_path_buf()
-        }
-
-        let path = Path::new("src").join("bin").join(&format!("{}.rs", bin.name()));
-        if package_root.join(&path).exists() {
-            return path.to_path_buf()
-        }
-
-        return Path::new("src").join("bin").join(&format!("main.rs")).to_path_buf()
-    }
-
     // here we have a single bin, so it may be located in src/main.rs, src/foo.rs,
     // srb/bin/foo.rs or src/bin/main.rs
     if bin_len == 1 {
@@ -1477,9 +1451,11 @@ fn inferred_bin_path(bin: &TomlBinTarget,
             return path.to_path_buf()
         }
 
-        let path = Path::new("src").join(&format!("{}.rs", bin.name()));
-        if package_root.join(&path).exists() {
-            return path.to_path_buf()
+        if !has_lib {
+            let path = Path::new("src").join(&format!("{}.rs", bin.name()));
+            if package_root.join(&path).exists() {
+                return path.to_path_buf()
+            }
         }
 
         let path = Path::new("src").join("bin").join(&format!("{}.rs", bin.name()));
@@ -1496,9 +1472,11 @@ fn inferred_bin_path(bin: &TomlBinTarget,
         return path.to_path_buf()
     }
 
-    let path = Path::new("src").join(&format!("{}.rs", bin.name()));
-    if package_root.join(&path).exists() {
-        return path.to_path_buf()
+    if !has_lib {
+        let path = Path::new("src").join(&format!("{}.rs", bin.name()));
+        if package_root.join(&path).exists() {
+            return path.to_path_buf()
+        }
     }
 
     let path = Path::new("src").join("bin").join(&format!("main.rs"));

tests/build.rs

@@ -3229,3 +3229,45 @@ fn deterministic_cfg_flags() {
 --cfg cfg_a --cfg cfg_b --cfg cfg_c --cfg cfg_d --cfg cfg_e`
 [FINISHED] dev [unoptimized + debuginfo] target(s) in [..]"));
 }
+
+#[test]
+fn explicit_bins_without_paths() {
+    let p = project("foo")
+        .file("Cargo.toml", r#"
+            [package]
+            name = "foo"
+            version = "0.1.0"
+            authors = []
+
+            [[bin]]
+            name = "foo"
+
+            [[bin]]
+            name = "bar"
+        "#)
+        .file("src/lib.rs", "")
+        .file("src/main.rs", "fn main() {}")
+        .file("src/bin/bar.rs", "fn main() {}");
+
+    assert_that(p.cargo_process("build"), execs().with_status(0));
+}
+
+#[test]
+fn no_bin_in_src_with_lib() {
+    let p = project("foo")
+        .file("Cargo.toml", r#"
+            [package]
+            name = "foo"
+            version = "0.1.0"
+            authors = []
+
+            [[bin]]
+            name = "foo"
+        "#)
+        .file("src/lib.rs", "")
+        .file("src/foo.rs", "fn main() {}");
+
+    assert_that(p.cargo_process("build"),
+                execs().with_status(101)
+                       .with_stderr_contains(r#"[ERROR] couldn't read "[..]main.rs"[..]"#));
+}

tests/cargotest/support/mod.rs

@@ -436,13 +436,12 @@ impl Execs {
         }
 
         if let Some(ref objects) = self.expect_json {
-            let lines = match str::from_utf8(&actual.stdout) {
-                Err(..) => return Err("stdout was not utf8 encoded".to_owned()),
-                Ok(stdout) => stdout.lines().collect::<Vec<_>>(),
-            };
+            let stdout = str::from_utf8(&actual.stdout)
+                .map_err(|_| "stdout was not utf8 encoded".to_owned())?;
+            let lines = stdout.lines().collect::<Vec<_>>();
             if lines.len() != objects.len() {
-                return Err(format!("expected {} json lines, got {}",
-                                   objects.len(), lines.len()));
+                return Err(format!("expected {} json lines, got {}, stdout:\n{}",
+                                   objects.len(), lines.len(), stdout));
             }
             for (obj, line) in objects.iter().zip(lines) {
                 self.match_json(obj, line)?;