nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2025-05-05 14:37:37 +00:00
Code Issues Packages Projects Releases Wiki Activity
b58a0061a3
rust/src/librustc_lint/lib.rs

408 lines
17 KiB
Rust
Raw Normal View History

Various minor/cosmetic improvements to code
2018-11-27 02:59:49 +00:00
//! # Lints in the Rust compiler
Update docs for rustc_lint crateification.
2015-02-25 12:03:44 +00:00
//!
//! This currently only contains the definitions and implementations
//! of most of the lints that `rustc` supports directly, it does not
//! contain the infrastructure for defining/registering lints. That is
move librustc/plugin to librustc_plugin this is a [breaking-change] to all plugin authors - sorry
2015-11-22 20:14:09 +00:00
//! available in `rustc::lint` and `rustc_plugin` respectively.
Separate most of rustc::lint::builtin into a separate crate. This pulls out the implementations of most built-in lints into a separate crate, to reduce edit-compile-test iteration times with librustc_lint and increase parallelism. This should enable lints to be refactored, added and deleted much more easily as it slashes the edit-compile cycle to get a minimal working compiler to test with (`make rustc-stage1`) from librustc -> librustc_typeck -> ... -> librustc_driver -> libcore -> ... -> libstd to librustc_lint -> librustc_driver -> libcore -> ... libstd which is significantly faster, mainly due to avoiding the librustc build itself. The intention would be to move as much as possible of the infrastructure into the crate too, but the plumbing is deeply intertwined with librustc itself at the moment. Also, there are lints for which diagnostics are registered directly in the compiler code, not in their own crate traversal, and their definitions have to remain in librustc. This is a [breaking-change] for direct users of the compiler APIs: callers of `rustc::session::build_session` or `rustc::session::build_session_` need to manually call `rustc_lint::register_builtins` on their return value. This should make #22206 easier.
2015-02-25 11:44:44 +00:00
//!
Various minor/cosmetic improvements to code
2018-11-27 02:59:49 +00:00
//! ## Note
Separate most of rustc::lint::builtin into a separate crate. This pulls out the implementations of most built-in lints into a separate crate, to reduce edit-compile-test iteration times with librustc_lint and increase parallelism. This should enable lints to be refactored, added and deleted much more easily as it slashes the edit-compile cycle to get a minimal working compiler to test with (`make rustc-stage1`) from librustc -> librustc_typeck -> ... -> librustc_driver -> libcore -> ... -> libstd to librustc_lint -> librustc_driver -> libcore -> ... libstd which is significantly faster, mainly due to avoiding the librustc build itself. The intention would be to move as much as possible of the infrastructure into the crate too, but the plumbing is deeply intertwined with librustc itself at the moment. Also, there are lints for which diagnostics are registered directly in the compiler code, not in their own crate traversal, and their definitions have to remain in librustc. This is a [breaking-change] for direct users of the compiler APIs: callers of `rustc::session::build_session` or `rustc::session::build_session_` need to manually call `rustc_lint::register_builtins` on their return value. This should make #22206 easier.
2015-02-25 11:44:44 +00:00
//!
//! This API is completely unstable and subject to change.
Remove images' url to make it work even without internet connection
2019-02-05 13:37:15 +00:00
#![doc(html_root_url = "https://doc.rust-lang.org/nightly/")]
Separate most of rustc::lint::builtin into a separate crate. This pulls out the implementations of most built-in lints into a separate crate, to reduce edit-compile-test iteration times with librustc_lint and increase parallelism. This should enable lints to be refactored, added and deleted much more easily as it slashes the edit-compile cycle to get a minimal working compiler to test with (`make rustc-stage1`) from librustc -> librustc_typeck -> ... -> librustc_driver -> libcore -> ... -> libstd to librustc_lint -> librustc_driver -> libcore -> ... libstd which is significantly faster, mainly due to avoiding the librustc build itself. The intention would be to move as much as possible of the infrastructure into the crate too, but the plumbing is deeply intertwined with librustc itself at the moment. Also, there are lints for which diagnostics are registered directly in the compiler code, not in their own crate traversal, and their definitions have to remain in librustc. This is a [breaking-change] for direct users of the compiler APIs: callers of `rustc::session::build_session` or `rustc::session::build_session_` need to manually call `rustc_lint::register_builtins` on their return value. This should make #22206 easier.
2015-02-25 11:44:44 +00:00
collections: Split the `collections` feature This commit also deprecates the `as_string` and `as_slice` free functions in the `string` and `vec` modules.
2015-06-09 21:39:23 +00:00
#![cfg_attr(test, feature(test))]
Separate most of rustc::lint::builtin into a separate crate. This pulls out the implementations of most built-in lints into a separate crate, to reduce edit-compile-test iteration times with librustc_lint and increase parallelism. This should enable lints to be refactored, added and deleted much more easily as it slashes the edit-compile cycle to get a minimal working compiler to test with (`make rustc-stage1`) from librustc -> librustc_typeck -> ... -> librustc_driver -> libcore -> ... -> libstd to librustc_lint -> librustc_driver -> libcore -> ... libstd which is significantly faster, mainly due to avoiding the librustc build itself. The intention would be to move as much as possible of the infrastructure into the crate too, but the plumbing is deeply intertwined with librustc itself at the moment. Also, there are lints for which diagnostics are registered directly in the compiler code, not in their own crate traversal, and their definitions have to remain in librustc. This is a [breaking-change] for direct users of the compiler APIs: callers of `rustc::session::build_session` or `rustc::session::build_session_` need to manually call `rustc_lint::register_builtins` on their return value. This should make #22206 easier.
2015-02-25 11:44:44 +00:00
#![feature(box_patterns)]
#![feature(box_syntax)]
Bump to 1.31.0 and bootstrap from 1.30 beta
2018-09-26 21:26:46 +00:00
#![feature(nll)]
Separate most of rustc::lint::builtin into a separate crate. This pulls out the implementations of most built-in lints into a separate crate, to reduce edit-compile-test iteration times with librustc_lint and increase parallelism. This should enable lints to be refactored, added and deleted much more easily as it slashes the edit-compile cycle to get a minimal working compiler to test with (`make rustc-stage1`) from librustc -> librustc_typeck -> ... -> librustc_driver -> libcore -> ... -> libstd to librustc_lint -> librustc_driver -> libcore -> ... libstd which is significantly faster, mainly due to avoiding the librustc build itself. The intention would be to move as much as possible of the infrastructure into the crate too, but the plumbing is deeply intertwined with librustc itself at the moment. Also, there are lints for which diagnostics are registered directly in the compiler code, not in their own crate traversal, and their definitions have to remain in librustc. This is a [breaking-change] for direct users of the compiler APIs: callers of `rustc::session::build_session` or `rustc::session::build_session_` need to manually call `rustc_lint::register_builtins` on their return value. This should make #22206 easier.
2015-02-25 11:44:44 +00:00
#![feature(rustc_diagnostic_macros)]
rustc: Remove #![unstable] annotation These are now no longer necessary with `-Z force-unstable-if-unmarked`
2017-05-08 21:36:44 +00:00
Fix recursion limits
2018-12-13 15:57:25 +00:00
#![recursion_limit="256"]
librustc_lint => 2018
2019-02-08 11:35:41 +00:00
#![deny(rust_2018_idioms)]
Separate most of rustc::lint::builtin into a separate crate. This pulls out the implementations of most built-in lints into a separate crate, to reduce edit-compile-test iteration times with librustc_lint and increase parallelism. This should enable lints to be refactored, added and deleted much more easily as it slashes the edit-compile cycle to get a minimal working compiler to test with (`make rustc-stage1`) from librustc -> librustc_typeck -> ... -> librustc_driver -> libcore -> ... -> libstd to librustc_lint -> librustc_driver -> libcore -> ... libstd which is significantly faster, mainly due to avoiding the librustc build itself. The intention would be to move as much as possible of the infrastructure into the crate too, but the plumbing is deeply intertwined with librustc itself at the moment. Also, there are lints for which diagnostics are registered directly in the compiler code, not in their own crate traversal, and their definitions have to remain in librustc. This is a [breaking-change] for direct users of the compiler APIs: callers of `rustc::session::build_session` or `rustc::session::build_session_` need to manually call `rustc_lint::register_builtins` on their return value. This should make #22206 easier.
2015-02-25 11:44:44 +00:00
#[macro_use]
extern crate rustc;
Various minor/cosmetic improvements to code
2018-11-27 02:59:49 +00:00
mod diagnostics;
mod nonstandard_style;
pub mod builtin;
mod types;
mod unused;
rustc: Remove some dead code
2017-08-19 00:09:55 +00:00
use rustc::lint;
Combine all builtin early lints and use a separate walk for plugin lints. Add a -Z no-interleave-lints option to allow benchmarking lints
2019-01-18 06:40:55 +00:00
use rustc::lint::{EarlyContext, LateContext, LateLintPass, EarlyLintPass, LintPass, LintArray};
make it a migration lint
2018-07-13 02:25:02 +00:00
use rustc::lint::builtin::{
BARE_TRAIT_OBJECTS,
ABSOLUTE_PATHS_NOT_STARTING_WITH_CRATE,
ELIDED_LIFETIMES_IN_PATHS,
in which inferable outlives-requirements are linted RFC 2093 (tracking issue #44493) lets us leave off commonsensically inferable `T: 'a` outlives requirements. (A separate feature-gate was split off for the case of 'static lifetimes, for which questions still remain.) Detecting these was requested as an idioms-2018 lint. It turns out that issuing a correct, autofixable suggestion here is somewhat subtle in the presence of other bounds and generic parameters. Basically, we want to handle these three cases: • One outlives-bound. We want to drop the bound altogether, including the colon— MyStruct<'a, T: 'a> ^^^^ help: remove this bound • An outlives bound first, followed by a trait bound. We want to delete the outlives bound and the following plus sign (and hopefully get the whitespace right, too)— MyStruct<'a, T: 'a + MyTrait> ^^^^^ help: remove this bound • An outlives bound after a trait bound. We want to delete the outlives lifetime and the preceding plus sign— MyStruct<'a, T: MyTrait + 'a> ^^^^^ help: remove this bound This gets (slightly) even more complicated in the case of where clauses, where we want to drop the where clause altogether if there's just the one bound. Hopefully the comments are enough to explain what's going on! A script (in Python, sorry) was used to generate the hopefully-sufficiently-exhaustive UI test input. Some of these are split off into a different file because rust-lang-nursery/rustfix#141 (and, causally upstream of that, #53934) prevents them from being `run-rustfix`-tested. We also make sure to include a UI test of a case (copied from RFC 2093) where the outlives-bound can't be inferred. Special thanks to Niko Matsakis for pointing out the `inferred_outlives_of` query, rather than blindly stripping outlives requirements as if we weren't a production compiler and didn't care. This concerns #52042.
2018-08-26 19:22:04 +00:00
EXPLICIT_OUTLIVES_REQUIREMENTS,
add a lint group for lints emitted by rustdoc
2018-12-10 20:58:57 +00:00
INTRA_DOC_LINK_RESOLUTION_FAILURE,
MISSING_DOC_CODE_EXAMPLES,
PRIVATE_DOC_TESTS,
Implement basic input validation for built-in attributes
2019-01-01 23:21:05 +00:00
parser::QUESTION_MARK_MACRO_SEP,
parser::ILL_FORMED_ATTRIBUTE_INPUT,
make it a migration lint
2018-07-13 02:25:02 +00:00
};
rustc: Remove some dead code
2017-08-19 00:09:55 +00:00
use rustc::session;
Combine all builtin late lints
2018-06-21 07:04:50 +00:00
use rustc::hir;
use syntax::ast;
Various minor/cosmetic improvements to code
2018-11-27 02:59:49 +00:00
use syntax::edition::Edition;
Combine all builtin late lints
2018-06-21 07:04:50 +00:00
use syntax_pos::Span;
Separate most of rustc::lint::builtin into a separate crate. This pulls out the implementations of most built-in lints into a separate crate, to reduce edit-compile-test iteration times with librustc_lint and increase parallelism. This should enable lints to be refactored, added and deleted much more easily as it slashes the edit-compile cycle to get a minimal working compiler to test with (`make rustc-stage1`) from librustc -> librustc_typeck -> ... -> librustc_driver -> libcore -> ... -> libstd to librustc_lint -> librustc_driver -> libcore -> ... libstd which is significantly faster, mainly due to avoiding the librustc build itself. The intention would be to move as much as possible of the infrastructure into the crate too, but the plumbing is deeply intertwined with librustc itself at the moment. Also, there are lints for which diagnostics are registered directly in the compiler code, not in their own crate traversal, and their definitions have to remain in librustc. This is a [breaking-change] for direct users of the compiler APIs: callers of `rustc::session::build_session` or `rustc::session::build_session_` need to manually call `rustc_lint::register_builtins` on their return value. This should make #22206 easier.
2015-02-25 11:44:44 +00:00
use session::Session;
Add trivial cast lints. This permits all coercions to be performed in casts, but adds lints to warn in those cases. Part of this patch moves cast checking to a later stage of type checking. We acquire obligations to check casts as part of type checking where we previously checked them. Once we have type checked a function or module, then we check any cast obligations which have been acquired. That means we have more type information available to check casts (this was crucial to making coercions work properly in place of some casts), but it means that casts cannot feed input into type inference. [breaking change] * Adds two new lints for trivial casts and trivial numeric casts, these are warn by default, but can cause errors if you build with warnings as errors. Previously, trivial numeric casts and casts to trait objects were allowed. * The unused casts lint has gone. * Interactions between casting and type inference have changed in subtle ways. Two ways this might manifest are: - You may need to 'direct' casts more with extra type information, for example, in some cases where `foo as _ as T` succeeded, you may now need to specify the type for `_` - Casts do not influence inference of integer types. E.g., the following used to type check: ``` let x = 42; let y = &x as *const u32; ``` Because the cast would inform inference that `x` must have type `u32`. This no longer applies and the compiler will fallback to `i32` for `x` and thus there will be a type error in the cast. The solution is to add more type information: ``` let x: u32 = 42; let y = &x as *const u32; ```
2015-03-20 04:15:27 +00:00
use lint::LintId;
Revamp the "future incompatible" section to clarify the situation better
2016-01-08 22:53:44 +00:00
use lint::FutureIncompatibleInfo;
Separate most of rustc::lint::builtin into a separate crate. This pulls out the implementations of most built-in lints into a separate crate, to reduce edit-compile-test iteration times with librustc_lint and increase parallelism. This should enable lints to be refactored, added and deleted much more easily as it slashes the edit-compile cycle to get a minimal working compiler to test with (`make rustc-stage1`) from librustc -> librustc_typeck -> ... -> librustc_driver -> libcore -> ... -> libstd to librustc_lint -> librustc_driver -> libcore -> ... libstd which is significantly faster, mainly due to avoiding the librustc build itself. The intention would be to move as much as possible of the infrastructure into the crate too, but the plumbing is deeply intertwined with librustc itself at the moment. Also, there are lints for which diagnostics are registered directly in the compiler code, not in their own crate traversal, and their definitions have to remain in librustc. This is a [breaking-change] for direct users of the compiler APIs: callers of `rustc::session::build_session` or `rustc::session::build_session_` need to manually call `rustc_lint::register_builtins` on their return value. This should make #22206 easier.
2015-02-25 11:44:44 +00:00
Replace usages of 'bad_style' with 'nonstandard_style'. `bad_style` is being deprecated in favor of `nonstandard_style`: - https://github.com/rust-lang/rust/issues/41646
2018-08-29 13:21:01 +00:00
use nonstandard_style::*;
Split out the bad_style lints into a new module Part of #22206
2015-09-15 02:36:39 +00:00
use builtin::*;
Split out the type lints into a new module Part of #22206
2015-09-22 00:58:57 +00:00
use types::*;
Split out the UNUSED_* lints into a new module Part of #22206
2015-09-15 22:58:19 +00:00
use unused::*;
Split out the bad_style lints into a new module Part of #22206
2015-09-15 02:36:39 +00:00
Fix options issues
2018-06-09 15:20:58 +00:00
/// Useful for other parts of the compiler.
pub use builtin::SoftLints;
Combine all builtin early lints and use a separate walk for plugin lints. Add a -Z no-interleave-lints option to allow benchmarking lints
2019-01-18 06:40:55 +00:00
macro_rules! pre_expansion_lint_passes {
($macro:path, $args:tt) => (
$macro!($args, [
KeywordIdents: KeywordIdents,
]);
)
}
macro_rules! early_lint_passes {
($macro:path, $args:tt) => (
$macro!($args, [
UnusedParens: UnusedParens,
UnusedImportBraces: UnusedImportBraces,
UnsafeCode: UnsafeCode,
AnonymousParameters: AnonymousParameters,
UnusedDocComment: UnusedDocComment,
EllipsisInclusiveRangePatterns: EllipsisInclusiveRangePatterns,
NonCamelCaseTypes: NonCamelCaseTypes,
DeprecatedAttr: DeprecatedAttr::new(),
]);
)
}
macro_rules! declare_combined_early_pass {
([$name:ident], $passes:tt) => (
early_lint_methods!(declare_combined_early_lint_pass, [pub $name, $passes]);
)
}
pre_expansion_lint_passes!(declare_combined_early_pass, [BuiltinCombinedPreExpansionLintPass]);
early_lint_passes!(declare_combined_early_pass, [BuiltinCombinedEarlyLintPass]);
Update docs for rustc_lint crateification.
2015-02-25 12:03:44 +00:00
/// Tell the `LintStore` about all the built-in lints (the ones
/// defined in this crate and the ones defined in
/// `rustc::lint::builtin`).
Separate most of rustc::lint::builtin into a separate crate. This pulls out the implementations of most built-in lints into a separate crate, to reduce edit-compile-test iteration times with librustc_lint and increase parallelism. This should enable lints to be refactored, added and deleted much more easily as it slashes the edit-compile cycle to get a minimal working compiler to test with (`make rustc-stage1`) from librustc -> librustc_typeck -> ... -> librustc_driver -> libcore -> ... -> libstd to librustc_lint -> librustc_driver -> libcore -> ... libstd which is significantly faster, mainly due to avoiding the librustc build itself. The intention would be to move as much as possible of the infrastructure into the crate too, but the plumbing is deeply intertwined with librustc itself at the moment. Also, there are lints for which diagnostics are registered directly in the compiler code, not in their own crate traversal, and their definitions have to remain in librustc. This is a [breaking-change] for direct users of the compiler APIs: callers of `rustc::session::build_session` or `rustc::session::build_session_` need to manually call `rustc_lint::register_builtins` on their return value. This should make #22206 easier.
2015-02-25 11:44:44 +00:00
pub fn register_builtins(store: &mut lint::LintStore, sess: Option<&Session>) {
Combine all builtin early lints and use a separate walk for plugin lints. Add a -Z no-interleave-lints option to allow benchmarking lints
2019-01-18 06:40:55 +00:00
macro_rules! add_lint_group {
($sess:ident, $name:expr, $($lint:ident),*) => (
store.register_group($sess, false, $name, None, vec![$(LintId::of($lint)),*]);
Make `bad_style` a silent alias for `nonstandard_style` Now only `nonstandard_style` is suggested in `rustc -W help`, but `bad_style` will not produce a warning.
2018-09-15 14:26:45 +00:00
)
Lint the use of async as an identifier
2018-07-14 14:40:17 +00:00
}
Combine all builtin early lints and use a separate walk for plugin lints. Add a -Z no-interleave-lints option to allow benchmarking lints
2019-01-18 06:40:55 +00:00
macro_rules! register_passes {
([$method:ident], [$($passes:ident: $constructor:expr,)*]) => (
$(
store.$method(sess, false, false, box $constructor);
)*
Make `bad_style` a silent alias for `nonstandard_style` Now only `nonstandard_style` is suggested in `rustc -W help`, but `bad_style` will not produce a warning.
2018-09-15 14:26:45 +00:00
)
review changes
2016-10-18 05:04:28 +00:00
}
Combine all builtin early lints and use a separate walk for plugin lints. Add a -Z no-interleave-lints option to allow benchmarking lints
2019-01-18 06:40:55 +00:00
if sess.map(|sess| sess.opts.debugging_opts.no_interleave_lints).unwrap_or(false) {
pre_expansion_lint_passes!(register_passes, [register_pre_expansion_pass]);
early_lint_passes!(register_passes, [register_early_pass]);
} else {
store.register_pre_expansion_pass(
sess,
false,
true,
box BuiltinCombinedPreExpansionLintPass::new()
);
store.register_early_pass(sess, false, true, box BuiltinCombinedEarlyLintPass::new());
Separate most of rustc::lint::builtin into a separate crate. This pulls out the implementations of most built-in lints into a separate crate, to reduce edit-compile-test iteration times with librustc_lint and increase parallelism. This should enable lints to be refactored, added and deleted much more easily as it slashes the edit-compile cycle to get a minimal working compiler to test with (`make rustc-stage1`) from librustc -> librustc_typeck -> ... -> librustc_driver -> libcore -> ... -> libstd to librustc_lint -> librustc_driver -> libcore -> ... libstd which is significantly faster, mainly due to avoiding the librustc build itself. The intention would be to move as much as possible of the infrastructure into the crate too, but the plumbing is deeply intertwined with librustc itself at the moment. Also, there are lints for which diagnostics are registered directly in the compiler code, not in their own crate traversal, and their definitions have to remain in librustc. This is a [breaking-change] for direct users of the compiler APIs: callers of `rustc::session::build_session` or `rustc::session::build_session_` need to manually call `rustc_lint::register_builtins` on their return value. This should make #22206 easier.
2015-02-25 11:44:44 +00:00
}
Combine all builtin late lints
2018-06-21 07:04:50 +00:00
late_lint_methods!(declare_combined_late_lint_pass, [BuiltinCombinedLateLintPass, [
HardwiredLints: HardwiredLints,
WhileTrue: WhileTrue,
ImproperCTypes: ImproperCTypes,
VariantSizeDifferences: VariantSizeDifferences,
BoxPointers: BoxPointers,
UnusedAttributes: UnusedAttributes,
PathStatements: PathStatements,
UnusedResults: UnusedResults,
NonSnakeCase: NonSnakeCase,
NonUpperCaseGlobals: NonUpperCaseGlobals,
NonShorthandFieldPatterns: NonShorthandFieldPatterns,
UnusedAllocation: UnusedAllocation,
MissingCopyImplementations: MissingCopyImplementations,
UnstableFeatures: UnstableFeatures,
InvalidNoMangleItems: InvalidNoMangleItems,
PluginAsLibrary: PluginAsLibrary,
MutableTransmutes: MutableTransmutes,
UnionsWithDropFields: UnionsWithDropFields,
UnreachablePub: UnreachablePub,
Introduce Custom Test Frameworks
2018-07-21 01:04:02 +00:00
UnnameableTestItems: UnnameableTestItems::new(),
Combine all builtin late lints
2018-06-21 07:04:50 +00:00
TypeAliasBounds: TypeAliasBounds,
UnusedBrokenConst: UnusedBrokenConst,
TrivialConstraints: TrivialConstraints,
TypeLimits: TypeLimits::new(),
MissingDoc: MissingDoc::new(),
MissingDebugImplementations: MissingDebugImplementations::new(),
in which inferable outlives-requirements are linted RFC 2093 (tracking issue #44493) lets us leave off commonsensically inferable `T: 'a` outlives requirements. (A separate feature-gate was split off for the case of 'static lifetimes, for which questions still remain.) Detecting these was requested as an idioms-2018 lint. It turns out that issuing a correct, autofixable suggestion here is somewhat subtle in the presence of other bounds and generic parameters. Basically, we want to handle these three cases: • One outlives-bound. We want to drop the bound altogether, including the colon— MyStruct<'a, T: 'a> ^^^^ help: remove this bound • An outlives bound first, followed by a trait bound. We want to delete the outlives bound and the following plus sign (and hopefully get the whitespace right, too)— MyStruct<'a, T: 'a + MyTrait> ^^^^^ help: remove this bound • An outlives bound after a trait bound. We want to delete the outlives lifetime and the preceding plus sign— MyStruct<'a, T: MyTrait + 'a> ^^^^^ help: remove this bound This gets (slightly) even more complicated in the case of where clauses, where we want to drop the where clause altogether if there's just the one bound. Hopefully the comments are enough to explain what's going on! A script (in Python, sorry) was used to generate the hopefully-sufficiently-exhaustive UI test input. Some of these are split off into a different file because rust-lang-nursery/rustfix#141 (and, causally upstream of that, #53934) prevents them from being `run-rustfix`-tested. We also make sure to include a UI test of a case (copied from RFC 2093) where the outlives-bound can't be inferred. Special thanks to Niko Matsakis for pointing out the `inferred_outlives_of` query, rather than blindly stripping outlives requirements as if we weren't a production compiler and didn't care. This concerns #52042.
2018-08-26 19:22:04 +00:00
ExplicitOutlivesRequirements: ExplicitOutlivesRequirements,
Combine all builtin late lints
2018-06-21 07:04:50 +00:00
]], ['tcx]);
store.register_late_pass(sess, false, box BuiltinCombinedLateLintPass::new());
Separate most of rustc::lint::builtin into a separate crate. This pulls out the implementations of most built-in lints into a separate crate, to reduce edit-compile-test iteration times with librustc_lint and increase parallelism. This should enable lints to be refactored, added and deleted much more easily as it slashes the edit-compile cycle to get a minimal working compiler to test with (`make rustc-stage1`) from librustc -> librustc_typeck -> ... -> librustc_driver -> libcore -> ... -> libstd to librustc_lint -> librustc_driver -> libcore -> ... libstd which is significantly faster, mainly due to avoiding the librustc build itself. The intention would be to move as much as possible of the infrastructure into the crate too, but the plumbing is deeply intertwined with librustc itself at the moment. Also, there are lints for which diagnostics are registered directly in the compiler code, not in their own crate traversal, and their definitions have to remain in librustc. This is a [breaking-change] for direct users of the compiler APIs: callers of `rustc::session::build_session` or `rustc::session::build_session_` need to manually call `rustc_lint::register_builtins` on their return value. This should make #22206 easier.
2015-02-25 11:44:44 +00:00
Add nonstandard_style alias for bad_style.
2018-02-20 21:28:51 +00:00
add_lint_group!(sess,
"nonstandard_style",
NON_CAMEL_CASE_TYPES,
NON_SNAKE_CASE,
NON_UPPER_CASE_GLOBALS);
run rustfmt on librustc_lint folder
2016-10-09 04:08:07 +00:00
add_lint_group!(sess,
"unused",
UNUSED_IMPORTS,
UNUSED_VARIABLES,
UNUSED_ASSIGNMENTS,
DEAD_CODE,
UNUSED_MUT,
UNREACHABLE_CODE,
Make is_useful handle empty types properly
2016-11-29 07:10:26 +00:00
UNREACHABLE_PATTERNS,
run rustfmt on librustc_lint folder
2016-10-09 04:08:07 +00:00
UNUSED_MUST_USE,
UNUSED_UNSAFE,
PATH_STATEMENTS,
Add lint for unused macros
2017-05-11 08:26:07 +00:00
UNUSED_ATTRIBUTES,
Add several lints into `unused` lint group Remove a couple of obsolete lints
2017-10-20 21:00:57 +00:00
UNUSED_MACROS,
UNUSED_ALLOCATION,
Fix naming conventions for new lints
2018-05-18 22:13:53 +00:00
UNUSED_DOC_COMMENTS,
Add several lints into `unused` lint group Remove a couple of obsolete lints
2017-10-20 21:00:57 +00:00
UNUSED_EXTERN_CRATES,
UNUSED_FEATURES,
Default `unused_labels` to allow, move to "unused"
2018-05-18 23:53:39 +00:00
UNUSED_LABELS,
Add several lints into `unused` lint group Remove a couple of obsolete lints
2017-10-20 21:00:57 +00:00
UNUSED_PARENS);
Separate most of rustc::lint::builtin into a separate crate. This pulls out the implementations of most built-in lints into a separate crate, to reduce edit-compile-test iteration times with librustc_lint and increase parallelism. This should enable lints to be refactored, added and deleted much more easily as it slashes the edit-compile cycle to get a minimal working compiler to test with (`make rustc-stage1`) from librustc -> librustc_typeck -> ... -> librustc_driver -> libcore -> ... -> libstd to librustc_lint -> librustc_driver -> libcore -> ... libstd which is significantly faster, mainly due to avoiding the librustc build itself. The intention would be to move as much as possible of the infrastructure into the crate too, but the plumbing is deeply intertwined with librustc itself at the moment. Also, there are lints for which diagnostics are registered directly in the compiler code, not in their own crate traversal, and their definitions have to remain in librustc. This is a [breaking-change] for direct users of the compiler APIs: callers of `rustc::session::build_session` or `rustc::session::build_session_` need to manually call `rustc_lint::register_builtins` on their return value. This should make #22206 easier.
2015-02-25 11:44:44 +00:00
Add rust_2018_idioms lint group
2018-03-08 21:23:52 +00:00
add_lint_group!(sess,
Rename the 2018 edition lint names * `rust_2018_breakage` -> `rust_2018_compatibility` - the lint for ensuring that your code, in the 2015 edition, is compatible with the 2018 edition's semantics. This is required to pass *before* you enable the 2018 edition. * `rust_2018_migration` -> `rust_2018_idioms` - the lint for writing idiomatic code after you've already enabled the 2018 edition
2018-05-10 18:28:11 +00:00
"rust_2018_idioms",
Fix naming conventions for new lints
2018-05-18 22:13:53 +00:00
BARE_TRAIT_OBJECTS,
inclusive range syntax lint (`...` → `..=`) Our implementation ends up changing the `PatKind::Range` variant in the AST to take a `Spanned<RangeEnd>` instead of just a `RangeEnd`, because the alternative would be to try to infer the span of the range operator from the spans of the start and end subexpressions, which is both hideous and nontrivial to get right (whereas getting the change to the AST right was a simple game of type tennis). This is concerning #51043.
2018-05-29 02:32:03 +00:00
UNUSED_EXTERN_CRATES,
rustc: Trim down the `rust_2018_idioms` lint group These migration lints aren't all up to par in terms of a good migration experience. Some, like `unreachable_pub`, hit bugs like #52665 and unprepared macros to be handled enough of the time. Others like linting against `#[macro_use]` are swimming upstream in an ecosystem that's not quite ready (and slightly buggy pending a few current PRs). The general idea is that we will continue to recommend the `rust_2018_idioms` lint group as part of the transition guide (as an optional step) but we'll be much more selective about which lints make it into this group. Only those with a strong track record of not causing too much churn will make the cut. cc #52679
2018-07-31 22:45:11 +00:00
ELLIPSIS_INCLUSIVE_RANGE_PATTERNS,
in which inferable outlives-requirements are linted RFC 2093 (tracking issue #44493) lets us leave off commonsensically inferable `T: 'a` outlives requirements. (A separate feature-gate was split off for the case of 'static lifetimes, for which questions still remain.) Detecting these was requested as an idioms-2018 lint. It turns out that issuing a correct, autofixable suggestion here is somewhat subtle in the presence of other bounds and generic parameters. Basically, we want to handle these three cases: • One outlives-bound. We want to drop the bound altogether, including the colon— MyStruct<'a, T: 'a> ^^^^ help: remove this bound • An outlives bound first, followed by a trait bound. We want to delete the outlives bound and the following plus sign (and hopefully get the whitespace right, too)— MyStruct<'a, T: 'a + MyTrait> ^^^^^ help: remove this bound • An outlives bound after a trait bound. We want to delete the outlives lifetime and the preceding plus sign— MyStruct<'a, T: MyTrait + 'a> ^^^^^ help: remove this bound This gets (slightly) even more complicated in the case of where clauses, where we want to drop the where clause altogether if there's just the one bound. Hopefully the comments are enough to explain what's going on! A script (in Python, sorry) was used to generate the hopefully-sufficiently-exhaustive UI test input. Some of these are split off into a different file because rust-lang-nursery/rustfix#141 (and, causally upstream of that, #53934) prevents them from being `run-rustfix`-tested. We also make sure to include a UI test of a case (copied from RFC 2093) where the outlives-bound can't be inferred. Special thanks to Niko Matsakis for pointing out the `inferred_outlives_of` query, rather than blindly stripping outlives requirements as if we weren't a production compiler and didn't care. This concerns #52042.
2018-08-26 19:22:04 +00:00
ELIDED_LIFETIMES_IN_PATHS,
EXPLICIT_OUTLIVES_REQUIREMENTS
rustc: Trim down the `rust_2018_idioms` lint group These migration lints aren't all up to par in terms of a good migration experience. Some, like `unreachable_pub`, hit bugs like #52665 and unprepared macros to be handled enough of the time. Others like linting against `#[macro_use]` are swimming upstream in an ecosystem that's not quite ready (and slightly buggy pending a few current PRs). The general idea is that we will continue to recommend the `rust_2018_idioms` lint group as part of the transition guide (as an optional step) but we'll be much more selective about which lints make it into this group. Only those with a strong track record of not causing too much churn will make the cut. cc #52679
2018-07-31 22:45:11 +00:00
// FIXME(#52665, #47816) not always applicable and not all
// macros are ready for this yet.
// UNREACHABLE_PUB,
// FIXME macro crates are not up for this yet, too much
// breakage is seen if we try to encourage this lint.
// MACRO_USE_EXTERN_CRATE,
);
Add rust_2018_idioms lint group
2018-03-08 21:23:52 +00:00
add a lint group for lints emitted by rustdoc
2018-12-10 20:58:57 +00:00
add_lint_group!(sess,
"rustdoc",
INTRA_DOC_LINK_RESOLUTION_FAILURE,
MISSING_DOC_CODE_EXAMPLES,
PRIVATE_DOC_TESTS);
Revamp the "future incompatible" section to clarify the situation better
2016-01-08 22:53:44 +00:00
// Guidelines for creating a future incompatibility lint:
//
// - Create a lint defaulting to warn as normal, with ideally the same error
// message you would normally give
// - Add a suitable reference, typically an RFC or tracking issue. Go ahead
Turn sufficiently old compatibility lints into hard errors
2017-05-21 11:11:08 +00:00
// and include the full URL, sort items in ascending order of issue numbers.
Revamp the "future incompatible" section to clarify the situation better
2016-01-08 22:53:44 +00:00
// - Later, change lint to error
// - Eventually, remove lint
Various minor/cosmetic improvements to code
2018-11-27 02:59:49 +00:00
store.register_future_incompatible(sess, vec![
Revamp the "future incompatible" section to clarify the situation better
2016-01-08 22:53:44 +00:00
FutureIncompatibleInfo {
id: LintId::of(PRIVATE_IN_PUBLIC),
Make `private_in_public` compatibility lint deny-by-default
2016-06-10 20:30:05 +00:00
reference: "issue #34537 <https://github.com/rust-lang/rust/issues/34537>",
rename epoch to edition
2018-03-15 03:30:06 +00:00
edition: None,
Revamp the "future incompatible" section to clarify the situation better
2016-01-08 22:53:44 +00:00
},
Move public reexports of private extern crates into a separate lint This is going to be a hard error while all private-in-public errors from rustc_privacy will be reclassified into lints.
2017-06-25 02:50:51 +00:00
FutureIncompatibleInfo {
id: LintId::of(PUB_USE_OF_PRIVATE_EXTERN_CRATE),
reference: "issue #34537 <https://github.com/rust-lang/rust/issues/34537>",
rename epoch to edition
2018-03-15 03:30:06 +00:00
edition: None,
Move public reexports of private extern crates into a separate lint This is going to be a hard error while all private-in-public errors from rustc_privacy will be reclassified into lints.
2017-06-25 02:50:51 +00:00
},
Warn instead of error when using an inaccessable extern crate
2016-02-12 06:42:44 +00:00
FutureIncompatibleInfo {
Turn sufficiently old compatibility lints into hard errors
2017-05-21 11:11:08 +00:00
id: LintId::of(PATTERNS_IN_FNS_WITHOUT_BODY),
reference: "issue #35203 <https://github.com/rust-lang/rust/issues/35203>",
rename epoch to edition
2018-03-15 03:30:06 +00:00
edition: None,
Use a proper future-compatibility lint
2017-01-21 07:15:23 +00:00
},
Prohibit duplicate `macro_export`s
2018-04-21 14:18:38 +00:00
FutureIncompatibleInfo {
id: LintId::of(DUPLICATE_MACRO_EXPORTS),
reference: "issue #35896 <https://github.com/rust-lang/rust/issues/35896>",
edition: Some(Edition::Edition2018),
},
Make `async_idents` an edition incompat lint
2018-07-17 17:56:41 +00:00
FutureIncompatibleInfo {
Generalize `async_idents` to all new keywords This commit generalizes the existing `async_idents` lint to easily encompass other identifiers that will be keywords in future editions. The new lint is called `keyword_idents` and the old `async_idents` lint is registered as renamed to this new lint. As a proof of concept the `try` keyword was added to this list as it looks to be listed as a keyword in the 2018 edition only. The `await` keyword was not added as it's not listed as a keyword yet. Closes #53077
2018-08-24 20:48:20 +00:00
id: LintId::of(KEYWORD_IDENTS),
Make `async_idents` an edition incompat lint
2018-07-17 17:56:41 +00:00
reference: "issue #49716 <https://github.com/rust-lang/rust/issues/49716>",
edition: Some(Edition::Edition2018),
},
Issue deprecation warnings for safe accesses to extern statics
2016-08-26 16:23:42 +00:00
FutureIncompatibleInfo {
id: LintId::of(SAFE_EXTERN_STATICS),
Turn sufficiently old compatibility lints into hard errors
2017-05-21 11:11:08 +00:00
reference: "issue #36247 <https://github.com/rust-lang/rust/issues/36247>",
rename epoch to edition
2018-03-15 03:30:06 +00:00
edition: None,
Prohibit patterns in trait methods without bodies
2016-10-22 00:33:36 +00:00
},
Turn `invalid_type_param_default` into a lint again
2017-05-26 22:52:25 +00:00
FutureIncompatibleInfo {
id: LintId::of(INVALID_TYPE_PARAM_DEFAULT),
reference: "issue #36887 <https://github.com/rust-lang/rust/issues/36887>",
rename epoch to edition
2018-03-15 03:30:06 +00:00
edition: None,
Turn `invalid_type_param_default` into a lint again
2017-05-26 22:52:25 +00:00
},
Start warning cycle.
2016-11-14 09:31:03 +00:00
FutureIncompatibleInfo {
id: LintId::of(LEGACY_DIRECTORY_OWNERSHIP),
reference: "issue #37872 <https://github.com/rust-lang/rust/issues/37872>",
rename epoch to edition
2018-03-15 03:30:06 +00:00
edition: None,
Start warning cycle.
2016-11-14 09:31:03 +00:00
},
Implement compatibility lint for legacy constructor visibilities
2017-01-20 15:53:49 +00:00
FutureIncompatibleInfo {
id: LintId::of(LEGACY_CONSTRUCTOR_VISIBILITY),
reference: "issue #39207 <https://github.com/rust-lang/rust/issues/39207>",
rename epoch to edition
2018-03-15 03:30:06 +00:00
edition: None,
Implement compatibility lint for legacy constructor visibilities
2017-01-20 15:53:49 +00:00
},
Add warning cycle.
2017-02-26 03:25:22 +00:00
FutureIncompatibleInfo {
id: LintId::of(MISSING_FRAGMENT_SPECIFIER),
reference: "issue #40107 <https://github.com/rust-lang/rust/issues/40107>",
rename epoch to edition
2018-03-15 03:30:06 +00:00
edition: None,
Add warning cycle.
2017-02-26 03:25:22 +00:00
},
Add warning cycle #42238.
2017-05-26 13:20:53 +00:00
FutureIncompatibleInfo {
Turn sufficiently old compatibility lints into hard errors
2017-05-21 11:11:08 +00:00
id: LintId::of(ILLEGAL_FLOATING_POINT_LITERAL_PATTERN),
reference: "issue #41620 <https://github.com/rust-lang/rust/issues/41620>",
rename epoch to edition
2018-03-15 03:30:06 +00:00
edition: None,
Add warning cycle #42238.
2017-05-26 13:20:53 +00:00
},
Add a lint to disallow anonymous parameters
2017-05-02 02:38:46 +00:00
FutureIncompatibleInfo {
id: LintId::of(ANONYMOUS_PARAMETERS),
reference: "issue #41686 <https://github.com/rust-lang/rust/issues/41686>",
Fix anon param + make it allow-by-def
2018-08-27 17:14:31 +00:00
edition: Some(Edition::Edition2018),
Add a lint to disallow anonymous parameters
2017-05-02 02:38:46 +00:00
},
Turn sufficiently old compatibility lints into hard errors
2017-05-21 11:11:08 +00:00
FutureIncompatibleInfo {
id: LintId::of(PARENTHESIZED_PARAMS_IN_TYPES_AND_MODULES),
reference: "issue #42238 <https://github.com/rust-lang/rust/issues/42238>",
rename epoch to edition
2018-03-15 03:30:06 +00:00
edition: None,
Prohibit lifetime arguments in path segments with late bound lifetime parameters
2017-06-23 21:56:25 +00:00
},
FutureIncompatibleInfo {
id: LintId::of(LATE_BOUND_LIFETIME_ARGUMENTS),
reference: "issue #42868 <https://github.com/rust-lang/rust/issues/42868>",
rename epoch to edition
2018-03-15 03:30:06 +00:00
edition: None,
Prohibit lifetime arguments in path segments with late bound lifetime parameters
2017-06-23 21:56:25 +00:00
},
make accessing packed fields a future-compat warning
2017-11-16 18:12:23 +00:00
FutureIncompatibleInfo {
id: LintId::of(SAFE_PACKED_BORROWS),
reference: "issue #46043 <https://github.com/rust-lang/rust/issues/46043>",
rename epoch to edition
2018-03-15 03:30:06 +00:00
edition: None,
make accessing packed fields a future-compat warning
2017-11-16 18:12:23 +00:00
},
convert the new conflicts to a soft error
2017-11-23 17:05:23 +00:00
FutureIncompatibleInfo {
id: LintId::of(INCOHERENT_FUNDAMENTAL_IMPLS),
reference: "issue #46205 <https://github.com/rust-lang/rust/issues/46205>",
rename epoch to edition
2018-03-15 03:30:06 +00:00
edition: None,
convert the new conflicts to a soft error
2017-11-23 17:05:23 +00:00
},
add the ORDER_DEPENDENT_TRAIT_OBJECTS lint
2018-12-03 21:27:22 +00:00
FutureIncompatibleInfo {
id: LintId::of(ORDER_DEPENDENT_TRAIT_OBJECTS),
use tracking issue instead of original issue
2018-12-03 23:00:21 +00:00
reference: "issue #56484 <https://github.com/rust-lang/rust/issues/56484>",
add the ORDER_DEPENDENT_TRAIT_OBJECTS lint
2018-12-03 21:27:22 +00:00
edition: None,
},
Convert warning about `*const _` to a future-compat lint
2017-12-21 16:20:53 +00:00
FutureIncompatibleInfo {
id: LintId::of(TYVAR_BEHIND_RAW_POINTER),
reference: "issue #46906 <https://github.com/rust-lang/rust/issues/46906>",
rename epoch to edition
2018-03-15 03:30:06 +00:00
edition: Some(Edition::Edition2018),
When picking a candidate, consider the unstable ones last. If there is potential ambiguity after stabilizing those candidates, a warning will be emitted.
2018-02-26 13:34:06 +00:00
},
FutureIncompatibleInfo {
Fix naming conventions for new lints
2018-05-18 22:13:53 +00:00
id: LintId::of(UNSTABLE_NAME_COLLISIONS),
Filed a proper tracking issue.
2018-03-10 17:58:57 +00:00
reference: "issue #48919 <https://github.com/rust-lang/rust/issues/48919>",
When picking a candidate, consider the unstable ones last. If there is potential ambiguity after stabilizing those candidates, a warning will be emitted.
2018-02-26 13:34:06 +00:00
edition: None,
// Note: this item represents future incompatibility of all unstable functions in the
// standard library, and thus should never be removed or changed to an error.
},
Add ABSOLUTE_PATH_STARTING_WITH_MODULE epoch lint for path breakage
2018-04-19 23:45:33 +00:00
FutureIncompatibleInfo {
Fix naming conventions for new lints
2018-05-18 22:13:53 +00:00
id: LintId::of(ABSOLUTE_PATHS_NOT_STARTING_WITH_CRATE),
pick a reference issue for absolute-paths future incompatibility info It would be kind of embarrassing to ship with the "issue TBD" message!
2018-10-20 18:17:42 +00:00
reference: "issue #53130 <https://github.com/rust-lang/rust/issues/53130>",
Add ABSOLUTE_PATH_STARTING_WITH_MODULE epoch lint for path breakage
2018-04-19 23:45:33 +00:00
edition: Some(Edition::Edition2018),
},
Make where clause object safety be a warn-by-default lint
2018-05-30 12:06:08 +00:00
FutureIncompatibleInfo {
id: LintId::of(WHERE_CLAUSES_OBJECT_SAFETY),
Fill in tracking issue for WHERE_CLAUSES_OBJECT_SAFETY future compat lint
2018-06-08 21:26:37 +00:00
reference: "issue #51443 <https://github.com/rust-lang/rust/issues/51443>",
Make where clause object safety be a warn-by-default lint
2018-05-30 12:06:08 +00:00
edition: None,
Fix according to comments
2018-05-19 14:47:34 +00:00
},
Remove fallback to parent modules from lexical resolution
2018-07-07 20:07:06 +00:00
FutureIncompatibleInfo {
id: LintId::of(PROC_MACRO_DERIVE_RESOLUTION_FALLBACK),
reference: "issue #50504 <https://github.com/rust-lang/rust/issues/50504>",
edition: None,
},
make it a migration lint
2018-07-13 02:25:02 +00:00
FutureIncompatibleInfo {
id: LintId::of(QUESTION_MARK_MACRO_SEP),
reference: "issue #48075 <https://github.com/rust-lang/rust/issues/48075>",
edition: Some(Edition::Edition2018),
Turn the error for module-relative access to macro-expanded `macro_export` macros into a deprecation lint
2018-08-23 23:51:41 +00:00
},
FutureIncompatibleInfo {
id: LintId::of(MACRO_EXPANDED_MACRO_EXPORTS_ACCESSED_BY_ABSOLUTE_PATHS),
reference: "issue #52234 <https://github.com/rust-lang/rust/issues/52234>",
edition: None,
},
Implement basic input validation for built-in attributes
2019-01-01 23:21:05 +00:00
FutureIncompatibleInfo {
id: LintId::of(ILL_FORMED_ATTRIBUTE_INPUT),
Address review comments
2019-01-12 16:00:42 +00:00
reference: "issue #57571 <https://github.com/rust-lang/rust/issues/57571>",
Implement basic input validation for built-in attributes
2019-01-01 23:21:05 +00:00
edition: None,
},
Prioritize variants as inherent associated items during name resolution
2019-01-10 20:23:30 +00:00
FutureIncompatibleInfo {
id: LintId::of(AMBIGUOUS_ASSOCIATED_ITEMS),
reference: "issue #57644 <https://github.com/rust-lang/rust/issues/57644>",
edition: None,
},
Make it an incompatibility lint for now
2019-01-18 03:19:56 +00:00
FutureIncompatibleInfo {
id: LintId::of(DUPLICATE_MATCHER_BINDING_NAME),
reference: "issue #57593 <https://github.com/rust-lang/rust/issues/57593>",
edition: None,
},
Revamp the "future incompatible" section to clarify the situation better
2016-01-08 22:53:44 +00:00
]);
Use lint instead of warning
2015-11-26 17:56:20 +00:00
Various minor/cosmetic improvements to code
2018-11-27 02:59:49 +00:00
// Register renamed and removed lints.
Fix naming conventions for new lints
2018-05-18 22:13:53 +00:00
store.register_renamed("single_use_lifetime", "single_use_lifetimes");
store.register_renamed("elided_lifetime_in_path", "elided_lifetimes_in_paths");
store.register_renamed("bare_trait_object", "bare_trait_objects");
store.register_renamed("unstable_name_collision", "unstable_name_collisions");
store.register_renamed("unused_doc_comment", "unused_doc_comments");
Generalize `async_idents` to all new keywords This commit generalizes the existing `async_idents` lint to easily encompass other identifiers that will be keywords in future editions. The new lint is called `keyword_idents` and the old `async_idents` lint is registered as renamed to this new lint. As a proof of concept the `try` keyword was added to this list as it looks to be listed as a keyword in the 2018 edition only. The `await` keyword was not added as it's not listed as a keyword yet. Closes #53077
2018-08-24 20:48:20 +00:00
store.register_renamed("async_idents", "keyword_idents");
Convert unknown_features lint into an error
2018-07-23 20:05:39 +00:00
store.register_removed("unknown_features", "replaced by an error");
Add several lints into `unused` lint group Remove a couple of obsolete lints
2017-10-20 21:00:57 +00:00
store.register_removed("unsigned_negation", "replaced by negate_unsigned feature gate");
[breaking-change] remove negate_unsigned feature gate
2016-01-11 11:31:46 +00:00
store.register_removed("negate_unsigned", "cast a signed value instead");
rustc: Fix bugs in renamed and removed lints and re-add raw_pointer_derive cc #30346
2016-01-13 18:54:06 +00:00
store.register_removed("raw_pointer_derive", "using derive with raw pointers is ok");
Various minor/cosmetic improvements to code
2018-11-27 02:59:49 +00:00
// Register lint group aliases.
Make `bad_style` a silent alias for `nonstandard_style` Now only `nonstandard_style` is suggested in `rustc -W help`, but `bad_style` will not produce a warning.
2018-09-15 14:26:45 +00:00
store.register_group_alias("nonstandard_style", "bad_style");
Various minor/cosmetic improvements to code
2018-11-27 02:59:49 +00:00
// This was renamed to `raw_pointer_derive`, which was then removed,
// so it is also considered removed.
Add several lints into `unused` lint group Remove a couple of obsolete lints
2017-10-20 21:00:57 +00:00
store.register_removed("raw_pointer_deriving", "using derive with raw pointers is ok");
Remove drop flags from structs and enums implementing Drop.
2016-08-23 07:39:30 +00:00
store.register_removed("drop_with_repr_extern", "drop flags have been removed");
Add several lints into `unused` lint group Remove a couple of obsolete lints
2017-10-20 21:00:57 +00:00
store.register_removed("fat_ptr_transmutes", "was accidentally removed back in 2014");
store.register_removed("deprecated_attr", "use `deprecated` instead");
Make transmuting from fn item types to pointer-sized types a hard error.
2016-06-10 10:00:21 +00:00
store.register_removed("transmute_from_fn_item_types",
"always cast functions before transmuting them");
Turn sufficiently old compatibility lints into hard errors
2017-05-21 11:11:08 +00:00
store.register_removed("hr_lifetime_in_assoc_type",
"converted into hard error, see https://github.com/rust-lang/rust/issues/33685");
store.register_removed("inaccessible_extern_crate",
"converted into hard error, see https://github.com/rust-lang/rust/issues/36886");
store.register_removed("super_or_self_in_global_path",
"converted into hard error, see https://github.com/rust-lang/rust/issues/36888");
store.register_removed("overlapping_inherent_impls",
"converted into hard error, see https://github.com/rust-lang/rust/issues/36889");
store.register_removed("illegal_floating_point_constant_pattern",
"converted into hard error, see https://github.com/rust-lang/rust/issues/36890");
store.register_removed("illegal_struct_or_enum_constant_pattern",
"converted into hard error, see https://github.com/rust-lang/rust/issues/36891");
store.register_removed("lifetime_underscore",
"converted into hard error, see https://github.com/rust-lang/rust/issues/36892");
convert EXTRA_REQUIREMENT_IN_IMPL into a hard error cc #37166
2017-11-01 18:23:30 +00:00
store.register_removed("extra_requirement_in_impl",
"converted into hard error, see https://github.com/rust-lang/rust/issues/37166");
Turn deprecation lint `legacy_imports` into a hard error
2018-05-14 22:24:34 +00:00
store.register_removed("legacy_imports",
"converted into hard error, see https://github.com/rust-lang/rust/issues/38260");
register removed lints
2018-03-14 04:04:29 +00:00
store.register_removed("coerce_never",
"converted into hard error, see https://github.com/rust-lang/rust/issues/48950");
store.register_removed("resolve_trait_on_defaulted_unit",
"converted into hard error, see https://github.com/rust-lang/rust/issues/48950");
rustc: Allow `#[no_mangle]` anywhere in a crate This commit updates the compiler to allow the `#[no_mangle]` (and `#[export_name]` attributes) to be located anywhere within a crate. These attributes are unconditionally processed, causing the compiler to always generate an exported symbol with the appropriate name. After some discussion on #54135 it was found that not a great reason this hasn't been allowed already, and it seems to match the behavior that many expect! Previously the compiler would only export a `#[no_mangle]` symbol if it were *publicly reachable*, meaning that it itself is `pub` and it's otherwise publicly reachable from the root of the crate. This new definition is that `#[no_mangle]` *is always reachable*, no matter where it is in a crate or whether it has `pub` or not. This should make it much easier to declare an exported symbol with a known and unique name, even when it's an internal implementation detail of the crate itself. Note that these symbols will persist beyond LTO as well, always making their way to the linker. Along the way this commit removes the `private_no_mangle_functions` lint (also for statics) as there's no longer any need to lint these situations. Furthermore a good number of tests were updated now that symbol visibility has been changed. Closes #54135
2018-09-21 22:58:11 +00:00
store.register_removed("private_no_mangle_fns",
Fix private_no_mangle_fns message grammar
2018-12-12 05:42:23 +00:00
"no longer a warning, #[no_mangle] functions always exported");
rustc: Allow `#[no_mangle]` anywhere in a crate This commit updates the compiler to allow the `#[no_mangle]` (and `#[export_name]` attributes) to be located anywhere within a crate. These attributes are unconditionally processed, causing the compiler to always generate an exported symbol with the appropriate name. After some discussion on #54135 it was found that not a great reason this hasn't been allowed already, and it seems to match the behavior that many expect! Previously the compiler would only export a `#[no_mangle]` symbol if it were *publicly reachable*, meaning that it itself is `pub` and it's otherwise publicly reachable from the root of the crate. This new definition is that `#[no_mangle]` *is always reachable*, no matter where it is in a crate or whether it has `pub` or not. This should make it much easier to declare an exported symbol with a known and unique name, even when it's an internal implementation detail of the crate itself. Note that these symbols will persist beyond LTO as well, always making their way to the linker. Along the way this commit removes the `private_no_mangle_functions` lint (also for statics) as there's no longer any need to lint these situations. Furthermore a good number of tests were updated now that symbol visibility has been changed. Closes #54135
2018-09-21 22:58:11 +00:00
store.register_removed("private_no_mangle_statics",
Fix private_no_mangle_fns message grammar
2018-12-12 05:42:23 +00:00
"no longer a warning, #[no_mangle] statics always exported");
Implement basic input validation for built-in attributes
2019-01-01 23:21:05 +00:00
store.register_removed("bad_repr",
"replaced with a generic attribute input check");
Separate most of rustc::lint::builtin into a separate crate. This pulls out the implementations of most built-in lints into a separate crate, to reduce edit-compile-test iteration times with librustc_lint and increase parallelism. This should enable lints to be refactored, added and deleted much more easily as it slashes the edit-compile cycle to get a minimal working compiler to test with (`make rustc-stage1`) from librustc -> librustc_typeck -> ... -> librustc_driver -> libcore -> ... -> libstd to librustc_lint -> librustc_driver -> libcore -> ... libstd which is significantly faster, mainly due to avoiding the librustc build itself. The intention would be to move as much as possible of the infrastructure into the crate too, but the plumbing is deeply intertwined with librustc itself at the moment. Also, there are lints for which diagnostics are registered directly in the compiler code, not in their own crate traversal, and their definitions have to remain in librustc. This is a [breaking-change] for direct users of the compiler APIs: callers of `rustc::session::build_session` or `rustc::session::build_session_` need to manually call `rustc_lint::register_builtins` on their return value. This should make #22206 easier.
2015-02-25 11:44:44 +00:00
}
Reference in New Issue Copy Permalink