rustc subcommand

src/bin/bench.rs

@@ -75,6 +75,7 @@ pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
                                             &options.flag_test,
                                             &options.flag_example,
                                             &options.flag_bench),
+            target_rustc_args: None,
         },
     };
 

src/bin/build.rs

@@ -76,6 +76,7 @@ pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
                                         &options.flag_test,
                                         &options.flag_example,
                                         &options.flag_bench),
+        target_rustc_args: None,
     };
 
     ops::compile(&root, &opts).map(|_| None).map_err(|err| {

src/bin/cargo.rs

@@ -75,6 +75,7 @@ macro_rules! each_subcommand{ ($mac:ident) => ({
     $mac!(publish);
     $mac!(read_manifest);
     $mac!(run);
+    $mac!(rustc);
     $mac!(search);
     $mac!(test);
     $mac!(update);

src/bin/doc.rs

@@ -62,6 +62,7 @@ pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
             mode: ops::CompileMode::Doc {
                 deps: !options.flag_no_deps,
             },
+            target_rustc_args: None,
         },
     };
 

src/bin/run.rs

@@ -72,6 +72,7 @@ pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
                 bins: &bins, examples: &examples,
             }
         },
+        target_rustc_args: None,
     };
 
     let err = try!(ops::run(&root,

src/bin/rustc.rs

@@ -0,0 +1,90 @@
+use std::env;
+
+use cargo::ops::CompileOptions;
+use cargo::ops;
+use cargo::util::important_paths::{find_root_manifest_for_cwd};
+use cargo::util::{CliResult, CliError, Config};
+
+#[derive(RustcDecodable)]
+struct Options {
+    arg_opts: Option<Vec<String>>,
+    flag_package: Option<String>,
+    flag_jobs: Option<u32>,
+    flag_features: Vec<String>,
+    flag_no_default_features: bool,
+    flag_target: Option<String>,
+    flag_manifest_path: Option<String>,
+    flag_verbose: bool,
+    flag_release: bool,
+    flag_lib: bool,
+    flag_bin: Vec<String>,
+    flag_example: Vec<String>,
+    flag_test: Vec<String>,
+    flag_bench: Vec<String>,
+}
+
+pub const USAGE: &'static str = "
+Compile a package and all of its dependencies
+
+Usage:
+    cargo rustc [options] [--] [<opts>...]
+
+Options:
+    -h, --help               Print this message
+    -p SPEC, --package SPEC  The profile to compile for
+    -j N, --jobs N           The number of jobs to run in parallel
+    --lib                    Build only this package's library
+    --bin NAME               Build only the specified binary
+    --example NAME           Build only the specified example
+    --test NAME              Build only the specified test
+    --bench NAME             Build only the specified benchmark
+    --release                Build artifacts in release mode, with optimizations
+    --features FEATURES      Features to compile for the package
+    --no-default-features    Do not compile default features for the package
+    --target TRIPLE          Target triple which compiles will be for
+    --manifest-path PATH     Path to the manifest to fetch depednencies for
+    -v, --verbose            Use verbose output
+
+The specified target for the current package (or package specified by SPEC if
+provided) will be compiled along with all of its dependencies. The specified
+<opts>... will all be passed to the final compiler invocation, not any of the
+dependencies. Note that the compiler will still unconditionally receive
+arguments such as -L, --extern, and --crate-type, and the specified <opts>...
+will simply be added to the compiler invocation.
+
+This command requires that only one target is being compiled. If more than one
+target is available for the current package the filters of --lib, --bin, etc,
+must be used to select which target is compiled.
+";
+
+pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
+    debug!("executing; cmd=cargo-rustc; args={:?}",
+           env::args().collect::<Vec<_>>());
+    config.shell().set_verbose(options.flag_verbose);
+
+    let root = try!(find_root_manifest_for_cwd(options.flag_manifest_path));
+
+    let opts = CompileOptions {
+        config: config,
+        jobs: options.flag_jobs,
+        target: options.flag_target.as_ref().map(|t| &t[..]),
+        features: &options.flag_features,
+        no_default_features: options.flag_no_default_features,
+        spec: options.flag_package.as_ref().map(|s| &s[..]),
+        exec_engine: None,
+        mode: ops::CompileMode::Build,
+        release: options.flag_release,
+        filter: ops::CompileFilter::new(options.flag_lib,
+                                        &options.flag_bin,
+                                        &options.flag_test,
+                                        &options.flag_example,
+                                        &options.flag_bench),
+        target_rustc_args: options.arg_opts.as_ref().map(|a| &a[..]),
+    };
+
+    ops::compile(&root, &opts).map(|_| None).map_err(|err| {
+        CliError::from_boxed(err, 101)
+    })
+}
+
+

src/bin/test.rs

@@ -79,6 +79,7 @@ pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
                                             &options.flag_test,
                                             &options.flag_example,
                                             &options.flag_bench),
