Convert (almost) all cross-references in the documentation to intradoc links

Compiler will check existence of the intradoc links.

Cross-references in the Deserializer couldn't be converted to intradoc links,
because trait is implemented for `&mut` and rustdoc cannot resolve that links

Author: Mingun

src/de/map.rs

@@ -517,15 +517,15 @@ where
     forward!(deserialize_any);
     forward!(deserialize_ignored_any);
 
-    /// Tuple representation is the same as [sequences](#method.deserialize_seq).
+    /// Tuple representation is the same as [sequences](Self::deserialize_seq).
     fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, DeError>
     where
         V: Visitor<'de>,
     {
         self.deserialize_seq(visitor)
     }
 
-    /// Named tuple representation is the same as [unnamed tuples](#method.deserialize_tuple).
+    /// Named tuple representation is the same as [unnamed tuples](Self::deserialize_tuple).
     fn deserialize_tuple_struct<V>(
         self,
         _name: &'static str,
@@ -687,15 +687,15 @@ where
     forward!(deserialize_any);
     forward!(deserialize_ignored_any);
 
-    /// Representation of tuples the same as [sequences](#method.deserialize_seq).
+    /// Representation of tuples the same as [sequences](Self::deserialize_seq).
     fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, DeError>
     where
         V: Visitor<'de>,
     {
         self.deserialize_seq(visitor)
     }
 
-    /// Representation of named tuples the same as [unnamed tuples](#method.deserialize_tuple).
+    /// Representation of named tuples the same as [unnamed tuples](Self::deserialize_tuple).
     fn deserialize_tuple_struct<V>(
         self,
         _name: &'static str,

src/errors.rs

@@ -79,8 +79,6 @@ impl From<AttrError> for Error {
 }
 
 /// A specialized `Result` type where the error is hard-wired to [`Error`].
-///
-/// [`Error`]: enum.Error.html
 pub type Result<T> = std::result::Result<T, Error>;
 
 impl std::fmt::Display for Error {

src/events/attributes.rs

@@ -17,15 +17,13 @@ use std::{borrow::Cow, collections::HashMap, ops::Range};
 /// want to access the value using one of the [`unescaped_value`] and [`unescape_and_decode_value`]
 /// functions.
 ///
-/// [`unescaped_value`]: #method.unescaped_value
-/// [`unescape_and_decode_value`]: #method.unescape_and_decode_value
+/// [`unescaped_value`]: Self::unescaped_value
+/// [`unescape_and_decode_value`]: Self::unescape_and_decode_value
 #[derive(Clone, PartialEq)]
 pub struct Attribute<'a> {
     /// The key to uniquely define the attribute.
     ///
     /// If [`Attributes::with_checks`] is turned off, the key might not be unique.
-    ///
-    /// [`Attributes::with_checks`]: struct.Attributes.html#method.with_checks
     pub key: QName<'a>,
     /// The raw value of the attribute.
     pub value: Cow<'a, [u8]>,
@@ -39,7 +37,7 @@ impl<'a> Attribute<'a> {
     ///
     /// This will allocate if the value contains any escape sequences.
     ///
-    /// See also [`unescaped_value_with_custom_entities()`](#method.unescaped_value_with_custom_entities)
+    /// See also [`unescaped_value_with_custom_entities()`](Self::unescaped_value_with_custom_entities)
     pub fn unescaped_value(&self) -> XmlResult<Cow<[u8]>> {
         self.make_unescaped_value(None)
     }
@@ -52,7 +50,7 @@ impl<'a> Attribute<'a> {
     ///
     /// This will allocate if the value contains any escape sequences.
     ///
-    /// See also [`unescaped_value()`](#method.unescaped_value)
+    /// See also [`unescaped_value()`](Self::unescaped_value)
     ///
     /// # Pre-condition
     ///
@@ -76,11 +74,11 @@ impl<'a> Attribute<'a> {
     /// This allocates a `String` in all cases. For performance reasons it might be a better idea to
     /// instead use one of:
     ///
-    /// * [`Reader::decode()`], as it only allocates when the decoding can't be performed otherwise.
+    /// * [`Reader::decoder().decode()`], as it only allocates when the decoding can't be performed otherwise.
     /// * [`unescaped_value()`], as it doesn't allocate when no escape sequences are used.
     ///
-    /// [`unescaped_value()`]: #method.unescaped_value
-    /// [`Reader::decode()`]: ../../reader/struct.Reader.html#method.decode
+    /// [`unescaped_value()`]: Self::unescaped_value
+    /// [`Reader::decoder().decode()`]: crate::reader::Decoder::decode
     pub fn unescape_and_decode_value<B>(&self, reader: &Reader<B>) -> XmlResult<String> {
         self.do_unescape_and_decode_value(reader, None)
     }
@@ -90,11 +88,11 @@ impl<'a> Attribute<'a> {
     /// This allocates a `String` in all cases. For performance reasons it might be a better idea to
     /// instead use one of:
     ///
-    /// * [`Reader::decode()`], as it only allocates when the decoding can't be performed otherwise.
+    /// * [`Reader::decoder().decode()`], as it only allocates when the decoding can't be performed otherwise.
     /// * [`unescaped_value_with_custom_entities()`], as it doesn't allocate when no escape sequences are used.
     ///
-    /// [`unescaped_value_with_custom_entities()`]: #method.unescaped_value_with_custom_entities
-    /// [`Reader::decode()`]: ../../reader/struct.Reader.html#method.decode
+    /// [`unescaped_value_with_custom_entities()`]: Self::unescaped_value_with_custom_entities
+    /// [`Reader::decoder().decode()`]: crate::reader::Decoder::decode
     ///
     /// # Pre-condition
     ///
@@ -189,7 +187,7 @@ impl<'a> From<Attr<&'a [u8]>> for Attribute<'a> {
 /// Yields `Result<Attribute>`. An `Err` will be yielded if an attribute is malformed or duplicated.
 /// The duplicate check can be turned off by calling [`with_checks(false)`].
 ///
-/// [`with_checks(false)`]: #method.with_checks
+/// [`with_checks(false)`]: Self::with_checks
 #[derive(Clone, Debug)]
 pub struct Attributes<'a> {
     /// slice of `Element` corresponding to attributes

src/events/mod.rs

@@ -108,13 +108,12 @@ impl<'a> From<BytesText<'a>> for BytesStartText<'a> {
 ///
 /// `<name attr="value">`.
 ///
-/// The name can be accessed using the [`name`], [`local_name`] or [`unescaped`] methods. An
-/// iterator over the attributes is returned by the [`attributes`] method.
+/// The name can be accessed using the [`name`] or [`local_name`] methods.
+/// An iterator over the attributes is returned by the [`attributes`] method.
 ///
-/// [`name`]: #method.name
-/// [`local_name`]: #method.local_name
-/// [`unescaped`]: #method.unescaped
-/// [`attributes`]: #method.attributes
+/// [`name`]: Self::name
+/// [`local_name`]: Self::local_name
+/// [`attributes`]: Self::attributes
 #[derive(Clone, Eq, PartialEq)]
 pub struct BytesStart<'a> {
     /// content of the element, before any utf8 conversion
@@ -203,7 +202,7 @@ impl<'a> BytesStart<'a> {
     /// # }}
     /// ```
     ///
-    /// [`to_end`]: #method.to_end
+    /// [`to_end`]: Self::to_end
     pub fn to_borrowed(&self) -> BytesStart {
         BytesStart::borrowed(&self.buf, self.name_len)
     }
@@ -718,7 +717,7 @@ impl<'a> BytesText<'a> {
     /// Searches for '&' into content and try to escape the coded character if possible
     /// returns Malformed error with index within element if '&' is not followed by ';'
     ///
-    /// See also [`unescaped_with_custom_entities()`](#method.unescaped_with_custom_entities)
+    /// See also [`unescaped_with_custom_entities()`](Self::unescaped_with_custom_entities)
     pub fn unescaped(&self) -> Result<Cow<[u8]>> {
         self.make_unescaped(None)
     }
@@ -733,7 +732,7 @@ impl<'a> BytesText<'a> {
     ///
     /// The keys and values of `custom_entities`, if any, must be valid UTF-8.
     ///
-    /// See also [`unescaped()`](#method.unescaped)
+    /// See also [`unescaped()`](Self::unescaped)
     pub fn unescaped_with_custom_entities<'s>(
         &'s self,
         custom_entities: &HashMap<Vec<u8>, Vec<u8>>,

src/reader.rs

@@ -234,9 +234,9 @@ impl<R> Reader<R> {
     ///
     /// (`false` by default)
     ///
-    /// [`Empty`]: events/enum.Event.html#variant.Empty
-    /// [`Start`]: events/enum.Event.html#variant.Start
-    /// [`End`]: events/enum.Event.html#variant.End
+    /// [`Empty`]: Event::Empty
+    /// [`Start`]: Event::Start
+    /// [`End`]: Event::End
     pub fn expand_empty_elements(&mut self, val: bool) -> &mut Self {
         self.expand_empty_elements = val;
         self
@@ -249,7 +249,7 @@ impl<R> Reader<R> {
     ///
     /// (`false` by default)
     ///
-    /// [`Text`]: events/enum.Event.html#variant.Text
+    /// [`Text`]: Event::Text
     pub fn trim_text(&mut self, val: bool) -> &mut Self {
         self.trim_text_start = val;
         self.trim_text_end = val;
@@ -262,7 +262,7 @@ impl<R> Reader<R> {
     ///
     /// (`false` by default)
     ///
-    /// [`Text`]: events/enum.Event.html#variant.Text
+    /// [`Text`]: Event::Text
     pub fn trim_text_end(&mut self, val: bool) -> &mut Self {
         self.trim_text_end = val;
         self
@@ -278,7 +278,7 @@ impl<R> Reader<R> {
     ///
     /// (`true` by default)
     ///
-    /// [`End`]: events/enum.Event.html#variant.End
+    /// [`End`]: Event::End
     pub fn trim_markup_names_in_closing_tags(&mut self, val: bool) -> &mut Self {
         self.trim_markup_names_in_closing_tags = val;
         self
@@ -300,7 +300,7 @@ impl<R> Reader<R> {
     ///
     /// (`true` by default)
     ///
-    /// [`End`]: events/enum.Event.html#variant.End
+    /// [`End`]: Event::End
     pub fn check_end_names(&mut self, val: bool) -> &mut Self {
         self.check_end_names = val;
         self
@@ -315,7 +315,7 @@ impl<R> Reader<R> {
     ///
     /// (`false` by default)
     ///
-    /// [`Comment`]: events/enum.Event.html#variant.Comment
+    /// [`Comment`]: Event::Comment
     pub fn check_comments(&mut self, val: bool) -> &mut Self {
         self.check_comments = val;
         self

src/writer.rs

@@ -152,13 +152,15 @@ impl<W: Write> Writer<W> {
 
     /// Manually write a newline and indentation at the proper level.
     ///
-    /// This can be used when the heuristic to line break and indent after any [Event] apart
-    /// from [Text] fails such as when a [Start] occurs directly after [Text].
-    /// This method will do nothing if `Writer` was not constructed with `new_with_indent`.
+    /// This can be used when the heuristic to line break and indent after any
+    /// [`Event`] apart from [`Text`] fails such as when a [`Start`] occurs directly
+    /// after [`Text`].
     ///
-    /// [Event]: events/enum.Event.html
-    /// [Text]: events/enum.Event.html#variant.Text
-    /// [Start]: events/enum.Event.html#variant.Start
+    /// This method will do nothing if `Writer` was not constructed with [`new_with_indent`].
+    ///
+    /// [`Text`]: Event::Text
+    /// [`Start`]: Event::Start
+    /// [`new_with_indent`]: Self::new_with_indent
     pub fn write_indent(&mut self) -> Result<()> {
         if let Some(ref i) = self.indent {
             self.writer.write_all(b"\n").map_err(Error::Io)?;
@@ -171,7 +173,8 @@ impl<W: Write> Writer<W> {
 
     /// Provides a simple, high-level API for writing XML elements.
     ///
-    /// Returns an [ElementWriter] that simplifies setting attributes and writing content inside the element.
+    /// Returns an [`ElementWriter`] that simplifies setting attributes and writing
+    /// content inside the element.
     ///
     /// # Example
     ///