mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
cf629e7cfa
rust/src/librustc/diagnostics.rs

61 lines
1.3 KiB
Rust
Raw Normal View History

Add scaffolding for assigning alpha-numeric codes to rustc diagnostics
2014-07-01 11:39:41 -05:00
// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
Unify non-snake-case lints and non-uppercase statics lints This unifies the `non_snake_case_functions` and `uppercase_variables` lints into one lint, `non_snake_case`. It also now checks for non-snake-case modules. This also extends the non-camel-case types lint to check type parameters, and merges the `non_uppercase_pattern_statics` lint into the `non_uppercase_statics` lint. Because the `uppercase_variables` lint is now part of the `non_snake_case` lint, all non-snake-case variables that start with lowercase characters (such as `fooBar`) will now trigger the `non_snake_case` lint. New code should be updated to use the new `non_snake_case` lint instead of the previous `non_snake_case_functions` and `uppercase_variables` lints. All use of the `non_uppercase_pattern_statics` should be replaced with the `non_uppercase_statics` lint. Any code that previously contained non-snake-case module or variable names should be updated to use snake case names or disable the `non_snake_case` lint. Any code with non-camel-case type parameters should be changed to use camel case or disable the `non_camel_case_types` lint. [breaking-change]
2014-07-18 07:45:17 -05:00
#![allow(non_snake_case)]
librustc: Always parse `macro!()`/`macro![]` as expressions if not followed by a semicolon. This allows code like `vec![1i, 2, 3].len();` to work. This breaks code that uses macros as statements without putting semicolons after them, such as: fn main() { ... assert!(a == b) assert!(c == d) println(...); } It also breaks code that uses macros as items without semicolons: local_data_key!(foo) fn main() { println("hello world") } Add semicolons to fix this code. Those two examples can be fixed as follows: fn main() { ... assert!(a == b); assert!(c == d); println(...); } local_data_key!(foo); fn main() { println("hello world") } RFC #378. Closes #18635. [breaking-change]
2014-11-14 11:18:10 -06:00
register_diagnostic! { E0001, r##"
Add scaffolding for assigning alpha-numeric codes to rustc diagnostics
2014-07-01 11:39:41 -05:00
This error suggests that the expression arm corresponding to the noted pattern
will never be reached as for all possible values of the expression being matched,
one of the preceeding patterns will match.
This means that perhaps some of the preceeding patterns are too general, this
one is too specific or the ordering is incorrect.
librustc: Always parse `macro!()`/`macro![]` as expressions if not followed by a semicolon. This allows code like `vec![1i, 2, 3].len();` to work. This breaks code that uses macros as statements without putting semicolons after them, such as: fn main() { ... assert!(a == b) assert!(c == d) println(...); } It also breaks code that uses macros as items without semicolons: local_data_key!(foo) fn main() { println("hello world") } Add semicolons to fix this code. Those two examples can be fixed as follows: fn main() { ... assert!(a == b); assert!(c == d); println(...); } local_data_key!(foo); fn main() { println("hello world") } RFC #378. Closes #18635. [breaking-change]
2014-11-14 11:18:10 -06:00
"## }
Convert a first batch of diagnostics to have error codes
2014-07-11 11:54:01 -05:00
librustc: Always parse `macro!()`/`macro![]` as expressions if not followed by a semicolon. This allows code like `vec![1i, 2, 3].len();` to work. This breaks code that uses macros as statements without putting semicolons after them, such as: fn main() { ... assert!(a == b) assert!(c == d) println(...); } It also breaks code that uses macros as items without semicolons: local_data_key!(foo) fn main() { println("hello world") } Add semicolons to fix this code. Those two examples can be fixed as follows: fn main() { ... assert!(a == b); assert!(c == d); println(...); } local_data_key!(foo); fn main() { println("hello world") } RFC #378. Closes #18635. [breaking-change]
2014-11-14 11:18:10 -06:00
register_diagnostics! {
Convert a first batch of diagnostics to have error codes
2014-07-11 11:54:01 -05:00
E0002,
E0003,
E0004,
E0005,
E0006,
E0007,
E0008,
E0009,
E0010,
E0011,
E0012,
E0014,
E0015,
E0016,
E0017,
Prevent pointer -> int casts in constexprs These cause issues, as addresses aren't fixed at compile-time. Fixes #18294
2014-10-25 12:18:32 -05:00
E0018,
Convert a first batch of diagnostics to have error codes
2014-07-11 11:54:01 -05:00
E0019,
E0020,
E0022,
Assign more diagnostic codes
2014-07-17 12:56:37 -05:00
E0109,
E0110,
E0133,
E0134,
E0135,
E0136,
E0137,
E0138,
E0139,
E0152,
Detect a traits being used as structs in check_expr_with_unifier Fixes #16750 Fixes #15812
2014-08-29 21:24:06 -05:00
E0158,
Temporarily remove the description for the diagnostic E0162 It turns out that adding new diagnostics is causing link failures in runpass-full-deps tests. Further investigation pending.
2014-09-30 11:52:40 -05:00
E0161,
Fix handling of struct variants in a couple of places Fixes #17405. Fixes #17518. Fixes #17800.
2014-09-20 14:25:25 -05:00
E0162,
Remove ty_bot from the type system We now instead use a fresh variable for expressions that diverge.
2014-10-24 14:14:37 -05:00
E0165,
Make error code registration work again. #19624
2015-01-16 17:54:58 -06:00
E0170
librustc: Always parse `macro!()`/`macro![]` as expressions if not followed by a semicolon. This allows code like `vec![1i, 2, 3].len();` to work. This breaks code that uses macros as statements without putting semicolons after them, such as: fn main() { ... assert!(a == b) assert!(c == d) println(...); } It also breaks code that uses macros as items without semicolons: local_data_key!(foo) fn main() { println("hello world") } Add semicolons to fix this code. Those two examples can be fixed as follows: fn main() { ... assert!(a == b); assert!(c == d); println(...); } local_data_key!(foo); fn main() { println("hello world") } RFC #378. Closes #18635. [breaking-change]
2014-11-14 11:18:10 -06:00
}
Make error code registration work again. #19624
2015-01-16 17:54:58 -06:00
__build_diagnostic_array! { DIAGNOSTICS }
Reference in New Issue Copy Permalink