clippy_lints/src/utils/internal_lints.rs

   1 use rustc::lint::*;
   2 use rustc::hir::*;
   3 use rustc::hir::intravisit::{Visitor, walk_expr, NestedVisitorMap};
   4 use utils::{paths, match_path, span_lint};
   5 use syntax::symbol::InternedString;
   6 use syntax::ast::{Name, NodeId, ItemKind, Crate as AstCrate};
   7 use syntax::codemap::Span;
   8 use std::collections::{HashSet, HashMap};
   9
  10
  11 /// **What it does:** Checks for various things we like to keep tidy in clippy.
  12 ///
  13 /// **Why is this bad?** We like to pretend we're an example of tidy code.
  14 ///
  15 /// **Known problems:** None.
  16 ///
  17 /// **Example:** Wrong ordering of the util::paths constants.
  18 declare_lint! {
  19     pub CLIPPY_LINTS_INTERNAL,
  20     Allow,
  21     "various things that will negatively affect your clippy experience"
  22 }
  23
  24
  25 /// **What it does:** Ensures every lint is associated to a `LintPass`.
  26 ///
  27 /// **Why is this bad?** The compiler only knows lints via a `LintPass`. Without
  28 /// putting a lint to a `LintPass::get_lints()`'s return, the compiler will not
  29 /// know the name of the lint.
  30 ///
  31 /// **Known problems:** Only checks for lints associated using the `lint_array!`
  32 /// macro.
  33 ///
  34 /// **Example:**
  35 /// ```rust
  36 /// declare_lint! { pub LINT_1, ... }
  37 /// declare_lint! { pub LINT_2, ... }
  38 /// declare_lint! { pub FORGOTTEN_LINT, ... }
  39 /// // ...
  40 /// pub struct Pass;
  41 /// impl LintPass for Pass {
  42 ///     fn get_lints(&self) -> LintArray {
  43 ///         lint_array![LINT_1, LINT_2]
  44 ///         // missing FORGOTTEN_LINT
  45 ///     }
  46 /// }
  47 /// ```
  48 declare_lint! {
  49     pub LINT_WITHOUT_LINT_PASS,
  50     Warn,
  51     "declaring a lint without associating it in a LintPass"
  52 }
  53
  54
  55 #[derive(Copy, Clone)]
  56 pub struct Clippy;
  57
  58 impl LintPass for Clippy {
  59     fn get_lints(&self) -> LintArray {
  60         lint_array!(CLIPPY_LINTS_INTERNAL)
  61     }
  62 }
  63
  64 impl EarlyLintPass for Clippy {
  65     fn check_crate(&mut self, cx: &EarlyContext, krate: &AstCrate) {
  66         if let Some(utils) = krate.module.items.iter().find(|item| item.ident.name == "utils") {
  67             if let ItemKind::Mod(ref utils_mod) = utils.node {
  68                 if let Some(paths) = utils_mod.items.iter().find(|item| item.ident.name == "paths") {
  69                     if let ItemKind::Mod(ref paths_mod) = paths.node {
  70                         let mut last_name: Option<InternedString> = None;
  71                         for item in &paths_mod.items {
  72                             let name = item.ident.name.as_str();
  73                             if let Some(ref last_name) = last_name {
  74                                 if **last_name > *name {
  75                                     span_lint(cx,
  76                                               CLIPPY_LINTS_INTERNAL,
  77                                               item.span,
  78                                               "this constant should be before the previous constant due to lexical ordering",
  79                                     );
  80                                 }
  81                             }
  82                             last_name = Some(name);
  83                         }
  84                     }
  85                 }
  86             }
  87         }
  88     }
  89 }
  90
  91
  92
  93 #[derive(Clone, Debug, Default)]
  94 pub struct LintWithoutLintPass {
  95     declared_lints: HashMap<Name, Span>,
  96     registered_lints: HashSet<Name>,
  97 }
  98
  99
 100 impl LintPass for LintWithoutLintPass {
 101     fn get_lints(&self) -> LintArray {
 102         lint_array!(LINT_WITHOUT_LINT_PASS)
 103     }
 104 }
 105
 106
 107 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for LintWithoutLintPass {
 108     fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx Item) {
 109         if let ItemStatic(ref ty, MutImmutable, ref expr) = item.node {
 110             if is_lint_ref_type(ty) {
 111                 self.declared_lints.insert(item.name, item.span);
 112             } else if is_lint_array_type(ty) && item.vis == Visibility::Inherited && item.name == "ARRAY" {
 113                 let mut collector = LintCollector { output: &mut self.registered_lints, cx: cx };
 114                 collector.visit_expr(expr);
 115             }
 116         }
 117     }
 118
 119     fn check_crate_post(&mut self, cx: &LateContext<'a, 'tcx>, _: &'tcx Crate) {
 120         for (lint_name, &lint_span) in &self.declared_lints {
 121             // When using the `declare_lint!` macro, the original `lint_span`'s
 122             // file points to "<rustc macros>".
 123             // `compiletest-rs` thinks that's an error in a different file and
 124             // just ignores it. This causes the test in compile-fail/lint_pass
 125             // not able to capture the error.
 126             // Therefore, we need to climb the macro expansion tree and find the
 127             // actual span that invoked `declare_lint!`:
 128             let lint_span = cx.sess().codemap().source_callsite(lint_span);
 129
 130             if !self.registered_lints.contains(lint_name) {
 131                 span_lint(cx,
 132                           LINT_WITHOUT_LINT_PASS,
 133                           lint_span,
 134                           &format!("the lint `{}` is not added to any `LintPass`", lint_name));
 135             }
 136         }
 137     }
 138 }
 139
 140
 141 fn is_lint_ref_type(ty: &Ty) -> bool {
 142     if let TyRptr(Some(_), MutTy { ty: ref inner, mutbl: MutImmutable }) = ty.node {
 143         if let TyPath(ref path) = inner.node {
 144             return match_path(path, &paths::LINT);
 145         }
 146     }
 147     false
 148 }
 149
 150
 151 fn is_lint_array_type(ty: &Ty) -> bool {
 152     if let TyPath(ref path) = ty.node {
 153         match_path(path, &paths::LINT_ARRAY)
 154     } else {
 155         false
 156     }
 157 }
 158
 159 struct LintCollector<'a, 'tcx: 'a> {
 160     output: &'a mut HashSet<Name>,
 161     cx: &'a LateContext<'a, 'tcx>,
 162 }
 163
 164 impl<'a, 'tcx: 'a> Visitor<'tcx> for LintCollector<'a, 'tcx> {
 165     fn visit_expr(&mut self, expr: &'tcx Expr) {
 166         walk_expr(self, expr);
 167     }
 168
 169     fn visit_path(&mut self, path: &'tcx Path, _: NodeId) {
 170         if path.segments.len() == 1 {
 171             self.output.insert(path.segments[0].name);
 172         }
 173     }
 174     fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> {
 175         NestedVisitorMap::All(&self.cx.tcx.map)
 176     }
 177 }