Lower lifetime resolution failures that are suppressed by Rustdoc

Rather than emit errors in cases that were previously suppressed by
Rustdoc, we lower such name resolution failures to a new
`RustdocSuppressedError` variant.

Author: eggyal

compiler/rustc_ast_lowering/src/lib.rs

@@ -1952,6 +1952,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     assert!(matches!(ident.name, kw::StaticLifetime | kw::UnderscoreLifetime));
                     hir::LifetimeKind::Static
                 }
+                LifetimeRes::RustdocSuppressedError => hir::LifetimeKind::RustdocSuppressedError,
                 LifetimeRes::Error(guar) => hir::LifetimeKind::Error(guar),
                 LifetimeRes::ElidedAnchor { .. } => {
                     panic!("Unexpected `ElidedAnchar` {:?} at {:?}", ident, ident.span);

compiler/rustc_hir/src/def.rs

@@ -989,6 +989,8 @@ pub enum LifetimeRes {
     Infer,
     /// `'static` lifetime.
     Static,
+    /// A resolution failure that is ignored by Rustdoc.
+    RustdocSuppressedError,
     /// Resolution failure.
     Error(rustc_span::ErrorGuaranteed),
     /// HACK: This is used to recover the NodeId of an elided lifetime.

compiler/rustc_hir/src/hir.rs

@@ -236,6 +236,9 @@ pub enum LifetimeKind {
     /// parameter.
     ImplicitObjectLifetimeDefault,
 
+    /// Indicates an error during lowering that was suppressed by rustdoc.
+    RustdocSuppressedError,
+
     /// Indicates an error during lowering (usually `'_` in wrong place)
     /// that was already reported.
     Error(ErrorGuaranteed),
@@ -258,7 +261,10 @@ impl LifetimeKind {
             // -- but this is because, as far as the code in the compiler is
             // concerned -- `Fresh` variants act equivalently to "some fresh name".
             // They correspond to early-bound regions on an impl, in other words.
-            LifetimeKind::Error(..) | LifetimeKind::Param(..) | LifetimeKind::Static => false,
+            LifetimeKind::RustdocSuppressedError
+            | LifetimeKind::Error(..)
+            | LifetimeKind::Param(..)
+            | LifetimeKind::Static => false,
         }
     }
 }

compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs

@@ -663,7 +663,7 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {
                 LifetimeKind::Param(def_id) => {
                     self.resolve_lifetime_ref(def_id, lt);
                 }
-                LifetimeKind::Error(..) => {}
+                LifetimeKind::RustdocSuppressedError | LifetimeKind::Error(..) => {}
                 LifetimeKind::ImplicitObjectLifetimeDefault
                 | LifetimeKind::Infer
                 | LifetimeKind::Static => {
@@ -804,7 +804,7 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {
                         // If the user wrote an explicit name, use that.
                         self.visit_lifetime(&*lifetime);
                     }
-                    LifetimeKind::Error(..) => {}
+                    LifetimeKind::RustdocSuppressedError | LifetimeKind::Error(..) => {}
                 }
             }
             hir::TyKind::Ref(lifetime_ref, ref mt) => {
@@ -891,6 +891,8 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {
             hir::LifetimeKind::Param(param_def_id) => {
                 self.resolve_lifetime_ref(param_def_id, lifetime_ref)
             }
+            // Just ignore `lifetime_ref` if it couldn't be resolved
+            hir::LifetimeKind::RustdocSuppressedError => {}
             // Keep track of lifetimes about which errors have already been reported
             hir::LifetimeKind::Error(guar) => {
                 self.insert_lifetime(lifetime_ref, ResolvedArg::Error(guar))

compiler/rustc_resolve/src/late.rs

@@ -2342,7 +2342,10 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                     candidates.push((res, candidate));
                 }
             }
-            LifetimeRes::Infer | LifetimeRes::Error(..) | LifetimeRes::ElidedAnchor { .. } => {}
+            LifetimeRes::Infer
+            | LifetimeRes::RustdocSuppressedError
+            | LifetimeRes::Error(..)
+            | LifetimeRes::ElidedAnchor { .. } => {}
         }
     }
 
@@ -3068,11 +3071,17 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                     Entry::Occupied(entry) => {
                         let span = *entry.get();
                         let err = ResolutionError::NameAlreadyUsedInParameterList(ident, span);
-                        let guar = self.r.report_error(param.ident.span, err);
+                        let guar = self.report_error(param.ident.span, err);
                         let rib = match param.kind {
                             GenericParamKind::Lifetime => {
                                 // Record lifetime res, so lowering knows there is something fishy.
-                                self.record_lifetime_param(param.id, LifetimeRes::Error(guar));
+                                self.record_lifetime_param(
+                                    param.id,
+                                    guar.map_or(
+                                        LifetimeRes::RustdocSuppressedError,
+                                        LifetimeRes::Error,
+                                    ),
+                                );
                                 continue;
                             }
                             GenericParamKind::Type { .. } => &mut function_type_rib,
@@ -4701,10 +4710,12 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
     /// A wrapper around [`Resolver::report_error`].
     ///
     /// This doesn't emit errors for function bodies if this is rustdoc.
-    fn report_error(&mut self, span: Span, resolution_error: ResolutionError<'ra>) {
-        if self.should_report_errs() {
-            self.r.report_error(span, resolution_error);
-        }
+    fn report_error(
+        &mut self,
+        span: Span,
+        resolution_error: ResolutionError<'ra>,
+    ) -> Option<ErrorGuaranteed> {
+        self.should_report_errs().then(|| self.r.report_error(span, resolution_error))
     }
 
     #[inline]