Reuse existing markdown parser in doc_link_code

Author: Alexendoo

clippy_lints/src/doc/doc_link_code.rs

@@ -0,0 +1,77 @@
+use std::ops::Range;
+
+use clippy_utils::diagnostics::span_lint_and_then;
+use rustc_errors::Applicability;
+use rustc_lint::LateContext;
+use rustc_resolve::rustdoc::pulldown_cmark::{Event, Tag, TagEnd};
+
+use crate::doc::Fragments;
+
+use super::DOC_LINK_CODE;
+
+#[derive(Default)]
+pub(super) struct LinkCode {
+    start: Option<usize>,
+    end: Option<usize>,
+    includes_link: bool,
+}
+
+impl LinkCode {
+    pub fn check(
+        &mut self,
+        cx: &LateContext<'_>,
+        event: &Event<'_>,
+        range: Range<usize>,
+        in_link: bool,
+        doc: &str,
+        fragments: Fragments<'_>,
+    ) {
+        match event {
+            Event::Start(Tag::Link { .. }) => {
+                if self.start.is_some() {
+                    self.end = Some(range.end);
+                } else {
+                    self.start = Some(range.start);
+                }
+                self.includes_link = true;
+            },
+            Event::End(TagEnd::Link) => {},
+            _ if in_link => {
+                if !matches!(event, Event::Code(_)) {
+                    self.reset();
+                }
+            },
+            Event::Code(_) => {
+                if self.start.is_some() {
+                    self.end = Some(range.end);
+                } else {
+                    self.start = Some(range.start);
+                }
+            },
+            _ => {
+                if let Some(start) = self.start
+                    && let Some(end) = self.end
+                    && self.includes_link
+                    && let Some(span) = fragments.span(cx, start..end)
+                {
+                    span_lint_and_then(cx, DOC_LINK_CODE, span, "code link adjacent to code text", |diag| {
+                        let sugg = format!("<code>{}</code>", doc[start..end].replace('`', ""));
+                        diag.span_suggestion_verbose(
+                            span,
+                            "wrap the entire group in `<code>` tags",
+                            sugg,
+                            Applicability::MaybeIncorrect,
+                        );
+                        diag.help("separate code snippets will be shown with a gap");
+                    });
+                }
+
+                self.reset();
+            },
+        }
+    }
+
+    fn reset(&mut self) {
+        *self = LinkCode::default();
+    }
+}

clippy_lints/src/doc/mod.rs

@@ -25,8 +25,12 @@ use rustc_span::Span;
 use std::ops::Range;
 use url::Url;
 
+use doc_link_code::LinkCode;
+use doc_paragraphs_missing_punctuation::MissingPunctuation;
+
 mod broken_link;
 mod doc_comment_double_space_linebreaks;
+mod doc_link_code;
 mod doc_paragraphs_missing_punctuation;
 mod doc_suspicious_footnotes;
 mod include_in_doc_without_cfg;
@@ -847,14 +851,6 @@ struct DocHeaders {
 /// back in the various late lint pass methods if they need the final doc headers, like "Safety" or
 /// "Panics" sections.
 fn check_attrs(cx: &LateContext<'_>, valid_idents: &FxHashSet<String>, attrs: &[Attribute]) -> Option<DocHeaders> {
-    // We don't want the parser to choke on intra doc links. Since we don't
-    // actually care about rendering them, just pretend that all broken links
-    // point to a fake address.
-    #[expect(clippy::unnecessary_wraps)] // we're following a type signature
-    fn fake_broken_link_callback<'a>(_: BrokenLink<'_>) -> Option<(CowStr<'a>, CowStr<'a>)> {
-        Some(("fake".into(), "fake".into()))
-    }
-
     if suspicious_doc_comments::check(cx, attrs) || is_doc_hidden(attrs) {
         return None;
     }
@@ -889,32 +885,16 @@ fn check_attrs(cx: &LateContext<'_>, valid_idents: &FxHashSet<String>, attrs: &[
         return Some(DocHeaders::default());
     }
 
-    check_for_code_clusters(
-        cx,
-        pulldown_cmark::Parser::new_with_broken_link_callback(
-            &doc,
-            main_body_opts() - Options::ENABLE_SMART_PUNCTUATION,
-            Some(&mut fake_broken_link_callback),
-        )
-        .into_offset_iter(),
-        &doc,
-        Fragments {
-            doc: &doc,
-            fragments: &fragments,
-        },
-    );
-
     // NOTE: check_doc uses it own cb function,
     // to avoid causing duplicated diagnostics for the broken link checker.
-    let mut full_fake_broken_link_callback = |bl: BrokenLink<'_>| -> Option<(CowStr<'_>, CowStr<'_>)> {
+    let mut broken_link_callback = |bl: BrokenLink<'_>| -> Option<(CowStr<'_>, CowStr<'_>)> {
         broken_link::check(cx, &bl, &doc, &fragments);
         Some(("fake".into(), "fake".into()))
     };
 
     // disable smart punctuation to pick up ['link'] more easily
     let opts = main_body_opts() - Options::ENABLE_SMART_PUNCTUATION;
