Reuse existing markdown parser in doc_link_code

Author: Alexendoo

clippy_lints/src/doc/doc_link_code.rs

@@ -0,0 +1,90 @@
+use std::mem;
+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;
+
+struct PendingLink {
+    range: Range<usize>,
+    seen_code: bool,
+}
+
+#[derive(Default)]
+pub(super) struct LinkCode {
+    start: Option<usize>,
+    end: Option<usize>,
+    includes_link: bool,
+    pending_link: Option<PendingLink>,
+}
+
+impl LinkCode {
+    pub fn check(
+        &mut self,
+        cx: &LateContext<'_>,
+        event: &Event<'_>,
+        range: Range<usize>,
+        doc: &str,
+        fragments: Fragments<'_>,
+    ) {
+        match event {
+            Event::Start(Tag::Link { .. }) => {
+                self.pending_link = Some(PendingLink {
+                    range,
+                    seen_code: false,
+                });
+            },
+            Event::End(TagEnd::Link) => {
+                if let Some(PendingLink { range, seen_code: true }) = self.pending_link.take() {
+                    if self.start.is_some() {
+                        self.end = Some(range.end);
+                    } else {
+                        self.start = Some(range.start);
+                    }
+                    self.includes_link = true;
+                }
+            },
+            _ if let Some(pending_link) = &mut self.pending_link => {
+                if matches!(event, Event::Code(_)) && !pending_link.seen_code {
+                    pending_link.seen_code = true;
+                } else {
+                    self.consume(cx, fragments, doc);
+                }
+            },
+            Event::Code(_) => {
+                if self.start.is_some() {
+                    self.end = Some(range.end);
+                } else {
+                    self.start = Some(range.start);
+                }
+            },
+            _ => self.consume(cx, fragments, doc),
+        }
+    }
+
+    fn consume(&mut self, cx: &LateContext<'_>, fragments: Fragments<'_>, doc: &str) {
+        if let LinkCode {
+            start: Some(start),
+            end: Some(end),
+            includes_link: true,
+            pending_link: _,
+        } = mem::take(self)
+            && let Some(span) = fragments.span(cx, start..end)
+        {
+            span_lint_and_then(cx, DOC_LINK_CODE, span, "code link adjacent to code text", |diag| {
+                diag.span_suggestion_verbose(
+                    span,
+                    "wrap the entire group in `<code>` tags",
+                    format!("<code>{}</code>", doc[start..end].replace('`', "")),
+                    Applicability::MaybeIncorrect,
+                );
+                diag.help("separate code snippets will be shown with a gap");
+            });
+        }
+    }
+}

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(), doc, fragments);
 
         match event {
             Html(tag) | InlineHtml(tag) => {

tests/ui/doc/link_adjacent.fixed

@@ -9,6 +9,8 @@
 //! Neither is this: [`first`](x) `second`
 //!
 //! Neither is this: [first](x)`second`
+//! 
+//! Neither is this: `first`[](x)
 //!
 //! This is: <code>[first](x)second</code>
 //~^ ERROR: adjacent
@@ -24,6 +26,9 @@
 //!
 //! So is this <code>[first](x)second[third](x)</code>
 //~^ ERROR: adjacent
+//!
+//! <code>first[second](x)</code>[third](x)
+//~^ ERROR: adjacent
 
 /// Test case for code links that are adjacent to code text.
 ///
@@ -35,6 +40,8 @@
 ///
 /// Neither is this: [first](x)`second` arst
 ///
+/// Neither is this: `first`[](x) arst
+/// 
 /// This is: <code>[first](x)second</code> arst
 //~^ ERROR: adjacent
 ///
@@ -49,4 +56,7 @@
 ///
 /// So is this <code>[first](x)second[third](x)</code> arst
 //~^ ERROR: adjacent
+///
+/// <code>first[second](x)</code>[third](x) arst
+//~^ ERROR: adjacent
 pub struct WithTrailing;

tests/ui/doc/link_adjacent.rs

@@ -10,6 +10,10 @@
 //!
 //! Neither is this: [first](x)`second`
 //!
+//! Neither is this: `first`[](x)
+//! 
+//! Neither is this: `first`[`second` not code](x)
+//!
 //! This is: [`first`](x)`second`
 //~^ ERROR: adjacent
 //!
@@ -24,6 +28,9 @@
 //!
 //! So is this [`first`](x)`second`[`third`](x)
 //~^ ERROR: adjacent
+//!
+//! `first`[`second`](x)[third](x)
+//~^ ERROR: adjacent
 
 /// Test case for code links that are adjacent to code text.
 ///
@@ -35,6 +42,10 @@
 ///
 /// Neither is this: [first](x)`second` arst
 ///
+/// Neither is this: `first`[](x) arst
+/// 
+/// Neither is this: `first`[`second` not code](x) arst
+/// 
 /// This is: [`first`](x)`second` arst
 //~^ ERROR: adjacent
 ///
@@ -49,4 +60,7 @@
 ///
 /// So is this [`first`](x)`second`[`third`](x) arst
 //~^ ERROR: adjacent
+///
+/// `first`[`second`](x)[third](x) arst
+//~^ ERROR: adjacent
 pub struct WithTrailing;