Use syn in needless_doctest_main lint

Author: llogiq

clippy_lints/Cargo.toml

@@ -32,6 +32,7 @@ url = { version =  "2.1.0", features = ["serde"] } # cargo requires serde feat i
 # see https://github.com/rust-lang/rust/pull/63587#issuecomment-522343864
 if_chain = "1.0.0"
 smallvec = { version = "0.6.5", features = ["union"] }
+syn = { version = "1.0.5", features = ["full"] }
 
 [features]
 debugging = []

clippy_lints/src/doc.rs

@@ -10,6 +10,7 @@ use syntax::ast::Attribute;
 use syntax::source_map::{BytePos, Span};
 use syntax_pos::Pos;
 use url::Url;
+use syn::*;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for the presence of `_`, `::` or camel-case words
@@ -73,7 +74,9 @@ declare_clippy_lint! {
     /// **What it does:** Checks for `fn main() { .. }` in doctests
     ///
     /// **Why is this bad?** The test can be shorter (and likely more readable)
-    /// if the `fn main()` is left implicit.
+    /// if the `fn main()` is left implicit. In some cases, you'll need an
+    /// empty `fn main() {}` in your doctest to avoid rustdoc introducing one,
+    /// which is why the line will ignore empty `main` functions.
     ///
     /// **Known problems:** None.
     ///
@@ -86,6 +89,7 @@ declare_clippy_lint! {
     /// /// ```
     /// /// fn main() {
     /// ///     // this needs not be in an `fn`
+    /// ///     unimplemented!();
     /// /// }
     /// /// ```
     /// fn needless_main() {
@@ -344,9 +348,34 @@ fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize
     safety_header
 }
 
-fn check_code(cx: &LateContext<'_, '_>, text: &str, span: Span) {
-    if text.contains("fn main() {") {
-        span_lint(cx, NEEDLESS_DOCTEST_MAIN, span, "needless `fn main` in doctest");
+// check a syn Item for non-empty `fn main() { .. }`
+fn is_default_main_fn(item: &syn::Item) -> bool {
+    match item {
+        Item::Fn(ItemFn { ref sig, ref block, .. }) => {
+            !block.stmts.is_empty()
+                && sig.ident == "main"
+                && match sig.output {
+                    ReturnType::Default => true,
+                    ReturnType::Type(_, ref ty) => match **ty {
+                        Type::Tuple(TypeTuple { ref elems, .. }) => elems.is_empty(),
+                        _ => false,
+                    },
+                }
+        },
+        _ => false,
+    }
+}
+
+fn check_code(cx: &LateContext<'_, '_>, code: &str, span: Span) {
+    if let Ok(file) = syn::parse_file(code) {
+        if file.items.iter().any(is_default_main_fn) {
+            span_lint(
+                cx,
+                NEEDLESS_DOCTEST_MAIN,
+                span,
+                "needless `fn main() {} in doctest",
+            );
+        }
     }
 }
 

tests/ui/needless_doc_main.rs

@@ -0,0 +1,27 @@
+/// This method does nothing. It's just there for testing.
+///
+/// # Examples:
+///
+/// ```text,ignore
+/// This is not Rust code
+/// Just check that parsing won't crash
+/// R€fridger@tør.
+/// ```
+///
+/// ```
+/// fn main() {
+///     let this_is_linted = 42u8;
+///     assert_eq!(this_is_linted / 2, 21);
+/// }
+/// ```
+///
+/// ```
+/// #[allow(unused)]
+/// const I = 1;
+/// fn main() {
+///     // this main method contains no code and is thus not linted.
+/// }
+/// ```
+fn main() {
+    // nothing to see here, move along.
+}