src/test/ui/array-slice-vec/subslice-patterns-pass.rs

   1 // This test comprehensively checks the passing static and dynamic semantics
   2 // of subslice patterns `..`, `x @ ..`, `ref x @ ..`, and `ref mut @ ..`
   3 // in slice patterns `[$($pat), $(,)?]` .
   4
   5 // run-pass
   6
   7 #![feature(slice_patterns)]
   8
   9 #![allow(unreachable_patterns)]
  10
  11 use std::convert::identity;
  12
  13 #[derive(PartialEq, Debug, Clone)]
  14 struct N(u8);
  15
  16 macro_rules! n {
  17     ($($e:expr),* $(,)?) => {
  18         [$(N($e)),*]
  19     }
  20 }
  21
  22 macro_rules! c {
  23     ($inp:expr, $typ:ty, $out:expr $(,)?) => {
  24         assert_eq!($out, identity::<$typ>($inp));
  25     }
  26 }
  27
  28 macro_rules! m {
  29     ($e:expr, $p:pat => $b:expr) => {
  30         match $e {
  31             $p => $b,
  32             _ => panic!(),
  33         }
  34     }
  35 }
  36
  37 fn main() {
  38     slices();
  39     arrays();
  40 }
  41
  42 fn slices() {
  43     // Matching slices using `ref` patterns:
  44     let mut v = vec![N(0), N(1), N(2), N(3), N(4)];
  45     let mut vc = (0..=4).collect::<Vec<u8>>();
  46
  47     let [..] = v[..]; // Always matches.
  48     m!(v[..], [N(0), ref sub @ .., N(4)] => c!(sub, &[N], n![1, 2, 3]));
  49     m!(v[..], [N(0), ref sub @ ..] => c!(sub, &[N], n![1, 2, 3, 4]));
  50     m!(v[..], [ref sub @ .., N(4)] => c!(sub, &[N], n![0, 1, 2, 3]));
  51     m!(v[..], [ref sub @ .., _, _, _, _, _] => c!(sub, &[N], &n![] as &[N]));
  52     m!(v[..], [_, _, _, _, _, ref sub @ ..] => c!(sub, &[N], &n![] as &[N]));
  53     m!(vc[..], [x, .., y] => c!((x, y), (u8, u8), (0, 4)));
  54
  55     // Matching slices using `ref mut` patterns:
  56     let [..] = v[..]; // Always matches.
  57     m!(v[..], [N(0), ref mut sub @ .., N(4)] => c!(sub, &mut [N], n![1, 2, 3]));
  58     m!(v[..], [N(0), ref mut sub @ ..] => c!(sub, &mut [N], n![1, 2, 3, 4]));
  59     m!(v[..], [ref mut sub @ .., N(4)] => c!(sub, &mut [N], n![0, 1, 2, 3]));
  60     m!(v[..], [ref mut sub @ .., _, _, _, _, _] => c!(sub, &mut [N], &mut n![] as &mut [N]));
  61     m!(v[..], [_, _, _, _, _, ref mut sub @ ..] => c!(sub, &mut [N], &mut n![] as &mut [N]));
  62     m!(vc[..], [x, .., y] => c!((x, y), (u8, u8), (0, 4)));
  63
  64     // Matching slices using default binding modes (&):
  65     let [..] = &v[..]; // Always matches.
  66     m!(&v[..], [N(0), sub @ .., N(4)] => c!(sub, &[N], n![1, 2, 3]));
  67     m!(&v[..], [N(0), sub @ ..] => c!(sub, &[N], n![1, 2, 3, 4]));
  68     m!(&v[..], [sub @ .., N(4)] => c!(sub, &[N], n![0, 1, 2, 3]));
  69     m!(&v[..], [sub @ .., _, _, _, _, _] => c!(sub, &[N], &n![] as &[N]));
  70     m!(&v[..], [_, _, _, _, _, sub @ ..] => c!(sub, &[N], &n![] as &[N]));
  71     m!(&vc[..], [x, .., y] => c!((x, y), (&u8, &u8), (&0, &4)));
  72
  73     // Matching slices using default binding modes (&mut):
  74     let [..] = &mut v[..]; // Always matches.
  75     m!(&mut v[..], [N(0), sub @ .., N(4)] => c!(sub, &mut [N], n![1, 2, 3]));
  76     m!(&mut v[..], [N(0), sub @ ..] => c!(sub, &mut [N], n![1, 2, 3, 4]));
  77     m!(&mut v[..], [sub @ .., N(4)] => c!(sub, &mut [N], n![0, 1, 2, 3]));
  78     m!(&mut v[..], [sub @ .., _, _, _, _, _] => c!(sub, &mut [N], &mut n![] as &mut [N]));
  79     m!(&mut v[..], [_, _, _, _, _, sub @ ..] => c!(sub, &mut [N], &mut n![] as &mut [N]));
  80     m!(&mut vc[..], [x, .., y] => c!((x, y), (&mut u8, &mut u8), (&mut 0, &mut 4)));
  81 }
  82
  83 fn arrays() {
  84     let mut v = n![0, 1, 2, 3, 4];
  85     let vc = [0, 1, 2, 3, 4];
  86
  87     // Matching arrays by value:
  88     m!(v.clone(), [N(0), sub @ .., N(4)] => c!(sub, [N; 3], n![1, 2, 3]));
  89     m!(v.clone(), [N(0), sub @ ..] => c!(sub, [N; 4], n![1, 2, 3, 4]));
  90     m!(v.clone(), [sub @ .., N(4)] => c!(sub, [N; 4], n![0, 1, 2, 3]));
  91     m!(v.clone(), [sub @ .., _, _, _, _, _] => c!(sub, [N; 0], n![] as [N; 0]));
  92     m!(v.clone(), [_, _, _, _, _, sub @ ..] => c!(sub, [N; 0], n![] as [N; 0]));
  93     m!(v.clone(), [x, .., y] => c!((x, y), (N, N), (N(0), N(4))));
  94     m!(v.clone(), [..] => ());
  95
  96     // Matching arrays by ref patterns:
  97     m!(v, [N(0), ref sub @ .., N(4)] => c!(sub, &[N; 3], &n![1, 2, 3]));
  98     m!(v, [N(0), ref sub @ ..] => c!(sub, &[N; 4], &n![1, 2, 3, 4]));
  99     m!(v, [ref sub @ .., N(4)] => c!(sub, &[N; 4], &n![0, 1, 2, 3]));
 100     m!(v, [ref sub @ .., _, _, _, _, _] => c!(sub, &[N; 0], &n![] as &[N; 0]));
 101     m!(v, [_, _, _, _, _, ref sub @ ..] => c!(sub, &[N; 0], &n![] as &[N; 0]));
 102     m!(vc, [x, .., y] => c!((x, y), (u8, u8), (0, 4)));
 103
 104     // Matching arrays by ref mut patterns:
 105     m!(v, [N(0), ref mut sub @ .., N(4)] => c!(sub, &mut [N; 3], &mut n![1, 2, 3]));
 106     m!(v, [N(0), ref mut sub @ ..] => c!(sub, &mut [N; 4], &mut n![1, 2, 3, 4]));
 107     m!(v, [ref mut sub @ .., N(4)] => c!(sub, &mut [N; 4], &mut n![0, 1, 2, 3]));
 108     m!(v, [ref mut sub @ .., _, _, _, _, _] => c!(sub, &mut [N; 0], &mut n![] as &mut [N; 0]));
 109     m!(v, [_, _, _, _, _, ref mut sub @ ..] => c!(sub, &mut [N; 0], &mut n![] as &mut [N; 0]));
 110
 111     // Matching arrays by default binding modes (&):
 112     m!(&v, [N(0), sub @ .., N(4)] => c!(sub, &[N; 3], &n![1, 2, 3]));
 113     m!(&v, [N(0), sub @ ..] => c!(sub, &[N; 4], &n![1, 2, 3, 4]));
 114     m!(&v, [sub @ .., N(4)] => c!(sub, &[N; 4], &n![0, 1, 2, 3]));
 115     m!(&v, [sub @ .., _, _, _, _, _] => c!(sub, &[N; 0], &n![] as &[N; 0]));
 116     m!(&v, [_, _, _, _, _, sub @ ..] => c!(sub, &[N; 0], &n![] as &[N; 0]));
 117     m!(&v, [..] => ());
 118     m!(&v, [x, .., y] => c!((x, y), (&N, &N), (&N(0), &N(4))));
 119
 120     // Matching arrays by default binding modes (&mut):
 121     m!(&mut v, [N(0), sub @ .., N(4)] => c!(sub, &mut [N; 3], &mut n![1, 2, 3]));
 122     m!(&mut v, [N(0), sub @ ..] => c!(sub, &mut [N; 4], &mut n![1, 2, 3, 4]));
 123     m!(&mut v, [sub @ .., N(4)] => c!(sub, &mut [N; 4], &mut n![0, 1, 2, 3]));
 124     m!(&mut v, [sub @ .., _, _, _, _, _] => c!(sub, &mut [N; 0], &mut n![] as &[N; 0]));
 125     m!(&mut v, [_, _, _, _, _, sub @ ..] => c!(sub, &mut [N; 0], &mut n![] as &[N; 0]));
 126     m!(&mut v, [..] => ());
 127     m!(&mut v, [x, .., y] => c!((x, y), (&mut N, &mut N), (&mut N(0), &mut N(4))));
 128 }