[Jump to usage instructions](#usage)
##Lints
-There are 81 lints included in this crate:
+There are 82 lints included in this crate:
name | default | meaning
---------------------------------------------------------------------------------------------------------|---------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
[unicode_not_nfc](https://github.com/Manishearth/rust-clippy/wiki#unicode_not_nfc) | allow | using a unicode literal not in NFC normal form (see http://www.unicode.org/reports/tr15/ for further information)
[unit_cmp](https://github.com/Manishearth/rust-clippy/wiki#unit_cmp) | warn | comparing unit values (which is always `true` or `false`, respectively)
[unnecessary_mut_passed](https://github.com/Manishearth/rust-clippy/wiki#unnecessary_mut_passed) | warn | an argument is passed as a mutable reference although the function/method only demands an immutable reference
+[unneeded_field_pattern](https://github.com/Manishearth/rust-clippy/wiki#unneeded_field_pattern) | warn | Struct fields are bound to a wildcard instead of using `..`
[unstable_as_mut_slice](https://github.com/Manishearth/rust-clippy/wiki#unstable_as_mut_slice) | warn | as_mut_slice is not stable and can be replaced by &mut v[..]see https://github.com/rust-lang/rust/issues/27729
[unstable_as_slice](https://github.com/Manishearth/rust-clippy/wiki#unstable_as_slice) | warn | as_slice is not stable and can be replaced by & v[..]see https://github.com/rust-lang/rust/issues/27729
[unused_collect](https://github.com/Manishearth/rust-clippy/wiki#unused_collect) | warn | `collect()`ing an iterator without using the result; this is usually better written as a for loop
pub mod transmute;
pub mod cyclomatic_complexity;
pub mod escape;
+pub mod misc_early;
mod reexport {
pub use syntax::ast::{Name, Ident, NodeId};
reg.register_late_lint_pass(box transmute::UselessTransmute);
reg.register_late_lint_pass(box cyclomatic_complexity::CyclomaticComplexity::new(25));
reg.register_late_lint_pass(box escape::EscapePass);
+ reg.register_early_lint_pass(box misc_early::MiscEarly);
reg.register_lint_group("clippy_pedantic", vec![
methods::OPTION_UNWRAP_USED,
misc::MODULO_ONE,
misc::REDUNDANT_PATTERN,
misc::TOPLEVEL_REF_ARG,
+ misc_early::UNNEEDED_FIELD_PATTERN,
mut_reference::UNNECESSARY_MUT_PASSED,
mutex_atomic::MUTEX_ATOMIC,
needless_bool::NEEDLESS_BOOL,
--- /dev/null
+//use rustc_front::hir::*;
+
+use rustc::lint::*;
+
+use syntax::ast::*;
+
+use utils::span_lint;
+
+declare_lint!(pub UNNEEDED_FIELD_PATTERN, Warn,
+ "Struct fields are bound to a wildcard instead of using `..`");
+
+#[derive(Copy, Clone)]
+pub struct MiscEarly;
+
+impl LintPass for MiscEarly {
+ fn get_lints(&self) -> LintArray {
+ lint_array!(UNNEEDED_FIELD_PATTERN)
+ }
+}
+
+impl EarlyLintPass for MiscEarly {
+ fn check_pat(&mut self, cx: &EarlyContext, pat: &Pat) {
+ if let PatStruct(_, ref pfields, _) = pat.node {
+ let mut wilds = 0;
+
+ for field in pfields {
+ if field.node.pat.node == PatWild {
+ wilds += 1;
+ }
+ }
+ if !pfields.is_empty() && wilds == pfields.len() {
+ span_lint(cx, UNNEEDED_FIELD_PATTERN, pat.span,
+ "All the struct fields are matched to a wildcard pattern, \
+ consider using `..`.");
+ return;
+ }
+ if wilds > 0 {
+ for field in pfields {
+ if field.node.pat.node == PatWild {
+ span_lint(cx, UNNEEDED_FIELD_PATTERN, field.span,
+ "You matched a field with a wildcard pattern. \
+ Consider using `..` instead");
+ }
+ }
+ }
+ }
+ }
+}
unwrap_addr(expr).map_or((), |e| {
unwrap_addr(e).map_or_else(
|| {
- if let TyRef(_, TypeAndMut{ty: _, mutbl: MutMutable}) =
+ if let TyRef(_, TypeAndMut{mutbl: MutMutable, ..}) =
cx.tcx.expr_ty(e).sty {
span_lint(cx, MUT_MUT, expr.span,
"this expression mutably borrows a mutable reference. \
let parameters = &fn_type.sig.skip_binder().inputs;
for (argument, parameter) in arguments.iter().zip(parameters.iter()) {
match parameter.sty {
- TypeVariants::TyRef(_, TypeAndMut {ty: _, mutbl: MutImmutable}) |
- TypeVariants::TyRawPtr(TypeAndMut {ty: _, mutbl: MutImmutable}) => {
+ TypeVariants::TyRef(_, TypeAndMut {mutbl: MutImmutable, ..}) |
+ TypeVariants::TyRawPtr(TypeAndMut {mutbl: MutImmutable, ..}) => {
if let ExprAddrOf(MutMutable, _) = argument.node {
span_lint(cx, UNNECESSARY_MUT_PASSED,
argument.span, &format!("The function/method \"{}\" \
let argument_option = match arguments[1].node {
ExprLit(ref span) => {
- if let Spanned {node: LitBool(lit), span: _} = **span {
+ if let Spanned {node: LitBool(lit), ..} = **span {
if lit {Argument::True} else {Argument::False}
} else {
return; // The function is called with a literal
if in_external_macro(cx, decl.span) { return; }
if is_from_for_desugar(decl) { return; }
if let DeclLocal(ref local) = decl.node {
- let Local{ ref pat, ref ty, ref init, id: _, span, attrs: _ } = **local;
+ let Local{ ref pat, ref ty, ref init, span, .. } = **local;
if let Some(ref t) = *ty { check_ty(cx, t, bindings) }
if let Some(ref o) = *init {
check_expr(cx, o, bindings);
let parent_id = cx.tcx.map.get_parent(expr.id);
match cx.tcx.map.find(parent_id) {
Some(NodeItem(&Item{ ref name, .. })) |
- Some(NodeTraitItem(&TraitItem{ id: _, ref name, .. })) |
- Some(NodeImplItem(&ImplItem{ id: _, ref name, .. })) => {
+ Some(NodeTraitItem(&TraitItem{ ref name, .. })) |
+ Some(NodeImplItem(&ImplItem{ ref name, .. })) => {
Some(*name)
}
_ => None,