1 files changed, 0 insertions, 166 deletions

diff --git a/crates/libsyntax2/src/lexer/ptr.rs b/crates/libsyntax2/src/lexer/ptr.rs
deleted file mode 100644
index c9a5354ea..000000000
--- a/crates/libsyntax2/src/lexer/ptr.rs
+++ /dev/null
@@ -1,166 +0,0 @@
-use TextUnit;
-
-use std::str::Chars;
-
-/// A simple view into the characters of a string.
-pub(crate) struct Ptr<'s> {
-    text: &'s str,
-    len: TextUnit,
-}
-
-impl<'s> Ptr<'s> {
-    /// Creates a new `Ptr` from a string.
-    pub fn new(text: &'s str) -> Ptr<'s> {
-        Ptr {
-            text,
-            len: 0.into(),
-        }
-    }
-
-    /// Gets the length of the remaining string.
-    pub fn into_len(self) -> TextUnit {
-        self.len
-    }
-
-    /// Gets the current character, if one exists.
-    pub fn current(&self) -> Option<char> {
-        self.chars().next()
-    }
-
-    /// Gets the nth character from the current.
-    /// For example, 0 will return the current token, 1 will return the next, etc.
-    pub fn nth(&self, n: u32) -> Option<char> {
-        let mut chars = self.chars().peekable();
-        chars.by_ref().skip(n as usize).next()
-    }
-
-    /// Checks whether the current character is `c`.
-    pub fn at(&self, c: char) -> bool {
-        self.current() == Some(c)
-    }
-
-    /// Checks whether the next characters match `s`.
-    pub fn at_str(&self, s: &str) -> bool {
-        let chars = self.chars();
-        chars.as_str().starts_with(s)
-    }
-
-    /// Checks whether the current character satisfies the predicate `p`.
-    pub fn at_p<P: Fn(char) -> bool>(&self, p: P) -> bool {
-        self.current().map(p) == Some(true)
-    }
-
-    /// Checks whether the nth character satisfies the predicate `p`.
-    pub fn nth_is_p<P: Fn(char) -> bool>(&self, n: u32, p: P) -> bool {
-        self.nth(n).map(p) == Some(true)
-    }
-
-    /// Moves to the next character.
-    pub fn bump(&mut self) -> Option<char> {
-        let ch = self.chars().next()?;
-        self.len += TextUnit::of_char(ch);
-        Some(ch)
-    }
-
-    /// Moves to the next character as long as `pred` is satisfied.
-    pub fn bump_while<F: Fn(char) -> bool>(&mut self, pred: F) {
-        loop {
-            match self.current() {
-                Some(c) if pred(c) => {
-                    self.bump();
-                }
-                _ => return,
-            }
-        }
-    }
-
-    /// Returns the text up to the current point.
-    pub fn current_token_text(&self) -> &str {
-        let len: u32 = self.len.into();
-        &self.text[..len as usize]
-    }
-
-    /// Returns an iterator over the remaining characters.
-    fn chars(&self) -> Chars {
-        let len: u32 = self.len.into();
-        self.text[len as usize..].chars()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_current() {
-        let ptr = Ptr::new("test");
-        assert_eq!(ptr.current(), Some('t'));
-    }
-
-    #[test]
-    fn test_nth() {
-        let ptr = Ptr::new("test");
-        assert_eq!(ptr.nth(0), Some('t'));
-        assert_eq!(ptr.nth(1), Some('e'));
-        assert_eq!(ptr.nth(2), Some('s'));
-        assert_eq!(ptr.nth(3), Some('t'));
-        assert_eq!(ptr.nth(4), None);
-    }
-
-    #[test]
-    fn test_at() {
-        let ptr = Ptr::new("test");
-        assert!(ptr.at('t'));
-        assert!(!ptr.at('a'));
-    }
-
-    #[test]
-    fn test_at_str() {
-        let ptr = Ptr::new("test");
-        assert!(ptr.at_str("t"));
-        assert!(ptr.at_str("te"));
-        assert!(ptr.at_str("test"));
-        assert!(!ptr.at_str("tests"));
-        assert!(!ptr.at_str("rust"));
-    }
-
-    #[test]
-    fn test_at_p() {
-        let ptr = Ptr::new("test");
-        assert!(ptr.at_p(|c| c == 't'));
-        assert!(!ptr.at_p(|c| c == 'e'));
-    }
-
-    #[test]
-    fn test_nth_is_p() {
-        let ptr = Ptr::new("test");
-        assert!(ptr.nth_is_p(0,|c| c == 't'));
-        assert!(!ptr.nth_is_p(1,|c| c == 't'));
-        assert!(ptr.nth_is_p(3,|c| c == 't'));
-        assert!(!ptr.nth_is_p(150,|c| c == 't'));
-    }
-
-    #[test]
-    fn test_bump() {
-        let mut ptr = Ptr::new("test");
-        assert_eq!(ptr.current(), Some('t'));
-        ptr.bump();
-        assert_eq!(ptr.current(), Some('e'));
-        ptr.bump();
-        assert_eq!(ptr.current(), Some('s'));
-        ptr.bump();
-        assert_eq!(ptr.current(), Some('t'));
-        ptr.bump();
-        assert_eq!(ptr.current(), None);
-        ptr.bump();
-        assert_eq!(ptr.current(), None);
-    }
-
-    #[test]
-    fn test_bump_while() {
-        let mut ptr = Ptr::new("test");
-        assert_eq!(ptr.current(), Some('t'));
-        ptr.bump_while(|c| c != 's');
-        assert_eq!(ptr.current(), Some('s'));
-    }
-}