From febf34e2b4ed9b66fc3095d55ae13cef9b6b154b Mon Sep 17 00:00:00 2001
From: Yoshitomo Nakanishi <yurayura.rounin.3@gmail.com>
Date: Wed, 24 Mar 2021 23:12:08 +0900
Subject: [PATCH] Move too_many_arguments to its own module
---
.../src/{functions.rs => functions/mod.rs} | 67 ++++++-----------
.../src/functions/too_many_arguments.rs | 73 +++++++++++++++++++
clippy_lints/src/lib.rs | 6 +-
3 files changed, 97 insertions(+), 49 deletions(-)
rename clippy_lints/src/{functions.rs => functions/mod.rs} (92%)
create mode 100644 clippy_lints/src/functions/too_many_arguments.rs
diff --git a/clippy_lints/src/functions.rs b/clippy_lints/src/functions/mod.rs
similarity index 92%
rename from clippy_lints/src/functions.rs
rename to clippy_lints/src/functions/mod.rs
index 730492fc7e3..68badb87b22 100644
--- a/clippy_lints/src/functions.rs
+++ b/clippy_lints/src/functions/mod.rs
@@ -1,9 +1,11 @@
+mod too_many_arguments;
+
use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_then};
use clippy_utils::source::{snippet, snippet_opt};
use clippy_utils::ty::{is_must_use_ty, is_type_diagnostic_item, type_is_unsafe_function};
use clippy_utils::{
- attr_by_name, attrs::is_proc_macro, is_trait_impl_item, iter_input_pats, match_def_path, must_use_attr,
- path_to_local, return_ty, trait_ref_of_method,
+ attr_by_name, attrs::is_proc_macro, iter_input_pats, match_def_path, must_use_attr, path_to_local, return_ty,
+ trait_ref_of_method,
};
use if_chain::if_chain;
use rustc_ast::ast::Attribute;
@@ -17,9 +19,7 @@ use rustc_middle::hir::map::Map;
use rustc_middle::lint::in_external_macro;
use rustc_middle::ty::{self, Ty};
use rustc_session::{declare_tool_lint, impl_lint_pass};
-use rustc_span::source_map::Span;
-use rustc_span::sym;
-use rustc_target::spec::abi::Abi;
+use rustc_span::{sym, Span};
use rustc_typeck::hir_ty_to_ty;
declare_clippy_lint! {
@@ -222,13 +222,16 @@ declare_clippy_lint! {
#[derive(Copy, Clone)]
pub struct Functions {
- threshold: u64,
- max_lines: u64,
+ too_many_arguments_threshold: u64,
+ too_many_lines_threshold: u64,
}
impl Functions {
- pub fn new(threshold: u64, max_lines: u64) -> Self {
- Self { threshold, max_lines }
+ pub fn new(too_many_arguments_threshold: u64, too_many_lines_threshold: u64) -> Self {
+ Self {
+ too_many_arguments_threshold,
+ too_many_lines_threshold,
+ }
}
}
@@ -252,31 +255,14 @@ impl<'tcx> LateLintPass<'tcx> for Functions {
span: Span,
hir_id: hir::HirId,
) {
+ too_many_arguments::check_fn(cx, kind, decl, span, hir_id, self.too_many_arguments_threshold);
+
let unsafety = match kind {
intravisit::FnKind::ItemFn(_, _, hir::FnHeader { unsafety, .. }, _) => unsafety,
intravisit::FnKind::Method(_, sig, _) => sig.header.unsafety,
intravisit::FnKind::Closure => return,
};
- // don't warn for implementations, it's not their fault
- if !is_trait_impl_item(cx, hir_id) {
- // don't lint extern functions decls, it's not their fault either
- match kind {
- intravisit::FnKind::Method(
- _,
- &hir::FnSig {
- header: hir::FnHeader { abi: Abi::Rust, .. },
- ..
- },
- _,
- )
- | intravisit::FnKind::ItemFn(_, _, hir::FnHeader { abi: Abi::Rust, .. }, _) => {
- self.check_arg_number(cx, decl, span.with_hi(decl.output.span().hi()))
- },
- _ => {},
- }
- }
-
Self::check_raw_ptr(cx, unsafety, decl, body, hir_id);
self.check_line_number(cx, span, body);
}
@@ -335,11 +321,9 @@ impl<'tcx> LateLintPass<'tcx> for Functions {
}
fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::TraitItem<'_>) {
+ too_many_arguments::check_trait_item(cx, item, self.too_many_arguments_threshold);
+
if let hir::TraitItemKind::Fn(ref sig, ref eid) = item.kind {
- // don't lint extern functions decls, it's not their fault
- if sig.header.abi == Abi::Rust {
- self.check_arg_number(cx, &sig.decl, item.span.with_hi(sig.decl.output.span().hi()));
- }
let is_public = cx.access_levels.is_exported(item.hir_id());
let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
if is_public {
@@ -372,18 +356,6 @@ impl<'tcx> LateLintPass<'tcx> for Functions {
}
impl<'tcx> Functions {
- fn check_arg_number(self, cx: &LateContext<'_>, decl: &hir::FnDecl<'_>, fn_span: Span) {
- let args = decl.inputs.len() as u64;
- if args > self.threshold {
- span_lint(
- cx,
- TOO_MANY_ARGUMENTS,
- fn_span,
- &format!("this function has too many arguments ({}/{})", args, self.threshold),
- );
- }
- }
-
fn check_line_number(self, cx: &LateContext<'_>, span: Span, body: &'tcx hir::Body<'_>) {
if in_external_macro(cx.sess(), span) {
return;
@@ -430,12 +402,15 @@ impl<'tcx> Functions {
}
}
- if line_count > self.max_lines {
+ if line_count > self.too_many_lines_threshold {
span_lint(
cx,
TOO_MANY_LINES,
span,
- &format!("this function has too many lines ({}/{})", line_count, self.max_lines),
+ &format!(
+ "this function has too many lines ({}/{})",
+ line_count, self.too_many_lines_threshold
+ ),
)
}
}
diff --git a/clippy_lints/src/functions/too_many_arguments.rs b/clippy_lints/src/functions/too_many_arguments.rs
new file mode 100644
index 00000000000..62b1e6bd7ca
--- /dev/null
+++ b/clippy_lints/src/functions/too_many_arguments.rs
@@ -0,0 +1,73 @@
+use rustc_hir::{self as hir, intravisit};
+use rustc_lint::LateContext;
+use rustc_span::Span;
+use rustc_target::spec::abi::Abi;
+
+use clippy_utils::diagnostics::span_lint;
+use clippy_utils::is_trait_impl_item;
+
+use super::TOO_MANY_ARGUMENTS;
+
+pub(super) fn check_fn(
+ cx: &LateContext<'tcx>,
+ kind: intravisit::FnKind<'tcx>,
+ decl: &'tcx hir::FnDecl<'_>,
+ span: Span,
+ hir_id: hir::HirId,
+ too_many_arguments_threshold: u64,
+) {
+ // don't warn for implementations, it's not their fault
+ if !is_trait_impl_item(cx, hir_id) {
+ // don't lint extern functions decls, it's not their fault either
+ match kind {
+ intravisit::FnKind::Method(
+ _,
+ &hir::FnSig {
+ header: hir::FnHeader { abi: Abi::Rust, .. },
+ ..
+ },
+ _,
+ )
+ | intravisit::FnKind::ItemFn(_, _, hir::FnHeader { abi: Abi::Rust, .. }, _) => check_arg_number(
+ cx,
+ decl,
+ span.with_hi(decl.output.span().hi()),
+ too_many_arguments_threshold,
+ ),
+ _ => {},
+ }
+ }
+}
+
+pub(super) fn check_trait_item(
+ cx: &LateContext<'tcx>,
+ item: &'tcx hir::TraitItem<'_>,
+ too_many_arguments_threshold: u64,
+) {
+ if let hir::TraitItemKind::Fn(ref sig, _) = item.kind {
+ // don't lint extern functions decls, it's not their fault
+ if sig.header.abi == Abi::Rust {
+ check_arg_number(
+ cx,
+ &sig.decl,
+ item.span.with_hi(sig.decl.output.span().hi()),
+ too_many_arguments_threshold,
+ );
+ }
+ }
+}
+
+fn check_arg_number(cx: &LateContext<'_>, decl: &hir::FnDecl<'_>, fn_span: Span, too_many_arguments_threshold: u64) {
+ let args = decl.inputs.len() as u64;
+ if args > too_many_arguments_threshold {
+ span_lint(
+ cx,
+ TOO_MANY_ARGUMENTS,
+ fn_span,
+ &format!(
+ "this function has too many arguments ({}/{})",
+ args, too_many_arguments_threshold
+ ),
+ );
+ }
+}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index f013613119c..3d3e57f7d2f 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -1124,9 +1124,9 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
store.register_late_pass(|| box new_without_default::NewWithoutDefault::default());
let blacklisted_names = conf.blacklisted_names.iter().cloned().collect::<FxHashSet<_>>();
store.register_late_pass(move || box blacklisted_name::BlacklistedName::new(blacklisted_names.clone()));
- let too_many_arguments_threshold1 = conf.too_many_arguments_threshold;
- let too_many_lines_threshold2 = conf.too_many_lines_threshold;
- store.register_late_pass(move || box functions::Functions::new(too_many_arguments_threshold1, too_many_lines_threshold2));
+ let too_many_arguments_threshold = conf.too_many_arguments_threshold;
+ let too_many_lines_threshold = conf.too_many_lines_threshold;
+ store.register_late_pass(move || box functions::Functions::new(too_many_arguments_threshold, too_many_lines_threshold));
let doc_valid_idents = conf.doc_valid_idents.iter().cloned().collect::<FxHashSet<_>>();
store.register_late_pass(move || box doc::DocMarkdown::new(doc_valid_idents.clone()));
store.register_late_pass(|| box neg_multiply::NegMultiply);