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

72 lines
1.4 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,
E0013,
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,
E0140,
E0152,
E0153,
Forbid extern statics from appearing in patterns Fixes #16149.
2014-08-17 15:10:25 -05:00
E0157,
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,
Support parenthesized paths `Foo(A,B) -> C` that expand to `Foo<(A,B),C>`. These paths also bind anonymous regions (or will, once HRTB is fully working). Fixes #18423.
2014-11-03 20:52:52 -06:00
E0166,
Fix an ICE when using struct patterns with traits Fixes #18986.
2014-11-16 13:55:17 -06:00
E0167,
Make it an error to use parenthetical notation with something other than a trait type.
2014-11-15 15:53:07 -06:00
E0168,
Implement the new parsing rules for types in the parser, modifying the AST appropriately.
2014-11-20 14:05:29 -06:00
E0169,
E0170,
More test fixes and rebase conflicts!
2014-11-26 13:17:23 -06:00
E0171,
Add support for equality constraints on associated types
2014-11-28 22:08:30 -06:00
E0172,
E0173,
E0174,
E0177,
Reviewer comments
2014-12-02 17:03:02 -06:00
E0178
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
}
Reference in New Issue Copy Permalink