Replace elided_lifetime_in_paths with multiple renamed lints

Removing the `issue-91763` test as the implementation is completely
different now.

Bootstrap forces `rust_2018_idioms` to the warning level in the
rustc_lint doctests using `-Zcrate-attr`. This overrides the doctest's
crate-level `deny` attributes, so I've changed those to be
statement-level attributes.

Author: shepmaster

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_lint/messages.ftl

@@ -293,8 +293,6 @@ lint_hidden_lifetime_in_path =
 lint_hidden_lifetime_in_path_suggestion =
     indicate the anonymous lifetime
 
-lint_hidden_lifetime_parameters = hidden lifetime parameters in types are deprecated
-
 lint_hidden_unicode_codepoints = unicode codepoint changing visible direction of text present in {$label}
     .label = this {$label} contains {$count ->
         [one] an invisible

compiler/rustc_lint/src/early/diagnostics.rs

@@ -4,9 +4,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;
@@ -75,19 +73,6 @@ pub(super) fn decorate_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);

compiler/rustc_lint/src/lib.rs

@@ -319,7 +319,9 @@ fn register_builtins(store: &mut LintStore) {
         BARE_TRAIT_OBJECTS,
         UNUSED_EXTERN_CRATES,
         ELLIPSIS_INCLUSIVE_RANGE_PATTERNS,
-        ELIDED_LIFETIMES_IN_PATHS,
+        HIDDEN_LIFETIMES_IN_OUTPUT_PATHS,
+        HIDDEN_LIFETIMES_IN_INPUT_PATHS,
+        HIDDEN_LIFETIMES_IN_TYPE_PATHS,
         EXPLICIT_OUTLIVES_REQUIREMENTS,
         // FIXME(#52665, #47816) not always applicable and not all
         // macros are ready for this yet.
@@ -339,9 +341,15 @@ fn register_builtins(store: &mut LintStore) {
 
     add_lint_group!("deprecated_safe", DEPRECATED_SAFE_2024);
 
+    add_lint_group!(
+        "hidden_lifetimes_in_paths",
+        HIDDEN_LIFETIMES_IN_OUTPUT_PATHS,
+        HIDDEN_LIFETIMES_IN_INPUT_PATHS,
+        HIDDEN_LIFETIMES_IN_TYPE_PATHS,
+    );
+
     // Register renamed and removed lints.
     store.register_renamed("single_use_lifetime", "single_use_lifetimes");
-    store.register_renamed("elided_lifetime_in_path", "elided_lifetimes_in_paths");
     store.register_renamed("bare_trait_object", "bare_trait_objects");
     store.register_renamed("unstable_name_collision", "unstable_name_collisions");
     store.register_renamed("unused_doc_comment", "unused_doc_comments");
@@ -357,6 +365,10 @@ fn register_builtins(store: &mut LintStore) {
     store.register_renamed("temporary_cstring_as_ptr", "dangling_pointers_from_temporaries");
     store.register_renamed("elided_named_lifetimes", "mismatched_lifetime_syntaxes");
 
+    // Register renamed lint groups
+    store.register_renamed_group("elided_lifetime_in_path", "hidden_lifetimes_in_paths");
+    store.register_renamed_group("elided_lifetimes_in_paths", "hidden_lifetimes_in_paths");
+
     // These were moved to tool lints, but rustc still sees them when compiling normally, before
     // tool lints are registered, so `check_tool_name_for_backwards_compat` doesn't work. Use
     // `register_removed` explicitly.

compiler/rustc_lint/src/lifetime_style.rs

@@ -70,17 +70,16 @@ declare_lint! {
 }
 
 declare_lint! {
-    /// The `hidden_lifetimes_in_input_paths2` lint detects the use of
+    /// The `hidden_lifetimes_in_input_paths` lint detects the use of
     /// hidden lifetime parameters in types occurring as a function
     /// argument.
     ///
     /// ### Example
     ///
     /// ```rust,compile_fail
-    /// #![deny(hidden_lifetimes_in_input_paths2)]
-    ///
     /// struct ContainsLifetime<'a>(&'a i32);
     ///
+    /// #[deny(hidden_lifetimes_in_input_paths)]
     /// fn foo(x: ContainsLifetime) {}
     /// ```
     ///
@@ -99,23 +98,22 @@ declare_lint! {
     /// themselves do not usually cause much confusion.
     ///
     /// [placeholder lifetime]: https://doc.rust-lang.org/reference/lifetime-elision.html#lifetime-elision-in-functions
-    pub HIDDEN_LIFETIMES_IN_INPUT_PATHS2,
+    pub HIDDEN_LIFETIMES_IN_INPUT_PATHS,
     Allow,
     "hidden lifetime parameters in types in function arguments may be confusing"
 }
 
 declare_lint! {
-    /// The `hidden_lifetimes_in_output_paths2` lint detects the use
+    /// The `hidden_lifetimes_in_output_paths` lint detects the use
     /// of hidden lifetime parameters in types occurring as a function
     /// return value.
     ///
     /// ### Example
     ///
     /// ```rust,compile_fail
-    /// #![deny(hidden_lifetimes_in_output_paths2)]
-    ///
     /// struct ContainsLifetime<'a>(&'a i32);
     ///
+    /// #[deny(hidden_lifetimes_in_output_paths)]
     /// fn foo(x: &i32) -> ContainsLifetime {
     ///     ContainsLifetime(x)
     /// }
@@ -137,15 +135,15 @@ declare_lint! {
     /// lifetime].
     ///
     /// [placeholder lifetime]: https://doc.rust-lang.org/reference/lifetime-elision.html#lifetime-elision-in-functions
-    pub HIDDEN_LIFETIMES_IN_OUTPUT_PATHS2,
+    pub HIDDEN_LIFETIMES_IN_OUTPUT_PATHS,
     Allow,
     "hidden lifetime parameters in types in function return values are deprecated"
 }
 
 declare_lint_pass!(LifetimeStyle => [
     MISMATCHED_LIFETIME_SYNTAXES,
-    HIDDEN_LIFETIMES_IN_INPUT_PATHS2,
-    HIDDEN_LIFETIMES_IN_OUTPUT_PATHS2,
+    HIDDEN_LIFETIMES_IN_INPUT_PATHS,
+    HIDDEN_LIFETIMES_IN_OUTPUT_PATHS,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for LifetimeStyle {
@@ -171,8 +169,8 @@ impl<'tcx> LateLintPass<'tcx> for LifetimeStyle {
         }
 
         report_mismatches(cx, &input_map, &output_map);
-        report_hidden_in_paths(cx, &input_map, HIDDEN_LIFETIMES_IN_INPUT_PATHS2);
-        report_hidden_in_paths(cx, &output_map, HIDDEN_LIFETIMES_IN_OUTPUT_PATHS2);
+        report_hidden_in_paths(cx, &input_map, HIDDEN_LIFETIMES_IN_INPUT_PATHS);
+        report_hidden_in_paths(cx, &output_map, HIDDEN_LIFETIMES_IN_OUTPUT_PATHS);
     }
 }
 
@@ -427,17 +425,16 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeInfoCollector<'a, 'tcx> {
 }
 
 declare_lint! {
-    /// The `hidden_lifetimes_in_type_paths2` lint detects the use of
+    /// The `hidden_lifetimes_in_type_paths` lint detects the use of
     /// hidden lifetime parameters in types not part of a function's
     /// arguments or return values.
     ///
     /// ### Example
     ///
     /// ```rust,compile_fail
-    /// #![deny(hidden_lifetimes_in_type_paths2)]
-    ///
     /// struct ContainsLifetime<'a>(&'a i32);
     ///
+    /// #[deny(hidden_lifetimes_in_type_paths)]
     /// static FOO: ContainsLifetime = ContainsLifetime(&42);
     /// ```
     ///
@@ -453,7 +450,7 @@ declare_lint! {
     /// lifetime].
     ///
     /// [placeholder lifetime]: https://doc.rust-lang.org/reference/lifetime-elision.html#lifetime-elision-in-functions
-    pub HIDDEN_LIFETIMES_IN_TYPE_PATHS2,
+    pub HIDDEN_LIFETIMES_IN_TYPE_PATHS,
     Allow,
     "hidden lifetime parameters in types outside function signatures are discouraged"
 }
@@ -463,7 +460,7 @@ pub(crate) struct HiddenLifetimesInTypePaths {
     inside_fn_signature: bool,
 }
 
-impl_lint_pass!(HiddenLifetimesInTypePaths => [HIDDEN_LIFETIMES_IN_TYPE_PATHS2]);
+impl_lint_pass!(HiddenLifetimesInTypePaths => [HIDDEN_LIFETIMES_IN_TYPE_PATHS]);
 
 impl<'tcx> LateLintPass<'tcx> for HiddenLifetimesInTypePaths {
     #[instrument(skip(self, cx))]
@@ -506,7 +503,7 @@ impl<'tcx> LateLintPass<'tcx> for HiddenLifetimesInTypePaths {
         }
 
         cx.emit_span_lint(
-            HIDDEN_LIFETIMES_IN_TYPE_PATHS2,
+            HIDDEN_LIFETIMES_IN_TYPE_PATHS,
             ty.span,
             lints::HiddenLifetimeInPath {
                 suggestions: lints::HiddenLifetimeInPathSuggestion { suggestions },

compiler/rustc_lint/src/lints.rs

@@ -5,8 +5,8 @@ use std::num::NonZero;
 use rustc_abi::ExternAbi;
 use rustc_errors::codes::*;
 use rustc_errors::{
-    Applicability, Diag, DiagArgValue, DiagMessage, DiagStyledString, ElidedLifetimeInPathSubdiag,
-    EmissionGuarantee, LintDiagnostic, MultiSpan, Subdiagnostic, SuggestionStyle,
+    Applicability, Diag, DiagArgValue, DiagMessage, DiagStyledString, EmissionGuarantee,
+    LintDiagnostic, MultiSpan, Subdiagnostic, SuggestionStyle,
 };
 use rustc_hir as hir;
 use rustc_hir::def::Namespace;
@@ -2646,13 +2646,6 @@ pub(crate) struct MacroExpandedMacroExportsAccessedByAbsolutePaths {
     pub definition: Span,
 }
 
-#[derive(LintDiagnostic)]
-#[diag(lint_hidden_lifetime_parameters)]
-pub(crate) struct ElidedLifetimesInPaths {
-    #[subdiagnostic]
-    pub subdiag: ElidedLifetimeInPathSubdiag,
-}
-
 #[derive(LintDiagnostic)]
 #[diag(lint_invalid_crate_type_value)]
 pub(crate) struct UnknownCrateTypes {

compiler/rustc_lint_defs/src/builtin.rs

@@ -39,7 +39,6 @@ declare_lint_pass! {
         DEPRECATED_WHERE_CLAUSE_LOCATION,
         DUPLICATE_MACRO_ATTRIBUTES,
         ELIDED_LIFETIMES_IN_ASSOCIATED_CONSTANT,
-        ELIDED_LIFETIMES_IN_PATHS,
         EXPLICIT_BUILTIN_CFGS_IN_FLAGS,
         EXPORTED_PRIVATE_DEPENDENCIES,
         FFI_UNWIND_CALLS,
@@ -1792,41 +1791,6 @@ declare_lint! {
     };
 }
 
-declare_lint! {
-    /// The `elided_lifetimes_in_paths` lint detects the use of hidden
-    /// lifetime parameters.
-    ///
-    /// ### Example
-    ///
-    /// ```rust,compile_fail
-    /// #![deny(elided_lifetimes_in_paths)]
-    /// #![deny(warnings)]
-    /// struct Foo<'a> {
-    ///     x: &'a u32
-    /// }
-    ///
-    /// fn foo(x: &Foo) {
-    /// }
-    /// ```
-    ///
-    /// {{produces}}
-    ///
-    /// ### Explanation
-    ///
-    /// Elided lifetime parameters can make it difficult to see at a glance
-    /// that borrowing is occurring. This lint ensures that lifetime
-    /// parameters are always explicitly stated, even if it is the `'_`
-    /// [placeholder lifetime].
-    ///
-    /// This lint is "allow" by default because it has some known issues, and
-    /// may require a significant transition for old code.
-    ///
-    /// [placeholder lifetime]: https://doc.rust-lang.org/reference/lifetime-elision.html#lifetime-elision-in-functions
-    pub ELIDED_LIFETIMES_IN_PATHS,
-    Allow,
-    "hidden lifetime parameters in types are deprecated"
-}
-
 declare_lint! {
     /// The `bare_trait_objects` lint suggests using `dyn Trait` for trait
     /// objects.

compiler/rustc_lint_defs/src/lib.rs

@@ -645,7 +645,6 @@ pub enum BuiltinLintDiag {
         ident: Ident,
     },
     MacroExpandedMacroExportsAccessedByAbsolutePaths(Span),
-    ElidedLifetimesInPaths(usize, Span, bool, Span),
     UnknownCrateTypes {
         span: Span,
         candidate: Option<Symbol>,

compiler/rustc_resolve/src/late.rs

@@ -2072,7 +2072,6 @@ impl<'a, 'ast, 'ra: 'ast, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                 kind,
                 count: expected_lifetimes,
             };
-            let mut should_lint = true;
             for rib in self.lifetime_ribs.iter().rev() {
                 match rib.kind {
                     // In create-parameter mode we error here because we don't want to support
@@ -2095,7 +2094,6 @@ impl<'a, 'ast, 'ra: 'ast, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                             span: path_span,
                             subdiag,
                         });
-                        should_lint = false;
 
                         for id in node_ids {
                             self.record_lifetime_res(
@@ -2164,20 +2162,6 @@ impl<'a, 'ast, 'ra: 'ast, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                     }
                 }
             }
-
-            if should_lint {
-                self.r.lint_buffer.buffer_lint(
-                    lint::builtin::ELIDED_LIFETIMES_IN_PATHS,
-                    segment_id,
-                    elided_lifetime_span,
-                    lint::BuiltinLintDiag::ElidedLifetimesInPaths(
-                        expected_lifetimes,
-                        path_span,
-                        !segment.has_generic_args,
-                        elided_lifetime_span,
-                    ),
-                );
-            }
         }
     }
 

src/tools/lint-docs/src/groups.rs

@@ -12,6 +12,7 @@ static GROUP_DESCRIPTIONS: &[(&str, &str)] = &[
     ("let-underscore", "Lints that detect wildcard let bindings that are likely to be invalid"),
     ("rustdoc", "Rustdoc-specific lints"),
     ("rust-2018-idioms", "Lints to nudge you toward idiomatic features of Rust 2018"),
+    ("hidden-lifetimes-in-paths", "Lints that detect the use of hidden lifetime parameters"),
     ("nonstandard-style", "Violation of standard naming conventions"),
     ("future-incompatible", "Lints that detect code that has future-compatibility problems"),
     ("rust-2018-compatibility", "Lints used to transition code from the 2015 edition to 2018"),

src/tools/lint-docs/src/lib.rs

@@ -23,7 +23,7 @@ static RENAMES: &[(Level, &[(&str, &str)])] = &[
         Level::Allow,
         &[
             ("single-use-lifetime", "single-use-lifetimes"),
-            ("elided-lifetime-in-path", "elided-lifetimes-in-paths"),
+            ("elided-lifetime-in-path", "hidden-lifetimes-in-paths"),
             ("async-idents", "keyword-idents"),
             ("disjoint-capture-migration", "rust-2021-incompatible-closure-captures"),
             ("keyword-idents", "keyword-idents-2018"),

src/tools/tidy/src/issues.txt

@@ -2637,7 +2637,6 @@ ui/let-else/issue-100103.rs
 ui/let-else/issue-102317.rs
 ui/let-else/issue-94176.rs
 ui/let-else/issue-99975.rs
-ui/lifetimes/auxiliary/issue-91763-aux.rs
 ui/lifetimes/issue-103582-hint-for-missing-lifetime-bound-on-trait-object-using-type-alias.rs
 ui/lifetimes/issue-104432-unused-lifetimes-in-expansion.rs
 ui/lifetimes/issue-105227.rs
@@ -2670,7 +2669,6 @@ ui/lifetimes/issue-84398.rs
 ui/lifetimes/issue-84604.rs
 ui/lifetimes/issue-90170-elision-mismatch.rs
 ui/lifetimes/issue-90600-expected-return-static-indirect.rs
-ui/lifetimes/issue-91763.rs
 ui/lifetimes/issue-93911.rs
 ui/lifetimes/issue-95023.rs
 ui/lifetimes/issue-97193.rs