Add -Zborrowck-unreachable=no

The magic button for when you don't care about whether your code works, you just want it to compile.

Currently, this avoids running borrowck or typeck on dead code that isn't monomorphized.
In the future, it could be extended to ignore (but still emit) parse errors, mismatches in generic parameters, uses of private items, as long as the use doesn't need to make it to codegen.
However, I don't propose to put them under the same flag.

There is precedent for this in Haskell as -f defer-type-errors: https://ghc.gitlab.haskell.org/ghc/doc/users_guide/exts/defer_type_errors.html
Build systems also commonly have this as --keep-going, which ignores failed builds while continuing to run other builds that aren't dependent on the one that failed.

Some example motivations:

- When making a large refactor, run a single test that doesn't affect the rest of the codebase. In essence this is a "poor man's workspace", but adhoc and much faster than splitting out a single crate into multiple.
- Prototype a new application where you're rapidly changing the code and don't need it to be precisely correct, just see if it could eventually be made to compile.

Author: jyn514

compiler/rustc_driver/src/lib.rs

@@ -367,6 +367,13 @@ fn run_compiler(
                 return early_exit();
             }
 
+            // We need to get at least far before we have even a hope of generating a binary.
+            // FIXME: is that true? maybe we can ignore unresolved locals in dead code and that sort of thing
+            // That might require making name-resolution incremental, though.
+            if !sess.opts.unstable_opts.borrowck_unreachable {
+                return queries.linker().map(Some);
+            }
+
             queries.global_ctxt()?;
 
             if sess.opts.unstable_opts.no_analysis {

compiler/rustc_interface/src/queries.rs

@@ -237,7 +237,9 @@ impl<'tcx> Queries<'tcx> {
         self.ongoing_codegen.compute(|| {
             let outputs = self.prepare_outputs()?;
             self.global_ctxt()?.peek_mut().enter(|tcx| {
-                tcx.analysis(()).ok();
+                if tcx.sess.opts.unstable_opts.borrowck_unreachable {
+                    tcx.analysis(()).ok();
+                }
 
                 // Don't do code generation if there were any errors
                 self.session().compile_status()?;

compiler/rustc_monomorphize/src/collector.rs

@@ -1186,6 +1186,16 @@ struct RootCollector<'a, 'tcx> {
 
 impl<'v> RootCollector<'_, 'v> {
     fn process_item(&mut self, id: hir::ItemId) {
+        let def_id = id.owner_id.def_id;
+        let (live_symbols, _) = self.tcx.live_symbols_and_ignored_derived_traits(());
+        if !live_symbols.contains(&def_id) {
+            // This is dead code; ignore it.
+            return;
+        }
+        // We need this for `-Zborrowck-unreachable=no`, since we don't borrowck the whole crate at once, only on-demand.
+        if self.tcx.hir().maybe_body_owned_by(def_id).is_some() {
+            self.tcx.ensure().mir_borrowck(def_id);
+        }
         match self.tcx.def_kind(id.owner_id) {
             DefKind::Enum | DefKind::Struct | DefKind::Union => {
                 let item = self.tcx.hir().item(id);

compiler/rustc_session/src/options.rs

@@ -1311,6 +1311,8 @@ options! {
         (default: no)"),
     force_unstable_if_unmarked: bool = (false, parse_bool, [TRACKED],
         "force all crates to be `rustc_private` unstable (default: no)"),
+    borrowck_unreachable: bool = (true, parse_bool, [TRACKED],
+        "force borrowck to run even on functions that are never used"),
     fuel: Option<(String, u64)> = (None, parse_optimization_fuel, [TRACKED],
         "set the optimization fuel quota for a crate"),
     function_sections: Option<bool> = (None, parse_opt_bool, [TRACKED],

src/test/ui/fuckit/borrowck-live-code.rs

@@ -0,0 +1,9 @@
+// compile-flags: -Z borrowck-unreachable=no
+// build-fail
+fn live_code(s: &str) -> &'static str {
+    s //~ ERROR lifetime may not live long enough
+}
+
+fn main() {
+    println!("{}", live_code("he he he"));
+}

src/test/ui/fuckit/borrowck-live-code.stderr

@@ -0,0 +1,10 @@
+error: lifetime may not live long enough
+  --> $DIR/borrowck-live-code.rs:4:5
+   |
+LL | fn live_code(s: &str) -> &'static str {
+   |                 - let's call the lifetime of this reference `'1`
+LL |     s
+   |     ^ returning this value requires that `'1` must outlive `'static`
+
+error: aborting due to previous error
+

src/test/ui/fuckit/no-borrowck-dead-code.rs

@@ -0,0 +1,10 @@
+// compile-flags: -Z borrowck-unreachable=no
+// run-pass
+
+fn dead_code(s: &str) -> &'static str {
+    s
+}
+
+fn main() {
+    println!("he he he")
+}