Split elided_lifetime_in_paths into finer-grained lints

Cargo.lock

@@ -3889,6 +3889,7 @@ dependencies = [
 name = "rustc_hir"
 version = "0.0.0"
 dependencies = [
+ "bitflags",
  "odht",
  "rustc_abi",
  "rustc_arena",

compiler/rustc_ast_lowering/src/delegation.rs

@@ -40,7 +40,7 @@ use std::iter;
 
 use ast::visit::Visitor;
 use hir::def::{DefKind, PartialRes, Res};
-use hir::{BodyId, HirId};
+use hir::{BodyId, HirId, PathFlags};
 use rustc_abi::ExternAbi;
 use rustc_ast::*;
 use rustc_errors::ErrorGuaranteed;
@@ -264,7 +264,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             hir_id: self.next_id(),
             res: Res::Local(param_id),
             args: None,
-            infer_args: false,
+            flags: PathFlags::empty(),
         }));
 
         let path = self.arena.alloc(hir::Path { span, res: Res::Local(param_id), segments });
@@ -366,6 +366,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 GenericArgsMode::Err,
                 ImplTraitContext::Disallowed(ImplTraitPosition::Path),
                 None,
+                PathFlags::empty(),
             );
             let segment = self.arena.alloc(segment);
 

compiler/rustc_ast_lowering/src/expr.rs

@@ -5,10 +5,9 @@ use rustc_ast::ptr::P as AstP;
 use rustc_ast::*;
 use rustc_ast_pretty::pprust::expr_to_string;
 use rustc_data_structures::stack::ensure_sufficient_stack;
-use rustc_hir as hir;
 use rustc_hir::attrs::AttributeKind;
 use rustc_hir::def::{DefKind, Res};
-use rustc_hir::{HirId, find_attr};
+use rustc_hir::{self as hir, HirId, PathFlags, find_attr};
 use rustc_middle::span_bug;
 use rustc_middle::ty::TyCtxt;
 use rustc_session::errors::report_lit_error;
@@ -126,6 +125,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         ImplTraitContext::Disallowed(ImplTraitPosition::Path),
                         // Method calls can't have bound modifiers
                         None,
+                        PathFlags::empty(),
                     ));
                     let receiver = self.lower_expr(receiver);
                     let args =

compiler/rustc_ast_lowering/src/lib.rs

@@ -54,7 +54,7 @@ use rustc_hir::def_id::{CRATE_DEF_ID, LOCAL_CRATE, LocalDefId};
 use rustc_hir::lints::DelayedLint;
 use rustc_hir::{
     self as hir, AngleBrackets, ConstArg, GenericArg, HirId, ItemLocalMap, LifetimeSource,
-    LifetimeSyntax, ParamName, TraitCandidate,
+    LifetimeSyntax, ParamName, PathFlags, TraitCandidate,
 };
 use rustc_index::{Idx, IndexSlice, IndexVec};
 use rustc_macros::extension;
@@ -781,6 +781,8 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         let def_id = self.tcx.require_lang_item(lang_item, span);
         let def_kind = self.tcx.def_kind(def_id);
         let res = Res::Def(def_kind, def_id);
+        let mut flags = PathFlags::empty();
+        flags.set(PathFlags::INFER_ARGS, args.is_none());
         self.arena.alloc(hir::Path {
             span,
             res,
@@ -789,7 +791,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 hir_id: self.next_id(),
                 res,
                 args,
-                infer_args: args.is_none(),
+                flags,
             }]),
         })
     }

compiler/rustc_ast_lowering/src/path.rs

@@ -3,7 +3,7 @@ use std::sync::Arc;
 use rustc_ast::{self as ast, *};
 use rustc_hir::def::{DefKind, PartialRes, PerNS, Res};
 use rustc_hir::def_id::DefId;
-use rustc_hir::{self as hir, GenericArg};
+use rustc_hir::{self as hir, GenericArg, PathFlags};
 use rustc_middle::{span_bug, ty};
 use rustc_session::parse::add_feature_diagnostics;
 use rustc_span::{BytePos, DUMMY_SP, DesugaringKind, Ident, Span, Symbol, sym};
@@ -135,6 +135,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                         generic_args_mode,
                         itctx(i),
                         bound_modifier_allowed_features.clone(),
