src/tools/miri/tests/pass/closures.rs

   1 fn simple() -> i32 {
   2     let y = 10;
   3     let f = |x| x + y;
   4     f(2)
   5 }
   6
   7 fn crazy_closure() -> (i32, i32, i32) {
   8     fn inner<T: Copy>(t: T) -> (i32, T, T) {
   9         struct NonCopy;
  10         let x = NonCopy;
  11
  12         let a = 2;
  13         let b = 40;
  14         let f = move |y, z, asdf| {
  15             drop(x);
  16             (a + b + y + z, asdf, t)
  17         };
  18         f(a, b, t)
  19     }
  20
  21     inner(10)
  22 }
  23
  24 fn closure_arg_adjustment_problem() -> i64 {
  25     fn once<F: FnOnce(i64)>(f: F) {
  26         f(2);
  27     }
  28     let mut y = 1;
  29     {
  30         let f = |x| y += x;
  31         once(f);
  32     }
  33     y
  34 }
  35
  36 fn fn_once_closure_with_multiple_args() -> i64 {
  37     fn once<F: FnOnce(i64, i64) -> i64>(f: F) -> i64 {
  38         f(2, 3)
  39     }
  40     let y = 1;
  41     {
  42         let f = |x, z| x + y + z;
  43         once(f)
  44     }
  45 }
  46
  47 fn boxed_fn_once(f: Box<dyn FnOnce() -> i32>) -> i32 {
  48     f()
  49 }
  50
  51 fn box_dyn() {
  52     let x: Box<dyn Fn(i32) -> i32> = Box::new(|x| x * 2);
  53     assert_eq!(x(21), 42);
  54     let mut i = 5;
  55     {
  56         let mut x: Box<dyn FnMut()> = Box::new(|| i *= 2);
  57         x();
  58         x();
  59     }
  60     assert_eq!(i, 20);
  61 }
  62
  63 fn fn_item_as_closure_trait_object() {
  64     fn foo() {}
  65     let f: &dyn Fn() = &foo;
  66     f();
  67 }
  68
  69 fn fn_item_with_args_as_closure_trait_object() {
  70     fn foo(i: i32) {
  71         assert_eq!(i, 42);
  72     }
  73     let f: &dyn Fn(i32) = &foo;
  74     f(42);
  75 }
  76
  77 fn fn_item_with_multiple_args_as_closure_trait_object() {
  78     fn foo(i: i32, j: i32) {
  79         assert_eq!(i, 42);
  80         assert_eq!(j, 55);
  81     }
  82
  83     fn bar(i: i32, j: i32, k: f32) {
  84         assert_eq!(i, 42);
  85         assert_eq!(j, 55);
  86         assert_eq!(k, 3.14159)
  87     }
  88     let f: &dyn Fn(i32, i32) = &foo;
  89     f(42, 55);
  90     let f: &dyn Fn(i32, i32, f32) = &bar;
  91     f(42, 55, 3.14159);
  92 }
  93
  94 fn fn_ptr_as_closure_trait_object() {
  95     fn foo() {}
  96     fn bar(u: u32) {
  97         assert_eq!(u, 42);
  98     }
  99     fn baa(u: u32, f: f32) {
 100         assert_eq!(u, 42);
 101         assert_eq!(f, 3.141);
 102     }
 103     let f: &dyn Fn() = &(foo as fn());
 104     f();
 105     let f: &dyn Fn(u32) = &(bar as fn(u32));
 106     f(42);
 107     let f: &dyn Fn(u32, f32) = &(baa as fn(u32, f32));
 108     f(42, 3.141);
 109 }
 110
 111 fn main() {
 112     assert_eq!(simple(), 12);
 113     assert_eq!(crazy_closure(), (84, 10, 10));
 114     assert_eq!(closure_arg_adjustment_problem(), 3);
 115     assert_eq!(fn_once_closure_with_multiple_args(), 6);
 116     assert_eq!(
 117         boxed_fn_once(Box::new({
 118             let x = 13;
 119             move || x
 120         })),
 121         13,
 122     );
 123
 124     box_dyn();
 125     fn_item_as_closure_trait_object();
 126     fn_item_with_args_as_closure_trait_object();
 127     fn_item_with_multiple_args_as_closure_trait_object();
 128     fn_ptr_as_closure_trait_object();
 129 }