Turn parsing into a query

Author: Zoxc

src/librustc/query/mod.rs

@@ -30,6 +30,28 @@ use syntax_pos::symbol::InternedString;
 // as they will raise an fatal error on query cycles instead.
 rustc_queries! {
     Other {
+        query parse(_: LocalCrate) -> Result<Lrc<Steal<ast::Crate>>, ErrorReported> {
+            no_hash
+            eval_always
+            desc { "parsing crate" }
+        }
+
+        query register_plugins(
+            _: LocalCrate
+        ) -> Result<Lrc<Steal<(ast::Crate, ty::PluginInfo)>>, ErrorReported> {
+            no_hash
+            eval_always
+            desc { "registering plugins" }
+        }
+
+        /// The definite name of the current crate after taking into account
+        /// attributes, commandline parameters, etc.
+        query early_crate_name(_: LocalCrate) -> Result<Symbol, ErrorReported> {
+            no_hash
+            eval_always
+            desc { "finding the crate name" }
+        }
+
         query expand_macros(_: LocalCrate) -> Result<Lrc<ty::ExpansionResult>, ErrorReported> {
             no_hash
             eval_always
@@ -734,6 +756,7 @@ rustc_queries! {
             eval_always
             desc { "looking up the hash a crate" }
         }
+        // FIXME: Remove this as it's the same as `crate_name`
         query original_crate_name(_: CrateNum) -> Symbol {
             eval_always
             desc { "looking up the original name a crate" }

src/librustc/session/config.rs

@@ -400,6 +400,9 @@ top_level_options!(
         // try to not rely on this too much.
         actually_rustdoc: bool [TRACKED],
 
+        // Replaces bodies with loops
+        everybody_loops: bool [TRACKED],
+
         // Specifications of codegen units / ThinLTO which are forced as a
         // result of parsing command line options. These are not necessarily
         // what rustc was invoked with, but massaged a bit to agree with
@@ -623,6 +626,7 @@ impl Default for Options {
             unstable_features: UnstableFeatures::Disallow,
             debug_assertions: true,
             actually_rustdoc: false,
+            everybody_loops: false,
             cli_forced_codegen_units: None,
             cli_forced_thinlto_off: false,
             remap_path_prefix: Vec::new(),
@@ -2366,6 +2370,7 @@ pub fn build_session_options_and_crate_config(
             unstable_features: UnstableFeatures::from_environment(),
             debug_assertions,
             actually_rustdoc: false,
+            everybody_loops: false,
             cli_forced_codegen_units: codegen_units,
             cli_forced_thinlto_off: disable_thinlto,
             remap_path_prefix,

src/librustc/ty/context.rs

@@ -51,7 +51,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::{Lrc, Lock, WorkerLocal, AtomicOnce, Once, OneThread};
+use rustc_data_structures::sync::{self, Lrc, Lock, WorkerLocal, AtomicOnce, Once};
 use std::any::Any;
 use std::borrow::Borrow;
 use std::cmp::Ordering;
@@ -70,7 +70,7 @@ use syntax::attr;
 use syntax::source_map::MultiSpan;
 use syntax::edition::Edition;
 use syntax::feature_gate;
-use syntax::symbol::{Symbol, keywords, InternedString};
+use syntax::symbol::{keywords, InternedString};
 use syntax_pos::Span;
 
 use crate::hir;
@@ -1021,13 +1021,10 @@ pub struct GlobalCtxt<'tcx> {
 
     /// This stores a `Lrc<CStore>`, but that type depends on
     /// rustc_metadata, so it cannot be used here.
-    pub cstore_rc: OneThread<Steal<Box<dyn Any>>>,
+    pub cstore_rc: &'tcx (dyn Any + sync::Sync),
 
     pub sess_rc: Lrc<Session>,
 
-    /// The AST after registering plugins.
-    pub ast_crate: Steal<(ast::Crate, ty::PluginInfo)>,
-
     lowered_hir: AtomicOnce<&'tcx hir::LoweredHir>,
     hir_map: AtomicOnce<&'tcx hir_map::Map<'tcx>>,
 
@@ -1047,9 +1044,7 @@ pub struct GlobalCtxt<'tcx> {
     /// Merge this with `selection_cache`?
     pub evaluation_cache: traits::EvaluationCache<'tcx>,
 
-    /// The definite name of the current crate after taking into account
-    /// attributes, commandline parameters, etc.
-    pub crate_name: Symbol,
+    pub crate_name_override: Option<String>,
 
     /// Data layout specification for the current target.
     pub data_layout: TargetDataLayout,
@@ -1210,15 +1205,13 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
     pub fn create_global_ctxt(
         s: &'tcx Lrc<Session>,
         cstore: &'tcx CrateStoreDyn,
-        cstore_rc: Box<dyn Any>,
+        cstore_rc: &'tcx (dyn Any + sync::Sync),
         local_providers: ty::query::Providers<'tcx>,
         extern_providers: ty::query::Providers<'tcx>,
         arenas: &'tcx AllArenas<'tcx>,
         dep_graph: DepGraph,
-        ast_crate: ast::Crate,
-        plugin_info: ty::PluginInfo,
         on_disk_query_result_cache: query::OnDiskCache<'tcx>,
-        crate_name: &str,
+        crate_name: Option<String>,
         tx: mpsc::Sender<Box<dyn Any + Send>>,
         io: InputsAndOutputs,
     ) -> GlobalCtxt<'tcx> {
@@ -1234,13 +1227,12 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
         GlobalCtxt {
             sess: &**s,
             cstore,
-            cstore_rc: OneThread::new(Steal::new(cstore_rc)),
+            cstore_rc,
             sess_rc: s.clone(),
             global_arenas: &arenas.global,
             global_interners: interners,
             dep_graph,
             types: common_types,
-            ast_crate: Steal::new((ast_crate, plugin_info)),
             lowered_hir: AtomicOnce::new(),
             hir_map: AtomicOnce::new(),
             metadata_dep_nodes: Once::new(),
@@ -1252,7 +1244,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
             rcache: Default::default(),
             selection_cache: Default::default(),
             evaluation_cache: Default::default(),
-            crate_name: Symbol::intern(crate_name),
+            crate_name_override: crate_name,
             data_layout,
             layout_interner: Default::default(),
             stability_interner: Default::default(),
@@ -1361,7 +1353,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
         // statements within the query system and we'd run into endless
         // recursion otherwise.
         let (crate_name, crate_disambiguator) = if def_id.is_local() {
-            (self.crate_name.clone(),
+            (self.crate_name(LOCAL_CRATE),
              self.sess.local_crate_disambiguator())
         } else {
             (self.cstore.crate_name_untracked(def_id.krate),
@@ -3008,7 +3000,7 @@ pub fn provide(providers: &mut ty::query::Providers<'_>) {
     };
     providers.crate_name = |tcx, id| {
         assert_eq!(id, LOCAL_CRATE);
-        tcx.crate_name
+        tcx.early_crate_name(LocalCrate).unwrap()
     };
     providers.get_lib_features = |tcx, id| {
         assert_eq!(id, LOCAL_CRATE);

src/librustc/ty/mod.rs

@@ -3294,8 +3294,7 @@ fn crate_disambiguator<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
 
 fn original_crate_name<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
                                  crate_num: CrateNum) -> Symbol {
-    assert_eq!(crate_num, LOCAL_CRATE);
-    tcx.crate_name.clone()
+    tcx.crate_name(crate_num)
 }
 
 fn crate_hash<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,

src/librustc_codegen_llvm/lib.rs

@@ -275,7 +275,7 @@ impl CodegenBackend for LlvmCodegenBackend {
         target_features(sess)
     }
 
-    fn metadata_loader(&self) -> Box<dyn MetadataLoader + Sync> {
+    fn metadata_loader(&self) -> Box<dyn MetadataLoader + Sync + Send> {
         box metadata::LlvmMetadataLoader
     }
 

src/librustc_codegen_utils/codegen_backend.rs

@@ -31,7 +31,7 @@ pub trait CodegenBackend {
     fn print_version(&self) {}
     fn diagnostics(&self) -> &[(&'static str, &'static str)] { &[] }
 
-    fn metadata_loader(&self) -> Box<dyn MetadataLoader + Sync>;
+    fn metadata_loader(&self) -> Box<dyn MetadataLoader + Sync + Send>;
     fn provide(&self, _providers: &mut Providers<'_>);
     fn provide_extern(&self, _providers: &mut Providers<'_>);
     fn codegen_crate<'a, 'tcx>(

src/librustc_driver/lib.rs

@@ -226,6 +226,8 @@ pub fn run_compiler(
 
     callbacks.config(&mut config);
 
+    let pretty_info = parse_pretty(&mut config.opts, &matches);
+
     interface::run_compiler(config, |compiler| {
         let sess = compiler.session();
         let should_stop = RustcDefaultCalls::print_crate_info(
@@ -245,14 +247,9 @@ pub fn run_compiler(
             return sess.compile_status();
         }
 
-        let pretty_info = parse_pretty(sess, &matches);
-
-        compiler.parse()?;
-
         if let Some((ppm, opt_uii)) = pretty_info {
             if ppm.needs_ast_map(&opt_uii) {
-                pretty::visit_crate(sess, &mut compiler.parse()?.peek_mut(), ppm);
-                compiler.global_ctxt()?.peek_mut().enter(|tcx| {
+                compiler.enter(|tcx| {
                     let expansion_result = tcx.expand_macros(LocalCrate)?;
                     pretty::print_after_hir_lowering(
                         tcx,
@@ -266,19 +263,24 @@ pub fn run_compiler(
                 })?;
                 return sess.compile_status();
             } else {
-                let mut krate = compiler.parse()?.take();
-                pretty::visit_crate(sess, &mut krate, ppm);
-                pretty::print_after_parsing(
-                    sess,
-                    &compiler.input(),
-                    &krate,
-                    ppm,
-                    compiler.output_file().as_ref().map(|p| &**p),
-                );
+                compiler.enter(|tcx| {
+                    let krate = tcx.parse(LocalCrate)?;
+                    let krate = krate.borrow();
+                    pretty::print_after_parsing(
+                        sess,
+                        &compiler.input(),
+                        &krate,
+                        ppm,
+                        compiler.output_file().as_ref().map(|p| &**p),
+                    );
+                    Ok(())
+                })?;
                 return sess.compile_status();
             }
         }
 
+        compiler.enter(|tcx| tcx.parse(LocalCrate))?;
+
         if !callbacks.after_parsing(compiler) {
             return sess.compile_status();
         }
@@ -289,15 +291,15 @@ pub fn run_compiler(
             return sess.compile_status();
         }
 
-        compiler.register_plugins()?;
+        compiler.enter(|tcx| tcx.register_plugins(LocalCrate))?;
 
         // Lint plugins are registered; now we can process command line flags.
         if sess.opts.describe_lints {
             describe_lints(&sess, &sess.lint_store.borrow(), true);
             return sess.compile_status();
         }
 
-        compiler.global_ctxt()?.peek_mut().enter(|tcx| {
+        compiler.enter(|tcx| {
             tcx.prepare_outputs(LocalCrate)?;
             Ok(())
         })?;
@@ -308,7 +310,7 @@ pub fn run_compiler(
             return sess.compile_status();
         }
 
-        compiler.global_ctxt()?.peek_mut().enter(|tcx| {
+        compiler.enter(|tcx| {
             tcx.lower_ast_to_hir(LocalCrate)?;
             Ok(())
         })?;
@@ -319,10 +321,10 @@ pub fn run_compiler(
         }
 
         if sess.opts.debugging_opts.save_analysis {
-            compiler.global_ctxt()?.peek_mut().enter(|tcx| {
+            compiler.enter(|tcx| {
                 let expansion_result = tcx.expand_macros(LocalCrate)?;
                 let result = tcx.analysis(LOCAL_CRATE);
-                let crate_name = &tcx.crate_name.as_str();
+                let crate_name = &tcx.crate_name(LOCAL_CRATE).as_str();
 
                 time(sess, "save analysis", || {
                     save::process_crate(
@@ -340,20 +342,20 @@ pub fn run_compiler(
                 // (needed by the RLS)
             })?;
         } else {
-            compiler.global_ctxt()?.peek_mut().enter(|tcx| {
+            compiler.enter(|tcx| {
                 // Drop AST after lowering HIR to free memory
                 mem::drop(tcx.expand_macros(LocalCrate).unwrap().ast_crate.steal());
             });
         }
 
-        compiler.global_ctxt()?.peek_mut().enter(|tcx| tcx.analysis(LOCAL_CRATE))?;
+        compiler.enter(|tcx| tcx.analysis(LOCAL_CRATE))?;
 
         if !callbacks.after_analysis(compiler) {
             return sess.compile_status();
         }
 
         if sess.opts.debugging_opts.save_analysis {
-            compiler.global_ctxt()?.peek_mut().enter(|tcx| {
+            compiler.enter(|tcx| {
                 // Drop AST after lowering HIR to free memory
                 mem::drop(tcx.expand_macros(LocalCrate).unwrap().ast_crate.steal());
             });
@@ -426,22 +428,22 @@ fn make_input(free_matches: &[String]) -> Option<(Input, Option<PathBuf>, Option
     }
 }
 
-fn parse_pretty(sess: &Session,
+fn parse_pretty(opts: &mut config::Options,
                 matches: &getopts::Matches)
                 -> Option<(PpMode, Option<UserIdentifiedItem>)> {
-    let pretty = if sess.opts.debugging_opts.unstable_options {
+    let pretty = if opts.debugging_opts.unstable_options {
         matches.opt_default("pretty", "normal").map(|a| {
             // stable pretty-print variants only
-            pretty::parse_pretty(sess, &a, false)
+            pretty::parse_pretty(opts, &a, false)
         })
     } else {
         None
     };
 
     if pretty.is_none() {
-        sess.opts.debugging_opts.unpretty.as_ref().map(|a| {
+        opts.debugging_opts.unpretty.clone().map(|a| {
             // extended with unstable pretty-print variants
-            pretty::parse_pretty(sess, &a, true)
+            pretty::parse_pretty(opts, &a, true)
         })
     } else {
         pretty