src/tools/clippy/tests/ui/collection_is_never_read.rs

   1 #![allow(unused)]
   2 #![warn(clippy::collection_is_never_read)]
   3
   4 use std::collections::{HashMap, HashSet};
   5
   6 fn main() {}
   7
   8 fn not_a_collection() {
   9     // TODO: Expand `collection_is_never_read` beyond collections?
  10     let mut x = 10; // Ok
  11     x += 1;
  12 }
  13
  14 fn no_access_at_all() {
  15     // Other lints should catch this.
  16     let x = vec![1, 2, 3]; // Ok
  17 }
  18
  19 fn write_without_read() {
  20     // The main use case for `collection_is_never_read`.
  21     let mut x = HashMap::new(); // WARNING
  22     x.insert(1, 2);
  23 }
  24
  25 fn read_without_write() {
  26     let mut x = vec![1, 2, 3]; // Ok
  27     let _ = x.len();
  28 }
  29
  30 fn write_and_read() {
  31     let mut x = vec![1, 2, 3]; // Ok
  32     x.push(4);
  33     let _ = x.len();
  34 }
  35
  36 fn write_after_read() {
  37     // TODO: Warn here, but this requires more extensive data flow analysis.
  38     let mut x = vec![1, 2, 3]; // Ok
  39     let _ = x.len();
  40     x.push(4); // Pointless
  41 }
  42
  43 fn write_before_reassign() {
  44     // TODO: Warn here, but this requires more extensive data flow analysis.
  45     let mut x = HashMap::new(); // Ok
  46     x.insert(1, 2); // Pointless
  47     x = HashMap::new();
  48     let _ = x.len();
  49 }
  50
  51 fn read_in_closure() {
  52     let mut x = HashMap::new(); // Ok
  53     x.insert(1, 2);
  54     let _ = || {
  55         let _ = x.len();
  56     };
  57 }
  58
  59 fn write_in_closure() {
  60     let mut x = vec![1, 2, 3]; // WARNING
  61     let _ = || {
  62         x.push(4);
  63     };
  64 }
  65
  66 fn read_in_format() {
  67     let mut x = HashMap::new(); // Ok
  68     x.insert(1, 2);
  69     format!("{x:?}");
  70 }
  71
  72 fn shadowing_1() {
  73     let x = HashMap::<usize, usize>::new(); // Ok
  74     let _ = x.len();
  75     let mut x = HashMap::new(); // WARNING
  76     x.insert(1, 2);
  77 }
  78
  79 fn shadowing_2() {
  80     let mut x = HashMap::new(); // WARNING
  81     x.insert(1, 2);
  82     let x = HashMap::<usize, usize>::new(); // Ok
  83     let _ = x.len();
  84 }
  85
  86 #[allow(clippy::let_unit_value)]
  87 fn fake_read_1() {
  88     let mut x = vec![1, 2, 3]; // WARNING
  89     x.reverse();
  90     let _: () = x.clear();
  91 }
  92
  93 fn fake_read_2() {
  94     let mut x = vec![1, 2, 3]; // WARNING
  95     x.reverse();
  96     println!("{:?}", x.push(5));
  97 }
  98
  99 fn assignment() {
 100     let mut x = vec![1, 2, 3]; // WARNING
 101     let y = vec![4, 5, 6]; // Ok
 102     x = y;
 103 }
 104
 105 #[allow(clippy::self_assignment)]
 106 fn self_assignment() {
 107     let mut x = vec![1, 2, 3]; // WARNING
 108     x = x;
 109 }
 110
 111 fn method_argument_but_not_target() {
 112     struct MyStruct;
 113     impl MyStruct {
 114         fn my_method(&self, _argument: &[usize]) {}
 115     }
 116     let my_struct = MyStruct;
 117
 118     let mut x = vec![1, 2, 3]; // Ok
 119     x.reverse();
 120     my_struct.my_method(&x);
 121 }
 122
 123 fn insert_is_not_a_read() {
 124     let mut x = HashSet::new(); // WARNING
 125     x.insert(5);
 126 }
 127
 128 fn insert_is_a_read() {
 129     let mut x = HashSet::new(); // Ok
 130     if x.insert(5) {
 131         println!("5 was inserted");
 132     }
 133 }
 134
 135 fn not_read_if_return_value_not_used() {
 136     // `is_empty` does not modify the set, so it's a query. But since the return value is not used, the
 137     // lint does not consider it a read here.
 138     let x = vec![1, 2, 3]; // WARNING
 139     x.is_empty();
 140 }
 141
 142 fn extension_traits() {
 143     trait VecExt<T> {
 144         fn method_with_side_effect(&self);
 145         fn method_without_side_effect(&self);
 146     }
 147
 148     impl<T> VecExt<T> for Vec<T> {
 149         fn method_with_side_effect(&self) {
 150             println!("my length: {}", self.len());
 151         }
 152         fn method_without_side_effect(&self) {}
 153     }
 154
 155     let x = vec![1, 2, 3]; // Ok
 156     x.method_with_side_effect();
 157
 158     let y = vec![1, 2, 3]; // Ok (false negative)
 159     y.method_without_side_effect();
 160 }
 161
 162 fn function_argument() {
 163     #[allow(clippy::ptr_arg)]
 164     fn foo<T>(v: &Vec<T>) -> usize {
 165         v.len()
 166     }
 167
 168     let x = vec![1, 2, 3]; // Ok
 169     foo(&x);
 170 }
 171
 172 fn string() {
 173     // Do lint (write without read)
 174     let mut s = String::new();
 175     s.push_str("Hello, World!");
 176
 177     // Do not lint (read without write)
 178     let mut s = String::from("Hello, World!");
 179     let _ = s.len();
 180
 181     // Do not lint (write and read)
 182     let mut s = String::from("Hello, World!");
 183     s.push_str("foo, bar");
 184     let _ = s.len();
 185
 186     // Do lint the first line, but not the second
 187     let mut s = String::from("Hello, World!");
 188     let t = String::from("foo, bar");
 189     s = t;
 190 }