Autogenerate new lints

clippy_dev/src/main.rs

@@ -4,6 +4,7 @@ use clap::{App, Arg, SubCommand};
 use clippy_dev::*;
 
 mod fmt;
+mod new_lint;
 mod stderr_length_check;
 
 #[derive(PartialEq)]
@@ -51,6 +52,47 @@ fn main() {
                         .help("Checks that util/dev update_lints has been run. Used on CI."),
                 ),
         )
+        .subcommand(
+            SubCommand::with_name("new_lint")
+                .about("Create new lint and run util/dev update_lints")
+                .arg(
+                    Arg::with_name("pass")
+                        .short("p")
+                        .long("pass")
+                        .help("Specify whether the lint runs during the early or late pass")
+                        .takes_value(true)
+                        .possible_values(&["early", "late"])
+                        .required(true),
+                )
+                .arg(
+                    Arg::with_name("name")
+                        .short("n")
+                        .long("name")
+                        .help("Name of the new lint in snake case, ex: fn_too_long")
+                        .takes_value(true)
+                        .required(true),
+                )
+                .arg(
+                    Arg::with_name("category")
+                        .short("c")
+                        .long("category")
+                        .help("What category the lint belongs to")
+                        .default_value("nursery")
+                        .possible_values(&[
+                            "style",
+                            "correctness",
+                            "complexity",
+                            "perf",
+                            "pedantic",
+                            "restriction",
+                            "cargo",
+                            "nursery",
+                            "internal",
+                            "internal_warn",
+                        ])
+                        .takes_value(true),
+                ),
+        )
         .arg(
             Arg::with_name("limit-stderr-length")
                 .long("limit-stderr-length")
@@ -75,6 +117,16 @@ fn main() {
                 update_lints(&UpdateMode::Change);
             }
         },
+        ("new_lint", Some(matches)) => {
+            match new_lint::create(
+                matches.value_of("pass"),
+                matches.value_of("name"),
+                matches.value_of("category"),
+            ) {
+                Ok(_) => update_lints(&UpdateMode::Change),
+                Err(e) => eprintln!("Unable to create lint: {}", e),
+            }
+        },
         _ => {},
     }
 }

clippy_dev/src/new_lint.rs

