2015-12-05 20:21:34 -06:00
|
|
|
use rustc::lint::*;
|
2016-01-03 07:00:42 -06:00
|
|
|
use std::collections::HashMap;
|
2016-08-05 11:50:02 -05:00
|
|
|
use std::char;
|
2015-12-05 20:21:34 -06:00
|
|
|
use syntax::ast::*;
|
2016-01-03 07:00:42 -06:00
|
|
|
use syntax::codemap::Span;
|
|
|
|
use syntax::visit::FnKind;
|
2016-08-27 18:52:01 -05:00
|
|
|
use utils::{constants, span_lint, span_help_and_lint, snippet, snippet_opt, span_lint_and_then};
|
2016-08-06 02:55:04 -05:00
|
|
|
|
|
|
|
/// **What it does:** Checks for structure field patterns bound to wildcards.
|
2015-12-14 15:16:56 -06:00
|
|
|
///
|
2016-08-06 02:55:04 -05:00
|
|
|
/// **Why is this bad?** Using `..` instead is shorter and leaves the focus on
|
|
|
|
/// the fields that are actually bound.
|
2015-12-14 15:16:56 -06:00
|
|
|
///
|
|
|
|
/// **Known problems:** None.
|
|
|
|
///
|
2016-07-15 17:25:44 -05:00
|
|
|
/// **Example:**
|
|
|
|
/// ```rust
|
|
|
|
/// let { a: _, b: ref b, c: _ } = ..
|
|
|
|
/// ```
|
2016-02-05 17:13:29 -06:00
|
|
|
declare_lint! {
|
2016-08-06 03:18:36 -05:00
|
|
|
pub UNNEEDED_FIELD_PATTERN,
|
|
|
|
Warn,
|
|
|
|
"struct fields bound to a wildcard instead of using `..`"
|
2016-02-05 17:13:29 -06:00
|
|
|
}
|
2015-12-05 20:21:34 -06:00
|
|
|
|
2016-08-06 02:55:04 -05:00
|
|
|
/// **What it does:** Checks for function arguments having the similar names
|
|
|
|
/// differing by an underscore.
|
2016-01-03 07:00:42 -06:00
|
|
|
///
|
2016-08-06 02:55:04 -05:00
|
|
|
/// **Why is this bad?** It affects code readability.
|
2016-01-03 07:00:42 -06:00
|
|
|
///
|
|
|
|
/// **Known problems:** None.
|
|
|
|
///
|
2016-07-15 17:25:44 -05:00
|
|
|
/// **Example:**
|
|
|
|
/// ```rust
|
|
|
|
/// fn foo(a: i32, _a: i32) {}
|
|
|
|
/// ```
|
2016-02-05 17:13:29 -06:00
|
|
|
declare_lint! {
|
2016-08-06 03:18:36 -05:00
|
|
|
pub DUPLICATE_UNDERSCORE_ARGUMENT,
|
|
|
|
Warn,
|
|
|
|
"function arguments having names which only differ by an underscore"
|
2016-02-05 17:13:29 -06:00
|
|
|
}
|
2016-01-03 07:00:42 -06:00
|
|
|
|
2016-08-06 02:55:04 -05:00
|
|
|
/// **What it does:** Detects closures called in the same expression where they are defined.
|
2016-03-03 13:14:49 -06:00
|
|
|
///
|
|
|
|
/// **Why is this bad?** It is unnecessarily adding to the expression's complexity.
|
|
|
|
///
|
|
|
|
/// **Known problems:** None.
|
|
|
|
///
|
2016-07-15 17:25:44 -05:00
|
|
|
/// **Example:**
|
|
|
|
/// ```rust
|
|
|
|
/// (|| 42)()
|
|
|
|
/// ```
|
2016-03-03 13:14:49 -06:00
|
|
|
declare_lint! {
|
2016-08-06 03:18:36 -05:00
|
|
|
pub REDUNDANT_CLOSURE_CALL,
|
|
|
|
Warn,
|
|
|
|
"throwaway closures called in the expression they are defined"
|
2016-03-03 13:14:49 -06:00
|
|
|
}
|
|
|
|
|
2016-08-06 02:55:04 -05:00
|
|
|
/// **What it does:** Detects expressions of the form `--x`.
|
2016-06-29 18:00:25 -05:00
|
|
|
///
|
2016-08-06 02:55:04 -05:00
|
|
|
/// **Why is this bad?** It can mislead C/C++ programmers to think `x` was
|
|
|
|
/// decremented.
|
2016-06-29 18:00:25 -05:00
|
|
|
///
|
|
|
|
/// **Known problems:** None.
|
|
|
|
///
|
2016-07-15 17:25:44 -05:00
|
|
|
/// **Example:**
|
|
|
|
/// ```rust
|
|
|
|
/// --x;
|
|
|
|
/// ```
|
2016-06-29 18:00:25 -05:00
|
|
|
declare_lint! {
|
2016-08-06 03:18:36 -05:00
|
|
|
pub DOUBLE_NEG,
|
|
|
|
Warn,
|
|
|
|
"`--x`, which is a double negation of `x` and not a pre-decrement as in C/C++"
|
2016-06-29 18:00:25 -05:00
|
|
|
}
|
|
|
|
|
2016-08-05 11:30:07 -05:00
|
|
|
/// **What it does:** Warns on hexadecimal literals with mixed-case letter digits.
|
|
|
|
///
|
|
|
|
/// **Why is this bad?** It looks confusing.
|
|
|
|
///
|
|
|
|
/// **Known problems:** None.
|
|
|
|
///
|
|
|
|
/// **Example:**
|
|
|
|
/// ```rust
|
|
|
|
/// let y = 0x1a9BAcD;
|
|
|
|
/// ```
|
|
|
|
declare_lint! {
|
2016-08-06 03:18:36 -05:00
|
|
|
pub MIXED_CASE_HEX_LITERALS,
|
|
|
|
Warn,
|
|
|
|
"hex literals whose letter digits are not consistently upper- or lowercased"
|
2016-08-05 11:30:07 -05:00
|
|
|
}
|
|
|
|
|
2016-08-05 11:50:02 -05:00
|
|
|
/// **What it does:** Warns if literal suffixes are not separated by an underscore.
|
|
|
|
///
|
|
|
|
/// **Why is this bad?** It is much less readable.
|
|
|
|
///
|
|
|
|
/// **Known problems:** None.
|
|
|
|
///
|
|
|
|
/// **Example:**
|
|
|
|
/// ```rust
|
|
|
|
/// let y = 123832i32;
|
|
|
|
/// ```
|
|
|
|
declare_lint! {
|
2016-08-06 03:18:36 -05:00
|
|
|
pub UNSEPARATED_LITERAL_SUFFIX,
|
|
|
|
Allow,
|
|
|
|
"literals whose suffix is not separated by an underscore"
|
2016-08-05 11:50:02 -05:00
|
|
|
}
|
|
|
|
|
2016-08-24 07:37:09 -05:00
|
|
|
/// **What it does:** Warns if an integral constant literal starts with `0`.
|
2016-08-20 11:11:15 -05:00
|
|
|
///
|
|
|
|
/// **Why is this bad?** In some languages (including the infamous C language and most of its
|
|
|
|
/// familly), this marks an octal constant. In Rust however, this is a decimal constant. This could
|
|
|
|
/// be confusing for both the writer and a reader of the constant.
|
|
|
|
///
|
|
|
|
/// **Known problems:** None.
|
|
|
|
///
|
|
|
|
/// **Example:**
|
|
|
|
///
|
|
|
|
/// In Rust:
|
|
|
|
/// ```rust
|
|
|
|
/// fn main() {
|
|
|
|
/// let a = 0123;
|
|
|
|
/// println!("{}", a);
|
|
|
|
/// }
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// prints `123`, while in C:
|
|
|
|
///
|
|
|
|
/// ```c
|
|
|
|
/// #include <stdio.h>
|
|
|
|
///
|
|
|
|
/// int main() {
|
|
|
|
/// int a = 0123;
|
|
|
|
/// printf("%d\n", a);
|
|
|
|
/// }
|
|
|
|
/// ```
|
|
|
|
///
|
2016-08-24 07:37:09 -05:00
|
|
|
/// prints `83` (as `83 == 0o123` while `123 == 0o173`).
|
2016-08-20 11:11:15 -05:00
|
|
|
declare_lint! {
|
|
|
|
pub ZERO_PREFIXED_LITERAL,
|
|
|
|
Warn,
|
|
|
|
"integer literals starting with `0`"
|
|
|
|
}
|
|
|
|
|
2016-08-27 18:52:01 -05:00
|
|
|
/// **What it does:** Warns if a generic shadows a built-in type.
|
|
|
|
///
|
|
|
|
/// **Why is this bad?** This gives surprising type errors.
|
|
|
|
///
|
|
|
|
/// **Known problems:** None.
|
|
|
|
///
|
|
|
|
/// **Example:**
|
|
|
|
///
|
|
|
|
/// ```rust
|
|
|
|
/// impl<u32> Foo<u32> {
|
|
|
|
/// fn impl_func(&self) -> u32 {
|
|
|
|
/// 42
|
|
|
|
/// }
|
|
|
|
/// }
|
|
|
|
/// ```
|
|
|
|
declare_lint! {
|
|
|
|
pub BUILTIN_TYPE_SHADOW,
|
|
|
|
Warn,
|
|
|
|
"shadowing a builtin type"
|
|
|
|
}
|
|
|
|
|
2016-06-29 18:00:25 -05:00
|
|
|
|
2015-12-05 20:21:34 -06:00
|
|
|
#[derive(Copy, Clone)]
|
|
|
|
pub struct MiscEarly;
|
|
|
|
|
|
|
|
impl LintPass for MiscEarly {
|
|
|
|
fn get_lints(&self) -> LintArray {
|
2016-12-20 11:21:30 -06:00
|
|
|
lint_array!(UNNEEDED_FIELD_PATTERN,
|
|
|
|
DUPLICATE_UNDERSCORE_ARGUMENT,
|
|
|
|
REDUNDANT_CLOSURE_CALL,
|
|
|
|
DOUBLE_NEG,
|
|
|
|
MIXED_CASE_HEX_LITERALS,
|
|
|
|
UNSEPARATED_LITERAL_SUFFIX,
|
|
|
|
ZERO_PREFIXED_LITERAL,
|
|
|
|
BUILTIN_TYPE_SHADOW)
|
2015-12-05 20:21:34 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl EarlyLintPass for MiscEarly {
|
2016-08-27 18:52:01 -05:00
|
|
|
fn check_generics(&mut self, cx: &EarlyContext, gen: &Generics) {
|
|
|
|
for ty in &gen.ty_params {
|
|
|
|
let name = ty.ident.name.as_str();
|
|
|
|
if constants::BUILTIN_TYPES.contains(&&*name) {
|
|
|
|
span_lint(cx,
|
|
|
|
BUILTIN_TYPE_SHADOW,
|
|
|
|
ty.span,
|
|
|
|
&format!("This generic shadows the built-in type `{}`", name));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-12-05 20:21:34 -06:00
|
|
|
fn check_pat(&mut self, cx: &EarlyContext, pat: &Pat) {
|
2016-02-17 06:38:44 -06:00
|
|
|
if let PatKind::Struct(ref npat, ref pfields, _) = pat.node {
|
2015-12-05 20:21:34 -06:00
|
|
|
let mut wilds = 0;
|
2016-02-20 14:03:45 -06:00
|
|
|
let type_name = npat.segments.last().expect("A path must have at least one segment").identifier.name;
|
2015-12-05 20:21:34 -06:00
|
|
|
|
|
|
|
for field in pfields {
|
2016-02-17 06:38:44 -06:00
|
|
|
if field.node.pat.node == PatKind::Wild {
|
2015-12-05 20:21:34 -06:00
|
|
|
wilds += 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if !pfields.is_empty() && wilds == pfields.len() {
|
2016-01-03 22:26:12 -06:00
|
|
|
span_help_and_lint(cx,
|
|
|
|
UNNEEDED_FIELD_PATTERN,
|
|
|
|
pat.span,
|
|
|
|
"All the struct fields are matched to a wildcard pattern, consider using `..`.",
|
|
|
|
&format!("Try with `{} {{ .. }}` instead", type_name));
|
2015-12-05 20:21:34 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
if wilds > 0 {
|
2016-01-03 22:26:12 -06:00
|
|
|
let mut normal = vec![];
|
2016-01-01 22:52:13 -06:00
|
|
|
|
|
|
|
for field in pfields {
|
2016-02-17 06:38:44 -06:00
|
|
|
if field.node.pat.node != PatKind::Wild {
|
2016-01-01 22:52:13 -06:00
|
|
|
if let Ok(n) = cx.sess().codemap().span_to_snippet(field.span) {
|
|
|
|
normal.push(n);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2015-12-05 20:21:34 -06:00
|
|
|
for field in pfields {
|
2016-02-17 06:38:44 -06:00
|
|
|
if field.node.pat.node == PatKind::Wild {
|
2016-01-01 22:52:13 -06:00
|
|
|
wilds -= 1;
|
|
|
|
if wilds > 0 {
|
2016-01-03 22:26:12 -06:00
|
|
|
span_lint(cx,
|
|
|
|
UNNEEDED_FIELD_PATTERN,
|
|
|
|
field.span,
|
|
|
|
"You matched a field with a wildcard pattern. Consider using `..` instead");
|
2016-01-01 22:52:13 -06:00
|
|
|
} else {
|
2016-01-03 22:26:12 -06:00
|
|
|
span_help_and_lint(cx,
|
|
|
|
UNNEEDED_FIELD_PATTERN,
|
|
|
|
field.span,
|
|
|
|
"You matched a field with a wildcard pattern. Consider using `..` \
|
|
|
|
instead",
|
2016-01-01 22:52:13 -06:00
|
|
|
&format!("Try with `{} {{ {}, .. }}`",
|
|
|
|
type_name,
|
|
|
|
normal[..].join(", ")));
|
|
|
|
}
|
2015-12-05 20:21:34 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-01-03 07:00:42 -06:00
|
|
|
|
2016-11-16 14:57:56 -06:00
|
|
|
fn check_fn(&mut self, cx: &EarlyContext, _: FnKind, decl: &FnDecl, _: Span, _: NodeId) {
|
2016-01-03 22:26:12 -06:00
|
|
|
let mut registered_names: HashMap<String, Span> = HashMap::new();
|
2016-01-03 07:00:42 -06:00
|
|
|
|
2016-08-01 09:59:14 -05:00
|
|
|
for arg in &decl.inputs {
|
2016-02-17 06:38:44 -06:00
|
|
|
if let PatKind::Ident(_, sp_ident, None) = arg.pat.node {
|
2016-01-03 09:55:09 -06:00
|
|
|
let arg_name = sp_ident.node.to_string();
|
2016-01-03 07:00:42 -06:00
|
|
|
|
2016-02-14 21:40:43 -06:00
|
|
|
if arg_name.starts_with('_') {
|
2016-03-19 09:06:56 -05:00
|
|
|
if let Some(correspondence) = registered_names.get(&arg_name[1..]) {
|
2016-01-03 22:26:12 -06:00
|
|
|
span_lint(cx,
|
|
|
|
DUPLICATE_UNDERSCORE_ARGUMENT,
|
2016-03-19 09:06:56 -05:00
|
|
|
*correspondence,
|
2016-01-03 22:26:12 -06:00
|
|
|
&format!("`{}` already exists, having another argument having almost the same \
|
|
|
|
name makes code comprehension and documentation more difficult",
|
2016-03-03 13:14:49 -06:00
|
|
|
arg_name[1..].to_owned()));;
|
2016-01-03 09:55:09 -06:00
|
|
|
}
|
|
|
|
} else {
|
2016-02-02 15:35:01 -06:00
|
|
|
registered_names.insert(arg_name, arg.pat.span);
|
2016-01-03 07:00:42 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-03-03 13:14:49 -06:00
|
|
|
|
|
|
|
fn check_expr(&mut self, cx: &EarlyContext, expr: &Expr) {
|
2016-06-29 18:00:25 -05:00
|
|
|
match expr.node {
|
|
|
|
ExprKind::Call(ref paren, _) => {
|
|
|
|
if let ExprKind::Paren(ref closure) = paren.node {
|
|
|
|
if let ExprKind::Closure(_, ref decl, ref block, _) = closure.node {
|
|
|
|
span_lint_and_then(cx,
|
|
|
|
REDUNDANT_CLOSURE_CALL,
|
|
|
|
expr.span,
|
|
|
|
"Try not to call a closure in the expression where it is declared.",
|
|
|
|
|db| {
|
2016-12-21 03:25:14 -06:00
|
|
|
if decl.inputs.is_empty() {
|
|
|
|
let hint = snippet(cx, block.span, "..").into_owned();
|
|
|
|
db.span_suggestion(expr.span, "Try doing something like: ", hint);
|
|
|
|
}
|
|
|
|
});
|
2016-06-29 18:00:25 -05:00
|
|
|
}
|
2016-03-03 13:14:49 -06:00
|
|
|
}
|
2016-12-20 11:21:30 -06:00
|
|
|
},
|
2016-06-29 18:00:25 -05:00
|
|
|
ExprKind::Unary(UnOp::Neg, ref inner) => {
|
|
|
|
if let ExprKind::Unary(UnOp::Neg, _) = inner.node {
|
|
|
|
span_lint(cx,
|
|
|
|
DOUBLE_NEG,
|
|
|
|
expr.span,
|
|
|
|
"`--x` could be misinterpreted as pre-decrement by C programmers, is usually a no-op");
|
2016-08-05 11:30:07 -05:00
|
|
|
}
|
2016-12-20 11:21:30 -06:00
|
|
|
},
|
2016-08-05 11:30:07 -05:00
|
|
|
ExprKind::Lit(ref lit) => {
|
|
|
|
if_let_chain! {[
|
2016-08-20 11:11:15 -05:00
|
|
|
let LitKind::Int(value, ..) = lit.node,
|
2016-08-05 11:30:07 -05:00
|
|
|
let Some(src) = snippet_opt(cx, lit.span),
|
2016-08-05 11:50:02 -05:00
|
|
|
let Some(firstch) = src.chars().next(),
|
|
|
|
char::to_digit(firstch, 10).is_some()
|
2016-08-05 11:30:07 -05:00
|
|
|
], {
|
2016-08-05 11:50:02 -05:00
|
|
|
let mut prev = '\0';
|
2016-08-05 11:30:07 -05:00
|
|
|
for ch in src.chars() {
|
2016-08-05 11:50:02 -05:00
|
|
|
if ch == 'i' || ch == 'u' {
|
|
|
|
if prev != '_' {
|
|
|
|
span_lint(cx, UNSEPARATED_LITERAL_SUFFIX, lit.span,
|
|
|
|
"integer type suffix should be separated by an underscore");
|
|
|
|
}
|
|
|
|
break;
|
2016-08-05 11:30:07 -05:00
|
|
|
}
|
2016-08-05 11:50:02 -05:00
|
|
|
prev = ch;
|
2016-08-05 11:30:07 -05:00
|
|
|
}
|
2016-08-05 11:50:02 -05:00
|
|
|
if src.starts_with("0x") {
|
|
|
|
let mut seen = (false, false);
|
|
|
|
for ch in src.chars() {
|
|
|
|
match ch {
|
|
|
|
'a' ... 'f' => seen.0 = true,
|
|
|
|
'A' ... 'F' => seen.1 = true,
|
|
|
|
'i' | 'u' => break, // start of suffix already
|
|
|
|
_ => ()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if seen.0 && seen.1 {
|
|
|
|
span_lint(cx, MIXED_CASE_HEX_LITERALS, lit.span,
|
|
|
|
"inconsistent casing in hexadecimal literal");
|
|
|
|
}
|
2016-08-28 10:59:01 -05:00
|
|
|
} else if src.starts_with("0b") || src.starts_with("0o") {
|
|
|
|
/* nothing to do */
|
2016-08-20 11:11:15 -05:00
|
|
|
} else if value != 0 && src.starts_with('0') {
|
|
|
|
span_lint_and_then(cx,
|
|
|
|
ZERO_PREFIXED_LITERAL,
|
|
|
|
lit.span,
|
|
|
|
"this is a decimal constant",
|
|
|
|
|db| {
|
|
|
|
db.span_suggestion(lit.span, "if you mean to use a decimal constant, remove the `0` to remove confusion:", src[1..].to_string());
|
|
|
|
db.span_suggestion(lit.span, "if you mean to use an octal constant, use `0o`:", format!("0o{}", &src[1..]));
|
|
|
|
});
|
2016-08-05 11:50:02 -05:00
|
|
|
}
|
|
|
|
}}
|
|
|
|
if_let_chain! {[
|
|
|
|
let LitKind::Float(..) = lit.node,
|
|
|
|
let Some(src) = snippet_opt(cx, lit.span),
|
|
|
|
let Some(firstch) = src.chars().next(),
|
|
|
|
char::to_digit(firstch, 10).is_some()
|
|
|
|
], {
|
|
|
|
let mut prev = '\0';
|
|
|
|
for ch in src.chars() {
|
|
|
|
if ch == 'f' {
|
|
|
|
if prev != '_' {
|
|
|
|
span_lint(cx, UNSEPARATED_LITERAL_SUFFIX, lit.span,
|
|
|
|
"float type suffix should be separated by an underscore");
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
prev = ch;
|
2016-08-05 11:30:07 -05:00
|
|
|
}
|
|
|
|
}}
|
2016-12-20 11:21:30 -06:00
|
|
|
},
|
|
|
|
_ => (),
|
2016-03-03 13:14:49 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn check_block(&mut self, cx: &EarlyContext, block: &Block) {
|
|
|
|
for w in block.stmts.windows(2) {
|
|
|
|
if_let_chain! {[
|
2016-06-28 08:54:23 -05:00
|
|
|
let StmtKind::Local(ref local) = w[0].node,
|
2016-03-03 13:14:49 -06:00
|
|
|
let Option::Some(ref t) = local.init,
|
2016-06-28 08:54:23 -05:00
|
|
|
let ExprKind::Closure(_, _, _, _) = t.node,
|
|
|
|
let PatKind::Ident(_, sp_ident, _) = local.pat.node,
|
|
|
|
let StmtKind::Semi(ref second) = w[1].node,
|
|
|
|
let ExprKind::Assign(_, ref call) = second.node,
|
|
|
|
let ExprKind::Call(ref closure, _) = call.node,
|
|
|
|
let ExprKind::Path(_, ref path) = closure.node
|
2016-03-03 13:14:49 -06:00
|
|
|
], {
|
|
|
|
if sp_ident.node == (&path.segments[0]).identifier {
|
|
|
|
span_lint(cx, REDUNDANT_CLOSURE_CALL, second.span, "Closure called just once immediately after it was declared");
|
|
|
|
}
|
|
|
|
}}
|
|
|
|
}
|
|
|
|
}
|
2015-12-05 20:21:34 -06:00
|
|
|
}
|