Use eval_local in more places.

Jarcho · Jarcho · commit 47b0f903a3b0 · 2025-10-04T10:41:35.000-04:00
diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
@@ -111,8 +111,8 @@ declare_lint_pass!(FloatingPointArithmetic => [
 
 // Returns the specialized log method for a given base if base is constant
 // and is one of 2, 10 and e
-fn get_specialized_log_method(cx: &LateContext<'_>, base: &Expr<'_>) -> Option<&'static str> {
-    if let Some(value) = ConstEvalCtxt::new(cx).eval(base) {
+fn get_specialized_log_method(cx: &LateContext<'_>, base: &Expr<'_>, ctxt: SyntaxContext) -> Option<&'static str> {
+    if let Some(value) = ConstEvalCtxt::new(cx).eval_local(base, ctxt) {
         if F32(2.0) == value || F64(2.0) == value {
             return Some("log2");
         } else if F32(10.0) == value || F64(10.0) == value {
@@ -158,7 +158,7 @@ fn prepare_receiver_sugg<'a>(cx: &LateContext<'_>, mut expr: &'a Expr<'a>) -> Su
 }
 
 fn check_log_base(cx: &LateContext<'_>, expr: &Expr<'_>, receiver: &Expr<'_>, args: &[Expr<'_>]) {
-    if let Some(method) = get_specialized_log_method(cx, &args[0]) {
+    if let Some(method) = get_specialized_log_method(cx, &args[0], expr.span.ctxt()) {
         span_lint_and_sugg(
             cx,
             SUBOPTIMAL_FLOPS,
diff --git a/clippy_lints/src/implicit_saturating_add.rs b/clippy_lints/src/implicit_saturating_add.rs
@@ -117,10 +117,11 @@ fn get_int_max(ty: Ty<'_>) -> Option<u128> {
 fn get_const<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) -> Option<(u128, BinOpKind, &'tcx Expr<'tcx>)> {
     if let ExprKind::Binary(op, l, r) = expr.kind {
         let ecx = ConstEvalCtxt::new(cx);
-        if let Some(Constant::Int(c)) = ecx.eval(r) {
+        let ctxt = expr.span.ctxt();
+        if let Some(Constant::Int(c)) = ecx.eval_local(r, ctxt) {
             return Some((c, op.node, l));
         }
-        if let Some(Constant::Int(c)) = ecx.eval(l) {
+        if let Some(Constant::Int(c)) = ecx.eval_local(l, ctxt) {
             return Some((c, invert_op(op.node)?, r));
         }
     }
diff --git a/clippy_lints/src/manual_float_methods.rs b/clippy_lints/src/manual_float_methods.rs
@@ -1,5 +1,5 @@
 use clippy_config::Conf;
-use clippy_utils::consts::{ConstEvalCtxt, Constant};
+use clippy_utils::consts::ConstEvalCtxt;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::SpanRangeExt;
@@ -146,13 +146,14 @@ impl<'tcx> LateLintPass<'tcx> for ManualFloatMethods {
             )
             && let [first, second, const_1, const_2] = exprs
             && let ecx = ConstEvalCtxt::new(cx)
-            && let Some(const_1) = ecx.eval(const_1)
-            && let Some(const_2) = ecx.eval(const_2)
+            && let ctxt = expr.span.ctxt()
+            && let Some(const_1) = ecx.eval_local(const_1, ctxt)
+            && let Some(const_2) = ecx.eval_local(const_2, ctxt)
             && path_to_local(first).is_some_and(|f| path_to_local(second).is_some_and(|s| f == s))
             // The actual infinity check, we also allow `NEG_INFINITY` before` INFINITY` just in
             // case somebody does that for some reason
-            && (is_infinity(&const_1) && is_neg_infinity(&const_2)
-                || is_neg_infinity(&const_1) && is_infinity(&const_2))
+            && (const_1.is_pos_infinity() && const_2.is_neg_infinity()
+                || const_1.is_neg_infinity() && const_2.is_pos_infinity())
             && let Some(local_snippet) = first.span.get_source_text(cx)
         {
             let variant = match (kind.node, lhs_kind.node, rhs_kind.node) {
@@ -201,21 +202,3 @@ impl<'tcx> LateLintPass<'tcx> for ManualFloatMethods {
         }
     }
 }
-
-fn is_infinity(constant: &Constant) -> bool {
-    match constant {
-        // FIXME(f16_f128): add f16 and f128 when constants are available
-        Constant::F32(float) => *float == f32::INFINITY,
-        Constant::F64(float) => *float == f64::INFINITY,
-        _ => false,
-    }
-}
-
-fn is_neg_infinity(constant: &Constant) -> bool {
-    match constant {
-        // FIXME(f16_f128): add f16 and f128 when constants are available
-        Constant::F32(float) => *float == f32::NEG_INFINITY,
-        Constant::F64(float) => *float == f64::NEG_INFINITY,
-        _ => false,
-    }
-}
diff --git a/clippy_lints/src/manual_rotate.rs b/clippy_lints/src/manual_rotate.rs
@@ -66,7 +66,7 @@ fn parse_shift<'tcx>(
             BinOpKind::Shr => ShiftDirection::Right,
             _ => return None,
         };
-        let const_expr = ConstEvalCtxt::new(cx).eval(r)?;
+        let const_expr = ConstEvalCtxt::new(cx).eval_local(r, expr.span.ctxt())?;
         if let Constant::Int(shift) = const_expr {
             return Some((dir, shift, l));
         }
diff --git a/clippy_lints/src/manual_strip.rs b/clippy_lints/src/manual_strip.rs
@@ -16,7 +16,7 @@ use rustc_lint::{LateContext, LateLintPass, LintContext as _};
 use rustc_middle::ty;
 use rustc_session::impl_lint_pass;
 use rustc_span::source_map::Spanned;
-use rustc_span::{Symbol, sym};
+use rustc_span::{Symbol, SyntaxContext, sym};
 use std::iter;
 
 declare_clippy_lint! {
@@ -92,7 +92,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualStrip {
                 return;
             }
 
-            let (strippings, bindings) = find_stripping(cx, strip_kind, target_res, pattern, then);
+            let (strippings, bindings) = find_stripping(cx, strip_kind, target_res, pattern, then, expr.span.ctxt());
             if !strippings.is_empty() && self.msrv.meets(cx, msrvs::STR_STRIP_PREFIX) {
                 let kind_word = match strip_kind {
                     StripKind::Prefix => "prefix",
@@ -166,8 +166,8 @@ fn len_arg<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<&'tcx E
 }
 
 // Returns the length of the `expr` if it's a constant string or char.
-fn constant_length(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<u128> {
-    let value = ConstEvalCtxt::new(cx).eval(expr)?;
+fn constant_length(cx: &LateContext<'_>, expr: &Expr<'_>, ctxt: SyntaxContext) -> Option<u128> {
+    let value = ConstEvalCtxt::new(cx).eval_local(expr, ctxt)?;
     match value {
         Constant::Str(value) => Some(value.len() as u128),
         Constant::Char(value) => Some(value.len_utf8() as u128),
@@ -176,13 +176,18 @@ fn constant_length(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<u128> {
 }
 
 // Tests if `expr` equals the length of the pattern.
-fn eq_pattern_length<'tcx>(cx: &LateContext<'tcx>, pattern: &Expr<'_>, expr: &'tcx Expr<'_>) -> bool {
+fn eq_pattern_length<'tcx>(
+    cx: &LateContext<'tcx>,
+    pattern: &Expr<'_>,
+    expr: &'tcx Expr<'_>,
+    ctxt: SyntaxContext,
+) -> bool {
     if let ExprKind::Lit(Spanned {
         node: LitKind::Int(n, _),
         ..
     }) = expr.kind
     {
-        constant_length(cx, pattern).is_some_and(|length| n == length)
+        constant_length(cx, pattern, ctxt).is_some_and(|length| n == length)
     } else {
         len_arg(cx, expr).is_some_and(|arg| eq_expr_value(cx, pattern, arg))
     }
@@ -215,6 +220,7 @@ fn find_stripping<'tcx>(
     target: Res,
     pattern: &'tcx Expr<'_>,
     expr: &'tcx Expr<'tcx>,
+    ctxt: SyntaxContext,
 ) -> (Vec<&'tcx Expr<'tcx>>, FxHashMap<Symbol, usize>) {
     struct StrippingFinder<'a, 'tcx> {
         cx: &'a LateContext<'tcx>,
@@ -223,6 +229,7 @@ fn find_stripping<'tcx>(
         pattern: &'tcx Expr<'tcx>,
         results: Vec<&'tcx Expr<'tcx>>,
         bindings: FxHashMap<Symbol, usize>,
+        ctxt: SyntaxContext,
     }
 
     impl<'tcx> Visitor<'tcx> for StrippingFinder<'_, 'tcx> {
@@ -236,7 +243,7 @@ fn find_stripping<'tcx>(
             {
                 match (self.strip_kind, start, end) {
                     (StripKind::Prefix, Some(start), None) => {
-                        if eq_pattern_length(self.cx, self.pattern, start) {
+                        if eq_pattern_length(self.cx, self.pattern, start, self.ctxt) {
                             self.results.push(ex);
                             return;
                         }
@@ -252,7 +259,7 @@ fn find_stripping<'tcx>(
                             && let Some(left_arg) = len_arg(self.cx, left)
                             && let ExprKind::Path(left_path) = &left_arg.kind
                             && self.cx.qpath_res(left_path, left_arg.hir_id) == self.target
-                            && eq_pattern_length(self.cx, self.pattern, right)
+                            && eq_pattern_length(self.cx, self.pattern, right, self.ctxt)
                         {
                             self.results.push(ex);
                             return;
@@ -280,6 +287,7 @@ fn find_stripping<'tcx>(
         pattern,
         results: vec![],
         bindings: FxHashMap::default(),
+        ctxt,
     };
     walk_expr(&mut finder, expr);
     (finder.results, finder.bindings)
diff --git a/clippy_lints/src/methods/ip_constant.rs b/clippy_lints/src/methods/ip_constant.rs
@@ -17,10 +17,12 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, func: &Expr<'_>, args
             cx.tcx.get_diagnostic_name(func_def_id),
             Some(sym::Ipv4Addr | sym::Ipv6Addr)
         )
+        && let ecx = ConstEvalCtxt::new(cx)
+        && let ctxt = expr.span.ctxt()
         && let Some(args) = args
             .iter()
             .map(|arg| {
-                if let Some(Constant::Int(constant @ (0 | 1 | 127 | 255))) = ConstEvalCtxt::new(cx).eval(arg) {
+                if let Some(Constant::Int(constant @ (0 | 1 | 127 | 255))) = ecx.eval_local(arg, ctxt) {
                     u8::try_from(constant).ok()
                 } else {
                     None
diff --git a/clippy_lints/src/methods/iter_nth_zero.rs b/clippy_lints/src/methods/iter_nth_zero.rs
@@ -14,7 +14,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr
     if let OwnerNode::Item(item) = cx.tcx.hir_owner_node(cx.tcx.hir_get_parent_item(expr.hir_id))
         && let def_id = item.owner_id.to_def_id()
         && is_trait_method(cx, expr, sym::Iterator)
-        && let Some(Constant::Int(0)) = ConstEvalCtxt::new(cx).eval(arg)
+        && let Some(Constant::Int(0)) = ConstEvalCtxt::new(cx).eval_local(arg, expr.span.ctxt())
         && !is_lang_item_or_ctor(cx, def_id, LangItem::IteratorNext)
     {
         let mut app = Applicability::MachineApplicable;
diff --git a/clippy_lints/src/methods/iter_skip_zero.rs b/clippy_lints/src/methods/iter_skip_zero.rs
@@ -11,13 +11,15 @@ use super::ITER_SKIP_ZERO;
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, arg_expr: &Expr<'_>) {
     if !expr.span.from_expansion()
         && is_trait_method(cx, expr, sym::Iterator)
-        && let Some(arg) = ConstEvalCtxt::new(cx).eval(arg_expr).and_then(|constant| {
-            if let Constant::Int(arg) = constant {
-                Some(arg)
-            } else {
-                None
-            }
-        })
+        && let Some(arg) = ConstEvalCtxt::new(cx)
+            .eval_local(arg_expr, expr.span.ctxt())
+            .and_then(|constant| {
+                if let Constant::Int(arg) = constant {
+                    Some(arg)
+                } else {
+                    None
+                }
+            })
         && arg == 0
         && !is_from_proc_macro(cx, expr)
     {
diff --git a/clippy_lints/src/methods/repeat_once.rs b/clippy_lints/src/methods/repeat_once.rs
@@ -14,7 +14,7 @@ pub(super) fn check<'tcx>(
     recv: &'tcx Expr<'_>,
     repeat_arg: &'tcx Expr<'_>,
 ) {
-    if ConstEvalCtxt::new(cx).eval(repeat_arg) == Some(Constant::Int(1)) {
+    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();
         if ty.is_str() {
             span_lint_and_sugg(
diff --git a/clippy_lints/src/methods/str_splitn.rs b/clippy_lints/src/methods/str_splitn.rs
@@ -304,7 +304,7 @@ fn parse_iter_usage<'tcx>(
                     };
                 },
                 (sym::nth | sym::skip, [idx_expr]) if cx.tcx.trait_of_assoc(did) == Some(iter_id) => {
-                    if let Some(Constant::Int(idx)) = ConstEvalCtxt::new(cx).eval(idx_expr) {
+                    if let Some(Constant::Int(idx)) = ConstEvalCtxt::new(cx).eval_local(idx_expr, ctxt) {
                         let span = if name.ident.as_str() == "nth" {
                             e.span
                         } else if let Some((_, Node::Expr(next_expr))) = iter.next()
diff --git a/clippy_lints/src/minmax.rs b/clippy_lints/src/minmax.rs
@@ -61,7 +61,7 @@ enum MinMax {
     Max,
 }
 
-fn min_max<'a, 'tcx>(cx: &LateContext<'tcx>, expr: &'a Expr<'a>) -> Option<(MinMax, Constant, &'a Expr<'a>)> {
+fn min_max<'a>(cx: &LateContext<'_>, expr: &'a Expr<'a>) -> Option<(MinMax, Constant, &'a Expr<'a>)> {
     match expr.kind {
         ExprKind::Call(path, args) => {
             if let ExprKind::Path(ref qpath) = path.kind {
@@ -92,8 +92,8 @@ fn min_max<'a, 'tcx>(cx: &LateContext<'tcx>, expr: &'a Expr<'a>) -> Option<(MinM
     }
 }
 
-fn fetch_const<'a, 'tcx>(
-    cx: &LateContext<'tcx>,
+fn fetch_const<'a>(
+    cx: &LateContext<'_>,
     ctxt: SyntaxContext,
     receiver: Option<&'a Expr<'a>>,
     args: &'a [Expr<'a>],
diff --git a/clippy_lints/src/operators/duration_subsec.rs b/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
         && is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(self_arg).peel_refs(), sym::Duration)
-        && let Some(Constant::Int(divisor)) = ConstEvalCtxt::new(cx).eval(right)
+        && let Some(Constant::Int(divisor)) = ConstEvalCtxt::new(cx).eval_local(right, expr.span.ctxt())
     {
         let suggested_fn = match (method_path.ident.name, divisor) {
             (sym::subsec_micros, 1_000) | (sym::subsec_nanos, 1_000_000) => "subsec_millis",
diff --git a/clippy_lints/src/operators/modulo_arithmetic.rs b/clippy_lints/src/operators/modulo_arithmetic.rs
@@ -39,7 +39,9 @@ fn used_in_comparison_with_zero(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
         && let BinOpKind::Eq | BinOpKind::Ne = op.node
     {
         let ecx = ConstEvalCtxt::new(cx);
-        matches!(ecx.eval(lhs), Some(Constant::Int(0))) || matches!(ecx.eval(rhs), Some(Constant::Int(0)))
+        let ctxt = expr.span.ctxt();
+        matches!(ecx.eval_local(lhs, ctxt), Some(Constant::Int(0)))
+            || matches!(ecx.eval_local(rhs, ctxt), Some(Constant::Int(0)))
     } else {
         false
     }
@@ -55,7 +57,7 @@ fn analyze_operand(operand: &Expr<'_>, cx: &LateContext<'_>, expr: &Expr<'_>) ->
     match ConstEvalCtxt::new(cx).eval(operand)? {
         Constant::Int(v) => match *cx.typeck_results().expr_ty(expr).kind() {
             ty::Int(ity) => {
-                let value = sext(cx.tcx, v, ity);
+                let value: i128 = sext(cx.tcx, v, ity);
                 Some(OperandInfo {
                     string_representation: Some(value.to_string()),
                     is_negative: value < 0,
diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
@@ -312,7 +312,7 @@ struct RangeBounds<'a> {
 // Takes a binary expression such as x <= 2 as input
 // Breaks apart into various pieces, such as the value of the number,
 // hir id of the variable, and direction/inclusiveness of the operator
-fn check_range_bounds<'a, 'tcx>(cx: &'a LateContext<'tcx>, ex: &'a Expr<'_>) -> Option<RangeBounds<'a>> {
+fn check_range_bounds<'a>(cx: &'a LateContext<'_>, ex: &'a Expr<'_>) -> Option<RangeBounds<'a>> {
     if let ExprKind::Binary(ref op, l, r) = ex.kind {
         let (inclusive, ordering) = match op.node {
             BinOpKind::Gt => (false, Ordering::Greater),
diff --git a/clippy_utils/src/consts.rs b/clippy_utils/src/consts.rs
@@ -128,15 +128,11 @@ impl PartialEq for Constant {
             (&Self::Char(l), &Self::Char(r)) => l == r,
             (&Self::Int(l), &Self::Int(r)) => l == r,
             (&Self::F64(l), &Self::F64(r)) => {
-                // We want `Fw32 == FwAny` and `FwAny == Fw64`, and by transitivity we must have
-                // `Fw32 == Fw64`, so don’t compare them.
-                // `to_bits` is required to catch non-matching 0.0, -0.0, and NaNs.
+                // `to_bits` is required to catch non-matching `0.0` and `-0.0`.
                 l.to_bits() == r.to_bits() && !l.is_nan()
             },
             (&Self::F32(l), &Self::F32(r)) => {
-                // We want `Fw32 == FwAny` and `FwAny == Fw64`, and by transitivity we must have
-                // `Fw32 == Fw64`, so don’t compare them.
-                // `to_bits` is required to catch non-matching 0.0, -0.0, and NaNs.
+                // `to_bits` is required to catch non-matching `0.0` and `-0.0`.
                 l.to_bits() == r.to_bits() && !l.is_nan()
             },
             (&Self::Bool(l), &Self::Bool(r)) => l == r,
diff --git a/tests/ui/duration_subsec.fixed b/tests/ui/duration_subsec.fixed
@@ -25,8 +25,7 @@ fn main() {
 
     // Handle constants
     const NANOS_IN_MICRO: u32 = 1_000;
-    let _ = dur.subsec_micros();
-    //~^ duration_subsec
+    let _ = dur.subsec_nanos() / NANOS_IN_MICRO;
 
     // Other literals aren't linted
     let _ = dur.subsec_nanos() / 699;
diff --git a/tests/ui/duration_subsec.rs b/tests/ui/duration_subsec.rs
@@ -26,7 +26,6 @@ fn main() {
     // Handle constants
     const NANOS_IN_MICRO: u32 = 1_000;
     let _ = dur.subsec_nanos() / NANOS_IN_MICRO;
-    //~^ duration_subsec
 
     // Other literals aren't linted
     let _ = dur.subsec_nanos() / 699;
diff --git a/tests/ui/duration_subsec.stderr b/tests/ui/duration_subsec.stderr
@@ -25,11 +25,5 @@ error: calling `subsec_micros()` is more concise than this calculation
 LL |     let _ = (&dur).subsec_nanos() / 1_000;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `(&dur).subsec_micros()`
 
-error: calling `subsec_micros()` is more concise than this calculation
-  --> tests/ui/duration_subsec.rs:28:13
-   |
-LL |     let _ = dur.subsec_nanos() / NANOS_IN_MICRO;
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `dur.subsec_micros()`
-
-error: aborting due to 5 previous errors
+error: aborting due to 4 previous errors
 
diff --git a/tests/ui/floating_point_log.fixed b/tests/ui/floating_point_log.fixed
@@ -14,10 +14,8 @@ fn check_log_base() {
     //~^ suboptimal_flops
     let _ = x.ln();
     //~^ suboptimal_flops
-    let _ = x.log2();
-    //~^ suboptimal_flops
-    let _ = x.ln();
-    //~^ suboptimal_flops
+    let _ = x.log(TWO);
+    let _ = x.log(E);
     let _ = (x as f32).log2();
     //~^ suboptimal_flops
 
diff --git a/tests/ui/floating_point_log.rs b/tests/ui/floating_point_log.rs
@@ -15,9 +15,7 @@ fn check_log_base() {
     let _ = x.log(std::f32::consts::E);
     //~^ suboptimal_flops
     let _ = x.log(TWO);
-    //~^ suboptimal_flops
     let _ = x.log(E);
-    //~^ suboptimal_flops
     let _ = (x as f32).log(2f32);
     //~^ suboptimal_flops
 
diff --git a/tests/ui/floating_point_log.stderr b/tests/ui/floating_point_log.stderr
diff --git a/tests/ui/ip_constant.fixed b/tests/ui/ip_constant.fixed
diff --git a/tests/ui/ip_constant.rs b/tests/ui/ip_constant.rs
diff --git a/tests/ui/ip_constant.stderr b/tests/ui/ip_constant.stderr
diff --git a/tests/ui/manual_float_methods.rs b/tests/ui/manual_float_methods.rs
diff --git a/tests/ui/manual_float_methods.stderr b/tests/ui/manual_float_methods.stderr
diff --git a/tests/ui/manual_strip.stderr b/tests/ui/manual_strip.stderr
diff --git a/tests/ui/repeat_once.fixed b/tests/ui/repeat_once.fixed
diff --git a/tests/ui/repeat_once.rs b/tests/ui/repeat_once.rs
diff --git a/tests/ui/repeat_once.stderr b/tests/ui/repeat_once.stderr

Original file line number	Diff line number	Diff line change
`@@ -117,10 +117,11 @@ fn get_int_max(ty: Ty<'_>) -> Option<u128> {`
`117`	`117`	`fn get_const<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) -> Option<(u128, BinOpKind, &'tcx Expr<'tcx>)> {`
`118`	`118`	`if let ExprKind::Binary(op, l, r) = expr.kind {`
`119`	`119`	`let ecx = ConstEvalCtxt::new(cx);`
`120`		`- if let Some(Constant::Int(c)) = ecx.eval(r) {`
	`120`	`+ let ctxt = expr.span.ctxt();`
	`121`	`+ if let Some(Constant::Int(c)) = ecx.eval_local(r, ctxt) {`
`121`	`122`	`return Some((c, op.node, l));`
`122`	`123`	`}`
`123`		`- if let Some(Constant::Int(c)) = ecx.eval(l) {`
	`124`	`+ if let Some(Constant::Int(c)) = ecx.eval_local(l, ctxt) {`
`124`	`125`	`return Some((c, invert_op(op.node)?, r));`
`125`	`126`	`}`
`126`	`127`	`}`
Original file line number	Diff line number	Diff line change
`@@ -66,7 +66,7 @@ fn parse_shift<'tcx>(`
`66`	`66`	`BinOpKind::Shr => ShiftDirection::Right,`
`67`	`67`	`_ => return None,`
`68`	`68`	`};`
`69`		`- let const_expr = ConstEvalCtxt::new(cx).eval(r)?;`
	`69`	`+ let const_expr = ConstEvalCtxt::new(cx).eval_local(r, expr.span.ctxt())?;`
`70`	`70`	`if let Constant::Int(shift) = const_expr {`
`71`	`71`	`return Some((dir, shift, l));`
`72`	`72`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr`
`14`	`14`	`if let OwnerNode::Item(item) = cx.tcx.hir_owner_node(cx.tcx.hir_get_parent_item(expr.hir_id))`
`15`	`15`	`&& let def_id = item.owner_id.to_def_id()`
`16`	`16`	`&& is_trait_method(cx, expr, sym::Iterator)`
`17`		`- && let Some(Constant::Int(0)) = ConstEvalCtxt::new(cx).eval(arg)`
	`17`	`+ && let Some(Constant::Int(0)) = ConstEvalCtxt::new(cx).eval_local(arg, expr.span.ctxt())`
`18`	`18`	`&& !is_lang_item_or_ctor(cx, def_id, LangItem::IteratorNext)`
`19`	`19`	`{`
`20`	`20`	`let mut app = Applicability::MachineApplicable;`