fn check_impl_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx ImplItem) {
if is_relevant_impl(cx.tcx, item) {
- check_attrs(cx, item.span, item.name, &item.attrs)
+ check_attrs(cx, item.span, item.ident.name, &item.attrs)
}
}
fn check_trait_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx TraitItem) {
if is_relevant_trait(cx.tcx, item) {
- check_attrs(cx, item.span, item.name, &item.attrs)
+ check_attrs(cx, item.span, item.ident.name, &item.attrs)
}
}
}
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BlackListedName {
fn check_pat(&mut self, cx: &LateContext<'a, 'tcx>, pat: &'tcx Pat) {
- if let PatKind::Binding(_, _, ref ident, _) = pat.node {
- if self.blacklist.iter().any(|s| ident.node == *s) {
+ if let PatKind::Binding(_, _, ident, _) = pat.node {
+ if self.blacklist.iter().any(|s| ident.name == *s) {
span_lint(
cx,
BLACKLISTED_NAME,
ident.span,
- &format!("use of a blacklisted/placeholder name `{}`", ident.node),
+ &format!("use of a blacklisted/placeholder name `{}`", ident.name),
);
}
}
METHODS_WITH_NEGATION
.iter().cloned()
.flat_map(|(a, b)| vec![(a, b), (b, a)])
- .find(|&(a, _)| a == path.name.as_str())
+ .find(|&(a, _)| a == path.ident.as_str())
.and_then(|(_, neg_method)| Some(format!("{}.{}()", self.snip(&args[0])?, neg_method)))
},
_ => None,
fn check_expr(&mut self, cx: &LateContext, expr: &Expr) {
if_chain! {
if let ExprMethodCall(ref count, _, ref count_args) = expr.node;
- if count.name == "count";
+ if count.ident.name == "count";
if count_args.len() == 1;
if let ExprMethodCall(ref filter, _, ref filter_args) = count_args[0].node;
- if filter.name == "filter";
+ if filter.ident.name == "filter";
if filter_args.len() == 2;
if let ExprClosure(_, _, body_id, _, _) = filter_args[1].node;
then {
}
let haystack = if let ExprMethodCall(ref path, _, ref args) =
filter_args[0].node {
- let p = path.name;
+ let p = path.ident.name;
if (p == "iter" || p == "iter_mut") && args.len() == 1 {
&args[0]
} else {
} else {
None
},
- ExprPath(ref qpath) => single_segment_path(qpath).map(|ps| ps.name),
+ ExprPath(ref qpath) => single_segment_path(qpath).map(|ps| ps.ident.name),
_ => None,
}
}
PatKind::TupleStruct(_, ref pats, _) => for pat in pats {
bindings_impl(cx, pat, map);
},
- PatKind::Binding(_, _, ref ident, ref as_pat) => {
- if let Entry::Vacant(v) = map.entry(ident.node.as_str()) {
+ PatKind::Binding(_, _, ident, ref as_pat) => {
+ if let Entry::Vacant(v) = map.entry(ident.as_str()) {
v.insert(cx.tables.pat_ty(pat));
}
if let Some(ref as_pat) = *as_pat {
if match_type(cx, walk_ptrs_ty(cx.tables.expr_ty(&args[0])), &paths::DURATION);
if let Some((Constant::Int(divisor), _)) = constant(cx, cx.tables, right);
then {
- let suggested_fn = match (method_path.name.as_str().as_ref(), divisor) {
+ let suggested_fn = match (method_path.ident.as_str().as_ref(), divisor) {
("subsec_micros", 1_000) => "subsec_millis",
("subsec_nanos", 1_000) => "subsec_micros",
("subsec_nanos", 1_000_000) => "subsec_millis",
if_chain! {
if let ExprMethodCall(ref path, _, ref params) = check.node;
if params.len() >= 2;
- if path.name == "contains_key";
+ if path.ident.name == "contains_key";
if let ExprAddrOf(_, ref key) = params[1].node;
then {
let map = ¶ms[0];
if_chain! {
if let ExprMethodCall(ref path, _, ref params) = expr.node;
if params.len() == 3;
- if path.name == "insert";
+ if path.ident.name == "insert";
if get_item_name(self.cx, self.map) == get_item_name(self.cx, ¶ms[0]);
if SpanlessEq::new(self.cx).eq_expr(self.key, ¶ms[1]);
then {
}
fn var2str(var: &Variant) -> LocalInternedString {
- var.node.ident.name.as_str()
+ var.node.ident.as_str()
}
/// Returns the number of chars that match from the start
}
fn check_item(&mut self, cx: &EarlyContext, item: &Item) {
- let item_name = item.ident.name.as_str();
+ let item_name = item.ident.as_str();
let item_name_chars = item_name.chars().count();
let item_camel = to_camel_case(&item_name);
if !in_macro(item.span) {
// If it's a proper path, it can't be a local variable
return;
}
- if p.segments[0].name != ident.node {
+ if p.segments[0].ident.name != ident.name {
// The two idents should be the same
return;
}
if_chain! {
// match call to unwrap
if let ExprMethodCall(ref unwrap_fun, _, ref unwrap_args) = expr.node;
- if unwrap_fun.name == "unwrap";
+ if unwrap_fun.ident.name == "unwrap";
// match call to write_fmt
if unwrap_args.len() > 0;
if let ExprMethodCall(ref write_fun, _, ref write_args) =
unwrap_args[0].node;
- if write_fun.name == "write_fmt";
+ if write_fun.ident.name == "write_fmt";
// match calls to std::io::stdout() / std::io::stderr ()
if write_args.len() > 0;
if let ExprCall(ref dest_fun, _) = write_args[0].node;
for impl_item in impl_items {
if_chain! {
- if impl_item.name == "from";
+ if impl_item.ident.name == "from";
if let ImplItemKind::Method(_, body_id) =
cx.tcx.hir.impl_item(impl_item.id).node;
then {
if let ExprStruct(_, ref fields, _) = format_field.expr.node;
if let Some(align_field) = fields.iter().find(|f| f.ident.name == "width");
if let ExprPath(ref qpath) = align_field.expr.node;
- if last_path_segment(qpath).name == "Implied";
+ if last_path_segment(qpath).ident.name == "Implied";
then {
return true;
}
},
ExprMethodCall(ref name, .., ref args) => {
- if match_trait_method(cx, e, &paths::INTO[..]) && &*name.name.as_str() == "into" {
+ if match_trait_method(cx, e, &paths::INTO[..]) && &*name.ident.as_str() == "into" {
let a = cx.tables.expr_ty(e);
let b = cx.tables.expr_ty(&args[0]);
if same_tys(cx, a, b) {
match expr.node {
ExprMethodCall(ref method, _, ref args) => {
for &(name, len, heuristic, cap) in HEURISTICS.iter() {
- if method.name == name && args.len() == len {
+ if method.ident.name == name && args.len() == len {
return (match heuristic {
Always => Infinite,
First => is_infinite(cx, &args[0]),
}).and(cap);
}
}
- if method.name == "flat_map" && args.len() == 2 {
+ if method.ident.name == "flat_map" && args.len() == 2 {
if let ExprClosure(_, _, body_id, _, _) = args[1].node {
let body = cx.tcx.hir.body(body_id);
return is_infinite(cx, &body.value);
match expr.node {
ExprMethodCall(ref method, _, ref args) => {
for &(name, len) in COMPLETING_METHODS.iter() {
- if method.name == name && args.len() == len {
+ if method.ident.name == name && args.len() == len {
return is_infinite(cx, &args[0]);
}
}
for &(name, len) in POSSIBLY_COMPLETING_METHODS.iter() {
- if method.name == name && args.len() == len {
+ if method.ident.name == name && args.len() == len {
return MaybeInfinite.and(is_infinite(cx, &args[0]));
}
}
- if method.name == "last" && args.len() == 1 {
+ if method.ident.name == "last" && args.len() == 1 {
let not_double_ended = get_trait_def_id(cx, &paths::DOUBLE_ENDED_ITERATOR)
.map_or(false, |id| !implements_trait(cx, cx.tables.expr_ty(&args[0]), id, &[]));
if not_double_ended {
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
fn check_trait_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx TraitItem) {
if let TraitItemKind::Method(_, TraitMethod::Required(_)) = item.node {
- check_attrs(cx, item.name, &item.attrs);
+ check_attrs(cx, item.ident.name, &item.attrs);
}
}
}
fn check_trait_items(cx: &LateContext, visited_trait: &Item, trait_items: &[TraitItemRef]) {
fn is_named_self(cx: &LateContext, item: &TraitItemRef, name: &str) -> bool {
- item.name == name && if let AssociatedItemKind::Method { has_self } = item.kind {
+ item.ident.name == name && if let AssociatedItemKind::Method { has_self } = item.kind {
has_self && {
let did = cx.tcx.hir.local_def_id(item.id.node_id);
cx.tcx.fn_sig(did).inputs().skip_binder().len() == 1
.iter()
.flat_map(|&i| cx.tcx.associated_items(i))
.any(|i| {
- i.kind == ty::AssociatedKind::Method && i.method_has_self_argument && i.name == "is_empty"
+ i.kind == ty::AssociatedKind::Method && i.method_has_self_argument && i.ident.name == "is_empty"
&& cx.tcx.fn_sig(i.def_id).inputs().skip_binder().len() == 1
});
fn check_impl_items(cx: &LateContext, item: &Item, impl_items: &[ImplItemRef]) {
fn is_named_self(cx: &LateContext, item: &ImplItemRef, name: &str) -> bool {
- item.name == name && if let AssociatedItemKind::Method { has_self } = item.kind {
+ item.ident.name == name && if let AssociatedItemKind::Method { has_self } = item.kind {
has_self && {
let did = cx.tcx.hir.local_def_id(item.id.node_id);
cx.tcx.fn_sig(did).inputs().skip_binder().len() == 1
}
}
- check_len(cx, span, method_path.name, args, lit, op, compare_to)
+ check_len(cx, span, method_path.ident.name, args, lit, op, compare_to)
}
}
/// Get an `AssociatedItem` and return true if it matches `is_empty(self)`.
fn is_is_empty(cx: &LateContext, item: &ty::AssociatedItem) -> bool {
if let ty::AssociatedKind::Method = item.kind {
- if item.name == "is_empty" {
+ if item.ident.name == "is_empty" {
let sig = cx.tcx.fn_sig(item.def_id);
let ty = sig.skip_binder();
ty.inputs().len() == 1
if let Some(expr) = it.peek();
if let hir::StmtDecl(ref decl, _) = stmt.node;
if let hir::DeclLocal(ref decl) = decl.node;
- if let hir::PatKind::Binding(mode, canonical_id, ref name, None) = decl.pat.node;
+ if let hir::PatKind::Binding(mode, canonical_id, ident, None) = decl.pat.node;
if let hir::StmtExpr(ref if_, _) = expr.node;
if let hir::ExprIf(ref cond, ref then, ref else_) = if_.node;
if !used_in_expr(cx, canonical_id, cond);
let sug = format!(
"let {mut}{name} = if {cond} {{{then} {value} }} else {{{else} {default} }};",
mut=mutability,
- name=name.node,
+ name=ident.name,
cond=snippet(cx, cond.span, "_"),
then=if then.stmts.len() > 1 { " ..;" } else { "" },
else=if default_multi_stmts { " ..;" } else { "" },
GenericArg::Type(_) => None,
});
for bound in lifetimes {
- if bound.name.name() != "'static" && !bound.is_elided() {
+ if bound.name.ident().name != "'static" && !bound.is_elided() {
return;
}
bounds_lts.push(bound);
for par in named_generics.iter() {
if let GenericParamKind::Lifetime { .. } = par.kind {
if par.bounds.is_empty() {
- allowed_lts.insert(RefLt::Named(par.name.name()));
+ allowed_lts.insert(RefLt::Named(par.name.ident().name));
}
}
}
fn lts_from_bounds<'a, T: Iterator<Item = &'a Lifetime>>(mut vec: Vec<RefLt>, bounds_lts: T) -> Vec<RefLt> {
for lt in bounds_lts {
- if lt.name.name() != "'static" {
- vec.push(RefLt::Named(lt.name.name()));
+ if lt.name.ident().name != "'static" {
+ vec.push(RefLt::Named(lt.name.ident().name));
}
}
fn record(&mut self, lifetime: &Option<Lifetime>) {
if let Some(ref lt) = *lifetime {
- if lt.name.name() == "'static" {
+ if lt.name.ident().name == "'static" {
self.lts.push(RefLt::Static);
} else if lt.is_elided() {
self.lts.push(RefLt::Unnamed);
} else {
- self.lts.push(RefLt::Named(lt.name.name()));
+ self.lts.push(RefLt::Named(lt.name.ident().name));
}
} else {
self.lts.push(RefLt::Unnamed);
impl<'tcx> Visitor<'tcx> for LifetimeChecker {
// for lifetimes as parameters of generics
fn visit_lifetime(&mut self, lifetime: &'tcx Lifetime) {
- self.map.remove(&lifetime.name.name());
+ self.map.remove(&lifetime.name.ident().name);
}
fn visit_generic_param(&mut self, param: &'tcx GenericParam) {
fn report_extra_lifetimes<'a, 'tcx: 'a>(cx: &LateContext<'a, 'tcx>, func: &'tcx FnDecl, generics: &'tcx Generics) {
let hs = generics.params.iter()
.filter_map(|par| match par.kind {
- GenericParamKind::Lifetime { .. } => Some((par.name.name(), par.span)),
+ GenericParamKind::Lifetime { .. } => Some((par.name.ident().name, par.span)),
_ => None,
})
.collect();
impl<'tcx> Visitor<'tcx> for BodyLifetimeChecker {
// for lifetimes as parameters of generics
fn visit_lifetime(&mut self, lifetime: &'tcx Lifetime) {
- if lifetime.name.name() != keywords::Invalid.name() && lifetime.name.name() != "'static" {
+ if lifetime.name.ident().name != keywords::Invalid.name() && lifetime.name.ident().name != "'static" {
self.lifetimes_used_in_body = true;
}
}
{
let iter_expr = &method_args[0];
let lhs_constructor = last_path_segment(qpath);
- if method_path.name == "next" && match_trait_method(cx, match_expr, &paths::ITERATOR)
- && lhs_constructor.name == "Some" && !is_refutable(cx, &pat_args[0])
+ if method_path.ident.name == "next" && match_trait_method(cx, match_expr, &paths::ITERATOR)
+ && lhs_constructor.ident.name == "Some" && !is_refutable(cx, &pat_args[0])
&& !is_iterator_used_after_while_let(cx, iter_expr)
&& !is_nested(cx, expr, &method_args[0])
{
fn check_stmt(&mut self, cx: &LateContext<'a, 'tcx>, stmt: &'tcx Stmt) {
if let StmtSemi(ref expr, _) = stmt.node {
if let ExprMethodCall(ref method, _, ref args) = expr.node {
- if args.len() == 1 && method.name == "collect" && match_trait_method(cx, expr, &paths::ITERATOR) {
+ if args.len() == 1 && method.ident.name == "collect" && match_trait_method(cx, expr, &paths::ITERATOR) {
span_lint(
cx,
UNUSED_COLLECT,
) -> Option<FixedOffsetVar> {
if_chain! {
if let ExprMethodCall(ref method, _, ref args) = expr.node;
- if method.name == "clone";
+ if method.ident.name == "clone";
if args.len() == 1;
if let Some(arg) = args.get(0);
then {
let print_limit = |end: &Option<&Expr>, offset: Offset, var_name: &str| if let Some(end) = *end {
if_chain! {
if let ExprMethodCall(ref method, _, ref len_args) = end.node;
- if method.name == "len";
+ if method.ident.name == "len";
if len_args.len() == 1;
if let Some(arg) = len_args.get(0);
if snippet(cx, arg.span, "??") == var_name;
}) = higher::range(cx, arg)
{
// the var must be a single name
- if let PatKind::Binding(_, canonical_id, ref ident, _) = pat.node {
+ if let PatKind::Binding(_, canonical_id, ident, _) = pat.node {
let mut visitor = VarVisitor {
cx,
var: canonical_id,
cx,
NEEDLESS_RANGE_LOOP,
expr.span,
- &format!("the loop variable `{}` is used to index `{}`", ident.node, indexed),
+ &format!("the loop variable `{}` is used to index `{}`", ident.name, indexed),
|db| {
multispan_sugg(
db,
"consider using an iterator".to_string(),
vec![
- (pat.span, format!("({}, <item>)", ident.node)),
+ (pat.span, format!("({}, <item>)", ident.name)),
(arg.span, format!("{}.{}().enumerate(){}{}", indexed, method, take, skip)),
],
);
cx,
NEEDLESS_RANGE_LOOP,
expr.span,
- &format!("the loop variable `{}` is only used to index `{}`.", ident.node, indexed),
+ &format!("the loop variable `{}` is only used to index `{}`.", ident.name, indexed),
|db| {
multispan_sugg(
db,
if_chain! {
if let ExprMethodCall(ref method, _, ref len_args) = expr.node;
if len_args.len() == 1;
- if method.name == "len";
+ if method.ident.name == "len";
if let ExprPath(QPath::Resolved(_, ref path)) = len_args[0].node;
if path.segments.len() == 1;
- if path.segments[0].name == var;
+ if path.segments[0].ident.name == var;
then {
return true;
}
if let ExprMethodCall(ref method, _, ref args) = arg.node {
// just the receiver, no arguments
if args.len() == 1 {
- let method_name = &*method.name.as_str();
+ let method_name = &*method.ident.as_str();
// check for looping over x.iter() or x.iter_mut(), could use &x or &mut x
if method_name == "iter" || method_name == "iter_mut" {
if is_ref_iterable_type(cx, &args[0]) {
fn pat_is_wild<'tcx>(pat: &'tcx PatKind, body: &'tcx Expr) -> bool {
match *pat {
PatKind::Wild => true,
- PatKind::Binding(_, _, ident, None) if ident.node.as_str().starts_with('_') => {
+ PatKind::Binding(_, _, ident, None) if ident.as_str().starts_with('_') => {
let mut visitor = UsedVisitor {
- var: ident.node,
+ var: ident.name,
used: false,
};
walk_expr(&mut visitor, body);
if indexed_indirectly || index_used_directly {
if self.prefer_mutable {
- self.indexed_mut.insert(seqvar.segments[0].name);
+ self.indexed_mut.insert(seqvar.segments[0].ident.name);
}
let def = self.cx.tables.qpath_def(seqpath, seqexpr.hir_id);
match def {
let parent_def_id = self.cx.tcx.hir.local_def_id(parent_id);
let extent = self.cx.tcx.region_scope_tree(parent_def_id).var_scope(hir_id.local_id);
if indexed_indirectly {
- self.indexed_indirectly.insert(seqvar.segments[0].name, Some(extent));
+ self.indexed_indirectly.insert(seqvar.segments[0].ident.name, Some(extent));
}
if index_used_directly {
- self.indexed_directly.insert(seqvar.segments[0].name, Some(extent));
+ self.indexed_directly.insert(seqvar.segments[0].ident.name, Some(extent));
}
return false; // no need to walk further *on the variable*
}
Def::Static(..) | Def::Const(..) => {
if indexed_indirectly {
- self.indexed_indirectly.insert(seqvar.segments[0].name, None);
+ self.indexed_indirectly.insert(seqvar.segments[0].ident.name, None);
}
if index_used_directly {
- self.indexed_directly.insert(seqvar.segments[0].name, None);
+ self.indexed_directly.insert(seqvar.segments[0].ident.name, None);
}
return false; // no need to walk further *on the variable*
}
if_chain! {
// a range index op
if let ExprMethodCall(ref meth, _, ref args) = expr.node;
- if (meth.name == "index" && match_trait_method(self.cx, expr, &paths::INDEX))
- || (meth.name == "index_mut" && match_trait_method(self.cx, expr, &paths::INDEX_MUT));
+ if (meth.ident.name == "index" && match_trait_method(self.cx, expr, &paths::INDEX))
+ || (meth.ident.name == "index_mut" && match_trait_method(self.cx, expr, &paths::INDEX_MUT));
if !self.check(&args[1], &args[0], expr);
then { return }
}
self.nonindex = true;
} else {
// not the correct variable, but still a variable
- self.referenced.insert(path.segments[0].name);
+ self.referenced.insert(path.segments[0].ident.name);
}
}
}
// Look for declarations of the variable
if let DeclLocal(ref local) = decl.node {
if local.pat.id == self.var_id {
- if let PatKind::Binding(_, _, ref ident, _) = local.pat.node {
- self.name = Some(ident.node);
+ if let PatKind::Binding(_, _, ident, _) = local.pat.node {
+ self.name = Some(ident.name);
self.state = if let Some(ref init) = local.init {
if is_integer_literal(init, 0) {
return;
}
if let PatKind::Binding(_, _, span_name, _) = pat.node {
- if self.iterator == span_name.node {
+ if self.iterator == span_name.name {
self.nesting = RuledOut;
return;
}
if let ExprPath(QPath::Resolved(_, ref path)) = e.node {
let segments = &path.segments;
if segments.len() == 1 {
- return Some(segments[0].name);
+ return Some(segments[0].ident.name);
}
};
None
use rustc::hir::*;
use rustc::ty;
use syntax::ast;
-use crate::utils::{get_arg_name, is_adjusted, iter_input_pats, match_qpath, match_trait_method, match_type,
+use crate::utils::{get_arg_ident, is_adjusted, iter_input_pats, match_qpath, match_trait_method, match_type,
paths, remove_blocks, snippet, span_help_and_lint, walk_ptrs_ty, walk_ptrs_ty_depth};
/// **What it does:** Checks for mapping `clone()` over an iterator.
fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
// call to .map()
if let ExprMethodCall(ref method, _, ref args) = expr.node {
- if method.name == "map" && args.len() == 2 {
+ if method.ident.name == "map" && args.len() == 2 {
match args[1].node {
ExprClosure(_, ref decl, closure_eid, _, _) => {
let body = cx.tcx.hir.body(closure_eid);
// nothing special in the argument, besides reference bindings
// (e.g. .map(|&x| x) )
if let Some(first_arg) = iter_input_pats(decl, body).next();
- if let Some(arg_ident) = get_arg_name(&first_arg.pat);
+ if let Some(arg_ident) = get_arg_ident(&first_arg.pat);
// the method is being called on a known type (option or iterator)
if let Some(type_name) = get_type_name(cx, expr, &args[0]);
then {
}
// explicit clone() calls ( .map(|x| x.clone()) )
else if let ExprMethodCall(ref clone_call, _, ref clone_args) = closure_expr.node {
- if clone_call.name == "clone" &&
+ if clone_call.ident.name == "clone" &&
clone_args.len() == 1 &&
match_trait_method(cx, closure_expr, &paths::CLONE_TRAIT) &&
expr_eq_name(&clone_args[0], arg_ident)
}
}
-fn expr_eq_name(expr: &Expr, id: ast::Name) -> bool {
+fn expr_eq_name(expr: &Expr, id: ast::Ident) -> bool {
match expr.node {
ExprPath(QPath::Resolved(None, ref path)) => {
let arg_segment = [
PathSegment {
- name: id,
+ ident: id,
args: None,
infer_types: true,
},
}
}
-fn only_derefs(cx: &LateContext, expr: &Expr, id: ast::Name) -> bool {
+fn only_derefs(cx: &LateContext, expr: &Expr, id: ast::Ident) -> bool {
match expr.node {
ExprUnary(UnDeref, ref subexpr) if !is_adjusted(cx, subexpr) => only_derefs(cx, subexpr, id),
_ => expr_eq_name(expr, id),
}
print::to_string(print::NO_ANN, |s| s.print_qpath(path, false))
},
- PatKind::Binding(BindingAnnotation::Unannotated, _, ident, None) => ident.node.to_string(),
+ PatKind::Binding(BindingAnnotation::Unannotated, _, ident, None) => ident.to_string(),
PatKind::Path(ref path) => print::to_string(print::NO_ANN, |s| s.print_qpath(path, false)),
_ => return,
};
if_chain! {
if let PatKind::TupleStruct(ref path, ref pats, _) = arm.pats[0].node;
if pats.len() == 1 && match_qpath(path, &paths::OPTION_SOME);
- if let PatKind::Binding(rb, _, ref ident, _) = pats[0].node;
+ if let PatKind::Binding(rb, _, ident, _) = pats[0].node;
if rb == BindingAnnotation::Ref || rb == BindingAnnotation::RefMut;
if let ExprCall(ref e, ref args) = remove_blocks(&arm.body).node;
if let ExprPath(ref some_path) = e.node;
if match_qpath(some_path, &paths::OPTION_SOME) && args.len() == 1;
if let ExprPath(ref qpath) = args[0].node;
if let &QPath::Resolved(_, ref path2) = qpath;
- if path2.segments.len() == 1 && ident.node == path2.segments[0].name;
+ if path2.segments.len() == 1 && ident.name == path2.segments[0].ident.name;
then {
return Some(rb)
}
lint_unnecessary_fold(cx, expr, arglists[0]);
}
- lint_or_fun_call(cx, expr, *method_span, &method_call.name.as_str(), args);
- lint_expect_fun_call(cx, expr, *method_span, &method_call.name.as_str(), args);
+ lint_or_fun_call(cx, expr, *method_span, &method_call.ident.as_str(), args);
+ lint_expect_fun_call(cx, expr, *method_span, &method_call.ident.as_str(), args);
let self_ty = cx.tables.expr_ty_adjusted(&args[0]);
- if args.len() == 1 && method_call.name == "clone" {
+ if args.len() == 1 && method_call.ident.name == "clone" {
lint_clone_on_copy(cx, expr, &args[0], self_ty);
lint_clone_on_ref_ptr(cx, expr, &args[0]);
}
match self_ty.sty {
ty::TyRef(_, ty, _) if ty.sty == ty::TyStr => for &(method, pos) in &PATTERN_METHODS {
- if method_call.name == method && args.len() > pos {
+ if method_call.ident.name == method && args.len() > pos {
lint_single_char_pattern(cx, expr, &args[pos]);
}
},
if in_external_macro(cx, implitem.span) {
return;
}
- let name = implitem.name;
+ let name = implitem.ident.name;
let parent = cx.tcx.hir.get_parent(implitem.id);
let item = cx.tcx.hir.expect_item(parent);
if_chain! {
if name == "unwrap_or" {
if let hir::ExprPath(ref qpath) = fun.node {
- let path = &*last_path_segment(qpath).name.as_str();
+ let path = &*last_path_segment(qpath).ident.as_str();
if ["default", "new"].contains(&path) {
let arg_ty = cx.tables.expr_ty(arg);
}
if let hir::ExprMethodCall(ref path, _, ref args) = expr.node {
- if path.name == "iter" && may_slice(cx, cx.tables.expr_ty(&args[0])) {
+ if path.ident.name == "iter" && may_slice(cx, cx.tables.expr_ty(&args[0])) {
sugg::Sugg::hir_opt(cx, &args[0]).map(|sugg| sugg.addr())
} else {
None
if arg_char.len() == 1;
if let hir::ExprPath(ref qpath) = fun.node;
if let Some(segment) = single_segment_path(qpath);
- if segment.name == "Some";
+ if segment.ident.name == "Some";
then {
let self_ty = walk_ptrs_ty(cx.tables.expr_ty_adjusted(&args[0][0]));
single_segment_ty(ty).map_or(false, |seg| {
generics.params.iter().any(|param| match param.kind {
hir::GenericParamKind::Type { .. } => {
- param.name.name() == seg.name && param.bounds.iter().any(|bound| {
+ param.name.ident().name == seg.ident.name && param.bounds.iter().any(|bound| {
if let hir::GenericBound::Trait(ref ptr, ..) = *bound {
let path = &ptr.trait_ref.path;
match_path(path, name) && path.segments.last().map_or(false, |s| {
) => ty_path
.segments
.iter()
- .map(|seg| seg.name)
- .eq(self_ty_path.segments.iter().map(|seg| seg.name)),
+ .map(|seg| seg.ident.name)
+ .eq(self_ty_path.segments.iter().map(|seg| seg.ident.name)),
_ => false,
}
}
}
let binding = match expr.node {
ExprPath(ref qpath) => {
- let binding = last_path_segment(qpath).name.as_str();
+ let binding = last_path_segment(qpath).ident.as_str();
if binding.starts_with('_') &&
!binding.starts_with("__") &&
binding != "_result" && // FIXME: #944
}
fn check_pat(&mut self, cx: &LateContext<'a, 'tcx>, pat: &'tcx Pat) {
- if let PatKind::Binding(_, _, ref ident, Some(ref right)) = pat.node {
+ if let PatKind::Binding(_, _, ident, Some(ref right)) = pat.node {
if right.node == PatKind::Wild {
span_lint(
cx,
REDUNDANT_PATTERN,
pat.span,
- &format!("the `{} @ _` pattern can be written as just `{}`", ident.node, ident.node),
+ &format!("the `{} @ _` pattern can be written as just `{}`", ident.name, ident.name),
);
}
}
fn check_nan(cx: &LateContext, path: &Path, expr: &Expr) {
if !in_constant(cx, expr.id) {
if let Some(seg) = path.segments.last() {
- if seg.name == "NAN" {
+ if seg.ident.name == "NAN" {
span_lint(
cx,
CMP_NAN,
fn check_generics(&mut self, cx: &EarlyContext, gen: &Generics) {
for param in &gen.params {
if let GenericParamKind::Type { .. } = param.kind {
- let name = param.ident.name.as_str();
+ let name = param.ident.as_str();
if constants::BUILTIN_TYPES.contains(&&*name) {
span_lint(
cx,
for arg in &decl.inputs {
if let PatKind::Ident(_, ident, None) = arg.pat.node {
- let arg_name = ident.name.to_string();
+ let arg_name = ident.to_string();
if arg_name.starts_with('_') {
if let Some(correspondence) = registered_names.get(&arg_name[1..]) {
let def_id = cx.tables.type_dependent_defs()[e.hir_id].def_id();
let substs = cx.tables.node_substs(e.hir_id);
let method_type = cx.tcx.type_of(def_id).subst(cx.tcx, substs);
- check_arguments(cx, arguments, method_type, &path.name.as_str())
+ check_arguments(cx, arguments, method_type, &path.ident.as_str())
},
_ => (),
}
// Ignore `self`s.
if idx == 0 {
- if let PatKind::Binding(_, _, name, ..) = arg.pat.node {
- if name.node.as_str() == "self" {
+ if let PatKind::Binding(_, _, ident, ..) = arg.pat.node {
+ if ident.as_str() == "self" {
continue;
}
}
get_spans(cx, Some(body.id()), idx, &[("clone", ".to_owned()")]);
if let TyPath(QPath::Resolved(_, ref path)) = input.node;
if let Some(elem_ty) = path.segments.iter()
- .find(|seg| seg.name == "Vec")
+ .find(|seg| seg.ident.name == "Vec")
.and_then(|ps| ps.args.as_ref())
.map(|params| params.args.iter().find_map(|arg| match arg {
GenericArg::Type(ty) => Some(ty),
return;
}
if let hir::ImplItemKind::Method(ref sig, _) = impl_item.node {
- let name = impl_item.name;
+ let name = impl_item.ident.name;
let id = impl_item.id;
if sig.header.constness == hir::Constness::Const {
// can't be implemented by default
fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, e: &'tcx Expr) {
if let ExprMethodCall(ref path, _, ref arguments) = e.node {
let obj_ty = walk_ptrs_ty(cx.tables.expr_ty(&arguments[0]));
- if path.name == "open" && match_type(cx, obj_ty, &paths::OPEN_OPTIONS) {
+ if path.ident.name == "open" && match_type(cx, obj_ty, &paths::OPEN_OPTIONS) {
let mut options = Vec::new();
get_open_options(cx, &arguments[0], &mut options);
check_open_options(cx, &options, e.span);
_ => Argument::Unknown,
};
- match &*path.name.as_str() {
+ match &*path.ident.as_str() {
"create" => {
options.push((OpenOption::Create, argument_option));
},
if trait_ref.path.def.def_id() == eq_trait;
then {
for impl_item in impl_items {
- if impl_item.name == "ne" {
+ if impl_item.ident.name == "ne" {
span_lint(cx,
PARTIALEQ_NE_IMPL,
impl_item.span,
if_chain! {
if let ExprIf(ref if_expr, ref body, _) = expr.node;
if let ExprMethodCall(ref segment, _, ref args) = if_expr.node;
- if segment.name == "is_none";
+ if segment.ident.name == "is_none";
if Self::expression_returns_none(cx, body);
if let Some(subject) = args.get(0);
if Self::is_option(cx, subject);
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
fn check_expr(&mut self, cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr) {
if let ExprMethodCall(ref path, _, ref args) = expr.node {
- let name = path.name.as_str();
+ let name = path.ident.as_str();
// Range with step_by(0).
if name == "step_by" && args.len() == 2 && has_step_by(cx, &args[0]) {
if_chain! {
// .iter() call
if let ExprMethodCall(ref iter_path, _, ref iter_args ) = *iter;
- if iter_path.name == "iter";
+ if iter_path.ident.name == "iter";
// range expression in .zip() call: 0..x.len()
if let Some(higher::Range { start: Some(start), end: Some(end), .. }) = higher::range(cx, zip_arg);
if is_integer_literal(start, 0);
// .len() call
if let ExprMethodCall(ref len_path, _, ref len_args) = end.node;
- if len_path.name == "len" && len_args.len() == 1;
+ if len_path.ident.name == "len" && len_args.len() == 1;
// .iter() and .len() called on same Path
if let ExprPath(QPath::Resolved(_, ref iter_path)) = iter_args[0].node;
if let ExprPath(QPath::Resolved(_, ref len_path)) = len_args[0].node;
if let Some(ref initexpr) = local.init;
if let ast::PatKind::Ident(_, ident, _) = local.pat.node;
if let ast::ExprKind::Path(_, ref path) = retexpr.node;
- if match_path_ast(path, &[&ident.name.as_str()]);
+ if match_path_ast(path, &[&ident.as_str()]);
if !in_external_macro(cx, initexpr.span);
then {
span_note_and_lint(cx,
let mut seen_str = None;
let mut seen_string = None;
for item in items {
- match &*item.name.as_str() {
+ match &*item.ident.as_str() {
"visit_str" => seen_str = Some(item.span),
"visit_string" => seen_string = Some(item.span),
_ => {},
let mut bindings = Vec::new();
for arg in iter_input_pats(decl, body) {
if let PatKind::Binding(_, _, ident, _) = arg.pat.node {
- bindings.push((ident.node, ident.span))
+ bindings.push((ident.name, ident.span))
}
}
check_expr(cx, &body.value, &mut bindings);
) {
// TODO: match more stuff / destructuring
match pat.node {
- PatKind::Binding(_, _, ref ident, ref inner) => {
- let name = ident.node;
+ PatKind::Binding(_, _, ident, ref inner) => {
+ let name = ident.name;
if is_binding(cx, pat.hir_id) {
let mut new_binding = true;
for tup in bindings.iter_mut() {
}
fn path_eq_name(name: Name, path: &Path) -> bool {
- !path.is_global() && path.segments.len() == 1 && path.segments[0].name.as_str() == name.as_str()
+ !path.is_global() && path.segments.len() == 1 && path.segments[0].ident.as_str() == name.as_str()
}
use crate::utils::{in_macro, snippet};
if let ExprMethodCall(ref path, _, ref args) = e.node {
- if path.name == "as_bytes" {
+ if path.ident.name == "as_bytes" {
if let ExprLit(ref lit) = args[0].node {
if let LitKind::Str(ref lit_content, _) = lit.node {
if lit_content.as_str().chars().all(|c| c.is_ascii()) && !in_macro(args[0].span) {
if let StmtDecl(ref tmp, _) = w[0].node;
if let DeclLocal(ref tmp) = tmp.node;
if let Some(ref tmp_init) = tmp.init;
- if let PatKind::Binding(_, _, ref tmp_name, None) = tmp.pat.node;
+ if let PatKind::Binding(_, _, ident, None) = tmp.pat.node;
// foo() = bar();
if let StmtSemi(ref first, _) = w[1].node;
if let ExprPath(QPath::Resolved(None, ref rhs2)) = rhs2.node;
if rhs2.segments.len() == 1;
- if tmp_name.node.as_str() == rhs2.segments[0].name.as_str();
+ if ident.as_str() == rhs2.segments[0].ident.as_str();
if SpanlessEq::new(cx).ignore_fn().eq_expr(tmp_init, lhs1);
if SpanlessEq::new(cx).ignore_fn().eq_expr(rhs1, lhs2);
then {
let ltopt = if lt.is_elided() {
"".to_owned()
} else {
- format!("{} ", lt.name.name().as_str())
+ format!("{} ", lt.name.ident().name.as_str())
};
let mutopt = if mut_ty.mutbl == Mutability::MutMutable {
"mut "
}
if match_path(ty_path, &paths::HASHMAP) {
- if method.name == "new" {
+ if method.ident.name == "new" {
self.suggestions
.insert(e.span, "HashMap::default()".to_string());
- } else if method.name == "with_capacity" {
+ } else if method.ident.name == "with_capacity" {
self.suggestions.insert(
e.span,
format!(
);
}
} else if match_path(ty_path, &paths::HASHSET) {
- if method.name == "new" {
+ if method.ident.name == "new" {
self.suggestions
.insert(e.span, "HashSet::default()".to_string());
- } else if method.name == "with_capacity" {
+ } else if method.ident.name == "with_capacity" {
self.suggestions.insert(
e.span,
format!(
}
},
- hir::ExprMethodCall(ref path, _, ref args) => match &*path.name.as_str() {
+ hir::ExprMethodCall(ref path, _, ref args) => match &*path.ident.as_str() {
"expect" | "unwrap" | "unwrap_or" | "unwrap_or_else" => {
check_method_call(cx, &args[0], expr);
},
fn check_method_call(cx: &LateContext, call: &hir::Expr, expr: &hir::Expr) {
if let hir::ExprMethodCall(ref path, _, _) = call.node {
- let symbol = &*path.name.as_str();
+ let symbol = &*path.ident.as_str();
if match_trait_method(cx, call, &paths::IO_READ) && symbol == "read" {
span_lint(
cx,
fn visit_expr(&mut self, expr: &'tcx hir::Expr) {
match expr.node {
hir::ExprBreak(destination, _) | hir::ExprContinue(destination) => if let Some(label) = destination.label {
- self.labels.remove(&label.name.as_str());
+ self.labels.remove(&label.ident.as_str());
},
hir::ExprLoop(_, Some(label), _) | hir::ExprWhile(_, _, Some(label)) => {
- self.labels.insert(label.name.as_str(), expr.span);
+ self.labels.insert(label.ident.as_str(), expr.span);
},
_ => (),
}
if let Expr_::ExprPath(QPath::Resolved(None, path)) = &args[0].node;
let ty = cx.tables.expr_ty(&args[0]);
if match_type(cx, ty, &paths::OPTION) || match_type(cx, ty, &paths::RESULT);
- let name = method_name.name.as_str();
+ let name = method_name.ident.as_str();
if ["is_some", "is_none", "is_ok", "is_err"].contains(&&*name);
then {
assert!(args.len() == 1);
if_chain! {
if let Expr_::ExprMethodCall(ref method_name, _, ref args) = expr.node;
if let Expr_::ExprPath(QPath::Resolved(None, ref path)) = args[0].node;
- if ["unwrap", "unwrap_err"].contains(&&*method_name.name.as_str());
- let call_to_unwrap = method_name.name == "unwrap";
+ if ["unwrap", "unwrap_err"].contains(&&*method_name.ident.as_str());
+ let call_to_unwrap = method_name.ident.name == "unwrap";
if let Some(unwrappable) = self.unwrappables.iter()
.find(|u| u.ident.def == path.def);
then {
expr.span,
&format!("You checked before that `{}()` cannot fail. \
Instead of checking and unwrapping, it's better to use `if let` or `match`.",
- method_name.name),
+ method_name.ident.name),
|db| { db.span_label(unwrappable.check.span, "the check is happening here"); },
);
} else {
PANICKING_UNWRAP,
expr.span,
&format!("This call to `{}()` will always panic.",
- method_name.name),
+ method_name.ident.name),
|db| { db.span_label(unwrappable.check.span, "because of this check"); },
);
}
impl<'a, 'tcx> Visitor<'tcx> for UseSelfVisitor<'a, 'tcx> {
fn visit_path(&mut self, path: &'tcx Path, _id: NodeId) {
- if self.item_path.def == path.def && path.segments.last().expect(SEGMENTS_MSG).name != SelfType.name() {
+ if self.item_path.def == path.def && path.segments.last().expect(SEGMENTS_MSG).ident.name != SelfType.name() {
span_lint_and_then(self.cx, USE_SELF, path.span, "unnecessary structure name repetition", |db| {
db.span_suggestion(path.span, "use the applicable keyword", "Self".to_owned());
});
let obj_pat = self.next("object");
let field_name_pat = self.next("field_name");
println!("Field(ref {}, ref {}) = {};", obj_pat, field_name_pat, current);
- println!(" if {}.node.as_str() == {:?}", field_name_pat, field_ident.name.as_str());
+ println!(" if {}.node.as_str() == {:?}", field_name_pat, field_ident.as_str());
self.current = obj_pat;
self.visit_expr(object);
},
let current = format!("{}.node", self.current);
match pat.node {
PatKind::Wild => println!("Wild = {};", current),
- PatKind::Binding(anno, _, name, ref sub) => {
+ PatKind::Binding(anno, _, ident, ref sub) => {
let anno_pat = match anno {
BindingAnnotation::Unannotated => "BindingAnnotation::Unannotated",
BindingAnnotation::Mutable => "BindingAnnotation::Mutable",
} else {
println!("Binding({}, _, {}, None) = {};", anno_pat, name_pat, current);
}
- println!(" if {}.node.as_str() == \"{}\";", name_pat, name.node.as_str());
+ println!(" if {}.node.as_str() == \"{}\";", name_pat, ident.as_str());
}
PatKind::Struct(ref path, ref fields, ignore) => {
let path_pat = self.next("path");
} else {
print!(", ");
}
- print!("{:?}", segment.name.as_str());
+ print!("{:?}", segment.ident.as_str());
},
QPath::TypeRelative(ref ty, ref segment) => match ty.node {
hir::Ty_::TyPath(ref inner_path) => {
} else {
print!(", ");
}
- print!("{:?}", segment.name.as_str());
+ print!("{:?}", segment.ident.as_str());
},
ref other => print!("/* unimplemented: {:?}*/", other),
},
match (&left.node, &right.node) {
(&ExprAddrOf(l_mut, ref le), &ExprAddrOf(r_mut, ref re)) => l_mut == r_mut && self.eq_expr(le, re),
(&ExprContinue(li), &ExprContinue(ri)) => {
- both(&li.label, &ri.label, |l, r| l.name.as_str() == r.name.as_str())
+ both(&li.label, &ri.label, |l, r| l.ident.as_str() == r.ident.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)) => {
})
},
(&ExprBreak(li, ref le), &ExprBreak(ri, ref re)) => {
- both(&li.label, &ri.label, |l, r| l.name.as_str() == r.name.as_str())
+ both(&li.label, &ri.label, |l, r| l.ident.as_str() == r.ident.as_str())
&& both(le, re, |l, r| self.eq_expr(l, r))
},
(&ExprBox(ref l), &ExprBox(ref r)) => self.eq_expr(l, r),
},
(&ExprLit(ref l), &ExprLit(ref r)) => l.node == r.node,
(&ExprLoop(ref lb, ref ll, ref lls), &ExprLoop(ref rb, ref rl, ref rls)) => {
- lls == rls && self.eq_block(lb, rb) && both(ll, rl, |l, r| l.name.as_str() == r.name.as_str())
+ lls == rls && self.eq_block(lb, rb) && both(ll, rl, |l, r| l.ident.as_str() == r.ident.as_str())
},
(&ExprMatch(ref le, ref la, ref ls), &ExprMatch(ref re, ref ra, ref rs)) => {
ls == rs && self.eq_expr(le, re) && over(la, ra, |l, r| {
(&ExprUnary(l_op, ref le), &ExprUnary(r_op, ref re)) => l_op == r_op && self.eq_expr(le, re),
(&ExprArray(ref l), &ExprArray(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.ident.as_str() == r.ident.as_str())
},
_ => false,
}
self.eq_qpath(lp, rp) && over(la, ra, |l, r| self.eq_pat(l, r)) && ls == rs
},
(&PatKind::Binding(ref lb, _, ref li, ref lp), &PatKind::Binding(ref rb, _, ref ri, ref rp)) => {
- lb == rb && li.node.as_str() == ri.node.as_str() && both(lp, rp, |l, r| self.eq_pat(l, r))
+ lb == rb && li.name.as_str() == ri.name.as_str() && both(lp, rp, |l, r| self.eq_pat(l, r))
},
(&PatKind::Path(ref l), &PatKind::Path(ref r)) => self.eq_qpath(l, r),
(&PatKind::Lit(ref l), &PatKind::Lit(ref r)) => self.eq_expr(l, r),
fn eq_path_segment(&mut self, left: &PathSegment, right: &PathSegment) -> bool {
// The == of idents doesn't work with different contexts,
// we have to be explicit about hygiene
- if left.name.as_str() != right.name.as_str() {
+ if left.ident.as_str() != right.ident.as_str() {
return false;
}
match (&left.args, &right.args) {
}
fn eq_type_binding(&mut self, left: &TypeBinding, right: &TypeBinding) -> bool {
- left.name == right.name && self.eq_ty(&left.ty, &right.ty)
+ left.ident.name == right.ident.name && self.eq_ty(&left.ty, &right.ty)
}
}
let c: fn(_) -> _ = ExprContinue;
c.hash(&mut self.s);
if let Some(i) = i.label {
- self.hash_name(i.name);
+ self.hash_name(i.ident.name);
}
},
ExprYield(ref e) => {
let c: fn(_, _) -> _ = ExprBreak;
c.hash(&mut self.s);
if let Some(i) = i.label {
- self.hash_name(i.name);
+ self.hash_name(i.ident.name);
}
if let Some(ref j) = *j {
self.hash_expr(&*j);
c.hash(&mut self.s);
self.hash_block(b);
if let Some(i) = *i {
- self.hash_name(i.name);
+ self.hash_name(i.ident.name);
}
},
ExprMatch(ref e, ref arms, ref s) => {
ExprMethodCall(ref path, ref _tys, ref args) => {
let c: fn(_, _, _) -> _ = ExprMethodCall;
c.hash(&mut self.s);
- self.hash_name(path.name);
+ self.hash_name(path.ident.name);
self.hash_exprs(args);
},
ExprRepeat(ref e, ref l_id) => {
self.hash_expr(cond);
self.hash_block(b);
if let Some(l) = l {
- self.hash_name(l.name);
+ self.hash_name(l.ident.name);
}
},
}
self.hash_path(path);
},
QPath::TypeRelative(_, ref path) => {
- self.hash_name(path.name);
+ self.hash_name(path.ident.name);
},
}
// self.cx.tables.qpath_def(p, id).hash(&mut self.s);
pub fn hash_path(&mut self, p: &Path) {
p.is_global().hash(&mut self.s);
for p in &p.segments {
- self.hash_name(p.name);
+ self.hash_name(p.ident.name);
}
}
if !has_attr(&item.attrs) {
return;
}
- println!("impl item `{}`", item.name);
+ println!("impl item `{}`", item.ident.name);
match item.vis {
hir::Visibility::Public => println!("public"),
hir::Visibility::Crate(_) => println!("visible crate wide"),
},
hir::ExprMethodCall(ref path, _, ref args) => {
println!("{}MethodCall", ind);
- println!("{}method name: {}", ind, path.name);
+ println!("{}method name: {}", ind, path.ident.name);
for arg in args {
print_expr(cx, arg, indent + 1);
}
println!("{}rhs:", ind);
print_expr(cx, rhs, indent + 1);
},
- hir::ExprField(ref e, ref ident) => {
+ hir::ExprField(ref e, ident) => {
println!("{}Field", ind);
println!("{}field name: {}", ind, ident.name);
println!("{}struct expr:", ind);
println!("{}+", ind);
match pat.node {
hir::PatKind::Wild => println!("{}Wild", ind),
- hir::PatKind::Binding(ref mode, _, ref name, ref inner) => {
+ hir::PatKind::Binding(ref mode, _, ident, ref inner) => {
println!("{}Binding", ind);
println!("{}mode: {:?}", ind, mode);
- println!("{}name: {}", ind, name.node);
+ println!("{}name: {}", ind, ident.name);
if let Some(ref inner) = *inner {
println!("{}inner:", ind);
print_pat(cx, inner, indent + 1);
if let ItemKind::Mod(ref paths_mod) = paths.node {
let mut last_name: Option<LocalInternedString> = None;
for item in &paths_mod.items {
- let name = item.ident.name.as_str();
+ let name = item.ident.as_str();
if let Some(ref last_name) = last_name {
if **last_name > *name {
span_lint(
fn visit_path(&mut self, path: &'tcx Path, _: NodeId) {
if path.segments.len() == 1 {
- self.output.insert(path.segments[0].name);
+ self.output.insert(path.segments[0].ident.name);
}
}
fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> {
/// Check if an expression references a variable of the given name.
pub fn match_var(expr: &Expr, var: Name) -> bool {
if let ExprPath(QPath::Resolved(None, ref path)) = expr.node {
- if path.segments.len() == 1 && path.segments[0].name == var {
+ if path.segments.len() == 1 && path.segments[0].ident.name == var {
return true;
}
}
QPath::TypeRelative(ref ty, ref segment) => match ty.node {
TyPath(ref inner_path) => {
!segments.is_empty() && match_qpath(inner_path, &segments[..(segments.len() - 1)])
- && segment.name == segments[segments.len() - 1]
+ && segment.ident.name == segments[segments.len() - 1]
},
_ => false,
},
.iter()
.rev()
.zip(segments.iter().rev())
- .all(|(a, b)| a.name == *b)
+ .all(|(a, b)| a.ident.name == *b)
}
/// Match a `Path` against a slice of segment string literals, e.g.
for method_name in methods.iter().rev() {
// method chains are stored last -> first
if let ExprMethodCall(ref path, _, ref args) = current.node {
- if path.name == *method_name {
+ if path.ident.name == *method_name {
if args.iter().any(|e| in_macro(e.span)) {
return None;
}
pub fn get_item_name(cx: &LateContext, expr: &Expr) -> Option<Name> {
let parent_id = cx.tcx.hir.get_parent(expr.id);
match cx.tcx.hir.find(parent_id) {
- Some(Node::NodeItem(&Item { ref name, .. })) |
- Some(Node::NodeTraitItem(&TraitItem { ref name, .. })) |
- Some(Node::NodeImplItem(&ImplItem { ref name, .. })) => Some(*name),
+ Some(Node::NodeItem(&Item { ref name, .. })) => Some(*name),
+ Some(Node::NodeTraitItem(&TraitItem { ident, .. })) |
+ Some(Node::NodeImplItem(&ImplItem { ident, .. })) => Some(ident.name),
_ => None,
}
}
/// Get the name of a `Pat`, if any
pub fn get_pat_name(pat: &Pat) -> Option<Name> {
match pat.node {
- PatKind::Binding(_, _, ref spname, _) => Some(spname.node),
- PatKind::Path(ref qpath) => single_segment_path(qpath).map(|ps| ps.name),
+ PatKind::Binding(_, _, ref spname, _) => Some(spname.name),
+ PatKind::Path(ref qpath) => single_segment_path(qpath).map(|ps| ps.ident.name),
PatKind::Box(ref p) | PatKind::Ref(ref p, _) => get_pat_name(&*p),
_ => None,
}
pub fn last_line_of_span<'a, T: LintContext<'a>>(cx: &T, span: Span) -> Span {
let file_map_and_line = cx.sess().codemap().lookup_line(span.lo()).unwrap();
let line_no = file_map_and_line.line;
- let line_start = &file_map_and_line.fm.lines.clone().into_inner()[line_no];
+ let line_start = &file_map_and_line.fm.lines[line_no];
Span::new(*line_start, span.hi(), span.ctxt())
}
pub fn is_self(slf: &Arg) -> bool {
if let PatKind::Binding(_, _, name, _) = slf.pat.node {
- name.node == keywords::SelfValue.name()
+ name.name == keywords::SelfValue.name()
} else {
false
}
pub fn get_arg_name(pat: &Pat) -> Option<ast::Name> {
match pat.node {
- PatKind::Binding(_, _, name, None) => Some(name.node),
+ PatKind::Binding(_, _, ident, None) => Some(ident.name),
PatKind::Ref(ref subpat, _) => get_arg_name(subpat),
_ => None,
}
}
+pub fn get_arg_ident(pat: &Pat) -> Option<ast::Ident> {
+ match pat.node {
+ PatKind::Binding(_, _, ident, None) => Some(ident),
+ PatKind::Ref(ref subpat, _) => get_arg_ident(subpat),
+ _ => None,
+ }
+}
+
pub fn int_bits(tcx: TyCtxt, ity: ast::IntTy) -> u64 {
layout::Integer::from_attr(tcx, attr::IntType::SignedInt(ity)).size().bits()
}
}
if let ExprMethodCall(ref seg, _, ref args) = expr.node {
if args.len() == 1 && match_var(&args[0], self.name) {
- if seg.name == "capacity" {
+ if seg.ident.name == "capacity" {
self.abort = true;
return;
}
for &(fn_name, suffix) in self.replace {
- if seg.name == fn_name {
+ if seg.ident.name == fn_name {
self.spans
.push((expr.span, snippet(self.cx, args[0].span, "_") + suffix));
return;
},
// write!()
ExprMethodCall(ref fun, _, ref args) => {
- if fun.name == "write_fmt" {
+ if fun.ident.name == "write_fmt" {
check_write_variants(cx, expr, args);
}
},
if let ExprStruct(_, ref fields, _) = format_field.node;
if let Some(width_field) = fields.iter().find(|f| f.ident.name == "width");
if let ExprPath(ref qpath) = width_field.expr.node;
- if last_path_segment(qpath).name == "Implied";
+ if last_path_segment(qpath).ident.name == "Implied";
if let Some(align_field) = fields.iter().find(|f| f.ident.name == "align");
if let ExprPath(ref qpath) = align_field.expr.node;
- if last_path_segment(qpath).name == "Unknown";
+ if last_path_segment(qpath).ident.name == "Unknown";
if let Some(precision_field) = fields.iter().find(|f| f.ident.name == "precision");
if let ExprPath(ref qpath_precision) = precision_field.expr.node;
- if last_path_segment(qpath_precision).name == "Implied";
+ if last_path_segment(qpath_precision).ident.name == "Implied";
then {
return true;
}
projects / rust.git / commitdiff