+            target_rustc_args: None,
         },
     };
 

src/cargo/core/manifest.rs

@@ -116,6 +116,7 @@ pub struct Profile {
     pub opt_level: u32,
     pub lto: bool,
     pub codegen_units: Option<u32>,    // None = use rustc default
+    pub rustc_args: Option<Vec<String>>,
     pub debuginfo: bool,
     pub debug_assertions: bool,
     pub rpath: bool,
@@ -464,6 +465,7 @@ impl Default for Profile {
             opt_level: 0,
             lto: false,
             codegen_units: None,
+            rustc_args: None,
             debuginfo: false,
             debug_assertions: false,
             rpath: false,

src/cargo/ops/cargo_compile.rs

@@ -58,6 +58,9 @@ pub struct CompileOptions<'a, 'b: 'a> {
     pub release: bool,
     /// Mode for this compile.
     pub mode: CompileMode,
+    /// The specified target will be compiled with all the available arguments,
+    /// note that this only accounts for the *final* invocation of rustc
+    pub target_rustc_args: Option<&'a [String]>,
 }
 
 #[derive(Clone, Copy, PartialEq)]
@@ -102,7 +105,8 @@ pub fn compile_pkg(package: &Package, options: &CompileOptions)
                    -> CargoResult<ops::Compilation> {
     let CompileOptions { config, jobs, target, spec, features,
                          no_default_features, release, mode,
-                         ref filter, ref exec_engine } = *options;
+                         ref filter, ref exec_engine,
+                         ref target_rustc_args } = *options;
 
     let target = target.map(|s| s.to_string());
     let features = features.iter().flat_map(|s| {
@@ -163,6 +167,23 @@ pub fn compile_pkg(package: &Package, options: &CompileOptions)
     let to_build = packages.iter().find(|p| p.package_id() == pkgid).unwrap();
     let targets = try!(generate_targets(to_build, mode, filter, release));
 
+    let target_with_args = match *target_rustc_args {
+        Some(args) if targets.len() == 1 => {
+            let (target, profile) = targets[0];
+            let mut profile = profile.clone();
+            profile.rustc_args = Some(args.to_vec());
+            Some((target, profile))
+        }
+        Some(_) =>
+            return Err(human("extra arguments to `rustc` can only be passed to one target, \
+                              consider filtering\nthe package by passing e.g. `--lib` or \
+                              `--bin NAME` to specify a single target")),
+        None => None,
+    };
+
+    let targets = target_with_args.as_ref().map(|&(t, ref p)| vec![(t, p)])
+                                           .unwrap_or(targets);
+
     let ret = {
         let _p = profile::start("compiling");
         let mut build_config = try!(scrape_build_config(config, jobs, target));

src/cargo/ops/cargo_package.rs

@@ -189,6 +189,7 @@ fn run_verify(config: &Config, pkg: &Package, tar: &Path)
         exec_engine: None,
         release: false,
         mode: ops::CompileMode::Build,
+        target_rustc_args: None,
     }));
 
     Ok(())

src/cargo/ops/cargo_rustc/mod.rs

@@ -620,8 +620,8 @@ fn build_base_args(cx: &Context,
                    profile: &Profile,
                    crate_types: &[&str]) {
     let Profile {
-        opt_level, lto, codegen_units, debuginfo, debug_assertions, rpath, test,
-        doc: _doc,
+        opt_level, lto, codegen_units, ref rustc_args, debuginfo, debug_assertions,
+        rpath, test, doc: _doc,
     } = *profile;
 
     // Move to cwd so the root_path() passed below is actually correct
@@ -664,6 +664,10 @@ fn build_base_args(cx: &Context,
         cmd.arg("-g");
     }
 
+    if let Some(ref args) = *rustc_args {
+        cmd.args(args);
+    }
+
     if debug_assertions && opt_level > 0 {
         cmd.args(&["-C", "debug-assertions=on"]);
     } else if !debug_assertions && opt_level == 0 {

src/cargo/util/toml.rs

@@ -814,6 +814,7 @@ fn build_profiles(profiles: &Option<TomlProfiles>) -> Profiles {
             opt_level: opt_level.unwrap_or(profile.opt_level),
             lto: lto.unwrap_or(profile.lto),
             codegen_units: codegen_units,
+            rustc_args: None,
             debuginfo: debug.unwrap_or(profile.debuginfo),
             debug_assertions: debug_assertions.unwrap_or(profile.debug_assertions),
             rpath: rpath.unwrap_or(profile.rpath),