Auto merge of #6523 - brightly-salty:missing-panic-doc, r=flip1995

Add new lint "missing_panics_doc"

fixes #1974
changelog: Added the "missing_panics_doc" lint which lints when public functions that may panic are missing "# Panics" in their doc comment

CHANGELOG.md

@@ -2079,6 +2079,7 @@ Released 2018-09-13
 [`missing_docs_in_private_items`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_docs_in_private_items
 [`missing_errors_doc`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_errors_doc
 [`missing_inline_in_public_items`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_inline_in_public_items
+[`missing_panics_doc`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_panics_doc
 [`missing_safety_doc`]: https://rust-lang.github.io/rust-clippy/master/index.html#missing_safety_doc
 [`mistyped_literal_suffixes`]: https://rust-lang.github.io/rust-clippy/master/index.html#mistyped_literal_suffixes
 [`mixed_case_hex_literals`]: https://rust-lang.github.io/rust-clippy/master/index.html#mixed_case_hex_literals

clippy_dev/src/bless.rs

@@ -24,6 +24,9 @@ static CLIPPY_BUILD_TIME: SyncLazy<Option<std::time::SystemTime>> = SyncLazy::ne
     fs::metadata(path).ok()?.modified().ok()
 });
 
+/// # Panics
+///
+/// Panics if the path to a test file is broken
 pub fn bless(ignore_timestamp: bool) {
     let test_suite_dirs = [
         clippy_project_root().join("tests").join("ui"),

clippy_dev/src/lib.rs

@@ -236,6 +236,10 @@ pub struct FileChange {
 /// `path` is the relative path to the file on which you want to perform the replacement.
 ///
 /// See `replace_region_in_text` for documentation of the other options.
+///
+/// # Panics
+///
+/// Panics if the path could not read or then written
 pub fn replace_region_in_file<F>(
     path: &Path,
     start: &str,
@@ -283,6 +287,10 @@ where
 ///     .new_lines;
 /// assert_eq!("replace_start\na different\ntext\nreplace_end", result);
 /// ```
+///
+/// # Panics
+///
+/// Panics if start or end is not valid regex
 pub fn replace_region_in_text<F>(text: &str, start: &str, end: &str, replace_start: bool, replacements: F) -> FileChange
 where
     F: FnOnce() -> Vec<String>,
@@ -329,6 +337,11 @@ where
 }
 
 /// Returns the path to the Clippy project directory
+///
+/// # Panics
+///
+/// Panics if the current directory could not be retrieved, there was an error reading any of the
+/// Cargo.toml files or ancestor directory is the clippy root directory
 #[must_use]
 pub fn clippy_project_root() -> PathBuf {
     let current_dir = std::env::current_dir().unwrap();

clippy_dev/src/ra_setup.rs

@@ -8,6 +8,9 @@ use std::path::{Path, PathBuf};
 // This allows rust analyzer to analyze rustc internals and show proper information inside clippy
 // code. See https://github.com/rust-analyzer/rust-analyzer/issues/3517 and https://github.com/rust-lang/rust-clippy/issues/5514 for details
 
+/// # Panics
+///
+/// Panics if `rustc_path` does not lead to a rustc repo or the files could not be read
 pub fn run(rustc_path: Option<&str>) {
     // we can unwrap here because the arg is required by clap
     let rustc_path = PathBuf::from(rustc_path.unwrap());

clippy_dev/src/serve.rs

@@ -4,6 +4,9 @@ use std::process::Command;
 use std::thread;
 use std::time::{Duration, SystemTime};
 
+/// # Panics
+///
+/// Panics if the python commands could not be spawned
 pub fn run(port: u16, lint: Option<&str>) -> ! {
     let mut url = Some(match lint {
         None => format!("http://localhost:{}", port),

clippy_lints/src/doc.rs

@@ -1,4 +1,7 @@
-use crate::utils::{implements_trait, is_entrypoint_fn, is_type_diagnostic_item, return_ty, span_lint};
+use crate::utils::{
+    implements_trait, is_entrypoint_fn, is_type_diagnostic_item, match_panic_def_id, method_chain_args, return_ty,
+    span_lint, span_lint_and_note,
+};
 use if_chain::if_chain;
 use itertools::Itertools;
 use rustc_ast::ast::{Async, AttrKind, Attribute, FnRetTy, ItemKind};
@@ -8,7 +11,10 @@ use rustc_data_structures::sync::Lrc;
 use rustc_errors::emitter::EmitterWriter;
 use rustc_errors::Handler;
 use rustc_hir as hir;
+use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
+use rustc_hir::{Expr, ExprKind, QPath};
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::hir::map::Map;
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty;
 use rustc_parse::maybe_new_parser_from_source_str;
@@ -122,6 +128,37 @@ declare_clippy_lint! {
     "`pub fn` returns `Result` without `# Errors` in doc comment"
 }
 
+declare_clippy_lint! {
+    /// **What it does:** Checks the doc comments of publicly visible functions that
+    /// may panic and warns if there is no `# Panics` section.
+    ///
+    /// **Why is this bad?** Documenting the scenarios in which panicking occurs
+    /// can help callers who do not want to panic to avoid those situations.
+    ///
+    /// **Known problems:** None.
+    ///
+    /// **Examples:**
+    ///
+    /// Since the following function may panic it has a `# Panics` section in
+    /// its doc comment:
+    ///
+    /// ```rust
+    /// /// # Panics
+    /// ///
+    /// /// Will panic if y is 0
+    /// pub fn divide_by(x: i32, y: i32) -> i32 {
+    ///     if y == 0 {
+    ///         panic!("Cannot divide by 0")
+    ///     } else {
+    ///         x / y
+    ///     }
+    /// }
+    /// ```
+    pub MISSING_PANICS_DOC,
+    pedantic,
+    "`pub fn` may panic without `# Panics` in doc comment"
+}
+
 declare_clippy_lint! {
     /// **What it does:** Checks for `fn main() { .. }` in doctests
     ///
@@ -166,7 +203,9 @@ impl DocMarkdown {
     }
 }
 
-impl_lint_pass!(DocMarkdown => [DOC_MARKDOWN, MISSING_SAFETY_DOC, MISSING_ERRORS_DOC, NEEDLESS_DOCTEST_MAIN]);
+impl_lint_pass!(DocMarkdown =>
+    [DOC_MARKDOWN, MISSING_SAFETY_DOC, MISSING_ERRORS_DOC, MISSING_PANICS_DOC, NEEDLESS_DOCTEST_MAIN]
+);
 
 impl<'tcx> LateLintPass<'tcx> for DocMarkdown {
     fn check_crate(&mut self, cx: &LateContext<'tcx>, krate: &'tcx hir::Crate<'_>) {
@@ -180,7 +219,15 @@ impl<'tcx> LateLintPass<'tcx> for DocMarkdown {
                 if !(is_entrypoint_fn(cx, cx.tcx.hir().local_def_id(item.hir_id).to_def_id())
                     || in_external_macro(cx.tcx.sess, item.span))
                 {
-                    lint_for_missing_headers(cx, item.hir_id, item.span, sig, headers, Some(body_id));
+                    let body = cx.tcx.hir().body(body_id);
+                    let impl_item_def_id = cx.tcx.hir().local_def_id(item.hir_id);
+                    let mut fpu = FindPanicUnwrap {
+                        cx,
+                        typeck_results: cx.tcx.typeck(impl_item_def_id),
+                        panic_span: None,
+                    };
+                    fpu.visit_expr(&body.value);
+                    lint_for_missing_headers(cx, item.hir_id, item.span, sig, headers, Some(body_id), fpu.panic_span);
                 }
             },
             hir::ItemKind::Impl(ref impl_) => {
@@ -200,7 +247,7 @@ impl<'tcx> LateLintPass<'tcx> for DocMarkdown {
         let headers = check_attrs(cx, &self.valid_idents, &item.attrs);
         if let hir::TraitItemKind::Fn(ref sig, ..) = item.kind {
             if !in_external_macro(cx.tcx.sess, item.span) {
-                lint_for_missing_headers(cx, item.hir_id, item.span, sig, headers, None);
+                lint_for_missing_headers(cx, item.hir_id, item.span, sig, headers, None, None);
             }
         }
     }
@@ -211,7 +258,15 @@ impl<'tcx> LateLintPass<'tcx> for DocMarkdown {
             return;
         }
         if let hir::ImplItemKind::Fn(ref sig, body_id) = item.kind {
-            lint_for_missing_headers(cx, item.hir_id, item.span, sig, headers, Some(body_id));
+            let body = cx.tcx.hir().body(body_id);
+            let impl_item_def_id = cx.tcx.hir().local_def_id(item.hir_id);
+            let mut fpu = FindPanicUnwrap {
+                cx,
+                typeck_results: cx.tcx.typeck(impl_item_def_id),
+                panic_span: None,
+            };
+            fpu.visit_expr(&body.value);
+            lint_for_missing_headers(cx, item.hir_id, item.span, sig, headers, Some(body_id), fpu.panic_span);
         }
     }
 }
@@ -223,6 +278,7 @@ fn lint_for_missing_headers<'tcx>(
     sig: &hir::FnSig<'_>,
     headers: DocHeaders,
     body_id: Option<hir::BodyId>,
+    panic_span: Option<Span>,
 ) {
     if !cx.access_levels.is_exported(hir_id) {
         return; // Private functions do not require doc comments
@@ -235,6 +291,16 @@ fn lint_for_missing_headers<'tcx>(
             "unsafe function's docs miss `# Safety` section",
         );
     }
+    if !headers.panics && panic_span.is_some() {
+        span_lint_and_note(
+            cx,
+            MISSING_PANICS_DOC,
+            span,
+            "docs for function which may panic missing `# Panics` section",
+            panic_span,
+            "first possible panic found here",
+        );
+    }
     if !headers.errors {
         if is_type_diagnostic_item(cx, return_ty(cx, hir_id), sym::result_type) {
             span_lint(
@@ -321,6 +387,7 @@ pub fn strip_doc_comment_decoration(doc: &str, comment_kind: CommentKind, span:
 struct DocHeaders {
     safety: bool,
     errors: bool,
+    panics: bool,
 }
 
 fn check_attrs<'a>(cx: &LateContext<'_>, valid_idents: &FxHashSet<String>, attrs: &'a [Attribute]) -> DocHeaders {
@@ -338,6 +405,7 @@ fn check_attrs<'a>(cx: &LateContext<'_>, valid_idents: &FxHashSet<String>, attrs
             return DocHeaders {
                 safety: true,
                 errors: true,
+                panics: true,
             };
         }
     }
@@ -353,6 +421,7 @@ fn check_attrs<'a>(cx: &LateContext<'_>, valid_idents: &FxHashSet<String>, attrs
         return DocHeaders {
             safety: false,
             errors: false,
+            panics: false,
         };
     }
 
@@ -394,6 +463,7 @@ fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize
     let mut headers = DocHeaders {
         safety: false,
         errors: false,
+        panics: false,
     };
     let mut in_code = false;
     let mut in_link = None;
@@ -439,6 +509,7 @@ fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize
                 }
                 headers.safety |= in_heading && text.trim() == "Safety";
                 headers.errors |= in_heading && text.trim() == "Errors";
+                headers.panics |= in_heading && text.trim() == "Panics";
                 let index = match spans.binary_search_by(|c| c.0.cmp(&range.start)) {
                     Ok(o) => o,
                     Err(e) => e - 1,
@@ -607,3 +678,47 @@ fn check_word(cx: &LateContext<'_>, word: &str, span: Span) {
         );
     }
 }
+
+struct FindPanicUnwrap<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+    panic_span: Option<Span>,
+    typeck_results: &'tcx ty::TypeckResults<'tcx>,
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for FindPanicUnwrap<'a, 'tcx> {
+    type Map = Map<'tcx>;
+
+    fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
+        if self.panic_span.is_some() {
+            return;
+        }
+
+        // check for `begin_panic`
+        if_chain! {
+            if let ExprKind::Call(ref func_expr, _) = expr.kind;
+            if let ExprKind::Path(QPath::Resolved(_, ref path)) = func_expr.kind;
+            if let Some(path_def_id) = path.res.opt_def_id();
+            if match_panic_def_id(self.cx, path_def_id);
+            then {
+                self.panic_span = Some(expr.span);
+            }
+        }
+
+        // check for `unwrap`
+        if let Some(arglists) = method_chain_args(expr, &["unwrap"]) {
+            let reciever_ty = self.typeck_results.expr_ty(&arglists[0][0]).peel_refs();
+            if is_type_diagnostic_item(self.cx, reciever_ty, sym::option_type)
+                || is_type_diagnostic_item(self.cx, reciever_ty, sym::result_type)
+            {
+                self.panic_span = Some(expr.span);
+            }
+        }
+
+        // and check sub-expressions
+        intravisit::walk_expr(self, expr);
+    }
+
+    fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
+        NestedVisitorMap::OnlyBodies(self.cx.tcx.hir())
+    }
+}

clippy_lints/src/lib.rs

@@ -592,6 +592,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         &disallowed_method::DISALLOWED_METHOD,
         &doc::DOC_MARKDOWN,
         &doc::MISSING_ERRORS_DOC,
+        &doc::MISSING_PANICS_DOC,
         &doc::MISSING_SAFETY_DOC,
         &doc::NEEDLESS_DOCTEST_MAIN,
         &double_comparison::DOUBLE_COMPARISONS,
@@ -1317,6 +1318,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
         LintId::of(&derive::UNSAFE_DERIVE_DESERIALIZE),
         LintId::of(&doc::DOC_MARKDOWN),
         LintId::of(&doc::MISSING_ERRORS_DOC),
+        LintId::of(&doc::MISSING_PANICS_DOC),
         LintId::of(&empty_enum::EMPTY_ENUM),
         LintId::of(&enum_variants::MODULE_NAME_REPETITIONS),
         LintId::of(&enum_variants::PUB_ENUM_VARIANT_NAMES),

clippy_lints/src/utils/diagnostics.rs

@@ -110,7 +110,7 @@ pub fn span_lint_and_help<'a, T: LintContext>(
 pub fn span_lint_and_note<'a, T: LintContext>(
     cx: &'a T,
     lint: &'static Lint,
-    span: Span,
+    span: impl Into<MultiSpan>,
     msg: &str,
     note_span: Option<Span>,
     note: &str,

mini-macro/src/lib.rs

@@ -7,6 +7,9 @@ extern crate proc_macro;
 use proc_macro::{quote, TokenStream};
 
 #[proc_macro_derive(ClippyMiniMacroTest)]
+/// # Panics
+///
+/// Panics if the macro derivation fails
 pub fn mini_macro(_: TokenStream) -> TokenStream {
     quote!(
         #[allow(unused)]