* [License](#license)
##Lints
-There are 135 lints included in this crate:
+There are 136 lints included in this crate:
name | default | meaning
---------------------------------------------------------------------------------------------------------------------|---------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
[suspicious_assignment_formatting](https://github.com/Manishearth/rust-clippy/wiki#suspicious_assignment_formatting) | warn | suspicious formatting of `*=`, `-=` or `!=`
[suspicious_else_formatting](https://github.com/Manishearth/rust-clippy/wiki#suspicious_else_formatting) | warn | suspicious formatting of `else if`
[temporary_assignment](https://github.com/Manishearth/rust-clippy/wiki#temporary_assignment) | warn | assignments to temporaries
+[too_many_arguments](https://github.com/Manishearth/rust-clippy/wiki#too_many_arguments) | warn | functions with too many arguments
[toplevel_ref_arg](https://github.com/Manishearth/rust-clippy/wiki#toplevel_ref_arg) | warn | An entire binding was declared as `ref`, in a function argument (`fn foo(ref x: Bar)`), or a `let` statement (`let ref x = foo()`). In such cases, it is preferred to take references with `&`.
[trivial_regex](https://github.com/Manishearth/rust-clippy/wiki#trivial_regex) | warn | finds trivial regular expressions in `Regex::new(_)` invocations
[type_complexity](https://github.com/Manishearth/rust-clippy/wiki#type_complexity) | warn | usage of very complex types; recommends factoring out parts into `type` definitions
--- /dev/null
+use rustc::lint::*;
+use rustc_front::hir;
+use rustc_front::intravisit;
+use syntax::ast;
+use syntax::codemap::Span;
+use utils::span_lint;
+
+/// **What it does:** Check for functions with too many parameters.
+///
+/// **Why is this bad?** Functions with lots of parameters are considered bad style and reduce
+/// readability (“what does the 5th parameter means?”). Consider grouping some parameters into a
+/// new type.
+///
+/// **Known problems:** None.
+///
+/// **Example:**
+///
+/// ```
+/// fn foo(x: u32, y: u32, name: &str, c: Color, w: f32, h: f32, a: f32, b: f32) { .. }
+/// ```
+declare_lint! {
+ pub TOO_MANY_ARGUMENTS,
+ Warn,
+ "functions with too many arguments"
+}
+
+#[derive(Copy,Clone)]
+pub struct Functions {
+ threshold: u64,
+}
+
+impl Functions {
+ pub fn new(threshold: u64) -> Functions {
+ Functions {
+ threshold: threshold
+ }
+ }
+}
+
+impl LintPass for Functions {
+ fn get_lints(&self) -> LintArray {
+ lint_array!(TOO_MANY_ARGUMENTS)
+ }
+}
+
+impl LateLintPass for Functions {
+ fn check_fn(&mut self, cx: &LateContext, _: intravisit::FnKind, decl: &hir::FnDecl, _: &hir::Block, span: Span, nodeid: ast::NodeId) {
+ use rustc::front::map::Node::*;
+
+ if let Some(NodeItem(ref item)) = cx.tcx.map.find(cx.tcx.map.get_parent_node(nodeid)) {
+ match item.node {
+ hir::ItemImpl(_, _, _, Some(_), _, _) | hir::ItemDefaultImpl(..) => return,
+ _ => (),
+ }
+ }
+
+ self.check_arg_number(cx, decl, span);
+ }
+
+ fn check_trait_item(&mut self, cx: &LateContext, item: &hir::TraitItem) {
+ if let hir::MethodTraitItem(ref sig, _) = item.node {
+ self.check_arg_number(cx, &sig.decl, item.span);
+ }
+ }
+}
+
+impl Functions {
+ fn check_arg_number(&self, cx: &LateContext, decl: &hir::FnDecl, span: Span) {
+ let args = decl.inputs.len() as u64;
+ if args > self.threshold {
+ span_lint(cx, TOO_MANY_ARGUMENTS, span,
+ &format!("this function has to many arguments ({}/{})", args, self.threshold));
+ }
+ }
+}
pub mod eta_reduction;
pub mod format;
pub mod formatting;
+pub mod functions;
pub mod identity_op;
pub mod if_not_else;
pub mod items_after_statements;
reg.register_late_lint_pass(box unused_label::UnusedLabel);
reg.register_late_lint_pass(box new_without_default::NewWithoutDefault);
reg.register_late_lint_pass(box blacklisted_name::BlackListedName::new(conf.blacklisted_names));
+ reg.register_late_lint_pass(box functions::Functions::new(conf.too_many_arguments_threshold));
reg.register_lint_group("clippy_pedantic", vec![
array_indexing::INDEXING_SLICING,
format::USELESS_FORMAT,
formatting::SUSPICIOUS_ASSIGNMENT_FORMATTING,
formatting::SUSPICIOUS_ELSE_FORMATTING,
+ functions::TOO_MANY_ARGUMENTS,
identity_op::IDENTITY_OP,
if_not_else::IF_NOT_ELSE,
items_after_statements::ITEMS_AFTER_STATEMENTS,
/// Lint: CYCLOMATIC_COMPLEXITY. The maximum cyclomatic complexity a function can have
("cyclomatic-complexity-threshold", cyclomatic_complexity_threshold, 25 => u64),
/// Lint: TOO_MANY_ARGUMENTS. The maximum number of argument a function or method can have
- ("too-many-arguments-threshold", too_many_arguments_threshold, 6 => u64),
+ ("too-many-arguments-threshold", too_many_arguments_threshold, 7 => u64),
/// Lint: TYPE_COMPLEXITY. The maximum complexity a type can have
("type-complexity-threshold", type_complexity_threshold, 250 => u64),
}
--- /dev/null
+#![feature(plugin)]
+#![plugin(clippy)]
+
+#![deny(clippy)]
+#![allow(dead_code)]
+
+fn good(_one: u32, _two: u32, _three: &str, _four: bool, _five: f32, _six: f32, _seven: bool) {}
+
+fn bad(_one: u32, _two: u32, _three: &str, _four: bool, _five: f32, _six: f32, _seven: bool, _eight: ()) {
+ //~^ ERROR: this function has to many arguments (8/7)
+}
+
+trait Foo {
+ fn good(_one: u32, _two: u32, _three: &str, _four: bool, _five: f32, _six: f32, _seven: bool);
+ fn bad(_one: u32, _two: u32, _three: &str, _four: bool, _five: f32, _six: f32, _seven: bool, _eight: ());
+ //~^ ERROR: this function has to many arguments (8/7)
+}
+
+struct Bar;
+
+impl Bar {
+ fn good_method(_one: u32, _two: u32, _three: &str, _four: bool, _five: f32, _six: f32, _seven: bool) {}
+ fn bad_method(_one: u32, _two: u32, _three: &str, _four: bool, _five: f32, _six: f32, _seven: bool, _eight: ()) {}
+ //~^ ERROR: this function has to many arguments (8/7)
+}
+
+// ok, we don’t want to warn implementations
+impl Foo for Bar {
+ fn good(_one: u32, _two: u32, _three: &str, _four: bool, _five: f32, _six: f32, _seven: bool) {}
+ fn bad(_one: u32, _two: u32, _three: &str, _four: bool, _five: f32, _six: f32, _seven: bool, _eight: ()) {}
+}
+
+fn main() {}