address review: tcx as first argument

Author: LorrensP-2158466

compiler/rustc_metadata/src/creader.rs

@@ -206,8 +206,8 @@ impl CStore {
 
     fn intern_stable_crate_id<'tcx>(
         &mut self,
-        root: &CrateRoot,
         tcx: TyCtxt<'tcx>,
+        root: &CrateRoot,
     ) -> Result<TyCtxtFeed<'tcx, CrateNum>, CrateError> {
         assert_eq!(self.metas.len(), tcx.untracked().stable_crate_ids.read().len());
         let num = tcx.create_crate_num(root.stable_crate_id()).map_err(|existing| {
@@ -480,10 +480,10 @@ impl CStore {
 
     fn existing_match(
         &self,
+        tcx: TyCtxt<'_>,
         name: Symbol,
         hash: Option<Svh>,
         kind: PathKind,
-        tcx: TyCtxt<'_>,
     ) -> Option<CrateNum> {
         for (cnum, data) in self.iter_crate_data() {
             if data.name() != name {
@@ -563,10 +563,10 @@ impl CStore {
     /// command parameter is set to `public-dependency`
     fn is_private_dep<'tcx>(
         &self,
+        tcx: TyCtxt<'tcx>,
         name: Symbol,
         private_dep: Option<bool>,
         origin: CrateOrigin<'_>,
-        tcx: TyCtxt<'tcx>,
     ) -> bool {
         if matches!(origin, CrateOrigin::Injected) {
             return true;
@@ -584,24 +584,24 @@ impl CStore {
 
     fn register_crate<'tcx>(
         &mut self,
+        tcx: TyCtxt<'tcx>,
         host_lib: Option<Library>,
         origin: CrateOrigin<'_>,
         lib: Library,
         dep_kind: CrateDepKind,
         name: Symbol,
         private_dep: Option<bool>,
-        tcx: TyCtxt<'tcx>,
     ) -> Result<CrateNum, CrateError> {
         let _prof_timer =
             tcx.sess.prof.generic_activity_with_arg("metadata_register_crate", name.as_str());
 
         let Library { source, metadata } = lib;
         let crate_root = metadata.get_root();
         let host_hash = host_lib.as_ref().map(|lib| lib.metadata.get_root().hash());
-        let private_dep = self.is_private_dep(name, private_dep, origin, tcx);
+        let private_dep = self.is_private_dep(tcx, name, private_dep, origin);
 
         // Claim this crate number and cache it
-        let feed = self.intern_stable_crate_id(&crate_root, tcx)?;
+        let feed = self.intern_stable_crate_id(tcx, &crate_root)?;
         let cnum = feed.key();
 
         info!(
@@ -622,13 +622,13 @@ impl CStore {
         };
 
         let cnum_map = self.resolve_crate_deps(
+            tcx,
             dep_root,
             &crate_root,
             &metadata,
             cnum,
             dep_kind,
             private_dep,
-            tcx,
         )?;
 
         let raw_proc_macros = if crate_root.is_proc_macro_crate() {
@@ -641,7 +641,7 @@ impl CStore {
                 None => (&source, &crate_root),
             };
             let dlsym_dylib = dlsym_source.dylib.as_ref().expect("no dylib for a proc-macro crate");
-            Some(self.dlsym_proc_macros(&dlsym_dylib.0, dlsym_root.stable_crate_id(), tcx)?)
+            Some(self.dlsym_proc_macros(tcx, &dlsym_dylib.0, dlsym_root.stable_crate_id())?)
         } else {
             None
         };
@@ -667,11 +667,11 @@ impl CStore {
 
     fn load_proc_macro<'b, 'tcx>(
         &self,
+        tcx: TyCtxt<'tcx>,
         locator: &mut CrateLocator<'b>,
         crate_rejections: &mut CrateRejections,
         path_kind: PathKind,
         host_hash: Option<Svh>,
-        tcx: TyCtxt<'tcx>,
     ) -> Result<Option<(LoadResult, Option<Library>)>, CrateError>
     where
         'tcx: 'b,
@@ -734,14 +734,14 @@ impl CStore {
 
     fn resolve_crate<'tcx>(
         &mut self,
+        tcx: TyCtxt<'tcx>,
         name: Symbol,
         span: Span,
         dep_kind: CrateDepKind,
         origin: CrateOrigin<'_>,
-        tcx: TyCtxt<'tcx>,
     ) -> Option<CrateNum> {
         self.used_extern_options.insert(name);
-        match self.maybe_resolve_crate(name, dep_kind, origin, tcx) {
+        match self.maybe_resolve_crate(tcx, name, dep_kind, origin) {
             Ok(cnum) => {
                 self.set_used_recursively(cnum);
                 Some(cnum)
@@ -750,10 +750,10 @@ impl CStore {
                 debug!("failed to resolve crate {} {:?}", name, dep_kind);
                 let missing_core = self
                     .maybe_resolve_crate(
+                        tcx,
                         sym::core,
                         CrateDepKind::Explicit,
                         CrateOrigin::Extern,
-                        tcx,
                     )
                     .is_err();
                 err.report(tcx.sess, span, missing_core);
@@ -764,10 +764,10 @@ impl CStore {
 
     fn maybe_resolve_crate<'b, 'tcx>(
         &'b mut self,
+        tcx: TyCtxt<'tcx>,
         name: Symbol,
         mut dep_kind: CrateDepKind,
         origin: CrateOrigin<'b>,
-        tcx: TyCtxt<'tcx>,
     ) -> Result<CrateNum, CrateError> {
         info!("resolving crate `{}`", name);
         if !name.as_str().is_ascii() {
@@ -782,7 +782,7 @@ impl CStore {
         let path_kind = if dep.is_some() { PathKind::Dependency } else { PathKind::Crate };
         let private_dep = origin.private_dep();
 
-        let result = if let Some(cnum) = self.existing_match(name, hash, path_kind, tcx) {
+        let result = if let Some(cnum) = self.existing_match(tcx, name, hash, path_kind) {
             (LoadResult::Previous(cnum), None)
         } else {
             info!("falling back to a load");
@@ -805,11 +805,11 @@ impl CStore {
                     info!("falling back to loading proc_macro");
                     dep_kind = CrateDepKind::MacrosOnly;
                     match self.load_proc_macro(
+                        tcx,
                         &mut locator,
                         &mut crate_rejections,
                         path_kind,
                         host_hash,
-                        tcx,
                     )? {
                         Some(res) => res,
                         None => return Err(locator.into_error(crate_rejections, dep_root.cloned())),
@@ -825,7 +825,7 @@ impl CStore {
                 // not specified by `--extern` on command line parameters, it may be
                 // `private-dependency` when `register_crate` is called for the first time. Then it must be updated to
                 // `public-dependency` here.
-                let private_dep = self.is_private_dep(name, private_dep, origin, tcx);
+                let private_dep = self.is_private_dep(tcx, name, private_dep, origin);
                 let data = self.get_crate_data_mut(cnum);
                 if data.is_proc_macro_crate() {
                     dep_kind = CrateDepKind::MacrosOnly;
@@ -836,7 +836,7 @@ impl CStore {
             }
             (LoadResult::Loaded(library), host_library) => {
                 info!("register newly loaded library for `{}`", name);
-                self.register_crate(host_library, origin, library, dep_kind, name, private_dep, tcx)
+                self.register_crate(tcx, host_library, origin, library, dep_kind, name, private_dep)
             }
             _ => panic!(),
         }
@@ -871,13 +871,13 @@ impl CStore {
     /// Go through the crate metadata and load any crates that it references.
     fn resolve_crate_deps(
         &mut self,
+        tcx: TyCtxt<'_>,
         dep_root: &CratePaths,
         crate_root: &CrateRoot,
         metadata: &MetadataBlob,
         krate: CrateNum,
         dep_kind: CrateDepKind,
         parent_is_private: bool,
-        tcx: TyCtxt<'_>,
     ) -> Result<CrateNumMap, CrateError> {
         debug!(
             "resolving deps of external crate `{}` with dep root `{}`",
@@ -908,14 +908,14 @@ impl CStore {
                 _ => dep.kind,
             };
             let cnum = self.maybe_resolve_crate(
+                tcx,
                 dep.name,
                 dep_kind,
                 CrateOrigin::IndirectDependency {
                     dep_root,
                     parent_private: parent_is_private,
                     dep: &dep,
                 },
-                tcx,
             )?;
             crate_num_map.push(cnum);
         }
@@ -926,9 +926,9 @@ impl CStore {
 
     fn dlsym_proc_macros<'tcx>(
         &self,
+        tcx: TyCtxt<'tcx>,
         path: &Path,
         stable_crate_id: StableCrateId,
-        tcx: TyCtxt<'tcx>,
     ) -> Result<&'static [ProcMacro], CrateError> {
         let sym_name = tcx.sess.generate_proc_macro_decls_symbol(stable_crate_id);
         debug!("trying to dlsym proc_macros {} for symbol `{}`", path.display(), sym_name);
@@ -952,7 +952,7 @@ impl CStore {
         }
     }
 
-    fn inject_panic_runtime(&mut self, krate: &ast::Crate, tcx: TyCtxt<'_>) {
+    fn inject_panic_runtime(&mut self, tcx: TyCtxt<'_>, krate: &ast::Crate) {
         // If we're only compiling an rlib, then there's no need to select a
         // panic runtime, so we just skip this section entirely.
         let only_rlib = tcx.crate_types().iter().all(|ct| *ct == CrateType::Rlib);
@@ -992,7 +992,7 @@ impl CStore {
         info!("panic runtime not found -- loading {}", name);
 
         let Some(cnum) =
-            self.resolve_crate(name, DUMMY_SP, CrateDepKind::Implicit, CrateOrigin::Injected, tcx)
+            self.resolve_crate(tcx, name, DUMMY_SP, CrateDepKind::Implicit, CrateOrigin::Injected)
         else {
             return;
         };
@@ -1022,7 +1022,7 @@ impl CStore {
 
         let name = Symbol::intern(&tcx.sess.opts.unstable_opts.profiler_runtime);
         let Some(cnum) =
-            self.resolve_crate(name, DUMMY_SP, CrateDepKind::Implicit, CrateOrigin::Injected, tcx)
+            self.resolve_crate(tcx, name, DUMMY_SP, CrateDepKind::Implicit, CrateOrigin::Injected)
         else {
             return;
         };
@@ -1034,7 +1034,7 @@ impl CStore {
         }
     }
 
-    fn inject_allocator_crate(&mut self, krate: &ast::Crate, tcx: TyCtxt<'_>) {
+    fn inject_allocator_crate(&mut self, tcx: TyCtxt<'_>, krate: &ast::Crate) {
         self.has_global_allocator =
             match &*fn_spans(krate, Symbol::intern(&global_fn_name(sym::alloc))) {
                 [span1, span2, ..] => {
@@ -1142,19 +1142,19 @@ impl CStore {
                 let name_interned = Symbol::intern(name);
                 if !self.used_extern_options.contains(&name_interned) {
                     self.resolve_crate(
+                        tcx,
                         name_interned,
                         DUMMY_SP,
                         CrateDepKind::Explicit,
                         CrateOrigin::Extern,
-                        tcx,
                     );
                 }
             }
         }
     }
 
     /// Inject the `compiler_builtins` crate if it is not already in the graph.
-    fn inject_compiler_builtins(&mut self, krate: &ast::Crate, tcx: TyCtxt<'_>) {
+    fn inject_compiler_builtins(&mut self, tcx: TyCtxt<'_>, krate: &ast::Crate) {
         // `compiler_builtins` does not get extern builtins, nor do `#![no_core]` crates
         if attr::contains_name(&krate.attrs, sym::compiler_builtins)
             || attr::contains_name(&krate.attrs, sym::no_core)
@@ -1174,11 +1174,11 @@ impl CStore {
 
         // `compiler_builtins` is not yet in the graph; inject it. Error on resolution failure.
         let Some(cnum) = self.resolve_crate(
+            tcx,
             sym::compiler_builtins,
             krate.spans.inner_span.shrink_to_lo(),
             CrateDepKind::Explicit,
             CrateOrigin::Injected,
-            tcx,
         ) else {
             info!("`compiler_builtins` not resolved");
             return;
@@ -1191,7 +1191,7 @@ impl CStore {
         }
     }
 
-    fn report_unused_deps_in_crate(&mut self, krate: &ast::Crate, tcx: TyCtxt<'_>) {
+    fn report_unused_deps_in_crate(&mut self, tcx: TyCtxt<'_>, krate: &ast::Crate) {
         // Make a point span rather than covering the whole file
         let span = krate.spans.inner_span.shrink_to_lo();
         // Complain about anything left over
@@ -1227,7 +1227,7 @@ impl CStore {
         }
     }
 
-    fn report_future_incompatible_deps(&self, krate: &ast::Crate, tcx: TyCtxt<'_>) {
+    fn report_future_incompatible_deps(&self, tcx: TyCtxt<'_>, krate: &ast::Crate) {
         let name = tcx.crate_name(LOCAL_CRATE);
 
         if name.as_str() == "wasm_bindgen" {
@@ -1260,26 +1260,26 @@ impl CStore {
         }
     }
 
-    pub fn postprocess(&mut self, krate: &ast::Crate, tcx: TyCtxt<'_>) {
-        self.inject_compiler_builtins(krate, tcx);
+    pub fn postprocess(&mut self, tcx: TyCtxt<'_>, krate: &ast::Crate) {
+        self.inject_compiler_builtins(tcx, krate);
         self.inject_forced_externs(tcx);
         self.inject_profiler_runtime(tcx);
-        self.inject_allocator_crate(krate, tcx);
-        self.inject_panic_runtime(krate, tcx);
+        self.inject_allocator_crate(tcx, krate);
+        self.inject_panic_runtime(tcx, krate);
 
-        self.report_unused_deps_in_crate(krate, tcx);
-        self.report_future_incompatible_deps(krate, tcx);
+        self.report_unused_deps_in_crate(tcx, krate);
+        self.report_future_incompatible_deps(tcx, krate);
 
         info!("{:?}", CrateDump(self));
     }
 
     /// Process an `extern crate foo` AST node.
     pub fn process_extern_crate(
         &mut self,
+        tcx: TyCtxt<'_>,
         item: &ast::Item,
         def_id: LocalDefId,
         definitions: &Definitions,
-        tcx: TyCtxt<'_>,
     ) -> Option<CrateNum> {
         match item.kind {
             ast::ItemKind::ExternCrate(orig_name, ident) => {
@@ -1298,7 +1298,7 @@ impl CStore {
                 };
 
                 let cnum =
-                    self.resolve_crate(name, item.span, dep_kind, CrateOrigin::Extern, tcx)?;
+                    self.resolve_crate(tcx, name, item.span, dep_kind, CrateOrigin::Extern)?;
 
                 let path_len = definitions.def_path(def_id).data.len();
                 self.update_extern_crate(
@@ -1318,12 +1318,12 @@ impl CStore {
 
     pub fn process_path_extern(
         &mut self,
+        tcx: TyCtxt<'_>,
         name: Symbol,
         span: Span,
-        tcx: TyCtxt<'_>,
     ) -> Option<CrateNum> {
         let cnum =
-            self.resolve_crate(name, span, CrateDepKind::Explicit, CrateOrigin::Extern, tcx)?;
+            self.resolve_crate(tcx, name, span, CrateDepKind::Explicit, CrateOrigin::Extern)?;
 
         self.update_extern_crate(
             cnum,
@@ -1339,8 +1339,8 @@ impl CStore {
         Some(cnum)
     }
 
-    pub fn maybe_process_path_extern(&mut self, name: Symbol, tcx: TyCtxt<'_>) -> Option<CrateNum> {
-        self.maybe_resolve_crate(name, CrateDepKind::Explicit, CrateOrigin::Extern, tcx).ok()
+    pub fn maybe_process_path_extern(&mut self, tcx: TyCtxt<'_>, name: Symbol) -> Option<CrateNum> {
+        self.maybe_resolve_crate(tcx, name, CrateDepKind::Explicit, CrateOrigin::Extern).ok()
     }
 }
 

compiler/rustc_resolve/src/build_reduced_graph.rs

@@ -911,10 +911,10 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
         } else {
             let tcx = self.r.tcx;
             let crate_id = self.r.cstore_mut().process_extern_crate(
+                self.r.tcx,
                 item,
                 local_def_id,
                 &tcx.definitions_untracked(),
-                self.r.tcx,
             );
             crate_id.map(|crate_id| {
                 self.r.extern_crate_map.insert(local_def_id, crate_id);