Perf improvements

Author: Amanieu

compiler/rustc_resolve/src/build_reduced_graph.rs

@@ -400,27 +400,32 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         // Record primary definitions.
         let mut define_extern = |ns| {
             let orig_ident_span = orig_ident.span;
-            let edition_redirects = edition_redirects
-                .iter()
-                .map(|redirect| crate::EditionRedirectDecl {
-                    before: redirect.before,
-                    // Model this as a one-step reexport under the original
-                    // child's name: the target supplies the resolution, while
-                    // the child supplies its visibility and provenance.
-                    target: self.arenas.alloc_decl(DeclData {
-                        kind: DeclKind::Def(redirect.target.expect_non_local()),
-                        ambiguity: CmCell::new(None),
-                        initial_vis: vis,
-                        ambiguity_vis_max: CmCell::new(None),
-                        ambiguity_vis_min: CmCell::new(None),
-                        span,
-                        expansion,
-                        parent_module: Some(parent.to_module()),
-                        edition_redirects: &[],
-                    }),
-                })
-                .collect::<SmallVec<[_; 1]>>();
-            let edition_redirects = self.arenas.alloc_edition_redirects(&edition_redirects);
+            let edition_redirects = if edition_redirects.is_empty() {
+                // Fast path when there are no edition redirects.
+                &[]
+            } else {
+                let edition_redirects = edition_redirects
+                    .iter()
+                    .map(|redirect| crate::EditionRedirectDecl {
+                        before: redirect.before,
+                        // Model this as a one-step reexport under the original
+                        // child's name: the target supplies the resolution, while
+                        // the child supplies its visibility and provenance.
+                        target: self.arenas.alloc_decl(DeclData {
+                            kind: DeclKind::Def(redirect.target.expect_non_local()),
+                            ambiguity: CmCell::new(None),
+                            initial_vis: vis,
+                            ambiguity_vis_max: CmCell::new(None),
+                            ambiguity_vis_min: CmCell::new(None),
+                            span,
+                            expansion,
+                            parent_module: Some(parent.to_module()),
+                            edition_redirects: &[],
+                        }),
+                    })
+                    .collect::<SmallVec<[_; 1]>>();
+                self.arenas.alloc_edition_redirects(&edition_redirects)
+            };
             let decl = self.arenas.alloc_decl(DeclData {
                 kind: DeclKind::Def(res),
                 ambiguity: CmCell::new(ambig),
@@ -1434,12 +1439,13 @@ impl<'a, 'ra, 'tcx> DefCollector<'a, 'ra, 'tcx> {
         // The resolver runs before these attributes are available through HIR.
         // Parse and retain them here, but leave their target paths unresolved
         // until ordinary imports have settled.
-        if let Some(Attribute::Parsed(AttributeKind::RustcEditionRedirect(mut redirects))) =
-            AttributeParser::parse_limited_sym(
-                self.r.tcx.sess,
-                &item.attrs,
-                &[sym::rustc_edition_redirect],
-            )
+        if ast::attr::contains_name(&item.attrs, sym::rustc_edition_redirect)
+            && let Some(Attribute::Parsed(AttributeKind::RustcEditionRedirect(mut redirects))) =
+                AttributeParser::parse_limited_sym(
+                    self.r.tcx.sess,
+                    &item.attrs,
+                    &[sym::rustc_edition_redirect],
+                )
         {
             redirects.sort_by_key(|redirect| redirect.before);
             let edition_redirects = redirects

compiler/rustc_resolve/src/ident.rs

@@ -713,7 +713,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 }
             }
             Scope::MacroUsePrelude => match self.macro_use_prelude.get(&ident.name).cloned() {
-                Some(decl) => Ok(self.edition_adjusted_decl(decl, orig_ident_span.edition())),
+                Some(decl) => Ok(self.edition_adjusted_decl(decl, orig_ident_span)),
                 None => Err(Determinacy::determined(!self.graph_root.has_unexpanded_invocations())),
             },
             Scope::BuiltinAttrs => match self.builtin_attr_decls.get(&ident.name) {
@@ -1114,10 +1114,16 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         let resolution =
             &*self.resolution(module.to_module(), key).ok_or(ControlFlow::Continue(Determined))?;
 
-        let binding = resolution
-            .non_glob_decl
-            .filter(|b| Some(*b) != ignore_decl)
-            .map(|binding| self.edition_adjusted_decl(binding, orig_ident_span.edition()));
+        let binding = resolution.non_glob_decl.filter(|b| Some(*b) != ignore_decl).map(|binding| {
+            // This check is redundant with the one inside
+            // edition_adjusted_decl, but this is a hot path and we want to
+            // avoid the call if it isn't necessary.
+            if !binding.edition_redirects.is_empty() {
+                self.edition_adjusted_decl(binding, orig_ident_span)
+            } else {
+                binding
+            }
+        });
 
         if let Some(finalize) = finalize {
             return self.get_mut().finalize_module_binding(

compiler/rustc_resolve/src/imports.rs

@@ -467,7 +467,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         // Without `edition_redirect`, the first import consumes the redirect
         // using that import's edition. The resulting binding is fixed for
         // downstream users.
-        decl = self.edition_adjusted_decl(decl, import.span.edition());
+        decl = self.edition_adjusted_decl(decl, import.span);
 
         let vis = self.import_decl_vis(decl, import.summary());
 
@@ -483,28 +483,33 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         // each target in this import so a downstream edition adjustment retains
         // its visibility and re-export provenance. Other crates consume the
         // redirects above and produce re-exports with no redirects.
-        let edition_redirects = if self.features.edition_redirect() {
-            decl.edition_redirects
-                .iter()
-                .map(|redirect| crate::EditionRedirectDecl {
-                    before: redirect.before,
-                    target: self.arenas.alloc_decl(DeclData {
-                        kind: DeclKind::Import { source_decl: redirect.target, import },
-                        ambiguity: CmCell::new(None),
-                        span: import.span,
-                        initial_vis: vis.to_mod_id(),
-                        ambiguity_vis_max: CmCell::new(None),
-                        ambiguity_vis_min: CmCell::new(None),
-                        expansion: import.parent_scope.expansion,
-                        parent_module: Some(import.parent_scope.module),
-                        edition_redirects: &[],
-                    }),
-                })
-                .collect::<SmallVec<[_; 1]>>()
+        let edition_redirects = if decl.edition_redirects.is_empty() {
+            // Fast path when there are no edition redirects.
+            &[]
         } else {
-            SmallVec::new()
+            let edition_redirects = if self.features.edition_redirect() {
+                decl.edition_redirects
+                    .iter()
+                    .map(|redirect| crate::EditionRedirectDecl {
+                        before: redirect.before,
+                        target: self.arenas.alloc_decl(DeclData {
+                            kind: DeclKind::Import { source_decl: redirect.target, import },
+                            ambiguity: CmCell::new(None),
+                            span: import.span,
+                            initial_vis: vis.to_mod_id(),
+                            ambiguity_vis_max: CmCell::new(None),
+                            ambiguity_vis_min: CmCell::new(None),
+                            expansion: import.parent_scope.expansion,
+                            parent_module: Some(import.parent_scope.module),
+                            edition_redirects: &[],
+                        }),
+                    })
+                    .collect::<SmallVec<[_; 1]>>()
+            } else {
+                SmallVec::new()
+            };
+            self.arenas.alloc_edition_redirects(&edition_redirects)
         };
-        let edition_redirects = self.arenas.alloc_edition_redirects(&edition_redirects);
 
         self.arenas.alloc_decl(DeclData {
             kind: DeclKind::Import { source_decl: decl, import },
@@ -625,7 +630,9 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             }
             glob_decl
         } else if glob_decl.res() != old_glob_decl.res()
-            || !Self::same_edition_redirects(old_glob_decl, glob_decl)
+            || (!(old_glob_decl.edition_redirects.is_empty()
+                && glob_decl.edition_redirects.is_empty())
+                && !Self::same_edition_redirects(old_glob_decl, glob_decl))
         {
             // Redirects are part of a binding's behavior. If two globs resolve
             // to the same item but redirect differently, retaining either
@@ -668,6 +675,11 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
     /// considered: they affect only the metadata produced for downstream
     /// crates, not local name resolution.
     fn same_edition_redirects(decl1: Decl<'ra>, decl2: Decl<'ra>) -> bool {
+        // Fast path when there are no edition redirects.
+        if decl1.edition_redirects.is_empty() && decl2.edition_redirects.is_empty() {
+            return true;
+        }
+
         decl1.edition_redirects.len() == decl2.edition_redirects.len()
             && decl1.edition_redirects.iter().zip(decl2.edition_redirects).all(
                 |(redirect1, redirect2)| {
@@ -1860,8 +1872,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                 .iter()
                 .filter_map(|(key, resolution)| {
                     let res = resolution.borrow();
-                    let decl =
-                        self.edition_adjusted_decl(res.determined_decl()?, import.span.edition());
+                    let decl = self.edition_adjusted_decl(res.determined_decl()?, import.span);
                     let mut key = *key;
                     let scope = match key.ident.ctxt.update_unchecked(|ctxt| {
                         ctxt.reverse_glob_adjust(module.expansion, import.span)
@@ -1960,30 +1971,14 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         }
     }
 
-    /// Produces the sorted, metadata-ready edition redirects for `decl` in
-    /// `ns`.
-    ///
-    /// Targets declared in the current crate are resolved here, after ordinary
-    /// imports have settled and once the namespace exported by the declaration
-    /// is known. Redirects on external declarations are already resolved in
-    /// crate metadata and are copied through unchanged.
-    fn resolved_edition_redirects(
+    /// Resolves local redirect targets after ordinary imports have settled and
+    /// once the namespace exported by `decl` is known.
+    fn resolve_local_edition_redirects(
         &mut self,
         ns: Namespace,
         decl: Decl<'ra>,
+        redirects: Vec<crate::LocalEditionRedirect<'ra>>,
     ) -> SmallVec<[MetadataEditionRedirect; 1]> {
-        let Some(redirects) = self.local_edition_redirects(decl) else {
-            // External declarations already carry resolved redirect targets
-            // from crate metadata.
-            return decl
-                .edition_redirects
-                .iter()
-                .map(|redirect| MetadataEditionRedirect {
-                    before: redirect.before,
-                    target: redirect.target.res().expect_non_local(),
-                })
-                .collect();
-        };
         redirects
             .into_iter()
             .filter_map(|redirect| {
@@ -2080,9 +2075,16 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
 
         let Some(def_id) = module.opt_def_id() else { return };
 
+        enum EditionRedirectSlot {
+            Child(usize),
+            AmbiguousMain(usize),
+            AmbiguousSecond(usize),
+        }
+
         let mut children = Vec::new();
         let mut ambig_children = Vec::new();
-        module.to_module().for_each_child_mut(self, |this, ident, orig_ident_span, ns, decl| {
+        let mut pending_edition_redirects = Vec::new();
+        module.to_module().for_each_child(self, |this, ident, orig_ident_span, ns, decl| {
             let res = decl.res().expect_non_local();
             if res != def::Res::Err {
                 let vis = if this.rust_embed_hack(module, decl) {
@@ -2091,34 +2093,84 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     decl.vis()
                 };
                 let ident = ident.orig(orig_ident_span);
+                let mut edition_redirects = |decl, child| {
+                    // Local redirect targets must be resolved after
+                    // `for_each_child` releases its borrow. Otherwise copy any
+                    // already-resolved redirects decoded from external crate
+                    // metadata.
+                    if !this.local_edition_redirects.is_empty()
+                        && let Some(redirects) = this.local_edition_redirects(decl)
+                    {
+                        pending_edition_redirects.push((child, ns, decl, redirects));
+                        SmallVec::new()
+                    } else if decl.edition_redirects.is_empty() {
+                        SmallVec::new()
+                    } else {
+                        decl.edition_redirects
+                            .iter()
+                            .map(|redirect| MetadataEditionRedirect {
+                                before: redirect.before,
+                                target: redirect.target.res().expect_non_local(),
+                            })
+                            .collect()
+                    }
+                };
                 if let Some((ambig_binding1, ambig_binding2)) = decl.descent_to_ambiguity() {
+                    let index = ambig_children.len();
                     let main = ModChild {
                         ident,
                         res,
                         vis,
                         reexport_chain: ambig_binding1.reexport_chain(),
-                        edition_redirects: this.resolved_edition_redirects(ns, ambig_binding1),
+                        edition_redirects: edition_redirects(
+                            ambig_binding1,
+                            EditionRedirectSlot::AmbiguousMain(index),
+                        ),
                     };
                     let second = ModChild {
                         ident,
                         res: ambig_binding2.res().expect_non_local(),
                         vis: ambig_binding2.vis(),
                         reexport_chain: ambig_binding2.reexport_chain(),
-                        edition_redirects: this.resolved_edition_redirects(ns, ambig_binding2),
+                        edition_redirects: edition_redirects(
+                            ambig_binding2,
+                            EditionRedirectSlot::AmbiguousSecond(index),
+                        ),
                     };
                     ambig_children.push(AmbigModChild { main, second })
                 } else {
+                    let index = children.len();
                     children.push(ModChild {
                         ident,
                         res,
                         vis,
                         reexport_chain: decl.reexport_chain(),
-                        edition_redirects: this.resolved_edition_redirects(ns, decl),
+                        edition_redirects: edition_redirects(
+                            decl,
+                            EditionRedirectSlot::Child(index),
+                        ),
                     });
                 }
             }
         });
 
+        // Resolving a target can record import uses and diagnostics, so wait
+        // until `for_each_child` releases its borrow of the module resolutions.
+        for (child, ns, decl, redirects) in pending_edition_redirects {
+            let redirects = self.resolve_local_edition_redirects(ns, decl, redirects);
+            match child {
+                EditionRedirectSlot::Child(index) => {
+                    children[index].edition_redirects = redirects;
+                }
+                EditionRedirectSlot::AmbiguousMain(index) => {
+                    ambig_children[index].main.edition_redirects = redirects;
+                }
+                EditionRedirectSlot::AmbiguousSecond(index) => {
+                    ambig_children[index].second.edition_redirects = redirects;
+                }
+            }
+        }
+
         if !children.is_empty() {
             module_children.insert(def_id.expect_local(), children);
         }

compiler/rustc_resolve/src/lib.rs

@@ -2063,7 +2063,12 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         f(self, MacroNS);
     }
 
-    fn edition_adjusted_decl(&self, decl: Decl<'ra>, edition: Edition) -> Decl<'ra> {
+    fn edition_adjusted_decl(&self, decl: Decl<'ra>, span: Span) -> Decl<'ra> {
+        // Nothing to do if the decl has no redirects.
+        if decl.edition_redirects.is_empty() {
+            return decl;
+        }
+
         // Crates with `edition_redirect` resolve canonical bindings so
         // redirects can be preserved through their re-exports. Other crates
         // select using the use-site edition.
@@ -2079,6 +2084,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             return decl;
         }
 
+        let edition = span.edition();
         decl.edition_redirects
             .iter()
             .find(|redirect| edition < redirect.before)