move fn is_item_raw to TypingEnv

lcnr · lcnr · commit 809b420e16d4 · 2024-11-19T18:06:20.000+01:00
diff --git a/clippy_lints/src/casts/ptr_as_ptr.rs b/clippy_lints/src/casts/ptr_as_ptr.rs
@@ -39,7 +39,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, msrv: &Msrv) {
             (Mutability::Not, Mutability::Not) | (Mutability::Mut, Mutability::Mut))
         // The `U` in `pointer::cast` have to be `Sized`
         // as explained here: https://github.com/rust-lang/rust/issues/60602.
-        && to_pointee_ty.is_sized(cx.tcx, cx.param_env)
+        && to_pointee_ty.is_sized(cx.tcx, cx.typing_env())
     {
         let mut app = Applicability::MachineApplicable;
         let turbofish = match &cast_to_hir_ty.kind {
diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
@@ -1028,7 +1028,7 @@ fn report<'tcx>(
         State::ExplicitDeref { mutability } => {
             if is_block_like(expr)
                 && let ty::Ref(_, ty, _) = data.adjusted_ty.kind()
-                && ty.is_sized(cx.tcx, cx.param_env)
+                && ty.is_sized(cx.tcx, cx.typing_env())
             {
                 // Rustc bug: auto deref doesn't work on block expression when targeting sized types.
                 return;
diff --git a/clippy_lints/src/functions/must_use.rs b/clippy_lints/src/functions/must_use.rs
@@ -198,7 +198,7 @@ fn is_mutable_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, tys: &mut DefIdSet)
         // primitive types are never mutable
         ty::Bool | ty::Char | ty::Int(_) | ty::Uint(_) | ty::Float(_) | ty::Str => false,
         ty::Adt(adt, args) => {
-            tys.insert(adt.did()) && !ty.is_freeze(cx.tcx, cx.param_env)
+            tys.insert(adt.did()) && !ty.is_freeze(cx.tcx, cx.typing_env())
                 || matches!(cx.tcx.get_diagnostic_name(adt.did()), Some(sym::Rc | sym::Arc))
                     && args.types().any(|ty| is_mutable_ty(cx, ty, tys))
         },
diff --git a/clippy_lints/src/let_if_seq.rs b/clippy_lints/src/let_if_seq.rs
@@ -80,7 +80,7 @@ impl<'tcx> LateLintPass<'tcx> for LetIfSeq {
                 let has_interior_mutability = !cx
                     .typeck_results()
                     .node_type(canonical_id)
-                    .is_freeze(cx.tcx, cx.param_env);
+                    .is_freeze(cx.tcx, cx.typing_env());
                 if has_interior_mutability {
                     return;
                 }
diff --git a/clippy_lints/src/methods/manual_inspect.rs b/clippy_lints/src/methods/manual_inspect.rs
@@ -148,7 +148,7 @@ pub(crate) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, arg: &Expr<'_>, name:
                                 _ => {},
                             }
                         }
-                        requires_copy |= !ty.is_copy_modulo_regions(cx.tcx, cx.param_env);
+                        requires_copy |= !ty.is_copy_modulo_regions(cx.tcx, cx.typing_env());
                         break;
                     }
                 },
@@ -158,9 +158,9 @@ pub(crate) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, arg: &Expr<'_>, name:
         }
 
         if can_lint
-            && (!requires_copy || arg_ty.is_copy_modulo_regions(cx.tcx, cx.param_env))
+            && (!requires_copy || arg_ty.is_copy_modulo_regions(cx.tcx, cx.typing_env()))
             // This case could be handled, but a fair bit of care would need to be taken.
