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

   1 // Test some cases where or-patterns may ostensibly be allowed but are in fact not.
   2 // This is not a semantic test. We only test parsing.
   3
   4 #![feature(or_patterns)]
   5 //~^ WARN the feature `or_patterns` is incomplete and may cause the compiler to crash
   6
   7 fn main() {}
   8
   9 // Test the `pat` macro fragment parser:
  10 macro_rules! accept_pat {
  11     ($p:pat) => {}
  12 }
  13
  14 accept_pat!(p | q); //~ ERROR no rules expected the token `|`
  15 accept_pat!(| p | q); //~ ERROR no rules expected the token `|`
  16
  17 // Non-macro tests:
  18
  19 enum E { A, B }
  20 use E::*;
  21
  22 fn no_top_level_or_patterns() {
  23     // We do *not* allow or-patterns at the top level of lambdas...
  24     let _ = |A | B: E| (); //~ ERROR binary operation `|` cannot be applied to type `E`
  25     //           -------- This looks like an or-pattern but is in fact `|A| (B: E | ())`.
  26
  27     // ...and for now neither do we allow or-patterns at the top level of functions.
  28     fn fun1(A | B: E) {} //~ ERROR an or-pattern parameter must be wrapped in parenthesis
  29
  30     fn fun2(| A | B: E) {}
  31     //~^ ERROR a leading `|` is not allowed in a parameter pattern
  32     //~| ERROR an or-pattern parameter must be wrapped in parenthesis
  33 }
  34
  35 // We also do not allow a leading `|` when not in a top level position:
  36
  37 fn no_leading_inner() {
  38     struct TS(E);
  39     struct NS { f: E }
  40
  41     let ( | A | B) = E::A; //~ ERROR a leading `|` is only allowed in a top-level pattern
  42     let ( | A | B,) = (E::B,); //~ ERROR a leading `|` is only allowed in a top-level pattern
  43     let [ | A | B ] = [E::A]; //~ ERROR a leading `|` is only allowed in a top-level pattern
  44     let TS( | A | B ); //~ ERROR a leading `|` is only allowed in a top-level pattern
  45     let NS { f: | A | B }; //~ ERROR a leading `|` is only allowed in a top-level pattern
  46
  47     let ( || A | B) = E::A; //~ ERROR a leading `|` is only allowed in a top-level pattern
  48     let [ || A | B ] = [E::A]; //~ ERROR a leading `|` is only allowed in a top-level pattern
  49     let TS( || A | B ); //~ ERROR a leading `|` is only allowed in a top-level pattern
  50     let NS { f: || A | B }; //~ ERROR a leading `|` is only allowed in a top-level pattern
  51
  52     let recovery_witness: String = 0; //~ ERROR mismatched types
  53 }