Add rustdoc::unescaped_backtick lint

Author: Lukas Markeffsky

src/doc/rustdoc/src/lints.md

@@ -374,3 +374,38 @@ warning: this URL is not a hyperlink
 
 warning: 2 warnings emitted
 ```
+
+## `unescaped_backticks`
+
+This lint **warns by default**. It detects backticks (\`) that are not escaped.
+This usually means broken inline code. For example:
+
+```rust
+#![warn(rustdoc::unescaped_backticks)] // note: unnecessary - warns by default.
+
+/// Addition is commutative, which means that `add(a, b) is the same as `add(b, a)`.
+pub fn add(a: i32, b: i32) -> i32 { a + b }
+```
+
+Which will give:
+
+```text
+warning: unescaped backtick
+ --> src/lib.rs:1:83
+  |
+1 | /// Addition is commutative, which means that `add(a, b) is the same as `add(b, a)`.
+  |                                                                                   ^
+  |
+  = help: the opening or closing backtick of an inline code may be missing
+  = note: `#[warn(rustdoc::unescaped_backticks)]` on by default
+help: a previous inline code might be longer than expected
+  |
+1 | /// Addition is commutative, which means that `add(a, b)` is the same as `add(b, a)`.
+  |                                                         +
+help: if you meant to use a literal backtick, escape it
+  |
+1 | /// Addition is commutative, which means that `add(a, b) is the same as `add(b, a)\`.
+  |                                                                                   +
+
+warning: 1 warning emitted
+```

src/librustdoc/lib.rs

@@ -8,13 +8,15 @@
 #![feature(box_patterns)]
 #![feature(control_flow_enum)]
 #![feature(drain_filter)]
+#![feature(iter_intersperse)]
+#![feature(is_some_and)]
 #![feature(is_terminal)]
 #![feature(let_chains)]
 #![feature(test)]
 #![feature(never_type)]
 #![feature(once_cell)]
+#![feature(round_char_boundary)]
 #![feature(type_ascription)]
-#![feature(iter_intersperse)]
 #![feature(type_alias_impl_trait)]
 #![recursion_limit = "256"]
 #![warn(rustc::internal)]

src/librustdoc/lint.rs

@@ -174,6 +174,17 @@ declare_rustdoc_lint! {
    "codeblock could not be parsed as valid Rust or is empty"
 }
 
+declare_rustdoc_lint! {
+   /// The `unescaped_backticks` lint detects unescaped backticks (\`), which usually
+   /// mean broken inline code. This is a `rustdoc` only lint, see the documentation
+   /// in the [rustdoc book].
+   ///
+   /// [rustdoc book]: ../../../rustdoc/lints.html#unescaped_backticks
+   UNESCAPED_BACKTICKS,
+   Warn,
+   "detects unescaped backticks in doc comments"
+}
+
 pub(crate) static RUSTDOC_LINTS: Lazy<Vec<&'static Lint>> = Lazy::new(|| {
     vec![
         BROKEN_INTRA_DOC_LINKS,
@@ -185,6 +196,7 @@ pub(crate) static RUSTDOC_LINTS: Lazy<Vec<&'static Lint>> = Lazy::new(|| {
         INVALID_HTML_TAGS,
         BARE_URLS,
         MISSING_CRATE_LEVEL_DOCS,
+        UNESCAPED_BACKTICKS,
     ]
 });
 

src/librustdoc/passes/lint.rs

@@ -4,6 +4,7 @@
 mod bare_urls;
 mod check_code_block_syntax;
 mod html_tags;
+mod unescaped_backticks;
 
 use super::Pass;
 use crate::clean::*;
@@ -27,6 +28,7 @@ impl<'a, 'tcx> DocVisitor for Linter<'a, 'tcx> {
         bare_urls::visit_item(self.cx, item);
         check_code_block_syntax::visit_item(self.cx, item);
         html_tags::visit_item(self.cx, item);
+        unescaped_backticks::visit_item(self.cx, item);
 
         self.visit_item_recur(item)
     }