summary refs log tree commit diff
path: root/src/test/ui/or-patterns/or-patterns-syntactic-fail.stderr
blob: b6ff39d64d6dbb4997820db24725350e0f54eb99 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
error: an or-pattern parameter must be wrapped in parenthesis
  --> $DIR/or-patterns-syntactic-fail.rs:28:13
   |
LL |     fn fun1(A | B: E) {}
   |             ^^^^^ help: wrap the pattern in parenthesis: `(A | B)`

error: a leading `|` is not allowed in a parameter pattern
  --> $DIR/or-patterns-syntactic-fail.rs:30:13
   |
LL |     fn fun2(| A | B: E) {}
   |             ^ help: remove the `|`

error: an or-pattern parameter must be wrapped in parenthesis
  --> $DIR/or-patterns-syntactic-fail.rs:30:15
   |
LL |     fn fun2(| A | B: E) {}
   |               ^^^^^ help: wrap the pattern in parenthesis: `(A | B)`

error: a leading `|` is only allowed in a top-level pattern
  --> $DIR/or-patterns-syntactic-fail.rs:41:11
   |
LL |     let ( | A | B) = E::A;
   |           ^ help: remove the `|`

error: a leading `|` is only allowed in a top-level pattern
  --> $DIR/or-patterns-syntactic-fail.rs:42:11
   |
LL |     let ( | A | B,) = (E::B,);
   |           ^ help: remove the `|`

error: a leading `|` is only allowed in a top-level pattern
  --> $DIR/or-patterns-syntactic-fail.rs:43:11
   |
LL |     let [ | A | B ] = [E::A];
   |           ^ help: remove the `|`

error: a leading `|` is only allowed in a top-level pattern
  --> $DIR/or-patterns-syntactic-fail.rs:44:13
   |
LL |     let TS( | A | B );
   |             ^ help: remove the `|`

error: a leading `|` is only allowed in a top-level pattern
  --> $DIR/or-patterns-syntactic-fail.rs:45:17
   |
LL |     let NS { f: | A | B };
   |                 ^ help: remove the `|`

error: a leading `|` is only allowed in a top-level pattern
  --> $DIR/or-patterns-syntactic-fail.rs:47:11
   |
LL |     let ( || A | B) = E::A;
   |           ^^ help: remove the `||`
   |
   = note: alternatives in or-patterns are separated with `|`, not `||`

error: a leading `|` is only allowed in a top-level pattern
  --> $DIR/or-patterns-syntactic-fail.rs:48:11
   |
LL |     let [ || A | B ] = [E::A];
   |           ^^ help: remove the `||`
   |
   = note: alternatives in or-patterns are separated with `|`, not `||`

error: a leading `|` is only allowed in a top-level pattern
  --> $DIR/or-patterns-syntactic-fail.rs:49:13
   |
LL |     let TS( || A | B );
   |             ^^ help: remove the `||`
   |
   = note: alternatives in or-patterns are separated with `|`, not `||`

error: a leading `|` is only allowed in a top-level pattern
  --> $DIR/or-patterns-syntactic-fail.rs:50:17
   |
LL |     let NS { f: || A | B };
   |                 ^^ help: remove the `||`
   |
   = note: alternatives in or-patterns are separated with `|`, not `||`

error: no rules expected the token `|`
  --> $DIR/or-patterns-syntactic-fail.rs:14:15
   |
LL | macro_rules! accept_pat {
   | ----------------------- when calling this macro
...
LL | accept_pat!(p | q);
   |               ^ no rules expected this token in macro call

error: no rules expected the token `|`
  --> $DIR/or-patterns-syntactic-fail.rs:15:13
   |
LL | macro_rules! accept_pat {
   | ----------------------- when calling this macro
...
LL | accept_pat!(| p | q);
   |             ^ no rules expected this token in macro call

warning: the feature `or_patterns` is incomplete and may cause the compiler to crash
  --> $DIR/or-patterns-syntactic-fail.rs:4:12
   |
LL | #![feature(or_patterns)]
   |            ^^^^^^^^^^^
   |
   = note: `#[warn(incomplete_features)]` on by default

error[E0369]: binary operation `|` cannot be applied to type `E`
  --> $DIR/or-patterns-syntactic-fail.rs:24:22
   |
LL |     let _ = |A | B: E| ();
   |                  ----^ -- ()
   |                  |
   |                  E
   |
   = note: an implementation of `std::ops::BitOr` might be missing for `E`

error[E0308]: mismatched types
  --> $DIR/or-patterns-syntactic-fail.rs:52:36
   |
LL |     let recovery_witness: String = 0;
   |                           ------   ^
   |                           |        |
   |                           |        expected struct `std::string::String`, found integer
   |                           |        help: try using a conversion method: `0.to_string()`
   |                           expected due to this

error: aborting due to 16 previous errors

Some errors have detailed explanations: E0308, E0369.
For more information about an error, try `rustc --explain E0308`.