Introduce rustc_interface and move some methods there

28 files changed, 1303 insertions, 1055 deletions

diff --git a/src/bootstrap/bin/rustc.rs b/src/bootstrap/bin/rustc.rs
index b6afe317a07..70e4a69a07d 100644
--- a/src/bootstrap/bin/rustc.rs
+++ b/src/bootstrap/bin/rustc.rs
@@ -107,6 +107,8 @@ fn main() {
         // actually downloaded, so we just always pass the `--sysroot` option.
         cmd.arg("--sysroot").arg(&sysroot);
 
+        cmd.arg("-Zexternal-macro-backtrace");
+
         // When we build Rust dylibs they're all intended for intermediate
         // usage, so make sure we pass the -Cprefer-dynamic flag instead of
         // linking all deps statically into the dylib.
diff --git a/src/librustc/dep_graph/dep_node.rs b/src/librustc/dep_graph/dep_node.rs
index 0d8f71a50ce..c607eb5906e 100644
--- a/src/librustc/dep_graph/dep_node.rs
+++ b/src/librustc/dep_graph/dep_node.rs
@@ -456,6 +456,7 @@ define_dep_nodes!( <'tcx>
     [eval_always] CoherenceInherentImplOverlapCheck,
     [] CoherenceCheckTrait(DefId),
     [eval_always] PrivacyAccessLevels(CrateNum),
+    [eval_always] Analysis(CrateNum),
 
     // Represents the MIR for a fn; also used as the task node for
     // things read/modify that MIR.
diff --git a/src/librustc/session/config.rs b/src/librustc/session/config.rs
index 65da458efbf..99eee4b559a 100644
--- a/src/librustc/session/config.rs
+++ b/src/librustc/session/config.rs
@@ -499,6 +499,13 @@ impl Input {
             Input::Str { ref mut input, .. } => Some(input),
         }
     }
+
+    pub fn source_name(&self) -> FileName {
+        match *self {
+            Input::File(ref ifile) => ifile.clone().into(),
+            Input::Str { ref name, .. } => name.clone(),
+        }
+    }
 }
 
 #[derive(Clone, Hash)]
