From 9bcb544c89a5fab0dc404d2efeda3a9219db29b7 Mon Sep 17 00:00:00 2001 From: Jason Newcomb Date: Mon, 15 Jun 2026 13:15:47 -0400 Subject: [PATCH 1/6] Don't lint the crate if all lint passes have been filtered. --- compiler/rustc_lint/src/late.rs | 25 ++++++++++++------------- 1 file changed, 12 insertions(+), 13 deletions(-) diff --git a/compiler/rustc_lint/src/late.rs b/compiler/rustc_lint/src/late.rs index 19008a771dedd..4c4b94d3d361f 100644 --- a/compiler/rustc_lint/src/late.rs +++ b/compiler/rustc_lint/src/late.rs @@ -405,7 +405,7 @@ fn late_lint_mod_inner<'tcx, T: LateLintPass<'tcx>>( fn late_lint_crate<'tcx>(tcx: TyCtxt<'tcx>) { // Note: `passes` is often empty. - let passes: Vec<_> = + let mut passes: Vec<_> = unerased_lint_store(tcx.sess).late_passes.iter().map(|mk_pass| (mk_pass)(tcx)).collect(); if passes.is_empty() { @@ -424,19 +424,18 @@ fn late_lint_crate<'tcx>(tcx: TyCtxt<'tcx>) { }; let lints_that_dont_need_to_run = tcx.lints_that_dont_need_to_run(()); + passes.retain(|pass| { + let lints = (**pass).get_lints(); + // Lintless passes are always in + lints.is_empty() || + // If the pass doesn't have a single needed lint, omit it + !lints.iter().all(|lint| lints_that_dont_need_to_run.contains(&LintId::of(lint))) + }); + if passes.is_empty() { + return; + } - let mut filtered_passes: Vec>> = passes - .into_iter() - .filter(|pass| { - let lints = (**pass).get_lints(); - // Lintless passes are always in - lints.is_empty() || - // If the pass doesn't have a single needed lint, omit it - !lints.iter().all(|lint| lints_that_dont_need_to_run.contains(&LintId::of(lint))) - }) - .collect(); - - let pass = RuntimeCombinedLateLintPass { passes: &mut filtered_passes[..] }; + let pass = RuntimeCombinedLateLintPass { passes: &mut passes[..] }; let mut cx = LateContextAndPass { context, pass }; // Visit the whole crate. From ee07fbd2cf64bcdeae74ecae7aa9a273b8a51c59 Mon Sep 17 00:00:00 2001 From: Jason Newcomb Date: Mon, 15 Jun 2026 21:02:26 -0400 Subject: [PATCH 2/6] Filter late module lint passes. --- compiler/rustc_lint/src/late.rs | 17 ++++++++++++++--- 1 file changed, 14 insertions(+), 3 deletions(-) diff --git a/compiler/rustc_lint/src/late.rs b/compiler/rustc_lint/src/late.rs index 4c4b94d3d361f..6214ff966e937 100644 --- a/compiler/rustc_lint/src/late.rs +++ b/compiler/rustc_lint/src/late.rs @@ -354,10 +354,10 @@ pub fn late_lint_mod<'tcx, T: LateLintPass<'tcx> + 'tcx>( // `RuntimeCombinedLateLintPass`. let store = unerased_lint_store(tcx.sess); + let dont_need_to_run = tcx.lints_that_dont_need_to_run(()); if store.late_module_passes.is_empty() { // If all builtin lints can be skipped, there is no point in running `late_lint_mod_inner` // at all. This happens often for dependencies built with `--cap-lints=allow`. - let dont_need_to_run = tcx.lints_that_dont_need_to_run(()); let can_skip_lints = builtin_lints .get_lints() .iter() @@ -367,14 +367,25 @@ pub fn late_lint_mod<'tcx, T: LateLintPass<'tcx> + 'tcx>( } } else { let builtin_lints = Box::new(builtin_lints) as Box>; - let mut binding = store + let mut passes = store .late_module_passes .iter() .map(|mk_pass| (mk_pass)(tcx)) .chain(std::iter::once(builtin_lints)) .collect::>(); - let pass = RuntimeCombinedLateLintPass { passes: binding.as_mut_slice() }; + passes.retain(|pass| { + let lints = (**pass).get_lints(); + // Lintless passes are always in + lints.is_empty() || + // If the pass doesn't have a single needed lint, omit it + !lints.iter().all(|lint| dont_need_to_run.contains(&LintId::of(lint))) + }); + if passes.is_empty() { + return; + } + + let pass = RuntimeCombinedLateLintPass { passes: passes.as_mut_slice() }; late_lint_mod_inner(tcx, module_def_id, context, pass); } } From 4c1ec7d7c83adf1a80fa3533e2cb30dbc3b1cda1 Mon Sep 17 00:00:00 2001 From: Jason Newcomb Date: Mon, 15 Jun 2026 13:28:25 -0400 Subject: [PATCH 3/6] Preemptively fetch the typeck results when linting bodies. --- compiler/rustc_lint/src/context.rs | 18 ++--- compiler/rustc_lint/src/late.rs | 101 +++++++++++++++++++++-------- compiler/rustc_lint/src/lib.rs | 3 +- src/librustdoc/core.rs | 5 +- 4 files changed, 82 insertions(+), 45 deletions(-) diff --git a/compiler/rustc_lint/src/context.rs b/compiler/rustc_lint/src/context.rs index 4ea1a3f1209e4..c909e0ce97a3f 100644 --- a/compiler/rustc_lint/src/context.rs +++ b/compiler/rustc_lint/src/context.rs @@ -3,7 +3,6 @@ //! See for an //! overview of how lints are implemented. -use std::cell::Cell; use std::slice; use rustc_abi as abi; @@ -485,11 +484,8 @@ pub struct LateContext<'tcx> { /// Current body, or `None` if outside a body. pub enclosing_body: Option, - /// 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>>, + /// 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>, @@ -667,13 +663,7 @@ 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. @@ -681,7 +671,7 @@ impl<'tcx> LateContext<'tcx> { /// `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. diff --git a/compiler/rustc_lint/src/late.rs b/compiler/rustc_lint/src/late.rs index 6214ff966e937..d4c8056e69000 100644 --- a/compiler/rustc_lint/src/late.rs +++ b/compiler/rustc_lint/src/late.rs @@ -4,19 +4,19 @@ //! 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; use rustc_hir::def_id::{LocalDefId, LocalModDefId}; -use rustc_hir::{self as hir, AmbigArg, HirId, intravisit as hir_visit}; +use rustc_hir::{self as hir, AmbigArg, BodyId, HirId, intravisit as hir_visit}; use rustc_middle::hir::nested_filter; -use rustc_middle::ty::{self, TyCtxt}; +use rustc_middle::ty::{self, TyCtxt, TypeckResults}; use rustc_session::Session; use rustc_session::lint::LintPass; use rustc_span::Span; use tracing::debug; +use crate::builtin::MissingDoc; use crate::passes::LateLintPassObject; use crate::{LateContext, LateLintPass, LintId, LintStore}; @@ -34,12 +34,38 @@ 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>> { +struct LateContextAndPass<'tcx, T: LateLintPass<'tcx>, Typeck> { context: LateContext<'tcx>, pass: T, + // See comment on `lint_missing_docs`. + _typeck_body: Typeck, } -impl<'tcx, T: LateLintPass<'tcx>> LateContextAndPass<'tcx, T> { +trait TypeckBody { + fn typeck_body<'tcx>( + cx: &mut LateContext<'tcx>, + body: BodyId, + ) -> Option<&'tcx TypeckResults<'tcx>>; +} +impl TypeckBody for () { + fn typeck_body<'tcx>( + cx: &mut LateContext<'tcx>, + body: BodyId, + ) -> Option<&'tcx TypeckResults<'tcx>> { + cx.typeck_results.replace(cx.tcx.typeck_body(body)) + } +} +struct NoTypeckBody; +impl TypeckBody for NoTypeckBody { + fn typeck_body<'tcx>( + _: &mut LateContext<'tcx>, + _: BodyId, + ) -> Option<&'tcx TypeckResults<'tcx>> { + None + } +} + +impl<'tcx, T: LateLintPass<'tcx>, Typeck: TypeckBody> LateContextAndPass<'tcx, T, Typeck> { /// 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 +103,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>, Typeck: TypeckBody> hir_visit::Visitor<'tcx> + for LateContextAndPass<'tcx, T, Typeck> +{ type NestedFilter = nested_filter::All; /// Because lints are scoped lexically, we want to walk nested @@ -89,23 +117,18 @@ 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. + // The body and typeck results are also set in `visit_fn`. + // Only fetch the results if this is for a new body. if old_enclosing_body != Some(body_id) { - self.context.cached_typeck_results.set(None); + Typeck::typeck_body(&mut self.context, 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); - } + self.context.typeck_results = old_typeck_results; } fn visit_param(&mut self, param: &'tcx hir::Param<'tcx>) { @@ -123,7 +146,7 @@ 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.take(); 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 +156,7 @@ 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); + self.context.typeck_results = old_typeck_results; self.context.generics = generics; } @@ -189,12 +212,12 @@ 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 = Typeck::typeck_body(&mut self.context, 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); + self.context.typeck_results = old_typeck_results; } fn visit_variant_data(&mut self, s: &'tcx hir::VariantData<'tcx>) { @@ -333,6 +356,31 @@ 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: +/// . +pub fn lint_missing_docs<'tcx>(tcx: TyCtxt<'tcx>, module_def_id: LocalModDefId) { + 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(module_def_id), + generics: None, + only_module: true, + }; + + let dont_need_to_run = tcx.lints_that_dont_need_to_run(()); + let can_skip_lints = + MissingDoc.get_lints().iter().all(|lint| dont_need_to_run.contains(&LintId::of(lint))); + if !can_skip_lints { + late_lint_mod_inner(tcx, module_def_id, context, MissingDoc, NoTypeckBody); + } +} + pub fn late_lint_mod<'tcx, T: LateLintPass<'tcx> + 'tcx>( tcx: TyCtxt<'tcx>, module_def_id: LocalModDefId, @@ -341,7 +389,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(module_def_id), @@ -363,7 +411,7 @@ pub fn late_lint_mod<'tcx, T: LateLintPass<'tcx> + 'tcx>( .iter() .all(|lint| dont_need_to_run.contains(&LintId::of(lint))); if !can_skip_lints { - late_lint_mod_inner(tcx, module_def_id, context, builtin_lints); + late_lint_mod_inner(tcx, module_def_id, context, builtin_lints, ()); } } else { let builtin_lints = Box::new(builtin_lints) as Box>; @@ -386,7 +434,7 @@ pub fn late_lint_mod<'tcx, T: LateLintPass<'tcx> + 'tcx>( } let pass = RuntimeCombinedLateLintPass { passes: passes.as_mut_slice() }; - late_lint_mod_inner(tcx, module_def_id, context, pass); + late_lint_mod_inner(tcx, module_def_id, context, pass, ()); } } @@ -395,8 +443,9 @@ fn late_lint_mod_inner<'tcx, T: LateLintPass<'tcx>>( module_def_id: LocalModDefId, context: LateContext<'tcx>, pass: T, + typeck_body: impl TypeckBody, ) { - let mut cx = LateContextAndPass { context, pass }; + let mut cx = LateContextAndPass { context, pass, _typeck_body: typeck_body }; let (module, _span, hir_id) = tcx.hir_get_module(module_def_id); @@ -426,7 +475,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, @@ -447,7 +496,7 @@ fn late_lint_crate<'tcx>(tcx: TyCtxt<'tcx>) { } let pass = RuntimeCombinedLateLintPass { passes: &mut passes[..] }; - let mut cx = LateContextAndPass { context, pass }; + let mut cx = LateContextAndPass { context, pass, _typeck_body: () }; // Visit the whole crate. cx.with_lint_attrs(hir::CRATE_HIR_ID, |cx| { diff --git a/compiler/rustc_lint/src/lib.rs b/compiler/rustc_lint/src/lib.rs index 6d69421b83161..b37a98c901679 100644 --- a/compiler/rustc_lint/src/lib.rs +++ b/compiler/rustc_lint/src/lib.rs @@ -132,11 +132,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; diff --git a/src/librustdoc/core.rs b/src/librustdoc/core.rs index fccfa3f57e930..e4a2f2d793073 100644 --- a/src/librustdoc/core.rs +++ b/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::{ @@ -310,8 +310,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> = LazyLock::new(UnordSet::default); From 3737b313565ee00508edf0b2b1f55a4cb47c4cbb Mon Sep 17 00:00:00 2001 From: Jason Newcomb Date: Mon, 15 Jun 2026 13:32:58 -0400 Subject: [PATCH 4/6] Remove `maybe_typeck_results` from `LateContext`. --- compiler/rustc_hir_typeck/src/expr_use_visitor.rs | 2 +- compiler/rustc_lint/src/context.rs | 9 ++------- compiler/rustc_lint/src/unit_bindings.rs | 2 +- .../src/functions/not_unsafe_ptr_arg_deref.rs | 2 +- src/tools/clippy/clippy_lints/src/implicit_hasher.rs | 2 +- .../clippy/clippy_lints/src/pass_by_ref_or_value.rs | 2 +- src/tools/clippy/clippy_utils/src/hir_utils.rs | 4 ++-- src/tools/clippy/clippy_utils/src/res.rs | 2 +- src/tools/clippy/clippy_utils/src/ty/mod.rs | 2 +- 9 files changed, 11 insertions(+), 16 deletions(-) diff --git a/compiler/rustc_hir_typeck/src/expr_use_visitor.rs b/compiler/rustc_hir_typeck/src/expr_use_visitor.rs index a924a81f89b0d..e1f5db900a6ca 100644 --- a/compiler/rustc_hir_typeck/src/expr_use_visitor.rs +++ b/compiler/rustc_hir_typeck/src/expr_use_visitor.rs @@ -234,7 +234,7 @@ impl<'tcx> TypeInformationCtxt<'tcx> for (&LateContext<'tcx>, LocalDefId) { type Error = !; fn typeck_results(&self) -> Self::TypeckResults<'_> { - self.0.maybe_typeck_results().expect("expected typeck results") + self.0.typeck_results() } fn structurally_resolve_type(&self, _span: Span, ty: Ty<'tcx>) -> Ty<'tcx> { diff --git a/compiler/rustc_lint/src/context.rs b/compiler/rustc_lint/src/context.rs index c909e0ce97a3f..214cd26dd3bae 100644 --- a/compiler/rustc_lint/src/context.rs +++ b/compiler/rustc_lint/src/context.rs @@ -660,15 +660,10 @@ impl<'tcx> LateContext<'tcx> { self.tcx.type_is_use_cloned_modulo_regions(self.typing_env(), ty) } - /// 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.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). + #[inline] #[track_caller] pub fn typeck_results(&self) -> &'tcx ty::TypeckResults<'tcx> { self.typeck_results.expect("`LateContext::typeck_results` called outside of body") @@ -681,7 +676,7 @@ impl<'tcx> LateContext<'tcx> { match *qpath { hir::QPath::Resolved(_, path) => path.res, hir::QPath::TypeRelative(..) => self - .maybe_typeck_results() + .typeck_results .filter(|typeck_results| typeck_results.hir_owner == id.owner) .or_else(|| { self.tcx diff --git a/compiler/rustc_lint/src/unit_bindings.rs b/compiler/rustc_lint/src/unit_bindings.rs index ed015908ae54a..61c4a95c995b4 100644 --- a/compiler/rustc_lint/src/unit_bindings.rs +++ b/compiler/rustc_lint/src/unit_bindings.rs @@ -53,7 +53,7 @@ impl<'tcx> LateLintPass<'tcx> for UnitBindings { // - explicitly wrote `let pat = ();` // - explicitly wrote `let () = init;`. if !local.span.from_expansion() - && let Some(tyck_results) = cx.maybe_typeck_results() + && let Some(tyck_results) = cx.typeck_results && let Some(init) = local.init && let init_ty = tyck_results.expr_ty(init) && let local_ty = tyck_results.node_type(local.hir_id) diff --git a/src/tools/clippy/clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs b/src/tools/clippy/clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs index e49dee4164b88..0c19b1cf09095 100644 --- a/src/tools/clippy/clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs +++ b/src/tools/clippy/clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs @@ -78,7 +78,7 @@ fn check_raw_ptr<'tcx>( fn raw_ptr_arg(cx: &LateContext<'_>, arg: &hir::Param<'_>) -> Option { if let (&hir::PatKind::Binding(_, id, _, _), Some(&ty::RawPtr(_, _))) = ( &arg.pat.kind, - cx.maybe_typeck_results() + cx.typeck_results .map(|typeck_results| typeck_results.pat_ty(arg.pat).kind()), ) { Some(id) diff --git a/src/tools/clippy/clippy_lints/src/implicit_hasher.rs b/src/tools/clippy/clippy_lints/src/implicit_hasher.rs index 70176c62772b7..392adeea7abca 100644 --- a/src/tools/clippy/clippy_lints/src/implicit_hasher.rs +++ b/src/tools/clippy/clippy_lints/src/implicit_hasher.rs @@ -303,7 +303,7 @@ impl<'a, 'b, 'tcx> ImplicitHasherConstructorVisitor<'a, 'b, 'tcx> { fn new(cx: &'a LateContext<'tcx>, target: &'b ImplicitHasherType<'tcx>) -> Self { Self { cx, - maybe_typeck_results: cx.maybe_typeck_results(), + maybe_typeck_results: cx.typeck_results, target, suggestions: BTreeMap::new(), } diff --git a/src/tools/clippy/clippy_lints/src/pass_by_ref_or_value.rs b/src/tools/clippy/clippy_lints/src/pass_by_ref_or_value.rs index 039da4cc4757a..d8bff9e9f1703 100644 --- a/src/tools/clippy/clippy_lints/src/pass_by_ref_or_value.rs +++ b/src/tools/clippy/clippy_lints/src/pass_by_ref_or_value.rs @@ -174,7 +174,7 @@ impl PassByRefOrValue { && size <= self.ref_min_size && let hir::TyKind::Ref(_, MutTy { ty: decl_ty, .. }) = input.kind { - if let Some(typeck) = cx.maybe_typeck_results() + if let Some(typeck) = cx.typeck_results // Don't lint if a raw pointer is created. // TODO: Limit the check only to raw pointers to the argument (or part of the argument) // which escape the current function. diff --git a/src/tools/clippy/clippy_utils/src/hir_utils.rs b/src/tools/clippy/clippy_utils/src/hir_utils.rs index 38724a1053f65..769523a5af11c 100644 --- a/src/tools/clippy/clippy_utils/src/hir_utils.rs +++ b/src/tools/clippy/clippy_utils/src/hir_utils.rs @@ -69,7 +69,7 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> { pub fn new(cx: &'a LateContext<'tcx>) -> Self { Self { cx, - maybe_typeck_results: cx.maybe_typeck_results().map(|x| (x, x)), + maybe_typeck_results: cx.typeck_results.map(|x| (x, x)), allow_side_effects: true, expr_fallback: None, path_check: PathCheck::default(), @@ -1140,7 +1140,7 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> { pub fn new(cx: &'a LateContext<'tcx>) -> Self { Self { cx, - maybe_typeck_results: cx.maybe_typeck_results(), + maybe_typeck_results: cx.typeck_results, s: FxHasher::default(), path_check: PathCheck::default(), } diff --git a/src/tools/clippy/clippy_utils/src/res.rs b/src/tools/clippy/clippy_utils/src/res.rs index 23afb25f1bbfe..59571a929887a 100644 --- a/src/tools/clippy/clippy_utils/src/res.rs +++ b/src/tools/clippy/clippy_utils/src/res.rs @@ -72,7 +72,7 @@ impl<'tcx> MaybeTypeckRes<'tcx> for LateContext<'tcx> { #[inline] #[cfg_attr(debug_assertions, track_caller)] fn typeck_res(&self) -> Option<&TypeckResults<'tcx>> { - if let Some(typeck) = self.maybe_typeck_results() { + if let Some(typeck) = self.typeck_results { Some(typeck) } else { // It's possible to get the `TypeckResults` for any other body, but diff --git a/src/tools/clippy/clippy_utils/src/ty/mod.rs b/src/tools/clippy/clippy_utils/src/ty/mod.rs index 60d19ecf68bb5..7ade8407074b8 100644 --- a/src/tools/clippy/clippy_utils/src/ty/mod.rs +++ b/src/tools/clippy/clippy_utils/src/ty/mod.rs @@ -40,7 +40,7 @@ pub use type_certainty::expr_type_is_certain; /// Lower a [`hir::Ty`] to a [`rustc_middle::ty::Ty`]. pub fn ty_from_hir_ty<'tcx>(cx: &LateContext<'tcx>, hir_ty: &hir::Ty<'tcx>) -> Ty<'tcx> { - cx.maybe_typeck_results() + cx.typeck_results .filter(|results| results.hir_owner == hir_ty.hir_id.owner) .and_then(|results| results.node_type_opt(hir_ty.hir_id)) .unwrap_or_else(|| lower_ty(cx.tcx, hir_ty)) From 7ae18173f62e1f3dc9ac84a7dff6ab6a41d4c50f Mon Sep 17 00:00:00 2001 From: Jason Newcomb Date: Mon, 15 Jun 2026 19:25:06 -0400 Subject: [PATCH 5/6] Use an ownerless `TypeckResults` instead of `None` as the starting value when linting. --- .../rustc_hir_typeck/src/fn_ctxt/checks.rs | 2 +- compiler/rustc_hir_typeck/src/lib.rs | 2 +- compiler/rustc_hir_typeck/src/writeback.rs | 57 ++++++------ compiler/rustc_lint/src/context.rs | 13 +-- compiler/rustc_lint/src/late.rs | 29 +++--- compiler/rustc_lint/src/unit_bindings.rs | 5 +- compiler/rustc_middle/src/ty/context.rs | 10 +- .../rustc_middle/src/ty/typeck_results.rs | 91 +++++++++++++++---- .../src/error_reporting/traits/suggestions.rs | 15 ++- .../src/functions/not_unsafe_ptr_arg_deref.rs | 24 +++-- .../clippy_lints/src/implicit_hasher.rs | 11 ++- .../clippy_lints/src/pass_by_ref_or_value.rs | 10 +- .../clippy/clippy_utils/src/hir_utils.rs | 71 +++++++-------- src/tools/clippy/clippy_utils/src/res.rs | 36 ++++---- src/tools/clippy/clippy_utils/src/ty/mod.rs | 11 ++- 15 files changed, 210 insertions(+), 177 deletions(-) diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs index a295cc4127b67..4b8f1ac9c6834 100644 --- a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs +++ b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs @@ -1623,7 +1623,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { } let typeck = self.typeck_results.borrow(); for (rcvr, args) in call_finder.calls { - if rcvr.hir_id.owner == typeck.hir_owner + if Some(rcvr.hir_id.owner) == typeck.hir_owner && let Some(rcvr_ty) = typeck.node_type_opt(rcvr.hir_id) && let ty::Closure(call_def_id, _) = rcvr_ty.kind() && def_id == *call_def_id diff --git a/compiler/rustc_hir_typeck/src/lib.rs b/compiler/rustc_hir_typeck/src/lib.rs index 3941f06c3e7d3..be8ad421fae3a 100644 --- a/compiler/rustc_hir_typeck/src/lib.rs +++ b/compiler/rustc_hir_typeck/src/lib.rs @@ -273,7 +273,7 @@ fn typeck_with_inspect<'tcx>( // Consistency check our TypeckResults instance can hold all ItemLocalIds // it will need to hold. - assert_eq!(typeck_results.hir_owner, id.owner); + assert_eq!(typeck_results.hir_owner, Some(id.owner)); typeck_results } diff --git a/compiler/rustc_hir_typeck/src/writeback.rs b/compiler/rustc_hir_typeck/src/writeback.rs index ba5b55b43049f..cbf2d6d7e2424 100644 --- a/compiler/rustc_hir_typeck/src/writeback.rs +++ b/compiler/rustc_hir_typeck/src/writeback.rs @@ -16,7 +16,7 @@ use rustc_data_structures::unord::ExtendUnord; use rustc_errors::{E0720, ErrorGuaranteed}; use rustc_hir::def_id::LocalDefId; use rustc_hir::intravisit::{self, InferKind, Visitor}; -use rustc_hir::{self as hir, AmbigArg, HirId, find_attr}; +use rustc_hir::{self as hir, AmbigArg, HirId, ItemLocalId, find_attr}; use rustc_infer::traits::solve::Goal; use rustc_middle::traits::ObligationCause; use rustc_middle::ty::adjustment::{Adjust, Adjustment, PointerCoercion}; @@ -449,16 +449,16 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> { fn visit_closures(&mut self) { let fcx_typeck_results = self.fcx.typeck_results.borrow(); assert_eq!(fcx_typeck_results.hir_owner, self.typeck_results.hir_owner); - let common_hir_owner = fcx_typeck_results.hir_owner; let fcx_closure_kind_origins = fcx_typeck_results.closure_kind_origins().items_in_stable_order(); for (local_id, origin) in fcx_closure_kind_origins { - let hir_id = HirId { owner: common_hir_owner, local_id }; let place_span = origin.0; let place = self.resolve(origin.1.clone(), &place_span); - self.typeck_results.closure_kind_origins_mut().insert(hir_id, (place_span, place)); + self.typeck_results + .closure_kind_origins_mut() + .insert_local(local_id, (place_span, place)); } } @@ -476,9 +476,10 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> { fn visit_user_provided_tys(&mut self) { let fcx_typeck_results = self.fcx.typeck_results.borrow(); assert_eq!(fcx_typeck_results.hir_owner, self.typeck_results.hir_owner); - let common_hir_owner = fcx_typeck_results.hir_owner; if self.rustc_dump_user_args { + let common_hir_owner = fcx_typeck_results.hir_owner.unwrap(); + let sorted_user_provided_types = fcx_typeck_results.user_provided_types().items_in_stable_order(); @@ -505,11 +506,8 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> { } } - self.typeck_results.user_provided_types_mut().extend( - fcx_typeck_results.user_provided_types().items().map(|(local_id, c_ty)| { - let hir_id = HirId { owner: common_hir_owner, local_id }; - (hir_id, *c_ty) - }), + self.typeck_results.user_provided_types_mut().extend_local( + fcx_typeck_results.user_provided_types().items().map(|(id, &c_ty)| (id, c_ty)), ); } @@ -742,43 +740,37 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> { fn visit_liberated_fn_sigs(&mut self) { let fcx_typeck_results = self.fcx.typeck_results.borrow(); assert_eq!(fcx_typeck_results.hir_owner, self.typeck_results.hir_owner); - let common_hir_owner = fcx_typeck_results.hir_owner; let fcx_liberated_fn_sigs = fcx_typeck_results.liberated_fn_sigs().items_in_stable_order(); for (local_id, &fn_sig) in fcx_liberated_fn_sigs { - let hir_id = HirId { owner: common_hir_owner, local_id }; - let fn_sig = self.resolve(fn_sig, &hir_id); - self.typeck_results.liberated_fn_sigs_mut().insert(hir_id, fn_sig); + let fn_sig = self.resolve(fn_sig, &local_id); + self.typeck_results.liberated_fn_sigs_mut().insert_local(local_id, fn_sig); } } fn visit_fru_field_types(&mut self) { let fcx_typeck_results = self.fcx.typeck_results.borrow(); assert_eq!(fcx_typeck_results.hir_owner, self.typeck_results.hir_owner); - let common_hir_owner = fcx_typeck_results.hir_owner; let fcx_fru_field_types = fcx_typeck_results.fru_field_types().items_in_stable_order(); for (local_id, ftys) in fcx_fru_field_types { - let hir_id = HirId { owner: common_hir_owner, local_id }; - let ftys = self.resolve(ftys.clone(), &hir_id); - self.typeck_results.fru_field_types_mut().insert(hir_id, ftys); + let ftys = self.resolve(ftys.clone(), &local_id); + self.typeck_results.fru_field_types_mut().insert_local(local_id, ftys); } } fn visit_offset_of_container_types(&mut self) { let fcx_typeck_results = self.fcx.typeck_results.borrow(); assert_eq!(fcx_typeck_results.hir_owner, self.typeck_results.hir_owner); - let common_hir_owner = fcx_typeck_results.hir_owner; for (local_id, indices) in fcx_typeck_results.offset_of_data().items_in_stable_order() { - let hir_id = HirId { owner: common_hir_owner, local_id }; let indices = indices .iter() - .map(|&(ty, variant, field)| (self.resolve(ty, &hir_id), variant, field)) + .map(|&(ty, variant, field)| (self.resolve(ty, &local_id), variant, field)) .collect(); - self.typeck_results.offset_of_data_mut().insert(hir_id, indices); + self.typeck_results.offset_of_data_mut().insert_local(local_id, indices); } } @@ -835,7 +827,7 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> { )) }) // FIXME: throwing away the param-env :( - .map(|goal| (goal.predicate, self.fcx.misc(span.to_span(self.fcx.tcx)))), + .map(|goal| (goal.predicate, self.fcx.misc(span.to_span(self.fcx)))), ); assert_eq!(unexpected_goals, vec![]); @@ -876,18 +868,25 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> { } pub(crate) trait Locatable { - fn to_span(&self, tcx: TyCtxt<'_>) -> Span; + fn to_span(&self, tcx: &FnCtxt<'_, '_>) -> Span; } impl Locatable for Span { - fn to_span(&self, _: TyCtxt<'_>) -> Span { + fn to_span(&self, _: &FnCtxt<'_, '_>) -> Span { *self } } impl Locatable for HirId { - fn to_span(&self, tcx: TyCtxt<'_>) -> Span { - tcx.hir_span(*self) + fn to_span(&self, fcx: &FnCtxt<'_, '_>) -> Span { + fcx.tcx.hir_span(*self) + } +} + +impl Locatable for ItemLocalId { + fn to_span(&self, fcx: &FnCtxt<'_, '_>) -> Span { + fcx.tcx + .hir_span(HirId { owner: fcx.typeck_results.borrow().expect_owner(), local_id: *self }) } } @@ -920,7 +919,7 @@ impl<'cx, 'tcx> Resolver<'cx, 'tcx> { .err_ctxt() .emit_inference_failure_err( self.fcx.tcx.hir_body_owner_def_id(self.body.id()), - self.span.to_span(self.fcx.tcx), + self.span.to_span(self.fcx), p.into(), TypeAnnotationNeeded::E0282, false, @@ -944,7 +943,7 @@ impl<'cx, 'tcx> Resolver<'cx, 'tcx> { // that types that show up in the typeck are fully normalized. let mut value = if self.should_normalize && self.fcx.next_trait_solver() { let body_id = tcx.hir_body_owner_def_id(self.body.id()); - let cause = ObligationCause::misc(self.span.to_span(tcx), body_id); + let cause = ObligationCause::misc(self.span.to_span(self.fcx), body_id); let at = self.fcx.at(&cause, self.fcx.param_env); let universes = vec![None; outer_exclusive_binder(&value).as_usize()]; match solve::deeply_normalize_with_skipped_universes_and_ambiguous_coroutine_goals( diff --git a/compiler/rustc_lint/src/context.rs b/compiler/rustc_lint/src/context.rs index 214cd26dd3bae..95914c94b3839 100644 --- a/compiler/rustc_lint/src/context.rs +++ b/compiler/rustc_lint/src/context.rs @@ -485,7 +485,7 @@ pub struct LateContext<'tcx> { pub enclosing_body: Option, /// Type-checking results for the current body. - pub typeck_results: Option<&'tcx ty::TypeckResults<'tcx>>, + pub typeck_results: &'tcx ty::TypeckResults<'tcx>, /// Parameter environment for the item we are in. pub param_env: ty::ParamEnv<'tcx>, @@ -660,13 +660,9 @@ impl<'tcx> LateContext<'tcx> { self.tcx.type_is_use_cloned_modulo_regions(self.typing_env(), ty) } - /// 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). #[inline] - #[track_caller] pub fn typeck_results(&self) -> &'tcx ty::TypeckResults<'tcx> { - self.typeck_results.expect("`LateContext::typeck_results` called outside of body") + self.typeck_results } /// Returns the final resolution of a `QPath`, or `Res::Err` if unavailable. @@ -675,9 +671,8 @@ impl<'tcx> LateContext<'tcx> { pub fn qpath_res(&self, qpath: &hir::QPath<'_>, id: hir::HirId) -> Res { match *qpath { hir::QPath::Resolved(_, path) => path.res, - hir::QPath::TypeRelative(..) => self - .typeck_results - .filter(|typeck_results| typeck_results.hir_owner == id.owner) + hir::QPath::TypeRelative(..) => Some(self.typeck_results) + .filter(|typeck_results| typeck_results.hir_owner == Some(id.owner)) .or_else(|| { self.tcx .has_typeck_results(id.owner.def_id) diff --git a/compiler/rustc_lint/src/late.rs b/compiler/rustc_lint/src/late.rs index d4c8056e69000..8eaec0a69e61e 100644 --- a/compiler/rustc_lint/src/late.rs +++ b/compiler/rustc_lint/src/late.rs @@ -4,6 +4,7 @@ //! borrow checking, etc.). These lints have full type information available. use std::any::Any; +use std::mem; use rustc_data_structures::stack::ensure_sufficient_stack; use rustc_data_structures::sync::par_join; @@ -42,26 +43,17 @@ struct LateContextAndPass<'tcx, T: LateLintPass<'tcx>, Typeck> { } trait TypeckBody { - fn typeck_body<'tcx>( - cx: &mut LateContext<'tcx>, - body: BodyId, - ) -> Option<&'tcx TypeckResults<'tcx>>; + fn typeck_body<'tcx>(cx: &mut LateContext<'tcx>, body: BodyId) -> &'tcx TypeckResults<'tcx>; } impl TypeckBody for () { - fn typeck_body<'tcx>( - cx: &mut LateContext<'tcx>, - body: BodyId, - ) -> Option<&'tcx TypeckResults<'tcx>> { - cx.typeck_results.replace(cx.tcx.typeck_body(body)) + fn typeck_body<'tcx>(cx: &mut LateContext<'tcx>, body: BodyId) -> &'tcx TypeckResults<'tcx> { + mem::replace(&mut cx.typeck_results, cx.tcx.typeck_body(body)) } } struct NoTypeckBody; impl TypeckBody for NoTypeckBody { - fn typeck_body<'tcx>( - _: &mut LateContext<'tcx>, - _: BodyId, - ) -> Option<&'tcx TypeckResults<'tcx>> { - None + fn typeck_body<'tcx>(cx: &mut LateContext<'tcx>, _: BodyId) -> &'tcx TypeckResults<'tcx> { + cx.typeck_results } } @@ -146,7 +138,8 @@ impl<'tcx, T: LateLintPass<'tcx>, Typeck: TypeckBody> hir_visit::Visitor<'tcx> fn visit_item(&mut self, it: &'tcx hir::Item<'tcx>) { let generics = self.context.generics.take(); self.context.generics = it.kind.generics(); - let old_typeck_results = self.context.typeck_results.take(); + let old_typeck_results = self.context.typeck_results; + self.context.typeck_results = self.context.tcx.dummy_typeck_results; 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| { @@ -365,7 +358,7 @@ pub fn lint_missing_docs<'tcx>(tcx: TyCtxt<'tcx>, module_def_id: LocalModDefId) let context = LateContext { tcx, enclosing_body: None, - typeck_results: None, + typeck_results: tcx.dummy_typeck_results, param_env: ty::ParamEnv::empty(), effective_visibilities: tcx.effective_visibilities(()), last_node_with_lint_attrs: tcx.local_def_id_to_hir_id(module_def_id), @@ -389,7 +382,7 @@ pub fn late_lint_mod<'tcx, T: LateLintPass<'tcx> + 'tcx>( let context = LateContext { tcx, enclosing_body: None, - typeck_results: None, + typeck_results: tcx.dummy_typeck_results, param_env: ty::ParamEnv::empty(), effective_visibilities: tcx.effective_visibilities(()), last_node_with_lint_attrs: tcx.local_def_id_to_hir_id(module_def_id), @@ -475,7 +468,7 @@ fn late_lint_crate<'tcx>(tcx: TyCtxt<'tcx>) { let context = LateContext { tcx, enclosing_body: None, - typeck_results: None, + typeck_results: tcx.dummy_typeck_results, param_env: ty::ParamEnv::empty(), effective_visibilities: tcx.effective_visibilities(()), last_node_with_lint_attrs: hir::CRATE_HIR_ID, diff --git a/compiler/rustc_lint/src/unit_bindings.rs b/compiler/rustc_lint/src/unit_bindings.rs index 61c4a95c995b4..e075969176e16 100644 --- a/compiler/rustc_lint/src/unit_bindings.rs +++ b/compiler/rustc_lint/src/unit_bindings.rs @@ -53,10 +53,9 @@ impl<'tcx> LateLintPass<'tcx> for UnitBindings { // - explicitly wrote `let pat = ();` // - explicitly wrote `let () = init;`. if !local.span.from_expansion() - && let Some(tyck_results) = cx.typeck_results && let Some(init) = local.init - && let init_ty = tyck_results.expr_ty(init) - && let local_ty = tyck_results.node_type(local.hir_id) + && let init_ty = cx.typeck_results.expr_ty(init) + && let local_ty = cx.typeck_results.node_type(local.hir_id) && init_ty == cx.tcx.types.unit && local_ty == cx.tcx.types.unit && local.ty.is_none() diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs index c6fa3801fb1bc..6606f64b74c53 100644 --- a/compiler/rustc_middle/src/ty/context.rs +++ b/compiler/rustc_middle/src/ty/context.rs @@ -71,7 +71,7 @@ use crate::ty::{ GenericArgs, GenericArgsRef, GenericParamDefKind, List, ListWithCachedTypeInfo, ParamConst, Pattern, PatternKind, PolyExistentialPredicate, PolyFnSig, Predicate, PredicateKind, PredicatePolarity, Region, RegionKind, ReprOptions, TraitObjectVisitor, Ty, TyKind, TyVid, - ValTree, ValTreeKind, Visibility, + TypeckResults, ValTree, ValTreeKind, Visibility, }; impl<'tcx> rustc_type_ir::inherent::DefId> for DefId { @@ -725,6 +725,12 @@ pub struct GlobalCtxt<'tcx> { /// Common consts, pre-interned for your convenience. pub consts: CommonConsts<'tcx>, + /// The dummy ownerless typeck results. All attempts to lookup a HIR node in any of + /// the contained tables will panic. + /// + /// FIXME: This cannot be a static as the lifetime argument is invariant. + pub dummy_typeck_results: &'tcx TypeckResults<'tcx>, + /// Hooks to be able to register functions in other crates that can then still /// be called from rustc_middle. pub(crate) hooks: crate::hooks::Providers, @@ -954,6 +960,7 @@ impl<'tcx> TyCtxt<'tcx> { let common_types = CommonTypes::new(&interners); let common_lifetimes = CommonLifetimes::new(&interners); let common_consts = CommonConsts::new(&interners, &common_types); + let dummy_typeck_results = arena.alloc(TypeckResults::dummy()); let gcx = gcx_cell.get_or_init(|| GlobalCtxt { sess, @@ -968,6 +975,7 @@ impl<'tcx> TyCtxt<'tcx> { types: common_types, lifetimes: common_lifetimes, consts: common_consts, + dummy_typeck_results, untracked, query_system, dep_kind_vtables, diff --git a/compiler/rustc_middle/src/ty/typeck_results.rs b/compiler/rustc_middle/src/ty/typeck_results.rs index 1287047581196..fd1dc176b331f 100644 --- a/compiler/rustc_middle/src/ty/typeck_results.rs +++ b/compiler/rustc_middle/src/ty/typeck_results.rs @@ -3,7 +3,7 @@ use std::hash::Hash; use std::iter; use rustc_abi::{FieldIdx, VariantIdx}; -use rustc_data_structures::fx::{FxIndexMap, FxIndexSet}; +use rustc_data_structures::fx::{FxBuildHasher, FxIndexMap, FxIndexSet}; use rustc_data_structures::unord::{ExtendUnord, UnordItems, UnordSet}; use rustc_errors::ErrorGuaranteed; use rustc_hir::def::{DefKind, Res}; @@ -30,7 +30,7 @@ use crate::ty::{ #[derive(TyEncodable, TyDecodable, Debug, StableHash)] pub struct TypeckResults<'tcx> { /// The `HirId::owner` all `ItemLocalId`s in this table are relative to. - pub hir_owner: OwnerId, + pub hir_owner: Option, /// Resolved definitions for `::X` associated paths and /// method calls, including those of overloaded operators. @@ -225,9 +225,40 @@ pub struct TypeckResults<'tcx> { } impl<'tcx> TypeckResults<'tcx> { + pub(crate) fn dummy() -> Self { + Self { + hir_owner: None, + type_dependent_defs: Default::default(), + field_indices: Default::default(), + user_provided_types: Default::default(), + user_provided_sigs: Default::default(), + node_types: Default::default(), + node_args: Default::default(), + adjustments: Default::default(), + pat_binding_modes: Default::default(), + pat_adjustments: Default::default(), + rust_2024_migration_desugared_pats: Default::default(), + skipped_ref_pats: Default::default(), + closure_kind_origins: Default::default(), + liberated_fn_sigs: Default::default(), + fru_field_types: Default::default(), + coercion_casts: Default::default(), + used_trait_imports: Default::default(), + tainted_by_errors: None, + hidden_types: FxIndexMap::with_hasher(FxBuildHasher), + closure_min_captures: Default::default(), + closure_fake_reads: Default::default(), + coroutine_stalled_predicates: FxIndexSet::with_hasher(FxBuildHasher), + potentially_region_dependent_goals: FxIndexSet::with_hasher(FxBuildHasher), + closure_size_eval: Default::default(), + transmutes_to_check: Default::default(), + offset_of_data: Default::default(), + } + } + pub fn new(hir_owner: OwnerId) -> TypeckResults<'tcx> { TypeckResults { - hir_owner, + hir_owner: Some(hir_owner), type_dependent_defs: Default::default(), field_indices: Default::default(), user_provided_types: Default::default(), @@ -256,6 +287,17 @@ impl<'tcx> TypeckResults<'tcx> { } } + #[inline] + pub fn is_dummy(&self) -> bool { + self.hir_owner.is_none() + } + + #[inline] + #[track_caller] + pub fn expect_owner(&self) -> OwnerId { + self.hir_owner.expect("attempted to access the owner of the dummy `TypeckResults`") + } + /// Returns the final resolution of a `QPath` in an `Expr` or `Pat` node. pub fn qpath_res(&self, qpath: &hir::QPath<'_>, id: HirId) -> Res { match *qpath { @@ -577,26 +619,30 @@ impl<'tcx> TypeckResults<'tcx> { /// would result in lookup errors, or worse, in silently wrong data being /// stored/returned. #[inline] -fn validate_hir_id_for_typeck_results(hir_owner: OwnerId, hir_id: HirId) { - if hir_id.owner != hir_owner { +fn validate_hir_id_for_typeck_results(hir_owner: Option, hir_id: HirId) { + if Some(hir_id.owner) != hir_owner { invalid_hir_id_for_typeck_results(hir_owner, hir_id); } } #[cold] #[inline(never)] -fn invalid_hir_id_for_typeck_results(hir_owner: OwnerId, hir_id: HirId) { - ty::tls::with(|tcx| { - bug!( - "node {} cannot be placed in TypeckResults with hir_owner {:?}", - tcx.hir_id_to_string(hir_id), - hir_owner - ) - }); +fn invalid_hir_id_for_typeck_results(hir_owner: Option, hir_id: HirId) { + if let Some(hir_owner) = hir_owner { + ty::tls::with(|tcx| { + bug!( + "node {} cannot be placed in TypeckResults with hir_owner {:?}", + tcx.hir_id_to_string(hir_id), + hir_owner + ) + }); + } else { + bug!("attempted access of the dummy `TypeckResults`"); + } } pub struct LocalTableInContext<'a, V> { - hir_owner: OwnerId, + hir_owner: Option, data: &'a ItemLocalMap, } @@ -634,7 +680,7 @@ impl<'a, V> ::std::ops::Index for LocalTableInContext<'a, V> { } pub struct LocalTableInContextMut<'a, V> { - hir_owner: OwnerId, + hir_owner: Option, data: &'a mut ItemLocalMap, } @@ -659,6 +705,10 @@ impl<'a, V> LocalTableInContextMut<'a, V> { self.data.insert(id.local_id, val) } + pub fn insert_local(&mut self, id: ItemLocalId, val: V) -> Option { + self.data.insert(id, val) + } + pub fn remove(&mut self, id: HirId) -> Option { validate_hir_id_for_typeck_results(self.hir_owner, id); self.data.remove(&id.local_id) @@ -670,11 +720,18 @@ impl<'a, V> LocalTableInContextMut<'a, V> { (id.local_id, value) })) } + + pub fn extend_local( + &mut self, + items: UnordItems<(ItemLocalId, V), impl Iterator>, + ) { + self.data.extend_unord(items); + } } #[derive(Clone, Copy, Debug)] pub struct LocalSetInContext<'a> { - hir_owner: OwnerId, + hir_owner: Option, data: &'a ItemLocalSet, } @@ -691,7 +748,7 @@ impl<'a> LocalSetInContext<'a> { #[derive(Debug)] pub struct LocalSetInContextMut<'a> { - hir_owner: OwnerId, + hir_owner: Option, data: &'a mut ItemLocalSet, } diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs index c3f4a09b2d431..65cb71a129423 100644 --- a/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs +++ b/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs @@ -337,7 +337,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> { return; } - let fn_body_hir_id = self.tcx.local_def_id_to_hir_id(typeck_results.hir_owner.def_id); + let fn_body_hir_id = self.tcx.local_def_id_to_hir_id(hir_id.owner.def_id); let mut private_candidate: Option<(Ty<'tcx>, Ty<'tcx>, Span)> = None; for (deref_base_ty, _) in (self.autoderef_steps)(base_ty) { @@ -3136,19 +3136,16 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> { // type-checking; otherwise, get them by performing a query. This is needed to avoid // cycles. If we can't use resolved types because the coroutine comes from another crate, // we still provide a targeted error but without all the relevant spans. - let coroutine_data = match &self.typeck_results { - Some(t) if t.hir_owner.to_def_id() == coroutine_did_root => CoroutineData(t), + let (coroutine_data, coroutine_within_in_progress_typeck) = match &self.typeck_results { + Some(t) if t.hir_owner.map(|x| x.to_def_id()) == Some(coroutine_did_root) => { + (CoroutineData(t), true) + } _ if coroutine_did.is_local() => { - CoroutineData(self.tcx.typeck(coroutine_did.expect_local())) + (CoroutineData(self.tcx.typeck(coroutine_did.expect_local())), false) } _ => return false, }; - let coroutine_within_in_progress_typeck = match &self.typeck_results { - Some(t) => t.hir_owner.to_def_id() == coroutine_did_root, - _ => false, - }; - let mut interior_or_upvar_span = None; let from_awaited_ty = coroutine_data.get_from_await_ty(visitor, self.tcx, ty_matches); diff --git a/src/tools/clippy/clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs b/src/tools/clippy/clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs index 0c19b1cf09095..df723b4f3dc03 100644 --- a/src/tools/clippy/clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs +++ b/src/tools/clippy/clippy_lints/src/functions/not_unsafe_ptr_arg_deref.rs @@ -1,11 +1,10 @@ use clippy_utils::res::MaybeResPath; use rustc_hir::{self as hir, HirId, HirIdSet, intravisit}; use rustc_lint::LateContext; -use rustc_middle::ty; +use rustc_middle::ty::{self, Ty}; use rustc_span::def_id::LocalDefId; use clippy_utils::diagnostics::span_lint; -use clippy_utils::iter_input_pats; use clippy_utils::ty::is_unsafe_fn; use clippy_utils::visitors::for_each_expr; @@ -16,7 +15,7 @@ use super::NOT_UNSAFE_PTR_ARG_DEREF; pub(super) fn check_fn<'tcx>( cx: &LateContext<'tcx>, kind: intravisit::FnKind<'tcx>, - decl: &'tcx hir::FnDecl<'tcx>, + _decl: &'tcx hir::FnDecl<'tcx>, body: &'tcx hir::Body<'tcx>, def_id: LocalDefId, ) { @@ -26,26 +25,26 @@ pub(super) fn check_fn<'tcx>( intravisit::FnKind::Closure => return, }; - check_raw_ptr(cx, safety, decl, body, def_id); + check_raw_ptr(cx, safety, body, def_id); } pub(super) fn check_trait_item<'tcx>(cx: &LateContext<'tcx>, item: &'tcx hir::TraitItem<'_>) { if let hir::TraitItemKind::Fn(ref sig, hir::TraitFn::Provided(eid)) = item.kind { let body = cx.tcx.hir_body(eid); - check_raw_ptr(cx, sig.header.safety(), sig.decl, body, item.owner_id.def_id); + check_raw_ptr(cx, sig.header.safety(), body, item.owner_id.def_id); } } fn check_raw_ptr<'tcx>( cx: &LateContext<'tcx>, safety: hir::Safety, - decl: &'tcx hir::FnDecl<'tcx>, body: &'tcx hir::Body<'tcx>, def_id: LocalDefId, ) { if safety.is_safe() && cx.effective_visibilities.is_exported(def_id) { - let raw_ptrs = iter_input_pats(decl, body) - .filter_map(|arg| raw_ptr_arg(cx, arg)) + let sig = cx.tcx.fn_sig(def_id).instantiate_identity().skip_binder(); + let raw_ptrs = body.params.iter().zip(sig.inputs_and_output) + .filter_map(|(param, ty)| raw_ptr_arg(param, ty)) .collect::(); if !raw_ptrs.is_empty() { @@ -75,11 +74,10 @@ fn check_raw_ptr<'tcx>( } } -fn raw_ptr_arg(cx: &LateContext<'_>, arg: &hir::Param<'_>) -> Option { - if let (&hir::PatKind::Binding(_, id, _, _), Some(&ty::RawPtr(_, _))) = ( - &arg.pat.kind, - cx.typeck_results - .map(|typeck_results| typeck_results.pat_ty(arg.pat).kind()), +fn raw_ptr_arg(param: &hir::Param<'_>, ty: Ty<'_>) -> Option { + if let (&hir::PatKind::Binding(_, id, _, _), &ty::RawPtr(_, _)) = ( + ¶m.pat.kind, + ty.kind(), ) { Some(id) } else { diff --git a/src/tools/clippy/clippy_lints/src/implicit_hasher.rs b/src/tools/clippy/clippy_lints/src/implicit_hasher.rs index 392adeea7abca..9ac92ca7c33b4 100644 --- a/src/tools/clippy/clippy_lints/src/implicit_hasher.rs +++ b/src/tools/clippy/clippy_lints/src/implicit_hasher.rs @@ -1,5 +1,6 @@ use std::borrow::Cow; use std::collections::BTreeMap; +use std::mem; use clippy_utils::res::MaybeDef; use rustc_errors::{Applicability, Diag}; @@ -294,7 +295,7 @@ impl<'tcx> Visitor<'tcx> for ImplicitHasherTypeVisitor<'_, 'tcx> { /// Looks for default-hasher-dependent constructors like `HashMap::new`. struct ImplicitHasherConstructorVisitor<'a, 'b, 'tcx> { cx: &'a LateContext<'tcx>, - maybe_typeck_results: Option<&'tcx TypeckResults<'tcx>>, + typeck_results: &'tcx TypeckResults<'tcx>, target: &'b ImplicitHasherType<'tcx>, suggestions: BTreeMap, } @@ -303,7 +304,7 @@ impl<'a, 'b, 'tcx> ImplicitHasherConstructorVisitor<'a, 'b, 'tcx> { fn new(cx: &'a LateContext<'tcx>, target: &'b ImplicitHasherType<'tcx>) -> Self { Self { cx, - maybe_typeck_results: cx.typeck_results, + typeck_results: cx.typeck_results, target, suggestions: BTreeMap::new(), } @@ -314,9 +315,9 @@ impl<'tcx> Visitor<'tcx> for ImplicitHasherConstructorVisitor<'_, '_, 'tcx> { type NestedFilter = nested_filter::OnlyBodies; fn visit_body(&mut self, body: &Body<'tcx>) { - let old_maybe_typeck_results = self.maybe_typeck_results.replace(self.cx.tcx.typeck_body(body.id())); + let old_typeck_results = mem::replace(&mut self.typeck_results, self.cx.tcx.typeck_body(body.id())); walk_body(self, body); - self.maybe_typeck_results = old_maybe_typeck_results; + self.typeck_results = old_typeck_results; } fn visit_expr(&mut self, e: &'tcx Expr<'_>) { @@ -326,7 +327,7 @@ impl<'tcx> Visitor<'tcx> for ImplicitHasherConstructorVisitor<'_, '_, 'tcx> { && let TyKind::Path(QPath::Resolved(None, ty_path)) = ty.kind && let Some(ty_did) = ty_path.res.opt_def_id() { - if self.target.ty() != self.maybe_typeck_results.unwrap().expr_ty(e) { + if self.target.ty() != self.typeck_results.expr_ty(e) { return; } diff --git a/src/tools/clippy/clippy_lints/src/pass_by_ref_or_value.rs b/src/tools/clippy/clippy_lints/src/pass_by_ref_or_value.rs index d8bff9e9f1703..cacf5da3e2b0d 100644 --- a/src/tools/clippy/clippy_lints/src/pass_by_ref_or_value.rs +++ b/src/tools/clippy/clippy_lints/src/pass_by_ref_or_value.rs @@ -174,16 +174,12 @@ impl PassByRefOrValue { && size <= self.ref_min_size && let hir::TyKind::Ref(_, MutTy { ty: decl_ty, .. }) = input.kind { - if let Some(typeck) = cx.typeck_results - // Don't lint if a raw pointer is created. - // TODO: Limit the check only to raw pointers to the argument (or part of the argument) - // which escape the current function. - && (typeck.node_types().items().any(|(_, &ty)| ty.is_raw_ptr()) - || typeck + if cx.typeck_results.node_types().items().any(|(_, &ty)| ty.is_raw_ptr()) + || cx.typeck_results .adjustments() .items() .flat_map(|(_, a)| UnordItems::new(a.iter())) - .any(|a| matches!(a.kind, Adjust::Pointer(PointerCoercion::UnsafeFnPointer)))) + .any(|a| matches!(a.kind, Adjust::Pointer(PointerCoercion::UnsafeFnPointer))) { continue; } diff --git a/src/tools/clippy/clippy_utils/src/hir_utils.rs b/src/tools/clippy/clippy_utils/src/hir_utils.rs index 769523a5af11c..3df94db457afa 100644 --- a/src/tools/clippy/clippy_utils/src/hir_utils.rs +++ b/src/tools/clippy/clippy_utils/src/hir_utils.rs @@ -59,7 +59,7 @@ pub enum PathCheck { pub struct SpanlessEq<'a, 'tcx> { /// Context used to evaluate constant expressions. cx: &'a LateContext<'tcx>, - maybe_typeck_results: Option<(&'tcx TypeckResults<'tcx>, &'tcx TypeckResults<'tcx>)>, + typeck_results: (&'tcx TypeckResults<'tcx>, &'tcx TypeckResults<'tcx>), allow_side_effects: bool, expr_fallback: Option>>, path_check: PathCheck, @@ -69,7 +69,7 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> { pub fn new(cx: &'a LateContext<'tcx>) -> Self { Self { cx, - maybe_typeck_results: cx.typeck_results.map(|x| (x, x)), + typeck_results: (cx.typeck_results, cx.typeck_results), allow_side_effects: true, expr_fallback: None, path_check: PathCheck::default(), @@ -183,12 +183,10 @@ impl HirEqInterExpr<'_, '_, '_> { (StmtKind::Let(l), StmtKind::Let(r)) => { // This additional check ensures that the type of the locals are equivalent even if the init // expression or type have some inferred parts. - if let Some((typeck_lhs, typeck_rhs)) = self.inner.maybe_typeck_results { - let l_ty = typeck_lhs.pat_ty(l.pat); - let r_ty = typeck_rhs.pat_ty(r.pat); - if l_ty != r_ty { - return false; - } + let l_ty = self.inner.typeck_results.0.pat_ty(l.pat); + let r_ty = self.inner.typeck_results.1.pat_ty(r.pat); + if l_ty != r_ty { + return false; } // eq_pat adds the HirIds to the locals map. We therefore call it last to make sure that @@ -481,15 +479,18 @@ impl HirEqInterExpr<'_, '_, '_> { pub fn eq_body(&mut self, left: BodyId, right: BodyId) -> bool { // swap out TypeckResults when hashing a body - let old_maybe_typeck_results = self.inner.maybe_typeck_results.replace(( - self.inner.cx.tcx.typeck_body(left), - self.inner.cx.tcx.typeck_body(right), - )); + let old_typeck_results = mem::replace( + &mut self.inner.typeck_results, + ( + self.inner.cx.tcx.typeck_body(left), + self.inner.cx.tcx.typeck_body(right), + ), + ); let res = self.eq_expr( self.inner.cx.tcx.hir_body(left).value, self.inner.cx.tcx.hir_body(right).value, ); - self.inner.maybe_typeck_results = old_maybe_typeck_results; + self.inner.typeck_results = old_typeck_results; res } @@ -497,12 +498,11 @@ impl HirEqInterExpr<'_, '_, '_> { pub fn eq_expr(&mut self, left: &Expr<'_>, right: &Expr<'_>) -> bool { match self.check_ctxt(left.span.ctxt(), right.span.ctxt()) { None => { - if let Some((typeck_lhs, typeck_rhs)) = self.inner.maybe_typeck_results - && typeck_lhs.expr_ty(left) == typeck_rhs.expr_ty(right) + if self.inner.typeck_results.0.expr_ty(left) == self.inner.typeck_results.1.expr_ty(right) && let (Some(l), Some(r)) = ( - ConstEvalCtxt::with_env(self.inner.cx.tcx, self.inner.cx.typing_env(), typeck_lhs) + ConstEvalCtxt::with_env(self.inner.cx.tcx, self.inner.cx.typing_env(), self.inner.typeck_results.0) .eval_local(left, self.eval_ctxt), - ConstEvalCtxt::with_env(self.inner.cx.tcx, self.inner.cx.typing_env(), typeck_rhs) + ConstEvalCtxt::with_env(self.inner.cx.tcx, self.inner.cx.typing_env(), self.inner.typeck_results.1) .eval_local(right, self.eval_ctxt), ) && l == r @@ -670,15 +670,12 @@ impl HirEqInterExpr<'_, '_, '_> { ) => false, }; (is_eq && (!self.should_ignore(left) || !self.should_ignore(right))) - || self - .inner - .maybe_typeck_results - .is_some_and(|(left_typeck_results, right_typeck_results)| { - self.inner - .expr_fallback - .as_mut() - .is_some_and(|f| f(left_typeck_results, left, right_typeck_results, right)) - }) + || self.inner + .expr_fallback + .as_mut() + .is_some_and(|f| f( + self.inner.typeck_results.0, left, + self.inner.typeck_results.1, right)) } fn eq_exprs(&mut self, left: &[Expr<'_>], right: &[Expr<'_>]) -> bool { @@ -1011,13 +1008,9 @@ impl HirEqInterExpr<'_, '_, '_> { | BinOpKind::Or | BinOpKind::BitAnd | BinOpKind::BitXor - | BinOpKind::BitOr => self.inner.maybe_typeck_results.and_then(|(typeck_lhs, _)| { - typeck_lhs - .expr_ty_adjusted(lhs) - .peel_refs() - .is_primitive() - .then_some((binop, rhs, lhs)) - }), + | BinOpKind::BitOr => self.inner.typeck_results.0.expr_ty_adjusted(lhs).peel_refs() + .is_primitive() + .then_some((binop, rhs, lhs)), } } } @@ -1131,7 +1124,7 @@ fn generic_path_segments<'tcx>(segments: &'tcx [PathSegment<'tcx>]) -> Option<&' pub struct SpanlessHash<'a, 'tcx> { /// Context used to evaluate constant expressions. cx: &'a LateContext<'tcx>, - maybe_typeck_results: Option<&'tcx TypeckResults<'tcx>>, + typeck_results: &'tcx TypeckResults<'tcx>, s: FxHasher, path_check: PathCheck, } @@ -1140,7 +1133,7 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> { pub fn new(cx: &'a LateContext<'tcx>) -> Self { Self { cx, - maybe_typeck_results: cx.typeck_results, + typeck_results: cx.typeck_results, s: FxHasher::default(), path_check: PathCheck::default(), } @@ -1174,9 +1167,7 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> { #[expect(clippy::too_many_lines)] pub fn hash_expr(&mut self, e: &Expr<'_>) { - let simple_const = self.maybe_typeck_results.and_then(|typeck_results| { - ConstEvalCtxt::with_env(self.cx.tcx, self.cx.typing_env(), typeck_results).eval_local(e, e.span.ctxt()) - }); + let simple_const = ConstEvalCtxt::with_env(self.cx.tcx, self.cx.typing_env(), self.typeck_results).eval_local(e, e.span.ctxt()); // const hashing may result in the same hash as some unrelated node, so add a sort of // discriminant depending on which path we're choosing next @@ -1661,9 +1652,9 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> { pub fn hash_body(&mut self, body_id: BodyId) { // swap out TypeckResults when hashing a body - let old_maybe_typeck_results = self.maybe_typeck_results.replace(self.cx.tcx.typeck_body(body_id)); + let old_typeck_results = mem::replace(&mut self.typeck_results, self.cx.tcx.typeck_body(body_id)); self.hash_expr(self.cx.tcx.hir_body(body_id).value); - self.maybe_typeck_results = old_maybe_typeck_results; + self.typeck_results = old_typeck_results; } fn hash_const_arg(&mut self, const_arg: &ConstArg<'_>) { diff --git a/src/tools/clippy/clippy_utils/src/res.rs b/src/tools/clippy/clippy_utils/src/res.rs index 59571a929887a..9b0299b0a5471 100644 --- a/src/tools/clippy/clippy_utils/src/res.rs +++ b/src/tools/clippy/clippy_utils/src/res.rs @@ -33,7 +33,7 @@ pub trait MaybeTypeckRes<'tcx> { /// With debug assertions enabled this will always return `Some`. `None` is /// only returned so logic errors can be handled by not emitting a lint on /// release builds. - fn typeck_res(&self) -> Option<&TypeckResults<'tcx>>; + fn typeck_res(&self) -> &TypeckResults<'tcx>; /// Gets the type-dependent resolution of the specified node. /// @@ -46,7 +46,7 @@ pub trait MaybeTypeckRes<'tcx> { #[inline] #[cfg_attr(debug_assertions, track_caller)] fn f(typeck: &TypeckResults<'_>, id: HirId) -> Option { - if typeck.hir_owner == id.owner { + if typeck.hir_owner == Some(id.owner) { let def = typeck.type_dependent_def(id); debug_assert!( def.is_some(), @@ -65,28 +65,24 @@ pub trait MaybeTypeckRes<'tcx> { None } } - self.typeck_res().and_then(|typeck| f(typeck, node.hir_id())) + f(self.typeck_res(), node.hir_id()) } } impl<'tcx> MaybeTypeckRes<'tcx> for LateContext<'tcx> { #[inline] #[cfg_attr(debug_assertions, track_caller)] - fn typeck_res(&self) -> Option<&TypeckResults<'tcx>> { - if let Some(typeck) = self.typeck_results { - Some(typeck) - } else { - // It's possible to get the `TypeckResults` for any other body, but - // attempting to lookup the type of something across bodies like this - // is a good indication of a bug. - debug_assert!(false, "attempted type-dependent lookup in a non-body context"); - None - } + fn typeck_res(&self) -> &TypeckResults<'tcx> { + // It's possible to get the `TypeckResults` for any other body, but + // attempting to lookup the type of something across bodies like this + // is a good indication of a bug. + debug_assert!(!self.typeck_results.is_dummy(), "attempted type-dependent lookup in a non-body context"); + self.typeck_results } } impl<'tcx> MaybeTypeckRes<'tcx> for TypeckResults<'tcx> { #[inline] - fn typeck_res(&self) -> Option<&TypeckResults<'tcx>> { - Some(self) + fn typeck_res(&self) -> &TypeckResults<'tcx> { + self } } @@ -112,7 +108,7 @@ pub trait MaybeQPath<'a>: Copy { } } match self.opt_qpath() { - Some((qpath, id)) if let Some(typeck) = typeck.typeck_res() => f(qpath, id, typeck), + Some((qpath, id))=> f(qpath, id, typeck.typeck_res()), _ => Res::Err, } } @@ -141,7 +137,7 @@ pub trait MaybeQPath<'a>: Copy { } } match self.opt_qpath() { - Some((qpath, id)) if let Some(typeck) = typeck.typeck_res() => f(qpath, id, typeck, name), + Some((qpath, id)) => f(qpath, id, typeck.typeck_res(), name), _ => Res::Err, } } @@ -161,7 +157,7 @@ pub trait MaybeQPath<'a>: Copy { } } match self.opt_qpath() { - Some((qpath, id)) if let Some(typeck) = typeck.typeck_res() => f(qpath, id, typeck), + Some((qpath, id)) => f(qpath, id, typeck.typeck_res()), _ => (Res::Err, None), } } @@ -195,7 +191,7 @@ pub trait MaybeQPath<'a>: Copy { } } match self.opt_qpath() { - Some((qpath, id)) if let Some(typeck) = typeck.typeck_res() => f(qpath, id, typeck), + Some((qpath, id)) => f(qpath, id, typeck.typeck_res()), _ => Res::Err, } } @@ -237,7 +233,7 @@ pub trait MaybeQPath<'a>: Copy { } } match self.opt_qpath() { - Some((qpath, id)) if let Some(typeck) = typeck.typeck_res() => f(qpath, id, typeck, name), + Some((qpath, id)) => f(qpath, id, typeck.typeck_res(), name), _ => Res::Err, } } diff --git a/src/tools/clippy/clippy_utils/src/ty/mod.rs b/src/tools/clippy/clippy_utils/src/ty/mod.rs index 7ade8407074b8..fb5fd5ad97c4e 100644 --- a/src/tools/clippy/clippy_utils/src/ty/mod.rs +++ b/src/tools/clippy/clippy_utils/src/ty/mod.rs @@ -40,10 +40,13 @@ pub use type_certainty::expr_type_is_certain; /// Lower a [`hir::Ty`] to a [`rustc_middle::ty::Ty`]. pub fn ty_from_hir_ty<'tcx>(cx: &LateContext<'tcx>, hir_ty: &hir::Ty<'tcx>) -> Ty<'tcx> { - cx.typeck_results - .filter(|results| results.hir_owner == hir_ty.hir_id.owner) - .and_then(|results| results.node_type_opt(hir_ty.hir_id)) - .unwrap_or_else(|| lower_ty(cx.tcx, hir_ty)) + if cx.typeck_results.hir_owner == Some(hir_ty.hir_id.owner) + && let Some(ty) = cx.typeck_results.node_type_opt(hir_ty.hir_id) + { + ty + } else { + lower_ty(cx.tcx, hir_ty) + } } /// Checks if the given type implements copy. From ad839736ebae627aeb9cba2a870c384c67afd525 Mon Sep 17 00:00:00 2001 From: Jason Newcomb Date: Tue, 16 Jun 2026 22:00:20 -0400 Subject: [PATCH 6/6] Remove the `LateContext::typeck_results` method. --- .../rustc_hir_typeck/src/expr_use_visitor.rs | 2 +- compiler/rustc_lint/src/autorefs.rs | 4 +- compiler/rustc_lint/src/builtin.rs | 14 ++--- compiler/rustc_lint/src/context.rs | 7 +-- compiler/rustc_lint/src/dangling.rs | 4 +- .../rustc_lint/src/drop_forget_useless.rs | 2 +- .../src/enum_intrinsics_non_enums.rs | 4 +- .../src/for_loops_over_fallibles.rs | 6 +- .../src/function_cast_as_integer.rs | 4 +- .../rustc_lint/src/fuzzy_provenance_casts.rs | 2 +- compiler/rustc_lint/src/if_let_rescope.rs | 6 +- .../rustc_lint/src/interior_mutable_consts.rs | 4 +- compiler/rustc_lint/src/internal.rs | 14 ++--- compiler/rustc_lint/src/let_underscore.rs | 2 +- .../rustc_lint/src/lossy_provenance_casts.rs | 2 +- compiler/rustc_lint/src/map_unit_fn.rs | 6 +- compiler/rustc_lint/src/non_fmt_panic.rs | 4 +- compiler/rustc_lint/src/noop_method_call.rs | 10 ++-- compiler/rustc_lint/src/ptr_nulls.rs | 10 ++-- compiler/rustc_lint/src/reference_casting.rs | 10 ++-- compiler/rustc_lint/src/shadowed_into_iter.rs | 6 +- compiler/rustc_lint/src/static_mut_refs.rs | 2 +- compiler/rustc_lint/src/transmute.rs | 2 +- compiler/rustc_lint/src/types.rs | 16 ++--- compiler/rustc_lint/src/types/literal.rs | 10 ++-- compiler/rustc_lint/src/unused.rs | 4 +- compiler/rustc_lint/src/unused/must_use.rs | 6 +- compiler/rustc_lint/src/utils.rs | 2 +- .../development/common_tools_writing_lints.md | 6 +- .../book/src/development/trait_checking.md | 6 +- .../book/src/development/type_checking.md | 4 +- .../src/arc_with_non_send_sync.rs | 4 +- .../src/assertions_on_result_states.rs | 2 +- .../clippy_lints/src/assigning_clones.rs | 12 ++-- .../src/bool_assert_comparison.rs | 2 +- .../clippy_lints/src/bool_comparison.rs | 4 +- .../clippy_lints/src/bool_to_int_with_if.rs | 2 +- src/tools/clippy/clippy_lints/src/booleans.rs | 14 ++--- .../clippy_lints/src/borrow_deref_ref.rs | 4 +- .../clippy/clippy_lints/src/box_default.rs | 2 +- .../clippy_lints/src/byte_char_slices.rs | 2 +- .../clippy_lints/src/casts/as_ptr_cast_mut.rs | 4 +- .../clippy_lints/src/casts/as_underscore.rs | 2 +- .../clippy_lints/src/casts/borrow_as_ptr.rs | 2 +- .../src/casts/cast_ptr_alignment.rs | 4 +- .../clippy_lints/src/casts/cast_sign_loss.rs | 4 +- .../src/casts/cast_slice_different_sizes.rs | 4 +- .../src/casts/cast_slice_from_raw_parts.rs | 2 +- .../src/casts/manual_dangling_ptr.rs | 6 +- .../clippy/clippy_lints/src/casts/mod.rs | 4 +- .../src/casts/needless_type_cast.rs | 10 ++-- .../clippy_lints/src/casts/ref_as_ptr.rs | 6 +- .../src/casts/unnecessary_cast.rs | 10 ++-- .../src/cloned_ref_to_slice_refs.rs | 10 ++-- .../src/coerce_container_to_any.rs | 6 +- .../clippy_lints/src/cognitive_complexity.rs | 2 +- .../src/collection_is_never_read.rs | 6 +- .../clippy_lints/src/comparison_chain.rs | 2 +- src/tools/clippy/clippy_lints/src/default.rs | 4 +- .../src/default_constructed_unit_structs.rs | 2 +- .../src/default_numeric_fallback.rs | 10 ++-- .../clippy/clippy_lints/src/dereference.rs | 12 ++-- .../clippy_lints/src/disallowed_fields.rs | 4 +- .../clippy_lints/src/disallowed_methods.rs | 2 +- .../clippy_lints/src/drop_forget_ref.rs | 2 +- .../src/duration_suboptimal_units.rs | 4 +- .../clippy_lints/src/empty_with_brackets.rs | 6 +- .../clippy/clippy_lints/src/endian_bytes.rs | 2 +- src/tools/clippy/clippy_lints/src/entry.rs | 8 +-- .../clippy_lints/src/equatable_if_let.rs | 6 +- .../clippy/clippy_lints/src/eta_reduction.rs | 2 +- .../clippy/clippy_lints/src/float_literal.rs | 4 +- .../src/floating_point_arithmetic/expm1.rs | 4 +- .../src/floating_point_arithmetic/lib.rs | 2 +- .../src/floating_point_arithmetic/mod.rs | 2 +- .../src/floating_point_arithmetic/mul_add.rs | 8 +-- src/tools/clippy/clippy_lints/src/format.rs | 2 +- .../clippy/clippy_lints/src/format_args.rs | 14 ++--- .../clippy/clippy_lints/src/format_impl.rs | 2 +- .../clippy_lints/src/format_push_string.rs | 4 +- .../src/from_raw_with_void_ptr.rs | 2 +- .../clippy_lints/src/from_str_radix_10.rs | 2 +- .../src/functions/misnamed_getters.rs | 2 +- .../clippy_lints/src/functions/ref_option.rs | 2 +- .../clippy_lints/src/functions/result.rs | 2 +- .../clippy/clippy_lints/src/if_let_mutex.rs | 2 +- .../src/ifs/branches_sharing_code.rs | 4 +- .../clippy_lints/src/ifs/ifs_same_cond.rs | 2 +- .../clippy_lints/src/ignored_unit_patterns.rs | 2 +- .../clippy_lints/src/implicit_return.rs | 4 +- .../src/implicit_saturating_add.rs | 2 +- .../src/implicit_saturating_sub.rs | 12 ++-- .../clippy_lints/src/incompatible_msrv.rs | 4 +- .../src/inconsistent_struct_constructor.rs | 2 +- .../clippy_lints/src/index_refutable_slice.rs | 2 +- .../clippy_lints/src/indexing_slicing.rs | 8 +-- .../src/ineffective_open_options.rs | 2 +- .../clippy/clippy_lints/src/infinite_iter.rs | 4 +- .../clippy_lints/src/iter_over_hash_type.rs | 2 +- .../clippy/clippy_lints/src/large_futures.rs | 2 +- .../clippy_lints/src/large_stack_arrays.rs | 2 +- src/tools/clippy/clippy_lints/src/len_zero.rs | 2 +- .../clippy/clippy_lints/src/let_if_seq.rs | 2 +- .../clippy/clippy_lints/src/let_underscore.rs | 8 +-- .../src/loops/char_indices_as_byte_indices.rs | 8 +-- .../src/loops/explicit_counter_loop.rs | 2 +- .../src/loops/explicit_into_iter_loop.rs | 2 +- .../src/loops/explicit_iter_loop.rs | 2 +- .../clippy_lints/src/loops/for_kv_map.rs | 6 +- .../src/loops/for_unbounded_range.rs | 2 +- .../clippy_lints/src/loops/manual_find.rs | 4 +- .../clippy_lints/src/loops/manual_flatten.rs | 2 +- .../clippy_lints/src/loops/manual_memcpy.rs | 6 +- .../src/loops/manual_slice_fill.rs | 6 +- .../src/loops/manual_while_let_some.rs | 2 +- .../src/loops/missing_spin_loop.rs | 2 +- .../src/loops/needless_range_loop.rs | 10 ++-- .../clippy_lints/src/loops/never_loop.rs | 6 +- .../clippy_lints/src/loops/same_item_push.rs | 4 +- .../src/loops/unused_enumerate_index.rs | 4 +- .../clippy/clippy_lints/src/loops/utils.rs | 8 +-- .../clippy_lints/src/loops/while_float.rs | 2 +- .../clippy_lints/src/loops/while_let_loop.rs | 2 +- .../src/loops/while_let_on_iterator.rs | 8 +-- .../clippy_lints/src/manual_abs_diff.rs | 6 +- .../clippy_lints/src/manual_assert_eq.rs | 4 +- .../clippy/clippy_lints/src/manual_bits.rs | 2 +- .../clippy_lints/src/manual_checked_ops.rs | 2 +- .../clippy/clippy_lints/src/manual_clamp.rs | 14 ++--- .../src/manual_ignore_case_cmp.rs | 2 +- .../clippy/clippy_lints/src/manual_ilog2.rs | 4 +- .../clippy_lints/src/manual_is_ascii_check.rs | 4 +- .../src/manual_is_power_of_two.rs | 4 +- .../clippy_lints/src/manual_let_else.rs | 2 +- .../src/manual_main_separator_str.rs | 2 +- .../src/manual_option_as_slice.rs | 2 +- .../clippy/clippy_lints/src/manual_pop_if.rs | 4 +- .../clippy/clippy_lints/src/manual_retain.rs | 24 ++++---- .../clippy/clippy_lints/src/manual_rotate.rs | 2 +- .../src/manual_slice_size_calculation.rs | 4 +- .../clippy_lints/src/manual_string_new.rs | 2 +- .../clippy/clippy_lints/src/manual_strip.rs | 6 +- .../clippy/clippy_lints/src/map_unit_fn.rs | 8 +-- .../clippy_lints/src/match_result_ok.rs | 2 +- .../clippy_lints/src/matches/manual_filter.rs | 4 +- .../clippy_lints/src/matches/manual_ok_err.rs | 8 +-- .../src/matches/manual_unwrap_or.rs | 12 ++-- .../clippy_lints/src/matches/manual_utils.rs | 10 ++-- .../clippy_lints/src/matches/match_as_ref.rs | 4 +- .../clippy_lints/src/matches/match_bool.rs | 2 +- .../src/matches/match_like_matches.rs | 8 +-- .../src/matches/match_ref_pats.rs | 2 +- .../src/matches/match_same_arms.rs | 4 +- .../src/matches/match_str_case_mismatch.rs | 4 +- .../src/matches/match_wild_enum.rs | 2 +- .../src/matches/match_wild_err_arm.rs | 2 +- .../src/matches/needless_match.rs | 6 +- .../src/matches/overlapping_arms.rs | 6 +- .../src/matches/redundant_guards.rs | 4 +- .../src/matches/redundant_pattern_match.rs | 8 +-- .../matches/significant_drop_in_scrutinee.rs | 6 +- .../clippy_lints/src/matches/single_match.rs | 4 +- .../clippy_lints/src/matches/try_err.rs | 4 +- .../src/matches/wild_in_or_pats.rs | 2 +- .../clippy/clippy_lints/src/mem_replace.rs | 6 +- .../src/methods/bind_instead_of_map.rs | 2 +- .../clippy_lints/src/methods/bytecount.rs | 4 +- .../src/methods/bytes_count_to_len.rs | 4 +- .../clippy_lints/src/methods/bytes_nth.rs | 2 +- ...se_sensitive_file_extension_comparisons.rs | 6 +- .../clippy_lints/src/methods/chars_cmp.rs | 2 +- .../src/methods/clear_with_drain.rs | 4 +- .../clippy_lints/src/methods/clone_on_copy.rs | 10 ++-- .../src/methods/clone_on_ref_ptr.rs | 2 +- .../src/methods/cloned_instead_of_copied.rs | 2 +- .../src/methods/collapsible_str_replace.rs | 6 +- .../src/methods/double_ended_iterator_last.rs | 8 +-- .../clippy_lints/src/methods/drain_collect.rs | 4 +- .../clippy_lints/src/methods/err_expect.rs | 2 +- .../src/methods/expect_fun_call.rs | 6 +- .../src/methods/extend_with_drain.rs | 6 +- .../src/methods/filetype_is_file.rs | 2 +- .../clippy_lints/src/methods/filter_map.rs | 6 +- .../src/methods/filter_map_bool_then.rs | 6 +- .../clippy_lints/src/methods/filter_next.rs | 2 +- .../src/methods/flat_map_option.rs | 2 +- .../src/methods/format_collect.rs | 2 +- .../clippy_lints/src/methods/get_first.rs | 2 +- .../src/methods/get_last_with_len.rs | 2 +- .../clippy_lints/src/methods/get_unwrap.rs | 2 +- .../src/methods/implicit_clone.rs | 6 +- .../src/methods/inefficient_to_string.rs | 6 +- .../src/methods/into_iter_on_ref.rs | 2 +- .../src/methods/is_digit_ascii_radix.rs | 2 +- .../clippy_lints/src/methods/is_empty.rs | 2 +- .../src/methods/iter_cloned_collect.rs | 4 +- .../clippy_lints/src/methods/iter_count.rs | 2 +- .../clippy_lints/src/methods/iter_filter.rs | 4 +- .../clippy_lints/src/methods/iter_kv_map.rs | 2 +- .../src/methods/iter_next_slice.rs | 6 +- .../clippy_lints/src/methods/iter_nth.rs | 4 +- .../iter_on_single_or_empty_collections.rs | 2 +- .../src/methods/iter_out_of_bounds.rs | 4 +- .../src/methods/iter_overeager_cloned.rs | 2 +- .../src/methods/iter_with_drain.rs | 2 +- .../src/methods/join_absolute_paths.rs | 2 +- .../src/methods/lines_filter_map_ok.rs | 4 +- .../clippy_lints/src/methods/manual_clear.rs | 2 +- .../src/methods/manual_contains.rs | 4 +- .../src/methods/manual_inspect.rs | 4 +- .../src/methods/manual_is_variant_and.rs | 14 ++--- .../src/methods/manual_next_back.rs | 2 +- .../clippy_lints/src/methods/manual_ok_or.rs | 2 +- .../src/methods/manual_option_zip.rs | 4 +- .../src/methods/manual_repeat_n.rs | 2 +- .../methods/manual_saturating_arithmetic.rs | 6 +- .../src/methods/manual_str_repeat.rs | 6 +- .../src/methods/manual_try_fold.rs | 2 +- .../clippy_lints/src/methods/map_clone.rs | 14 ++--- .../src/methods/map_collect_result_unit.rs | 2 +- .../src/methods/map_err_ignore.rs | 2 +- .../clippy_lints/src/methods/map_flatten.rs | 4 +- .../clippy_lints/src/methods/map_identity.rs | 4 +- .../src/methods/map_or_identity.rs | 2 +- .../clippy_lints/src/methods/map_unwrap_or.rs | 6 +- .../src/methods/map_unwrap_or_else.rs | 2 +- .../src/methods/mut_mutex_lock.rs | 4 +- .../src/methods/needless_as_bytes.rs | 2 +- .../methods/needless_character_iteration.rs | 4 +- .../src/methods/needless_collect.rs | 22 +++---- .../src/methods/needless_option_as_deref.rs | 2 +- .../src/methods/needless_option_take.rs | 2 +- .../src/methods/no_effect_replace.rs | 2 +- .../src/methods/obfuscated_if_else.rs | 2 +- .../clippy_lints/src/methods/ok_expect.rs | 2 +- .../clippy_lints/src/methods/open_options.rs | 6 +- .../src/methods/option_as_ref_cloned.rs | 2 +- .../src/methods/option_as_ref_deref.rs | 6 +- .../src/methods/option_map_or_none.rs | 4 +- .../clippy_lints/src/methods/or_fun_call.rs | 6 +- .../src/methods/or_then_unwrap.rs | 2 +- .../src/methods/path_buf_push_overwrite.rs | 2 +- .../src/methods/path_ends_with_ext.rs | 2 +- .../src/methods/ptr_offset_by_literal.rs | 2 +- .../src/methods/ptr_offset_with_cast.rs | 4 +- .../src/methods/read_line_without_trim.rs | 4 +- .../src/methods/readonly_write_lock.rs | 4 +- .../src/methods/redundant_as_str.rs | 2 +- .../clippy_lints/src/methods/repeat_once.rs | 2 +- .../src/methods/result_map_or_else_none.rs | 2 +- .../src/methods/return_and_then.rs | 2 +- .../src/methods/search_is_some.rs | 2 +- .../src/methods/seek_from_current.rs | 2 +- .../seek_to_start_instead_of_rewind.rs | 2 +- .../src/methods/single_char_add_str.rs | 6 +- .../src/methods/sliced_string_as_bytes.rs | 2 +- .../src/methods/stable_sort_primitive.rs | 2 +- .../clippy_lints/src/methods/str_split.rs | 2 +- .../clippy_lints/src/methods/str_splitn.rs | 10 ++-- .../src/methods/string_extend_chars.rs | 4 +- .../methods/suspicious_command_arg_space.rs | 2 +- .../src/methods/suspicious_map.rs | 2 +- .../src/methods/suspicious_splitn.rs | 2 +- .../src/methods/suspicious_to_owned.rs | 4 +- .../src/methods/swap_with_temporary.rs | 2 +- .../src/methods/type_id_on_box.rs | 2 +- .../src/methods/unbuffered_bytes.rs | 2 +- .../src/methods/uninit_assumed_init.rs | 2 +- .../clippy_lints/src/methods/unit_hash.rs | 2 +- .../unnecessary_fallible_conversions.rs | 4 +- .../src/methods/unnecessary_filter_map.rs | 6 +- .../methods/unnecessary_first_then_check.rs | 2 +- .../src/methods/unnecessary_fold.rs | 6 +- .../src/methods/unnecessary_get_then_check.rs | 2 +- .../src/methods/unnecessary_iter_cloned.rs | 4 +- .../src/methods/unnecessary_join.rs | 2 +- .../src/methods/unnecessary_lazy_eval.rs | 6 +- .../src/methods/unnecessary_literal_unwrap.rs | 2 +- .../src/methods/unnecessary_map_or.rs | 2 +- .../src/methods/unnecessary_map_or_else.rs | 2 +- .../src/methods/unnecessary_min_or_max.rs | 4 +- .../src/methods/unnecessary_sort_by.rs | 8 +-- .../src/methods/unnecessary_to_owned.rs | 44 +++++++------- .../src/methods/unwrap_expect_used.rs | 4 +- .../clippy_lints/src/methods/useless_asref.rs | 16 ++--- .../methods/useless_nonzero_new_unchecked.rs | 2 +- .../clippy/clippy_lints/src/methods/utils.rs | 4 +- .../src/methods/vec_resize_to_zero.rs | 2 +- .../src/methods/verbose_file_reads.rs | 2 +- .../src/methods/waker_clone_wake.rs | 2 +- .../clippy_lints/src/methods/zst_offset.rs | 2 +- src/tools/clippy/clippy_lints/src/minmax.rs | 6 +- src/tools/clippy/clippy_lints/src/misc.rs | 4 +- .../src/missing_asserts_for_indexing.rs | 6 +- .../src/missing_fields_in_debug.rs | 2 +- .../src/mixed_read_write_in_expression.rs | 4 +- .../src/multiple_unsafe_ops_per_block.rs | 2 +- src/tools/clippy/clippy_lints/src/mut_key.rs | 2 +- src/tools/clippy/clippy_lints/src/mut_mut.rs | 2 +- .../src/mutable_debug_assertion.rs | 2 +- .../clippy/clippy_lints/src/mutex_atomic.rs | 2 +- .../src/needless_borrows_for_generic_args.rs | 12 ++-- .../clippy_lints/src/needless_continue.rs | 2 +- .../clippy_lints/src/needless_for_each.rs | 2 +- .../clippy_lints/src/needless_late_init.rs | 6 +- .../src/needless_pass_by_ref_mut.rs | 2 +- .../src/needless_question_mark.rs | 4 +- .../clippy_lints/src/needless_update.rs | 2 +- .../src/neg_cmp_op_on_partial_ord.rs | 2 +- .../clippy/clippy_lints/src/neg_multiply.rs | 4 +- .../clippy/clippy_lints/src/no_effect.rs | 14 ++--- .../clippy/clippy_lints/src/non_copy_const.rs | 2 +- .../src/non_octal_unix_permissions.rs | 2 +- .../clippy_lints/src/non_std_lazy_statics.rs | 2 +- .../clippy_lints/src/non_zero_suggestions.rs | 4 +- .../src/only_used_in_recursion.rs | 2 +- .../operators/absurd_extreme_comparisons.rs | 8 +-- .../src/operators/arithmetic_side_effects.rs | 14 ++--- .../src/operators/assign_op_pattern.rs | 6 +- .../clippy_lints/src/operators/bit_mask.rs | 2 +- .../clippy_lints/src/operators/cmp_owned.rs | 2 +- .../src/operators/const_comparisons.rs | 2 +- .../src/operators/duration_subsec.rs | 2 +- .../clippy_lints/src/operators/eq_op.rs | 2 +- .../clippy_lints/src/operators/erasing_op.rs | 2 +- .../clippy_lints/src/operators/float_cmp.rs | 4 +- .../operators/float_equality_without_abs.rs | 4 +- .../clippy_lints/src/operators/identity_op.rs | 10 ++-- .../src/operators/integer_division.rs | 4 +- .../integer_division_remainder_used.rs | 4 +- .../operators/invalid_upcast_comparisons.rs | 4 +- .../src/operators/manual_div_ceil.rs | 10 ++-- .../src/operators/manual_is_multiple_of.rs | 8 +-- .../operators/manual_isolate_lowest_one.rs | 8 +-- .../src/operators/manual_midpoint.rs | 4 +- .../src/operators/modulo_arithmetic.rs | 4 +- .../src/operators/needless_bitwise_bool.rs | 2 +- .../src/operators/numeric_arithmetic.rs | 4 +- .../clippy_lints/src/operators/op_ref.rs | 20 +++---- .../clippy_lints/src/option_if_let_else.rs | 14 ++--- .../src/panicking_overflow_checks.rs | 2 +- .../clippy_lints/src/partialeq_to_none.rs | 2 +- .../src/pathbuf_init_then_push.rs | 4 +- .../clippy_lints/src/pattern_type_mismatch.rs | 2 +- .../src/permissions_set_readonly_false.rs | 2 +- .../src/pointers_in_nomem_asm_block.rs | 2 +- .../clippy/clippy_lints/src/ptr/ptr_arg.rs | 2 +- .../clippy/clippy_lints/src/ptr/ptr_eq.rs | 6 +- .../clippy/clippy_lints/src/question_mark.rs | 10 ++-- src/tools/clippy/clippy_lints/src/ranges.rs | 14 ++--- .../clippy_lints/src/rc_clone_in_vec_init.rs | 2 +- .../clippy_lints/src/redundant_async_block.rs | 4 +- .../clippy_lints/src/redundant_locals.rs | 2 +- .../clippy_lints/src/redundant_slicing.rs | 10 ++-- .../src/redundant_type_annotations.rs | 2 +- .../clippy/clippy_lints/src/reference.rs | 4 +- .../clippy/clippy_lints/src/replace_box.rs | 2 +- .../src/returns/let_and_return.rs | 2 +- .../src/returns/needless_return.rs | 2 +- .../needless_return_with_question_mark.rs | 2 +- .../src/same_length_and_capacity.rs | 2 +- .../src/semicolon_if_nothing_returned.rs | 2 +- .../src/set_contains_or_insert.rs | 6 +- .../src/significant_drop_tightening.rs | 2 +- .../clippy_lints/src/single_option_map.rs | 2 +- .../src/single_range_in_vec_init.rs | 4 +- .../src/size_of_in_element_count.rs | 6 +- .../clippy/clippy_lints/src/size_of_ref.rs | 2 +- .../clippy_lints/src/string_patterns.rs | 4 +- src/tools/clippy/clippy_lints/src/strings.rs | 10 ++-- .../clippy_lints/src/strlen_on_c_strings.rs | 2 +- src/tools/clippy/clippy_lints/src/swap.rs | 2 +- .../clippy_lints/src/swap_ptr_to_ref.rs | 2 +- .../clippy_lints/src/time_subtraction.rs | 4 +- .../clippy_lints/src/to_digit_is_some.rs | 2 +- .../src/transmute/eager_transmute.rs | 4 +- .../clippy/clippy_lints/src/transmute/mod.rs | 6 +- .../src/tuple_array_conversions.rs | 6 +- .../src/unconditional_recursion.rs | 16 ++--- .../src/uninhabited_references.rs | 2 +- .../clippy/clippy_lints/src/uninit_vec.rs | 6 +- .../src/unit_return_expecting_ord.rs | 4 +- .../src/unit_types/let_unit_value.rs | 4 +- .../clippy_lints/src/unit_types/unit_arg.rs | 2 +- .../clippy_lints/src/unit_types/unit_cmp.rs | 4 +- .../src/unnecessary_map_on_constructor.rs | 2 +- .../src/unnecessary_mut_passed.rs | 6 +- .../src/unnecessary_owned_empty_strings.rs | 4 +- .../clippy_lints/src/unnecessary_semicolon.rs | 4 +- .../src/unnecessary_struct_initialization.rs | 10 ++-- .../clippy_lints/src/unused_io_amount.rs | 2 +- .../clippy_lints/src/unused_peekable.rs | 6 +- .../clippy_lints/src/unused_result_ok.rs | 2 +- src/tools/clippy/clippy_lints/src/unwrap.rs | 4 +- .../clippy_lints/src/unwrap_in_result.rs | 4 +- src/tools/clippy/clippy_lints/src/use_self.rs | 4 +- .../clippy_lints/src/useless_conversion.rs | 32 +++++----- .../clippy/clippy_lints/src/useless_vec.rs | 6 +- .../clippy_lints/src/vec_init_then_push.rs | 4 +- .../clippy_lints/src/volatile_composites.rs | 4 +- .../clippy_lints/src/with_capacity_zero.rs | 2 +- .../src/zero_repeat_side_effects.rs | 4 +- .../clippy_lints/src/zombie_processes.rs | 2 +- .../src/outer_expn_data_pass.rs | 2 +- .../src/repeated_is_diagnostic_item.rs | 8 +-- .../clippy_lints_internal/src/symbols.rs | 4 +- .../src/unusual_names.rs | 2 +- src/tools/clippy/clippy_utils/src/consts.rs | 4 +- .../clippy/clippy_utils/src/eager_or_lazy.rs | 22 +++---- src/tools/clippy/clippy_utils/src/higher.rs | 4 +- src/tools/clippy/clippy_utils/src/lib.rs | 60 +++++++++---------- src/tools/clippy/clippy_utils/src/sugg.rs | 6 +- src/tools/clippy/clippy_utils/src/ty/mod.rs | 2 +- .../clippy_utils/src/ty/type_certainty/mod.rs | 8 +-- src/tools/clippy/clippy_utils/src/visitors.rs | 20 +++---- 415 files changed, 982 insertions(+), 987 deletions(-) diff --git a/compiler/rustc_hir_typeck/src/expr_use_visitor.rs b/compiler/rustc_hir_typeck/src/expr_use_visitor.rs index e1f5db900a6ca..a536cfcc0efd0 100644 --- a/compiler/rustc_hir_typeck/src/expr_use_visitor.rs +++ b/compiler/rustc_hir_typeck/src/expr_use_visitor.rs @@ -234,7 +234,7 @@ impl<'tcx> TypeInformationCtxt<'tcx> for (&LateContext<'tcx>, LocalDefId) { type Error = !; fn typeck_results(&self) -> Self::TypeckResults<'_> { - self.0.typeck_results() + self.0.typeck_results } fn structurally_resolve_type(&self, _span: Span, ty: Ty<'tcx>) -> Ty<'tcx> { diff --git a/compiler/rustc_lint/src/autorefs.rs b/compiler/rustc_lint/src/autorefs.rs index 24759f3ee4a01..009f6390a50b7 100644 --- a/compiler/rustc_lint/src/autorefs.rs +++ b/compiler/rustc_lint/src/autorefs.rs @@ -88,7 +88,7 @@ impl<'tcx> LateLintPass<'tcx> for ImplicitAutorefs { _ => return, }; - let typeck = cx.typeck_results(); + let typeck = cx.typeck_results; let adjustments_table = typeck.adjustments(); if let Some(adjustments) = adjustments_table.get(inner.hir_id) @@ -104,7 +104,7 @@ impl<'tcx> LateLintPass<'tcx> for ImplicitAutorefs { && typeck.expr_ty(dereferenced).is_raw_ptr() && let method_did = match expr.kind { // PERF: 5. b. A method call annotated with `#[rustc_no_implicit_refs]` - ExprKind::MethodCall(..) => cx.typeck_results().type_dependent_def_id(expr.hir_id), + ExprKind::MethodCall(..) => cx.typeck_results.type_dependent_def_id(expr.hir_id), _ => None, } && method_did.map(|did| find_attr!(cx.tcx, did, RustcNoImplicitAutorefs)).unwrap_or(true) diff --git a/compiler/rustc_lint/src/builtin.rs b/compiler/rustc_lint/src/builtin.rs index 383023aa24457..2218f0a0e5de9 100644 --- a/compiler/rustc_lint/src/builtin.rs +++ b/compiler/rustc_lint/src/builtin.rs @@ -151,10 +151,10 @@ impl<'tcx> LateLintPass<'tcx> for NonShorthandFieldPatterns { fn check_pat(&mut self, cx: &LateContext<'_>, pat: &hir::Pat<'_>) { // The result shouldn't be tainted, otherwise it will cause ICE. if let PatKind::Struct(ref qpath, field_pats, _) = pat.kind - && cx.typeck_results().tainted_by_errors.is_none() + && cx.typeck_results.tainted_by_errors.is_none() { let variant = cx - .typeck_results() + .typeck_results .pat_ty(pat) .ty_adt_def() .expect("struct pattern type is not an ADT") @@ -171,7 +171,7 @@ impl<'tcx> LateLintPass<'tcx> for NonShorthandFieldPatterns { } if let PatKind::Binding(binding_annot, _, ident, None) = fieldpat.pat.kind { if cx.tcx.find_field_index(ident, variant) - == Some(cx.typeck_results().field_index(fieldpat.hir_id)) + == Some(cx.typeck_results.field_index(fieldpat.hir_id)) { cx.emit_span_lint( NON_SHORTHAND_FIELD_PATTERNS, @@ -1016,7 +1016,7 @@ impl<'tcx> LateLintPass<'tcx> for MutableTransmutes { if !def_id_is_transmute(cx, did) { return None; } - let sig = cx.typeck_results().node_type(expr.hir_id).fn_sig(cx.tcx); + let sig = cx.typeck_results.node_type(expr.hir_id).fn_sig(cx.tcx); let from = sig.inputs().skip_binder()[0]; let to = sig.output().skip_binder(); return Some((from, to)); @@ -2390,7 +2390,7 @@ impl<'tcx> LateLintPass<'tcx> for InvalidValue { } } else if let hir::ExprKind::MethodCall(_, receiver, ..) = expr.kind { // Find problematic calls to `MaybeUninit::assume_init`. - let def_id = cx.typeck_results().type_dependent_def_id(expr.hir_id)?; + let def_id = cx.typeck_results.type_dependent_def_id(expr.hir_id)?; if cx.tcx.is_diagnostic_item(sym::assume_init, def_id) { // This is a call to *some* method named `assume_init`. // See if the `self` parameter is one of the dangerous constructors. @@ -2594,7 +2594,7 @@ impl<'tcx> LateLintPass<'tcx> for InvalidValue { // This conjures an instance of a type out of nothing, // using zeroed or uninitialized memory. // We are extremely conservative with what we warn about. - let conjured_ty = cx.typeck_results().expr_ty(expr); + let conjured_ty = cx.typeck_results.expr_ty(expr); if let Some(err) = with_no_trimmed_paths!(ty_find_init_error(cx, conjured_ty, init)) { let msg = match init { InitKind::Zeroed => { @@ -2656,7 +2656,7 @@ impl<'tcx> LateLintPass<'tcx> for DerefNullPtr { fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &hir::Expr<'_>) { /// test if expression is a null ptr fn is_null_ptr(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> bool { - let pointer_ty = cx.typeck_results().expr_ty(expr); + let pointer_ty = cx.typeck_results.expr_ty(expr); let ty::RawPtr(pointee, _) = pointer_ty.kind() else { return false; }; diff --git a/compiler/rustc_lint/src/context.rs b/compiler/rustc_lint/src/context.rs index 95914c94b3839..bb894dbf4ddfe 100644 --- a/compiler/rustc_lint/src/context.rs +++ b/compiler/rustc_lint/src/context.rs @@ -660,13 +660,8 @@ impl<'tcx> LateContext<'tcx> { self.tcx.type_is_use_cloned_modulo_regions(self.typing_env(), ty) } - #[inline] - pub fn typeck_results(&self) -> &'tcx ty::TypeckResults<'tcx> { - self.typeck_results - } - /// Returns the final resolution of a `QPath`, or `Res::Err` if unavailable. - /// Unlike `.typeck_results().qpath_res(qpath, id)`, this can be used even outside + /// Unlike `.typeck_results.qpath_res(qpath, id)`, this can be used even outside /// bodies (e.g. for paths in `hir::Ty`), without any risk of ICE-ing. pub fn qpath_res(&self, qpath: &hir::QPath<'_>, id: hir::HirId) -> Res { match *qpath { diff --git a/compiler/rustc_lint/src/dangling.rs b/compiler/rustc_lint/src/dangling.rs index cb5c2adf19aa8..2ff4ed8791046 100644 --- a/compiler/rustc_lint/src/dangling.rs +++ b/compiler/rustc_lint/src/dangling.rs @@ -264,9 +264,9 @@ impl DanglingPointerSearcher<'_, '_> { fn lint_expr(cx: &LateContext<'_>, expr: &Expr<'_>) { if let ExprKind::MethodCall(method, receiver, _args, _span) = expr.kind && is_temporary_rvalue(receiver) - && let ty = cx.typeck_results().expr_ty(receiver) + && let ty = cx.typeck_results.expr_ty(receiver) && owns_allocation(cx.tcx, ty) - && let Some(fn_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) + && let Some(fn_id) = cx.typeck_results.type_dependent_def_id(expr.hir_id) && find_attr!(cx.tcx, fn_id, RustcAsPtr) { cx.tcx.emit_node_span_lint( diff --git a/compiler/rustc_lint/src/drop_forget_useless.rs b/compiler/rustc_lint/src/drop_forget_useless.rs index c2d137986ce4d..ce5de672797d5 100644 --- a/compiler/rustc_lint/src/drop_forget_useless.rs +++ b/compiler/rustc_lint/src/drop_forget_useless.rs @@ -143,7 +143,7 @@ impl<'tcx> LateLintPass<'tcx> for DropForgetUseless { && let Some(def_id) = cx.qpath_res(qpath, path.hir_id).opt_def_id() && let Some(fn_name) = cx.tcx.get_diagnostic_name(def_id) { - let arg_ty = cx.typeck_results().expr_ty(arg); + let arg_ty = cx.typeck_results.expr_ty(arg); let is_copy = cx.type_is_copy_modulo_regions(arg_ty); let drop_is_single_call_in_arm = is_single_call_in_arm(cx, arg, expr); let let_underscore_ignore_sugg = || { diff --git a/compiler/rustc_lint/src/enum_intrinsics_non_enums.rs b/compiler/rustc_lint/src/enum_intrinsics_non_enums.rs index 179f2bcf07f59..28ce779838451 100644 --- a/compiler/rustc_lint/src/enum_intrinsics_non_enums.rs +++ b/compiler/rustc_lint/src/enum_intrinsics_non_enums.rs @@ -51,7 +51,7 @@ fn enforce_mem_discriminant( expr_span: Span, args_span: Span, ) { - let ty_param = cx.typeck_results().node_args(func_expr.hir_id).type_at(0); + let ty_param = cx.typeck_results.node_args(func_expr.hir_id).type_at(0); if is_non_enum(ty_param) { cx.emit_span_lint( ENUM_INTRINSICS_NON_ENUMS, @@ -62,7 +62,7 @@ fn enforce_mem_discriminant( } fn enforce_mem_variant_count(cx: &LateContext<'_>, func_expr: &hir::Expr<'_>, span: Span) { - let ty_param = cx.typeck_results().node_args(func_expr.hir_id).type_at(0); + let ty_param = cx.typeck_results.node_args(func_expr.hir_id).type_at(0); if is_non_enum(ty_param) { cx.emit_span_lint(ENUM_INTRINSICS_NON_ENUMS, span, EnumIntrinsicsMemVariant { ty_param }); } diff --git a/compiler/rustc_lint/src/for_loops_over_fallibles.rs b/compiler/rustc_lint/src/for_loops_over_fallibles.rs index a7c5943c250b8..0a4af5891970e 100644 --- a/compiler/rustc_lint/src/for_loops_over_fallibles.rs +++ b/compiler/rustc_lint/src/for_loops_over_fallibles.rs @@ -56,7 +56,7 @@ impl<'tcx> LateLintPass<'tcx> for ForLoopsOverFallibles { let arg_span = arg.span.source_callsite(); - let ty = cx.typeck_results().expr_ty(arg); + let ty = cx.typeck_results.expr_ty(arg); let (adt, args, ref_mutability) = match ty.kind() { &ty::Adt(adt, args) => (adt, args, None), @@ -136,7 +136,7 @@ fn extract_iterator_next_call<'tcx>( // This won't work for `Iterator::next(iter)`, is this an issue? if let hir::ExprKind::MethodCall(_, recv, _, _) = expr.kind && cx - .typeck_results() + .typeck_results .type_dependent_def_id(expr.hir_id) .is_some_and(|def_id| cx.tcx.is_lang_item(def_id, LangItem::IteratorNext)) { @@ -164,7 +164,7 @@ fn suggest_question_mark<'tcx>( // Check that the function/closure/constant we are in has a `Result` type. // Otherwise suggesting using `?` may not be a good idea. { - let ty = cx.typeck_results().expr_ty(cx.tcx.hir_body(body_id).value); + let ty = cx.typeck_results.expr_ty(cx.tcx.hir_body(body_id).value); let ty::Adt(ret_adt, ..) = ty.kind() else { return false }; if !cx.tcx.is_diagnostic_item(sym::Result, ret_adt.did()) { return false; diff --git a/compiler/rustc_lint/src/function_cast_as_integer.rs b/compiler/rustc_lint/src/function_cast_as_integer.rs index 2a4ff1f63db52..28bf47bdfa6a9 100644 --- a/compiler/rustc_lint/src/function_cast_as_integer.rs +++ b/compiler/rustc_lint/src/function_cast_as_integer.rs @@ -37,7 +37,7 @@ declare_lint_pass!( impl<'tcx> LateLintPass<'tcx> for FunctionCastsAsInteger { fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'tcx>) { let hir::ExprKind::Cast(cast_from_expr, cast_to_expr) = expr.kind else { return }; - let cast_to_ty = cx.typeck_results().expr_ty(expr); + let cast_to_ty = cx.typeck_results.expr_ty(expr); // Casting to a function (pointer?), so all good. // // Normally, only casts to integers is possible, but if it ever changed, this condition @@ -45,7 +45,7 @@ impl<'tcx> LateLintPass<'tcx> for FunctionCastsAsInteger { if matches!(cast_to_ty.kind(), ty::FnDef(..) | ty::FnPtr(..) | ty::RawPtr(..)) { return; } - let cast_from_ty = cx.typeck_results().expr_ty(cast_from_expr); + let cast_from_ty = cx.typeck_results.expr_ty(cast_from_expr); if matches!(cast_from_ty.kind(), ty::FnDef(..)) { cx.tcx.emit_node_span_lint( FUNCTION_CASTS_AS_INTEGER, diff --git a/compiler/rustc_lint/src/fuzzy_provenance_casts.rs b/compiler/rustc_lint/src/fuzzy_provenance_casts.rs index 699004a3b37e0..bcf9848c84c9d 100644 --- a/compiler/rustc_lint/src/fuzzy_provenance_casts.rs +++ b/compiler/rustc_lint/src/fuzzy_provenance_casts.rs @@ -57,7 +57,7 @@ impl<'tcx> LateLintPass<'tcx> for FuzzyProvenanceCasts { fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'tcx>) { let hir::ExprKind::Cast(cast_from_expr, cast_to_hir) = expr.kind else { return }; - let typeck_results = cx.typeck_results(); + let typeck_results = cx.typeck_results; // Only lint casts from integer to pointer let cast_from_ty = typeck_results.expr_ty(cast_from_expr); if !cast_from_ty.is_integral() { diff --git a/compiler/rustc_lint/src/if_let_rescope.rs b/compiler/rustc_lint/src/if_let_rescope.rs index cc8229b3f387b..dfa027d1daf08 100644 --- a/compiler/rustc_lint/src/if_let_rescope.rs +++ b/compiler/rustc_lint/src/if_let_rescope.rs @@ -425,7 +425,7 @@ impl<'tcx> FindSignificantDropper<'_, 'tcx> { ) -> ControlFlow<(Span, SmallVec<[Ty<'tcx>; 4]>)> { if expr.is_place_expr(|base| { self.cx - .typeck_results() + .typeck_results .adjustments() .get(base.hir_id) .is_some_and(|x| x.iter().any(|adj| matches!(adj.kind, Adjust::Deref(_)))) @@ -436,7 +436,7 @@ impl<'tcx> FindSignificantDropper<'_, 'tcx> { let drop_tys = extract_component_with_significant_dtor( self.cx.tcx, self.cx.typing_env(), - self.cx.typeck_results().expr_ty(expr), + self.cx.typeck_results.expr_ty(expr), ); if drop_tys.is_empty() { return ControlFlow::Continue(()); @@ -460,7 +460,7 @@ impl<'tcx> Visitor<'tcx> for FindSignificantDropper<'_, 'tcx> { // Check for promoted temporaries from autoref, e.g. // `if let None = TypeWithDrop.as_ref() {} else {}` // where `fn as_ref(&self) -> Option<...>`. - for adj in self.cx.typeck_results().expr_adjustments(expr) { + for adj in self.cx.typeck_results.expr_adjustments(expr) { match adj.kind { // Skip when we hit the first deref expr. Adjust::Deref(_) => break, diff --git a/compiler/rustc_lint/src/interior_mutable_consts.rs b/compiler/rustc_lint/src/interior_mutable_consts.rs index 27b2a0b03c577..c308957445514 100644 --- a/compiler/rustc_lint/src/interior_mutable_consts.rs +++ b/compiler/rustc_lint/src/interior_mutable_consts.rs @@ -50,7 +50,7 @@ declare_lint_pass!(InteriorMutableConsts => [CONST_ITEM_INTERIOR_MUTATIONS]); impl<'tcx> LateLintPass<'tcx> for InteriorMutableConsts { fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) { - let typeck = cx.typeck_results(); + let typeck = cx.typeck_results; let (method_did, receiver) = match expr.kind { // matching on `.method(..)` @@ -80,7 +80,7 @@ impl<'tcx> LateLintPass<'tcx> for InteriorMutableConsts { // Don't consider derefs as those can do arbitrary things // like using thread local (see rust-lang/rust#150157) && !cx - .typeck_results() + .typeck_results .expr_adjustments(receiver) .into_iter() .any(|adj| matches!(adj.kind, Adjust::Deref(_))) diff --git a/compiler/rustc_lint/src/internal.rs b/compiler/rustc_lint/src/internal.rs index e10ee05e01d91..566b35a1eec55 100644 --- a/compiler/rustc_lint/src/internal.rs +++ b/compiler/rustc_lint/src/internal.rs @@ -167,15 +167,15 @@ fn get_callee_span_generic_args_and_args<'tcx>( expr: &'tcx Expr<'tcx>, ) -> Option<(DefId, Span, GenericArgsRef<'tcx>, Option<&'tcx Expr<'tcx>>, &'tcx [Expr<'tcx>])> { if let ExprKind::Call(callee, args) = expr.kind - && let callee_ty = cx.typeck_results().expr_ty(callee) + && let callee_ty = cx.typeck_results.expr_ty(callee) && let ty::FnDef(callee_def_id, generic_args) = callee_ty.kind() { return Some((*callee_def_id, callee.span, generic_args, None, args)); } if let ExprKind::MethodCall(segment, recv, args, _) = expr.kind - && let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) + && let Some(method_def_id) = cx.typeck_results.type_dependent_def_id(expr.hir_id) { - let generic_args = cx.typeck_results().node_args(expr.hir_id); + let generic_args = cx.typeck_results.node_args(expr.hir_id); return Some((method_def_id, segment.ident.span, generic_args, Some(recv), args)); } None @@ -381,7 +381,7 @@ impl<'tcx> LateLintPass<'tcx> for TypeIr { let res_def_id = match expr.kind { hir::ExprKind::Path(hir::QPath::Resolved(_, path)) => path.res.opt_def_id(), hir::ExprKind::Path(hir::QPath::TypeRelative(..)) | hir::ExprKind::MethodCall(..) => { - cx.typeck_results().type_dependent_def_id(expr.hir_id) + cx.typeck_results.type_dependent_def_id(expr.hir_id) } _ => return, }; @@ -507,7 +507,7 @@ declare_lint_pass!(BadOptAccess => [BAD_OPT_ACCESS]); impl LateLintPass<'_> for BadOptAccess { fn check_expr(&mut self, cx: &LateContext<'_>, expr: &hir::Expr<'_>) { let hir::ExprKind::Field(base, target) = expr.kind else { return }; - let Some(adt_def) = cx.typeck_results().expr_ty(base).ty_adt_def() else { return }; + let Some(adt_def) = cx.typeck_results.expr_ty(base).ty_adt_def() else { return }; // Skip types without `#[rustc_lint_opt_ty]` - only so that the rest of the lint can be // avoided. if !find_attr!(cx.tcx, adt_def.did(), RustcLintOptTy) { @@ -555,7 +555,7 @@ impl<'tcx> LateLintPass<'tcx> for SpanUseEqCtxt { fn is_span_ctxt_call(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> bool { match &expr.kind { hir::ExprKind::MethodCall(..) => cx - .typeck_results() + .typeck_results .type_dependent_def_id(expr.hir_id) .is_some_and(|call_did| cx.tcx.is_diagnostic_item(sym::SpanCtxt, call_did)), @@ -728,7 +728,7 @@ declare_tool_lint! { declare_lint_pass!(RustcMustMatchExhaustively => [RUSTC_MUST_MATCH_EXHAUSTIVELY]); fn is_rustc_must_match_exhaustively(cx: &LateContext<'_>, id: HirId) -> Option { - let res = cx.typeck_results(); + let res = cx.typeck_results; let ty = res.node_type(id); diff --git a/compiler/rustc_lint/src/let_underscore.rs b/compiler/rustc_lint/src/let_underscore.rs index d061a56c93461..dce7dad4870c9 100644 --- a/compiler/rustc_lint/src/let_underscore.rs +++ b/compiler/rustc_lint/src/let_underscore.rs @@ -124,7 +124,7 @@ impl<'tcx> LateLintPass<'tcx> for LetUnderscore { return; } - let ty = cx.typeck_results().pat_ty(pat); + let ty = cx.typeck_results.pat_ty(pat); // If the type has a trivial Drop implementation, then it doesn't // matter that we drop the value immediately. diff --git a/compiler/rustc_lint/src/lossy_provenance_casts.rs b/compiler/rustc_lint/src/lossy_provenance_casts.rs index bdb5bdf6bb0e3..758336ba847a3 100644 --- a/compiler/rustc_lint/src/lossy_provenance_casts.rs +++ b/compiler/rustc_lint/src/lossy_provenance_casts.rs @@ -60,7 +60,7 @@ impl<'tcx> LateLintPass<'tcx> for LossyProvenanceCasts { fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'tcx>) { let hir::ExprKind::Cast(cast_from_expr, cast_to_hir) = expr.kind else { return }; - let typeck_results = cx.typeck_results(); + let typeck_results = cx.typeck_results; // Only lint casts from pointer to integer let cast_from_ty = typeck_results.expr_ty(cast_from_expr); if !cast_from_ty.is_raw_ptr() { diff --git a/compiler/rustc_lint/src/map_unit_fn.rs b/compiler/rustc_lint/src/map_unit_fn.rs index 50471b40ecdea..4f8995f578413 100644 --- a/compiler/rustc_lint/src/map_unit_fn.rs +++ b/compiler/rustc_lint/src/map_unit_fn.rs @@ -52,13 +52,13 @@ impl<'tcx> LateLintPass<'tcx> for MapUnitFn { || arg.span.from_expansion() || !is_impl_slice(cx, receiver) || !cx - .typeck_results() + .typeck_results .type_dependent_def_id(expr.hir_id) .is_some_and(|id| cx.tcx.is_diagnostic_item(sym::IteratorMap, id)) { return; } - let (id, sig) = match *cx.typeck_results().expr_ty(arg).kind() { + let (id, sig) = match *cx.typeck_results.expr_ty(arg).kind() { ty::Closure(id, subs) => (id, subs.as_closure().sig()), ty::FnDef(id, _) => (id, cx.tcx.fn_sig(id).skip_binder()), _ => return, @@ -81,7 +81,7 @@ impl<'tcx> LateLintPass<'tcx> for MapUnitFn { } fn is_impl_slice(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool { - if let Some(method_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) + if let Some(method_id) = cx.typeck_results.type_dependent_def_id(expr.hir_id) && let Some(impl_id) = cx.tcx.impl_of_assoc(method_id) { return cx.tcx.type_of(impl_id).skip_binder().is_slice(); diff --git a/compiler/rustc_lint/src/non_fmt_panic.rs b/compiler/rustc_lint/src/non_fmt_panic.rs index 7f137d5bf0603..ee6615dc3c1d1 100644 --- a/compiler/rustc_lint/src/non_fmt_panic.rs +++ b/compiler/rustc_lint/src/non_fmt_panic.rs @@ -49,7 +49,7 @@ declare_lint_pass!(NonPanicFmt => [NON_FMT_PANICS]); impl<'tcx> LateLintPass<'tcx> for NonPanicFmt { fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'tcx>) { if let hir::ExprKind::Call(f, [arg]) = &expr.kind - && let &ty::FnDef(def_id, _) = cx.typeck_results().expr_ty(f).kind() + && let &ty::FnDef(def_id, _) = cx.typeck_results.expr_ty(f).kind() { let f_diagnostic_name = cx.tcx.get_diagnostic_name(def_id); @@ -121,7 +121,7 @@ impl<'a, 'b, 'tcx> Diagnostic<'a, ()> for PanicMessageNotLiteral<'b, 'tcx> { ); } } else { - let ty = cx.typeck_results().expr_ty(arg); + let ty = cx.typeck_results.expr_ty(arg); // If this is a &str or String, we can confidently give the `"{}", ` suggestion. let is_str = matches!( ty.kind(), diff --git a/compiler/rustc_lint/src/noop_method_call.rs b/compiler/rustc_lint/src/noop_method_call.rs index 6ea72de92ce8c..ea3b4474e4c13 100644 --- a/compiler/rustc_lint/src/noop_method_call.rs +++ b/compiler/rustc_lint/src/noop_method_call.rs @@ -80,7 +80,7 @@ impl<'tcx> LateLintPass<'tcx> for NoopMethodCall { // We only care about method calls corresponding to the `Clone`, `Deref` and `Borrow` // traits and ignore any other method call. - let Some((DefKind::AssocFn, did)) = cx.typeck_results().type_dependent_def(expr.hir_id) + let Some((DefKind::AssocFn, did)) = cx.typeck_results.type_dependent_def(expr.hir_id) else { return; }; @@ -95,7 +95,7 @@ impl<'tcx> LateLintPass<'tcx> for NoopMethodCall { let args = cx.tcx.normalize_erasing_regions( cx.typing_env(), - Unnormalized::new_wip(cx.typeck_results().node_args(expr.hir_id)), + Unnormalized::new_wip(cx.typeck_results.node_args(expr.hir_id)), ); // Resolve the trait method instance. let Ok(Some(i)) = ty::Instance::try_resolve(cx.tcx, cx.typing_env(), did, args) else { @@ -110,9 +110,9 @@ impl<'tcx> LateLintPass<'tcx> for NoopMethodCall { return; } - let receiver_ty = cx.typeck_results().expr_ty(receiver); - let expr_ty = cx.typeck_results().expr_ty_adjusted(expr); - let arg_adjustments = cx.typeck_results().expr_adjustments(receiver); + let receiver_ty = cx.typeck_results.expr_ty(receiver); + let expr_ty = cx.typeck_results.expr_ty_adjusted(expr); + let arg_adjustments = cx.typeck_results.expr_adjustments(receiver); // If there is any user defined auto-deref step, then we don't want to warn. // https://github.com/rust-lang/rust-clippy/issues/9272 diff --git a/compiler/rustc_lint/src/ptr_nulls.rs b/compiler/rustc_lint/src/ptr_nulls.rs index 34c569232fc0d..bd0b18bb20a21 100644 --- a/compiler/rustc_lint/src/ptr_nulls.rs +++ b/compiler/rustc_lint/src/ptr_nulls.rs @@ -71,7 +71,7 @@ fn useless_check<'a, 'tcx: 'a>( loop { e = e.peel_blocks(); if let ExprKind::MethodCall(_, _expr, [], _) = e.kind - && let Some(def_id) = cx.typeck_results().type_dependent_def_id(e.hir_id) + && let Some(def_id) = cx.typeck_results.type_dependent_def_id(e.hir_id) && find_attr!(cx.tcx, def_id, RustcNeverReturnsNullPtr) && let Some(fn_name) = cx.tcx.opt_item_ident(def_id) { @@ -90,13 +90,13 @@ fn useless_check<'a, 'tcx: 'a>( had_at_least_one_cast = true; expr } else if let ExprKind::MethodCall(_, expr, [], _) = e.kind - && let Some(def_id) = cx.typeck_results().type_dependent_def_id(e.hir_id) + && let Some(def_id) = cx.typeck_results.type_dependent_def_id(e.hir_id) && matches!(cx.tcx.get_diagnostic_name(def_id), Some(sym::ptr_cast | sym::ptr_cast_mut)) { had_at_least_one_cast = true; expr } else if had_at_least_one_cast { - let orig_ty = cx.typeck_results().expr_ty(e); + let orig_ty = cx.typeck_results.expr_ty(e); return if orig_ty.is_fn() { Some(UselessPtrNullChecksDiag::FnPtr { orig_ty, label: e.span }) } else if orig_ty.is_ref() { @@ -175,7 +175,7 @@ impl<'tcx> LateLintPass<'tcx> for PtrNullChecks { for &arg_idx in arg_indices { if let Some(arg) = args.get(arg_idx) && let Some(null_span) = is_null_ptr(cx, arg) - && let Some(ty) = cx.typeck_results().expr_ty_opt(arg) + && let Some(ty) = cx.typeck_results.expr_ty_opt(arg) && let RawPtr(ty, _mutbl) = ty.kind() { // If ZST are fine, don't lint on them @@ -203,7 +203,7 @@ impl<'tcx> LateLintPass<'tcx> for PtrNullChecks { // Catching: // (fn_ptr as * ).is_null() ExprKind::MethodCall(_, receiver, _, _) - if let Some(def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) + if let Some(def_id) = cx.typeck_results.type_dependent_def_id(expr.hir_id) && matches!( cx.tcx.get_diagnostic_name(def_id), Some(sym::ptr_const_is_null | sym::ptr_is_null) diff --git a/compiler/rustc_lint/src/reference_casting.rs b/compiler/rustc_lint/src/reference_casting.rs index 6052a16a7f117..98ad042680cdd 100644 --- a/compiler/rustc_lint/src/reference_casting.rs +++ b/compiler/rustc_lint/src/reference_casting.rs @@ -151,7 +151,7 @@ fn is_cast_from_ref_to_mut_ptr<'tcx>( orig_expr: &'tcx Expr<'tcx>, mut peel_casts: impl FnMut() -> (&'tcx Expr<'tcx>, bool), ) -> Option { - let end_ty = cx.typeck_results().node_type(orig_expr.hir_id); + let end_ty = cx.typeck_results.node_type(orig_expr.hir_id); // Bail out early if the end type is **not** a mutable pointer. if !matches!(end_ty.kind(), ty::RawPtr(_, Mutability::Mut)) { @@ -160,7 +160,7 @@ fn is_cast_from_ref_to_mut_ptr<'tcx>( let (e, need_check_freeze) = peel_casts(); - let start_ty = cx.typeck_results().node_type(e.hir_id); + let start_ty = cx.typeck_results.node_type(e.hir_id); if let ty::Ref(_, inner_ty, Mutability::Not) = start_ty.kind() { // If an UnsafeCell method is involved, we need to additionally check the // inner type for the presence of the Freeze trait (ie does NOT contain @@ -182,14 +182,14 @@ fn is_cast_to_bigger_memory_layout<'tcx>( orig_expr: &'tcx Expr<'tcx>, mut peel_casts: impl FnMut() -> (&'tcx Expr<'tcx>, bool), ) -> Option<(TyAndLayout<'tcx>, TyAndLayout<'tcx>, Expr<'tcx>)> { - let end_ty = cx.typeck_results().node_type(orig_expr.hir_id); + let end_ty = cx.typeck_results.node_type(orig_expr.hir_id); let ty::RawPtr(inner_end_ty, _) = end_ty.kind() else { return None; }; let (e, _) = peel_casts(); - let start_ty = cx.typeck_results().node_type(e.hir_id); + let start_ty = cx.typeck_results.node_type(e.hir_id); let ty::Ref(_, inner_start_ty, _) = start_ty.kind() else { return None; @@ -209,7 +209,7 @@ fn is_cast_to_bigger_memory_layout<'tcx>( return None; } - let alloc_ty = cx.typeck_results().node_type(e_alloc.hir_id); + let alloc_ty = cx.typeck_results.node_type(e_alloc.hir_id); // if we do not find it we bail out, as this may not be UB // see https://github.com/rust-lang/unsafe-code-guidelines/issues/256 diff --git a/compiler/rustc_lint/src/shadowed_into_iter.rs b/compiler/rustc_lint/src/shadowed_into_iter.rs index 05bb2113db09e..66785fcaabbb9 100644 --- a/compiler/rustc_lint/src/shadowed_into_iter.rs +++ b/compiler/rustc_lint/src/shadowed_into_iter.rs @@ -75,7 +75,7 @@ impl<'tcx> LateLintPass<'tcx> for ShadowedIntoIter { // Check if the method call actually calls the libcore // `IntoIterator::into_iter`. - let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) else { + let Some(method_def_id) = cx.typeck_results.type_dependent_def_id(expr.hir_id) else { return; }; if !cx.tcx.is_lang_item(method_def_id, LangItem::IntoIterIntoIter) { @@ -83,8 +83,8 @@ impl<'tcx> LateLintPass<'tcx> for ShadowedIntoIter { } // As this is a method call expression, we have at least one argument. - let receiver_ty = cx.typeck_results().expr_ty(receiver_arg); - let adjustments = cx.typeck_results().expr_adjustments(receiver_arg); + let receiver_ty = cx.typeck_results.expr_ty(receiver_arg); + let adjustments = cx.typeck_results.expr_adjustments(receiver_arg); let adjusted_receiver_tys: Vec<_> = [receiver_ty].into_iter().chain(adjustments.iter().map(|adj| adj.target)).collect(); diff --git a/compiler/rustc_lint/src/static_mut_refs.rs b/compiler/rustc_lint/src/static_mut_refs.rs index 67e83d0652c3d..b76f3ec00c16c 100644 --- a/compiler/rustc_lint/src/static_mut_refs.rs +++ b/compiler/rustc_lint/src/static_mut_refs.rs @@ -98,7 +98,7 @@ impl<'tcx> LateLintPass<'tcx> for StaticMutRefs { } hir::ExprKind::MethodCall(_, e, _, _) if let Some(static_mut) = path_is_static_mut(e, expr.span) - && let typeck = cx.typeck_results() + && let typeck = cx.typeck_results && let Some(method_def_id) = typeck.type_dependent_def_id(expr.hir_id) && let inputs = cx.tcx.fn_sig(method_def_id).skip_binder().inputs().skip_binder() diff --git a/compiler/rustc_lint/src/transmute.rs b/compiler/rustc_lint/src/transmute.rs index 4ee25ac008eb7..e7c511c17baec 100644 --- a/compiler/rustc_lint/src/transmute.rs +++ b/compiler/rustc_lint/src/transmute.rs @@ -124,7 +124,7 @@ impl<'tcx> LateLintPass<'tcx> for CheckTransmutes { }; let body_owner_def_id = cx.tcx.hir_enclosing_body_owner(expr.hir_id); let const_context = cx.tcx.hir_body_const_context(body_owner_def_id); - let args = cx.typeck_results().node_args(callee.hir_id); + let args = cx.typeck_results.node_args(callee.hir_id); let src = args.type_at(0); let dst = args.type_at(1); diff --git a/compiler/rustc_lint/src/types.rs b/compiler/rustc_lint/src/types.rs index a12e347284f7c..b6f8e1aef5ce6 100644 --- a/compiler/rustc_lint/src/types.rs +++ b/compiler/rustc_lint/src/types.rs @@ -225,7 +225,7 @@ fn lint_nan<'tcx>( let expr = expr.peel_blocks().peel_borrows(); match expr.kind { ExprKind::Path(qpath) => { - let Some(def_id) = cx.typeck_results().qpath_res(&qpath, expr.hir_id).opt_def_id() + let Some(def_id) = cx.typeck_results.qpath_res(&qpath, expr.hir_id).opt_def_id() else { return false; }; @@ -327,10 +327,10 @@ fn lint_wide_pointer<'tcx>( let l = l.peel_borrows(); let r = r.peel_borrows(); - let Some(l_ty) = cx.typeck_results().expr_ty_opt(l) else { + let Some(l_ty) = cx.typeck_results.expr_ty_opt(l) else { return; }; - let Some(r_ty) = cx.typeck_results().expr_ty_opt(r) else { + let Some(r_ty) = cx.typeck_results.expr_ty_opt(r) else { return; }; @@ -441,8 +441,8 @@ fn lint_fn_pointer<'tcx>( let l = l.peel_borrows(); let r = r.peel_borrows(); - let Some(l_ty) = cx.typeck_results().expr_ty_opt(l) else { return }; - let Some(r_ty) = cx.typeck_results().expr_ty_opt(r) else { return }; + let Some(l_ty) = cx.typeck_results.expr_ty_opt(l) else { return }; + let Some(r_ty) = cx.typeck_results.expr_ty_opt(r) else { return }; // Remove any references as `==` will deref through them (and count the // number of references removed, for latter). @@ -578,7 +578,7 @@ impl<'tcx> LateLintPass<'tcx> for TypeLimits { lint_fn_pointer(cx, e, cmpop, l, r); } hir::ExprKind::MethodCall(_, l, [r], _) - if let Some(def_id) = cx.typeck_results().type_dependent_def_id(e.hir_id) + if let Some(def_id) = cx.typeck_results.type_dependent_def_id(e.hir_id) && let Some(diag_item) = cx.tcx.get_diagnostic_name(def_id) && let Some(cmpop) = diag_item_cmpop(diag_item) => { @@ -623,7 +623,7 @@ impl<'tcx> LateLintPass<'tcx> for TypeLimits { // Normalize the binop so that the literal is always on the RHS in // the comparison let norm_binop = if swap { rev_binop(binop) } else { binop }; - match *cx.typeck_results().node_type(expr.hir_id).kind() { + match *cx.typeck_results.node_type(expr.hir_id).kind() { ty::Int(int_ty) => { let (min, max) = int_ty_range(int_ty); let lit_val: i128 = match lit.kind { @@ -1040,7 +1040,7 @@ impl InvalidAtomicOrdering { ) -> Option<(Symbol, &'hir [Expr<'hir>])> { if let ExprKind::MethodCall(method_path, _, args, _) = &expr.kind && recognized_names.contains(&method_path.ident.name) - && let Some(m_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) + && let Some(m_def_id) = cx.typeck_results.type_dependent_def_id(expr.hir_id) // skip extension traits, only lint functions from the standard library && let Some(impl_did) = cx.tcx.inherent_impl_of_assoc(m_def_id) && let Some(adt) = cx.tcx.type_of(impl_did).instantiate_identity().skip_norm_wip().ty_adt_def() diff --git a/compiler/rustc_lint/src/types/literal.rs b/compiler/rustc_lint/src/types/literal.rs index 45d79fec75ae9..e1a1ffda4f9aa 100644 --- a/compiler/rustc_lint/src/types/literal.rs +++ b/compiler/rustc_lint/src/types/literal.rs @@ -173,7 +173,7 @@ fn report_bin_hex_error( ty: t, } }; - let sub = get_type_suggestion(cx.typeck_results().node_type(hir_id), val, negative).map( + let sub = get_type_suggestion(cx.typeck_results.node_type(hir_id), val, negative).map( |suggestion_ty| { if let Some(pos) = repr_str.chars().position(|c| c == 'i' || c == 'u') { let (sans_suffix, _) = repr_str.split_at(pos); @@ -185,7 +185,7 @@ fn report_bin_hex_error( ); let sign_bit_sub = (!negative) .then(|| { - let ty::Int(int_ty) = cx.typeck_results().node_type(hir_id).kind() else { + let ty::Int(int_ty) = cx.typeck_results.node_type(hir_id).kind() else { return None; }; @@ -300,7 +300,7 @@ fn lint_int_literal<'tcx>( .source_map() .span_to_snippet(span) .unwrap_or_else(|_| if negative { format!("-{v}") } else { v.to_string() }); - let help = get_type_suggestion(cx.typeck_results().node_type(hir_id), v, negative) + let help = get_type_suggestion(cx.typeck_results.node_type(hir_id), v, negative) .map(|suggestion_ty| OverflowingIntHelp { suggestion_ty }); cx.emit_span_lint( @@ -331,7 +331,7 @@ fn lint_uint_literal<'tcx>( if let Node::Expr(par_e) = cx.tcx.parent_hir_node(hir_id) { match par_e.kind { hir::ExprKind::Cast(..) => { - if let ty::Char = cx.typeck_results().expr_ty(par_e).kind() { + if let ty::Char = cx.typeck_results.expr_ty(par_e).kind() { if lit_val > 0x10FFFF { cx.emit_span_lint( OVERFLOWING_LITERALS, @@ -406,7 +406,7 @@ pub(crate) fn lint_literal<'tcx>( lit: &hir::Lit, negated: bool, ) { - match *cx.typeck_results().node_type(hir_id).kind() { + match *cx.typeck_results.node_type(hir_id).kind() { ty::Int(t) => { match lit.node { ast::LitKind::Int(v, ast::LitIntType::Signed(_) | ast::LitIntType::Unsuffixed) => { diff --git a/compiler/rustc_lint/src/unused.rs b/compiler/rustc_lint/src/unused.rs index 73be0d9a02f3e..8dd8a5854f9f1 100644 --- a/compiler/rustc_lint/src/unused.rs +++ b/compiler/rustc_lint/src/unused.rs @@ -44,7 +44,7 @@ impl<'tcx> LateLintPass<'tcx> for PathStatements { if let hir::StmtKind::Semi(expr) = s.kind && let hir::ExprKind::Path(_) = expr.kind { - let ty = cx.typeck_results().expr_ty(expr); + let ty = cx.typeck_results.expr_ty(expr); if ty.needs_drop(cx.tcx, cx.typing_env()) { let sub = if let Ok(snippet) = cx.sess().source_map().span_to_snippet(expr.span) { PathStatementDropSub::Suggestion { span: s.span, snippet } @@ -1279,7 +1279,7 @@ impl<'tcx> LateLintPass<'tcx> for UnusedAllocation { _ => return, } - for adj in cx.typeck_results().expr_adjustments(e) { + for adj in cx.typeck_results.expr_adjustments(e) { if let adjustment::Adjust::Borrow(adjustment::AutoBorrow::Ref(m)) = adj.kind { if let ty::Ref(_, inner_ty, _) = adj.target.kind() && inner_ty.is_box() diff --git a/compiler/rustc_lint/src/unused/must_use.rs b/compiler/rustc_lint/src/unused/must_use.rs index 293320d868a66..e5bce7eddb317 100644 --- a/compiler/rustc_lint/src/unused/must_use.rs +++ b/compiler/rustc_lint/src/unused/must_use.rs @@ -295,7 +295,7 @@ impl<'tcx> LateLintPass<'tcx> for UnusedResults { } if let hir::ExprKind::Match(await_expr, _arms, hir::MatchSource::AwaitDesugar) = expr.kind - && let ty = cx.typeck_results().expr_ty(await_expr) + && let ty = cx.typeck_results.expr_ty(await_expr) && let ty::Alias(ty::AliasTy { kind: ty::Opaque { def_id: future_def_id }, .. }) = ty.kind() && cx.tcx.ty_is_opaque_future(ty) && let async_fn_def_id = cx.tcx.parent(*future_def_id) @@ -316,7 +316,7 @@ impl<'tcx> LateLintPass<'tcx> for UnusedResults { return; } - let ty = cx.typeck_results().expr_ty(expr); + let ty = cx.typeck_results.expr_ty(expr); let must_use_result = is_ty_must_use(cx, ty, expr); let type_lint_emitted_or_trivial = match must_use_result { @@ -424,7 +424,7 @@ fn check_fn_must_use(cx: &LateContext<'_>, expr: &hir::Expr<'_>, expr_is_from_bl None } } - hir::ExprKind::MethodCall(..) => cx.typeck_results().type_dependent_def_id(expr.hir_id), + hir::ExprKind::MethodCall(..) => cx.typeck_results.type_dependent_def_id(expr.hir_id), _ => None, }; diff --git a/compiler/rustc_lint/src/utils.rs b/compiler/rustc_lint/src/utils.rs index a7295d9c5326c..4495bd8b11f4f 100644 --- a/compiler/rustc_lint/src/utils.rs +++ b/compiler/rustc_lint/src/utils.rs @@ -21,7 +21,7 @@ pub(crate) fn peel_casts<'tcx>( expr // .cast(), .cast_mut() or .cast_const() } else if let ExprKind::MethodCall(_, expr, [], _) = e.kind - && let Some(def_id) = cx.typeck_results().type_dependent_def_id(e.hir_id) + && let Some(def_id) = cx.typeck_results.type_dependent_def_id(e.hir_id) && matches!( cx.tcx.get_diagnostic_name(def_id), Some(sym::ptr_cast | sym::const_ptr_cast | sym::ptr_cast_mut | sym::ptr_cast_const) diff --git a/src/tools/clippy/book/src/development/common_tools_writing_lints.md b/src/tools/clippy/book/src/development/common_tools_writing_lints.md index b5958f802e384..b08ade9111af5 100644 --- a/src/tools/clippy/book/src/development/common_tools_writing_lints.md +++ b/src/tools/clippy/book/src/development/common_tools_writing_lints.md @@ -35,7 +35,7 @@ Example of use: impl LateLintPass<'_> for MyStructLint { fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) { // Get type of `expr` - let ty = cx.typeck_results().expr_ty(expr); + let ty = cx.typeck_results.expr_ty(expr); // Match its kind to enter its type match ty.kind() { ty::Adt(adt_def, _) if adt_def.is_struct() => println!("Our `expr` is a struct!"), @@ -92,7 +92,7 @@ use rustc_hir::LangItem; impl LateLintPass<'_> for MyStructLint { fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) { // Getting the expression type - let ty = cx.typeck_results().expr_ty(expr); + let ty = cx.typeck_results.expr_ty(expr); // 1. Using diagnostic items // The last argument is the diagnostic item to check for @@ -135,7 +135,7 @@ impl LateLintPass<'_> for MyStructLint { let trait_id = cx.tcx.get_diagnostic_item(sym::Eq); // 2. Check for the trait implementation via the `implements_trait` util. - let ty = cx.typeck_results().expr_ty(expr); + let ty = cx.typeck_results.expr_ty(expr); if trait_id.is_some_and(|id| implements_trait(cx, ty, id, &[])) { // `ty` implements the trait. } diff --git a/src/tools/clippy/book/src/development/trait_checking.md b/src/tools/clippy/book/src/development/trait_checking.md index 714607ef25e5f..b1297faf2b9e7 100644 --- a/src/tools/clippy/book/src/development/trait_checking.md +++ b/src/tools/clippy/book/src/development/trait_checking.md @@ -25,7 +25,7 @@ use rustc_lint::{LateContext, LateLintPass}; impl LateLintPass<'_> for CheckIteratorTraitLint { fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) { let implements_iterator = (cx.tcx.get_diagnostic_item(sym::Iterator)) - .is_some_and(|id| implements_trait(cx, cx.typeck_results().expr_ty(expr), id, &[])); + .is_some_and(|id| implements_trait(cx, cx.typeck_results.expr_ty(expr), id, &[])); if implements_iterator { // [...] } @@ -59,7 +59,7 @@ use rustc_lint::{LateContext, LateLintPass}; impl LateLintPass<'_> for CheckDropTraitLint { fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) { - let ty = cx.typeck_results().expr_ty(expr); + let ty = cx.typeck_results.expr_ty(expr); if cx.tcx.lang_items() .drop_trait() .map_or(false, |id| implements_trait(cx, ty, id, &[])) { @@ -86,7 +86,7 @@ use rustc_lint::{LateContext, LateLintPass}; impl LateLintPass<'_> for CheckIterStep { fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) { - let ty = cx.typeck_results().expr_ty(expr); + let ty = cx.typeck_results.expr_ty(expr); if let Some(trait_def_id) = paths::ITER_STEP.first(cx) && implements_trait(cx, ty, trait_def_id, &[]) { diff --git a/src/tools/clippy/book/src/development/type_checking.md b/src/tools/clippy/book/src/development/type_checking.md index e92e766988858..2c55885872535 100644 --- a/src/tools/clippy/book/src/development/type_checking.md +++ b/src/tools/clippy/book/src/development/type_checking.md @@ -50,7 +50,7 @@ is a specific type, such as `char` type, so we could write the following: impl LateLintPass<'_> for MyStructLint { fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) { // Get type of `expr` - let ty = cx.typeck_results().expr_ty(expr); + let ty = cx.typeck_results.expr_ty(expr); // Check if the `Ty` of this expression is of character type if ty.is_char() { @@ -92,7 +92,7 @@ For instance, if we want to check for a `struct`, we could examine if the impl LateLintPass<'_> for MyStructLint { fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) { // Get type of `expr` - let ty = cx.typeck_results().expr_ty(expr); + let ty = cx.typeck_results.expr_ty(expr); // Match its kind to enter the type match ty.kind() { ty::Adt(adt_def, _) if adt_def.is_struct() => println!("Our `expr` is a struct!"), diff --git a/src/tools/clippy/clippy_lints/src/arc_with_non_send_sync.rs b/src/tools/clippy/clippy_lints/src/arc_with_non_send_sync.rs index e449b06199d36..ba8bbaf43502a 100644 --- a/src/tools/clippy/clippy_lints/src/arc_with_non_send_sync.rs +++ b/src/tools/clippy/clippy_lints/src/arc_with_non_send_sync.rs @@ -48,8 +48,8 @@ impl<'tcx> LateLintPass<'tcx> for ArcWithNonSendSync { && let ExprKind::Path(QPath::TypeRelative(func_ty, func_name)) = func.kind && func_name.ident.name == sym::new && !expr.span.from_expansion() - && cx.typeck_results().node_type(func_ty.hir_id).is_diag_item(cx, sym::Arc) - && let arg_ty = cx.typeck_results().expr_ty(arg) + && cx.typeck_results.node_type(func_ty.hir_id).is_diag_item(cx, sym::Arc) + && let arg_ty = cx.typeck_results.expr_ty(arg) // make sure that the type is not and does not contain any type parameters && arg_ty.walk().all(|arg| { !matches!(arg.kind(), GenericArgKind::Type(ty) if matches!(ty.kind(), ty::Param(_))) diff --git a/src/tools/clippy/clippy_lints/src/assertions_on_result_states.rs b/src/tools/clippy/clippy_lints/src/assertions_on_result_states.rs index d48ef10c8cd25..ee2abaa993aa4 100644 --- a/src/tools/clippy/clippy_lints/src/assertions_on_result_states.rs +++ b/src/tools/clippy/clippy_lints/src/assertions_on_result_states.rs @@ -54,7 +54,7 @@ impl<'tcx> LateLintPass<'tcx> for AssertionsOnResultStates { && let Some((condition, panic_expn)) = find_assert_args(cx, e, macro_call.expn) && panic_expn.is_default_message() && let ExprKind::MethodCall(method_segment, recv, [], _) = condition.kind - && let result_type_with_refs = cx.typeck_results().expr_ty(recv) + && let result_type_with_refs = cx.typeck_results.expr_ty(recv) && let result_type = result_type_with_refs.peel_refs() && result_type.is_diag_item(cx, sym::Result) && let ty::Adt(_, args) = result_type.kind() diff --git a/src/tools/clippy/clippy_lints/src/assigning_clones.rs b/src/tools/clippy/clippy_lints/src/assigning_clones.rs index 60bc9b2b5b853..cc8703574c591 100644 --- a/src/tools/clippy/clippy_lints/src/assigning_clones.rs +++ b/src/tools/clippy/clippy_lints/src/assigning_clones.rs @@ -68,7 +68,7 @@ impl AssigningClones { impl<'tcx> LateLintPass<'tcx> for AssigningClones { fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) { if let ExprKind::Assign(lhs, rhs, _) = e.kind - && let typeck = cx.typeck_results() + && let typeck = cx.typeck_results && let (call_kind, fn_name, fn_def, fn_arg, fn_gen_args) = match rhs.kind { ExprKind::Call(f, [arg]) if let ExprKind::Path(fn_path) = &f.kind @@ -228,7 +228,7 @@ fn build_sugg<'tcx>( // the generated code a bit simpler. In other cases, we don't do this special case, to avoid // having to deal with Deref (https://github.com/rust-lang/rust-clippy/issues/12437). - let ty = cx.typeck_results().expr_ty(ref_expr); + let ty = cx.typeck_results.expr_ty(ref_expr); if ty.is_ref() { // Apply special case, remove `*` // `*lhs = self_expr.clone();` -> `lhs.clone_from(self_expr)` @@ -246,8 +246,8 @@ fn build_sugg<'tcx>( .maybe_paren(); // Determine whether we need to reference the argument to clone_from(). - let clone_receiver_type = cx.typeck_results().expr_ty(fn_arg); - let clone_receiver_adj_type = cx.typeck_results().expr_ty_adjusted(fn_arg); + let clone_receiver_type = cx.typeck_results.expr_ty(fn_arg); + let clone_receiver_adj_type = cx.typeck_results.expr_ty_adjusted(fn_arg); let mut arg_sugg = Sugg::hir_with_context(cx, fn_arg, ctxt, "_", app); if clone_receiver_type != clone_receiver_adj_type { // The receiver may have been a value type, so we need to add an `&` to @@ -260,7 +260,7 @@ fn build_sugg<'tcx>( CallKind::Ufcs => { let self_sugg = if let ExprKind::Unary(hir::UnOp::Deref, ref_expr) = lhs.kind { // See special case of removing `*` in method handling above - let ty = cx.typeck_results().expr_ty(ref_expr); + let ty = cx.typeck_results.expr_ty(ref_expr); if ty.is_ref() { // `*lhs = Clone::clone(self_expr);` -> `Clone::clone_from(lhs, self_expr)` Sugg::hir_with_applicability(cx, ref_expr, "_", app) @@ -285,7 +285,7 @@ fn build_sugg<'tcx>( // `*lhs = rhs.to_owned()` -> `rhs.clone_into(lhs)` // `*lhs = ToOwned::to_owned(rhs)` -> `ToOwned::clone_into(rhs, lhs)` let sugg = Sugg::hir_with_applicability(cx, ref_expr, "_", app).maybe_paren(); - let inner_type = cx.typeck_results().expr_ty(ref_expr); + let inner_type = cx.typeck_results.expr_ty(ref_expr); // If after unwrapping the dereference, the type is not a mutable reference, we add &mut to make it // deref to a mutable reference. if matches!(inner_type.kind(), ty::Ref(_, _, Mutability::Mut)) { diff --git a/src/tools/clippy/clippy_lints/src/bool_assert_comparison.rs b/src/tools/clippy/clippy_lints/src/bool_assert_comparison.rs index cdcb66566d951..c8ada4840608b 100644 --- a/src/tools/clippy/clippy_lints/src/bool_assert_comparison.rs +++ b/src/tools/clippy/clippy_lints/src/bool_assert_comparison.rs @@ -103,7 +103,7 @@ impl<'tcx> LateLintPass<'tcx> for BoolAssertComparison { _ => return, }; - let non_lit_ty = cx.typeck_results().expr_ty(non_lit_expr); + let non_lit_ty = cx.typeck_results.expr_ty(non_lit_expr); if !is_impl_not_trait_with_bool_out(cx, non_lit_ty) { // At this point the expression which is not a boolean diff --git a/src/tools/clippy/clippy_lints/src/bool_comparison.rs b/src/tools/clippy/clippy_lints/src/bool_comparison.rs index feeefefc3b8f1..bb9d44d24b611 100644 --- a/src/tools/clippy/clippy_lints/src/bool_comparison.rs +++ b/src/tools/clippy/clippy_lints/src/bool_comparison.rs @@ -44,8 +44,8 @@ impl<'tcx> LateLintPass<'tcx> for BoolComparison { if let ExprKind::Binary(Spanned { node, .. }, left_side, right_side) = e.kind && is_expn_of(left_side.span, sym::cfg).is_none() && is_expn_of(right_side.span, sym::cfg).is_none() - && cx.typeck_results().expr_ty(left_side).is_bool() - && cx.typeck_results().expr_ty(right_side).is_bool() + && cx.typeck_results.expr_ty(left_side).is_bool() + && cx.typeck_results.expr_ty(right_side).is_bool() { let ignore_case = None::<(fn(_) -> _, &str)>; let ignore_no_literal = None::<(fn(_, _) -> _, &str)>; diff --git a/src/tools/clippy/clippy_lints/src/bool_to_int_with_if.rs b/src/tools/clippy/clippy_lints/src/bool_to_int_with_if.rs index 8b45473687e6d..3f155a48f455a 100644 --- a/src/tools/clippy/clippy_lints/src/bool_to_int_with_if.rs +++ b/src/tools/clippy/clippy_lints/src/bool_to_int_with_if.rs @@ -58,7 +58,7 @@ impl<'tcx> LateLintPass<'tcx> for BoolToIntWithIf { && then_lit != else_lit && !is_in_const_context(cx) { - let ty = cx.typeck_results().expr_ty(then); + let ty = cx.typeck_results.expr_ty(then); let mut applicability = if span_contains_comment(cx, expr.span) { Applicability::MaybeIncorrect } else { diff --git a/src/tools/clippy/clippy_lints/src/booleans.rs b/src/tools/clippy/clippy_lints/src/booleans.rs index 2f2382d9a50ed..1feaccd1becae 100644 --- a/src/tools/clippy/clippy_lints/src/booleans.rs +++ b/src/tools/clippy/clippy_lints/src/booleans.rs @@ -149,8 +149,8 @@ fn check_inverted_bool_in_condition( right: &Expr<'_>, ) { if expr_span.from_expansion() - || !cx.typeck_results().node_types()[left.hir_id].is_bool() - || !cx.typeck_results().node_types()[right.hir_id].is_bool() + || !cx.typeck_results.node_types()[left.hir_id].is_bool() + || !cx.typeck_results.node_types()[right.hir_id].is_bool() { return; } @@ -293,7 +293,7 @@ impl<'v> Hir2Qmm<'_, '_, 'v> { } } - if self.cx.typeck_results().expr_ty(e).is_never() { + if self.cx.typeck_results.expr_ty(e).is_never() { return Err("contains never type".to_owned()); } @@ -437,7 +437,7 @@ fn simplify_not(cx: &LateContext<'_>, curr_msrv: Msrv, expr: &Expr<'_>) -> Optio }) }, ExprKind::MethodCall(path, receiver, args, _) => { - let type_of_receiver = cx.typeck_results().expr_ty(receiver); + let type_of_receiver = cx.typeck_results.expr_ty(receiver); if !matches!(type_of_receiver.opt_diag_name(cx), Some(sym::Option | sym::Result)) { return None; } @@ -663,11 +663,11 @@ impl<'tcx> Visitor<'tcx> for NonminimalBoolVisitor<'_, 'tcx> { }, ExprKind::Unary(UnOp::Not, inner) => { if let ExprKind::Unary(UnOp::Not, ex) = inner.kind - && !self.cx.typeck_results().node_types()[ex.hir_id].is_bool() + && !self.cx.typeck_results.node_types()[ex.hir_id].is_bool() { return; } - if self.cx.typeck_results().node_types()[inner.hir_id].is_bool() { + if self.cx.typeck_results.node_types()[inner.hir_id].is_bool() { self.bool_expr(e); } }, @@ -679,7 +679,7 @@ impl<'tcx> Visitor<'tcx> for NonminimalBoolVisitor<'_, 'tcx> { } fn implements_ord(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool { - let ty = cx.typeck_results().expr_ty(expr); + let ty = cx.typeck_results.expr_ty(expr); cx.tcx .get_diagnostic_item(sym::Ord) .is_some_and(|id| implements_trait(cx, ty, id, &[])) diff --git a/src/tools/clippy/clippy_lints/src/borrow_deref_ref.rs b/src/tools/clippy/clippy_lints/src/borrow_deref_ref.rs index 947b99696bb1f..f08375208c3a9 100644 --- a/src/tools/clippy/clippy_lints/src/borrow_deref_ref.rs +++ b/src/tools/clippy/clippy_lints/src/borrow_deref_ref.rs @@ -58,7 +58,7 @@ impl<'tcx> LateLintPass<'tcx> for BorrowDerefRef { && !e.span.from_expansion() && !deref_target.span.from_expansion() && !addrof_target.span.from_expansion() - && let ref_ty = cx.typeck_results().expr_ty(deref_target) + && let ref_ty = cx.typeck_results.expr_ty(deref_target) && let ty::Ref(_, inner_ty, Mutability::Not) = ref_ty.kind() && get_parent_expr(cx, e).is_none_or(|parent| { match parent.kind { @@ -76,7 +76,7 @@ impl<'tcx> LateLintPass<'tcx> for BorrowDerefRef { } }) && !is_from_proc_macro(cx, e) - && let e_ty = cx.typeck_results().expr_ty_adjusted(e) + && let e_ty = cx.typeck_results.expr_ty_adjusted(e) // check if the reference is coercing to a mutable reference && (!matches!(e_ty.kind(), ty::Ref(_, _, Mutability::Mut)) || is_mutable(cx, deref_target)) // If the new borrow might be itself borrowed mutably and the original reference is not a temporary diff --git a/src/tools/clippy/clippy_lints/src/box_default.rs b/src/tools/clippy/clippy_lints/src/box_default.rs index 34b96b1d9d7a1..0b44895e3e9c6 100644 --- a/src/tools/clippy/clippy_lints/src/box_default.rs +++ b/src/tools/clippy/clippy_lints/src/box_default.rs @@ -128,7 +128,7 @@ fn given_type(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool { && let Some(input) = sig.input(index) && let Some(input_ty) = input.no_bound_vars() { - input_ty == cx.typeck_results().expr_ty_adjusted(expr) + input_ty == cx.typeck_results.expr_ty_adjusted(expr) } else { false } diff --git a/src/tools/clippy/clippy_lints/src/byte_char_slices.rs b/src/tools/clippy/clippy_lints/src/byte_char_slices.rs index 5104594790fe8..5ed3055ab5923 100644 --- a/src/tools/clippy/clippy_lints/src/byte_char_slices.rs +++ b/src/tools/clippy/clippy_lints/src/byte_char_slices.rs @@ -61,7 +61,7 @@ impl<'tcx> LateLintPass<'tcx> for ByteCharSlice { slice.push('"'); Cow::Owned(slice) }); - if !has_ref && !cx.typeck_results().expr_ty_adjusted(expr).is_array_slice() { + if !has_ref && !cx.typeck_results.expr_ty_adjusted(expr).is_array_slice() { sugg = sugg.deref(); } diff --git a/src/tools/clippy/clippy_lints/src/casts/as_ptr_cast_mut.rs b/src/tools/clippy/clippy_lints/src/casts/as_ptr_cast_mut.rs index adc43e282fc5c..320cc41c0f532 100644 --- a/src/tools/clippy/clippy_lints/src/casts/as_ptr_cast_mut.rs +++ b/src/tools/clippy/clippy_lints/src/casts/as_ptr_cast_mut.rs @@ -11,11 +11,11 @@ use super::AS_PTR_CAST_MUT; pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>, cast_to: Ty<'_>) { if let ty::RawPtr(ptrty, Mutability::Mut) = cast_to.kind() - && let ty::RawPtr(_, Mutability::Not) = cx.typeck_results().node_type(cast_expr.hir_id).kind() + && let ty::RawPtr(_, Mutability::Not) = cx.typeck_results.node_type(cast_expr.hir_id).kind() && let ExprKind::MethodCall(method_name, receiver, [], _) = cast_expr.peel_blocks().kind && method_name.ident.name == sym::as_ptr && let Some(as_ptr_did) = cx - .typeck_results() + .typeck_results .type_dependent_def_id(cast_expr.peel_blocks().hir_id) && let as_ptr_sig = cx.tcx.fn_sig(as_ptr_did).instantiate_identity().skip_norm_wip() && let Some(first_param_ty) = as_ptr_sig.skip_binder().inputs().iter().next() diff --git a/src/tools/clippy/clippy_lints/src/casts/as_underscore.rs b/src/tools/clippy/clippy_lints/src/casts/as_underscore.rs index a73e48e5fd5d1..ee3957e1797d0 100644 --- a/src/tools/clippy/clippy_lints/src/casts/as_underscore.rs +++ b/src/tools/clippy/clippy_lints/src/casts/as_underscore.rs @@ -9,7 +9,7 @@ use super::AS_UNDERSCORE; pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, ty: &'tcx Ty<'_>) { if matches!(ty.kind, TyKind::Infer(())) { span_lint_and_then(cx, AS_UNDERSCORE, expr.span, "using `as _` conversion", |diag| { - let ty_resolved = cx.typeck_results().expr_ty(expr); + let ty_resolved = cx.typeck_results.expr_ty(expr); if ty_resolved.is_suggestable(cx.tcx, true) { diag.span_suggestion( ty.span, diff --git a/src/tools/clippy/clippy_lints/src/casts/borrow_as_ptr.rs b/src/tools/clippy/clippy_lints/src/casts/borrow_as_ptr.rs index eb75d5576f5cf..5b13970fc93af 100644 --- a/src/tools/clippy/clippy_lints/src/casts/borrow_as_ptr.rs +++ b/src/tools/clippy/clippy_lints/src/casts/borrow_as_ptr.rs @@ -62,7 +62,7 @@ pub(super) fn check_implicit_cast(cx: &LateContext<'_>, expr: &Expr<'_>) { if !expr.span.from_expansion() && let ExprKind::AddrOf(BorrowKind::Ref, _, pointee) = expr.kind && !matches!(get_parent_expr(cx, expr).map(|e| e.kind), Some(ExprKind::Cast(..))) - && let [deref, borrow] = cx.typeck_results().expr_adjustments(expr) + && let [deref, borrow] = cx.typeck_results.expr_adjustments(expr) && matches!(deref.kind, Adjust::Deref(..)) && let Adjust::Borrow(AutoBorrow::RawPtr(mutability)) = borrow.kind // Do not suggest taking a raw pointer to a temporary value diff --git a/src/tools/clippy/clippy_lints/src/casts/cast_ptr_alignment.rs b/src/tools/clippy/clippy_lints/src/casts/cast_ptr_alignment.rs index 69490fb23646d..effb88a5bc9c8 100644 --- a/src/tools/clippy/clippy_lints/src/casts/cast_ptr_alignment.rs +++ b/src/tools/clippy/clippy_lints/src/casts/cast_ptr_alignment.rs @@ -20,7 +20,7 @@ pub(super) fn check_cast_method(cx: &LateContext<'_>, expr: &Expr<'_>) { // There probably is no obvious reason to do this, just to be consistent with `as` cases. && !is_hir_ty_cfg_dependant(cx, cast_to.as_unambig_ty()) { - let (cast_from, cast_to) = (cx.typeck_results().expr_ty(self_arg), cx.typeck_results().expr_ty(expr)); + let (cast_from, cast_to) = (cx.typeck_results.expr_ty(self_arg), cx.typeck_results.expr_ty(expr)); lint_cast_ptr_alignment(cx, expr, cast_from, cast_to); } } @@ -57,7 +57,7 @@ fn is_used_as_unaligned(cx: &LateContext<'_>, e: &Expr<'_>) -> bool { match parent.kind { ExprKind::MethodCall(name, self_arg, ..) if self_arg.hir_id == e.hir_id => { if matches!(name.ident.name, sym::read_unaligned | sym::write_unaligned) - && let Some(def_id) = cx.typeck_results().type_dependent_def_id(parent.hir_id) + && let Some(def_id) = cx.typeck_results.type_dependent_def_id(parent.hir_id) && let Some(def_id) = cx.tcx.impl_of_assoc(def_id) && cx .tcx diff --git a/src/tools/clippy/clippy_lints/src/casts/cast_sign_loss.rs b/src/tools/clippy/clippy_lints/src/casts/cast_sign_loss.rs index f870d27b796e8..d71c1dd2c3672 100644 --- a/src/tools/clippy/clippy_lints/src/casts/cast_sign_loss.rs +++ b/src/tools/clippy/clippy_lints/src/casts/cast_sign_loss.rs @@ -110,7 +110,7 @@ fn get_const_signed_int_eval<'cx>( expr: &Expr<'_>, ty: impl Into>>, ) -> Option { - let ty = ty.into().unwrap_or_else(|| cx.typeck_results().expr_ty(expr)); + let ty = ty.into().unwrap_or_else(|| cx.typeck_results.expr_ty(expr)); if let Constant::Int(n) = ConstEvalCtxt::new(cx).eval(expr)? && let ty::Int(ity) = *ty.kind() @@ -125,7 +125,7 @@ fn get_const_unsigned_int_eval<'cx>( expr: &Expr<'_>, ty: impl Into>>, ) -> Option { - let ty = ty.into().unwrap_or_else(|| cx.typeck_results().expr_ty(expr)); + let ty = ty.into().unwrap_or_else(|| cx.typeck_results.expr_ty(expr)); if let Constant::Int(n) = ConstEvalCtxt::new(cx).eval(expr)? && let ty::Uint(_ity) = *ty.kind() diff --git a/src/tools/clippy/clippy_lints/src/casts/cast_slice_different_sizes.rs b/src/tools/clippy/clippy_lints/src/casts/cast_slice_different_sizes.rs index a5b295c88b1c7..ff24ecb4788b8 100644 --- a/src/tools/clippy/clippy_lints/src/casts/cast_slice_different_sizes.rs +++ b/src/tools/clippy/clippy_lints/src/casts/cast_slice_different_sizes.rs @@ -104,7 +104,7 @@ struct CastChainInfo<'tcx> { /// Returns None if the expr is not a Cast fn expr_cast_chain_tys<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) -> Option> { if let ExprKind::Cast(cast_expr, _cast_to_hir_ty) = expr.peel_blocks().kind { - let cast_to = cx.typeck_results().expr_ty(expr); + let cast_to = cx.typeck_results.expr_ty(expr); let to_slice_ty = get_raw_slice_ty_mut(cast_to)?; // If the expression that makes up the source of this cast is itself a cast, recursively @@ -116,7 +116,7 @@ fn expr_cast_chain_tys<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) -> Optio ..prev_info }) } else { - let cast_from = cx.typeck_results().expr_ty(cast_expr); + let cast_from = cx.typeck_results.expr_ty(cast_expr); let from_slice_ty = get_raw_slice_ty_mut(cast_from)?; Some(CastChainInfo { left_cast: cast_expr, diff --git a/src/tools/clippy/clippy_lints/src/casts/cast_slice_from_raw_parts.rs b/src/tools/clippy/clippy_lints/src/casts/cast_slice_from_raw_parts.rs index bce7b4c69cc62..eb63f66635804 100644 --- a/src/tools/clippy/clippy_lints/src/casts/cast_slice_from_raw_parts.rs +++ b/src/tools/clippy/clippy_lints/src/casts/cast_slice_from_raw_parts.rs @@ -64,7 +64,7 @@ pub(super) fn check_implicit_cast(cx: &LateContext<'_>, expr: &Expr<'_>) { && let Some(fun_def_id) = cx.qpath_res(qpath, fun.hir_id).opt_def_id() && let Some(rpk) = raw_parts_kind(cx, fun_def_id) && !matches!(get_parent_expr(cx, expr).map(|e| e.kind), Some(ExprKind::Cast(..))) - && let [deref, borrow] = cx.typeck_results().expr_adjustments(expr) + && let [deref, borrow] = cx.typeck_results.expr_adjustments(expr) && matches!(deref.kind, Adjust::Deref(..)) && let Adjustment { kind: Adjust::Borrow(AutoBorrow::RawPtr(..)), diff --git a/src/tools/clippy/clippy_lints/src/casts/manual_dangling_ptr.rs b/src/tools/clippy/clippy_lints/src/casts/manual_dangling_ptr.rs index 55b0945f0962b..c601b3eee5dd7 100644 --- a/src/tools/clippy/clippy_lints/src/casts/manual_dangling_ptr.rs +++ b/src/tools/clippy/clippy_lints/src/casts/manual_dangling_ptr.rs @@ -15,7 +15,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, from: &Expr<'_>, to: let init_expr = expr_or_init(cx, from); if is_expr_const_aligned(cx, init_expr, ptr_ty.ty) && let Some(std_or_core) = std_or_core(cx) - && let pointee_ty = cx.typeck_results().node_type(ptr_ty.ty.hir_id) + && let pointee_ty = cx.typeck_results.node_type(ptr_ty.ty.hir_id) && pointee_ty.is_sized(cx.tcx, cx.typing_env()) { let sugg_fn = match ptr_ty.mutbl { @@ -60,7 +60,7 @@ fn is_align_of_call(cx: &LateContext<'_>, fun: &Expr<'_>, to: &Ty<'_>) -> bool { && let Some(args) = path.segments.last().and_then(|seg| seg.args) && let [GenericArg::Type(generic_ty)] = args.args { - let typeck = cx.typeck_results(); + let typeck = cx.typeck_results; return typeck.node_type(generic_ty.hir_id) == typeck.node_type(to.hir_id); } false @@ -71,7 +71,7 @@ fn is_literal_aligned(cx: &LateContext<'_>, lit: &Spanned, to: &Ty<'_>) if val == 0 { return false; } - let to_mid_ty = cx.typeck_results().node_type(to.hir_id); + let to_mid_ty = cx.typeck_results.node_type(to.hir_id); cx.tcx .layout_of(cx.typing_env().as_query_input(to_mid_ty)) .is_ok_and(|layout| { diff --git a/src/tools/clippy/clippy_lints/src/casts/mod.rs b/src/tools/clippy/clippy_lints/src/casts/mod.rs index de34b2691abc6..fd2b74bd9c2bd 100644 --- a/src/tools/clippy/clippy_lints/src/casts/mod.rs +++ b/src/tools/clippy/clippy_lints/src/casts/mod.rs @@ -898,8 +898,8 @@ impl<'tcx> LateLintPass<'tcx> for Casts { return; } let (cast_from, cast_to) = ( - cx.typeck_results().expr_ty(cast_from_expr), - cx.typeck_results().expr_ty(expr), + cx.typeck_results.expr_ty(cast_from_expr), + cx.typeck_results.expr_ty(expr), ); if !expr.span.from_expansion() && unnecessary_cast::check(cx, expr, cast_from_expr, cast_from, cast_to) { diff --git a/src/tools/clippy/clippy_lints/src/casts/needless_type_cast.rs b/src/tools/clippy/clippy_lints/src/casts/needless_type_cast.rs index 844d4c7acbe7f..305ce5961b19e 100644 --- a/src/tools/clippy/clippy_lints/src/casts/needless_type_cast.rs +++ b/src/tools/clippy/clippy_lints/src/casts/needless_type_cast.rs @@ -69,7 +69,7 @@ fn collect_binding_from_let<'a>( if let PatKind::Binding(_, hir_id, _, _) = let_expr.pat.kind && let Some(ty_hir) = let_expr.ty { - let ty = cx.typeck_results().pat_ty(let_expr.pat); + let ty = cx.typeck_results.pat_ty(let_expr.pat); if ty.is_numeric() { bindings.insert( hir_id, @@ -100,7 +100,7 @@ fn collect_binding_from_local<'a>( if let PatKind::Binding(_, hir_id, _, _) = let_stmt.pat.kind && let Some(ty_hir) = let_stmt.ty { - let ty = cx.typeck_results().pat_ty(let_stmt.pat); + let ty = cx.typeck_results.pat_ty(let_stmt.pat); if ty.is_numeric() { bindings.insert( hir_id, @@ -157,7 +157,7 @@ fn has_generic_return_type(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool { }) .is_some(), ExprKind::MethodCall(..) => { - if let Some(def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) { + if let Some(def_id) = cx.typeck_results.type_dependent_def_id(expr.hir_id) { let sig = cx.tcx.fn_sig(def_id).instantiate_identity().skip_norm_wip(); let ret_ty = sig.output().skip_binder(); return ret_ty.has_param(); @@ -214,7 +214,7 @@ fn is_cast_in_generic_context<'a>(cx: &LateContext<'a>, cast_expr: &Expr<'a>) -> } }, ExprKind::MethodCall(..) => { - if let Some(def_id) = cx.typeck_results().type_dependent_def_id(parent_expr.hir_id) + if let Some(def_id) = cx.typeck_results.type_dependent_def_id(parent_expr.hir_id) && cx .tcx .generics_of(def_id) @@ -263,7 +263,7 @@ fn check_binding_usages<'a>(cx: &LateContext<'a>, body: &Body<'a>, hir_id: HirId && !parent_expr.span.from_expansion() { UsageInfo { - cast_to: Some(cx.typeck_results().expr_ty(parent_expr)), + cast_to: Some(cx.typeck_results.expr_ty(parent_expr)), in_generic_context: is_cast_in_generic_context(cx, parent_expr), } } else { diff --git a/src/tools/clippy/clippy_lints/src/casts/ref_as_ptr.rs b/src/tools/clippy/clippy_lints/src/casts/ref_as_ptr.rs index aef04dc9f7f9a..e6fbe90b9b009 100644 --- a/src/tools/clippy/clippy_lints/src/casts/ref_as_ptr.rs +++ b/src/tools/clippy/clippy_lints/src/casts/ref_as_ptr.rs @@ -16,8 +16,8 @@ pub(super) fn check<'tcx>( cast_to_hir_ty: &Ty<'_>, ) { let (cast_from, cast_to) = ( - cx.typeck_results().expr_ty(cast_expr), - cx.typeck_results().expr_ty(expr), + cx.typeck_results.expr_ty(cast_expr), + cx.typeck_results.expr_ty(expr), ); if matches!(cast_from.kind(), ty::Ref(..)) @@ -27,7 +27,7 @@ pub(super) fn check<'tcx>( if let ExprKind::AddrOf(_, _, addr_inner) = cast_expr.kind && is_expr_temporary_value(cx, addr_inner) && matches!( - get_expr_use_site(cx.tcx, cx.typeck_results(), expr.span.ctxt(), expr).use_node(cx), + get_expr_use_site(cx.tcx, cx.typeck_results, expr.span.ctxt(), expr).use_node(cx), ExprUseNode::LetStmt(_) | ExprUseNode::ConstStatic(_) ) { diff --git a/src/tools/clippy/clippy_lints/src/casts/unnecessary_cast.rs b/src/tools/clippy/clippy_lints/src/casts/unnecessary_cast.rs index 333f31ba00eac..10c603b5ac013 100644 --- a/src/tools/clippy/clippy_lints/src/casts/unnecessary_cast.rs +++ b/src/tools/clippy/clippy_lints/src/casts/unnecessary_cast.rs @@ -155,7 +155,7 @@ pub(super) fn check<'tcx>( fn is_borrow_expr(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool { matches!(expr.kind, ExprKind::AddrOf(..)) || cx - .typeck_results() + .typeck_results .expr_adjustments(expr) .first() .is_some_and(|adj| matches!(adj.kind, Adjust::Borrow(_))) @@ -371,7 +371,7 @@ fn contains_unsuffixed_numeric_literal<'e>(expr: &'e Expr<'e>) -> bool { fn is_inference_sensitive_inner_expr(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool { match expr.kind { ExprKind::MethodCall(..) | ExprKind::Binary(..) | ExprKind::Unary(..) | ExprKind::Index(..) => cx - .typeck_results() + .typeck_results .type_dependent_def_id(expr.hir_id) .and_then(|def_id| cx.tcx.opt_associated_item(def_id)) .is_some_and(|assoc| assoc.trait_container(cx.tcx).is_some()), @@ -469,7 +469,7 @@ fn walk_receiver_path_method_call( let passthrough = !has_explicit_type_or_const_args(segment.args) && cx - .typeck_results() + .typeck_results .type_dependent_def_id(parent.hir_id) .is_some_and(|def_id| output_depends_on_input_param(cx, def_id, arg_index + 1)); @@ -478,7 +478,7 @@ fn walk_receiver_path_method_call( || args.iter().any(|arg| { arg.hir_id != current_hir_id && get_numeric_literal(arg).is_none() - && !cx.typeck_results().expr_ty(arg).is_primitive() + && !cx.typeck_results.expr_ty(arg).is_primitive() }) { ReceiverPathResult::Stop(true) @@ -552,7 +552,7 @@ fn walk_receiver_path_step(cx: &LateContext<'_>, current_hir_id: HirId, mode: Re { if matches!(mode, ReceiverPathMode::FindLintBlockingContext) { let sibling = if left.hir_id == current_hir_id { right } else { left }; - if get_numeric_literal(sibling).is_none() && !cx.typeck_results().expr_ty(sibling).is_primitive() { + if get_numeric_literal(sibling).is_none() && !cx.typeck_results.expr_ty(sibling).is_primitive() { ReceiverPathResult::Stop(true) } else { ReceiverPathResult::Continue(parent.hir_id) diff --git a/src/tools/clippy/clippy_lints/src/cloned_ref_to_slice_refs.rs b/src/tools/clippy/clippy_lints/src/cloned_ref_to_slice_refs.rs index 4f663f4aa9098..6bab704984e6b 100644 --- a/src/tools/clippy/clippy_lints/src/cloned_ref_to_slice_refs.rs +++ b/src/tools/clippy/clippy_lints/src/cloned_ref_to_slice_refs.rs @@ -130,13 +130,13 @@ fn is_needless_clone_or_equivalent<'tcx>( return None; } - let method_ret_ty = cx.typeck_results().node_type(hir_id); - let method_recv_ty = cx.typeck_results().expr_ty_adjusted(method_recv); + let method_ret_ty = cx.typeck_results.node_type(hir_id); + let method_recv_ty = cx.typeck_results.expr_ty_adjusted(method_recv); let ty::Ref(_, method_recv_ty_inner, Mutability::Not) = method_recv_ty.kind() else { return None; }; - let method_recv_adjustments = cx.typeck_results().expr_adjustments(method_recv); + let method_recv_adjustments = cx.typeck_results.expr_adjustments(method_recv); // The return type of the clone-like method should be the same as the inner type of the reference // being cloned, except for the following special cases: @@ -157,7 +157,7 @@ fn is_needless_clone_or_equivalent<'tcx>( && matches!(last_borrow.kind, Adjust::Borrow(_)) && special_case.target.is_diag_item(cx, after_special_case_ty_name) && let before_special_case_ty = preceeding_derefs - .last().map_or_else(|| cx.typeck_results().expr_ty(method_recv), |a| a.target) + .last().map_or_else(|| cx.typeck_results.expr_ty(method_recv), |a| a.target) && matches!( (before_special_case_ty.opt_diag_name(cx)?, after_special_case_ty_name), (sym::OsString, sym::OsStr) | (sym::PathBuf, sym::Path)) @@ -168,7 +168,7 @@ fn is_needless_clone_or_equivalent<'tcx>( }; // Find the number of adjustments required until `method_recv_ty_source` becomes `adjust_target_ty` - let method_recv_ty_source = cx.typeck_results().expr_ty(method_recv); + let method_recv_ty_source = cx.typeck_results.expr_ty(method_recv); let adjust_count = method_recv_adjustments .iter() .enumerate() diff --git a/src/tools/clippy/clippy_lints/src/coerce_container_to_any.rs b/src/tools/clippy/clippy_lints/src/coerce_container_to_any.rs index 1a7e20b982719..997d0fee2b770 100644 --- a/src/tools/clippy/clippy_lints/src/coerce_container_to_any.rs +++ b/src/tools/clippy/clippy_lints/src/coerce_container_to_any.rs @@ -52,13 +52,13 @@ declare_lint_pass!(CoerceContainerToAny => [COERCE_CONTAINER_TO_ANY]); impl<'tcx> LateLintPass<'tcx> for CoerceContainerToAny { fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) { // If this expression was coerced to `&dyn Any` ... - if !cx.typeck_results().expr_adjustments(e).last().is_some_and(|adj| { + if !cx.typeck_results.expr_adjustments(e).last().is_some_and(|adj| { matches!(adj.kind, Adjust::Pointer(PointerCoercion::Unsize)) && is_ref_dyn_any(cx.tcx, adj.target) }) { return; } - let expr_ty = cx.typeck_results().expr_ty(e); + let expr_ty = cx.typeck_results.expr_ty(e); let ty::Ref(_, expr_ref_ty, _) = *expr_ty.kind() else { return; }; @@ -80,7 +80,7 @@ impl<'tcx> LateLintPass<'tcx> for CoerceContainerToAny { ExprKind::AddrOf(_, _, referent) => (referent, depth), _ => (e, depth + 1), }; - let ty::Ref(_, _, mutability) = *cx.typeck_results().expr_ty_adjusted(e).kind() else { + let ty::Ref(_, _, mutability) = *cx.typeck_results.expr_ty_adjusted(e).kind() else { return; }; let sugg = sugg::make_unop( diff --git a/src/tools/clippy/clippy_lints/src/cognitive_complexity.rs b/src/tools/clippy/clippy_lints/src/cognitive_complexity.rs index 95b99c1d2435f..df12ebb81c083 100644 --- a/src/tools/clippy/clippy_lints/src/cognitive_complexity.rs +++ b/src/tools/clippy/clippy_lints/src/cognitive_complexity.rs @@ -90,7 +90,7 @@ impl CognitiveComplexity { ControlFlow::Continue(()) }); - let ret_ty = cx.typeck_results().node_type(expr.hir_id); + let ret_ty = cx.typeck_results.node_type(expr.hir_id); let ret_adjust = if ret_ty.is_diag_item(cx, sym::Result) { returns } else { diff --git a/src/tools/clippy/clippy_lints/src/collection_is_never_read.rs b/src/tools/clippy/clippy_lints/src/collection_is_never_read.rs index ddd3e8b805d19..5eb2f052069ea 100644 --- a/src/tools/clippy/clippy_lints/src/collection_is_never_read.rs +++ b/src/tools/clippy/clippy_lints/src/collection_is_never_read.rs @@ -57,7 +57,7 @@ impl<'tcx> LateLintPass<'tcx> for CollectionIsNeverRead { } fn match_acceptable_type(cx: &LateContext<'_>, local: &LetStmt<'_>) -> bool { - let ty = cx.typeck_results().pat_ty(local.pat); + let ty = cx.typeck_results.pat_ty(local.pat); matches!( ty.opt_diag_name(cx), Some( @@ -108,7 +108,7 @@ fn has_no_read_access<'tcx, T: Visitable<'tcx>>(cx: &LateContext<'tcx>, id: HirI if let Node::Expr(parent) = cx.tcx.parent_hir_node(expr.hir_id) && let ExprKind::MethodCall(_, receiver, args, _) = parent.kind && receiver.res_local_id() == Some(id) - && let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(parent.hir_id) + && let Some(method_def_id) = cx.typeck_results.type_dependent_def_id(parent.hir_id) && !method_def_id.is_local() { // If this "official" method takes closures, @@ -142,7 +142,7 @@ fn has_no_read_access<'tcx, T: Visitable<'tcx>>(cx: &LateContext<'tcx>, id: HirI // // let y = x.clear(); // println!("{:?}", x.clear()); - if cx.typeck_results().expr_ty(parent).is_unit() { + if cx.typeck_results.expr_ty(parent).is_unit() { return ControlFlow::Continue(()); } } diff --git a/src/tools/clippy/clippy_lints/src/comparison_chain.rs b/src/tools/clippy/clippy_lints/src/comparison_chain.rs index 554f1ab186852..7c6a647f66077 100644 --- a/src/tools/clippy/clippy_lints/src/comparison_chain.rs +++ b/src/tools/clippy/clippy_lints/src/comparison_chain.rs @@ -110,7 +110,7 @@ impl<'tcx> LateLintPass<'tcx> for ComparisonChain { } // Check that the type being compared implements `core::cmp::Ord` - let ty = cx.typeck_results().expr_ty(lhs1); + let ty = cx.typeck_results.expr_ty(lhs1); let is_ord = cx .tcx .get_diagnostic_item(sym::Ord) diff --git a/src/tools/clippy/clippy_lints/src/default.rs b/src/tools/clippy/clippy_lints/src/default.rs index 2f4a67e15b927..fbf60532b1cbd 100644 --- a/src/tools/clippy/clippy_lints/src/default.rs +++ b/src/tools/clippy/clippy_lints/src/default.rs @@ -90,7 +90,7 @@ impl<'tcx> LateLintPass<'tcx> for Default { && !is_update_syntax_base(cx, expr) // Detect and ignore ::default() because these calls do explicitly name the type. && let QPath::Resolved(None, _path) = qpath - && let expr_ty = cx.typeck_results().expr_ty(expr) + && let expr_ty = cx.typeck_results.expr_ty(expr) && let ty::Adt(def, ..) = expr_ty.kind() && !is_from_proc_macro(cx, expr) { @@ -129,7 +129,7 @@ impl<'tcx> LateLintPass<'tcx> for Default { && let PatKind::Binding(_, binding_id, ident, _) = local.pat.kind // only when assigning `... = Default::default()` && is_expr_default(cx, expr) - && let binding_type = cx.typeck_results().node_type(binding_id) + && let binding_type = cx.typeck_results.node_type(binding_id) && let ty::Adt(adt, args) = *binding_type.kind() && adt.is_struct() && let variant = adt.non_enum_variant() diff --git a/src/tools/clippy/clippy_lints/src/default_constructed_unit_structs.rs b/src/tools/clippy/clippy_lints/src/default_constructed_unit_structs.rs index c831f96443c60..6b728733c6c89 100644 --- a/src/tools/clippy/clippy_lints/src/default_constructed_unit_structs.rs +++ b/src/tools/clippy/clippy_lints/src/default_constructed_unit_structs.rs @@ -69,7 +69,7 @@ impl LateLintPass<'_> for DefaultConstructedUnitStructs { && let Res::Def(_, def_id) = cx.qpath_res(qpath, fn_expr.hir_id) && cx.tcx.is_diagnostic_item(sym::default_fn, def_id) // make sure we have a struct with no fields (unit struct) - && let ty::Adt(def, ..) = cx.typeck_results().expr_ty(expr).kind() + && let ty::Adt(def, ..) = cx.typeck_results.expr_ty(expr).kind() && def.is_struct() && let var @ ty::VariantDef { ctor: Some((hir::def::CtorKind::Const, _)), .. } = def.non_enum_variant() && !var.is_field_list_non_exhaustive() diff --git a/src/tools/clippy/clippy_lints/src/default_numeric_fallback.rs b/src/tools/clippy/clippy_lints/src/default_numeric_fallback.rs index 649d8449e431b..fe4669fc98057 100644 --- a/src/tools/clippy/clippy_lints/src/default_numeric_fallback.rs +++ b/src/tools/clippy/clippy_lints/src/default_numeric_fallback.rs @@ -169,7 +169,7 @@ impl<'tcx> Visitor<'tcx> for NumericFallbackVisitor<'_, 'tcx> { }, ExprKind::MethodCall(_, receiver, args, _) => { - if let Some(def_id) = self.cx.typeck_results().type_dependent_def_id(expr.hir_id) { + if let Some(def_id) = self.cx.typeck_results.type_dependent_def_id(expr.hir_id) { let fn_sig = self .cx .tcx @@ -187,7 +187,7 @@ impl<'tcx> Visitor<'tcx> for NumericFallbackVisitor<'_, 'tcx> { }, ExprKind::Struct(_, fields, base) => { - let ty = self.cx.typeck_results().expr_ty(expr); + let ty = self.cx.typeck_results.expr_ty(expr); if let Some(adt_def) = ty.ty_adt_def() && adt_def.is_struct() && let Some(variant) = adt_def.variants().iter().next() @@ -219,7 +219,7 @@ impl<'tcx> Visitor<'tcx> for NumericFallbackVisitor<'_, 'tcx> { }, ExprKind::Lit(lit) => { - let ty = self.cx.typeck_results().expr_ty(expr); + let ty = self.cx.typeck_results.expr_ty(expr); self.check_lit(*lit, ty, expr.hir_id); return; }, @@ -237,7 +237,7 @@ impl<'tcx> Visitor<'tcx> for NumericFallbackVisitor<'_, 'tcx> { .. }) = pat.kind { - let ty = self.cx.typeck_results().node_type(hir_id); + let ty = self.cx.typeck_results.node_type(hir_id); self.check_lit(lit, ty, hir_id); return; } @@ -258,7 +258,7 @@ impl<'tcx> Visitor<'tcx> for NumericFallbackVisitor<'_, 'tcx> { } fn fn_sig_opt<'tcx>(cx: &LateContext<'tcx>, hir_id: HirId) -> Option> { - let node_ty = cx.typeck_results().node_type_opt(hir_id)?; + let node_ty = cx.typeck_results.node_type_opt(hir_id)?; // We can't use `Ty::fn_sig` because it automatically performs args, this may result in FNs. match node_ty.kind() { ty::FnDef(def_id, _) => Some(cx.tcx.fn_sig(*def_id).instantiate_identity().skip_norm_wip()), diff --git a/src/tools/clippy/clippy_lints/src/dereference.rs b/src/tools/clippy/clippy_lints/src/dereference.rs index 26a06992d1a6f..f0a1b0f41b579 100644 --- a/src/tools/clippy/clippy_lints/src/dereference.rs +++ b/src/tools/clippy/clippy_lints/src/dereference.rs @@ -253,12 +253,12 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing<'tcx> { // Stop processing sub expressions when a macro call is seen if expr.span.from_expansion() { if let Some((state, data)) = self.state.take() { - self.report(cx, expr, state, data, cx.typeck_results()); + self.report(cx, expr, state, data, cx.typeck_results); } return; } - let typeck = cx.typeck_results(); + let typeck = cx.typeck_results; let Some((kind, sub_expr, skip_expr)) = try_parse_ref_op(cx.tcx, typeck, expr) else { // The whole chain of reference operations has been seen if let Some((state, data)) = self.state.take() { @@ -270,7 +270,7 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing<'tcx> { if is_from_proc_macro(cx, expr) { if let Some((state, data)) = self.state.take() { - self.report(cx, expr, state, data, cx.typeck_results()); + self.report(cx, expr, state, data, cx.typeck_results); } return; } @@ -671,7 +671,7 @@ impl<'tcx> LateLintPass<'tcx> for Dereferencing<'tcx> { } if !pat.span.from_expansion() - && let ty::Ref(_, tam, _) = *cx.typeck_results().pat_ty(pat).kind() + && let ty::Ref(_, tam, _) = *cx.typeck_results.pat_ty(pat).kind() // only lint immutable refs, because borrowed `&mut T` cannot be moved out && let ty::Ref(_, _, Mutability::Not) = *tam.kind() { @@ -1023,7 +1023,7 @@ impl<'tcx> Dereferencing<'tcx> { && let Some(pat) = outer_pat // Check for auto-deref && !matches!( - cx.typeck_results().expr_adjustments(e), + cx.typeck_results.expr_adjustments(e), [ Adjustment { kind: Adjust::Deref(_), @@ -1145,7 +1145,7 @@ impl<'tcx> Dereferencing<'tcx> { // as this may make rustc trigger its `dangerous_implicit_autorefs` lint. if let ExprKind::AddrOf(BorrowKind::Ref, _, subexpr) = data.first_expr.kind && let ExprKind::Unary(UnOp::Deref, subsubexpr) = subexpr.kind - && cx.typeck_results().expr_ty_adjusted(subsubexpr).is_raw_ptr() + && cx.typeck_results.expr_ty_adjusted(subsubexpr).is_raw_ptr() { return; } diff --git a/src/tools/clippy/clippy_lints/src/disallowed_fields.rs b/src/tools/clippy/clippy_lints/src/disallowed_fields.rs index 28fcb46c50b69..8e855c4a101c8 100644 --- a/src/tools/clippy/clippy_lints/src/disallowed_fields.rs +++ b/src/tools/clippy/clippy_lints/src/disallowed_fields.rs @@ -84,7 +84,7 @@ impl<'tcx> LateLintPass<'tcx> for DisallowedFields { // Very round-about way to get the field `DefId` from the expr: first we get its // parent `Ty`. Then we go through all its fields to find the one with the expected // name and get the `DefId` from it. - if let Some(parent_ty) = cx.typeck_results().expr_ty_adjusted_opt(e) + if let Some(parent_ty) = cx.typeck_results.expr_ty_adjusted_opt(e) && let Some(field_def_id) = get_field_def_id_by_name(parent_ty, ident.name) { (field_def_id, ident.span) @@ -109,7 +109,7 @@ impl<'tcx> LateLintPass<'tcx> for DisallowedFields { let PatKind::Struct(struct_path, pat_fields, _) = pat.kind else { return; }; - match cx.typeck_results().qpath_res(&struct_path, pat.hir_id) { + match cx.typeck_results.qpath_res(&struct_path, pat.hir_id) { Res::Def(DefKind::Struct, struct_def_id) => { let adt_def = cx.tcx.adt_def(struct_def_id); for field in pat_fields { diff --git a/src/tools/clippy/clippy_lints/src/disallowed_methods.rs b/src/tools/clippy/clippy_lints/src/disallowed_methods.rs index 58cc318d57ccd..740d7cdf068cb 100644 --- a/src/tools/clippy/clippy_lints/src/disallowed_methods.rs +++ b/src/tools/clippy/clippy_lints/src/disallowed_methods.rs @@ -176,7 +176,7 @@ impl<'tcx> LateLintPass<'tcx> for DisallowedMethods { } let (id, span) = match &expr.kind { ExprKind::Path(path) if let Res::Def(_, id) = cx.qpath_res(path, expr.hir_id) => (id, expr.span), - ExprKind::MethodCall(name, ..) if let Some(id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) => { + ExprKind::MethodCall(name, ..) if let Some(id) = cx.typeck_results.type_dependent_def_id(expr.hir_id) => { (id, name.ident.span) }, _ => return, diff --git a/src/tools/clippy/clippy_lints/src/drop_forget_ref.rs b/src/tools/clippy/clippy_lints/src/drop_forget_ref.rs index 5da76bc3095f2..c624daee61580 100644 --- a/src/tools/clippy/clippy_lints/src/drop_forget_ref.rs +++ b/src/tools/clippy/clippy_lints/src/drop_forget_ref.rs @@ -84,7 +84,7 @@ impl<'tcx> LateLintPass<'tcx> for DropForgetRef { && let Some(def_id) = cx.qpath_res(qpath, path.hir_id).opt_def_id() && let Some(fn_name) = cx.tcx.get_diagnostic_name(def_id) { - let arg_ty = cx.typeck_results().expr_ty(arg); + let arg_ty = cx.typeck_results.expr_ty(arg); let is_copy = is_copy(cx, arg_ty); let drop_is_single_call_in_arm = is_single_call_in_arm(cx, arg, expr); let (lint, msg, note_span) = match fn_name { diff --git a/src/tools/clippy/clippy_lints/src/duration_suboptimal_units.rs b/src/tools/clippy/clippy_lints/src/duration_suboptimal_units.rs index ceb24709add30..345bf7df8fc88 100644 --- a/src/tools/clippy/clippy_lints/src/duration_suboptimal_units.rs +++ b/src/tools/clippy/clippy_lints/src/duration_suboptimal_units.rs @@ -76,10 +76,10 @@ impl LateLintPass<'_> for DurationSuboptimalUnits { && let ExprKind::Call(func, [arg]) = expr.kind && let ExprKind::Path(QPath::TypeRelative(func_ty, func_name)) = func.kind && cx - .typeck_results() + .typeck_results .node_type(func_ty.hir_id) .is_diag_item(cx, sym::Duration) - && matches!(cx.typeck_results().expr_ty_adjusted(arg).kind(), ty::Uint(UintTy::U64)) + && matches!(cx.typeck_results.expr_ty_adjusted(arg).kind(), ty::Uint(UintTy::U64)) // We intentionally don't want to evaluate referenced constants, as we don't want to // recommend a literal value over using constants: // diff --git a/src/tools/clippy/clippy_lints/src/empty_with_brackets.rs b/src/tools/clippy/clippy_lints/src/empty_with_brackets.rs index ee1be48417222..1c057c1a46ea2 100644 --- a/src/tools/clippy/clippy_lints/src/empty_with_brackets.rs +++ b/src/tools/clippy/clippy_lints/src/empty_with_brackets.rs @@ -301,7 +301,7 @@ fn check_expr_for_enum_as_function(cx: &LateContext<'_>, expr: &Expr<'_>) -> Opt }, )) => def_id.as_local().map(|id| (id, span.with_lo(expr.span.hi()))), ExprKind::Struct(qpath, ..) - if let Def(DefKind::Variant, mut def_id) = cx.typeck_results().qpath_res(qpath, expr.hir_id) => + if let Def(DefKind::Variant, mut def_id) = cx.typeck_results.qpath_res(qpath, expr.hir_id) => { let ty = cx.tcx.type_of(def_id).instantiate_identity().skip_norm_wip(); if let ty::FnDef(ctor_def_id, _) = ty.kind() { @@ -317,12 +317,12 @@ fn check_expr_for_enum_as_function(cx: &LateContext<'_>, expr: &Expr<'_>) -> Opt fn check_pat_for_enum_as_function(cx: &LateContext<'_>, pat: &Pat<'_>) -> Option<(LocalDefId, Span)> { match pat.kind { PatKind::TupleStruct(qpath, ..) - if let Def(Ctor(CtorOf::Variant, _), def_id) = cx.typeck_results().qpath_res(&qpath, pat.hir_id) => + if let Def(Ctor(CtorOf::Variant, _), def_id) = cx.typeck_results.qpath_res(&qpath, pat.hir_id) => { def_id.as_local().map(|id| (id, qpath.span().with_lo(pat.span.hi()))) }, PatKind::Struct(qpath, ..) - if let Def(DefKind::Variant, mut def_id) = cx.typeck_results().qpath_res(&qpath, pat.hir_id) => + if let Def(DefKind::Variant, mut def_id) = cx.typeck_results.qpath_res(&qpath, pat.hir_id) => { let ty = cx.tcx.type_of(def_id).instantiate_identity().skip_norm_wip(); if let ty::FnDef(ctor_def_id, _) = ty.kind() { diff --git a/src/tools/clippy/clippy_lints/src/endian_bytes.rs b/src/tools/clippy/clippy_lints/src/endian_bytes.rs index d76729047cdc5..53dd36ca38289 100644 --- a/src/tools/clippy/clippy_lints/src/endian_bytes.rs +++ b/src/tools/clippy/clippy_lints/src/endian_bytes.rs @@ -124,7 +124,7 @@ impl LateLintPass<'_> for EndianBytes { _ => return, }; if !expr.span.in_external_macro(cx.sess().source_map()) - && let ty = cx.typeck_results().expr_ty(ty_expr) + && let ty = cx.typeck_results.expr_ty(ty_expr) && ty.is_primitive_ty() { maybe_lint_endian_bytes(cx, expr, prefix, name, ty); diff --git a/src/tools/clippy/clippy_lints/src/entry.rs b/src/tools/clippy/clippy_lints/src/entry.rs index a24cc957df070..5c8a1ad4390ec 100644 --- a/src/tools/clippy/clippy_lints/src/entry.rs +++ b/src/tools/clippy/clippy_lints/src/entry.rs @@ -277,7 +277,7 @@ fn try_parse_contains<'tcx>(cx: &LateContext<'_>, expr: &'tcx Expr<'_>) -> Optio } = arg && key_span.eq_ctxt(expr.span) { - let id = cx.typeck_results().type_dependent_def_id(expr.hir_id)?; + let id = cx.typeck_results.type_dependent_def_id(expr.hir_id)?; let expr = ContainsExpr { negated, map, @@ -318,7 +318,7 @@ struct InsertExpr<'tcx> { /// If the given expression is not an `insert` call into a `BTreeMap` or a `HashMap`, return `None`. fn try_parse_insert<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option> { if let ExprKind::MethodCall(_, map, [key, value], _) = expr.kind { - let id = cx.typeck_results().type_dependent_def_id(expr.hir_id)?; + let id = cx.typeck_results.type_dependent_def_id(expr.hir_id)?; if let Some(insert) = cx.tcx.get_diagnostic_name(id) && matches!(insert, sym::btreemap_insert | sym::hashmap_insert) { @@ -743,7 +743,7 @@ fn find_insert_calls<'tcx>( map_is_mutex_guard: false, }; // Check if the map is a non-async-aware `MutexGuard` - if let rustc_middle::ty::Adt(adt, _) = cx.typeck_results().expr_ty(contains_expr.map).kind() + if let rustc_middle::ty::Adt(adt, _) = cx.typeck_results.expr_ty(contains_expr.map).kind() && is_mutex_guard(cx, adt.did()) { s.map_is_mutex_guard = true; @@ -754,7 +754,7 @@ fn find_insert_calls<'tcx>( return None; } - let is_key_used_and_no_copy = s.is_key_used && !is_copy(cx, cx.typeck_results().expr_ty(contains_expr.key)); + let is_key_used_and_no_copy = s.is_key_used && !is_copy(cx, cx.typeck_results.expr_ty(contains_expr.key)); Some(InsertSearchResults { edits: s.edits, allow_insert_closure: s.allow_insert_closure, diff --git a/src/tools/clippy/clippy_lints/src/equatable_if_let.rs b/src/tools/clippy/clippy_lints/src/equatable_if_let.rs index a92bfd45df0ce..616e65152a968 100644 --- a/src/tools/clippy/clippy_lints/src/equatable_if_let.rs +++ b/src/tools/clippy/clippy_lints/src/equatable_if_let.rs @@ -88,7 +88,7 @@ fn contains_type_mismatch(cx: &LateContext<'_>, pat: &Pat<'_>) -> bool { _ => p, }; - if let Some(adjustments) = cx.typeck_results().pat_adjustments().get(adjust_pat.hir_id) + if let Some(adjustments) = cx.typeck_results.pat_adjustments().get(adjust_pat.hir_id) && adjustments.first().is_some_and(|first| first.source.is_ref()) { result = true; @@ -109,8 +109,8 @@ impl<'tcx> LateLintPass<'tcx> for PatternEquality { && !let_expr.pat.span.from_expansion() && !let_expr.init.span.from_expansion() { - let exp_ty = cx.typeck_results().expr_ty(let_expr.init); - let pat_ty = cx.typeck_results().pat_ty(let_expr.pat); + let exp_ty = cx.typeck_results.expr_ty(let_expr.init); + let pat_ty = cx.typeck_results.pat_ty(let_expr.pat); let mut app = Applicability::MachineApplicable; let ctxt = expr.span.ctxt(); diff --git a/src/tools/clippy/clippy_lints/src/eta_reduction.rs b/src/tools/clippy/clippy_lints/src/eta_reduction.rs index 6248ba6e44da5..8d5d12445a14d 100644 --- a/src/tools/clippy/clippy_lints/src/eta_reduction.rs +++ b/src/tools/clippy/clippy_lints/src/eta_reduction.rs @@ -127,7 +127,7 @@ fn check_closure<'tcx>(cx: &LateContext<'tcx>, outer_receiver: Option<&Expr<'tcx return; } - let typeck = cx.typeck_results(); + let typeck = cx.typeck_results; let closure = if let ty::Closure(_, closure_subs) = typeck.expr_ty(expr).kind() { closure_subs.as_closure() } else { diff --git a/src/tools/clippy/clippy_lints/src/float_literal.rs b/src/tools/clippy/clippy_lints/src/float_literal.rs index ab1f5b88bacee..433c0af48b693 100644 --- a/src/tools/clippy/clippy_lints/src/float_literal.rs +++ b/src/tools/clippy/clippy_lints/src/float_literal.rs @@ -79,7 +79,7 @@ impl<'tcx> LateLintPass<'tcx> for FloatLiteral { fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) { if let hir::ExprKind::Lit(lit) = expr.kind && let LitKind::Float(sym, lit_float_ty) = lit.node - && let ty::Float(fty) = *cx.typeck_results().expr_ty(expr).kind() + && let ty::Float(fty) = *cx.typeck_results.expr_ty(expr).kind() { let sym_str = sym.as_str(); let formatter = FloatFormat::new(sym_str); @@ -144,7 +144,7 @@ impl<'tcx> LateLintPass<'tcx> for FloatLiteral { } else if digits > max as usize && count_digits(&float_str) < digits { if digits >= self.const_literal_digits_threshold && matches!( - get_expr_use_site(cx.tcx, cx.typeck_results(), expr.span.ctxt(), expr).use_node(cx), + get_expr_use_site(cx.tcx, cx.typeck_results, expr.span.ctxt(), expr).use_node(cx), ExprUseNode::ConstStatic(_) ) { diff --git a/src/tools/clippy/clippy_lints/src/floating_point_arithmetic/expm1.rs b/src/tools/clippy/clippy_lints/src/floating_point_arithmetic/expm1.rs index bf376a51fec93..862d0f8f4c483 100644 --- a/src/tools/clippy/clippy_lints/src/floating_point_arithmetic/expm1.rs +++ b/src/tools/clippy/clippy_lints/src/floating_point_arithmetic/expm1.rs @@ -22,10 +22,10 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) { ) = expr.kind && let ExprKind::MethodCall(path, self_arg, [], _) = lhs.kind && path.ident.name == sym::exp - && cx.typeck_results().expr_ty(lhs).is_floating_point() + && cx.typeck_results.expr_ty(lhs).is_floating_point() && let Some(value) = ConstEvalCtxt::new(cx).eval(rhs) && (F32(1.0) == value || F64(1.0) == value) - && cx.typeck_results().expr_ty(self_arg).is_floating_point() + && cx.typeck_results.expr_ty(self_arg).is_floating_point() { span_lint_and_then( cx, diff --git a/src/tools/clippy/clippy_lints/src/floating_point_arithmetic/lib.rs b/src/tools/clippy/clippy_lints/src/floating_point_arithmetic/lib.rs index 3fa041f97802a..c3d76142278ae 100644 --- a/src/tools/clippy/clippy_lints/src/floating_point_arithmetic/lib.rs +++ b/src/tools/clippy/clippy_lints/src/floating_point_arithmetic/lib.rs @@ -17,7 +17,7 @@ pub(super) fn prepare_receiver_sugg<'a>( expr = inner_expr; } - if let ty::Float(float_ty) = cx.typeck_results().expr_ty(expr).kind() + if let ty::Float(float_ty) = cx.typeck_results.expr_ty(expr).kind() // if the expression is a float literal and it is unsuffixed then // add a suffix so the suggestion is valid and unambiguous && let ExprKind::Lit(lit) = expr.kind diff --git a/src/tools/clippy/clippy_lints/src/floating_point_arithmetic/mod.rs b/src/tools/clippy/clippy_lints/src/floating_point_arithmetic/mod.rs index 0833761b32dc7..164ba77dcb007 100644 --- a/src/tools/clippy/clippy_lints/src/floating_point_arithmetic/mod.rs +++ b/src/tools/clippy/clippy_lints/src/floating_point_arithmetic/mod.rs @@ -113,7 +113,7 @@ impl<'tcx> LateLintPass<'tcx> for FloatingPointArithmetic { } if let ExprKind::MethodCall(path, receiver, args, _) = expr.kind { - let recv_ty = cx.typeck_results().expr_ty(receiver); + let recv_ty = cx.typeck_results.expr_ty(receiver); if recv_ty.is_floating_point() && !is_no_std_crate(cx) && cx.ty_based_def(expr).opt_parent(cx).is_impl(cx) { match path.ident.name { diff --git a/src/tools/clippy/clippy_lints/src/floating_point_arithmetic/mul_add.rs b/src/tools/clippy/clippy_lints/src/floating_point_arithmetic/mul_add.rs index 888d5b7b762a0..446388d12caf4 100644 --- a/src/tools/clippy/clippy_lints/src/floating_point_arithmetic/mul_add.rs +++ b/src/tools/clippy/clippy_lints/src/floating_point_arithmetic/mul_add.rs @@ -17,8 +17,8 @@ fn is_float_mul_expr<'a>(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Option<(&' lhs, rhs, ) = expr.kind - && cx.typeck_results().expr_ty(lhs).is_floating_point() - && cx.typeck_results().expr_ty(rhs).is_floating_point() + && cx.typeck_results.expr_ty(lhs).is_floating_point() + && cx.typeck_results.expr_ty(rhs).is_floating_point() { return Some((lhs, rhs)); } @@ -73,13 +73,13 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) { }; let (recv, arg1, arg2, is_from_rhs) = if let Some((inner_lhs, inner_rhs)) = is_float_mul_expr(cx, rhs) - && cx.typeck_results().expr_ty(lhs).is_floating_point() + && cx.typeck_results.expr_ty(lhs).is_floating_point() && !has_ambiguous_type(inner_lhs) { (inner_lhs, inner_rhs, lhs, true) } else if !is_assign && let Some((inner_lhs, inner_rhs)) = is_float_mul_expr(cx, lhs) - && cx.typeck_results().expr_ty(rhs).is_floating_point() + && cx.typeck_results.expr_ty(rhs).is_floating_point() && !has_ambiguous_type(inner_lhs) { (inner_lhs, inner_rhs, rhs, false) diff --git a/src/tools/clippy/clippy_lints/src/format.rs b/src/tools/clippy/clippy_lints/src/format.rs index 2691fb4766397..71881d8ff4347 100644 --- a/src/tools/clippy/clippy_lints/src/format.rs +++ b/src/tools/clippy/clippy_lints/src/format.rs @@ -81,7 +81,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessFormat { && let FormatArgsPiece::Placeholder(placeholder) = piece && placeholder.format_trait == FormatTrait::Display && placeholder.format_options == FormatOptions::default() - && match cx.typeck_results().expr_ty(value).peel_refs().kind() { + && match cx.typeck_results.expr_ty(value).peel_refs().kind() { ty::Adt(adt, _) => Some(adt.did()) == cx.tcx.lang_items().string(), ty::Str => true, _ => false, diff --git a/src/tools/clippy/clippy_lints/src/format_args.rs b/src/tools/clippy/clippy_lints/src/format_args.rs index 05145456071c0..7887b5f41fb61 100644 --- a/src/tools/clippy/clippy_lints/src/format_args.rs +++ b/src/tools/clippy/clippy_lints/src/format_args.rs @@ -435,7 +435,7 @@ impl<'tcx> FormatArgsExpr<'_, 'tcx> { let name = self.cx.tcx.item_name(self.macro_call.def_id); self.check_unnecessary_debug_formatting(name, arg_expr); if let Some(span) = placeholder.span - && self.has_pointer_debug(self.cx.typeck_results().expr_ty(arg_expr), 0) + && self.has_pointer_debug(self.cx.typeck_results.expr_ty(arg_expr), 0) { span_lint(self.cx, POINTER_FORMAT, span, "pointer formatting detected"); } @@ -466,7 +466,7 @@ impl<'tcx> FormatArgsExpr<'_, 'tcx> { && let peeled_expr = peel_hir_expr_while(arg_expr, |e| { // Need to handle `&&&T` to `&T` when a single ref is still required if let ExprKind::AddrOf(BorrowKind::Ref, m, e) = e.kind - && let ty = self.cx.typeck_results().expr_ty(e) + && let ty = self.cx.typeck_results.expr_ty(e) && implements_trait(self.cx, ty, sized_trait, &[]) && implements_trait(self.cx, ty, fmt_trait, &[]) { @@ -505,7 +505,7 @@ impl<'tcx> FormatArgsExpr<'_, 'tcx> { if let Some(placeholder_span) = placeholder.span && *options != FormatOptions::default() - && let ty = self.cx.typeck_results().expr_ty(arg).peel_refs() + && let ty = self.cx.typeck_results.expr_ty(arg).peel_refs() && ty.is_lang_item(self.cx, LangItem::FormatArguments) { span_lint_and_then( @@ -684,14 +684,14 @@ impl<'tcx> FormatArgsExpr<'_, 'tcx> { if !value.span.from_expansion() && let ExprKind::MethodCall(_, receiver, [], to_string_span) = value.kind && cx - .typeck_results() + .typeck_results .type_dependent_def_id(value.hir_id) .opt_parent(cx) .is_diag_item(cx, sym::ToString) - && let receiver_ty = cx.typeck_results().expr_ty(receiver) + && let receiver_ty = cx.typeck_results.expr_ty(receiver) && let Some(display_trait_id) = cx.tcx.get_diagnostic_item(sym::Display) && let (n_needed_derefs, target) = - count_needed_derefs(receiver_ty, cx.typeck_results().expr_adjustments(receiver).iter()) + count_needed_derefs(receiver_ty, cx.typeck_results.expr_adjustments(receiver).iter()) && implements_trait(cx, target, display_trait_id, &[]) && let Some(sized_trait_id) = cx.tcx.lang_items().sized_trait() && let Some(receiver_snippet) = receiver.span.source_callsite().get_source_text(cx) @@ -730,7 +730,7 @@ impl<'tcx> FormatArgsExpr<'_, 'tcx> { if !is_in_test(cx.tcx, value.hir_id) && !value.span.from_expansion() && !is_from_proc_macro(cx, value) - && let ty = cx.typeck_results().expr_ty(value) + && let ty = cx.typeck_results.expr_ty(value) && self.can_display_format(ty) { // If the parent function is a method of `Debug`, we don't want to lint diff --git a/src/tools/clippy/clippy_lints/src/format_impl.rs b/src/tools/clippy/clippy_lints/src/format_impl.rs index 4d0a324a2a39c..63c071c379e69 100644 --- a/src/tools/clippy/clippy_lints/src/format_impl.rs +++ b/src/tools/clippy/clippy_lints/src/format_impl.rs @@ -160,7 +160,7 @@ impl FormatImplExpr<'_, '_> { // separately) && self .cx - .typeck_results() + .typeck_results .type_dependent_def_id(self.expr.hir_id) .opt_parent(self.cx) .is_diag_item(self.cx, sym::ToString) diff --git a/src/tools/clippy/clippy_lints/src/format_push_string.rs b/src/tools/clippy/clippy_lints/src/format_push_string.rs index d5a7cffe9e6c8..eaa484e1ccb9f 100644 --- a/src/tools/clippy/clippy_lints/src/format_push_string.rs +++ b/src/tools/clippy/clippy_lints/src/format_push_string.rs @@ -123,7 +123,7 @@ impl<'tcx> LateLintPass<'tcx> for FormatPushString { fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) { let (recv, arg) = match expr.kind { ExprKind::MethodCall(_, recv, [arg], _) => { - if let Some(fn_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) + if let Some(fn_def_id) = cx.typeck_results.type_dependent_def_id(expr.hir_id) && cx.tcx.is_diagnostic_item(sym::string_push_str, fn_def_id) { (recv, arg) @@ -190,7 +190,7 @@ impl<'tcx> LateLintPass<'tcx> for FormatPushString { } fn is_string(cx: &LateContext<'_>, e: &Expr<'_>) -> bool { - cx.typeck_results() + cx.typeck_results .expr_ty(e) .peel_refs() .is_lang_item(cx, LangItem::String) diff --git a/src/tools/clippy/clippy_lints/src/from_raw_with_void_ptr.rs b/src/tools/clippy/clippy_lints/src/from_raw_with_void_ptr.rs index 5c6d6607a0aa2..429f24e852e4a 100644 --- a/src/tools/clippy/clippy_lints/src/from_raw_with_void_ptr.rs +++ b/src/tools/clippy/clippy_lints/src/from_raw_with_void_ptr.rs @@ -44,7 +44,7 @@ impl LateLintPass<'_> for FromRawWithVoidPtr { && let ExprKind::Path(QPath::TypeRelative(ty, seg)) = box_from_raw.kind && seg.ident.name == sym::from_raw && let Some(type_str) = ty.basic_res().opt_def_id().and_then(|id| def_id_matches_type(cx, id)) - && let arg_kind = cx.typeck_results().expr_ty(arg).kind() + && let arg_kind = cx.typeck_results.expr_ty(arg).kind() && let ty::RawPtr(ty, _) = arg_kind && is_c_void(cx, *ty) { diff --git a/src/tools/clippy/clippy_lints/src/from_str_radix_10.rs b/src/tools/clippy/clippy_lints/src/from_str_radix_10.rs index df8a35d9658b0..5dc434ce08036 100644 --- a/src/tools/clippy/clippy_lints/src/from_str_radix_10.rs +++ b/src/tools/clippy/clippy_lints/src/from_str_radix_10.rs @@ -65,7 +65,7 @@ impl<'tcx> LateLintPass<'tcx> for FromStrRadix10 { && !is_in_const_context(cx) { let expr = if let ExprKind::AddrOf(_, _, expr) = &src.kind { - let ty = cx.typeck_results().expr_ty(expr); + let ty = cx.typeck_results.expr_ty(expr); if is_ty_stringish(cx, ty) { expr } else { &src } } else { &src diff --git a/src/tools/clippy/clippy_lints/src/functions/misnamed_getters.rs b/src/tools/clippy/clippy_lints/src/functions/misnamed_getters.rs index 215039952ca5a..29a21915e37bb 100644 --- a/src/tools/clippy/clippy_lints/src/functions/misnamed_getters.rs +++ b/src/tools/clippy/clippy_lints/src/functions/misnamed_getters.rs @@ -80,7 +80,7 @@ pub fn check_fn(cx: &LateContext<'_>, kind: FnKind<'_>, decl: &FnDecl<'_>, body: let mut used_field = None; let mut correct_field = None; - let typeck_results = cx.typeck_results(); + let typeck_results = cx.typeck_results; for adjusted_type in iter::once(typeck_results.expr_ty(self_data)) .chain(typeck_results.expr_adjustments(self_data).iter().map(|adj| adj.target)) { diff --git a/src/tools/clippy/clippy_lints/src/functions/ref_option.rs b/src/tools/clippy/clippy_lints/src/functions/ref_option.rs index 1727f50b521a6..cd87e52513edf 100644 --- a/src/tools/clippy/clippy_lints/src/functions/ref_option.rs +++ b/src/tools/clippy/clippy_lints/src/functions/ref_option.rs @@ -96,7 +96,7 @@ pub(crate) fn check_fn<'a>( }; // Figure out the signature of the closure - let ty::Closure(_, args) = cx.typeck_results().expr_ty(body.value).kind() else { + let ty::Closure(_, args) = cx.typeck_results.expr_ty(body.value).kind() else { return; }; let sig = args.as_closure().sig().skip_binder(); diff --git a/src/tools/clippy/clippy_lints/src/functions/result.rs b/src/tools/clippy/clippy_lints/src/functions/result.rs index 331c6e23bddd7..f55ae41443825 100644 --- a/src/tools/clippy/clippy_lints/src/functions/result.rs +++ b/src/tools/clippy/clippy_lints/src/functions/result.rs @@ -197,7 +197,7 @@ pub(super) fn check_expr<'tcx>( large_err_ignored: &DefIdSet, ) { if let hir::ExprKind::Closure(closure) = expr.kind - && let ty::Closure(_, args) = cx.typeck_results().expr_ty(expr).kind() + && let ty::Closure(_, args) = cx.typeck_results.expr_ty(expr).kind() && let closure_sig = args.as_closure().sig() && let Ok(err_binder) = closure_sig.output().try_map_bound(|output_ty| { if let ty::Adt(adt, args) = output_ty.kind() diff --git a/src/tools/clippy/clippy_lints/src/if_let_mutex.rs b/src/tools/clippy/clippy_lints/src/if_let_mutex.rs index 38fda71fccf2f..a6243b3d36d47 100644 --- a/src/tools/clippy/clippy_lints/src/if_let_mutex.rs +++ b/src/tools/clippy/clippy_lints/src/if_let_mutex.rs @@ -97,7 +97,7 @@ fn mutex_lock_call<'tcx>( ) -> ControlFlow<&'tcx Expr<'tcx>> { if let ExprKind::MethodCall(path, self_arg, [], _) = &expr.kind && path.ident.name == sym::lock - && let ty = cx.typeck_results().expr_ty(self_arg).peel_refs() + && let ty = cx.typeck_results.expr_ty(self_arg).peel_refs() && ty.is_diag_item(cx, sym::Mutex) && op_mutex.is_none_or(|op| eq_expr_value(cx, ctxt, self_arg, op)) { diff --git a/src/tools/clippy/clippy_lints/src/ifs/branches_sharing_code.rs b/src/tools/clippy/clippy_lints/src/ifs/branches_sharing_code.rs index 06ebd3ac7f5fd..9636595d33970 100644 --- a/src/tools/clippy/clippy_lints/src/ifs/branches_sharing_code.rs +++ b/src/tools/clippy/clippy_lints/src/ifs/branches_sharing_code.rs @@ -90,7 +90,7 @@ pub(super) fn check<'tcx>( sugg, Applicability::Unspecified, ); - if is_expr_parent_assignment(cx, expr) || !cx.typeck_results().expr_ty(expr).is_unit() { + if is_expr_parent_assignment(cx, expr) || !cx.typeck_results.expr_ty(expr).is_unit() { diag.note("the end suggestion probably needs some adjustments to use the expression result correctly"); } } @@ -232,7 +232,7 @@ fn scan_block_for_eq<'tcx>( .enumerate() .find(|&(i, stmt)| { if let StmtKind::Let(l) = stmt.kind - && needs_ordered_drop(cx, cx.typeck_results().node_type(l.hir_id)) + && needs_ordered_drop(cx, cx.typeck_results.node_type(l.hir_id)) { local_needs_ordered_drop = true; return true; diff --git a/src/tools/clippy/clippy_lints/src/ifs/ifs_same_cond.rs b/src/tools/clippy/clippy_lints/src/ifs/ifs_same_cond.rs index ac010a9314b3c..35be58923d6f9 100644 --- a/src/tools/clippy/clippy_lints/src/ifs/ifs_same_cond.rs +++ b/src/tools/clippy/clippy_lints/src/ifs/ifs_same_cond.rs @@ -13,7 +13,7 @@ fn method_caller_is_mutable<'tcx>( caller_expr: &Expr<'_>, interior_mut: &mut InteriorMut<'tcx>, ) -> bool { - let caller_ty = cx.typeck_results().expr_ty(caller_expr); + let caller_ty = cx.typeck_results.expr_ty(caller_expr); interior_mut.is_interior_mut_ty(cx, caller_ty) || caller_ty.is_mutable_ptr() diff --git a/src/tools/clippy/clippy_lints/src/ignored_unit_patterns.rs b/src/tools/clippy/clippy_lints/src/ignored_unit_patterns.rs index cf7b444f6754c..712480c964609 100644 --- a/src/tools/clippy/clippy_lints/src/ignored_unit_patterns.rs +++ b/src/tools/clippy/clippy_lints/src/ignored_unit_patterns.rs @@ -40,7 +40,7 @@ impl<'tcx> LateLintPass<'tcx> for IgnoredUnitPatterns { fn check_pat(&mut self, cx: &LateContext<'tcx>, pat: &'tcx hir::Pat<'tcx>) { if matches!(pat.kind, PatKind::Wild) && !pat.span.from_expansion() - && cx.typeck_results().pat_ty(pat).peel_refs().is_unit() + && cx.typeck_results.pat_ty(pat).peel_refs().is_unit() { match cx.tcx.parent_hir_node(pat.hir_id) { Node::Param(param) if matches!(cx.tcx.parent_hir_node(param.hir_id), Node::Item(_)) => { diff --git a/src/tools/clippy/clippy_lints/src/implicit_return.rs b/src/tools/clippy/clippy_lints/src/implicit_return.rs index 6ed478b2708a3..edfc185fa2be3 100644 --- a/src/tools/clippy/clippy_lints/src/implicit_return.rs +++ b/src/tools/clippy/clippy_lints/src/implicit_return.rs @@ -199,7 +199,7 @@ fn lint_implicit_returns( | ExprKind::Binary(..) | ExprKind::Unary(..) | ExprKind::Index(..) - if cx.typeck_results().expr_ty(expr).is_never() => + if cx.typeck_results.expr_ty(expr).is_never() => { LintLocation::Inner }, @@ -235,7 +235,7 @@ impl<'tcx> LateLintPass<'tcx> for ImplicitReturn { return; } - let res_ty = cx.typeck_results().expr_ty(body.value); + let res_ty = cx.typeck_results.expr_ty(body.value); if res_ty.is_unit() || res_ty.is_never() { return; } diff --git a/src/tools/clippy/clippy_lints/src/implicit_saturating_add.rs b/src/tools/clippy/clippy_lints/src/implicit_saturating_add.rs index 06342113b104e..5ec5995ab920f 100644 --- a/src/tools/clippy/clippy_lints/src/implicit_saturating_add.rs +++ b/src/tools/clippy/clippy_lints/src/implicit_saturating_add.rs @@ -62,7 +62,7 @@ impl<'tcx> LateLintPass<'tcx> for ImplicitSaturatingAdd { .. } = block && let ExprKind::AssignOp(op1, target, value) = ex.kind - && let ty = cx.typeck_results().expr_ty(target) + && let ty = cx.typeck_results.expr_ty(target) && Some(c) == get_int_max(ty) && let ctxt = expr.span.ctxt() && ex.span.ctxt() == ctxt diff --git a/src/tools/clippy/clippy_lints/src/implicit_saturating_sub.rs b/src/tools/clippy/clippy_lints/src/implicit_saturating_sub.rs index 4093ff9f4b2d8..fe6fbeb59b66e 100644 --- a/src/tools/clippy/clippy_lints/src/implicit_saturating_sub.rs +++ b/src/tools/clippy/clippy_lints/src/implicit_saturating_sub.rs @@ -130,7 +130,7 @@ fn check_manual_check<'tcx>( else_block: &Expr<'tcx>, msrv: Msrv, ) { - let ty = cx.typeck_results().expr_ty(left_hand); + let ty = cx.typeck_results.expr_ty(left_hand); if ty.is_numeric() && !ty.is_signed() { match condition.node { BinOpKind::Gt | BinOpKind::Ge => check_gt( @@ -255,7 +255,7 @@ fn check_subtraction( let get_snippet = |span: Span| { let (snippet, _) = snippet_with_context(cx, span, expr_span_ctxt, "..", &mut applicability); - let big_expr_ty = cx.typeck_results().expr_ty(big_expr); + let big_expr_ty = cx.typeck_results.expr_ty(big_expr); Cow::Owned(format!("{snippet}_{big_expr_ty}")) }; Sugg::hir_from_snippet(cx, big_expr, get_snippet) @@ -338,7 +338,7 @@ fn check_with_condition<'tcx>( }; // Check if the variable in the condition statement is an integer - if !cx.typeck_results().expr_ty(cond_var).is_integral() { + if !cx.typeck_results.expr_ty(cond_var).is_integral() { return; } @@ -348,7 +348,7 @@ fn check_with_condition<'tcx>( ExprKind::Lit(cond_lit) => { // Check if the constant is zero if let LitKind::Int(Pu128(0), _) = cond_lit.node { - if cx.typeck_results().expr_ty(cond_left).is_signed() { + if cx.typeck_results.expr_ty(cond_left).is_signed() { } else { print_lint_and_sugg(cx, var_name, expr); } @@ -356,7 +356,7 @@ fn check_with_condition<'tcx>( }, ExprKind::Path(QPath::TypeRelative(_, name)) => { if name.ident.name == sym::MIN - && let Some(const_id) = cx.typeck_results().type_dependent_def_id(cond_num_val.hir_id) + && let Some(const_id) = cx.typeck_results.type_dependent_def_id(cond_num_val.hir_id) && let Some(impl_id) = cx.tcx.inherent_impl_of_assoc(const_id) && cx .tcx @@ -371,7 +371,7 @@ fn check_with_condition<'tcx>( ExprKind::Call(func, []) => { if let ExprKind::Path(QPath::TypeRelative(_, name)) = func.kind && name.ident.name == sym::min_value - && let Some(func_id) = cx.typeck_results().type_dependent_def_id(func.hir_id) + && let Some(func_id) = cx.typeck_results.type_dependent_def_id(func.hir_id) && let Some(impl_id) = cx.tcx.inherent_impl_of_assoc(func_id) && cx .tcx diff --git a/src/tools/clippy/clippy_lints/src/incompatible_msrv.rs b/src/tools/clippy/clippy_lints/src/incompatible_msrv.rs index 1ae8198a432dd..a082f98a8d184 100644 --- a/src/tools/clippy/clippy_lints/src/incompatible_msrv.rs +++ b/src/tools/clippy/clippy_lints/src/incompatible_msrv.rs @@ -220,7 +220,7 @@ impl<'tcx> LateLintPass<'tcx> for IncompatibleMsrv { fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) { match expr.kind { ExprKind::MethodCall(_, _, _, span) => { - if let Some(method_did) = cx.typeck_results().type_dependent_def_id(expr.hir_id) { + if let Some(method_did) = cx.typeck_results.type_dependent_def_id(expr.hir_id) { self.emit_lint_if_under_msrv(cx, is_in_const_context(cx), method_did, expr.hir_id, span); } }, @@ -229,7 +229,7 @@ impl<'tcx> LateLintPass<'tcx> for IncompatibleMsrv { let needs_const = is_in_const_context(cx); let def_id = if let Some(def_id) = cx.qpath_res(&qpath, callee.hir_id).opt_def_id() { def_id - } else if needs_const && let ty::FnDef(def_id, _) = *cx.typeck_results().expr_ty(callee).kind() { + } else if needs_const && let ty::FnDef(def_id, _) = *cx.typeck_results.expr_ty(callee).kind() { // Edge case where a function is first assigned then called. // We previously would have warned for the non-const MSRV, when // checking the path, but now that it's called the const MSRV diff --git a/src/tools/clippy/clippy_lints/src/inconsistent_struct_constructor.rs b/src/tools/clippy/clippy_lints/src/inconsistent_struct_constructor.rs index 4555af85c2d26..8a4e608409abc 100644 --- a/src/tools/clippy/clippy_lints/src/inconsistent_struct_constructor.rs +++ b/src/tools/clippy/clippy_lints/src/inconsistent_struct_constructor.rs @@ -94,7 +94,7 @@ impl<'tcx> LateLintPass<'tcx> for InconsistentStructConstructor { return; }; if !expr.span.from_expansion() - && let ty = cx.typeck_results().expr_ty(expr) + && let ty = cx.typeck_results.expr_ty(expr) && let Some(adt_def) = ty.ty_adt_def() && adt_def.is_struct() && let Some(local_def_id) = adt_def.did().as_local() diff --git a/src/tools/clippy/clippy_lints/src/index_refutable_slice.rs b/src/tools/clippy/clippy_lints/src/index_refutable_slice.rs index b1f03babb9fa5..de732e42653f1 100644 --- a/src/tools/clippy/clippy_lints/src/index_refutable_slice.rs +++ b/src/tools/clippy/clippy_lints/src/index_refutable_slice.rs @@ -108,7 +108,7 @@ fn find_slice_values(cx: &LateContext<'_>, pat: &hir::Pat<'_>) -> FxIndexMap LateLintPass<'tcx> for IndexingSlicing { fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) { if let ExprKind::Index(array, index, _) = &expr.kind && (!self.suppress_restriction_lint_in_const || !cx.tcx.hir_is_inside_const_context(expr.hir_id)) - && let expr_ty = cx.typeck_results().expr_ty(array) + && let expr_ty = cx.typeck_results.expr_ty(array) && let mut deref = deref_chain(cx, expr_ty) && deref.any(|l| { l.peel_refs().is_slice() @@ -122,7 +122,7 @@ impl<'tcx> LateLintPass<'tcx> for IndexingSlicing { && !is_from_proc_macro(cx, expr) { let note = "the suggestion might not be applicable in constant blocks"; - let ty = cx.typeck_results().expr_ty(array).peel_refs(); + let ty = cx.typeck_results.expr_ty(array).peel_refs(); let allowed_in_tests = self.allow_indexing_slicing_in_tests && is_in_test(cx.tcx, expr.hir_id); if let Some(range) = higher::Range::hir(cx, index) { // Ranged indexes, i.e., &x[n..m], &x[n..], &x[..n] and &x[..] @@ -197,7 +197,7 @@ impl<'tcx> LateLintPass<'tcx> for IndexingSlicing { // leave other type to rustc if let Constant::Int(off) = constant && off <= usize::MAX as u128 - && let ty::Uint(utype) = cx.typeck_results().expr_ty(index).kind() + && let ty::Uint(utype) = cx.typeck_results.expr_ty(index).kind() && *utype == ty::UintTy::Usize && let ty::Array(_, s) = ty.kind() && let Some(size) = s.try_to_target_usize(cx.tcx) @@ -279,7 +279,7 @@ fn ty_has_applicable_get_function<'tcx>( && let Some(option_generic_param) = args.first() && let generic_ty = option_generic_param.expect_ty().peel_refs() // FIXME: ideally this would handle type params and projections properly, for now just assume it's the same type - && (cx.typeck_results().expr_ty(index_expr).peel_refs() == generic_ty.peel_refs() + && (cx.typeck_results.expr_ty(index_expr).peel_refs() == generic_ty.peel_refs() || matches!(generic_ty.peel_refs().kind(), ty::Param(_) | ty::Alias(_))) { true diff --git a/src/tools/clippy/clippy_lints/src/ineffective_open_options.rs b/src/tools/clippy/clippy_lints/src/ineffective_open_options.rs index bc57d9e85478a..c1a8b489e5016 100644 --- a/src/tools/clippy/clippy_lints/src/ineffective_open_options.rs +++ b/src/tools/clippy/clippy_lints/src/ineffective_open_options.rs @@ -48,7 +48,7 @@ impl<'tcx> LateLintPass<'tcx> for IneffectiveOpenOptions { && name.ident.name == sym::open && !expr.span.from_expansion() && cx - .typeck_results() + .typeck_results .expr_ty(recv) .peel_refs() .is_diag_item(cx, sym::FsOpenOptions) diff --git a/src/tools/clippy/clippy_lints/src/infinite_iter.rs b/src/tools/clippy/clippy_lints/src/infinite_iter.rs index 8b0a4b4d78d9a..58414cf4d1977 100644 --- a/src/tools/clippy/clippy_lints/src/infinite_iter.rs +++ b/src/tools/clippy/clippy_lints/src/infinite_iter.rs @@ -229,12 +229,12 @@ fn complete_infinite_iter(cx: &LateContext<'_>, expr: &Expr<'_>) -> Finiteness { let not_double_ended = cx .tcx .get_diagnostic_item(sym::DoubleEndedIterator) - .is_some_and(|id| !implements_trait(cx, cx.typeck_results().expr_ty(receiver), id, &[])); + .is_some_and(|id| !implements_trait(cx, cx.typeck_results.expr_ty(receiver), id, &[])); if not_double_ended { return is_infinite(cx, receiver); } } else if method.ident.name == sym::collect { - let ty = cx.typeck_results().expr_ty(expr); + let ty = cx.typeck_results.expr_ty(expr); if matches!( ty.opt_diag_name(cx), Some( diff --git a/src/tools/clippy/clippy_lints/src/iter_over_hash_type.rs b/src/tools/clippy/clippy_lints/src/iter_over_hash_type.rs index aec863af47717..325b17dacea5e 100644 --- a/src/tools/clippy/clippy_lints/src/iter_over_hash_type.rs +++ b/src/tools/clippy/clippy_lints/src/iter_over_hash_type.rs @@ -54,7 +54,7 @@ impl LateLintPass<'_> for IterOverHashType { if let Some(for_loop) = ForLoop::hir(expr) && !for_loop.body.span.from_expansion() - && let ty = cx.typeck_results().expr_ty(for_loop.arg).peel_refs() + && let ty = cx.typeck_results.expr_ty(for_loop.arg).peel_refs() && hash_iter_tys.into_iter().any(|sym| ty.is_diag_item(cx, sym)) { span_lint( diff --git a/src/tools/clippy/clippy_lints/src/large_futures.rs b/src/tools/clippy/clippy_lints/src/large_futures.rs index caa44d5ef1235..f38fb5c71cb86 100644 --- a/src/tools/clippy/clippy_lints/src/large_futures.rs +++ b/src/tools/clippy/clippy_lints/src/large_futures.rs @@ -61,7 +61,7 @@ impl<'tcx> LateLintPass<'tcx> for LargeFuture { && let ExprKind::Path(qpath) = func.kind && cx.tcx.qpath_is_lang_item(qpath, LangItem::IntoFutureIntoFuture) && !expr.span.from_expansion() - && let ty = cx.typeck_results().expr_ty(arg) + && let ty = cx.typeck_results.expr_ty(arg) && let Some(future_trait_def_id) = cx.tcx.lang_items().future_trait() && implements_trait(cx, ty, future_trait_def_id, &[]) && let Ok(layout) = cx diff --git a/src/tools/clippy/clippy_lints/src/large_stack_arrays.rs b/src/tools/clippy/clippy_lints/src/large_stack_arrays.rs index 9b0b65cd02c7f..e0e6c19393b04 100644 --- a/src/tools/clippy/clippy_lints/src/large_stack_arrays.rs +++ b/src/tools/clippy/clippy_lints/src/large_stack_arrays.rs @@ -80,7 +80,7 @@ impl<'tcx> LateLintPass<'tcx> for LargeStackArrays { if self.const_item_counter.0 == 0 && let ExprKind::Repeat(_, _) | ExprKind::Array(_) = expr.kind && !self.is_from_vec_macro(cx, expr.span) - && let ty::Array(element_type, cst) = cx.typeck_results().expr_ty(expr).kind() + && let ty::Array(element_type, cst) = cx.typeck_results.expr_ty(expr).kind() && let Some(element_count) = cst.try_to_target_usize(cx.tcx) && let Ok(element_size) = cx.layout_of(*element_type).map(|l| l.size.bytes()) && !cx.tcx.hir_parent_iter(expr.hir_id).any(|(_, node)| { diff --git a/src/tools/clippy/clippy_lints/src/len_zero.rs b/src/tools/clippy/clippy_lints/src/len_zero.rs index 53ee157dd6d70..ff65ce82503c1 100644 --- a/src/tools/clippy/clippy_lints/src/len_zero.rs +++ b/src/tools/clippy/clippy_lints/src/len_zero.rs @@ -355,5 +355,5 @@ fn has_is_empty(cx: &LateContext<'_>, expr: &Expr<'_>, msrv: Msrv) -> bool { } } - ty_has_is_empty(cx, cx.typeck_results().expr_ty(expr).peel_refs(), 0, msrv) + ty_has_is_empty(cx, cx.typeck_results.expr_ty(expr).peel_refs(), 0, msrv) } diff --git a/src/tools/clippy/clippy_lints/src/let_if_seq.rs b/src/tools/clippy/clippy_lints/src/let_if_seq.rs index dc7a916614be3..5961d7278f933 100644 --- a/src/tools/clippy/clippy_lints/src/let_if_seq.rs +++ b/src/tools/clippy/clippy_lints/src/let_if_seq.rs @@ -84,7 +84,7 @@ fn check_block_inner<'tcx>(cx: &LateContext<'tcx>, stmt: &'tcx hir::Stmt<'tcx>, let span = stmt.span.to(if_.span); let has_interior_mutability = !cx - .typeck_results() + .typeck_results .node_type(canonical_id) .is_freeze(cx.tcx, cx.typing_env()); if has_interior_mutability { diff --git a/src/tools/clippy/clippy_lints/src/let_underscore.rs b/src/tools/clippy/clippy_lints/src/let_underscore.rs index 984574c221fb6..70f165769ca4c 100644 --- a/src/tools/clippy/clippy_lints/src/let_underscore.rs +++ b/src/tools/clippy/clippy_lints/src/let_underscore.rs @@ -141,7 +141,7 @@ impl<'tcx> LateLintPass<'tcx> for LetUnderscore { && let Some(init) = local.init && !local.span.in_external_macro(cx.tcx.sess.source_map()) { - let init_ty = cx.typeck_results().expr_ty(init); + let init_ty = cx.typeck_results.expr_ty(init); let contains_sync_guard = init_ty.walk().any(|inner| match inner.kind() { GenericArgKind::Type(inner_ty) => inner_ty .ty_adt_def() @@ -163,7 +163,7 @@ impl<'tcx> LateLintPass<'tcx> for LetUnderscore { }, ); } else if let Some(future_trait_def_id) = cx.tcx.lang_items().future_trait() - && implements_trait(cx, cx.typeck_results().expr_ty(init), future_trait_def_id, &[]) + && implements_trait(cx, cx.typeck_results.expr_ty(init), future_trait_def_id, &[]) { #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")] span_lint_and_then( @@ -175,7 +175,7 @@ impl<'tcx> LateLintPass<'tcx> for LetUnderscore { diag.help("consider awaiting the future or dropping explicitly with `std::mem::drop`"); }, ); - } else if is_must_use_ty(cx, cx.typeck_results().expr_ty(init)) { + } else if is_must_use_ty(cx, cx.typeck_results.expr_ty(init)) { #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")] span_lint_and_then( cx, @@ -204,7 +204,7 @@ impl<'tcx> LateLintPass<'tcx> for LetUnderscore { // Ignore unnameable types if let Some(init) = local.init - && !cx.typeck_results().expr_ty(init).is_suggestable(cx.tcx, true) + && !cx.typeck_results.expr_ty(init).is_suggestable(cx.tcx, true) { return; } diff --git a/src/tools/clippy/clippy_lints/src/loops/char_indices_as_byte_indices.rs b/src/tools/clippy/clippy_lints/src/loops/char_indices_as_byte_indices.rs index 41022e6a5321b..f30056fd510c7 100644 --- a/src/tools/clippy/clippy_lints/src/loops/char_indices_as_byte_indices.rs +++ b/src/tools/clippy/clippy_lints/src/loops/char_indices_as_byte_indices.rs @@ -38,10 +38,10 @@ const CONTINUE: ControlFlow = ControlFlow::Continue(()); pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, pat: &Pat<'_>, iterable: &Expr<'_>, body: &'tcx Expr<'tcx>) { if let ExprKind::MethodCall(_, enumerate_recv, _, enumerate_span) = iterable.kind - && let Some(method_id) = cx.typeck_results().type_dependent_def_id(iterable.hir_id) + && let Some(method_id) = cx.typeck_results.type_dependent_def_id(iterable.hir_id) && cx.tcx.is_diagnostic_item(sym::enumerate_method, method_id) && let ExprKind::MethodCall(_, chars_recv, _, chars_span) = enumerate_recv.kind - && let Some(method_id) = cx.typeck_results().type_dependent_def_id(enumerate_recv.hir_id) + && let Some(method_id) = cx.typeck_results.type_dependent_def_id(enumerate_recv.hir_id) && cx.tcx.is_diagnostic_item(sym::str_chars, method_id) { if let PatKind::Tuple([pat, _], _) = pat.kind @@ -87,14 +87,14 @@ fn check_index_usage<'tcx>( // We currently only lint `str` methods (which `String` can deref to), so a `.is_str()` check is sufficient here // (contrary to the `ExprKind::Index` case which needs to handle both with `is_string_like` because `String` implements // `Index` directly and no deref to `str` would happen in that case). - if cx.typeck_results().expr_ty_adjusted(recv).peel_refs().is_str() + if cx.typeck_results.expr_ty_adjusted(recv).peel_refs().is_str() && BYTE_INDEX_METHODS.contains(&segment.ident.name) && eq_expr_value(cx, expr.span.ctxt(), chars_recv, recv) => { "passing a character position to a method that expects a byte index" }, ExprKind::Index(target, ..) - if is_string_like(cx.typeck_results().expr_ty_adjusted(target).peel_refs()) + if is_string_like(cx.typeck_results.expr_ty_adjusted(target).peel_refs()) && eq_expr_value(cx, expr.span.ctxt(), chars_recv, target) => { "indexing into a string with a character position where a byte index is expected" diff --git a/src/tools/clippy/clippy_lints/src/loops/explicit_counter_loop.rs b/src/tools/clippy/clippy_lints/src/loops/explicit_counter_loop.rs index b10584fb9bd7c..319cea694f7b2 100644 --- a/src/tools/clippy/clippy_lints/src/loops/explicit_counter_loop.rs +++ b/src/tools/clippy/clippy_lints/src/loops/explicit_counter_loop.rs @@ -40,7 +40,7 @@ pub(super) fn check<'tcx>( let Some((name, ty, initializer)) = initialize_visitor.get_result() else { continue; }; - if !cx.typeck_results().expr_ty(initializer).is_integral() { + if !cx.typeck_results.expr_ty(initializer).is_integral() { continue; } diff --git a/src/tools/clippy/clippy_lints/src/loops/explicit_into_iter_loop.rs b/src/tools/clippy/clippy_lints/src/loops/explicit_into_iter_loop.rs index daca78e344748..761e4c1c50ca7 100644 --- a/src/tools/clippy/clippy_lints/src/loops/explicit_into_iter_loop.rs +++ b/src/tools/clippy/clippy_lints/src/loops/explicit_into_iter_loop.rs @@ -51,7 +51,7 @@ pub(super) fn check(cx: &LateContext<'_>, self_arg: &Expr<'_>, call_expr: &Expr< return; } - let typeck = cx.typeck_results(); + let typeck = cx.typeck_results; let self_ty = typeck.expr_ty(self_arg); let adjust = match typeck.expr_adjustments(self_arg) { [] => AdjustKind::None, diff --git a/src/tools/clippy/clippy_lints/src/loops/explicit_iter_loop.rs b/src/tools/clippy/clippy_lints/src/loops/explicit_iter_loop.rs index 2cb98fdfe4484..0b77e8a90bdd7 100644 --- a/src/tools/clippy/clippy_lints/src/loops/explicit_iter_loop.rs +++ b/src/tools/clippy/clippy_lints/src/loops/explicit_iter_loop.rs @@ -110,7 +110,7 @@ fn is_ref_iterable<'tcx>( enforce_iter_loop_reborrow: bool, msrv: Msrv, ) -> Option<(AdjustKind, Ty<'tcx>)> { - let typeck = cx.typeck_results(); + let typeck = cx.typeck_results; if let Some(trait_id) = cx.tcx.get_diagnostic_item(sym::IntoIterator) && let Some(fn_id) = typeck.type_dependent_def_id(call_expr.hir_id) && let sig = cx diff --git a/src/tools/clippy/clippy_lints/src/loops/for_kv_map.rs b/src/tools/clippy/clippy_lints/src/loops/for_kv_map.rs index d28029790732b..42cc8808cef27 100644 --- a/src/tools/clippy/clippy_lints/src/loops/for_kv_map.rs +++ b/src/tools/clippy/clippy_lints/src/loops/for_kv_map.rs @@ -25,15 +25,15 @@ pub(super) fn check<'tcx>( let arg_span = arg.span; let (arg, arg_ty) = match arg.kind { // `for x in &expr` or `for x in &mut expr` - ExprKind::AddrOf(BorrowKind::Ref, _, expr) => (expr, cx.typeck_results().expr_ty(arg)), + ExprKind::AddrOf(BorrowKind::Ref, _, expr) => (expr, cx.typeck_results.expr_ty(arg)), // `for x in receiver.iter()` or `for x in receiver.iter_mut()` ExprKind::MethodCall(path, receiver, [], ..) if path.ident.name == sym::iter || path.ident.name == sym::iter_mut => { // Use `expr_ty_adjusted` because `.iter()` / `.iter_mut()` may introduce auto deferences - (receiver, cx.typeck_results().expr_ty_adjusted(receiver)) + (receiver, cx.typeck_results.expr_ty_adjusted(receiver)) }, - _ => (arg, cx.typeck_results().expr_ty(arg)), + _ => (arg, cx.typeck_results.expr_ty(arg)), }; let (new_pat_span, kind, ty, mutbl) = match *arg_ty.kind() { diff --git a/src/tools/clippy/clippy_lints/src/loops/for_unbounded_range.rs b/src/tools/clippy/clippy_lints/src/loops/for_unbounded_range.rs index 4691ee02d9539..8ef305b64da83 100644 --- a/src/tools/clippy/clippy_lints/src/loops/for_unbounded_range.rs +++ b/src/tools/clippy/clippy_lints/src/loops/for_unbounded_range.rs @@ -18,7 +18,7 @@ pub fn check<'tcx>( if let Some(range) = higher::Range::hir(cx, arg) && let Some(range_start) = range.start && let None = range.end - && let ty = cx.typeck_results().expr_ty_adjusted(range_start) + && let ty = cx.typeck_results.expr_ty_adjusted(range_start) && (ty.is_integral() || ty.is_char()) { let mut loop_visitor = LoopVisitor::new(cx, label); diff --git a/src/tools/clippy/clippy_lints/src/loops/manual_find.rs b/src/tools/clippy/clippy_lints/src/loops/manual_find.rs index d94dcfab23c73..18d1bfd559e61 100644 --- a/src/tools/clippy/clippy_lints/src/loops/manual_find.rs +++ b/src/tools/clippy/clippy_lints/src/loops/manual_find.rs @@ -54,7 +54,7 @@ pub(super) fn check<'tcx>( )[..], ); } - let ty = cx.typeck_results().expr_ty(inner_ret); + let ty = cx.typeck_results.expr_ty(inner_ret); if cx .tcx .lang_items() @@ -84,7 +84,7 @@ pub(super) fn check<'tcx>( } // If the return type requires adjustments, we need to add a `.map` after the iterator - let inner_ret_adjust = cx.typeck_results().expr_adjustments(inner_ret); + let inner_ret_adjust = cx.typeck_results.expr_adjustments(inner_ret); if !inner_ret_adjust.is_empty() { snippet.push_str(".map(|v| v as _)"); } diff --git a/src/tools/clippy/clippy_lints/src/loops/manual_flatten.rs b/src/tools/clippy/clippy_lints/src/loops/manual_flatten.rs index 2c89afc739745..5cc0b34d15357 100644 --- a/src/tools/clippy/clippy_lints/src/loops/manual_flatten.rs +++ b/src/tools/clippy/clippy_lints/src/loops/manual_flatten.rs @@ -56,7 +56,7 @@ pub(super) fn check<'tcx>( Applicability::MachineApplicable }; let arg_snippet = make_iterator_snippet(cx, arg, &mut applicability); - let copied = match cx.typeck_results().expr_ty(let_expr).kind() { + let copied = match cx.typeck_results.expr_ty(let_expr).kind() { ty::Ref(_, inner, _) => match inner.kind() { ty::Ref(..) => ".copied()", _ => "", diff --git a/src/tools/clippy/clippy_lints/src/loops/manual_memcpy.rs b/src/tools/clippy/clippy_lints/src/loops/manual_memcpy.rs index d8c55974fa926..69581a4e85f52 100644 --- a/src/tools/clippy/clippy_lints/src/loops/manual_memcpy.rs +++ b/src/tools/clippy/clippy_lints/src/loops/manual_memcpy.rs @@ -62,8 +62,8 @@ pub(super) fn check<'tcx>( let rhs = fetch_cloned_expr(rhs); if let ExprKind::Index(base_left, idx_left, _) = lhs.kind && let ExprKind::Index(base_right, idx_right, _) = rhs.kind - && let Some(ty) = get_slice_like_element_ty(cx, cx.typeck_results().expr_ty(base_left)) - && get_slice_like_element_ty(cx, cx.typeck_results().expr_ty(base_right)).is_some() + && let Some(ty) = get_slice_like_element_ty(cx, cx.typeck_results.expr_ty(base_left)) + && get_slice_like_element_ty(cx, cx.typeck_results.expr_ty(base_right)).is_some() && let Some((start_left, offset_left)) = get_details_from_idx(cx, idx_left, &starts) && let Some((start_right, offset_right)) = get_details_from_idx(cx, idx_right, &starts) && !local_used_in(cx, canonical_id, base_left) @@ -490,7 +490,7 @@ fn is_array_length_equal_to_range(cx: &LateContext<'_>, start: &Expr<'_>, end: & } } - let arr_ty = cx.typeck_results().expr_ty(arr).peel_refs(); + let arr_ty = cx.typeck_results.expr_ty(arr).peel_refs(); if let ty::Array(_, s) = arr_ty.kind() { let size: u128 = if let Some(size) = s.try_to_target_usize(cx.tcx) { diff --git a/src/tools/clippy/clippy_lints/src/loops/manual_slice_fill.rs b/src/tools/clippy/clippy_lints/src/loops/manual_slice_fill.rs index ffc6f7186922a..0693730ce9cec 100644 --- a/src/tools/clippy/clippy_lints/src/loops/manual_slice_fill.rs +++ b/src/tools/clippy/clippy_lints/src/loops/manual_slice_fill.rs @@ -52,13 +52,13 @@ pub(super) fn check<'tcx>( && switch_to_eager_eval(cx, assignval) // The `fill` method requires that the slice's element type implements the `Clone` trait. && let Some(clone_trait) = cx.tcx.lang_items().clone_trait() - && implements_trait(cx, cx.typeck_results().expr_ty(slice), clone_trait, &[]) + && implements_trait(cx, cx.typeck_results.expr_ty(slice), clone_trait, &[]) // https://github.com/rust-lang/rust-clippy/issues/14192 && let ExprKind::Path(Resolved(_, idx_path)) = idx.kind && let Res::Local(idx_hir) = idx_path.res && !is_local_used(cx, assignval, idx_hir) && msrv.meets(cx, msrvs::SLICE_FILL) - && let slice_ty = cx.typeck_results().expr_ty(slice).peel_refs() + && let slice_ty = cx.typeck_results.expr_ty(slice).peel_refs() && is_slice_like(cx, slice_ty) { sugg(cx, body, expr, slice.span, assignval.span); @@ -79,7 +79,7 @@ pub(super) fn check<'tcx>( && !is_local_used(cx, assignval, local) // The `fill` method cannot be used if the slice's element type does not implement the `Clone` trait. && let Some(clone_trait) = cx.tcx.lang_items().clone_trait() - && implements_trait(cx, cx.typeck_results().expr_ty(recv), clone_trait, &[]) + && implements_trait(cx, cx.typeck_results.expr_ty(recv), clone_trait, &[]) && msrv.meets(cx, msrvs::SLICE_FILL) { sugg(cx, body, expr, recv_path.span, assignval.span); diff --git a/src/tools/clippy/clippy_lints/src/loops/manual_while_let_some.rs b/src/tools/clippy/clippy_lints/src/loops/manual_while_let_some.rs index 22c97bcdbd97b..265aa4eae044b 100644 --- a/src/tools/clippy/clippy_lints/src/loops/manual_while_let_some.rs +++ b/src/tools/clippy/clippy_lints/src/loops/manual_while_let_some.rs @@ -50,7 +50,7 @@ fn report_lint(cx: &LateContext<'_>, pop_span: Span, pop_stmt_kind: PopStmt<'_>, fn match_method_call(cx: &LateContext<'_>, expr: &Expr<'_>, method: Symbol) -> bool { if let ExprKind::MethodCall(_, _, args, _) = expr.kind && args.len() == ARGS_COUNT - && let Some(id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) + && let Some(id) = cx.typeck_results.type_dependent_def_id(expr.hir_id) { cx.tcx.is_diagnostic_item(method, id) } else { diff --git a/src/tools/clippy/clippy_lints/src/loops/missing_spin_loop.rs b/src/tools/clippy/clippy_lints/src/loops/missing_spin_loop.rs index ca8383070d70f..0890cfc696000 100644 --- a/src/tools/clippy/clippy_lints/src/loops/missing_spin_loop.rs +++ b/src/tools/clippy/clippy_lints/src/loops/missing_spin_loop.rs @@ -39,7 +39,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, cond: &'tcx Expr<'_>, body: &' ) = body.kind && let ExprKind::MethodCall(method, callee, ..) = unpack_cond(cond).kind && [sym::load, sym::compare_exchange, sym::compare_exchange_weak].contains(&method.ident.name) - && let callee_ty = cx.typeck_results().expr_ty(callee) + && let callee_ty = cx.typeck_results.expr_ty(callee) && callee_ty.is_diag_item(cx, sym::Atomic) && let Some(std_or_core) = std_or_core(cx) { diff --git a/src/tools/clippy/clippy_lints/src/loops/needless_range_loop.rs b/src/tools/clippy/clippy_lints/src/loops/needless_range_loop.rs index 71280e4b03f8f..20ed63c1222ed 100644 --- a/src/tools/clippy/clippy_lints/src/loops/needless_range_loop.rs +++ b/src/tools/clippy/clippy_lints/src/loops/needless_range_loop.rs @@ -301,7 +301,7 @@ impl<'tcx> VarVisitor<'_, 'tcx> { if index_used_directly { self.indexed_directly.insert( seqvar.segments[0].ident.name, - (Some(extent), self.cx.typeck_results().node_type(seqexpr.hir_id)), + (Some(extent), self.cx.typeck_results.node_type(seqexpr.hir_id)), ); } else { self.indexed_indirectly @@ -313,7 +313,7 @@ impl<'tcx> VarVisitor<'_, 'tcx> { if index_used_directly { self.indexed_directly.insert( seqvar.segments[0].ident.name, - (None, self.cx.typeck_results().node_type(seqexpr.hir_id)), + (None, self.cx.typeck_results.node_type(seqexpr.hir_id)), ); } else { self.indexed_indirectly.insert(seqvar.segments[0].ident.name, None); @@ -339,7 +339,7 @@ impl<'tcx> Visitor<'tcx> for VarVisitor<'_, 'tcx> { if let ExprKind::MethodCall(meth, args_0, [args_1, ..], _) = &expr.kind && let Some(trait_id) = self .cx - .typeck_results() + .typeck_results .type_dependent_def_id(expr.hir_id) .and_then(|def_id| self.cx.tcx.trait_of_assoc(def_id)) && ((meth.ident.name == sym::index && self.cx.tcx.lang_items().index_trait() == Some(trait_id)) @@ -385,7 +385,7 @@ impl<'tcx> Visitor<'tcx> for VarVisitor<'_, 'tcx> { ExprKind::Call(f, args) => { self.visit_expr(f); for expr in args { - let ty = self.cx.typeck_results().expr_ty_adjusted(expr); + let ty = self.cx.typeck_results.expr_ty_adjusted(expr); self.prefer_mutable = false; if let ty::Ref(_, _, mutbl) = *ty.kind() && mutbl == Mutability::Mut @@ -396,7 +396,7 @@ impl<'tcx> Visitor<'tcx> for VarVisitor<'_, 'tcx> { } }, ExprKind::MethodCall(_, receiver, args, _) => { - let def_id = self.cx.typeck_results().type_dependent_def_id(expr.hir_id).unwrap(); + let def_id = self.cx.typeck_results.type_dependent_def_id(expr.hir_id).unwrap(); for (ty, expr) in iter::zip( self.cx .tcx diff --git a/src/tools/clippy/clippy_lints/src/loops/never_loop.rs b/src/tools/clippy/clippy_lints/src/loops/never_loop.rs index 9fac774e7690c..0eebfef071a3f 100644 --- a/src/tools/clippy/clippy_lints/src/loops/never_loop.rs +++ b/src/tools/clippy/clippy_lints/src/loops/never_loop.rs @@ -92,7 +92,7 @@ pub(super) fn check_iterator_reduction<'tcx>( closure: &'tcx Closure<'tcx>, ) { let closure_body = cx.tcx.hir_body(closure.body).value; - let body_ty = cx.typeck_results().expr_ty(closure_body); + let body_ty = cx.typeck_results.expr_ty(closure_body); if body_ty.is_never() && !contains_return(closure_body) { span_lint_and_then( cx, @@ -456,7 +456,7 @@ fn never_loop_expr<'tcx>( }; let result = combine_seq(result, || { - if cx.typeck_results().expr_ty(expr).is_never() { + if cx.typeck_results.expr_ty(expr).is_never() { NeverLoopResult::Diverging { break_spans: vec![], never_spans: all_spans_after_expr(cx, expr), @@ -507,7 +507,7 @@ fn find_non_obvious_spans<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'tcx>) -> let mut spans = vec![]; for_each_expr_without_closures(e, |expr: &'tcx Expr<'tcx>| -> ControlFlow<(), Descend> { - if cx.typeck_results().expr_ty(expr).is_never() && !expr.span.from_expansion() { + if cx.typeck_results.expr_ty(expr).is_never() && !expr.span.from_expansion() { match expr.kind { // The first arm handles both directly divergent expressions and expressions // that contain divergence indirectly. The latter are inspected to identify diff --git a/src/tools/clippy/clippy_lints/src/loops/same_item_push.rs b/src/tools/clippy/clippy_lints/src/loops/same_item_push.rs index ba309d94608c4..7ff749d753985 100644 --- a/src/tools/clippy/clippy_lints/src/loops/same_item_push.rs +++ b/src/tools/clippy/clippy_lints/src/loops/same_item_push.rs @@ -56,7 +56,7 @@ pub(super) fn check<'tcx>( walk_expr(&mut same_item_push_visitor, body); if same_item_push_visitor.should_lint() && let Some((vec, pushed_item, ctxt)) = same_item_push_visitor.vec_push - && let vec_ty = cx.typeck_results().expr_ty(vec) + && let vec_ty = cx.typeck_results.expr_ty(vec) && let ty = vec_ty.walk().nth(1).unwrap().expect_ty() && cx .tcx @@ -187,7 +187,7 @@ fn get_vec_push<'tcx>( && let ExprKind::MethodCall(path, self_expr, [pushed_item], _) = &semi_stmt.kind // Check that the method being called is push() on a Vec && path.ident.name == sym::push - && cx.typeck_results().expr_ty(self_expr).is_diag_item(cx, sym::Vec) + && cx.typeck_results.expr_ty(self_expr).is_diag_item(cx, sym::Vec) { return Some((self_expr, pushed_item, semi_stmt.span.ctxt())); } diff --git a/src/tools/clippy/clippy_lints/src/loops/unused_enumerate_index.rs b/src/tools/clippy/clippy_lints/src/loops/unused_enumerate_index.rs index 4ecfadbf9d494..406074d74185c 100644 --- a/src/tools/clippy/clippy_lints/src/loops/unused_enumerate_index.rs +++ b/src/tools/clippy/clippy_lints/src/loops/unused_enumerate_index.rs @@ -16,11 +16,11 @@ pub(super) fn check<'tcx>( body: &'tcx Expr<'tcx>, ) { if let PatKind::Tuple([idx_pat, inner_pat], _) = pat.kind - && cx.typeck_results().expr_ty(iter_expr).is_diag_item(cx, sym::Enumerate) + && cx.typeck_results.expr_ty(iter_expr).is_diag_item(cx, sym::Enumerate) && pat_is_wild(cx, &idx_pat.kind, body) && let enumerate_call = expr_or_init(cx, iter_expr) && let ExprKind::MethodCall(_, _, [], enumerate_span) = enumerate_call.kind - && let Some(enumerate_id) = cx.typeck_results().type_dependent_def_id(enumerate_call.hir_id) + && let Some(enumerate_id) = cx.typeck_results.type_dependent_def_id(enumerate_call.hir_id) && cx.tcx.is_diagnostic_item(sym::enumerate_method, enumerate_id) && !enumerate_call.span.from_expansion() && !pat.span.from_expansion() diff --git a/src/tools/clippy/clippy_lints/src/loops/utils.rs b/src/tools/clippy/clippy_lints/src/loops/utils.rs index 81e868b3b7ba7..cd4e145b3d3bc 100644 --- a/src/tools/clippy/clippy_lints/src/loops/utils.rs +++ b/src/tools/clippy/clippy_lints/src/loops/utils.rs @@ -156,7 +156,7 @@ impl<'tcx> Visitor<'tcx> for InitializeVisitor<'_, 'tcx> { if l.pat.hir_id == self.var_id && let PatKind::Binding(.., ident, _) = l.pat.kind { - let ty = l.ty.map(|_| self.cx.typeck_results().pat_ty(l.pat)); + let ty = l.ty.map(|_| self.cx.typeck_results.pat_ty(l.pat)); self.state = l.init.map_or(InitializeVisitorState::Declared(ident.name, ty), |init| { InitializeVisitorState::Initialized { @@ -208,7 +208,7 @@ impl<'tcx> Visitor<'tcx> for InitializeVisitor<'_, 'tcx> { { ty = None; } else { - ty = self.cx.typeck_results().expr_ty_opt(rhs); + ty = self.cx.typeck_results.expr_ty_opt(rhs); } } @@ -269,7 +269,7 @@ pub(super) fn make_iterator_snippet(cx: &LateContext<'_>, arg: &Expr<'_>, applic let impls_iterator = cx .tcx .get_diagnostic_item(sym::Iterator) - .is_some_and(|id| implements_trait(cx, cx.typeck_results().expr_ty(arg), id, &[])); + .is_some_and(|id| implements_trait(cx, cx.typeck_results.expr_ty(arg), id, &[])); if impls_iterator { format!( "{}", @@ -278,7 +278,7 @@ pub(super) fn make_iterator_snippet(cx: &LateContext<'_>, arg: &Expr<'_>, applic } else { // (&x).into_iter() ==> x.iter() // (&mut x).into_iter() ==> x.iter_mut() - let arg_ty = cx.typeck_results().expr_ty_adjusted(arg); + let arg_ty = cx.typeck_results.expr_ty_adjusted(arg); match &arg_ty.kind() { ty::Ref(_, inner_ty, mutbl) if has_iter_method(cx, *inner_ty).is_some() => { let method_name = match mutbl { diff --git a/src/tools/clippy/clippy_lints/src/loops/while_float.rs b/src/tools/clippy/clippy_lints/src/loops/while_float.rs index cf62ce29f0c7a..b6277a76ddb0f 100644 --- a/src/tools/clippy/clippy_lints/src/loops/while_float.rs +++ b/src/tools/clippy/clippy_lints/src/loops/while_float.rs @@ -16,5 +16,5 @@ pub(super) fn check(cx: &rustc_lint::LateContext<'_>, condition: &rustc_hir::Exp } fn is_float_type(cx: &rustc_lint::LateContext<'_>, expr: &rustc_hir::Expr<'_>) -> bool { - cx.typeck_results().expr_ty(expr).is_floating_point() + cx.typeck_results.expr_ty(expr).is_floating_point() } diff --git a/src/tools/clippy/clippy_lints/src/loops/while_let_loop.rs b/src/tools/clippy/clippy_lints/src/loops/while_let_loop.rs index e2ea24c399807..21098a2e054eb 100644 --- a/src/tools/clippy/clippy_lints/src/loops/while_let_loop.rs +++ b/src/tools/clippy/clippy_lints/src/loops/while_let_loop.rs @@ -91,7 +91,7 @@ fn could_be_while_let<'tcx>( inner_expr: Option<&Expr<'_>>, ) { if has_trailing_exprs - && (needs_ordered_drop(cx, cx.typeck_results().expr_ty(let_expr)) + && (needs_ordered_drop(cx, cx.typeck_results.expr_ty(let_expr)) || any_temporaries_need_ordered_drop(cx, let_expr)) { // Switching to a `while let` loop will extend the lifetime of some values. diff --git a/src/tools/clippy/clippy_lints/src/loops/while_let_on_iterator.rs b/src/tools/clippy/clippy_lints/src/loops/while_let_on_iterator.rs index fc0789894cc2c..f9fd1bd39d309 100644 --- a/src/tools/clippy/clippy_lints/src/loops/while_let_on_iterator.rs +++ b/src/tools/clippy/clippy_lints/src/loops/while_let_on_iterator.rs @@ -46,7 +46,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) { // passed by reference. TODO: If the struct can be partially moved from and the struct isn't used // afterwards a mutable borrow of a field isn't necessary. let iterator = snippet_with_applicability(cx, iter_expr.span, "_", &mut applicability); - let iterator_by_ref = if cx.typeck_results().expr_ty(iter_expr).ref_mutability() == Some(Mutability::Mut) + let iterator_by_ref = if cx.typeck_results.expr_ty(iter_expr).ref_mutability() == Some(Mutability::Mut) || !iter_expr_struct.can_move || !iter_expr_struct.fields.is_empty() || needs_mutable_borrow(cx, &iter_expr_struct, expr) @@ -85,7 +85,7 @@ fn try_parse_iter_expr(cx: &LateContext<'_>, mut e: &Expr<'_>) -> Option, mut e: &Expr<'_>) -> Option e = base, + ExprKind::Unary(UnOp::Deref, base) if cx.typeck_results.expr_ty(base).is_ref() => e = base, // Shouldn't have side effects, but there's no way to trace which field is used. So forget which fields have // already been seen. @@ -361,7 +361,7 @@ fn needs_mutable_borrow(cx: &LateContext<'_>, iter_expr: &IterExpr, loop_expr: & /// in which case it applies all derefs (e.g., `&mut **iterator` or `&mut ***iterator`). fn make_iterator_snippet<'tcx>(cx: &LateContext<'tcx>, iter_expr: &Expr<'tcx>, iterator: &str) -> String { if let Some((n, adjust)) = cx - .typeck_results() + .typeck_results .expr_adjustments(iter_expr) .iter() .take_while(|x| matches!(x.kind, Adjust::Deref(_))) diff --git a/src/tools/clippy/clippy_lints/src/manual_abs_diff.rs b/src/tools/clippy/clippy_lints/src/manual_abs_diff.rs index b3c2e93a077fc..e375634047c5d 100644 --- a/src/tools/clippy/clippy_lints/src/manual_abs_diff.rs +++ b/src/tools/clippy/clippy_lints/src/manual_abs_diff.rs @@ -102,8 +102,8 @@ impl ManualAbsDiff { let is_duration = |ty: Ty<'_>| ty.is_diag_item(cx, sym::Duration) && self.msrv.meets(cx, msrvs::DURATION_ABS_DIFF); - let a_ty = cx.typeck_results().expr_ty(a).peel_refs(); - let (b_ty, b_n_refs, _) = peel_and_count_ty_refs(cx.typeck_results().expr_ty(b)); + let a_ty = cx.typeck_results.expr_ty(a).peel_refs(); + let (b_ty, b_n_refs, _) = peel_and_count_ty_refs(cx.typeck_results.expr_ty(b)); (a_ty == b_ty && (is_int(a_ty) || is_duration(a_ty))).then_some((a_ty, b_n_refs)) } @@ -127,7 +127,7 @@ fn is_sub_expr( let unsigned = Ty::new_uint(cx.tcx, ty.to_unsigned()); return if let ExprKind::Cast(expr, cast_ty) = expr.kind - && cx.typeck_results().node_type(cast_ty.hir_id) == unsigned + && cx.typeck_results.node_type(cast_ty.hir_id) == unsigned { is_sub_expr(cx, expr, expected_a, expected_b, unsigned) } else { diff --git a/src/tools/clippy/clippy_lints/src/manual_assert_eq.rs b/src/tools/clippy/clippy_lints/src/manual_assert_eq.rs index d1770d2e95a66..a11b9d9d6e4b6 100644 --- a/src/tools/clippy/clippy_lints/src/manual_assert_eq.rs +++ b/src/tools/clippy/clippy_lints/src/manual_assert_eq.rs @@ -74,8 +74,8 @@ impl LateLintPass<'_> for ManualAssertEq { } && !cond.span.from_expansion() && let Some(debug_trait) = cx.tcx.get_diagnostic_item(sym::Debug) - && let lhs_ty = cx.typeck_results().expr_ty(lhs) - && let rhs_ty = cx.typeck_results().expr_ty(rhs) + && let lhs_ty = cx.typeck_results.expr_ty(lhs) + && let rhs_ty = cx.typeck_results.expr_ty(rhs) // Can't print the values unless the types implement `Debug` && implements_trait(cx, lhs_ty, debug_trait, &[]) && implements_trait(cx, rhs_ty, debug_trait, &[]) diff --git a/src/tools/clippy/clippy_lints/src/manual_bits.rs b/src/tools/clippy/clippy_lints/src/manual_bits.rs index dd64381033d41..7a6d50d11466c 100644 --- a/src/tools/clippy/clippy_lints/src/manual_bits.rs +++ b/src/tools/clippy/clippy_lints/src/manual_bits.rs @@ -99,7 +99,7 @@ fn get_size_of_ty<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option< && let Some(def_id) = cx.qpath_res(count_func_qpath, count_func.hir_id).opt_def_id() && cx.tcx.is_diagnostic_item(sym::mem_size_of, def_id) { - cx.typeck_results() + cx.typeck_results .node_args(count_func.hir_id) .types() .next() diff --git a/src/tools/clippy/clippy_lints/src/manual_checked_ops.rs b/src/tools/clippy/clippy_lints/src/manual_checked_ops.rs index 0bc1c192b5716..20de398760ff9 100644 --- a/src/tools/clippy/clippy_lints/src/manual_checked_ops.rs +++ b/src/tools/clippy/clippy_lints/src/manual_checked_ops.rs @@ -168,5 +168,5 @@ fn is_zero(expr: &Expr<'_>) -> bool { } fn is_unsigned_integer(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool { - matches!(cx.typeck_results().expr_ty(expr).peel_refs().kind(), ty::Uint(_)) + matches!(cx.typeck_results.expr_ty(expr).peel_refs().kind(), ty::Uint(_)) } diff --git a/src/tools/clippy/clippy_lints/src/manual_clamp.rs b/src/tools/clippy/clippy_lints/src/manual_clamp.rs index 6848af7748f3f..a7afa83263b69 100644 --- a/src/tools/clippy/clippy_lints/src/manual_clamp.rs +++ b/src/tools/clippy/clippy_lints/src/manual_clamp.rs @@ -113,8 +113,8 @@ impl<'tcx> ClampSuggestion<'tcx> { /// This function will return true if and only if you can demonstrate at compile time that min /// is less than max. fn min_less_than_max(&self, cx: &LateContext<'tcx>) -> bool { - let max_type = cx.typeck_results().expr_ty(self.params.max); - let min_type = cx.typeck_results().expr_ty(self.params.min); + let max_type = cx.typeck_results.expr_ty(self.params.max); + let min_type = cx.typeck_results.expr_ty(self.params.min); if max_type != min_type { return false; } @@ -293,13 +293,13 @@ fn is_if_elseif_else_pattern<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx /// ``` fn is_max_min_pattern<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Option> { if let ExprKind::MethodCall(seg_second, receiver, [arg_second], _) = expr.kind - && (cx.typeck_results().expr_ty_adjusted(receiver).is_floating_point() + && (cx.typeck_results.expr_ty_adjusted(receiver).is_floating_point() || cx.ty_based_def(expr).assoc_fn_parent(cx).is_diag_item(cx, sym::Ord)) && let ExprKind::MethodCall(seg_first, input, [arg_first], _) = &receiver.kind - && (cx.typeck_results().expr_ty_adjusted(input).is_floating_point() + && (cx.typeck_results.expr_ty_adjusted(input).is_floating_point() || cx.ty_based_def(receiver).assoc_fn_parent(cx).is_diag_item(cx, sym::Ord)) { - let is_float = cx.typeck_results().expr_ty_adjusted(input).is_floating_point(); + let is_float = cx.typeck_results.expr_ty_adjusted(input).is_floating_point(); let (min, max) = match (seg_first.ident.name, seg_second.ident.name) { (sym::min, sym::max) => (arg_second, arg_first), (sym::max, sym::min) => (arg_first, arg_second), @@ -372,7 +372,7 @@ fn is_call_max_min_pattern<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) (false, true) => (first, second), _ => return None, }; - let is_float = cx.typeck_results().expr_ty_adjusted(input).is_floating_point(); + let is_float = cx.typeck_results.expr_ty_adjusted(input).is_floating_point(); let (min, max) = match (inner_seg, outer_seg) { (FunctionType::CmpMin, FunctionType::CmpMax) => (outer_arg, inner_arg), (FunctionType::CmpMax, FunctionType::CmpMin) => (inner_arg, outer_arg), @@ -693,7 +693,7 @@ fn is_clamp_meta_pattern<'tcx>( first_expr, second_expr, ]; - let clampability = TypeClampability::is_clampable(cx, cx.typeck_results().expr_ty(first_expr))?; + let clampability = TypeClampability::is_clampable(cx, cx.typeck_results.expr_ty(first_expr))?; let is_float = clampability.is_float(); if exprs.iter().any(|e| peel_blocks(e).can_have_side_effects()) { return None; diff --git a/src/tools/clippy/clippy_lints/src/manual_ignore_case_cmp.rs b/src/tools/clippy/clippy_lints/src/manual_ignore_case_cmp.rs index 1c20a8f81efbd..68ce5a653fcff 100644 --- a/src/tools/clippy/clippy_lints/src/manual_ignore_case_cmp.rs +++ b/src/tools/clippy/clippy_lints/src/manual_ignore_case_cmp.rs @@ -53,7 +53,7 @@ fn get_ascii_type<'a>(cx: &LateContext<'a>, kind: rustc_hir::ExprKind<'_>) -> Op sym::to_ascii_uppercase => false, _ => return None, }; - let ty_raw = cx.typeck_results().expr_ty(expr); + let ty_raw = cx.typeck_results.expr_ty(expr); let ty = ty_raw.peel_refs(); if needs_ref_to_cmp(cx, ty) || ty.is_str() diff --git a/src/tools/clippy/clippy_lints/src/manual_ilog2.rs b/src/tools/clippy/clippy_lints/src/manual_ilog2.rs index 2c368f15d6705..15eff970ae8b2 100644 --- a/src/tools/clippy/clippy_lints/src/manual_ilog2.rs +++ b/src/tools/clippy/clippy_lints/src/manual_ilog2.rs @@ -64,7 +64,7 @@ impl LateLintPass<'_> for ManualIlog2 { && let LitKind::Int(Pu128(val), _) = lit.node && let ExprKind::MethodCall(leading_zeros, recv, [], _) = right.kind && leading_zeros.ident.name == sym::leading_zeros - && let ty = cx.typeck_results().expr_ty(recv) + && let ty = cx.typeck_results.expr_ty(recv) && let Some(bit_width) = match ty.kind() { ty::Uint(uint_ty) => uint_ty.bit_width(), ty::Int(_) => { @@ -88,7 +88,7 @@ impl LateLintPass<'_> for ManualIlog2 { && ilog.ident.name == sym::ilog && let ExprKind::Lit(lit) = two.kind && let LitKind::Int(Pu128(2), _) = lit.node - && cx.typeck_results().expr_ty_adjusted(recv).is_integral() + && cx.typeck_results.expr_ty_adjusted(recv).is_integral() /* no need to check MSRV here, as `ilog` and `ilog2` were introduced simultaneously */ && !is_from_proc_macro(cx, expr) => { diff --git a/src/tools/clippy/clippy_lints/src/manual_is_ascii_check.rs b/src/tools/clippy/clippy_lints/src/manual_is_ascii_check.rs index dd1385e48e977..da31d87b1799b 100644 --- a/src/tools/clippy/clippy_lints/src/manual_is_ascii_check.rs +++ b/src/tools/clippy/clippy_lints/src/manual_is_ascii_check.rs @@ -120,7 +120,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualIsAsciiCheck { limits: RangeLimits::Closed, span: _, }) = higher::Range::hir(cx, receiver) - && !matches!(cx.typeck_results().expr_ty(arg).peel_refs().kind(), ty::Param(_)) + && !matches!(cx.typeck_results.expr_ty(arg).peel_refs().kind(), ty::Param(_)) { let arg = peel_ref_operators(cx, arg); let range = check_expr_range(start, end); @@ -140,7 +140,7 @@ fn get_ty_sugg<'tcx>(cx: &LateContext<'tcx>, arg: &Expr<'_>) -> Option<(Span, Ty // `ty_span` and `span` are the same for inferred type, thus a type suggestion must be given && ty_span == span { - let arg_type = cx.typeck_results().expr_ty(arg); + let arg_type = cx.typeck_results.expr_ty(arg); return Some((*ty_span, arg_type)); } None diff --git a/src/tools/clippy/clippy_lints/src/manual_is_power_of_two.rs b/src/tools/clippy/clippy_lints/src/manual_is_power_of_two.rs index 26e0a6e2a51f8..770fded2e6cd4 100644 --- a/src/tools/clippy/clippy_lints/src/manual_is_power_of_two.rs +++ b/src/tools/clippy/clippy_lints/src/manual_is_power_of_two.rs @@ -96,7 +96,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualIsPowerOfTwo { /// `::count_ones(…)`. fn count_ones_receiver<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) -> Option<&'tcx Expr<'tcx>> { let (method, ty, receiver) = if let ExprKind::MethodCall(method_name, receiver, [], _) = expr.kind { - (method_name, cx.typeck_results().expr_ty_adjusted(receiver), receiver) + (method_name, cx.typeck_results.expr_ty_adjusted(receiver), receiver) } else if let ExprKind::Call(func, [arg]) = expr.kind && let ExprKind::Path(QPath::TypeRelative(ty, func_name)) = func.kind { @@ -117,7 +117,7 @@ fn is_one_less<'tcx>( if let Some((lhs, rhs)) = unexpanded_binop_operands(smaller, BinOpKind::Sub) && SpanlessEq::new(cx).eq_expr(ctxt, greater, lhs) && is_integer_literal(rhs, 1) - && matches!(cx.typeck_results().expr_ty_adjusted(greater).kind(), ty::Uint(_)) + && matches!(cx.typeck_results.expr_ty_adjusted(greater).kind(), ty::Uint(_)) { Some(greater) } else { diff --git a/src/tools/clippy/clippy_lints/src/manual_let_else.rs b/src/tools/clippy/clippy_lints/src/manual_let_else.rs index 8b92c3b8cbeb5..94f42c5bf5da1 100644 --- a/src/tools/clippy/clippy_lints/src/manual_let_else.rs +++ b/src/tools/clippy/clippy_lints/src/manual_let_else.rs @@ -362,7 +362,7 @@ fn pat_allowed_for_else(cx: &LateContext<'_>, pat: &'_ Pat<'_>, check_types: boo // We do a deep check, to be able to disallow Err(En::Foo(_)) // for usage of the En::Foo variant, as we disallow En::Foo(_), // but we allow Err(_). - let typeck_results = cx.typeck_results(); + let typeck_results = cx.typeck_results; let mut has_disallowed = false; pat.walk_always(|pat| { // Only do the check if the type is "spelled out" in the pattern diff --git a/src/tools/clippy/clippy_lints/src/manual_main_separator_str.rs b/src/tools/clippy/clippy_lints/src/manual_main_separator_str.rs index 47e98d68bc830..59fe7f1cec0d1 100644 --- a/src/tools/clippy/clippy_lints/src/manual_main_separator_str.rs +++ b/src/tools/clippy/clippy_lints/src/manual_main_separator_str.rs @@ -54,7 +54,7 @@ impl LateLintPass<'_> for ManualMainSeparatorStr { && let Res::Def(DefKind::Const { .. }, receiver_def_id) = path.res && cx.ty_based_def(target).opt_parent(cx).is_diag_item(cx, sym::ToString) && cx.tcx.is_diagnostic_item(sym::path_main_separator, receiver_def_id) - && let ty::Ref(_, ty, Mutability::Not) = cx.typeck_results().expr_ty_adjusted(expr).kind() + && let ty::Ref(_, ty, Mutability::Not) = cx.typeck_results.expr_ty_adjusted(expr).kind() && ty.is_str() && self.msrv.meets(cx, msrvs::PATH_MAIN_SEPARATOR_STR) { diff --git a/src/tools/clippy/clippy_lints/src/manual_option_as_slice.rs b/src/tools/clippy/clippy_lints/src/manual_option_as_slice.rs index a851f1ea48db4..d39d89358bb8a 100644 --- a/src/tools/clippy/clippy_lints/src/manual_option_as_slice.rs +++ b/src/tools/clippy/clippy_lints/src/manual_option_as_slice.rs @@ -112,7 +112,7 @@ fn check_map(cx: &LateContext<'_>, map: &Expr<'_>, span: Span, msrv: Msrv) { fn check_as_ref(cx: &LateContext<'_>, expr: &Expr<'_>, span: Span, msrv: Msrv) { if let ExprKind::MethodCall(seg, callee, [], _) = expr.kind && seg.ident.name == sym::as_ref - && cx.typeck_results().expr_ty(callee).is_diag_item(cx, sym::Option) + && cx.typeck_results.expr_ty(callee).is_diag_item(cx, sym::Option) && msrv.meets( cx, if clippy_utils::is_in_const_context(cx) { diff --git a/src/tools/clippy/clippy_lints/src/manual_pop_if.rs b/src/tools/clippy/clippy_lints/src/manual_pop_if.rs index f29403d1a9060..f03d5800dc0fb 100644 --- a/src/tools/clippy/clippy_lints/src/manual_pop_if.rs +++ b/src/tools/clippy/clippy_lints/src/manual_pop_if.rs @@ -118,7 +118,7 @@ impl ManualPopIfKind { } fn is_diag_item(self, cx: &LateContext<'_>, expr: &Expr<'_>) -> bool { - let ty = cx.typeck_results().expr_ty(expr).peel_refs(); + let ty = cx.typeck_results.expr_ty(expr).peel_refs(); match self { ManualPopIfKind::Vec => ty.is_diag_item(cx, sym::Vec), ManualPopIfKind::VecDequeBack | ManualPopIfKind::VecDequeFront => ty.is_diag_item(cx, sym::VecDeque), @@ -370,7 +370,7 @@ fn check_map_unwrap_or_pattern<'tcx>( && kind.is_diag_item(cx, collection_expr) && let ExprKind::Closure(closure) = closure_arg.kind && let body = cx.tcx.hir_body(closure.body) - && cx.typeck_results().expr_ty(body.value).is_bool() + && cx.typeck_results.expr_ty(body.value).is_bool() && let Some((pop_collection, pop_span, suggestable)) = check_pop_unwrap(cx, then_block, pop_method) && eq_expr_value(cx, if_expr_span.ctxt(), collection_expr, pop_collection) && let Some(param) = body.params.first() diff --git a/src/tools/clippy/clippy_lints/src/manual_retain.rs b/src/tools/clippy/clippy_lints/src/manual_retain.rs index bc2e67de99d85..3e5b299f4664e 100644 --- a/src/tools/clippy/clippy_lints/src/manual_retain.rs +++ b/src/tools/clippy/clippy_lints/src/manual_retain.rs @@ -61,7 +61,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualRetain { if let Assign(left_expr, collect_expr, _) = &expr.kind && let hir::ExprKind::MethodCall(seg, target_expr, [], _) = &collect_expr.kind && seg.args.is_none() - && let Some(collect_def_id) = cx.typeck_results().type_dependent_def_id(collect_expr.hir_id) + && let Some(collect_def_id) = cx.typeck_results.type_dependent_def_id(collect_expr.hir_id) && cx.tcx.is_diagnostic_item(sym::iterator_collect_fn, collect_def_id) { check_into_iter(cx, left_expr, target_expr, expr.span, self.msrv); @@ -79,10 +79,10 @@ fn check_into_iter( msrv: Msrv, ) { if let hir::ExprKind::MethodCall(_, into_iter_expr, [_], _) = &target_expr.kind - && let Some(filter_def_id) = cx.typeck_results().type_dependent_def_id(target_expr.hir_id) + && let Some(filter_def_id) = cx.typeck_results.type_dependent_def_id(target_expr.hir_id) && cx.tcx.is_diagnostic_item(sym::iter_filter, filter_def_id) && let hir::ExprKind::MethodCall(_, struct_expr, [], _) = &into_iter_expr.kind - && let Some(into_iter_def_id) = cx.typeck_results().type_dependent_def_id(into_iter_expr.hir_id) + && let Some(into_iter_def_id) = cx.typeck_results.type_dependent_def_id(into_iter_expr.hir_id) && Some(into_iter_def_id) == cx.tcx.lang_items().into_iter_fn() && match_acceptable_type(cx, left_expr, msrv) && SpanlessEq::new(cx).eq_expr(parent_expr_span.ctxt(), left_expr, struct_expr) @@ -122,14 +122,14 @@ fn check_iter( msrv: Msrv, ) { if let hir::ExprKind::MethodCall(_, filter_expr, [], _) = &target_expr.kind - && let Some(copied_def_id) = cx.typeck_results().type_dependent_def_id(target_expr.hir_id) + && let Some(copied_def_id) = cx.typeck_results.type_dependent_def_id(target_expr.hir_id) && let Some(copied_name) = cx.tcx.get_diagnostic_name(copied_def_id) && matches!(copied_name, sym::iter_copied | sym::iter_cloned) && let hir::ExprKind::MethodCall(_, iter_expr, [_], _) = &filter_expr.kind - && let Some(filter_def_id) = cx.typeck_results().type_dependent_def_id(filter_expr.hir_id) + && let Some(filter_def_id) = cx.typeck_results.type_dependent_def_id(filter_expr.hir_id) && cx.tcx.is_diagnostic_item(sym::iter_filter, filter_def_id) && let hir::ExprKind::MethodCall(_, struct_expr, [], _) = &iter_expr.kind - && let Some(iter_expr_def_id) = cx.typeck_results().type_dependent_def_id(iter_expr.hir_id) + && let Some(iter_expr_def_id) = cx.typeck_results.type_dependent_def_id(iter_expr.hir_id) && match_acceptable_sym(cx, iter_expr_def_id) && match_acceptable_type(cx, left_expr, msrv) && SpanlessEq::new(cx).eq_expr(parent_expr_span.ctxt(), left_expr, struct_expr) @@ -180,15 +180,15 @@ fn check_to_owned( msrv: Msrv, ) { if let hir::ExprKind::MethodCall(_, filter_expr, [], _) = &target_expr.kind - && let Some(to_owned_def_id) = cx.typeck_results().type_dependent_def_id(target_expr.hir_id) + && let Some(to_owned_def_id) = cx.typeck_results.type_dependent_def_id(target_expr.hir_id) && cx.tcx.is_diagnostic_item(sym::to_owned_method, to_owned_def_id) && let hir::ExprKind::MethodCall(_, chars_expr, [_], _) = &filter_expr.kind - && let Some(filter_def_id) = cx.typeck_results().type_dependent_def_id(filter_expr.hir_id) + && let Some(filter_def_id) = cx.typeck_results.type_dependent_def_id(filter_expr.hir_id) && cx.tcx.is_diagnostic_item(sym::iter_filter, filter_def_id) && let hir::ExprKind::MethodCall(_, str_expr, [], _) = &chars_expr.kind - && let Some(chars_expr_def_id) = cx.typeck_results().type_dependent_def_id(chars_expr.hir_id) + && let Some(chars_expr_def_id) = cx.typeck_results.type_dependent_def_id(chars_expr.hir_id) && cx.tcx.is_diagnostic_item(sym::str_chars, chars_expr_def_id) - && let ty = cx.typeck_results().expr_ty(str_expr).peel_refs() + && let ty = cx.typeck_results.expr_ty(str_expr).peel_refs() && ty.is_lang_item(cx, hir::LangItem::String) && SpanlessEq::new(cx).eq_expr(parent_expr_span.ctxt(), left_expr, str_expr) && let hir::ExprKind::MethodCall(_, _, [closure_expr], _) = filter_expr.kind @@ -249,7 +249,7 @@ fn match_acceptable_sym(cx: &LateContext<'_>, collect_def_id: DefId) -> bool { } fn match_acceptable_type(cx: &LateContext<'_>, expr: &hir::Expr<'_>, msrv: Msrv) -> bool { - let ty = cx.typeck_results().expr_ty(expr).peel_refs(); + let ty = cx.typeck_results.expr_ty(expr).peel_refs(); let required = match ty.opt_diag_name(cx) { Some(sym::BinaryHeap) => msrvs::BINARY_HEAP_RETAIN, Some(sym::BTreeSet) => msrvs::BTREE_SET_RETAIN, @@ -263,7 +263,7 @@ fn match_acceptable_type(cx: &LateContext<'_>, expr: &hir::Expr<'_>, msrv: Msrv) } fn match_map_type(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> bool { - let ty = cx.typeck_results().expr_ty(expr).peel_refs(); + let ty = cx.typeck_results.expr_ty(expr).peel_refs(); matches!(ty.opt_diag_name(cx), Some(sym::BTreeMap | sym::HashMap)) } diff --git a/src/tools/clippy/clippy_lints/src/manual_rotate.rs b/src/tools/clippy/clippy_lints/src/manual_rotate.rs index a3a937ad713d1..7d9274872f1df 100644 --- a/src/tools/clippy/clippy_lints/src/manual_rotate.rs +++ b/src/tools/clippy/clippy_lints/src/manual_rotate.rs @@ -77,7 +77,7 @@ impl LateLintPass<'_> for ManualRotate { && l_shift_dir != r_shift_dir && let ctxt = expr.span.ctxt() && clippy_utils::eq_expr_value(cx, ctxt, l_expr, r_expr) - && let Some(bit_width) = match cx.typeck_results().expr_ty(expr).kind() { + && let Some(bit_width) = match cx.typeck_results.expr_ty(expr).kind() { ty::Int(itype) => itype.bit_width(), ty::Uint(itype) => itype.bit_width(), _ => return, diff --git a/src/tools/clippy/clippy_lints/src/manual_slice_size_calculation.rs b/src/tools/clippy/clippy_lints/src/manual_slice_size_calculation.rs index f99a4bd186906..40382afd81fe8 100644 --- a/src/tools/clippy/clippy_lints/src/manual_slice_size_calculation.rs +++ b/src/tools/clippy/clippy_lints/src/manual_slice_size_calculation.rs @@ -102,7 +102,7 @@ fn simplify_half<'tcx>( // expr1 is `[T1].len()`? && let ExprKind::MethodCall(method_path, receiver, [], _) = expr1.kind && method_path.ident.name == sym::len - && let receiver_ty = cx.typeck_results().expr_ty(receiver) + && let receiver_ty = cx.typeck_results.expr_ty(receiver) && let (receiver_ty, refs_count, _) = peel_and_count_ty_refs(receiver_ty) && let ty::Slice(ty1) = receiver_ty.kind() // expr2 is `size_of::()`? @@ -110,7 +110,7 @@ fn simplify_half<'tcx>( && let ExprKind::Path(ref func_qpath) = func.kind && let Some(def_id) = cx.qpath_res(func_qpath, func.hir_id).opt_def_id() && cx.tcx.is_diagnostic_item(sym::mem_size_of, def_id) - && let Some(ty2) = cx.typeck_results().node_args(func.hir_id).types().next() + && let Some(ty2) = cx.typeck_results.node_args(func.hir_id).types().next() // T1 == T2? && *ty1 == ty2 { diff --git a/src/tools/clippy/clippy_lints/src/manual_string_new.rs b/src/tools/clippy/clippy_lints/src/manual_string_new.rs index a3ff19d34316a..3fbb4da534a9e 100644 --- a/src/tools/clippy/clippy_lints/src/manual_string_new.rs +++ b/src/tools/clippy/clippy_lints/src/manual_string_new.rs @@ -43,7 +43,7 @@ impl LateLintPass<'_> for ManualStringNew { return; } - let ty = cx.typeck_results().expr_ty(expr); + let ty = cx.typeck_results.expr_ty(expr); match ty.kind() { ty::Adt(adt_def, _) if adt_def.is_struct() => { if cx.tcx.lang_items().string() != Some(adt_def.did()) { diff --git a/src/tools/clippy/clippy_lints/src/manual_strip.rs b/src/tools/clippy/clippy_lints/src/manual_strip.rs index eaa6539653af3..4cc1f84f0d11c 100644 --- a/src/tools/clippy/clippy_lints/src/manual_strip.rs +++ b/src/tools/clippy/clippy_lints/src/manual_strip.rs @@ -72,7 +72,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualStrip { if let Some(higher::If { cond, then, .. }) = higher::If::hir(expr) && let ExprKind::MethodCall(_, target_arg, [pattern], _) = cond.kind && let ExprKind::Path(target_path) = &target_arg.kind - && let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(cond.hir_id) + && let Some(method_def_id) = cx.typeck_results.type_dependent_def_id(cond.hir_id) { let strip_kind = match cx.tcx.get_diagnostic_name(method_def_id) { Some(sym::str_starts_with) => StripKind::Prefix, @@ -155,7 +155,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualStrip { // Returns `Some(arg)` if `expr` matches `arg.len()` and `None` otherwise. fn len_arg<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<&'tcx Expr<'tcx>> { if let ExprKind::MethodCall(_, arg, [], _) = expr.kind - && let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) + && let Some(method_def_id) = cx.typeck_results.type_dependent_def_id(expr.hir_id) && cx.tcx.is_diagnostic_item(sym::str_len, method_def_id) { Some(arg) @@ -194,7 +194,7 @@ fn eq_pattern_length<'tcx>( // Tests if `expr` is a `&str`. fn is_ref_str(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool { - match cx.typeck_results().expr_ty_adjusted(expr).kind() { + match cx.typeck_results.expr_ty_adjusted(expr).kind() { ty::Ref(_, ty, _) => ty.is_str(), _ => false, } diff --git a/src/tools/clippy/clippy_lints/src/map_unit_fn.rs b/src/tools/clippy/clippy_lints/src/map_unit_fn.rs index 5089bd9e14e4a..e476fe60d4838 100644 --- a/src/tools/clippy/clippy_lints/src/map_unit_fn.rs +++ b/src/tools/clippy/clippy_lints/src/map_unit_fn.rs @@ -99,7 +99,7 @@ fn is_unit_type(ty: Ty<'_>) -> bool { } fn is_unit_function(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> bool { - let ty = cx.typeck_results().expr_ty(expr); + let ty = cx.typeck_results.expr_ty(expr); if let ty::FnDef(id, _) = *ty.kind() && let Some(fn_type) = cx.tcx.fn_sig(id).instantiate_identity().skip_norm_wip().no_bound_vars() @@ -110,7 +110,7 @@ fn is_unit_function(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> bool { } fn is_unit_expression(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> bool { - is_unit_type(cx.typeck_results().expr_ty(expr)) + is_unit_type(cx.typeck_results.expr_ty(expr)) } /// The expression inside a closure may or may not have surrounding braces and @@ -207,9 +207,9 @@ fn lint_map_unit_fn( ) { let var_arg = &map_args.0; - let (article, map_type, variant, lint) = if cx.typeck_results().expr_ty(var_arg).is_diag_item(cx, sym::Option) { + let (article, map_type, variant, lint) = if cx.typeck_results.expr_ty(var_arg).is_diag_item(cx, sym::Option) { ("an", "Option", "Some", OPTION_MAP_UNIT_FN) - } else if cx.typeck_results().expr_ty(var_arg).is_diag_item(cx, sym::Result) { + } else if cx.typeck_results.expr_ty(var_arg).is_diag_item(cx, sym::Result) { ("a", "Result", "Ok", RESULT_MAP_UNIT_FN) } else { return; diff --git a/src/tools/clippy/clippy_lints/src/match_result_ok.rs b/src/tools/clippy/clippy_lints/src/match_result_ok.rs index 1ebbd209ae52d..25073991811af 100644 --- a/src/tools/clippy/clippy_lints/src/match_result_ok.rs +++ b/src/tools/clippy/clippy_lints/src/match_result_ok.rs @@ -56,7 +56,7 @@ impl<'tcx> LateLintPass<'tcx> for MatchResultOk { if let ExprKind::MethodCall(ok_path, recv, [], ..) = let_expr.kind //check is expr.ok() has type Result.ok(, _) && ok_path.ident.name == sym::ok - && cx.typeck_results().expr_ty(recv).is_diag_item(cx, sym::Result) + && cx.typeck_results.expr_ty(recv).is_diag_item(cx, sym::Result) && let Some([ok_pat]) = as_some_pattern(cx, let_pat) //get operation && let ctxt = expr.span.ctxt() && let_expr.span.ctxt() == ctxt diff --git a/src/tools/clippy/clippy_lints/src/matches/manual_filter.rs b/src/tools/clippy/clippy_lints/src/matches/manual_filter.rs index 9c2d60eb9c575..a17f85b427d9b 100644 --- a/src/tools/clippy/clippy_lints/src/matches/manual_filter.rs +++ b/src/tools/clippy/clippy_lints/src/matches/manual_filter.rs @@ -103,7 +103,7 @@ pub(crate) fn check_and_then_method<'tcx>( call_span: Span, expr: &'tcx Expr<'_>, ) { - let ty = cx.typeck_results().expr_ty(scrutinee); + let ty = cx.typeck_results.expr_ty(scrutinee); if ty.is_diag_item(cx, sym::Option) && let ExprKind::Closure(closure) = arg.kind && let body = cx.tcx.hir_body(closure.body) @@ -158,7 +158,7 @@ pub(super) fn check_match<'tcx>( arms: &'tcx [Arm<'_>], expr: &'tcx Expr<'_>, ) { - let ty = cx.typeck_results().expr_ty(expr); + let ty = cx.typeck_results.expr_ty(expr); if ty.is_diag_item(cx, sym::Option) && let [first_arm, second_arm] = arms && first_arm.guard.is_none() diff --git a/src/tools/clippy/clippy_lints/src/matches/manual_ok_err.rs b/src/tools/clippy/clippy_lints/src/matches/manual_ok_err.rs index abbf60019c5c0..cee34c93606a3 100644 --- a/src/tools/clippy/clippy_lints/src/matches/manual_ok_err.rs +++ b/src/tools/clippy/clippy_lints/src/matches/manual_ok_err.rs @@ -23,7 +23,7 @@ pub(crate) fn check_if_let( if_then: &Expr<'_>, else_expr: &Expr<'_>, ) { - if let Some(inner_expr_ty) = option_arg_ty(cx, cx.typeck_results().expr_ty(expr)) + if let Some(inner_expr_ty) = option_arg_ty(cx, cx.typeck_results.expr_ty(expr)) && let Some((is_ok, ident)) = is_ok_or_err(cx, let_pat) && is_some_ident(cx, if_then, ident, inner_expr_ty) && is_none(cx, else_expr) @@ -33,7 +33,7 @@ pub(crate) fn check_if_let( } pub(crate) fn check_match(cx: &LateContext<'_>, expr: &Expr<'_>, scrutinee: &Expr<'_>, arms: &[Arm<'_>]) { - if let Some(inner_expr_ty) = option_arg_ty(cx, cx.typeck_results().expr_ty(expr)) + if let Some(inner_expr_ty) = option_arg_ty(cx, cx.typeck_results.expr_ty(expr)) && arms.len() == 2 && arms.iter().all(|arm| arm.guard.is_none()) && let Some((idx, is_ok)) = arms.iter().enumerate().find_map(|(arm_idx, arm)| { @@ -107,7 +107,7 @@ fn is_ok_or_err<'hir>(cx: &LateContext<'_>, pat: &Pat<'hir>) -> Option<(bool, &' /// Check if `expr` contains `Some(ident)`, possibly as a block fn is_some_ident<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, ident: &Ident, ty: Ty<'tcx>) -> bool { if let Some(body_arg) = as_some_expr(cx, peel_blocks(expr)) - && cx.typeck_results().expr_ty(body_arg) == ty + && cx.typeck_results.expr_ty(body_arg) == ty && let ExprKind::Path(QPath::Resolved( _, Path { @@ -137,7 +137,7 @@ fn apply_lint(cx: &LateContext<'_>, expr: &Expr<'_>, scrutinee: &Expr<'_>, is_ok }; let scrut = Sugg::hir_with_context(cx, scrutinee, expr.span.ctxt(), "..", &mut app).maybe_paren(); - let scrutinee_ty = cx.typeck_results().expr_ty(scrutinee); + let scrutinee_ty = cx.typeck_results.expr_ty(scrutinee); let (_, _, mutability) = peel_and_count_ty_refs(scrutinee_ty); let prefix = match mutability { Some(Mutability::Mut) => ".as_mut()", diff --git a/src/tools/clippy/clippy_lints/src/matches/manual_unwrap_or.rs b/src/tools/clippy/clippy_lints/src/matches/manual_unwrap_or.rs index e3a112d1f7802..d3c8625c19933 100644 --- a/src/tools/clippy/clippy_lints/src/matches/manual_unwrap_or.rs +++ b/src/tools/clippy/clippy_lints/src/matches/manual_unwrap_or.rs @@ -88,13 +88,13 @@ fn handle( binding_id: HirId, ) { // Only deal with situations where both alternatives return the same non-adjusted type. - if cx.typeck_results().expr_ty(body_some) != cx.typeck_results().expr_ty(body_none) + if cx.typeck_results.expr_ty(body_some) != cx.typeck_results.expr_ty(body_none) || !safe_to_move_scrutinee(cx, expr, condition) { return; } - let expr_type = cx.typeck_results().expr_ty(expr); + let expr_type = cx.typeck_results.expr_ty(expr); // We check that the `Some(x) => x` doesn't do anything apart "returning" the value in `Some`. if let ExprKind::Path(QPath::Resolved(_, path)) = peel_blocks(body_some).kind && let Res::Local(local_id) = path.res @@ -114,7 +114,7 @@ fn handle( && let Some(default_trait_id) = cx.tcx.get_diagnostic_item(sym::Default) && implements_trait(cx, expr_type, default_trait_id, &[]) // We check if the initial condition implements Default. - && let Some(condition_ty) = cx.typeck_results().expr_ty(condition).walk().nth(1) + && let Some(condition_ty) = cx.typeck_results.expr_ty(condition).walk().nth(1) && let GenericArgKind::Type(condition_ty) = condition_ty.kind() && implements_trait(cx, condition_ty, default_trait_id, &[]) && is_default_equivalent(cx, peel_blocks(body_none)) @@ -158,8 +158,8 @@ fn handle( format!("{receiver}.unwrap_or_default()"), applicability, ); - } else if let Some(ty_name) = find_type_name(cx, cx.typeck_results().expr_ty(condition)) - && cx.typeck_results().expr_adjustments(body_some).is_empty() + } else if let Some(ty_name) = find_type_name(cx, cx.typeck_results.expr_ty(condition)) + && cx.typeck_results.expr_adjustments(body_some).is_empty() && let Some(or_body_snippet) = peel_blocks(body_none).span.get_source_text(cx) && let Some(indent) = indent_of(cx, expr.span) && ConstEvalCtxt::new(cx).eval_local(body_none, expr.span.ctxt()).is_some() @@ -200,7 +200,7 @@ fn find_type_name<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<&'static /// ``` fn safe_to_move_scrutinee(cx: &LateContext<'_>, expr: &Expr<'_>, scrutinee: &Expr<'_>) -> bool { if let Some(hir_id) = scrutinee.res_local_id() - && let scrutinee_ty = cx.typeck_results().expr_ty(scrutinee) + && let scrutinee_ty = cx.typeck_results.expr_ty(scrutinee) && scrutinee_ty.is_diag_item(cx, sym::Result) && !is_copy(cx, scrutinee_ty) && local_used_after_expr(cx, hir_id, expr) diff --git a/src/tools/clippy/clippy_lints/src/matches/manual_utils.rs b/src/tools/clippy/clippy_lints/src/matches/manual_utils.rs index 26fd936767aa7..c75fb5b473095 100644 --- a/src/tools/clippy/clippy_lints/src/matches/manual_utils.rs +++ b/src/tools/clippy/clippy_lints/src/matches/manual_utils.rs @@ -30,10 +30,10 @@ pub(super) fn check_with<'tcx, F>( where F: Fn(&LateContext<'tcx>, &'tcx Pat<'_>, &'tcx Expr<'_>, SyntaxContext) -> Option>, { - let (scrutinee_ty, ty_ref_count, ty_mutability) = peel_and_count_ty_refs(cx.typeck_results().expr_ty(scrutinee)); + let (scrutinee_ty, ty_ref_count, ty_mutability) = peel_and_count_ty_refs(cx.typeck_results.expr_ty(scrutinee)); let ty_mutability = ty_mutability.unwrap_or(Mutability::Mut); - if !(scrutinee_ty.is_diag_item(cx, sym::Option) && cx.typeck_results().expr_ty(expr).is_diag_item(cx, sym::Option)) + if !(scrutinee_ty.is_diag_item(cx, sym::Option) && cx.typeck_results.expr_ty(expr).is_diag_item(cx, sym::Option)) { return None; } @@ -66,7 +66,7 @@ where let some_expr = get_some_expr_fn(cx, some_pat, some_expr, expr_ctxt)?; // These two lints will go back and forth with each other. - if cx.typeck_results().expr_ty(some_expr.expr) == cx.tcx.types.unit + if cx.typeck_results.expr_ty(some_expr.expr) == cx.tcx.types.unit && !is_lint_allowed(cx, OPTION_MAP_UNIT_FN, expr.hir_id) { return None; @@ -186,8 +186,8 @@ fn can_pass_as_func<'tcx>(cx: &LateContext<'tcx>, binding: HirId, expr: &'tcx Ex match expr.kind { ExprKind::Call(func, [arg]) if arg.res_local_id() == Some(binding) - && cx.typeck_results().expr_adjustments(arg).is_empty() - && !is_unsafe_fn(cx, cx.typeck_results().expr_ty(func).peel_refs()) => + && cx.typeck_results.expr_adjustments(arg).is_empty() + && !is_unsafe_fn(cx, cx.typeck_results.expr_ty(func).peel_refs()) => { Some(func) }, diff --git a/src/tools/clippy/clippy_lints/src/matches/match_as_ref.rs b/src/tools/clippy/clippy_lints/src/matches/match_as_ref.rs index 12fe44ef2f134..d563505967c9d 100644 --- a/src/tools/clippy/clippy_lints/src/matches/match_as_ref.rs +++ b/src/tools/clippy/clippy_lints/src/matches/match_as_ref.rs @@ -20,8 +20,8 @@ pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr: } else { None } - && let output_ty = cx.typeck_results().expr_ty(expr) - && let input_ty = cx.typeck_results().expr_ty(ex) + && let output_ty = cx.typeck_results.expr_ty(expr) + && let input_ty = cx.typeck_results.expr_ty(ex) && let Some(input_ty) = option_arg_ty(cx, input_ty) && let Some(output_ty) = option_arg_ty(cx, output_ty) && let ty::Ref(_, output_ty, output_mutbl) = *output_ty.kind() diff --git a/src/tools/clippy/clippy_lints/src/matches/match_bool.rs b/src/tools/clippy/clippy_lints/src/matches/match_bool.rs index 3e76231b6ef10..e69e047b64525 100644 --- a/src/tools/clippy/clippy_lints/src/matches/match_bool.rs +++ b/src/tools/clippy/clippy_lints/src/matches/match_bool.rs @@ -12,7 +12,7 @@ use super::MATCH_BOOL; pub(crate) fn check(cx: &LateContext<'_>, scrutinee: &Expr<'_>, arms: &[Arm<'_>], expr: &Expr<'_>) { // Type of expression is `bool`. - if *cx.typeck_results().expr_ty(scrutinee).kind() == ty::Bool + if *cx.typeck_results.expr_ty(scrutinee).kind() == ty::Bool && arms .iter() .all(|arm| arm.pat.walk_short(|p| !matches!(p.kind, PatKind::Binding(..)))) diff --git a/src/tools/clippy/clippy_lints/src/matches/match_like_matches.rs b/src/tools/clippy/clippy_lints/src/matches/match_like_matches.rs index 7b3ad2596b9eb..8c52e33d9c730 100644 --- a/src/tools/clippy/clippy_lints/src/matches/match_like_matches.rs +++ b/src/tools/clippy/clippy_lints/src/matches/match_like_matches.rs @@ -23,7 +23,7 @@ pub(crate) fn check_if_let<'tcx>( else_expr: &'tcx Expr<'_>, ) { if !span_contains_comment(cx, expr.span) - && cx.typeck_results().expr_ty(expr).is_bool() + && cx.typeck_results.expr_ty(expr).is_bool() && let Some(b0) = find_bool_lit(then_expr) && let Some(b1) = find_bool_lit(else_expr) && b0 != b1 @@ -40,7 +40,7 @@ pub(crate) fn check_if_let<'tcx>( // strip potential borrows (#6503), but only if the type is a reference let mut ex_new = let_expr; if let ExprKind::AddrOf(BorrowKind::Ref, .., ex_inner) = let_expr.kind - && let ty::Ref(..) = cx.typeck_results().expr_ty(ex_inner).kind() + && let ty::Ref(..) = cx.typeck_results.expr_ty(ex_inner).kind() { ex_new = ex_inner; } @@ -72,7 +72,7 @@ pub(super) fn check_match<'tcx>( if let Some((last_arm, arms_without_last)) = arms.split_last() && let Some((first_arm, middle_arms)) = arms_without_last.split_first() && !span_contains_comment(cx, e.span) - && cx.typeck_results().expr_ty(e).is_bool() + && cx.typeck_results.expr_ty(e).is_bool() && let Some(b0) = find_bool_lit(first_arm.body) && let Some(b1) = find_bool_lit(last_arm.body) && b0 != b1 @@ -172,7 +172,7 @@ pub(super) fn check_match<'tcx>( // strip potential borrows (#6503), but only if the type is a reference let mut ex_new = scrutinee; if let ExprKind::AddrOf(BorrowKind::Ref, .., ex_inner) = scrutinee.kind - && let ty::Ref(..) = cx.typeck_results().expr_ty(ex_inner).kind() + && let ty::Ref(..) = cx.typeck_results.expr_ty(ex_inner).kind() { ex_new = ex_inner; } diff --git a/src/tools/clippy/clippy_lints/src/matches/match_ref_pats.rs b/src/tools/clippy/clippy_lints/src/matches/match_ref_pats.rs index 042817f5cdb82..979f769b4a01c 100644 --- a/src/tools/clippy/clippy_lints/src/matches/match_ref_pats.rs +++ b/src/tools/clippy/clippy_lints/src/matches/match_ref_pats.rs @@ -18,7 +18,7 @@ where } // `!` cannot be deref-ed - if cx.typeck_results().expr_ty(scrutinee).is_never() { + if cx.typeck_results.expr_ty(scrutinee).is_never() { return; } diff --git a/src/tools/clippy/clippy_lints/src/matches/match_same_arms.rs b/src/tools/clippy/clippy_lints/src/matches/match_same_arms.rs index caef6a0b36377..b4ae764c7740b 100644 --- a/src/tools/clippy/clippy_lints/src/matches/match_same_arms.rs +++ b/src/tools/clippy/clippy_lints/src/matches/match_same_arms.rs @@ -277,7 +277,7 @@ impl<'a> NormalizedPat<'a> { Self::Struct(cx.qpath_res(path, pat.hir_id).opt_def_id(), fields) }, PatKind::TupleStruct(ref path, pats, wild_idx) => { - let Some(adt) = cx.typeck_results().pat_ty(pat).ty_adt_def() else { + let Some(adt) = cx.typeck_results.pat_ty(pat).ty_adt_def() else { return Self::Wild; }; let (var_id, variant) = if adt.is_enum() { @@ -308,7 +308,7 @@ impl<'a> NormalizedPat<'a> { .. }) => Self::Path(cx.qpath_res(path, *hir_id).opt_def_id()), PatKind::Tuple(pats, wild_idx) => { - let field_count = match cx.typeck_results().pat_ty(pat).kind() { + let field_count = match cx.typeck_results.pat_ty(pat).kind() { ty::Tuple(subs) => subs.len(), _ => return Self::Wild, }; diff --git a/src/tools/clippy/clippy_lints/src/matches/match_str_case_mismatch.rs b/src/tools/clippy/clippy_lints/src/matches/match_str_case_mismatch.rs index 3f8f2dc0e132d..930de2071c679 100644 --- a/src/tools/clippy/clippy_lints/src/matches/match_str_case_mismatch.rs +++ b/src/tools/clippy/clippy_lints/src/matches/match_str_case_mismatch.rs @@ -23,7 +23,7 @@ enum CaseMethod { } pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, scrutinee: &'tcx Expr<'_>, arms: &'tcx [Arm<'_>]) { - if let ty::Ref(_, ty, _) = cx.typeck_results().expr_ty(scrutinee).kind() + if let ty::Ref(_, ty, _) = cx.typeck_results.expr_ty(scrutinee).kind() && let ty::Str = ty.kind() { let mut visitor = MatchExprVisitor { cx }; @@ -56,7 +56,7 @@ impl<'tcx> Visitor<'tcx> for MatchExprVisitor<'_, 'tcx> { impl MatchExprVisitor<'_, '_> { fn case_altered(&self, segment_ident: Symbol, receiver: &Expr<'_>) -> ControlFlow { if let Some(case_method) = get_case_method(segment_ident) { - let ty = self.cx.typeck_results().expr_ty(receiver).peel_refs(); + let ty = self.cx.typeck_results.expr_ty(receiver).peel_refs(); if ty.is_lang_item(self.cx, LangItem::String) || ty.kind() == &ty::Str { return ControlFlow::Break(case_method); diff --git a/src/tools/clippy/clippy_lints/src/matches/match_wild_enum.rs b/src/tools/clippy/clippy_lints/src/matches/match_wild_enum.rs index 6b46791eb117a..5add605504194 100644 --- a/src/tools/clippy/clippy_lints/src/matches/match_wild_enum.rs +++ b/src/tools/clippy/clippy_lints/src/matches/match_wild_enum.rs @@ -13,7 +13,7 @@ use super::{MATCH_WILDCARD_FOR_SINGLE_VARIANTS, WILDCARD_ENUM_MATCH_ARM}; #[expect(clippy::too_many_lines)] pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>]) { - let ty = cx.typeck_results().expr_ty(ex).peel_refs(); + let ty = cx.typeck_results.expr_ty(ex).peel_refs(); let adt_def = match ty.kind() { ty::Adt(adt_def, _) if adt_def.is_enum() && !matches!(ty.opt_diag_name(cx), Some(sym::Option | sym::Result)) => diff --git a/src/tools/clippy/clippy_lints/src/matches/match_wild_err_arm.rs b/src/tools/clippy/clippy_lints/src/matches/match_wild_err_arm.rs index e38ba801c0bf7..b98af829283b2 100644 --- a/src/tools/clippy/clippy_lints/src/matches/match_wild_err_arm.rs +++ b/src/tools/clippy/clippy_lints/src/matches/match_wild_err_arm.rs @@ -15,7 +15,7 @@ pub(crate) fn check<'tcx>(cx: &LateContext<'tcx>, ex: &Expr<'tcx>, arms: &[Arm<' return; } - let ex_ty = cx.typeck_results().expr_ty(ex).peel_refs(); + let ex_ty = cx.typeck_results.expr_ty(ex).peel_refs(); if ex_ty.is_diag_item(cx, sym::Result) { for arm in arms { if let PatKind::TupleStruct(ref path, inner, _) = arm.pat.kind { diff --git a/src/tools/clippy/clippy_lints/src/matches/needless_match.rs b/src/tools/clippy/clippy_lints/src/matches/needless_match.rs index 0151aa8ef15ef..1f3d76baa1c8d 100644 --- a/src/tools/clippy/clippy_lints/src/matches/needless_match.rs +++ b/src/tools/clippy/clippy_lints/src/matches/needless_match.rs @@ -106,7 +106,7 @@ fn check_if_let_inner(cx: &LateContext<'_>, ctxt: SyntaxContext, if_let: &higher if matches!(else_expr.kind, ExprKind::Block(..)) { return false; } - let let_expr_ty = cx.typeck_results().expr_ty(if_let.let_expr); + let let_expr_ty = cx.typeck_results.expr_ty(if_let.let_expr); if let_expr_ty.is_diag_item(cx, sym::Option) { return else_expr.res(cx).ctor_parent(cx).is_lang_item(cx, OptionNone) || eq_expr_value(cx, ctxt, if_let.let_expr, else_expr); @@ -124,7 +124,7 @@ fn expr_ty_matches_p_ty(cx: &LateContext<'_>, expr: &Expr<'_>, p_expr: &Expr<'_> match cx.tcx.parent_hir_node(p_expr.hir_id) { // Compare match_expr ty with local in `let local = match match_expr {..}` Node::LetStmt(local) => { - let results = cx.typeck_results(); + let results = cx.typeck_results; return same_type_modulo_regions(results.node_type(local.hir_id), results.expr_ty(expr)); }, // compare match_expr ty with RetTy in `fn foo() -> RetTy` @@ -137,7 +137,7 @@ fn expr_ty_matches_p_ty(cx: &LateContext<'_>, expr: &Expr<'_>, p_expr: &Expr<'_> .skip_norm_wip() .output() .skip_binder(); - return same_type_modulo_regions(output, cx.typeck_results().expr_ty(expr)); + return same_type_modulo_regions(output, cx.typeck_results.expr_ty(expr)); } }, // check the parent expr for this whole block `{ match match_expr {..} }` diff --git a/src/tools/clippy/clippy_lints/src/matches/overlapping_arms.rs b/src/tools/clippy/clippy_lints/src/matches/overlapping_arms.rs index d76218e6305b0..87fcb40153e52 100644 --- a/src/tools/clippy/clippy_lints/src/matches/overlapping_arms.rs +++ b/src/tools/clippy/clippy_lints/src/matches/overlapping_arms.rs @@ -9,8 +9,8 @@ use rustc_span::Span; use super::MATCH_OVERLAPPING_ARM; pub(crate) fn check<'tcx>(cx: &LateContext<'tcx>, ex: &'tcx Expr<'_>, arms: &'tcx [Arm<'_>]) { - if arms.len() >= 2 && cx.typeck_results().expr_ty(ex).is_integral() { - let ranges = all_ranges(cx, arms, cx.typeck_results().expr_ty(ex)); + if arms.len() >= 2 && cx.typeck_results.expr_ty(ex).is_integral() { + let ranges = all_ranges(cx, arms, cx.typeck_results.expr_ty(ex)); if !ranges.is_empty() && let Some((start, end)) = overlapping(&ranges) { @@ -57,7 +57,7 @@ fn all_ranges<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>], ty: Ty<'tcx>) if let PatKind::Expr(value) = pat.kind { let value = ConstEvalCtxt::new(cx) .eval_pat_expr(value)? - .int_value(cx.tcx, cx.typeck_results().node_type(pat.hir_id))?; + .int_value(cx.tcx, cx.typeck_results.node_type(pat.hir_id))?; return Some(SpannedRange { span: pat.span, node: (value, EndBound::Included(value)), diff --git a/src/tools/clippy/clippy_lints/src/matches/redundant_guards.rs b/src/tools/clippy/clippy_lints/src/matches/redundant_guards.rs index fa8b6a65a2038..b7d1397f1f3e2 100644 --- a/src/tools/clippy/clippy_lints/src/matches/redundant_guards.rs +++ b/src/tools/clippy/clippy_lints/src/matches/redundant_guards.rs @@ -72,7 +72,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'tcx>], msrv: // extraordinary amount of FPs. // // This isn't necessary in the other two checks, as they must be a pattern already. - && cx.typeck_results().expr_ty(local) == cx.typeck_results().expr_ty(pat) + && cx.typeck_results.expr_ty(local) == cx.typeck_results.expr_ty(pat) // Since we want to lint on both `x == Some(2)` and `Some(2) == x`, we might have to "swap" // `local` and `pat`, depending on which side they are. && let Some((binding, pat)) = get_pat_binding(cx, local, outer_arm) @@ -110,7 +110,7 @@ fn check_method_calls<'tcx>( if_expr: &Expr<'_>, binding: &PatBindingInfo, ) { - let ty = cx.typeck_results().expr_ty(recv).peel_refs(); + let ty = cx.typeck_results.expr_ty(recv).peel_refs(); let slice_like = ty.is_slice() || ty.is_array(); let sugg = if method == sym::is_empty { diff --git a/src/tools/clippy/clippy_lints/src/matches/redundant_pattern_match.rs b/src/tools/clippy/clippy_lints/src/matches/redundant_pattern_match.rs index b10c6c0ac5934..1e3b51bb19602 100644 --- a/src/tools/clippy/clippy_lints/src/matches/redundant_pattern_match.rs +++ b/src/tools/clippy/clippy_lints/src/matches/redundant_pattern_match.rs @@ -126,7 +126,7 @@ fn find_method_and_type<'tcx>( let is_rest = matches!((args, rest.as_opt_usize()), ([], Some(_))); if is_wildcard || is_rest { - let res = cx.typeck_results().qpath_res(qpath, check_pat.hir_id); + let res = cx.typeck_results.qpath_res(qpath, check_pat.hir_id); let id = res.opt_def_id().map(|ctor_id| cx.tcx.parent(ctor_id))?; let lang_items = cx.tcx.lang_items(); if Some(id) == lang_items.result_ok_variant() { @@ -188,7 +188,7 @@ fn find_method_sugg_for_if_let<'tcx>( PatKind::Ref(inner, _pinnedness, _mutability) => inner, _ => let_pat, }; - let op_ty = cx.typeck_results().expr_ty(let_expr); + let op_ty = cx.typeck_results.expr_ty(let_expr); // Determine which function should be used, and the type contained by the corresponding // variant. let Some((good_method, inner_ty)) = find_method_and_type(cx, check_pat, op_ty) else { @@ -450,7 +450,7 @@ enum Item { } fn is_pat_variant(cx: &LateContext<'_>, pat: &Pat<'_>, path: &QPath<'_>, expected_item: Item) -> bool { - let Some(id) = cx.typeck_results().qpath_res(path, pat.hir_id).opt_def_id() else { + let Some(id) = cx.typeck_results.qpath_res(path, pat.hir_id).opt_def_id() else { return false; }; @@ -461,7 +461,7 @@ fn is_pat_variant(cx: &LateContext<'_>, pat: &Pat<'_>, path: &QPath<'_>, expecte .get(expected_lang_item) .is_some_and(|expected_id| cx.tcx.parent(id) == expected_id), Item::Diag(expected_ty, expected_variant) => { - let ty = cx.typeck_results().pat_ty(pat); + let ty = cx.typeck_results.pat_ty(pat); if ty.is_diag_item(cx, expected_ty) { let variant = ty diff --git a/src/tools/clippy/clippy_lints/src/matches/significant_drop_in_scrutinee.rs b/src/tools/clippy/clippy_lints/src/matches/significant_drop_in_scrutinee.rs index ae7702105462f..ceb35b61f3f09 100644 --- a/src/tools/clippy/clippy_lints/src/matches/significant_drop_in_scrutinee.rs +++ b/src/tools/clippy/clippy_lints/src/matches/significant_drop_in_scrutinee.rs @@ -173,7 +173,7 @@ impl<'a, 'tcx> SigDropChecker<'a, 'tcx> { } fn is_sig_drop_expr(&mut self, ex: &'tcx Expr<'_>) -> bool { - !ex.is_syntactic_place_expr() && self.has_sig_drop_attr(self.cx.typeck_results().expr_ty(ex)) + !ex.is_syntactic_place_expr() && self.has_sig_drop_attr(self.cx.typeck_results.expr_ty(ex)) } fn has_sig_drop_attr(&mut self, ty: Ty<'tcx>) -> bool { @@ -302,7 +302,7 @@ impl<'a, 'tcx> SigDropHelper<'a, 'tcx> { } if self.sig_drop_holder != SigDropHolder::None { - let parent_ty = self.cx.typeck_results().expr_ty(parent_expr); + let parent_ty = self.cx.typeck_results.expr_ty(parent_expr); if !parent_ty.has_erased_regions() && !parent_expr.is_syntactic_place_expr() { self.replace_current_sig_drop(parent_expr.span, parent_ty.is_unit(), 0); self.sig_drop_holder = SigDropHolder::Moved; @@ -342,7 +342,7 @@ impl<'a, 'tcx> SigDropHelper<'a, 'tcx> { return; }; - let fn_sig = if let Some(def_id) = self.cx.typeck_results().type_dependent_def_id(parent_expr.hir_id) { + let fn_sig = if let Some(def_id) = self.cx.typeck_results.type_dependent_def_id(parent_expr.hir_id) { self.cx.tcx.fn_sig(def_id).instantiate_identity().skip_norm_wip() } else { return; diff --git a/src/tools/clippy/clippy_lints/src/matches/single_match.rs b/src/tools/clippy/clippy_lints/src/matches/single_match.rs index b96c869b5151a..d37dea43d086a 100644 --- a/src/tools/clippy/clippy_lints/src/matches/single_match.rs +++ b/src/tools/clippy/clippy_lints/src/matches/single_match.rs @@ -53,7 +53,7 @@ pub(crate) fn check<'tcx>( return; }; - let typeck = cx.typeck_results(); + let typeck = cx.typeck_results; if *typeck.expr_ty(ex).peel_refs().kind() != ty::Bool || is_lint_allowed(cx, MATCH_BOOL, ex.hir_id) { let mut v = PatVisitor { typeck, @@ -130,7 +130,7 @@ fn report_single_pattern( let (pat, pat_ref_count) = peel_hir_pat_refs(arm.pat); let (msg, sugg) = if let PatKind::Expr(_) = pat.kind - && let (ty, ty_ref_count, _) = peel_and_count_ty_refs(cx.typeck_results().expr_ty(ex)) + && let (ty, ty_ref_count, _) = peel_and_count_ty_refs(cx.typeck_results.expr_ty(ex)) && let Some(spe_trait_id) = cx.tcx.lang_items().structural_peq_trait() && let Some(pe_trait_id) = cx.tcx.lang_items().eq_trait() && (ty.is_integral() diff --git a/src/tools/clippy/clippy_lints/src/matches/try_err.rs b/src/tools/clippy/clippy_lints/src/matches/try_err.rs index 401b8468135bc..fd295f0428540 100644 --- a/src/tools/clippy/clippy_lints/src/matches/try_err.rs +++ b/src/tools/clippy/clippy_lints/src/matches/try_err.rs @@ -45,7 +45,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, scrutine expr.span, "returning an `Err(_)` with the `?` operator", |diag| { - let expr_err_ty = cx.typeck_results().expr_ty(err_arg); + let expr_err_ty = cx.typeck_results.expr_ty(err_arg); let span = hygiene::walk_chain(err_arg.span, try_arg.span.ctxt()); let mut applicability = Applicability::MachineApplicable; let origin_snippet = snippet_with_applicability(cx, span, "_", &mut applicability); @@ -70,7 +70,7 @@ fn find_return_type<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx ExprKind<'_>) -> O if let ExprKind::Match(_, arms, MatchSource::TryDesugar(_)) = expr { for arm in *arms { if let ExprKind::Ret(Some(ret)) = arm.body.kind { - return Some(cx.typeck_results().expr_ty(ret)); + return Some(cx.typeck_results.expr_ty(ret)); } } } diff --git a/src/tools/clippy/clippy_lints/src/matches/wild_in_or_pats.rs b/src/tools/clippy/clippy_lints/src/matches/wild_in_or_pats.rs index 43102d78bfebd..fcdc829a92189 100644 --- a/src/tools/clippy/clippy_lints/src/matches/wild_in_or_pats.rs +++ b/src/tools/clippy/clippy_lints/src/matches/wild_in_or_pats.rs @@ -8,7 +8,7 @@ use super::WILDCARD_IN_OR_PATTERNS; pub(crate) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, arms: &[Arm<'_>]) { // first check if we are matching on an enum that has the non_exhaustive attribute - let ty = cx.typeck_results().expr_ty(expr).peel_refs(); + let ty = cx.typeck_results.expr_ty(expr).peel_refs(); if let ty::Adt(adt_def, _) = ty.kind() && has_non_exhaustive_attr(cx.tcx, *adt_def) { diff --git a/src/tools/clippy/clippy_lints/src/mem_replace.rs b/src/tools/clippy/clippy_lints/src/mem_replace.rs index 0d417c25ef0e1..de28eda28d388 100644 --- a/src/tools/clippy/clippy_lints/src/mem_replace.rs +++ b/src/tools/clippy/clippy_lints/src/mem_replace.rs @@ -192,7 +192,7 @@ fn check_replace_option_with_some( } fn check_replace_with_uninit(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<'_>, expr_span: Span) { - if let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(src.hir_id) + if let Some(method_def_id) = cx.typeck_results.type_dependent_def_id(src.hir_id) // check if replacement is mem::MaybeUninit::uninit().assume_init() && cx.tcx.is_diagnostic_item(sym::assume_init, method_def_id) { @@ -233,7 +233,7 @@ fn check_replace_with_uninit(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<' ), applicability, ); - } else if repl_name == Some(sym::mem_zeroed) && !cx.typeck_results().expr_ty(src).is_primitive() { + } else if repl_name == Some(sym::mem_zeroed) && !cx.typeck_results.expr_ty(src).is_primitive() { span_lint_and_help( cx, MEM_REPLACE_WITH_UNINIT, @@ -255,7 +255,7 @@ fn check_replace_with_default( ) -> bool { if is_expr_used_or_unified(cx.tcx, expr) // disable lint for primitives - && let expr_type = cx.typeck_results().expr_ty_adjusted(src) + && let expr_type = cx.typeck_results.expr_ty_adjusted(src) && !is_non_aggregate_primitive_type(expr_type) && is_default_equivalent(cx, src) && !expr.span.in_external_macro(cx.tcx.sess.source_map()) diff --git a/src/tools/clippy/clippy_lints/src/methods/bind_instead_of_map.rs b/src/tools/clippy/clippy_lints/src/methods/bind_instead_of_map.rs index 6390680c067cb..e901a431da754 100644 --- a/src/tools/clippy/clippy_lints/src/methods/bind_instead_of_map.rs +++ b/src/tools/clippy/clippy_lints/src/methods/bind_instead_of_map.rs @@ -154,7 +154,7 @@ impl BindInsteadOfMap { /// Lint use of `_.and_then(|x| Some(y))` for `Option`s fn check(&self, cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>, arg: &hir::Expr<'_>) -> bool { - if let Some(adt) = cx.typeck_results().expr_ty(recv).ty_adt_def() + if let Some(adt) = cx.typeck_results.expr_ty(recv).ty_adt_def() && let Some(vid) = cx.tcx.lang_items().get(self.variant_lang_item) && adt.did() == cx.tcx.parent(vid) { diff --git a/src/tools/clippy/clippy_lints/src/methods/bytecount.rs b/src/tools/clippy/clippy_lints/src/methods/bytecount.rs index 2ad7facf64d88..aac5a6839f6d5 100644 --- a/src/tools/clippy/clippy_lints/src/methods/bytecount.rs +++ b/src/tools/clippy/clippy_lints/src/methods/bytecount.rs @@ -23,7 +23,7 @@ pub(super) fn check<'tcx>( && let ExprKind::Binary(ref op, l, r) = body.value.kind && op.node == BinOpKind::Eq && cx - .typeck_results() + .typeck_results .expr_ty(filter_recv) .peel_refs() .is_diag_item(cx, sym::SliceIter) @@ -38,7 +38,7 @@ pub(super) fn check<'tcx>( } else { return; } - && ty::Uint(UintTy::U8) == *cx.typeck_results().expr_ty(needle).peel_refs().kind() + && ty::Uint(UintTy::U8) == *cx.typeck_results.expr_ty(needle).peel_refs().kind() && !is_local_used(cx, needle, arg_id) { let haystack = if let ExprKind::MethodCall(path, receiver, [], _) = filter_recv.kind { diff --git a/src/tools/clippy/clippy_lints/src/methods/bytes_count_to_len.rs b/src/tools/clippy/clippy_lints/src/methods/bytes_count_to_len.rs index 5abdd82f1cde2..4b3e63cd8dc83 100644 --- a/src/tools/clippy/clippy_lints/src/methods/bytes_count_to_len.rs +++ b/src/tools/clippy/clippy_lints/src/methods/bytes_count_to_len.rs @@ -13,10 +13,10 @@ pub(super) fn check<'tcx>( count_recv: &'tcx hir::Expr<'_>, bytes_recv: &'tcx hir::Expr<'_>, ) { - if let Some(bytes_id) = cx.typeck_results().type_dependent_def_id(count_recv.hir_id) + if let Some(bytes_id) = cx.typeck_results.type_dependent_def_id(count_recv.hir_id) && let Some(impl_id) = cx.tcx.impl_of_assoc(bytes_id) && cx.tcx.type_of(impl_id).instantiate_identity().skip_norm_wip().is_str() - && let ty = cx.typeck_results().expr_ty(bytes_recv).peel_refs() + && let ty = cx.typeck_results.expr_ty(bytes_recv).peel_refs() && (ty.is_str() || ty.is_lang_item(cx, hir::LangItem::String)) { let mut applicability = Applicability::MachineApplicable; diff --git a/src/tools/clippy/clippy_lints/src/methods/bytes_nth.rs b/src/tools/clippy/clippy_lints/src/methods/bytes_nth.rs index 0a3ea3005e72b..1b19b810e2572 100644 --- a/src/tools/clippy/clippy_lints/src/methods/bytes_nth.rs +++ b/src/tools/clippy/clippy_lints/src/methods/bytes_nth.rs @@ -11,7 +11,7 @@ use crate::methods::method_call; use super::BYTES_NTH; pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, recv: &'tcx Expr<'tcx>, n_arg: &'tcx Expr<'tcx>) { - let ty = cx.typeck_results().expr_ty(recv).peel_refs(); + let ty = cx.typeck_results.expr_ty(recv).peel_refs(); let caller_type = if ty.is_str() { "str" } else if ty.is_lang_item(cx, LangItem::String) { diff --git a/src/tools/clippy/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs b/src/tools/clippy/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs index 15f4d91e4bd9e..da1a9195e1539 100644 --- a/src/tools/clippy/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs +++ b/src/tools/clippy/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs @@ -28,7 +28,7 @@ pub(super) fn check<'tcx>( return; } - if let Some(method_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) + if let Some(method_id) = cx.typeck_results.type_dependent_def_id(expr.hir_id) && let Some(impl_id) = cx.tcx.impl_of_assoc(method_id) && cx.tcx.type_of(impl_id).instantiate_identity().skip_norm_wip().is_str() && let ExprKind::Lit(Spanned { @@ -41,7 +41,7 @@ pub(super) fn check<'tcx>( && (ext_str.chars().skip(1).all(|c| c.is_uppercase() || c.is_ascii_digit()) || ext_str.chars().skip(1).all(|c| c.is_lowercase() || c.is_ascii_digit())) && !ext_str.chars().skip(1).all(|c| c.is_ascii_digit()) - && let recv_ty = cx.typeck_results().expr_ty(recv).peel_refs() + && let recv_ty = cx.typeck_results.expr_ty(recv).peel_refs() && (recv_ty.is_str() || recv_ty.is_lang_item(cx, LangItem::String)) { span_lint_and_then( @@ -52,7 +52,7 @@ pub(super) fn check<'tcx>( |diag| { diag.help("consider using a case-insensitive comparison instead"); if let Some(recv_source) = recv.span.get_source_text(cx) { - let recv_source = if cx.typeck_results().expr_ty(recv).is_ref() { + let recv_source = if cx.typeck_results.expr_ty(recv).is_ref() { recv_source.to_owned() } else { format!("&{recv_source}") diff --git a/src/tools/clippy/clippy_lints/src/methods/chars_cmp.rs b/src/tools/clippy/clippy_lints/src/methods/chars_cmp.rs index 4b0fc7eba8e34..f2fdac77101d2 100644 --- a/src/tools/clippy/clippy_lints/src/methods/chars_cmp.rs +++ b/src/tools/clippy/clippy_lints/src/methods/chars_cmp.rs @@ -22,7 +22,7 @@ pub(super) fn check( && Some(id) == cx.tcx.lang_items().option_some_variant() { let mut applicability = Applicability::MachineApplicable; - let self_ty = cx.typeck_results().expr_ty_adjusted(args[0].0).peel_refs(); + let self_ty = cx.typeck_results.expr_ty_adjusted(args[0].0).peel_refs(); if *self_ty.kind() != ty::Str { return false; diff --git a/src/tools/clippy/clippy_lints/src/methods/clear_with_drain.rs b/src/tools/clippy/clippy_lints/src/methods/clear_with_drain.rs index cd6b39b15a1b9..92d8eace7308d 100644 --- a/src/tools/clippy/clippy_lints/src/methods/clear_with_drain.rs +++ b/src/tools/clippy/clippy_lints/src/methods/clear_with_drain.rs @@ -27,14 +27,14 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, span } fn match_acceptable_type(cx: &LateContext<'_>, expr: &Expr<'_>, types: &[rustc_span::Symbol]) -> bool { - let expr_ty = cx.typeck_results().expr_ty(expr).peel_refs(); + let expr_ty = cx.typeck_results.expr_ty(expr).peel_refs(); types.iter().any(|&ty| expr_ty.is_diag_item(cx, ty)) // String type is a lang item but not a diagnostic item for now so we need a separate check || expr_ty.is_lang_item(cx, LangItem::String) } fn suggest(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, span: Span) { - if let Some(adt) = cx.typeck_results().expr_ty(recv).ty_adt_def() + if let Some(adt) = cx.typeck_results.expr_ty(recv).ty_adt_def() // Use `opt_item_name` while `String` is not a diagnostic item && let Some(ty_name) = cx.tcx.opt_item_name(adt.did()) { diff --git a/src/tools/clippy/clippy_lints/src/methods/clone_on_copy.rs b/src/tools/clippy/clippy_lints/src/methods/clone_on_copy.rs index 18087bd96debf..ec2d7392b3196 100644 --- a/src/tools/clippy/clippy_lints/src/methods/clone_on_copy.rs +++ b/src/tools/clippy/clippy_lints/src/methods/clone_on_copy.rs @@ -13,7 +13,7 @@ use super::CLONE_ON_COPY; /// Checks for the `CLONE_ON_COPY` lint. pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, receiver: &Expr<'_>) { if cx - .typeck_results() + .typeck_results .type_dependent_def_id(expr.hir_id) .and_then(|id| cx.tcx.trait_of_assoc(id)) .zip(cx.tcx.lang_items().clone_trait()) @@ -21,12 +21,12 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, receiver: &Expr<'_>) { return; } - let arg_adjustments = cx.typeck_results().expr_adjustments(receiver); + let arg_adjustments = cx.typeck_results.expr_adjustments(receiver); let arg_ty = arg_adjustments .last() - .map_or_else(|| cx.typeck_results().expr_ty(receiver), |a| a.target); + .map_or_else(|| cx.typeck_results.expr_ty(receiver), |a| a.target); - let ty = cx.typeck_results().expr_ty(expr); + let ty = cx.typeck_results.expr_ty(expr); if let ty::Ref(_, inner, _) = arg_ty.kind() && let ty::Ref(..) = inner.kind() { @@ -40,7 +40,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, receiver: &Expr<'_>) ExprKind::AddrOf(..) => return, // (*x).func() is useless, x.clone().func() can work in case func borrows self ExprKind::MethodCall(_, self_arg, ..) - if expr.hir_id == self_arg.hir_id && ty != cx.typeck_results().expr_ty_adjusted(expr) => + if expr.hir_id == self_arg.hir_id && ty != cx.typeck_results.expr_ty_adjusted(expr) => { return; }, diff --git a/src/tools/clippy/clippy_lints/src/methods/clone_on_ref_ptr.rs b/src/tools/clippy/clippy_lints/src/methods/clone_on_ref_ptr.rs index de32b0476d205..d6cbd48230ef2 100644 --- a/src/tools/clippy/clippy_lints/src/methods/clone_on_ref_ptr.rs +++ b/src/tools/clippy/clippy_lints/src/methods/clone_on_ref_ptr.rs @@ -10,7 +10,7 @@ use rustc_span::symbol::sym; use super::CLONE_ON_REF_PTR; pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, receiver: &hir::Expr<'_>) { - let receiver_ty = cx.typeck_results().expr_ty(receiver); + let receiver_ty = cx.typeck_results.expr_ty(receiver); let (receiver_ty_peeled, n_refs, _) = peel_and_count_ty_refs(receiver_ty); if let ty::Adt(adt, subst) = receiver_ty_peeled.kind() diff --git a/src/tools/clippy/clippy_lints/src/methods/cloned_instead_of_copied.rs b/src/tools/clippy/clippy_lints/src/methods/cloned_instead_of_copied.rs index d80d6f7810f53..d11776bae0577 100644 --- a/src/tools/clippy/clippy_lints/src/methods/cloned_instead_of_copied.rs +++ b/src/tools/clippy/clippy_lints/src/methods/cloned_instead_of_copied.rs @@ -11,7 +11,7 @@ use rustc_span::{Span, sym}; use super::CLONED_INSTEAD_OF_COPIED; pub fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, span: Span, msrv: Msrv) { - let recv_ty = cx.typeck_results().expr_ty_adjusted(recv); + let recv_ty = cx.typeck_results.expr_ty_adjusted(recv); let inner_ty = match recv_ty.kind() { // `Option` -> `T` ty::Adt(adt, subst) diff --git a/src/tools/clippy/clippy_lints/src/methods/collapsible_str_replace.rs b/src/tools/clippy/clippy_lints/src/methods/collapsible_str_replace.rs index ce296d45d605c..9b09528315126 100644 --- a/src/tools/clippy/clippy_lints/src/methods/collapsible_str_replace.rs +++ b/src/tools/clippy/clippy_lints/src/methods/collapsible_str_replace.rs @@ -18,13 +18,13 @@ pub(super) fn check<'tcx>( ) { let replace_methods = collect_replace_calls(cx, expr, to); if replace_methods.methods.len() > 1 { - let from_kind = cx.typeck_results().expr_ty(from).peel_refs().kind(); + let from_kind = cx.typeck_results.expr_ty(from).peel_refs().kind(); // If the parent node's `to` argument is the same as the `to` argument // of the last replace call in the current chain, don't lint as it was already linted if let Some(parent) = get_parent_expr(cx, expr) && let Some((sym::replace, _, [current_from, current_to], _, _)) = method_call(parent) && eq_expr_value(cx, parent.span.ctxt(), to, current_to) - && from_kind == cx.typeck_results().expr_ty(current_from).peel_refs().kind() + && from_kind == cx.typeck_results.expr_ty(current_from).peel_refs().kind() { return; } @@ -49,7 +49,7 @@ fn collect_replace_calls<'tcx>( let ctxt = expr.span.ctxt(); let _: Option<()> = for_each_expr_without_closures(expr, |e| { if let Some((sym::replace, _, [from, to], _, _)) = method_call(e) { - if eq_expr_value(cx, ctxt, to_arg, to) && cx.typeck_results().expr_ty(from).peel_refs().is_char() { + if eq_expr_value(cx, ctxt, to_arg, to) && cx.typeck_results.expr_ty(from).peel_refs().is_char() { methods.push_front(e); from_args.push_front(from); ControlFlow::Continue(()) diff --git a/src/tools/clippy/clippy_lints/src/methods/double_ended_iterator_last.rs b/src/tools/clippy/clippy_lints/src/methods/double_ended_iterator_last.rs index 8ba8264b713c4..1e1b0f2803c05 100644 --- a/src/tools/clippy/clippy_lints/src/methods/double_ended_iterator_last.rs +++ b/src/tools/clippy/clippy_lints/src/methods/double_ended_iterator_last.rs @@ -11,13 +11,13 @@ use rustc_span::Span; use super::DOUBLE_ENDED_ITERATOR_LAST; pub(super) fn check(cx: &LateContext<'_>, expr: &'_ Expr<'_>, self_expr: &'_ Expr<'_>, call_span: Span) { - let typeck = cx.typeck_results(); + let typeck = cx.typeck_results; // if the "last" method is that of Iterator if cx.ty_based_def(expr).opt_parent(cx).is_diag_item(cx, sym::Iterator) // if self implements DoubleEndedIterator && let Some(deiter_id) = cx.tcx.get_diagnostic_item(sym::DoubleEndedIterator) - && let self_type = cx.typeck_results().expr_ty(self_expr) + && let self_type = cx.typeck_results.expr_ty(self_expr) && implements_trait(cx, self_type.peel_refs(), deiter_id, &[]) // resolve the method definition && let id = typeck.type_dependent_def_id(expr.hir_id).unwrap() @@ -28,7 +28,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &'_ Expr<'_>, self_expr: &'_ Exp && let Some(last_def) = cx.tcx.provided_trait_methods(item).find(|m| m.name() == sym::last) // if the resolved method is the same as the provided definition && fn_def.def_id() == last_def.def_id - && let self_ty = cx.typeck_results().expr_ty(self_expr) + && let self_ty = cx.typeck_results.expr_ty(self_expr) && !has_non_owning_mutable_access(cx, self_ty) { let mut sugg = vec![(call_span, String::from("next_back()"))]; @@ -55,7 +55,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &'_ Expr<'_>, self_expr: &'_ Exp expr.span, "called `Iterator::last` on a `DoubleEndedIterator`; this will needlessly iterate the entire iterator", |diag| { - let expr_ty = cx.typeck_results().expr_ty(expr); + let expr_ty = cx.typeck_results.expr_ty(expr); let droppable_elements = expr_ty.has_significant_drop(cx.tcx, cx.typing_env()); diag.multipart_suggestion( "try", diff --git a/src/tools/clippy/clippy_lints/src/methods/drain_collect.rs b/src/tools/clippy/clippy_lints/src/methods/drain_collect.rs index 6c222640e2601..32c521cc2f0be 100644 --- a/src/tools/clippy/clippy_lints/src/methods/drain_collect.rs +++ b/src/tools/clippy/clippy_lints/src/methods/drain_collect.rs @@ -49,8 +49,8 @@ fn check_collections(cx: &LateContext<'_>, expr: Ty<'_>, recv: Ty<'_>) -> Option } pub(super) fn check(cx: &LateContext<'_>, args: &[Expr<'_>], expr: &Expr<'_>, recv: &Expr<'_>) { - let expr_ty = cx.typeck_results().expr_ty(expr); - let recv_ty = cx.typeck_results().expr_ty(recv); + let expr_ty = cx.typeck_results.expr_ty(expr); + let recv_ty = cx.typeck_results.expr_ty(recv); let recv_ty_no_refs = recv_ty.peel_refs(); if let ExprKind::Path(QPath::Resolved(_, recv_path)) = recv.kind diff --git a/src/tools/clippy/clippy_lints/src/methods/err_expect.rs b/src/tools/clippy/clippy_lints/src/methods/err_expect.rs index 4353f6302c4b9..72e482e65c17e 100644 --- a/src/tools/clippy/clippy_lints/src/methods/err_expect.rs +++ b/src/tools/clippy/clippy_lints/src/methods/err_expect.rs @@ -16,7 +16,7 @@ pub(super) fn check( err_span: Span, msrv: Msrv, ) { - let result_ty = cx.typeck_results().expr_ty(recv); + let result_ty = cx.typeck_results.expr_ty(recv); // Grabs the `Result` type if let Some(data_type) = get_data_type(cx, result_ty) // Tests if the T type in a `Result` implements Debug diff --git a/src/tools/clippy/clippy_lints/src/methods/expect_fun_call.rs b/src/tools/clippy/clippy_lints/src/methods/expect_fun_call.rs index 89b37d507b702..20d0b6570a410 100644 --- a/src/tools/clippy/clippy_lints/src/methods/expect_fun_call.rs +++ b/src/tools/clippy/clippy_lints/src/methods/expect_fun_call.rs @@ -24,7 +24,7 @@ pub(super) fn check<'tcx>( ) { let arg_root = get_arg_root(cx, arg); if contains_call(cx, arg_root) && !contains_return(arg_root) { - let receiver_type = cx.typeck_results().expr_ty_adjusted(receiver); + let receiver_type = cx.typeck_results.expr_ty_adjusted(receiver); let closure_args = match receiver_type.opt_diag_name(cx) { Some(sym::Option) => "||", Some(sym::Result) => "|_|", @@ -76,7 +76,7 @@ fn get_arg_root<'a>(cx: &LateContext<'_>, arg: &'a hir::Expr<'a>) -> &'a hir::Ex loop { arg_root = match &arg_root.kind { hir::ExprKind::AddrOf(hir::BorrowKind::Ref, _, expr) => { - let expr_ty = cx.typeck_results().expr_ty(expr); + let expr_ty = cx.typeck_results.expr_ty(expr); if expr_ty.is_str() { break; } @@ -84,7 +84,7 @@ fn get_arg_root<'a>(cx: &LateContext<'_>, arg: &'a hir::Expr<'a>) -> &'a hir::Ex }, hir::ExprKind::MethodCall(method_name, receiver, [], ..) => { if (method_name.ident.name == sym::as_str || method_name.ident.name == sym::as_ref) && { - let arg_type = cx.typeck_results().expr_ty(receiver); + let arg_type = cx.typeck_results.expr_ty(receiver); let base_type = arg_type.peel_refs(); base_type.is_str() || base_type.is_lang_item(cx, hir::LangItem::String) } { diff --git a/src/tools/clippy/clippy_lints/src/methods/extend_with_drain.rs b/src/tools/clippy/clippy_lints/src/methods/extend_with_drain.rs index 829c1226a859e..cab4d16e59390 100644 --- a/src/tools/clippy/clippy_lints/src/methods/extend_with_drain.rs +++ b/src/tools/clippy/clippy_lints/src/methods/extend_with_drain.rs @@ -9,18 +9,18 @@ use rustc_lint::LateContext; use super::EXTEND_WITH_DRAIN; pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, arg: &Expr<'_>) { - let ty = cx.typeck_results().expr_ty(recv).peel_refs(); + let ty = cx.typeck_results.expr_ty(recv).peel_refs(); if ty.is_diag_item(cx, sym::Vec) //check source object && let ExprKind::MethodCall(src_method, drain_vec, [drain_arg], _) = &arg.kind && src_method.ident.name == sym::drain - && let src_ty = cx.typeck_results().expr_ty(drain_vec) + && let src_ty = cx.typeck_results.expr_ty(drain_vec) //check if actual src type is mutable for code suggestion && let immutable = src_ty.is_mutable_ptr() && let src_ty = src_ty.peel_refs() && src_ty.is_diag_item(cx, sym::Vec) //check drain range - && let src_ty_range = cx.typeck_results().expr_ty(drain_arg).peel_refs() + && let src_ty_range = cx.typeck_results.expr_ty(drain_arg).peel_refs() && src_ty_range.is_lang_item(cx, LangItem::RangeFull) { let mut applicability = Applicability::MachineApplicable; diff --git a/src/tools/clippy/clippy_lints/src/methods/filetype_is_file.rs b/src/tools/clippy/clippy_lints/src/methods/filetype_is_file.rs index 15f3adf3405e5..eb478345026f6 100644 --- a/src/tools/clippy/clippy_lints/src/methods/filetype_is_file.rs +++ b/src/tools/clippy/clippy_lints/src/methods/filetype_is_file.rs @@ -8,7 +8,7 @@ use rustc_span::Span; use super::FILETYPE_IS_FILE; pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>) { - let ty = cx.typeck_results().expr_ty(recv); + let ty = cx.typeck_results.expr_ty(recv); if !ty.is_diag_item(cx, sym::FileType) { return; diff --git a/src/tools/clippy/clippy_lints/src/methods/filter_map.rs b/src/tools/clippy/clippy_lints/src/methods/filter_map.rs index 9ddc3d1bf1d8e..d7c3dec960743 100644 --- a/src/tools/clippy/clippy_lints/src/methods/filter_map.rs +++ b/src/tools/clippy/clippy_lints/src/methods/filter_map.rs @@ -226,7 +226,7 @@ impl<'tcx> OffendingFilterExpr<'tcx> { fn hir(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, filter_param_id: HirId) -> Option { if let ExprKind::MethodCall(path, receiver, [], _) = expr.kind - && let Some(recv_ty) = cx.typeck_results().expr_ty(receiver).peel_refs().ty_adt_def() + && let Some(recv_ty) = cx.typeck_results.expr_ty(receiver).peel_refs().ty_adt_def() { // we still want to lint if the expression possibly contains side effects, // *but* it can't be machine-applicable then, because that can change the behavior of the program: @@ -271,7 +271,7 @@ fn is_filter_some_map_unwrap( map_arg: &Expr<'_>, ) -> bool { let iterator = cx.ty_based_def(expr).opt_parent(cx).is_diag_item(cx, sym::Iterator); - let option = cx.typeck_results().expr_ty(filter_recv).is_diag_item(cx, sym::Option); + let option = cx.typeck_results.expr_ty(filter_recv).is_diag_item(cx, sym::Option); (iterator || option) && is_option_filter_map(cx, filter_arg, map_arg) } @@ -345,7 +345,7 @@ pub(super) fn check( CalledMethod::ResultIsOk => (".ok()", String::new()), CalledMethod::OptionIsSome => { let derefs = cx - .typeck_results() + .typeck_results .expr_adjustments(map_arg) .iter() .filter(|adj| matches!(adj.kind, Adjust::Deref(_))) diff --git a/src/tools/clippy/clippy_lints/src/methods/filter_map_bool_then.rs b/src/tools/clippy/clippy_lints/src/methods/filter_map_bool_then.rs index 8e5b271212e67..d1f48e330fbb5 100644 --- a/src/tools/clippy/clippy_lints/src/methods/filter_map_bool_then.rs +++ b/src/tools/clippy/clippy_lints/src/methods/filter_map_bool_then.rs @@ -27,7 +27,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, arg: & && let param_ty = cx.tcx.liberate_late_bound_regions( closure.def_id.to_def_id(), Binder::bind_with_vars( - cx.typeck_results().node_type(param_ty.hir_id), + cx.typeck_results.node_type(param_ty.hir_id), cx.tcx.late_bound_vars(cx.tcx.local_def_id_to_hir_id(closure.def_id)), ), ) @@ -35,11 +35,11 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, arg: & && let ExprKind::MethodCall(_, recv, [then_arg], _) = value.kind && let ExprKind::Closure(then_closure) = then_arg.kind && let then_body = peel_blocks(cx.tcx.hir_body(then_closure.body).value) - && let Some(def_id) = cx.typeck_results().type_dependent_def_id(value.hir_id) + && let Some(def_id) = cx.typeck_results.type_dependent_def_id(value.hir_id) && cx.tcx.is_diagnostic_item(sym::bool_then, def_id) && !is_from_proc_macro(cx, expr) // Count the number of derefs needed to get to the bool because we need those in the suggestion - && let needed_derefs = cx.typeck_results().expr_adjustments(recv) + && let needed_derefs = cx.typeck_results.expr_adjustments(recv) .iter() .filter(|adj| matches!(adj.kind, Adjust::Deref(_))) .count() diff --git a/src/tools/clippy/clippy_lints/src/methods/filter_next.rs b/src/tools/clippy/clippy_lints/src/methods/filter_next.rs index 9c6b16b88bfd1..92e6cdd101c32 100644 --- a/src/tools/clippy/clippy_lints/src/methods/filter_next.rs +++ b/src/tools/clippy/clippy_lints/src/methods/filter_next.rs @@ -33,7 +33,7 @@ pub(super) fn check<'tcx>( if !cx .tcx .get_diagnostic_item(required_trait) - .is_some_and(|id| implements_trait(cx, cx.typeck_results().expr_ty(recv), id, &[])) + .is_some_and(|id| implements_trait(cx, cx.typeck_results.expr_ty(recv), id, &[])) { return; } diff --git a/src/tools/clippy/clippy_lints/src/methods/flat_map_option.rs b/src/tools/clippy/clippy_lints/src/methods/flat_map_option.rs index fb0e8f9d91b5a..e11b8a200e9c8 100644 --- a/src/tools/clippy/clippy_lints/src/methods/flat_map_option.rs +++ b/src/tools/clippy/clippy_lints/src/methods/flat_map_option.rs @@ -12,7 +12,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>, arg if !cx.ty_based_def(expr).opt_parent(cx).is_diag_item(cx, sym::Iterator) { return; } - let arg_ty = cx.typeck_results().expr_ty_adjusted(arg); + let arg_ty = cx.typeck_results.expr_ty_adjusted(arg); let sig = match arg_ty.kind() { ty::Closure(_, args) => args.as_closure().sig(), _ if arg_ty.is_fn() => arg_ty.fn_sig(cx.tcx), diff --git a/src/tools/clippy/clippy_lints/src/methods/format_collect.rs b/src/tools/clippy/clippy_lints/src/methods/format_collect.rs index 7b2fe00d32188..fc7c39cb98780 100644 --- a/src/tools/clippy/clippy_lints/src/methods/format_collect.rs +++ b/src/tools/clippy/clippy_lints/src/methods/format_collect.rs @@ -17,7 +17,7 @@ fn peel_non_expn_blocks<'tcx>(expr: &'tcx Expr<'tcx>) -> Option<&'tcx Expr<'tcx> } pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, map_arg: &Expr<'_>, map_span: Span) { - if cx.typeck_results().expr_ty(expr).is_lang_item(cx, LangItem::String) + if cx.typeck_results.expr_ty(expr).is_lang_item(cx, LangItem::String) && let ExprKind::Closure(closure) = map_arg.kind && let body = cx.tcx.hir_body(closure.body) && let Some(value) = peel_non_expn_blocks(body.value) diff --git a/src/tools/clippy/clippy_lints/src/methods/get_first.rs b/src/tools/clippy/clippy_lints/src/methods/get_first.rs index c3598eb59478a..f0e3fc8c6631a 100644 --- a/src/tools/clippy/clippy_lints/src/methods/get_first.rs +++ b/src/tools/clippy/clippy_lints/src/methods/get_first.rs @@ -17,7 +17,7 @@ pub(super) fn check<'tcx>( recv: &'tcx hir::Expr<'_>, arg: &'tcx hir::Expr<'_>, ) { - if let Some(method_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) + if let Some(method_id) = cx.typeck_results.type_dependent_def_id(expr.hir_id) && let Some(impl_id) = cx.tcx.impl_of_assoc(method_id) && let identity = cx.tcx.type_of(impl_id).instantiate_identity().skip_norm_wip() && let hir::ExprKind::Lit(Spanned { diff --git a/src/tools/clippy/clippy_lints/src/methods/get_last_with_len.rs b/src/tools/clippy/clippy_lints/src/methods/get_last_with_len.rs index bdf8eb3045e07..ce05705d3fde1 100644 --- a/src/tools/clippy/clippy_lints/src/methods/get_last_with_len.rs +++ b/src/tools/clippy/clippy_lints/src/methods/get_last_with_len.rs @@ -30,7 +30,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, arg: && SpanlessEq::new(cx).eq_expr(expr.span.ctxt(), recv, lhs_recv) && !recv.can_have_side_effects() { - let method = match cx.typeck_results().expr_ty_adjusted(recv).peel_refs().kind() { + let method = match cx.typeck_results.expr_ty_adjusted(recv).peel_refs().kind() { ty::Adt(def, _) if cx.tcx.is_diagnostic_item(sym::VecDeque, def.did()) => "back", ty::Slice(_) => "last", _ => return, diff --git a/src/tools/clippy/clippy_lints/src/methods/get_unwrap.rs b/src/tools/clippy/clippy_lints/src/methods/get_unwrap.rs index 676f1b13b16e2..ddfe0df176727 100644 --- a/src/tools/clippy/clippy_lints/src/methods/get_unwrap.rs +++ b/src/tools/clippy/clippy_lints/src/methods/get_unwrap.rs @@ -17,7 +17,7 @@ pub(super) fn check<'tcx>( ) { // Note: we don't want to lint `get_mut().unwrap` for `HashMap` or `BTreeMap`, // because they do not implement `IndexMut` - let expr_ty = cx.typeck_results().expr_ty(recv); + let expr_ty = cx.typeck_results.expr_ty(recv); let caller_type = if derefs_to_slice(cx, recv, expr_ty).is_some() { "slice" } else { diff --git a/src/tools/clippy/clippy_lints/src/methods/implicit_clone.rs b/src/tools/clippy/clippy_lints/src/methods/implicit_clone.rs index 768612d6bbdc1..72fc57ade9da1 100644 --- a/src/tools/clippy/clippy_lints/src/methods/implicit_clone.rs +++ b/src/tools/clippy/clippy_lints/src/methods/implicit_clone.rs @@ -11,10 +11,10 @@ use rustc_span::Symbol; use super::IMPLICIT_CLONE; pub fn check(cx: &LateContext<'_>, method_name: Symbol, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>) { - if let Some(method_parent_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id).opt_parent(cx) + if let Some(method_parent_id) = cx.typeck_results.type_dependent_def_id(expr.hir_id).opt_parent(cx) && is_clone_like(cx, method_name, method_parent_id) - && let return_type = cx.typeck_results().expr_ty(expr) - && let input_type = cx.typeck_results().expr_ty(recv) + && let return_type = cx.typeck_results.expr_ty(expr) + && let input_type = cx.typeck_results.expr_ty(recv) && let (input_type, ref_count, _) = peel_and_count_ty_refs(input_type) && !(ref_count > 0 && method_parent_id.is_diag_item(cx, sym::ToOwned)) && let Some(ty_name) = input_type.ty_adt_def().map(|adt_def| cx.tcx.item_name(adt_def.did())) diff --git a/src/tools/clippy/clippy_lints/src/methods/inefficient_to_string.rs b/src/tools/clippy/clippy_lints/src/methods/inefficient_to_string.rs index 374639985bee0..2e572634cb72e 100644 --- a/src/tools/clippy/clippy_lints/src/methods/inefficient_to_string.rs +++ b/src/tools/clippy/clippy_lints/src/methods/inefficient_to_string.rs @@ -12,10 +12,10 @@ use rustc_middle::ty::{self, Ty}; use super::INEFFICIENT_TO_STRING; pub fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, receiver: &hir::Expr<'_>, msrv: Msrv) { - if let Some(to_string_meth_did) = cx.typeck_results().type_dependent_def_id(expr.hir_id) + if let Some(to_string_meth_did) = cx.typeck_results.type_dependent_def_id(expr.hir_id) && cx.tcx.is_diagnostic_item(sym::to_string_method, to_string_meth_did) - && let Some(args) = cx.typeck_results().node_args_opt(expr.hir_id) - && let arg_ty = cx.typeck_results().expr_ty_adjusted(receiver) + && let Some(args) = cx.typeck_results.node_args_opt(expr.hir_id) + && let arg_ty = cx.typeck_results.expr_ty_adjusted(receiver) && let self_ty = args.type_at(0) && let (deref_self_ty, deref_count, _) = peel_and_count_ty_refs(self_ty) && deref_count >= 1 diff --git a/src/tools/clippy/clippy_lints/src/methods/into_iter_on_ref.rs b/src/tools/clippy/clippy_lints/src/methods/into_iter_on_ref.rs index 5a062732721e5..dd9c18f4ba245 100644 --- a/src/tools/clippy/clippy_lints/src/methods/into_iter_on_ref.rs +++ b/src/tools/clippy/clippy_lints/src/methods/into_iter_on_ref.rs @@ -11,7 +11,7 @@ use rustc_span::symbol::{Symbol, sym}; use super::INTO_ITER_ON_REF; pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, method_span: Span, receiver: &hir::Expr<'_>) { - let self_ty = cx.typeck_results().expr_ty_adjusted(receiver); + let self_ty = cx.typeck_results.expr_ty_adjusted(receiver); if let ty::Ref(..) = self_ty.kind() && cx.ty_based_def(expr).opt_parent(cx).is_diag_item(cx, sym::IntoIterator) && let Some((kind, method_name)) = ty_has_iter_method(cx, self_ty) diff --git a/src/tools/clippy/clippy_lints/src/methods/is_digit_ascii_radix.rs b/src/tools/clippy/clippy_lints/src/methods/is_digit_ascii_radix.rs index 2aeb6f42d05cd..d3cac7541e7cf 100644 --- a/src/tools/clippy/clippy_lints/src/methods/is_digit_ascii_radix.rs +++ b/src/tools/clippy/clippy_lints/src/methods/is_digit_ascii_radix.rs @@ -14,7 +14,7 @@ pub(super) fn check<'tcx>( radix: &'tcx Expr<'_>, msrv: Msrv, ) { - if !cx.typeck_results().expr_ty_adjusted(self_arg).peel_refs().is_char() { + if !cx.typeck_results.expr_ty_adjusted(self_arg).peel_refs().is_char() { return; } diff --git a/src/tools/clippy/clippy_lints/src/methods/is_empty.rs b/src/tools/clippy/clippy_lints/src/methods/is_empty.rs index cfda39ed08ff1..544264832756e 100644 --- a/src/tools/clippy/clippy_lints/src/methods/is_empty.rs +++ b/src/tools/clippy/clippy_lints/src/methods/is_empty.rs @@ -48,7 +48,7 @@ fn expr_or_init<'a, 'b, 'tcx: 'b>(cx: &LateContext<'tcx>, mut expr: &'a Expr<'b> while let Some(init) = expr .res_local_id() .and_then(|id| find_binding_init(cx, id)) - .filter(|init| cx.typeck_results().expr_adjustments(init).is_empty()) + .filter(|init| cx.typeck_results.expr_adjustments(init).is_empty()) .filter(|init| !is_under_cfg(cx, init.hir_id)) { expr = init; diff --git a/src/tools/clippy/clippy_lints/src/methods/iter_cloned_collect.rs b/src/tools/clippy/clippy_lints/src/methods/iter_cloned_collect.rs index 484d00e94f450..a5523c385303a 100644 --- a/src/tools/clippy/clippy_lints/src/methods/iter_cloned_collect.rs +++ b/src/tools/clippy/clippy_lints/src/methods/iter_cloned_collect.rs @@ -11,10 +11,10 @@ use rustc_span::{Symbol, sym}; use super::ITER_CLONED_COLLECT; pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, method_name: Symbol, expr: &Expr<'_>, recv: &'tcx Expr<'_>) { - let expr_ty = cx.typeck_results().expr_ty(expr); + let expr_ty = cx.typeck_results.expr_ty(expr); if let ty::Adt(def, args) = expr_ty.kind() && def.is_diag_item(cx, sym::Vec) - && let recv_ty = cx.typeck_results().expr_ty(recv) + && let recv_ty = cx.typeck_results.expr_ty(recv) && let Some(slice) = derefs_to_slice(cx, recv, recv_ty) && let Some(iter_item_ty) = get_iterator_item_ty(cx, recv_ty) && let ty::Ref(_, iter_item_ty, _) = iter_item_ty.kind() diff --git a/src/tools/clippy/clippy_lints/src/methods/iter_count.rs b/src/tools/clippy/clippy_lints/src/methods/iter_count.rs index 18278446bf610..1bf311ad6af3c 100644 --- a/src/tools/clippy/clippy_lints/src/methods/iter_count.rs +++ b/src/tools/clippy/clippy_lints/src/methods/iter_count.rs @@ -11,7 +11,7 @@ use rustc_span::Symbol; use super::ITER_COUNT; pub(crate) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, recv: &'tcx Expr<'tcx>, iter_method: Symbol) { - let ty = cx.typeck_results().expr_ty(recv); + let ty = cx.typeck_results.expr_ty(recv); let caller_type = match ty.opt_diag_name(cx) { _ if derefs_to_slice(cx, recv, ty).is_some() => "slice", Some(sym::Vec) => "Vec", diff --git a/src/tools/clippy/clippy_lints/src/methods/iter_filter.rs b/src/tools/clippy/clippy_lints/src/methods/iter_filter.rs index 3aa666145b86a..fe479d975de87 100644 --- a/src/tools/clippy/clippy_lints/src/methods/iter_filter.rs +++ b/src/tools/clippy/clippy_lints/src/methods/iter_filter.rs @@ -86,7 +86,7 @@ fn is_method( false }, ExprKind::Path(QPath::TypeRelative(ty, mname)) => { - let ty = cx.typeck_results().node_type(ty.hir_id); + let ty = cx.typeck_results.node_type(ty.hir_id); if let Some(did) = cx.tcx.get_diagnostic_item(type_symbol) && ty.ty_adt_def() == cx.tcx.type_of(did).skip_binder().ty_adt_def() { @@ -149,7 +149,7 @@ fn expression_type( return None; } if let ExprKind::MethodCall(_, receiver, _, _) = expr.kind - && let receiver_ty = cx.typeck_results().expr_ty(receiver) + && let receiver_ty = cx.typeck_results.expr_ty(receiver) && let Some(iter_item_ty) = get_iterator_item_ty(cx, receiver_ty) { if let Some(opt_defid) = cx.tcx.get_diagnostic_item(sym::Option) diff --git a/src/tools/clippy/clippy_lints/src/methods/iter_kv_map.rs b/src/tools/clippy/clippy_lints/src/methods/iter_kv_map.rs index 283b9b5fc5b4c..948d9d6b7dcf5 100644 --- a/src/tools/clippy/clippy_lints/src/methods/iter_kv_map.rs +++ b/src/tools/clippy/clippy_lints/src/methods/iter_kv_map.rs @@ -38,7 +38,7 @@ pub(super) fn check<'tcx>( (PatKind::Binding(ann, _, key, _), value) if pat_is_wild(cx, value, m_arg) => ("key", ann, key), _ => return, } - && let ty = cx.typeck_results().expr_ty_adjusted(recv).peel_refs() + && let ty = cx.typeck_results.expr_ty_adjusted(recv).peel_refs() && matches!(ty.opt_diag_name(cx), Some(sym::HashMap | sym::BTreeMap)) { let mut applicability = rustc_errors::Applicability::MachineApplicable; diff --git a/src/tools/clippy/clippy_lints/src/methods/iter_next_slice.rs b/src/tools/clippy/clippy_lints/src/methods/iter_next_slice.rs index 4d1a4343c03c3..1a6a0646020ff 100644 --- a/src/tools/clippy/clippy_lints/src/methods/iter_next_slice.rs +++ b/src/tools/clippy/clippy_lints/src/methods/iter_next_slice.rs @@ -32,7 +32,7 @@ pub(super) fn check<'tcx>( } else { "first" }; - if derefs_to_slice(cx, caller_expr, cx.typeck_results().expr_ty(caller_expr)).is_some() { + if derefs_to_slice(cx, caller_expr, cx.typeck_results.expr_ty(caller_expr)).is_some() { // caller is a Slice if let hir::ExprKind::Index(caller_var, index_expr, _) = &caller_expr.kind && let Some(higher::Range { @@ -87,6 +87,6 @@ pub(super) fn check<'tcx>( } fn is_vec_or_array<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'_>) -> bool { - cx.typeck_results().expr_ty(expr).is_diag_item(cx, sym::Vec) - || matches!(&cx.typeck_results().expr_ty(expr).peel_refs().kind(), ty::Array(_, _)) + cx.typeck_results.expr_ty(expr).is_diag_item(cx, sym::Vec) + || matches!(&cx.typeck_results.expr_ty(expr).peel_refs().kind(), ty::Array(_, _)) } diff --git a/src/tools/clippy/clippy_lints/src/methods/iter_nth.rs b/src/tools/clippy/clippy_lints/src/methods/iter_nth.rs index 6d1ee32e50269..aadccfbf5dc4c 100644 --- a/src/tools/clippy/clippy_lints/src/methods/iter_nth.rs +++ b/src/tools/clippy/clippy_lints/src/methods/iter_nth.rs @@ -16,10 +16,10 @@ pub(super) fn check<'tcx>( iter_span: Span, nth_span: Span, ) -> bool { - let caller_type = match cx.typeck_results().expr_ty(iter_recv).peel_refs().opt_diag_name(cx) { + let caller_type = match cx.typeck_results.expr_ty(iter_recv).peel_refs().opt_diag_name(cx) { Some(sym::Vec) => "`Vec`", Some(sym::VecDeque) => "`VecDeque`", - _ if cx.typeck_results().expr_ty_adjusted(iter_recv).peel_refs().is_slice() => "slice", + _ if cx.typeck_results.expr_ty_adjusted(iter_recv).peel_refs().is_slice() => "slice", // caller is not a type that we want to lint _ => return false, }; diff --git a/src/tools/clippy/clippy_lints/src/methods/iter_on_single_or_empty_collections.rs b/src/tools/clippy/clippy_lints/src/methods/iter_on_single_or_empty_collections.rs index a69671faae783..1d38b91467f77 100644 --- a/src/tools/clippy/clippy_lints/src/methods/iter_on_single_or_empty_collections.rs +++ b/src/tools/clippy/clippy_lints/src/methods/iter_on_single_or_empty_collections.rs @@ -84,7 +84,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, method expr_sig(cx, recv).is_some_and(|fn_sig| is_arg_ty_unified_in_fn(cx, fn_sig, child_id, args, false)) }, ExprKind::MethodCall(_name, recv, args, _span) => cx - .typeck_results() + .typeck_results .type_dependent_def_id(parent.hir_id) .and_then(|def_id| ty_sig(cx, cx.tcx.type_of(def_id).instantiate_identity().skip_norm_wip())) .is_some_and(|fn_sig| { diff --git a/src/tools/clippy/clippy_lints/src/methods/iter_out_of_bounds.rs b/src/tools/clippy/clippy_lints/src/methods/iter_out_of_bounds.rs index b0e805815bc9b..3c9471ac9cc48 100644 --- a/src/tools/clippy/clippy_lints/src/methods/iter_out_of_bounds.rs +++ b/src/tools/clippy/clippy_lints/src/methods/iter_out_of_bounds.rs @@ -21,7 +21,7 @@ fn expr_as_u128(cx: &LateContext<'_>, e: &Expr<'_>) -> Option { /// Attempts to extract the length out of an iterator expression. fn get_iterator_length<'tcx>(cx: &LateContext<'tcx>, iter: &'tcx Expr<'tcx>) -> Option { - let ty::Adt(adt, substs) = cx.typeck_results().expr_ty(iter).kind() else { + let ty::Adt(adt, substs) = cx.typeck_results.expr_ty(iter).kind() else { return None; }; @@ -32,7 +32,7 @@ fn get_iterator_length<'tcx>(cx: &LateContext<'tcx>, iter: &'tcx Expr<'tcx>) -> substs.const_at(1).try_to_target_usize(cx.tcx).map(u128::from) }, Some(sym::SliceIter) if let ExprKind::MethodCall(_, recv, ..) = iter.kind => { - if let ty::Array(_, len) = cx.typeck_results().expr_ty(recv).peel_refs().kind() { + if let ty::Array(_, len) = cx.typeck_results.expr_ty(recv).peel_refs().kind() { // For slice::Iter<'_, T>, the receiver might be an array literal: [1,2,3].iter().skip(..) len.try_to_target_usize(cx.tcx).map(u128::from) } else { diff --git a/src/tools/clippy/clippy_lints/src/methods/iter_overeager_cloned.rs b/src/tools/clippy/clippy_lints/src/methods/iter_overeager_cloned.rs index 241791e57c8e6..a0c2fd92d105c 100644 --- a/src/tools/clippy/clippy_lints/src/methods/iter_overeager_cloned.rs +++ b/src/tools/clippy/clippy_lints/src/methods/iter_overeager_cloned.rs @@ -42,7 +42,7 @@ pub(super) fn check<'tcx>( op: Op<'tcx>, needs_into_iter: bool, ) { - let typeck = cx.typeck_results(); + let typeck = cx.typeck_results; if let Some(iter_id) = cx.tcx.get_diagnostic_item(sym::Iterator) && let Some(method_id) = typeck.type_dependent_def_id(expr.hir_id) && cx.tcx.trait_of_assoc(method_id) == Some(iter_id) diff --git a/src/tools/clippy/clippy_lints/src/methods/iter_with_drain.rs b/src/tools/clippy/clippy_lints/src/methods/iter_with_drain.rs index 8d1585baac451..530bdce53e043 100644 --- a/src/tools/clippy/clippy_lints/src/methods/iter_with_drain.rs +++ b/src/tools/clippy/clippy_lints/src/methods/iter_with_drain.rs @@ -9,7 +9,7 @@ use super::ITER_WITH_DRAIN; pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, span: Span, arg: &Expr<'_>) { if !matches!(recv.kind, ExprKind::Field(..)) - && let Some(adt) = cx.typeck_results().expr_ty(recv).ty_adt_def() + && let Some(adt) = cx.typeck_results.expr_ty(recv).ty_adt_def() && let Some(ty_name) = cx.tcx.get_diagnostic_name(adt.did()) && matches!(ty_name, sym::Vec | sym::VecDeque) && let ExprKind::Path(QPath::Resolved(None, container_path)) = recv.kind diff --git a/src/tools/clippy/clippy_lints/src/methods/join_absolute_paths.rs b/src/tools/clippy/clippy_lints/src/methods/join_absolute_paths.rs index fe3ca632d6e35..f21f9b3022f70 100644 --- a/src/tools/clippy/clippy_lints/src/methods/join_absolute_paths.rs +++ b/src/tools/clippy/clippy_lints/src/methods/join_absolute_paths.rs @@ -11,7 +11,7 @@ use rustc_span::Span; use super::JOIN_ABSOLUTE_PATHS; pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, recv: &'tcx Expr<'tcx>, join_arg: &'tcx Expr<'tcx>, expr_span: Span) { - let ty = cx.typeck_results().expr_ty(recv).peel_refs(); + let ty = cx.typeck_results.expr_ty(recv).peel_refs(); if matches!(ty.opt_diag_name(cx), Some(sym::Path | sym::PathBuf)) && let ExprKind::Lit(spanned) = expr_or_init(cx, join_arg).kind && let LitKind::Str(symbol, style) = spanned.node diff --git a/src/tools/clippy/clippy_lints/src/methods/lines_filter_map_ok.rs b/src/tools/clippy/clippy_lints/src/methods/lines_filter_map_ok.rs index baf5b6f93f637..46107e2937665 100644 --- a/src/tools/clippy/clippy_lints/src/methods/lines_filter_map_ok.rs +++ b/src/tools/clippy/clippy_lints/src/methods/lines_filter_map_ok.rs @@ -12,7 +12,7 @@ use super::LINES_FILTER_MAP_OK; pub(super) fn check_flatten(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, call_span: Span, msrv: Msrv) { if cx.ty_based_def(expr).opt_parent(cx).is_diag_item(cx, sym::Iterator) && cx - .typeck_results() + .typeck_results .expr_ty_adjusted(recv) .is_diag_item(cx, sym::IoLines) && msrv.meets(cx, msrvs::MAP_WHILE) @@ -32,7 +32,7 @@ pub(super) fn check_filter_or_flat_map( ) { if cx.ty_based_def(expr).opt_parent(cx).is_diag_item(cx, sym::Iterator) && cx - .typeck_results() + .typeck_results .expr_ty_adjusted(recv) .is_diag_item(cx, sym::IoLines) && match method_arg.kind { diff --git a/src/tools/clippy/clippy_lints/src/methods/manual_clear.rs b/src/tools/clippy/clippy_lints/src/methods/manual_clear.rs index dbf1c85add55d..9eac4e5861ef9 100644 --- a/src/tools/clippy/clippy_lints/src/methods/manual_clear.rs +++ b/src/tools/clippy/clippy_lints/src/methods/manual_clear.rs @@ -9,7 +9,7 @@ use rustc_span::Span; use super::MANUAL_CLEAR; pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, arg: &Expr<'_>, method_span: Span) { - let ty = cx.typeck_results().expr_ty_adjusted(recv); + let ty = cx.typeck_results.expr_ty_adjusted(recv); let ty = ty.peel_refs(); let diag_name = ty.ty_adt_def().and_then(|def| cx.tcx.get_diagnostic_name(def.did())); diff --git a/src/tools/clippy/clippy_lints/src/methods/manual_contains.rs b/src/tools/clippy/clippy_lints/src/methods/manual_contains.rs index f1d399e1bbd2f..1eceafc9d819e 100644 --- a/src/tools/clippy/clippy_lints/src/methods/manual_contains.rs +++ b/src/tools/clippy/clippy_lints/src/methods/manual_contains.rs @@ -23,10 +23,10 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, clos && let ExprKind::Binary(op, lhs, rhs) = value.kind && let (peeled_ref_pat, _) = peel_hir_pat_refs(param.pat) && let Some((snip,snip_expr)) = can_replace_with_contains(cx, op, lhs, rhs, peeled_ref_pat.hir_id, &mut app) - && let ref_type = cx.typeck_results().expr_ty_adjusted(recv) + && let ref_type = cx.typeck_results.expr_ty_adjusted(recv) && let ty::Ref(_, inner_type, _) = ref_type.kind() && let ty::Slice(slice_type) = inner_type.kind() - && *slice_type == cx.typeck_results().expr_ty(snip_expr) + && *slice_type == cx.typeck_results.expr_ty(snip_expr) { span_lint_and_sugg( cx, diff --git a/src/tools/clippy/clippy_lints/src/methods/manual_inspect.rs b/src/tools/clippy/clippy_lints/src/methods/manual_inspect.rs index a89a656a6bc7e..2be600140efd2 100644 --- a/src/tools/clippy/clippy_lints/src/methods/manual_inspect.rs +++ b/src/tools/clippy/clippy_lints/src/methods/manual_inspect.rs @@ -18,7 +18,7 @@ use super::MANUAL_INSPECT; pub(crate) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, arg: &Expr<'_>, name: Symbol, name_span: Span, msrv: Msrv) { if let ExprKind::Closure(c) = arg.kind && matches!(c.kind, ClosureKind::Closure) - && let typeck = cx.typeck_results() + && let typeck = cx.typeck_results && let Some(fn_def) = typeck.type_dependent_def(expr.hir_id) && (fn_def.opt_parent(cx).is_diag_item(cx, sym::Iterator) || ((fn_def.opt_parent(cx).opt_impl_ty(cx).is_diag_item(cx, sym::Option) @@ -210,7 +210,7 @@ enum UseKind<'tcx> { /// Checks how the value is used, and whether it was used in the same `SyntaxContext`. fn check_use<'tcx>(cx: &LateContext<'tcx>, ctxt: SyntaxContext, e: &'tcx Expr<'_>) -> (UseKind<'tcx>, bool) { - let use_cx = get_expr_use_site(cx.tcx, cx.typeck_results(), ctxt, e); + let use_cx = get_expr_use_site(cx.tcx, cx.typeck_results, ctxt, e); if use_cx .adjustments .first() diff --git a/src/tools/clippy/clippy_lints/src/methods/manual_is_variant_and.rs b/src/tools/clippy/clippy_lints/src/methods/manual_is_variant_and.rs index df209a1671509..b33e1293b9b3c 100644 --- a/src/tools/clippy/clippy_lints/src/methods/manual_is_variant_and.rs +++ b/src/tools/clippy/clippy_lints/src/methods/manual_is_variant_and.rs @@ -61,7 +61,7 @@ pub(super) fn check_map_unwrap_or_default( } // 2. the caller of `map()` is neither `Option` nor `Result` - let Some(flavor) = (cx.typeck_results()) + let Some(flavor) = (cx.typeck_results) .expr_ty(map_recv) .opt_def_id() .and_then(|did| Flavor::new(cx, did)) @@ -70,7 +70,7 @@ pub(super) fn check_map_unwrap_or_default( }; // 3. the caller of `unwrap_or_default` is neither `Option` nor `Result` - if !cx.typeck_results().expr_ty(expr).is_bool() { + if !cx.typeck_results.expr_ty(expr).is_bool() { return; } @@ -215,11 +215,11 @@ pub(super) fn check_map(cx: &LateContext<'_>, expr: &Expr<'_>) { && let ExprKind::Path(QPath::Resolved(_, path)) = call.kind && let Res::Def(DefKind::Ctor(CtorOf::Variant, CtorKind::Fn), _) = path.res && let ExprKind::MethodCall(_, recv, [map_expr], _) = expr2.kind - && let ty = cx.typeck_results().expr_ty(expr1) + && let ty = cx.typeck_results.expr_ty(expr1) && let ty::Adt(adt, args) = ty.kind() && let Some(flavor) = Flavor::new(cx, adt.did()) && args.type_at(0).is_bool() - && cx.typeck_results().expr_ty(recv).is_diag_item(cx, flavor.diag_sym()) + && cx.typeck_results.expr_ty(recv).is_diag_item(cx, flavor.diag_sym()) && let Ok(map_func) = MapFunc::try_from(map_expr) { emit_lint(cx, parent_expr.span, op, flavor, bool_cst, map_func, recv); @@ -247,12 +247,12 @@ pub(super) fn check_or<'tcx>( && none_path.ident.name == sym::is_none && some_path.ident.name == sym::is_some_and && cx - .typeck_results() + .typeck_results .expr_ty_adjusted(none_recv) .peel_refs() .is_diag_item(cx, sym::Option) && cx - .typeck_results() + .typeck_results .expr_ty_adjusted(some_recv) .peel_refs() .is_diag_item(cx, sym::Option) @@ -300,7 +300,7 @@ pub(super) fn check_is_some_is_none<'tcx>( msrv: Msrv, ) { if cx - .typeck_results() + .typeck_results .expr_ty_adjusted(recv) .peel_refs() .is_diag_item(cx, sym::Option) diff --git a/src/tools/clippy/clippy_lints/src/methods/manual_next_back.rs b/src/tools/clippy/clippy_lints/src/methods/manual_next_back.rs index 221c7f08c923c..3973fe1c79b46 100644 --- a/src/tools/clippy/clippy_lints/src/methods/manual_next_back.rs +++ b/src/tools/clippy/clippy_lints/src/methods/manual_next_back.rs @@ -12,7 +12,7 @@ pub(super) fn check<'tcx>( rev_call: &'tcx Expr<'_>, rev_recv: &'tcx Expr<'_>, ) { - let rev_recv_ty = cx.typeck_results().expr_ty(rev_recv); + let rev_recv_ty = cx.typeck_results.expr_ty(rev_recv); // check that the receiver of `rev` implements `DoubleEndedIterator` and // that `rev` and `next` come from `Iterator` diff --git a/src/tools/clippy/clippy_lints/src/methods/manual_ok_or.rs b/src/tools/clippy/clippy_lints/src/methods/manual_ok_or.rs index 48f2c10f97cc6..1ed2c9369102e 100644 --- a/src/tools/clippy/clippy_lints/src/methods/manual_ok_or.rs +++ b/src/tools/clippy/clippy_lints/src/methods/manual_ok_or.rs @@ -16,7 +16,7 @@ pub(super) fn check<'tcx>( or_expr: &'tcx Expr<'_>, map_expr: &'tcx Expr<'_>, ) { - if let Some(method_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) + if let Some(method_id) = cx.typeck_results.type_dependent_def_id(expr.hir_id) && let Some(impl_id) = cx.tcx.impl_of_assoc(method_id) && cx .tcx diff --git a/src/tools/clippy/clippy_lints/src/methods/manual_option_zip.rs b/src/tools/clippy/clippy_lints/src/methods/manual_option_zip.rs index aa23b9deff45b..7f231c1f9796d 100644 --- a/src/tools/clippy/clippy_lints/src/methods/manual_option_zip.rs +++ b/src/tools/clippy/clippy_lints/src/methods/manual_option_zip.rs @@ -24,11 +24,11 @@ pub(super) fn check<'tcx>( if let ExprKind::Closure(&hir::Closure { body: outer_body_id, .. }) = arg.kind && let hir::Body { params: [outer_param], value: outer_value, .. } = cx.tcx.hir_body(outer_body_id) && let PatKind::Binding(_, outer_param_id, _, None) = outer_param.pat.kind - && cx.typeck_results().expr_ty(recv).is_diag_item(cx, sym::Option) + && cx.typeck_results.expr_ty(recv).is_diag_item(cx, sym::Option) // `b.map(|b| ...)` && let ExprKind::MethodCall(method_path, map_recv, [map_arg], _) = peel_blocks(outer_value).kind && method_path.ident.name == sym::map - && cx.typeck_results().expr_ty(map_recv).is_diag_item(cx, sym::Option) + && cx.typeck_results.expr_ty(map_recv).is_diag_item(cx, sym::Option) // `b` does not reference the outer closure parameter `a`. && !local_used_in(cx, outer_param_id, map_recv) // `|b| (a, b)` diff --git a/src/tools/clippy/clippy_lints/src/methods/manual_repeat_n.rs b/src/tools/clippy/clippy_lints/src/methods/manual_repeat_n.rs index 6f65fc48b38af..e5f8ff5686713 100644 --- a/src/tools/clippy/clippy_lints/src/methods/manual_repeat_n.rs +++ b/src/tools/clippy/clippy_lints/src/methods/manual_repeat_n.rs @@ -21,7 +21,7 @@ pub(super) fn check<'tcx>( && let ExprKind::Call(_, [repeat_arg]) = repeat_expr.kind && let Some(def_id) = fn_def_id(cx, repeat_expr) && cx.tcx.is_diagnostic_item(sym::iter_repeat, def_id) - && !get_expr_use_site(cx.tcx, cx.typeck_results(), expr.span.ctxt(), expr).is_ty_unified + && !get_expr_use_site(cx.tcx, cx.typeck_results, expr.span.ctxt(), expr).is_ty_unified && let Some(std_or_core) = std_or_core(cx) && msrv.meets(cx, msrvs::REPEAT_N) { diff --git a/src/tools/clippy/clippy_lints/src/methods/manual_saturating_arithmetic.rs b/src/tools/clippy/clippy_lints/src/methods/manual_saturating_arithmetic.rs index a3dd967bd77a9..e6f01e93608da 100644 --- a/src/tools/clippy/clippy_lints/src/methods/manual_saturating_arithmetic.rs +++ b/src/tools/clippy/clippy_lints/src/methods/manual_saturating_arithmetic.rs @@ -19,7 +19,7 @@ pub fn check_unwrap_or( unwrap_arg: &Expr<'_>, arith: Symbol, ) { - let ty = cx.typeck_results().expr_ty(arith_lhs); + let ty = cx.typeck_results.expr_ty(arith_lhs); if !ty.is_integral() { return; } @@ -41,7 +41,7 @@ pub(super) fn check_sub_unwrap_or_default( arith_lhs: &Expr<'_>, arith_rhs: &Expr<'_>, ) { - let ty = cx.typeck_results().expr_ty(arith_lhs); + let ty = cx.typeck_results.expr_ty(arith_lhs); if !ty.is_integral() { return; } @@ -149,7 +149,7 @@ fn is_min_or_max(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option { } } - let ty = cx.typeck_results().expr_ty(expr); + let ty = cx.typeck_results.expr_ty(expr); // `T::MAX` and `T::MIN` constants if let hir::ExprKind::Path(hir::QPath::TypeRelative(base, seg)) = expr.kind diff --git a/src/tools/clippy/clippy_lints/src/methods/manual_str_repeat.rs b/src/tools/clippy/clippy_lints/src/methods/manual_str_repeat.rs index 457549d1091c0..fa1cf01f9625f 100644 --- a/src/tools/clippy/clippy_lints/src/methods/manual_str_repeat.rs +++ b/src/tools/clippy/clippy_lints/src/methods/manual_str_repeat.rs @@ -33,7 +33,7 @@ fn parse_repeat_arg(cx: &LateContext<'_>, e: &Expr<'_>) -> Option { _ => None, } } else { - let ty = cx.typeck_results().expr_ty(e); + let ty = cx.typeck_results.expr_ty(e); if ty.is_lang_item(cx, LangItem::String) || (ty.is_lang_item(cx, LangItem::OwnedBox) && get_ty_param(ty).is_some_and(Ty::is_str)) || (ty.is_diag_item(cx, sym::Cow) && get_ty_param(ty).is_some_and(Ty::is_str)) @@ -56,10 +56,10 @@ pub(super) fn check( if let ExprKind::Call(repeat_fn, [repeat_arg]) = take_self_arg.kind && repeat_fn.basic_res().is_diag_item(cx, sym::iter_repeat) && cx - .typeck_results() + .typeck_results .expr_ty(collect_expr) .is_lang_item(cx, LangItem::String) - && let Some(take_id) = cx.typeck_results().type_dependent_def_id(take_expr.hir_id) + && let Some(take_id) = cx.typeck_results.type_dependent_def_id(take_expr.hir_id) && let Some(iter_trait_id) = cx.tcx.get_diagnostic_item(sym::Iterator) && cx.tcx.trait_of_assoc(take_id) == Some(iter_trait_id) && let Some(repeat_kind) = parse_repeat_arg(cx, repeat_arg) diff --git a/src/tools/clippy/clippy_lints/src/methods/manual_try_fold.rs b/src/tools/clippy/clippy_lints/src/methods/manual_try_fold.rs index 5f5944d5d4230..7768b6f601a41 100644 --- a/src/tools/clippy/clippy_lints/src/methods/manual_try_fold.rs +++ b/src/tools/clippy/clippy_lints/src/methods/manual_try_fold.rs @@ -22,7 +22,7 @@ pub(super) fn check<'tcx>( ) { if !fold_span.in_external_macro(cx.sess().source_map()) && cx.ty_based_def(expr).opt_parent(cx).is_diag_item(cx, sym::Iterator) - && let init_ty = cx.typeck_results().expr_ty(init) + && let init_ty = cx.typeck_results.expr_ty(init) && let Some(try_trait) = cx.tcx.lang_items().try_trait() && implements_trait(cx, init_ty, try_trait, &[]) && let ExprKind::Call(path, [first, rest @ ..]) = init.kind diff --git a/src/tools/clippy/clippy_lints/src/methods/map_clone.rs b/src/tools/clippy/clippy_lints/src/methods/map_clone.rs index efbb094d49c79..8f3b1f754643e 100644 --- a/src/tools/clippy/clippy_lints/src/methods/map_clone.rs +++ b/src/tools/clippy/clippy_lints/src/methods/map_clone.rs @@ -42,7 +42,7 @@ fn should_run_lint(cx: &LateContext<'_>, e: &hir::Expr<'_>, method_parent_id: De } pub(super) fn check(cx: &LateContext<'_>, e: &hir::Expr<'_>, recv: &hir::Expr<'_>, arg: &hir::Expr<'_>, msrv: Msrv) { - if let Some(parent_id) = cx.typeck_results().type_dependent_def_id(e.hir_id).opt_parent(cx) + if let Some(parent_id) = cx.typeck_results.type_dependent_def_id(e.hir_id).opt_parent(cx) && should_run_lint(cx, e, parent_id) { match arg.kind { @@ -61,21 +61,21 @@ pub(super) fn check(cx: &LateContext<'_>, e: &hir::Expr<'_>, recv: &hir::Expr<'_ match closure_expr.kind { hir::ExprKind::Unary(hir::UnOp::Deref, inner) => { if ident_eq(name, inner) - && let ty::Ref(.., Mutability::Not) = cx.typeck_results().expr_ty(inner).kind() + && let ty::Ref(.., Mutability::Not) = cx.typeck_results.expr_ty(inner).kind() { lint_explicit_closure(cx, e.span, recv.span, true, msrv); } }, hir::ExprKind::MethodCall(method, obj, [], _) => { if ident_eq(name, obj) && method.ident.name == sym::clone - && let Some(fn_id) = cx.typeck_results().type_dependent_def_id(closure_expr.hir_id) + && let Some(fn_id) = cx.typeck_results.type_dependent_def_id(closure_expr.hir_id) && let Some(trait_id) = cx.tcx.trait_of_assoc(fn_id) && cx.tcx.lang_items().clone_trait() == Some(trait_id) // no autoderefs - && !cx.typeck_results().expr_adjustments(obj).iter() + && !cx.typeck_results.expr_adjustments(obj).iter() .any(|a| matches!(a.kind, Adjust::Deref(DerefAdjustKind::Overloaded(..)))) { - let obj_ty = cx.typeck_results().expr_ty(obj); + let obj_ty = cx.typeck_results.expr_ty(obj); if let ty::Ref(_, ty, mutability) = obj_ty.kind() { if matches!(mutability, Mutability::Not) { let copy = is_copy(cx, *ty); @@ -116,11 +116,11 @@ fn handle_path( && cx.tcx.lang_items().get(LangItem::CloneFn) == Some(path_def_id) // The `copied` and `cloned` methods are only available on `&T` and `&mut T` in `Option` // and `Result`. - && let ty::Adt(_, args) = cx.typeck_results().expr_ty(recv).kind() + && let ty::Adt(_, args) = cx.typeck_results.expr_ty(recv).kind() && let args = args.as_slice() && let Some(ty) = args.iter().find_map(|generic_arg| generic_arg.as_type()) && let ty::Ref(_, ty, Mutability::Not) = ty.kind() - && let ty::FnDef(_, lst) = cx.typeck_results().expr_ty(arg).kind() + && let ty::FnDef(_, lst) = cx.typeck_results.expr_ty(arg).kind() && lst.iter().all(|l| l.as_type() == Some(*ty)) && !should_call_clone_as_function(cx, *ty) { diff --git a/src/tools/clippy/clippy_lints/src/methods/map_collect_result_unit.rs b/src/tools/clippy/clippy_lints/src/methods/map_collect_result_unit.rs index 1112fbc2a1c74..5c3234c40c4cf 100644 --- a/src/tools/clippy/clippy_lints/src/methods/map_collect_result_unit.rs +++ b/src/tools/clippy/clippy_lints/src/methods/map_collect_result_unit.rs @@ -11,7 +11,7 @@ use super::MAP_COLLECT_RESULT_UNIT; pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, iter: &hir::Expr<'_>, map_fn: &hir::Expr<'_>) { // return of collect `Result<(),_>` - let collect_ret_ty = cx.typeck_results().expr_ty(expr); + let collect_ret_ty = cx.typeck_results.expr_ty(expr); if collect_ret_ty.is_diag_item(cx, sym::Result) && let ty::Adt(_, args) = collect_ret_ty.kind() && let Some(result_t) = args.types().next() diff --git a/src/tools/clippy/clippy_lints/src/methods/map_err_ignore.rs b/src/tools/clippy/clippy_lints/src/methods/map_err_ignore.rs index 96b8b9dc03227..fb4b66ebfce7e 100644 --- a/src/tools/clippy/clippy_lints/src/methods/map_err_ignore.rs +++ b/src/tools/clippy/clippy_lints/src/methods/map_err_ignore.rs @@ -7,7 +7,7 @@ use rustc_span::sym; use super::MAP_ERR_IGNORE; pub(super) fn check(cx: &LateContext<'_>, e: &Expr<'_>, arg: &Expr<'_>) { - if let Some(method_id) = cx.typeck_results().type_dependent_def_id(e.hir_id) + if let Some(method_id) = cx.typeck_results.type_dependent_def_id(e.hir_id) && let Some(impl_id) = cx.tcx.impl_of_assoc(method_id) && cx .tcx diff --git a/src/tools/clippy/clippy_lints/src/methods/map_flatten.rs b/src/tools/clippy/clippy_lints/src/methods/map_flatten.rs index b654548cc2050..c00bc2bc0817a 100644 --- a/src/tools/clippy/clippy_lints/src/methods/map_flatten.rs +++ b/src/tools/clippy/clippy_lints/src/methods/map_flatten.rs @@ -49,7 +49,7 @@ fn try_get_caller_ty_name_and_method_name( Some(("Iterator", "flat_map")) } } else { - if let ty::Adt(adt, _) = cx.typeck_results().expr_ty(caller_expr).kind() { + if let ty::Adt(adt, _) = cx.typeck_results.expr_ty(caller_expr).kind() { match cx.tcx.get_diagnostic_name(adt.did()) { Some(sym::Option) => return Some(("Option", "and_then")), Some(sym::Result) => return Some(("Result", "and_then")), @@ -61,7 +61,7 @@ fn try_get_caller_ty_name_and_method_name( } fn is_map_to_option(cx: &LateContext<'_>, map_arg: &Expr<'_>) -> bool { - let map_closure_ty = cx.typeck_results().expr_ty(map_arg); + let map_closure_ty = cx.typeck_results.expr_ty(map_arg); match map_closure_ty.kind() { ty::Closure(_, _) | ty::FnDef(_, _) | ty::FnPtr(..) => { let map_closure_sig = match map_closure_ty.kind() { diff --git a/src/tools/clippy/clippy_lints/src/methods/map_identity.rs b/src/tools/clippy/clippy_lints/src/methods/map_identity.rs index fa394526bdf1e..d842a82af28d7 100644 --- a/src/tools/clippy/clippy_lints/src/methods/map_identity.rs +++ b/src/tools/clippy/clippy_lints/src/methods/map_identity.rs @@ -20,7 +20,7 @@ pub(super) fn check( name: Symbol, _map_span: Span, ) { - let caller_ty = cx.typeck_results().expr_ty(caller); + let caller_ty = cx.typeck_results.expr_ty(caller); if (cx.ty_based_def(expr).opt_parent(cx).is_diag_item(cx, sym::Iterator) || caller_ty.is_diag_item(cx, sym::Result) @@ -39,7 +39,7 @@ pub(super) fn check( Applicability::MachineApplicable }; - let needs_to_be_mutable = cx.typeck_results().expr_ty_adjusted(expr).is_mutable_ptr(); + let needs_to_be_mutable = cx.typeck_results.expr_ty_adjusted(expr).is_mutable_ptr(); if needs_to_be_mutable && !is_mutable(cx, caller) { if let Some(hir_id) = path_to_local_with_projections(caller) && let Node::Pat(pat) = cx.tcx.hir_node(hir_id) diff --git a/src/tools/clippy/clippy_lints/src/methods/map_or_identity.rs b/src/tools/clippy/clippy_lints/src/methods/map_or_identity.rs index e4e5fa5420105..1463c6a24f836 100644 --- a/src/tools/clippy/clippy_lints/src/methods/map_or_identity.rs +++ b/src/tools/clippy/clippy_lints/src/methods/map_or_identity.rs @@ -21,7 +21,7 @@ pub(super) fn check( ) { // lint if the caller of `map_or()` is a `Result` or an `Option` // and if the mapping function is the identity function - if let Some(symbol @ (sym::Result | sym::Option)) = cx.typeck_results().expr_ty_adjusted(recv).opt_diag_name(cx) + if let Some(symbol @ (sym::Result | sym::Option)) = cx.typeck_results.expr_ty_adjusted(recv).opt_diag_name(cx) && is_expr_identity_function(cx, map_arg) { let msg = format!("expression can be simplified using `{symbol}::unwrap_or()`"); diff --git a/src/tools/clippy/clippy_lints/src/methods/map_unwrap_or.rs b/src/tools/clippy/clippy_lints/src/methods/map_unwrap_or.rs index ac2f991804865..8237a31a04733 100644 --- a/src/tools/clippy/clippy_lints/src/methods/map_unwrap_or.rs +++ b/src/tools/clippy/clippy_lints/src/methods/map_unwrap_or.rs @@ -27,14 +27,14 @@ pub(super) fn check<'tcx>( map_span: Span, msrv: Msrv, ) { - let recv_ty = cx.typeck_results().expr_ty(recv).peel_refs(); + let recv_ty = cx.typeck_results.expr_ty(recv).peel_refs(); let recv_ty_kind = match recv_ty.opt_diag_name(cx) { Some(sym::Option) => sym::Option, Some(sym::Result) if msrv.meets(cx, msrvs::RESULT_MAP_OR) => sym::Result, _ => return, }; - let unwrap_arg_ty = cx.typeck_results().expr_ty(unwrap_arg); + let unwrap_arg_ty = cx.typeck_results.expr_ty(unwrap_arg); if !is_copy(cx, unwrap_arg_ty) { // Replacing `.map().unwrap_or()` with `.map_or(, )` can sometimes lead to // borrowck errors, see #10579 for one such instance. @@ -130,7 +130,7 @@ pub(super) fn check<'tcx>( (SuggestedKind::IsVariantAnd, sym::Option) => "is_some_and", (SuggestedKind::Other, _) if unwrap_arg_ty.peel_refs().is_array() - && cx.typeck_results().expr_ty_adjusted(unwrap_arg).peel_refs().is_slice() => + && cx.typeck_results.expr_ty_adjusted(unwrap_arg).peel_refs().is_slice() => { return; }, diff --git a/src/tools/clippy/clippy_lints/src/methods/map_unwrap_or_else.rs b/src/tools/clippy/clippy_lints/src/methods/map_unwrap_or_else.rs index 8bb532b21635a..05df44df4851a 100644 --- a/src/tools/clippy/clippy_lints/src/methods/map_unwrap_or_else.rs +++ b/src/tools/clippy/clippy_lints/src/methods/map_unwrap_or_else.rs @@ -21,7 +21,7 @@ pub(super) fn check<'tcx>( unwrap_arg: &'tcx hir::Expr<'_>, msrv: Msrv, ) -> bool { - let recv_ty = cx.typeck_results().expr_ty(recv).peel_refs(); + let recv_ty = cx.typeck_results.expr_ty(recv).peel_refs(); let recv_ty_kind = match recv_ty.opt_diag_name(cx) { Some(sym::Option) => sym::Option, Some(sym::Result) if msrv.meets(cx, msrvs::RESULT_MAP_OR_ELSE) => sym::Result, diff --git a/src/tools/clippy/clippy_lints/src/methods/mut_mutex_lock.rs b/src/tools/clippy/clippy_lints/src/methods/mut_mutex_lock.rs index c9264e747b56d..1a8c94d1739f3 100644 --- a/src/tools/clippy/clippy_lints/src/methods/mut_mutex_lock.rs +++ b/src/tools/clippy/clippy_lints/src/methods/mut_mutex_lock.rs @@ -11,8 +11,8 @@ use super::MUT_MUTEX_LOCK; pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, ex: &'tcx Expr<'tcx>, recv: &'tcx Expr<'tcx>, name_span: Span) { if matches!(expr_custom_deref_adjustment(cx, recv), None | Some(Mutability::Mut)) - && let (_, _, Some(Mutability::Mut)) = peel_and_count_ty_refs(cx.typeck_results().expr_ty(recv)) - && let Some(method_id) = cx.typeck_results().type_dependent_def_id(ex.hir_id) + && let (_, _, Some(Mutability::Mut)) = peel_and_count_ty_refs(cx.typeck_results.expr_ty(recv)) + && let Some(method_id) = cx.typeck_results.type_dependent_def_id(ex.hir_id) && let Some(impl_id) = cx.tcx.impl_of_assoc(method_id) && cx.tcx.type_of(impl_id).is_diag_item(cx, sym::Mutex) { diff --git a/src/tools/clippy/clippy_lints/src/methods/needless_as_bytes.rs b/src/tools/clippy/clippy_lints/src/methods/needless_as_bytes.rs index 22baad40b4496..973c59fcd73df 100644 --- a/src/tools/clippy/clippy_lints/src/methods/needless_as_bytes.rs +++ b/src/tools/clippy/clippy_lints/src/methods/needless_as_bytes.rs @@ -9,7 +9,7 @@ use rustc_span::{Span, Symbol}; use super::NEEDLESS_AS_BYTES; pub fn check(cx: &LateContext<'_>, prev_method: Symbol, method: Symbol, prev_recv: &Expr<'_>, span: Span) { - let ty1 = cx.typeck_results().expr_ty_adjusted(prev_recv).peel_refs(); + let ty1 = cx.typeck_results.expr_ty_adjusted(prev_recv).peel_refs(); if ty1.is_lang_item(cx, LangItem::String) || ty1.is_str() { let mut app = Applicability::MachineApplicable; let sugg = Sugg::hir_with_context(cx, prev_recv, span.ctxt(), "..", &mut app); diff --git a/src/tools/clippy/clippy_lints/src/methods/needless_character_iteration.rs b/src/tools/clippy/clippy_lints/src/methods/needless_character_iteration.rs index 948ed8a25746e..d383de711f79d 100644 --- a/src/tools/clippy/clippy_lints/src/methods/needless_character_iteration.rs +++ b/src/tools/clippy/clippy_lints/src/methods/needless_character_iteration.rs @@ -34,7 +34,7 @@ fn handle_expr( if revert != is_all && method.ident.name == sym::is_ascii && receiver.res_local_id() == Some(first_param) - && let char_arg_ty = cx.typeck_results().expr_ty_adjusted(receiver).peel_refs() + && let char_arg_ty = cx.typeck_results.expr_ty_adjusted(receiver).peel_refs() && *char_arg_ty.kind() == ty::Char && let Some(snippet) = before_chars.get_source_text(cx) { @@ -101,7 +101,7 @@ pub(super) fn check(cx: &LateContext<'_>, call_expr: &Expr<'_>, recv: &Expr<'_>, && let Some(first_param) = body.params.first() && let ExprKind::MethodCall(method, mut recv, [], _) = recv.kind && method.ident.name == sym::chars - && let str_ty = cx.typeck_results().expr_ty_adjusted(recv).peel_refs() + && let str_ty = cx.typeck_results.expr_ty_adjusted(recv).peel_refs() && *str_ty.kind() == ty::Str { let expr_start = recv.span; diff --git a/src/tools/clippy/clippy_lints/src/methods/needless_collect.rs b/src/tools/clippy/clippy_lints/src/methods/needless_collect.rs index 4f281d745a94e..517bd69ec2240 100644 --- a/src/tools/clippy/clippy_lints/src/methods/needless_collect.rs +++ b/src/tools/clippy/clippy_lints/src/methods/needless_collect.rs @@ -30,7 +30,7 @@ pub(super) fn check<'tcx>( iter_expr: &'tcx Expr<'tcx>, call_span: Span, ) { - let iter_ty = cx.typeck_results().expr_ty(iter_expr); + let iter_ty = cx.typeck_results.expr_ty(iter_expr); if has_non_owning_mutable_access(cx, iter_ty) { return; // don't lint if the iterator has side effects } @@ -44,7 +44,7 @@ pub(super) fn check<'tcx>( if let ExprKind::MethodCall(name, _, args @ ([] | [_]), _) = parent.kind { app = Applicability::MachineApplicable; - let collect_ty = cx.typeck_results().expr_ty(collect_expr); + let collect_ty = cx.typeck_results.expr_ty(collect_expr); sugg = match name.ident.name { sym::len => { @@ -61,7 +61,7 @@ pub(super) fn check<'tcx>( }, sym::is_empty if is_is_empty_sig(cx, parent.hir_id) - && iterates_same_ty(cx, cx.typeck_results().expr_ty(iter_expr), collect_ty) => + && iterates_same_ty(cx, cx.typeck_results.expr_ty(iter_expr), collect_ty) => { "next().is_none()".into() }, @@ -83,7 +83,7 @@ pub(super) fn check<'tcx>( _ => return, }; } else if let ExprKind::Index(_, index, _) = parent.kind - && cx.typeck_results().expr_ty(index).is_usize() + && cx.typeck_results.expr_ty(index).is_usize() { app = Applicability::MaybeIncorrect; let snip = snippet_with_applicability(cx, index.span, "_", &mut app); @@ -104,9 +104,9 @@ pub(super) fn check<'tcx>( }, Node::LetStmt(l) => { if let PatKind::Binding(BindingMode::NONE | BindingMode::MUT, id, _, None) = l.pat.kind - && let ty = cx.typeck_results().expr_ty(collect_expr) + && let ty = cx.typeck_results.expr_ty(collect_expr) && let Some(extra_spec) = ty.opt_diag_name(cx).and_then(ExtraFunctionSpec::new) - && let iter_ty = cx.typeck_results().expr_ty(iter_expr) + && let iter_ty = cx.typeck_results.expr_ty(iter_expr) && let Some(block) = get_enclosing_block(cx, l.hir_id) && let Some((iter_calls, extra_calls)) = detect_iter_and_into_iters(block, id, cx, get_captured_ids(cx, iter_ty), extra_spec) @@ -232,7 +232,7 @@ fn check_collect_into_intoiterator<'tcx>( /// Checks if the given method call matches the expected signature of `([&[mut]] self) -> bool` fn is_is_empty_sig(cx: &LateContext<'_>, call_id: HirId) -> bool { - cx.typeck_results().type_dependent_def_id(call_id).is_some_and(|id| { + cx.typeck_results.type_dependent_def_id(call_id).is_some_and(|id| { let sig = cx.tcx.fn_sig(id).instantiate_identity().skip_norm_wip().skip_binder(); sig.inputs().len() == 1 && sig.output().is_bool() }) @@ -263,7 +263,7 @@ fn iterates_same_ty<'tcx>(cx: &LateContext<'tcx>, iter_ty: Ty<'tcx>, collect_ty: /// Checks if the given method call matches the expected signature of /// `([&[mut]] self, &::Item) -> bool` fn is_contains_sig(cx: &LateContext<'_>, call_id: HirId, iter_expr: &Expr<'_>) -> bool { - let typeck = cx.typeck_results(); + let typeck = cx.typeck_results; if let Some(id) = typeck.type_dependent_def_id(call_id) && let sig = cx.tcx.fn_sig(id).instantiate_identity().skip_norm_wip() && sig.skip_binder().output().is_bool() @@ -287,7 +287,7 @@ fn is_contains_sig(cx: &LateContext<'_>, call_id: HirId, iter_expr: &Expr<'_>) - { item_ty == EarlyBinder::bind(search_ty) - .instantiate(cx.tcx, cx.typeck_results().node_args(call_id)) + .instantiate(cx.tcx, cx.typeck_results.node_args(call_id)) .skip_norm_wip() } else { false @@ -485,7 +485,7 @@ impl<'tcx> Visitor<'tcx> for IterFunctionVisitor<'_, 'tcx> { .opt_parent(self.cx) .is_diag_item(self.cx, sym::Iterator) { - self.current_mutably_captured_ids = get_captured_ids(self.cx, self.cx.typeck_results().expr_ty(recv)); + self.current_mutably_captured_ids = get_captured_ids(self.cx, self.cx.typeck_results.expr_ty(recv)); self.visit_expr(recv); return; } @@ -636,7 +636,7 @@ fn check_loop_kind<'tcx>(expr: &Expr<'tcx>) -> Option> { impl<'tcx> IterFunctionVisitor<'_, 'tcx> { fn visit_block_expr(&mut self, expr: &'tcx Expr<'tcx>, hir_id: Option) { self.current_statement_hir_id = hir_id; - self.current_mutably_captured_ids = get_captured_ids(self.cx, self.cx.typeck_results().expr_ty(expr)); + self.current_mutably_captured_ids = get_captured_ids(self.cx, self.cx.typeck_results.expr_ty(expr)); self.visit_expr(expr); } } diff --git a/src/tools/clippy/clippy_lints/src/methods/needless_option_as_deref.rs b/src/tools/clippy/clippy_lints/src/methods/needless_option_as_deref.rs index 06e6a3c70b87d..0b0e2eaa94f62 100644 --- a/src/tools/clippy/clippy_lints/src/methods/needless_option_as_deref.rs +++ b/src/tools/clippy/clippy_lints/src/methods/needless_option_as_deref.rs @@ -12,7 +12,7 @@ use rustc_span::Symbol; use super::NEEDLESS_OPTION_AS_DEREF; pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, name: Symbol) { - let typeck = cx.typeck_results(); + let typeck = cx.typeck_results; let outer_ty = typeck.expr_ty(expr); if outer_ty.is_diag_item(cx, sym::Option) && outer_ty == typeck.expr_ty(recv) { diff --git a/src/tools/clippy/clippy_lints/src/methods/needless_option_take.rs b/src/tools/clippy/clippy_lints/src/methods/needless_option_take.rs index 1622fdb88bd53..d2648d423d92f 100644 --- a/src/tools/clippy/clippy_lints/src/methods/needless_option_take.rs +++ b/src/tools/clippy/clippy_lints/src/methods/needless_option_take.rs @@ -34,7 +34,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, recv: &' } fn is_expr_option(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool { - let expr_type = cx.typeck_results().expr_ty(expr); + let expr_type = cx.typeck_results.expr_ty(expr); expr_type.is_diag_item(cx, sym::Option) } diff --git a/src/tools/clippy/clippy_lints/src/methods/no_effect_replace.rs b/src/tools/clippy/clippy_lints/src/methods/no_effect_replace.rs index 2afda2956beb6..60a96ec1fed66 100644 --- a/src/tools/clippy/clippy_lints/src/methods/no_effect_replace.rs +++ b/src/tools/clippy/clippy_lints/src/methods/no_effect_replace.rs @@ -13,7 +13,7 @@ pub(super) fn check<'tcx>( arg1: &'tcx rustc_hir::Expr<'_>, arg2: &'tcx rustc_hir::Expr<'_>, ) { - let ty = cx.typeck_results().expr_ty(expr).peel_refs(); + let ty = cx.typeck_results.expr_ty(expr).peel_refs(); if !(ty.is_str() || ty.is_lang_item(cx, LangItem::String)) { return; } diff --git a/src/tools/clippy/clippy_lints/src/methods/obfuscated_if_else.rs b/src/tools/clippy/clippy_lints/src/methods/obfuscated_if_else.rs index 69d851e816005..8f1f1b7c497bc 100644 --- a/src/tools/clippy/clippy_lints/src/methods/obfuscated_if_else.rs +++ b/src/tools/clippy/clippy_lints/src/methods/obfuscated_if_else.rs @@ -18,7 +18,7 @@ pub(super) fn check<'tcx>( then_method_name: Symbol, unwrap: Unwrap<'tcx>, ) { - let recv_ty = cx.typeck_results().expr_ty(then_recv); + let recv_ty = cx.typeck_results.expr_ty(then_recv); if recv_ty.is_bool() { let then_eager = switch_to_eager_eval(cx, then_arg); diff --git a/src/tools/clippy/clippy_lints/src/methods/ok_expect.rs b/src/tools/clippy/clippy_lints/src/methods/ok_expect.rs index 5f1cae130daed..2f844a9518072 100644 --- a/src/tools/clippy/clippy_lints/src/methods/ok_expect.rs +++ b/src/tools/clippy/clippy_lints/src/methods/ok_expect.rs @@ -10,7 +10,7 @@ use super::OK_EXPECT; /// lint use of `ok().expect()` for `Result`s pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>, recv_inner: &hir::Expr<'_>) { - let result_ty = cx.typeck_results().expr_ty(recv_inner); + let result_ty = cx.typeck_results.expr_ty(recv_inner); // lint if the caller of `ok()` is a `Result` if let Some(error_type) = get_error_type(cx, result_ty) && has_debug_impl(cx, error_type) diff --git a/src/tools/clippy/clippy_lints/src/methods/open_options.rs b/src/tools/clippy/clippy_lints/src/methods/open_options.rs index 3ce28e41e6b78..675613938f8b5 100644 --- a/src/tools/clippy/clippy_lints/src/methods/open_options.rs +++ b/src/tools/clippy/clippy_lints/src/methods/open_options.rs @@ -16,7 +16,7 @@ fn is_open_options(cx: &LateContext<'_>, ty: Ty<'_>) -> bool { } pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>, recv: &'tcx Expr<'_>) { - if let Some(method_id) = cx.typeck_results().type_dependent_def_id(e.hir_id) + if let Some(method_id) = cx.typeck_results.type_dependent_def_id(e.hir_id) && let Some(impl_id) = cx.tcx.impl_of_assoc(method_id) && is_open_options(cx, cx.tcx.type_of(impl_id).instantiate_identity().skip_norm_wip()) { @@ -64,7 +64,7 @@ fn get_open_options( options: &mut Vec<(OpenOption, Argument, Span)>, ) -> bool { if let ExprKind::MethodCall(path, receiver, arguments, span) = argument.kind { - let obj_ty = cx.typeck_results().expr_ty(receiver).peel_refs(); + let obj_ty = cx.typeck_results.expr_ty(receiver).peel_refs(); // Only proceed if this is a call on some object of type std::fs::OpenOptions if !arguments.is_empty() && is_open_options(cx, obj_ty) { @@ -109,7 +109,7 @@ fn get_open_options( // Avoid linting altogether if this method is from a trait. // This might be a user defined extension trait with a method like `truncate_write` // which would be a false positive - if let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(argument.hir_id) + if let Some(method_def_id) = cx.typeck_results.type_dependent_def_id(argument.hir_id) && cx.tcx.trait_of_assoc(method_def_id).is_some() { return false; diff --git a/src/tools/clippy/clippy_lints/src/methods/option_as_ref_cloned.rs b/src/tools/clippy/clippy_lints/src/methods/option_as_ref_cloned.rs index 156c624488eba..3fb148116cdc9 100644 --- a/src/tools/clippy/clippy_lints/src/methods/option_as_ref_cloned.rs +++ b/src/tools/clippy/clippy_lints/src/methods/option_as_ref_cloned.rs @@ -16,7 +16,7 @@ pub(super) fn check( as_ref_ident_span: Span, ) { if cx - .typeck_results() + .typeck_results .expr_ty(as_ref_recv) .peel_refs() .is_diag_item(cx, sym::Option) diff --git a/src/tools/clippy/clippy_lints/src/methods/option_as_ref_deref.rs b/src/tools/clippy/clippy_lints/src/methods/option_as_ref_deref.rs index a52f3c1be26e9..f7dc8404578ed 100644 --- a/src/tools/clippy/clippy_lints/src/methods/option_as_ref_deref.rs +++ b/src/tools/clippy/clippy_lints/src/methods/option_as_ref_deref.rs @@ -22,7 +22,7 @@ pub(super) fn check( ) { let same_mutability = |m| (is_mut && m == &hir::Mutability::Mut) || (!is_mut && m == &hir::Mutability::Not); - let option_ty = cx.typeck_results().expr_ty(as_ref_recv); + let option_ty = cx.typeck_results.expr_ty(as_ref_recv); if !option_ty.is_diag_item(cx, sym::Option) { return; } @@ -53,7 +53,7 @@ pub(super) fn check( hir::ExprKind::MethodCall(_, receiver, [], _) => { if receiver.res_local_id() == Some(closure_body.params[0].pat.hir_id) && let adj = cx - .typeck_results() + .typeck_results .expr_adjustments(receiver) .iter() .map(|x| &x.kind) @@ -62,7 +62,7 @@ pub(super) fn check( ty::adjustment::Adjust::Deref(ty::adjustment::DerefAdjustKind::Builtin), ty::adjustment::Adjust::Borrow(_), ] = *adj - && let method_did = cx.typeck_results().type_dependent_def_id(closure_expr.hir_id).unwrap() + && let method_did = cx.typeck_results.type_dependent_def_id(closure_expr.hir_id).unwrap() && let Some(method_name) = cx.tcx.get_diagnostic_name(method_did) { matches!(method_name, sym::deref_method | sym::deref_mut_method) diff --git a/src/tools/clippy/clippy_lints/src/methods/option_map_or_none.rs b/src/tools/clippy/clippy_lints/src/methods/option_map_or_none.rs index 817388915f189..cdfd2babdf799 100644 --- a/src/tools/clippy/clippy_lints/src/methods/option_map_or_none.rs +++ b/src/tools/clippy/clippy_lints/src/methods/option_map_or_none.rs @@ -37,8 +37,8 @@ pub(super) fn check<'tcx>( def_arg: &'tcx hir::Expr<'_>, map_arg: &'tcx hir::Expr<'_>, ) { - let is_option = cx.typeck_results().expr_ty(recv).is_diag_item(cx, sym::Option); - let is_result = cx.typeck_results().expr_ty(recv).is_diag_item(cx, sym::Result); + let is_option = cx.typeck_results.expr_ty(recv).is_diag_item(cx, sym::Option); + let is_result = cx.typeck_results.expr_ty(recv).is_diag_item(cx, sym::Result); // There are two variants of this `map_or` lint: // (1) using `map_or` as an adapter from `Result` to `Option` diff --git a/src/tools/clippy/clippy_lints/src/methods/or_fun_call.rs b/src/tools/clippy/clippy_lints/src/methods/or_fun_call.rs index a07cd5a8925ae..c8d8584dfaf27 100644 --- a/src/tools/clippy/clippy_lints/src/methods/or_fun_call.rs +++ b/src/tools/clippy/clippy_lints/src/methods/or_fun_call.rs @@ -112,7 +112,7 @@ fn check_unwrap_or_default( method_span: Span, msrv: Msrv, ) -> bool { - let receiver_ty = cx.typeck_results().expr_ty_adjusted(receiver).peel_refs(); + let receiver_ty = cx.typeck_results.expr_ty_adjusted(receiver).peel_refs(); // Check MSRV, but only for `Result::unwrap_or_default` if receiver_ty.is_diag_item(cx, sym::Result) && !msrv.meets(cx, msrvs::RESULT_UNWRAP_OR_DEFAULT) { @@ -133,7 +133,7 @@ fn check_unwrap_or_default( }; let output_type_implements_default = |fun| { - let fun_ty = cx.typeck_results().expr_ty(fun); + let fun_ty = cx.typeck_results.expr_ty(fun); if let ty::FnDef(def_id, args) = *fun_ty.kind() { let output_ty = cx .tcx @@ -244,7 +244,7 @@ fn check_or_fn_call<'tcx>( if KNOW_TYPES.iter().any(|k| k.2.contains(&name)) && switch_to_lazy_eval(cx, arg) && !contains_return(arg) - && let self_ty = cx.typeck_results().expr_ty(self_expr) + && let self_ty = cx.typeck_results.expr_ty(self_expr) && let Some(&(_, fn_has_arguments, _, suffix)) = KNOW_TYPES .iter() .find(|&&i| self_ty.is_diag_item(cx, i.0) && i.2.contains(&name)) diff --git a/src/tools/clippy/clippy_lints/src/methods/or_then_unwrap.rs b/src/tools/clippy/clippy_lints/src/methods/or_then_unwrap.rs index 448ab621a7ce6..bc2368fc3aad7 100644 --- a/src/tools/clippy/clippy_lints/src/methods/or_then_unwrap.rs +++ b/src/tools/clippy/clippy_lints/src/methods/or_then_unwrap.rs @@ -16,7 +16,7 @@ pub(super) fn check<'tcx>( or_arg: &'tcx Expr<'_>, or_span: Span, ) { - let ty = cx.typeck_results().expr_ty(recv); // get type of x (we later check if it's Option or Result) + let ty = cx.typeck_results.expr_ty(recv); // get type of x (we later check if it's Option or Result) let title; let or_arg_content: Span; diff --git a/src/tools/clippy/clippy_lints/src/methods/path_buf_push_overwrite.rs b/src/tools/clippy/clippy_lints/src/methods/path_buf_push_overwrite.rs index 923e4ea4dd975..de0425332f1e6 100644 --- a/src/tools/clippy/clippy_lints/src/methods/path_buf_push_overwrite.rs +++ b/src/tools/clippy/clippy_lints/src/methods/path_buf_push_overwrite.rs @@ -10,7 +10,7 @@ use std::path::{Component, Path}; use super::PATH_BUF_PUSH_OVERWRITE; pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, arg: &'tcx Expr<'_>) { - if let Some(method_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) + if let Some(method_id) = cx.typeck_results.type_dependent_def_id(expr.hir_id) && let Some(impl_id) = cx.tcx.impl_of_assoc(method_id) && cx .tcx diff --git a/src/tools/clippy/clippy_lints/src/methods/path_ends_with_ext.rs b/src/tools/clippy/clippy_lints/src/methods/path_ends_with_ext.rs index ffba244dcf61c..63b980f9089ee 100644 --- a/src/tools/clippy/clippy_lints/src/methods/path_ends_with_ext.rs +++ b/src/tools/clippy/clippy_lints/src/methods/path_ends_with_ext.rs @@ -24,7 +24,7 @@ pub(super) fn check( allowed_dotfiles: &FxHashSet<&'static str>, ) { if cx - .typeck_results() + .typeck_results .expr_ty(recv) .peel_refs() .is_diag_item(cx, sym::Path) diff --git a/src/tools/clippy/clippy_lints/src/methods/ptr_offset_by_literal.rs b/src/tools/clippy/clippy_lints/src/methods/ptr_offset_by_literal.rs index b5d2add65cf19..7f786dcbb0a06 100644 --- a/src/tools/clippy/clippy_lints/src/methods/ptr_offset_by_literal.rs +++ b/src/tools/clippy/clippy_lints/src/methods/ptr_offset_by_literal.rs @@ -28,7 +28,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, msrv: Ms _ => return, }; - if !cx.typeck_results().expr_ty_adjusted(recv).is_raw_ptr() { + if !cx.typeck_results.expr_ty_adjusted(recv).is_raw_ptr() { return; } diff --git a/src/tools/clippy/clippy_lints/src/methods/ptr_offset_with_cast.rs b/src/tools/clippy/clippy_lints/src/methods/ptr_offset_with_cast.rs index d19d3b8eb89d9..0853c97e8756d 100644 --- a/src/tools/clippy/clippy_lints/src/methods/ptr_offset_with_cast.rs +++ b/src/tools/clippy/clippy_lints/src/methods/ptr_offset_with_cast.rs @@ -29,13 +29,13 @@ pub(super) fn check( _ => return, }; - if !cx.typeck_results().expr_ty_adjusted(recv).is_raw_ptr() { + if !cx.typeck_results.expr_ty_adjusted(recv).is_raw_ptr() { return; } // Check if the argument to the method call is a cast from usize. let cast_lhs_expr = match arg.kind { - ExprKind::Cast(lhs, _) if cx.typeck_results().expr_ty(lhs).is_usize() => lhs, + ExprKind::Cast(lhs, _) if cx.typeck_results.expr_ty(lhs).is_usize() => lhs, _ => return, }; diff --git a/src/tools/clippy/clippy_lints/src/methods/read_line_without_trim.rs b/src/tools/clippy/clippy_lints/src/methods/read_line_without_trim.rs index a6dfbada53483..57569684a87aa 100644 --- a/src/tools/clippy/clippy_lints/src/methods/read_line_without_trim.rs +++ b/src/tools/clippy/clippy_lints/src/methods/read_line_without_trim.rs @@ -31,7 +31,7 @@ fn parse_fails_on_trailing_newline(ty: Ty<'_>) -> bool { } pub fn check(cx: &LateContext<'_>, call: &Expr<'_>, recv: &Expr<'_>, arg: &Expr<'_>) { - let recv_ty = cx.typeck_results().expr_ty(recv); + let recv_ty = cx.typeck_results.expr_ty(recv); if recv_ty.is_diag_item(cx, sym::Stdin) && let ExprKind::Path(QPath::Resolved(_, path)) = arg.peel_borrows().kind && let Res::Local(local_id) = path.res @@ -44,7 +44,7 @@ pub fn check(cx: &LateContext<'_>, call: &Expr<'_>, recv: &Expr<'_>, arg: &Expr< let data = if let ExprKind::MethodCall(segment, recv, args, span) = parent.kind { if args.is_empty() && segment.ident.name == sym::parse - && let parse_result_ty = cx.typeck_results().expr_ty(parent) + && let parse_result_ty = cx.typeck_results.expr_ty(parent) && parse_result_ty.is_diag_item(cx, sym::Result) && let ty::Adt(_, substs) = parse_result_ty.kind() && let Some(ok_ty) = substs[0].as_type() diff --git a/src/tools/clippy/clippy_lints/src/methods/readonly_write_lock.rs b/src/tools/clippy/clippy_lints/src/methods/readonly_write_lock.rs index b89aa8dfb4db1..56adb6d9bde32 100644 --- a/src/tools/clippy/clippy_lints/src/methods/readonly_write_lock.rs +++ b/src/tools/clippy/clippy_lints/src/methods/readonly_write_lock.rs @@ -13,7 +13,7 @@ fn is_unwrap_call(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool { if let ExprKind::MethodCall(path, receiver, [], _) = expr.kind && path.ident.name == sym::unwrap { - cx.typeck_results() + cx.typeck_results .expr_ty(receiver) .peel_refs() .is_diag_item(cx, sym::Result) @@ -23,7 +23,7 @@ fn is_unwrap_call(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool { } pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, receiver: &Expr<'_>) { - if cx.typeck_results().expr_ty(receiver).peel_refs().is_diag_item(cx, sym::RwLock) + if cx.typeck_results.expr_ty(receiver).peel_refs().is_diag_item(cx, sym::RwLock) && let Node::Expr(unwrap_call_expr) = cx.tcx.parent_hir_node(expr.hir_id) && is_unwrap_call(cx, unwrap_call_expr) && let parent = cx.tcx.parent_hir_node(unwrap_call_expr.hir_id) diff --git a/src/tools/clippy/clippy_lints/src/methods/redundant_as_str.rs b/src/tools/clippy/clippy_lints/src/methods/redundant_as_str.rs index 24de1979c631b..8415f9404517f 100644 --- a/src/tools/clippy/clippy_lints/src/methods/redundant_as_str.rs +++ b/src/tools/clippy/clippy_lints/src/methods/redundant_as_str.rs @@ -14,7 +14,7 @@ pub(super) fn check( other_method_span: Span, ) { if cx - .typeck_results() + .typeck_results .expr_ty(recv) .ty_adt_def() .is_some_and(|adt| Some(adt.did()) == cx.tcx.lang_items().string()) diff --git a/src/tools/clippy/clippy_lints/src/methods/repeat_once.rs b/src/tools/clippy/clippy_lints/src/methods/repeat_once.rs index 57a7254605f93..ee0df253b0b47 100644 --- a/src/tools/clippy/clippy_lints/src/methods/repeat_once.rs +++ b/src/tools/clippy/clippy_lints/src/methods/repeat_once.rs @@ -15,7 +15,7 @@ pub(super) fn check<'tcx>( repeat_arg: &'tcx Expr<'_>, ) { if ConstEvalCtxt::new(cx).eval_local(repeat_arg, expr.span.ctxt()) == Some(Constant::Int(1)) { - let ty = cx.typeck_results().expr_ty(recv).peel_refs(); + let ty = cx.typeck_results.expr_ty(recv).peel_refs(); if ty.is_str() { span_lint_and_sugg( cx, diff --git a/src/tools/clippy/clippy_lints/src/methods/result_map_or_else_none.rs b/src/tools/clippy/clippy_lints/src/methods/result_map_or_else_none.rs index d5477b9be4c1e..02d870c44f557 100644 --- a/src/tools/clippy/clippy_lints/src/methods/result_map_or_else_none.rs +++ b/src/tools/clippy/clippy_lints/src/methods/result_map_or_else_none.rs @@ -19,7 +19,7 @@ pub(super) fn check<'tcx>( map_arg: &'tcx hir::Expr<'_>, ) { // lint if the caller of `map_or_else()` is a `Result` - if cx.typeck_results().expr_ty(recv).is_diag_item(cx, sym::Result) + if cx.typeck_results.expr_ty(recv).is_diag_item(cx, sym::Result) // We check that it is mapped as `Some`. && map_arg.res(cx).ctor_parent(cx).is_lang_item(cx, OptionSome) && let hir::ExprKind::Closure(&hir::Closure { body, .. }) = def_arg.kind diff --git a/src/tools/clippy/clippy_lints/src/methods/return_and_then.rs b/src/tools/clippy/clippy_lints/src/methods/return_and_then.rs index 8f47306c89479..3c13c3607a99f 100644 --- a/src/tools/clippy/clippy_lints/src/methods/return_and_then.rs +++ b/src/tools/clippy/clippy_lints/src/methods/return_and_then.rs @@ -25,7 +25,7 @@ pub(super) fn check<'tcx>( return; } - let recv_type = cx.typeck_results().expr_ty(recv); + let recv_type = cx.typeck_results.expr_ty(recv); if !matches!(recv_type.opt_diag_name(cx), Some(sym::Option | sym::Result)) { return; } diff --git a/src/tools/clippy/clippy_lints/src/methods/search_is_some.rs b/src/tools/clippy/clippy_lints/src/methods/search_is_some.rs index 8732eba6d4e87..11c08c5f7f873 100644 --- a/src/tools/clippy/clippy_lints/src/methods/search_is_some.rs +++ b/src/tools/clippy/clippy_lints/src/methods/search_is_some.rs @@ -100,7 +100,7 @@ pub(super) fn check<'tcx>( // lint if `find()` is called by `String` or `&str` else if search_method == sym::find { let is_string_or_str_slice = |e| { - let self_ty = cx.typeck_results().expr_ty(e).peel_refs(); + let self_ty = cx.typeck_results.expr_ty(e).peel_refs(); if self_ty.is_lang_item(cx, hir::LangItem::String) { true } else { diff --git a/src/tools/clippy/clippy_lints/src/methods/seek_from_current.rs b/src/tools/clippy/clippy_lints/src/methods/seek_from_current.rs index 8b51268da465e..dcf510b26503c 100644 --- a/src/tools/clippy/clippy_lints/src/methods/seek_from_current.rs +++ b/src/tools/clippy/clippy_lints/src/methods/seek_from_current.rs @@ -12,7 +12,7 @@ use clippy_utils::{is_enum_variant_ctor, sym}; use super::SEEK_FROM_CURRENT; pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, recv: &'tcx Expr<'_>, arg: &'tcx Expr<'_>) { - let ty = cx.typeck_results().expr_ty(recv); + let ty = cx.typeck_results.expr_ty(recv); if let Some(def_id) = cx.tcx.get_diagnostic_item(sym::IoSeek) && implements_trait(cx, ty, def_id, &[]) diff --git a/src/tools/clippy/clippy_lints/src/methods/seek_to_start_instead_of_rewind.rs b/src/tools/clippy/clippy_lints/src/methods/seek_to_start_instead_of_rewind.rs index b8405a78f23a9..d187d623cc210 100644 --- a/src/tools/clippy/clippy_lints/src/methods/seek_to_start_instead_of_rewind.rs +++ b/src/tools/clippy/clippy_lints/src/methods/seek_to_start_instead_of_rewind.rs @@ -18,7 +18,7 @@ pub(super) fn check<'tcx>( name_span: Span, ) { // Get receiver type - let ty = cx.typeck_results().expr_ty(recv).peel_refs(); + let ty = cx.typeck_results.expr_ty(recv).peel_refs(); if is_expr_used_or_unified(cx.tcx, expr) { return; diff --git a/src/tools/clippy/clippy_lints/src/methods/single_char_add_str.rs b/src/tools/clippy/clippy_lints/src/methods/single_char_add_str.rs index 581c400e25c5c..97950b357426e 100644 --- a/src/tools/clippy/clippy_lints/src/methods/single_char_add_str.rs +++ b/src/tools/clippy/clippy_lints/src/methods/single_char_add_str.rs @@ -9,7 +9,7 @@ use rustc_lint::LateContext; use rustc_middle::ty; pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, receiver: &Expr<'_>, args: &[Expr<'_>]) { - if let Some(fn_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) { + if let Some(fn_def_id) = cx.typeck_results.type_dependent_def_id(expr.hir_id) { let mut applicability = Applicability::MachineApplicable; let (short_name, arg, extra) = match cx.tcx.get_diagnostic_name(fn_def_id) { Some(sym::string_insert_str) => ( @@ -72,9 +72,9 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, receiver: &Expr<'_>, } fn is_ref_char(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool { - matches!(cx.typeck_results().expr_ty(expr).kind(), ty::Ref(_, ty, _) if ty.is_char()) + matches!(cx.typeck_results.expr_ty(expr).kind(), ty::Ref(_, ty, _) if ty.is_char()) } fn is_char(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool { - cx.typeck_results().expr_ty(expr).is_char() + cx.typeck_results.expr_ty(expr).is_char() } diff --git a/src/tools/clippy/clippy_lints/src/methods/sliced_string_as_bytes.rs b/src/tools/clippy/clippy_lints/src/methods/sliced_string_as_bytes.rs index fb124f3605b94..0e7ec683bbb90 100644 --- a/src/tools/clippy/clippy_lints/src/methods/sliced_string_as_bytes.rs +++ b/src/tools/clippy/clippy_lints/src/methods/sliced_string_as_bytes.rs @@ -16,7 +16,7 @@ fn is_bounded_range_literal(cx: &LateContext<'_>, index: &Expr<'_>) -> bool { pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>) { if let ExprKind::Index(indexed, index, _) = recv.kind && is_bounded_range_literal(cx, index) - && let ty = cx.typeck_results().expr_ty(indexed).peel_refs() + && let ty = cx.typeck_results.expr_ty(indexed).peel_refs() && (ty.is_str() || ty.is_lang_item(cx, LangItem::String)) { let mut applicability = Applicability::MaybeIncorrect; diff --git a/src/tools/clippy/clippy_lints/src/methods/stable_sort_primitive.rs b/src/tools/clippy/clippy_lints/src/methods/stable_sort_primitive.rs index 75b67f1bdd7d8..b050c9891309a 100644 --- a/src/tools/clippy/clippy_lints/src/methods/stable_sort_primitive.rs +++ b/src/tools/clippy/clippy_lints/src/methods/stable_sort_primitive.rs @@ -8,7 +8,7 @@ use rustc_lint::LateContext; use super::STABLE_SORT_PRIMITIVE; pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>, recv: &'tcx Expr<'_>) { - if let Some(method_id) = cx.typeck_results().type_dependent_def_id(e.hir_id) + if let Some(method_id) = cx.typeck_results.type_dependent_def_id(e.hir_id) && let Some(impl_id) = cx.tcx.impl_of_assoc(method_id) && cx .tcx diff --git a/src/tools/clippy/clippy_lints/src/methods/str_split.rs b/src/tools/clippy/clippy_lints/src/methods/str_split.rs index 8641f7c0abec3..f050e562f1b6b 100644 --- a/src/tools/clippy/clippy_lints/src/methods/str_split.rs +++ b/src/tools/clippy/clippy_lints/src/methods/str_split.rs @@ -22,7 +22,7 @@ pub(super) fn check<'a>( // basic ones: a `'\n'`, `"\n"`, and `"\r\n"`. if let ExprKind::MethodCall(trim_method_name, trim_recv, [], trim_span) = split_recv.kind && trim_method_name.ident.name == sym::trim - && cx.typeck_results().expr_ty_adjusted(trim_recv).peel_refs().is_str() + && cx.typeck_results.expr_ty_adjusted(trim_recv).peel_refs().is_str() && !is_const_evaluatable(cx, trim_recv) && let ExprKind::Lit(split_lit) = split_arg.kind && matches!( diff --git a/src/tools/clippy/clippy_lints/src/methods/str_splitn.rs b/src/tools/clippy/clippy_lints/src/methods/str_splitn.rs index fff203296bce9..e56ddde09f140 100644 --- a/src/tools/clippy/clippy_lints/src/methods/str_splitn.rs +++ b/src/tools/clippy/clippy_lints/src/methods/str_splitn.rs @@ -26,7 +26,7 @@ pub(super) fn check( count: u128, msrv: Msrv, ) { - if count < 2 || !cx.typeck_results().expr_ty_adjusted(self_arg).peel_refs().is_str() { + if count < 2 || !cx.typeck_results.expr_ty_adjusted(self_arg).peel_refs().is_str() { return; } @@ -282,14 +282,14 @@ fn parse_iter_usage<'tcx>( let ExprKind::MethodCall(name, _, args, _) = e.kind else { return None; }; - let did = cx.typeck_results().type_dependent_def_id(e.hir_id)?; + let did = cx.typeck_results.type_dependent_def_id(e.hir_id)?; let iter_id = cx.tcx.get_diagnostic_item(sym::Iterator)?; match (name.ident.name, args) { (sym::next, []) if cx.tcx.trait_of_assoc(did) == Some(iter_id) => (IterUsageKind::Nth(0), e.span), (sym::next_tuple, []) => { return if paths::ITERTOOLS_NEXT_TUPLE.matches(cx, did) - && let ty::Adt(adt_def, subs) = cx.typeck_results().expr_ty(e).kind() + && let ty::Adt(adt_def, subs) = cx.typeck_results.expr_ty(e).kind() && cx.tcx.is_diagnostic_item(sym::Option, adt_def.did()) && let ty::Tuple(subs) = subs.type_at(0).kind() && subs.len() == 2 @@ -311,7 +311,7 @@ fn parse_iter_usage<'tcx>( && let ExprKind::MethodCall(next_name, _, [], _) = next_expr.kind && next_name.ident.name == sym::next && next_expr.span.ctxt() == ctxt - && let Some(next_id) = cx.typeck_results().type_dependent_def_id(next_expr.hir_id) + && let Some(next_id) = cx.typeck_results.type_dependent_def_id(next_expr.hir_id) && cx.tcx.trait_of_assoc(next_id) == Some(iter_id) { next_expr.span @@ -349,7 +349,7 @@ fn parse_iter_usage<'tcx>( ExprKind::MethodCall(name, _, [], _) if name.ident.name == sym::unwrap && cx - .typeck_results() + .typeck_results .type_dependent_def_id(e.hir_id) .opt_parent(cx) .opt_impl_ty(cx) diff --git a/src/tools/clippy/clippy_lints/src/methods/string_extend_chars.rs b/src/tools/clippy/clippy_lints/src/methods/string_extend_chars.rs index 1fc0633f4f959..e9983b2ef6aac 100644 --- a/src/tools/clippy/clippy_lints/src/methods/string_extend_chars.rs +++ b/src/tools/clippy/clippy_lints/src/methods/string_extend_chars.rs @@ -9,13 +9,13 @@ use rustc_lint::LateContext; use super::STRING_EXTEND_CHARS; pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>, arg: &hir::Expr<'_>) { - let obj_ty = cx.typeck_results().expr_ty(recv).peel_refs(); + let obj_ty = cx.typeck_results.expr_ty(recv).peel_refs(); if !obj_ty.is_lang_item(cx, hir::LangItem::String) { return; } if let Some(arglists) = method_chain_args(arg, &[sym::chars]) { let target = &arglists[0].0; - let self_ty = cx.typeck_results().expr_ty(target).peel_refs(); + let self_ty = cx.typeck_results.expr_ty(target).peel_refs(); let ref_str = if self_ty.is_str() { if matches!(target.kind, hir::ExprKind::Index(..)) { "&" diff --git a/src/tools/clippy/clippy_lints/src/methods/suspicious_command_arg_space.rs b/src/tools/clippy/clippy_lints/src/methods/suspicious_command_arg_space.rs index b4ea2e62b3c1f..a453fbd728e54 100644 --- a/src/tools/clippy/clippy_lints/src/methods/suspicious_command_arg_space.rs +++ b/src/tools/clippy/clippy_lints/src/methods/suspicious_command_arg_space.rs @@ -10,7 +10,7 @@ use rustc_span::Span; use super::SUSPICIOUS_COMMAND_ARG_SPACE; pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, recv: &'tcx hir::Expr<'_>, arg: &'tcx hir::Expr<'_>, span: Span) { - let ty = cx.typeck_results().expr_ty(recv).peel_refs(); + let ty = cx.typeck_results.expr_ty(recv).peel_refs(); if ty.is_diag_item(cx, sym::Command) && let hir::ExprKind::Lit(lit) = &arg.kind diff --git a/src/tools/clippy/clippy_lints/src/methods/suspicious_map.rs b/src/tools/clippy/clippy_lints/src/methods/suspicious_map.rs index ece97c1f758c0..24628e2adb861 100644 --- a/src/tools/clippy/clippy_lints/src/methods/suspicious_map.rs +++ b/src/tools/clippy/clippy_lints/src/methods/suspicious_map.rs @@ -15,7 +15,7 @@ pub fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, count_recv: &hir::Expr< .is_diag_item(cx, sym::Iterator) && let hir::ExprKind::Closure(closure) = expr_or_init(cx, map_arg).kind && let closure_body = cx.tcx.hir_body(closure.body) - && !cx.typeck_results().expr_ty(closure_body.value).is_unit() + && !cx.typeck_results.expr_ty(closure_body.value).is_unit() { if let Some(map_mutated_vars) = mutated_variables(closure_body.value, cx) // A variable is used mutably inside of the closure. Suppress the lint. diff --git a/src/tools/clippy/clippy_lints/src/methods/suspicious_splitn.rs b/src/tools/clippy/clippy_lints/src/methods/suspicious_splitn.rs index 3a4c71fed3b5d..1c961978b5a1f 100644 --- a/src/tools/clippy/clippy_lints/src/methods/suspicious_splitn.rs +++ b/src/tools/clippy/clippy_lints/src/methods/suspicious_splitn.rs @@ -8,7 +8,7 @@ use super::SUSPICIOUS_SPLITN; pub(super) fn check(cx: &LateContext<'_>, method_name: Symbol, expr: &Expr<'_>, self_arg: &Expr<'_>, count: u128) { if count <= 1 - && let Some(call_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) + && let Some(call_id) = cx.typeck_results.type_dependent_def_id(expr.hir_id) && let Some(impl_id) = cx.tcx.inherent_impl_of_assoc(call_id) && let self_ty = cx.tcx.type_of(impl_id).instantiate_identity().skip_norm_wip() && (self_ty.is_slice() || self_ty.is_str()) diff --git a/src/tools/clippy/clippy_lints/src/methods/suspicious_to_owned.rs b/src/tools/clippy/clippy_lints/src/methods/suspicious_to_owned.rs index 5d0fd6ca4c80f..651432f647060 100644 --- a/src/tools/clippy/clippy_lints/src/methods/suspicious_to_owned.rs +++ b/src/tools/clippy/clippy_lints/src/methods/suspicious_to_owned.rs @@ -11,11 +11,11 @@ use super::SUSPICIOUS_TO_OWNED; pub fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, method_span: Span) -> bool { if cx - .typeck_results() + .typeck_results .type_dependent_def_id(expr.hir_id) .opt_parent(cx) .is_diag_item(cx, sym::ToOwned) - && let input_type = cx.typeck_results().expr_ty(expr) + && let input_type = cx.typeck_results.expr_ty(expr) && input_type.is_diag_item(cx, sym::Cow) { let app = Applicability::MaybeIncorrect; diff --git a/src/tools/clippy/clippy_lints/src/methods/swap_with_temporary.rs b/src/tools/clippy/clippy_lints/src/methods/swap_with_temporary.rs index 0b8f6ae9f2779..963612d0452ae 100644 --- a/src/tools/clippy/clippy_lints/src/methods/swap_with_temporary.rs +++ b/src/tools/clippy/clippy_lints/src/methods/swap_with_temporary.rs @@ -44,7 +44,7 @@ impl<'tcx> ArgKind<'tcx> { /// `ArgKind::RefMutToTemp` variant, as this may cause a spurious lint to be emitted. fn new(cx: &LateContext<'tcx>, arg: &'tcx Expr<'tcx>) -> Self { if let ExprKind::AddrOf(BorrowKind::Ref, _, target) = arg.kind - && let adjustments = cx.typeck_results().expr_adjustments(arg) + && let adjustments = cx.typeck_results.expr_adjustments(arg) && adjustments .first() .is_some_and(|adj| matches!(adj.kind, Adjust::Deref(DerefAdjustKind::Builtin))) diff --git a/src/tools/clippy/clippy_lints/src/methods/type_id_on_box.rs b/src/tools/clippy/clippy_lints/src/methods/type_id_on_box.rs index 3e4eae9e53668..c071b4ed99c53 100644 --- a/src/tools/clippy/clippy_lints/src/methods/type_id_on_box.rs +++ b/src/tools/clippy/clippy_lints/src/methods/type_id_on_box.rs @@ -41,7 +41,7 @@ fn is_subtrait_of_any(cx: &LateContext<'_>, ty: Ty<'_>) -> bool { } pub(super) fn check(cx: &LateContext<'_>, receiver: &Expr<'_>, call_span: Span) { - let recv_adjusts = cx.typeck_results().expr_adjustments(receiver); + let recv_adjusts = cx.typeck_results.expr_adjustments(receiver); if let Some(Adjustment { target: recv_ty, .. }) = recv_adjusts.last() && let ty::Ref(_, ty, _) = recv_ty.kind() diff --git a/src/tools/clippy/clippy_lints/src/methods/unbuffered_bytes.rs b/src/tools/clippy/clippy_lints/src/methods/unbuffered_bytes.rs index b86ba39d7b6c9..72a2b039e8e00 100644 --- a/src/tools/clippy/clippy_lints/src/methods/unbuffered_bytes.rs +++ b/src/tools/clippy/clippy_lints/src/methods/unbuffered_bytes.rs @@ -10,7 +10,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr // Lint if the `.bytes()` call is from the `Read` trait and the implementor is not buffered. if cx.ty_based_def(expr).opt_parent(cx).is_diag_item(cx, sym::IoRead) && let Some(buf_read) = cx.tcx.get_diagnostic_item(sym::IoBufRead) - && let ty = cx.typeck_results().expr_ty_adjusted(recv) + && let ty = cx.typeck_results.expr_ty_adjusted(recv) && !implements_trait(cx, ty, buf_read, &[]) { span_lint_and_help( diff --git a/src/tools/clippy/clippy_lints/src/methods/uninit_assumed_init.rs b/src/tools/clippy/clippy_lints/src/methods/uninit_assumed_init.rs index 5e247a50358e6..ae595008ef454 100644 --- a/src/tools/clippy/clippy_lints/src/methods/uninit_assumed_init.rs +++ b/src/tools/clippy/clippy_lints/src/methods/uninit_assumed_init.rs @@ -11,7 +11,7 @@ use super::UNINIT_ASSUMED_INIT; pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>) { if let hir::ExprKind::Call(callee, []) = recv.kind && callee.ty_rel_def(cx).is_diag_item(cx, sym::maybe_uninit_uninit) - && !is_uninit_value_valid_for_ty(cx, cx.typeck_results().expr_ty_adjusted(expr)) + && !is_uninit_value_valid_for_ty(cx, cx.typeck_results.expr_ty_adjusted(expr)) { span_lint( cx, diff --git a/src/tools/clippy/clippy_lints/src/methods/unit_hash.rs b/src/tools/clippy/clippy_lints/src/methods/unit_hash.rs index fb447a99abdce..cdd12325ceb96 100644 --- a/src/tools/clippy/clippy_lints/src/methods/unit_hash.rs +++ b/src/tools/clippy/clippy_lints/src/methods/unit_hash.rs @@ -9,7 +9,7 @@ use rustc_span::sym; use super::UNIT_HASH; pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, recv: &'tcx Expr<'_>, arg: &'tcx Expr<'_>) { - if cx.ty_based_def(expr).opt_parent(cx).is_diag_item(cx, sym::Hash) && cx.typeck_results().expr_ty(recv).is_unit() { + if cx.ty_based_def(expr).opt_parent(cx).is_diag_item(cx, sym::Hash) && cx.typeck_results.expr_ty(recv).is_unit() { span_lint_and_then( cx, UNIT_HASH, diff --git a/src/tools/clippy/clippy_lints/src/methods/unnecessary_fallible_conversions.rs b/src/tools/clippy/clippy_lints/src/methods/unnecessary_fallible_conversions.rs index 23546cad0af70..6dbfbcf9490c0 100644 --- a/src/tools/clippy/clippy_lints/src/methods/unnecessary_fallible_conversions.rs +++ b/src/tools/clippy/clippy_lints/src/methods/unnecessary_fallible_conversions.rs @@ -152,7 +152,7 @@ pub(super) fn check_method(cx: &LateContext<'_>, expr: &Expr<'_>) { check( cx, expr, - cx.typeck_results().node_args(expr.hir_id), + cx.typeck_results.node_args(expr.hir_id), FunctionKind::TryIntoMethod, path.ident.span, ); @@ -186,7 +186,7 @@ pub(super) fn check_function(cx: &LateContext<'_>, expr: &Expr<'_>, callee: &Exp check( cx, expr, - cx.typeck_results().node_args(callee.hir_id), + cx.typeck_results.node_args(callee.hir_id), match cx.tcx.get_diagnostic_name(trait_def_id) { Some(sym::TryFrom) => FunctionKind::TryFromFunction(qpath_spans), Some(sym::TryInto) => FunctionKind::TryIntoFunction(qpath_spans), diff --git a/src/tools/clippy/clippy_lints/src/methods/unnecessary_filter_map.rs b/src/tools/clippy/clippy_lints/src/methods/unnecessary_filter_map.rs index 54f3fe4105198..17d16739482ef 100644 --- a/src/tools/clippy/clippy_lints/src/methods/unnecessary_filter_map.rs +++ b/src/tools/clippy/clippy_lints/src/methods/unnecessary_filter_map.rs @@ -43,7 +43,7 @@ pub(super) fn check<'tcx>( ControlFlow::Continue(Descend::Yes) } }); - let in_ty = cx.typeck_results().node_type(body.params[0].hir_id); + let in_ty = cx.typeck_results.node_type(body.params[0].hir_id); let sugg = if !found_filtering { // Check if the closure is .filter_map(|x| Some(x)) if kind.is_filter_map() @@ -63,7 +63,7 @@ pub(super) fn check<'tcx>( Kind::FindMap => "map(..).next()", } } else if !found_mapping && !mutates_arg && (!clone_or_copy_needed || is_copy(cx, in_ty)) { - let ty = cx.typeck_results().expr_ty(body.value); + let ty = cx.typeck_results.expr_ty(body.value); if option_arg_ty(cx, ty).is_some_and(|t| t == in_ty) { match kind { Kind::FilterMap => "filter(..)", @@ -133,7 +133,7 @@ fn check_expression<'tcx>(cx: &LateContext<'tcx>, arg_id: hir::HirId, expr: &'tc }, hir::ExprKind::MethodCall(segment, recv, [arg], _) if segment.ident.name == sym::then_some - && cx.typeck_results().expr_ty(recv).is_bool() + && cx.typeck_results.expr_ty(recv).is_bool() && arg.res_local_id() == Some(arg_id) => { // bool.then_some(arg_id) diff --git a/src/tools/clippy/clippy_lints/src/methods/unnecessary_first_then_check.rs b/src/tools/clippy/clippy_lints/src/methods/unnecessary_first_then_check.rs index d322909bef359..8cf3480badd7d 100644 --- a/src/tools/clippy/clippy_lints/src/methods/unnecessary_first_then_check.rs +++ b/src/tools/clippy/clippy_lints/src/methods/unnecessary_first_then_check.rs @@ -16,7 +16,7 @@ pub(super) fn check( is_some: bool, ) { if !cx - .typeck_results() + .typeck_results .expr_ty_adjusted(first_caller) .peel_refs() .is_slice() diff --git a/src/tools/clippy/clippy_lints/src/methods/unnecessary_fold.rs b/src/tools/clippy/clippy_lints/src/methods/unnecessary_fold.rs index 15337082c03a5..e3a56daa5b0ed 100644 --- a/src/tools/clippy/clippy_lints/src/methods/unnecessary_fold.rs +++ b/src/tools/clippy/clippy_lints/src/methods/unnecessary_fold.rs @@ -18,7 +18,7 @@ use super::UNNECESSARY_FOLD; /// Changing `fold` to `sum` needs it sometimes when the return type can't be /// inferred. This checks for some common cases where it can be safely omitted fn needs_turbofish<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'tcx>) -> bool { - let use_site = get_expr_use_site(cx.tcx, cx.typeck_results(), expr.span.ctxt(), expr); + let use_site = get_expr_use_site(cx.tcx, cx.typeck_results, expr.span.ctxt(), expr); if use_site.same_ctxt && let use_node = use_site.use_node(cx) && let Some(ty) = use_node.defined_ty(cx) @@ -150,7 +150,7 @@ fn check_fold_with_op( |diag| { let mut applicability = replacement.default_applicability(); let turbofish = - replacement.maybe_turbofish(cx.typeck_results().expr_ty_adjusted(right_expr).peel_refs()); + replacement.maybe_turbofish(cx.typeck_results.expr_ty_adjusted(right_expr).peel_refs()); let (r_snippet, _) = snippet_with_context(cx, triggered_expr_span, expr.span.ctxt(), "EXPR", &mut applicability); let sugg = if replacement.has_args { @@ -197,7 +197,7 @@ fn check_fold_with_method( format!( "{method}{turbofish}()", method = replacement.method_name, - turbofish = replacement.maybe_turbofish(cx.typeck_results().expr_ty(expr)) + turbofish = replacement.maybe_turbofish(cx.typeck_results.expr_ty(expr)) ), replacement.default_applicability(), ); diff --git a/src/tools/clippy/clippy_lints/src/methods/unnecessary_get_then_check.rs b/src/tools/clippy/clippy_lints/src/methods/unnecessary_get_then_check.rs index b2413bb77aa73..ae47adc641fec 100644 --- a/src/tools/clippy/clippy_lints/src/methods/unnecessary_get_then_check.rs +++ b/src/tools/clippy/clippy_lints/src/methods/unnecessary_get_then_check.rs @@ -27,7 +27,7 @@ pub(super) fn check( arg: &Expr<'_>, is_some: bool, ) { - let caller_ty = cx.typeck_results().expr_ty(get_caller); + let caller_ty = cx.typeck_results.expr_ty(get_caller); let is_set = is_a_std_set_type(cx, caller_ty); let is_map = is_a_std_map_type(cx, caller_ty); diff --git a/src/tools/clippy/clippy_lints/src/methods/unnecessary_iter_cloned.rs b/src/tools/clippy/clippy_lints/src/methods/unnecessary_iter_cloned.rs index 444d0a1d72422..7a9166dd0c75e 100644 --- a/src/tools/clippy/clippy_lints/src/methods/unnecessary_iter_cloned.rs +++ b/src/tools/clippy/clippy_lints/src/methods/unnecessary_iter_cloned.rs @@ -94,11 +94,11 @@ pub fn check_for_loop_iter( let snippet = if let ExprKind::MethodCall(maybe_iter_method_name, collection, [], _) = receiver.kind && maybe_iter_method_name.ident.name == sym::iter && let Some(iterator_trait_id) = cx.tcx.get_diagnostic_item(sym::Iterator) - && let receiver_ty = cx.typeck_results().expr_ty(receiver) + && let receiver_ty = cx.typeck_results.expr_ty(receiver) && implements_trait(cx, receiver_ty, iterator_trait_id, &[]) && let Some(iter_item_ty) = get_iterator_item_ty(cx, receiver_ty) && let Some(into_iterator_trait_id) = cx.tcx.get_diagnostic_item(sym::IntoIterator) - && let collection_ty = cx.typeck_results().expr_ty(collection) + && let collection_ty = cx.typeck_results.expr_ty(collection) && implements_trait(cx, collection_ty, into_iterator_trait_id, &[]) && let Some(into_iter_item_ty) = cx.get_associated_type(collection_ty, into_iterator_trait_id, sym::Item) && iter_item_ty == into_iter_item_ty diff --git a/src/tools/clippy/clippy_lints/src/methods/unnecessary_join.rs b/src/tools/clippy/clippy_lints/src/methods/unnecessary_join.rs index 3290bdd778243..869a1bc94fe3e 100644 --- a/src/tools/clippy/clippy_lints/src/methods/unnecessary_join.rs +++ b/src/tools/clippy/clippy_lints/src/methods/unnecessary_join.rs @@ -17,7 +17,7 @@ pub(super) fn check<'tcx>( span: Span, ) { let applicability = Applicability::MachineApplicable; - let collect_output_adjusted_type = cx.typeck_results().expr_ty_adjusted(join_self_arg); + let collect_output_adjusted_type = cx.typeck_results.expr_ty_adjusted(join_self_arg); if let ty::Ref(_, ref_type, _) = collect_output_adjusted_type.kind() // the turbofish for collect is ::> && let ty::Slice(slice) = *ref_type.kind() diff --git a/src/tools/clippy/clippy_lints/src/methods/unnecessary_lazy_eval.rs b/src/tools/clippy/clippy_lints/src/methods/unnecessary_lazy_eval.rs index 2869547650f31..deeeeed7eafc6 100644 --- a/src/tools/clippy/clippy_lints/src/methods/unnecessary_lazy_eval.rs +++ b/src/tools/clippy/clippy_lints/src/methods/unnecessary_lazy_eval.rs @@ -19,9 +19,9 @@ pub(super) fn check<'tcx>( arg: &'tcx hir::Expr<'_>, simplify_using: &str, ) -> bool { - let is_option = cx.typeck_results().expr_ty(recv).is_diag_item(cx, sym::Option); - let is_result = cx.typeck_results().expr_ty(recv).is_diag_item(cx, sym::Result); - let is_bool = cx.typeck_results().expr_ty(recv).is_bool(); + let is_option = cx.typeck_results.expr_ty(recv).is_diag_item(cx, sym::Option); + let is_result = cx.typeck_results.expr_ty(recv).is_diag_item(cx, sym::Result); + let is_bool = cx.typeck_results.expr_ty(recv).is_bool(); if (is_option || is_result || is_bool) && let hir::ExprKind::Closure(&hir::Closure { diff --git a/src/tools/clippy/clippy_lints/src/methods/unnecessary_literal_unwrap.rs b/src/tools/clippy/clippy_lints/src/methods/unnecessary_literal_unwrap.rs index fdd335c762013..ee07bd9d0826f 100644 --- a/src/tools/clippy/clippy_lints/src/methods/unnecessary_literal_unwrap.rs +++ b/src/tools/clippy/clippy_lints/src/methods/unnecessary_literal_unwrap.rs @@ -90,7 +90,7 @@ pub(super) fn check( Some(suggs) }, (sym::None, sym::unwrap_or_default, _) => { - let ty = cx.typeck_results().expr_ty(expr); + let ty = cx.typeck_results.expr_ty(expr); let default_ty_string = if let ty::Adt(def, ..) = ty.kind() { with_forced_trimmed_paths!(cx.tcx.def_path_str(def.did())) } else { diff --git a/src/tools/clippy/clippy_lints/src/methods/unnecessary_map_or.rs b/src/tools/clippy/clippy_lints/src/methods/unnecessary_map_or.rs index b9af391843876..3a89f4a48e8c1 100644 --- a/src/tools/clippy/clippy_lints/src/methods/unnecessary_map_or.rs +++ b/src/tools/clippy/clippy_lints/src/methods/unnecessary_map_or.rs @@ -52,7 +52,7 @@ pub(super) fn check<'a>( return; }; - let typeck = cx.typeck_results(); + let typeck = cx.typeck_results; let recv_ty = typeck.expr_ty_adjusted(recv); diff --git a/src/tools/clippy/clippy_lints/src/methods/unnecessary_map_or_else.rs b/src/tools/clippy/clippy_lints/src/methods/unnecessary_map_or_else.rs index 7c1c31d2bd381..29c674294b52a 100644 --- a/src/tools/clippy/clippy_lints/src/methods/unnecessary_map_or_else.rs +++ b/src/tools/clippy/clippy_lints/src/methods/unnecessary_map_or_else.rs @@ -19,7 +19,7 @@ pub(super) fn check( map_arg: &Expr<'_>, call_span: Span, ) { - let (symbol, lint) = match cx.typeck_results().expr_ty(recv).opt_diag_name(cx) { + let (symbol, lint) = match cx.typeck_results.expr_ty(recv).opt_diag_name(cx) { Some(x @ sym::Result) => (x, UNNECESSARY_RESULT_MAP_OR_ELSE), Some(x @ sym::Option) => (x, UNNECESSARY_OPTION_MAP_OR_ELSE), _ => return, diff --git a/src/tools/clippy/clippy_lints/src/methods/unnecessary_min_or_max.rs b/src/tools/clippy/clippy_lints/src/methods/unnecessary_min_or_max.rs index ea1dff6369400..2aff57a79d2b0 100644 --- a/src/tools/clippy/clippy_lints/src/methods/unnecessary_min_or_max.rs +++ b/src/tools/clippy/clippy_lints/src/methods/unnecessary_min_or_max.rs @@ -19,7 +19,7 @@ pub(super) fn check<'tcx>( recv: &'tcx Expr<'_>, arg: &'tcx Expr<'_>, ) { - let typeck_results = cx.typeck_results(); + let typeck_results = cx.typeck_results; let ecx = ConstEvalCtxt::with_env(cx.tcx, cx.typing_env(), typeck_results); if let Some(id) = typeck_results.type_dependent_def_id(expr.hir_id) && let Some(fn_name) = cx.tcx.get_diagnostic_name(id) @@ -81,7 +81,7 @@ enum Extrema { Maximum, } fn detect_extrema<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option { - let ty = cx.typeck_results().expr_ty(expr); + let ty = cx.typeck_results.expr_ty(expr); let cv = ConstEvalCtxt::new(cx).eval(expr)?; diff --git a/src/tools/clippy/clippy_lints/src/methods/unnecessary_sort_by.rs b/src/tools/clippy/clippy_lints/src/methods/unnecessary_sort_by.rs index 391209d8c3657..37a3d12228d7d 100644 --- a/src/tools/clippy/clippy_lints/src/methods/unnecessary_sort_by.rs +++ b/src/tools/clippy/clippy_lints/src/methods/unnecessary_sort_by.rs @@ -241,7 +241,7 @@ fn mapping_of_mirrored_pats(a_pat: &Pat<'_>, b_pat: &Pat<'_>) -> Option, expr: &Expr<'_>, arg: &Expr<'_>) -> Option { - if let Some(method_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) + if let Some(method_id) = cx.typeck_results.type_dependent_def_id(expr.hir_id) && let Some(impl_id) = cx.tcx.impl_of_assoc(method_id) && cx .tcx @@ -283,12 +283,12 @@ fn detect_lint(cx: &LateContext<'_>, expr: &Expr<'_>, arg: &Expr<'_>) -> Option< { if let PatKind::Binding(_, _, left_ident, _) = l_pat.kind && *left_name == left_ident - && implements_trait(cx, cx.typeck_results().expr_ty(left_expr), ord_trait, &[]) + && implements_trait(cx, cx.typeck_results.expr_ty(left_expr), ord_trait, &[]) { return Some(LintTrigger::Sort); } - let mut left_expr_ty = cx.typeck_results().expr_ty(left_expr); + let mut left_expr_ty = cx.typeck_results.expr_ty(left_expr); let left_ident_n_refs = binding_map .get(&BindingKey { ident: *left_name, @@ -315,7 +315,7 @@ fn detect_lint(cx: &LateContext<'_>, expr: &Expr<'_>, arg: &Expr<'_>) -> Option< } } - let left_expr_ty = cx.typeck_results().expr_ty(left_expr); + let left_expr_ty = cx.typeck_results.expr_ty(left_expr); if !expr_borrows(left_expr_ty) // Don't lint if the closure is accessing non-Copy fields && (!expr_is_field_access(left_expr) || is_copy(cx, left_expr_ty)) diff --git a/src/tools/clippy/clippy_lints/src/methods/unnecessary_to_owned.rs b/src/tools/clippy/clippy_lints/src/methods/unnecessary_to_owned.rs index a56dcd894b6aa..2b16f024ea933 100644 --- a/src/tools/clippy/clippy_lints/src/methods/unnecessary_to_owned.rs +++ b/src/tools/clippy/clippy_lints/src/methods/unnecessary_to_owned.rs @@ -32,7 +32,7 @@ pub fn check<'tcx>( args: &'tcx [Expr<'_>], msrv: Msrv, ) { - if let Some(method_parent_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id).opt_parent(cx) + if let Some(method_parent_id) = cx.typeck_results.type_dependent_def_id(expr.hir_id).opt_parent(cx) && args.is_empty() { if is_cloned_or_copied(cx, method_name, method_parent_id) { @@ -73,7 +73,7 @@ fn check_addr_of_expr( ) -> bool { if let Some(parent) = get_parent_expr(cx, expr) && let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, _) = parent.kind - && let adjustments = cx.typeck_results().expr_adjustments(parent).iter().collect::>() + && let adjustments = cx.typeck_results.expr_adjustments(parent).iter().collect::>() && let // For matching uses of `Cow::from` [ @@ -116,7 +116,7 @@ fn check_addr_of_expr( target: target_ty, }, ] = adjustments[..] - && let receiver_ty = cx.typeck_results().expr_ty(receiver) + && let receiver_ty = cx.typeck_results.expr_ty(receiver) && let (target_ty, n_target_refs, _) = peel_and_count_ty_refs(*target_ty) && let (receiver_ty, n_receiver_refs, _) = peel_and_count_ty_refs(receiver_ty) // Only flag cases satisfying at least one of the following three conditions: @@ -157,7 +157,7 @@ fn check_addr_of_expr( // Make sure that it's actually calling the right `.to_string()`, (#10033) // *or* this is a `Cow::into_owned()` call (which would be the wrong into_owned receiver (str != Cow) // but that's ok for Cow::into_owned specifically) - && (cx.typeck_results().expr_ty_adjusted(receiver).peel_refs() == target_ty + && (cx.typeck_results.expr_ty_adjusted(receiver).peel_refs() == target_ty || is_cow_into_owned(cx, method_name, method_parent_id)) { if n_receiver_refs > 0 { @@ -214,12 +214,12 @@ fn check_into_iter_call_arg( && let Some(callee_def_id) = fn_def_id(cx, parent) && is_into_iter(cx, callee_def_id) && let Some(iterator_trait_id) = cx.tcx.get_diagnostic_item(sym::Iterator) - && let parent_ty = cx.typeck_results().expr_ty(parent) + && let parent_ty = cx.typeck_results.expr_ty(parent) && implements_trait(cx, parent_ty, iterator_trait_id, &[]) && let Some(item_ty) = get_iterator_item_ty(cx, parent_ty) && let Some(receiver_snippet) = receiver.span.get_source_text(cx) // If the receiver is a `Cow`, we can't remove the `into_owned` generally, see https://github.com/rust-lang/rust-clippy/issues/13624. - && !cx.typeck_results().expr_ty(receiver).is_diag_item(cx, sym::Cow) + && !cx.typeck_results.expr_ty(receiver).is_diag_item(cx, sym::Cow) // Calling `iter()` on a temporary object can lead to false positives. #14242 && !is_expr_temporary_value(cx, receiver) { @@ -261,7 +261,7 @@ fn check_string_from_utf8<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, && matches!(unwrap_method_name.ident.name, sym::unwrap | sym::expect) && let Some(ref_string) = get_parent_expr(cx, unwrap_call) && let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, _) = ref_string.kind - && let adjusted_ty = cx.typeck_results().expr_ty_adjusted(ref_string) + && let adjusted_ty = cx.typeck_results.expr_ty_adjusted(ref_string) // `&...` creates a `&String`, so only actually lint if this coerces to a `&str` && matches!(adjusted_ty.kind(), ty::Ref(_, ty, _) if ty.is_str()) { @@ -274,7 +274,7 @@ fn check_string_from_utf8<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, let arg_suggestion = format!( "{borrow}{recv_snippet}", recv_snippet = snippet(cx, receiver.span.source_callsite(), ".."), - borrow = if cx.typeck_results().expr_ty(receiver).is_ref() { + borrow = if cx.typeck_results.expr_ty(receiver).is_ref() { "" } else { // If not already a reference, prefix with a borrow so that it can coerce to one @@ -319,9 +319,9 @@ fn check_split_call_arg(cx: &LateContext<'_>, expr: &Expr<'_>, method_name: Symb // We may end-up here because of an expression like `x.to_string().split(…)` where the type of `x` // implements `AsRef` but does not implement `Deref`. In this case, we have to // add `.as_ref()` to the suggestion. - let as_ref = if cx.typeck_results().expr_ty(expr).is_lang_item(cx, LangItem::String) + let as_ref = if cx.typeck_results.expr_ty(expr).is_lang_item(cx, LangItem::String) && let Some(deref_trait_id) = cx.tcx.get_diagnostic_item(sym::Deref) - && cx.get_associated_type(cx.typeck_results().expr_ty(receiver), deref_trait_id, sym::Target) + && cx.get_associated_type(cx.typeck_results.expr_ty(receiver), deref_trait_id, sym::Target) != Some(cx.tcx.types.str_) { ".as_ref()" @@ -360,7 +360,7 @@ fn get_fn_name_and_arg<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) -> Optio // Only return Fn-like DefIds, not the DefIds of statics/consts/etc that contain or // deref to fn pointers, dyn Fn, impl Fn - #8850 if let Res::Def(DefKind::Fn | DefKind::Ctor(..) | DefKind::AssocFn, def_id) = - cx.typeck_results().qpath_res(qpath, *path_hir_id) + cx.typeck_results.qpath_res(qpath, *path_hir_id) && let Some(fn_name) = cx.tcx.opt_item_name(def_id) { Some((fn_name, *arg_expr)) @@ -397,7 +397,7 @@ fn check_other_call_arg<'tcx>( && let Some(deref_trait_id) = cx.tcx.get_diagnostic_item(sym::Deref) && let Some(as_ref_trait_id) = cx.tcx.get_diagnostic_item(sym::AsRef) && (trait_predicate.def_id() == deref_trait_id || trait_predicate.def_id() == as_ref_trait_id) - && let receiver_ty = cx.typeck_results().expr_ty(receiver) + && let receiver_ty = cx.typeck_results.expr_ty(receiver) // We can't add an `&` when the trait is `Deref` because `Target = &T` won't match // `Target = T`. && let Some((n_refs, receiver_ty)) = if n_refs > 0 || is_copy(cx, receiver_ty) { @@ -457,16 +457,16 @@ fn get_callee_generic_args_and_args<'tcx>( &'tcx [Expr<'tcx>], )> { if let ExprKind::Call(callee, args) = expr.kind - && let callee_ty = cx.typeck_results().expr_ty(callee) + && let callee_ty = cx.typeck_results.expr_ty(callee) && let ty::FnDef(callee_def_id, _) = callee_ty.kind() { - let generic_args = cx.typeck_results().node_args(callee.hir_id); + let generic_args = cx.typeck_results.node_args(callee.hir_id); return Some((*callee_def_id, generic_args, None, args)); } if let ExprKind::MethodCall(_, recv, args, _) = expr.kind - && let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) + && let Some(method_def_id) = cx.typeck_results.type_dependent_def_id(expr.hir_id) { - let generic_args = cx.typeck_results().node_args(expr.hir_id); + let generic_args = cx.typeck_results.node_args(expr.hir_id); return Some((method_def_id, generic_args, Some(recv), args)); } None @@ -649,7 +649,7 @@ fn is_to_string_on_string_like<'a>( return false; } - if let Some(args) = cx.typeck_results().node_args_opt(call_expr.hir_id) + if let Some(args) = cx.typeck_results.node_args_opt(call_expr.hir_id) && let [generic_arg] = args.as_slice() && let GenericArgKind::Type(ty) = generic_arg.kind() && let Some(deref_trait_id) = cx.tcx.get_diagnostic_item(sym::Deref) @@ -693,7 +693,7 @@ fn is_slice_and_vec(cx: &LateContext<'_>, arg_ty: Ty<'_>, original_arg_ty: Ty<'_ fn check_if_applicable_to_argument<'tcx>(cx: &LateContext<'tcx>, arg: &Expr<'tcx>) { if let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Not, expr) = arg.kind && let ExprKind::MethodCall(method_path, caller, &[], _) = expr.kind - && let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) + && let Some(method_def_id) = cx.typeck_results.type_dependent_def_id(expr.hir_id) && let method_name = method_path.ident.name && match method_name { sym::to_owned => cx.tcx.is_diagnostic_item(sym::to_owned_method, method_def_id), @@ -704,8 +704,8 @@ fn check_if_applicable_to_argument<'tcx>(cx: &LateContext<'tcx>, arg: &Expr<'tcx .is_some_and(|impl_did| cx.tcx.type_of(impl_did).instantiate_identity().skip_norm_wip().is_slice()), _ => false, } - && let original_arg_ty = cx.typeck_results().node_type(caller.hir_id).peel_refs() - && let arg_ty = cx.typeck_results().expr_ty(arg) + && let original_arg_ty = cx.typeck_results.node_type(caller.hir_id).peel_refs() + && let arg_ty = cx.typeck_results.expr_ty(arg) && let ty::Ref(_, arg_ty, Mutability::Not) = arg_ty.kind() // FIXME: try to fix `can_change_type` to make it work in this case. // && can_change_type(cx, caller, *arg_ty) @@ -738,7 +738,7 @@ fn check_if_applicable_to_argument<'tcx>(cx: &LateContext<'tcx>, arg: &Expr<'tcx // 4. The key to the "map type" is not a reference. fn check_borrow_predicate<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) { if let ExprKind::MethodCall(_, caller, &[arg], _) = expr.kind - && let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) + && let Some(method_def_id) = cx.typeck_results.type_dependent_def_id(expr.hir_id) && cx.tcx.trait_of_assoc(method_def_id).is_none() && let Some(borrow_id) = cx.tcx.get_diagnostic_item(sym::Borrow) && cx.tcx.predicates_of(method_def_id).predicates.iter().any(|(pred, _)| { @@ -751,7 +751,7 @@ fn check_borrow_predicate<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) { false } }) - && let caller_ty = cx.typeck_results().expr_ty(caller) + && let caller_ty = cx.typeck_results.expr_ty(caller) // For now we limit it to "map types". && let Some(key_ty) = std_map_key(cx, caller_ty) // We need to check that the key type is not a reference. diff --git a/src/tools/clippy/clippy_lints/src/methods/unwrap_expect_used.rs b/src/tools/clippy/clippy_lints/src/methods/unwrap_expect_used.rs index ad7b0fc47cf3a..4f1a88ef0ef67 100644 --- a/src/tools/clippy/clippy_lints/src/methods/unwrap_expect_used.rs +++ b/src/tools/clippy/clippy_lints/src/methods/unwrap_expect_used.rs @@ -48,7 +48,7 @@ pub(super) fn check( unwrap_allowed_aliases: &[rustc_hir::def_id::DefId], variant: Variant, ) { - let ty = cx.typeck_results().expr_ty(recv).peel_refs(); + let ty = cx.typeck_results.expr_ty(recv).peel_refs(); let (kind, none_value, none_prefix) = match ty.opt_diag_name(cx) { Some(sym::Option) if !is_err => ("an `Option`", "None", ""), @@ -144,7 +144,7 @@ pub(super) fn check_call( let Some(recv) = args.first() else { return; }; - let Some((DefKind::AssocFn, def_id)) = cx.typeck_results().type_dependent_def(func.hir_id) else { + let Some((DefKind::AssocFn, def_id)) = cx.typeck_results.type_dependent_def(func.hir_id) else { return; }; diff --git a/src/tools/clippy/clippy_lints/src/methods/useless_asref.rs b/src/tools/clippy/clippy_lints/src/methods/useless_asref.rs index 3737249a40cb0..61a712e8278f3 100644 --- a/src/tools/clippy/clippy_lints/src/methods/useless_asref.rs +++ b/src/tools/clippy/clippy_lints/src/methods/useless_asref.rs @@ -44,14 +44,14 @@ fn get_enum_ty(enum_ty: Ty<'_>) -> Option> { pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, call_name: Symbol, recvr: &hir::Expr<'_>) { // when we get here, we've already checked that the call name is "as_ref" or "as_mut" // check if the call is to the actual `AsRef` or `AsMut` trait - let Some(def) = cx.typeck_results().type_dependent_def_id(expr.hir_id) else { + let Some(def) = cx.typeck_results.type_dependent_def_id(expr.hir_id) else { return; }; if def.opt_parent(cx).is_diag_item(cx, sym::AsRef) || def.opt_parent(cx).is_diag_item(cx, sym::AsMut) { // check if the type after `as_ref` or `as_mut` is the same as before - let rcv_ty = cx.typeck_results().expr_ty(recvr); - let res_ty = cx.typeck_results().expr_ty(expr); + let rcv_ty = cx.typeck_results.expr_ty(recvr); + let res_ty = cx.typeck_results.expr_ty(expr); let (base_res_ty, res_depth, _) = peel_and_count_ty_refs(res_ty); let (base_rcv_ty, rcv_depth, _) = peel_and_count_ty_refs(rcv_ty); if base_rcv_ty == base_res_ty && rcv_depth >= res_depth { @@ -108,8 +108,8 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, call_name: Symbo def.opt_parent(cx).opt_impl_ty(cx).opt_diag_name(cx), Some(sym::Option | sym::Result) ) { - let rcv_ty = cx.typeck_results().expr_ty(recvr).peel_refs(); - let res_ty = cx.typeck_results().expr_ty(expr).peel_refs(); + let rcv_ty = cx.typeck_results.expr_ty(recvr).peel_refs(); + let res_ty = cx.typeck_results.expr_ty(expr).peel_refs(); if let Some(rcv_ty) = get_enum_ty(rcv_ty) && let Some(res_ty) = get_enum_ty(res_ty) @@ -127,7 +127,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, call_name: Symbo && !should_call_clone_as_function(cx, rcv_ty) // https://github.com/rust-lang/rust-clippy/issues/12357 && let Some(clone_trait) = cx.tcx.lang_items().clone_trait() - && implements_trait(cx, cx.typeck_results().expr_ty(recvr), clone_trait, &[]) + && implements_trait(cx, cx.typeck_results.expr_ty(recvr), clone_trait, &[]) { lint_as_ref_clone(cx, expr.span.with_hi(parent.span.hi()), recvr, call_name); } @@ -155,12 +155,12 @@ fn is_calling_clone(cx: &LateContext<'_>, arg: &hir::Expr<'_>) -> bool { match closure_expr.kind { hir::ExprKind::MethodCall(method, obj, [], _) => { if method.ident.name == sym::clone - && let Some(fn_id) = cx.typeck_results().type_dependent_def_id(closure_expr.hir_id) + && let Some(fn_id) = cx.typeck_results.type_dependent_def_id(closure_expr.hir_id) && let Some(trait_id) = cx.tcx.trait_of_assoc(fn_id) // We check it's the `Clone` trait. && cx.tcx.lang_items().clone_trait().is_some_and(|id| id == trait_id) // no autoderefs - && !cx.typeck_results().expr_adjustments(obj).iter() + && !cx.typeck_results.expr_adjustments(obj).iter() .any(|a| matches!(a.kind, Adjust::Deref(DerefAdjustKind::Overloaded(..)))) && obj.res_local_id() == Some(local_id) { diff --git a/src/tools/clippy/clippy_lints/src/methods/useless_nonzero_new_unchecked.rs b/src/tools/clippy/clippy_lints/src/methods/useless_nonzero_new_unchecked.rs index c6f54159c7a78..70a4d96b14e6c 100644 --- a/src/tools/clippy/clippy_lints/src/methods/useless_nonzero_new_unchecked.rs +++ b/src/tools/clippy/clippy_lints/src/methods/useless_nonzero_new_unchecked.rs @@ -15,7 +15,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, func: &Expr<' && segment.ident.name == sym::new_unchecked && let [init_arg] = args && is_inside_always_const_context(cx.tcx, expr.hir_id) - && cx.typeck_results().node_type(ty.hir_id).is_diag_item(cx, sym::NonZero) + && cx.typeck_results.node_type(ty.hir_id).is_diag_item(cx, sym::NonZero) && msrv.meets(cx, msrvs::CONST_UNWRAP) { let mut app = Applicability::MachineApplicable; diff --git a/src/tools/clippy/clippy_lints/src/methods/utils.rs b/src/tools/clippy/clippy_lints/src/methods/utils.rs index 33346d867ffee..eb953cb52929e 100644 --- a/src/tools/clippy/clippy_lints/src/methods/utils.rs +++ b/src/tools/clippy/clippy_lints/src/methods/utils.rs @@ -28,7 +28,7 @@ pub(super) fn derefs_to_slice<'tcx>( } if let ExprKind::MethodCall(path, self_arg, ..) = &expr.kind { - if path.ident.name == sym::iter && may_slice(cx, cx.typeck_results().expr_ty(self_arg)) { + if path.ident.name == sym::iter && may_slice(cx, cx.typeck_results.expr_ty(self_arg)) { Some(self_arg) } else { None @@ -110,7 +110,7 @@ impl<'tcx> Visitor<'tcx> for CloneOrCopyVisitor<'_, 'tcx> { }, ExprKind::MethodCall(.., args, _) => { if args.iter().all(|arg| !self.is_binding(arg)) - && let Some(method_def_id) = self.cx.typeck_results().type_dependent_def_id(parent.hir_id) + && let Some(method_def_id) = self.cx.typeck_results.type_dependent_def_id(parent.hir_id) && let method_ty = self .cx .tcx diff --git a/src/tools/clippy/clippy_lints/src/methods/vec_resize_to_zero.rs b/src/tools/clippy/clippy_lints/src/methods/vec_resize_to_zero.rs index eed2ebebc0281..0c93b76e1e99a 100644 --- a/src/tools/clippy/clippy_lints/src/methods/vec_resize_to_zero.rs +++ b/src/tools/clippy/clippy_lints/src/methods/vec_resize_to_zero.rs @@ -16,7 +16,7 @@ pub(super) fn check<'tcx>( default_arg: &'tcx Expr<'_>, name_span: Span, ) { - if let Some(method_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) + if let Some(method_id) = cx.typeck_results.type_dependent_def_id(expr.hir_id) && let Some(impl_id) = cx.tcx.impl_of_assoc(method_id) && cx .tcx diff --git a/src/tools/clippy/clippy_lints/src/methods/verbose_file_reads.rs b/src/tools/clippy/clippy_lints/src/methods/verbose_file_reads.rs index b67e084a35332..d7b32accd20e9 100644 --- a/src/tools/clippy/clippy_lints/src/methods/verbose_file_reads.rs +++ b/src/tools/clippy/clippy_lints/src/methods/verbose_file_reads.rs @@ -21,7 +21,7 @@ pub(super) fn check<'tcx>( if cx.ty_based_def(expr).opt_parent(cx).is_diag_item(cx, sym::IoRead) && matches!(recv.kind, ExprKind::Path(QPath::Resolved(None, _))) && cx - .typeck_results() + .typeck_results .expr_ty_adjusted(recv) .peel_refs() .is_diag_item(cx, sym::File) diff --git a/src/tools/clippy/clippy_lints/src/methods/waker_clone_wake.rs b/src/tools/clippy/clippy_lints/src/methods/waker_clone_wake.rs index bb26c2d935784..9d37d9b45a8a1 100644 --- a/src/tools/clippy/clippy_lints/src/methods/waker_clone_wake.rs +++ b/src/tools/clippy/clippy_lints/src/methods/waker_clone_wake.rs @@ -9,7 +9,7 @@ use rustc_lint::LateContext; use super::WAKER_CLONE_WAKE; pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, recv: &'tcx Expr<'_>) { - let ty = cx.typeck_results().expr_ty(recv); + let ty = cx.typeck_results.expr_ty(recv); if let Some(did) = ty.ty_adt_def() && cx.tcx.is_diagnostic_item(sym::Waker, did.did()) diff --git a/src/tools/clippy/clippy_lints/src/methods/zst_offset.rs b/src/tools/clippy/clippy_lints/src/methods/zst_offset.rs index 941afb9e2a988..9e90d453820de 100644 --- a/src/tools/clippy/clippy_lints/src/methods/zst_offset.rs +++ b/src/tools/clippy/clippy_lints/src/methods/zst_offset.rs @@ -8,7 +8,7 @@ use rustc_span::sym; use super::ZST_OFFSET; pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>) { - let recv_ty = cx.typeck_results().expr_ty(recv); + let recv_ty = cx.typeck_results.expr_ty(recv); let pointee_ty = match recv_ty.kind() { ty::RawPtr(ty, _) => *ty, ty::Adt(_, args) if recv_ty.is_diag_item(cx, sym::NonNull) => args.type_at(0), diff --git a/src/tools/clippy/clippy_lints/src/minmax.rs b/src/tools/clippy/clippy_lints/src/minmax.rs index ba62853c74571..b7039b85ffc7b 100644 --- a/src/tools/clippy/clippy_lints/src/minmax.rs +++ b/src/tools/clippy/clippy_lints/src/minmax.rs @@ -40,7 +40,7 @@ impl<'tcx> LateLintPass<'tcx> for MinMaxPass { if let Some((outer_max, outer_c, oe)) = min_max(cx, expr) && let Some((inner_max, inner_c, ie)) = min_max(cx, oe) && outer_max != inner_max - && let Some(ord) = Constant::partial_cmp(cx.tcx, cx.typeck_results().expr_ty(ie), &outer_c, &inner_c) + && let Some(ord) = Constant::partial_cmp(cx.tcx, cx.typeck_results.expr_ty(ie), &outer_c, &inner_c) && matches!( (outer_max, ord), (MinMax::Max, Equal | Greater) | (MinMax::Min, Equal | Less) @@ -66,7 +66,7 @@ fn min_max<'a>(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Option<(MinMax, Cons match expr.kind { ExprKind::Call(path, args) => { if let ExprKind::Path(ref qpath) = path.kind { - cx.typeck_results() + cx.typeck_results .qpath_res(qpath, path.hir_id) .opt_def_id() .and_then(|def_id| match cx.tcx.get_diagnostic_name(def_id) { @@ -79,7 +79,7 @@ fn min_max<'a>(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Option<(MinMax, Cons } }, ExprKind::MethodCall(path, receiver, args @ [_], _) => { - if cx.typeck_results().expr_ty(receiver).is_floating_point() + if cx.typeck_results.expr_ty(receiver).is_floating_point() || cx.ty_based_def(expr).opt_parent(cx).is_diag_item(cx, sym::Ord) { match path.ident.name { diff --git a/src/tools/clippy/clippy_lints/src/misc.rs b/src/tools/clippy/clippy_lints/src/misc.rs index 0bfb28d6b8bf4..f20db6c1dba62 100644 --- a/src/tools/clippy/clippy_lints/src/misc.rs +++ b/src/tools/clippy/clippy_lints/src/misc.rs @@ -150,7 +150,7 @@ fn used_underscore_items<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) { } }, ExprKind::MethodCall(path, ..) => { - if let Some(def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) { + if let Some(def_id) = cx.typeck_results.type_dependent_def_id(expr.hir_id) { (def_id, path.ident) } else { return; @@ -201,7 +201,7 @@ fn used_underscore_binding<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) { } }, ExprKind::Field(recv, ident) => { - if let Some(adt_def) = cx.typeck_results().expr_ty_adjusted(recv).ty_adt_def() + if let Some(adt_def) = cx.typeck_results.expr_ty_adjusted(recv).ty_adt_def() && let Some(field) = adt_def.all_fields().find(|field| field.name == ident.name) && let Some(local_did) = field.did.as_local() && !cx.tcx.type_of(field.did).skip_binder().is_phantom_data() diff --git a/src/tools/clippy/clippy_lints/src/missing_asserts_for_indexing.rs b/src/tools/clippy/clippy_lints/src/missing_asserts_for_indexing.rs index 885e0c4ed527d..7ba9b8aa21ab7 100644 --- a/src/tools/clippy/clippy_lints/src/missing_asserts_for_indexing.rs +++ b/src/tools/clippy/clippy_lints/src/missing_asserts_for_indexing.rs @@ -138,7 +138,7 @@ fn assert_len_expr<'hir>( && let ExprKind::Binary(bin_op, left, right) = &condition.kind // check if `then` block has a never type expression && let ExprKind::Block(Block { expr: Some(then_expr), .. }, _) = then.kind - && cx.typeck_results().expr_ty(then_expr).is_never() + && cx.typeck_results.expr_ty(then_expr).is_never() { (len_comparison(bin_op.node, left, right)?, sym::assert_macro) } else if let Some((macro_call, bin_op)) = first_node_macro_backtrace(cx, expr).find_map(|macro_call| { @@ -160,7 +160,7 @@ fn assert_len_expr<'hir>( }; if let ExprKind::MethodCall(method, recv, [], _) = &slice_len.kind - && cx.typeck_results().expr_ty_adjusted(recv).peel_refs().is_slice() + && cx.typeck_results.expr_ty_adjusted(recv).peel_refs().is_slice() && method.ident.name == sym::len { Some((cmp, asserted_len, recv, macro_call)) @@ -239,7 +239,7 @@ fn upper_index_expr(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option { /// Checks if the expression is an index into a slice and adds it to `indexes` fn check_index<'hir>(cx: &LateContext<'_>, expr: &'hir Expr<'hir>, map: &mut UnindexMap>>) { if let ExprKind::Index(slice, index_lit, _) = expr.kind - && cx.typeck_results().expr_ty_adjusted(slice).peel_refs().is_slice() + && cx.typeck_results.expr_ty_adjusted(slice).peel_refs().is_slice() && let Some(index) = upper_index_expr(cx, index_lit) { let hash = hash_expr(cx, slice); diff --git a/src/tools/clippy/clippy_lints/src/missing_fields_in_debug.rs b/src/tools/clippy/clippy_lints/src/missing_fields_in_debug.rs index 634745422204f..8f2d8de071029 100644 --- a/src/tools/clippy/clippy_lints/src/missing_fields_in_debug.rs +++ b/src/tools/clippy/clippy_lints/src/missing_fields_in_debug.rs @@ -224,7 +224,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingFieldsInDebug { && let Some(self_adt) = self_ty.ty_adt_def() && let Some(self_def_id) = self_adt.did().as_local() && let Node::Item(self_item) = cx.tcx.hir_node_by_def_id(self_def_id) - // NB: can't call cx.typeck_results() as we are not in a body + // NB: can't call cx.typeck_results as we are not in a body && let typeck_results = cx.tcx.typeck_body(body.id()) && should_lint(cx, typeck_results, block) // we intentionally only lint structs, see lint description diff --git a/src/tools/clippy/clippy_lints/src/mixed_read_write_in_expression.rs b/src/tools/clippy/clippy_lints/src/mixed_read_write_in_expression.rs index 99561e60f725a..dc3d821cabd1a 100644 --- a/src/tools/clippy/clippy_lints/src/mixed_read_write_in_expression.rs +++ b/src/tools/clippy/clippy_lints/src/mixed_read_write_in_expression.rs @@ -170,7 +170,7 @@ impl<'tcx> Visitor<'tcx> for DivergenceVisitor<'_, 'tcx> { }, ExprKind::Continue(_) | ExprKind::Break(_, _) | ExprKind::Ret(_) => self.report_diverging_sub_expr(e), ExprKind::Call(func, _) => { - let typ = self.cx.typeck_results().expr_ty(func); + let typ = self.cx.typeck_results.expr_ty(func); if typ.is_fn() { let sig = typ.fn_sig(self.cx.tcx); if self.cx.tcx.instantiate_bound_regions_with_erased(sig).output().kind() == &ty::Never { @@ -179,7 +179,7 @@ impl<'tcx> Visitor<'tcx> for DivergenceVisitor<'_, 'tcx> { } }, ExprKind::MethodCall(..) => { - let borrowed_table = self.cx.typeck_results(); + let borrowed_table = self.cx.typeck_results; if borrowed_table.expr_ty(e).is_never() { self.report_diverging_sub_expr(e); } diff --git a/src/tools/clippy/clippy_lints/src/multiple_unsafe_ops_per_block.rs b/src/tools/clippy/clippy_lints/src/multiple_unsafe_ops_per_block.rs index 7e96507a27b16..c8d20c897ea1b 100644 --- a/src/tools/clippy/clippy_lints/src/multiple_unsafe_ops_per_block.rs +++ b/src/tools/clippy/clippy_lints/src/multiple_unsafe_ops_per_block.rs @@ -110,7 +110,7 @@ impl<'tcx> UnsafeExprCollector<'tcx> { fn collect_unsafe_exprs(cx: &LateContext<'tcx>, block: &'tcx hir::Block<'tcx>) -> Vec<(&'static str, Span)> { let mut collector = Self { tcx: cx.tcx, - typeck_results: cx.typeck_results(), + typeck_results: cx.typeck_results, unsafe_ops: FxHashMap::default(), }; collector.visit_block(block); diff --git a/src/tools/clippy/clippy_lints/src/mut_key.rs b/src/tools/clippy/clippy_lints/src/mut_key.rs index 93282545bf2a1..404098db5e6cb 100644 --- a/src/tools/clippy/clippy_lints/src/mut_key.rs +++ b/src/tools/clippy/clippy_lints/src/mut_key.rs @@ -98,7 +98,7 @@ impl<'tcx> LateLintPass<'tcx> for MutableKeyType<'tcx> { if let hir::PatKind::Wild = local.pat.kind { return; } - self.check_ty_(cx, local.span, cx.typeck_results().pat_ty(local.pat)); + self.check_ty_(cx, local.span, cx.typeck_results.pat_ty(local.pat)); } } diff --git a/src/tools/clippy/clippy_lints/src/mut_mut.rs b/src/tools/clippy/clippy_lints/src/mut_mut.rs index 588afd85afb02..8a9d234558ab9 100644 --- a/src/tools/clippy/clippy_lints/src/mut_mut.rs +++ b/src/tools/clippy/clippy_lints/src/mut_mut.rs @@ -159,7 +159,7 @@ impl<'tcx> intravisit::Visitor<'tcx> for MutVisitor<'_, 'tcx> { ); }, ); - } else if let ty::Ref(_, ty, Mutability::Mut) = self.cx.typeck_results().expr_ty(e).kind() + } else if let ty::Ref(_, ty, Mutability::Mut) = self.cx.typeck_results.expr_ty(e).kind() && ty.peel_refs().is_sized(self.cx.tcx, self.cx.typing_env()) { let mut applicability = Applicability::MaybeIncorrect; diff --git a/src/tools/clippy/clippy_lints/src/mutable_debug_assertion.rs b/src/tools/clippy/clippy_lints/src/mutable_debug_assertion.rs index a18817ac716b8..07d8e79207509 100644 --- a/src/tools/clippy/clippy_lints/src/mutable_debug_assertion.rs +++ b/src/tools/clippy/clippy_lints/src/mutable_debug_assertion.rs @@ -110,7 +110,7 @@ impl<'tcx> Visitor<'tcx> for MutArgVisitor<'_, 'tcx> { return; }, ExprKind::Path(_) => { - if let Some(adj) = self.cx.typeck_results().adjustments().get(expr.hir_id) + if let Some(adj) = self.cx.typeck_results.adjustments().get(expr.hir_id) && adj .iter() .any(|a| matches!(a.target.kind(), ty::Ref(_, _, Mutability::Mut))) diff --git a/src/tools/clippy/clippy_lints/src/mutex_atomic.rs b/src/tools/clippy/clippy_lints/src/mutex_atomic.rs index ad44d65b4d663..72416309a1f73 100644 --- a/src/tools/clippy/clippy_lints/src/mutex_atomic.rs +++ b/src/tools/clippy/clippy_lints/src/mutex_atomic.rs @@ -109,7 +109,7 @@ impl<'tcx> LateLintPass<'tcx> for Mutex { if !stmt.span.from_expansion() && let Some(init) = stmt.init { - let mid_ty = cx.typeck_results().expr_ty(init); + let mid_ty = cx.typeck_results.expr_ty(init); check_expr(cx, init.peel_blocks(), &TypeAscriptionKind::Optional(stmt.ty), mid_ty); } } diff --git a/src/tools/clippy/clippy_lints/src/needless_borrows_for_generic_args.rs b/src/tools/clippy/clippy_lints/src/needless_borrows_for_generic_args.rs index f8fe6aa15d324..d11306c61a5ca 100644 --- a/src/tools/clippy/clippy_lints/src/needless_borrows_for_generic_args.rs +++ b/src/tools/clippy/clippy_lints/src/needless_borrows_for_generic_args.rs @@ -83,7 +83,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessBorrowsForGenericArgs<'tcx> { fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) { if matches!(expr.kind, ExprKind::AddrOf(..)) && !expr.span.from_expansion() - && let use_site = get_expr_use_site(cx.tcx, cx.typeck_results(), SyntaxContext::root(), expr) + && let use_site = get_expr_use_site(cx.tcx, cx.typeck_results, SyntaxContext::root(), expr) && use_site.same_ctxt && !use_site.is_ty_unified && let use_node = use_site.use_node(cx) @@ -92,7 +92,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessBorrowsForGenericArgs<'tcx> { && let Some((hir_id, fn_id, i)) = match use_node { ExprUseNode::MethodArg(_, _, 0) => None, ExprUseNode::MethodArg(hir_id, None, i) => cx - .typeck_results() + .typeck_results .type_dependent_def_id(hir_id) .map(|id| (hir_id, id, i)), ExprUseNode::FnArg( @@ -102,7 +102,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessBorrowsForGenericArgs<'tcx> { .. }, i, - ) if !path_has_args(p) => match cx.typeck_results().qpath_res(p, hir_id) { + ) if !path_has_args(p) => match cx.typeck_results.qpath_res(p, hir_id) { Res::Def(DefKind::Fn | DefKind::Ctor(..) | DefKind::AssocFn, id) => Some((hir_id, id, i)), _ => None, }, @@ -112,7 +112,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessBorrowsForGenericArgs<'tcx> { cx, &mut self.possible_borrowers, fn_id, - cx.typeck_results().node_args(hir_id), + cx.typeck_results.node_args(hir_id), i, param_ty, expr, @@ -240,13 +240,13 @@ fn needless_borrow_count<'tcx>( let mut check_reference_and_referent = |reference: &Expr<'tcx>, referent: &Expr<'tcx>| { if let ExprKind::Field(base, _) = &referent.kind - && let base_ty = cx.typeck_results().expr_ty(base) + && let base_ty = cx.typeck_results.expr_ty(base) && drop_trait_def_id.is_some_and(|id| implements_trait(cx, base_ty, id, &[])) { return false; } - let referent_ty = cx.typeck_results().expr_ty(referent); + let referent_ty = cx.typeck_results.expr_ty(referent); if !(is_copy(cx, referent_ty) || referent_ty.is_ref() && referent_used_exactly_once(cx, possible_borrowers, reference) diff --git a/src/tools/clippy/clippy_lints/src/needless_continue.rs b/src/tools/clippy/clippy_lints/src/needless_continue.rs index d1d0d31ed91a5..08a6bf579b84e 100644 --- a/src/tools/clippy/clippy_lints/src/needless_continue.rs +++ b/src/tools/clippy/clippy_lints/src/needless_continue.rs @@ -432,7 +432,7 @@ where } }, ExprKind::Match(_, arms, _) => { - let match_ty = cx.typeck_results().expr_ty(inner_expr); + let match_ty = cx.typeck_results.expr_ty(inner_expr); if !match_ty.is_unit() && !match_ty.is_never() { return; } diff --git a/src/tools/clippy/clippy_lints/src/needless_for_each.rs b/src/tools/clippy/clippy_lints/src/needless_for_each.rs index 55a5a16c00991..1f852bd95de5b 100644 --- a/src/tools/clippy/clippy_lints/src/needless_for_each.rs +++ b/src/tools/clippy/clippy_lints/src/needless_for_each.rs @@ -80,7 +80,7 @@ fn check_expr(cx: &LateContext<'_>, expr: &Expr<'_>, outer_span: Span) { && method_name.ident.name == sym::for_each && cx.ty_based_def(expr).opt_parent(cx).is_diag_item(cx, sym::Iterator) // Checks the type of the `iter` method receiver is NOT a user defined type. - && has_iter_method(cx, cx.typeck_results().expr_ty(iter_recv)).is_some() + && has_iter_method(cx, cx.typeck_results.expr_ty(iter_recv)).is_some() // Skip the lint if the body is not block because this is simpler than `for` loop. // e.g. `v.iter().for_each(f)` is simpler and clearer than using `for` loop. && let ExprKind::Closure(&Closure { body, fn_decl, .. }) = for_each_arg.kind diff --git a/src/tools/clippy/clippy_lints/src/needless_late_init.rs b/src/tools/clippy/clippy_lints/src/needless_late_init.rs index bc4f6ca401710..0825265caaafc 100644 --- a/src/tools/clippy/clippy_lints/src/needless_late_init.rs +++ b/src/tools/clippy/clippy_lints/src/needless_late_init.rs @@ -91,7 +91,7 @@ fn stmt_needs_ordered_drop(cx: &LateContext<'_>, stmt: &Stmt<'_>) -> bool { }; !local.pat.walk_short(|pat| { if let PatKind::Binding(.., None) = pat.kind { - !needs_ordered_drop(cx, cx.typeck_results().pat_ty(pat)) + !needs_ordered_drop(cx, cx.typeck_results.pat_ty(pat)) } else { true } @@ -164,7 +164,7 @@ fn assignment_suggestions<'tcx>( let mut assignments = Vec::new(); for expr in exprs { - let ty = cx.typeck_results().expr_ty(expr); + let ty = cx.typeck_results.expr_ty(expr); if ty.is_never() { continue; @@ -215,7 +215,7 @@ fn first_usage<'tcx>( local_stmt_id: HirId, block: &'tcx Block<'tcx>, ) -> Option> { - let significant_drop = needs_ordered_drop(cx, cx.typeck_results().node_type(binding_id)); + let significant_drop = needs_ordered_drop(cx, cx.typeck_results.node_type(binding_id)); block .stmts diff --git a/src/tools/clippy/clippy_lints/src/needless_pass_by_ref_mut.rs b/src/tools/clippy/clippy_lints/src/needless_pass_by_ref_mut.rs index 91358ef77fa1e..4f5f8855c13c0 100644 --- a/src/tools/clippy/clippy_lints/src/needless_pass_by_ref_mut.rs +++ b/src/tools/clippy/clippy_lints/src/needless_pass_by_ref_mut.rs @@ -240,7 +240,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByRefMut<'tcx> { fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) { // #11182; do not lint if mutability is required elsewhere if let ExprKind::Path(..) = expr.kind - && let ty::FnDef(def_id, _) = cx.typeck_results().expr_ty(expr).kind() + && let ty::FnDef(def_id, _) = cx.typeck_results.expr_ty(expr).kind() && let Some(def_id) = def_id.as_local() { if let Node::Expr(e) = cx.tcx.parent_hir_node(expr.hir_id) diff --git a/src/tools/clippy/clippy_lints/src/needless_question_mark.rs b/src/tools/clippy/clippy_lints/src/needless_question_mark.rs index 29c45168b61e5..15109fa986c7c 100644 --- a/src/tools/clippy/clippy_lints/src/needless_question_mark.rs +++ b/src/tools/clippy/clippy_lints/src/needless_question_mark.rs @@ -108,8 +108,8 @@ fn check(cx: &LateContext<'_>, expr: &Expr<'_>) { && let ExprKind::Path(qpath) = called.kind && cx.tcx.qpath_is_lang_item(qpath, LangItem::TryTraitBranch) && expr.span.eq_ctxt(inner_expr.span) - && let expr_ty = cx.typeck_results().expr_ty(expr) - && let inner_ty = cx.typeck_results().expr_ty(inner_expr) + && let expr_ty = cx.typeck_results.expr_ty(expr) + && let inner_ty = cx.typeck_results.expr_ty(inner_expr) && expr_ty == inner_ty { span_lint_hir_and_then( diff --git a/src/tools/clippy/clippy_lints/src/needless_update.rs b/src/tools/clippy/clippy_lints/src/needless_update.rs index 4a86c3720ca24..1c37d854ba383 100644 --- a/src/tools/clippy/clippy_lints/src/needless_update.rs +++ b/src/tools/clippy/clippy_lints/src/needless_update.rs @@ -52,7 +52,7 @@ declare_lint_pass!(NeedlessUpdate => [NEEDLESS_UPDATE]); impl<'tcx> LateLintPass<'tcx> for NeedlessUpdate { fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) { if let ExprKind::Struct(_, fields, StructTailExpr::Base(base)) = expr.kind { - let ty = cx.typeck_results().expr_ty(expr); + let ty = cx.typeck_results.expr_ty(expr); if let ty::Adt(def, _) = ty.kind() && fields.len() == def.non_enum_variant().fields.len() && !def.variant(0_usize.into()).is_field_list_non_exhaustive() diff --git a/src/tools/clippy/clippy_lints/src/neg_cmp_op_on_partial_ord.rs b/src/tools/clippy/clippy_lints/src/neg_cmp_op_on_partial_ord.rs index 4f62ba2e58db2..038d78a20053c 100644 --- a/src/tools/clippy/clippy_lints/src/neg_cmp_op_on_partial_ord.rs +++ b/src/tools/clippy/clippy_lints/src/neg_cmp_op_on_partial_ord.rs @@ -49,7 +49,7 @@ impl<'tcx> LateLintPass<'tcx> for NoNegCompOpForPartialOrd { && let BinOpKind::Le | BinOpKind::Ge | BinOpKind::Lt | BinOpKind::Gt = op.node && !expr.span.in_external_macro(cx.sess().source_map()) { - let ty = cx.typeck_results().expr_ty(left); + let ty = cx.typeck_results.expr_ty(left); let implements_ord = { if let Some(id) = cx.tcx.get_diagnostic_item(sym::Ord) { diff --git a/src/tools/clippy/clippy_lints/src/neg_multiply.rs b/src/tools/clippy/clippy_lints/src/neg_multiply.rs index 946114e104195..9993cd6387b19 100644 --- a/src/tools/clippy/clippy_lints/src/neg_multiply.rs +++ b/src/tools/clippy/clippy_lints/src/neg_multiply.rs @@ -66,14 +66,14 @@ fn check_mul(cx: &LateContext<'_>, mul_expr: &Expr<'_>, lit: &Expr<'_>, exp: &Ex const F128_ONE: u128 = 1.0_f128.to_bits(); if let ExprKind::Lit(l) = lit.kind && matches!( - consts::lit_to_mir_constant(&l.node, cx.typeck_results().expr_ty_opt(lit)), + consts::lit_to_mir_constant(&l.node, cx.typeck_results.expr_ty_opt(lit)), Constant::Int(1) | Constant::F16(F16_ONE) | Constant::F32(1.0) | Constant::F64(1.0) | Constant::F128(F128_ONE) ) - && cx.typeck_results().expr_ty(exp).is_numeric() + && cx.typeck_results.expr_ty(exp).is_numeric() { let mut applicability = Applicability::MachineApplicable; let (snip, from_macro) = snippet_with_context(cx, exp.span, mul_expr.span.ctxt(), "..", &mut applicability); diff --git a/src/tools/clippy/clippy_lints/src/no_effect.rs b/src/tools/clippy/clippy_lints/src/no_effect.rs index f2a54b99170e9..ac0cbc503704e 100644 --- a/src/tools/clippy/clippy_lints/src/no_effect.rs +++ b/src/tools/clippy/clippy_lints/src/no_effect.rs @@ -151,7 +151,7 @@ impl NoEffect { && let [.., final_stmt] = block.stmts && final_stmt.hir_id == stmt.hir_id { - let expr_ty = cx.typeck_results().expr_ty(expr); + let expr_ty = cx.typeck_results.expr_ty(expr); let mut ret_ty = cx .tcx .fn_sig(item.owner_id) @@ -219,7 +219,7 @@ fn is_operator_overridden(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool { // reference: rust/compiler/rustc_middle/src/ty/typeck_results.rs: `is_method_call`. // use this function to check whether operator is overridden in `ExprKind::{Binary, Unary}`. - cx.typeck_results().is_method_call(expr) + cx.typeck_results.is_method_call(expr) }, _ => false, } @@ -227,7 +227,7 @@ fn is_operator_overridden(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool { /// Checks if dropping `expr` might have a visible side effect. fn expr_ty_has_significant_drop(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool { - let ty = cx.typeck_results().expr_ty(expr); + let ty = cx.typeck_results.expr_ty(expr); ty.has_significant_drop(cx.tcx, cx.typing_env()) } @@ -253,7 +253,7 @@ fn has_no_effect(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool { }, ExprKind::Call(callee, args) => { if let ExprKind::Path(ref qpath) = callee.kind { - if cx.typeck_results().type_dependent_def(expr.hir_id).is_some() { + if cx.typeck_results.type_dependent_def(expr.hir_id).is_some() { // type-dependent function call like `impl FnOnce for X` return false; } @@ -353,7 +353,7 @@ fn reduce_expression<'a>(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Option { - if has_drop(cx, cx.typeck_results().expr_ty(expr)) { + if has_drop(cx, cx.typeck_results.expr_ty(expr)) { None } else { let base = match base { @@ -365,14 +365,14 @@ fn reduce_expression<'a>(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Option { if let ExprKind::Path(ref qpath) = callee.kind { - if cx.typeck_results().type_dependent_def(expr.hir_id).is_some() { + if cx.typeck_results.type_dependent_def(expr.hir_id).is_some() { // type-dependent function call like `impl FnOnce for X` return None; } let res = cx.qpath_res(qpath, callee.hir_id); match res { Res::Def(DefKind::Struct | DefKind::Variant | DefKind::Ctor(..), ..) - if !has_drop(cx, cx.typeck_results().expr_ty(expr)) => + if !has_drop(cx, cx.typeck_results.expr_ty(expr)) => { Some(args.iter().collect()) }, diff --git a/src/tools/clippy/clippy_lints/src/non_copy_const.rs b/src/tools/clippy/clippy_lints/src/non_copy_const.rs index 22d7d83d730d9..f58c4dc873eb3 100644 --- a/src/tools/clippy/clippy_lints/src/non_copy_const.rs +++ b/src/tools/clippy/clippy_lints/src/non_copy_const.rs @@ -852,7 +852,7 @@ impl<'tcx> LateLintPass<'tcx> for NonCopyConst<'tcx> { fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) { if let ExprKind::Path(qpath) = &e.kind - && let typeck = cx.typeck_results() + && let typeck = cx.typeck_results && let Res::Def(DefKind::Const { .. } | DefKind::AssocConst { .. }, did) = typeck.qpath_res(qpath, e.hir_id) // As of `1.80` constant contexts can't borrow any type with interior mutability && !is_in_const_context(cx) diff --git a/src/tools/clippy/clippy_lints/src/non_octal_unix_permissions.rs b/src/tools/clippy/clippy_lints/src/non_octal_unix_permissions.rs index cb934466bd890..e69cc22b23358 100644 --- a/src/tools/clippy/clippy_lints/src/non_octal_unix_permissions.rs +++ b/src/tools/clippy/clippy_lints/src/non_octal_unix_permissions.rs @@ -42,7 +42,7 @@ impl<'tcx> LateLintPass<'tcx> for NonOctalUnixPermissions { fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) { match &expr.kind { ExprKind::MethodCall(path, func, [param], _) => { - if let Some(adt) = cx.typeck_results().expr_ty(func).peel_refs().ty_adt_def() + if let Some(adt) = cx.typeck_results.expr_ty(func).peel_refs().ty_adt_def() && matches!( (cx.tcx.get_diagnostic_name(adt.did()), path.ident.name), (Some(sym::FsOpenOptions | sym::DirBuilder), sym::mode) diff --git a/src/tools/clippy/clippy_lints/src/non_std_lazy_statics.rs b/src/tools/clippy/clippy_lints/src/non_std_lazy_statics.rs index 487eaecf18890..17816da9c4166 100644 --- a/src/tools/clippy/clippy_lints/src/non_std_lazy_statics.rs +++ b/src/tools/clippy/clippy_lints/src/non_std_lazy_statics.rs @@ -137,7 +137,7 @@ impl<'hir> LateLintPass<'hir> for NonStdLazyStatic { && let Some(call_def_id) = fn_def_id(cx, expr) && self.sugg_map.contains_key(&call_def_id) && let ExprKind::Path(qpath) = arg.peel_borrows().kind - && let Some(arg_def_id) = cx.typeck_results().qpath_res(&qpath, arg.hir_id).opt_def_id() + && let Some(arg_def_id) = cx.typeck_results.qpath_res(&qpath, arg.hir_id).opt_def_id() && let Some(lazy_info) = self.lazy_type_defs.get_mut(&arg_def_id) { lazy_info.calls_span_and_id.insert(callee.span, call_def_id); diff --git a/src/tools/clippy/clippy_lints/src/non_zero_suggestions.rs b/src/tools/clippy/clippy_lints/src/non_zero_suggestions.rs index 1b8ab1bdedf8a..70af29dfdcae6 100644 --- a/src/tools/clippy/clippy_lints/src/non_zero_suggestions.rs +++ b/src/tools/clippy/clippy_lints/src/non_zero_suggestions.rs @@ -75,8 +75,8 @@ fn check_non_zero_conversion(cx: &LateContext<'_>, expr: &Expr<'_>, applicabilit && rcv_path.ident.name == sym::get { let fn_name = cx.tcx.item_name(def_id); - let target_ty = cx.typeck_results().expr_ty(expr); - let receiver_ty = cx.typeck_results().expr_ty(receiver); + let target_ty = cx.typeck_results.expr_ty(expr); + let receiver_ty = cx.typeck_results.expr_ty(receiver); // Check if the receiver type is a NonZero type if let ty::Adt(adt_def, _) = receiver_ty.kind() diff --git a/src/tools/clippy/clippy_lints/src/only_used_in_recursion.rs b/src/tools/clippy/clippy_lints/src/only_used_in_recursion.rs index 2bb5615cfb767..f41f0ca7bcba2 100644 --- a/src/tools/clippy/clippy_lints/src/only_used_in_recursion.rs +++ b/src/tools/clippy/clippy_lints/src/only_used_in_recursion.rs @@ -367,7 +367,7 @@ impl<'tcx> LateLintPass<'tcx> for OnlyUsedInRecursion { if let Some(id) = e.res_local_id() && let Some(param) = self.params.get_by_id_mut(id) { - let typeck = cx.typeck_results(); + let typeck = cx.typeck_results; let span = e.span; let mut e = e; loop { diff --git a/src/tools/clippy/clippy_lints/src/operators/absurd_extreme_comparisons.rs b/src/tools/clippy/clippy_lints/src/operators/absurd_extreme_comparisons.rs index dbc9948eeedc7..05b7c8548e094 100644 --- a/src/tools/clippy/clippy_lints/src/operators/absurd_extreme_comparisons.rs +++ b/src/tools/clippy/clippy_lints/src/operators/absurd_extreme_comparisons.rs @@ -64,8 +64,8 @@ enum AbsurdComparisonResult { fn is_cast_between_fixed_and_target<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool { if let ExprKind::Cast(cast_exp, _) = expr.kind { - let precast_ty = cx.typeck_results().expr_ty(cast_exp); - let cast_ty = cx.typeck_results().expr_ty(expr); + let precast_ty = cx.typeck_results.expr_ty(cast_exp); + let cast_ty = cx.typeck_results.expr_ty(expr); return is_isize_or_usize(precast_ty) != is_isize_or_usize(cast_ty); } @@ -83,7 +83,7 @@ fn detect_absurd_comparison<'tcx>( use ExtremeType::{Maximum, Minimum}; // absurd comparison only makes sense on primitive types // primitive types don't implement comparison operators with each other - if cx.typeck_results().expr_ty(lhs) != cx.typeck_results().expr_ty(rhs) { + if cx.typeck_results.expr_ty(lhs) != cx.typeck_results.expr_ty(rhs) { return None; } @@ -119,7 +119,7 @@ fn detect_absurd_comparison<'tcx>( } fn detect_extreme_expr<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option> { - let ty = cx.typeck_results().expr_ty(expr); + let ty = cx.typeck_results.expr_ty(expr); let cv = ConstEvalCtxt::new(cx).eval(expr)?; diff --git a/src/tools/clippy/clippy_lints/src/operators/arithmetic_side_effects.rs b/src/tools/clippy/clippy_lints/src/operators/arithmetic_side_effects.rs index 6891ecb0cf9d8..c661383b9ef77 100644 --- a/src/tools/clippy/clippy_lints/src/operators/arithmetic_side_effects.rs +++ b/src/tools/clippy/clippy_lints/src/operators/arithmetic_side_effects.rs @@ -159,15 +159,15 @@ impl ArithmeticSideEffects { if let hir::BinOpKind::Sub = op && let hir::ExprKind::MethodCall(method, receiver, [], _) = actual_lhs.kind && method.ident.name == sym::get - && let receiver_ty = cx.typeck_results().expr_ty(receiver).peel_refs() + && let receiver_ty = cx.typeck_results.expr_ty(receiver).peel_refs() && is_non_zero_u(cx, receiver_ty) && literal_integer(cx, actual_rhs) == Some(1) { return; } - let lhs_ty = cx.typeck_results().expr_ty(actual_lhs).peel_refs(); - let rhs_ty = cx.typeck_results().expr_ty_adjusted(actual_rhs).peel_refs(); + let lhs_ty = cx.typeck_results.expr_ty(actual_lhs).peel_refs(); + let rhs_ty = cx.typeck_results.expr_ty_adjusted(actual_rhs).peel_refs(); if self.has_allowed_binary(lhs_ty, rhs_ty) | has_specific_allowed_type_and_operation(cx, lhs_ty, op, rhs_ty) | is_safe_due_to_smaller_source_type(cx, op, (actual_lhs, lhs_ty), actual_rhs) @@ -225,7 +225,7 @@ impl ArithmeticSideEffects { if ConstEvalCtxt::new(cx).eval_local(receiver, expr.span.ctxt()).is_some() { return; } - let instance_ty = cx.typeck_results().expr_ty_adjusted(receiver); + let instance_ty = cx.typeck_results.expr_ty_adjusted(receiver); if !is_integer(instance_ty) { return; } @@ -253,7 +253,7 @@ impl ArithmeticSideEffects { if ConstEvalCtxt::new(cx).eval(un_expr).is_some() { return; } - let ty = cx.typeck_results().expr_ty_adjusted(expr).peel_refs(); + let ty = cx.typeck_results.expr_ty_adjusted(expr).peel_refs(); if self.has_allowed_unary(ty) { return; } @@ -332,9 +332,9 @@ impl<'tcx> LateLintPass<'tcx> for ArithmeticSideEffects { fn find_original_primitive_ty<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>) -> Option> { match &expr.kind { hir::ExprKind::Call(path, [arg]) if path.res(cx).opt_def_id().is_diag_item(&cx.tcx, sym::from_fn) => { - Some(cx.typeck_results().expr_ty(arg)) + Some(cx.typeck_results.expr_ty(arg)) }, - hir::ExprKind::Cast(arg, _) => Some(cx.typeck_results().expr_ty(arg)), + hir::ExprKind::Cast(arg, _) => Some(cx.typeck_results.expr_ty(arg)), _ => None, } } diff --git a/src/tools/clippy/clippy_lints/src/operators/assign_op_pattern.rs b/src/tools/clippy/clippy_lints/src/operators/assign_op_pattern.rs index 5695779425f4a..bebf1f4057b81 100644 --- a/src/tools/clippy/clippy_lints/src/operators/assign_op_pattern.rs +++ b/src/tools/clippy/clippy_lints/src/operators/assign_op_pattern.rs @@ -25,8 +25,8 @@ pub(super) fn check<'tcx>( ) { if let hir::ExprKind::Binary(op, l, r) = &e.kind { let lint = |assignee: &hir::Expr<'_>, rhs: &hir::Expr<'_>| { - let ty = cx.typeck_results().expr_ty(assignee); - let rty = cx.typeck_results().expr_ty(rhs); + let ty = cx.typeck_results.expr_ty(assignee); + let rty = cx.typeck_results.expr_ty(rhs); if let Some((_, lang_item)) = binop_traits(op.node) && let Some(trait_id) = cx.tcx.lang_items().get(lang_item) && let parent_fn = cx.tcx.hir_get_parent_item(e.hir_id) @@ -109,7 +109,7 @@ pub(super) fn check<'tcx>( } // a = b commutative_op a // Limited to primitive type as these ops are know to be commutative - if eq_expr_value(cx, ctxt, assignee, r) && cx.typeck_results().expr_ty(assignee).is_primitive_ty() { + if eq_expr_value(cx, ctxt, assignee, r) && cx.typeck_results.expr_ty(assignee).is_primitive_ty() { match op.node { hir::BinOpKind::Add | hir::BinOpKind::Mul diff --git a/src/tools/clippy/clippy_lints/src/operators/bit_mask.rs b/src/tools/clippy/clippy_lints/src/operators/bit_mask.rs index 1607d23e6a335..60f6a91e4635d 100644 --- a/src/tools/clippy/clippy_lints/src/operators/bit_mask.rs +++ b/src/tools/clippy/clippy_lints/src/operators/bit_mask.rs @@ -42,7 +42,7 @@ fn check_compare<'a>(cx: &LateContext<'a>, bit_op: &Expr<'a>, cmp_op: BinOpKind, return; } if let Some(mask) = fetch_int_literal(cx, right).or_else(|| fetch_int_literal(cx, left)) { - let ty = cx.typeck_results().expr_ty(bit_op); + let ty = cx.typeck_results.expr_ty(bit_op); if ty.is_primitive() && !ty.is_ptr_sized_integral() && let bits = ty.primitive_size(cx.tcx) diff --git a/src/tools/clippy/clippy_lints/src/operators/cmp_owned.rs b/src/tools/clippy/clippy_lints/src/operators/cmp_owned.rs index fa1ce43d53b42..3bfbff70d26b0 100644 --- a/src/tools/clippy/clippy_lints/src/operators/cmp_owned.rs +++ b/src/tools/clippy/clippy_lints/src/operators/cmp_owned.rs @@ -40,7 +40,7 @@ fn check_op(cx: &LateContext<'_>, outer: &Expr<'_>, expr: &Expr<'_>, other: &Exp return; } - let typeck = cx.typeck_results(); + let typeck = cx.typeck_results; let (arg, arg_span) = match expr.kind { ExprKind::MethodCall(_, arg, [], _) if typeck diff --git a/src/tools/clippy/clippy_lints/src/operators/const_comparisons.rs b/src/tools/clippy/clippy_lints/src/operators/const_comparisons.rs index 85128f9114e6b..3e7705fd0f027 100644 --- a/src/tools/clippy/clippy_lints/src/operators/const_comparisons.rs +++ b/src/tools/clippy/clippy_lints/src/operators/const_comparisons.rs @@ -52,7 +52,7 @@ pub(super) fn check<'tcx>( && let ExprKind::Binary(_, _, _) = left_cond.kind && let ExprKind::Binary(_, _, _) = right_cond.kind - && let typeck = cx.typeck_results() + && let typeck = cx.typeck_results // Check that both operands to '&&' compare a non-literal to a literal && let Some((left_cmp_op, left_expr, left_const_expr, left_const, left_type)) = diff --git a/src/tools/clippy/clippy_lints/src/operators/duration_subsec.rs b/src/tools/clippy/clippy_lints/src/operators/duration_subsec.rs index 4a1da7e07a888..913a1217ee614 100644 --- a/src/tools/clippy/clippy_lints/src/operators/duration_subsec.rs +++ b/src/tools/clippy/clippy_lints/src/operators/duration_subsec.rs @@ -19,7 +19,7 @@ pub(crate) fn check<'tcx>( if op == BinOpKind::Div && let ExprKind::MethodCall(method_path, self_arg, [], _) = left.kind && cx - .typeck_results() + .typeck_results .expr_ty(self_arg) .peel_refs() .is_diag_item(cx, sym::Duration) diff --git a/src/tools/clippy/clippy_lints/src/operators/eq_op.rs b/src/tools/clippy/clippy_lints/src/operators/eq_op.rs index 8e086cea7d91d..0aaaecdff1ce1 100644 --- a/src/tools/clippy/clippy_lints/src/operators/eq_op.rs +++ b/src/tools/clippy/clippy_lints/src/operators/eq_op.rs @@ -48,7 +48,7 @@ pub(crate) fn check<'tcx>( format!("equal expressions as operands to `{}`", op.as_str()), |diag| { if let BinOpKind::Ne = op - && cx.typeck_results().expr_ty(left).is_floating_point() + && cx.typeck_results.expr_ty(left).is_floating_point() { diag.note("if you intended to check if the operand is NaN, use `.is_nan()` instead"); } diff --git a/src/tools/clippy/clippy_lints/src/operators/erasing_op.rs b/src/tools/clippy/clippy_lints/src/operators/erasing_op.rs index ae1a94a3e23f0..74869c9ce6c59 100644 --- a/src/tools/clippy/clippy_lints/src/operators/erasing_op.rs +++ b/src/tools/clippy/clippy_lints/src/operators/erasing_op.rs @@ -15,7 +15,7 @@ pub(super) fn check<'tcx>( left: &'tcx Expr<'_>, right: &'tcx Expr<'_>, ) { - let tck = cx.typeck_results(); + let tck = cx.typeck_results; match op { BinOpKind::Mul | BinOpKind::BitAnd => { check_op(cx, tck, left, right, e); diff --git a/src/tools/clippy/clippy_lints/src/operators/float_cmp.rs b/src/tools/clippy/clippy_lints/src/operators/float_cmp.rs index eb2353cfd90bf..5e2dc816cd207 100644 --- a/src/tools/clippy/clippy_lints/src/operators/float_cmp.rs +++ b/src/tools/clippy/clippy_lints/src/operators/float_cmp.rs @@ -117,7 +117,7 @@ fn is_signum(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool { } fn is_float(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool { - let value = &cx.typeck_results().expr_ty(expr).peel_refs().kind(); + let value = &cx.typeck_results.expr_ty(expr).peel_refs().kind(); if let ty::Array(arr_ty, _) = value { return matches!(arr_ty.kind(), ty::Float(_)); @@ -127,5 +127,5 @@ fn is_float(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool { } fn is_array(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool { - matches!(&cx.typeck_results().expr_ty(expr).peel_refs().kind(), ty::Array(_, _)) + matches!(&cx.typeck_results.expr_ty(expr).peel_refs().kind(), ty::Array(_, _)) } diff --git a/src/tools/clippy/clippy_lints/src/operators/float_equality_without_abs.rs b/src/tools/clippy/clippy_lints/src/operators/float_equality_without_abs.rs index 6c6221525b578..3b484c66fc226 100644 --- a/src/tools/clippy/clippy_lints/src/operators/float_equality_without_abs.rs +++ b/src/tools/clippy/clippy_lints/src/operators/float_equality_without_abs.rs @@ -40,8 +40,8 @@ pub(crate) fn check<'tcx>( && matches!(sym, sym::f16_epsilon | sym::f32_epsilon | sym::f64_epsilon | sym::f128_epsilon) // values of the subtractions on the left hand side are of the type float - && let t_val_l = cx.typeck_results().expr_ty(val_l) - && let t_val_r = cx.typeck_results().expr_ty(val_r) + && let t_val_l = cx.typeck_results.expr_ty(val_l) + && let t_val_r = cx.typeck_results.expr_ty(val_r) && let ty::Float(_) = t_val_l.kind() && let ty::Float(_) = t_val_r.kind() { diff --git a/src/tools/clippy/clippy_lints/src/operators/identity_op.rs b/src/tools/clippy/clippy_lints/src/operators/identity_op.rs index 2e0beb2d4e821..6b5867281dc03 100644 --- a/src/tools/clippy/clippy_lints/src/operators/identity_op.rs +++ b/src/tools/clippy/clippy_lints/src/operators/identity_op.rs @@ -84,7 +84,7 @@ pub(crate) fn check<'tcx>( } fn expr_is_erased_ref(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool { - match cx.typeck_results().expr_ty(expr).kind() { + match cx.typeck_results.expr_ty(expr).kind() { ty::Ref(r, ..) => r.is_erased(), _ => false, } @@ -180,8 +180,8 @@ fn is_allowed<'tcx>( } // This lint applies to integers and their references - cx.typeck_results().expr_ty(left).peel_refs().is_integral() - && cx.typeck_results().expr_ty(right).peel_refs().is_integral() + cx.typeck_results.expr_ty(left).peel_refs().is_integral() + && cx.typeck_results.expr_ty(right).peel_refs().is_integral() // `1 << 0` is a common pattern in bit manipulation code && !(cmp == BinOpKind::Shl && is_zero_integer_const(cx, right, expr.span.ctxt()) @@ -202,7 +202,7 @@ fn check_remainder(cx: &LateContext<'_>, left: &Expr<'_>, right: &Expr<'_>, span fn is_redundant_op(cx: &LateContext<'_>, e: &Expr<'_>, m: i8, ctxt: SyntaxContext) -> bool { if let Some(Constant::Int(v)) = ConstEvalCtxt::new(cx).eval_local(e, ctxt).map(Constant::peel_refs) { - let check = match *cx.typeck_results().expr_ty(e).peel_refs().kind() { + let check = match *cx.typeck_results.expr_ty(e).peel_refs().kind() { ty::Int(ity) => unsext(cx.tcx, -1_i128, ity), ty::Uint(uty) => clip(cx.tcx, !0, uty), _ => return false, @@ -250,7 +250,7 @@ fn span_ineffective_operation( } fn is_expr_used_with_type_annotation<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool { - match get_expr_use_site(cx.tcx, cx.typeck_results(), expr.span.ctxt(), expr).use_node(cx) { + match get_expr_use_site(cx.tcx, cx.typeck_results, expr.span.ctxt(), expr).use_node(cx) { ExprUseNode::LetStmt(letstmt) => letstmt.ty.is_some(), ExprUseNode::Return(_) => true, _ => false, diff --git a/src/tools/clippy/clippy_lints/src/operators/integer_division.rs b/src/tools/clippy/clippy_lints/src/operators/integer_division.rs index 1620312474e99..c71b37ffd5856 100644 --- a/src/tools/clippy/clippy_lints/src/operators/integer_division.rs +++ b/src/tools/clippy/clippy_lints/src/operators/integer_division.rs @@ -14,8 +14,8 @@ pub(crate) fn check<'tcx>( right: &'tcx hir::Expr<'_>, ) { if op == hir::BinOpKind::Div - && cx.typeck_results().expr_ty(left).is_integral() - && let right_ty = cx.typeck_results().expr_ty(right) + && cx.typeck_results.expr_ty(left).is_integral() + && let right_ty = cx.typeck_results.expr_ty(right) && (right_ty.is_integral() || right_ty.is_diag_item(cx, sym::NonZero)) { #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")] diff --git a/src/tools/clippy/clippy_lints/src/operators/integer_division_remainder_used.rs b/src/tools/clippy/clippy_lints/src/operators/integer_division_remainder_used.rs index 976b2d8b0c63a..f184fdb39b75d 100644 --- a/src/tools/clippy/clippy_lints/src/operators/integer_division_remainder_used.rs +++ b/src/tools/clippy/clippy_lints/src/operators/integer_division_remainder_used.rs @@ -9,8 +9,8 @@ use super::INTEGER_DIVISION_REMAINDER_USED; pub(super) fn check(cx: &LateContext<'_>, op: BinOpKind, lhs: &Expr<'_>, rhs: &Expr<'_>, span: Span) { if let BinOpKind::Div | BinOpKind::Rem = op - && let lhs_ty = cx.typeck_results().expr_ty(lhs) - && let rhs_ty = cx.typeck_results().expr_ty(rhs) + && let lhs_ty = cx.typeck_results.expr_ty(lhs) + && let rhs_ty = cx.typeck_results.expr_ty(rhs) && let ty::Int(_) | ty::Uint(_) = lhs_ty.peel_refs().kind() && let ty::Int(_) | ty::Uint(_) = rhs_ty.peel_refs().kind() { diff --git a/src/tools/clippy/clippy_lints/src/operators/invalid_upcast_comparisons.rs b/src/tools/clippy/clippy_lints/src/operators/invalid_upcast_comparisons.rs index b32848a323375..9c73e62f06ace 100644 --- a/src/tools/clippy/clippy_lints/src/operators/invalid_upcast_comparisons.rs +++ b/src/tools/clippy/clippy_lints/src/operators/invalid_upcast_comparisons.rs @@ -34,8 +34,8 @@ pub(super) fn check<'tcx>( fn numeric_cast_precast_bounds(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<(FullInt, FullInt)> { if let ExprKind::Cast(cast_exp, _) = expr.kind { - let pre_cast_ty = cx.typeck_results().expr_ty(cast_exp); - let cast_ty = cx.typeck_results().expr_ty(expr); + let pre_cast_ty = cx.typeck_results.expr_ty(cast_exp); + let cast_ty = cx.typeck_results.expr_ty(expr); // if it's a cast from i32 to u32 wrapping will invalidate all these checks if cx.layout_of(pre_cast_ty).ok().map(|l| l.size) == cx.layout_of(cast_ty).ok().map(|l| l.size) { return None; diff --git a/src/tools/clippy/clippy_lints/src/operators/manual_div_ceil.rs b/src/tools/clippy/clippy_lints/src/operators/manual_div_ceil.rs index 57f5a046cb061..b0d5975ad577c 100644 --- a/src/tools/clippy/clippy_lints/src/operators/manual_div_ceil.rs +++ b/src/tools/clippy/clippy_lints/src/operators/manual_div_ceil.rs @@ -17,8 +17,8 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, op: BinOpKind, lhs: & let mut applicability = Applicability::MachineApplicable; if op == BinOpKind::Div - && check_int_ty_and_feature(cx, cx.typeck_results().expr_ty(lhs)) - && check_int_ty_and_feature(cx, cx.typeck_results().expr_ty(rhs)) + && check_int_ty_and_feature(cx, cx.typeck_results.expr_ty(lhs)) + && check_int_ty_and_feature(cx, cx.typeck_results.expr_ty(rhs)) && msrv.meets(cx, msrvs::DIV_CEIL) { let ctxt = expr.span.ctxt(); @@ -76,7 +76,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, op: BinOpKind, lhs: & }, ExprKind::MethodCall(method, receiver, [next_multiple_of_arg], _) if method.ident.name == sym::next_multiple_of - && check_int_ty(cx.typeck_results().expr_ty(receiver)) + && check_int_ty(cx.typeck_results.expr_ty(receiver)) && SpanlessEq::new(cx).eq_expr(ctxt, next_multiple_of_arg, rhs) => { // x.next_multiple_of(Y) / Y @@ -147,8 +147,8 @@ fn build_suggestion( ) { let ctxt = expr.span.ctxt(); let dividend_sugg = Sugg::hir_with_context(cx, lhs, ctxt, "..", applicability).maybe_paren(); - let rhs_ty = cx.typeck_results().expr_ty(rhs); - let type_suffix = if cx.typeck_results().expr_ty(lhs).is_numeric() + let rhs_ty = cx.typeck_results.expr_ty(rhs); + let type_suffix = if cx.typeck_results.expr_ty(lhs).is_numeric() && matches!( lhs.kind, ExprKind::Lit(Spanned { diff --git a/src/tools/clippy/clippy_lints/src/operators/manual_is_multiple_of.rs b/src/tools/clippy/clippy_lints/src/operators/manual_is_multiple_of.rs index 291d81097b51f..b30db8f6c52fb 100644 --- a/src/tools/clippy/clippy_lints/src/operators/manual_is_multiple_of.rs +++ b/src/tools/clippy/clippy_lints/src/operators/manual_is_multiple_of.rs @@ -24,11 +24,11 @@ pub(super) fn check<'tcx>( && let ExprKind::Binary(operand_op, operand_left, operand_right) = operand.kind && operand_op.node == BinOpKind::Rem && matches!( - cx.typeck_results().expr_ty_adjusted(operand_left).peel_refs().kind(), + cx.typeck_results.expr_ty_adjusted(operand_left).peel_refs().kind(), ty::Uint(_) ) && matches!( - cx.typeck_results().expr_ty_adjusted(operand_right).peel_refs().kind(), + cx.typeck_results.expr_ty_adjusted(operand_right).peel_refs().kind(), ty::Uint(_) ) && expr_type_is_certain(cx, operand_left) @@ -36,7 +36,7 @@ pub(super) fn check<'tcx>( let mut app = Applicability::MachineApplicable; let divisor = deref_sugg( Sugg::hir_with_context(cx, operand_right, expr.span.ctxt(), "_", &mut app), - cx.typeck_results().expr_ty_adjusted(operand_right), + cx.typeck_results.expr_ty_adjusted(operand_right), ); span_lint_and_sugg( cx, @@ -76,7 +76,7 @@ fn uint_compare_to_zero<'tcx>( return None; }; - matches!(cx.typeck_results().expr_ty_adjusted(operand).kind(), ty::Uint(_)).then_some(operand) + matches!(cx.typeck_results.expr_ty_adjusted(operand).kind(), ty::Uint(_)).then_some(operand) } fn deref_sugg<'a>(sugg: Sugg<'a>, ty: Ty<'_>) -> Sugg<'a> { diff --git a/src/tools/clippy/clippy_lints/src/operators/manual_isolate_lowest_one.rs b/src/tools/clippy/clippy_lints/src/operators/manual_isolate_lowest_one.rs index f62514ce99a63..89776a4d00efc 100644 --- a/src/tools/clippy/clippy_lints/src/operators/manual_isolate_lowest_one.rs +++ b/src/tools/clippy/clippy_lints/src/operators/manual_isolate_lowest_one.rs @@ -137,17 +137,17 @@ fn is_local_path(expr: &Expr<'_>) -> bool { fn is_primitive_int(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool { matches!( - cx.typeck_results().expr_ty_adjusted(expr).kind(), + cx.typeck_results.expr_ty_adjusted(expr).kind(), ty::Int(_) | ty::Uint(_) ) } fn is_signed_int(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool { - matches!(cx.typeck_results().expr_ty_adjusted(expr).kind(), ty::Int(_)) + matches!(cx.typeck_results.expr_ty_adjusted(expr).kind(), ty::Int(_)) } fn is_nonzero_int(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool { - if let ty::Adt(adt, args) = cx.typeck_results().expr_ty_adjusted(expr).kind() + if let ty::Adt(adt, args) = cx.typeck_results.expr_ty_adjusted(expr).kind() && cx.tcx.is_diagnostic_item(sym::NonZero, adt.did()) { matches!(args.type_at(0).kind(), ty::Int(_) | ty::Uint(_)) @@ -157,7 +157,7 @@ fn is_nonzero_int(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool { } fn is_nonzero_signed_int(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool { - if let ty::Adt(adt, args) = cx.typeck_results().expr_ty_adjusted(expr).kind() + if let ty::Adt(adt, args) = cx.typeck_results.expr_ty_adjusted(expr).kind() && cx.tcx.is_diagnostic_item(sym::NonZero, adt.did()) { matches!(args.type_at(0).kind(), ty::Int(_)) diff --git a/src/tools/clippy/clippy_lints/src/operators/manual_midpoint.rs b/src/tools/clippy/clippy_lints/src/operators/manual_midpoint.rs index 1ad58612c2fe4..93cad5b6afe81 100644 --- a/src/tools/clippy/clippy_lints/src/operators/manual_midpoint.rs +++ b/src/tools/clippy/clippy_lints/src/operators/manual_midpoint.rs @@ -35,8 +35,8 @@ pub(super) fn check<'tcx>( && !right.span.from_expansion() && let Some((add_l_expr, add_r_expr)) = add_operands(maybe_add_expr) && add_operands(add_l_expr).is_none() && add_operands(add_r_expr).is_none() - && let left_ty = cx.typeck_results().expr_ty_adjusted(add_l_expr) - && let right_ty = cx.typeck_results().expr_ty_adjusted(add_r_expr) + && let left_ty = cx.typeck_results.expr_ty_adjusted(add_l_expr) + && let right_ty = cx.typeck_results.expr_ty_adjusted(add_r_expr) && left_ty == right_ty && (!require_uint || matches!(left_ty.kind(), ty::Uint(_))) // Do not lint on `(_+1)/2` and `(1+_)/2`, it is likely a `div_ceil()` operation diff --git a/src/tools/clippy/clippy_lints/src/operators/modulo_arithmetic.rs b/src/tools/clippy/clippy_lints/src/operators/modulo_arithmetic.rs index ffe91fc2cef6d..ceccc89d7021e 100644 --- a/src/tools/clippy/clippy_lints/src/operators/modulo_arithmetic.rs +++ b/src/tools/clippy/clippy_lints/src/operators/modulo_arithmetic.rs @@ -55,7 +55,7 @@ struct OperandInfo { fn analyze_operand(operand: &Expr<'_>, cx: &LateContext<'_>, expr: &Expr<'_>) -> Option { match ConstEvalCtxt::new(cx).eval(operand)? { - Constant::Int(v) => match *cx.typeck_results().expr_ty(expr).kind() { + Constant::Int(v) => match *cx.typeck_results.expr_ty(expr).kind() { ty::Int(ity) => { let value: i128 = sext(cx.tcx, v, ity); Some(OperandInfo { @@ -117,7 +117,7 @@ fn check_const_operands<'tcx>( } fn check_non_const_operands<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, operand: &Expr<'_>) { - let operand_type = cx.typeck_results().expr_ty(operand); + let operand_type = cx.typeck_results.expr_ty(operand); if might_have_negative_value(operand_type) { span_lint_and_then( cx, diff --git a/src/tools/clippy/clippy_lints/src/operators/needless_bitwise_bool.rs b/src/tools/clippy/clippy_lints/src/operators/needless_bitwise_bool.rs index cac3169bd2899..ece6175326f5b 100644 --- a/src/tools/clippy/clippy_lints/src/operators/needless_bitwise_bool.rs +++ b/src/tools/clippy/clippy_lints/src/operators/needless_bitwise_bool.rs @@ -15,7 +15,7 @@ pub(super) fn check(cx: &LateContext<'_>, e: &Expr<'_>, op: BinOpKind, lhs: &Exp if matches!( rhs.kind, ExprKind::Call(..) | ExprKind::MethodCall(..) | ExprKind::Binary(..) | ExprKind::Unary(..) - ) && cx.typeck_results().expr_ty(e).is_bool() + ) && cx.typeck_results.expr_ty(e).is_bool() && !rhs.can_have_side_effects() { span_lint_and_then( diff --git a/src/tools/clippy/clippy_lints/src/operators/numeric_arithmetic.rs b/src/tools/clippy/clippy_lints/src/operators/numeric_arithmetic.rs index 622f328f369a5..9309408f8479c 100644 --- a/src/tools/clippy/clippy_lints/src/operators/numeric_arithmetic.rs +++ b/src/tools/clippy/clippy_lints/src/operators/numeric_arithmetic.rs @@ -43,7 +43,7 @@ impl Context { _ => (), } - let (l_ty, r_ty) = (cx.typeck_results().expr_ty(l), cx.typeck_results().expr_ty(r)); + let (l_ty, r_ty) = (cx.typeck_results.expr_ty(l), cx.typeck_results.expr_ty(r)); if l_ty.peel_refs().is_floating_point() && r_ty.peel_refs().is_floating_point() { span_lint(cx, FLOAT_ARITHMETIC, expr.span, "floating-point arithmetic detected"); self.expr_id = Some(expr.hir_id); @@ -54,7 +54,7 @@ impl Context { if self.skip_expr(expr) { return; } - let ty = cx.typeck_results().expr_ty(arg); + let ty = cx.typeck_results.expr_ty(arg); if ConstEvalCtxt::new(cx).eval_local(expr, expr.span.ctxt()).is_none() && ty.is_floating_point() { span_lint(cx, FLOAT_ARITHMETIC, expr.span, "floating-point arithmetic detected"); self.expr_id = Some(expr.hir_id); diff --git a/src/tools/clippy/clippy_lints/src/operators/op_ref.rs b/src/tools/clippy/clippy_lints/src/operators/op_ref.rs index 9c160ff680ec8..686c3d10c551a 100644 --- a/src/tools/clippy/clippy_lints/src/operators/op_ref.rs +++ b/src/tools/clippy/clippy_lints/src/operators/op_ref.rs @@ -43,8 +43,8 @@ pub(crate) fn check<'tcx>( (&ExprKind::Lit(..), _) | (_, &ExprKind::Lit(..)) => {}, // &foo == &bar (&ExprKind::AddrOf(BorrowKind::Ref, _, l), &ExprKind::AddrOf(BorrowKind::Ref, _, r)) => { - let lty = cx.typeck_results().expr_ty(l); - let rty = cx.typeck_results().expr_ty(r); + let lty = cx.typeck_results.expr_ty(l); + let rty = cx.typeck_results.expr_ty(r); let lcpy = is_copy(cx, lty); let rcpy = is_copy(cx, rty); if let Some((self_ty, other_ty)) = in_impl(cx, e, trait_id) @@ -73,7 +73,7 @@ pub(crate) fn check<'tcx>( ); } else if lcpy && !rcpy - && implements_trait(cx, lty, trait_id, &[cx.typeck_results().expr_ty(right).into()]) + && implements_trait(cx, lty, trait_id, &[cx.typeck_results.expr_ty(right).into()]) { span_lint_and_then( cx, @@ -88,7 +88,7 @@ pub(crate) fn check<'tcx>( ); } else if !lcpy && rcpy - && implements_trait(cx, cx.typeck_results().expr_ty(left), trait_id, &[rty.into()]) + && implements_trait(cx, cx.typeck_results.expr_ty(left), trait_id, &[rty.into()]) { span_lint_and_then( cx, @@ -110,9 +110,9 @@ pub(crate) fn check<'tcx>( }, // &foo == bar (&ExprKind::AddrOf(BorrowKind::Ref, _, l), _) => { - let lty = cx.typeck_results().expr_ty(l); + let lty = cx.typeck_results.expr_ty(l); if let Some((self_ty, other_ty)) = in_impl(cx, e, trait_id) { - let rty = cx.typeck_results().expr_ty(right); + let rty = cx.typeck_results.expr_ty(right); if (are_equal(cx, rty, self_ty) && are_equal(cx, lty, other_ty)) || (are_equal(cx, rty, other_ty) && are_equal(cx, lty, self_ty)) { @@ -121,7 +121,7 @@ pub(crate) fn check<'tcx>( } let lcpy = is_copy(cx, lty); if (requires_ref || lcpy) - && implements_trait(cx, lty, trait_id, &[cx.typeck_results().expr_ty(right).into()]) + && implements_trait(cx, lty, trait_id, &[cx.typeck_results.expr_ty(right).into()]) { span_lint_and_then( cx, @@ -143,9 +143,9 @@ pub(crate) fn check<'tcx>( }, // foo == &bar (_, &ExprKind::AddrOf(BorrowKind::Ref, _, r)) => { - let rty = cx.typeck_results().expr_ty(r); + let rty = cx.typeck_results.expr_ty(r); if let Some((self_ty, other_ty)) = in_impl(cx, e, trait_id) { - let lty = cx.typeck_results().expr_ty(left); + let lty = cx.typeck_results.expr_ty(left); if (are_equal(cx, rty, self_ty) && are_equal(cx, lty, other_ty)) || (are_equal(cx, rty, other_ty) && are_equal(cx, lty, self_ty)) { @@ -154,7 +154,7 @@ pub(crate) fn check<'tcx>( } let rcpy = is_copy(cx, rty); if (requires_ref || rcpy) - && implements_trait(cx, cx.typeck_results().expr_ty(left), trait_id, &[rty.into()]) + && implements_trait(cx, cx.typeck_results.expr_ty(left), trait_id, &[rty.into()]) { span_lint_and_then(cx, OP_REF, e.span, "taken reference of right operand", |diag| { let mut applicability = Applicability::MachineApplicable; diff --git a/src/tools/clippy/clippy_lints/src/option_if_let_else.rs b/src/tools/clippy/clippy_lints/src/option_if_let_else.rs index 85cf483fce90d..74f275a55ad60 100644 --- a/src/tools/clippy/clippy_lints/src/option_if_let_else.rs +++ b/src/tools/clippy/clippy_lints/src/option_if_let_else.rs @@ -128,7 +128,7 @@ fn try_get_option_occurrence<'tcx>( ) -> Option { let cond_expr = match expr.kind { ExprKind::AddrOf(_, _, inner_expr) => inner_expr, - ExprKind::Unary(UnOp::Deref, inner_expr) if !cx.typeck_results().expr_ty(inner_expr).is_raw_ptr() => inner_expr, + ExprKind::Unary(UnOp::Deref, inner_expr) if !cx.typeck_results.expr_ty(inner_expr).is_raw_ptr() => inner_expr, _ => expr, }; let (inner_pat, is_result) = try_get_inner_pat_and_is_result(cx, pat)?; @@ -156,7 +156,7 @@ fn try_get_option_occurrence<'tcx>( let (as_ref, as_mut) = match &expr.kind { ExprKind::AddrOf(_, Mutability::Not, _) => (true, false), ExprKind::AddrOf(_, Mutability::Mut, _) => (false, true), - _ if let Some(mutb) = cx.typeck_results().expr_ty(expr).ref_mutability() => { + _ if let Some(mutb) = cx.typeck_results.expr_ty(expr).ref_mutability() => { (mutb == Mutability::Not, mutb == Mutability::Mut) }, _ => ( @@ -191,7 +191,7 @@ fn try_get_option_occurrence<'tcx>( Some(CaptureKind::Ref(Mutability::Not)) | None => (), } } - } else if !is_copy(cx, cx.typeck_results().expr_ty(expr)) + } else if !is_copy(cx, cx.typeck_results.expr_ty(expr)) // TODO: Cover more match cases && matches!( expr.kind, @@ -213,8 +213,8 @@ fn try_get_option_occurrence<'tcx>( } } - let some_body_ty = cx.typeck_results().expr_ty(some_body); - let none_body_ty = cx.typeck_results().expr_ty(none_body); + let some_body_ty = cx.typeck_results.expr_ty(some_body); + let none_body_ty = cx.typeck_results.expr_ty(none_body); // Check if coercion is needed for the `None` arm. If so, we cannot suggest because it will // introduce a type mismatch. A special case is when both arms have the same type, then // coercion is fine. @@ -337,7 +337,7 @@ fn detect_option_if_let_else<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) -> if_else: Some(if_else), .. }) = higher::IfLet::hir(cx, expr) - && !cx.typeck_results().expr_ty(expr).is_unit() + && !cx.typeck_results.expr_ty(expr).is_unit() && !is_else_clause(cx.tcx, expr) { try_get_option_occurrence(cx, expr.span.ctxt(), let_pat, let_expr, if_then, if_else) @@ -348,7 +348,7 @@ fn detect_option_if_let_else<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) -> fn detect_option_match<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) -> Option { if let ExprKind::Match(ex, arms, MatchSource::Normal) = expr.kind - && !cx.typeck_results().expr_ty(expr).is_unit() + && !cx.typeck_results.expr_ty(expr).is_unit() && let Some((let_pat, if_then, if_else)) = try_convert_match(cx, arms) { try_get_option_occurrence(cx, expr.span.ctxt(), let_pat, ex, if_then, if_else) diff --git a/src/tools/clippy/clippy_lints/src/panicking_overflow_checks.rs b/src/tools/clippy/clippy_lints/src/panicking_overflow_checks.rs index 7e75e0affc729..5faad3c584a54 100644 --- a/src/tools/clippy/clippy_lints/src/panicking_overflow_checks.rs +++ b/src/tools/clippy/clippy_lints/src/panicking_overflow_checks.rs @@ -66,7 +66,7 @@ impl<'tcx> LateLintPass<'tcx> for PanickingOverflowChecks { }, _ => return, } - && let typeck = cx.typeck_results() + && let typeck = cx.typeck_results && let ty = typeck.expr_ty(op_lhs) && matches!(ty.kind(), ty::Uint(_)) && ty == typeck.expr_ty(op_rhs) diff --git a/src/tools/clippy/clippy_lints/src/partialeq_to_none.rs b/src/tools/clippy/clippy_lints/src/partialeq_to_none.rs index 72d2fdeda21c9..eb5af45511482 100644 --- a/src/tools/clippy/clippy_lints/src/partialeq_to_none.rs +++ b/src/tools/clippy/clippy_lints/src/partialeq_to_none.rs @@ -49,7 +49,7 @@ impl<'tcx> LateLintPass<'tcx> for PartialeqToNone { // If the expression is of type `Option` let is_ty_option = |expr: &Expr<'_>| { - cx.typeck_results() + cx.typeck_results .expr_ty(expr) .peel_refs() .is_diag_item(cx, sym::Option) diff --git a/src/tools/clippy/clippy_lints/src/pathbuf_init_then_push.rs b/src/tools/clippy/clippy_lints/src/pathbuf_init_then_push.rs index a5e57d97301e3..41b50fd0c23ab 100644 --- a/src/tools/clippy/clippy_lints/src/pathbuf_init_then_push.rs +++ b/src/tools/clippy/clippy_lints/src/pathbuf_init_then_push.rs @@ -136,7 +136,7 @@ impl<'tcx> LateLintPass<'tcx> for PathbufThenPush<'tcx> { if let Some(init_expr) = local.init && let PatKind::Binding(BindingMode::MUT, id, name, None) = local.pat.kind && !local.span.in_external_macro(cx.sess().source_map()) - && let ty = cx.typeck_results().pat_ty(local.pat) + && let ty = cx.typeck_results.pat_ty(local.pat) && ty.is_diag_item(cx, sym::PathBuf) { self.searcher = Some(PathbufPushSearcher { @@ -157,7 +157,7 @@ impl<'tcx> LateLintPass<'tcx> for PathbufThenPush<'tcx> { && let [name] = &path.segments && let Res::Local(id) = path.res && !expr.span.in_external_macro(cx.sess().source_map()) - && let ty = cx.typeck_results().expr_ty(left) + && let ty = cx.typeck_results.expr_ty(left) && ty.is_diag_item(cx, sym::PathBuf) { self.searcher = Some(PathbufPushSearcher { diff --git a/src/tools/clippy/clippy_lints/src/pattern_type_mismatch.rs b/src/tools/clippy/clippy_lints/src/pattern_type_mismatch.rs index 4197680dd0472..6eada6f909683 100644 --- a/src/tools/clippy/clippy_lints/src/pattern_type_mismatch.rs +++ b/src/tools/clippy/clippy_lints/src/pattern_type_mismatch.rs @@ -183,7 +183,7 @@ fn find_first_mismatch(cx: &LateContext<'_>, pat: &Pat<'_>) -> Option<(Span, Mut PatKind::Or([p, ..]) => p, _ => p, }; - if let Some(adjustments) = cx.typeck_results().pat_adjustments().get(adjust_pat.hir_id) + if let Some(adjustments) = cx.typeck_results.pat_adjustments().get(adjust_pat.hir_id) && let [first, ..] = **adjustments && let ty::Ref(.., mutability) = *first.source.kind() { diff --git a/src/tools/clippy/clippy_lints/src/permissions_set_readonly_false.rs b/src/tools/clippy/clippy_lints/src/permissions_set_readonly_false.rs index a888ee5462949..e95e4d5f8eb89 100644 --- a/src/tools/clippy/clippy_lints/src/permissions_set_readonly_false.rs +++ b/src/tools/clippy/clippy_lints/src/permissions_set_readonly_false.rs @@ -38,7 +38,7 @@ impl<'tcx> LateLintPass<'tcx> for PermissionsSetReadonlyFalse { && LitKind::Bool(false) == lit.node && path.ident.name == sym::set_readonly && cx - .typeck_results() + .typeck_results .expr_ty(receiver) .is_diag_item(cx, sym::FsPermissions) { diff --git a/src/tools/clippy/clippy_lints/src/pointers_in_nomem_asm_block.rs b/src/tools/clippy/clippy_lints/src/pointers_in_nomem_asm_block.rs index 385f634a15050..2e34ba92f2749 100644 --- a/src/tools/clippy/clippy_lints/src/pointers_in_nomem_asm_block.rs +++ b/src/tools/clippy/clippy_lints/src/pointers_in_nomem_asm_block.rs @@ -79,7 +79,7 @@ fn has_in_operand_pointer(cx: &LateContext<'_>, asm_op: &InlineAsmOperand<'_>) - // This checks for raw ptrs, refs and function pointers - the last one // also technically counts as reading memory. - cx.typeck_results().expr_ty(asm_in_expr).is_any_ptr() + cx.typeck_results.expr_ty(asm_in_expr).is_any_ptr() } fn additional_notes(diag: &mut rustc_errors::Diag<'_, ()>) { diff --git a/src/tools/clippy/clippy_lints/src/ptr/ptr_arg.rs b/src/tools/clippy/clippy_lints/src/ptr/ptr_arg.rs index 40bc42dcdcb36..cc459ac039557 100644 --- a/src/tools/clippy/clippy_lints/src/ptr/ptr_arg.rs +++ b/src/tools/clippy/clippy_lints/src/ptr/ptr_arg.rs @@ -398,7 +398,7 @@ fn check_ptr_arg_usage<'tcx>(cx: &LateContext<'tcx>, body: &Body<'tcx>, args: &[ // If the expression's type gets adjusted down to the deref type, we might as // well have started with that deref type -- the lint should fire let deref_ty = args.deref_ty.ty(self.cx); - let adjusted_ty = self.cx.typeck_results().expr_ty_adjusted(e).peel_refs(); + let adjusted_ty = self.cx.typeck_results.expr_ty_adjusted(e).peel_refs(); if adjusted_ty == deref_ty { return; } diff --git a/src/tools/clippy/clippy_lints/src/ptr/ptr_eq.rs b/src/tools/clippy/clippy_lints/src/ptr/ptr_eq.rs index c982bb1ffbc5f..e6f3dd6c56fbe 100644 --- a/src/tools/clippy/clippy_lints/src/ptr/ptr_eq.rs +++ b/src/tools/clippy/clippy_lints/src/ptr/ptr_eq.rs @@ -26,7 +26,7 @@ pub(super) fn check<'tcx>( }; // This lint concerns raw pointers - let (left_ty, right_ty) = (cx.typeck_results().expr_ty(left), cx.typeck_results().expr_ty(right)); + let (left_ty, right_ty) = (cx.typeck_results.expr_ty(left), cx.typeck_results.expr_ty(right)); if !left_ty.is_raw_ptr() || !right_ty.is_raw_ptr() { return; } @@ -61,7 +61,7 @@ pub(super) fn check<'tcx>( // E.g., `foo as *const _ as usize` returns `foo as *const _`. fn expr_as_cast_to_usize<'tcx>(cx: &LateContext<'tcx>, cast_expr: &'tcx Expr<'_>) -> Option<&'tcx Expr<'tcx>> { if !cast_expr.span.from_expansion() - && cx.typeck_results().expr_ty(cast_expr) == cx.tcx.types.usize + && cx.typeck_results.expr_ty(cast_expr) == cx.tcx.types.usize && let ExprKind::Cast(expr, _) = cast_expr.kind { Some(expr) @@ -76,7 +76,7 @@ fn peel_raw_casts<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, expr_ty: if !expr.span.from_expansion() && let ExprKind::Cast(inner, _) = expr.kind && let ty::RawPtr(target_ty, _) = expr_ty.kind() - && let inner_ty = cx.typeck_results().expr_ty(inner) + && let inner_ty = cx.typeck_results.expr_ty(inner) && let ty::RawPtr(inner_target_ty, _) | ty::Ref(_, inner_target_ty, _) = inner_ty.kind() && target_ty == inner_target_ty { diff --git a/src/tools/clippy/clippy_lints/src/question_mark.rs b/src/tools/clippy/clippy_lints/src/question_mark.rs index cbfd1af1907b7..3e4278787e995 100644 --- a/src/tools/clippy/clippy_lints/src/question_mark.rs +++ b/src/tools/clippy/clippy_lints/src/question_mark.rs @@ -128,7 +128,7 @@ fn check_let_some_else_return_none(cx: &LateContext<'_>, stmt: &Stmt<'_>) { /// or `(&some_struct.opt)?` since the first one has different semantics and the later does /// not implements `Try`. fn init_expr_can_use_question_mark(cx: &LateContext<'_>, init_expr: &Expr<'_>) -> bool { - let init_ty = cx.typeck_results().expr_ty_adjusted(init_expr); + let init_ty = cx.typeck_results.expr_ty_adjusted(init_expr); cx.tcx .lang_items() .try_trait() @@ -290,7 +290,7 @@ fn check_is_none_or_err_and_early_return<'tcx>(cx: &LateContext<'tcx>, expr: &Ex if let Some(higher::If { cond, then, r#else }) = higher::If::hir(expr) && !is_else_clause(cx.tcx, expr) && let ExprKind::MethodCall(segment, caller, [], _) = &cond.kind - && let caller_ty = cx.typeck_results().expr_ty(caller) + && let caller_ty = cx.typeck_results.expr_ty(caller) && let if_block = IfBlockType::IfIs(caller, caller_ty, segment.ident.name, then) && (is_early_return(sym::Option, cx, &if_block) || is_early_return(sym::Result, cx, &if_block)) { @@ -327,7 +327,7 @@ enum TryMode { } fn find_try_mode<'tcx>(cx: &LateContext<'tcx>, scrutinee: &Expr<'tcx>) -> Option { - let scrutinee_ty = cx.typeck_results().expr_ty_adjusted(scrutinee).peel_refs(); + let scrutinee_ty = cx.typeck_results.expr_ty_adjusted(scrutinee).peel_refs(); let ty::Adt(scrutinee_adt_def, _) = scrutinee_ty.kind() else { return None; }; @@ -525,7 +525,7 @@ fn check_if_let_some_or_err_and_early_return<'tcx>(cx: &LateContext<'tcx>, expr: && let PatKind::TupleStruct(ref path1, [field], ddpos) = let_pat.kind && ddpos.as_opt_usize().is_none() && let PatKind::Binding(BindingMode(by_ref, _), bind_id, ident, None) = field.kind - && let caller_ty = cx.typeck_results().expr_ty(let_expr) + && let caller_ty = cx.typeck_results.expr_ty(let_expr) && let if_block = IfBlockType::IfLet( cx.qpath_res(path1, let_pat.hir_id), caller_ty, @@ -564,7 +564,7 @@ fn check_if_let_some_or_err_and_early_return<'tcx>(cx: &LateContext<'tcx>, expr: let receiver_str = snippet_with_applicability(cx, let_expr.span, "..", &mut applicability); if !is_option_early_return || peel_blocks(if_then).res_local_id() == Some(bind_id) { let parent = cx.tcx.parent_hir_node(expr.hir_id); - let requires_semi = matches!(parent, Node::Stmt(_)) || cx.typeck_results().expr_ty(expr).is_unit(); + let requires_semi = matches!(parent, Node::Stmt(_)) || cx.typeck_results.expr_ty(expr).is_unit(); let method_call_str = match by_ref { ByRef::Yes(_, Mutability::Mut) => ".as_mut()", ByRef::Yes(_, Mutability::Not) => ".as_ref()", diff --git a/src/tools/clippy/clippy_lints/src/ranges.rs b/src/tools/clippy/clippy_lints/src/ranges.rs index 71965ee1e29f9..4d33d2bd60ce2 100644 --- a/src/tools/clippy/clippy_lints/src/ranges.rs +++ b/src/tools/clippy/clippy_lints/src/ranges.rs @@ -226,7 +226,7 @@ fn check_possible_range_contains( if l.id != r.id || l.ord == r.ord { return; } - let ord = Constant::partial_cmp(cx.tcx, cx.typeck_results().expr_ty(l.expr), &l.val, &r.val); + let ord = Constant::partial_cmp(cx.tcx, cx.typeck_results.expr_ty(l.expr), &l.val, &r.val); if combine_and && ord == Some(r.ord) { // order lower bound and upper bound let (l_span, u_span, l_inc, u_inc) = if r.ord == Ordering::Less { @@ -260,7 +260,7 @@ fn check_possible_range_contains( } else if !combine_and && ord == Some(l.ord) { // For floating-point types, `q < lo || q > hi` evaluates to `false` for NaN, // but `!(lo..=hi).contains(&q)` evaluates to `true` for NaN, so not linting. - if matches!(cx.typeck_results().expr_ty(l.expr).kind(), ty::Float(_)) { + if matches!(cx.typeck_results.expr_ty(l.expr).kind(), ty::Float(_)) { return; } // `!_.contains(_)` @@ -373,7 +373,7 @@ fn can_switch_ranges<'tcx>( original: RangeLimits, inner_ty: Ty<'tcx>, ) -> bool { - let use_site = get_expr_use_site(cx.tcx, cx.typeck_results(), ctxt, expr); + let use_site = get_expr_use_site(cx.tcx, cx.typeck_results, ctxt, expr); let (Node::Expr(parent_expr), false) = (use_site.node, use_site.is_ty_unified) else { return false; }; @@ -392,7 +392,7 @@ fn can_switch_ranges<'tcx>( // or `RangeBounds` traits. if let ExprKind::MethodCall(_, receiver, _, _) = parent_expr.kind && receiver.hir_id == use_site.child_id - && let Some(method_did) = cx.typeck_results().type_dependent_def_id(parent_expr.hir_id) + && let Some(method_did) = cx.typeck_results.type_dependent_def_id(parent_expr.hir_id) && let Some(trait_did) = cx.tcx.trait_of_assoc(method_did) && matches!( cx.tcx.get_diagnostic_name(trait_did), @@ -464,7 +464,7 @@ fn can_switch_ranges<'tcx>( .skip_norm_wip() // Check that the switched range type can be used for indexing the original expression // through the `Index` or `IndexMut` trait. - && let ty::Ref(_, outer_ty, mutability) = cx.typeck_results().expr_ty_adjusted(outer_expr).kind() + && let ty::Ref(_, outer_ty, mutability) = cx.typeck_results.expr_ty_adjusted(outer_expr).kind() && let Some(index_def_id) = match mutability { Mutability::Not => cx.tcx.lang_items().index_trait(), Mutability::Mut => cx.tcx.lang_items().index_mut_trait(), @@ -527,7 +527,7 @@ fn check_range_switch<'tcx>( && span.can_be_used_for_suggestions() && limits == kind && let Some(y) = predicate(end) - && can_switch_ranges(cx, span.ctxt(), expr, kind, cx.typeck_results().expr_ty(y)) + && can_switch_ranges(cx, span.ctxt(), expr, kind, cx.typeck_results.expr_ty(y)) { span_lint_and_then(cx, lint, span, msg, |diag| { let mut app = Applicability::MachineApplicable; @@ -586,7 +586,7 @@ fn check_reversed_empty_range(cx: &LateContext<'_>, expr: &Expr<'_>) { limits, span, }) = higher::Range::hir(cx, expr) - && let ty = cx.typeck_results().expr_ty(start) + && let ty = cx.typeck_results.expr_ty(start) && let ty::Int(_) | ty::Uint(_) = ty.kind() && let ecx = ConstEvalCtxt::new(cx) && let Some(start_idx) = ecx.eval(start) diff --git a/src/tools/clippy/clippy_lints/src/rc_clone_in_vec_init.rs b/src/tools/clippy/clippy_lints/src/rc_clone_in_vec_init.rs index e3f718cb2d7d4..59aba472957e1 100644 --- a/src/tools/clippy/clippy_lints/src/rc_clone_in_vec_init.rs +++ b/src/tools/clippy/clippy_lints/src/rc_clone_in_vec_init.rs @@ -133,7 +133,7 @@ fn ref_init(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<(Symbol, Span)> { return Some((symbol, func.span)); } - if let ty::Adt(adt, _) = *cx.typeck_results().expr_ty(expr).kind() + if let ty::Adt(adt, _) = *cx.typeck_results.expr_ty(expr).kind() && matches!(cx.tcx.get_diagnostic_name(adt.did()), Some(sym::RcWeak | sym::ArcWeak)) { return Some((sym::Weak, func.span)); diff --git a/src/tools/clippy/clippy_lints/src/redundant_async_block.rs b/src/tools/clippy/clippy_lints/src/redundant_async_block.rs index 386bf3cf90fdc..60914e8d310ad 100644 --- a/src/tools/clippy/clippy_lints/src/redundant_async_block.rs +++ b/src/tools/clippy/clippy_lints/src/redundant_async_block.rs @@ -49,7 +49,7 @@ impl<'tcx> LateLintPass<'tcx> for RedundantAsyncBlock { expr.span.eq_ctxt(body_expr.span) && // The await prefix must implement Future, as implementing IntoFuture is not enough. let Some(future_trait) = cx.tcx.lang_items().future_trait() && - implements_trait(cx, cx.typeck_results().expr_ty(expr), future_trait, &[]) && + implements_trait(cx, cx.typeck_results.expr_ty(expr), future_trait, &[]) && // An async block does not have immediate side-effects from a `.await` point-of-view. (!expr.can_have_side_effects() || desugar_async_block(cx, expr).is_some()) && let Some(shortened_span) = walk_span_to_context(expr.span, span.ctxt()) @@ -80,7 +80,7 @@ fn desugar_async_block<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Op )) ) { - cx.typeck_results() + cx.typeck_results .closure_min_captures .get(def_id) .is_none_or(|m| { diff --git a/src/tools/clippy/clippy_lints/src/redundant_locals.rs b/src/tools/clippy/clippy_lints/src/redundant_locals.rs index 13bd05511ec33..b8c5e63c43e4f 100644 --- a/src/tools/clippy/clippy_lints/src/redundant_locals.rs +++ b/src/tools/clippy/clippy_lints/src/redundant_locals.rs @@ -67,7 +67,7 @@ impl<'tcx> LateLintPass<'tcx> for RedundantLocals { // the local does not change the effect of assignments to the binding. see #11290 && !affects_assignments(cx, mutability, binding_id, local.hir_id) // the local does not affect the code's drop behavior - && !needs_ordered_drop(cx, cx.typeck_results().expr_ty(expr)) + && !needs_ordered_drop(cx, cx.typeck_results.expr_ty(expr)) // the local is user-controlled && !local.span.in_external_macro(cx.sess().source_map()) && !is_from_proc_macro(cx, expr) diff --git a/src/tools/clippy/clippy_lints/src/redundant_slicing.rs b/src/tools/clippy/clippy_lints/src/redundant_slicing.rs index be5e4190e1284..94d08552e6994 100644 --- a/src/tools/clippy/clippy_lints/src/redundant_slicing.rs +++ b/src/tools/clippy/clippy_lints/src/redundant_slicing.rs @@ -82,12 +82,12 @@ impl<'tcx> LateLintPass<'tcx> for RedundantSlicing { && addressee.span.ctxt() == ctxt && let ExprKind::Index(indexed, range, _) = addressee.kind && cx - .typeck_results() + .typeck_results .expr_ty_adjusted(range) .is_lang_item(cx, LangItem::RangeFull) { - let (expr_ty, expr_ref_count, _) = peel_and_count_ty_refs(cx.typeck_results().expr_ty(expr)); - let (indexed_ty, indexed_ref_count, _) = peel_and_count_ty_refs(cx.typeck_results().expr_ty(indexed)); + let (expr_ty, expr_ref_count, _) = peel_and_count_ty_refs(cx.typeck_results.expr_ty(expr)); + let (indexed_ty, indexed_ref_count, _) = peel_and_count_ty_refs(cx.typeck_results.expr_ty(indexed)); let parent_expr = get_parent_expr(cx, expr); let needs_parens_for_prefix = parent_expr.is_some_and(|parent| cx.precedence(parent) > ExprPrecedence::Prefix); @@ -112,13 +112,13 @@ impl<'tcx> LateLintPass<'tcx> for RedundantSlicing { kind: ExprKind::AddrOf(BorrowKind::Ref, Mutability::Mut, _), .. }) - ) || cx.typeck_results().expr_adjustments(expr).first().is_some_and(|a| { + ) || cx.typeck_results.expr_adjustments(expr).first().is_some_and(|a| { matches!( a.kind, Adjust::Borrow(AutoBorrow::Ref(AutoBorrowMutability::Mut { .. })) ) }) || (matches!( - cx.typeck_results().expr_ty(indexed).ref_mutability(), + cx.typeck_results.expr_ty(indexed).ref_mutability(), Some(Mutability::Mut) ) && mutability == Mutability::Not) { diff --git a/src/tools/clippy/clippy_lints/src/redundant_type_annotations.rs b/src/tools/clippy/clippy_lints/src/redundant_type_annotations.rs index 3ffb00e2ee9d1..b40fd3395c8ce 100644 --- a/src/tools/clippy/clippy_lints/src/redundant_type_annotations.rs +++ b/src/tools/clippy/clippy_lints/src/redundant_type_annotations.rs @@ -59,7 +59,7 @@ fn is_same_type<'tcx>(cx: &LateContext<'tcx>, ty_resolved_path: hir::def::Res, f } fn func_hir_id_to_func_ty<'tcx>(cx: &LateContext<'tcx>, hir_id: hir::hir_id::HirId) -> Option> { - if let Some((defkind, func_defid)) = cx.typeck_results().type_dependent_def(hir_id) + if let Some((defkind, func_defid)) = cx.typeck_results.type_dependent_def(hir_id) && defkind == DefKind::AssocFn && let Some(init_ty) = cx.tcx.type_of(func_defid).no_bound_vars() { diff --git a/src/tools/clippy/clippy_lints/src/reference.rs b/src/tools/clippy/clippy_lints/src/reference.rs index 3bbcad12a3199..99ae15b817bb8 100644 --- a/src/tools/clippy/clippy_lints/src/reference.rs +++ b/src/tools/clippy/clippy_lints/src/reference.rs @@ -99,7 +99,7 @@ fn is_manually_drop_through_union( addrof_target: &Expr<'_>, ) -> ManuallyDropThroughUnion { if is_reached_through_union(cx, addrof_target) { - let typeck = cx.typeck_results(); + let typeck = cx.typeck_results; for (idx, id) in std::iter::once(expr_id) .chain(cx.tcx.hir_parent_id_iter(expr_id)) .enumerate() @@ -123,7 +123,7 @@ fn is_manually_drop_through_union( /// Checks whether `expr` denotes an object reached through a union fn is_reached_through_union(cx: &LateContext<'_>, mut expr: &Expr<'_>) -> bool { while let ExprKind::Field(parent, _) | ExprKind::Index(parent, _, _) = expr.kind { - if cx.typeck_results().expr_ty_adjusted(parent).is_union() { + if cx.typeck_results.expr_ty_adjusted(parent).is_union() { return true; } expr = parent; diff --git a/src/tools/clippy/clippy_lints/src/replace_box.rs b/src/tools/clippy/clippy_lints/src/replace_box.rs index 7b743746df2c1..3a1ee9481f223 100644 --- a/src/tools/clippy/clippy_lints/src/replace_box.rs +++ b/src/tools/clippy/clippy_lints/src/replace_box.rs @@ -81,7 +81,7 @@ impl LateLintPass<'_> for ReplaceBox { if let ExprKind::Assign(lhs, rhs, _) = &expr.kind && !lhs.span.from_expansion() && !rhs.span.from_expansion() - && let lhs_ty = cx.typeck_results().expr_ty(lhs) + && let lhs_ty = cx.typeck_results.expr_ty(lhs) && let Some(inner_ty) = lhs_ty.boxed_ty() // No diagnostic for late-initialized locals && lhs.res_local_id().is_none_or(|local| local_is_initialized(cx, local)) diff --git a/src/tools/clippy/clippy_lints/src/returns/let_and_return.rs b/src/tools/clippy/clippy_lints/src/returns/let_and_return.rs index 2ec921ed21c7d..d711d8e67a247 100644 --- a/src/tools/clippy/clippy_lints/src/returns/let_and_return.rs +++ b/src/tools/clippy/clippy_lints/src/returns/let_and_return.rs @@ -48,7 +48,7 @@ pub(super) fn check_block<'tcx>(cx: &LateContext<'tcx>, block: &'tcx Block<'_>) } else { format!("({src})") } - } else if !cx.typeck_results().expr_adjustments(retexpr).is_empty() { + } else if !cx.typeck_results.expr_adjustments(retexpr).is_empty() { if has_enclosing_paren(&src) { format!("{src} as _") } else { diff --git a/src/tools/clippy/clippy_lints/src/returns/needless_return.rs b/src/tools/clippy/clippy_lints/src/returns/needless_return.rs index f3d6324e1885e..52c984982d8ce 100644 --- a/src/tools/clippy/clippy_lints/src/returns/needless_return.rs +++ b/src/tools/clippy/clippy_lints/src/returns/needless_return.rs @@ -222,7 +222,7 @@ fn check_final_expr<'tcx>( // note, if without else is going to be a type checking error anyways // (except for unit type functions) so we don't match it ExprKind::Match(_, arms, MatchSource::Normal) => { - let match_ty = cx.typeck_results().expr_ty(peeled_drop_expr); + let match_ty = cx.typeck_results.expr_ty(peeled_drop_expr); for arm in *arms { check_final_expr(cx, arm.body, semi_spans.clone(), RetReplacement::Unit, Some(match_ty)); } diff --git a/src/tools/clippy/clippy_lints/src/returns/needless_return_with_question_mark.rs b/src/tools/clippy/clippy_lints/src/returns/needless_return_with_question_mark.rs index e37ea9800ed0e..fa5ea1e45afdd 100644 --- a/src/tools/clippy/clippy_lints/src/returns/needless_return_with_question_mark.rs +++ b/src/tools/clippy/clippy_lints/src/returns/needless_return_with_question_mark.rs @@ -66,7 +66,7 @@ fn stmt_needs_never_type(cx: &LateContext<'_>, stmt_hir_id: HirId) -> bool { .hir_parent_iter(stmt_hir_id) .find_map(|(_, node)| if let Node::Expr(expr) = node { Some(expr) } else { None }) .is_some_and(|e| { - cx.typeck_results() + cx.typeck_results .expr_adjustments(e) .iter() .any(|adjust| adjust.target != cx.tcx.types.unit && matches!(adjust.kind, Adjust::NeverToAny)) diff --git a/src/tools/clippy/clippy_lints/src/same_length_and_capacity.rs b/src/tools/clippy/clippy_lints/src/same_length_and_capacity.rs index 1d5d960665ef6..8d69dc841bd08 100644 --- a/src/tools/clippy/clippy_lints/src/same_length_and_capacity.rs +++ b/src/tools/clippy/clippy_lints/src/same_length_and_capacity.rs @@ -81,7 +81,7 @@ impl<'tcx> LateLintPass<'tcx> for SameLengthAndCapacity { && args.len() >= 3 && eq_expr_value(cx, expr.span.ctxt(), &args[1], &args[2]) { - let middle_ty = cx.typeck_results().node_type(ty.hir_id); + let middle_ty = cx.typeck_results.node_type(ty.hir_id); if middle_ty.is_diag_item(cx, rustc_sym::Vec) { span_lint_and_help( cx, diff --git a/src/tools/clippy/clippy_lints/src/semicolon_if_nothing_returned.rs b/src/tools/clippy/clippy_lints/src/semicolon_if_nothing_returned.rs index 63237c655ef17..2fff144b6166e 100644 --- a/src/tools/clippy/clippy_lints/src/semicolon_if_nothing_returned.rs +++ b/src/tools/clippy/clippy_lints/src/semicolon_if_nothing_returned.rs @@ -40,7 +40,7 @@ impl<'tcx> LateLintPass<'tcx> for SemicolonIfNothingReturned { if !block.span.from_expansion() && let Some(expr) = block.expr && !from_attr_macro(expr.span) - && let t_expr = cx.typeck_results().expr_ty(expr) + && let t_expr = cx.typeck_results.expr_ty(expr) && t_expr.is_unit() && let mut app = Applicability::MachineApplicable && let snippet = snippet_with_context(cx, expr.span, block.span.ctxt(), "}", &mut app).0 diff --git a/src/tools/clippy/clippy_lints/src/set_contains_or_insert.rs b/src/tools/clippy/clippy_lints/src/set_contains_or_insert.rs index 4aba49071ee56..06f3626b13c1d 100644 --- a/src/tools/clippy/clippy_lints/src/set_contains_or_insert.rs +++ b/src/tools/clippy/clippy_lints/src/set_contains_or_insert.rs @@ -100,7 +100,7 @@ fn try_parse_op_call<'tcx>( } }); let receiver = receiver.peel_borrows(); - let receiver_ty = cx.typeck_results().expr_ty(receiver).peel_refs(); + let receiver_ty = cx.typeck_results.expr_ty(receiver).peel_refs(); if value.span.eq_ctxt(expr.span) && path.ident.name == symbol { for sym in &[sym::HashSet, sym::BTreeSet] { if receiver_ty.is_diag_item(cx, *sym) { @@ -114,9 +114,9 @@ fn try_parse_op_call<'tcx>( fn is_set_mutated<'tcx>(cx: &LateContext<'tcx>, contains_expr: &OpExpr<'tcx>, expr: &'tcx Expr<'_>) -> bool { // Guard on type to avoid useless potentially expansive `SpanlessEq` checks - cx.typeck_results().expr_ty_adjusted(expr).is_mutable_ptr() + cx.typeck_results.expr_ty_adjusted(expr).is_mutable_ptr() && matches!( - cx.typeck_results().expr_ty(expr).peel_refs().opt_diag_name(cx), + cx.typeck_results.expr_ty(expr).peel_refs().opt_diag_name(cx), Some(sym::HashSet | sym::BTreeSet) ) && SpanlessEq::new(cx).eq_expr(SyntaxContext::root(), contains_expr.receiver, expr.peel_borrows()) diff --git a/src/tools/clippy/clippy_lints/src/significant_drop_tightening.rs b/src/tools/clippy/clippy_lints/src/significant_drop_tightening.rs index 86b3387ae643f..70617a13b0016 100644 --- a/src/tools/clippy/clippy_lints/src/significant_drop_tightening.rs +++ b/src/tools/clippy/clippy_lints/src/significant_drop_tightening.rs @@ -274,7 +274,7 @@ impl<'tcx> Visitor<'tcx> for StmtsChecker<'_, '_, '_, '_, 'tcx> { apa.has_expensive_expr_after_last_attr = false; }; let mut ac = AttrChecker::new(self.cx, self.type_cache); - if ac.has_sig_drop_attr(self.cx.typeck_results().expr_ty(expr), 0) { + if ac.has_sig_drop_attr(self.cx.typeck_results.expr_ty(expr), 0) { if let hir::StmtKind::Let(local) = self.ap.curr_stmt.kind && let hir::PatKind::Binding(_, hir_id, ident, _) = local.pat.kind && !self.ap.apas.contains_key(&hir_id) diff --git a/src/tools/clippy/clippy_lints/src/single_option_map.rs b/src/tools/clippy/clippy_lints/src/single_option_map.rs index 4556d287711fe..ae6a7dcd9aed3 100644 --- a/src/tools/clippy/clippy_lints/src/single_option_map.rs +++ b/src/tools/clippy/clippy_lints/src/single_option_map.rs @@ -54,7 +54,7 @@ impl<'tcx> LateLintPass<'tcx> for SingleOptionMap { let func_body = peel_blocks(body.value); if let ExprKind::MethodCall(method_name, callee, args, _span) = func_body.kind && method_name.ident.name == sym::map - && let callee_type = cx.typeck_results().expr_ty(callee) + && let callee_type = cx.typeck_results.expr_ty(callee) && callee_type.is_diag_item(cx, sym::Option) && let ExprKind::Path(_path) = callee.kind && matches!(callee.basic_res(), Res::Local(_)) diff --git a/src/tools/clippy/clippy_lints/src/single_range_in_vec_init.rs b/src/tools/clippy/clippy_lints/src/single_range_in_vec_init.rs index fc5702a358bbc..bfde4fd981572 100644 --- a/src/tools/clippy/clippy_lints/src/single_range_in_vec_init.rs +++ b/src/tools/clippy/clippy_lints/src/single_range_in_vec_init.rs @@ -102,7 +102,7 @@ impl LateLintPass<'_> for SingleRangeInVecInit { let mut applicability = Applicability::MaybeIncorrect; let suggestion = match (range.start, range.end, range.limits) { (Some(start), Some(end), limits) => { - let ty = cx.typeck_results().expr_ty(start); + let ty = cx.typeck_results.expr_ty(start); let (start_snippet, _) = snippet_with_context(cx, start.span, span.ctxt(), "..", &mut applicability); let (end_snippet, _) = snippet_with_context(cx, end.span, span.ctxt(), "..", &mut applicability); @@ -148,7 +148,7 @@ impl LateLintPass<'_> for SingleRangeInVecInit { span, format!( "{suggested_type} of `{}` that is only one element", - cx.typeck_results() + cx.typeck_results .expr_ty(inner_expr) .ty_adt_def() .map_or(sym::Range, |adt_def| cx.tcx.item_name(adt_def.did())) diff --git a/src/tools/clippy/clippy_lints/src/size_of_in_element_count.rs b/src/tools/clippy/clippy_lints/src/size_of_in_element_count.rs index 3623039aece15..5a7b2e64f90bb 100644 --- a/src/tools/clippy/clippy_lints/src/size_of_in_element_count.rs +++ b/src/tools/clippy/clippy_lints/src/size_of_in_element_count.rs @@ -43,7 +43,7 @@ fn get_size_of_ty<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, inverted: Some(sym::mem_size_of | sym::mem_size_of_val) ) { - cx.typeck_results().node_args(count_func.hir_id).types().next() + cx.typeck_results.node_args(count_func.hir_id).types().next() } else { None } @@ -92,7 +92,7 @@ fn get_pointee_ty_and_count_expr<'tcx>( )) // Get the pointee type - && let Some(pointee_ty) = cx.typeck_results().node_args(func.hir_id).types().next() + && let Some(pointee_ty) = cx.typeck_results.node_args(func.hir_id).types().next() { return Some((pointee_ty, count)); } @@ -103,7 +103,7 @@ fn get_pointee_ty_and_count_expr<'tcx>( // Get the pointee type && let ty::RawPtr(pointee_ty, _) = - cx.typeck_results().expr_ty(ptr_self).kind() + cx.typeck_results.expr_ty(ptr_self).kind() { return Some((*pointee_ty, count)); } diff --git a/src/tools/clippy/clippy_lints/src/size_of_ref.rs b/src/tools/clippy/clippy_lints/src/size_of_ref.rs index 0e78cf277c643..971e3b0b7faec 100644 --- a/src/tools/clippy/clippy_lints/src/size_of_ref.rs +++ b/src/tools/clippy/clippy_lints/src/size_of_ref.rs @@ -59,7 +59,7 @@ impl LateLintPass<'_> for SizeOfRef { fn check_expr(&mut self, cx: &LateContext<'_>, expr: &'_ Expr<'_>) { if let ExprKind::Call(path, [arg]) = expr.kind && path.basic_res().is_diag_item(cx, sym::mem_size_of_val) - && let arg_ty = cx.typeck_results().expr_ty(arg) + && let arg_ty = cx.typeck_results.expr_ty(arg) && peel_and_count_ty_refs(arg_ty).1 > 1 { span_lint_and_help( diff --git a/src/tools/clippy/clippy_lints/src/string_patterns.rs b/src/tools/clippy/clippy_lints/src/string_patterns.rs index b4eb8977bf0fb..4d57d11fb00ff 100644 --- a/src/tools/clippy/clippy_lints/src/string_patterns.rs +++ b/src/tools/clippy/clippy_lints/src/string_patterns.rs @@ -128,7 +128,7 @@ fn check_single_char_pattern_lint(cx: &LateContext<'_>, arg: &Expr<'_>) { } fn get_char_span<'tcx>(cx: &'_ LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option { - if cx.typeck_results().expr_ty_adjusted(expr).is_char() + if cx.typeck_results.expr_ty_adjusted(expr).is_char() && !expr.span.from_expansion() && switch_to_eager_eval(cx, expr) { @@ -230,7 +230,7 @@ impl<'tcx> LateLintPass<'tcx> for StringPatterns { fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) { if !expr.span.from_expansion() && let ExprKind::MethodCall(method, receiver, args, _) = expr.kind - && let ty::Ref(_, ty, _) = cx.typeck_results().expr_ty_adjusted(receiver).kind() + && let ty::Ref(_, ty, _) = cx.typeck_results.expr_ty_adjusted(receiver).kind() && ty.is_str() && let method_name = method.ident.name && let Some(&(_, pos)) = PATTERN_METHODS diff --git a/src/tools/clippy/clippy_lints/src/strings.rs b/src/tools/clippy/clippy_lints/src/strings.rs index df3ca09dd76df..2c88235494e69 100644 --- a/src/tools/clippy/clippy_lints/src/strings.rs +++ b/src/tools/clippy/clippy_lints/src/strings.rs @@ -259,7 +259,7 @@ impl<'tcx> LateLintPass<'tcx> for StringAdd { ); }, ExprKind::Index(target, _idx, _) => { - let e_ty = cx.typeck_results().expr_ty_adjusted(target).peel_refs(); + let e_ty = cx.typeck_results.expr_ty_adjusted(target).peel_refs(); if e_ty.is_str() || e_ty.is_lang_item(cx, LangItem::String) { span_lint( cx, @@ -275,7 +275,7 @@ impl<'tcx> LateLintPass<'tcx> for StringAdd { } fn is_string(cx: &LateContext<'_>, e: &Expr<'_>) -> bool { - cx.typeck_results() + cx.typeck_results .expr_ty(e) .peel_refs() .is_lang_item(cx, LangItem::String) @@ -418,7 +418,7 @@ impl<'tcx> LateLintPass<'tcx> for StrToString { if let ExprKind::MethodCall(path, self_arg, [], _) = &expr.kind && path.ident.name == sym::to_string - && let ty = cx.typeck_results().expr_ty(self_arg) + && let ty = cx.typeck_results.expr_ty(self_arg) && let ty::Ref(_, ty, ..) = ty.kind() && ty.is_str() { @@ -440,7 +440,7 @@ impl<'tcx> LateLintPass<'tcx> for StrToString { && args.iter().any(|a| a.hir_id == expr.hir_id) && let Res::Def(DefKind::AssocFn, def_id) = expr.res(cx) && cx.tcx.is_diagnostic_item(sym::to_string_method, def_id) - && let Some(args) = cx.typeck_results().node_args_opt(expr.hir_id) + && let Some(args) = cx.typeck_results.node_args_opt(expr.hir_id) && args.type_at(0).is_str() { // Detected `ToString::to_string` passed as an argument (generic: any call or method call) @@ -459,7 +459,7 @@ impl<'tcx> LateLintPass<'tcx> for StrToString { impl<'tcx> LateLintPass<'tcx> for TrimSplitWhitespace { fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'_>) { - let tyckres = cx.typeck_results(); + let tyckres = cx.typeck_results; if let ExprKind::MethodCall(path, split_recv, [], split_ws_span) = expr.kind && path.ident.name == sym::split_whitespace && let Some(split_ws_def_id) = tyckres.type_dependent_def_id(expr.hir_id) diff --git a/src/tools/clippy/clippy_lints/src/strlen_on_c_strings.rs b/src/tools/clippy/clippy_lints/src/strlen_on_c_strings.rs index 53038672d1ec4..f7d607c73f663 100644 --- a/src/tools/clippy/clippy_lints/src/strlen_on_c_strings.rs +++ b/src/tools/clippy/clippy_lints/src/strlen_on_c_strings.rs @@ -59,7 +59,7 @@ impl<'tcx> LateLintPass<'tcx> for StrlenOnCStrings { && let ExprKind::MethodCall(path, self_arg, [], _) = recv.kind && !recv.span.from_expansion() && path.ident.name == sym::as_ptr - && let typeck = cx.typeck_results() + && let typeck = cx.typeck_results && typeck .expr_ty_adjusted(self_arg) .peel_refs() diff --git a/src/tools/clippy/clippy_lints/src/swap.rs b/src/tools/clippy/clippy_lints/src/swap.rs index 871c59d52659e..c2c3f5aa98c15 100644 --- a/src/tools/clippy/clippy_lints/src/swap.rs +++ b/src/tools/clippy/clippy_lints/src/swap.rs @@ -105,7 +105,7 @@ fn generate_swap_warning<'tcx>( && e2.span.ctxt() == ctxt && eq_expr_value(cx, ctxt, lhs1, lhs2) { - let ty = cx.typeck_results().expr_ty(lhs1).peel_refs(); + let ty = cx.typeck_results.expr_ty(lhs1).peel_refs(); if matches!(ty.kind(), ty::Slice(_)) || matches!(ty.kind(), ty::Array(_, _)) diff --git a/src/tools/clippy/clippy_lints/src/swap_ptr_to_ref.rs b/src/tools/clippy/clippy_lints/src/swap_ptr_to_ref.rs index 4d7bb2cc1f988..27d252c014189 100644 --- a/src/tools/clippy/clippy_lints/src/swap_ptr_to_ref.rs +++ b/src/tools/clippy/clippy_lints/src/swap_ptr_to_ref.rs @@ -76,7 +76,7 @@ impl LateLintPass<'_> for SwapPtrToRef { fn is_ptr_to_ref(cx: &LateContext<'_>, e: &Expr<'_>, ctxt: SyntaxContext) -> (bool, Option) { if let ExprKind::AddrOf(BorrowKind::Ref, Mutability::Mut, borrowed_expr) = e.kind && let ExprKind::Unary(UnOp::Deref, derefed_expr) = borrowed_expr.kind - && cx.typeck_results().expr_ty(derefed_expr).is_raw_ptr() + && cx.typeck_results.expr_ty(derefed_expr).is_raw_ptr() { ( true, diff --git a/src/tools/clippy/clippy_lints/src/time_subtraction.rs b/src/tools/clippy/clippy_lints/src/time_subtraction.rs index e906ee081346f..d5410da384e9a 100644 --- a/src/tools/clippy/clippy_lints/src/time_subtraction.rs +++ b/src/tools/clippy/clippy_lints/src/time_subtraction.rs @@ -95,7 +95,7 @@ impl LateLintPass<'_> for UncheckedTimeSubtraction { ExprKind::MethodCall(_, lhs, [rhs], _) if cx.ty_based_def(expr).is_diag_item(cx, sym::sub) => (lhs, rhs), _ => return, }; - let typeck = cx.typeck_results(); + let typeck = cx.typeck_results; let lhs_name = typeck.expr_ty(lhs).opt_diag_name(cx); let rhs_name = typeck.expr_ty(rhs).opt_diag_name(cx); @@ -159,7 +159,7 @@ fn is_chained_time_subtraction(cx: &LateContext<'_>, lhs: &Expr<'_>) -> bool { if let ExprKind::Binary(op, inner_lhs, inner_rhs) = &lhs.kind && matches!(op.node, BinOpKind::Sub) { - let typeck = cx.typeck_results(); + let typeck = cx.typeck_results; let left_ty = typeck.expr_ty(inner_lhs); let right_ty = typeck.expr_ty(inner_rhs); is_time_type(cx, left_ty) && is_time_type(cx, right_ty) diff --git a/src/tools/clippy/clippy_lints/src/to_digit_is_some.rs b/src/tools/clippy/clippy_lints/src/to_digit_is_some.rs index 71c4172c98528..587f0c76cf02d 100644 --- a/src/tools/clippy/clippy_lints/src/to_digit_is_some.rs +++ b/src/tools/clippy/clippy_lints/src/to_digit_is_some.rs @@ -55,7 +55,7 @@ impl<'tcx> LateLintPass<'tcx> for ToDigitIsSome { let match_result = match to_digit_expr.kind { hir::ExprKind::MethodCall(to_digits_path, char_arg, [radix_arg], _) => { if to_digits_path.ident.name == sym::to_digit - && cx.typeck_results().expr_ty_adjusted(char_arg).is_char() + && cx.typeck_results.expr_ty_adjusted(char_arg).is_char() { Some((true, char_arg, radix_arg)) } else { diff --git a/src/tools/clippy/clippy_lints/src/transmute/eager_transmute.rs b/src/tools/clippy/clippy_lints/src/transmute/eager_transmute.rs index 05c0af9228543..59c5acca34ef5 100644 --- a/src/tools/clippy/clippy_lints/src/transmute/eager_transmute.rs +++ b/src/tools/clippy/clippy_lints/src/transmute/eager_transmute.rs @@ -45,7 +45,7 @@ fn binops_with_local(cx: &LateContext<'_>, local_expr: &Expr<'_>, expr: &Expr<'_ ExprKind::MethodCall(path, receiver, [arg], _) if path.ident.name == sym::contains // ... `contains` called on some kind of range - && let Some(receiver_adt) = cx.typeck_results().expr_ty(receiver).peel_refs().ty_adt_def() + && let Some(receiver_adt) = cx.typeck_results.expr_ty(receiver).peel_refs().ty_adt_def() && let lang_items = cx.tcx.lang_items() && [ lang_items.range_from_struct(), @@ -76,7 +76,7 @@ pub(super) fn check<'tcx>( ) -> bool { if let Some(then_some_call) = peel_parent_unsafe_blocks(cx, expr) && let ExprKind::MethodCall(path, receiver, [arg], _) = then_some_call.kind - && cx.typeck_results().expr_ty(receiver).is_bool() + && cx.typeck_results.expr_ty(receiver).is_bool() && path.ident.name == sym::then_some && is_local_with_projections(transmutable) && binops_with_local(cx, transmutable, receiver) diff --git a/src/tools/clippy/clippy_lints/src/transmute/mod.rs b/src/tools/clippy/clippy_lints/src/transmute/mod.rs index 4a150ba098e4b..6492bd3755d67 100644 --- a/src/tools/clippy/clippy_lints/src/transmute/mod.rs +++ b/src/tools/clippy/clippy_lints/src/transmute/mod.rs @@ -535,12 +535,12 @@ impl<'tcx> LateLintPass<'tcx> for Transmute { // - char conversions (https://github.com/rust-lang/rust/issues/89259) let const_context = is_in_const_context(cx); - let (from_ty, from_ty_adjusted) = match cx.typeck_results().expr_adjustments(arg) { - [] => (cx.typeck_results().expr_ty(arg), false), + let (from_ty, from_ty_adjusted) = match cx.typeck_results.expr_adjustments(arg) { + [] => (cx.typeck_results.expr_ty(arg), false), [.., a] => (a.target, true), }; // Adjustments for `to_ty` happen after the call to `transmute`, so don't use them. - let to_ty = cx.typeck_results().expr_ty(e); + let to_ty = cx.typeck_results.expr_ty(e); // If useless_transmute is triggered, the other lints can be skipped. if useless_transmute::check(cx, e, from_ty, to_ty, arg) { diff --git a/src/tools/clippy/clippy_lints/src/tuple_array_conversions.rs b/src/tools/clippy/clippy_lints/src/tuple_array_conversions.rs index 8bbecb5c19540..181214987e2cd 100644 --- a/src/tools/clippy/clippy_lints/src/tuple_array_conversions.rs +++ b/src/tools/clippy/clippy_lints/src/tuple_array_conversions.rs @@ -67,7 +67,7 @@ impl LateLintPass<'_> for TupleArrayConversions { } fn check_array<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, elements: &'tcx [Expr<'tcx>]) { - let Some(ty) = cx.typeck_results().expr_ty(expr).builtin_index() else { + let Some(ty) = cx.typeck_results.expr_ty(expr).builtin_index() else { unreachable!("`expr` must be an array or slice due to `ExprKind::Array`"); }; @@ -101,7 +101,7 @@ fn check_array<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, elements: & } fn check_tuple<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, elements: &'tcx [Expr<'tcx>]) { - if let ty::Tuple(tys) = cx.typeck_results().expr_ty(expr).kind() + if let ty::Tuple(tys) = cx.typeck_results.expr_ty(expr).kind() && let [first, ..] = elements // Fix #11100 && tys.iter().all_equal() @@ -192,7 +192,7 @@ fn all_bindings_are_for_conv<'tcx>( Node::LetStmt(l) => Some(l.hir_id), _ => None, } - .map(|hir_id| cx.typeck_results().node_type(hir_id)) else { + .map(|hir_id| cx.typeck_results.node_type(hir_id)) else { return false; }; match (kind, ty.kind()) { diff --git a/src/tools/clippy/clippy_lints/src/unconditional_recursion.rs b/src/tools/clippy/clippy_lints/src/unconditional_recursion.rs index 3df16bf71ce7e..f02ebd23c9eb2 100644 --- a/src/tools/clippy/clippy_lints/src/unconditional_recursion.rs +++ b/src/tools/clippy/clippy_lints/src/unconditional_recursion.rs @@ -176,7 +176,7 @@ fn matches_ty<'tcx>( fn check_partial_eq(cx: &LateContext<'_>, method_span: Span, method_def_id: LocalDefId, name: Ident, expr: &Expr<'_>) { let Some(sig) = cx - .typeck_results() + .typeck_results .liberated_fn_sigs() .get(cx.tcx.local_def_id_to_hir_id(method_def_id)) else { @@ -200,15 +200,15 @@ fn check_partial_eq(cx: &LateContext<'_>, method_span: Span, method_def_id: Loca let is_bad = match expr.kind { ExprKind::Binary(op, left, right) if op.node == to_check_op => { // Then we check if the LHS matches self_arg and RHS matches other_arg - let left_ty = cx.typeck_results().expr_ty_adjusted(left); - let right_ty = cx.typeck_results().expr_ty_adjusted(right); + let left_ty = cx.typeck_results.expr_ty_adjusted(left); + let right_ty = cx.typeck_results.expr_ty_adjusted(right); matches_ty(left_ty, right_ty, self_arg, other_arg) }, ExprKind::MethodCall(segment, receiver, [arg], _) if segment.ident.name == name.name => { - let receiver_ty = cx.typeck_results().expr_ty_adjusted(receiver); - let arg_ty = cx.typeck_results().expr_ty_adjusted(arg); + let receiver_ty = cx.typeck_results.expr_ty_adjusted(receiver); + let arg_ty = cx.typeck_results.expr_ty_adjusted(arg); - if let Some(fn_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) + if let Some(fn_id) = cx.typeck_results.type_dependent_def_id(expr.hir_id) && let Some(trait_id) = cx.tcx.trait_of_assoc(fn_id) && trait_id == trait_def_id && matches_ty(receiver_ty, arg_ty, self_arg, other_arg) @@ -252,7 +252,7 @@ fn check_to_string(cx: &LateContext<'_>, method_span: Span, method_def_id: Local { let is_bad = match expr.kind { ExprKind::MethodCall(segment, _receiver, &[_arg], _) if segment.ident.name == name.name => { - if let Some(fn_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) + if let Some(fn_id) = cx.typeck_results.type_dependent_def_id(expr.hir_id) && let Some(trait_id) = cx.tcx.trait_of_assoc(fn_id) && trait_id == trait_def_id { @@ -412,7 +412,7 @@ impl UnconditionalRecursion { fn check_from(cx: &LateContext<'_>, method_span: Span, method_def_id: LocalDefId, expr: &Expr<'_>) { let Some(sig) = cx - .typeck_results() + .typeck_results .liberated_fn_sigs() .get(cx.tcx.local_def_id_to_hir_id(method_def_id)) else { diff --git a/src/tools/clippy/clippy_lints/src/uninhabited_references.rs b/src/tools/clippy/clippy_lints/src/uninhabited_references.rs index b342f37f0c5ff..2547a60559bcb 100644 --- a/src/tools/clippy/clippy_lints/src/uninhabited_references.rs +++ b/src/tools/clippy/clippy_lints/src/uninhabited_references.rs @@ -44,7 +44,7 @@ impl LateLintPass<'_> for UninhabitedReferences { } if let ExprKind::Unary(UnOp::Deref, _) = expr.kind { - let ty = cx.typeck_results().expr_ty_adjusted(expr); + let ty = cx.typeck_results.expr_ty_adjusted(expr); if ty.is_privately_uninhabited(cx.tcx, cx.typing_env()) { span_lint( cx, diff --git a/src/tools/clippy/clippy_lints/src/uninit_vec.rs b/src/tools/clippy/clippy_lints/src/uninit_vec.rs index 9449d44c009e5..37607ff4a9062 100644 --- a/src/tools/clippy/clippy_lints/src/uninit_vec.rs +++ b/src/tools/clippy/clippy_lints/src/uninit_vec.rs @@ -95,7 +95,7 @@ fn handle_uninit_vec_pair<'tcx>( if let Some(vec) = extract_init_or_reserve_target(cx, maybe_init_or_reserve) && let Some((set_len_self, call_span)) = extract_set_len_self(cx, maybe_set_len) && vec.location.eq_expr(cx, ctxt, set_len_self) - && let ty::Ref(_, vec_ty, _) = cx.typeck_results().expr_ty_adjusted(set_len_self).kind() + && let ty::Ref(_, vec_ty, _) = cx.typeck_results.expr_ty_adjusted(set_len_self).kind() && let ty::Adt(_, args) = vec_ty.kind() // `#[allow(...)]` attribute can be set on enclosing unsafe block of `set_len()` && !is_lint_allowed(cx, UNINIT_VEC, maybe_set_len.hir_id) @@ -193,7 +193,7 @@ fn extract_init_or_reserve_target<'tcx>(cx: &LateContext<'tcx>, stmt: &'tcx Stmt } fn is_reserve(cx: &LateContext<'_>, path: &PathSegment<'_>, self_expr: &Expr<'_>) -> bool { - cx.typeck_results() + cx.typeck_results .expr_ty(self_expr) .peel_refs() .is_diag_item(cx, sym::Vec) @@ -217,7 +217,7 @@ fn extract_set_len_self<'tcx>(cx: &LateContext<'_>, expr: &'tcx Expr<'_>) -> Opt }); match expr.kind { ExprKind::MethodCall(path, self_expr, [arg], _) => { - let self_type = cx.typeck_results().expr_ty(self_expr).peel_refs(); + let self_type = cx.typeck_results.expr_ty(self_expr).peel_refs(); if self_type.is_diag_item(cx, sym::Vec) && path.ident.name == sym::set_len && !is_integer_literal(arg, 0) { Some((self_expr, expr.span)) } else { diff --git a/src/tools/clippy/clippy_lints/src/unit_return_expecting_ord.rs b/src/tools/clippy/clippy_lints/src/unit_return_expecting_ord.rs index 735225a9e2cee..980dadb7c6efe 100644 --- a/src/tools/clippy/clippy_lints/src/unit_return_expecting_ord.rs +++ b/src/tools/clippy/clippy_lints/src/unit_return_expecting_ord.rs @@ -88,7 +88,7 @@ fn get_args_to_check<'tcx>( partial_ord_trait: Option, ) -> Vec<(usize, Symbol)> { let mut args_to_check = Vec::new(); - if let Some(def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) { + if let Some(def_id) = cx.typeck_results.type_dependent_def_id(expr.hir_id) { let fn_sig = cx.tcx.fn_sig(def_id).instantiate_identity().skip_norm_wip(); let generics = cx.tcx.predicates_of(def_id); let [fn_mut_preds, ord_preds, partial_ord_preds] = @@ -138,7 +138,7 @@ fn get_args_to_check<'tcx>( fn check_arg<'tcx>(cx: &LateContext<'tcx>, arg: &'tcx Expr<'tcx>) -> Option<(Span, Option)> { if let ExprKind::Closure(&Closure { body, fn_decl_span, .. }) = arg.kind - && let ty::Closure(_def_id, args) = &cx.typeck_results().node_type(arg.hir_id).kind() + && let ty::Closure(_def_id, args) = &cx.typeck_results.node_type(arg.hir_id).kind() && let ret_ty = args.as_closure().sig().output() && let ty = cx.tcx.instantiate_bound_regions_with_erased(ret_ty) && ty.is_unit() diff --git a/src/tools/clippy/clippy_lints/src/unit_types/let_unit_value.rs b/src/tools/clippy/clippy_lints/src/unit_types/let_unit_value.rs index 8bb6ceb863a37..0f2a64bdea3eb 100644 --- a/src/tools/clippy/clippy_lints/src/unit_types/let_unit_value.rs +++ b/src/tools/clippy/clippy_lints/src/unit_types/let_unit_value.rs @@ -26,7 +26,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, format_args: &FormatArgsStorag && !local.pat.span.from_expansion() && !local.span.in_external_macro(cx.sess().source_map()) && !local.span.is_from_async_await() - && cx.typeck_results().pat_ty(local.pat).is_unit() + && cx.typeck_results.pat_ty(local.pat).is_unit() { // skip `let awa = ()` if let ExprKind::Tup([]) = init.kind { @@ -303,7 +303,7 @@ fn needs_inferred_result_ty( Res::Def(DefKind::AssocFn | DefKind::Fn, id) => (id, None, args), _ => return false, }, - ExprKind::MethodCall(_, receiver, args, _) => match cx.typeck_results().type_dependent_def_id(e.hir_id) { + ExprKind::MethodCall(_, receiver, args, _) => match cx.typeck_results.type_dependent_def_id(e.hir_id) { Some(id) => (id, Some(receiver), args), None => return false, }, diff --git a/src/tools/clippy/clippy_lints/src/unit_types/unit_arg.rs b/src/tools/clippy/clippy_lints/src/unit_types/unit_arg.rs index 6df3e7baa1bca..ab15722806b0c 100644 --- a/src/tools/clippy/clippy_lints/src/unit_types/unit_arg.rs +++ b/src/tools/clippy/clippy_lints/src/unit_types/unit_arg.rs @@ -40,7 +40,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) { .into_iter() .chain(args) .filter(|arg| { - if cx.typeck_results().expr_ty(arg).is_unit() && !utils::is_unit_literal(arg) { + if cx.typeck_results.expr_ty(arg).is_unit() && !utils::is_unit_literal(arg) { !matches!( &arg.kind, ExprKind::Match(.., MatchSource::TryDesugar(_)) | ExprKind::Path(..) diff --git a/src/tools/clippy/clippy_lints/src/unit_types/unit_cmp.rs b/src/tools/clippy/clippy_lints/src/unit_types/unit_cmp.rs index 38716519e23b6..7722089dc90b9 100644 --- a/src/tools/clippy/clippy_lints/src/unit_types/unit_cmp.rs +++ b/src/tools/clippy/clippy_lints/src/unit_types/unit_cmp.rs @@ -22,7 +22,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) { if is_unit_expr(lhs) || is_unit_expr(rhs) { return; } - if !cx.typeck_results().expr_ty(lhs).is_unit() { + if !cx.typeck_results.expr_ty(lhs).is_unit() { return; } span_lint( @@ -40,7 +40,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) { if let ExprKind::Binary(ref cmp, left, _) = expr.kind { let op = cmp.node; - if op.is_comparison() && cx.typeck_results().expr_ty(left).is_unit() { + if op.is_comparison() && cx.typeck_results.expr_ty(left).is_unit() { let result = match op { BinOpKind::Eq | BinOpKind::Le | BinOpKind::Ge => "true", _ => "false", diff --git a/src/tools/clippy/clippy_lints/src/unnecessary_map_on_constructor.rs b/src/tools/clippy/clippy_lints/src/unnecessary_map_on_constructor.rs index 6754c224e7e42..52ff3496f0d66 100644 --- a/src/tools/clippy/clippy_lints/src/unnecessary_map_on_constructor.rs +++ b/src/tools/clippy/clippy_lints/src/unnecessary_map_on_constructor.rs @@ -42,7 +42,7 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryMapOnConstructor { && let hir::ExprKind::MethodCall(path, recv, [map_arg], ..) = expr.kind && !map_arg.span.from_expansion() && let hir::ExprKind::Path(fun) = map_arg.kind - && let Some(sym::Option | sym::Result) = cx.typeck_results().expr_ty(recv).opt_diag_name(cx) + && let Some(sym::Option | sym::Result) = cx.typeck_results.expr_ty(recv).opt_diag_name(cx) { let (constructor_path, constructor_item) = if let hir::ExprKind::Call(constructor, [arg, ..]) = recv.kind && let hir::ExprKind::Path(constructor_path) = constructor.kind diff --git a/src/tools/clippy/clippy_lints/src/unnecessary_mut_passed.rs b/src/tools/clippy/clippy_lints/src/unnecessary_mut_passed.rs index 75b0b7b10687a..260cea4f03988 100644 --- a/src/tools/clippy/clippy_lints/src/unnecessary_mut_passed.rs +++ b/src/tools/clippy/clippy_lints/src/unnecessary_mut_passed.rs @@ -50,16 +50,16 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryMutPassed { check_arguments( cx, &mut arguments.iter(), - cx.typeck_results().expr_ty(fn_expr), + cx.typeck_results.expr_ty(fn_expr), &rustc_hir_pretty::qpath_to_string(&cx.tcx, path), "function", ); } }, ExprKind::MethodCall(path, receiver, arguments, _) - if let Some(def_id) = cx.typeck_results().type_dependent_def_id(e.hir_id) => + if let Some(def_id) = cx.typeck_results.type_dependent_def_id(e.hir_id) => { - let args = cx.typeck_results().node_args(e.hir_id); + let args = cx.typeck_results.node_args(e.hir_id); let method_type = cx.tcx.type_of(def_id).instantiate(cx.tcx, args).skip_norm_wip(); check_arguments( cx, diff --git a/src/tools/clippy/clippy_lints/src/unnecessary_owned_empty_strings.rs b/src/tools/clippy/clippy_lints/src/unnecessary_owned_empty_strings.rs index 6960c006ab949..b405311285da0 100644 --- a/src/tools/clippy/clippy_lints/src/unnecessary_owned_empty_strings.rs +++ b/src/tools/clippy/clippy_lints/src/unnecessary_owned_empty_strings.rs @@ -41,7 +41,7 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryOwnedEmptyStrings { && let ExprKind::Call(fun, args) = inner_expr.kind && let ExprKind::Path(ref qpath) = fun.kind && let Some(fun_def_id) = cx.qpath_res(qpath, fun.hir_id).opt_def_id() - && let ty::Ref(_, inner_str, _) = cx.typeck_results().expr_ty_adjusted(expr).kind() + && let ty::Ref(_, inner_str, _) = cx.typeck_results.expr_ty_adjusted(expr).kind() && inner_str.is_str() { let fun_name = cx.tcx.get_diagnostic_name(fun_def_id); @@ -60,7 +60,7 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryOwnedEmptyStrings { && let ExprKind::Lit(spanned) = &arg.kind && let LitKind::Str(symbol, _) = spanned.node && symbol.is_empty() - && let inner_expr_type = cx.typeck_results().expr_ty(inner_expr) + && let inner_expr_type = cx.typeck_results.expr_ty(inner_expr) && inner_expr_type.is_lang_item(cx, LangItem::String) { span_lint_and_sugg( diff --git a/src/tools/clippy/clippy_lints/src/unnecessary_semicolon.rs b/src/tools/clippy/clippy_lints/src/unnecessary_semicolon.rs index 8a76fdecc0a67..783a24981a509 100644 --- a/src/tools/clippy/clippy_lints/src/unnecessary_semicolon.rs +++ b/src/tools/clippy/clippy_lints/src/unnecessary_semicolon.rs @@ -50,7 +50,7 @@ impl UnnecessarySemicolon { && let Some(last_stmt) = block.stmts.last() { if enter { - let block_ty = cx.typeck_results().node_type(block.hir_id); + let block_ty = cx.typeck_results.node_type(block.hir_id); self.last_statements.push((last_stmt.hir_id, block_ty.is_unit())); } else { self.last_statements.pop(); @@ -86,7 +86,7 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessarySemicolon { expr.kind, ExprKind::If(..) | ExprKind::Match(_, _, MatchSource::Normal | MatchSource::Postfix) ) - && cx.typeck_results().expr_ty(expr).is_unit() + && cx.typeck_results.expr_ty(expr).is_unit() // if a stmt has attrs, then turning it into an expr will break the code, since attrs aren't allowed on exprs // -- unless the corresponding feature is enabled && (cx.tcx.hir_attrs(stmt.hir_id).is_empty() || cx.tcx.features().stmt_expr_attributes()) diff --git a/src/tools/clippy/clippy_lints/src/unnecessary_struct_initialization.rs b/src/tools/clippy/clippy_lints/src/unnecessary_struct_initialization.rs index 65a3c2f304af8..d37c7a3fc9163 100644 --- a/src/tools/clippy/clippy_lints/src/unnecessary_struct_initialization.rs +++ b/src/tools/clippy/clippy_lints/src/unnecessary_struct_initialization.rs @@ -100,7 +100,7 @@ fn base_is_suitable(cx: &LateContext<'_>, expr: &Expr<'_>, base: &Expr<'_>) -> b // TODO: do not propose to replace *XX if XX is not Copy if let ExprKind::Unary(UnOp::Deref, target) = base.kind && matches!(target.kind, ExprKind::Path(..)) - && !is_copy(cx, cx.typeck_results().expr_ty(expr)) + && !is_copy(cx, cx.typeck_results.expr_ty(expr)) { // `*base` cannot be used instead of the struct in the general case if it is not Copy. return false; @@ -123,7 +123,7 @@ fn same_path_in_all_fields<'tcx>( expr: &Expr<'_>, fields: &[ExprField<'tcx>], ) -> Option<&'tcx Path<'tcx>> { - let ty = cx.typeck_results().expr_ty(expr); + let ty = cx.typeck_results.expr_ty(expr); let mut found = None; @@ -131,7 +131,7 @@ fn same_path_in_all_fields<'tcx>( // fields are assigned from expression if let ExprKind::Field(src_expr, ident) = f.expr.kind // expression type matches - && ty == cx.typeck_results().expr_ty(src_expr) + && ty == cx.typeck_results.expr_ty(src_expr) // field name matches && ident_without_range_desugaring(f.ident) == ident // assigned from a path expression @@ -163,10 +163,10 @@ fn same_path_in_all_fields<'tcx>( fn check_references(cx: &LateContext<'_>, expr_a: &Expr<'_>, expr_b: &Expr<'_>) -> bool { if let Some(parent) = get_parent_expr(cx, expr_a) - && let parent_ty = cx.typeck_results().expr_ty_adjusted(parent) + && let parent_ty = cx.typeck_results.expr_ty_adjusted(parent) && parent_ty.is_any_ptr() { - if is_copy(cx, cx.typeck_results().expr_ty(expr_a)) && expr_b.res_local_id().is_some() { + if is_copy(cx, cx.typeck_results.expr_ty(expr_a)) && expr_b.res_local_id().is_some() { // When the type implements `Copy`, a reference to the new struct works on the // copy. Using the original would borrow it. return false; diff --git a/src/tools/clippy/clippy_lints/src/unused_io_amount.rs b/src/tools/clippy/clippy_lints/src/unused_io_amount.rs index ffce03cb5dbea..29b0f0dd8334c 100644 --- a/src/tools/clippy/clippy_lints/src/unused_io_amount.rs +++ b/src/tools/clippy/clippy_lints/src/unused_io_amount.rs @@ -300,7 +300,7 @@ fn check_io_mode(cx: &LateContext<'_>, call: &hir::Expr<'_>) -> Option { }, }; - if let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(call.hir_id) + if let Some(method_def_id) = cx.typeck_results.type_dependent_def_id(call.hir_id) && let Some(trait_def_id) = cx.tcx.trait_of_assoc(method_def_id) { if let Some(diag_name) = cx.tcx.get_diagnostic_name(trait_def_id) { diff --git a/src/tools/clippy/clippy_lints/src/unused_peekable.rs b/src/tools/clippy/clippy_lints/src/unused_peekable.rs index 668663e4cf794..f4b24206df551 100644 --- a/src/tools/clippy/clippy_lints/src/unused_peekable.rs +++ b/src/tools/clippy/clippy_lints/src/unused_peekable.rs @@ -49,7 +49,7 @@ impl<'tcx> LateLintPass<'tcx> for UnusedPeekable { fn check_block(&mut self, cx: &LateContext<'tcx>, block: &Block<'tcx>) { // Don't lint `Peekable`s returned from a block if let Some(expr) = block.expr - && let Some(ty) = cx.typeck_results().expr_ty_opt(peel_ref_operators(cx, expr)) + && let Some(ty) = cx.typeck_results.expr_ty_opt(peel_ref_operators(cx, expr)) && ty.is_diag_item(cx, sym::IterPeekable) { return; @@ -61,7 +61,7 @@ impl<'tcx> LateLintPass<'tcx> for UnusedPeekable { && let PatKind::Binding(_, binding, ident, _) = local.pat.kind && let Some(init) = local.init && !init.span.from_expansion() - && let Some(ty) = cx.typeck_results().expr_ty_opt(init) + && let Some(ty) = cx.typeck_results.expr_ty_opt(init) && let (ty, _, None | Some(Mutability::Mut)) = peel_and_count_ty_refs(ty) && ty.is_diag_item(cx, sym::IterPeekable) { @@ -215,7 +215,7 @@ impl<'tcx> Visitor<'tcx> for PeekableVisitor<'_, 'tcx> { } fn arg_is_mut_peekable(cx: &LateContext<'_>, arg: &Expr<'_>) -> bool { - if let Some(ty) = cx.typeck_results().expr_ty_opt(arg) + if let Some(ty) = cx.typeck_results.expr_ty_opt(arg) && let (ty, _, None | Some(Mutability::Mut)) = peel_and_count_ty_refs(ty) && ty.is_diag_item(cx, sym::IterPeekable) { diff --git a/src/tools/clippy/clippy_lints/src/unused_result_ok.rs b/src/tools/clippy/clippy_lints/src/unused_result_ok.rs index c1dc64e0bbe8d..f5267fbb7cdfa 100644 --- a/src/tools/clippy/clippy_lints/src/unused_result_ok.rs +++ b/src/tools/clippy/clippy_lints/src/unused_result_ok.rs @@ -38,7 +38,7 @@ impl LateLintPass<'_> for UnusedResultOk { if let StmtKind::Semi(expr) = stmt.kind && let ExprKind::MethodCall(ok_path, recv, [], ..) = expr.kind //check is expr.ok() has type Result.ok(, _) && ok_path.ident.name == sym::ok - && cx.typeck_results().expr_ty(recv).is_diag_item(cx, sym::Result) + && cx.typeck_results.expr_ty(recv).is_diag_item(cx, sym::Result) && !stmt.span.in_external_macro(cx.sess().source_map()) { let ctxt = expr.span.ctxt(); diff --git a/src/tools/clippy/clippy_lints/src/unwrap.rs b/src/tools/clippy/clippy_lints/src/unwrap.rs index d87289e1362dd..cfcb253918d69 100644 --- a/src/tools/clippy/clippy_lints/src/unwrap.rs +++ b/src/tools/clippy/clippy_lints/src/unwrap.rs @@ -271,7 +271,7 @@ fn collect_unwrap_info<'tcx>( ExprKind::Unary(UnOp::Not, expr) => inner(cx, if_expr, expr, branch, !invert, false, out), ExprKind::MethodCall(method_name, receiver, [], _) if let Some(local) = extract_local(cx, receiver) - && let ty = cx.typeck_results().expr_ty(receiver) + && let ty = cx.typeck_results.expr_ty(receiver) && let name = method_name.ident.name && let Some((kind, unwrappable)) = option_or_result_call(cx, ty, name) => { @@ -303,7 +303,7 @@ fn extract_local(cx: &LateContext<'_>, mut expr: &Expr<'_>) -> Option { let span = expr.span; let mut field_indices = vec![]; while let ExprKind::Field(recv, _) = expr.kind - && let Some(field_idx) = cx.typeck_results().opt_field_index(expr.hir_id) + && let Some(field_idx) = cx.typeck_results.opt_field_index(expr.hir_id) { field_indices.push(field_idx); expr = recv; diff --git a/src/tools/clippy/clippy_lints/src/unwrap_in_result.rs b/src/tools/clippy/clippy_lints/src/unwrap_in_result.rs index aafd1153f9335..2b8c396e144a5 100644 --- a/src/tools/clippy/clippy_lints/src/unwrap_in_result.rs +++ b/src/tools/clippy/clippy_lints/src/unwrap_in_result.rs @@ -199,7 +199,7 @@ fn is_unwrap_or_expect_call(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<(Op }, )) = func.kind { - is_option_or_result(cx, cx.typeck_results().node_type(hir_ty.hir_id)).map(|oor| (oor, *name)) + is_option_or_result(cx, cx.typeck_results.node_type(hir_ty.hir_id)).map(|oor| (oor, *name)) } else if let ExprKind::MethodCall( PathSegment { ident: Ident { @@ -213,7 +213,7 @@ fn is_unwrap_or_expect_call(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<(Op _, ) = expr.kind { - is_option_or_result(cx, cx.typeck_results().expr_ty_adjusted(recv)).map(|oor| (oor, *name)) + is_option_or_result(cx, cx.typeck_results.expr_ty_adjusted(recv)).map(|oor| (oor, *name)) } else { None } diff --git a/src/tools/clippy/clippy_lints/src/use_self.rs b/src/tools/clippy/clippy_lints/src/use_self.rs index 93d0870a30a21..d796b6b2aaef5 100644 --- a/src/tools/clippy/clippy_lints/src/use_self.rs +++ b/src/tools/clippy/clippy_lints/src/use_self.rs @@ -232,7 +232,7 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf { fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) { if !expr.span.from_expansion() && let Some(&StackItem::Check { impl_id, .. }) = self.stack.last() - && cx.typeck_results().expr_ty(expr) == cx.tcx.type_of(impl_id).instantiate_identity().skip_norm_wip() + && cx.typeck_results.expr_ty(expr) == cx.tcx.type_of(impl_id).instantiate_identity().skip_norm_wip() && self.msrv.meets(cx, msrvs::TYPE_ALIAS_ENUM_VARIANTS) { match expr.kind { @@ -255,7 +255,7 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf { && let PatKind::Expr(&PatExpr { kind: PatExprKind::Path(QPath::Resolved(_, path)), .. }) | PatKind::TupleStruct(QPath::Resolved(_, path), _, _) | PatKind::Struct(QPath::Resolved(_, path), _, _) = pat.kind - && cx.typeck_results().pat_ty(pat) == cx.tcx.type_of(impl_id).instantiate_identity().skip_norm_wip() + && cx.typeck_results.pat_ty(pat) == cx.tcx.type_of(impl_id).instantiate_identity().skip_norm_wip() && self.msrv.meets(cx, msrvs::TYPE_ALIAS_ENUM_VARIANTS) { check_path(cx, path); diff --git a/src/tools/clippy/clippy_lints/src/useless_conversion.rs b/src/tools/clippy/clippy_lints/src/useless_conversion.rs index d6db088ba76c0..ad2b48c086069 100644 --- a/src/tools/clippy/clippy_lints/src/useless_conversion.rs +++ b/src/tools/clippy/clippy_lints/src/useless_conversion.rs @@ -186,7 +186,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion { arg.res(cx).assoc_parent(cx).opt_diag_name(cx), Some(sym::Into | sym::From) ) - && let ty::FnDef(_, args) = cx.typeck_results().expr_ty(arg).kind() + && let ty::FnDef(_, args) = cx.typeck_results.expr_ty(arg).kind() && let &[from_ty, to_ty] = args.into_type_list(cx.tcx).as_slice() && same_type_modulo_regions(from_ty, to_ty) { @@ -209,8 +209,8 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion { ExprKind::MethodCall(name, recv, [], _) => { if cx.ty_based_def(e).opt_parent(cx).is_diag_item(cx, sym::Into) && name.ident.name == sym::into { - let a = cx.typeck_results().expr_ty(e); - let b = cx.typeck_results().expr_ty(recv); + let a = cx.typeck_results.expr_ty(e); + let b = cx.typeck_results.expr_ty(recv); if same_type_modulo_regions(a, b) { let mut app = Applicability::MachineApplicable; let sugg = snippet_with_context(cx, recv.span, e.span.ctxt(), "", &mut app).0; @@ -245,16 +245,16 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion { Some(( did, args, - cx.typeck_results().node_args(recv.hir_id), + cx.typeck_results.node_args(recv.hir_id), MethodOrFunction::Function, )) }, ExprKind::MethodCall(.., args, _) => { - cx.typeck_results().type_dependent_def_id(parent.hir_id).map(|did| { + cx.typeck_results.type_dependent_def_id(parent.hir_id).map(|did| { ( did, args, - cx.typeck_results().node_args(parent.hir_id), + cx.typeck_results.node_args(parent.hir_id), MethodOrFunction::Method, ) }) @@ -272,7 +272,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion { cx, parent_fn_did, into_iter_did, - cx.typeck_results().expr_ty(into_iter_recv), + cx.typeck_results.expr_ty(into_iter_recv), param.index, node_args, ) @@ -322,8 +322,8 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion { return; } - let iter_ty = cx.typeck_results().expr_ty(e); - let into_iter_ty = cx.typeck_results().expr_ty(recv); + let iter_ty = cx.typeck_results.expr_ty(e); + let into_iter_ty = cx.typeck_results.expr_ty(recv); // If the types are identical then .into_iter() can be removed, unless the type // implements Copy, in which case .into_iter() returns a copy of the receiver and @@ -336,7 +336,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion { if let Some(parent) = get_parent_expr(cx, e) && let ExprKind::MethodCall(_, recv, _, _) = parent.kind && recv.hir_id == e.hir_id - && let Some(def_id) = cx.typeck_results().type_dependent_def_id(parent.hir_id) + && let Some(def_id) = cx.typeck_results.type_dependent_def_id(parent.hir_id) && let sig = cx.tcx.fn_sig(def_id).skip_binder().skip_binder() && let inputs = sig.inputs() && inputs.len() >= 2 @@ -395,8 +395,8 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion { } if cx.ty_based_def(e).opt_parent(cx).is_diag_item(cx, sym::TryInto) && name.ident.name == sym::try_into - && let a = cx.typeck_results().expr_ty(e) - && let b = cx.typeck_results().expr_ty(recv) + && let a = cx.typeck_results.expr_ty(e) + && let b = cx.typeck_results.expr_ty(recv) && a.is_diag_item(cx, sym::Result) && let ty::Adt(_, args) = a.kind() && let Some(a_type) = args.types().next() @@ -419,8 +419,8 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion { && let Some(def_id) = cx.qpath_res(qpath, path.hir_id).opt_def_id() && let Some(name) = cx.tcx.get_diagnostic_name(def_id) { - let a = cx.typeck_results().expr_ty(e); - let b = cx.typeck_results().expr_ty(arg); + let a = cx.typeck_results.expr_ty(e); + let b = cx.typeck_results.expr_ty(arg); if name == sym::try_from_fn && a.is_diag_item(cx, sym::Result) && let ty::Adt(_, args) = a.kind() @@ -470,7 +470,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessConversion { fn has_eligible_receiver(cx: &LateContext<'_>, recv: &Expr<'_>, expr: &Expr<'_>) -> bool { if cx.ty_based_def(expr).opt_parent(cx).is_impl(cx) { matches!( - cx.typeck_results().expr_ty(recv).opt_diag_name(cx), + cx.typeck_results.expr_ty(recv).opt_diag_name(cx), Some(sym::Option | sym::Result | sym::ControlFlow) ) } else { @@ -481,7 +481,7 @@ fn has_eligible_receiver(cx: &LateContext<'_>, recv: &Expr<'_>, expr: &Expr<'_>) fn adjustments(cx: &LateContext<'_>, expr: &Expr<'_>) -> String { let mut prefix = String::new(); - let adjustments = cx.typeck_results().expr_adjustments(expr); + let adjustments = cx.typeck_results.expr_adjustments(expr); let [.., last] = adjustments else { return prefix }; let target = last.target; diff --git a/src/tools/clippy/clippy_lints/src/useless_vec.rs b/src/tools/clippy/clippy_lints/src/useless_vec.rs index 7b6122213d608..5c91633c1ed82 100644 --- a/src/tools/clippy/clippy_lints/src/useless_vec.rs +++ b/src/tools/clippy/clippy_lints/src/useless_vec.rs @@ -189,7 +189,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessVec { // and don't need to be inserted into the state map. let vec_snippet = match vec_args { higher::VecArgs::Repeat(expr, len) => { - if is_copy(cx, cx.typeck_results().expr_ty(expr)) + if is_copy(cx, cx.typeck_results.expr_ty(expr)) && let Some(Constant::Int(length)) = ConstEvalCtxt::new(cx).eval(len) && let Ok(length) = u64::try_from(length) && size_of(cx, expr) @@ -301,12 +301,12 @@ impl SuggestedType { } fn size_of(cx: &LateContext<'_>, expr: &Expr<'_>) -> u64 { - let ty = cx.typeck_results().expr_ty_adjusted(expr); + let ty = cx.typeck_results.expr_ty_adjusted(expr); cx.layout_of(ty).map_or(0, |l| l.size.bytes()) } fn adjusts_to_slice(cx: &LateContext<'_>, e: &Expr<'_>) -> bool { - matches!(cx.typeck_results().expr_ty_adjusted(e).kind(), ty::Ref(_, ty, _) if ty.is_slice()) + matches!(cx.typeck_results.expr_ty_adjusted(e).kind(), ty::Ref(_, ty, _) if ty.is_slice()) } fn suggest_type(expr: &Expr<'_>) -> SuggestedType { diff --git a/src/tools/clippy/clippy_lints/src/vec_init_then_push.rs b/src/tools/clippy/clippy_lints/src/vec_init_then_push.rs index 5d074208c029c..73c979fe30ba8 100644 --- a/src/tools/clippy/clippy_lints/src/vec_init_then_push.rs +++ b/src/tools/clippy/clippy_lints/src/vec_init_then_push.rs @@ -76,7 +76,7 @@ impl VecPushSearcher { let Some(parent) = get_parent_expr(cx, e) else { return ControlFlow::Continue(()); }; - let adjusted_ty = cx.typeck_results().expr_ty_adjusted(e); + let adjusted_ty = cx.typeck_results.expr_ty_adjusted(e); let adjusted_mut = adjusted_ty.ref_mutability().unwrap_or(Mutability::Not); needs_mut |= adjusted_mut == Mutability::Mut; match parent.kind { @@ -95,7 +95,7 @@ impl VecPushSearcher { break; } } - needs_mut |= cx.typeck_results().expr_ty_adjusted(last_place).ref_mutability() + needs_mut |= cx.typeck_results.expr_ty_adjusted(last_place).ref_mutability() == Some(Mutability::Mut) || get_parent_expr(cx, last_place) .is_some_and(|e| matches!(e.kind, ExprKind::AddrOf(_, Mutability::Mut, _))); diff --git a/src/tools/clippy/clippy_lints/src/volatile_composites.rs b/src/tools/clippy/clippy_lints/src/volatile_composites.rs index 45177c7a86be6..1f191c91d38b9 100644 --- a/src/tools/clippy/clippy_lints/src/volatile_composites.rs +++ b/src/tools/clippy/clippy_lints/src/volatile_composites.rs @@ -150,7 +150,7 @@ impl<'tcx> LateLintPass<'tcx> for VolatileComposites { ExprKind::MethodCall(name, self_arg, _, _) if matches!(name.ident.name, sym::read_volatile | sym::write_volatile) => { - let self_ty = cx.typeck_results().expr_ty(self_arg); + let self_ty = cx.typeck_results.expr_ty(self_arg); match self_ty.kind() { // Raw pointers ty::RawPtr(innerty, _) => report_volatile_safe(cx, expr, *innerty), @@ -170,7 +170,7 @@ impl<'tcx> LateLintPass<'tcx> for VolatileComposites { cx.tcx.get_diagnostic_name(def_id), Some(sym::ptr_read_volatile | sym::ptr_write_volatile) ) - && let ty::RawPtr(ptrty, _) = cx.typeck_results().expr_ty_adjusted(arg_ptr).kind() + && let ty::RawPtr(ptrty, _) = cx.typeck_results.expr_ty_adjusted(arg_ptr).kind() { report_volatile_safe(cx, expr, *ptrty); } diff --git a/src/tools/clippy/clippy_lints/src/with_capacity_zero.rs b/src/tools/clippy/clippy_lints/src/with_capacity_zero.rs index 26c09c9dc3a6b..374d3ae65fea7 100644 --- a/src/tools/clippy/clippy_lints/src/with_capacity_zero.rs +++ b/src/tools/clippy/clippy_lints/src/with_capacity_zero.rs @@ -53,7 +53,7 @@ impl<'tcx> LateLintPass<'tcx> for WithCapacityZero { && cx.tcx.item_name(def_id) == sym::with_capacity && is_integer_literal(arg, 0) && let ExprKind::Path(ref qpath) = func.kind - && let ty = cx.typeck_results().expr_ty(expr) + && let ty = cx.typeck_results.expr_ty(expr) && is_target_type(cx, ty) { let last_seg = last_path_segment(qpath); diff --git a/src/tools/clippy/clippy_lints/src/zero_repeat_side_effects.rs b/src/tools/clippy/clippy_lints/src/zero_repeat_side_effects.rs index cb254cc156296..ab21d1b11450b 100644 --- a/src/tools/clippy/clippy_lints/src/zero_repeat_side_effects.rs +++ b/src/tools/clippy/clippy_lints/src/zero_repeat_side_effects.rs @@ -74,8 +74,8 @@ fn inner_check(cx: &LateContext<'_>, expr: &'_ Expr<'_>, inner_expr: &'_ Expr<'_ // check if expr is a call or has a call inside it if inner_expr.can_have_side_effects() { let parent_hir_node = cx.tcx.parent_hir_node(expr.hir_id); - let inner_expr_ty = cx.typeck_results().expr_ty(inner_expr); - let return_type = cx.typeck_results().expr_ty(expr); + let inner_expr_ty = cx.typeck_results.expr_ty(inner_expr); + let return_type = cx.typeck_results.expr_ty(expr); let inner_expr = snippet(cx, inner_expr.span.source_callsite(), ".."); let indent = snippet_indent(cx, expr.span).unwrap_or_default(); diff --git a/src/tools/clippy/clippy_lints/src/zombie_processes.rs b/src/tools/clippy/clippy_lints/src/zombie_processes.rs index df2dcdbb9d067..36afed2cd5f6b 100644 --- a/src/tools/clippy/clippy_lints/src/zombie_processes.rs +++ b/src/tools/clippy/clippy_lints/src/zombie_processes.rs @@ -60,7 +60,7 @@ declare_lint_pass!(ZombieProcesses => [ZOMBIE_PROCESSES]); impl<'tcx> LateLintPass<'tcx> for ZombieProcesses { fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) { if let ExprKind::Call(..) | ExprKind::MethodCall(..) = expr.kind - && let child_ty = cx.typeck_results().expr_ty(expr) + && let child_ty = cx.typeck_results.expr_ty(expr) && child_ty.is_diag_item(cx, sym::Child) { match cx.tcx.parent_hir_node(expr.hir_id) { diff --git a/src/tools/clippy/clippy_lints_internal/src/outer_expn_data_pass.rs b/src/tools/clippy/clippy_lints_internal/src/outer_expn_data_pass.rs index 5cdc66ae90536..f97b7c3168f56 100644 --- a/src/tools/clippy/clippy_lints_internal/src/outer_expn_data_pass.rs +++ b/src/tools/clippy/clippy_lints_internal/src/outer_expn_data_pass.rs @@ -42,7 +42,7 @@ impl<'tcx> LateLintPass<'tcx> for OuterExpnDataPass { if let [sym::expn_data, sym::outer_expn] = method_names.as_slice() && let (self_arg, args) = arg_lists[1] && args.is_empty() - && let self_ty = cx.typeck_results().expr_ty(self_arg).peel_refs() + && let self_ty = cx.typeck_results.expr_ty(self_arg).peel_refs() && internal_paths::SYNTAX_CONTEXT.matches_ty(cx, self_ty) { span_lint_and_sugg( diff --git a/src/tools/clippy/clippy_lints_internal/src/repeated_is_diagnostic_item.rs b/src/tools/clippy/clippy_lints_internal/src/repeated_is_diagnostic_item.rs index b300dfa27b0eb..7dfaed999941d 100644 --- a/src/tools/clippy/clippy_lints_internal/src/repeated_is_diagnostic_item.rs +++ b/src/tools/clippy/clippy_lints_internal/src/repeated_is_diagnostic_item.rs @@ -166,7 +166,7 @@ impl<'tcx> LateLintPass<'tcx> for RepeatedIsDiagnosticItem { && eq_expr_value(cx, ctxt, recv1, recv2) { let recv_ty = - with_forced_trimmed_paths!(format!("{}", cx.typeck_results().expr_ty_adjusted(recv1).peel_refs())); + with_forced_trimmed_paths!(format!("{}", cx.typeck_results.expr_ty_adjusted(recv1).peel_refs())); let recv_ty = recv_ty.trim_end_matches("<'_>"); span_lint_and_then( cx, @@ -274,7 +274,7 @@ fn check_ors(cx: &LateContext<'_>, span: Span, left: &Expr<'_>, right: &Expr<'_> && eq_expr_value(cx, ctxt, recv1, recv2) { let recv_ty = - with_forced_trimmed_paths!(format!("{}", cx.typeck_results().expr_ty_adjusted(recv1).peel_refs())); + with_forced_trimmed_paths!(format!("{}", cx.typeck_results.expr_ty_adjusted(recv1).peel_refs())); let recv_ty = recv_ty.trim_end_matches("<'_>"); span_lint_and_then( cx, @@ -340,7 +340,7 @@ fn check_ands(cx: &LateContext<'_>, span: Span, left: &Expr<'_>, right: &Expr<'_ && eq_expr_value(cx, ctxt, recv1, recv2) { let recv_ty = - with_forced_trimmed_paths!(format!("{}", cx.typeck_results().expr_ty_adjusted(recv1).peel_refs())); + with_forced_trimmed_paths!(format!("{}", cx.typeck_results.expr_ty_adjusted(recv1).peel_refs())); let recv_ty = recv_ty.trim_end_matches("<'_>"); span_lint_and_then( cx, @@ -413,7 +413,7 @@ fn check_if_chains<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, conds: Vec<&'t && results.len() > 1 { let recv_ty = - with_forced_trimmed_paths!(format!("{}", cx.typeck_results().expr_ty_adjusted(recv1).peel_refs())); + with_forced_trimmed_paths!(format!("{}", cx.typeck_results.expr_ty_adjusted(recv1).peel_refs())); let recv_ty = recv_ty.trim_end_matches("<'_>"); span_lint_and_then( cx, diff --git a/src/tools/clippy/clippy_lints_internal/src/symbols.rs b/src/tools/clippy/clippy_lints_internal/src/symbols.rs index ae74186ea90c2..8f4fba6d3817d 100644 --- a/src/tools/clippy/clippy_lints_internal/src/symbols.rs +++ b/src/tools/clippy/clippy_lints_internal/src/symbols.rs @@ -128,7 +128,7 @@ impl<'tcx> LateLintPass<'tcx> for Symbols { fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) { if let ExprKind::Call(func, [arg]) = &expr.kind - && let ty::FnDef(def_id, _) = cx.typeck_results().expr_ty(func).kind() + && let ty::FnDef(def_id, _) = cx.typeck_results.expr_ty(func).kind() && cx.tcx.is_diagnostic_item(sym::SymbolIntern, *def_id) && let Some((_, sugg)) = self.expr_suggestion(arg) { @@ -196,7 +196,7 @@ impl<'tcx> LateLintPass<'tcx> for Symbols { /// ``` fn as_str_span(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option { if let ExprKind::MethodCall(_, recv, [], _) = expr.kind - && let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) + && let Some(method_def_id) = cx.typeck_results.type_dependent_def_id(expr.hir_id) && internal_paths::SYMBOL_AS_STR.matches(cx, method_def_id) { Some(recv.span.shrink_to_hi().to(expr.span.shrink_to_hi())) diff --git a/src/tools/clippy/clippy_lints_internal/src/unusual_names.rs b/src/tools/clippy/clippy_lints_internal/src/unusual_names.rs index b68ebed713fcb..f8802c8b2151d 100644 --- a/src/tools/clippy/clippy_lints_internal/src/unusual_names.rs +++ b/src/tools/clippy/clippy_lints_internal/src/unusual_names.rs @@ -49,7 +49,7 @@ impl<'tcx> LateLintPass<'tcx> for UnusualNames { if let StmtKind::Let(let_stmt) = stmt.kind && let Some(init_expr) = let_stmt.init { - check_pat_name_for_ty(cx, let_stmt.pat, cx.typeck_results().expr_ty(init_expr), "variable"); + check_pat_name_for_ty(cx, let_stmt.pat, cx.typeck_results.expr_ty(init_expr), "variable"); } } diff --git a/src/tools/clippy/clippy_utils/src/consts.rs b/src/tools/clippy/clippy_utils/src/consts.rs index 098be98f3672c..1b1683bfb5981 100644 --- a/src/tools/clippy/clippy_utils/src/consts.rs +++ b/src/tools/clippy/clippy_utils/src/consts.rs @@ -507,7 +507,7 @@ pub fn eval_int(cx: &LateContext<'_>, e: &Expr<'_>) -> Option { { Some(FullInt::S(val.0.cast_signed().wrapping_neg())) }, - _ if let ty = cx.typeck_results().expr_ty(e) + _ if let ty = cx.typeck_results.expr_ty(e) && let ty::Int(_) | ty::Uint(_) = *ty.kind() => { ConstEvalCtxt::new(cx).eval(e).and_then(|x| x.int_value(cx.tcx, ty)) @@ -536,7 +536,7 @@ impl<'tcx> ConstEvalCtxt<'tcx> { Self { tcx: cx.tcx, typing_env: cx.typing_env(), - typeck: cx.typeck_results(), + typeck: cx.typeck_results, source: Cell::new(ConstantSource::Local), ctxt: Cell::new(SyntaxContext::root()), } diff --git a/src/tools/clippy/clippy_utils/src/eager_or_lazy.rs b/src/tools/clippy/clippy_utils/src/eager_or_lazy.rs index cd609980b149b..ca1dcf33a98fc 100644 --- a/src/tools/clippy/clippy_utils/src/eager_or_lazy.rs +++ b/src/tools/clippy/clippy_utils/src/eager_or_lazy.rs @@ -109,7 +109,7 @@ fn res_has_significant_drop(res: Res, cx: &LateContext<'_>, e: &Expr<'_>) -> boo | Res::SelfCtor(_) | Res::SelfTyAlias { .. } = res { - cx.typeck_results() + cx.typeck_results .expr_ty(e) .has_significant_drop(cx.tcx, cx.typing_env()) } else { @@ -135,7 +135,7 @@ fn expr_eagerness<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> EagernessS // so don't suggest changing it. if self .cx - .typeck_results() + .typeck_results .expr_adjustments(e) .iter() .any(|adj| matches!(adj.kind, Adjust::Deref(DerefAdjustKind::Overloaded(_)))) @@ -197,12 +197,12 @@ fn expr_eagerness<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> EagernessS ExprKind::MethodCall(name, ..) => { self.eagerness |= self .cx - .typeck_results() + .typeck_results .type_dependent_def_id(e.hir_id) .map_or(Lazy, |id| fn_eagerness(self.cx, id, name.ident.name, true)); }, ExprKind::Index(_, e, _) => { - let ty = self.cx.typeck_results().expr_ty_adjusted(e); + let ty = self.cx.typeck_results.expr_ty_adjusted(e); if is_copy(self.cx, ty) && !ty.is_ref() { self.eagerness |= NoChange; } else { @@ -217,16 +217,16 @@ fn expr_eagerness<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> EagernessS // Custom `Deref` impl might have side effects ExprKind::Unary(UnOp::Deref, e) - if self.cx.typeck_results().expr_ty(e).builtin_deref(true).is_none() => + if self.cx.typeck_results.expr_ty(e).builtin_deref(true).is_none() => { self.eagerness |= NoChange; }, // Dereferences should be cheap, but dereferencing a raw pointer earlier may not be safe. - ExprKind::Unary(UnOp::Deref, e) if !self.cx.typeck_results().expr_ty(e).is_raw_ptr() => (), + ExprKind::Unary(UnOp::Deref, e) if !self.cx.typeck_results.expr_ty(e).is_raw_ptr() => (), ExprKind::Unary(UnOp::Deref, _) => self.eagerness |= NoChange, ExprKind::Unary(_, e) if matches!( - self.cx.typeck_results().expr_ty(e).kind(), + self.cx.typeck_results.expr_ty(e).kind(), ty::Bool | ty::Int(_) | ty::Uint(_), ) => {}, @@ -244,7 +244,7 @@ fn expr_eagerness<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> EagernessS ExprKind::Binary(op, left, right) if matches!(op.node, BinOpKind::Div | BinOpKind::Rem) - && let right_ty = self.cx.typeck_results().expr_ty(right) + && let right_ty = self.cx.typeck_results.expr_ty(right) && let ecx = ConstEvalCtxt::new(self.cx) && let left = ecx.eval(left) && let right = ecx.eval(right).and_then(|c| c.int_value(self.cx.tcx, right_ty)) @@ -265,7 +265,7 @@ fn expr_eagerness<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> EagernessS // error and it's good to have the eagerness warning up front when the user fixes the logic error. ExprKind::Binary(op, left, right) if matches!(op.node, BinOpKind::Add | BinOpKind::Sub | BinOpKind::Mul) - && !self.cx.typeck_results().expr_ty(e).is_floating_point() + && !self.cx.typeck_results.expr_ty(e).is_floating_point() && let ecx = ConstEvalCtxt::new(self.cx) && (ecx.eval(left).is_none() || ecx.eval(right).is_none()) => { @@ -273,8 +273,8 @@ fn expr_eagerness<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> EagernessS }, ExprKind::Binary(_, lhs, rhs) - if self.cx.typeck_results().expr_ty(lhs).is_primitive() - && self.cx.typeck_results().expr_ty(rhs).is_primitive() => {}, + if self.cx.typeck_results.expr_ty(lhs).is_primitive() + && self.cx.typeck_results.expr_ty(rhs).is_primitive() => {}, // Can't be moved into a closure ExprKind::Break(..) diff --git a/src/tools/clippy/clippy_utils/src/higher.rs b/src/tools/clippy/clippy_utils/src/higher.rs index 9c0b136e02b5c..f34584d1f37ff 100644 --- a/src/tools/clippy/clippy_utils/src/higher.rs +++ b/src/tools/clippy/clippy_utils/src/higher.rs @@ -455,7 +455,7 @@ pub fn get_vec_init_kind<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) - if let ExprKind::Call(func, args) = expr.kind { match func.kind { ExprKind::Path(QPath::TypeRelative(ty, name)) - if cx.typeck_results().node_type(ty.hir_id).is_diag_item(cx, sym::Vec) => + if cx.typeck_results.node_type(ty.hir_id).is_diag_item(cx, sym::Vec) => { if name.ident.name == sym::new { return Some(VecInitKind::New); @@ -471,7 +471,7 @@ pub fn get_vec_init_kind<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) - }, ExprKind::Path(QPath::Resolved(_, path)) if cx.tcx.is_diagnostic_item(sym::default_fn, path.res.opt_def_id()?) - && cx.typeck_results().expr_ty(expr).is_diag_item(cx, sym::Vec) => + && cx.typeck_results.expr_ty(expr).is_diag_item(cx, sym::Vec) => { return Some(VecInitKind::Default); }, diff --git a/src/tools/clippy/clippy_utils/src/lib.rs b/src/tools/clippy/clippy_utils/src/lib.rs index c208b8b97506f..7543446f44f58 100644 --- a/src/tools/clippy/clippy_utils/src/lib.rs +++ b/src/tools/clippy/clippy_utils/src/lib.rs @@ -171,7 +171,7 @@ pub fn expr_or_init<'a, 'b, 'tcx: 'b>(cx: &LateContext<'tcx>, mut expr: &'a Expr while let Some(init) = expr .res_local_id() .and_then(|id| find_binding_init(cx, id)) - .filter(|init| cx.typeck_results().expr_adjustments(init).is_empty()) + .filter(|init| cx.typeck_results.expr_adjustments(init).is_empty()) { expr = init; } @@ -493,7 +493,7 @@ fn projection_stack<'a, 'hir>( /// Gets the mutability of the custom deref adjustment, if any. pub fn expr_custom_deref_adjustment(cx: &LateContext<'_>, e: &Expr<'_>) -> Option { - cx.typeck_results() + cx.typeck_results .expr_adjustments(e) .iter() .find_map(|a| match a.kind { @@ -784,7 +784,7 @@ pub fn can_move_expr_to_closure_no_visit<'tcx>( .. }, _, - ) if !ignore_locals.contains(local_id) && can_partially_move_ty(cx, cx.typeck_results().node_type(hir_id)) => { + ) if !ignore_locals.contains(local_id) && can_partially_move_ty(cx, cx.typeck_results.node_type(hir_id)) => { // TODO: check if the local has been partially moved. Assume it has for now. false }, @@ -831,11 +831,11 @@ pub fn capture_local_usage(cx: &LateContext<'_>, e: &Expr<'_>) -> CaptureKind { fn pat_capture_kind(cx: &LateContext<'_>, pat: &Pat<'_>) -> CaptureKind { let mut capture = CaptureKind::Ref(Mutability::Not); pat.each_binding_or_first(&mut |_, id, span, _| match cx - .typeck_results() + .typeck_results .extract_binding_mode(cx.sess(), id, span) .0 { - ByRef::No if !is_copy(cx, cx.typeck_results().node_type(id)) => { + ByRef::No if !is_copy(cx, cx.typeck_results.node_type(id)) => { capture = CaptureKind::Value; }, ByRef::Yes(_, Mutability::Mut) if capture != CaptureKind::Value => { @@ -862,7 +862,7 @@ pub fn capture_local_usage(cx: &LateContext<'_>, e: &Expr<'_>) -> CaptureKind { }, ref adjust @ .., ] = *cx - .typeck_results() + .typeck_results .adjustments() .get(child_id) .map_or(&[][..], |x| &**x) @@ -912,7 +912,7 @@ pub fn capture_local_usage(cx: &LateContext<'_>, e: &Expr<'_>) -> CaptureKind { } } - if capture == CaptureKind::Value && is_copy(cx, cx.typeck_results().expr_ty(capture_expr_ty)) { + if capture == CaptureKind::Value && is_copy(cx, cx.typeck_results.expr_ty(capture_expr_ty)) { // Copy types are never automatically captured by value. CaptureKind::Ref(Mutability::Not) } else { @@ -949,7 +949,7 @@ pub fn can_move_expr_to_closure<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<' } }, ExprKind::Closure(closure) => { - for capture in self.cx.typeck_results().closure_min_captures_flattened(closure.def_id) { + for capture in self.cx.typeck_results.closure_min_captures_flattened(closure.def_id) { let local_id = match capture.place.base { PlaceBase::Local(id) => id, PlaceBase::Upvar(var) => var.var_path.hir_id, @@ -1180,7 +1180,7 @@ pub fn get_enclosing_closure<'tcx>(cx: &LateContext<'tcx>, hir_id: HirId) -> Opt /// Checks whether a local identified by `local_id` is captured as an upvar by the given `closure`. pub fn is_upvar_in_closure(cx: &LateContext<'_>, closure: &Closure<'_>, local_id: HirId) -> bool { - cx.typeck_results() + cx.typeck_results .closure_min_captures .get(&closure.def_id) .is_some_and(|x| x.contains_key(&local_id)) @@ -1195,7 +1195,7 @@ pub fn get_enclosing_loop_or_multi_call_closure<'tcx>( match node { Node::Expr(e) => match e.kind { ExprKind::Closure { .. } - if let rustc_ty::Closure(_, subs) = cx.typeck_results().expr_ty(e).kind() + if let rustc_ty::Closure(_, subs) = cx.typeck_results.expr_ty(e).kind() && subs.as_closure().kind() == ClosureKind::FnOnce => {}, // Note: A closure's kind is determined by how it's used, not it's captures. @@ -1344,7 +1344,7 @@ pub fn is_else_clause_in_let_else(tcx: TyCtxt<'_>, expr: &Expr<'_>) -> bool { /// /// If the given `Expr` is not some kind of range, the function returns `false`. pub fn is_range_full(cx: &LateContext<'_>, expr: &Expr<'_>, container_path: Option<&Path<'_>>) -> bool { - let ty = cx.typeck_results().expr_ty(expr); + let ty = cx.typeck_results.expr_ty(expr); if let Some(Range { start, end, limits, .. }) = Range::hir(cx, expr) { let start_is_none_or_min = start.is_none_or(|start| { if let rustc_ty::Adt(_, subst) = ty.kind() @@ -1424,7 +1424,7 @@ pub fn is_float_literal(expr: &Expr<'_>, value: f64) -> bool { /// See `rustc_middle::ty::adjustment::Adjustment` and `rustc_hir_analysis::check::coercion` for /// more information on adjustments and coercions. pub fn is_adjusted(cx: &LateContext<'_>, e: &Expr<'_>) -> bool { - cx.typeck_results().adjustments().get(e.hir_id).is_some() + cx.typeck_results.adjustments().get(e.hir_id).is_some() } /// Returns the pre-expansion span if this comes from an expansion of the @@ -1544,7 +1544,7 @@ pub fn is_refutable(cx: &LateContext<'_>, pat: &Pat<'_>) -> bool { is_qpath_refutable(cx, qpath, pat.hir_id) || are_refutable(cx, pats) }, PatKind::Slice(head, middle, tail) => { - match &cx.typeck_results().node_type(pat.hir_id).kind() { + match &cx.typeck_results.node_type(pat.hir_id).kind() { rustc_ty::Slice(..) => { // [..] is the only irrefutable slice pattern. !head.is_empty() || middle.is_none() || !tail.is_empty() @@ -1819,7 +1819,7 @@ pub fn is_must_use_func_call(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool { None } }, - ExprKind::MethodCall(..) => cx.typeck_results().type_dependent_def_id(expr.hir_id), + ExprKind::MethodCall(..) => cx.typeck_results.type_dependent_def_id(expr.hir_id), _ => None, }; @@ -1934,7 +1934,7 @@ fn is_body_identity_function<'hir>(cx: &LateContext<'_>, func: &Body<'hir>) -> b /// This can be useful when checking patterns in `let` bindings or `match` arms. pub fn is_expr_identity_of_pat(cx: &LateContext<'_>, pat: &Pat<'_>, expr: &Expr<'_>, by_hir: bool) -> bool { if cx - .typeck_results() + .typeck_results .pat_binding_modes() .get(pat.hir_id) .is_some_and(|mode| matches!(mode.0, ByRef::Yes(..))) @@ -1946,11 +1946,11 @@ pub fn is_expr_identity_of_pat(cx: &LateContext<'_>, pat: &Pat<'_>, expr: &Expr< } // NOTE: we're inside a (function) body, so this won't ICE - let qpath_res = |qpath, hir| cx.typeck_results().qpath_res(qpath, hir); + let qpath_res = |qpath, hir| cx.typeck_results.qpath_res(qpath, hir); match (pat.kind, expr.kind) { (PatKind::Binding(_, id, _, _), _) if by_hir => { - expr.res_local_id() == Some(id) && cx.typeck_results().expr_adjustments(expr).is_empty() + expr.res_local_id() == Some(id) && cx.typeck_results.expr_adjustments(expr).is_empty() }, (PatKind::Binding(_, _, ident, _), ExprKind::Path(QPath::Resolved(_, path))) => { matches!(path.segments, [ segment] if segment.ident.name == ident.name) @@ -2078,7 +2078,7 @@ pub fn is_expr_final_block_expr(tcx: TyCtxt<'_>, expr: &Expr<'_>) -> bool { // https://github.com/rust-lang/rust/blob/3ed2a10d173d6c2e0232776af338ca7d080b1cd4/compiler/rustc_hir_typeck/src/expr.rs#L482-L499 pub fn is_expr_temporary_value(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool { !expr.is_place_expr(|base| { - cx.typeck_results() + cx.typeck_results .adjustments() .get(base.hir_id) .is_some_and(|x| x.iter().any(|adj| matches!(adj.kind, Adjust::Deref(_)))) @@ -2151,7 +2151,7 @@ pub fn fn_def_id_with_node_args<'tcx>( cx: &LateContext<'tcx>, expr: &Expr<'_>, ) -> Option<(DefId, GenericArgsRef<'tcx>)> { - let typeck = cx.typeck_results(); + let typeck = cx.typeck_results; match &expr.kind { ExprKind::MethodCall(..) => Some(( typeck.type_dependent_def_id(expr.hir_id)?, @@ -2184,7 +2184,7 @@ pub fn fn_def_id_with_node_args<'tcx>( /// /// (As defined in the `is_recursively_primitive_type` function.) Returns `None` otherwise. pub fn is_slice_of_primitives(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option { - let expr_type = cx.typeck_results().expr_ty_adjusted(expr); + let expr_type = cx.typeck_results.expr_ty_adjusted(expr); let expr_kind = expr_type.kind(); let is_primitive = match expr_kind { rustc_ty::Slice(element_type) => is_recursively_primitive_type(*element_type), @@ -2351,7 +2351,7 @@ pub fn peel_ref_operators<'hir>(cx: &LateContext<'_>, mut expr: &'hir Expr<'hir> loop { match expr.kind { ExprKind::AddrOf(_, _, e) => expr = e, - ExprKind::Unary(UnOp::Deref, e) if cx.typeck_results().expr_ty(e).is_ref() => expr = e, + ExprKind::Unary(UnOp::Deref, e) if cx.typeck_results.expr_ty(e).is_ref() => expr = e, _ => break, } } @@ -2367,7 +2367,7 @@ pub fn get_ref_operators<'hir>(cx: &LateContext<'_>, expr: &'hir Expr<'hir>) -> operators.push(expr); Some(e) }, - ExprKind::Unary(UnOp::Deref, e) if cx.typeck_results().expr_ty(e).is_ref() => { + ExprKind::Unary(UnOp::Deref, e) if cx.typeck_results.expr_ty(e).is_ref() => { operators.push(expr); Some(e) }, @@ -2680,7 +2680,7 @@ impl<'tcx> ExprUseNode<'tcx> { }) }, Self::MethodArg(id, _, i) => { - let id = cx.typeck_results().type_dependent_def_id(id)?; + let id = cx.typeck_results.type_dependent_def_id(id)?; let sig = cx.tcx.fn_sig(id).skip_binder(); Some(DefinedTy::Mir { def_site_def_id: Some(id), @@ -3101,7 +3101,7 @@ pub fn is_never_expr<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> Option< } }, _ => { - self.requires_semi = !self.cx.typeck_results().expr_ty(e).is_never(); + self.requires_semi = !self.cx.typeck_results.expr_ty(e).is_never(); }, } } @@ -3197,7 +3197,7 @@ pub fn is_never_expr<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> Option< _ => { self.in_final_expr = false; walk_expr(self, e); - self.is_never |= self.cx.typeck_results().expr_ty(e).is_never(); + self.is_never |= self.cx.typeck_results.expr_ty(e).is_never(); }, } } @@ -3234,7 +3234,7 @@ pub fn is_never_expr<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> Option< } } - if cx.typeck_results().expr_ty(e).is_never() { + if cx.typeck_results.expr_ty(e).is_never() { Some(RequiresSemi::No) } else if let ExprKind::Block(b, _) = e.kind && !b.targeted_by_break @@ -3460,7 +3460,7 @@ pub fn leaks_droppable_temporary_with_limited_lifetime<'tcx>(cx: &LateContext<'t /// [coercion sites]: https://doc.rust-lang.org/stable/reference/type-coercions.html#coercion-sites pub fn expr_requires_coercion<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) -> bool { let expr_ty_is_adjusted = cx - .typeck_results() + .typeck_results .expr_adjustments(expr) .iter() // ignore `NeverToAny` adjustments, such as `panic!` call. @@ -3499,9 +3499,9 @@ pub fn expr_requires_coercion<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) - }, // Struct/union initialization. ExprKind::Struct(qpath, _, _) => { - let res = cx.typeck_results().qpath_res(qpath, expr.hir_id); + let res = cx.typeck_results.qpath_res(qpath, expr.hir_id); if let Some((_, v_def)) = adt_and_variant_of_res(cx, res) { - let rustc_ty::Adt(_, generic_args) = cx.typeck_results().expr_ty_adjusted(expr).kind() else { + let rustc_ty::Adt(_, generic_args) = cx.typeck_results.expr_ty_adjusted(expr).kind() else { // This should never happen, but when it does, not linting is the better option. return true; }; @@ -3670,7 +3670,7 @@ pub fn potential_return_of_enclosing_body(cx: &LateContext<'_>, expr: &Expr<'_>) /// Checks if the expression has adjustments that require coercion, for example: dereferencing with /// overloaded deref, coercing pointers and `dyn` objects. pub fn expr_adjustment_requires_coercion(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool { - cx.typeck_results().expr_adjustments(expr).iter().any(|adj| { + cx.typeck_results.expr_adjustments(expr).iter().any(|adj| { matches!( adj.kind, Adjust::Deref(DerefAdjustKind::Overloaded(_)) diff --git a/src/tools/clippy/clippy_utils/src/sugg.rs b/src/tools/clippy/clippy_utils/src/sugg.rs index f194103ae2e88..40a91cbffb101 100644 --- a/src/tools/clippy/clippy_utils/src/sugg.rs +++ b/src/tools/clippy/clippy_utils/src/sugg.rs @@ -108,7 +108,7 @@ impl<'a> Sugg<'a> { if expr.span.ctxt() == ctxt { if let ExprKind::Unary(op, inner) = expr.kind && matches!(op, UnOp::Neg | UnOp::Not) - && cx.typeck_results().expr_ty(expr) == cx.typeck_results().expr_ty(inner) + && cx.typeck_results.expr_ty(expr) == cx.typeck_results.expr_ty(inner) { Sugg::UnOp( op, @@ -895,7 +895,7 @@ impl<'tcx> DerefDelegate<'_, 'tcx> { ExprKind::MethodCall(_, receiver, call_args, _) => { if let Some(sig) = self .cx - .typeck_results() + .typeck_results .type_dependent_def_id(parent_expr.hir_id) .map(|did| { self.cx @@ -985,7 +985,7 @@ impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> { // i.e.: `Call`: `|x| please(x)` or `MethodCall`: `|x| [1, 2, 3].contains(x)` ExprKind::Call(_, call_args) | ExprKind::MethodCall(_, _, call_args, _) => { let expr = self.cx.tcx.hir_expect_expr(cmt.hir_id); - let arg_ty_kind = self.cx.typeck_results().expr_ty(expr).kind(); + let arg_ty_kind = self.cx.typeck_results.expr_ty(expr).kind(); if matches!(arg_ty_kind, ty::Ref(_, _, Mutability::Not)) { // suggest ampersand if call function is taking args by double reference diff --git a/src/tools/clippy/clippy_utils/src/ty/mod.rs b/src/tools/clippy/clippy_utils/src/ty/mod.rs index fb5fd5ad97c4e..854e23f68f36a 100644 --- a/src/tools/clippy/clippy_utils/src/ty/mod.rs +++ b/src/tools/clippy/clippy_utils/src/ty/mod.rs @@ -621,7 +621,7 @@ pub fn expr_sig<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>) -> Option, expr: &Expr<'_>, in_arg: bool) -> C // Even if `receiver_type_certainty` is `Certain(Some(..))`, the `Self` type in the method // identified by `type_dependent_def_id(..)` can differ. This can happen as a result of a `deref`, // for example. So update the `DefId` in `receiver_type_certainty` (if any). - if let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) + if let Some(method_def_id) = cx.typeck_results.type_dependent_def_id(expr.hir_id) && let Some(self_ty_def_id) = adt_def_id(self_ty(cx, method_def_id)) { receiver_type_certainty = receiver_type_certainty.with_def_id(self_ty_def_id); @@ -113,7 +113,7 @@ fn expr_type_certainty(cx: &LateContext<'_>, expr: &Expr<'_>, in_arg: bool) -> C _ => Certainty::Uncertain, }; - let expr_ty = cx.typeck_results().expr_ty(expr); + let expr_ty = cx.typeck_results.expr_ty(expr); if let Some(def_id) = adt_def_id(expr_ty) { certainty.with_def_id(def_id) } else { @@ -320,14 +320,14 @@ fn update_res( fn type_is_inferable_from_arguments(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool { let Some(callee_def_id) = (match expr.kind { ExprKind::Call(callee, _) => { - let callee_ty = cx.typeck_results().expr_ty(callee); + let callee_ty = cx.typeck_results.expr_ty(callee); if let ty::FnDef(callee_def_id, _) = callee_ty.kind() { Some(*callee_def_id) } else { None } }, - ExprKind::MethodCall(_, _, _, _) => cx.typeck_results().type_dependent_def_id(expr.hir_id), + ExprKind::MethodCall(_, _, _, _) => cx.typeck_results.type_dependent_def_id(expr.hir_id), _ => None, }) else { return false; diff --git a/src/tools/clippy/clippy_utils/src/visitors.rs b/src/tools/clippy/clippy_utils/src/visitors.rs index 28449a75a8fc5..648816e2e3e6f 100644 --- a/src/tools/clippy/clippy_utils/src/visitors.rs +++ b/src/tools/clippy/clippy_utils/src/visitors.rs @@ -350,17 +350,17 @@ pub fn is_const_evaluatable<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> ExprKind::MethodCall(..) if self .cx - .typeck_results() + .typeck_results .type_dependent_def_id(e.hir_id) .is_some_and(|id| is_stable_const_fn(self.cx, id, Msrv::default())) => {}, ExprKind::Binary(_, lhs, rhs) - if self.cx.typeck_results().expr_ty(lhs).peel_refs().is_primitive_ty() - && self.cx.typeck_results().expr_ty(rhs).peel_refs().is_primitive_ty() => {}, - ExprKind::Unary(UnOp::Deref, e) if self.cx.typeck_results().expr_ty(e).is_raw_ptr() => (), - ExprKind::Unary(_, e) if self.cx.typeck_results().expr_ty(e).peel_refs().is_primitive_ty() => (), + if self.cx.typeck_results.expr_ty(lhs).peel_refs().is_primitive_ty() + && self.cx.typeck_results.expr_ty(rhs).peel_refs().is_primitive_ty() => {}, + ExprKind::Unary(UnOp::Deref, e) if self.cx.typeck_results.expr_ty(e).is_raw_ptr() => (), + ExprKind::Unary(_, e) if self.cx.typeck_results.expr_ty(e).peel_refs().is_primitive_ty() => (), ExprKind::Index(base, _, _) if matches!( - self.cx.typeck_results().expr_ty(base).peel_refs().kind(), + self.cx.typeck_results.expr_ty(base).peel_refs().kind(), ty::Slice(_) | ty::Array(..) ) => {}, ExprKind::Path(ref p) @@ -421,19 +421,19 @@ pub fn is_expr_unsafe<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> bool { } fn visit_expr(&mut self, e: &'tcx Expr<'_>) -> Self::Result { match e.kind { - ExprKind::Unary(UnOp::Deref, e) if self.cx.typeck_results().expr_ty(e).is_raw_ptr() => { + ExprKind::Unary(UnOp::Deref, e) if self.cx.typeck_results.expr_ty(e).is_raw_ptr() => { ControlFlow::Break(()) }, ExprKind::MethodCall(..) if self .cx - .typeck_results() + .typeck_results .type_dependent_def_id(e.hir_id) .is_some_and(|id| self.cx.tcx.fn_sig(id).skip_binder().safety().is_unsafe()) => { ControlFlow::Break(()) }, - ExprKind::Call(func, _) => match *self.cx.typeck_results().expr_ty(func).peel_refs().kind() { + ExprKind::Call(func, _) => match *self.cx.typeck_results.expr_ty(func).peel_refs().kind() { ty::FnDef(id, _) if self.cx.tcx.fn_sig(id).skip_binder().safety().is_unsafe() => { ControlFlow::Break(()) }, @@ -705,7 +705,7 @@ pub fn for_each_unconsumed_temporary<'tcx, B>( } ControlFlow::Continue(()) } - helper(cx.typeck_results(), true, e, &mut f) + helper(cx.typeck_results, true, e, &mut f) } pub fn any_temporaries_need_ordered_drop<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'tcx>) -> bool {