syntax: switch to rustdoc intra links

Get rid of those old crusty HTML links!

Also, if an intradoc link is used that is bunk, fail the build.

Author: BurntSushi

regex-syntax/src/ast/parse.rs

@@ -229,8 +229,7 @@ impl ParserBuilder {
 /// abstract syntax tree. The size of the tree is proportional to the length
 /// of the regular expression pattern.
 ///
-/// A `Parser` can be configured in more detail via a
-/// [`ParserBuilder`](struct.ParserBuilder.html).
+/// A `Parser` can be configured in more detail via a [`ParserBuilder`].
 #[derive(Clone, Debug)]
 pub struct Parser {
     /// The current position of the parser.
@@ -336,8 +335,7 @@ impl Parser {
     /// The parser can be run with either the `parse` or `parse_with_comments`
     /// methods. The parse methods return an abstract syntax tree.
     ///
-    /// To set configuration options on the parser, use
-    /// [`ParserBuilder`](struct.ParserBuilder.html).
+    /// To set configuration options on the parser, use [`ParserBuilder`].
     pub fn new() -> Parser {
         ParserBuilder::new().build()
     }

regex-syntax/src/ast/visitor.rs

@@ -11,15 +11,12 @@ use crate::ast::{self, Ast};
 /// may be proportional to end user input.
 ///
 /// Typical usage of this trait involves providing an implementation and then
-/// running it using the [`visit`](fn.visit.html) function.
+/// running it using the [`visit`] function.
 ///
 /// Note that the abstract syntax tree for a regular expression is quite
-/// complex. Unless you specifically need it, you might be able to use the
-/// much simpler
-/// [high-level intermediate representation](../hir/struct.Hir.html)
-/// and its
-/// [corresponding `Visitor` trait](../hir/trait.Visitor.html)
-/// instead.
+/// complex. Unless you specifically need it, you might be able to use the much
+/// simpler [high-level intermediate representation](crate::hir::Hir) and its
+/// [corresponding `Visitor` trait](crate::hir::Visitor) instead.
 pub trait Visitor {
     /// The result of visiting an AST.
     type Output;
@@ -46,13 +43,12 @@ pub trait Visitor {
     }
 
     /// This method is called between child nodes of an
-    /// [`Alternation`](struct.Alternation.html).
+    /// [`Alternation`](ast::Alternation).
     fn visit_alternation_in(&mut self) -> Result<(), Self::Err> {
         Ok(())
     }
 
-    /// This method is called on every
-    /// [`ClassSetItem`](enum.ClassSetItem.html)
+    /// This method is called on every [`ClassSetItem`](ast::ClassSetItem)
     /// before descending into child nodes.
     fn visit_class_set_item_pre(
         &mut self,
@@ -61,8 +57,7 @@ pub trait Visitor {
         Ok(())
     }
 
-    /// This method is called on every
-    /// [`ClassSetItem`](enum.ClassSetItem.html)
+    /// This method is called on every [`ClassSetItem`](ast::ClassSetItem)
     /// after descending into child nodes.
     fn visit_class_set_item_post(
         &mut self,
@@ -72,8 +67,8 @@ pub trait Visitor {
     }
 
     /// This method is called on every
-    /// [`ClassSetBinaryOp`](struct.ClassSetBinaryOp.html)
-    /// before descending into child nodes.
+    /// [`ClassSetBinaryOp`](ast::ClassSetBinaryOp) before descending into
+    /// child nodes.
     fn visit_class_set_binary_op_pre(
         &mut self,
         _ast: &ast::ClassSetBinaryOp,
@@ -82,8 +77,8 @@ pub trait Visitor {
     }
 
     /// This method is called on every
-    /// [`ClassSetBinaryOp`](struct.ClassSetBinaryOp.html)
-    /// after descending into child nodes.
+    /// [`ClassSetBinaryOp`](ast::ClassSetBinaryOp) after descending into child
+    /// nodes.
     fn visit_class_set_binary_op_post(
         &mut self,
         _ast: &ast::ClassSetBinaryOp,
@@ -92,7 +87,7 @@ pub trait Visitor {
     }
 
     /// This method is called between the left hand and right hand child nodes
-    /// of a [`ClassSetBinaryOp`](struct.ClassSetBinaryOp.html).
+    /// of a [`ClassSetBinaryOp`](ast::ClassSetBinaryOp).
     fn visit_class_set_binary_op_in(
         &mut self,
         _ast: &ast::ClassSetBinaryOp,
@@ -104,8 +99,7 @@ pub trait Visitor {
 /// Executes an implementation of `Visitor` in constant stack space.
 ///
 /// This function will visit every node in the given `Ast` while calling the
-/// appropriate methods provided by the
-/// [`Visitor`](trait.Visitor.html) trait.
+/// appropriate methods provided by the [`Visitor`] trait.
 ///
 /// The primary use case for this method is when one wants to perform case
 /// analysis over an `Ast` without using a stack size proportional to the depth

regex-syntax/src/hir/literal/mod.rs

@@ -30,11 +30,11 @@ use crate::hir::{self, Hir, HirKind};
 /// bounded to some low number by default using heuristics, but the limits can
 /// be tweaked.
 ///
-/// **WARNING**: Literal extraction uses stack space proportional to the size
-/// of the `Hir` expression. At some point, this drawback will be eliminated.
-/// To protect yourself, set a reasonable
-/// [`nest_limit` on your `Parser`](../../struct.ParserBuilder.html#method.nest_limit).
-/// This is done for you by default.
+/// **WARNING**: Literal extraction uses stack space proportional to the
+/// size of the `Hir` expression. At some point, this drawback will be
+/// eliminated. To protect yourself, set a reasonable [`nest_limit` on your
+/// `Parser`](crate::ParserBuilder::nest_limit). This is done for you by
+/// default.
 #[derive(Clone, Eq, PartialEq)]
 pub struct Literals {
     lits: Vec<Literal>,

regex-syntax/src/hir/mod.rs

@@ -681,8 +681,8 @@ impl HirKind {
     /// Return true if and only if this HIR is the empty regular expression.
     ///
     /// Note that this is not defined inductively. That is, it only tests if
-    /// this kind is the `Empty` variant. To get the inductive definition,
-    /// use the `is_match_empty` method on [`Hir`](struct.Hir.html).
+    /// this kind is the `Empty` variant. To get the inductive definition, use
+    /// the `is_match_empty` method on [`Hir`].
     pub fn is_empty(&self) -> bool {
         match *self {
             HirKind::Empty => true,
@@ -756,12 +756,12 @@ impl Literal {
 /// A character class, regardless of its character type, is represented by a
 /// sequence of non-overlapping non-adjacent ranges of characters.
 ///
-/// Note that unlike [`Literal`](enum.Literal.html), a `Bytes` variant may
-/// be produced even when it exclusively matches valid UTF-8. This is because
-/// a `Bytes` variant represents an intention by the author of the regular
-/// expression to disable Unicode mode, which in turn impacts the semantics of
-/// case insensitive matching. For example, `(?i)k` and `(?i-u)k` will not
-/// match the same set of strings.
+/// Note that unlike [`Literal`], a `Bytes` variant may be produced even when
+/// it exclusively matches valid UTF-8. This is because a `Bytes` variant
+/// represents an intention by the author of the regular expression to disable
+/// Unicode mode, which in turn impacts the semantics of case insensitive
+/// matching. For example, `(?i)k` and `(?i-u)k` will not match the same set of
+/// strings.
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub enum Class {
     /// A set of characters represented by Unicode scalar values.
@@ -1424,10 +1424,9 @@ impl Repetition {
     ///
     /// Note that this is not defined inductively. For example, while `a*`
     /// will report `true`, `()+` will not, even though `()` matches the empty
-    /// string and one or more occurrences of something that matches the empty
-    /// string will always match the empty string. In order to get the
-    /// inductive definition, see the corresponding method on
-    /// [`Hir`](struct.Hir.html).
+    /// string and one or more occurrences of something that matches the
+    /// empty string will always match the empty string. In order to get the
+    /// inductive definition, see the corresponding method on [`Hir`].
     pub fn is_match_empty(&self) -> bool {
         match self.kind {
             RepetitionKind::ZeroOrOne => true,

regex-syntax/src/hir/translate.rs

@@ -103,7 +103,7 @@ impl TranslatorBuilder {
 /// many abstract syntax trees.
 ///
 /// A `Translator` can be configured in more detail via a
-/// [`TranslatorBuilder`](struct.TranslatorBuilder.html).
+/// [`TranslatorBuilder`].
 #[derive(Clone, Debug)]
 pub struct Translator {
     /// Our call stack, but on the heap.

regex-syntax/src/hir/visitor.rs

@@ -11,7 +11,7 @@ use crate::hir::{self, Hir, HirKind};
 /// important since the size of an HIR may be proportional to end user input.
 ///
 /// Typical usage of this trait involves providing an implementation and then
-/// running it using the [`visit`](fn.visit.html) function.
+/// running it using the [`visit`] function.
 pub trait Visitor {
     /// The result of visiting an HIR.
     type Output;
@@ -46,8 +46,7 @@ pub trait Visitor {
 /// Executes an implementation of `Visitor` in constant stack space.
 ///
 /// This function will visit every node in the given `Hir` while calling
-/// appropriate methods provided by the
-/// [`Visitor`](trait.Visitor.html) trait.
+/// appropriate methods provided by the [`Visitor`] trait.
 ///
 /// The primary use case for this method is when one wants to perform case
 /// analysis over an `Hir` without using a stack size proportional to the depth

regex-syntax/src/lib.rs

@@ -3,14 +3,14 @@ This crate provides a robust regular expression parser.
 
 This crate defines two primary types:
 
-* [`Ast`](ast/enum.Ast.html) is the abstract syntax of a regular expression.
+* [`Ast`](ast::Ast) is the abstract syntax of a regular expression.
   An abstract syntax corresponds to a *structured representation* of the
   concrete syntax of a regular expression, where the concrete syntax is the
   pattern string itself (e.g., `foo(bar)+`). Given some abstract syntax, it
   can be converted back to the original concrete syntax (modulo some details,
   like whitespace). To a first approximation, the abstract syntax is complex
   and difficult to analyze.
-* [`Hir`](hir/struct.Hir.html) is the high-level intermediate representation
+* [`Hir`](hir::Hir) is the high-level intermediate representation
   ("HIR" or "high-level IR" for short) of regular expression. It corresponds to
   an intermediate state of a regular expression that sits between the abstract
   syntax and the low level compiled opcodes that are eventually responsible for
@@ -22,14 +22,14 @@ This crate defines two primary types:
 
 These two types come with conversion routines:
 
-* An [`ast::parse::Parser`](ast/parse/struct.Parser.html) converts concrete
-  syntax (a `&str`) to an [`Ast`](ast/enum.Ast.html).
-* A [`hir::translate::Translator`](hir/translate/struct.Translator.html)
-  converts an [`Ast`](ast/enum.Ast.html) to a [`Hir`](hir/struct.Hir.html).
+* An [`ast::parse::Parser`] converts concrete syntax (a `&str`) to an
+[`Ast`](ast::Ast).
+* A [`hir::translate::Translator`] converts an [`Ast`](ast::Ast) to a
+[`Hir`](hir::Hir).
 
 As a convenience, the above two conversion routines are combined into one via
-the top-level [`Parser`](struct.Parser.html) type. This `Parser` will first
-convert your pattern to an `Ast` and then convert the `Ast` to an `Hir`.
+the top-level [`Parser`] type. This `Parser` will first convert your pattern to
+an `Ast` and then convert the `Ast` to an `Hir`.
 
 
 # Example
@@ -81,10 +81,10 @@ in a monospace font.
 
 # Literal extraction
 
-This crate provides limited support for
-[literal extraction from `Hir` values](hir/literal/struct.Literals.html).
-Be warned that literal extraction currently uses recursion, and therefore,
-stack size proportional to the size of the `Hir`.
+This crate provides limited support for [literal extraction from `Hir`
+values](hir::literal::Literals). Be warned that literal extraction currently
+uses recursion, and therefore, stack size proportional to the size of the
+`Hir`.
 
 The purpose of literal extraction is to speed up searches. That is, if you
 know a regular expression must match a prefix or suffix literal, then it is
@@ -159,11 +159,12 @@ The following features are available:
   `\p{sb=ATerm}`.
 */
 
+#![no_std]
 #![forbid(unsafe_code)]
-#![deny(missing_docs)]
+#![deny(missing_docs, rustdoc::broken_intra_doc_links)]
+#![doc(test(attr(deny(warnings))))]
 #![warn(missing_debug_implementations)]
 #![cfg_attr(docsrs, feature(doc_auto_cfg))]
-#![no_std]
 
 #[cfg(any(test, feature = "std"))]
 extern crate std;
@@ -240,10 +241,9 @@ pub fn is_meta_character(c: char) -> bool {
 ///
 /// # Panics
 ///
-/// If the `unicode-perl` feature is not enabled, then this function panics.
-/// For this reason, it is recommended that callers use
-/// [`try_is_word_character`](fn.try_is_word_character.html)
-/// instead.
+/// If the `unicode-perl` feature is not enabled, then this function
+/// panics. For this reason, it is recommended that callers use
+/// [`try_is_word_character`] instead.
 pub fn is_word_character(c: char) -> bool {
     try_is_word_character(c).expect("unicode-perl feature must be enabled")
 }

regex-syntax/src/parser.rs

@@ -4,10 +4,9 @@ use crate::{ast, hir, Result};
 ///
 /// This builder permits modifying configuration options for the parser.
 ///
-/// This type combines the builder options for both the
-/// [AST `ParserBuilder`](ast/parse/struct.ParserBuilder.html)
-/// and the
-/// [HIR `TranslatorBuilder`](hir/translate/struct.TranslatorBuilder.html).
+/// This type combines the builder options for both the [AST
+/// `ParserBuilder`](ast::parse::ParserBuilder) and the [HIR
+/// `TranslatorBuilder`](hir::translate::TranslatorBuilder).
 #[derive(Clone, Debug, Default)]
 pub struct ParserBuilder {
     ast: ast::parse::ParserBuilder,
@@ -164,10 +163,9 @@ impl ParserBuilder {
 /// convenience for never having to deal with it at all.
 ///
 /// If callers have more fine grained use cases that need an AST, then please
-/// see the [`ast::parse`](ast/parse/index.html) module.
+/// see the [`ast::parse`] module.
 ///
-/// A `Parser` can be configured in more detail via a
-/// [`ParserBuilder`](struct.ParserBuilder.html).
+/// A `Parser` can be configured in more detail via a [`ParserBuilder`].
 #[derive(Clone, Debug)]
 pub struct Parser {
     ast: ast::parse::Parser,
@@ -181,8 +179,7 @@ impl Parser {
     /// a high level intermediate representation of the given regular
     /// expression.
     ///
-    /// To set configuration options on the parser, use
-    /// [`ParserBuilder`](struct.ParserBuilder.html).
+    /// To set configuration options on the parser, use [`ParserBuilder`].
     pub fn new() -> Parser {
         ParserBuilder::new().build()
     }

regex-syntax/src/utf8.rs

@@ -3,7 +3,7 @@ Converts ranges of Unicode scalar values to equivalent ranges of UTF-8 bytes.
 
 This is sub-module is useful for constructing byte based automatons that need
 to embed UTF-8 decoding. The most common use of this module is in conjunction
-with the [`hir::ClassUnicodeRange`](../hir/struct.ClassUnicodeRange.html) type.
+with the [`hir::ClassUnicodeRange`](crate::hir::ClassUnicodeRange) type.
 
 See the documentation on the `Utf8Sequences` iterator for more details and
 an example.