src/test/ui/threads-sendsync/sync-send-iterators-in-libcore.rs

   1 // run-pass
   2 // pretty-expanded FIXME #23616
   3
   4 #![allow(warnings)]
   5
   6 use std::iter::{empty, once, repeat};
   7
   8 fn is_sync<T>(_: T) where T: Sync {}
   9 fn is_send<T>(_: T) where T: Send {}
  10
  11 macro_rules! all_sync_send {
  12     ($ctor:expr, $iter:ident) => ({
  13         let mut x = $ctor;
  14         is_sync(x.$iter());
  15         let mut y = $ctor;
  16         is_send(y.$iter());
  17     });
  18     ($ctor:expr, $iter:ident($($param:expr),+)) => ({
  19         let mut x = $ctor;
  20         is_sync(x.$iter($( $param ),+));
  21         let mut y = $ctor;
  22         is_send(y.$iter($( $param ),+));
  23     });
  24     ($ctor:expr, $iter:ident, $($rest:tt)*) => ({
  25         all_sync_send!($ctor, $iter);
  26         all_sync_send!($ctor, $($rest)*);
  27     });
  28     ($ctor:expr, $iter:ident($($param:expr),+), $($rest:tt)*) => ({
  29         all_sync_send!($ctor, $iter($( $param ),+));
  30         all_sync_send!($ctor, $($rest)*);
  31     });
  32 }
  33
  34 macro_rules! all_sync_send_mutable_ref {
  35     ($ctor:expr, $($iter:ident),+) => ({
  36         $(
  37             let mut x = $ctor;
  38             is_sync((&mut x).$iter());
  39             let mut y = $ctor;
  40             is_send((&mut y).$iter());
  41         )+
  42     })
  43 }
  44
  45 macro_rules! is_sync_send {
  46     ($ctor:expr) => ({
  47         let x = $ctor;
  48         is_sync(x);
  49         let y = $ctor;
  50         is_send(y);
  51     })
  52 }
  53
  54 fn main() {
  55     // for char.rs
  56     all_sync_send!("Я", escape_debug, escape_default, escape_unicode);
  57
  58     // for iter.rs
  59     all_sync_send_mutable_ref!([1], iter);
  60
  61     // Bytes implements DoubleEndedIterator
  62     all_sync_send!("a".bytes(), rev);
  63
  64     let a = [1];
  65     let b = [2];
  66     all_sync_send!(a.iter(),
  67                    cloned,
  68                    cycle,
  69                    chain([2].iter()),
  70                    zip([2].iter()),
  71                    map(|_| 1),
  72                    filter(|_| true),
  73                    filter_map(|_| Some(1)),
  74                    enumerate,
  75                    peekable,
  76                    skip_while(|_| true),
  77                    take_while(|_| true),
  78                    skip(1),
  79                    take(1),
  80                    scan(1, |_, _| Some(1)),
  81                    flat_map(|_| b.iter()),
  82                    fuse,
  83                    inspect(|_| ()));
  84
  85     is_sync_send!((1..).step_by(2));
  86     is_sync_send!((1..2).step_by(2));
  87     is_sync_send!((1..2));
  88     is_sync_send!((1..));
  89     is_sync_send!(repeat(1));
  90     is_sync_send!(empty::<usize>());
  91     is_sync_send!(empty::<*mut i32>());
  92     is_sync_send!(once(1));
  93
  94     // for option.rs
  95     // FIXME
  96
  97     // for result.rs
  98     // FIXME
  99
 100     // for slice.rs
 101     // FIXME
 102
 103     // for str/mod.rs
 104     // FIXME
 105 }