@@ -0,0 +1,182 @@
+use std::fs::{File, OpenOptions};
+use std::io;
+use std::io::prelude::*;
+use std::io::ErrorKind;
+use std::path::{Path, PathBuf};
+
+pub fn create(pass: Option<&str>, lint_name: Option<&str>, category: Option<&str>) -> Result<(), io::Error> {
+    let pass = pass.expect("`pass` argument is validated by clap");
+    let lint_name = lint_name.expect("`name` argument is validated by clap");
+    let category = category.expect("`category` argument is validated by clap");
+
+    match open_files(lint_name) {
+        Ok((mut test_file, mut lint_file)) => {
+            let (pass_type, pass_import, context_import) = match pass {
+                "early" => ("EarlyLintPass", "use syntax::ast::*;", "EarlyContext"),
+                "late" => ("LateLintPass", "use rustc_hir::*;", "LateContext"),
+                _ => {
+                    unreachable!("`pass_type` should only ever be `early` or `late`!");
+                },
+            };
+
+            let camel_case_name = to_camel_case(lint_name);
+
+            if let Err(e) = test_file.write_all(get_test_file_contents(lint_name).as_bytes()) {
+                return Err(io::Error::new(
+                    ErrorKind::Other,
+                    format!("Could not write to test file: {}", e),
+                ));
+            };
+
+            if let Err(e) = lint_file.write_all(
+                get_lint_file_contents(
+                    pass_type,
+                    lint_name,
+                    &camel_case_name,
+                    category,
+                    pass_import,
+                    context_import,
+                )
+                .as_bytes(),
+            ) {
+                return Err(io::Error::new(
+                    ErrorKind::Other,
+                    format!("Could not write to lint file: {}", e),
+                ));
+            }
+            Ok(())
+        },
+        Err(e) => Err(io::Error::new(
+            ErrorKind::Other,
+            format!("Unable to create lint: {}", e),
+        )),
+    }
+}
+
+fn open_files(lint_name: &str) -> Result<(File, File), io::Error> {
+    let project_root = project_root()?;
+
+    let test_file_path = project_root.join("tests").join("ui").join(format!("{}.rs", lint_name));
+    let lint_file_path = project_root
+        .join("clippy_lints")
+        .join("src")
+        .join(format!("{}.rs", lint_name));
+
+    if Path::new(&test_file_path).exists() {
+        return Err(io::Error::new(
+            ErrorKind::AlreadyExists,
+            format!("test file {:?} already exists", test_file_path),
+        ));
+    }
+    if Path::new(&lint_file_path).exists() {
+        return Err(io::Error::new(
+            ErrorKind::AlreadyExists,
+            format!("lint file {:?} already exists", lint_file_path),
+        ));
+    }
+
+    let test_file = OpenOptions::new().write(true).create_new(true).open(test_file_path)?;
+    let lint_file = OpenOptions::new().write(true).create_new(true).open(lint_file_path)?;
+
+    Ok((test_file, lint_file))
+}
+
+fn project_root() -> Result<PathBuf, io::Error> {
+    let current_dir = std::env::current_dir()?;
+    for path in current_dir.ancestors() {
+        let result = std::fs::read_to_string(path.join("Cargo.toml"));
+        if let Err(err) = &result {
+            if err.kind() == io::ErrorKind::NotFound {
+                continue;
+            }
+        }
+
+        let content = result?;
+        if content.contains("[package]\nname = \"clippy\"") {
+            return Ok(path.to_path_buf());
+        }
+    }
+    Err(io::Error::new(ErrorKind::Other, "Unable to find project root"))
+}
+
+fn to_camel_case(name: &str) -> String {
+    name.split('_')
+        .map(|s| {
+            if s.is_empty() {
+                String::from("")
+            } else {
+                [&s[0..1].to_uppercase(), &s[1..]].concat()
+            }
+        })
+        .collect()
+}
+
+fn get_test_file_contents(lint_name: &str) -> String {
+    format!(
+        "#![warn(clippy::{})]
+
+fn main() {{
+    // test code goes here
+}}
+",
+        lint_name
+    )
+}
+
+fn get_lint_file_contents(
+    pass_type: &str,
+    lint_name: &str,
+    camel_case_name: &str,
+    category: &str,
+    pass_import: &str,
+    context_import: &str,
+) -> String {
+    format!(
+        "use rustc::lint::{{LintArray, LintPass, {type}, {context_import}}};
+use rustc_session::{{declare_lint_pass, declare_tool_lint}};
+{pass_import}
+
+declare_clippy_lint! {{
+    /// **What it does:**
+    ///
+    /// **Why is this bad?**
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Example:**
+    ///
+    /// ```rust
+    /// // example code
+    /// ```
+    pub {name_upper},
+    {category},
+    \"default lint description\"
+}}
+
+declare_lint_pass!({name_camel} => [{name_upper}]);
+
+impl {type} for {name_camel} {{}}
+",
+        type=pass_type,
+        name_upper=lint_name.to_uppercase(),
+        name_camel=camel_case_name,
+        category=category,
+        pass_import=pass_import,
+        context_import=context_import
+    )
+}
+
+#[test]
+fn test_camel_case() {
+    let s = "a_lint";
+    let s2 = to_camel_case(s);
+    assert_eq!(s2, "ALint");
+
+    let name = "a_really_long_new_lint";
+    let name2 = to_camel_case(name);
+    assert_eq!(name2, "AReallyLongNewLint");
+
+    let name3 = "lint__name";
+    let name4 = to_camel_case(name3);
+    assert_eq!(name4, "LintName");
+}

