chore: reduce redundant lexer methods (#2165)

crates/biome_grit_parser/src/lexer/mod.rs

@@ -143,32 +143,6 @@ impl<'src> GritLexer<'src> {
         }
     }
 
-    /// Get the UTF8 char which starts at the current byte
-    ///
-    /// ## Safety
-    /// Must be called at a valid UT8 char boundary
-    #[inline]
-    fn current_char_unchecked(&self) -> char {
-        // Precautionary measure for making sure the unsafe code below does not
-        // read over memory boundary.
-        debug_assert!(!self.is_eof());
-        self.assert_current_char_boundary();
-
-        // Safety: We know this is safe because we require the input to the
-        // lexer to be valid utf8 and we always call this when we are at a char.
-        unsafe {
-            let Some(chr) = self
-                .source
-                .get_unchecked(self.position..self.source.len())
-                .chars()
-                .next()
-            else {
-                core::hint::unreachable_unchecked();
-            };
-            chr
-        }
-    }
-
     /// Bumps the current byte and creates a lexed token of the passed in kind.
     #[inline]
     fn consume_byte(&mut self, tok: GritSyntaxKind) -> GritSyntaxKind {

crates/biome_js_parser/src/lexer/mod.rs

@@ -485,50 +485,6 @@ impl<'src> JsLexer<'src> {
         }
     }
 
-    /// Get the UTF8 char which starts at the current byte
-    ///
-    /// ## Safety
-    /// Must be called at a valid UT8 char boundary
-    fn current_char_unchecked(&self) -> char {
-        // Precautionary measure for making sure the unsafe code below does not read over memory boundary
-        debug_assert!(!self.is_eof());
-        self.assert_current_char_boundary();
-
-        // Safety: We know this is safe because we require the input to the lexer to be valid utf8 and we always call this when we are at a char
-        let string = unsafe {
-            std::str::from_utf8_unchecked(self.source.as_bytes().get_unchecked(self.position..))
-        };
-        let chr = if let Some(chr) = string.chars().next() {
-            chr
-        } else {
-            // Safety: we always call this when we are at a valid char, so this branch is completely unreachable
-            unsafe {
-                core::hint::unreachable_unchecked();
-            }
-        };
-
-        chr
-    }
-
-    /// Gets the current byte.
-    ///
-    /// ## Returns
-    /// The current byte if the lexer isn't at the end of the file.
-    #[inline]
-    fn current_byte(&self) -> Option<u8> {
-        if self.is_eof() {
-            None
-        } else {
-            Some(self.source.as_bytes()[self.position])
-        }
-    }
-
-    /// Asserts that the lexer is currently positioned at `byte`
-    #[inline]
-    fn assert_byte(&self, byte: u8) {
-        debug_assert_eq!(self.source.as_bytes()[self.position], byte);
-    }
-
     /// Returns the current byte without checking if the lexer is at the end of the file.
     ///
     /// ## Safety
@@ -562,18 +518,6 @@ impl<'src> JsLexer<'src> {
         }
     }
 
-    /// Peeks at the next byte
-    #[inline]
-    fn peek_byte(&self) -> Option<u8> {
-        self.byte_at(1)
-    }
-
-    /// Returns the byte at position `self.position + offset` or `None` if it is out of bounds.
-    #[inline]
-    fn byte_at(&self, offset: usize) -> Option<u8> {
-        self.source.as_bytes().get(self.position + offset).copied()
-    }
-
     /// Advances the current position by `n` bytes.
     #[inline]
     fn advance(&mut self, n: usize) {
@@ -589,12 +533,6 @@ impl<'src> JsLexer<'src> {
         }
     }
 
-    /// Returns `true` if the parser is at or passed the end of the file.
-    #[inline]
-    fn is_eof(&self) -> bool {
-        self.position >= self.source.len()
-    }
-
     // Read a `\u{000...}` escape sequence, this expects the cur char to be the `{`
     fn read_codepoint_escape(&mut self) -> Result<char, ()> {
         let start = self.position + 1;

crates/biome_parser/src/lexer.rs

@@ -233,6 +233,32 @@ pub trait Lexer<'src> {
             None
         }
     }
+
+    /// Get the UTF8 char which starts at the current byte
+    ///
+    /// ## Safety
+    /// Must be called at a valid UT8 char boundary
+    #[inline]
+    fn current_char_unchecked(&self) -> char {
+        // Precautionary measure for making sure the unsafe code below does not
+        // read over memory boundary.
+        debug_assert!(!self.is_eof());
+        self.assert_current_char_boundary();
+
+        // Safety: We know this is safe because we require the input to the
+        // lexer to be valid utf8 and we always call this when we are at a char.
+        unsafe {
+            let Some(chr) = self
+                .source()
+                .get_unchecked(self.position()..self.source().len())
+                .chars()
+                .next()
+            else {
+                core::hint::unreachable_unchecked();
+            };
+            chr
+        }
+    }
 }
 
 /// `LexContext` is a trait that represents the context in