[unused_label](https://github.com/Manishearth/rust-clippy/wiki#unused_label) | warn | unused label
[unused_lifetimes](https://github.com/Manishearth/rust-clippy/wiki#unused_lifetimes) | warn | unused lifetimes in function definitions
[use_debug](https://github.com/Manishearth/rust-clippy/wiki#use_debug) | allow | use `Debug`-based formatting
-[used_underscore_binding](https://github.com/Manishearth/rust-clippy/wiki#used_underscore_binding) | warn | using a binding which is prefixed with an underscore
+[used_underscore_binding](https://github.com/Manishearth/rust-clippy/wiki#used_underscore_binding) | allow | using a binding which is prefixed with an underscore
[useless_format](https://github.com/Manishearth/rust-clippy/wiki#useless_format) | warn | useless use of `format!`
[useless_transmute](https://github.com/Manishearth/rust-clippy/wiki#useless_transmute) | warn | transmutes that have the same to and from types
[useless_vec](https://github.com/Manishearth/rust-clippy/wiki#useless_vec) | warn | useless `vec!`
impl LateLintPass for BlackListedName {
fn check_pat(&mut self, cx: &LateContext, pat: &Pat) {
if let PatKind::Ident(_, ref ident, _) = pat.node {
- if self.blacklist.iter().any(|s| s == &*ident.node.name.as_str()) {
+ if self.blacklist.iter().any(|s| s == &*ident.node.as_str()) {
span_lint(cx,
BLACKLISTED_NAME,
pat.span,
- &format!("use of a blacklisted/placeholder name `{}`", ident.node.name));
+ &format!("use of a blacklisted/placeholder name `{}`", ident.node));
}
}
}
}
}
PatKind::Ident(_, ref ident, ref as_pat) => {
- if let Entry::Vacant(v) = map.entry(ident.node.name.as_str()) {
+ if let Entry::Vacant(v) = map.entry(ident.node.as_str()) {
v.insert(cx.tcx.pat_ty(pat));
}
if let Some(ref as_pat) = *as_pat {
// If it's a proper path, it can't be a local variable
return;
}
- if p.segments[0].identifier != ident.node {
+ if p.segments[0].name != ident.node {
// The two idents should be the same
return;
}
methods::OPTION_UNWRAP_USED,
methods::RESULT_UNWRAP_USED,
methods::WRONG_PUB_SELF_CONVENTION,
+ misc::USED_UNDERSCORE_BINDING,
mut_mut::MUT_MUT,
mutex_atomic::MUTEX_INTEGER,
non_expressive_names::SIMILAR_NAMES,
misc::MODULO_ONE,
misc::REDUNDANT_PATTERN,
misc::TOPLEVEL_REF_ARG,
- misc::USED_UNDERSCORE_BINDING,
misc_early::DUPLICATE_UNDERSCORE_ARGUMENT,
misc_early::REDUNDANT_CLOSURE_CALL,
misc_early::UNNEEDED_FIELD_PATTERN,
if let Some(lhs_constructor) = path.segments.last() {
if method_name.node.as_str() == "next" &&
match_trait_method(cx, match_expr, &paths::ITERATOR) &&
- lhs_constructor.identifier.name.as_str() == "Some" &&
+ lhs_constructor.name.as_str() == "Some" &&
!is_iterator_used_after_while_let(cx, iter_expr) {
let iterator = snippet(cx, method_args[0].span, "_");
let loop_var = snippet(cx, pat_args[0].span, "_");
if let PatKind::Ident(_, ref ident, _) = pat.node {
let mut visitor = VarVisitor {
cx: cx,
- var: ident.node.name,
+ var: ident.node,
indexed: HashMap::new(),
nonindex: false,
};
expr.span,
&format!("the loop variable `{}` is used to index `{}`. Consider using `for ({}, \
item) in {}.iter().enumerate(){}{}` or similar iterators",
- ident.node.name,
+ ident.node,
indexed,
- ident.node.name,
+ ident.node,
indexed,
take,
skip));
expr.span,
&format!("the loop variable `{}` is only used to index `{}`. \
Consider using `for item in {}` or similar iterators",
- ident.node.name,
+ ident.node,
indexed,
repl));
}
method.node.as_str() == "len",
let ExprPath(_, ref path) = len_args[0].node,
path.segments.len() == 1,
- &path.segments[0].identifier.name == var
+ &path.segments[0].name == var
], {
return true;
}}
fn pat_is_wild(pat: &PatKind, body: &Expr) -> bool {
match *pat {
PatKind::Wild => true,
- PatKind::Ident(_, ident, None) if ident.node.name.as_str().starts_with('_') => {
+ PatKind::Ident(_, ident, None) if ident.node.as_str().starts_with('_') => {
let mut visitor = UsedVisitor {
var: ident.node,
used: false,
}
struct UsedVisitor {
- var: Ident, // var to look for
+ var: ast::Name, // var to look for
used: bool, // has the var been used otherwise?
}
impl<'a> Visitor<'a> for UsedVisitor {
fn visit_expr(&mut self, expr: &Expr) {
if let ExprPath(None, ref path) = expr.node {
- if path.segments.len() == 1 && path.segments[0].identifier == self.var {
+ if path.segments.len() == 1 && path.segments[0].name == self.var {
self.used = true;
return;
}
impl<'v, 't> Visitor<'v> for VarVisitor<'v, 't> {
fn visit_expr(&mut self, expr: &'v Expr) {
if let ExprPath(None, ref path) = expr.node {
- if path.segments.len() == 1 && path.segments[0].identifier.name == self.var {
+ if path.segments.len() == 1 && path.segments[0].name == self.var {
// we are referencing our variable! now check if it's as an index
if_let_chain! {
[
match def.base_def {
Def::Local(..) | Def::Upvar(..) => {
let extent = self.cx.tcx.region_maps.var_scope(def.base_def.var_id());
- self.indexed.insert(seqvar.segments[0].identifier.name, Some(extent));
+ self.indexed.insert(seqvar.segments[0].name, Some(extent));
return; // no need to walk further
}
Def::Static(..) | Def::Const(..) => {
- self.indexed.insert(seqvar.segments[0].identifier.name, None);
+ self.indexed.insert(seqvar.segments[0].name, None);
return; // no need to walk further
}
_ => (),
if let DeclLocal(ref local) = decl.node {
if local.pat.id == self.var_id {
if let PatKind::Ident(_, ref ident, _) = local.pat.node {
- self.name = Some(ident.node.name);
+ self.name = Some(ident.node);
self.state = if let Some(ref init) = local.init {
if is_integer_literal(init, 0) {
use rustc::lint::*;
use rustc::hir::*;
+use syntax::ast;
use utils::{is_adjusted, match_path, match_trait_method, match_type, paths, snippet,
span_help_and_lint, walk_ptrs_ty, walk_ptrs_ty_depth};
if clone_call.node.as_str() == "clone" &&
clone_args.len() == 1 &&
match_trait_method(cx, closure_expr, &paths::CLONE_TRAIT) &&
- expr_eq_ident(&clone_args[0], arg_ident)
+ expr_eq_name(&clone_args[0], arg_ident)
{
span_help_and_lint(cx, MAP_CLONE, expr.span, &format!(
"you seem to be using .map() to clone the contents of an {}, consider \
}
}
-fn expr_eq_ident(expr: &Expr, id: Ident) -> bool {
+fn expr_eq_name(expr: &Expr, id: ast::Name) -> bool {
match expr.node {
ExprPath(None, ref path) => {
let arg_segment = [PathSegment {
- identifier: id,
+ name: id,
parameters: PathParameters::none(),
}];
!path.global && path.segments[..] == arg_segment
}
}
-fn get_arg_name(pat: &Pat) -> Option<Ident> {
+fn get_arg_name(pat: &Pat) -> Option<ast::Name> {
match pat.node {
- PatKind::Ident(_, ident, None) => Some(ident.node),
+ PatKind::Ident(_, name, None) => Some(name.node),
PatKind::Ref(ref subpat, _) => get_arg_name(subpat),
_ => None,
}
}
-fn only_derefs(cx: &LateContext, expr: &Expr, id: Ident) -> bool {
+fn only_derefs(cx: &LateContext, expr: &Expr, id: ast::Name) -> bool {
match expr.node {
ExprUnary(UnDeref, ref subexpr) if !is_adjusted(cx, subexpr) => only_derefs(cx, subexpr, id),
- _ => expr_eq_ident(expr, id),
+ _ => expr_eq_name(expr, id),
}
}
let path: &str = &path.segments
.last()
.expect("A path must have at least one segment")
- .identifier
.name
.as_str();
let hir::ExprCall(ref fun, ref arg_char) = other.node,
arg_char.len() == 1,
let hir::ExprPath(None, ref path) = fun.node,
- path.segments.len() == 1 && path.segments[0].identifier.name.as_str() == "Some"
+ path.segments.len() == 1 && path.segments[0].name.as_str() == "Some"
], {
let self_ty = walk_ptrs_ty(cx.tcx.expr_ty_adjusted(&args[0][0]));
use rustc_const_eval::eval_const_expr_partial;
use syntax::codemap::{Span, Spanned, ExpnFormat};
use syntax::ptr::P;
-use utils::{get_item_name, match_path, snippet, get_parent_expr, span_lint};
-use utils::{span_lint_and_then, walk_ptrs_ty, is_integer_literal, implements_trait};
+use utils::{
+ get_item_name, get_parent_expr, implements_trait, is_integer_literal, match_path, snippet,
+ span_lint, span_lint_and_then, walk_ptrs_ty
+};
/// **What it does:** This lint checks for function arguments and let bindings denoted as `ref`.
///
fn check_nan(cx: &LateContext, path: &Path, span: Span) {
path.segments.last().map(|seg| {
- if seg.identifier.name.as_str() == "NAN" {
+ if seg.name.as_str() == "NAN" {
span_lint(cx,
CMP_NAN,
span,
REDUNDANT_PATTERN,
pat.span,
&format!("the `{} @ _` pattern can be written as just `{}`",
- ident.node.name,
- ident.node.name));
+ ident.node,
+ ident.node));
}
}
}
/// **Why is this bad?** A single leading underscore is usually used to indicate that a binding
/// will not be used. Using such a binding breaks this expectation.
///
-/// **Known problems:** None
+/// **Known problems:** The lint does not work properly with desugaring and macro, it has been
+/// allowed in the mean time.
///
/// **Example**:
/// ```
/// let y = _x + 1; // Here we are using `_x`, even though it has a leading underscore.
/// // We should rename `_x` to `x`
/// ```
-declare_lint!(pub USED_UNDERSCORE_BINDING, Warn,
+declare_lint!(pub USED_UNDERSCORE_BINDING, Allow,
"using a binding which is prefixed with an underscore");
#[derive(Copy, Clone)]
#[cfg_attr(rustfmt, rustfmt_skip)]
fn check_expr(&mut self, cx: &LateContext, expr: &Expr) {
if in_attributes_expansion(cx, expr) {
- // Don't lint things expanded by #[derive(...)], etc
+ // Don't lint things expanded by #[derive(...)], etc
return;
}
- let needs_lint = match expr.node {
+ let binding = match expr.node {
ExprPath(_, ref path) => {
- let ident = path.segments
+ let segment = path.segments
.last()
.expect("path should always have at least one segment")
- .identifier;
- ident.name.as_str().starts_with('_') &&
- !ident.name.as_str().starts_with("__") &&
- ident.name != ident.unhygienic_name &&
- is_used(cx, expr) // not in bang macro
+ .name;
+ if segment.as_str().starts_with('_') &&
+ !segment.as_str().starts_with("__") &&
+ segment != segment.unhygienize() && // not in bang macro
+ is_used(cx, expr) {
+ Some(segment.as_str())
+ } else {
+ None
+ }
}
ExprField(_, spanned) => {
let name = spanned.node.as_str();
- name.starts_with('_') && !name.starts_with("__")
+ if name.starts_with('_') && !name.starts_with("__") {
+ Some(name)
+ } else {
+ None
+ }
}
- _ => false,
+ _ => None,
};
- if needs_lint {
- span_lint(cx,
- USED_UNDERSCORE_BINDING,
- expr.span,
- "used binding which is prefixed with an underscore. A leading underscore signals that a \
- binding will not be used.");
+ if let Some(binding) = binding {
+ if binding != "_result" { // FIXME: #944
+ span_lint(cx,
+ USED_UNDERSCORE_BINDING,
+ expr.span,
+ &format!("used binding `{}` which is prefixed with an underscore. A leading \
+ underscore signals that a binding will not be used.", binding));
+ }
}
}
}
}
}
-/// Test whether an expression is in a macro expansion (e.g. something generated by #[derive(...)]
-/// or the like)
+/// Test whether an expression is in a macro expansion (e.g. something generated by
+/// `#[derive(...)`] or the like).
fn in_attributes_expansion(cx: &LateContext, expr: &Expr) -> bool {
cx.sess().codemap().with_expn_info(expr.span.expn_id, |info_opt| {
info_opt.map_or(false, |info| {
let Expr_::ExprPath(_,ref path1) = ident1.node,
let Expr_::ExprPath(_, ref path2) = ident2.node,
let Expr_::ExprPath(_, ref path3) = second.node,
- (&path1.segments[0]).identifier == (&path3.segments[0]).identifier || (&path2.segments[0]).identifier == (&path3.segments[0]).identifier,
+ &path1.segments[0] == &path3.segments[0] || &path2.segments[0] == &path3.segments[0],
cx.tcx.expr_ty(ident1).is_integral(),
cx.tcx.expr_ty(ident2).is_integral()
], {
let Expr_::ExprPath(_,ref path1) = ident1.node,
let Expr_::ExprPath(_, ref path2) = ident2.node,
let Expr_::ExprPath(_, ref path3) = first.node,
- (&path1.segments[0]).identifier == (&path3.segments[0]).identifier || (&path2.segments[0]).identifier == (&path3.segments[0]).identifier,
+ &path1.segments[0] == &path3.segments[0] || &path2.segments[0] == &path3.segments[0],
cx.tcx.expr_ty(ident1).is_integral(),
cx.tcx.expr_ty(ident2).is_integral()
], {
let mut bindings = Vec::new();
for arg in &decl.inputs {
if let PatKind::Ident(_, ident, _) = arg.pat.node {
- bindings.push((ident.node.unhygienic_name, ident.span))
+ bindings.push((ident.node.unhygienize(), ident.span))
}
}
check_block(cx, block, &mut bindings);
// TODO: match more stuff / destructuring
match pat.node {
PatKind::Ident(_, ref ident, ref inner) => {
- let name = ident.node.unhygienic_name;
+ let name = ident.node.unhygienize();
if is_binding(cx, pat) {
let mut new_binding = true;
for tup in bindings.iter_mut() {
}
fn path_eq_name(name: Name, path: &Path) -> bool {
- !path.global && path.segments.len() == 1 && path.segments[0].identifier.unhygienic_name == name
+ !path.global && path.segments.len() == 1 && path.segments[0].name.unhygienize() == name
}
struct ContainsSelf {
}
impl<'v> Visitor<'v> for ContainsSelf {
- fn visit_ident(&mut self, _: Span, ident: Ident) {
- if self.name == ident.unhygienic_name {
+ fn visit_name(&mut self, _: Span, name: Name) {
+ if self.name == name.unhygienize() {
self.result = true;
}
}
let ExprPath(None, ref rhs2) = rhs2.node,
rhs2.segments.len() == 1,
- tmp_name.node.name.as_str() == rhs2.segments[0].identifier.name.as_str(),
+ tmp_name.node.as_str() == rhs2.segments[0].name.as_str(),
SpanlessEq::new(cx).ignore_fn().eq_expr(tmp_init, lhs1),
SpanlessEq::new(cx).ignore_fn().eq_expr(rhs1, lhs2)
], {
path.segments
.last()
.expect("use paths cannot be empty")
- .identifier.name,
+ .name,
*name,
cx, &item.span
);
fn visit_expr(&mut self, expr: &hir::Expr) {
match expr.node {
hir::ExprBreak(Some(label)) | hir::ExprAgain(Some(label)) => {
- self.labels.remove(&label.node.name.as_str());
+ self.labels.remove(&label.node.as_str());
}
hir::ExprLoop(_, Some(label)) | hir::ExprWhile(_, _, Some(label)) => {
- self.labels.insert(label.name.as_str(), expr.span);
+ self.labels.insert(label.as_str(), expr.span);
}
_ => (),
}
match (&left.node, &right.node) {
(&ExprAddrOf(l_mut, ref le), &ExprAddrOf(r_mut, ref re)) => l_mut == r_mut && self.eq_expr(le, re),
- (&ExprAgain(li), &ExprAgain(ri)) => both(&li, &ri, |l, r| l.node.name.as_str() == r.node.name.as_str()),
+ (&ExprAgain(li), &ExprAgain(ri)) => both(&li, &ri, |l, r| l.node.as_str() == r.node.as_str()),
(&ExprAssign(ref ll, ref lr), &ExprAssign(ref rl, ref rr)) => self.eq_expr(ll, rl) && self.eq_expr(lr, rr),
(&ExprAssignOp(ref lo, ref ll, ref lr), &ExprAssignOp(ref ro, ref rl, ref rr)) => {
lo.node == ro.node && self.eq_expr(ll, rl) && self.eq_expr(lr, rr)
l_op == r_op.node && self.eq_expr(ll, rl) && self.eq_expr(lr, rr)
})
}
- (&ExprBreak(li), &ExprBreak(ri)) => both(&li, &ri, |l, r| l.node.name.as_str() == r.node.name.as_str()),
+ (&ExprBreak(li), &ExprBreak(ri)) => both(&li, &ri, |l, r| l.node.as_str() == r.node.as_str()),
(&ExprBox(ref l), &ExprBox(ref r)) => self.eq_expr(l, r),
(&ExprCall(ref l_fun, ref l_args), &ExprCall(ref r_fun, ref r_args)) => {
!self.ignore_fn && self.eq_expr(l_fun, r_fun) && self.eq_exprs(l_args, r_args)
}
(&ExprLit(ref l), &ExprLit(ref r)) => l.node == r.node,
(&ExprLoop(ref lb, ref ll), &ExprLoop(ref rb, ref rl)) => {
- self.eq_block(lb, rb) && both(ll, rl, |l, r| l.name.as_str() == r.name.as_str())
+ self.eq_block(lb, rb) && both(ll, rl, |l, r| l.as_str() == r.as_str())
}
(&ExprMatch(ref le, ref la, ref ls), &ExprMatch(ref re, ref ra, ref rs)) => {
ls == rs && self.eq_expr(le, re) &&
(&ExprUnary(l_op, ref le), &ExprUnary(r_op, ref re)) => l_op == r_op && self.eq_expr(le, re),
(&ExprVec(ref l), &ExprVec(ref r)) => self.eq_exprs(l, r),
(&ExprWhile(ref lc, ref lb, ref ll), &ExprWhile(ref rc, ref rb, ref rl)) => {
- self.eq_expr(lc, rc) && self.eq_block(lb, rb) && both(ll, rl, |l, r| l.name.as_str() == r.name.as_str())
+ self.eq_expr(lc, rc) && self.eq_block(lb, rb) && both(ll, rl, |l, r| l.as_str() == r.as_str())
}
_ => false,
}
self.eq_path(lp, rp) && both(la, ra, |l, r| over(l, r, |l, r| self.eq_pat(l, r)))
}
(&PatKind::Ident(ref lb, ref li, ref lp), &PatKind::Ident(ref rb, ref ri, ref rp)) => {
- lb == rb && li.node.name.as_str() == ri.node.name.as_str() && both(lp, rp, |l, r| self.eq_pat(l, r))
+ lb == rb && li.node.as_str() == ri.node.as_str() && both(lp, rp, |l, r| self.eq_pat(l, r))
}
(&PatKind::Lit(ref l), &PatKind::Lit(ref r)) => self.eq_expr(l, r),
(&PatKind::QPath(ref ls, ref lp), &PatKind::QPath(ref rs, ref rp)) => {
left.global == right.global &&
over(&left.segments,
&right.segments,
- |l, r| l.identifier.name.as_str() == r.identifier.name.as_str() && l.parameters == r.parameters)
+ |l, r| l.name.as_str() == r.name.as_str() && l.parameters == r.parameters)
}
fn eq_qself(&self, left: &QSelf, right: &QSelf) -> bool {
let c: fn(_) -> _ = ExprAgain;
c.hash(&mut self.s);
if let Some(i) = i {
- self.hash_name(&i.node.name);
+ self.hash_name(&i.node);
}
}
ExprAssign(ref l, ref r) => {
let c: fn(_) -> _ = ExprBreak;
c.hash(&mut self.s);
if let Some(i) = i {
- self.hash_name(&i.node.name);
+ self.hash_name(&i.node);
}
}
ExprBox(ref e) => {
c.hash(&mut self.s);
self.hash_block(b);
if let Some(i) = *i {
- self.hash_name(&i.name);
+ self.hash_name(&i);
}
}
ExprMatch(ref e, ref arms, ref s) => {
self.hash_expr(cond);
self.hash_block(b);
if let Some(l) = l {
- self.hash_name(&l.name);
+ self.hash_name(&l);
}
}
}
pub fn hash_path(&mut self, p: &Path) {
p.global.hash(&mut self.s);
for p in &p.segments {
- self.hash_name(&p.identifier.name);
+ self.hash_name(&p.name);
}
}
/// match_path(path, &["std", "rt", "begin_unwind"])
/// ```
pub fn match_path(path: &Path, segments: &[&str]) -> bool {
- path.segments.iter().rev().zip(segments.iter().rev()).all(|(a, b)| a.identifier.name.as_str() == *b)
+ path.segments.iter().rev().zip(segments.iter().rev()).all(|(a, b)| a.name.as_str() == *b)
}
/// Match a `Path` against a slice of segment string literals, e.g.
#![deny(clippy)]
#![allow(blacklisted_name)]
+#![deny(used_underscore_binding)]
/// Test that we lint if we use a binding with a single leading underscore
fn prefix_underscore(_foo: u32) -> u32 {
- _foo + 1 //~ ERROR used binding which is prefixed with an underscore
+ _foo + 1 //~ ERROR used binding `_foo` which is prefixed with an underscore
}
/// Test that we lint even if the use is within a macro expansion
fn in_macro(_foo: u32) {
- println!("{}", _foo); //~ ERROR used binding which is prefixed with an underscore
+ println!("{}", _foo); //~ ERROR used binding `_foo` which is prefixed with an underscore
}
// Struct for testing use of fields prefixed with an underscore
/// Test that we lint the use of a struct field which is prefixed with an underscore
fn in_struct_field() {
let mut s = StructFieldTest { _underscore_field: 0 };
- s._underscore_field += 1; //~ Error used binding which is prefixed with an underscore
+ s._underscore_field += 1; //~ Error used binding `_underscore_field` which is prefixed with an underscore
}
/// Test that we do not lint if the underscore is not a prefix
projects / rust.git / commitdiff