src/test/ui/or-patterns/or-patterns-syntactic-pass.rs

   1 // Here we test all the places `|` is *syntactically* allowed.
   2 // This is not a semantic test. We only test parsing.
   3
   4 // check-pass
   5
   6 #![feature(or_patterns)]
   7 #![feature(box_patterns)]
   8
   9 fn main() {}
  10
  11 // Test the `pat` macro fragment parser:
  12 macro_rules! accept_pat {
  13     ($p:pat) => {}
  14 }
  15
  16 accept_pat!((p | q));
  17 accept_pat!((p | q,));
  18 accept_pat!(TS(p | q));
  19 accept_pat!(NS { f: p | q });
  20 accept_pat!([p | q]);
  21
  22 // Non-macro tests:
  23
  24 #[cfg(FALSE)]
  25 fn or_patterns() {
  26     // Top level of `let`:
  27     let | A | B;
  28     let A | B;
  29     let A | B: u8;
  30     let A | B = 0;
  31     let A | B: u8 = 0;
  32
  33     // Top level of `for`:
  34     for | A | B in 0 {}
  35     for A | B in 0 {}
  36
  37     // Top level of `while`:
  38     while let | A | B = 0 {}
  39     while let A | B = 0 {}
  40
  41     // Top level of `if`:
  42     if let | A | B = 0 {}
  43     if let A | B = 0 {}
  44
  45     // Top level of `match` arms:
  46     match 0 {
  47         | A | B => {},
  48         A | B => {},
  49     }
  50
  51     // Functions:
  52     fn fun((A | B): _) {}
  53
  54     // Lambdas:
  55     let _ = |(A | B): u8| ();
  56
  57     // Parenthesis and tuple patterns:
  58     let (A | B);
  59     let (A | B,);
  60
  61     // Tuple struct patterns:
  62     let A(B | C);
  63     let E::V(B | C);
  64
  65     // Struct patterns:
  66     let S { f1: B | C, f2 };
  67     let E::V { f1: B | C, f2 };
  68
  69     // Slice patterns:
  70     let [A | B, .. | ..];
  71
  72     // These bind as `(prefix p) | q` as opposed to `prefix (p | q)`:
  73     let box 0 | 1; // Unstable; we *can* the precedence if we want.
  74     let &0 | 1;
  75     let &mut 0 | 1;
  76     let x @ 0 | 1;
  77     let ref x @ 0 | 1;
  78     let ref mut x @ 0 | 1;
  79 }