Auto merge of #125105 - nnethercote:rustc_resolve-cleanups, r=estebank

`rustc_resolve` cleanups

Some improvements I found while looking through this code.

r? `@estebank`

compiler/rustc_resolve/src/build_reduced_graph.rs

@@ -32,6 +32,8 @@ use rustc_span::Span;
 
 use std::cell::Cell;
 
+use tracing::debug;
+
 type Res = def::Res<NodeId>;
 
 impl<'a, Id: Into<DefId>> ToNameBinding<'a>

compiler/rustc_resolve/src/def_collector.rs

@@ -7,6 +7,7 @@ use rustc_hir::def_id::LocalDefId;
 use rustc_span::hygiene::LocalExpnId;
 use rustc_span::symbol::{kw, sym, Symbol};
 use rustc_span::Span;
+use tracing::debug;
 
 pub(crate) fn collect_definitions(
     resolver: &mut Resolver<'_, '_>,

compiler/rustc_resolve/src/diagnostics.rs

@@ -28,6 +28,7 @@ use rustc_span::source_map::SourceMap;
 use rustc_span::symbol::{kw, sym, Ident, Symbol};
 use rustc_span::{BytePos, Span, SyntaxContext};
 use thin_vec::{thin_vec, ThinVec};
+use tracing::debug;
 
 use crate::errors::{
     self, AddedMacroUse, ChangeImportBinding, ChangeImportBindingSuggestion, ConsiderAddingADerive,
@@ -43,9 +44,6 @@ use crate::{LexicalScopeBinding, NameBinding, NameBindingKind, PrivacyError, Vis
 use crate::{ParentScope, PathResult, ResolutionError, Resolver, Scope, ScopeSet};
 use crate::{Segment, UseError};
 
-#[cfg(test)]
-mod tests;
-
 type Res = def::Res<ast::NodeId>;
 
 /// A vector of spans and replacements, a message and applicability.
@@ -3026,14 +3024,3 @@ fn is_span_suitable_for_use_injection(s: Span) -> bool {
     // import or other generated ones
     !s.from_expansion()
 }
-
-/// Convert the given number into the corresponding ordinal
-pub(crate) fn ordinalize(v: usize) -> String {
-    let suffix = match ((11..=13).contains(&(v % 100)), v % 10) {
-        (false, 1) => "st",
-        (false, 2) => "nd",
-        (false, 3) => "rd",
-        _ => "th",
-    };
-    format!("{v}{suffix}")
-}

compiler/rustc_resolve/src/diagnostics/tests.rs

@@ -1,40 +0,0 @@
-use super::ordinalize;
-
-#[test]
-fn test_ordinalize() {
-    assert_eq!(ordinalize(1), "1st");
-    assert_eq!(ordinalize(2), "2nd");
-    assert_eq!(ordinalize(3), "3rd");
-    assert_eq!(ordinalize(4), "4th");
-    assert_eq!(ordinalize(5), "5th");
-    // ...
-    assert_eq!(ordinalize(10), "10th");
-    assert_eq!(ordinalize(11), "11th");
-    assert_eq!(ordinalize(12), "12th");
-    assert_eq!(ordinalize(13), "13th");
-    assert_eq!(ordinalize(14), "14th");
-    // ...
-    assert_eq!(ordinalize(20), "20th");
-    assert_eq!(ordinalize(21), "21st");
-    assert_eq!(ordinalize(22), "22nd");
-    assert_eq!(ordinalize(23), "23rd");
-    assert_eq!(ordinalize(24), "24th");
-    // ...
-    assert_eq!(ordinalize(30), "30th");
-    assert_eq!(ordinalize(31), "31st");
-    assert_eq!(ordinalize(32), "32nd");
-    assert_eq!(ordinalize(33), "33rd");
-    assert_eq!(ordinalize(34), "34th");
-    // ...
-    assert_eq!(ordinalize(7010), "7010th");
-    assert_eq!(ordinalize(7011), "7011th");
-    assert_eq!(ordinalize(7012), "7012th");
-    assert_eq!(ordinalize(7013), "7013th");
-    assert_eq!(ordinalize(7014), "7014th");
-    // ...
-    assert_eq!(ordinalize(7020), "7020th");
-    assert_eq!(ordinalize(7021), "7021st");
-    assert_eq!(ordinalize(7022), "7022nd");
-    assert_eq!(ordinalize(7023), "7023rd");
-    assert_eq!(ordinalize(7024), "7024th");
-}

compiler/rustc_resolve/src/effective_visibilities.rs

@@ -11,6 +11,7 @@ use rustc_middle::middle::privacy::Level;
 use rustc_middle::middle::privacy::{EffectiveVisibilities, EffectiveVisibility};
 use rustc_middle::ty::Visibility;
 use std::mem;
+use tracing::info;
 
 #[derive(Clone, Copy)]
 enum ParentId<'a> {

compiler/rustc_resolve/src/ident.rs

@@ -11,6 +11,7 @@ use rustc_span::hygiene::{ExpnId, ExpnKind, LocalExpnId, MacroKind, SyntaxContex
 use rustc_span::sym;
 use rustc_span::symbol::{kw, Ident};
 use rustc_span::Span;
+use tracing::{debug, instrument};
 
 use crate::errors::{ParamKindInEnumDiscriminant, ParamKindInNonTrivialAnonConst};
 use crate::late::{ConstantHasGenerics, NoConstantGenericsReason, PathSource, Rib, RibKind};

compiler/rustc_resolve/src/imports.rs

@@ -34,6 +34,7 @@ use rustc_span::hygiene::LocalExpnId;
 use rustc_span::symbol::{kw, Ident, Symbol};
 use rustc_span::Span;
 use smallvec::SmallVec;
+use tracing::debug;
 
 use std::cell::Cell;
 use std::mem;

compiler/rustc_resolve/src/late.rs

@@ -30,6 +30,7 @@ use rustc_span::source_map::{respan, Spanned};
 use rustc_span::symbol::{kw, sym, Ident, Symbol};
 use rustc_span::{BytePos, Span, SyntaxContext};
 use smallvec::{smallvec, SmallVec};
+use tracing::{debug, instrument, trace};
 
 use std::assert_matches::debug_assert_matches;
 use std::borrow::Cow;

compiler/rustc_resolve/src/late/diagnostics.rs

@@ -40,6 +40,7 @@ use std::iter;
 use std::ops::Deref;
 
 use thin_vec::ThinVec;
+use tracing::debug;
 
 use super::NoConstantGenericsReason;
 

compiler/rustc_resolve/src/lib.rs

@@ -6,9 +6,13 @@
 //!
 //! Type-relative name resolution (methods, fields, associated items) happens in `rustc_hir_analysis`.
 
+// tidy-alphabetical-start
+#![allow(internal_features)]
+#![allow(rustc::diagnostic_outside_of_impl)]
+#![allow(rustc::potential_query_instability)]
+#![allow(rustc::untranslatable_diagnostic)]
 #![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
 #![doc(rust_logo)]
-#![feature(rustdoc_internals)]
 #![feature(assert_matches)]
 #![feature(box_patterns)]
 #![feature(extract_if)]
@@ -16,18 +20,9 @@
 #![feature(iter_intersperse)]
 #![feature(let_chains)]
 #![feature(rustc_attrs)]
-#![allow(rustdoc::private_intra_doc_links)]
-#![allow(rustc::diagnostic_outside_of_impl)]
-#![allow(rustc::potential_query_instability)]
-#![allow(rustc::untranslatable_diagnostic)]
-#![allow(internal_features)]
+#![feature(rustdoc_internals)]
+// tidy-alphabetical-end
 
-#[macro_use]
-extern crate tracing;
-
-use errors::{
-    ParamKindInEnumDiscriminant, ParamKindInNonTrivialAnonConst, ParamKindInTyOfConstParam,
-};
 use rustc_arena::{DroplessArena, TypedArena};
 use rustc_ast::expand::StrippedCfgItem;
 use rustc_ast::node_id::NodeMap;
@@ -60,19 +55,21 @@ use rustc_session::lint::LintBuffer;
 use rustc_span::hygiene::{ExpnId, LocalExpnId, MacroKind, SyntaxContext, Transparency};
 use rustc_span::symbol::{kw, sym, Ident, Symbol};
 use rustc_span::{Span, DUMMY_SP};
-
 use smallvec::{smallvec, SmallVec};
 use std::cell::{Cell, RefCell};
 use std::collections::BTreeSet;
 use std::fmt;
+use tracing::debug;
 
 use diagnostics::{ImportSuggestion, LabelSuggestion, Suggestion};
+use effective_visibilities::EffectiveVisibilitiesVisitor;
+use errors::{
+    ParamKindInEnumDiscriminant, ParamKindInNonTrivialAnonConst, ParamKindInTyOfConstParam,
+};
 use imports::{Import, ImportData, ImportKind, NameResolution};
 use late::{HasGenericParams, PathSource, PatternSource, UnnecessaryQualification};
 use macros::{MacroRulesBinding, MacroRulesScope, MacroRulesScopeRef};
 
-use crate::effective_visibilities::EffectiveVisibilitiesVisitor;
-
 type Res = def::Res<NodeId>;
 
 mod build_reduced_graph;
@@ -964,7 +961,6 @@ struct DeriveData {
     has_derive_copy: bool,
 }
 
-#[derive(Clone)]
 struct MacroData {
     ext: Lrc<SyntaxExtension>,
     rule_spans: Vec<(usize, Span)>,

compiler/rustc_resolve/src/macros.rs

@@ -328,11 +328,7 @@ impl<'a, 'tcx> ResolverExpand for Resolver<'a, 'tcx> {
                 UNUSED_MACRO_RULES,
                 node_id,
                 rule_span,
-                format!(
-                    "{} rule of macro `{}` is never used",
-                    crate::diagnostics::ordinalize(arm_i + 1),
-                    ident.name
-                ),
+                format!("rule #{} of macro `{}` is never used", arm_i + 1, ident.name),
             );
         }
     }

compiler/rustc_resolve/src/rustdoc.rs

@@ -8,6 +8,7 @@ use rustc_span::symbol::{kw, sym, Symbol};
 use rustc_span::{InnerSpan, Span, DUMMY_SP};
 use std::mem;
 use std::ops::Range;
+use tracing::{debug, trace};
 
 #[derive(Clone, Copy, PartialEq, Eq, Debug)]
 pub enum DocFragmentKind {

tests/ui/lint/unused/unused-macro-rules-compile-error.rs

@@ -9,7 +9,7 @@ macro_rules! num {
     // Some nested use
     (two_) => { foo(compile_error!("foo")); };
     (three) => { 3 };
-    (four) => { 4 }; //~ ERROR: rule of macro
+    (four) => { 4 }; //~ ERROR: rule #5 of macro
 }
 const _NUM: u8 = num!(one) + num!(three);
 
@@ -17,9 +17,9 @@ const _NUM: u8 = num!(one) + num!(three);
 macro_rules! num2 {
     (one) => { 1 };
     // Only identifier present
-    (two) => { fn compile_error() {} }; //~ ERROR: rule of macro
+    (two) => { fn compile_error() {} }; //~ ERROR: rule #2 of macro
     // Only identifier and bang present
-    (two_) => { compile_error! }; //~ ERROR: rule of macro
+    (two_) => { compile_error! }; //~ ERROR: rule #3 of macro
     (three) => { 3 };
 }
 const _NUM2: u8 = num2!(one) + num2!(three);

tests/ui/lint/unused/unused-macro-rules-compile-error.stderr

@@ -1,4 +1,4 @@
-error: 5th rule of macro `num` is never used
+error: rule #5 of macro `num` is never used
   --> $DIR/unused-macro-rules-compile-error.rs:12:5
    |
 LL |     (four) => { 4 };
@@ -10,13 +10,13 @@ note: the lint level is defined here
 LL | #![deny(unused_macro_rules)]
    |         ^^^^^^^^^^^^^^^^^^
 
-error: 3rd rule of macro `num2` is never used
+error: rule #3 of macro `num2` is never used
   --> $DIR/unused-macro-rules-compile-error.rs:22:5
    |
 LL |     (two_) => { compile_error! };
    |     ^^^^^^
 
-error: 2nd rule of macro `num2` is never used
+error: rule #2 of macro `num2` is never used
   --> $DIR/unused-macro-rules-compile-error.rs:20:5
    |
 LL |     (two) => { fn compile_error() {} };

tests/ui/lint/unused/unused-macro-rules-decl.rs

@@ -6,9 +6,9 @@
 // Most simple case
 macro num {
     (one) => { 1 },
-    (two) => { 2 }, //~ ERROR: 2nd rule of macro
+    (two) => { 2 }, //~ ERROR: rule #2 of macro
     (three) => { 3 },
-    (four) => { 4 }, //~ ERROR: 4th rule of macro
+    (four) => { 4 }, //~ ERROR: rule #4 of macro
 }
 const _NUM: u8 = num!(one) + num!(three);
 
@@ -28,7 +28,7 @@ macro num_rec {
     (two) => {
         num_rec!(one) + num_rec!(one)
     },
-    (three) => { //~ ERROR: 3rd rule of macro
+    (three) => { //~ ERROR: rule #3 of macro
         num_rec!(one) + num_rec!(two)
     },
     (four) => {

tests/ui/lint/unused/unused-macro-rules-decl.stderr

@@ -1,4 +1,4 @@
-error: 4th rule of macro `num` is never used
+error: rule #4 of macro `num` is never used
   --> $DIR/unused-macro-rules-decl.rs:11:5
    |
 LL |     (four) => { 4 },
@@ -10,13 +10,13 @@ note: the lint level is defined here
 LL | #![deny(unused_macro_rules)]
    |         ^^^^^^^^^^^^^^^^^^
 
-error: 2nd rule of macro `num` is never used
+error: rule #2 of macro `num` is never used
   --> $DIR/unused-macro-rules-decl.rs:9:5
    |
 LL |     (two) => { 2 },
    |     ^^^^^
 
-error: 3rd rule of macro `num_rec` is never used
+error: rule #3 of macro `num_rec` is never used
   --> $DIR/unused-macro-rules-decl.rs:31:5
    |
 LL |     (three) => {

tests/ui/lint/unused/unused-macro-rules.rs

@@ -5,9 +5,9 @@
 // Most simple case
 macro_rules! num {
     (one) => { 1 };
-    (two) => { 2 }; //~ ERROR: 2nd rule of macro
+    (two) => { 2 }; //~ ERROR: rule #2 of macro
     (three) => { 3 };
-    (four) => { 4 }; //~ ERROR: 4th rule of macro
+    (four) => { 4 }; //~ ERROR: rule #4 of macro
 }
 const _NUM: u8 = num!(one) + num!(three);
 
@@ -27,7 +27,7 @@ macro_rules! num_rec {
     (two) => {
         num_rec!(one) + num_rec!(one)
     };
-    (three) => { //~ ERROR: 3rd rule of macro
+    (three) => { //~ ERROR: rule #3 of macro
         num_rec!(one) + num_rec!(two)
     };
     (four) => { num_rec!(two) + num_rec!(two) };

tests/ui/lint/unused/unused-macro-rules.stderr

@@ -1,4 +1,4 @@
-error: 4th rule of macro `num` is never used
+error: rule #4 of macro `num` is never used
   --> $DIR/unused-macro-rules.rs:10:5
    |
 LL |     (four) => { 4 };
@@ -10,13 +10,13 @@ note: the lint level is defined here
 LL | #![deny(unused_macro_rules)]
    |         ^^^^^^^^^^^^^^^^^^
 
-error: 2nd rule of macro `num` is never used
+error: rule #2 of macro `num` is never used
   --> $DIR/unused-macro-rules.rs:8:5
    |
 LL |     (two) => { 2 };
    |     ^^^^^
 
-error: 3rd rule of macro `num_rec` is never used
+error: rule #3 of macro `num_rec` is never used
   --> $DIR/unused-macro-rules.rs:30:5
    |
 LL |     (three) => {