Use recently stabilized intra-doc links

See RFC: https://github.com/rust-lang/rfcs/blob/master/text/1946-intra-rustdoc-links.md

core/src/length.rs

@@ -26,8 +26,6 @@ impl Length {
     /// The _fill factor_ is a relative unit describing how much of the
     /// remaining space should be filled when compared to other elements. It
     /// is only meant to be used by layout engines.
-    ///
-    /// [`Length`]: enum.Length.html
     pub fn fill_factor(&self) -> u16 {
         match self {
             Length::Fill => 1,

core/src/point.rs

@@ -12,20 +12,14 @@ pub struct Point {
 
 impl Point {
     /// The origin (i.e. a [`Point`] at (0, 0)).
-    ///
-    /// [`Point`]: struct.Point.html
     pub const ORIGIN: Point = Point::new(0.0, 0.0);
 
     /// Creates a new [`Point`] with the given coordinates.
-    ///
-    /// [`Point`]: struct.Point.html
     pub const fn new(x: f32, y: f32) -> Self {
         Self { x, y }
     }
 
     /// Computes the distance to another [`Point`].
-    ///
-    /// [`Point`]: struct.Point.html
     pub fn distance(&self, to: Point) -> f32 {
         let a = self.x - to.x;
         let b = self.y - to.y;

core/src/rectangle.rs

@@ -19,10 +19,6 @@ pub struct Rectangle<T = f32> {
 impl Rectangle<f32> {
     /// Creates a new [`Rectangle`] with its top-left corner in the given
     /// [`Point`] and with the provided [`Size`].
-    ///
-    /// [`Rectangle`]: struct.Rectangle.html
-    /// [`Point`]: struct.Point.html
-    /// [`Size`]: struct.Size.html
     pub fn new(top_left: Point, size: Size) -> Self {
         Self {
             x: top_left.x,
@@ -34,9 +30,6 @@ impl Rectangle<f32> {
 
     /// Creates a new [`Rectangle`] with its top-left corner at the origin
     /// and with the provided [`Size`].
-    ///
-    /// [`Rectangle`]: struct.Rectangle.html
-    /// [`Size`]: struct.Size.html
     pub fn with_size(size: Size) -> Self {
         Self {
             x: 0.0,
@@ -47,50 +40,33 @@ impl Rectangle<f32> {
     }
 
     /// Returns the [`Point`] at the center of the [`Rectangle`].
-    ///
-    /// [`Point`]: struct.Point.html
-    /// [`Rectangle`]: struct.Rectangle.html
     pub fn center(&self) -> Point {
         Point::new(self.center_x(), self.center_y())
     }
 
     /// Returns the X coordinate of the [`Point`] at the center of the
     /// [`Rectangle`].
-    ///
-    /// [`Point`]: struct.Point.html
-    /// [`Rectangle`]: struct.Rectangle.html
     pub fn center_x(&self) -> f32 {
         self.x + self.width / 2.0
     }
 
     /// Returns the Y coordinate of the [`Point`] at the center of the
     /// [`Rectangle`].
-    ///
-    /// [`Point`]: struct.Point.html
-    /// [`Rectangle`]: struct.Rectangle.html
     pub fn center_y(&self) -> f32 {
         self.y + self.height / 2.0
     }
 
     /// Returns the position of the top left corner of the [`Rectangle`].
-    ///
-    /// [`Rectangle`]: struct.Rectangle.html
     pub fn position(&self) -> Point {
         Point::new(self.x, self.y)
     }
 
     /// Returns the [`Size`] of the [`Rectangle`].
-    ///
-    /// [`Size`]: struct.Size.html
-    /// [`Rectangle`]: struct.Rectangle.html
     pub fn size(&self) -> Size {
         Size::new(self.width, self.height)
     }
 
     /// Returns true if the given [`Point`] is contained in the [`Rectangle`].
-    ///
-    /// [`Point`]: struct.Point.html
-    /// [`Rectangle`]: struct.Rectangle.html
     pub fn contains(&self, point: Point) -> bool {
         self.x <= point.x
             && point.x <= self.x + self.width
@@ -99,8 +75,6 @@ impl Rectangle<f32> {
     }
 
     /// Computes the intersection with the given [`Rectangle`].
-    ///
-    /// [`Rectangle`]: struct.Rectangle.html
     pub fn intersection(
         &self,
         other: &Rectangle<f32>,
@@ -127,8 +101,6 @@ impl Rectangle<f32> {
     }
 
     /// Snaps the [`Rectangle`] to __unsigned__ integer coordinates.
-    ///
-    /// [`Rectangle`]: struct.Rectangle.html
     pub fn snap(self) -> Rectangle<u32> {
         Rectangle {
             x: self.x as u32,

core/src/size.rs

@@ -12,8 +12,6 @@ pub struct Size<T = f32> {
 
 impl<T> Size<T> {
     /// Creates a new  [`Size`] with the given width and height.
-    ///
-    /// [`Size`]: struct.Size.html
     pub const fn new(width: T, height: T) -> Self {
         Size { width, height }
     }
@@ -21,23 +19,15 @@ impl<T> Size<T> {
 
 impl Size {
     /// A [`Size`] with zero width and height.
-    ///
-    /// [`Size`]: struct.Size.html
     pub const ZERO: Size = Size::new(0., 0.);
 
     /// A [`Size`] with a width and height of 1 unit.
-    ///
-    /// [`Size`]: struct.Size.html
     pub const UNIT: Size = Size::new(1., 1.);
 
     /// A [`Size`] with infinite width and height.
-    ///
-    /// [`Size`]: struct.Size.html
     pub const INFINITY: Size = Size::new(f32::INFINITY, f32::INFINITY);
 
     /// Increments the [`Size`] to account for the given padding.
-    ///
-    /// [`Size`]: struct.Size.html
     pub fn pad(&self, padding: f32) -> Self {
         Size {
             width: self.width + padding * 2.0,

core/src/vector.rs

@@ -2,20 +2,14 @@
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub struct Vector<T = f32> {
     /// The X component of the [`Vector`]
-    ///
-    /// [`Vector`]: struct.Vector.html
     pub x: T,
 
     /// The Y component of the [`Vector`]
-    ///
-    /// [`Vector`]: struct.Vector.html
     pub y: T,
 }
 
 impl<T> Vector<T> {
     /// Creates a new [`Vector`] with the given components.
-    ///
-    /// [`Vector`]: struct.Vector.html
     pub const fn new(x: T, y: T) -> Self {
         Self { x, y }
     }