feat: add indexing analysis as well

Author: kayagokalp

clippy_config/src/types.rs

@@ -140,18 +140,19 @@ pub(crate) const DEFAULT_NONFALLIBLE_PATHS: &[&str] =
 
 #[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize)]
 pub struct TestWithoutFailCaseBehaviour {
-    /// Indexing into a slice is fallible, and thus the a test that is doing that
-    /// can fail. If set true, the lint consider indexing into a slice a failable case
+    /// Indexing is fallible, and thus the a test that is doing that can fail.
+    ///
+    /// If set true, the lint consider indexing into a slice a failable case
     /// and won't lint tests that has some sort of indexing. This analysis still done
     /// in a interfunctional manner. Meaning that any indexing opeartion done inside of
     /// a function that the test calls will still mark the test fallible.
     ///
-    /// By default this is set to `false`. That is becuase from a usability perspective,
+    /// By default this is set to `false`. That is because from a usability perspective,
     /// indexing an array is not the intended way to fail a test. So setting this `true`
     /// reduces false positives but makes the analysis more focused on possible byproducts
     /// of a test. That is the set of operations to get the point we assert something rather
     /// than the existance of asserting that thing.
-    pub include_slice_indexing: bool,
+    pub include_indexing: bool,
     /// List of full paths of macros and functions, that can fail. If a test, or a function
     /// that the test calls contains any one of these macros, we will mark the test fallible.
     /// By default this macros are defined as `assert!`, `assert_eq!`, `panic!`.
@@ -163,20 +164,10 @@ pub struct TestWithoutFailCaseBehaviour {
     pub non_fallible_paths: Vec<String>,
 }
 
-impl TestWithoutFailCaseBehaviour {
-    pub fn new(include_slice_indexing: bool, fallible_paths: Vec<String>, non_fallible_paths: Vec<String>) -> Self {
-        Self {
-            include_slice_indexing,
-            fallible_paths,
-            non_fallible_paths,
-        }
-    }
-}
-
 impl Default for TestWithoutFailCaseBehaviour {
     fn default() -> Self {
         Self {
-            include_slice_indexing: false,
+            include_indexing: false,
             fallible_paths: DEFAULT_FALLIBLE_PATHS.iter().map(|s| s.to_string()).collect(),
             non_fallible_paths: DEFAULT_NONFALLIBLE_PATHS.iter().map(|a| a.to_string()).collect(),
         }

clippy_lints/src/test_without_fail_case.rs

@@ -58,7 +58,7 @@ impl TestWithoutFailCase {
     pub fn new(conf: &Conf) -> Self {
         Self {
             config: SearchConfig {
-                indexing_into_slice_fallible: conf.test_without_fail_case.include_slice_indexing,
+                indexing_fallible: conf.test_without_fail_case.include_indexing,
                 fallible_paths: conf.test_without_fail_case.fallible_paths.iter().cloned().collect(),
                 non_fallible_paths: conf.test_without_fail_case.non_fallible_paths.iter().cloned().collect(),
             },
@@ -95,8 +95,8 @@ impl<'tcx> LateLintPass<'tcx> for TestWithoutFailCase {
 /// Set of options that user provivdes through configs, to modify the lint behaviour
 /// according to their repo.
 struct SearchConfig {
-    /// If search should consider indexing into slice as fallible.
-    indexing_into_slice_fallible: bool,
+    /// If search should consider indexing as fallible.
+    indexing_fallible: bool,
     /// Set of paths that are marked as fallible.
     fallible_paths: FxHashSet<String>,
     /// Set of paths that are marked as non fallible.
@@ -187,6 +187,15 @@ impl<'tcx> Visitor<'tcx> for SearchFailIntraFunction<'_, 'tcx> {
         }
 
         match expr.kind {
+            ExprKind::Index(slice_expr, index_expr, _) => {
+                // If indexing into slices is considered fallible, we treat it as a potential failure point
+                if self.search_config.indexing_fallible {
+                    self.fail_found = true;
+                    return;
+                }
+                self.visit_expr(slice_expr);
+                self.visit_expr(index_expr);
+            },
             ExprKind::Call(callee, args) => {
                 if let ExprKind::Path(ref qpath) = callee.kind {
                     if let Res::Def(_, def_id) = self.cx.qpath_res(qpath, callee.hir_id) {