X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=clippy_lints%2Fsrc%2Futils%2Finternal_lints.rs;h=226817c8e51f0f140835f9c3f2fb09926b303cd6;hb=b109e1033476390f95c728d674909ef90f0ff0ca;hp=964774562e2a204148df31214cb3a233e516480f;hpb=5f09020e90b485481fde984cc2e31c0112ebf1f1;p=rust.git diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs index 964774562e2..226817c8e51 100644 --- a/clippy_lints/src/utils/internal_lints.rs +++ b/clippy_lints/src/utils/internal_lints.rs @@ -1,11 +1,13 @@ use rustc::lint::*; +use rustc::{declare_lint, lint_array}; use rustc::hir::*; -use rustc::hir::intravisit::{Visitor, walk_expr}; -use utils::{paths, match_path, span_lint}; -use syntax::parse::token::InternedString; -use syntax::ast::{Name, NodeId, ItemKind, Crate as AstCrate}; +use rustc::hir; +use rustc::hir::intravisit::{walk_expr, NestedVisitorMap, Visitor}; +use crate::utils::{match_qpath, paths, span_lint}; +use syntax::symbol::LocalInternedString; +use syntax::ast::{Crate as AstCrate, ItemKind, Name}; use syntax::codemap::Span; -use std::collections::{HashSet, HashMap}; +use std::collections::{HashMap, HashSet}; /// **What it does:** Checks for various things we like to keep tidy in clippy. @@ -15,9 +17,9 @@ /// **Known problems:** None. /// /// **Example:** Wrong ordering of the util::paths constants. -declare_lint! { +declare_clippy_lint! { pub CLIPPY_LINTS_INTERNAL, - Allow, + internal, "various things that will negatively affect your clippy experience" } @@ -45,9 +47,9 @@ /// } /// } /// ``` -declare_lint! { +declare_clippy_lint! { pub LINT_WITHOUT_LINT_PASS, - Warn, + internal, "declaring a lint without associating it in a LintPass" } @@ -62,20 +64,31 @@ fn get_lints(&self) -> LintArray { } impl EarlyLintPass for Clippy { - fn check_crate(&mut self, cx: &EarlyContext, krate: &AstCrate) { - if let Some(utils) = krate.module.items.iter().find(|item| item.ident.name.as_str() == "utils") { + fn check_crate(&mut self, cx: &EarlyContext<'_>, krate: &AstCrate) { + if let Some(utils) = krate + .module + .items + .iter() + .find(|item| item.ident.name == "utils") + { if let ItemKind::Mod(ref utils_mod) = utils.node { - if let Some(paths) = utils_mod.items.iter().find(|item| item.ident.name.as_str() == "paths") { + if let Some(paths) = utils_mod + .items + .iter() + .find(|item| item.ident.name == "paths") + { if let ItemKind::Mod(ref paths_mod) = paths.node { - let mut last_name: Option = None; + let mut last_name: Option = None; for item in &paths_mod.items { - let name = item.ident.name.as_str(); + let name = item.ident.as_str(); if let Some(ref last_name) = last_name { if **last_name > *name { - span_lint(cx, - CLIPPY_LINTS_INTERNAL, - item.span, - "this constant should be before the previous constant due to lexical ordering", + span_lint( + cx, + CLIPPY_LINTS_INTERNAL, + item.span, + "this constant should be before the previous constant due to lexical \ + ordering", ); } } @@ -104,19 +117,24 @@ fn get_lints(&self) -> LintArray { } -impl LateLintPass for LintWithoutLintPass { - fn check_item(&mut self, _: &LateContext, item: &Item) { - if let ItemStatic(ref ty, MutImmutable, ref expr) = item.node { +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, MutImmutable, body_id) = item.node { if is_lint_ref_type(ty) { self.declared_lints.insert(item.name, item.span); - } else if is_lint_array_type(ty) && item.vis == Visibility::Inherited && item.name.as_str() == "ARRAY" { - let mut collector = LintCollector { output: &mut self.registered_lints }; - collector.visit_expr(expr); + } else if is_lint_array_type(ty) && item.name == "ARRAY" { + if let VisibilityKind::Inherited = item.vis.node { + let mut collector = LintCollector { + output: &mut self.registered_lints, + cx, + }; + collector.visit_expr(&cx.tcx.hir.body(body_id).value); + } } } } - fn check_crate_post(&mut self, cx: &LateContext, _: &Crate) { + fn check_crate_post(&mut self, cx: &LateContext<'a, 'tcx>, _: &'tcx Crate) { for (lint_name, &lint_span) in &self.declared_lints { // When using the `declare_lint!` macro, the original `lint_span`'s // file points to "". @@ -125,13 +143,20 @@ fn check_crate_post(&mut self, cx: &LateContext, _: &Crate) { // not able to capture the error. // Therefore, we need to climb the macro expansion tree and find the // actual span that invoked `declare_lint!`: - let lint_span = cx.sess().codemap().source_callsite(lint_span); + let lint_span = lint_span + .ctxt() + .outer() + .expn_info() + .map(|ei| ei.call_site) + .expect("unable to get call_site"); if !self.registered_lints.contains(lint_name) { - span_lint(cx, - LINT_WITHOUT_LINT_PASS, - lint_span, - &format!("the lint `{}` is not added to any `LintPass`", lint_name)); + span_lint( + cx, + LINT_WITHOUT_LINT_PASS, + lint_span, + &format!("the lint `{}` is not added to any `LintPass`", lint_name), + ); } } } @@ -139,9 +164,16 @@ fn check_crate_post(&mut self, cx: &LateContext, _: &Crate) { fn is_lint_ref_type(ty: &Ty) -> bool { - if let TyRptr(Some(_), MutTy { ty: ref inner, mutbl: MutImmutable }) = ty.node { - if let TyPath(None, ref path) = inner.node { - return match_path(path, &paths::LINT); + if let TyKind::Rptr( + _, + MutTy { + ty: ref inner, + mutbl: MutImmutable, + }, + ) = ty.node + { + if let TyKind::Path(ref path) = inner.node { + return match_qpath(path, &paths::LINT); } } false @@ -149,25 +181,29 @@ fn is_lint_ref_type(ty: &Ty) -> bool { fn is_lint_array_type(ty: &Ty) -> bool { - if let TyPath(None, ref path) = ty.node { - match_path(path, &paths::LINT_ARRAY) + if let TyKind::Path(ref path) = ty.node { + match_qpath(path, &paths::LINT_ARRAY) } else { false } } -struct LintCollector<'a> { +struct LintCollector<'a, 'tcx: 'a> { output: &'a mut HashSet, + cx: &'a LateContext<'a, 'tcx>, } -impl<'v, 'a: 'v> Visitor<'v> for LintCollector<'a> { - fn visit_expr(&mut self, expr: &'v Expr) { +impl<'a, 'tcx: 'a> Visitor<'tcx> for LintCollector<'a, 'tcx> { + fn visit_expr(&mut self, expr: &'tcx Expr) { walk_expr(self, expr); } - fn visit_path(&mut self, path: &'v Path, _: NodeId) { + fn visit_path(&mut self, path: &'tcx Path, _: HirId) { if path.segments.len() == 1 { - self.output.insert(path.segments[0].name); + self.output.insert(path.segments[0].ident.name); } } + fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'tcx> { + NestedVisitorMap::All(&self.cx.tcx.hir) + } }