chore: use const fn in Span

Author: bvanjoi

crates/swc_common/src/syntax_pos.rs

@@ -2,7 +2,7 @@
 use std::sync::Mutex;
 use std::{
     borrow::Cow,
-    cmp, fmt,
+    fmt,
     hash::{Hash, Hasher},
     ops::{Add, Sub},
     path::PathBuf,
@@ -385,71 +385,71 @@ extern "C" {
 
 impl Span {
     #[inline]
-    pub fn lo(self) -> BytePos {
+    pub const fn lo(self) -> BytePos {
         self.lo
     }
 
     #[inline]
-    pub fn new(mut lo: BytePos, mut hi: BytePos) -> Self {
-        if lo > hi {
-            std::mem::swap(&mut lo, &mut hi);
+    pub const fn new(lo: BytePos, hi: BytePos) -> Self {
+        if lo.0 > hi.0 {
+            Span { lo: hi, hi: lo }
+        } else {
+            Span { lo, hi }
         }
-
-        Span { lo, hi }
     }
 
     #[inline]
-    pub fn with_lo(&self, lo: BytePos) -> Span {
+    pub const fn with_lo(&self, lo: BytePos) -> Span {
         Span::new(lo, self.hi)
     }
 
     #[inline]
-    pub fn hi(self) -> BytePos {
+    pub const fn hi(self) -> BytePos {
         self.hi
     }
 
     #[inline]
-    pub fn with_hi(&self, hi: BytePos) -> Span {
+    pub const fn with_hi(&self, hi: BytePos) -> Span {
         Span::new(self.lo, hi)
     }
 
     /// Returns `true` if this is a dummy span with any hygienic context.
     #[inline]
-    pub fn is_dummy(self) -> bool {
+    pub const fn is_dummy(self) -> bool {
         self.lo.0 == 0 && self.hi.0 == 0 || self.lo.0 >= DUMMY_RESERVE
     }
 
     #[inline]
-    pub fn is_pure(self) -> bool {
+    pub const fn is_pure(self) -> bool {
         self.lo.is_pure()
     }
 
     #[inline]
-    pub fn is_placeholder(self) -> bool {
+    pub const fn is_placeholder(self) -> bool {
         self.lo.is_placeholder()
     }
 
     /// Returns `true` if this is a dummy span with any hygienic context.
     #[inline]
-    pub fn is_dummy_ignoring_cmt(self) -> bool {
-        self.lo.0 == 0 && self.hi.0 == 0
+    pub const fn is_dummy_ignoring_cmt(self) -> bool {
+        self.lo.is_dummy() && self.hi.is_dummy()
     }
 
     /// Returns a new span representing an empty span at the beginning of this
     /// span
     #[inline]
-    pub fn shrink_to_lo(self) -> Span {
+    pub const fn shrink_to_lo(self) -> Span {
         self.with_hi(self.lo)
     }
 
     /// Returns a new span representing an empty span at the end of this span
     #[inline]
-    pub fn shrink_to_hi(self) -> Span {
+    pub const fn shrink_to_hi(self) -> Span {
         self.with_lo(self.hi)
     }
 
     /// Returns `self` if `self` is not the dummy span, and `other` otherwise.
-    pub fn substitute_dummy(self, other: Span) -> Span {
+    pub const fn substitute_dummy(self, other: Span) -> Span {
         if self.is_dummy() {
             other
         } else {
@@ -458,22 +458,22 @@ impl Span {
     }
 
     /// Return true if `self` fully encloses `other`.
-    pub fn contains(self, other: Span) -> bool {
-        self.lo <= other.lo && other.hi <= self.hi
+    pub const fn contains(self, other: Span) -> bool {
+        self.lo.0 <= other.lo.0 && other.hi.0 <= self.hi.0
     }
 
     /// Return true if the spans are equal with regards to the source text.
     ///
     /// Use this instead of `==` when either span could be generated code,
     /// and you only care that they point to the same bytes of source text.
-    pub fn source_equal(self, other: Span) -> bool {
-        self.lo == other.lo && self.hi == other.hi
+    pub const fn source_equal(self, other: Span) -> bool {
+        self.lo.0 == other.lo.0 && self.hi.0 == other.hi.0
     }
 
     /// Returns `Some(span)`, where the start is trimmed by the end of `other`
-    pub fn trim_start(self, other: Span) -> Option<Span> {
-        if self.hi > other.hi {
-            Some(self.with_lo(cmp::max(self.lo, other.hi)))
+    pub const fn trim_start(self, other: Span) -> Option<Span> {
+        if self.hi.0 > other.hi.0 {
+            Some(self.with_lo(self.lo.max(other.hi)))
         } else {
             None
         }
@@ -488,31 +488,29 @@ impl Span {
         // output. It is preferable to have an incomplete span than a completely
         // nonsensical one.
 
-        Span::new(
-            cmp::min(span_data.lo, end_data.lo),
-            cmp::max(span_data.hi, end_data.hi),
-        )
+        let lo = span_data.lo.min(end_data.lo);
+        let hi = span_data.hi.max(end_data.hi);
+        Span::new(lo, hi)
     }
 
     /// Return a `Span` between the end of `self` to the beginning of `end`.
-    pub fn between(self, end: Span) -> Span {
+    pub const fn between(self, end: Span) -> Span {
         let span = self;
         Span::new(span.hi, end.lo)
     }
 
     /// Return a `Span` between the beginning of `self` to the beginning of
     /// `end`.
-    pub fn until(self, end: Span) -> Span {
+    pub const fn until(self, end: Span) -> Span {
         let span = self;
         Span::new(span.lo, end.lo)
     }
 
-    pub fn from_inner_byte_pos(self, start: usize, end: usize) -> Span {
+    pub const fn from_inner_byte_pos(self, start: usize, end: usize) -> Span {
         let span = self;
-        Span::new(
-            span.lo + BytePos::from_usize(start),
-            span.lo + BytePos::from_usize(end),
-        )
+        let lo = BytePos(span.lo.0 + start as u32);
+        let hi = BytePos(span.lo.0 + end as u32);
+        Span::new(lo, hi)
     }
 
     /// Dummy span, both position are extremely large numbers so they would be
@@ -1109,6 +1107,22 @@ impl BytePos {
     pub const fn can_have_comment(self) -> bool {
         self.0 != 0
     }
+
+    const fn max(self, other: BytePos) -> BytePos {
+        if self.0 > other.0 {
+            self
+        } else {
+            other
+        }
+    }
+
+    const fn min(self, other: BytePos) -> BytePos {
+        if self.0 < other.0 {
+            self
+        } else {
+            other
+        }
+    }
 }
 
 /// A character offset. Because of multibyte utf8 characters, a byte offset