-    let parser =
-        pulldown_cmark::Parser::new_with_broken_link_callback(&doc, opts, Some(&mut full_fake_broken_link_callback));
+    let parser = pulldown_cmark::Parser::new_with_broken_link_callback(&doc, opts, Some(&mut broken_link_callback));
 
     Some(check_doc(
         cx,
@@ -934,65 +914,6 @@ enum Container {
     List(usize),
 }
 
-/// Scan the documentation for code links that are back-to-back with code spans.
-///
-/// This is done separately from the rest of the docs, because that makes it easier to produce
-/// the correct messages.
-fn check_for_code_clusters<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize>)>>(
-    cx: &LateContext<'_>,
-    events: Events,
-    doc: &str,
-    fragments: Fragments<'_>,
-) {
-    let mut events = events.peekable();
-    let mut code_starts_at = None;
-    let mut code_ends_at = None;
-    let mut code_includes_link = false;
-    while let Some((event, range)) = events.next() {
-        match event {
-            Start(Link { .. }) if matches!(events.peek(), Some((Code(_), _range))) => {
-                if code_starts_at.is_some() {
-                    code_ends_at = Some(range.end);
-                } else {
-                    code_starts_at = Some(range.start);
-                }
-                code_includes_link = true;
-                // skip the nested "code", because we're already handling it here
-                let _ = events.next();
-            },
-            Code(_) => {
-                if code_starts_at.is_some() {
-                    code_ends_at = Some(range.end);
-                } else {
-                    code_starts_at = Some(range.start);
-                }
-            },
-            End(TagEnd::Link) => {},
-            _ => {
-                if let Some(start) = code_starts_at
-                    && let Some(end) = code_ends_at
-                    && code_includes_link
-                    && let Some(span) = fragments.span(cx, start..end)
-                {
-                    span_lint_and_then(cx, DOC_LINK_CODE, span, "code link adjacent to code text", |diag| {
-                        let sugg = format!("<code>{}</code>", doc[start..end].replace('`', ""));
-                        diag.span_suggestion_verbose(
-                            span,
-                            "wrap the entire group in `<code>` tags",
-                            sugg,
-                            Applicability::MaybeIncorrect,
-                        );
-                        diag.help("separate code snippets will be shown with a gap");
-                    });
-                }
-                code_includes_link = false;
-                code_starts_at = None;
-                code_ends_at = None;
-            },
-        }
-    }
-}
-
 #[derive(Clone, Copy)]
 #[expect(clippy::struct_excessive_bools)]
 struct CodeTags {
@@ -1070,7 +991,8 @@ fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize
     fragments: Fragments<'_>,
     attrs: &[Attribute],
 ) -> DocHeaders {
-    let mut missing_punctuation = doc_paragraphs_missing_punctuation::MissingPunctuation::default();
+    let mut missing_punctuation = MissingPunctuation::default();
+    let mut link_code = LinkCode::default();
 
     // true if a safety header was found
     let mut headers = DocHeaders::default();
@@ -1092,6 +1014,7 @@ fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize
 
     while let Some((event, range)) = events.next() {
         missing_punctuation.check(cx, &event, range.clone(), doc, fragments);
+        link_code.check(cx, &event, range.clone(), in_link.is_some(), doc, fragments);
 
         match event {
             Html(tag) | InlineHtml(tag) => {