Auto merge of #2482 - ryanq:issue2266, r=alexcrichton

Suggest the best matching target for cargo run

Targets passed to cargo compile are validated against the package. If
the target exists, it is compiled. If not, cargo will bail and offer a
suggested target name if there is a close match.

The tests create and build/run binaries and examples using filenames
that are close (or not so close) to the target names to verify that
close matching names are suggested to the user.

Sample output attached.
<img width="838" alt="screen shot 2016-03-14 at 12 32 59 pm" src="https://cloud.githubusercontent.com/assets/124247/13754913/28490e42-e9ef-11e5-9617-8d3c01106527.png">

Closes #2266

Author: bors

Cargo.lock

@@ -6,10 +6,10 @@ use std::path::{Path, PathBuf};
 
 use semver::Version;
 
-use core::{Dependency, Manifest, PackageId, SourceId, Target};
+use core::{Dependency, Manifest, PackageId, SourceId, Target, TargetKind};
 use core::{Summary, Metadata, SourceMap};
 use ops;
-use util::{CargoResult, Config, LazyCell, ChainError, internal, human};
+use util::{CargoResult, Config, LazyCell, ChainError, internal, human, lev_distance};
 use rustc_serialize::{Encoder,Encodable};
 
 /// Information about a package that is available somewhere in the file system.
@@ -89,6 +89,15 @@ impl Package {
     pub fn generate_metadata(&self) -> Metadata {
         self.package_id().generate_metadata()
     }
+
+    pub fn find_closest_target(&self, target: &str, kind: TargetKind) -> Option<&Target> {
+        let targets = self.targets();
+
+        let matches = targets.iter().filter(|t| *t.kind() == kind)
+                                    .map(|t| (lev_distance(target, t.name()), t))
+                                    .filter(|&(d, _)| d < 4);
+        matches.min_by_key(|t| t.0).map(|t| t.1)
+    }
 }
 
 impl fmt::Display for Package {

src/cargo/core/package.rs

@@ -363,7 +363,17 @@ fn generate_targets<'a>(pkg: &'a Package,
                         });
                         let t = match target {
                             Some(t) => t,
-                            None => bail!("no {} target named `{}`", desc, name),
+                            None => {
+                                let suggestion = pkg.find_closest_target(name, kind);
+                                match suggestion {
+                                    Some(s) => {
+                                        let suggested_name = s.name();
+                                        bail!("no {} target named `{}`\n\nDid you mean `{}`?",
+                                              desc, name, suggested_name)
+                                    }
+                                    None => bail!("no {} target named `{}`", desc, name),
+                                }
+                            }
                         };
                         debug!("found {} `{}`", desc, name);
                         targets.push((t, profile));

src/cargo/ops/cargo_compile.rs

@@ -621,6 +621,44 @@ version required: *
 "#, error = ERROR, proj_dir = p.url())));
 });
 
+test!(cargo_compile_with_filename{
+    let p = project("foo")
+        .file("Cargo.toml", r#"
+            [project]
+            name = "foo"
+            version = "0.0.1"
+            authors = []
+        "#)
+        .file("src/lib.rs", "")
+        .file("src/bin/a.rs", r#"
+            extern crate foo;
+            fn main() { println!("hello a.rs"); }
+        "#)
+        .file("examples/a.rs", r#"
+            fn main() { println!("example"); }
+        "#);
+
+    assert_that(p.cargo_process("build").arg("--bin").arg("bin.rs"),
+                execs().with_status(101).with_stderr(&format!("\
+{error} no bin target named `bin.rs`", error = ERROR)));
+
+    assert_that(p.cargo_process("build").arg("--bin").arg("a.rs"),
+                execs().with_status(101).with_stderr(&format!("\
+{error} no bin target named `a.rs`
+
+Did you mean `a`?", error = ERROR)));
+
+    assert_that(p.cargo_process("build").arg("--example").arg("example.rs"),
+                execs().with_status(101).with_stderr(&format!("\
+{error} no example target named `example.rs`", error = ERROR)));
+
+    assert_that(p.cargo_process("build").arg("--example").arg("a.rs"),
+                execs().with_status(101).with_stderr(&format!("\
+{error} no example target named `a.rs`
+
+Did you mean `a`?", error = ERROR)));
+});
+
 test!(compile_path_dep_then_change_version {
     let p = project("foo")
         .file("Cargo.toml", r#"

tests/test_cargo_compile.rs

@@ -234,6 +234,44 @@ example
         sep = SEP)));
 });
 
+test!(run_with_filename {
+    let p = project("foo")
+        .file("Cargo.toml", r#"
+            [project]
+            name = "foo"
+            version = "0.0.1"
+            authors = []
+        "#)
+        .file("src/lib.rs", "")
+        .file("src/bin/a.rs", r#"
+            extern crate foo;
+            fn main() { println!("hello a.rs"); }
+        "#)
+        .file("examples/a.rs", r#"
+            fn main() { println!("example"); }
+        "#);
+
+    assert_that(p.cargo_process("run").arg("--bin").arg("bin.rs"),
+                execs().with_status(101).with_stderr(&format!("\
+{error} no bin target named `bin.rs`", error = ERROR)));
+
+    assert_that(p.cargo_process("run").arg("--bin").arg("a.rs"),
+                execs().with_status(101).with_stderr(&format!("\
+{error} no bin target named `a.rs`
+
+Did you mean `a`?", error = ERROR)));
+
+    assert_that(p.cargo_process("run").arg("--example").arg("example.rs"),
+                execs().with_status(101).with_stderr(&format!("\
+{error} no example target named `example.rs`", error = ERROR)));
+
+    assert_that(p.cargo_process("run").arg("--example").arg("a.rs"),
+                execs().with_status(101).with_stderr(&format!("\
+{error} no example target named `a.rs`
+
+Did you mean `a`?", error = ERROR)));
+});
+
 test!(either_name_or_example {
     let p = project("foo")
         .file("Cargo.toml", r#"