Preemptively fetch the typeck results when linting bodies.

Author: Jarcho

compiler/rustc_lint/src/context.rs

@@ -3,7 +3,6 @@
 //! See <https://rustc-dev-guide.rust-lang.org/diagnostics.html> for an
 //! overview of how lints are implemented.
 
-use std::cell::Cell;
 use std::slice;
 
 use rustc_abi as abi;
@@ -484,11 +483,8 @@ pub struct LateContext<'tcx> {
     /// Current body, or `None` if outside a body.
     pub enclosing_body: Option<hir::BodyId>,
 
-    /// Type-checking results for the current body. Access using the `typeck_results`
-    /// and `maybe_typeck_results` methods, which handle querying the typeck results on demand.
-    // FIXME(eddyb) move all the code accessing internal fields like this,
-    // to this module, to avoid exposing it to lint logic.
-    pub(super) cached_typeck_results: Cell<Option<&'tcx ty::TypeckResults<'tcx>>>,
+    /// Type-checking results for the current body.
+    pub typeck_results: Option<&'tcx ty::TypeckResults<'tcx>>,
 
     /// Parameter environment for the item we are in.
     pub param_env: ty::ParamEnv<'tcx>,
@@ -666,21 +662,15 @@ impl<'tcx> LateContext<'tcx> {
     /// Gets the type-checking results for the current body,
     /// or `None` if outside a body.
     pub fn maybe_typeck_results(&self) -> Option<&'tcx ty::TypeckResults<'tcx>> {
-        self.cached_typeck_results.get().or_else(|| {
-            self.enclosing_body.map(|body| {
-                let typeck_results = self.tcx.typeck_body(body);
-                self.cached_typeck_results.set(Some(typeck_results));
-                typeck_results
-            })
-        })
+        self.typeck_results
     }
 
     /// Gets the type-checking results for the current body.
     /// As this will ICE if called outside bodies, only call when working with
     /// `Expr` or `Pat` nodes (they are guaranteed to be found only in bodies).
     #[track_caller]
     pub fn typeck_results(&self) -> &'tcx ty::TypeckResults<'tcx> {
-        self.maybe_typeck_results().expect("`LateContext::typeck_results` called outside of body")
+        self.typeck_results.expect("`LateContext::typeck_results` called outside of body")
     }
 
     /// Returns the final resolution of a `QPath`, or `Res::Err` if unavailable.

compiler/rustc_lint/src/late.rs

@@ -4,7 +4,6 @@
 //! borrow checking, etc.). These lints have full type information available.
 
 use std::any::Any;
-use std::cell::Cell;
 
 use rustc_data_structures::stack::ensure_sufficient_stack;
 use rustc_data_structures::sync::par_join;
@@ -17,6 +16,7 @@ use rustc_session::lint::LintPass;
 use rustc_span::Span;
 use tracing::debug;
 
+use crate::builtin::MissingDoc;
 use crate::passes::LateLintPassObject;
 use crate::{LateContext, LateLintPass, LintStore, is_lint_pass_required};
 
@@ -34,12 +34,16 @@ macro_rules! lint_callback { ($cx:expr, $f:ident, $($args:expr),*) => ({
 
 /// Implements the AST traversal for late lint passes. `T` provides the
 /// `check_*` methods.
-struct LateContextAndPass<'tcx, T: LateLintPass<'tcx>> {
+///
+/// `TYPECK_BODY` determines whether we fetch typeck results while walking the HIR tree.
+/// When set to `false` we do not ever assign to the `typeck_results` field during the
+/// tree walk. See [`lint_missing_docs`] for why this exists.
+struct LateContextAndPass<'tcx, T: LateLintPass<'tcx>, const TYPECK_BODY: bool> {
     context: LateContext<'tcx>,
     pass: T,
 }
 
-impl<'tcx, T: LateLintPass<'tcx>> LateContextAndPass<'tcx, T> {
+impl<'tcx, T: LateLintPass<'tcx>, const TYPECK_BODY: bool> LateContextAndPass<'tcx, T, TYPECK_BODY> {
     /// Merge the lints specified by any lint attributes into the
     /// current lint context, call the provided function, then reset the
     /// lints in effect to their previous state.
@@ -77,7 +81,9 @@ impl<'tcx, T: LateLintPass<'tcx>> LateContextAndPass<'tcx, T> {
     }
 }
 
-impl<'tcx, T: LateLintPass<'tcx>> hir_visit::Visitor<'tcx> for LateContextAndPass<'tcx, T> {
+impl<'tcx, T: LateLintPass<'tcx>, const TYPECK_BODY: bool> hir_visit::Visitor<'tcx>
+    for LateContextAndPass<'tcx, T, TYPECK_BODY>
+{
     type NestedFilter = nested_filter::All;
 
     /// Because lints are scoped lexically, we want to walk nested
@@ -89,22 +95,19 @@ impl<'tcx, T: LateLintPass<'tcx>> hir_visit::Visitor<'tcx> for LateContextAndPas
 
     fn visit_nested_body(&mut self, body_id: hir::BodyId) {
         let old_enclosing_body = self.context.enclosing_body.replace(body_id);
-        let old_cached_typeck_results = self.context.cached_typeck_results.get();
+        let old_typeck_results = self.context.typeck_results;
 
-        // HACK(eddyb) avoid trashing `cached_typeck_results` when we're
-        // nested in `visit_fn`, which may have already resulted in them
-        // being queried.
-        if old_enclosing_body != Some(body_id) {
-            self.context.cached_typeck_results.set(None);
+        // The body and typeck results are also set in `visit_fn`.
+        // Only fetch the results if this is for a new body.
+        if TYPECK_BODY && old_enclosing_body != Some(body_id) {
+            self.context.typeck_results = Some(self.context.tcx.typeck_body(body_id));
         }
 
         let body = self.context.tcx.hir_body(body_id);
         self.visit_body(body);
         self.context.enclosing_body = old_enclosing_body;
-
-        // See HACK comment above.
-        if old_enclosing_body != Some(body_id) {
-            self.context.cached_typeck_results.set(old_cached_typeck_results);
+        if TYPECK_BODY {
+            self.context.typeck_results = old_typeck_results;
         }
     }
 
@@ -123,7 +126,10 @@ impl<'tcx, T: LateLintPass<'tcx>> hir_visit::Visitor<'tcx> for LateContextAndPas
     fn visit_item(&mut self, it: &'tcx hir::Item<'tcx>) {
         let generics = self.context.generics.take();
         self.context.generics = it.kind.generics();
-        let old_cached_typeck_results = self.context.cached_typeck_results.take();
+        let old_typeck_results = self.context.typeck_results;
+        if TYPECK_BODY {
+            self.context.typeck_results = None;
+        }
         let old_enclosing_body = self.context.enclosing_body.take();
         self.with_lint_attrs(it.hir_id(), |cx| {
             cx.with_param_env(it.owner_id, |cx| {
@@ -133,7 +139,9 @@ impl<'tcx, T: LateLintPass<'tcx>> hir_visit::Visitor<'tcx> for LateContextAndPas
             });
         });
         self.context.enclosing_body = old_enclosing_body;
-        self.context.cached_typeck_results.set(old_cached_typeck_results);
+        if TYPECK_BODY {
+            self.context.typeck_results = old_typeck_results;
+        }
         self.context.generics = generics;
     }
 
@@ -189,12 +197,17 @@ impl<'tcx, T: LateLintPass<'tcx>> hir_visit::Visitor<'tcx> for LateContextAndPas
         // Wrap in typeck results here, not just in visit_nested_body,
         // in order for `check_fn` to be able to use them.
         let old_enclosing_body = self.context.enclosing_body.replace(body_id);
-        let old_cached_typeck_results = self.context.cached_typeck_results.take();
+        let old_typeck_results = self.context.typeck_results;
+        if TYPECK_BODY {
+            self.context.typeck_results = Some(self.context.tcx.typeck_body(body_id));
+        }
         let body = self.context.tcx.hir_body(body_id);
         lint_callback!(self, check_fn, fk, decl, body, span, id);
         hir_visit::walk_fn(self, fk, decl, body_id, id);
         self.context.enclosing_body = old_enclosing_body;
-        self.context.cached_typeck_results.set(old_cached_typeck_results);
+        if TYPECK_BODY {
+            self.context.typeck_results = old_typeck_results;
+        }
     }
 
     fn visit_variant_data(&mut self, s: &'tcx hir::VariantData<'tcx>) {
@@ -333,6 +346,27 @@ macro_rules! impl_late_lint_pass {
 
 crate::late_lint_methods!(impl_late_lint_pass, []);
 
+/// Runs only the `MissingDoc` lint pass without type checking bodies.
+///
+/// **DO NOT** use this for anything other than rustdoc. This exists solely to workaround
+/// the fact that rustdoc parses functions which would not pass type checking. See:
+/// <https://github.com/rust-lang/rust/pull/73566>.
+pub fn lint_missing_docs<'tcx>(tcx: TyCtxt<'tcx>, mod_id: LocalModId) {
+    if is_lint_pass_required(tcx.skippable_lints(()), &MissingDoc.get_lints()) {
+        let context = LateContext {
+            tcx,
+            enclosing_body: None,
+            typeck_results: None,
+            param_env: ty::ParamEnv::empty(),
+            effective_visibilities: tcx.effective_visibilities(()),
+            last_node_with_lint_attrs: tcx.local_def_id_to_hir_id(mod_id),
+            generics: None,
+            only_module: true,
+        };
+        late_lint_mod_inner::<'_, _, false>(tcx, mod_id, context, MissingDoc);
+    }
+}
+
 pub fn late_lint_mod<'tcx, T: LateLintPass<'tcx> + 'tcx>(
     tcx: TyCtxt<'tcx>,
     mod_id: LocalModId,
@@ -341,7 +375,7 @@ pub fn late_lint_mod<'tcx, T: LateLintPass<'tcx> + 'tcx>(
     let context = LateContext {
         tcx,
         enclosing_body: None,
-        cached_typeck_results: Cell::new(None),
+        typeck_results: None,
         param_env: ty::ParamEnv::empty(),
         effective_visibilities: tcx.effective_visibilities(()),
         last_node_with_lint_attrs: tcx.local_def_id_to_hir_id(mod_id),
@@ -363,24 +397,24 @@ pub fn late_lint_mod<'tcx, T: LateLintPass<'tcx> + 'tcx>(
     let builtin_lints_must_run = is_lint_pass_required(skippable_lints, &builtin_lints.get_lints());
     if passes.is_empty() {
         if builtin_lints_must_run {
-            late_lint_mod_inner(tcx, mod_id, context, builtin_lints);
+            late_lint_mod_inner::<'_, _, true>(tcx, mod_id, context, builtin_lints);
         }
     } else {
         if builtin_lints_must_run {
             passes.push(Box::new(builtin_lints) as Box<dyn LateLintPass<'tcx>>);
         }
         let pass = RuntimeCombinedLateLintPass { passes };
-        late_lint_mod_inner(tcx, mod_id, context, pass);
+        late_lint_mod_inner::<'_, _, true>(tcx, mod_id, context, pass);
     }
 }
 
-fn late_lint_mod_inner<'tcx, T: LateLintPass<'tcx>>(
+fn late_lint_mod_inner<'tcx, T: LateLintPass<'tcx>, const TYPECK_BODY: bool>(
     tcx: TyCtxt<'tcx>,
     mod_id: LocalModId,
     context: LateContext<'tcx>,
     pass: T,
 ) {
-    let mut cx = LateContextAndPass { context, pass };
+    let mut cx = LateContextAndPass::<'tcx, T, TYPECK_BODY> { context, pass };
 
     let (module, _span, hir_id) = tcx.hir_get_module(mod_id);
 
@@ -415,7 +449,7 @@ fn late_lint_crate<'tcx>(tcx: TyCtxt<'tcx>) {
     let context = LateContext {
         tcx,
         enclosing_body: None,
-        cached_typeck_results: Cell::new(None),
+        typeck_results: None,
         param_env: ty::ParamEnv::empty(),
         effective_visibilities: tcx.effective_visibilities(()),
         last_node_with_lint_attrs: hir::CRATE_HIR_ID,
@@ -424,7 +458,7 @@ fn late_lint_crate<'tcx>(tcx: TyCtxt<'tcx>) {
     };
 
     let pass = RuntimeCombinedLateLintPass { passes };
-    let mut cx = LateContextAndPass { context, pass };
+    let mut cx = LateContextAndPass::<'_, _, true> { context, pass };
 
     // Visit the whole crate.
     cx.with_lint_attrs(hir::CRATE_HIR_ID, |cx| {

compiler/rustc_lint/src/lib.rs

@@ -136,11 +136,10 @@ use unused::must_use::*;
 use unused::*;
 
 #[rustfmt::skip]
-pub use builtin::MissingDoc;
 pub use context::{CheckLintNameResult, EarlyContext, LateContext, LintContext, LintStore};
 pub use early::diagnostics::DiagAndSess;
 pub use early::{EarlyCheckNode, check_ast_node};
-pub use late::{check_crate, late_lint_mod, unerased_lint_store};
+pub use late::{check_crate, late_lint_mod, lint_missing_docs, unerased_lint_store};
 pub use levels::LintLevelsBuilder;
 pub use passes::{EarlyLintPass, LateLintPass};
 pub use rustc_errors::BufferedEarlyLint;

src/librustdoc/core.rs

@@ -14,7 +14,7 @@ use rustc_hir::def::Res;
 use rustc_hir::def_id::{DefId, DefIdMap, DefIdSet, LocalDefId};
 use rustc_hir::intravisit::{self, Visitor};
 use rustc_hir::{HirId, Path};
-use rustc_lint::{MissingDoc, late_lint_mod};
+use rustc_lint::lint_missing_docs;
 use rustc_middle::hir::nested_filter;
 use rustc_middle::ty::{self, ParamEnv, Ty, TyCtxt};
 use rustc_session::config::{
@@ -316,8 +316,7 @@ pub(crate) fn create_config(
         override_queries: Some(|_sess, providers| {
             // We do not register late module lints, so this only runs `MissingDoc`.
             // Most lints will require typechecking, so just don't run them.
-            providers.queries.lint_mod =
-                |tcx, module_def_id| late_lint_mod(tcx, module_def_id, MissingDoc);
+            providers.queries.lint_mod = |tcx, module_def_id| lint_missing_docs(tcx, module_def_id);
             // hack so that `used_trait_imports` won't try to call typeck
             providers.queries.used_trait_imports = |_, _| {
                 static EMPTY_SET: LazyLock<UnordSet<LocalDefId>> = LazyLock::new(UnordSet::default);