-            && (!requires_deref || arg_ty.is_freeze(cx.tcx, cx.param_env))
+            && (!requires_deref || arg_ty.is_freeze(cx.tcx, cx.typing_env()))
         {
             if requires_deref {
                 edits.push((param.span.shrink_to_lo(), "&".into()));
diff --git a/clippy_lints/src/mut_mut.rs b/clippy_lints/src/mut_mut.rs
@@ -80,7 +80,7 @@ impl<'tcx> intravisit::Visitor<'tcx> for MutVisitor<'_, 'tcx> {
                     "generally you want to avoid `&mut &mut _` if possible",
                 );
             } else if let ty::Ref(_, ty, hir::Mutability::Mut) = self.cx.typeck_results().expr_ty(e).kind() {
-                if ty.peel_refs().is_sized(self.cx.tcx, self.cx.param_env) {
+                if ty.peel_refs().is_sized(self.cx.tcx, self.cx.typing_env()) {
                     span_lint_hir(
                         self.cx,
                         MUT_MUT,
diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs
@@ -180,7 +180,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue {
             if !is_self(arg)
                 && !ty.is_mutable_ptr()
                 && !is_copy(cx, ty)
-                && ty.is_sized(cx.tcx, cx.param_env)
+                && ty.is_sized(cx.tcx, cx.typing_env())
                 && !allowed_traits.iter().any(|&t| {
                     implements_trait_with_env_from_iter(cx.tcx, cx.param_env, ty, t, None, [Option::<
                         ty::GenericArg<'tcx>,
diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
@@ -251,7 +251,7 @@ fn check_is_none_or_err_and_early_return<'tcx>(cx: &LateContext<'tcx>, expr: &Ex
     {
         let mut applicability = Applicability::MachineApplicable;
         let receiver_str = snippet_with_applicability(cx, caller.span, "..", &mut applicability);
-        let by_ref = !caller_ty.is_copy_modulo_regions(cx.tcx, cx.param_env)
+        let by_ref = !caller_ty.is_copy_modulo_regions(cx.tcx, cx.typing_env())
             && !matches!(caller.kind, ExprKind::Call(..) | ExprKind::MethodCall(..));
         let sugg = if let Some(else_inner) = r#else {
             if eq_expr_value(cx, caller, peel_blocks(else_inner)) {
diff --git a/clippy_lints/src/transmute/transmute_ptr_to_ptr.rs b/clippy_lints/src/transmute/transmute_ptr_to_ptr.rs
@@ -27,7 +27,7 @@ pub(super) fn check<'tcx>(
                 |diag| {
                     if let Some(arg) = sugg::Sugg::hir_opt(cx, arg) {
                         if from_mutbl == to_mutbl
-                            && to_pointee_ty.is_sized(cx.tcx, cx.param_env)
+                            && to_pointee_ty.is_sized(cx.tcx, cx.typing_env())
                             && msrv.meets(msrvs::POINTER_CAST)
                         {
                             diag.span_suggestion_verbose(
diff --git a/clippy_lints/src/transmute/transmute_undefined_repr.rs b/clippy_lints/src/transmute/transmute_undefined_repr.rs
@@ -206,12 +206,12 @@ fn reduce_refs<'tcx>(cx: &LateContext<'tcx>, mut from_ty: Ty<'tcx>, mut to_ty: T
                 continue;
             },
             (&(ty::Ref(_, unsized_ty, _) | ty::RawPtr(unsized_ty, _)), _)
-                if !unsized_ty.is_sized(cx.tcx, cx.param_env) =>
+                if !unsized_ty.is_sized(cx.tcx, cx.typing_env()) =>
             {
                 (true, false)
             },
             (_, &(ty::Ref(_, unsized_ty, _) | ty::RawPtr(unsized_ty, _)))
-                if !unsized_ty.is_sized(cx.tcx, cx.param_env) =>
+                if !unsized_ty.is_sized(cx.tcx, cx.typing_env()) =>
             {
                 (false, true)
             },
diff --git a/clippy_lints/src/types/redundant_allocation.rs b/clippy_lints/src/types/redundant_allocation.rs
@@ -60,7 +60,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, hir_ty: &hir::Ty<'tcx>, qpath:
             // here because `mod.rs` guarantees this lint is only run on types outside of bodies and
             // is not run on locals.
             let ty = lower_ty(cx.tcx, hir_ty);
-            if ty.has_escaping_bound_vars() || !ty.is_sized(cx.tcx, cx.param_env) {
+            if ty.has_escaping_bound_vars() || !ty.is_sized(cx.tcx, cx.typing_env()) {
                 return false;
             }
             hir_ty.span
diff --git a/clippy_lints/src/types/vec_box.rs b/clippy_lints/src/types/vec_box.rs
@@ -37,7 +37,7 @@ pub(super) fn check<'tcx>(
             && let boxed_alloc_ty = last.args.get(1)
             && let ty_ty = lower_ty(cx.tcx, boxed_ty)
             && !ty_ty.has_escaping_bound_vars()
-            && ty_ty.is_sized(cx.tcx, cx.param_env)
+            && ty_ty.is_sized(cx.tcx, cx.typing_env())
             && let Ok(ty_ty_size) = cx.layout_of(ty_ty).map(|l| l.size.bytes())
             && ty_ty_size < box_size_threshold
             // https://github.com/rust-lang/rust-clippy/issues/7114
diff --git a/clippy_lints/src/unnecessary_box_returns.rs b/clippy_lints/src/unnecessary_box_returns.rs
@@ -82,7 +82,7 @@ impl UnnecessaryBoxReturns {
         // It's sometimes useful to return Box<T> if T is unsized, so don't lint those.
         // Also, don't lint if we know that T is very large, in which case returning
         // a Box<T> may be beneficial.
-        if boxed_ty.is_sized(cx.tcx, cx.param_env) && approx_ty_size(cx, boxed_ty) <= self.maximum_size {
+        if boxed_ty.is_sized(cx.tcx, cx.typing_env()) && approx_ty_size(cx, boxed_ty) <= self.maximum_size {
             span_lint_and_then(
                 cx,
                 UNNECESSARY_BOX_RETURNS,
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
@@ -38,7 +38,7 @@ pub use type_certainty::expr_type_is_certain;
 
 /// Checks if the given type implements copy.
 pub fn is_copy<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
-    ty.is_copy_modulo_regions(cx.tcx, cx.param_env)
+    ty.is_copy_modulo_regions(cx.tcx, cx.typing_env())
 }
 
 /// This checks whether a given type is known to implement Debug.

Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, msrv: &Msrv) {`
`39`	`39`	`(Mutability::Not, Mutability::Not) \| (Mutability::Mut, Mutability::Mut))`
`40`	`40`	// The `U` in `pointer::cast` have to be `Sized`
`41`	`41`	`// as explained here: https://github.com/rust-lang/rust/issues/60602.`
`42`		`- && to_pointee_ty.is_sized(cx.tcx, cx.param_env)`
	`42`	`+ && to_pointee_ty.is_sized(cx.tcx, cx.typing_env())`
`43`	`43`	`{`
`44`	`44`	`let mut app = Applicability::MachineApplicable;`
`45`	`45`	`let turbofish = match &cast_to_hir_ty.kind {`
Original file line number	Diff line number	Diff line change
`@@ -1028,7 +1028,7 @@ fn report<'tcx>(`
`1028`	`1028`	`State::ExplicitDeref { mutability } => {`
`1029`	`1029`	`if is_block_like(expr)`
`1030`	`1030`	`&& let ty::Ref(_, ty, _) = data.adjusted_ty.kind()`
`1031`		`- && ty.is_sized(cx.tcx, cx.param_env)`
	`1031`	`+ && ty.is_sized(cx.tcx, cx.typing_env())`
`1032`	`1032`	`{`
`1033`	`1033`	`// Rustc bug: auto deref doesn't work on block expression when targeting sized types.`
`1034`	`1034`	`return;`
Original file line number	Diff line number	Diff line change
`@@ -80,7 +80,7 @@ impl<'tcx> LateLintPass<'tcx> for LetIfSeq {`
`80`	`80`	`let has_interior_mutability = !cx`
`81`	`81`	`.typeck_results()`
`82`	`82`	`.node_type(canonical_id)`
`83`		`- .is_freeze(cx.tcx, cx.param_env);`
	`83`	`+ .is_freeze(cx.tcx, cx.typing_env());`
`84`	`84`	`if has_interior_mutability {`
`85`	`85`	`return;`
`86`	`86`	`}`
Original file line number	Diff line number	Diff line change
`@@ -148,7 +148,7 @@ pub(crate) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, arg: &Expr<'_>, name:`
`148`	`148`	`_ => {},`
`149`	`149`	`}`
`150`	`150`	`}`
`151`		`- requires_copy \|= !ty.is_copy_modulo_regions(cx.tcx, cx.param_env);`
	`151`	`+ requires_copy \|= !ty.is_copy_modulo_regions(cx.tcx, cx.typing_env());`
`152`	`152`	`break;`
`153`	`153`	`}`
`154`	`154`	`},`
`@@ -158,9 +158,9 @@ pub(crate) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, arg: &Expr<'_>, name:`
`158`	`158`	`}`
`159`	`159`
`160`	`160`	`if can_lint`
`161`		`- && (!requires_copy \|\| arg_ty.is_copy_modulo_regions(cx.tcx, cx.param_env))`
	`161`	`+ && (!requires_copy \|\| arg_ty.is_copy_modulo_regions(cx.tcx, cx.typing_env()))`
`162`	`162`	`// This case could be handled, but a fair bit of care would need to be taken.`
`163`		`- && (!requires_deref \|\| arg_ty.is_freeze(cx.tcx, cx.param_env))`
	`163`	`+ && (!requires_deref \|\| arg_ty.is_freeze(cx.tcx, cx.typing_env()))`
`164`	`164`	`{`
`165`	`165`	`if requires_deref {`
`166`	`166`	`edits.push((param.span.shrink_to_lo(), "&".into()));`
Original file line number	Diff line number	Diff line change
`@@ -251,7 +251,7 @@ fn check_is_none_or_err_and_early_return<'tcx>(cx: &LateContext<'tcx>, expr: &Ex`
`251`	`251`	`{`
`252`	`252`	`let mut applicability = Applicability::MachineApplicable;`
`253`	`253`	`let receiver_str = snippet_with_applicability(cx, caller.span, "..", &mut applicability);`
`254`		`- let by_ref = !caller_ty.is_copy_modulo_regions(cx.tcx, cx.param_env)`
	`254`	`+ let by_ref = !caller_ty.is_copy_modulo_regions(cx.tcx, cx.typing_env())`
`255`	`255`	`&& !matches!(caller.kind, ExprKind::Call(..) \| ExprKind::MethodCall(..));`
`256`	`256`	`let sugg = if let Some(else_inner) = r#else {`
`257`	`257`	`if eq_expr_value(cx, caller, peel_blocks(else_inner)) {`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ pub(super) fn check<'tcx>(`
`27`	`27`	`\|diag\| {`
`28`	`28`	`if let Some(arg) = sugg::Sugg::hir_opt(cx, arg) {`
`29`	`29`	`if from_mutbl == to_mutbl`
`30`		`- && to_pointee_ty.is_sized(cx.tcx, cx.param_env)`
	`30`	`+ && to_pointee_ty.is_sized(cx.tcx, cx.typing_env())`
`31`	`31`	`&& msrv.meets(msrvs::POINTER_CAST)`
`32`	`32`	`{`
`33`	`33`	`diag.span_suggestion_verbose(`