Move compiler driver code from ops into core

Author: djc

src/cargo/ops/cargo_rustc/compilation.rs renamed to src/cargo/core/compiler/compilation.rs

@@ -21,6 +21,7 @@ pub mod resolver;
 pub mod summary;
 pub mod shell;
 pub mod registry;
+pub mod compiler;
 mod interning;
 mod package_id_spec;
 mod workspace;

src/cargo/ops/cargo_rustc/context/compilation_files.rs renamed to src/cargo/core/compiler/context/compilation_files.rs

@@ -2,10 +2,11 @@ use std::fs;
 use std::path::Path;
 
 use core::{Profiles, Workspace};
+use core::compiler::{BuildConfig, Context, Kind, Unit};
 use util::Config;
 use util::errors::{CargoResult, CargoResultExt};
 use util::paths;
-use ops::{self, BuildConfig, Context, Kind, Unit};
+use ops;
 
 pub struct CleanOptions<'a> {
     pub config: &'a Config,

src/cargo/ops/cargo_rustc/context/mod.rs renamed to src/cargo/core/compiler/context/mod.rs

@@ -28,8 +28,10 @@ use std::sync::Arc;
 
 use core::{Package, Source, Target};
 use core::{PackageId, PackageIdSpec, Profile, Profiles, TargetKind, Workspace};
+use core::compiler::{BuildConfig, BuildOutput, Compilation, Context, DefaultExecutor, Executor};
+use core::compiler::{Kind, TargetConfig, Unit};
 use core::resolver::{Method, Resolve};
-use ops::{self, BuildOutput, Context, DefaultExecutor, Executor, Kind, Unit};
+use ops;
 use util::config::Config;
 use util::{profile, CargoResult, CargoResultExt};
 
@@ -193,15 +195,15 @@ pub enum CompileFilter {
 pub fn compile<'a>(
     ws: &Workspace<'a>,
     options: &CompileOptions<'a>,
-) -> CargoResult<ops::Compilation<'a>> {
+) -> CargoResult<Compilation<'a>> {
     compile_with_exec(ws, options, Arc::new(DefaultExecutor))
 }
 
 pub fn compile_with_exec<'a>(
     ws: &Workspace<'a>,
     options: &CompileOptions<'a>,
     exec: Arc<Executor>,