+                        PathFlags::empty(),
                     )
                 },
             )),
@@ -160,16 +161,23 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         }
 
         // Create the innermost type that we're projecting from.
-        let mut ty = if path.segments.is_empty() {
+        let (mut ty, flags) = if path.segments.is_empty() {
             // If the base path is empty that means there exists a
             // syntactical `Self`, e.g., `&i32` in `<&i32>::clone`.
-            qself.expect("missing QSelf for <T>::...")
+            (qself.expect("missing QSelf for <T>::..."), PathFlags::empty())
         } else {
             // Otherwise, the base path is an implicit `Self` type path,
             // e.g., `Vec` in `Vec::new` or `<I as Iterator>::Item` in
             // `<I as Iterator>::Item::default`.
             let new_id = self.next_id();
-            self.arena.alloc(self.ty_path(new_id, path.span, hir::QPath::Resolved(qself, path)))
+            (
+                &*self.arena.alloc(self.ty_path(
+                    new_id,
+                    path.span,
+                    hir::QPath::Resolved(qself, path),
+                )),
+                PathFlags::IMPLICIT_SELF,
+            )
         };
 
         // Anything after the base path are associated "extensions",
@@ -199,6 +207,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 generic_args_mode,
                 itctx(i),
                 None,
+                flags,
             ));
             let qpath = hir::QPath::TypeRelative(ty, hir_segment);
 
@@ -241,6 +250,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     GenericArgsMode::Err,
                     ImplTraitContext::Disallowed(ImplTraitPosition::Path),
                     None,
+                    PathFlags::empty(),
                 )
             })),
             span: self.lower_span(p.span),
@@ -258,6 +268,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         // This is passed down to the implicit associated type binding in
         // parenthesized bounds.
         bound_modifier_allowed_features: Option<Arc<[Symbol]>>,
+        mut flags: PathFlags,
     ) -> hir::PathSegment<'hir> {
         debug!("path_span: {:?}, lower_path_segment(segment: {:?})", path_span, segment);
         let (mut generic_args, infer_args) = if let Some(generic_args) = segment.args.as_deref() {
@@ -400,11 +411,13 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             segment.ident, segment.id, hir_id,
         );
 
