split up functions

Author: untitaker

clippy_lints/src/loops/manual_memmove.rs

@@ -75,18 +75,7 @@ pub(super) fn check<'tcx>(
                             if let Some((start_left, offset_left)) = get_details_from_idx(cx, idx_left, starts);
                             if let Some((start_right, offset_right)) = get_details_from_idx(cx, idx_right, starts);
 
-                            // in order to be a memmove-type loop, read indices must be iterated
-                            // over at a later point than written indices. we currently enforce
-                            // this by ensuring that:
-                            //
-                            // - rhs is `path + offset` with offset >= 0
-                            // - lhs is just `path` (same path as rhs)
-                            if let ExprKind::Binary(idx_right_op, idx_right_lhs, idx_right_rhs) = idx_right.kind;
-                            if let Some(idx_right_local) = path_to_local(idx_right_lhs);
-                            if let Some(idx_left_local) = path_to_local(idx_left);
-                            if idx_right_local == idx_left_local;
-                            if let BinOpKind::Add = idx_right_op.node;
-                            if is_positive_offset(cx, idx_right_rhs);
+                            if left_is_smaller_than_right(cx, idx_left, idx_right);
 
                             if let StartKind::Range = start_left;
                             if let StartKind::Range = start_right;
@@ -217,7 +206,28 @@ fn build_manual_memmove_suggestion<'tcx>(
     )
 }
 
-fn is_positive_offset<'tcx>(cx: &LateContext<'tcx>, offset: &'tcx Expr<'_>) -> bool {
-    // the variable/item referred to has an uint type, therefore offset is positive
-    matches!(cx.typeck_results().expr_ty(offset).kind(), ty::Uint(_))
+fn left_is_smaller_than_right<'tcx>(
+    cx: &LateContext<'tcx>,
+    idx_left: &'tcx Expr<'_>,
+    idx_right: &'tcx Expr<'_>,
+) -> bool {
+    // in order to be a memmove-type loop, read indices must be iterated
+    // over at a later point than written indices. we currently enforce
+    // this by ensuring that:
+    //
+    // - rhs is `path + offset` with offset >= 0
+    // - lhs is just `path` (same path as rhs)
+    if_chain! {
+        if let ExprKind::Binary(idx_right_op, idx_right_lhs, idx_right_rhs) = idx_right.kind;
+        if idx_right_op.node == BinOpKind::Add;
+        if let Some(idx_left_local) = path_to_local(idx_left);
+        if let Some(idx_right_local) = path_to_local(idx_right_lhs);
+        if idx_right_local == idx_left_local;
+        if let ty::Uint(_) = cx.typeck_results().expr_ty(idx_right_rhs).kind();
+        then {
+            true
+        } else {
+            false
+        }
+    }
 }