Merge branch 'macro-use' into HEAD

[rust.git] / clippy_lints / src / missing_doc.rs

diff --git a/clippy_lints/src/missing_doc.rs b/clippy_lints/src/missing_doc.rs
index 21e19a3af849185e63fd5efb75362e8ee7bba5ff..e921c541be203f59d27197d5d4ba0c5241d9753b 100644 (file)
--- a/clippy_lints/src/missing_doc.rs
+++ b/clippy_lints/src/missing_doc.rs
@@ -15,24 +15,17 @@
 // *rustc*'s
 // [`missing_doc`].
 //
-// [`missing_doc`]:
-// https://github.
-// com/rust-lang/rust/blob/d6d05904697d89099b55da3331155392f1db9c00/src/librustc_lint/builtin.
-// 
-//
-//
-//
-//
-// rs#L246
+// [`missing_doc`]: https://github.com/rust-lang/rust/blob/d6d05904697d89099b55da3331155392f1db9c00/src/librustc_lint/builtin.rs#L246
 //
 
 use rustc::hir;
 use rustc::lint::*;
+use rustc::{declare_lint, lint_array};
 use rustc::ty;
 use syntax::ast;
 use syntax::attr;
 use syntax::codemap::Span;
-use utils::in_macro;
+use crate::utils::in_macro;
 
 /// **What it does:** Warns if there is missing doc for any documentable item
 /// (public or private).
@@ -43,9 +36,9 @@
 /// This lint fixes that.
 ///
 /// **Known problems:** None.
-declare_lint! {
+declare_clippy_lint! {
     pub MISSING_DOCS_IN_PRIVATE_ITEMS,
-    Allow,
+    restriction,
     "detects missing documentation for public and private members"
 }
 
@@ -63,13 +56,15 @@ fn default() -> Self {
 
 impl MissingDoc {
     pub fn new() -> Self {
-        Self { doc_hidden_stack: vec![false] }
+        Self {
+            doc_hidden_stack: vec![false],
+        }
     }
 
     fn doc_hidden(&self) -> bool {
-        *self.doc_hidden_stack.last().expect(
-            "empty doc_hidden_stack",
-        )
+        *self.doc_hidden_stack
+            .last()
+            .expect("empty doc_hidden_stack")
     }
 
     fn check_missing_docs_attrs(&self, cx: &LateContext, attrs: &[ast::Attribute], sp: Span, desc: &'static str) {
@@ -88,9 +83,9 @@ fn check_missing_docs_attrs(&self, cx: &LateContext, attrs: &[ast::Attribute], s
             return;
         }
 
-        let has_doc = attrs.iter().any(|a| {
-            a.is_value_str() && a.name().map_or(false, |n| n == "doc")
-        });
+        let has_doc = attrs
+            .iter()
+            .any(|a| a.is_value_str() && a.name() == "doc");
         if !has_doc {
             cx.span_lint(
                 MISSING_DOCS_IN_PRIVATE_ITEMS,
@@ -109,14 +104,12 @@ fn get_lints(&self) -> LintArray {
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingDoc {
     fn enter_lint_attrs(&mut self, _: &LateContext<'a, 'tcx>, attrs: &'tcx [ast::Attribute]) {
-        let doc_hidden = self.doc_hidden() ||
-            attrs.iter().any(|attr| {
-                attr.check_name("doc") &&
-                    match attr.meta_item_list() {
-                        None => false,
-                        Some(l) => attr::list_contains_name(&l[..], "hidden"),
-                    }
-            });
+        let doc_hidden = self.doc_hidden() || attrs.iter().any(|attr| {
+            attr.check_name("doc") && match attr.meta_item_list() {
+                None => false,
+                Some(l) => attr::list_contains_name(&l[..], "hidden"),
+            }
+        });
         self.doc_hidden_stack.push(doc_hidden);
     }
 
@@ -130,21 +123,32 @@ fn check_crate(&mut self, cx: &LateContext<'a, 'tcx>, krate: &'tcx hir::Crate) {
 
     fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, it: &'tcx hir::Item) {
         let desc = match it.node {
-            hir::ItemConst(..) => "a constant",
-            hir::ItemEnum(..) => "an enum",
-            hir::ItemFn(..) => "a function",
-            hir::ItemMod(..) => "a module",
-            hir::ItemStatic(..) => "a static",
-            hir::ItemStruct(..) => "a struct",
-            hir::ItemTrait(..) => "a trait",
-            hir::ItemGlobalAsm(..) => "an assembly blob",
-            hir::ItemTy(..) => "a type alias",
-            hir::ItemUnion(..) => "a union",
-            hir::ItemDefaultImpl(..) |
-            hir::ItemExternCrate(..) |
-            hir::ItemForeignMod(..) |
-            hir::ItemImpl(..) |
-            hir::ItemUse(..) => return,
+            hir::ItemKind::Const(..) => "a constant",
+            hir::ItemKind::Enum(..) => "an enum",
+            hir::ItemKind::Fn(..) => {
+                // ignore main()
+                if it.name == "main" {
+                    let def_id = cx.tcx.hir.local_def_id(it.id);
+                    let def_key = cx.tcx.hir.def_key(def_id);
+                    if def_key.parent == Some(hir::def_id::CRATE_DEF_INDEX) {
+                        return;
+                    }
+                }
+                "a function"
+            },
+            hir::ItemKind::Mod(..) => "a module",
+            hir::ItemKind::Static(..) => "a static",
+            hir::ItemKind::Struct(..) => "a struct",
+            hir::ItemKind::Trait(..) => "a trait",
+            hir::ItemKind::TraitAlias(..) => "a trait alias",
+            hir::ItemKind::GlobalAsm(..) => "an assembly blob",
+            hir::ItemKind::Ty(..) => "a type alias",
+            hir::ItemKind::Union(..) => "a union",
+            hir::ItemKind::Existential(..) => "an existential type",
+            hir::ItemKind::ExternCrate(..) |
+            hir::ItemKind::ForeignMod(..) |
+            hir::ItemKind::Impl(..) |
+            hir::ItemKind::Use(..) => return,
         };
 
         self.check_missing_docs_attrs(cx, &it.attrs, it.span, desc);
@@ -165,10 +169,8 @@ fn check_impl_item(&mut self, cx: &LateContext<'a, 'tcx>, impl_item: &'tcx hir::
         let def_id = cx.tcx.hir.local_def_id(impl_item.id);
         match cx.tcx.associated_item(def_id).container {
             ty::TraitContainer(_) => return,
-            ty::ImplContainer(cid) => {
-                if cx.tcx.impl_trait_ref(cid).is_some() {
-                    return;
-                }
+            ty::ImplContainer(cid) => if cx.tcx.impl_trait_ref(cid).is_some() {
+                return;
             },
         }
 
@@ -176,6 +178,7 @@ fn check_impl_item(&mut self, cx: &LateContext<'a, 'tcx>, impl_item: &'tcx hir::
             hir::ImplItemKind::Const(..) => "an associated constant",
             hir::ImplItemKind::Method(..) => "a method",
             hir::ImplItemKind::Type(_) => "an associated type",
+            hir::ImplItemKind::Existential(_) => "an existential type",
         };
         self.check_missing_docs_attrs(cx, &impl_item.attrs, impl_item.span, desc);
     }