clippy_lints/src/lib.rs

@@ -1090,6 +1090,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&utils::internal_lints::LINT_WITHOUT_LINT_PASS),
         LintId::of(&utils::internal_lints::OUTER_EXPN_EXPN_DATA),
         LintId::of(&utils::internal_lints::PRODUCE_ICE),
+        LintId::of(&utils::internal_lints::DEFAULT_LINT),
     ]);
 
     store.register_group(true, "clippy::all", Some("clippy"), vec![

clippy_lints/src/utils/internal_lints.rs

@@ -13,10 +13,10 @@ use rustc_hir::*;
 use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass};
 use rustc_session::declare_tool_lint;
 use rustc_session::{declare_lint_pass, impl_lint_pass};
-use rustc_span::source_map::Span;
+use rustc_span::source_map::{Span, Spanned};
 use rustc_span::symbol::SymbolStr;
 use syntax::ast;
-use syntax::ast::{Crate as AstCrate, ItemKind, Name};
+use syntax::ast::{Crate as AstCrate, ItemKind, LitKind, Name};
 use syntax::visit::FnKind;
 
 declare_clippy_lint! {
@@ -121,6 +121,29 @@ declare_clippy_lint! {
     "this message should not appear anywhere as we ICE before and don't emit the lint"
 }
 
+declare_clippy_lint! {
+    /// **What it does:** Checks for cases of an auto-generated lint without an updated description,
+    /// i.e. `default lint description`.
+    ///
+    /// **Why is this bad?** Indicates that the lint is not finished.
+    ///
+    /// **Known problems:** None
+    ///
+    /// **Example:**
+    /// Bad:
+    /// ```rust,ignore
+    /// declare_lint! { pub COOL_LINT, nursery, "default lint description" }
+    /// ```
+    ///
+    /// Good:
+    /// ```rust,ignore
+    /// declare_lint! { pub COOL_LINT, nursery, "a great new lint" }
+    /// ```
+    pub DEFAULT_LINT,
+    internal,
+    "found 'default lint description' in a lint declaration"
+}
+
 declare_lint_pass!(ClippyLintsInternal => [CLIPPY_LINTS_INTERNAL]);
 
 impl EarlyLintPass for ClippyLintsInternal {
@@ -163,12 +186,34 @@ pub struct LintWithoutLintPass {
     registered_lints: FxHashSet<Name>,
 }
 
-impl_lint_pass!(LintWithoutLintPass => [LINT_WITHOUT_LINT_PASS]);
+impl_lint_pass!(LintWithoutLintPass => [DEFAULT_LINT, LINT_WITHOUT_LINT_PASS]);
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for LintWithoutLintPass {
     fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item<'_>) {
-        if let hir::ItemKind::Static(ref ty, Mutability::Not, _) = item.kind {
+        if let hir::ItemKind::Static(ref ty, Mutability::Not, body_id) = item.kind {
             if is_lint_ref_type(cx, ty) {
+                let expr = &cx.tcx.hir().body(body_id).value;
+                if_chain! {
+                    if let ExprKind::AddrOf(_, _, ref inner_exp) = expr.kind;
+                    if let ExprKind::Struct(_, ref fields, _) = inner_exp.kind;
+                    let field = fields.iter()
+                                      .find(|f| f.ident.as_str() == "desc")
+                                      .expect("lints must have a description field");
+                    if let ExprKind::Lit(Spanned {
+                        node: LitKind::Str(ref sym, _),
+                        ..
+                    }) = field.expr.kind;
+                    if sym.as_str() == "default lint description";
+
+                    then {
+                        span_lint(
+                            cx,
+                            DEFAULT_LINT,
+                            item.span,
+                            &format!("the lint `{}` has the default lint description", item.ident.name),
+                        );
+                    }
+                }
                 self.declared_lints.insert(item.ident.name, item.span);
             }
         } else if is_expn_of(item.span, "impl_lint_pass").is_some()