Implement the panic profile option

src/cargo/core/manifest.rs

@@ -113,14 +113,17 @@ pub struct Profile {
     pub test: bool,
     pub doc: bool,
     pub run_custom_build: bool,
+    pub panic: Option<String>,
 }
 
 #[derive(Default, Clone, Debug)]
 pub struct Profiles {
     pub release: Profile,
     pub dev: Profile,
     pub test: Profile,
+    pub test_deps: Profile,
     pub bench: Profile,
+    pub bench_deps: Profile,
     pub doc: Profile,
     pub custom_build: Profile,
 }
@@ -469,6 +472,7 @@ impl Default for Profile {
             test: false,
             doc: false,
             run_custom_build: false,
+            panic: None,
         }
     }
 }

src/cargo/ops/cargo_clean.rs

@@ -58,9 +58,11 @@ pub fn clean(manifest_path: &Path, opts: &CleanOptions) -> CargoResult<()> {
                 try!(rm_rf(&layout.build(&pkg)));
                 let Profiles {
                     ref release, ref dev, ref test, ref bench, ref doc,
-                    ref custom_build,
+                    ref custom_build, ref test_deps, ref bench_deps,
                 } = *root.manifest().profiles();
-                for profile in [release, dev, test, bench, doc, custom_build].iter() {
+                let profiles = [release, dev, test, bench, doc, custom_build,
+                                test_deps, bench_deps];
+                for profile in profiles.iter() {
                     let unit = Unit {
                         pkg: &pkg,
                         target: target,

src/cargo/ops/cargo_compile.rs

@@ -244,6 +244,7 @@ pub fn compile_pkg<'a>(root_package: &Package,
         let mut build_config = try!(scrape_build_config(config, jobs, target));
         build_config.exec_engine = exec_engine.clone();
         build_config.release = release;
+        build_config.test = mode == CompileMode::Test;
         if let CompileMode::Doc { deps } = mode {
             build_config.doc_all = deps;
         }

src/cargo/ops/cargo_rustc/context.rs

@@ -620,10 +620,15 @@ impl<'a, 'cfg> Context<'a, 'cfg> {
     }
 
     pub fn lib_profile(&self, _pkg: &PackageId) -> &'a Profile {
-        if self.build_config.release {
-            &self.profiles.release
+        let (normal, test) = if self.build_config.release {
+            (&self.profiles.release, &self.profiles.bench_deps)
         } else {
-            &self.profiles.dev
+            (&self.profiles.dev, &self.profiles.test_deps)
+        };
+        if self.build_config.test {
+            test
+        } else {
+            normal
         }
     }
 

src/cargo/ops/cargo_rustc/mod.rs

@@ -40,6 +40,7 @@ pub struct BuildConfig {
     pub requested_target: Option<String>,
     pub exec_engine: Option<Arc<Box<ExecEngine>>>,
     pub release: bool,
+    pub test: bool,
     pub doc_all: bool,
 }
 
@@ -451,7 +452,7 @@ fn build_base_args(cx: &Context,
     let Profile {
         opt_level, lto, codegen_units, ref rustc_args, debuginfo,
         debug_assertions, rpath, test, doc: _doc, run_custom_build,
-        rustdoc_args: _,
+        ref panic, rustdoc_args: _,
     } = *unit.profile;
     assert!(!run_custom_build);
 
@@ -478,6 +479,10 @@ fn build_base_args(cx: &Context,
         cmd.arg("-C").arg(&format!("opt-level={}", opt_level));
     }
 
+    if let Some(panic) = panic.as_ref() {
+        cmd.arg("-C").arg(format!("panic={}", panic));
+    }
+
     // Disable LTO for host builds as prefer_dynamic and it are mutually
     // exclusive.
     if unit.target.can_lto() && lto && !unit.target.for_host() {

src/cargo/util/toml.rs

@@ -238,6 +238,7 @@ pub struct TomlProfile {
     debug: Option<bool>,
     debug_assertions: Option<bool>,
     rpath: Option<bool>,
+    panic: Option<String>,
 }
 
 #[derive(RustcDecodable)]
@@ -1030,23 +1031,31 @@ fn normalize(lib: &Option<TomlLibTarget>,
 
 fn build_profiles(profiles: &Option<TomlProfiles>) -> Profiles {
     let profiles = profiles.as_ref();
-    return Profiles {
+    let mut profiles = Profiles {
         release: merge(Profile::default_release(),
                        profiles.and_then(|p| p.release.as_ref())),
         dev: merge(Profile::default_dev(),
                    profiles.and_then(|p| p.dev.as_ref())),
         test: merge(Profile::default_test(),
                     profiles.and_then(|p| p.test.as_ref())),
+        test_deps: merge(Profile::default_dev(),
+                         profiles.and_then(|p| p.dev.as_ref())),
         bench: merge(Profile::default_bench(),
                      profiles.and_then(|p| p.bench.as_ref())),
+        bench_deps: merge(Profile::default_release(),
+                          profiles.and_then(|p| p.release.as_ref())),
         doc: merge(Profile::default_doc(),
                    profiles.and_then(|p| p.doc.as_ref())),
         custom_build: Profile::default_custom_build(),
     };
+    profiles.test_deps.panic = None;
+    profiles.bench_deps.panic = None;
+    return profiles;
 
     fn merge(profile: Profile, toml: Option<&TomlProfile>) -> Profile {
         let &TomlProfile {
-            opt_level, lto, codegen_units, debug, debug_assertions, rpath
+            opt_level, lto, codegen_units, debug, debug_assertions, rpath,
+            ref panic
         } = match toml {
             Some(toml) => toml,
             None => return profile,
@@ -1063,6 +1072,7 @@ fn build_profiles(profiles: &Option<TomlProfiles>) -> Profiles {
             test: profile.test,
             doc: profile.doc,
             run_custom_build: profile.run_custom_build,
+            panic: panic.clone().or(profile.panic),
         }
     }
 }

src/rustversion.txt

@@ -1 +1 @@
-2016-04-23
+2016-05-13

tests/test_cargo_compile.rs

@@ -2128,3 +2128,23 @@ test!(manifest_with_bom_is_ok {
     assert_that(p.cargo_process("build").arg("-v"),
                 execs().with_status(0));
 });
+
+test!(panic_abort_compiles_with_panic_abort {
+    if !::is_nightly() {
+        return
+    }
+    let p = project("foo")
+        .file("Cargo.toml", r#"
+            [package]
+            name = "foo"
+            version = "0.0.1"
+            authors = []
+
+            [profile.dev]
+            panic = 'abort'
+        "#)
+        .file("src/lib.rs", "");
+    assert_that(p.cargo_process("build").arg("-v"),
+                execs().with_status(0)
+                       .with_stderr_contains("[..] -C panic=abort [..]"));
+});

tests/test_cargo_test.rs

@@ -2072,3 +2072,36 @@ test result: ok.[..]
 "));
 });
 
+test!(test_panic_abort_with_dep {
+    if !::is_nightly() {
+        return
+    }
+    let p = project("foo")
+        .file("Cargo.toml", r#"
+            [package]
+            name = "foo"
+            version = "0.0.1"
+            authors = []
+
+            [dependencies]
+            bar = { path = "bar" }
+
+            [profile.dev]
+            panic = 'abort'
+        "#)
+        .file("src/lib.rs", r#"
+            extern crate bar;
+
+            #[test]
+            fn foo() {}
+        "#)
+        .file("bar/Cargo.toml", r#"
+            [package]
+            name = "bar"
+            version = "0.0.1"
+            authors = []
+        "#)
+        .file("bar/src/lib.rs", "");
+    assert_that(p.cargo_process("test").arg("-v"),
+                execs().with_status(0));
+});