Add new unused_footnote_definition rustdoc lint

Author: GuillaumeGomez

src/librustdoc/lint.rs

@@ -211,6 +211,13 @@ declare_rustdoc_lint! {
     "footnote reference with no associated definition"
 }
 
+declare_rustdoc_lint! {
+    /// This lint checks if all footnote definitions are used.
+    UNUSED_FOOTNOTE_DEFINITION,
+    Warn,
+    "unused footnote definition"
+}
+
 pub(crate) static RUSTDOC_LINTS: Lazy<Vec<&'static Lint>> = Lazy::new(|| {
     vec![
         BROKEN_INTRA_DOC_LINKS,
@@ -226,6 +233,7 @@ pub(crate) static RUSTDOC_LINTS: Lazy<Vec<&'static Lint>> = Lazy::new(|| {
         REDUNDANT_EXPLICIT_LINKS,
         UNPORTABLE_MARKDOWN,
         BROKEN_FOOTNOTE,
+        UNUSED_FOOTNOTE_DEFINITION,
     ]
 });
 

src/librustdoc/passes/lint/footnotes.rs

@@ -12,38 +12,63 @@
 
 use std::ops::Range;
 
-use rustc_data_structures::fx::FxHashSet;
+use pulldown_cmark::{Event, Options, Parser, Tag};
+use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_hir::HirId;
 use rustc_lint_defs::Applicability;
 use rustc_resolve::rustdoc::source_span_for_markdown_range;
 
 use crate::clean::Item;
 use crate::core::DocContext;
 
-use pulldown_cmark::{Event, Options, Parser};
-
 pub(crate) fn visit_item(cx: &DocContext<'_>, item: &Item, hir_id: HirId, dox: &str) {
     let tcx = cx.tcx;
 
     let mut missing_footnote_references = FxHashSet::default();
+    let mut footnote_references = FxHashSet::default();
+    let mut footnote_definitions = FxHashMap::default();
 
     let options = Options::ENABLE_FOOTNOTES;
     let mut parser = Parser::new_ext(dox, options).into_offset_iter().peekable();
     while let Some((event, span)) = parser.next() {
         match event {
-            Event::Text(text) if &*text == "["
-                && let Some((Event::Text(text), _)) = parser.peek()
-                && text.trim_start().starts_with('^')
-                && parser.next().is_some()
-                && let Some((Event::Text(text), end_span)) = parser.peek()
-                && &**text == "]" =>
+            Event::Text(text)
+                if &*text == "["
+                    && let Some((Event::Text(text), _)) = parser.peek()
+                    && text.trim_start().starts_with('^')
+                    && parser.next().is_some()
+                    && let Some((Event::Text(text), end_span)) = parser.peek()
+                    && &**text == "]" =>
             {
                 missing_footnote_references.insert(Range { start: span.start, end: end_span.end });
             }
+            Event::FootnoteReference(label) => {
+                footnote_references.insert(label);
+            }
+            Event::Start(Tag::FootnoteDefinition(label)) => {
+                footnote_definitions.insert(label, span.start + 1);
+            }
             _ => {}
         }
     }
 
+    #[allow(rustc::potential_query_instability)]
+    for (footnote, span) in footnote_definitions {
+        if !footnote_references.contains(&footnote) {
+            let span = source_span_for_markdown_range(
+                tcx,
+                dox,
+                &(span..span + 1),
+                &item.attrs.doc_strings,
+            )
+            .unwrap_or_else(|| item.attr_span(tcx));
+
+            tcx.node_span_lint(crate::lint::UNUSED_FOOTNOTE_DEFINITION, hir_id, span, |lint| {
+                lint.primary_message("unused footnote definition");
+            });
+        }
+    }
+
     #[allow(rustc::potential_query_instability)]
     for span in missing_footnote_references {
         let (ref_span, precise) =