improve sniffing logic

Author: andjsrk

clippy_lints/src/missing_asserts_for_indexing.rs

@@ -108,6 +108,11 @@ enum AssertionSide<'hir> {
     AssertedLen(EvaluatedIntExpr<'hir>),
 }
 impl<'hir> AssertionSide<'hir> {
+    pub fn from_expr(cx: &LateContext<'_>, expr: &'hir Expr<'hir>) -> Option<Self> {
+        Self::asserted_len_from_int_lit_expr(expr)
+            .or_else(|| Self::slice_len_from_expr(cx, expr))
+            .or_else(|| Self::asserted_len_from_possibly_const_expr(cx, expr))
+    }
     pub fn slice_len_from_expr(cx: &LateContext<'_>, expr: &'hir Expr<'hir>) -> Option<Self> {
         if let ExprKind::MethodCall(method, recv, [], _) = expr.kind
             // checking method name first rather than receiver's type could improve performance
@@ -119,20 +124,22 @@ impl<'hir> AssertionSide<'hir> {
             None
         }
     }
-    pub fn asserted_len_from_expr(cx: &LateContext<'_>, expr: &'hir Expr<'hir>) -> Option<Self> {
-        if let ExprKind::Lit(Spanned { node, .. }) = expr.kind {
-            // cases like `b'A'` or `5.0` would be extremely rare so
-            // ignore those and consider only integers
-            if let LitKind::Int(Pu128(x), _) = node {
-                // integer literals
-                Some(Self::AssertedLen(EvaluatedIntExpr {
-                    expr,
-                    value: x as usize,
-                }))
-            } else {
-                None
-            }
-        } else if let Some(Constant::Int(x)) = ConstEvalCtxt::new(cx).eval(expr) {
+    pub fn asserted_len_from_int_lit_expr(expr: &'hir Expr<'hir>) -> Option<Self> {
+        if let ExprKind::Lit(Spanned {
+            node: LitKind::Int(Pu128(x), _),
+            ..
+        }) = expr.kind
+        {
+            Some(Self::AssertedLen(EvaluatedIntExpr {
+                expr,
+                value: x as usize,
+            }))
+        } else {
+            None
+        }
+    }
+    pub fn asserted_len_from_possibly_const_expr(cx: &LateContext<'_>, expr: &'hir Expr<'hir>) -> Option<Self> {
+        if let Some(Constant::Int(x)) = ConstEvalCtxt::new(cx).eval(expr) {
             Some(Self::AssertedLen(EvaluatedIntExpr {
                 expr,
                 value: x as usize,
@@ -152,21 +159,31 @@ fn len_comparison<'hir>(
     left_expr: &'hir Expr<'hir>,
     right_expr: &'hir Expr<'hir>,
 ) -> Option<(LengthComparison, EvaluatedIntExpr<'hir>, &'hir Expr<'hir>)> {
+    fn sniff_operands<'hir>(
+        cx: &LateContext<'_>,
+        left: &'hir Expr<'hir>,
+        right: &'hir Expr<'hir>,
+    ) -> Option<(AssertionSide<'hir>, AssertionSide<'hir>)> {
+        // sniff as cheap as possible
+        if let Some(left) = AssertionSide::asserted_len_from_int_lit_expr(left) {
+            Some((left, AssertionSide::from_expr(cx, right)?))
+        } else if let Some(left) = AssertionSide::slice_len_from_expr(cx, left) {
+            Some((left, AssertionSide::from_expr(cx, right)?))
+        } else {
+            Some((
+                AssertionSide::asserted_len_from_possibly_const_expr(cx, left)?,
+                AssertionSide::slice_len_from_expr(cx, right)?,
+            ))
+        }
+    }
+
     type Side<'hir> = AssertionSide<'hir>;
 
     // normalize comparison, `v.len() > 4` becomes `4 < v.len()`
     // this simplifies the logic a bit
     let (op, left_expr, right_expr) = normalize_comparison(bin_op, left_expr, right_expr)?;
 
-    // sniff operands as cheap as possible
-    // eliminate possibility of both sides being `v.len()` variant
-    let (left, right) = match AssertionSide::slice_len_from_expr(cx, left_expr) {
-        Some(left) => (left, AssertionSide::asserted_len_from_expr(cx, right_expr)?),
-        None => (
-            AssertionSide::asserted_len_from_expr(cx, left_expr)?,
-            AssertionSide::slice_len_from_expr(cx, right_expr)?,
-        ),
-    };
+    let (left, right) = sniff_operands(cx, left_expr, right_expr)?;
     let (swapped, asserted_len, slice) = match (left, right) {
         // `A > B` (e.g. `5 > 4`)
         | (Side::AssertedLen(_), Side::AssertedLen(_))