tests/ui/uninit_vec.rs

   1 #![warn(clippy::uninit_vec)]
   2
   3 use std::mem::MaybeUninit;
   4
   5 #[derive(Default)]
   6 struct MyVec {
   7     vec: Vec<u8>,
   8 }
   9
  10 fn main() {
  11     // with_capacity() -> set_len() should be detected
  12     let mut vec: Vec<u8> = Vec::with_capacity(1000);
  13     unsafe {
  14         vec.set_len(200);
  15     }
  16
  17     // reserve() -> set_len() should be detected
  18     vec.reserve(1000);
  19     unsafe {
  20         vec.set_len(200);
  21     }
  22
  23     // new() -> set_len() should be detected
  24     let mut vec: Vec<u8> = Vec::new();
  25     unsafe {
  26         vec.set_len(200);
  27     }
  28
  29     // default() -> set_len() should be detected
  30     let mut vec: Vec<u8> = Default::default();
  31     unsafe {
  32         vec.set_len(200);
  33     }
  34
  35     let mut vec: Vec<u8> = Vec::default();
  36     unsafe {
  37         vec.set_len(200);
  38     }
  39
  40     // test when both calls are enclosed in the same unsafe block
  41     unsafe {
  42         let mut vec: Vec<u8> = Vec::with_capacity(1000);
  43         vec.set_len(200);
  44
  45         vec.reserve(1000);
  46         vec.set_len(200);
  47     }
  48
  49     let mut vec: Vec<u8> = Vec::with_capacity(1000);
  50     unsafe {
  51         // test the case where there are other statements in the following unsafe block
  52         vec.set_len(200);
  53         assert!(vec.len() == 200);
  54     }
  55
  56     // handle vec stored in the field of a struct
  57     let mut my_vec = MyVec::default();
  58     my_vec.vec.reserve(1000);
  59     unsafe {
  60         my_vec.vec.set_len(200);
  61     }
  62
  63     my_vec.vec = Vec::with_capacity(1000);
  64     unsafe {
  65         my_vec.vec.set_len(200);
  66     }
  67
  68     // Test `#[allow(...)]` attributes on inner unsafe block (shouldn't trigger)
  69     let mut vec: Vec<u8> = Vec::with_capacity(1000);
  70     #[allow(clippy::uninit_vec)]
  71     unsafe {
  72         vec.set_len(200);
  73     }
  74
  75     // MaybeUninit-wrapped types should not be detected
  76     unsafe {
  77         let mut vec: Vec<MaybeUninit<u8>> = Vec::with_capacity(1000);
  78         vec.set_len(200);
  79
  80         let mut vec: Vec<(MaybeUninit<u8>, MaybeUninit<bool>)> = Vec::with_capacity(1000);
  81         vec.set_len(200);
  82
  83         let mut vec: Vec<(MaybeUninit<u8>, [MaybeUninit<bool>; 2])> = Vec::with_capacity(1000);
  84         vec.set_len(200);
  85     }
  86
  87     // known false negative
  88     let mut vec1: Vec<u8> = Vec::with_capacity(1000);
  89     let mut vec2: Vec<u8> = Vec::with_capacity(1000);
  90     unsafe {
  91         vec1.set_len(200);
  92         vec2.set_len(200);
  93     }
  94
  95     // set_len(0) should not be detected
  96     let mut vec: Vec<u8> = Vec::with_capacity(1000);
  97     unsafe {
  98         vec.set_len(0);
  99     }
 100 }