Added more tests for avoidable_slice_indexing

Author: xFrednet

tests/ui/avoidable_slice_indexing/if_let_slice_destruction.rs

@@ -76,6 +76,63 @@ fn slice_is_used() {
     if let Some(slice) = slice {
         println!("{:?}", slice.to_vec());
     }
+
+    let opt: Option<[String; 2]> = Some([String::from("Hello"), String::from("world")]);
+    if let Some(slice) = opt {
+        if !slice.is_empty() {
+            println!("first: {}", slice[0]);
+        }
+    }
+}
+
+/// The slice is used by an external function and should therefore not be linted
+fn check_slice_as_arg() {
+    fn is_interesting<T>(slice: &[T; 2]) -> bool {
+        !slice.is_empty()
+    }
+
+    let slice_wrapped: Option<[String; 2]> = Some([String::from("Hello"), String::from("world")]);
+    if let Some(slice) = &slice_wrapped {
+        if is_interesting(slice) {
+            println!("This is interesting {}", slice[0]);
+        }
+    }
+    println!("{:?}", slice_wrapped);
+}
+
+fn check_slice_in_struct() {
+    #[derive(Debug)]
+    struct Wrapper<'a> {
+        inner: Option<&'a [String]>,
+        is_awesome: bool,
+    }
+
+    impl<'a> Wrapper<'a> {
+        fn is_super_awesome(&self) -> bool {
+            self.is_awesome
+        }
+    }
+
+    let inner = &[String::from("New"), String::from("World")];
+    let wrap = Wrapper {
+        inner: Some(inner),
+        is_awesome: true,
+    };
+
+    // Test 1: Field access
+    if let Some(slice) = wrap.inner {
+        if wrap.is_awesome {
+            println!("This is awesome! {}", slice[0]);
+        }
+    }
+
+    // Test 2: function access
+    if let Some(slice) = wrap.inner {
+        if wrap.is_super_awesome() {
+            println!("This is super awesome! {}", slice[0]);
+        }
+    }
+    println!("Complete wrap: {:?}", wrap);
 }
 
 /// This would be a nice additional feature to have in the future, but adding it

tests/ui/avoidable_slice_indexing/if_let_slice_destruction.stderr

@@ -124,5 +124,35 @@ help: and replacing the index expressions here
 LL |         println!("{:?}", slice_0);
    |                          ~~~~~~~
 
-error: aborting due to 8 previous errors
+error: this slice can be deconstructured to avoid indexing
+  --> $DIR/if_let_slice_destruction.rs:123:17
+   |
+LL |     if let Some(slice) = wrap.inner {
+   |                 ^^^^^
+   |
+help: try destructing the slice with a pattern here
+   |
+LL |     if let Some([ref slice_0, ..]) = wrap.inner {
+   |                 ~~~~~~~~~~~~~~~~~
+help: and replacing the index expressions here
+   |
+LL |             println!("This is awesome! {}", slice_0);
+   |                                             ~~~~~~~
+
+error: this slice can be deconstructured to avoid indexing
+  --> $DIR/if_let_slice_destruction.rs:130:17
+   |
+LL |     if let Some(slice) = wrap.inner {
+   |                 ^^^^^
+   |
+help: try destructing the slice with a pattern here
+   |
+LL |     if let Some([ref slice_0, ..]) = wrap.inner {
+   |                 ~~~~~~~~~~~~~~~~~
+help: and replacing the index expressions here
+   |
+LL |             println!("This is super awesome! {}", slice_0);
+   |                                                   ~~~~~~~
+
+error: aborting due to 10 previous errors