diff --git a/src/librustc/session/mod.rs b/src/librustc/session/mod.rs
index 833785f0407..5b9b70edc68 100644
--- a/src/librustc/session/mod.rs
+++ b/src/librustc/session/mod.rs
@@ -899,14 +899,14 @@ impl Session {
 
     /// Returns the number of query threads that should be used for this
     /// compilation
-    pub fn threads_from_opts(opts: &config::Options) -> usize {
-        opts.debugging_opts.threads.unwrap_or(::num_cpus::get())
+    pub fn threads_from_count(query_threads: Option<usize>) -> usize {
+        query_threads.unwrap_or(::num_cpus::get())
     }
 
     /// Returns the number of query threads that should be used for this
     /// compilation
     pub fn threads(&self) -> usize {
-        Self::threads_from_opts(&self.opts)
+        Self::threads_from_count(self.opts.debugging_opts.threads)
     }
 
     /// Returns the number of codegen units that should be used for this
@@ -1023,16 +1023,67 @@ pub fn build_session(
         local_crate_source_file,
         registry,
         Lrc::new(source_map::SourceMap::new(file_path_mapping)),
-        None,
+        DiagnosticOutput::Default,
+        Default::default(),
     )
 }
 
+fn default_emitter(
+    sopts: &config::Options,
+    registry: errors::registry::Registry,
+    source_map: &Lrc<source_map::SourceMap>,
+    emitter_dest: Option<Box<dyn Write + Send>>,
+) -> Box<dyn Emitter + sync::Send> {
+    match (sopts.error_format, emitter_dest) {
+        (config::ErrorOutputType::HumanReadable(color_config), None) => Box::new(
+            EmitterWriter::stderr(
+                color_config,
+                Some(source_map.clone()),
+                false,
+                sopts.debugging_opts.teach,
+            ).ui_testing(sopts.debugging_opts.ui_testing),
+        ),
+        (config::ErrorOutputType::HumanReadable(_), Some(dst)) => Box::new(
+            EmitterWriter::new(dst, Some(source_map.clone()), false, false)
+                .ui_testing(sopts.debugging_opts.ui_testing),
+        ),
+        (config::ErrorOutputType::Json(pretty), None) => Box::new(
+            JsonEmitter::stderr(
+                Some(registry),
+                source_map.clone(),
+                pretty,
+            ).ui_testing(sopts.debugging_opts.ui_testing),
+        ),
+        (config::ErrorOutputType::Json(pretty), Some(dst)) => Box::new(
+            JsonEmitter::new(
+                dst,
+                Some(registry),
+                source_map.clone(),
+                pretty,
+            ).ui_testing(sopts.debugging_opts.ui_testing),
+        ),
+        (config::ErrorOutputType::Short(color_config), None) => Box::new(
+            EmitterWriter::stderr(color_config, Some(source_map.clone()), true, false),
+        ),
+        (config::ErrorOutputType::Short(_), Some(dst)) => {
+            Box::new(EmitterWriter::new(dst, Some(source_map.clone()), true, false))
+        }
+    }
+}
+
+pub enum DiagnosticOutput {
+    Default,
+    Raw(Box<dyn Write + Send>),
+    Emitter(Box<dyn Emitter + Send + sync::Send>)
+}
+
 pub fn build_session_with_source_map(
     sopts: config::Options,
     local_crate_source_file: Option<PathBuf>,
     registry: errors::registry::Registry,
     source_map: Lrc<source_map::SourceMap>,
-    emitter_dest: Option<Box<dyn Write + Send>>,
+    diagnostics_output: DiagnosticOutput,
+    lint_caps: FxHashMap<lint::LintId, lint::Level>,
 ) -> Session {
     // FIXME: This is not general enough to make the warning lint completely override
     // normal diagnostic warnings, since the warning lint can also be denied and changed
@@ -1054,42 +1105,13 @@ pub fn build_session_with_source_map(
 
     let external_macro_backtrace = sopts.debugging_opts.external_macro_backtrace;
 
-    let emitter: Box<dyn Emitter + sync::Send> =
-        match (sopts.error_format, emitter_dest) {
-            (config::ErrorOutputType::HumanReadable(color_config), None) => Box::new(
-                EmitterWriter::stderr(
-                    color_config,
-                    Some(source_map.clone()),
-                    false,
-                    sopts.debugging_opts.teach,
-                ).ui_testing(sopts.debugging_opts.ui_testing),
-            ),
-            (config::ErrorOutputType::HumanReadable(_), Some(dst)) => Box::new(
-                EmitterWriter::new(dst, Some(source_map.clone()), false, false)
-                    .ui_testing(sopts.debugging_opts.ui_testing),
-            ),
-            (config::ErrorOutputType::Json(pretty), None) => Box::new(
-                JsonEmitter::stderr(
-                    Some(registry),
-                    source_map.clone(),
-                    pretty,
-                ).ui_testing(sopts.debugging_opts.ui_testing),
-            ),
-            (config::ErrorOutputType::Json(pretty), Some(dst)) => Box::new(
-                JsonEmitter::new(
-                    dst,
-                    Some(registry),
-                    source_map.clone(),
-                    pretty,
-                ).ui_testing(sopts.debugging_opts.ui_testing),
-            ),
-            (config::ErrorOutputType::Short(color_config), None) => Box::new(
-                EmitterWriter::stderr(color_config, Some(source_map.clone()), true, false),
-            ),
-            (config::ErrorOutputType::Short(_), Some(dst)) => {
-                Box::new(EmitterWriter::new(dst, Some(source_map.clone()), true, false))
-            }
-        };
+    let emitter = match diagnostics_output {
+        DiagnosticOutput::Default => default_emitter(&sopts, registry, &source_map, None),
+        DiagnosticOutput::Raw(write) => {
+            default_emitter(&sopts, registry, &source_map, Some(write))
+        }
+        DiagnosticOutput::Emitter(emitter) => emitter,
+    };
 
     let diagnostic_handler = errors::Handler::with_emitter_and_flags(
         emitter,
@@ -1103,7 +1125,7 @@ pub fn build_session_with_source_map(
         },
     );
 
-    build_session_(sopts, local_crate_source_file, diagnostic_handler, source_map)
+    build_session_(sopts, local_crate_source_file, diagnostic_handler, source_map, lint_caps)
 }
 
 pub fn build_session_(
@@ -1111,6 +1133,7 @@ pub fn build_session_(
     local_crate_source_file: Option<PathBuf>,
     span_diagnostic: errors::Handler,
     source_map: Lrc<source_map::SourceMap>,
+    driver_lint_caps: FxHashMap<lint::LintId, lint::Level>,
 ) -> Session {
     let host_triple = TargetTriple::from_triple(config::host_triple());
     let host = Target::search(&host_triple).unwrap_or_else(|e|
@@ -1235,7 +1258,7 @@ pub fn build_session_(
         },
         has_global_allocator: Once::new(),
         has_panic_handler: Once::new(),
-        driver_lint_caps: Default::default(),
+        driver_lint_caps,
     };
 
     validate_commandline_args_with_session_available(&sess);
diff --git a/src/librustc/ty/context.rs b/src/librustc/ty/context.rs
index 9767396147c..d02c9fc174c 100644
--- a/src/librustc/ty/context.rs
+++ b/src/librustc/ty/context.rs
@@ -50,7 +50,7 @@ use rustc_data_structures::stable_hasher::{HashStable, hash_stable_hashmap,
                                            StableVec};
 use arena::{TypedArena, SyncDroplessArena};
 use rustc_data_structures::indexed_vec::{Idx, IndexVec};
-use rustc_data_structures::sync::{self, Lrc, Lock, WorkerLocal};
+use rustc_data_structures::sync::{Lrc, Lock, WorkerLocal};
 use std::any::Any;
 use std::borrow::Borrow;
 use std::cmp::Ordering;
@@ -1285,8 +1285,6 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
 
         let gcx = arenas.global_ctxt.as_ref().unwrap();
 
-        sync::assert_send_val(&gcx);
-
         let r = tls::enter_global(gcx, f);
 
         gcx.queries.record_computed_queries(s);
diff --git a/src/librustc/ty/query/config.rs b/src/librustc/ty/query/config.rs
index 0d3e9f7914b..feca0f7170e 100644
--- a/src/librustc/ty/query/config.rs
+++ b/src/librustc/ty/query/config.rs
@@ -611,6 +611,12 @@ impl<'tcx> QueryDescription<'tcx> for queries::extern_crate<'tcx> {
     }
 }
 
+impl<'tcx> QueryDescription<'tcx> for queries::analysis<'tcx> {
+    fn describe(_tcx: TyCtxt<'_, '_, '_>, _: CrateNum) -> Cow<'static, str> {
+        "running analysis passes on this crate".into()
+    }
+}
+
 impl<'tcx> QueryDescription<'tcx> for queries::lint_levels<'tcx> {
     fn describe(_tcx: TyCtxt<'_, '_, '_>, _: CrateNum) -> Cow<'static, str> {
         "computing the lint levels for items in this crate".into()
diff --git a/src/librustc/ty/query/mod.rs b/src/librustc/ty/query/mod.rs
index ee36a1af8f4..197b9a71b0a 100644
--- a/src/librustc/ty/query/mod.rs
+++ b/src/librustc/ty/query/mod.rs
@@ -19,7 +19,7 @@ use crate::mir::interpret::{ConstEvalRawResult, ConstEvalResult};
 use crate::mir::mono::CodegenUnit;
 use crate::mir;
 use crate::mir::interpret::GlobalId;
-use crate::session::{CompileResult, CrateDisambiguator};
+use crate::session::CrateDisambiguator;
 use crate::session::config::{EntryFnType, OutputFilenames, OptLevel};
 use crate::traits::{self, Vtable};
 use crate::traits::query::{
@@ -99,6 +99,9 @@ pub use self::on_disk_cache::OnDiskCache;
 // as they will raise an fatal error on query cycles instead.
 define_queries! { <'tcx>
     Other {
+        /// Run analysis passes on the crate
+        [] fn analysis: Analysis(CrateNum) -> Result<(), ErrorReported>,
+
         /// Records the type of every item.
         [] fn type_of: TypeOfItem(DefId) -> Ty<'tcx>,
 
@@ -290,7 +293,8 @@ define_queries! { <'tcx>
     },
 
     TypeChecking {
-        [] fn typeck_item_bodies: typeck_item_bodies_dep_node(CrateNum) -> CompileResult,
+        [] fn typeck_item_bodies:
+                typeck_item_bodies_dep_node(CrateNum) -> Result<(), ErrorReported>,
 
         [] fn typeck_tables_of: TypeckTables(DefId) -> &'tcx ty::TypeckTables<'tcx>,
     },
diff --git a/src/librustc/ty/query/plumbing.rs b/src/librustc/ty/query/plumbing.rs
index 37cb6753ed5..ebaa31d703f 100644
--- a/src/librustc/ty/query/plumbing.rs
+++ b/src/librustc/ty/query/plumbing.rs
@@ -1357,6 +1357,7 @@ pub fn force_from_dep_node<'a, 'gcx, 'lcx>(tcx: TyCtxt<'a, 'gcx, 'lcx>,
         DepKind::CrateHash => { force!(crate_hash, krate!()); }
         DepKind::OriginalCrateName => { force!(original_crate_name, krate!()); }
         DepKind::ExtraFileName => { force!(extra_filename, krate!()); }
+        DepKind::Analysis => { force!(analysis, krate!()); }
 
         DepKind::AllTraitImplementations => {
             force!(all_trait_implementations, krate!());
diff --git a/src/librustc_driver/Cargo.toml b/src/librustc_driver/Cargo.toml
index 2e6e775c526..0b379ef662d 100644
--- a/src/librustc_driver/Cargo.toml
+++ b/src/librustc_driver/Cargo.toml
@@ -33,6 +33,7 @@ rustc_save_analysis = { path = "../librustc_save_analysis" }
 rustc_traits = { path = "../librustc_traits" }
 rustc_codegen_utils = { path = "../librustc_codegen_utils" }
 rustc_typeck = { path = "../librustc_typeck" }
+rustc_interface = { path = "../librustc_interface" }
 serialize = { path = "../libserialize" }
 syntax = { path = "../libsyntax" }
 smallvec = { version = "0.6.7", features = ["union", "may_dangle"] }
diff --git a/src/librustc_driver/driver.rs b/src/librustc_driver/driver.rs
index b998b77a76b..f87a809e6c6 100644
--- a/src/librustc_driver/driver.rs
+++ b/src/librustc_driver/driver.rs
@@ -2,42 +2,39 @@ use rustc::dep_graph::DepGraph;
 use rustc::hir;
 use rustc::hir::lowering::lower_crate;
 use rustc::hir::map as hir_map;
+use rustc::hir::def_id::LOCAL_CRATE;
 use rustc::lint;
 use rustc::middle::{self, reachable, resolve_lifetime, stability};
 use rustc::ty::{self, AllArenas, Resolutions, TyCtxt};
 use rustc::traits;
 use rustc::util::common::{install_panic_hook, time, ErrorReported};
 use rustc::util::profiling::ProfileCategory;
-use rustc::session::{CompileResult, CrateDisambiguator, Session};
+use rustc::session::{CompileResult, Session};
 use rustc::session::CompileIncomplete;
 use rustc::session::config::{self, Input, OutputFilenames, OutputType};
 use rustc::session::search_paths::PathKind;
 use rustc_allocator as allocator;
 use rustc_borrowck as borrowck;
 use rustc_codegen_utils::codegen_backend::CodegenBackend;
-use rustc_data_structures::fingerprint::Fingerprint;
-use rustc_data_structures::stable_hasher::StableHasher;
 use rustc_data_structures::sync::{self, Lock};
 use rustc_incremental;
 use rustc_metadata::creader::CrateLoader;
 use rustc_metadata::cstore::{self, CStore};
 use rustc_mir as mir;
-use rustc_passes::{self, ast_validation, hir_stats, loops, rvalue_promotion, layout_test};
+use rustc_passes::{self, ast_validation, hir_stats};
 use rustc_plugin as plugin;
 use rustc_plugin::registry::Registry;
 use rustc_privacy;
 use rustc_resolve::{Resolver, ResolverArenas};
 use rustc_traits;
 use rustc_typeck as typeck;
-use syntax::{self, ast, attr, diagnostics, visit};
+use syntax::{self, ast, diagnostics, visit};
 use syntax::early_buffered_lints::BufferedEarlyLint;
 use syntax::ext::base::ExtCtxt;
 use syntax::mut_visit::MutVisitor;
 use syntax::parse::{self, PResult};
 use syntax::util::node_count::NodeCounter;
-use syntax::util::lev_distance::find_best_match_for_name;
-use syntax::symbol::Symbol;
-use syntax_pos::{FileName, hygiene};
+use syntax_pos::hygiene;
 use syntax_ext;
 
 use serialize::json;
@@ -46,14 +43,11 @@ use std::any::Any;
 use std::env;
 use std::ffi::OsString;
 use std::fs;
-use std::io::{self, Write};
 use std::iter;
 use std::path::{Path, PathBuf};
 use std::sync::mpsc;
 
-use pretty::ReplaceBodyWithLoop;
-use proc_macro_decls;
-use profile;
+use rustc_interface::{util, profile, passes};
 use super::Compilation;
 
 #[cfg(not(parallel_compiler))]
@@ -78,7 +72,7 @@ pub fn spawn_thread_pool<F: FnOnce(config::Options) -> R + sync::Send, R: sync::
     let gcx_ptr = &Lock::new(0);
 
     let config = ThreadPoolBuilder::new()
-        .num_threads(Session::threads_from_opts(&opts))
+        .num_threads(Session::threads_from_count(opts.debugging_opts.threads))
         .deadlock_handler(|| unsafe { ty::query::handle_deadlock() })
         .stack_size(::STACK_SIZE);
 
@@ -160,7 +154,7 @@ pub fn compile_input(
             (compile_state.krate.unwrap(), compile_state.registry)
         };
 
-        let outputs = build_output_filenames(input, outdir, output, &krate.attrs, sess);
+        let outputs = util::build_output_filenames(input, outdir, output, &krate.attrs, sess);
         let crate_name =
             ::rustc_codegen_utils::link::find_crate_name(Some(sess), &krate.attrs, input);
         install_panic_hook();
@@ -194,12 +188,17 @@ pub fn compile_input(
             )?
         };
 
-        let output_paths = generated_output_paths(sess, &outputs, output.is_some(), &crate_name);
+        let output_paths = passes::generated_output_paths(
+            sess,
+            &outputs,
+            output.is_some(),
+            &crate_name
+        );
 
         // Ensure the source file isn't accidentally overwritten during compilation.
         if let Some(ref input_path) = *input_path {
             if sess.opts.will_create_output_file() {
-                if output_contains_path(&output_paths, input_path) {
+                if passes::output_contains_path(&output_paths, input_path) {
                     sess.err(&format!(
                         "the input file \"{}\" would be overwritten by the generated \
                          executable",
@@ -207,7 +206,7 @@ pub fn compile_input(
                     ));
                     return Err(CompileIncomplete::Stopped);
                 }
-                if let Some(dir_path) = output_conflicts_with_dir(&output_paths) {
+                if let Some(dir_path) = passes::output_conflicts_with_dir(&output_paths) {
                     sess.err(&format!(
                         "the generated executable for the input file \"{}\" conflicts with the \
                          existing directory \"{}\"",
@@ -219,7 +218,7 @@ pub fn compile_input(
             }
         }
 
-        write_out_deps(sess, &outputs, &output_paths);
+        passes::write_out_deps(sess, &outputs, &output_paths);
         if sess.opts.output_types.contains_key(&OutputType::DepInfo)
             && sess.opts.output_types.len() == 1
         {
@@ -333,7 +332,7 @@ pub fn compile_input(
 
                 Ok((outputs.clone(), ongoing_codegen, tcx.dep_graph.clone()))
             },
-        )??
+        )?
     };
 
     if sess.opts.debugging_opts.print_type_sizes {
@@ -364,13 +363,6 @@ pub fn compile_input(
     Ok(())
 }
 
-pub fn source_name(input: &Input) -> FileName {
-    match *input {
-        Input::File(ref ifile) => ifile.clone().into(),
-        Input::Str { ref name, .. } => name.clone(),
-    }
-}
-
 /// CompileController is used to customize compilation, it allows compilation to
 /// be stopped and/or to call arbitrary code at various points in compilation.
 /// It also allows for various flags to be set to influence what information gets
@@ -806,10 +798,10 @@ where
     // these need to be set "early" so that expansion sees `quote` if enabled.
     sess.init_features(features);
 
-    let crate_types = collect_crate_types(sess, &krate.attrs);
+    let crate_types = util::collect_crate_types(sess, &krate.attrs);
     sess.crate_types.set(crate_types);
 
-    let disambiguator = compute_crate_disambiguator(sess);
+    let disambiguator = util::compute_crate_disambiguator(sess);
     sess.crate_disambiguator.set(disambiguator);
     rustc_incremental::prepare_session_directory(sess, &crate_name, disambiguator);
 
@@ -1019,7 +1011,7 @@ where
     // If we're actually rustdoc then there's no need to actually compile
     // anything, so switch everything to just looping
     if sess.opts.actually_rustdoc {
-        ReplaceBodyWithLoop::new(sess).visit_crate(&mut krate);
+        util::ReplaceBodyWithLoop::new(sess).visit_crate(&mut krate);
     }
 
     let (has_proc_macro_decls, has_global_allocator) = time(sess, "AST validation", || {
@@ -1145,7 +1137,7 @@ where
 }
 
 pub fn default_provide(providers: &mut ty::query::Providers) {
-    proc_macro_decls::provide(providers);
+    rustc_interface::passes::provide(providers);
     plugin::build::provide(providers);
     hir::provide(providers);
     borrowck::provide(providers);
@@ -1186,7 +1178,7 @@ pub fn phase_3_run_analysis_passes<'tcx, F, R>(
     name: &str,
     output_filenames: &OutputFilenames,
     f: F,
-) -> Result<R, CompileIncomplete>
+) -> R
 where
     F: for<'a> FnOnce(
         TyCtxt<'a, 'tcx, 'tcx>,
@@ -1227,114 +1219,9 @@ where
             // tcx available.
             time(sess, "dep graph tcx init", || rustc_incremental::dep_graph_tcx_init(tcx));
 
-            parallel!({
-                time(sess, "looking for entry point", || {
-                    middle::entry::find_entry_point(tcx)
-                });
-
-                time(sess, "looking for plugin registrar", || {
-                    plugin::build::find_plugin_registrar(tcx)
-                });
-
-                time(sess, "looking for derive registrar", || {
-                    proc_macro_decls::find(tcx)
-                });
-            }, {
-                time(sess, "loop checking", || loops::check_crate(tcx));
-            }, {
-                time(sess, "attribute checking", || {
-                    hir::check_attr::check_crate(tcx)
-                });
-            }, {
-                time(sess, "stability checking", || {
-                    stability::check_unstable_api_usage(tcx)
-                });
-            });
-
-            // passes are timed inside typeck
-            match typeck::check_crate(tcx) {
-                Ok(x) => x,
-                Err(x) => {
-                    f(tcx, rx, Err(x));
-                    return Err(x);
-                }
-            }
+            tcx.analysis(LOCAL_CRATE).ok();
 
-            time(sess, "misc checking", || {
-                parallel!({
-                    time(sess, "rvalue promotion", || {
-                        rvalue_promotion::check_crate(tcx)
-                    });
-                }, {
-                    time(sess, "intrinsic checking", || {
-                        middle::intrinsicck::check_crate(tcx)
-                    });
-                }, {
-                    time(sess, "match checking", || mir::matchck_crate(tcx));
-                }, {
-                    // this must run before MIR dump, because
-                    // "not all control paths return a value" is reported here.
-                    //
-                    // maybe move the check to a MIR pass?
-                    time(sess, "liveness checking", || {
-                        middle::liveness::check_crate(tcx)
-                    });
-                });
-            });
-
-            // Abort so we don't try to construct MIR with liveness errors.
-            // We also won't want to continue with errors from rvalue promotion
-            tcx.sess.abort_if_errors();
-
-            time(sess, "borrow checking", || {
-                if tcx.use_ast_borrowck() {
-                    borrowck::check_crate(tcx);
-                }
-            });
-
-            time(sess,
-                 "MIR borrow checking",
-                 || tcx.par_body_owners(|def_id| { tcx.ensure().mir_borrowck(def_id); }));
-
-            time(sess, "dumping chalk-like clauses", || {
-                rustc_traits::lowering::dump_program_clauses(tcx);
-            });
-
-            time(sess, "MIR effect checking", || {
-                for def_id in tcx.body_owners() {
-                    mir::transform::check_unsafety::check_unsafety(tcx, def_id)
-                }
-            });
-
-            time(sess, "layout testing", || layout_test::test_layout(tcx));
-
-            // Avoid overwhelming user with errors if borrow checking failed.
-            // I'm not sure how helpful this is, to be honest, but it avoids
-            // a
-            // lot of annoying errors in the compile-fail tests (basically,
-            // lint warnings and so on -- kindck used to do this abort, but
-            // kindck is gone now). -nmatsakis
-            if sess.err_count() > 0 {
-                return Ok(f(tcx, rx, sess.compile_status()));
-            }
-
-            time(sess, "misc checking", || {
-                parallel!({
-                    time(sess, "privacy checking", || {
-                        rustc_privacy::check_crate(tcx)
-                    });
-                }, {
-                    time(sess, "death checking", || middle::dead::check_crate(tcx));
-                },  {
-                    time(sess, "unused lib feature checking", || {
-                        stability::check_unused_or_stable_features(tcx)
-                    });
-                }, {
-                    time(sess, "lint checking", || lint::check_crate(tcx));
-                });
-            });
-
-            return Ok(f(tcx, rx, tcx.sess.compile_status()));
+            f(tcx, rx, tcx.sess.compile_status())
         },
     )
 }
@@ -1359,328 +1246,3 @@ pub fn phase_4_codegen<'a, 'tcx>(
 
     codegen
 }
-
-fn escape_dep_filename(filename: &FileName) -> String {
-    // Apparently clang and gcc *only* escape spaces:
-    // http://llvm.org/klaus/clang/commit/9d50634cfc268ecc9a7250226dd5ca0e945240d4
-    filename.to_string().replace(" ", "\\ ")
-}
-
-// Returns all the paths that correspond to generated files.
-fn generated_output_paths(
-    sess: &Session,
-    outputs: &OutputFilenames,
-    exact_name: bool,
-    crate_name: &str,
-) -> Vec<PathBuf> {
-    let mut out_filenames = Vec::new();
-    for output_type in sess.opts.output_types.keys() {
-        let file = outputs.path(*output_type);
-        match *output_type {
-            // If the filename has been overridden using `-o`, it will not be modified
-            // by appending `.rlib`, `.exe`, etc., so we can skip this transformation.
-            OutputType::Exe if !exact_name => for crate_type in sess.crate_types.borrow().iter() {
-                let p = ::rustc_codegen_utils::link::filename_for_input(
-                    sess,
-                    *crate_type,
-                    crate_name,
-                    outputs,
-                );
-                out_filenames.push(p);
-            },
-            OutputType::DepInfo if sess.opts.debugging_opts.dep_info_omit_d_target => {
-                // Don't add the dep-info output when omitting it from dep-info targets
-            }
-            _ => {
-                out_filenames.push(file);
-            }
-        }
-    }
-    out_filenames
-}
-
-// Runs `f` on every output file path and returns the first non-None result, or None if `f`
-// returns None for every file path.
-fn check_output<F, T>(output_paths: &[PathBuf], f: F) -> Option<T>
-where
-    F: Fn(&PathBuf) -> Option<T>,
-{
-    for output_path in output_paths {
-        if let Some(result) = f(output_path) {
-            return Some(result);
-        }
-    }
-    None
-}
-
-pub fn output_contains_path(output_paths: &[PathBuf], input_path: &PathBuf) -> bool {
-    let input_path = input_path.canonicalize().ok();
-    if input_path.is_none() {
-        return false;
-    }
-    let check = |output_path: &PathBuf| {
-        if output_path.canonicalize().ok() == input_path {
-            Some(())
-        } else {
-            None
-        }
-    };
-    check_output(output_paths, check).is_some()
-}
-
-pub fn output_conflicts_with_dir(output_paths: &[PathBuf]) -> Option<PathBuf> {
-    let check = |output_path: &PathBuf| {
-        if output_path.is_dir() {
-            Some(output_path.clone())
-        } else {
-            None
-        }
-    };
-    check_output(output_paths, check)
-}
-
-fn write_out_deps(sess: &Session, outputs: &OutputFilenames, out_filenames: &[PathBuf]) {
-    // Write out dependency rules to the dep-info file if requested
-    if !sess.opts.output_types.contains_key(&OutputType::DepInfo) {
-        return;
-    }
-    let deps_filename = outputs.path(OutputType::DepInfo);
-
-    let result = (|| -> io::Result<()> {
-        // Build a list of files used to compile the output and
-        // write Makefile-compatible dependency rules
-        let files: Vec<String> = sess.source_map()
-            .files()
-            .iter()
-            .filter(|fmap| fmap.is_real_file())
-            .filter(|fmap| !fmap.is_imported())
-            .map(|fmap| escape_dep_filename(&fmap.name))
-            .collect();
-        let mut file = fs::File::create(&deps_filename)?;
-        for path in out_filenames {
-            writeln!(file, "{}: {}\n", path.display(), files.join(" "))?;
-        }
-
-        // Emit a fake target for each input file to the compilation. This
-        // prevents `make` from spitting out an error if a file is later
-        // deleted. For more info see #28735
-        for path in files {
-            writeln!(file, "{}:", path)?;
-        }
-        Ok(())
-    })();
-
-    if let Err(e) = result {
-        sess.fatal(&format!(
-            "error writing dependencies to `{}`: {}",
-            deps_filename.display(),
-            e
-        ));
-    }
-}
-
-pub fn collect_crate_types(session: &Session, attrs: &[ast::Attribute]) -> Vec<config::CrateType> {
-    // Unconditionally collect crate types from attributes to make them used
-    let attr_types: Vec<config::CrateType> = attrs
-        .iter()
-        .filter_map(|a| {
-            if a.check_name("crate_type") {
-                match a.value_str() {
-                    Some(ref n) if *n == "rlib" => Some(config::CrateType::Rlib),
-                    Some(ref n) if *n == "dylib" => Some(config::CrateType::Dylib),
-                    Some(ref n) if *n == "cdylib" => Some(config::CrateType::Cdylib),
-                    Some(ref n) if *n == "lib" => Some(config::default_lib_output()),
-                    Some(ref n) if *n == "staticlib" => Some(config::CrateType::Staticlib),
-                    Some(ref n) if *n == "proc-macro" => Some(config::CrateType::ProcMacro),
-                    Some(ref n) if *n == "bin" => Some(config::CrateType::Executable),
-                    Some(ref n) => {
-                        let crate_types = vec![
-                            Symbol::intern("rlib"),
-                            Symbol::intern("dylib"),
-                            Symbol::intern("cdylib"),
-                            Symbol::intern("lib"),
-                            Symbol::intern("staticlib"),
-                            Symbol::intern("proc-macro"),
-                            Symbol::intern("bin")
-                        ];
-
-                        if let ast::MetaItemKind::NameValue(spanned) = a.meta().unwrap().node {
-                            let span = spanned.span;
-                            let lev_candidate = find_best_match_for_name(
-                                crate_types.iter(),
-                                &n.as_str(),
-                                None
-                            );
-                            if let Some(candidate) = lev_candidate {
-                                session.buffer_lint_with_diagnostic(
-                                    lint::builtin::UNKNOWN_CRATE_TYPES,
-                                    ast::CRATE_NODE_ID,
-                                    span,
-                                    "invalid `crate_type` value",
-                                    lint::builtin::BuiltinLintDiagnostics::
-                                        UnknownCrateTypes(
-                                            span,
-                                            "did you mean".to_string(),
-                                            format!("\"{}\"", candidate)
-                                        )
-                                );
-                            } else {
-                                session.buffer_lint(
-                                    lint::builtin::UNKNOWN_CRATE_TYPES,
-                                    ast::CRATE_NODE_ID,
-                                    span,
-                                    "invalid `crate_type` value"
-                                );
-                            }
-                        }
-                        None
-                    }
-                    None => None
-                }
-            } else {
-                None
-            }
-        })
-        .collect();
-
-    // If we're generating a test executable, then ignore all other output
-    // styles at all other locations
-    if session.opts.test {
-        return vec![config::CrateType::Executable];
-    }
-
-    // Only check command line flags if present. If no types are specified by
-    // command line, then reuse the empty `base` Vec to hold the types that
-    // will be found in crate attributes.
-    let mut base = session.opts.crate_types.clone();
-    if base.is_empty() {
-        base.extend(attr_types);
-        if base.is_empty() {
-            base.push(::rustc_codegen_utils::link::default_output_for_target(
-                session,
-            ));
-        } else {
-            base.sort();
-            base.dedup();
-        }
-    }
-
-    base.retain(|crate_type| {
-        let res = !::rustc_codegen_utils::link::invalid_output_for_target(session, *crate_type);
-
-        if !res {
-            session.warn(&format!(
-                "dropping unsupported crate type `{}` for target `{}`",
-                *crate_type, session.opts.target_triple
-            ));
-        }
-
-        res
-    });
-
-    base
-}
-
-pub fn compute_crate_disambiguator(session: &Session) -> CrateDisambiguator {
-    use std::hash::Hasher;
-
-    // The crate_disambiguator is a 128 bit hash. The disambiguator is fed
-    // into various other hashes quite a bit (symbol hashes, incr. comp. hashes,
-    // debuginfo type IDs, etc), so we don't want it to be too wide. 128 bits
-    // should still be safe enough to avoid collisions in practice.
-    let mut hasher = StableHasher::<Fingerprint>::new();
-
-    let mut metadata = session.opts.cg.metadata.clone();
-    // We don't want the crate_disambiguator to dependent on the order
-    // -C metadata arguments, so sort them:
-    metadata.sort();
-    // Every distinct -C metadata value is only incorporated once:
-    metadata.dedup();
-
-    hasher.write(b"metadata");
-    for s in &metadata {
-        // Also incorporate the length of a metadata string, so that we generate
-        // different values for `-Cmetadata=ab -Cmetadata=c` and
-        // `-Cmetadata=a -Cmetadata=bc`
-        hasher.write_usize(s.len());
-        hasher.write(s.as_bytes());
-    }
-
-    // Also incorporate crate type, so that we don't get symbol conflicts when
-    // linking against a library of the same name, if this is an executable.
-    let is_exe = session
-        .crate_types
-        .borrow()
-        .contains(&config::CrateType::Executable);
-    hasher.write(if is_exe { b"exe" } else { b"lib" });
-
-    CrateDisambiguator::from(hasher.finish())
-}
-
-pub fn build_output_filenames(
-    input: &Input,
-    odir: &Option<PathBuf>,
-    ofile: &Option<PathBuf>,
-    attrs: &[ast::Attribute],
-    sess: &Session,
-) -> OutputFilenames {
-    match *ofile {
-        None => {
-            // "-" as input file will cause the parser to read from stdin so we
-            // have to make up a name
-            // We want to toss everything after the final '.'
-            let dirpath = (*odir).as_ref().cloned().unwrap_or_default();
-
-            // If a crate name is present, we use it as the link name
-            let stem = sess.opts
-                .crate_name
-                .clone()
-                .or_else(|| attr::find_crate_name(attrs).map(|n| n.to_string()))
-                .unwrap_or_else(|| input.filestem().to_owned());
-
-            OutputFilenames {
-                out_directory: dirpath,
-                out_filestem: stem,
-                single_output_file: None,
-                extra: sess.opts.cg.extra_filename.clone(),
-                outputs: sess.opts.output_types.clone(),
-            }
-        }
-
-        Some(ref out_file) => {
-            let unnamed_output_types = sess.opts
-                .output_types
-                .values()
-                .filter(|a| a.is_none())
-                .count();
-            let ofile = if unnamed_output_types > 1 {
-                sess.warn(
-                    "due to multiple output types requested, the explicitly specified \
-                     output file name will be adapted for each output type",
-                );
-                None
-            } else {
-                Some(out_file.clone())
-            };
-            if *odir != None {
-                sess.warn("ignoring --out-dir flag due to -o flag");
-            }
-            if !sess.opts.cg.extra_filename.is_empty() {
-                sess.warn("ignoring -C extra-filename flag due to -o flag");
-            }
-
-            OutputFilenames {
-                out_directory: out_file.parent().unwrap_or_else(|| Path::new("")).to_path_buf(),
-                out_filestem: out_file
-                    .file_stem()
-                    .unwrap_or_default()
-                    .to_str()
-                    .unwrap()
-                    .to_string(),
-                single_output_file: ofile,
-                extra: sess.opts.cg.extra_filename.clone(),
-                outputs: sess.opts.output_types.clone(),
-            }
-        }
-    }
-}
diff --git a/src/librustc_driver/lib.rs b/src/librustc_driver/lib.rs
index e022d3a3818..52dbb618d0d 100644
--- a/src/librustc_driver/lib.rs
+++ b/src/librustc_driver/lib.rs
@@ -27,7 +27,6 @@ extern crate rustc;
 extern crate rustc_allocator;
 extern crate rustc_target;
 extern crate rustc_borrowck;
-#[macro_use]
 extern crate rustc_data_structures;
 extern crate rustc_errors as errors;
 extern crate rustc_passes;
@@ -42,6 +41,7 @@ extern crate rustc_save_analysis;
 extern crate rustc_traits;
 extern crate rustc_codegen_utils;
 extern crate rustc_typeck;
+extern crate rustc_interface;
 extern crate scoped_tls;
 extern crate serialize;
 extern crate smallvec;
@@ -58,19 +58,18 @@ use rustc_save_analysis as save;
 use rustc_save_analysis::DumpHandler;
 use rustc_data_structures::sync::{self, Lrc, Ordering::SeqCst};
 use rustc_data_structures::OnDrop;
-use rustc::session::{self, config, Session, build_session, CompileResult};
+use rustc::session::{self, config, Session, build_session, CompileResult, DiagnosticOutput};
 use rustc::session::CompileIncomplete;
 use rustc::session::config::{Input, PrintRequest, ErrorOutputType};
 use rustc::session::config::nightly_options;
-use rustc::session::filesearch;
 use rustc::session::{early_error, early_warn};
 use rustc::lint::Lint;
 use rustc::lint;
 use rustc_metadata::locator;
 use rustc_metadata::cstore::CStore;
-use rustc_metadata::dynamic_lib::DynamicLibrary;
 use rustc::util::common::{time, ErrorReported};
 use rustc_codegen_utils::codegen_backend::CodegenBackend;
+use rustc_interface::util::{self, get_codegen_sysroot};
 
 use serialize::json::ToJson;
 
@@ -78,19 +77,15 @@ use std::any::Any;
 use std::borrow::Cow;
 use std::cmp::max;
 use std::default::Default;
-use std::env::consts::{DLL_PREFIX, DLL_SUFFIX};
 use std::env;
 use std::error::Error;
 use std::ffi::OsString;
 use std::fmt::{self, Display};
 use std::io::{self, Read, Write};
-use std::mem;
 use std::panic;
-use std::path::{PathBuf, Path};
+use std::path::PathBuf;
 use std::process::{self, Command, Stdio};
 use std::str;
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::{Once, ONCE_INIT};
 use std::thread;
 
 use syntax::ast;
@@ -102,34 +97,8 @@ use syntax_pos::{DUMMY_SP, MultiSpan, FileName};
 #[cfg(test)]
 mod test;
 
-pub mod profile;
 pub mod driver;
 pub mod pretty;
-mod proc_macro_decls;
-
-pub mod target_features {
-    use syntax::ast;
-    use syntax::symbol::Symbol;
-    use rustc::session::Session;
-    use rustc_codegen_utils::codegen_backend::CodegenBackend;
-
-    /// Adds `target_feature = "..."` cfgs for a variety of platform
-    /// specific features (SSE, NEON etc.).
-    ///
-    /// This is performed by checking whether a whitelisted set of
-    /// features is available on the target machine, by querying LLVM.
-    pub fn add_configuration(cfg: &mut ast::CrateConfig,
-                             sess: &Session,
-                             codegen_backend: &dyn CodegenBackend) {
-        let tf = Symbol::intern("target_feature");
-
-        cfg.extend(codegen_backend.target_features(sess).into_iter().map(|feat| (tf, Some(feat))));
-
-        if sess.crt_static_feature() {
-            cfg.insert((tf, Some(Symbol::intern("crt-static"))));
-        }
-    }
-}
 
 /// Exit status code used for successful compilation and help output.
 pub const EXIT_SUCCESS: isize = 0;
@@ -196,235 +165,6 @@ pub fn run<F>(run_compiler: F) -> isize
     }
 }
 
-fn load_backend_from_dylib(path: &Path) -> fn() -> Box<dyn CodegenBackend> {
-    let lib = DynamicLibrary::open(Some(path)).unwrap_or_else(|err| {
-        let err = format!("couldn't load codegen backend {:?}: {:?}", path, err);
-        early_error(ErrorOutputType::default(), &err);
-    });
-    unsafe {
-        match lib.symbol("__rustc_codegen_backend") {
-            Ok(f) => {
-                mem::forget(lib);
-                mem::transmute::<*mut u8, _>(f)
-            }
-            Err(e) => {
-                let err = format!("couldn't load codegen backend as it \
-                                   doesn't export the `__rustc_codegen_backend` \
-                                   symbol: {:?}", e);
-                early_error(ErrorOutputType::default(), &err);
-            }
-        }
-    }
-}
-
-pub fn get_codegen_backend(sess: &Session) -> Box<dyn CodegenBackend> {
-    static INIT: Once = ONCE_INIT;
-
-    #[allow(deprecated)]
-    #[no_debug]
-    static mut LOAD: fn() -> Box<dyn CodegenBackend> = || unreachable!();
-
-    INIT.call_once(|| {
-        let codegen_name = sess.opts.debugging_opts.codegen_backend.as_ref()
-            .unwrap_or(&sess.target.target.options.codegen_backend);
-        let backend = match &codegen_name[..] {
-            "metadata_only" => {
-                rustc_codegen_utils::codegen_backend::MetadataOnlyCodegenBackend::boxed
-            }
-            filename if filename.contains(".") => {
-                load_backend_from_dylib(filename.as_ref())
-            }
-            codegen_name => get_codegen_sysroot(codegen_name),
-        };
-
-        unsafe {
-            LOAD = backend;
-        }
-    });
-    let backend = unsafe { LOAD() };
-    backend.init(sess);
-    backend
-}
-
-fn get_codegen_sysroot(backend_name: &str) -> fn() -> Box<dyn CodegenBackend> {
-    // For now we only allow this function to be called once as it'll dlopen a
-    // few things, which seems to work best if we only do that once. In
-    // general this assertion never trips due to the once guard in `get_codegen_backend`,
-    // but there's a few manual calls to this function in this file we protect
-    // against.
-    static LOADED: AtomicBool = AtomicBool::new(false);
-    assert!(!LOADED.fetch_or(true, Ordering::SeqCst),
-            "cannot load the default codegen backend twice");
-
-    // When we're compiling this library with `--test` it'll run as a binary but
-    // not actually exercise much functionality. As a result most of the logic
-    // here is defunkt (it assumes we're a dynamic library in a sysroot) so
-    // let's just return a dummy creation function which won't be used in
-    // general anyway.
-    if cfg!(test) {
-        return rustc_codegen_utils::codegen_backend::MetadataOnlyCodegenBackend::boxed
-    }
-
-    let target = session::config::host_triple();
-    let mut sysroot_candidates = vec![filesearch::get_or_default_sysroot()];
-    let path = current_dll_path()
-        .and_then(|s| s.canonicalize().ok());
-    if let Some(dll) = path {
-        // use `parent` twice to chop off the file name and then also the
-        // directory containing the dll which should be either `lib` or `bin`.
-        if let Some(path) = dll.parent().and_then(|p| p.parent()) {
-            // The original `path` pointed at the `rustc_driver` crate's dll.
-            // Now that dll should only be in one of two locations. The first is
-            // in the compiler's libdir, for example `$sysroot/lib/*.dll`. The
-            // other is the target's libdir, for example
-            // `$sysroot/lib/rustlib/$target/lib/*.dll`.
-            //
-            // We don't know which, so let's assume that if our `path` above
-            // ends in `$target` we *could* be in the target libdir, and always
-            // assume that we may be in the main libdir.
-            sysroot_candidates.push(path.to_owned());
-
-            if path.ends_with(target) {
-                sysroot_candidates.extend(path.parent() // chop off `$target`
-                    .and_then(|p| p.parent())           // chop off `rustlib`
-                    .and_then(|p| p.parent())           // chop off `lib`
-                    .map(|s| s.to_owned()));
-            }
-        }
-    }
-
-    let sysroot = sysroot_candidates.iter()
-        .map(|sysroot| {
-            let libdir = filesearch::relative_target_lib_path(&sysroot, &target);
-            sysroot.join(libdir).with_file_name(
-                option_env!("CFG_CODEGEN_BACKENDS_DIR").unwrap_or("codegen-backends"))
-        })
-        .filter(|f| {
-            info!("codegen backend candidate: {}", f.display());
-            f.exists()
-        })
-        .next();
-    let sysroot = sysroot.unwrap_or_else(|| {
-        let candidates = sysroot_candidates.iter()
-            .map(|p| p.display().to_string())
-            .collect::<Vec<_>>()
-            .join("\n* ");
-        let err = format!("failed to find a `codegen-backends` folder \
-                           in the sysroot candidates:\n* {}", candidates);
-        early_error(ErrorOutputType::default(), &err);
-    });
-    info!("probing {} for a codegen backend", sysroot.display());
-
-    let d = sysroot.read_dir().unwrap_or_else(|e| {
-        let err = format!("failed to load default codegen backend, couldn't \
-                           read `{}`: {}", sysroot.display(), e);
-        early_error(ErrorOutputType::default(), &err);
-    });
-
-    let mut file: Option<PathBuf> = None;
-
-    let expected_name = format!("rustc_codegen_llvm-{}", backend_name);
-    for entry in d.filter_map(|e| e.ok()) {
-        let path = entry.path();
-        let filename = match path.file_name().and_then(|s| s.to_str()) {
-            Some(s) => s,
-            None => continue,
-        };
-        if !(filename.starts_with(DLL_PREFIX) && filename.ends_with(DLL_SUFFIX)) {
-            continue
-        }
-        let name = &filename[DLL_PREFIX.len() .. filename.len() - DLL_SUFFIX.len()];
-        if name != expected_name {
-            continue
-        }
-        if let Some(ref prev) = file {
-            let err = format!("duplicate codegen backends found\n\
-                               first:  {}\n\
-                               second: {}\n\
-            ", prev.display(), path.display());
-            early_error(ErrorOutputType::default(), &err);
-        }
-        file = Some(path.clone());
-    }
-
-    match file {
-        Some(ref s) => return load_backend_from_dylib(s),
-        None => {
-            let err = format!("failed to load default codegen backend for `{}`, \
-                               no appropriate codegen dylib found in `{}`",
-                              backend_name, sysroot.display());
-            early_error(ErrorOutputType::default(), &err);
-        }
-    }
-
-    #[cfg(unix)]
-    fn current_dll_path() -> Option<PathBuf> {
-        use std::ffi::{OsStr, CStr};
-        use std::os::unix::prelude::*;
-
-        unsafe {
-            let addr = current_dll_path as usize as *mut _;
-            let mut info = mem::zeroed();
-            if libc::dladdr(addr, &mut info) == 0 {
-                info!("dladdr failed");
-                return None
-            }
-            if info.dli_fname.is_null() {
-                info!("dladdr returned null pointer");
-                return None
-            }
-            let bytes = CStr::from_ptr(info.dli_fname).to_bytes();
-            let os = OsStr::from_bytes(bytes);
-            Some(PathBuf::from(os))
-        }
-    }
-
-    #[cfg(windows)]
-    fn current_dll_path() -> Option<PathBuf> {
-        use std::ffi::OsString;
-        use std::os::windows::prelude::*;
-
-        extern "system" {
-            fn GetModuleHandleExW(dwFlags: u32,
-                                  lpModuleName: usize,
-                                  phModule: *mut usize) -> i32;
-            fn GetModuleFileNameW(hModule: usize,
-                                  lpFilename: *mut u16,
-                                  nSize: u32) -> u32;
-        }
-
-        const GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS: u32 = 0x00000004;
-
-        unsafe {
-            let mut module = 0;
-            let r = GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
-                                       current_dll_path as usize,
-                                       &mut module);
-            if r == 0 {
-                info!("GetModuleHandleExW failed: {}", io::Error::last_os_error());
-                return None
-            }
-            let mut space = Vec::with_capacity(1024);
-            let r = GetModuleFileNameW(module,
-                                       space.as_mut_ptr(),
-                                       space.capacity() as u32);
-            if r == 0 {
-                info!("GetModuleFileNameW failed: {}", io::Error::last_os_error());
-                return None
-            }
-            let r = r as usize;
-            if r >= space.capacity() {
-                info!("our buffer was too small? {}",
-                      io::Error::last_os_error());
-                return None
-            }
-            space.set_len(r);
-            let os = OsString::from_wide(&space);
-            Some(PathBuf::from(os))
-        }
-    }
-}
-
 // Parse args and run the compiler. This is the primary entry point for rustc.
 // See comments on CompilerCalls below for details about the callbacks argument.
 // The FileLoader provides a way to load files from sources other than the file system.
@@ -485,7 +225,12 @@ fn run_compiler_with_pool<'a>(
     let loader = file_loader.unwrap_or(box RealFileLoader);
     let source_map = Lrc::new(SourceMap::with_file_loader(loader, sopts.file_path_mapping()));
     let mut sess = session::build_session_with_source_map(
-        sopts, input_file_path.clone(), descriptions, source_map, emitter_dest,
+        sopts,
+        input_file_path.clone(),
+        descriptions,
+        source_map,
+        emitter_dest.map(|e| DiagnosticOutput::Raw(e)).unwrap_or(DiagnosticOutput::Default),
+        Default::default(),
     );
 
     if let Some(err) = input_err {
@@ -495,12 +240,12 @@ fn run_compiler_with_pool<'a>(
         return (Err(CompileIncomplete::Stopped), Some(sess));
     }
 
-    let codegen_backend = get_codegen_backend(&sess);
+    let codegen_backend = util::get_codegen_backend(&sess);
 
     rustc_lint::register_builtins(&mut sess.lint_store.borrow_mut(), Some(&sess));
 
     let mut cfg = config::build_configuration(&sess, cfg);
-    target_features::add_configuration(&mut cfg, &sess, &*codegen_backend);
+    util::add_configuration(&mut cfg, &sess, &*codegen_backend);
     sess.parse_sess.config = cfg;
 
     let result = {
@@ -710,8 +455,8 @@ fn stdout_isatty() -> bool {
 }
 
 fn handle_explain(code: &str,
-                  descriptions: &errors::registry::Registry,
                   output: ErrorOutputType) {
+    let descriptions = rustc_interface::util::diagnostics_registry();
     let normalised = if code.starts_with("E") {
         code.to_string()
     } else {
@@ -788,11 +533,11 @@ impl<'a> CompilerCalls<'a> for RustcDefaultCalls {
                       matches: &getopts::Matches,
                       _: &config::Options,
                       _: &ast::CrateConfig,
-                      descriptions: &errors::registry::Registry,
+                      _: &errors::registry::Registry,
                       output: ErrorOutputType)
                       -> Compilation {
         if let Some(ref code) = matches.opt_str("explain") {
-            handle_explain(code, descriptions, output);
+            handle_explain(code, output);
             return Compilation::Stop;
         }
 
@@ -820,8 +565,8 @@ impl<'a> CompilerCalls<'a> for RustcDefaultCalls {
                 }
                 rustc_lint::register_builtins(&mut sess.lint_store.borrow_mut(), Some(&sess));
                 let mut cfg = config::build_configuration(&sess, cfg.clone());
-                let codegen_backend = get_codegen_backend(&sess);
-                target_features::add_configuration(&mut cfg, &sess, &*codegen_backend);
+                let codegen_backend = util::get_codegen_backend(&sess);
+                util::add_configuration(&mut cfg, &sess, &*codegen_backend);
                 sess.parse_sess.config = cfg;
                 let should_stop = RustcDefaultCalls::print_crate_info(
                     &*codegen_backend,
@@ -1024,13 +769,19 @@ impl RustcDefaultCalls {
                     let input = input.unwrap_or_else(||
                         early_error(ErrorOutputType::default(), "no input file provided"));
                     let attrs = attrs.as_ref().unwrap();
-                    let t_outputs = driver::build_output_filenames(input, odir, ofile, attrs, sess);
+                    let t_outputs = rustc_interface::util::build_output_filenames(
+                        input,
+                        odir,
+                        ofile,
+                        attrs,
+                        sess
+                    );
                     let id = rustc_codegen_utils::link::find_crate_name(Some(sess), attrs, input);
                     if *req == PrintRequest::CrateName {
                         println!("{}", id);
                         continue;
                     }
-                    let crate_types = driver::collect_crate_types(sess, attrs);
+                    let crate_types = rustc_interface::util::collect_crate_types(sess, attrs);
                     for &style in &crate_types {
                         let fname = rustc_codegen_utils::link::filename_for_input(
                             sess,
diff --git a/src/librustc_driver/pretty.rs b/src/librustc_driver/pretty.rs
index 0698c15346e..ac2f6da0c60 100644
--- a/src/librustc_driver/pretty.rs
+++ b/src/librustc_driver/pretty.rs
@@ -9,36 +9,33 @@ use rustc::hir::print as pprust_hir;
 use rustc::session::Session;
 use rustc::session::config::{Input, OutputFilenames};
 use rustc::ty::{self, TyCtxt, Resolutions, AllArenas};
+use rustc_interface::util;
 use rustc_borrowck as borrowck;
 use rustc_borrowck::graphviz as borrowck_dot;
-use rustc_data_structures::thin_vec::ThinVec;
 use rustc_metadata::cstore::CStore;
 use rustc_mir::util::{write_mir_pretty, write_mir_graphviz};
 
-use syntax::ast::{self, BlockCheckMode};
-use syntax::mut_visit::{*, MutVisitor, visit_clobber};
+use syntax::ast;
+use syntax::mut_visit::MutVisitor;
 use syntax::print::{pprust};
 use syntax::print::pprust::PrintState;
-use syntax::ptr::P;
-use syntax_pos::{self, FileName};
+use syntax_pos::FileName;
 
 use graphviz as dot;
-use smallvec::SmallVec;
 
 use std::cell::Cell;
 use std::fs::File;
 use std::io::{self, Write};
-use std::ops::DerefMut;
 use std::option;
 use std::path::Path;
 use std::str::FromStr;
-use std::mem;
 
 pub use self::UserIdentifiedItem::*;
 pub use self::PpSourceMode::*;
 pub use self::PpMode::*;
 use self::NodesMatchingUII::*;
-use {abort_on_err, driver};
+use abort_on_err;
+use driver;
 
 #[derive(Copy, Clone, PartialEq, Debug)]
 pub enum PpSourceMode {
@@ -217,18 +214,19 @@ impl PpSourceMode {
             }
             PpmTyped => {
                 let control = &driver::CompileController::basic();
-                let codegen_backend = ::get_codegen_backend(sess);
+                let codegen_backend = util::get_codegen_backend(sess);
                 let mut arenas = AllArenas::new();
-                abort_on_err(driver::phase_3_run_analysis_passes(&*codegen_backend,
-                                                                 control,
-                                                                 sess,
-                                                                 cstore,
-                                                                 hir_map.clone(),
-                                                                 resolutions.clone(),
-                                                                 &mut arenas,
-                                                                 id,
-                                                                 output_filenames,
-                                                                 |tcx, _, _| {
+                driver::phase_3_run_analysis_passes(&*codegen_backend,
+                                                    control,
+                                                    sess,
+                                                    cstore,
+                                                    hir_map.clone(),
+                                                    resolutions.clone(),
+                                                    &mut arenas,
+                                                    id,
+                                                    output_filenames,
+                                                    |tcx, _, result| {
+                    abort_on_err(result, tcx.sess);
                     let empty_tables = ty::TypeckTables::empty(None);
                     let annotation = TypedAnnotation {
                         tcx,
@@ -237,8 +235,7 @@ impl PpSourceMode {
                     tcx.dep_graph.with_ignore(|| {
                         f(&annotation, hir_map.forest.krate())
                     })
-                }),
-                             sess)
+                })
             }
             _ => panic!("Should use call_with_pp_support"),
         }
@@ -627,204 +624,6 @@ impl UserIdentifiedItem {
     }
 }
 
-// Note: Also used by librustdoc, see PR #43348. Consider moving this struct elsewhere.
-//
-// FIXME: Currently the `everybody_loops` transformation is not applied to:
-//  * `const fn`, due to issue #43636 that `loop` is not supported for const evaluation. We are
-//    waiting for miri to fix that.
-//  * `impl Trait`, due to issue #43869 that functions returning impl Trait cannot be diverging.
-//    Solving this may require `!` to implement every trait, which relies on the an even more
-//    ambitious form of the closed RFC #1637. See also [#34511].
-//
-// [#34511]: https://github.com/rust-lang/rust/issues/34511#issuecomment-322340401
-pub struct ReplaceBodyWithLoop<'a> {
-    within_static_or_const: bool,
-    nested_blocks: Option<Vec<ast::Block>>,
-    sess: &'a Session,
-}
-
-impl<'a> ReplaceBodyWithLoop<'a> {
-    pub fn new(sess: &'a Session) -> ReplaceBodyWithLoop<'a> {
-        ReplaceBodyWithLoop {
-            within_static_or_const: false,
-            nested_blocks: None,
-            sess
-        }
-    }
-
-    fn run<R, F: FnOnce(&mut Self) -> R>(&mut self, is_const: bool, action: F) -> R {
-        let old_const = mem::replace(&mut self.within_static_or_const, is_const);
-        let old_blocks = self.nested_blocks.take();
-        let ret = action(self);
-        self.within_static_or_const = old_const;
-        self.nested_blocks = old_blocks;
-        ret
-    }
-
-    fn should_ignore_fn(ret_ty: &ast::FnDecl) -> bool {
-        if let ast::FunctionRetTy::Ty(ref ty) = ret_ty.output {
-            fn involves_impl_trait(ty: &ast::Ty) -> bool {
-                match ty.node {
-                    ast::TyKind::ImplTrait(..) => true,
-                    ast::TyKind::Slice(ref subty) |
-                    ast::TyKind::Array(ref subty, _) |
-                    ast::TyKind::Ptr(ast::MutTy { ty: ref subty, .. }) |
-                    ast::TyKind::Rptr(_, ast::MutTy { ty: ref subty, .. }) |
-                    ast::TyKind::Paren(ref subty) => involves_impl_trait(subty),
-                    ast::TyKind::Tup(ref tys) => any_involves_impl_trait(tys.iter()),
-                    ast::TyKind::Path(_, ref path) => path.segments.iter().any(|seg| {
-                        match seg.args.as_ref().map(|generic_arg| &**generic_arg) {
-                            None => false,
-                            Some(&ast::GenericArgs::AngleBracketed(ref data)) => {
-                                let types = data.args.iter().filter_map(|arg| match arg {
-                                    ast::GenericArg::Type(ty) => Some(ty),
-                                    _ => None,
-                                });
-                                any_involves_impl_trait(types.into_iter()) ||
-                                any_involves_impl_trait(data.bindings.iter().map(|b| &b.ty))
-                            },
-                            Some(&ast::GenericArgs::Parenthesized(ref data)) => {
-                                any_involves_impl_trait(data.inputs.iter()) ||
-                                any_involves_impl_trait(data.output.iter())
-                            }
-                        }
-                    }),
-                    _ => false,
-                }
-            }
-
-            fn any_involves_impl_trait<'a, I: Iterator<Item = &'a P<ast::Ty>>>(mut it: I) -> bool {
-                it.any(|subty| involves_impl_trait(subty))
-            }
-
-            involves_impl_trait(ty)
-        } else {
-            false
-        }
-    }
-}
-
-impl<'a> MutVisitor for ReplaceBodyWithLoop<'a> {
-    fn visit_item_kind(&mut self, i: &mut ast::ItemKind) {
-        let is_const = match i {
-            ast::ItemKind::Static(..) | ast::ItemKind::Const(..) => true,
-            ast::ItemKind::Fn(ref decl, ref header, _, _) =>
-                header.constness.node == ast::Constness::Const || Self::should_ignore_fn(decl),
-            _ => false,
-        };
-        self.run(is_const, |s| noop_visit_item_kind(i, s))
-    }
-
-    fn flat_map_trait_item(&mut self, i: ast::TraitItem) -> SmallVec<[ast::TraitItem; 1]> {
-        let is_const = match i.node {
-            ast::TraitItemKind::Const(..) => true,
-            ast::TraitItemKind::Method(ast::MethodSig { ref decl, ref header, .. }, _) =>
-                header.constness.node == ast::Constness::Const || Self::should_ignore_fn(decl),
-            _ => false,
-        };
-        self.run(is_const, |s| noop_flat_map_trait_item(i, s))
-    }
-
-    fn flat_map_impl_item(&mut self, i: ast::ImplItem) -> SmallVec<[ast::ImplItem; 1]> {
-        let is_const = match i.node {
-            ast::ImplItemKind::Const(..) => true,
-            ast::ImplItemKind::Method(ast::MethodSig { ref decl, ref header, .. }, _) =>
-                header.constness.node == ast::Constness::Const || Self::should_ignore_fn(decl),
-            _ => false,
-        };
-        self.run(is_const, |s| noop_flat_map_impl_item(i, s))
-    }
-
-    fn visit_anon_const(&mut self, c: &mut ast::AnonConst) {
-        self.run(true, |s| noop_visit_anon_const(c, s))
-    }
-
-    fn visit_block(&mut self, b: &mut P<ast::Block>) {
-        fn stmt_to_block(rules: ast::BlockCheckMode,
-                         s: Option<ast::Stmt>,
-                         sess: &Session) -> ast::Block {
-            ast::Block {
-                stmts: s.into_iter().collect(),
-                rules,
-                id: sess.next_node_id(),
-                span: syntax_pos::DUMMY_SP,
-            }
-        }
-
-        fn block_to_stmt(b: ast::Block, sess: &Session) -> ast::Stmt {
-            let expr = P(ast::Expr {
-                id: sess.next_node_id(),
-                node: ast::ExprKind::Block(P(b), None),
-                span: syntax_pos::DUMMY_SP,
-                attrs: ThinVec::new(),
-            });
-
-            ast::Stmt {
-                id: sess.next_node_id(),
-                node: ast::StmtKind::Expr(expr),
-                span: syntax_pos::DUMMY_SP,
-            }
-        }
-
-        let empty_block = stmt_to_block(BlockCheckMode::Default, None, self.sess);
-        let loop_expr = P(ast::Expr {
-            node: ast::ExprKind::Loop(P(empty_block), None),
-            id: self.sess.next_node_id(),
-            span: syntax_pos::DUMMY_SP,
-                attrs: ThinVec::new(),
-        });
-
-        let loop_stmt = ast::Stmt {
-            id: self.sess.next_node_id(),
-            span: syntax_pos::DUMMY_SP,
-            node: ast::StmtKind::Expr(loop_expr),
-        };
-
-        if self.within_static_or_const {
-            noop_visit_block(b, self)
-        } else {
-            visit_clobber(b.deref_mut(), |b| {
-                let mut stmts = vec![];
-                for s in b.stmts {
-                    let old_blocks = self.nested_blocks.replace(vec![]);
-
-                    stmts.extend(self.flat_map_stmt(s).into_iter().filter(|s| s.is_item()));
-
-                    // we put a Some in there earlier with that replace(), so this is valid
-                    let new_blocks = self.nested_blocks.take().unwrap();
-                    self.nested_blocks = old_blocks;
-                    stmts.extend(new_blocks.into_iter().map(|b| block_to_stmt(b, &self.sess)));
-                }
-
-                let mut new_block = ast::Block {
-                    stmts,
-                    ..b
-                };
-
-                if let Some(old_blocks) = self.nested_blocks.as_mut() {
-                    //push our fresh block onto the cache and yield an empty block with `loop {}`
-                    if !new_block.stmts.is_empty() {
-                        old_blocks.push(new_block);
-                    }
-
-                    stmt_to_block(b.rules, Some(loop_stmt), self.sess)
-                } else {
-                    //push `loop {}` onto the end of our fresh block and yield that
-                    new_block.stmts.push(loop_stmt);
-
-                    new_block
-                }
-            })
-        }
-    }
-
-    // in general the pretty printer processes unexpanded code, so
-    // we override the default `visit_mac` method which panics.
-    fn visit_mac(&mut self, mac: &mut ast::Mac) {
-        noop_visit_mac(mac, self)
-    }
-}
-
 fn print_flowgraph<'a, 'tcx, W: Write>(variants: Vec<borrowck_dot::Variant>,
                                        tcx: TyCtxt<'a, 'tcx, 'tcx>,
                                        code: blocks::Code<'tcx>,
@@ -892,12 +691,12 @@ fn print_flowgraph<'a, 'tcx, W: Write>(variants: Vec<borrowck_dot::Variant>,
 
 pub fn visit_crate(sess: &Session, krate: &mut ast::Crate, ppm: PpMode) {
     if let PpmSource(PpmEveryBodyLoops) = ppm {
-        ReplaceBodyWithLoop::new(sess).visit_crate(krate);
+        util::ReplaceBodyWithLoop::new(sess).visit_crate(krate);
     }
 }
 
 fn get_source(input: &Input, sess: &Session) -> (Vec<u8>, FileName) {
-    let src_name = driver::source_name(input);
+    let src_name = input.source_name();
     let src = sess.source_map()
         .get_source_file(&src_name)
         .unwrap()
@@ -1117,18 +916,19 @@ fn print_with_analysis<'tcx, 'a: 'tcx>(sess: &'a Session,
     let mut out = Vec::new();
 
     let control = &driver::CompileController::basic();
-    let codegen_backend = ::get_codegen_backend(sess);
+    let codegen_backend = util::get_codegen_backend(sess);
     let mut arenas = AllArenas::new();
-    abort_on_err(driver::phase_3_run_analysis_passes(&*codegen_backend,
-                                                     control,
-                                                     sess,
-                                                     cstore,
-                                                     hir_map.clone(),
-                                                     resolutions.clone(),
-                                                     &mut arenas,
-                                                     crate_name,
-                                                     output_filenames,
-                                                     |tcx, _, _| {
+    driver::phase_3_run_analysis_passes(&*codegen_backend,
+                                        control,
+                                        sess,
+                                        cstore,
+                                        hir_map.clone(),
+                                        resolutions.clone(),
+                                        &mut arenas,
+                                        crate_name,
+                                        output_filenames,
+                                        |tcx, _, result| {
+        abort_on_err(result, tcx.sess);
         match ppm {
             PpmMir | PpmMirCFG => {
                 if let Some(nodeid) = nodeid {
@@ -1174,9 +974,7 @@ fn print_with_analysis<'tcx, 'a: 'tcx>(sess: &'a Session,
             }
             _ => unreachable!(),
         }
-    }),
-                 sess)
-        .unwrap();
+    }).unwrap();
 
     write_output(out, ofile);
 }
diff --git a/src/librustc_driver/test.rs b/src/librustc_driver/test.rs
index 2ec755bd626..309a9f7b525 100644
--- a/src/librustc_driver/test.rs
+++ b/src/librustc_driver/test.rs
@@ -16,6 +16,7 @@ use rustc::ty::query::OnDiskCache;
 use rustc::ty::subst::Subst;
 use rustc::ty::{self, Ty, TyCtxt, TypeFoldable};
 use rustc_data_structures::sync::{self, Lrc};
+use rustc_interface::util;
 use rustc_lint;
 use rustc_metadata::cstore::CStore;
 use rustc_target::spec::abi::Abi;
@@ -91,6 +92,13 @@ where
         options.debugging_opts.verbose = true;
         options.unstable_features = UnstableFeatures::Allow;
 
+        // When we're compiling this library with `--test` it'll run as a binary but
+        // not actually exercise much functionality.
+        // As a result most of the logic loading the codegen backend is defunkt
+        // (it assumes we're a dynamic library in a sysroot)
+        // so let's just use the metadata only backend which doesn't need to load any libraries.
+        options.debugging_opts.codegen_backend = Some("metadata_only".to_owned());
+
         driver::spawn_thread_pool(options, |options| {
             test_env_with_pool(options, source_string, args, body)
         })
@@ -111,8 +119,9 @@ fn test_env_with_pool<F>(
         None,
         diagnostic_handler,
         Lrc::new(SourceMap::new(FilePathMapping::empty())),
+        Default::default(),
     );
-    let cstore = CStore::new(::get_codegen_backend(&sess).metadata_loader());
+    let cstore = CStore::new(util::get_codegen_backend(&sess).metadata_loader());
     rustc_lint::register_builtins(&mut sess.lint_store.borrow_mut(), Some(&sess));
     let input = config::Input::Str {
         name: FileName::anon_source_code(&source_string),
diff --git a/src/librustc_interface/Cargo.toml b/src/librustc_interface/Cargo.toml
new file mode 100644
index 00000000000..1acd3dfc765
--- /dev/null
+++ b/src/librustc_interface/Cargo.toml
@@ -0,0 +1,35 @@
+[package]
+authors = ["The Rust Project Developers"]
+name = "rustc_interface"
+version = "0.0.0"
+
+[lib]
+name = "rustc_interface"
+path = "lib.rs"
+crate-type = ["dylib"]
+
+[dependencies]
+log = "0.4"
+rustc-rayon = "0.1.1"
+smallvec = { version = "0.6.7", features = ["union", "may_dangle"] }
+scoped-tls = { version = "0.1.1", features = ["nightly"] }
+syntax = { path = "../libsyntax" }
+syntax_ext = { path = "../libsyntax_ext" }
+syntax_pos = { path = "../libsyntax_pos" }
+serialize = { path = "../libserialize" }
+rustc = { path = "../librustc" }
+rustc_allocator = { path = "../librustc_allocator" }
+rustc_borrowck = { path = "../librustc_borrowck" }
+rustc_incremental = { path = "../librustc_incremental" }
+rustc_traits = { path = "../librustc_traits" }
+rustc_data_structures = { path = "../librustc_data_structures" }
+rustc_codegen_utils = { path = "../librustc_codegen_utils" }
+rustc_metadata = { path = "../librustc_metadata" }
+rustc_mir = { path = "../librustc_mir" }
+rustc_passes = { path = "../librustc_passes" }
+rustc_typeck = { path = "../librustc_typeck" }
+rustc_lint = { path = "../librustc_lint" }
+rustc_errors = { path = "../librustc_errors" }
+rustc_plugin = { path = "../librustc_plugin" }
+rustc_privacy = { path = "../librustc_privacy" }
+rustc_resolve = { path = "../librustc_resolve" }
diff --git a/src/librustc_interface/lib.rs b/src/librustc_interface/lib.rs
new file mode 100644
index 00000000000..e5c7c35a36d
--- /dev/null
+++ b/src/librustc_interface/lib.rs
@@ -0,0 +1,43 @@
+#![feature(box_syntax)]
+#![feature(set_stdio)]
+#![feature(nll)]
+#![feature(arbitrary_self_types)]
+#![feature(generator_trait)]
+#![cfg_attr(unix, feature(libc))]
+
+#![allow(unused_imports)]
+
+#![recursion_limit="256"]
+
+#[cfg(unix)]
+extern crate libc;
+#[macro_use]
+extern crate log;
+extern crate rustc;
+extern crate rustc_codegen_utils;
+extern crate rustc_allocator;
+extern crate rustc_borrowck;
+extern crate rustc_incremental;
+extern crate rustc_traits;
+#[macro_use]
+extern crate rustc_data_structures;
+extern crate rustc_errors;
+extern crate rustc_lint;
+extern crate rustc_metadata;
+extern crate rustc_mir;
+extern crate rustc_passes;
+extern crate rustc_plugin;
+extern crate rustc_privacy;
+extern crate rustc_rayon as rayon;
+extern crate rustc_resolve;
+extern crate rustc_typeck;
+extern crate smallvec;
+extern crate serialize;
+extern crate syntax;
+extern crate syntax_pos;
+extern crate syntax_ext;
+
+pub mod passes;
+pub mod profile;
+pub mod util;
+pub mod proc_macro_decls;
diff --git a/src/librustc_interface/passes.rs b/src/librustc_interface/passes.rs
new file mode 100644
index 00000000000..16ced695638
--- /dev/null
+++ b/src/librustc_interface/passes.rs
@@ -0,0 +1,296 @@
+use util;
+use proc_macro_decls;
+
+use rustc::dep_graph::DepGraph;
+use rustc::hir;
+use rustc::hir::lowering::lower_crate;
+use rustc::hir::def_id::{CrateNum, LOCAL_CRATE};
+use rustc::lint;
+use rustc::middle::{self, reachable, resolve_lifetime, stability};
+use rustc::middle::privacy::AccessLevels;
+use rustc::ty::{self, AllArenas, Resolutions, TyCtxt};
+use rustc::ty::steal::Steal;
+use rustc::traits;
+use rustc::util::common::{time, ErrorReported};
+use rustc::util::profiling::ProfileCategory;
+use rustc::session::{CompileResult, CrateDisambiguator, Session};
+use rustc::session::config::{self, Input, OutputFilenames, OutputType};
+use rustc::session::search_paths::PathKind;
+use rustc_allocator as allocator;
+use rustc_borrowck as borrowck;
+use rustc_codegen_utils::codegen_backend::CodegenBackend;
+use rustc_data_structures::fingerprint::Fingerprint;
+use rustc_data_structures::stable_hasher::StableHasher;
+use rustc_data_structures::sync::Lrc;
+use rustc_incremental;
+use rustc_metadata::creader::CrateLoader;
+use rustc_metadata::cstore::{self, CStore};
+use rustc_mir as mir;
+use rustc_passes::{self, ast_validation, hir_stats, loops, rvalue_promotion, layout_test};
+use rustc_plugin as plugin;
+use rustc_plugin::registry::Registry;
+use rustc_privacy;
+use rustc_resolve::{Resolver, ResolverArenas};
+use rustc_traits;
+use rustc_typeck as typeck;
+use syntax::{self, ast, attr, diagnostics, visit};
+use syntax::early_buffered_lints::BufferedEarlyLint;
+use syntax::ext::base::ExtCtxt;
+use syntax::mut_visit::MutVisitor;
+use syntax::parse::{self, PResult};
+use syntax::util::node_count::NodeCounter;
+use syntax::util::lev_distance::find_best_match_for_name;
+use syntax::symbol::Symbol;
+use syntax_pos::{FileName, hygiene};
+use syntax_ext;
+
+use serialize::json;
+
+use std::any::Any;
+use std::env;
+use std::ffi::OsString;
+use std::fs;
+use std::io::{self, Write};
+use std::iter;
+use std::path::{Path, PathBuf};
+use std::sync::mpsc;
+use std::cell::RefCell;
+use std::rc::Rc;
+use std::mem;
+use std::ops::Generator;
+
+/// Returns all the paths that correspond to generated files.
+pub fn generated_output_paths(
+    sess: &Session,
+    outputs: &OutputFilenames,
+    exact_name: bool,
+    crate_name: &str,
+) -> Vec<PathBuf> {
+    let mut out_filenames = Vec::new();
+    for output_type in sess.opts.output_types.keys() {
+        let file = outputs.path(*output_type);
+        match *output_type {
+            // If the filename has been overridden using `-o`, it will not be modified
+            // by appending `.rlib`, `.exe`, etc., so we can skip this transformation.
+            OutputType::Exe if !exact_name => for crate_type in sess.crate_types.borrow().iter() {
+                let p = ::rustc_codegen_utils::link::filename_for_input(
+                    sess,
+                    *crate_type,
+                    crate_name,
+                    outputs,
+                );
+                out_filenames.push(p);
+            },
+            OutputType::DepInfo if sess.opts.debugging_opts.dep_info_omit_d_target => {
+                // Don't add the dep-info output when omitting it from dep-info targets
+            }
+            _ => {
+                out_filenames.push(file);
+            }
+        }
+    }
+    out_filenames
+}
+
+// Runs `f` on every output file path and returns the first non-None result, or None if `f`
+// returns None for every file path.
+fn check_output<F, T>(output_paths: &[PathBuf], f: F) -> Option<T>
+where
+    F: Fn(&PathBuf) -> Option<T>,
+{
+    for output_path in output_paths {
+        if let Some(result) = f(output_path) {
+            return Some(result);
+        }
+    }
+    None
+}
+
+pub fn output_contains_path(output_paths: &[PathBuf], input_path: &PathBuf) -> bool {
+    let input_path = input_path.canonicalize().ok();
+    if input_path.is_none() {
+        return false;
+    }
+    let check = |output_path: &PathBuf| {
+        if output_path.canonicalize().ok() == input_path {
+            Some(())
+        } else {
+            None
+        }
+    };
+    check_output(output_paths, check).is_some()
+}
+
+pub fn output_conflicts_with_dir(output_paths: &[PathBuf]) -> Option<PathBuf> {
+    let check = |output_path: &PathBuf| {
+        if output_path.is_dir() {
+            Some(output_path.clone())
+        } else {
+            None
+        }
+    };
+    check_output(output_paths, check)
+}
+
+fn escape_dep_filename(filename: &FileName) -> String {
+    // Apparently clang and gcc *only* escape spaces:
+    // http://llvm.org/klaus/clang/commit/9d50634cfc268ecc9a7250226dd5ca0e945240d4
+    filename.to_string().replace(" ", "\\ ")
+}
+
+pub fn write_out_deps(sess: &Session, outputs: &OutputFilenames, out_filenames: &[PathBuf]) {
+    // Write out dependency rules to the dep-info file if requested
+    if !sess.opts.output_types.contains_key(&OutputType::DepInfo) {
+        return;
+    }
+    let deps_filename = outputs.path(OutputType::DepInfo);
+
+    let result = (|| -> io::Result<()> {
+        // Build a list of files used to compile the output and
+        // write Makefile-compatible dependency rules
+        let files: Vec<String> = sess.source_map()
+            .files()
+            .iter()
+            .filter(|fmap| fmap.is_real_file())
+            .filter(|fmap| !fmap.is_imported())
+            .map(|fmap| escape_dep_filename(&fmap.name))
+            .collect();
+        let mut file = fs::File::create(&deps_filename)?;
+        for path in out_filenames {
+            writeln!(file, "{}: {}\n", path.display(), files.join(" "))?;
+        }
+
+        // Emit a fake target for each input file to the compilation. This
+        // prevents `make` from spitting out an error if a file is later
+        // deleted. For more info see #28735
+        for path in files {
+            writeln!(file, "{}:", path)?;
+        }
+        Ok(())
+    })();
+
+    if let Err(e) = result {
+        sess.fatal(&format!(
+            "error writing dependencies to `{}`: {}",
+            deps_filename.display(),
+            e
+        ));
+    }
+}
+
+pub fn provide(providers: &mut ty::query::Providers) {
+    providers.analysis = analysis;
+    proc_macro_decls::provide(providers);
+}
+
+fn analysis<'tcx>(
+    tcx: TyCtxt<'_, 'tcx, 'tcx>,
+    cnum: CrateNum,
+) -> Result<(), ErrorReported> {
+    assert_eq!(cnum, LOCAL_CRATE);
+
+    let sess = tcx.sess;
+
+    parallel!({
+        time(sess, "looking for entry point", || {
+            middle::entry::find_entry_point(tcx)
+        });
+
+        time(sess, "looking for plugin registrar", || {
+            plugin::build::find_plugin_registrar(tcx)
+        });
+
+        time(sess, "looking for derive registrar", || {
+            proc_macro_decls::find(tcx)
+        });
+    }, {
+        time(sess, "loop checking", || loops::check_crate(tcx));
+    }, {
+        time(sess, "attribute checking", || {
+            hir::check_attr::check_crate(tcx)
+        });
+    }, {
+        time(sess, "stability checking", || {
+            stability::check_unstable_api_usage(tcx)
+        });
+    });
+
+    // passes are timed inside typeck
+    typeck::check_crate(tcx)?;
+
+    time(sess, "misc checking", || {
+        parallel!({
+            time(sess, "rvalue promotion", || {
+                rvalue_promotion::check_crate(tcx)
+            });
+        }, {
+            time(sess, "intrinsic checking", || {
+                middle::intrinsicck::check_crate(tcx)
+            });
+        }, {
+            time(sess, "match checking", || mir::matchck_crate(tcx));
+        }, {
+            // this must run before MIR dump, because
+            // "not all control paths return a value" is reported here.
+            //
+            // maybe move the check to a MIR pass?
+            time(sess, "liveness checking", || {
+                middle::liveness::check_crate(tcx)
+            });
+        });
+    });
+
+    // Abort so we don't try to construct MIR with liveness errors.
+    // We also won't want to continue with errors from rvalue promotion
+    tcx.sess.abort_if_errors();
+
+    time(sess, "borrow checking", || {
+        if tcx.use_ast_borrowck() {
+            borrowck::check_crate(tcx);
+        }
+    });
+
+    time(sess,
+            "MIR borrow checking",
+            || tcx.par_body_owners(|def_id| { tcx.ensure().mir_borrowck(def_id); }));
+
+    time(sess, "dumping chalk-like clauses", || {
+        rustc_traits::lowering::dump_program_clauses(tcx);
+    });
+
+    time(sess, "MIR effect checking", || {
+        for def_id in tcx.body_owners() {
+            mir::transform::check_unsafety::check_unsafety(tcx, def_id)
+        }
+    });
+
+    time(sess, "layout testing", || layout_test::test_layout(tcx));
+
+    // Avoid overwhelming user with errors if borrow checking failed.
+    // I'm not sure how helpful this is, to be honest, but it avoids
+    // a
+    // lot of annoying errors in the compile-fail tests (basically,
+    // lint warnings and so on -- kindck used to do this abort, but
+    // kindck is gone now). -nmatsakis
+    if sess.err_count() > 0 {
+        return Err(ErrorReported);
+    }
+
+    time(sess, "misc checking", || {
+        parallel!({
+            time(sess, "privacy checking", || {
+                rustc_privacy::check_crate(tcx)
+            });
+        }, {
+            time(sess, "death checking", || middle::dead::check_crate(tcx));
+        },  {
+            time(sess, "unused lib feature checking", || {
+                stability::check_unused_or_stable_features(tcx)
+            });
+        }, {
+            time(sess, "lint checking", || lint::check_crate(tcx));
+        });
+    });
+
+    Ok(())
+}
diff --git a/src/librustc_driver/proc_macro_decls.rs b/src/librustc_interface/proc_macro_decls.rs
index 093d15b7e3c..093d15b7e3c 100644
--- a/src/librustc_driver/proc_macro_decls.rs
+++ b/src/librustc_interface/proc_macro_decls.rs
diff --git a/src/librustc_driver/profile/mod.rs b/src/librustc_interface/profile/mod.rs
index eb13a5668f9..eb13a5668f9 100644
--- a/src/librustc_driver/profile/mod.rs
+++ b/src/librustc_interface/profile/mod.rs
diff --git a/src/librustc_driver/profile/trace.rs b/src/librustc_interface/profile/trace.rs
index 95c4ea6ff23..95c4ea6ff23 100644
--- a/src/librustc_driver/profile/trace.rs
+++ b/src/librustc_interface/profile/trace.rs
diff --git a/src/librustc_interface/util.rs b/src/librustc_interface/util.rs
new file mode 100644
index 00000000000..6f92c304462
--- /dev/null
+++ b/src/librustc_interface/util.rs
@@ -0,0 +1,702 @@
+use rustc::session::config::{Input, OutputFilenames, ErrorOutputType};
+use rustc::session::{self, config, early_error, filesearch, Session, DiagnosticOutput};
+use rustc::session::CrateDisambiguator;
+use rustc::ty;
+use rustc::lint;
+use rustc_codegen_utils::codegen_backend::CodegenBackend;
+use rustc_data_structures::sync::{Lock, Lrc};
+use rustc_data_structures::stable_hasher::StableHasher;
+use rustc_data_structures::fingerprint::Fingerprint;
+use rustc_data_structures::thin_vec::ThinVec;
+use rustc_data_structures::fx::{FxHashSet, FxHashMap};
+use rustc_errors::registry::Registry;
+use rustc_lint;
+use rustc_metadata::dynamic_lib::DynamicLibrary;
+use rustc_mir;
+use rustc_passes;
+use rustc_plugin;
+use rustc_privacy;
+use rustc_resolve;
+use rustc_typeck;
+use std::collections::HashSet;
+use std::env;
+use std::env::consts::{DLL_PREFIX, DLL_SUFFIX};
+use std::io::{self, Write};
+use std::mem;
+use std::path::{Path, PathBuf};
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Arc, Mutex, Once};
+use std::ops::DerefMut;
+use smallvec::SmallVec;
+use syntax::ptr::P;
+use syntax::mut_visit::{*, MutVisitor, visit_clobber};
+use syntax::ast::BlockCheckMode;
+use syntax::util::lev_distance::find_best_match_for_name;
+use syntax::source_map::{FileLoader, RealFileLoader, SourceMap};
+use syntax::symbol::Symbol;
+use syntax::{self, ast, attr};
+#[cfg(not(parallel_compiler))]
+use std::{thread, panic};
+
+pub fn diagnostics_registry() -> Registry {
+    let mut all_errors = Vec::new();
+    all_errors.extend_from_slice(&rustc::DIAGNOSTICS);
+    all_errors.extend_from_slice(&rustc_typeck::DIAGNOSTICS);
+    all_errors.extend_from_slice(&rustc_resolve::DIAGNOSTICS);
+    all_errors.extend_from_slice(&rustc_privacy::DIAGNOSTICS);
+    // FIXME: need to figure out a way to get these back in here
+    // all_errors.extend_from_slice(get_codegen_backend(sess).diagnostics());
+    all_errors.extend_from_slice(&rustc_metadata::DIAGNOSTICS);
+    all_errors.extend_from_slice(&rustc_passes::DIAGNOSTICS);
+    all_errors.extend_from_slice(&rustc_plugin::DIAGNOSTICS);
+    all_errors.extend_from_slice(&rustc_mir::DIAGNOSTICS);
+    all_errors.extend_from_slice(&syntax::DIAGNOSTICS);
+
+    Registry::new(&all_errors)
+}
+
+/// Adds `target_feature = "..."` cfgs for a variety of platform
+/// specific features (SSE, NEON etc.).
+///
+/// This is performed by checking whether a whitelisted set of
+/// features is available on the target machine, by querying LLVM.
+pub fn add_configuration(
+    cfg: &mut ast::CrateConfig,
+    sess: &Session,
+    codegen_backend: &dyn CodegenBackend,
+) {
+    let tf = Symbol::intern("target_feature");
+
+    cfg.extend(
+        codegen_backend
+            .target_features(sess)
+            .into_iter()
+            .map(|feat| (tf, Some(feat))),
+    );
+
+    if sess.crt_static_feature() {
+        cfg.insert((tf, Some(Symbol::intern("crt-static"))));
+    }
+}
+
+fn load_backend_from_dylib(path: &Path) -> fn() -> Box<dyn CodegenBackend> {
+    let lib = DynamicLibrary::open(Some(path)).unwrap_or_else(|err| {
+        let err = format!("couldn't load codegen backend {:?}: {:?}", path, err);
+        early_error(ErrorOutputType::default(), &err);
+    });
+    unsafe {
+        match lib.symbol("__rustc_codegen_backend") {
+            Ok(f) => {
+                mem::forget(lib);
+                mem::transmute::<*mut u8, _>(f)
+            }
+            Err(e) => {
+                let err = format!("couldn't load codegen backend as it \
+                                   doesn't export the `__rustc_codegen_backend` \
+                                   symbol: {:?}", e);
+                early_error(ErrorOutputType::default(), &err);
+            }
+        }
+    }
+}
+
+pub fn get_codegen_backend(sess: &Session) -> Box<dyn CodegenBackend> {
+    static INIT: Once = Once::new();
+
+    static mut LOAD: fn() -> Box<dyn CodegenBackend> = || unreachable!();
+
+    INIT.call_once(|| {
+        let codegen_name = sess.opts.debugging_opts.codegen_backend.as_ref()
+            .unwrap_or(&sess.target.target.options.codegen_backend);
+        let backend = match &codegen_name[..] {
+            "metadata_only" => {
+                rustc_codegen_utils::codegen_backend::MetadataOnlyCodegenBackend::boxed
+            }
+            filename if filename.contains(".") => {
+                load_backend_from_dylib(filename.as_ref())
+            }
+            codegen_name => get_codegen_sysroot(codegen_name),
+        };
+
+        unsafe {
+            LOAD = backend;
+        }
+    });
+    let backend = unsafe { LOAD() };
+    backend.init(sess);
+    backend
+}
+
+pub fn get_codegen_sysroot(backend_name: &str) -> fn() -> Box<dyn CodegenBackend> {
+    // For now we only allow this function to be called once as it'll dlopen a
+    // few things, which seems to work best if we only do that once. In
+    // general this assertion never trips due to the once guard in `get_codegen_backend`,
+    // but there's a few manual calls to this function in this file we protect
+    // against.
+    static LOADED: AtomicBool = AtomicBool::new(false);
+    assert!(!LOADED.fetch_or(true, Ordering::SeqCst),
+            "cannot load the default codegen backend twice");
+
+    let target = session::config::host_triple();
+    let mut sysroot_candidates = vec![filesearch::get_or_default_sysroot()];
+    let path = current_dll_path()
+        .and_then(|s| s.canonicalize().ok());
+    if let Some(dll) = path {
+        // use `parent` twice to chop off the file name and then also the
+        // directory containing the dll which should be either `lib` or `bin`.
+        if let Some(path) = dll.parent().and_then(|p| p.parent()) {
+            // The original `path` pointed at the `rustc_driver` crate's dll.
+            // Now that dll should only be in one of two locations. The first is
+            // in the compiler's libdir, for example `$sysroot/lib/*.dll`. The
+            // other is the target's libdir, for example
+            // `$sysroot/lib/rustlib/$target/lib/*.dll`.
+            //
+            // We don't know which, so let's assume that if our `path` above
+            // ends in `$target` we *could* be in the target libdir, and always
+            // assume that we may be in the main libdir.
+            sysroot_candidates.push(path.to_owned());
+
+            if path.ends_with(target) {
+                sysroot_candidates.extend(path.parent() // chop off `$target`
+                    .and_then(|p| p.parent())           // chop off `rustlib`
+                    .and_then(|p| p.parent())           // chop off `lib`
+                    .map(|s| s.to_owned()));
+            }
+        }
+    }
+
+    let sysroot = sysroot_candidates.iter()
+        .map(|sysroot| {
+            let libdir = filesearch::relative_target_lib_path(&sysroot, &target);
+            sysroot.join(libdir).with_file_name(
+                option_env!("CFG_CODEGEN_BACKENDS_DIR").unwrap_or("codegen-backends"))
+        })
+        .filter(|f| {
+            info!("codegen backend candidate: {}", f.display());
+            f.exists()
+        })
+        .next();
+    let sysroot = sysroot.unwrap_or_else(|| {
+        let candidates = sysroot_candidates.iter()
+            .map(|p| p.display().to_string())
+            .collect::<Vec<_>>()
+            .join("\n* ");
+        let err = format!("failed to find a `codegen-backends` folder \
+                           in the sysroot candidates:\n* {}", candidates);
+        early_error(ErrorOutputType::default(), &err);
+    });
+    info!("probing {} for a codegen backend", sysroot.display());
+
+    let d = sysroot.read_dir().unwrap_or_else(|e| {
+        let err = format!("failed to load default codegen backend, couldn't \
+                           read `{}`: {}", sysroot.display(), e);
+        early_error(ErrorOutputType::default(), &err);
+    });
+
+    let mut file: Option<PathBuf> = None;
+
+    let expected_name = format!("rustc_codegen_llvm-{}", backend_name);
+    for entry in d.filter_map(|e| e.ok()) {
+        let path = entry.path();
+        let filename = match path.file_name().and_then(|s| s.to_str()) {
+            Some(s) => s,
+            None => continue,
+        };
+        if !(filename.starts_with(DLL_PREFIX) && filename.ends_with(DLL_SUFFIX)) {
+            continue
+        }
+        let name = &filename[DLL_PREFIX.len() .. filename.len() - DLL_SUFFIX.len()];
+        if name != expected_name {
+            continue
+        }
+        if let Some(ref prev) = file {
+            let err = format!("duplicate codegen backends found\n\
+                               first:  {}\n\
+                               second: {}\n\
+            ", prev.display(), path.display());
+            early_error(ErrorOutputType::default(), &err);
+        }
+        file = Some(path.clone());
+    }
+
+    match file {
+        Some(ref s) => return load_backend_from_dylib(s),
+        None => {
+            let err = format!("failed to load default codegen backend for `{}`, \
+                               no appropriate codegen dylib found in `{}`",
+                              backend_name, sysroot.display());
+            early_error(ErrorOutputType::default(), &err);
+        }
+    }
+
+    #[cfg(unix)]
+    fn current_dll_path() -> Option<PathBuf> {
+        use std::ffi::{OsStr, CStr};
+        use std::os::unix::prelude::*;
+
+        unsafe {
+            let addr = current_dll_path as usize as *mut _;
+            let mut info = mem::zeroed();
+            if libc::dladdr(addr, &mut info) == 0 {
+                info!("dladdr failed");
+                return None
+            }
+            if info.dli_fname.is_null() {
+                info!("dladdr returned null pointer");
+                return None
+            }
+            let bytes = CStr::from_ptr(info.dli_fname).to_bytes();
+            let os = OsStr::from_bytes(bytes);
+            Some(PathBuf::from(os))
+        }
+    }
+
+    #[cfg(windows)]
+    fn current_dll_path() -> Option<PathBuf> {
+        use std::ffi::OsString;
+        use std::os::windows::prelude::*;
+
+        extern "system" {
+            fn GetModuleHandleExW(dwFlags: u32,
+                                  lpModuleName: usize,
+                                  phModule: *mut usize) -> i32;
+            fn GetModuleFileNameW(hModule: usize,
+                                  lpFilename: *mut u16,
+                                  nSize: u32) -> u32;
+        }
+
+        const GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS: u32 = 0x00000004;
+
+        unsafe {
+            let mut module = 0;
+            let r = GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
+                                       current_dll_path as usize,
+                                       &mut module);
+            if r == 0 {
+                info!("GetModuleHandleExW failed: {}", io::Error::last_os_error());
+                return None
+            }
+            let mut space = Vec::with_capacity(1024);
+            let r = GetModuleFileNameW(module,
+                                       space.as_mut_ptr(),
+                                       space.capacity() as u32);
+            if r == 0 {
+                info!("GetModuleFileNameW failed: {}", io::Error::last_os_error());
+                return None
+            }
+            let r = r as usize;
+            if r >= space.capacity() {
+                info!("our buffer was too small? {}",
+                      io::Error::last_os_error());
+                return None
+            }
+            space.set_len(r);
+            let os = OsString::from_wide(&space);
+            Some(PathBuf::from(os))
+        }
+    }
+}
+
+pub fn compute_crate_disambiguator(session: &Session) -> CrateDisambiguator {
+    use std::hash::Hasher;
+
+    // The crate_disambiguator is a 128 bit hash. The disambiguator is fed
+    // into various other hashes quite a bit (symbol hashes, incr. comp. hashes,
+    // debuginfo type IDs, etc), so we don't want it to be too wide. 128 bits
+    // should still be safe enough to avoid collisions in practice.
+    let mut hasher = StableHasher::<Fingerprint>::new();
+
+    let mut metadata = session.opts.cg.metadata.clone();
+    // We don't want the crate_disambiguator to dependent on the order
+    // -C metadata arguments, so sort them:
+    metadata.sort();
+    // Every distinct -C metadata value is only incorporated once:
+    metadata.dedup();
+
+    hasher.write(b"metadata");
+    for s in &metadata {
+        // Also incorporate the length of a metadata string, so that we generate
+        // different values for `-Cmetadata=ab -Cmetadata=c` and
+        // `-Cmetadata=a -Cmetadata=bc`
+        hasher.write_usize(s.len());
+        hasher.write(s.as_bytes());
+    }
+
+    // Also incorporate crate type, so that we don't get symbol conflicts when
+    // linking against a library of the same name, if this is an executable.
+    let is_exe = session
+        .crate_types
+        .borrow()
+        .contains(&config::CrateType::Executable);
+    hasher.write(if is_exe { b"exe" } else { b"lib" });
+
+    CrateDisambiguator::from(hasher.finish())
+}
+
+pub fn collect_crate_types(session: &Session, attrs: &[ast::Attribute]) -> Vec<config::CrateType> {
+    // Unconditionally collect crate types from attributes to make them used
+    let attr_types: Vec<config::CrateType> = attrs
+        .iter()
+        .filter_map(|a| {
+            if a.check_name("crate_type") {
+                match a.value_str() {
+                    Some(ref n) if *n == "rlib" => Some(config::CrateType::Rlib),
+                    Some(ref n) if *n == "dylib" => Some(config::CrateType::Dylib),
+                    Some(ref n) if *n == "cdylib" => Some(config::CrateType::Cdylib),
+                    Some(ref n) if *n == "lib" => Some(config::default_lib_output()),
+                    Some(ref n) if *n == "staticlib" => Some(config::CrateType::Staticlib),
+                    Some(ref n) if *n == "proc-macro" => Some(config::CrateType::ProcMacro),
+                    Some(ref n) if *n == "bin" => Some(config::CrateType::Executable),
+                    Some(ref n) => {
+                        let crate_types = vec![
+                            Symbol::intern("rlib"),
+                            Symbol::intern("dylib"),
+                            Symbol::intern("cdylib"),
+                            Symbol::intern("lib"),
+                            Symbol::intern("staticlib"),
+                            Symbol::intern("proc-macro"),
+                            Symbol::intern("bin")
+                        ];
+
+                        if let ast::MetaItemKind::NameValue(spanned) = a.meta().unwrap().node {
+                            let span = spanned.span;
+                            let lev_candidate = find_best_match_for_name(
+                                crate_types.iter(),
+                                &n.as_str(),
+                                None
+                            );
+                            if let Some(candidate) = lev_candidate {
+                                session.buffer_lint_with_diagnostic(
+                                    lint::builtin::UNKNOWN_CRATE_TYPES,
+                                    ast::CRATE_NODE_ID,
+                                    span,
+                                    "invalid `crate_type` value",
+                                    lint::builtin::BuiltinLintDiagnostics::
+                                        UnknownCrateTypes(
+                                            span,
+                                            "did you mean".to_string(),
+                                            format!("\"{}\"", candidate)
+                                        )
+                                );
+                            } else {
+                                session.buffer_lint(
+                                    lint::builtin::UNKNOWN_CRATE_TYPES,
+                                    ast::CRATE_NODE_ID,
+                                    span,
+                                    "invalid `crate_type` value"
+                                );
+                            }
+                        }
+                        None
+                    }
+                    None => None
+                }
+            } else {
+                None
+            }
+        })
+        .collect();
+
+    // If we're generating a test executable, then ignore all other output
+    // styles at all other locations
+    if session.opts.test {
+        return vec![config::CrateType::Executable];
+    }
+
+    // Only check command line flags if present. If no types are specified by
+    // command line, then reuse the empty `base` Vec to hold the types that
+    // will be found in crate attributes.
+    let mut base = session.opts.crate_types.clone();
+    if base.is_empty() {
+        base.extend(attr_types);
+        if base.is_empty() {
+            base.push(::rustc_codegen_utils::link::default_output_for_target(
+                session,
+            ));
+        } else {
+            base.sort();
+            base.dedup();
+        }
+    }
+
+    base.retain(|crate_type| {
+        let res = !::rustc_codegen_utils::link::invalid_output_for_target(session, *crate_type);
+
+        if !res {
+            session.warn(&format!(
+                "dropping unsupported crate type `{}` for target `{}`",
+                *crate_type, session.opts.target_triple
+            ));
+        }
+
+        res
+    });
+
+    base
+}
+
+pub fn build_output_filenames(
+    input: &Input,
+    odir: &Option<PathBuf>,
+    ofile: &Option<PathBuf>,
+    attrs: &[ast::Attribute],
+    sess: &Session,
+) -> OutputFilenames {
+    match *ofile {
+        None => {
+            // "-" as input file will cause the parser to read from stdin so we
+            // have to make up a name
+            // We want to toss everything after the final '.'
+            let dirpath = (*odir).as_ref().cloned().unwrap_or_default();
+
+            // If a crate name is present, we use it as the link name
+            let stem = sess.opts
+                .crate_name
+                .clone()
+                .or_else(|| attr::find_crate_name(attrs).map(|n| n.to_string()))
+                .unwrap_or_else(|| input.filestem().to_owned());
+
+            OutputFilenames {
+                out_directory: dirpath,
+                out_filestem: stem,
+                single_output_file: None,
+                extra: sess.opts.cg.extra_filename.clone(),
+                outputs: sess.opts.output_types.clone(),
+            }
+        }
+
+        Some(ref out_file) => {
+            let unnamed_output_types = sess.opts
+                .output_types
+                .values()
+                .filter(|a| a.is_none())
+                .count();
+            let ofile = if unnamed_output_types > 1 {
+                sess.warn(
+                    "due to multiple output types requested, the explicitly specified \
+                     output file name will be adapted for each output type",
+                );
+                None
+            } else {
+                Some(out_file.clone())
+            };
+            if *odir != None {
+                sess.warn("ignoring --out-dir flag due to -o flag");
+            }
+            if !sess.opts.cg.extra_filename.is_empty() {
+                sess.warn("ignoring -C extra-filename flag due to -o flag");
+            }
+
+            OutputFilenames {
+                out_directory: out_file.parent().unwrap_or_else(|| Path::new("")).to_path_buf(),
+                out_filestem: out_file
+                    .file_stem()
+                    .unwrap_or_default()
+                    .to_str()
+                    .unwrap()
+                    .to_string(),
+                single_output_file: ofile,
+                extra: sess.opts.cg.extra_filename.clone(),
+                outputs: sess.opts.output_types.clone(),
+            }
+        }
+    }
+}
+
+// Note: Also used by librustdoc, see PR #43348. Consider moving this struct elsewhere.
+//
+// FIXME: Currently the `everybody_loops` transformation is not applied to:
+//  * `const fn`, due to issue #43636 that `loop` is not supported for const evaluation. We are
+//    waiting for miri to fix that.
+//  * `impl Trait`, due to issue #43869 that functions returning impl Trait cannot be diverging.
+//    Solving this may require `!` to implement every trait, which relies on the an even more
+//    ambitious form of the closed RFC #1637. See also [#34511].
+//
+// [#34511]: https://github.com/rust-lang/rust/issues/34511#issuecomment-322340401
+pub struct ReplaceBodyWithLoop<'a> {
+    within_static_or_const: bool,
+    nested_blocks: Option<Vec<ast::Block>>,
+    sess: &'a Session,
+}
+
+impl<'a> ReplaceBodyWithLoop<'a> {
+    pub fn new(sess: &'a Session) -> ReplaceBodyWithLoop<'a> {
+        ReplaceBodyWithLoop {
+            within_static_or_const: false,
+            nested_blocks: None,
+            sess
+        }
+    }
+
+    fn run<R, F: FnOnce(&mut Self) -> R>(&mut self, is_const: bool, action: F) -> R {
+        let old_const = mem::replace(&mut self.within_static_or_const, is_const);
+        let old_blocks = self.nested_blocks.take();
+        let ret = action(self);
+        self.within_static_or_const = old_const;
+        self.nested_blocks = old_blocks;
+        ret
+    }
+
+    fn should_ignore_fn(ret_ty: &ast::FnDecl) -> bool {
+        if let ast::FunctionRetTy::Ty(ref ty) = ret_ty.output {
+            fn involves_impl_trait(ty: &ast::Ty) -> bool {
+                match ty.node {
+                    ast::TyKind::ImplTrait(..) => true,
+                    ast::TyKind::Slice(ref subty) |
+                    ast::TyKind::Array(ref subty, _) |
+                    ast::TyKind::Ptr(ast::MutTy { ty: ref subty, .. }) |
+                    ast::TyKind::Rptr(_, ast::MutTy { ty: ref subty, .. }) |
+                    ast::TyKind::Paren(ref subty) => involves_impl_trait(subty),
+                    ast::TyKind::Tup(ref tys) => any_involves_impl_trait(tys.iter()),
+                    ast::TyKind::Path(_, ref path) => path.segments.iter().any(|seg| {
+                        match seg.args.as_ref().map(|generic_arg| &**generic_arg) {
+                            None => false,
+                            Some(&ast::GenericArgs::AngleBracketed(ref data)) => {
+                                let types = data.args.iter().filter_map(|arg| match arg {
+                                    ast::GenericArg::Type(ty) => Some(ty),
+                                    _ => None,
+                                });
+                                any_involves_impl_trait(types.into_iter()) ||
+                                any_involves_impl_trait(data.bindings.iter().map(|b| &b.ty))
+                            },
+                            Some(&ast::GenericArgs::Parenthesized(ref data)) => {
+                                any_involves_impl_trait(data.inputs.iter()) ||
+                                any_involves_impl_trait(data.output.iter())
+                            }
+                        }
+                    }),
+                    _ => false,
+                }
+            }
+
+            fn any_involves_impl_trait<'a, I: Iterator<Item = &'a P<ast::Ty>>>(mut it: I) -> bool {
+                it.any(|subty| involves_impl_trait(subty))
+            }
+
+            involves_impl_trait(ty)
+        } else {
+            false
+        }
+    }
+}
+
+impl<'a> MutVisitor for ReplaceBodyWithLoop<'a> {
+    fn visit_item_kind(&mut self, i: &mut ast::ItemKind) {
+        let is_const = match i {
+            ast::ItemKind::Static(..) | ast::ItemKind::Const(..) => true,
+            ast::ItemKind::Fn(ref decl, ref header, _, _) =>
+                header.constness.node == ast::Constness::Const || Self::should_ignore_fn(decl),
+            _ => false,
+        };
+        self.run(is_const, |s| noop_visit_item_kind(i, s))
+    }
+
+    fn flat_map_trait_item(&mut self, i: ast::TraitItem) -> SmallVec<[ast::TraitItem; 1]> {
+        let is_const = match i.node {
+            ast::TraitItemKind::Const(..) => true,
+            ast::TraitItemKind::Method(ast::MethodSig { ref decl, ref header, .. }, _) =>
+                header.constness.node == ast::Constness::Const || Self::should_ignore_fn(decl),
+            _ => false,
+        };
+        self.run(is_const, |s| noop_flat_map_trait_item(i, s))
+    }
+
+    fn flat_map_impl_item(&mut self, i: ast::ImplItem) -> SmallVec<[ast::ImplItem; 1]> {
+        let is_const = match i.node {
+            ast::ImplItemKind::Const(..) => true,
+            ast::ImplItemKind::Method(ast::MethodSig { ref decl, ref header, .. }, _) =>
+                header.constness.node == ast::Constness::Const || Self::should_ignore_fn(decl),
+            _ => false,
+        };
+        self.run(is_const, |s| noop_flat_map_impl_item(i, s))
+    }
+
+    fn visit_anon_const(&mut self, c: &mut ast::AnonConst) {
+        self.run(true, |s| noop_visit_anon_const(c, s))
+    }
+
+    fn visit_block(&mut self, b: &mut P<ast::Block>) {
+        fn stmt_to_block(rules: ast::BlockCheckMode,
+                         s: Option<ast::Stmt>,
+                         sess: &Session) -> ast::Block {
+            ast::Block {
+                stmts: s.into_iter().collect(),
+                rules,
+                id: sess.next_node_id(),
+                span: syntax_pos::DUMMY_SP,
+            }
+        }
+
+        fn block_to_stmt(b: ast::Block, sess: &Session) -> ast::Stmt {
+            let expr = P(ast::Expr {
+                id: sess.next_node_id(),
+                node: ast::ExprKind::Block(P(b), None),
+                span: syntax_pos::DUMMY_SP,
+                attrs: ThinVec::new(),
+            });
+
+            ast::Stmt {
+                id: sess.next_node_id(),
+                node: ast::StmtKind::Expr(expr),
+                span: syntax_pos::DUMMY_SP,
+            }
+        }
+
+        let empty_block = stmt_to_block(BlockCheckMode::Default, None, self.sess);
+        let loop_expr = P(ast::Expr {
+            node: ast::ExprKind::Loop(P(empty_block), None),
+            id: self.sess.next_node_id(),
+            span: syntax_pos::DUMMY_SP,
+                attrs: ThinVec::new(),
+        });
+
+        let loop_stmt = ast::Stmt {
+            id: self.sess.next_node_id(),
+            span: syntax_pos::DUMMY_SP,
+            node: ast::StmtKind::Expr(loop_expr),
+        };
+
+        if self.within_static_or_const {
+            noop_visit_block(b, self)
+        } else {
+            visit_clobber(b.deref_mut(), |b| {
+                let mut stmts = vec![];
+                for s in b.stmts {
+                    let old_blocks = self.nested_blocks.replace(vec![]);
+
+                    stmts.extend(self.flat_map_stmt(s).into_iter().filter(|s| s.is_item()));
+
+                    // we put a Some in there earlier with that replace(), so this is valid
+                    let new_blocks = self.nested_blocks.take().unwrap();
+                    self.nested_blocks = old_blocks;
+                    stmts.extend(new_blocks.into_iter().map(|b| block_to_stmt(b, &self.sess)));
+                }
+
+                let mut new_block = ast::Block {
+                    stmts,
+                    ..b
+                };
+
+                if let Some(old_blocks) = self.nested_blocks.as_mut() {
+                    //push our fresh block onto the cache and yield an empty block with `loop {}`
+                    if !new_block.stmts.is_empty() {
+                        old_blocks.push(new_block);
+                    }
+
+                    stmt_to_block(b.rules, Some(loop_stmt), self.sess)
+                } else {
+                    //push `loop {}` onto the end of our fresh block and yield that
+                    new_block.stmts.push(loop_stmt);
+
+                    new_block
+                }
+            })
+        }
+    }
+
+    // in general the pretty printer processes unexpanded code, so
+    // we override the default `visit_mac` method which panics.
+    fn visit_mac(&mut self, mac: &mut ast::Mac) {
+        noop_visit_mac(mac, self)
+    }
+}
diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs
index 3a430f77b6c..5769ab25312 100644
--- a/src/librustc_typeck/check/mod.rs
+++ b/src/librustc_typeck/check/mod.rs
@@ -131,7 +131,7 @@ use std::ops::{self, Deref};
 use std::slice;
 
 use crate::require_c_abi_if_c_variadic;
-use crate::session::{CompileIncomplete, Session};
+use crate::session::Session;
 use crate::session::config::EntryFnType;
 use crate::TypeAndSubsts;
 use crate::lint;
@@ -711,12 +711,12 @@ fn check_mod_item_types<'tcx>(tcx: TyCtxt<'_, 'tcx, 'tcx>, module_def_id: DefId)
     tcx.hir().visit_item_likes_in_module(module_def_id, &mut CheckItemTypesVisitor { tcx });
 }
 
-pub fn check_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), CompileIncomplete> {
+pub fn check_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Result<(), ErrorReported> {
     tcx.typeck_item_bodies(LOCAL_CRATE)
 }
 
 fn typeck_item_bodies<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, crate_num: CrateNum)
-                                -> Result<(), CompileIncomplete>
+                                -> Result<(), ErrorReported>
 {
     debug_assert!(crate_num == LOCAL_CRATE);
     Ok(tcx.sess.track_errors(|| {
diff --git a/src/librustc_typeck/lib.rs b/src/librustc_typeck/lib.rs
index 2095c81d0fb..00c2ab79286 100644
--- a/src/librustc_typeck/lib.rs
+++ b/src/librustc_typeck/lib.rs
@@ -102,7 +102,7 @@ use rustc::infer::InferOk;
 use rustc::lint;
 use rustc::middle;
 use rustc::session;
-use rustc::session::CompileIncomplete;
+use rustc::util::common::ErrorReported;
 use rustc::session::config::{EntryFnType, nightly_options};
 use rustc::traits::{ObligationCause, ObligationCauseCode, TraitEngine, TraitEngineExt};
 use rustc::ty::subst::SubstsRef;
@@ -315,7 +315,7 @@ pub fn provide(providers: &mut Providers<'_>) {
 }
 
 pub fn check_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>)
-                             -> Result<(), CompileIncomplete>
+                             -> Result<(), ErrorReported>
 {
     tcx.sess.profiler(|p| p.start_activity(ProfileCategory::TypeChecking));
 
@@ -324,7 +324,6 @@ pub fn check_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>)
     tcx.sess.track_errors(|| {
         time(tcx.sess, "type collecting", ||
              collect::collect_item_types(tcx));
-
     })?;
 
     if tcx.features().rustc_attrs {
@@ -362,7 +361,11 @@ pub fn check_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>)
 
     tcx.sess.profiler(|p| p.end_activity(ProfileCategory::TypeChecking));
 
-    tcx.sess.compile_status()
+    if tcx.sess.err_count() == 0 {
+        Ok(())
+    } else {
+        Err(ErrorReported)
+    }
 }
 
 /// A quasi-deprecated helper used in rustdoc and save-analysis to get
diff --git a/src/librustdoc/core.rs b/src/librustdoc/core.rs
index 4dce4e86cc4..fdb071638b7 100644
--- a/src/librustdoc/core.rs
+++ b/src/librustdoc/core.rs
@@ -1,5 +1,5 @@
 use rustc_lint;
-use rustc_driver::{self, driver, target_features, abort_on_err};
+use rustc_driver::{driver, abort_on_err};
 use rustc::session::{self, config};
 use rustc::hir::def_id::{DefId, DefIndex, DefIndexAddressSpace, CrateNum, LOCAL_CRATE};
 use rustc::hir::def::Def;
@@ -11,6 +11,7 @@ use rustc::hir::map as hir_map;
 use rustc::lint::{self, LintPass};
 use rustc::session::config::ErrorOutputType;
 use rustc::util::nodemap::{FxHashMap, FxHashSet};
+use rustc_interface::util;
 use rustc_resolve as resolve;
 use rustc_metadata::creader::CrateLoader;
 use rustc_metadata::cstore::CStore;
@@ -402,7 +403,7 @@ pub fn run_core(options: RustdocOptions) -> (clean::Crate, RenderInfo, RenderOpt
                                              debugging_options.ui_testing);
 
         let mut sess = session::build_session_(
-            sessopts, cpath, diagnostic_handler, source_map,
+            sessopts, cpath, diagnostic_handler, source_map, Default::default(),
         );
 
         lint::builtin::HardwiredLints.get_lints()
@@ -422,12 +423,12 @@ pub fn run_core(options: RustdocOptions) -> (clean::Crate, RenderInfo, RenderOpt
                                                                       lint::Allow);
                                      });
 
-        let codegen_backend = rustc_driver::get_codegen_backend(&sess);
+        let codegen_backend = util::get_codegen_backend(&sess);
         let cstore = Rc::new(CStore::new(codegen_backend.metadata_loader()));
         rustc_lint::register_builtins(&mut sess.lint_store.borrow_mut(), Some(&sess));
 
         let mut cfg = config::build_configuration(&sess, config::parse_cfgspecs(cfgs));
-        target_features::add_configuration(&mut cfg, &sess, &*codegen_backend);
+        util::add_configuration(&mut cfg, &sess, &*codegen_backend);
         sess.parse_sess.config = cfg;
 
         let control = &driver::CompileController::basic();
@@ -481,23 +482,23 @@ pub fn run_core(options: RustdocOptions) -> (clean::Crate, RenderInfo, RenderOpt
 
         let mut arenas = AllArenas::new();
         let hir_map = hir_map::map_crate(&sess, &*cstore, &mut hir_forest, &defs);
-        let output_filenames = driver::build_output_filenames(&input,
+        let output_filenames = util::build_output_filenames(&input,
                                                             &None,
                                                             &None,
                                                             &[],
                                                             &sess);
 
         let resolver = RefCell::new(resolver);
-        abort_on_err(driver::phase_3_run_analysis_passes(&*codegen_backend,
-                                                        control,
-                                                        &sess,
-                                                        &*cstore,
-                                                        hir_map,
-                                                        resolutions,
-                                                        &mut arenas,
-                                                        &name,
-                                                        &output_filenames,
-                                                        |tcx, _, result| {
+        driver::phase_3_run_analysis_passes(&*codegen_backend,
+                                            control,
+                                            &sess,
+                                            &*cstore,
+                                            hir_map,
+                                            resolutions,
+                                            &mut arenas,
+                                            &name,
+                                            &output_filenames,
+                                            |tcx, _, result| {
             if result.is_err() {
                 sess.fatal("Compilation failed, aborting rustdoc");
             }
@@ -615,6 +616,6 @@ pub fn run_core(options: RustdocOptions) -> (clean::Crate, RenderInfo, RenderOpt
             ctxt.sess().abort_if_errors();
 
             (krate, ctxt.renderinfo.into_inner(), render_options, passes)
-        }), &sess)
+        })
     })
 }
diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs
index 39e504951d1..b3807d750b6 100644
--- a/src/librustdoc/lib.rs
+++ b/src/librustdoc/lib.rs
@@ -30,6 +30,7 @@ extern crate rustc_lint;
 extern crate rustc_metadata;
 extern crate rustc_target;
 extern crate rustc_typeck;
+extern crate rustc_interface;
 extern crate serialize;
 extern crate syntax;
 extern crate syntax_pos;
diff --git a/src/librustdoc/test.rs b/src/librustdoc/test.rs
index 8dad26f9292..c3c0875bc7d 100644
--- a/src/librustdoc/test.rs
+++ b/src/librustdoc/test.rs
@@ -2,9 +2,10 @@ use errors::{self, FatalError};
 use errors::emitter::ColorConfig;
 use rustc_data_structures::sync::Lrc;
 use rustc_lint;
-use rustc_driver::{self, driver, target_features, Compilation};
+use rustc_driver::{self, driver, Compilation};
 use rustc_driver::driver::phase_2_configure_and_expand;
 use rustc_metadata::cstore::CStore;
+use rustc_interface::util;
 use rustc::hir;
 use rustc::hir::intravisit;
 use rustc::session::{self, CompileIncomplete, config};
@@ -70,15 +71,15 @@ pub fn run(mut options: Options) -> isize {
                                             Some(source_map.clone()));
 
         let mut sess = session::build_session_(
-            sessopts, Some(options.input), handler, source_map.clone(),
+            sessopts, Some(options.input), handler, source_map.clone(), Default::default(),
         );
-        let codegen_backend = rustc_driver::get_codegen_backend(&sess);
+        let codegen_backend = util::get_codegen_backend(&sess);
         let cstore = CStore::new(codegen_backend.metadata_loader());
         rustc_lint::register_builtins(&mut sess.lint_store.borrow_mut(), Some(&sess));
 
         let mut cfg = config::build_configuration(&sess,
                                                   config::parse_cfgspecs(options.cfgs.clone()));
-        target_features::add_configuration(&mut cfg, &sess, &*codegen_backend);
+        util::add_configuration(&mut cfg, &sess, &*codegen_backend);
         sess.parse_sess.config = cfg;
 
         let krate =
@@ -274,9 +275,9 @@ fn run_test(test: &str, cratename: &str, filename: &FileName, line: usize,
         let diagnostic_handler = errors::Handler::with_emitter(true, false, box emitter);
 
         let mut sess = session::build_session_(
-            sessopts, None, diagnostic_handler, source_map,
+            sessopts, None, diagnostic_handler, source_map, Default::default(),
         );
-        let codegen_backend = rustc_driver::get_codegen_backend(&sess);
+        let codegen_backend = util::get_codegen_backend(&sess);
         let cstore = CStore::new(codegen_backend.metadata_loader());
         rustc_lint::register_builtins(&mut sess.lint_store.borrow_mut(), Some(&sess));
 
@@ -305,7 +306,7 @@ fn run_test(test: &str, cratename: &str, filename: &FileName, line: usize,
         let mut control = driver::CompileController::basic();
 
         let mut cfg = config::build_configuration(&sess, config::parse_cfgspecs(cfgs.clone()));
-        target_features::add_configuration(&mut cfg, &sess, &*codegen_backend);
+        util::add_configuration(&mut cfg, &sess, &*codegen_backend);
         sess.parse_sess.config = cfg;
 
         let out = Some(outdir.lock().unwrap().path().join("rust_out"));
diff --git a/src/test/run-make-fulldeps/issue-19371/foo.rs b/src/test/run-make-fulldeps/issue-19371/foo.rs
index b8461c568c8..e9d825df2a4 100644
--- a/src/test/run-make-fulldeps/issue-19371/foo.rs
+++ b/src/test/run-make-fulldeps/issue-19371/foo.rs
@@ -6,6 +6,7 @@ extern crate rustc_lint;
 extern crate rustc_metadata;
 extern crate rustc_errors;
 extern crate rustc_codegen_utils;
+extern crate rustc_interface;
 extern crate syntax;
 
 use rustc::session::{build_session, Session};
@@ -14,6 +15,7 @@ use rustc::session::config::{Input, Options,
 use rustc_driver::driver::{self, compile_input, CompileController};
 use rustc_metadata::cstore::CStore;
 use rustc_errors::registry::Registry;
+use rustc_interface::util;
 use syntax::source_map::FileName;
 use rustc_codegen_utils::codegen_backend::CodegenBackend;
 
@@ -45,7 +47,7 @@ fn main() {
 fn basic_sess(opts: Options) -> (Session, Rc<CStore>, Box<CodegenBackend>) {
     let descriptions = Registry::new(&rustc::DIAGNOSTICS);
     let sess = build_session(opts, None, descriptions);
-    let codegen_backend = rustc_driver::get_codegen_backend(&sess);
+    let codegen_backend = util::get_codegen_backend(&sess);
     let cstore = Rc::new(CStore::new(codegen_backend.metadata_loader()));
     rustc_lint::register_builtins(&mut sess.lint_store.borrow_mut(), Some(&sess));
     (sess, cstore, codegen_backend)
diff --git a/src/test/rustdoc-ui/failed-doctest-output.stdout b/src/test/rustdoc-ui/failed-doctest-output.stdout
index b7617ec556d..895c40e4cab 100644
--- a/src/test/rustdoc-ui/failed-doctest-output.stdout
+++ b/src/test/rustdoc-ui/failed-doctest-output.stdout
@@ -12,7 +12,7 @@ error[E0425]: cannot find value `no` in this scope
 3 | no
   | ^^ not found in this scope
 
-thread '$DIR/failed-doctest-output.rs - OtherStruct (line 17)' panicked at 'couldn't compile the test', src/librustdoc/test.rs:351:13
+thread '$DIR/failed-doctest-output.rs - OtherStruct (line 17)' panicked at 'couldn't compile the test', src/librustdoc/test.rs:352:13
 note: Run with `RUST_BACKTRACE=1` environment variable to display a backtrace.
 
 ---- $DIR/failed-doctest-output.rs - SomeStruct (line 11) stdout ----
@@ -21,7 +21,7 @@ thread '$DIR/failed-doctest-output.rs - SomeStruct (line 11)' panicked at 'test
 thread 'main' panicked at 'oh no', $DIR/failed-doctest-output.rs:3:1
 note: Run with `RUST_BACKTRACE=1` environment variable to display a backtrace.
 
-', src/librustdoc/test.rs:372:17
+', src/librustdoc/test.rs:373:17
 
 
 failures:
diff --git a/src/test/ui/issues/issue-23302-3.stderr b/src/test/ui/issues/issue-23302-3.stderr
index 392769b4c56..b3ca736622a 100644
--- a/src/test/ui/issues/issue-23302-3.stderr
+++ b/src/test/ui/issues/issue-23302-3.stderr
@@ -20,6 +20,7 @@ note: ...which requires checking which parts of `B` are promotable to static...
 LL | const B: i32 = A;
    |                ^
    = note: ...which again requires const checking if rvalue is promotable to static `A`, completing the cycle
+   = note: cycle used when running analysis passes on this crate
 
 error: aborting due to previous error