+        flags.set(PathFlags::INFER_ARGS, infer_args);
+
         hir::PathSegment {
             ident: self.lower_ident(segment.ident),
             hir_id,
             res: self.lower_res(res),
-            infer_args,
+            flags,
             args: if generic_args.is_empty() && generic_args.span.is_empty() {
                 None
             } else {

compiler/rustc_baked_icu_data/src/lib.rs

@@ -21,13 +21,14 @@
 //! ```
 
 // tidy-alphabetical-start
-#![allow(elided_lifetimes_in_paths)]
 #![allow(internal_features)]
 #![allow(unreachable_pub)] // because this crate is mostly generated code
 #![doc(rust_logo)]
 #![feature(rustdoc_internals)]
 // #![warn(unreachable_pub)] // don't use because this crate is mostly generated code
 // tidy-alphabetical-end
+#![cfg_attr(bootstrap, allow(elided_lifetimes_in_paths))]
+#![cfg_attr(not(bootstrap), allow(hidden_lifetimes_in_paths))]
 
 mod data {
     include!("data/mod.rs");

compiler/rustc_hir/Cargo.toml

@@ -5,6 +5,7 @@ edition = "2024"
 
 [dependencies]
 # tidy-alphabetical-start
+bitflags = "2.4.1"
 odht = { version = "0.3.1", features = ["nightly"] }
 rustc_abi = { path = "../rustc_abi" }
 rustc_arena = { path = "../rustc_arena" }

compiler/rustc_hir/src/hir.rs

@@ -16,6 +16,7 @@ pub use rustc_ast::{
 };
 use rustc_data_structures::fingerprint::Fingerprint;
 use rustc_data_structures::sorted_map::SortedMap;
+use rustc_data_structures::stable_hasher::HashStable;
 use rustc_data_structures::tagged_ptr::TaggedRef;
 use rustc_index::IndexVec;
 use rustc_macros::{Decodable, Encodable, HashStable_Generic};
@@ -374,17 +375,37 @@ pub struct PathSegment<'hir> {
     /// distinction.
     pub args: Option<&'hir GenericArgs<'hir>>,
 
-    /// Whether to infer remaining type parameters, if any.
-    /// This only applies to expression and pattern paths, and
-    /// out of those only the segments with no type parameters
-    /// to begin with, e.g., `Vec::new` is `<Vec<..>>::new::<..>`.
-    pub infer_args: bool,
+    pub flags: PathFlags,
+}
+
+bitflags::bitflags! {
+    #[derive(Debug, Clone, Copy)]
+    pub struct PathFlags: u8 {
+        /// Whether to infer remaining type parameters, if any.
+        /// This only applies to expression and pattern paths, and
+        /// out of those only the segments with no type parameters
+        /// to begin with, e.g., `Vec::new` is `<Vec<..>>::new::<..>`.
+        const INFER_ARGS = 1 << 0;
+
+        /// Whether this path is an implicit `Self` type path.
+        const IMPLICIT_SELF = 1 << 1;
+    }
+}
+
+impl<CTX> HashStable<CTX> for PathFlags {
+    fn hash_stable(
+        &self,
+        hcx: &mut CTX,
+        hasher: &mut rustc_data_structures::stable_hasher::StableHasher,
+    ) {
+        self.bits().hash_stable(hcx, hasher)
+    }
 }
 
 impl<'hir> PathSegment<'hir> {
     /// Converts an identifier to the corresponding segment.
     pub fn new(ident: Ident, hir_id: HirId, res: Res) -> PathSegment<'hir> {
-        PathSegment { ident, hir_id, res, infer_args: true, args: None }
+        PathSegment { ident, hir_id, res, flags: PathFlags::INFER_ARGS, args: None }
     }
 
     pub fn invalid() -> Self {
@@ -399,6 +420,14 @@ impl<'hir> PathSegment<'hir> {
             DUMMY
         }
     }
+
+    pub fn infer_args(&self) -> bool {
+        self.flags.contains(PathFlags::INFER_ARGS)
+    }
+
+    pub fn implicit_self(&self) -> bool {
+        self.flags.contains(PathFlags::IMPLICIT_SELF)
+    }
 }
 
 /// A constant that enters the type system, used for arguments to const generics (e.g. array lengths).

compiler/rustc_hir/src/intravisit.rs

@@ -1427,7 +1427,7 @@ pub fn walk_path_segment<'v, V: Visitor<'v>>(
     visitor: &mut V,
     segment: &'v PathSegment<'v>,
 ) -> V::Result {
-    let PathSegment { ident, hir_id, res: _, args, infer_args: _ } = segment;
+    let PathSegment { ident, hir_id, res: _, args, flags: _ } = segment;
     try_visit!(visitor.visit_ident(*ident));
     try_visit!(visitor.visit_id(*hir_id));
     visit_opt!(visitor, visit_generic_args, *args);

compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs

@@ -6,7 +6,7 @@ use rustc_errors::struct_span_code_err;
 use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::{CRATE_DEF_ID, DefId, LocalDefId};
-use rustc_hir::{AmbigArg, PolyTraitRef};
+use rustc_hir::{AmbigArg, PathFlags, PolyTraitRef};
 use rustc_middle::bug;
 use rustc_middle::ty::{
     self as ty, IsSuggestable, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable, TypeVisitableExt,
@@ -602,7 +602,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                     hir_id: constraint.hir_id,
                     res: Res::Err,
                     args: Some(constraint.gen_args),
-                    infer_args: false,
+                    flags: PathFlags::empty(),
                 };
 
                 let alias_args = self.lower_generic_args_of_assoc_item(

compiler/rustc_hir_analysis/src/hir_ty_lowering/generics.rs

@@ -427,8 +427,8 @@ pub(crate) fn check_generic_arg_count(
         })
         .count();
     let named_const_param_count = param_counts.consts - synth_const_param_count;
-    let infer_lifetimes =
-        (gen_pos != GenericArgPosition::Type || seg.infer_args) && !gen_args.has_lifetime_params();
+    let infer_lifetimes = (gen_pos != GenericArgPosition::Type || seg.infer_args())
+        && !gen_args.has_lifetime_params();
 
     if gen_pos != GenericArgPosition::Type
         && let Some(c) = gen_args.constraints.first()
@@ -577,7 +577,7 @@ pub(crate) fn check_generic_arg_count(
     };
 
     let args_correct = {
-        let expected_min = if seg.infer_args {
+        let expected_min = if seg.infer_args() {
             0
         } else {
             param_counts.consts + named_type_param_count

compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs

@@ -670,7 +670,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             def_id,
             span,
             generic_args: segment.args(),
-            infer_args: segment.infer_args,
+            infer_args: segment.infer_args(),
             incorrect_args: &arg_count.correct,
         };
         let args = lower_generic_args(

compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs

@@ -1238,10 +1238,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     if !self.infer_args_for_err.contains(&index) {
                         // Check whether the user has provided generic arguments.
                         if let Some(data) = self.segments[index].args {
-                            return (Some(data), self.segments[index].infer_args);
+                            return (Some(data), self.segments[index].infer_args());
                         }
                     }
-                    return (None, self.segments[index].infer_args);
+                    return (None, self.segments[index].infer_args());
                 }
 
                 (None, true)

compiler/rustc_lint/messages.ftl

@@ -292,7 +292,11 @@ lint_hidden_glob_reexport = private item shadows public glob re-export
     .note_glob_reexport = the name `{$name}` in the {$namespace} namespace is supposed to be publicly re-exported here
     .note_private_item = but the private item here shadows it
 
-lint_hidden_lifetime_parameters = hidden lifetime parameters in types are deprecated
+lint_hidden_lifetime_in_path =
+    paths containing hidden lifetime parameters are deprecated
+
+lint_hidden_lifetime_in_path_suggestion =
+    indicate the anonymous lifetime
 
 lint_hidden_unicode_codepoints = unicode codepoint changing visible direction of text present in {$label}
     .label = this {$label} contains {$count ->

compiler/rustc_lint/src/context.rs

@@ -288,6 +288,26 @@ impl LintStore {
         self.by_name.insert(old_name.to_string(), Renamed(new_name.to_string(), target));
     }
 
+    #[track_caller]
+    pub fn register_renamed_group(&mut self, old_name: &'static str, new_name: &'static str) {
+        let prev_lint = self.lint_groups.insert(
+            old_name,
+            LintGroup {
+                lint_ids: vec![],
+                is_externally_loaded: false,
+                depr: Some(LintAlias { name: new_name, silent: false }),
+            },
+        );
+
+        if prev_lint.is_some() {
+            bug!("The lint group {old_name} has already been registered");
+        }
+
+        if !self.lint_groups.contains_key(new_name) {
+            bug!("The lint group {new_name} has not been registered");
+        }
+    }
+
     pub fn register_removed(&mut self, name: &str, reason: &str) {
         self.by_name.insert(name.into(), Removed(reason.into()));
     }

compiler/rustc_lint/src/early/diagnostics.rs

@@ -1,9 +1,7 @@
 use std::borrow::Cow;
 
 use rustc_ast::util::unicode::TEXT_FLOW_CONTROL_CHARS;
-use rustc_errors::{
-    Applicability, Diag, DiagArgValue, LintDiagnostic, elided_lifetime_in_path_suggestion,
-};
+use rustc_errors::{Applicability, Diag, DiagArgValue, LintDiagnostic};
 use rustc_middle::middle::stability;
 use rustc_middle::ty::TyCtxt;
 use rustc_session::Session;
@@ -72,19 +70,6 @@ pub fn decorate_builtin_lint(
             lints::MacroExpandedMacroExportsAccessedByAbsolutePaths { definition: span_def }
                 .decorate_lint(diag)
         }
-
-        BuiltinLintDiag::ElidedLifetimesInPaths(n, path_span, incl_angl_brckt, insertion_span) => {
-            lints::ElidedLifetimesInPaths {
-                subdiag: elided_lifetime_in_path_suggestion(
-                    sess.source_map(),
-                    n,
-                    path_span,
-                    incl_angl_brckt,
-                    insertion_span,
-                ),
-            }
-            .decorate_lint(diag);
-        }
         BuiltinLintDiag::UnknownCrateTypes { span, candidate } => {
             let sugg = candidate.map(|candidate| lints::UnknownCrateTypesSub { span, candidate });
             lints::UnknownCrateTypes { sugg }.decorate_lint(diag);