Merge branch 'master' into fix-4727
This commit is contained in:
commit
9c48a2c39a
55 changed files with 417 additions and 330 deletions
|
@ -56,15 +56,15 @@ matrix:
|
|||
# We don't want to run these always because they go towards
|
||||
# the build limit within the Travis rust-lang account.
|
||||
# The jobs are approximately sorted by execution time
|
||||
- env: INTEGRATION=rust-lang/rls
|
||||
if: repo =~ /^rust-lang\/rust-clippy$/ AND branch IN (auto, try)
|
||||
- env: INTEGRATION=rust-lang/cargo
|
||||
if: repo =~ /^rust-lang\/rust-clippy$/ AND branch IN (auto, try)
|
||||
- env: INTEGRATION=rust-lang-nursery/chalk
|
||||
if: repo =~ /^rust-lang\/rust-clippy$/ AND branch IN (auto, try)
|
||||
- env: INTEGRATION=rust-lang/rls
|
||||
if: repo =~ /^rust-lang\/rust-clippy$/ AND branch IN (auto, try)
|
||||
- env: INTEGRATION=Geal/nom
|
||||
if: repo =~ /^rust-lang\/rust-clippy$/ AND branch IN (auto, try)
|
||||
# FIXME blocked on https://github.com/rust-lang/rust-clippy/issues/4742
|
||||
# FIXME blocked on https://github.com/rust-lang/rust-clippy/issues/4727
|
||||
#- env: INTEGRATION=rust-lang/rustfmt
|
||||
# if: repo =~ /^rust-lang\/rust-clippy$/ AND branch IN (auto, try)
|
||||
- env: INTEGRATION=hyperium/hyper
|
||||
|
@ -90,7 +90,6 @@ matrix:
|
|||
allow_failures:
|
||||
- os: windows
|
||||
env: CARGO_INCREMENTAL=0 OS_WINDOWS=true
|
||||
- env: INTEGRATION=rust-lang-nursery/stdsimd
|
||||
|
||||
before_script:
|
||||
- |
|
||||
|
|
|
@ -996,6 +996,7 @@ Released 2018-09-13
|
|||
[`erasing_op`]: https://rust-lang.github.io/rust-clippy/master/index.html#erasing_op
|
||||
[`eval_order_dependence`]: https://rust-lang.github.io/rust-clippy/master/index.html#eval_order_dependence
|
||||
[`excessive_precision`]: https://rust-lang.github.io/rust-clippy/master/index.html#excessive_precision
|
||||
[`exit`]: https://rust-lang.github.io/rust-clippy/master/index.html#exit
|
||||
[`expect_fun_call`]: https://rust-lang.github.io/rust-clippy/master/index.html#expect_fun_call
|
||||
[`expl_impl_clone_on_copy`]: https://rust-lang.github.io/rust-clippy/master/index.html#expl_impl_clone_on_copy
|
||||
[`explicit_counter_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#explicit_counter_loop
|
||||
|
|
|
@ -18,20 +18,21 @@ edition = "2018"
|
|||
|
||||
[dependencies]
|
||||
cargo_metadata = "0.9.0"
|
||||
if_chain = "1.0.0"
|
||||
itertools = "0.8"
|
||||
lazy_static = "1.0.2"
|
||||
matches = "0.1.7"
|
||||
pulldown-cmark = "0.6.0"
|
||||
quine-mc_cluskey = "0.2.2"
|
||||
regex-syntax = "0.6"
|
||||
semver = "0.9.0"
|
||||
serde = { version = "1.0", features = ["derive"] }
|
||||
smallvec = { version = "1", features = ["union"] }
|
||||
toml = "0.5.3"
|
||||
unicode-normalization = "0.1"
|
||||
pulldown-cmark = "0.6.0"
|
||||
url = { version = "2.1.0", features = ["serde"] } # cargo requires serde feat in its url dep
|
||||
# see https://github.com/rust-lang/rust/pull/63587#issuecomment-522343864
|
||||
if_chain = "1.0.0"
|
||||
smallvec = { version = "0.6.5", features = ["union"] }
|
||||
semver = "0.9.0"
|
||||
# NOTE: cargo requires serde feat in its url dep
|
||||
# see <https://github.com/rust-lang/rust/pull/63587#issuecomment-522343864>
|
||||
url = { version = "2.1.0", features = ["serde"] }
|
||||
|
||||
[features]
|
||||
debugging = []
|
||||
|
|
|
@ -3,7 +3,7 @@ use rustc::hir::*;
|
|||
use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
|
||||
use rustc::{declare_lint_pass, declare_tool_lint};
|
||||
use std::f64::consts as f64;
|
||||
use syntax::ast::{FloatTy, LitKind};
|
||||
use syntax::ast::{FloatTy, LitFloatType, LitKind};
|
||||
use syntax::symbol;
|
||||
|
||||
declare_clippy_lint! {
|
||||
|
@ -62,9 +62,11 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ApproxConstant {
|
|||
|
||||
fn check_lit(cx: &LateContext<'_, '_>, lit: &LitKind, e: &Expr) {
|
||||
match *lit {
|
||||
LitKind::Float(s, FloatTy::F32) => check_known_consts(cx, e, s, "f32"),
|
||||
LitKind::Float(s, FloatTy::F64) => check_known_consts(cx, e, s, "f64"),
|
||||
LitKind::FloatUnsuffixed(s) => check_known_consts(cx, e, s, "f{32, 64}"),
|
||||
LitKind::Float(s, LitFloatType::Suffixed(fty)) => match fty {
|
||||
FloatTy::F32 => check_known_consts(cx, e, s, "f32"),
|
||||
FloatTy::F64 => check_known_consts(cx, e, s, "f64"),
|
||||
},
|
||||
LitKind::Float(s, LitFloatType::Unsuffixed) => check_known_consts(cx, e, s, "f{32, 64}"),
|
||||
_ => (),
|
||||
}
|
||||
}
|
||||
|
|
|
@ -15,7 +15,7 @@ use rustc::ty;
|
|||
use rustc::{declare_lint_pass, declare_tool_lint};
|
||||
use rustc_errors::Applicability;
|
||||
use semver::Version;
|
||||
use syntax::ast::{AttrStyle, Attribute, Lit, LitKind, MetaItemKind, NestedMetaItem};
|
||||
use syntax::ast::{AttrKind, AttrStyle, Attribute, Lit, LitKind, MetaItemKind, NestedMetaItem};
|
||||
use syntax::source_map::Span;
|
||||
use syntax_pos::symbol::Symbol;
|
||||
|
||||
|
@ -417,11 +417,14 @@ fn check_attrs(cx: &LateContext<'_, '_>, span: Span, name: Name, attrs: &[Attrib
|
|||
}
|
||||
|
||||
for attr in attrs {
|
||||
if attr.is_sugared_doc {
|
||||
return;
|
||||
}
|
||||
let attr_item = if let AttrKind::Normal(ref attr) = attr.kind {
|
||||
attr
|
||||
} else {
|
||||
continue;
|
||||
};
|
||||
|
||||
if attr.style == AttrStyle::Outer {
|
||||
if attr.tokens.is_empty() || !is_present_in_source(cx, attr.span) {
|
||||
if attr_item.tokens.is_empty() || !is_present_in_source(cx, attr.span) {
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
|
@ -161,9 +161,11 @@ pub fn lit_to_constant(lit: &LitKind, ty: Option<Ty<'_>>) -> Constant {
|
|||
LitKind::ByteStr(ref s) => Constant::Binary(Lrc::clone(s)),
|
||||
LitKind::Char(c) => Constant::Char(c),
|
||||
LitKind::Int(n, _) => Constant::Int(n),
|
||||
LitKind::Float(ref is, FloatTy::F32) => Constant::F32(is.as_str().parse().unwrap()),
|
||||
LitKind::Float(ref is, FloatTy::F64) => Constant::F64(is.as_str().parse().unwrap()),
|
||||
LitKind::FloatUnsuffixed(ref is) => match ty.expect("type of float is known").kind {
|
||||
LitKind::Float(ref is, LitFloatType::Suffixed(fty)) => match fty {
|
||||
FloatTy::F32 => Constant::F32(is.as_str().parse().unwrap()),
|
||||
FloatTy::F64 => Constant::F64(is.as_str().parse().unwrap()),
|
||||
},
|
||||
LitKind::Float(ref is, LitFloatType::Unsuffixed) => match ty.expect("type of float is known").kind {
|
||||
ty::Float(FloatTy::F32) => Constant::F32(is.as_str().parse().unwrap()),
|
||||
ty::Float(FloatTy::F64) => Constant::F64(is.as_str().parse().unwrap()),
|
||||
_ => bug!(),
|
||||
|
|
|
@ -4,129 +4,137 @@ macro_rules! declare_deprecated_lint {
|
|||
}
|
||||
}
|
||||
|
||||
/// **What it does:** Nothing. This lint has been deprecated.
|
||||
///
|
||||
/// **Deprecation reason:** This used to check for `assert!(a == b)` and recommend
|
||||
/// replacement with `assert_eq!(a, b)`, but this is no longer needed after RFC 2011.
|
||||
declare_deprecated_lint! {
|
||||
/// **What it does:** Nothing. This lint has been deprecated.
|
||||
///
|
||||
/// **Deprecation reason:** This used to check for `assert!(a == b)` and recommend
|
||||
/// replacement with `assert_eq!(a, b)`, but this is no longer needed after RFC 2011.
|
||||
pub SHOULD_ASSERT_EQ,
|
||||
"`assert!()` will be more flexible with RFC 2011"
|
||||
}
|
||||
|
||||
/// **What it does:** Nothing. This lint has been deprecated.
|
||||
///
|
||||
/// **Deprecation reason:** This used to check for `Vec::extend`, which was slower than
|
||||
/// `Vec::extend_from_slice`. Thanks to specialization, this is no longer true.
|
||||
declare_deprecated_lint! {
|
||||
/// **What it does:** Nothing. This lint has been deprecated.
|
||||
///
|
||||
/// **Deprecation reason:** This used to check for `Vec::extend`, which was slower than
|
||||
/// `Vec::extend_from_slice`. Thanks to specialization, this is no longer true.
|
||||
pub EXTEND_FROM_SLICE,
|
||||
"`.extend_from_slice(_)` is a faster way to extend a Vec by a slice"
|
||||
}
|
||||
|
||||
/// **What it does:** Nothing. This lint has been deprecated.
|
||||
///
|
||||
/// **Deprecation reason:** `Range::step_by(0)` used to be linted since it's
|
||||
/// an infinite iterator, which is better expressed by `iter::repeat`,
|
||||
/// but the method has been removed for `Iterator::step_by` which panics
|
||||
/// if given a zero
|
||||
declare_deprecated_lint! {
|
||||
/// **What it does:** Nothing. This lint has been deprecated.
|
||||
///
|
||||
/// **Deprecation reason:** `Range::step_by(0)` used to be linted since it's
|
||||
/// an infinite iterator, which is better expressed by `iter::repeat`,
|
||||
/// but the method has been removed for `Iterator::step_by` which panics
|
||||
/// if given a zero
|
||||
pub RANGE_STEP_BY_ZERO,
|
||||
"`iterator.step_by(0)` panics nowadays"
|
||||
}
|
||||
|
||||
/// **What it does:** Nothing. This lint has been deprecated.
|
||||
///
|
||||
/// **Deprecation reason:** This used to check for `Vec::as_slice`, which was unstable with good
|
||||
/// stable alternatives. `Vec::as_slice` has now been stabilized.
|
||||
declare_deprecated_lint! {
|
||||
/// **What it does:** Nothing. This lint has been deprecated.
|
||||
///
|
||||
/// **Deprecation reason:** This used to check for `Vec::as_slice`, which was unstable with good
|
||||
/// stable alternatives. `Vec::as_slice` has now been stabilized.
|
||||
pub UNSTABLE_AS_SLICE,
|
||||
"`Vec::as_slice` has been stabilized in 1.7"
|
||||
}
|
||||
|
||||
|
||||
/// **What it does:** Nothing. This lint has been deprecated.
|
||||
///
|
||||
/// **Deprecation reason:** This used to check for `Vec::as_mut_slice`, which was unstable with good
|
||||
/// stable alternatives. `Vec::as_mut_slice` has now been stabilized.
|
||||
declare_deprecated_lint! {
|
||||
/// **What it does:** Nothing. This lint has been deprecated.
|
||||
///
|
||||
/// **Deprecation reason:** This used to check for `Vec::as_mut_slice`, which was unstable with good
|
||||
/// stable alternatives. `Vec::as_mut_slice` has now been stabilized.
|
||||
pub UNSTABLE_AS_MUT_SLICE,
|
||||
"`Vec::as_mut_slice` has been stabilized in 1.7"
|
||||
}
|
||||
|
||||
/// **What it does:** Nothing. This lint has been deprecated.
|
||||
///
|
||||
/// **Deprecation reason:** This used to check for `.to_string()` method calls on values
|
||||
/// of type `&str`. This is not unidiomatic and with specialization coming, `to_string` could be
|
||||
/// specialized to be as efficient as `to_owned`.
|
||||
declare_deprecated_lint! {
|
||||
/// **What it does:** Nothing. This lint has been deprecated.
|
||||
///
|
||||
/// **Deprecation reason:** This used to check for `.to_string()` method calls on values
|
||||
/// of type `&str`. This is not unidiomatic and with specialization coming, `to_string` could be
|
||||
/// specialized to be as efficient as `to_owned`.
|
||||
pub STR_TO_STRING,
|
||||
"using `str::to_string` is common even today and specialization will likely happen soon"
|
||||
}
|
||||
|
||||
/// **What it does:** Nothing. This lint has been deprecated.
|
||||
///
|
||||
/// **Deprecation reason:** This used to check for `.to_string()` method calls on values
|
||||
/// of type `String`. This is not unidiomatic and with specialization coming, `to_string` could be
|
||||
/// specialized to be as efficient as `clone`.
|
||||
declare_deprecated_lint! {
|
||||
/// **What it does:** Nothing. This lint has been deprecated.
|
||||
///
|
||||
/// **Deprecation reason:** This used to check for `.to_string()` method calls on values
|
||||
/// of type `String`. This is not unidiomatic and with specialization coming, `to_string` could be
|
||||
/// specialized to be as efficient as `clone`.
|
||||
pub STRING_TO_STRING,
|
||||
"using `string::to_string` is common even today and specialization will likely happen soon"
|
||||
}
|
||||
|
||||
/// **What it does:** Nothing. This lint has been deprecated.
|
||||
///
|
||||
/// **Deprecation reason:** This lint should never have applied to non-pointer types, as transmuting
|
||||
/// between non-pointer types of differing alignment is well-defined behavior (it's semantically
|
||||
/// equivalent to a memcpy). This lint has thus been refactored into two separate lints:
|
||||
/// cast_ptr_alignment and transmute_ptr_to_ptr.
|
||||
declare_deprecated_lint! {
|
||||
/// **What it does:** Nothing. This lint has been deprecated.
|
||||
///
|
||||
/// **Deprecation reason:** This lint should never have applied to non-pointer types, as transmuting
|
||||
/// between non-pointer types of differing alignment is well-defined behavior (it's semantically
|
||||
/// equivalent to a memcpy). This lint has thus been refactored into two separate lints:
|
||||
/// cast_ptr_alignment and transmute_ptr_to_ptr.
|
||||
pub MISALIGNED_TRANSMUTE,
|
||||
"this lint has been split into cast_ptr_alignment and transmute_ptr_to_ptr"
|
||||
}
|
||||
|
||||
/// **What it does:** Nothing. This lint has been deprecated.
|
||||
///
|
||||
/// **Deprecation reason:** This lint is too subjective, not having a good reason for being in clippy.
|
||||
/// Additionally, compound assignment operators may be overloaded separately from their non-assigning
|
||||
/// counterparts, so this lint may suggest a change in behavior or the code may not compile.
|
||||
declare_deprecated_lint! {
|
||||
/// **What it does:** Nothing. This lint has been deprecated.
|
||||
///
|
||||
/// **Deprecation reason:** This lint is too subjective, not having a good reason for being in clippy.
|
||||
/// Additionally, compound assignment operators may be overloaded separately from their non-assigning
|
||||
/// counterparts, so this lint may suggest a change in behavior or the code may not compile.
|
||||
pub ASSIGN_OPS,
|
||||
"using compound assignment operators (e.g., `+=`) is harmless"
|
||||
}
|
||||
|
||||
/// **What it does:** Nothing. This lint has been deprecated.
|
||||
///
|
||||
/// **Deprecation reason:** The original rule will only lint for `if let`. After
|
||||
/// making it support to lint `match`, naming as `if let` is not suitable for it.
|
||||
/// So, this lint is deprecated.
|
||||
declare_deprecated_lint! {
|
||||
/// **What it does:** Nothing. This lint has been deprecated.
|
||||
///
|
||||
/// **Deprecation reason:** The original rule will only lint for `if let`. After
|
||||
/// making it support to lint `match`, naming as `if let` is not suitable for it.
|
||||
/// So, this lint is deprecated.
|
||||
pub IF_LET_REDUNDANT_PATTERN_MATCHING,
|
||||
"this lint has been changed to redundant_pattern_matching"
|
||||
}
|
||||
|
||||
/// **What it does:** Nothing. This lint has been deprecated.
|
||||
///
|
||||
/// **Deprecation reason:** This lint used to suggest replacing `let mut vec =
|
||||
/// Vec::with_capacity(n); vec.set_len(n);` with `let vec = vec![0; n];`. The
|
||||
/// replacement has very different performance characteristics so the lint is
|
||||
/// deprecated.
|
||||
declare_deprecated_lint! {
|
||||
/// **What it does:** Nothing. This lint has been deprecated.
|
||||
///
|
||||
/// **Deprecation reason:** This lint used to suggest replacing `let mut vec =
|
||||
/// Vec::with_capacity(n); vec.set_len(n);` with `let vec = vec![0; n];`. The
|
||||
/// replacement has very different performance characteristics so the lint is
|
||||
/// deprecated.
|
||||
pub UNSAFE_VECTOR_INITIALIZATION,
|
||||
"the replacement suggested by this lint had substantially different behavior"
|
||||
}
|
||||
|
||||
/// **What it does:** Nothing. This lint has been deprecated.
|
||||
///
|
||||
/// **Deprecation reason:** This lint has been superseded by the warn-by-default
|
||||
/// `invalid_value` rustc lint.
|
||||
declare_deprecated_lint! {
|
||||
/// **What it does:** Nothing. This lint has been deprecated.
|
||||
///
|
||||
/// **Deprecation reason:** This lint has been superseded by the warn-by-default
|
||||
/// `invalid_value` rustc lint.
|
||||
pub INVALID_REF,
|
||||
"superseded by rustc lint `invalid_value`"
|
||||
}
|
||||
|
||||
/// **What it does:** Nothing. This lint has been deprecated.
|
||||
///
|
||||
/// **Deprecation reason:** This lint has been superseded by #[must_use] in rustc.
|
||||
declare_deprecated_lint! {
|
||||
/// **What it does:** Nothing. This lint has been deprecated.
|
||||
///
|
||||
/// **Deprecation reason:** This lint has been superseded by #[must_use] in rustc.
|
||||
pub UNUSED_COLLECT,
|
||||
"`collect` has been marked as #[must_use] in rustc and that covers all cases of this lint"
|
||||
}
|
||||
|
||||
declare_deprecated_lint! {
|
||||
/// **What it does:** Nothing. This lint has been deprecated.
|
||||
///
|
||||
/// **Deprecation reason:** This lint has been uplifted to rustc and is now called
|
||||
/// `array_into_iter`.
|
||||
pub INTO_ITER_ON_ARRAY,
|
||||
"this lint has been uplifted to rustc and is now called `array_into_iter`"
|
||||
}
|
||||
|
|
|
@ -6,7 +6,7 @@ use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
|
|||
use rustc::{declare_tool_lint, impl_lint_pass};
|
||||
use rustc_data_structures::fx::FxHashSet;
|
||||
use std::ops::Range;
|
||||
use syntax::ast::Attribute;
|
||||
use syntax::ast::{AttrKind, Attribute};
|
||||
use syntax::source_map::{BytePos, Span};
|
||||
use syntax_pos::Pos;
|
||||
use url::Url;
|
||||
|
@ -247,13 +247,11 @@ pub fn check_attrs<'a>(cx: &LateContext<'_, '_>, valid_idents: &FxHashSet<String
|
|||
let mut spans = vec![];
|
||||
|
||||
for attr in attrs {
|
||||
if attr.is_sugared_doc {
|
||||
if let Some(ref current) = attr.value_str() {
|
||||
let current = current.to_string();
|
||||
let (current, current_spans) = strip_doc_comment_decoration(¤t, attr.span);
|
||||
spans.extend_from_slice(¤t_spans);
|
||||
doc.push_str(¤t);
|
||||
}
|
||||
if let AttrKind::DocComment(ref comment) = attr.kind {
|
||||
let comment = comment.to_string();
|
||||
let (comment, current_spans) = strip_doc_comment_decoration(&comment, attr.span);
|
||||
spans.extend_from_slice(¤t_spans);
|
||||
doc.push_str(&comment);
|
||||
} else if attr.check_name(sym!(doc)) {
|
||||
// ignore mix of sugared and non-sugared doc
|
||||
return true; // don't trigger the safety check
|
||||
|
|
|
@ -43,7 +43,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for ExcessivePrecision {
|
|||
let ty = cx.tables.expr_ty(expr);
|
||||
if let ty::Float(fty) = ty.kind;
|
||||
if let hir::ExprKind::Lit(ref lit) = expr.kind;
|
||||
if let LitKind::Float(sym, _) | LitKind::FloatUnsuffixed(sym) = lit.node;
|
||||
if let LitKind::Float(sym, _) = lit.node;
|
||||
if let Some(sugg) = Self::check(sym, fty);
|
||||
then {
|
||||
span_lint_and_sugg(
|
||||
|
|
47
clippy_lints/src/exit.rs
Normal file
47
clippy_lints/src/exit.rs
Normal file
|
@ -0,0 +1,47 @@
|
|||
use crate::utils::{is_entrypoint_fn, match_def_path, paths, qpath_res, span_lint};
|
||||
use if_chain::if_chain;
|
||||
use rustc::hir::{Expr, ExprKind, Item, ItemKind, Node};
|
||||
use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
|
||||
use rustc::{declare_lint_pass, declare_tool_lint};
|
||||
|
||||
declare_clippy_lint! {
|
||||
/// **What it does:** `exit()` terminates the program and doesn't provide a
|
||||
/// stack trace.
|
||||
///
|
||||
/// **Why is this bad?** Ideally a program is terminated by finishing
|
||||
/// the main function.
|
||||
///
|
||||
/// **Known problems:** None.
|
||||
///
|
||||
/// **Example:**
|
||||
/// ```ignore
|
||||
/// std::process::exit(0)
|
||||
/// ```
|
||||
pub EXIT,
|
||||
restriction,
|
||||
"`std::process::exit` is called, terminating the program"
|
||||
}
|
||||
|
||||
declare_lint_pass!(Exit => [EXIT]);
|
||||
|
||||
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Exit {
|
||||
fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) {
|
||||
if_chain! {
|
||||
if let ExprKind::Call(ref path_expr, ref _args) = e.kind;
|
||||
if let ExprKind::Path(ref path) = path_expr.kind;
|
||||
if let Some(def_id) = qpath_res(cx, path, path_expr.hir_id).opt_def_id();
|
||||
if match_def_path(cx, def_id, &paths::EXIT);
|
||||
then {
|
||||
let parent = cx.tcx.hir().get_parent_item(e.hir_id);
|
||||
if let Some(Node::Item(Item{kind: ItemKind::Fn(..), ..})) = cx.tcx.hir().find(parent) {
|
||||
// If the next item up is a function we check if it is an entry point
|
||||
// and only then emit a linter warning
|
||||
let def_id = cx.tcx.hir().local_def_id(parent);
|
||||
if !is_entrypoint_fn(cx, def_id) {
|
||||
span_lint(cx, EXIT, e.span, "usage of `process::exit`");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
|
@ -188,6 +188,7 @@ pub mod escape;
|
|||
pub mod eta_reduction;
|
||||
pub mod eval_order_dependence;
|
||||
pub mod excessive_precision;
|
||||
pub mod exit;
|
||||
pub mod explicit_write;
|
||||
pub mod fallible_impl_from;
|
||||
pub mod format;
|
||||
|
@ -430,6 +431,10 @@ pub fn register_plugins(store: &mut lint::LintStore, sess: &Session, conf: &Conf
|
|||
"clippy::unused_collect",
|
||||
"`collect` has been marked as #[must_use] in rustc and that covers all cases of this lint",
|
||||
);
|
||||
store.register_removed(
|
||||
"clippy::into_iter_on_array",
|
||||
"this lint has been uplifted to rustc and is now called `array_into_iter`",
|
||||
);
|
||||
// end deprecated lints, do not remove this comment, it’s used in `update_lints`
|
||||
|
||||
// begin register lints, do not remove this comment, it’s used in `update_lints`
|
||||
|
@ -497,6 +502,7 @@ pub fn register_plugins(store: &mut lint::LintStore, sess: &Session, conf: &Conf
|
|||
&eval_order_dependence::DIVERGING_SUB_EXPRESSION,
|
||||
&eval_order_dependence::EVAL_ORDER_DEPENDENCE,
|
||||
&excessive_precision::EXCESSIVE_PRECISION,
|
||||
&exit::EXIT,
|
||||
&explicit_write::EXPLICIT_WRITE,
|
||||
&fallible_impl_from::FALLIBLE_IMPL_FROM,
|
||||
&format::USELESS_FORMAT,
|
||||
|
@ -584,7 +590,6 @@ pub fn register_plugins(store: &mut lint::LintStore, sess: &Session, conf: &Conf
|
|||
&methods::FLAT_MAP_IDENTITY,
|
||||
&methods::GET_UNWRAP,
|
||||
&methods::INEFFICIENT_TO_STRING,
|
||||
&methods::INTO_ITER_ON_ARRAY,
|
||||
&methods::INTO_ITER_ON_REF,
|
||||
&methods::ITER_CLONED_COLLECT,
|
||||
&methods::ITER_NTH,
|
||||
|
@ -938,12 +943,14 @@ pub fn register_plugins(store: &mut lint::LintStore, sess: &Session, conf: &Conf
|
|||
store.register_early_pass(move || box enum_variants::EnumVariantNames::new(enum_variant_name_threshold));
|
||||
store.register_late_pass(|| box unused_self::UnusedSelf);
|
||||
store.register_late_pass(|| box mutable_debug_assertion::DebugAssertWithMutCall);
|
||||
store.register_late_pass(|| box exit::Exit);
|
||||
|
||||
store.register_group(true, "clippy::restriction", Some("clippy_restriction"), vec![
|
||||
LintId::of(&arithmetic::FLOAT_ARITHMETIC),
|
||||
LintId::of(&arithmetic::INTEGER_ARITHMETIC),
|
||||
LintId::of(&dbg_macro::DBG_MACRO),
|
||||
LintId::of(&else_if_without_else::ELSE_IF_WITHOUT_ELSE),
|
||||
LintId::of(&exit::EXIT),
|
||||
LintId::of(&implicit_return::IMPLICIT_RETURN),
|
||||
LintId::of(&indexing_slicing::INDEXING_SLICING),
|
||||
LintId::of(&inherent_impl::MULTIPLE_INHERENT_IMPL),
|
||||
|
@ -1142,7 +1149,6 @@ pub fn register_plugins(store: &mut lint::LintStore, sess: &Session, conf: &Conf
|
|||
LintId::of(&methods::FILTER_NEXT),
|
||||
LintId::of(&methods::FLAT_MAP_IDENTITY),
|
||||
LintId::of(&methods::INEFFICIENT_TO_STRING),
|
||||
LintId::of(&methods::INTO_ITER_ON_ARRAY),
|
||||
LintId::of(&methods::INTO_ITER_ON_REF),
|
||||
LintId::of(&methods::ITER_CLONED_COLLECT),
|
||||
LintId::of(&methods::ITER_NTH),
|
||||
|
@ -1481,7 +1487,6 @@ pub fn register_plugins(store: &mut lint::LintStore, sess: &Session, conf: &Conf
|
|||
LintId::of(&mem_discriminant::MEM_DISCRIMINANT_NON_ENUM),
|
||||
LintId::of(&mem_replace::MEM_REPLACE_WITH_UNINIT),
|
||||
LintId::of(&methods::CLONE_DOUBLE_REF),
|
||||
LintId::of(&methods::INTO_ITER_ON_ARRAY),
|
||||
LintId::of(&methods::TEMPORARY_CSTRING_AS_PTR),
|
||||
LintId::of(&methods::UNINIT_ASSUMED_INIT),
|
||||
LintId::of(&minmax::MIN_MAX),
|
||||
|
|
|
@ -373,7 +373,7 @@ impl LiteralDigitGrouping {
|
|||
}
|
||||
}
|
||||
},
|
||||
LitKind::Float(..) | LitKind::FloatUnsuffixed(..) => {
|
||||
LitKind::Float(..) => {
|
||||
// Lint floating-point literals.
|
||||
if_chain! {
|
||||
if let Some(src) = snippet_opt(cx, lit.span);
|
||||
|
@ -509,17 +509,12 @@ impl DecimalLiteralRepresentation {
|
|||
fn check_lit(self, cx: &EarlyContext<'_>, lit: &Lit) {
|
||||
// Lint integral literals.
|
||||
if_chain! {
|
||||
if let LitKind::Int(..) = lit.kind;
|
||||
if let LitKind::Int(val, _) = lit.kind;
|
||||
if let Some(src) = snippet_opt(cx, lit.span);
|
||||
if let Some(firstch) = src.chars().next();
|
||||
if char::to_digit(firstch, 10).is_some();
|
||||
let digit_info = DigitInfo::new(&src, false);
|
||||
if digit_info.radix == Radix::Decimal;
|
||||
if let Ok(val) = digit_info.digits
|
||||
.chars()
|
||||
.filter(|&c| c != '_')
|
||||
.collect::<String>()
|
||||
.parse::<u128>();
|
||||
if val >= u128::from(self.threshold);
|
||||
then {
|
||||
let hex = format!("{:#X}", val);
|
||||
|
|
|
@ -1,6 +1,7 @@
|
|||
use rustc::hir::{Crate, Expr, ExprKind, QPath};
|
||||
use rustc::lint::{LateContext, LateLintPass, LintArray, LintPass};
|
||||
use rustc::{declare_tool_lint, impl_lint_pass};
|
||||
use syntax::ast::AttrKind;
|
||||
use syntax::symbol::sym;
|
||||
|
||||
use crate::utils::{is_entrypoint_fn, snippet, span_help_and_lint};
|
||||
|
@ -34,7 +35,13 @@ impl_lint_pass!(MainRecursion => [MAIN_RECURSION]);
|
|||
|
||||
impl LateLintPass<'_, '_> for MainRecursion {
|
||||
fn check_crate(&mut self, _: &LateContext<'_, '_>, krate: &Crate) {
|
||||
self.has_no_std_attr = krate.attrs.iter().any(|attr| attr.path == sym::no_std);
|
||||
self.has_no_std_attr = krate.attrs.iter().any(|attr| {
|
||||
if let AttrKind::Normal(ref attr) = attr.kind {
|
||||
attr.path == sym::no_std
|
||||
} else {
|
||||
false
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
fn check_expr_post(&mut self, cx: &LateContext<'_, '_>, expr: &Expr) {
|
||||
|
|
|
@ -17,7 +17,7 @@ use rustc::{declare_lint_pass, declare_tool_lint};
|
|||
use rustc_errors::Applicability;
|
||||
use syntax::ast;
|
||||
use syntax::source_map::Span;
|
||||
use syntax::symbol::{sym, LocalInternedString, Symbol};
|
||||
use syntax::symbol::{sym, Symbol, SymbolStr};
|
||||
|
||||
use crate::utils::usage::mutated_variables;
|
||||
use crate::utils::{
|
||||
|
@ -968,34 +968,6 @@ declare_clippy_lint! {
|
|||
"using `filter_map` when a more succinct alternative exists"
|
||||
}
|
||||
|
||||
declare_clippy_lint! {
|
||||
/// **What it does:** Checks for `into_iter` calls on types which should be replaced by `iter` or
|
||||
/// `iter_mut`.
|
||||
///
|
||||
/// **Why is this bad?** Arrays and `PathBuf` do not yet have an `into_iter` method which move out
|
||||
/// their content into an iterator. Auto-referencing resolves the `into_iter` call to its reference
|
||||
/// instead, like `<&[T; N] as IntoIterator>::into_iter`, which just iterates over item references
|
||||
/// like calling `iter` would. Furthermore, when the standard library actually
|
||||
/// [implements the `into_iter` method](https://github.com/rust-lang/rust/issues/25725) which moves
|
||||
/// the content out of the array, the original use of `into_iter` got inferred with the wrong type
|
||||
/// and the code will be broken.
|
||||
///
|
||||
/// **Known problems:** None
|
||||
///
|
||||
/// **Example:**
|
||||
///
|
||||
/// ```rust
|
||||
/// let _ = [1, 2, 3].into_iter().map(|x| *x).collect::<Vec<u32>>();
|
||||
/// ```
|
||||
/// Could be written as:
|
||||
/// ```rust
|
||||
/// let _ = [1, 2, 3].iter().map(|x| *x).collect::<Vec<u32>>();
|
||||
/// ```
|
||||
pub INTO_ITER_ON_ARRAY,
|
||||
correctness,
|
||||
"using `.into_iter()` on an array"
|
||||
}
|
||||
|
||||
declare_clippy_lint! {
|
||||
/// **What it does:** Checks for `into_iter` calls on references which should be replaced by `iter`
|
||||
/// or `iter_mut`.
|
||||
|
@ -1133,7 +1105,6 @@ declare_lint_pass!(Methods => [
|
|||
USELESS_ASREF,
|
||||
UNNECESSARY_FOLD,
|
||||
UNNECESSARY_FILTER_MAP,
|
||||
INTO_ITER_ON_ARRAY,
|
||||
INTO_ITER_ON_REF,
|
||||
SUSPICIOUS_MAP,
|
||||
UNINIT_ASSUMED_INIT,
|
||||
|
@ -1148,8 +1119,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Methods {
|
|||
}
|
||||
|
||||
let (method_names, arg_lists, method_spans) = method_calls(expr, 2);
|
||||
let method_names: Vec<LocalInternedString> = method_names.iter().map(|s| s.as_str()).collect();
|
||||
let method_names: Vec<&str> = method_names.iter().map(std::convert::AsRef::as_ref).collect();
|
||||
let method_names: Vec<SymbolStr> = method_names.iter().map(|s| s.as_str()).collect();
|
||||
let method_names: Vec<&str> = method_names.iter().map(|s| &**s).collect();
|
||||
|
||||
match method_names.as_slice() {
|
||||
["unwrap", "get"] => lint_get_unwrap(cx, expr, arg_lists[1], false),
|
||||
|
@ -2786,16 +2757,8 @@ fn lint_asref(cx: &LateContext<'_, '_>, expr: &hir::Expr, call_name: &str, as_re
|
|||
}
|
||||
}
|
||||
|
||||
fn ty_has_iter_method(
|
||||
cx: &LateContext<'_, '_>,
|
||||
self_ref_ty: Ty<'_>,
|
||||
) -> Option<(&'static Lint, &'static str, &'static str)> {
|
||||
fn ty_has_iter_method(cx: &LateContext<'_, '_>, self_ref_ty: Ty<'_>) -> Option<(&'static str, &'static str)> {
|
||||
has_iter_method(cx, self_ref_ty).map(|ty_name| {
|
||||
let lint = if ty_name == "array" || ty_name == "PathBuf" {
|
||||
INTO_ITER_ON_ARRAY
|
||||
} else {
|
||||
INTO_ITER_ON_REF
|
||||
};
|
||||
let mutbl = match self_ref_ty.kind {
|
||||
ty::Ref(_, _, mutbl) => mutbl,
|
||||
_ => unreachable!(),
|
||||
|
@ -2804,7 +2767,7 @@ fn ty_has_iter_method(
|
|||
hir::MutImmutable => "iter",
|
||||
hir::MutMutable => "iter_mut",
|
||||
};
|
||||
(lint, ty_name, method_name)
|
||||
(ty_name, method_name)
|
||||
})
|
||||
}
|
||||
|
||||
|
@ -2812,10 +2775,10 @@ fn lint_into_iter(cx: &LateContext<'_, '_>, expr: &hir::Expr, self_ref_ty: Ty<'_
|
|||
if !match_trait_method(cx, expr, &paths::INTO_ITERATOR) {
|
||||
return;
|
||||
}
|
||||
if let Some((lint, kind, method_name)) = ty_has_iter_method(cx, self_ref_ty) {
|
||||
if let Some((kind, method_name)) = ty_has_iter_method(cx, self_ref_ty) {
|
||||
span_lint_and_sugg(
|
||||
cx,
|
||||
lint,
|
||||
INTO_ITER_ON_REF,
|
||||
method_span,
|
||||
&format!(
|
||||
"this .into_iter() call is equivalent to .{}() and will not move the {}",
|
||||
|
|
|
@ -482,8 +482,8 @@ impl MiscEarlyLints {
|
|||
|
||||
if let LitKind::Int(value, lit_int_type) = lit.kind {
|
||||
let suffix = match lit_int_type {
|
||||
LitIntType::Signed(ty) => ty.ty_to_string(),
|
||||
LitIntType::Unsigned(ty) => ty.ty_to_string(),
|
||||
LitIntType::Signed(ty) => ty.name_str(),
|
||||
LitIntType::Unsigned(ty) => ty.name_str(),
|
||||
LitIntType::Unsuffixed => "",
|
||||
};
|
||||
|
||||
|
@ -543,8 +543,8 @@ impl MiscEarlyLints {
|
|||
},
|
||||
);
|
||||
}
|
||||
} else if let LitKind::Float(_, float_ty) = lit.kind {
|
||||
let suffix = float_ty.ty_to_string();
|
||||
} else if let LitKind::Float(_, LitFloatType::Suffixed(float_ty)) = lit.kind {
|
||||
let suffix = float_ty.name_str();
|
||||
let maybe_last_sep_idx = lit_snip.len() - suffix.len() - 1;
|
||||
if lit_snip.as_bytes()[maybe_last_sep_idx] != b'_' {
|
||||
span_lint_and_sugg(
|
||||
|
|
|
@ -5,7 +5,7 @@ use std::cmp::Ordering;
|
|||
use syntax::ast::*;
|
||||
use syntax::attr;
|
||||
use syntax::source_map::Span;
|
||||
use syntax::symbol::LocalInternedString;
|
||||
use syntax::symbol::SymbolStr;
|
||||
use syntax::visit::{walk_block, walk_expr, walk_pat, Visitor};
|
||||
|
||||
declare_clippy_lint! {
|
||||
|
@ -72,7 +72,7 @@ pub struct NonExpressiveNames {
|
|||
impl_lint_pass!(NonExpressiveNames => [SIMILAR_NAMES, MANY_SINGLE_CHAR_NAMES, JUST_UNDERSCORES_AND_DIGITS]);
|
||||
|
||||
struct ExistingName {
|
||||
interned: LocalInternedString,
|
||||
interned: SymbolStr,
|
||||
span: Span,
|
||||
len: usize,
|
||||
whitelist: &'static [&'static str],
|
||||
|
|
|
@ -50,7 +50,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for PathBufPushOverwrite {
|
|||
if let Some(get_index_arg) = args.get(1);
|
||||
if let ExprKind::Lit(ref lit) = get_index_arg.kind;
|
||||
if let LitKind::Str(ref path_lit, _) = lit.node;
|
||||
if let pushed_path = Path::new(&path_lit.as_str());
|
||||
if let pushed_path = Path::new(&*path_lit.as_str());
|
||||
if let Some(pushed_path_lit) = pushed_path.to_str();
|
||||
if pushed_path.has_root();
|
||||
if let Some(root) = pushed_path.components().next();
|
||||
|
|
|
@ -90,7 +90,7 @@ impl EarlyLintPass for Precedence {
|
|||
if let Some(slf) = args.first() {
|
||||
if let ExprKind::Lit(ref lit) = slf.kind {
|
||||
match lit.kind {
|
||||
LitKind::Int(..) | LitKind::Float(..) | LitKind::FloatUnsuffixed(..) => {
|
||||
LitKind::Int(..) | LitKind::Float(..) => {
|
||||
let mut applicability = Applicability::MachineApplicable;
|
||||
span_lint_and_sugg(
|
||||
cx,
|
||||
|
|
|
@ -390,7 +390,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Transmute {
|
|||
|db| {
|
||||
let arg = sugg::Sugg::hir(cx, &args[0], "..");
|
||||
let arg = if let ty::Int(_) = from_ty.kind {
|
||||
arg.as_ty(ast::UintTy::U32)
|
||||
arg.as_ty(ast::UintTy::U32.name_str())
|
||||
} else {
|
||||
arg
|
||||
};
|
||||
|
|
|
@ -15,7 +15,7 @@ use rustc::{declare_lint_pass, declare_tool_lint, impl_lint_pass};
|
|||
use rustc_errors::Applicability;
|
||||
use rustc_target::spec::abi::Abi;
|
||||
use rustc_typeck::hir_ty_to_ty;
|
||||
use syntax::ast::{FloatTy, IntTy, LitIntType, LitKind, UintTy};
|
||||
use syntax::ast::{FloatTy, IntTy, LitFloatType, LitIntType, LitKind, UintTy};
|
||||
use syntax::errors::DiagnosticBuilder;
|
||||
use syntax::source_map::Span;
|
||||
use syntax::symbol::{sym, Symbol};
|
||||
|
@ -1186,7 +1186,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Casts {
|
|||
}
|
||||
}
|
||||
match lit.node {
|
||||
LitKind::Int(_, LitIntType::Unsuffixed) | LitKind::FloatUnsuffixed(_) => {},
|
||||
LitKind::Int(_, LitIntType::Unsuffixed) | LitKind::Float(_, LitFloatType::Unsuffixed) => {},
|
||||
_ => {
|
||||
if cast_from.kind == cast_to.kind && !in_external_macro(cx.sess(), expr.span) {
|
||||
span_lint(
|
||||
|
|
|
@ -3,7 +3,7 @@ use rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass};
|
|||
use rustc::{declare_lint_pass, declare_tool_lint};
|
||||
use syntax::ast::*;
|
||||
use syntax::source_map::Span;
|
||||
use syntax::symbol::LocalInternedString;
|
||||
use syntax::symbol::SymbolStr;
|
||||
|
||||
declare_clippy_lint! {
|
||||
/// **What it does:** Checks for imports that remove "unsafe" from an item's
|
||||
|
@ -73,6 +73,6 @@ fn unsafe_to_safe_check(old_name: Ident, new_name: Ident, cx: &EarlyContext<'_>,
|
|||
}
|
||||
|
||||
#[must_use]
|
||||
fn contains_unsafe(name: &LocalInternedString) -> bool {
|
||||
fn contains_unsafe(name: &SymbolStr) -> bool {
|
||||
name.contains("Unsafe") || name.contains("unsafe")
|
||||
}
|
||||
|
|
|
@ -57,6 +57,11 @@ pub fn get_attr<'a>(
|
|||
name: &'static str,
|
||||
) -> impl Iterator<Item = &'a ast::Attribute> {
|
||||
attrs.iter().filter(move |attr| {
|
||||
let attr = if let ast::AttrKind::Normal(ref attr) = attr.kind {
|
||||
attr
|
||||
} else {
|
||||
return false;
|
||||
};
|
||||
let attr_segments = &attr.path.segments;
|
||||
if attr_segments.len() == 2 && attr_segments[0].ident.to_string() == "clippy" {
|
||||
if let Some(deprecation_status) =
|
||||
|
|
|
@ -9,7 +9,7 @@ use rustc::lint::{LateContext, LateLintPass, LintArray, LintContext, LintPass};
|
|||
use rustc::session::Session;
|
||||
use rustc::{declare_lint_pass, declare_tool_lint};
|
||||
use rustc_data_structures::fx::FxHashMap;
|
||||
use syntax::ast::{Attribute, LitKind};
|
||||
use syntax::ast::{Attribute, LitFloatType, LitKind};
|
||||
|
||||
declare_clippy_lint! {
|
||||
/// **What it does:** Generates clippy code that detects the offending pattern
|
||||
|
@ -288,10 +288,14 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
|
|||
LitKind::Byte(b) => println!(" if let LitKind::Byte({}) = {}.node;", b, lit_pat),
|
||||
// FIXME: also check int type
|
||||
LitKind::Int(i, _) => println!(" if let LitKind::Int({}, _) = {}.node;", i, lit_pat),
|
||||
LitKind::Float(..) => println!(" if let LitKind::Float(..) = {}.node;", lit_pat),
|
||||
LitKind::FloatUnsuffixed(_) => {
|
||||
println!(" if let LitKind::FloatUnsuffixed(_) = {}.node;", lit_pat)
|
||||
},
|
||||
LitKind::Float(_, LitFloatType::Suffixed(_)) => println!(
|
||||
" if let LitKind::Float(_, LitFloatType::Suffixed(_)) = {}.node;",
|
||||
lit_pat
|
||||
),
|
||||
LitKind::Float(_, LitFloatType::Unsuffixed) => println!(
|
||||
" if let LitKind::Float(_, LitFloatType::Unsuffixed) = {}.node;",
|
||||
lit_pat
|
||||
),
|
||||
LitKind::ByteStr(ref vec) => {
|
||||
let vec_pat = self.next("vec");
|
||||
println!(" if let LitKind::ByteStr(ref {}) = {}.node;", vec_pat, lit_pat);
|
||||
|
|
|
@ -451,6 +451,7 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
|
|||
CaptureClause::CaptureByRef => 1,
|
||||
}
|
||||
.hash(&mut self.s);
|
||||
// closures inherit TypeckTables
|
||||
self.hash_expr(&self.cx.tcx.hir().body(eid).value);
|
||||
},
|
||||
ExprKind::Field(ref e, ref f) => {
|
||||
|
@ -490,10 +491,7 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
|
|||
},
|
||||
ExprKind::Repeat(ref e, ref l_id) => {
|
||||
self.hash_expr(e);
|
||||
let full_table = self.tables;
|
||||
self.tables = self.cx.tcx.body_tables(l_id.body);
|
||||
self.hash_expr(&self.cx.tcx.hir().body(l_id.body).value);
|
||||
self.tables = full_table;
|
||||
self.hash_body(l_id.body);
|
||||
},
|
||||
ExprKind::Ret(ref e) => {
|
||||
if let Some(ref e) = *e {
|
||||
|
@ -609,7 +607,7 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
|
|||
},
|
||||
TyKind::Array(ty, anon_const) => {
|
||||
self.hash_ty(ty);
|
||||
self.hash_expr(&self.cx.tcx.hir().body(anon_const.body).value);
|
||||
self.hash_body(anon_const.body);
|
||||
},
|
||||
TyKind::Ptr(mut_ty) => {
|
||||
self.hash_ty(&mut_ty.ty);
|
||||
|
@ -660,9 +658,7 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
|
|||
match arg {
|
||||
GenericArg::Lifetime(ref l) => self.hash_lifetime(l),
|
||||
GenericArg::Type(ref ty) => self.hash_ty(&ty),
|
||||
GenericArg::Const(ref ca) => {
|
||||
self.hash_expr(&self.cx.tcx.hir().body(ca.value.body).value);
|
||||
},
|
||||
GenericArg::Const(ref ca) => self.hash_body(ca.value.body),
|
||||
}
|
||||
}
|
||||
},
|
||||
|
@ -670,9 +666,17 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
|
|||
self.hash_lifetime(lifetime);
|
||||
},
|
||||
TyKind::Typeof(anon_const) => {
|
||||
self.hash_expr(&self.cx.tcx.hir().body(anon_const.body).value);
|
||||
self.hash_body(anon_const.body);
|
||||
},
|
||||
TyKind::Err | TyKind::Infer | TyKind::Never => {},
|
||||
}
|
||||
}
|
||||
|
||||
pub fn hash_body(&mut self, body_id: BodyId) {
|
||||
// swap out TypeckTables when hashing a body
|
||||
let old_tables = self.tables;
|
||||
self.tables = self.cx.tcx.body_tables(body_id);
|
||||
self.hash_expr(&self.cx.tcx.hir().body(body_id).value);
|
||||
self.tables = old_tables;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -13,7 +13,7 @@ use rustc_data_structures::fx::{FxHashMap, FxHashSet};
|
|||
use rustc_errors::Applicability;
|
||||
use syntax::ast::{Crate as AstCrate, ItemKind, Name};
|
||||
use syntax::source_map::Span;
|
||||
use syntax_pos::symbol::LocalInternedString;
|
||||
use syntax_pos::symbol::SymbolStr;
|
||||
|
||||
declare_clippy_lint! {
|
||||
/// **What it does:** Checks for various things we like to keep tidy in clippy.
|
||||
|
@ -112,7 +112,7 @@ impl EarlyLintPass for ClippyLintsInternal {
|
|||
if let ItemKind::Mod(ref utils_mod) = utils.kind {
|
||||
if let Some(paths) = utils_mod.items.iter().find(|item| item.ident.name.as_str() == "paths") {
|
||||
if let ItemKind::Mod(ref paths_mod) = paths.kind {
|
||||
let mut last_name: Option<LocalInternedString> = None;
|
||||
let mut last_name: Option<SymbolStr> = None;
|
||||
for item in &*paths_mod.items {
|
||||
let name = item.ident.as_str();
|
||||
if let Some(ref last_name) = last_name {
|
||||
|
@ -279,8 +279,8 @@ declare_lint_pass!(OuterExpnDataPass => [OUTER_EXPN_EXPN_DATA]);
|
|||
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for OuterExpnDataPass {
|
||||
fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx hir::Expr) {
|
||||
let (method_names, arg_lists, spans) = method_calls(expr, 2);
|
||||
let method_names: Vec<LocalInternedString> = method_names.iter().map(|s| s.as_str()).collect();
|
||||
let method_names: Vec<&str> = method_names.iter().map(std::convert::AsRef::as_ref).collect();
|
||||
let method_names: Vec<SymbolStr> = method_names.iter().map(|s| s.as_str()).collect();
|
||||
let method_names: Vec<&str> = method_names.iter().map(|s| &**s).collect();
|
||||
if_chain! {
|
||||
if let ["expn_data", "outer_expn"] = method_names.as_slice();
|
||||
let args = arg_lists[1];
|
||||
|
|
|
@ -27,6 +27,7 @@ pub const DROP: [&str; 3] = ["core", "mem", "drop"];
|
|||
pub const DROP_TRAIT: [&str; 4] = ["core", "ops", "drop", "Drop"];
|
||||
pub const DURATION: [&str; 3] = ["core", "time", "Duration"];
|
||||
pub const EARLY_CONTEXT: [&str; 4] = ["rustc", "lint", "context", "EarlyContext"];
|
||||
pub const EXIT: [&str; 3] = ["std", "process", "exit"];
|
||||
pub const FMT_ARGUMENTS_NEW_V1: [&str; 4] = ["core", "fmt", "Arguments", "new_v1"];
|
||||
pub const FMT_ARGUMENTS_NEW_V1_FORMATTED: [&str; 4] = ["core", "fmt", "Arguments", "new_v1_formatted"];
|
||||
pub const FMT_ARGUMENTV1_NEW: [&str; 4] = ["core", "fmt", "ArgumentV1", "new"];
|
||||
|
|
|
@ -12,9 +12,9 @@ use std::borrow::Cow;
|
|||
use std::convert::TryInto;
|
||||
use std::fmt::Display;
|
||||
use syntax::ast;
|
||||
use syntax::parse::token;
|
||||
use syntax::print::pprust::token_kind_to_string;
|
||||
use syntax::source_map::{CharPos, Span};
|
||||
use syntax::token;
|
||||
use syntax::util::parser::AssocOp;
|
||||
use syntax_pos::{BytePos, Pos};
|
||||
|
||||
|
@ -440,7 +440,7 @@ fn associativity(op: &AssocOp) -> Associativity {
|
|||
|
||||
/// Converts a `hir::BinOp` to the corresponding assigning binary operator.
|
||||
fn hirbinop2assignop(op: hir::BinOp) -> AssocOp {
|
||||
use syntax::parse::token::BinOpToken::*;
|
||||
use syntax::token::BinOpToken::*;
|
||||
|
||||
AssocOp::AssignOp(match op.node {
|
||||
hir::BinOpKind::Add => Plus,
|
||||
|
@ -468,7 +468,7 @@ fn hirbinop2assignop(op: hir::BinOp) -> AssocOp {
|
|||
/// Converts an `ast::BinOp` to the corresponding assigning binary operator.
|
||||
fn astbinop2assignop(op: ast::BinOp) -> AssocOp {
|
||||
use syntax::ast::BinOpKind::*;
|
||||
use syntax::parse::token::BinOpToken;
|
||||
use syntax::token::BinOpToken;
|
||||
|
||||
AssocOp::AssignOp(match op.node {
|
||||
Add => BinOpToken::Plus,
|
||||
|
|
|
@ -4,7 +4,8 @@ use rustc::{declare_lint_pass, declare_tool_lint};
|
|||
use rustc_errors::Applicability;
|
||||
use std::borrow::Cow;
|
||||
use syntax::ast::*;
|
||||
use syntax::parse::{parser, token};
|
||||
use syntax::parse::parser;
|
||||
use syntax::token;
|
||||
use syntax::tokenstream::TokenStream;
|
||||
use syntax_pos::{BytePos, Span};
|
||||
|
||||
|
|
|
@ -490,6 +490,13 @@ pub const ALL_LINTS: [Lint; 332] = [
|
|||
deprecation: None,
|
||||
module: "excessive_precision",
|
||||
},
|
||||
Lint {
|
||||
name: "exit",
|
||||
group: "restriction",
|
||||
desc: "`std::process::exit` is called, terminating the program",
|
||||
deprecation: None,
|
||||
module: "exit",
|
||||
},
|
||||
Lint {
|
||||
name: "expect_fun_call",
|
||||
group: "perf",
|
||||
|
@ -812,13 +819,6 @@ pub const ALL_LINTS: [Lint; 332] = [
|
|||
deprecation: None,
|
||||
module: "integer_division",
|
||||
},
|
||||
Lint {
|
||||
name: "into_iter_on_array",
|
||||
group: "correctness",
|
||||
desc: "using `.into_iter()` on an array",
|
||||
deprecation: None,
|
||||
module: "methods",
|
||||
},
|
||||
Lint {
|
||||
name: "into_iter_on_ref",
|
||||
group: "style",
|
||||
|
|
|
@ -16,7 +16,7 @@ pub fn derive(_: TokenStream) -> TokenStream {
|
|||
let output = quote! {
|
||||
// Should not trigger `useless_attribute`
|
||||
#[allow(dead_code)]
|
||||
extern crate clippy_lints;
|
||||
extern crate rustc;
|
||||
};
|
||||
output
|
||||
}
|
||||
|
|
|
@ -10,9 +10,11 @@ error[E0308]: mismatched types
|
|||
--> $DIR/builtin-type-shadow.rs:5:5
|
||||
|
|
||||
LL | fn foo<u32>(a: u32) -> u32 {
|
||||
| --- expected `u32` because of return type
|
||||
| --- --- expected `u32` because of return type
|
||||
| |
|
||||
| this type parameter
|
||||
LL | 42
|
||||
| ^^ expected type parameter, found integer
|
||||
| ^^ expected type parameter `u32`, found integer
|
||||
|
|
||||
= note: expected type `u32`
|
||||
found type `{integer}`
|
||||
|
|
10
tests/ui/crashes/ice-4760.rs
Normal file
10
tests/ui/crashes/ice-4760.rs
Normal file
|
@ -0,0 +1,10 @@
|
|||
// run-pass
|
||||
const COUNT: usize = 2;
|
||||
struct Thing;
|
||||
trait Dummy {}
|
||||
|
||||
const _: () = {
|
||||
impl Dummy for Thing where [i32; COUNT]: Sized {}
|
||||
};
|
||||
|
||||
fn main() {}
|
|
@ -5,5 +5,6 @@
|
|||
#[warn(clippy::misaligned_transmute)]
|
||||
#[warn(clippy::unused_collect)]
|
||||
#[warn(clippy::invalid_ref)]
|
||||
#[warn(clippy::into_iter_on_array)]
|
||||
|
||||
fn main() {}
|
||||
|
|
|
@ -42,11 +42,17 @@ error: lint `clippy::invalid_ref` has been removed: `superseded by rustc lint `i
|
|||
LL | #[warn(clippy::invalid_ref)]
|
||||
| ^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
error: lint `clippy::into_iter_on_array` has been removed: `this lint has been uplifted to rustc and is now called `array_into_iter``
|
||||
--> $DIR/deprecated.rs:8:8
|
||||
|
|
||||
LL | #[warn(clippy::into_iter_on_array)]
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
error: lint `clippy::str_to_string` has been removed: `using `str::to_string` is common even today and specialization will likely happen soon`
|
||||
--> $DIR/deprecated.rs:1:8
|
||||
|
|
||||
LL | #[warn(clippy::str_to_string)]
|
||||
| ^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
error: aborting due to 8 previous errors
|
||||
error: aborting due to 9 previous errors
|
||||
|
||||
|
|
15
tests/ui/exit1.rs
Normal file
15
tests/ui/exit1.rs
Normal file
|
@ -0,0 +1,15 @@
|
|||
#[warn(clippy::exit)]
|
||||
|
||||
fn not_main() {
|
||||
if true {
|
||||
std::process::exit(4);
|
||||
}
|
||||
}
|
||||
|
||||
fn main() {
|
||||
if true {
|
||||
std::process::exit(2);
|
||||
};
|
||||
not_main();
|
||||
std::process::exit(1);
|
||||
}
|
10
tests/ui/exit1.stderr
Normal file
10
tests/ui/exit1.stderr
Normal file
|
@ -0,0 +1,10 @@
|
|||
error: usage of `process::exit`
|
||||
--> $DIR/exit1.rs:5:9
|
||||
|
|
||||
LL | std::process::exit(4);
|
||||
| ^^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= note: `-D clippy::exit` implied by `-D warnings`
|
||||
|
||||
error: aborting due to previous error
|
||||
|
13
tests/ui/exit2.rs
Normal file
13
tests/ui/exit2.rs
Normal file
|
@ -0,0 +1,13 @@
|
|||
#[warn(clippy::exit)]
|
||||
|
||||
fn also_not_main() {
|
||||
std::process::exit(3);
|
||||
}
|
||||
|
||||
fn main() {
|
||||
if true {
|
||||
std::process::exit(2);
|
||||
};
|
||||
also_not_main();
|
||||
std::process::exit(1);
|
||||
}
|
10
tests/ui/exit2.stderr
Normal file
10
tests/ui/exit2.stderr
Normal file
|
@ -0,0 +1,10 @@
|
|||
error: usage of `process::exit`
|
||||
--> $DIR/exit2.rs:4:5
|
||||
|
|
||||
LL | std::process::exit(3);
|
||||
| ^^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= note: `-D clippy::exit` implied by `-D warnings`
|
||||
|
||||
error: aborting due to previous error
|
||||
|
8
tests/ui/exit3.rs
Normal file
8
tests/ui/exit3.rs
Normal file
|
@ -0,0 +1,8 @@
|
|||
#[warn(clippy::exit)]
|
||||
|
||||
fn main() {
|
||||
if true {
|
||||
std::process::exit(2);
|
||||
};
|
||||
std::process::exit(1);
|
||||
}
|
|
@ -31,7 +31,7 @@ impl Unrelated {
|
|||
clippy::cognitive_complexity,
|
||||
clippy::similar_names
|
||||
)]
|
||||
#[allow(clippy::many_single_char_names, unused_variables, clippy::into_iter_on_array)]
|
||||
#[allow(clippy::many_single_char_names, unused_variables)]
|
||||
fn main() {
|
||||
const MAX_LEN: usize = 42;
|
||||
let mut vec = vec![1, 2, 3, 4];
|
||||
|
@ -102,9 +102,6 @@ fn main() {
|
|||
let out_vec = vec![1, 2, 3];
|
||||
for _v in out_vec {}
|
||||
|
||||
let array = [1, 2, 3];
|
||||
for _v in &array {}
|
||||
|
||||
for _v in &vec {} // these are fine
|
||||
for _v in &mut vec {} // these are fine
|
||||
|
||||
|
|
|
@ -31,7 +31,7 @@ impl Unrelated {
|
|||
clippy::cognitive_complexity,
|
||||
clippy::similar_names
|
||||
)]
|
||||
#[allow(clippy::many_single_char_names, unused_variables, clippy::into_iter_on_array)]
|
||||
#[allow(clippy::many_single_char_names, unused_variables)]
|
||||
fn main() {
|
||||
const MAX_LEN: usize = 42;
|
||||
let mut vec = vec![1, 2, 3, 4];
|
||||
|
@ -102,9 +102,6 @@ fn main() {
|
|||
let out_vec = vec![1, 2, 3];
|
||||
for _v in out_vec.into_iter() {}
|
||||
|
||||
let array = [1, 2, 3];
|
||||
for _v in array.into_iter() {}
|
||||
|
||||
for _v in &vec {} // these are fine
|
||||
for _v in &mut vec {} // these are fine
|
||||
|
||||
|
|
|
@ -77,64 +77,58 @@ LL | for _v in out_vec.into_iter() {}
|
|||
= note: `-D clippy::explicit-into-iter-loop` implied by `-D warnings`
|
||||
|
||||
error: it is more concise to loop over references to containers instead of using explicit iteration methods
|
||||
--> $DIR/for_loop_fixable.rs:106:15
|
||||
|
|
||||
LL | for _v in array.into_iter() {}
|
||||
| ^^^^^^^^^^^^^^^^^ help: to write this more concisely, try: `&array`
|
||||
|
||||
error: it is more concise to loop over references to containers instead of using explicit iteration methods
|
||||
--> $DIR/for_loop_fixable.rs:111:15
|
||||
--> $DIR/for_loop_fixable.rs:108:15
|
||||
|
|
||||
LL | for _v in [1, 2, 3].iter() {}
|
||||
| ^^^^^^^^^^^^^^^^ help: to write this more concisely, try: `&[1, 2, 3]`
|
||||
|
||||
error: it is more concise to loop over references to containers instead of using explicit iteration methods
|
||||
--> $DIR/for_loop_fixable.rs:115:15
|
||||
--> $DIR/for_loop_fixable.rs:112:15
|
||||
|
|
||||
LL | for _v in [0; 32].iter() {}
|
||||
| ^^^^^^^^^^^^^^ help: to write this more concisely, try: `&[0; 32]`
|
||||
|
||||
error: it is more concise to loop over references to containers instead of using explicit iteration methods
|
||||
--> $DIR/for_loop_fixable.rs:120:15
|
||||
--> $DIR/for_loop_fixable.rs:117:15
|
||||
|
|
||||
LL | for _v in ll.iter() {}
|
||||
| ^^^^^^^^^ help: to write this more concisely, try: `&ll`
|
||||
|
||||
error: it is more concise to loop over references to containers instead of using explicit iteration methods
|
||||
--> $DIR/for_loop_fixable.rs:123:15
|
||||
--> $DIR/for_loop_fixable.rs:120:15
|
||||
|
|
||||
LL | for _v in vd.iter() {}
|
||||
| ^^^^^^^^^ help: to write this more concisely, try: `&vd`
|
||||
|
||||
error: it is more concise to loop over references to containers instead of using explicit iteration methods
|
||||
--> $DIR/for_loop_fixable.rs:126:15
|
||||
--> $DIR/for_loop_fixable.rs:123:15
|
||||
|
|
||||
LL | for _v in bh.iter() {}
|
||||
| ^^^^^^^^^ help: to write this more concisely, try: `&bh`
|
||||
|
||||
error: it is more concise to loop over references to containers instead of using explicit iteration methods
|
||||
--> $DIR/for_loop_fixable.rs:129:15
|
||||
--> $DIR/for_loop_fixable.rs:126:15
|
||||
|
|
||||
LL | for _v in hm.iter() {}
|
||||
| ^^^^^^^^^ help: to write this more concisely, try: `&hm`
|
||||
|
||||
error: it is more concise to loop over references to containers instead of using explicit iteration methods
|
||||
--> $DIR/for_loop_fixable.rs:132:15
|
||||
--> $DIR/for_loop_fixable.rs:129:15
|
||||
|
|
||||
LL | for _v in bt.iter() {}
|
||||
| ^^^^^^^^^ help: to write this more concisely, try: `&bt`
|
||||
|
||||
error: it is more concise to loop over references to containers instead of using explicit iteration methods
|
||||
--> $DIR/for_loop_fixable.rs:135:15
|
||||
--> $DIR/for_loop_fixable.rs:132:15
|
||||
|
|
||||
LL | for _v in hs.iter() {}
|
||||
| ^^^^^^^^^ help: to write this more concisely, try: `&hs`
|
||||
|
||||
error: it is more concise to loop over references to containers instead of using explicit iteration methods
|
||||
--> $DIR/for_loop_fixable.rs:138:15
|
||||
--> $DIR/for_loop_fixable.rs:135:15
|
||||
|
|
||||
LL | for _v in bs.iter() {}
|
||||
| ^^^^^^^^^ help: to write this more concisely, try: `&bs`
|
||||
|
||||
error: aborting due to 18 previous errors
|
||||
error: aborting due to 17 previous errors
|
||||
|
||||
|
|
|
@ -17,7 +17,7 @@
|
|||
unused,
|
||||
dead_code
|
||||
)]
|
||||
#[allow(clippy::many_single_char_names, unused_variables, clippy::into_iter_on_array)]
|
||||
#[allow(clippy::many_single_char_names, unused_variables)]
|
||||
fn main() {
|
||||
for i in 5..5 {
|
||||
println!("{}", i);
|
||||
|
|
|
@ -31,12 +31,12 @@ fn bad_multiline(
|
|||
extern "C" fn extern_fn(
|
||||
_one: u32,
|
||||
_two: u32,
|
||||
_three: &str,
|
||||
_three: *const u8,
|
||||
_four: bool,
|
||||
_five: f32,
|
||||
_six: f32,
|
||||
_seven: bool,
|
||||
_eight: (),
|
||||
_eight: *const std::ffi::c_void,
|
||||
) {
|
||||
}
|
||||
|
||||
|
|
|
@ -1,7 +1,6 @@
|
|||
// run-rustfix
|
||||
#![allow(clippy::useless_vec)]
|
||||
#![warn(clippy::into_iter_on_ref)]
|
||||
#![deny(clippy::into_iter_on_array)]
|
||||
|
||||
struct X;
|
||||
use std::collections::*;
|
||||
|
@ -10,9 +9,7 @@ fn main() {
|
|||
for _ in &[1, 2, 3] {}
|
||||
for _ in vec![X, X] {}
|
||||
for _ in &vec![X, X] {}
|
||||
for _ in [1, 2, 3].iter() {} //~ ERROR equivalent to .iter()
|
||||
|
||||
let _ = [1, 2, 3].iter(); //~ ERROR equivalent to .iter()
|
||||
let _ = vec![1, 2, 3].into_iter();
|
||||
let _ = (&vec![1, 2, 3]).iter(); //~ WARN equivalent to .iter()
|
||||
let _ = vec![1, 2, 3].into_boxed_slice().iter(); //~ WARN equivalent to .iter()
|
||||
|
|
|
@ -1,7 +1,6 @@
|
|||
// run-rustfix
|
||||
#![allow(clippy::useless_vec)]
|
||||
#![warn(clippy::into_iter_on_ref)]
|
||||
#![deny(clippy::into_iter_on_array)]
|
||||
|
||||
struct X;
|
||||
use std::collections::*;
|
||||
|
@ -10,9 +9,7 @@ fn main() {
|
|||
for _ in &[1, 2, 3] {}
|
||||
for _ in vec![X, X] {}
|
||||
for _ in &vec![X, X] {}
|
||||
for _ in [1, 2, 3].into_iter() {} //~ ERROR equivalent to .iter()
|
||||
|
||||
let _ = [1, 2, 3].into_iter(); //~ ERROR equivalent to .iter()
|
||||
let _ = vec![1, 2, 3].into_iter();
|
||||
let _ = (&vec![1, 2, 3]).into_iter(); //~ WARN equivalent to .iter()
|
||||
let _ = vec![1, 2, 3].into_boxed_slice().into_iter(); //~ WARN equivalent to .iter()
|
||||
|
|
|
@ -1,23 +1,5 @@
|
|||
error: this .into_iter() call is equivalent to .iter() and will not move the array
|
||||
--> $DIR/into_iter_on_ref.rs:13:24
|
||||
|
|
||||
LL | for _ in [1, 2, 3].into_iter() {} //~ ERROR equivalent to .iter()
|
||||
| ^^^^^^^^^ help: call directly: `iter`
|
||||
|
|
||||
note: lint level defined here
|
||||
--> $DIR/into_iter_on_ref.rs:4:9
|
||||
|
|
||||
LL | #![deny(clippy::into_iter_on_array)]
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
error: this .into_iter() call is equivalent to .iter() and will not move the array
|
||||
--> $DIR/into_iter_on_ref.rs:15:23
|
||||
|
|
||||
LL | let _ = [1, 2, 3].into_iter(); //~ ERROR equivalent to .iter()
|
||||
| ^^^^^^^^^ help: call directly: `iter`
|
||||
|
||||
error: this .into_iter() call is equivalent to .iter() and will not move the Vec
|
||||
--> $DIR/into_iter_on_ref.rs:17:30
|
||||
--> $DIR/into_iter_on_ref.rs:14:30
|
||||
|
|
||||
LL | let _ = (&vec![1, 2, 3]).into_iter(); //~ WARN equivalent to .iter()
|
||||
| ^^^^^^^^^ help: call directly: `iter`
|
||||
|
@ -25,154 +7,154 @@ LL | let _ = (&vec![1, 2, 3]).into_iter(); //~ WARN equivalent to .iter()
|
|||
= note: `-D clippy::into-iter-on-ref` implied by `-D warnings`
|
||||
|
||||
error: this .into_iter() call is equivalent to .iter() and will not move the slice
|
||||
--> $DIR/into_iter_on_ref.rs:18:46
|
||||
--> $DIR/into_iter_on_ref.rs:15:46
|
||||
|
|
||||
LL | let _ = vec![1, 2, 3].into_boxed_slice().into_iter(); //~ WARN equivalent to .iter()
|
||||
| ^^^^^^^^^ help: call directly: `iter`
|
||||
|
||||
error: this .into_iter() call is equivalent to .iter() and will not move the slice
|
||||
--> $DIR/into_iter_on_ref.rs:19:41
|
||||
--> $DIR/into_iter_on_ref.rs:16:41
|
||||
|
|
||||
LL | let _ = std::rc::Rc::from(&[X][..]).into_iter(); //~ WARN equivalent to .iter()
|
||||
| ^^^^^^^^^ help: call directly: `iter`
|
||||
|
||||
error: this .into_iter() call is equivalent to .iter() and will not move the slice
|
||||
--> $DIR/into_iter_on_ref.rs:20:44
|
||||
--> $DIR/into_iter_on_ref.rs:17:44
|
||||
|
|
||||
LL | let _ = std::sync::Arc::from(&[X][..]).into_iter(); //~ WARN equivalent to .iter()
|
||||
| ^^^^^^^^^ help: call directly: `iter`
|
||||
|
||||
error: this .into_iter() call is equivalent to .iter() and will not move the array
|
||||
--> $DIR/into_iter_on_ref.rs:22:32
|
||||
--> $DIR/into_iter_on_ref.rs:19:32
|
||||
|
|
||||
LL | let _ = (&&&&&&&[1, 2, 3]).into_iter(); //~ ERROR equivalent to .iter()
|
||||
| ^^^^^^^^^ help: call directly: `iter`
|
||||
|
||||
error: this .into_iter() call is equivalent to .iter() and will not move the array
|
||||
--> $DIR/into_iter_on_ref.rs:23:36
|
||||
--> $DIR/into_iter_on_ref.rs:20:36
|
||||
|
|
||||
LL | let _ = (&&&&mut &&&[1, 2, 3]).into_iter(); //~ ERROR equivalent to .iter()
|
||||
| ^^^^^^^^^ help: call directly: `iter`
|
||||
|
||||
error: this .into_iter() call is equivalent to .iter_mut() and will not move the array
|
||||
--> $DIR/into_iter_on_ref.rs:24:40
|
||||
--> $DIR/into_iter_on_ref.rs:21:40
|
||||
|
|
||||
LL | let _ = (&mut &mut &mut [1, 2, 3]).into_iter(); //~ ERROR equivalent to .iter_mut()
|
||||
| ^^^^^^^^^ help: call directly: `iter_mut`
|
||||
|
||||
error: this .into_iter() call is equivalent to .iter() and will not move the Option
|
||||
--> $DIR/into_iter_on_ref.rs:26:24
|
||||
--> $DIR/into_iter_on_ref.rs:23:24
|
||||
|
|
||||
LL | let _ = (&Some(4)).into_iter(); //~ WARN equivalent to .iter()
|
||||
| ^^^^^^^^^ help: call directly: `iter`
|
||||
|
||||
error: this .into_iter() call is equivalent to .iter_mut() and will not move the Option
|
||||
--> $DIR/into_iter_on_ref.rs:27:28
|
||||
--> $DIR/into_iter_on_ref.rs:24:28
|
||||
|
|
||||
LL | let _ = (&mut Some(5)).into_iter(); //~ WARN equivalent to .iter_mut()
|
||||
| ^^^^^^^^^ help: call directly: `iter_mut`
|
||||
|
||||
error: this .into_iter() call is equivalent to .iter() and will not move the Result
|
||||
--> $DIR/into_iter_on_ref.rs:28:32
|
||||
--> $DIR/into_iter_on_ref.rs:25:32
|
||||
|
|
||||
LL | let _ = (&Ok::<_, i32>(6)).into_iter(); //~ WARN equivalent to .iter()
|
||||
| ^^^^^^^^^ help: call directly: `iter`
|
||||
|
||||
error: this .into_iter() call is equivalent to .iter_mut() and will not move the Result
|
||||
--> $DIR/into_iter_on_ref.rs:29:37
|
||||
--> $DIR/into_iter_on_ref.rs:26:37
|
||||
|
|
||||
LL | let _ = (&mut Err::<i32, _>(7)).into_iter(); //~ WARN equivalent to .iter_mut()
|
||||
| ^^^^^^^^^ help: call directly: `iter_mut`
|
||||
|
||||
error: this .into_iter() call is equivalent to .iter() and will not move the Vec
|
||||
--> $DIR/into_iter_on_ref.rs:30:34
|
||||
--> $DIR/into_iter_on_ref.rs:27:34
|
||||
|
|
||||
LL | let _ = (&Vec::<i32>::new()).into_iter(); //~ WARN equivalent to .iter()
|
||||
| ^^^^^^^^^ help: call directly: `iter`
|
||||
|
||||
error: this .into_iter() call is equivalent to .iter_mut() and will not move the Vec
|
||||
--> $DIR/into_iter_on_ref.rs:31:38
|
||||
--> $DIR/into_iter_on_ref.rs:28:38
|
||||
|
|
||||
LL | let _ = (&mut Vec::<i32>::new()).into_iter(); //~ WARN equivalent to .iter_mut()
|
||||
| ^^^^^^^^^ help: call directly: `iter_mut`
|
||||
|
||||
error: this .into_iter() call is equivalent to .iter() and will not move the BTreeMap
|
||||
--> $DIR/into_iter_on_ref.rs:32:44
|
||||
--> $DIR/into_iter_on_ref.rs:29:44
|
||||
|
|
||||
LL | let _ = (&BTreeMap::<i32, u64>::new()).into_iter(); //~ WARN equivalent to .iter()
|
||||
| ^^^^^^^^^ help: call directly: `iter`
|
||||
|
||||
error: this .into_iter() call is equivalent to .iter_mut() and will not move the BTreeMap
|
||||
--> $DIR/into_iter_on_ref.rs:33:48
|
||||
--> $DIR/into_iter_on_ref.rs:30:48
|
||||
|
|
||||
LL | let _ = (&mut BTreeMap::<i32, u64>::new()).into_iter(); //~ WARN equivalent to .iter_mut()
|
||||
| ^^^^^^^^^ help: call directly: `iter_mut`
|
||||
|
||||
error: this .into_iter() call is equivalent to .iter() and will not move the VecDeque
|
||||
--> $DIR/into_iter_on_ref.rs:34:39
|
||||
--> $DIR/into_iter_on_ref.rs:31:39
|
||||
|
|
||||
LL | let _ = (&VecDeque::<i32>::new()).into_iter(); //~ WARN equivalent to .iter()
|
||||
| ^^^^^^^^^ help: call directly: `iter`
|
||||
|
||||
error: this .into_iter() call is equivalent to .iter_mut() and will not move the VecDeque
|
||||
--> $DIR/into_iter_on_ref.rs:35:43
|
||||
--> $DIR/into_iter_on_ref.rs:32:43
|
||||
|
|
||||
LL | let _ = (&mut VecDeque::<i32>::new()).into_iter(); //~ WARN equivalent to .iter_mut()
|
||||
| ^^^^^^^^^ help: call directly: `iter_mut`
|
||||
|
||||
error: this .into_iter() call is equivalent to .iter() and will not move the LinkedList
|
||||
--> $DIR/into_iter_on_ref.rs:36:41
|
||||
--> $DIR/into_iter_on_ref.rs:33:41
|
||||
|
|
||||
LL | let _ = (&LinkedList::<i32>::new()).into_iter(); //~ WARN equivalent to .iter()
|
||||
| ^^^^^^^^^ help: call directly: `iter`
|
||||
|
||||
error: this .into_iter() call is equivalent to .iter_mut() and will not move the LinkedList
|
||||
--> $DIR/into_iter_on_ref.rs:37:45
|
||||
--> $DIR/into_iter_on_ref.rs:34:45
|
||||
|
|
||||
LL | let _ = (&mut LinkedList::<i32>::new()).into_iter(); //~ WARN equivalent to .iter_mut()
|
||||
| ^^^^^^^^^ help: call directly: `iter_mut`
|
||||
|
||||
error: this .into_iter() call is equivalent to .iter() and will not move the HashMap
|
||||
--> $DIR/into_iter_on_ref.rs:38:43
|
||||
--> $DIR/into_iter_on_ref.rs:35:43
|
||||
|
|
||||
LL | let _ = (&HashMap::<i32, u64>::new()).into_iter(); //~ WARN equivalent to .iter()
|
||||
| ^^^^^^^^^ help: call directly: `iter`
|
||||
|
||||
error: this .into_iter() call is equivalent to .iter_mut() and will not move the HashMap
|
||||
--> $DIR/into_iter_on_ref.rs:39:47
|
||||
--> $DIR/into_iter_on_ref.rs:36:47
|
||||
|
|
||||
LL | let _ = (&mut HashMap::<i32, u64>::new()).into_iter(); //~ WARN equivalent to .iter_mut()
|
||||
| ^^^^^^^^^ help: call directly: `iter_mut`
|
||||
|
||||
error: this .into_iter() call is equivalent to .iter() and will not move the BTreeSet
|
||||
--> $DIR/into_iter_on_ref.rs:41:39
|
||||
--> $DIR/into_iter_on_ref.rs:38:39
|
||||
|
|
||||
LL | let _ = (&BTreeSet::<i32>::new()).into_iter(); //~ WARN equivalent to .iter()
|
||||
| ^^^^^^^^^ help: call directly: `iter`
|
||||
|
||||
error: this .into_iter() call is equivalent to .iter() and will not move the BinaryHeap
|
||||
--> $DIR/into_iter_on_ref.rs:42:41
|
||||
--> $DIR/into_iter_on_ref.rs:39:41
|
||||
|
|
||||
LL | let _ = (&BinaryHeap::<i32>::new()).into_iter(); //~ WARN equivalent to .iter()
|
||||
| ^^^^^^^^^ help: call directly: `iter`
|
||||
|
||||
error: this .into_iter() call is equivalent to .iter() and will not move the HashSet
|
||||
--> $DIR/into_iter_on_ref.rs:43:38
|
||||
--> $DIR/into_iter_on_ref.rs:40:38
|
||||
|
|
||||
LL | let _ = (&HashSet::<i32>::new()).into_iter(); //~ WARN equivalent to .iter()
|
||||
| ^^^^^^^^^ help: call directly: `iter`
|
||||
|
||||
error: this .into_iter() call is equivalent to .iter() and will not move the Path
|
||||
--> $DIR/into_iter_on_ref.rs:44:43
|
||||
--> $DIR/into_iter_on_ref.rs:41:43
|
||||
|
|
||||
LL | let _ = std::path::Path::new("12/34").into_iter(); //~ WARN equivalent to .iter()
|
||||
| ^^^^^^^^^ help: call directly: `iter`
|
||||
|
||||
error: this .into_iter() call is equivalent to .iter() and will not move the PathBuf
|
||||
--> $DIR/into_iter_on_ref.rs:45:47
|
||||
--> $DIR/into_iter_on_ref.rs:42:47
|
||||
|
|
||||
LL | let _ = std::path::PathBuf::from("12/34").into_iter(); //~ ERROR equivalent to .iter()
|
||||
| ^^^^^^^^^ help: call directly: `iter`
|
||||
|
||||
error: aborting due to 28 previous errors
|
||||
error: aborting due to 26 previous errors
|
||||
|
||||
|
|
|
@ -5,25 +5,25 @@
|
|||
extern crate rustc;
|
||||
use rustc::lint::{LintArray, LintPass};
|
||||
|
||||
#[macro_use]
|
||||
extern crate clippy_lints;
|
||||
|
||||
declare_clippy_lint! {
|
||||
pub TEST_LINT,
|
||||
correctness,
|
||||
""
|
||||
declare_tool_lint! {
|
||||
pub clippy::TEST_LINT,
|
||||
Warn,
|
||||
"",
|
||||
report_in_external_macro: true
|
||||
}
|
||||
|
||||
declare_clippy_lint! {
|
||||
pub TEST_LINT_REGISTERED,
|
||||
correctness,
|
||||
""
|
||||
declare_tool_lint! {
|
||||
pub clippy::TEST_LINT_REGISTERED,
|
||||
Warn,
|
||||
"",
|
||||
report_in_external_macro: true
|
||||
}
|
||||
|
||||
declare_clippy_lint! {
|
||||
pub TEST_LINT_REGISTERED_ONLY_IMPL,
|
||||
correctness,
|
||||
""
|
||||
declare_tool_lint! {
|
||||
pub clippy::TEST_LINT_REGISTERED_ONLY_IMPL,
|
||||
Warn,
|
||||
"",
|
||||
report_in_external_macro: true
|
||||
}
|
||||
|
||||
pub struct Pass;
|
||||
|
|
|
@ -1,10 +1,11 @@
|
|||
error: the lint `TEST_LINT` is not added to any `LintPass`
|
||||
--> $DIR/lint_without_lint_pass.rs:11:1
|
||||
--> $DIR/lint_without_lint_pass.rs:8:1
|
||||
|
|
||||
LL | / declare_clippy_lint! {
|
||||
LL | | pub TEST_LINT,
|
||||
LL | | correctness,
|
||||
LL | | ""
|
||||
LL | / declare_tool_lint! {
|
||||
LL | | pub clippy::TEST_LINT,
|
||||
LL | | Warn,
|
||||
LL | | "",
|
||||
LL | | report_in_external_macro: true
|
||||
LL | | }
|
||||
| |_^
|
||||
|
|
||||
|
|
|
@ -11,6 +11,7 @@
|
|||
use std::borrow::Borrow;
|
||||
use std::collections::HashSet;
|
||||
use std::convert::AsRef;
|
||||
use std::mem::MaybeUninit;
|
||||
|
||||
// `v` should be warned
|
||||
// `w`, `x` and `y` are allowed (moved or mutated)
|
||||
|
@ -111,8 +112,8 @@ trait FalsePositive {
|
|||
}
|
||||
|
||||
// shouldn't warn on extern funcs
|
||||
extern "C" fn ext(x: String) -> usize {
|
||||
x.len()
|
||||
extern "C" fn ext(x: MaybeUninit<usize>) -> usize {
|
||||
unsafe { x.assume_init() }
|
||||
}
|
||||
|
||||
// whitelist RangeArgument
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
error: this argument is passed by value, but not consumed in the function body
|
||||
--> $DIR/needless_pass_by_value.rs:17:23
|
||||
--> $DIR/needless_pass_by_value.rs:18:23
|
||||
|
|
||||
LL | fn foo<T: Default>(v: Vec<T>, w: Vec<T>, mut x: Vec<T>, y: Vec<T>) -> Vec<T> {
|
||||
| ^^^^^^ help: consider changing the type to: `&[T]`
|
||||
|
@ -7,55 +7,55 @@ LL | fn foo<T: Default>(v: Vec<T>, w: Vec<T>, mut x: Vec<T>, y: Vec<T>) -> Vec<T
|
|||
= note: `-D clippy::needless-pass-by-value` implied by `-D warnings`
|
||||
|
||||
error: this argument is passed by value, but not consumed in the function body
|
||||
--> $DIR/needless_pass_by_value.rs:31:11
|
||||
--> $DIR/needless_pass_by_value.rs:32:11
|
||||
|
|
||||
LL | fn bar(x: String, y: Wrapper) {
|
||||
| ^^^^^^ help: consider changing the type to: `&str`
|
||||
|
||||
error: this argument is passed by value, but not consumed in the function body
|
||||
--> $DIR/needless_pass_by_value.rs:31:22
|
||||
--> $DIR/needless_pass_by_value.rs:32:22
|
||||
|
|
||||
LL | fn bar(x: String, y: Wrapper) {
|
||||
| ^^^^^^^ help: consider taking a reference instead: `&Wrapper`
|
||||
|
||||
error: this argument is passed by value, but not consumed in the function body
|
||||
--> $DIR/needless_pass_by_value.rs:37:71
|
||||
--> $DIR/needless_pass_by_value.rs:38:71
|
||||
|
|
||||
LL | fn test_borrow_trait<T: Borrow<str>, U: AsRef<str>, V>(t: T, u: U, v: V) {
|
||||
| ^ help: consider taking a reference instead: `&V`
|
||||
|
||||
error: this argument is passed by value, but not consumed in the function body
|
||||
--> $DIR/needless_pass_by_value.rs:49:18
|
||||
--> $DIR/needless_pass_by_value.rs:50:18
|
||||
|
|
||||
LL | fn test_match(x: Option<Option<String>>, y: Option<Option<String>>) {
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^ help: consider taking a reference instead: `&Option<Option<String>>`
|
||||
|
||||
error: this argument is passed by value, but not consumed in the function body
|
||||
--> $DIR/needless_pass_by_value.rs:62:24
|
||||
--> $DIR/needless_pass_by_value.rs:63:24
|
||||
|
|
||||
LL | fn test_destructure(x: Wrapper, y: Wrapper, z: Wrapper) {
|
||||
| ^^^^^^^ help: consider taking a reference instead: `&Wrapper`
|
||||
|
||||
error: this argument is passed by value, but not consumed in the function body
|
||||
--> $DIR/needless_pass_by_value.rs:62:36
|
||||
--> $DIR/needless_pass_by_value.rs:63:36
|
||||
|
|
||||
LL | fn test_destructure(x: Wrapper, y: Wrapper, z: Wrapper) {
|
||||
| ^^^^^^^ help: consider taking a reference instead: `&Wrapper`
|
||||
|
||||
error: this argument is passed by value, but not consumed in the function body
|
||||
--> $DIR/needless_pass_by_value.rs:78:49
|
||||
--> $DIR/needless_pass_by_value.rs:79:49
|
||||
|
|
||||
LL | fn test_blanket_ref<T: Foo, S: Serialize>(_foo: T, _serializable: S) {}
|
||||
| ^ help: consider taking a reference instead: `&T`
|
||||
|
||||
error: this argument is passed by value, but not consumed in the function body
|
||||
--> $DIR/needless_pass_by_value.rs:80:18
|
||||
--> $DIR/needless_pass_by_value.rs:81:18
|
||||
|
|
||||
LL | fn issue_2114(s: String, t: String, u: Vec<i32>, v: Vec<i32>) {
|
||||
| ^^^^^^ help: consider taking a reference instead: `&String`
|
||||
|
||||
error: this argument is passed by value, but not consumed in the function body
|
||||
--> $DIR/needless_pass_by_value.rs:80:29
|
||||
--> $DIR/needless_pass_by_value.rs:81:29
|
||||
|
|
||||
LL | fn issue_2114(s: String, t: String, u: Vec<i32>, v: Vec<i32>) {
|
||||
| ^^^^^^
|
||||
|
@ -70,13 +70,13 @@ LL | let _ = t.to_string();
|
|||
| ^^^^^^^^^^^^^
|
||||
|
||||
error: this argument is passed by value, but not consumed in the function body
|
||||
--> $DIR/needless_pass_by_value.rs:80:40
|
||||
--> $DIR/needless_pass_by_value.rs:81:40
|
||||
|
|
||||
LL | fn issue_2114(s: String, t: String, u: Vec<i32>, v: Vec<i32>) {
|
||||
| ^^^^^^^^ help: consider taking a reference instead: `&Vec<i32>`
|
||||
|
||||
error: this argument is passed by value, but not consumed in the function body
|
||||
--> $DIR/needless_pass_by_value.rs:80:53
|
||||
--> $DIR/needless_pass_by_value.rs:81:53
|
||||
|
|
||||
LL | fn issue_2114(s: String, t: String, u: Vec<i32>, v: Vec<i32>) {
|
||||
| ^^^^^^^^
|
||||
|
@ -91,85 +91,85 @@ LL | let _ = v.to_owned();
|
|||
| ^^^^^^^^^^^^
|
||||
|
||||
error: this argument is passed by value, but not consumed in the function body
|
||||
--> $DIR/needless_pass_by_value.rs:93:12
|
||||
--> $DIR/needless_pass_by_value.rs:94:12
|
||||
|
|
||||
LL | s: String,
|
||||
| ^^^^^^ help: consider changing the type to: `&str`
|
||||
|
||||
error: this argument is passed by value, but not consumed in the function body
|
||||
--> $DIR/needless_pass_by_value.rs:94:12
|
||||
--> $DIR/needless_pass_by_value.rs:95:12
|
||||
|
|
||||
LL | t: String,
|
||||
| ^^^^^^ help: consider taking a reference instead: `&String`
|
||||
|
||||
error: this argument is passed by value, but not consumed in the function body
|
||||
--> $DIR/needless_pass_by_value.rs:103:23
|
||||
--> $DIR/needless_pass_by_value.rs:104:23
|
||||
|
|
||||
LL | fn baz(&self, _u: U, _s: Self) {}
|
||||
| ^ help: consider taking a reference instead: `&U`
|
||||
|
||||
error: this argument is passed by value, but not consumed in the function body
|
||||
--> $DIR/needless_pass_by_value.rs:103:30
|
||||
--> $DIR/needless_pass_by_value.rs:104:30
|
||||
|
|
||||
LL | fn baz(&self, _u: U, _s: Self) {}
|
||||
| ^^^^ help: consider taking a reference instead: `&Self`
|
||||
|
||||
error: this argument is passed by value, but not consumed in the function body
|
||||
--> $DIR/needless_pass_by_value.rs:125:24
|
||||
--> $DIR/needless_pass_by_value.rs:126:24
|
||||
|
|
||||
LL | fn bar_copy(x: u32, y: CopyWrapper) {
|
||||
| ^^^^^^^^^^^ help: consider taking a reference instead: `&CopyWrapper`
|
||||
|
|
||||
help: consider marking this type as Copy
|
||||
--> $DIR/needless_pass_by_value.rs:123:1
|
||||
--> $DIR/needless_pass_by_value.rs:124:1
|
||||
|
|
||||
LL | struct CopyWrapper(u32);
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
error: this argument is passed by value, but not consumed in the function body
|
||||
--> $DIR/needless_pass_by_value.rs:131:29
|
||||
--> $DIR/needless_pass_by_value.rs:132:29
|
||||
|
|
||||
LL | fn test_destructure_copy(x: CopyWrapper, y: CopyWrapper, z: CopyWrapper) {
|
||||
| ^^^^^^^^^^^ help: consider taking a reference instead: `&CopyWrapper`
|
||||
|
|
||||
help: consider marking this type as Copy
|
||||
--> $DIR/needless_pass_by_value.rs:123:1
|
||||
--> $DIR/needless_pass_by_value.rs:124:1
|
||||
|
|
||||
LL | struct CopyWrapper(u32);
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
error: this argument is passed by value, but not consumed in the function body
|
||||
--> $DIR/needless_pass_by_value.rs:131:45
|
||||
--> $DIR/needless_pass_by_value.rs:132:45
|
||||
|
|
||||
LL | fn test_destructure_copy(x: CopyWrapper, y: CopyWrapper, z: CopyWrapper) {
|
||||
| ^^^^^^^^^^^ help: consider taking a reference instead: `&CopyWrapper`
|
||||
|
|
||||
help: consider marking this type as Copy
|
||||
--> $DIR/needless_pass_by_value.rs:123:1
|
||||
--> $DIR/needless_pass_by_value.rs:124:1
|
||||
|
|
||||
LL | struct CopyWrapper(u32);
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
error: this argument is passed by value, but not consumed in the function body
|
||||
--> $DIR/needless_pass_by_value.rs:131:61
|
||||
--> $DIR/needless_pass_by_value.rs:132:61
|
||||
|
|
||||
LL | fn test_destructure_copy(x: CopyWrapper, y: CopyWrapper, z: CopyWrapper) {
|
||||
| ^^^^^^^^^^^ help: consider taking a reference instead: `&CopyWrapper`
|
||||
|
|
||||
help: consider marking this type as Copy
|
||||
--> $DIR/needless_pass_by_value.rs:123:1
|
||||
--> $DIR/needless_pass_by_value.rs:124:1
|
||||
|
|
||||
LL | struct CopyWrapper(u32);
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
error: this argument is passed by value, but not consumed in the function body
|
||||
--> $DIR/needless_pass_by_value.rs:143:40
|
||||
--> $DIR/needless_pass_by_value.rs:144:40
|
||||
|
|
||||
LL | fn some_fun<'b, S: Bar<'b, ()>>(_item: S) {}
|
||||
| ^ help: consider taking a reference instead: `&S`
|
||||
|
||||
error: this argument is passed by value, but not consumed in the function body
|
||||
--> $DIR/needless_pass_by_value.rs:148:20
|
||||
--> $DIR/needless_pass_by_value.rs:149:20
|
||||
|
|
||||
LL | fn more_fun(_item: impl Club<'static, i32>) {}
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^ help: consider taking a reference instead: `&impl Club<'static, i32>`
|
||||
|
|
|
@ -1,5 +1,6 @@
|
|||
// aux-build:proc_macro_derive.rs
|
||||
|
||||
#![feature(rustc_private)]
|
||||
#![warn(clippy::all)]
|
||||
#![allow(clippy::blacklisted_name)]
|
||||
#![warn(clippy::used_underscore_binding)]
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
error: used binding `_foo` which is prefixed with an underscore. A leading underscore signals that a binding will not be used.
|
||||
--> $DIR/used_underscore_binding.rs:24:5
|
||||
--> $DIR/used_underscore_binding.rs:25:5
|
||||
|
|
||||
LL | _foo + 1
|
||||
| ^^^^
|
||||
|
@ -7,25 +7,25 @@ LL | _foo + 1
|
|||
= note: `-D clippy::used-underscore-binding` implied by `-D warnings`
|
||||
|
||||
error: used binding `_foo` which is prefixed with an underscore. A leading underscore signals that a binding will not be used.
|
||||
--> $DIR/used_underscore_binding.rs:29:20
|
||||
--> $DIR/used_underscore_binding.rs:30:20
|
||||
|
|
||||
LL | println!("{}", _foo);
|
||||
| ^^^^
|
||||
|
||||
error: used binding `_foo` which is prefixed with an underscore. A leading underscore signals that a binding will not be used.
|
||||
--> $DIR/used_underscore_binding.rs:30:16
|
||||
--> $DIR/used_underscore_binding.rs:31:16
|
||||
|
|
||||
LL | assert_eq!(_foo, _foo);
|
||||
| ^^^^
|
||||
|
||||
error: used binding `_foo` which is prefixed with an underscore. A leading underscore signals that a binding will not be used.
|
||||
--> $DIR/used_underscore_binding.rs:30:22
|
||||
--> $DIR/used_underscore_binding.rs:31:22
|
||||
|
|
||||
LL | assert_eq!(_foo, _foo);
|
||||
| ^^^^
|
||||
|
||||
error: used binding `_underscore_field` which is prefixed with an underscore. A leading underscore signals that a binding will not be used.
|
||||
--> $DIR/used_underscore_binding.rs:43:5
|
||||
--> $DIR/used_underscore_binding.rs:44:5
|
||||
|
|
||||
LL | s._underscore_field += 1;
|
||||
| ^^^^^^^^^^^^^^^^^^^
|
||||
|
|
|
@ -2,16 +2,15 @@
|
|||
|
||||
#![warn(clippy::useless_attribute)]
|
||||
#![warn(unreachable_pub)]
|
||||
#![feature(rustc_private)]
|
||||
|
||||
#[allow(dead_code)]
|
||||
#[cfg_attr(feature = "cargo-clippy", allow(dead_code))]
|
||||
#[rustfmt::skip]
|
||||
#[cfg_attr(feature = "cargo-clippy",
|
||||
allow(dead_code))]
|
||||
#[allow(unused_imports)]
|
||||
#[allow(unused_extern_crates)]
|
||||
#[macro_use]
|
||||
extern crate clippy_lints;
|
||||
extern crate rustc;
|
||||
|
||||
#[macro_use]
|
||||
extern crate proc_macro_derive;
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
error: useless lint attribute
|
||||
--> $DIR/useless_attribute.rs:6:1
|
||||
--> $DIR/useless_attribute.rs:7:1
|
||||
|
|
||||
LL | #[allow(dead_code)]
|
||||
| ^^^^^^^^^^^^^^^^^^^ help: if you just forgot a `!`, use: `#![allow(dead_code)]`
|
||||
|
@ -7,7 +7,7 @@ LL | #[allow(dead_code)]
|
|||
= note: `-D clippy::useless-attribute` implied by `-D warnings`
|
||||
|
||||
error: useless lint attribute
|
||||
--> $DIR/useless_attribute.rs:7:1
|
||||
--> $DIR/useless_attribute.rs:8:1
|
||||
|
|
||||
LL | #[cfg_attr(feature = "cargo-clippy", allow(dead_code))]
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: if you just forgot a `!`, use: `#![cfg_attr(feature = "cargo-clippy", allow(dead_code)`
|
||||
|
|
Loading…
Reference in a new issue