rust-clippy/clippy_lints/src/misc_early.rs

430 lines
14 KiB
Rust
Raw Normal View History

use crate::rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass, LintContext, in_external_macro};
use crate::rustc::{declare_tool_lint, lint_array};
use crate::rustc_data_structures::fx::FxHashMap;
2018-07-19 08:00:54 +00:00
use if_chain::if_chain;
use std::char;
use crate::syntax::ast::*;
use crate::syntax::source_map::Span;
use crate::syntax::visit::FnKind;
2018-07-24 06:55:38 +00:00
use crate::utils::{constants, snippet, snippet_opt, span_help_and_lint, span_lint, span_lint_and_then};
/// **What it does:** Checks for structure field patterns bound to wildcards.
2015-12-14 21:16:56 +00:00
///
/// **Why is this bad?** Using `..` instead is shorter and leaves the focus on
/// the fields that are actually bound.
2015-12-14 21:16:56 +00:00
///
/// **Known problems:** None.
///
2016-07-15 22:25:44 +00:00
/// **Example:**
/// ```rust
/// let { a: _, b: ref b, c: _ } = ..
/// ```
2018-03-28 13:24:26 +00:00
declare_clippy_lint! {
pub UNNEEDED_FIELD_PATTERN,
2018-03-28 13:24:26 +00:00
style,
"struct fields bound to a wildcard instead of using `..`"
}
/// **What it does:** Checks for function arguments having the similar names
/// differing by an underscore.
///
/// **Why is this bad?** It affects code readability.
///
/// **Known problems:** None.
///
2016-07-15 22:25:44 +00:00
/// **Example:**
/// ```rust
/// fn foo(a: i32, _a: i32) {}
/// ```
2018-03-28 13:24:26 +00:00
declare_clippy_lint! {
pub DUPLICATE_UNDERSCORE_ARGUMENT,
2018-03-28 13:24:26 +00:00
style,
"function arguments having names which only differ by an underscore"
}
2017-08-09 07:30:56 +00:00
/// **What it does:** Detects closures called in the same expression where they
/// are defined.
///
2017-08-09 07:30:56 +00:00
/// **Why is this bad?** It is unnecessarily adding to the expression's
/// complexity.
///
/// **Known problems:** None.
///
2016-07-15 22:25:44 +00:00
/// **Example:**
/// ```rust
/// (|| 42)()
/// ```
2018-03-28 13:24:26 +00:00
declare_clippy_lint! {
pub REDUNDANT_CLOSURE_CALL,
2018-03-29 11:41:53 +00:00
complexity,
"throwaway closures called in the expression they are defined"
}
/// **What it does:** Detects expressions of the form `--x`.
2016-06-29 23:00:25 +00:00
///
/// **Why is this bad?** It can mislead C/C++ programmers to think `x` was
/// decremented.
2016-06-29 23:00:25 +00:00
///
/// **Known problems:** None.
///
2016-07-15 22:25:44 +00:00
/// **Example:**
/// ```rust
/// --x;
/// ```
2018-03-28 13:24:26 +00:00
declare_clippy_lint! {
pub DOUBLE_NEG,
2018-03-28 13:24:26 +00:00
style,
"`--x`, which is a double negation of `x` and not a pre-decrement as in C/C++"
2016-06-29 23:00:25 +00:00
}
2017-08-09 07:30:56 +00: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;
/// ```
2018-03-28 13:24:26 +00:00
declare_clippy_lint! {
pub MIXED_CASE_HEX_LITERALS,
2018-03-28 13:24:26 +00:00
style,
"hex literals whose letter digits are not consistently upper- or lowercased"
}
2017-08-09 07:30:56 +00: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;
/// ```
2018-03-28 13:24:26 +00:00
declare_clippy_lint! {
pub UNSEPARATED_LITERAL_SUFFIX,
2018-03-28 13:24:26 +00:00
pedantic,
"literals whose suffix is not separated by an underscore"
}
2016-08-24 12:37:09 +00:00
/// **What it does:** Warns if an integral constant literal starts with `0`.
2016-08-20 16:11:15 +00:00
///
2017-08-09 07:30:56 +00:00
/// **Why is this bad?** In some languages (including the infamous C language
/// and most of its
/// family), this marks an octal constant. In Rust however, this is a decimal
/// constant. This could
2016-08-20 16:11:15 +00:00
/// 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 12:37:09 +00:00
/// prints `83` (as `83 == 0o123` while `123 == 0o173`).
2018-03-28 13:24:26 +00:00
declare_clippy_lint! {
2016-08-20 16:11:15 +00:00
pub ZERO_PREFIXED_LITERAL,
2018-03-28 13:24:26 +00:00
complexity,
2016-08-20 16:11:15 +00:00
"integer literals starting with `0`"
}
2016-08-27 23:52:01 +00: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
/// }
/// }
/// ```
2018-03-28 13:24:26 +00:00
declare_clippy_lint! {
2016-08-27 23:52:01 +00:00
pub BUILTIN_TYPE_SHADOW,
2018-03-28 13:24:26 +00:00
style,
2016-08-27 23:52:01 +00:00
"shadowing a builtin type"
}
#[derive(Copy, Clone)]
pub struct MiscEarly;
impl LintPass for MiscEarly {
fn get_lints(&self) -> LintArray {
2017-08-09 07:30:56 +00: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
)
}
}
impl EarlyLintPass for MiscEarly {
2018-07-23 11:01:12 +00:00
fn check_generics(&mut self, cx: &EarlyContext<'_>, gen: &Generics) {
for param in &gen.params {
if let GenericParamKind::Type { .. } = param.kind {
2018-06-28 13:46:58 +00:00
let name = param.ident.as_str();
if constants::BUILTIN_TYPES.contains(&&*name) {
span_lint(
cx,
BUILTIN_TYPE_SHADOW,
param.ident.span,
&format!("This generic shadows the built-in type `{}`", name),
);
}
2016-08-27 23:52:01 +00:00
}
}
}
2018-07-23 11:01:12 +00:00
fn check_pat(&mut self, cx: &EarlyContext<'_>, pat: &Pat) {
if let PatKind::Struct(ref npat, ref pfields, _) = pat.node {
let mut wilds = 0;
2017-08-09 07:30:56 +00:00
let type_name = npat.segments
.last()
.expect("A path must have at least one segment")
.ident
2017-08-09 07:30:56 +00:00
.name;
for field in pfields {
if let PatKind::Wild = field.node.pat.node {
wilds += 1;
}
}
if !pfields.is_empty() && wilds == pfields.len() {
2017-08-09 07:30:56 +00: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),
);
return;
}
if wilds > 0 {
2016-01-04 04:26:12 +00:00
let mut normal = vec![];
2016-01-02 04:52:13 +00:00
for field in pfields {
match field.node.pat.node {
PatKind::Wild => {},
_ => if let Ok(n) = cx.sess().source_map().span_to_snippet(field.span) {
2016-01-02 04:52:13 +00:00
normal.push(n);
},
2016-01-02 04:52:13 +00:00
}
}
for field in pfields {
if let PatKind::Wild = field.node.pat.node {
2016-01-02 04:52:13 +00:00
wilds -= 1;
if wilds > 0 {
2017-08-09 07:30:56 +00:00
span_lint(
cx,
UNNEEDED_FIELD_PATTERN,
field.span,
"You matched a field with a wildcard pattern. Consider using `..` instead",
);
2016-01-02 04:52:13 +00:00
} else {
2017-08-09 07:30:56 +00:00
span_help_and_lint(
cx,
UNNEEDED_FIELD_PATTERN,
field.span,
"You matched a field with a wildcard pattern. Consider using `..` \
2017-09-05 09:33:04 +00:00
instead",
2017-08-09 07:30:56 +00:00
&format!("Try with `{} {{ {}, .. }}`", type_name, normal[..].join(", ")),
);
2016-01-02 04:52:13 +00:00
}
}
}
}
}
}
2018-07-23 11:01:12 +00:00
fn check_fn(&mut self, cx: &EarlyContext<'_>, _: FnKind<'_>, decl: &FnDecl, _: Span, _: NodeId) {
let mut registered_names: FxHashMap<String, Span> = FxHashMap::default();
2016-08-01 14:59:14 +00:00
for arg in &decl.inputs {
if let PatKind::Ident(_, ident, None) = arg.pat.node {
2018-06-28 13:46:58 +00:00
let arg_name = ident.to_string();
if arg_name.starts_with('_') {
if let Some(correspondence) = registered_names.get(&arg_name[1..]) {
2017-08-09 07:30:56 +00:00
span_lint(
cx,
DUPLICATE_UNDERSCORE_ARGUMENT,
*correspondence,
&format!(
"`{}` already exists, having another argument having almost the same \
2017-09-05 09:33:04 +00:00
name makes code comprehension and documentation more difficult",
2017-08-09 07:30:56 +00:00
arg_name[1..].to_owned()
),
);;
2016-01-03 15:55:09 +00:00
}
} else {
registered_names.insert(arg_name, arg.pat.span);
}
}
}
}
2018-07-23 11:01:12 +00:00
fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
2018-07-24 06:55:38 +00:00
if in_external_macro(cx.sess(), expr.span) {
2017-05-09 15:15:13 +00:00
return;
}
2016-06-29 23:00:25 +00:00
match expr.node {
2017-09-05 09:33:04 +00:00
ExprKind::Call(ref paren, _) => if let ExprKind::Paren(ref closure) = paren.node {
if let ExprKind::Closure(_, _, _, ref decl, ref block, _) = closure.node {
2017-09-05 09:33:04 +00:00
span_lint_and_then(
2017-08-09 07:30:56 +00:00
cx,
2017-09-05 09:33:04 +00:00
REDUNDANT_CLOSURE_CALL,
2017-08-09 07:30:56 +00:00
expr.span,
2017-09-05 09:33:04 +00:00
"Try not to call a closure in the expression where it is declared.",
|db| if decl.inputs.is_empty() {
let hint = snippet(cx, block.span, "..").into_owned();
db.span_suggestion(expr.span, "Try doing something like: ", hint);
},
2017-08-09 07:30:56 +00:00
);
}
2016-12-20 17:21:30 +00:00
},
2017-09-05 09:33:04 +00: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",
);
},
ExprKind::Lit(ref lit) => self.check_lit(cx, lit),
2016-12-20 17:21:30 +00:00
_ => (),
}
}
2018-07-23 11:01:12 +00:00
fn check_block(&mut self, cx: &EarlyContext<'_>, block: &Block) {
for w in block.stmts.windows(2) {
if_chain! {
if let StmtKind::Local(ref local) = w[0].node;
if let Option::Some(ref t) = local.init;
if let ExprKind::Closure(..) = t.node;
if let PatKind::Ident(_, ident, _) = local.pat.node;
if let StmtKind::Semi(ref second) = w[1].node;
if let ExprKind::Assign(_, ref call) = second.node;
if let ExprKind::Call(ref closure, _) = call.node;
if let ExprKind::Path(_, ref path) = closure.node;
then {
2018-05-29 12:45:10 +00:00
if ident == path.segments[0].ident {
span_lint(
cx,
REDUNDANT_CLOSURE_CALL,
second.span,
"Closure called just once immediately after it was declared",
);
}
}
}
}
}
}
impl MiscEarly {
2018-07-23 11:01:12 +00:00
fn check_lit(self, cx: &EarlyContext<'_>, lit: &Lit) {
if_chain! {
if let LitKind::Int(value, ..) = lit.node;
if let Some(src) = snippet_opt(cx, lit.span);
if let Some(firstch) = src.chars().next();
if char::to_digit(firstch, 10).is_some();
then {
let mut prev = '\0';
for ch in src.chars() {
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;
}
prev = ch;
}
if src.starts_with("0x") {
let mut seen = (false, false);
for ch in src.chars() {
match ch {
2018-06-28 11:33:11 +00:00
'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");
}
} else if src.starts_with("0b") || src.starts_with("0o") {
/* nothing to do */
} 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.trim_left_matches(|c| c == '_' || c == '0').to_string(),
);
db.span_suggestion(
lit.span,
"if you mean to use an octal constant, use `0o`",
format!("0o{}", src.trim_left_matches(|c| c == '_' || c == '0')),
);
});
}
}
}
if_chain! {
if let LitKind::Float(..) = lit.node;
if let Some(src) = snippet_opt(cx, lit.span);
if let Some(firstch) = src.chars().next();
if char::to_digit(firstch, 10).is_some();
then {
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;
}
}
}
}
}