]>
Commit | Line | Data |
---|---|---|
1a4d82fc JJ |
1 | // Copyright 2014 The Rust Project Developers. See the COPYRIGHT |
2 | // file at the top-level directory of this distribution and at | |
3 | // http://rust-lang.org/COPYRIGHT. | |
4 | // | |
5 | // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or | |
6 | // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license | |
7 | // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your | |
8 | // option. This file may not be copied, modified, or distributed | |
9 | // except according to those terms. | |
10 | ||
11 | #![allow(non_snake_case)] | |
12 | ||
9346a6ac AL |
13 | // Error messages for EXXXX errors. |
14 | // Each message should start and end with a new line, and be wrapped to 80 characters. | |
15 | // In vim you can `:set tw=80` and use `gq` to wrap paragraphs. Use `:set tw=0` to disable. | |
85aaf69f | 16 | register_long_diagnostics! { |
1a4d82fc | 17 | |
9346a6ac AL |
18 | E0001: r##" |
19 | This error suggests that the expression arm corresponding to the noted pattern | |
20 | will never be reached as for all possible values of the expression being | |
21 | matched, one of the preceding patterns will match. | |
22 | ||
23 | This means that perhaps some of the preceding patterns are too general, this one | |
24 | is too specific or the ordering is incorrect. | |
25 | "##, | |
26 | ||
27 | E0002: r##" | |
28 | This error indicates that an empty match expression is illegal because the type | |
29 | it is matching on is non-empty (there exist values of this type). In safe code | |
30 | it is impossible to create an instance of an empty type, so empty match | |
31 | expressions are almost never desired. This error is typically fixed by adding | |
32 | one or more cases to the match expression. | |
33 | ||
34 | An example of an empty type is `enum Empty { }`. | |
35 | "##, | |
36 | ||
37 | E0003: r##" | |
38 | Not-a-Number (NaN) values cannot be compared for equality and hence can never | |
39 | match the input to a match expression. To match against NaN values, you should | |
40 | instead use the `is_nan` method in a guard, as in: x if x.is_nan() => ... | |
41 | "##, | |
42 | ||
43 | E0004: r##" | |
44 | This error indicates that the compiler cannot guarantee a matching pattern for | |
45 | one or more possible inputs to a match expression. Guaranteed matches are | |
46 | required in order to assign values to match expressions, or alternatively, | |
47 | determine the flow of execution. | |
48 | ||
49 | If you encounter this error you must alter your patterns so that every possible | |
50 | value of the input type is matched. For types with a small number of variants | |
51 | (like enums) you should probably cover all cases explicitly. Alternatively, the | |
52 | underscore `_` wildcard pattern can be added after all other patterns to match | |
53 | "anything else". | |
54 | "##, | |
55 | ||
56 | // FIXME: Remove duplication here? | |
57 | E0005: r##" | |
58 | Patterns used to bind names must be irrefutable, that is, they must guarantee that a | |
59 | name will be extracted in all cases. If you encounter this error you probably need | |
60 | to use a `match` or `if let` to deal with the possibility of failure. | |
61 | "##, | |
62 | ||
63 | E0006: r##" | |
64 | Patterns used to bind names must be irrefutable, that is, they must guarantee that a | |
65 | name will be extracted in all cases. If you encounter this error you probably need | |
66 | to use a `match` or `if let` to deal with the possibility of failure. | |
67 | "##, | |
68 | ||
69 | E0007: r##" | |
70 | This error indicates that the bindings in a match arm would require a value to | |
71 | be moved into more than one location, thus violating unique ownership. Code like | |
72 | the following is invalid as it requires the entire Option<String> to be moved | |
73 | into a variable called `op_string` while simultaneously requiring the inner | |
74 | String to be moved into a variable called `s`. | |
75 | ||
76 | let x = Some("s".to_string()); | |
77 | match x { | |
78 | op_string @ Some(s) => ... | |
79 | None => ... | |
80 | } | |
81 | ||
82 | See also Error 303. | |
83 | "##, | |
84 | ||
85 | E0008: r##" | |
86 | Names bound in match arms retain their type in pattern guards. As such, if a | |
87 | name is bound by move in a pattern, it should also be moved to wherever it is | |
88 | referenced in the pattern guard code. Doing so however would prevent the name | |
89 | from being available in the body of the match arm. Consider the following: | |
90 | ||
91 | match Some("hi".to_string()) { | |
92 | Some(s) if s.len() == 0 => // use s. | |
93 | ... | |
94 | } | |
95 | ||
96 | The variable `s` has type String, and its use in the guard is as a variable of | |
97 | type String. The guard code effectively executes in a separate scope to the body | |
98 | of the arm, so the value would be moved into this anonymous scope and therefore | |
99 | become unavailable in the body of the arm. Although this example seems | |
100 | innocuous, the problem is most clear when considering functions that take their | |
101 | argument by value. | |
102 | ||
103 | match Some("hi".to_string()) { | |
104 | Some(s) if { drop(s); false } => (), | |
105 | Some(s) => // use s. | |
106 | ... | |
107 | } | |
108 | ||
109 | The value would be dropped in the guard then become unavailable not only in the | |
110 | body of that arm but also in all subsequent arms! The solution is to bind by | |
111 | reference when using guards or refactor the entire expression, perhaps by | |
112 | putting the condition inside the body of the arm. | |
113 | "##, | |
114 | ||
115 | E0162: r##" | |
116 | An if-let pattern attempts to match the pattern, and enters the body if the | |
117 | match was succesful. If the match is irrefutable (when it cannot fail to match), | |
118 | use a regular `let`-binding instead. For instance: | |
119 | ||
120 | struct Irrefutable(i32); | |
121 | let irr = Irrefutable(0); | |
122 | ||
123 | // This fails to compile because the match is irrefutable. | |
124 | if let Irrefutable(x) = irr { | |
125 | // This body will always be executed. | |
126 | foo(x); | |
127 | } | |
128 | ||
129 | // Try this instead: | |
130 | let Irrefutable(x) = irr; | |
131 | foo(x); | |
85aaf69f SL |
132 | "##, |
133 | ||
9346a6ac AL |
134 | E0165: r##" |
135 | A while-let pattern attempts to match the pattern, and enters the body if the | |
136 | match was succesful. If the match is irrefutable (when it cannot fail to match), | |
137 | use a regular `let`-binding inside a `loop` instead. For instance: | |
138 | ||
139 | struct Irrefutable(i32); | |
140 | let irr = Irrefutable(0); | |
141 | ||
142 | // This fails to compile because the match is irrefutable. | |
143 | while let Irrefutable(x) = irr { | |
144 | ... | |
145 | } | |
146 | ||
147 | // Try this instead: | |
148 | loop { | |
149 | let Irrefutable(x) = irr; | |
150 | ... | |
151 | } | |
85aaf69f SL |
152 | "##, |
153 | ||
9346a6ac AL |
154 | E0297: r##" |
155 | Patterns used to bind names must be irrefutable. That is, they must guarantee | |
156 | that a name will be extracted in all cases. Instead of pattern matching the | |
157 | loop variable, consider using a `match` or `if let` inside the loop body. For | |
158 | instance: | |
159 | ||
160 | // This fails because `None` is not covered. | |
161 | for Some(x) in xs { | |
162 | ... | |
163 | } | |
164 | ||
165 | // Match inside the loop instead: | |
166 | for item in xs { | |
167 | match item { | |
168 | Some(x) => ... | |
169 | None => ... | |
170 | } | |
171 | } | |
85aaf69f | 172 | |
9346a6ac AL |
173 | // Or use `if let`: |
174 | for item in xs { | |
175 | if let Some(x) = item { | |
176 | ... | |
177 | } | |
178 | } | |
85aaf69f SL |
179 | "##, |
180 | ||
9346a6ac AL |
181 | E0301: r##" |
182 | Mutable borrows are not allowed in pattern guards, because matching cannot have | |
183 | side effects. Side effects could alter the matched object or the environment | |
184 | on which the match depends in such a way, that the match would not be | |
185 | exhaustive. For instance, the following would not match any arm if mutable | |
186 | borrows were allowed: | |
187 | ||
188 | match Some(()) { | |
189 | None => { }, | |
190 | option if option.take().is_none() => { /* impossible, option is `Some` */ }, | |
191 | Some(_) => { } // When the previous match failed, the option became `None`. | |
192 | } | |
193 | "##, | |
194 | ||
195 | E0302: r##" | |
196 | Assignments are not allowed in pattern guards, because matching cannot have | |
197 | side effects. Side effects could alter the matched object or the environment | |
198 | on which the match depends in such a way, that the match would not be | |
199 | exhaustive. For instance, the following would not match any arm if assignments | |
200 | were allowed: | |
201 | ||
202 | match Some(()) { | |
203 | None => { }, | |
204 | option if { option = None; false } { }, | |
205 | Some(_) => { } // When the previous match failed, the option became `None`. | |
206 | } | |
85aaf69f SL |
207 | "##, |
208 | ||
9346a6ac AL |
209 | E0303: r##" |
210 | In certain cases it is possible for sub-bindings to violate memory safety. | |
211 | Updates to the borrow checker in a future version of Rust may remove this | |
212 | restriction, but for now patterns must be rewritten without sub-bindings. | |
213 | ||
214 | // Code like this... | |
215 | match Some(5) { | |
216 | ref op_num @ Some(num) => ... | |
217 | None => ... | |
218 | } | |
219 | ||
220 | // ... should be updated to code like this. | |
221 | match Some(5) { | |
222 | Some(num) => { | |
223 | let op_num = &Some(num); | |
224 | ... | |
225 | } | |
226 | None => ... | |
227 | } | |
228 | ||
229 | See also https://github.com/rust-lang/rust/issues/14587 | |
85aaf69f | 230 | "## |
9346a6ac | 231 | |
85aaf69f | 232 | } |
1a4d82fc JJ |
233 | |
234 | register_diagnostics! { | |
1a4d82fc JJ |
235 | E0009, |
236 | E0010, | |
237 | E0011, | |
238 | E0012, | |
239 | E0013, | |
240 | E0014, | |
241 | E0015, | |
242 | E0016, | |
243 | E0017, | |
244 | E0018, | |
245 | E0019, | |
246 | E0020, | |
247 | E0022, | |
c34b1796 AL |
248 | E0079, // enum variant: expected signed integer constant |
249 | E0080, // enum variant: constant evaluation error | |
1a4d82fc JJ |
250 | E0109, |
251 | E0110, | |
252 | E0133, | |
253 | E0134, | |
254 | E0135, | |
255 | E0136, | |
256 | E0137, | |
257 | E0138, | |
258 | E0139, | |
1a4d82fc | 259 | E0152, |
1a4d82fc JJ |
260 | E0158, |
261 | E0161, | |
1a4d82fc | 262 | E0170, |
85aaf69f SL |
263 | E0261, // use of undeclared lifetime name |
264 | E0262, // illegal lifetime parameter name | |
265 | E0263, // lifetime name declared twice in same scope | |
266 | E0264, // unknown external lang item | |
267 | E0265, // recursive constant | |
268 | E0266, // expected item | |
269 | E0267, // thing inside of a closure | |
270 | E0268, // thing outside of a loop | |
271 | E0269, // not all control paths return a value | |
272 | E0270, // computation may converge in a function marked as diverging | |
273 | E0271, // type mismatch resolving | |
274 | E0272, // rustc_on_unimplemented attribute refers to non-existent type parameter | |
275 | E0273, // rustc_on_unimplemented must have named format arguments | |
276 | E0274, // rustc_on_unimplemented must have a value | |
277 | E0275, // overflow evaluating requirement | |
278 | E0276, // requirement appears on impl method but not on corresponding trait method | |
279 | E0277, // trait is not implemented for type | |
280 | E0278, // requirement is not satisfied | |
281 | E0279, // requirement is not satisfied | |
282 | E0280, // requirement is not satisfied | |
283 | E0281, // type implements trait but other trait is required | |
284 | E0282, // unable to infer enough type information about | |
285 | E0283, // cannot resolve type | |
286 | E0284, // cannot resolve type | |
287 | E0285, // overflow evaluation builtin bounds | |
288 | E0296, // malformed recursion limit attribute | |
85aaf69f SL |
289 | E0298, // mismatched types between arms |
290 | E0299, // mismatched types between arms | |
291 | E0300, // unexpanded macro | |
85aaf69f SL |
292 | E0304, // expected signed integer constant |
293 | E0305, // expected constant | |
294 | E0306, // expected positive integer for repeat count | |
295 | E0307, // expected constant integer for repeat count | |
296 | E0308, | |
297 | E0309, // thing may not live long enough | |
298 | E0310, // thing may not live long enough | |
299 | E0311, // thing may not live long enough | |
300 | E0312, // lifetime of reference outlives lifetime of borrowed content | |
301 | E0313, // lifetime of borrowed pointer outlives lifetime of captured variable | |
302 | E0314, // closure outlives stack frame | |
303 | E0315, // cannot invoke closure outside of its lifetime | |
c34b1796 AL |
304 | E0316, // nested quantification of lifetimes |
305 | E0370 // discriminant overflow | |
1a4d82fc | 306 | } |
85aaf69f SL |
307 | |
308 | __build_diagnostic_array! { DIAGNOSTICS } |