let size = ConstInt::Infer(size as u64);
// Index is a constant uint
- let const_index = eval_const_expr_partial(cx.tcx, &index, ExprTypeChecked, None);
+ let const_index = eval_const_expr_partial(cx.tcx, index, ExprTypeChecked, None);
if let Ok(ConstVal::Integral(const_index)) = const_index {
if size <= const_index {
utils::span_lint(cx, OUT_OF_BOUNDS_INDEXING, e.span, "const index is out of bounds");
}
};
if complex {
- self.found_block = Some(&expr);
+ self.found_block = Some(expr);
return;
}
}
s.push('(');
}
}
- s.push_str(&snip(&terminals[n as usize]));
+ s.push_str(&snip(terminals[n as usize]));
if brackets {
if let ExprBinary(..) = terminals[n as usize].node {
s.push(')');
}
let mut improvements = Vec::new();
'simplified: for suggestion in &simplified {
- let simplified_stats = terminal_stats(&suggestion);
+ let simplified_stats = terminal_stats(suggestion);
let mut improvement = false;
for i in 0..32 {
// ignore any "simplifications" that end up requiring a terminal more often than in the original expression
}
}
(&Constant::Bool(ref l), &Constant::Bool(ref r)) => Some(l.cmp(r)),
- (&Constant::Vec(ref l), &Constant::Vec(ref r)) => l.partial_cmp(&r),
+ (&Constant::Vec(ref l), &Constant::Vec(ref r)) => l.partial_cmp(r),
(&Constant::Repeat(ref lv, ref ls), &Constant::Repeat(ref rv, ref rs)) => {
match lv.partial_cmp(rv) {
Some(Equal) => Some(ls.cmp(rs)),
};
if let ExprMatch(_, ref arms, MatchSource::Normal) = expr.node {
- if let Some((i, j)) = search_same(&arms, hash, eq) {
+ if let Some((i, j)) = search_same(arms, hash, eq) {
span_note_and_lint(cx,
MATCH_SAME_ARMS,
j.body.span,
match map.entry(hash(expr)) {
Entry::Occupied(o) => {
for o in o.get() {
- if eq(&o, expr) {
- return Some((&o, expr));
+ if eq(o, expr) {
+ return Some((o, expr));
}
}
}
divergence: 0,
short_circuits: 0,
returns: 0,
- tcx: &cx.tcx,
+ tcx: cx.tcx,
};
helper.visit_block(block);
let CCHelper { match_arms, divergence, short_circuits, returns, .. } = helper;
for var in &def.variants {
let name = var2str(var);
- let pre_match = partial_match(&pre, &name);
+ let pre_match = partial_match(pre, &name);
pre = &pre[..pre_match];
- let pre_camel = camel_case_until(&pre);
+ let pre_camel = camel_case_until(pre);
pre = &pre[..pre_camel];
while let Some((next, last)) = name[pre.len()..].chars().zip(pre.chars().rev()).next() {
if next.is_lowercase() {
}
}
- let post_match = partial_rmatch(&post, &name);
+ let post_match = partial_rmatch(post, &name);
let post_end = post.len() - post_match;
post = &post[post_end..];
- let post_camel = camel_case_from(&post);
+ let post_camel = camel_case_from(post);
post = &post[post_camel..];
}
let (what, value) = match (pre.is_empty(), post.is_empty()) {
})
}
- let ty = &walk_ptrs_ty(&cx.tcx.expr_ty(expr));
+ let ty = &walk_ptrs_ty(cx.tcx.expr_ty(expr));
match ty.sty {
ty::TyTrait(_) => {
cx.tcx
("clippy.toml", false)
};
- let (conf, errors) = utils::conf::read_conf(&file_name, must_exist);
+ let (conf, errors) = utils::conf::read_conf(file_name, must_exist);
// all conf errors are non-fatal, we just use the default conf in case of error
for error in errors {
impl LateLintPass for LifetimePass {
fn check_item(&mut self, cx: &LateContext, item: &Item) {
if let ItemFn(ref decl, _, _, _, ref generics, _) = item.node {
- check_fn_inner(cx, decl, None, &generics, item.span);
+ check_fn_inner(cx, decl, None, generics, item.span);
}
}
span,
"explicit lifetimes given in parameter types where they could be elided");
}
- report_extra_lifetimes(cx, decl, &generics, slf);
+ report_extra_lifetimes(cx, decl, generics, slf);
}
fn could_use_elision<'a, T: Iterator<Item = &'a Lifetime>>(cx: &LateContext, func: &FnDecl, slf: Option<&ExplicitSelf>,
/// Check for looping over a range and then indexing a sequence with it.
/// The iteratee must be a range literal.
fn check_for_loop_range(cx: &LateContext, pat: &Pat, arg: &Expr, body: &Expr, expr: &Expr) {
- if let Some(UnsugaredRange { start: Some(ref start), ref end, .. }) = unsugar_range(&arg) {
+ if let Some(UnsugaredRange { start: Some(ref start), ref end, .. }) = unsugar_range(arg) {
// the var must be a single name
if let PatKind::Ident(_, ref ident, _) = pat.node {
let mut visitor = VarVisitor {
};
let take: Cow<_> = if let Some(ref end) = *end {
- if is_len_call(&end, &indexed) {
+ if is_len_call(end, &indexed) {
"".into()
} else {
format!(".take({})", snippet(cx, end.span, "..")).into()
fn check_for_loop_reverse_range(cx: &LateContext, arg: &Expr, expr: &Expr) {
// if this for loop is iterating over a two-sided range...
- if let Some(UnsugaredRange { start: Some(ref start), end: Some(ref end), limits }) = unsugar_range(&arg) {
+ if let Some(UnsugaredRange { start: Some(ref start), end: Some(ref end), limits }) = unsugar_range(arg) {
// ...and both sides are compile-time constant integers...
- if let Ok(start_idx) = eval_const_expr_partial(&cx.tcx, start, ExprTypeChecked, None) {
- if let Ok(end_idx) = eval_const_expr_partial(&cx.tcx, end, ExprTypeChecked, None) {
+ if let Ok(start_idx) = eval_const_expr_partial(cx.tcx, start, ExprTypeChecked, None) {
+ if let Ok(end_idx) = eval_const_expr_partial(cx.tcx, end, ExprTypeChecked, None) {
// ...and the start index is greater than the end index,
// this loop will never run. This is often confusing for developers
// who think that this will iterate from the larger value to the
let mut values = Vec::with_capacity(2 * ranges.len());
for r in ranges {
- values.push(Kind::Start(r.node.0, &r));
- values.push(Kind::End(r.node.1, &r));
+ values.push(Kind::Start(r.node.0, r));
+ values.push(Kind::End(r.node.1, r));
}
values.sort();
}
}
(&Kind::End(a, _), &Kind::Start(b, _)) if a != b => (),
- _ => return Some((&a.range(), &b.range())),
+ _ => return Some((a.range(), b.range())),
}
}
lint_cstring_as_ptr(cx, expr, &arglists[0][0], &arglists[1][0]);
}
- lint_or_fun_call(cx, expr, &name.node.as_str(), &args);
+ lint_or_fun_call(cx, expr, &name.node.as_str(), args);
let self_ty = cx.tcx.expr_ty_adjusted(&args[0]);
if args.len() == 1 && name.node.as_str() == "clone" {
// check conventions w.r.t. conversion method names and predicates
let ty = cx.tcx.lookup_item_type(cx.tcx.map.local_def_id(item.id)).ty;
- let is_copy = is_copy(cx, &ty, &item);
+ let is_copy = is_copy(cx, ty, item);
for &(ref conv, self_kinds) in &CONVENTIONS {
if conv.check(&name.as_str()) &&
!self_kinds.iter().any(|k| k.matches(&sig.explicit_self.node, is_copy)) {
match parent.node {
ExprAssign(_, ref rhs) |
ExprAssignOp(_, _, ref rhs) => **rhs == *expr,
- _ => is_used(cx, &parent),
+ _ => is_used(cx, parent),
}
} else {
true
If this happened, the compiler would have \
aborted the compilation long ago");
if let ExprPath(_, ref path) = fn_expr.node {
- check_arguments(cx, &arguments, function_type, &path.to_string());
+ check_arguments(cx, arguments, function_type, &path.to_string());
}
}
ExprMethodCall(ref name, _, ref arguments) => {
let method_call = MethodCall::expr(e.id);
let method_type = borrowed_table.method_map.get(&method_call).expect("This should never happen.");
- check_arguments(cx, &arguments, method_type.ty, &name.node.as_str())
+ check_arguments(cx, arguments, method_type.ty, &name.node.as_str())
}
_ => (),
}
let mut visitor = SimilarNamesLocalVisitor {
names: Vec::new(),
cx: cx,
- lint: &self,
+ lint: self,
single_char_names: Vec::new(),
};
// initialize with function arguments
let len = bindings.len();
for ref arm in arms {
for ref pat in &arm.pats {
- check_pat(cx, &pat, &Some(&**init), pat.span, bindings);
+ check_pat(cx, pat, &Some(&**init), pat.span, bindings);
// This is ugly, but needed to get the right type
if let Some(ref guard) = arm.guard {
check_expr(cx, guard, bindings);
if let Some(norm_rhs_val) = node_as_const_fullint(cx, rhs) {
if rel == Rel::Eq || rel == Rel::Ne {
if norm_rhs_val < lb || norm_rhs_val > ub {
- err_upcast_comparison(cx, &span, lhs, rel == Rel::Ne);
+ err_upcast_comparison(cx, span, lhs, rel == Rel::Ne);
}
} else if match rel {
Rel::Lt => {
}
Rel::Eq | Rel::Ne => unreachable!(),
} {
- err_upcast_comparison(cx, &span, lhs, true)
+ err_upcast_comparison(cx, span, lhs, true)
} else if match rel {
Rel::Lt => {
if invert {
}
Rel::Eq | Rel::Ne => unreachable!(),
} {
- err_upcast_comparison(cx, &span, lhs, false)
+ err_upcast_comparison(cx, span, lhs, false)
}
}
}