src/test/ui/liveness/liveness-upvars.rs

   1 // edition:2018
   2 // check-pass
   3 #![warn(unused)]
   4 #![allow(unreachable_code)]
   5
   6 pub fn unintentional_copy_one() {
   7     let mut last = None;
   8     let mut f = move |s| {
   9         last = Some(s); //~  WARN value assigned to `last` is never read
  10                         //~| WARN unused variable: `last`
  11     };
  12     f("a");
  13     f("b");
  14     f("c");
  15     dbg!(last.unwrap());
  16 }
  17
  18 pub fn unintentional_copy_two() {
  19     let mut sum = 0;
  20     (1..10).for_each(move |x| {
  21         sum += x; //~ WARN unused variable: `sum`
  22     });
  23     dbg!(sum);
  24 }
  25
  26 pub fn f() {
  27     let mut c = 0;
  28
  29     // Captured by value, but variable is dead on entry.
  30     move || {
  31         c = 1; //~ WARN value captured by `c` is never read
  32         println!("{}", c);
  33     };
  34     let _ = async move {
  35         c = 1; //~ WARN value captured by `c` is never read
  36         println!("{}", c);
  37     };
  38
  39     // Read and written to, but never actually used.
  40     move || {
  41         c += 1; //~ WARN unused variable: `c`
  42     };
  43     let _ = async move {
  44         c += 1; //~  WARN value assigned to `c` is never read
  45                 //~| WARN unused variable: `c`
  46     };
  47
  48     move || {
  49         println!("{}", c);
  50         // Value is read by closure itself on later invocations.
  51         c += 1;
  52     };
  53     let b = Box::new(42);
  54     move || {
  55         println!("{}", c);
  56         // Never read because this is FnOnce closure.
  57         c += 1; //~  WARN value assigned to `c` is never read
  58         drop(b);
  59     };
  60     let _ = async move {
  61         println!("{}", c);
  62         // Never read because this is a generator.
  63         c += 1; //~  WARN value assigned to `c` is never read
  64     };
  65 }
  66
  67 pub fn nested() {
  68     let mut d = None;
  69     let mut e = None;
  70     || {
  71         || {
  72             d = Some("d1"); //~ WARN value assigned to `d` is never read
  73             d = Some("d2");
  74         };
  75         move || {
  76             e = Some("e1"); //~  WARN value assigned to `e` is never read
  77                             //~| WARN unused variable: `e`
  78             e = Some("e2"); //~  WARN value assigned to `e` is never read
  79         };
  80     };
  81 }
  82
  83 pub fn g<T: Default>(mut v: T) {
  84     |r| {
  85         if r {
  86             v = T::default(); //~ WARN value assigned to `v` is never read
  87         } else {
  88             drop(v);
  89         }
  90     };
  91 }
  92
  93 pub fn h<T: Copy + Default + std::fmt::Debug>() {
  94     let mut z = T::default();
  95     move |b| {
  96         loop {
  97             if b {
  98                 z = T::default(); //~  WARN value assigned to `z` is never read
  99                                   //~| WARN unused variable: `z`
 100             } else {
 101                 return;
 102             }
 103         }
 104         dbg!(z);
 105     };
 106 }
 107
 108 fn main() {}