-) -> CargoResult<ops::Compilation<'a>> {
+) -> CargoResult<Compilation<'a>> {
     for member in ws.members() {
         for warning in member.manifest().warnings().iter() {
             if warning.is_critical {
@@ -224,7 +226,7 @@ pub fn compile_ws<'a>(
     source: Option<Box<Source + 'a>>,
     options: &CompileOptions<'a>,
     exec: Arc<Executor>,
-) -> CargoResult<ops::Compilation<'a>> {
+) -> CargoResult<Compilation<'a>> {
     let CompileOptions {
         config,
         jobs,
@@ -844,7 +846,7 @@ fn scrape_build_config(
     config: &Config,
     jobs: Option<u32>,
     target: Option<String>,
-) -> CargoResult<ops::BuildConfig> {
+) -> CargoResult<BuildConfig> {
     if jobs.is_some() && config.jobserver_from_env().is_some() {
         config.shell().warn(
             "a `-j` argument was passed to Cargo but Cargo is \
@@ -875,7 +877,7 @@ fn scrape_build_config(
     let jobs = jobs.or(cfg_jobs).unwrap_or(::num_cpus::get() as u32);
     let cfg_target = config.get_string("build.target")?.map(|s| s.val);
     let target = target.or(cfg_target);
-    let mut base = ops::BuildConfig::new(&config.rustc()?.host, &target)?;
+    let mut base = BuildConfig::new(&config.rustc()?.host, &target)?;
     base.jobs = jobs;
     base.host = scrape_target_config(config, &base.host_triple)?;
     base.target = match target.as_ref() {
@@ -885,9 +887,9 @@ fn scrape_build_config(
     Ok(base)
 }
 
-fn scrape_target_config(config: &Config, triple: &str) -> CargoResult<ops::TargetConfig> {
+fn scrape_target_config(config: &Config, triple: &str) -> CargoResult<TargetConfig> {
     let key = format!("target.{}", triple);
-    let mut ret = ops::TargetConfig {
+    let mut ret = TargetConfig {
         ar: config.get_path(&format!("{}.ar", key))?.map(|v| v.val),
         linker: config.get_path(&format!("{}.linker", key))?.map(|v| v.val),
         overrides: HashMap::new(),

src/cargo/ops/cargo_rustc/context/target_info.rs renamed to src/cargo/core/compiler/context/target_info.rs

@@ -12,7 +12,8 @@ use toml;
 
 use core::{Dependency, Edition, Package, PackageIdSpec, Source, SourceId};
 use core::{PackageId, Workspace};
-use ops::{self, CompileFilter, DefaultExecutor};
+use core::compiler::DefaultExecutor;
+use ops::{self, CompileFilter};
 use sources::{GitSource, PathSource, SourceConfigMap};
 use util::{internal, Config};
 use util::{FileLock, Filesystem};

src/cargo/ops/cargo_rustc/context/unit_dependencies.rs renamed to src/cargo/core/compiler/context/unit_dependencies.rs

@@ -7,8 +7,7 @@ use std::path::{Path, PathBuf};
 use git2::Config as GitConfig;
 use git2::Repository as GitRepository;
 
-use core::Workspace;
-use ops::is_bad_artifact_name;
+use core::{compiler, Workspace};
 use util::{internal, FossilRepo, GitRepo, HgRepo, PijulRepo};
 use util::{paths, Config};
 use util::errors::{CargoResult, CargoResultExt};
@@ -136,7 +135,7 @@ fn check_name(name: &str, opts: &NewOptions) -> CargoResult<()> {
         "pure", "ref", "return", "self", "sizeof", "static", "struct", "super", "test", "trait",
         "true", "type", "typeof", "unsafe", "unsized", "use", "virtual", "where", "while", "yield",
     ];
-    if blacklist.contains(&name) || (opts.kind.is_bin() && is_bad_artifact_name(name)) {
+    if blacklist.contains(&name) || (opts.kind.is_bin() && compiler::is_bad_artifact_name(name)) {
         bail!(
             "The name `{}` cannot be used as a crate name{}",
             name,

src/cargo/ops/cargo_rustc/custom_build.rs renamed to src/cargo/core/compiler/custom_build.rs

@@ -10,11 +10,12 @@ use git2;
 use tar::{Archive, Builder, EntryType, Header};
 
 use core::{Package, Source, SourceId, Workspace};
+use core::compiler::DefaultExecutor;
 use sources::PathSource;
 use util::{self, internal, Config, FileLock};
 use util::paths;
 use util::errors::{CargoResult, CargoResultExt};
-use ops::{self, DefaultExecutor};
+use ops;
 
 pub struct PackageOpts<'cfg> {
     pub config: &'cfg Config,

src/cargo/ops/cargo_rustc/fingerprint.rs renamed to src/cargo/core/compiler/fingerprint.rs

@@ -1,6 +1,7 @@
 use std::ffi::{OsStr, OsString};
 
-use ops::{self, Compilation};
+use ops;
+use core::compiler::Compilation;
 use util::{self, CargoTestError, ProcessError, Test};
 use util::errors::CargoResult;
 use core::Workspace;

src/cargo/ops/cargo_rustc/job.rs renamed to src/cargo/core/compiler/job.rs

@@ -2,10 +2,6 @@ pub use self::cargo_clean::{clean, CleanOptions};
 pub use self::cargo_compile::{compile, compile_with_exec, compile_ws, CompileOptions};
 pub use self::cargo_compile::{CompileFilter, CompileMode, FilterRule, MessageFormat, Packages};
 pub use self::cargo_read_manifest::{read_package, read_packages};
-pub use self::cargo_rustc::{Compilation, Kind, Unit};
-pub use self::cargo_rustc::{is_bad_artifact_name, Context};
-pub use self::cargo_rustc::{BuildConfig, BuildOutput, TargetConfig};
-pub use self::cargo_rustc::{DefaultExecutor, Executor};
 pub use self::cargo_run::run;
 pub use self::cargo_install::{install, install_list, uninstall};
 pub use self::cargo_new::{init, new, NewOptions, VersionControl};
@@ -38,7 +34,6 @@ mod cargo_package;
 mod cargo_pkgid;
 mod cargo_read_manifest;
 mod cargo_run;
-mod cargo_rustc;
 mod cargo_test;
 mod lockfile;
 mod registry;

src/cargo/ops/cargo_rustc/job_queue.rs renamed to src/cargo/core/compiler/job_queue.rs

@@ -14,8 +14,7 @@ use std::path::{Path, PathBuf};
 use std::fs::{self, DirEntry};
 use std::collections::HashSet;
 
-use core::Target;
-use ops::is_bad_artifact_name;
+use core::{compiler, Target};
 use util::errors::CargoResult;
 use super::{LibKind, PathValue, StringOrBool, TomlBenchTarget, TomlBinTarget, TomlExampleTarget,
             TomlLibTarget, TomlManifest, TomlTarget, TomlTestTarget};
@@ -205,7 +204,7 @@ fn clean_bins(
             ));
         }
 
-        if is_bad_artifact_name(&name) {
+        if compiler::is_bad_artifact_name(&name) {
             bail!("the binary target name `{}` is forbidden", name)
         }
     }