Simplified cursor.rs a bit and renamed first to peek and eat_while to bump_while.

Julian Wollersberger · Julian Wollersberger · commit 629e161527a2 · 2021-03-04T12:22:31.000+01:00
diff --git a/compiler/rustc_lexer/src/cursor.rs b/compiler/rustc_lexer/src/cursor.rs
@@ -2,7 +2,7 @@ use std::str::Chars;
 
 /// Peekable iterator over a char sequence.
 ///
-/// Next characters can be peeked via `nth_char` method,
+/// Next characters can be peeked via `peek` method,
 /// and position can be shifted forward via `bump` method.
 pub(crate) struct Cursor<'a> {
     initial_len: usize,
@@ -37,22 +37,17 @@ impl<'a> Cursor<'a> {
         }
     }
 
-    /// Returns nth character relative to the current cursor position.
-    /// If requested position doesn't exist, `EOF_CHAR` is returned.
+    /// Peeks the next symbol from the input stream without consuming it.
+    /// If it doesn't exist, `EOF_CHAR` is returned.
     /// However, getting `EOF_CHAR` doesn't always mean actual end of file,
     /// it should be checked with `is_eof` method.
-    fn nth_char(&self, n: usize) -> char {
-        self.chars().nth(n).unwrap_or(EOF_CHAR)
-    }
-
-    /// Peeks the next symbol from the input stream without consuming it.
-    pub(crate) fn first(&self) -> char {
-        self.nth_char(0)
+    pub(crate) fn peek(&self) -> char {
+        self.chars.clone().nth(0).unwrap_or(EOF_CHAR)
     }
 
     /// Peeks the second symbol from the input stream without consuming it.
-    pub(crate) fn second(&self) -> char {
-        self.nth_char(1)
+    pub(crate) fn peek_second(&self) -> char {
+        self.chars.clone().nth(1).unwrap_or(EOF_CHAR)
     }
 
     /// Checks if there is nothing more to consume.
@@ -65,11 +60,6 @@ impl<'a> Cursor<'a> {
         self.initial_len - self.chars.as_str().len()
     }
 
-    /// Returns a `Chars` iterator over the remaining characters.
-    fn chars(&self) -> Chars<'a> {
-        self.chars.clone()
-    }
-
     /// Moves to the next character.
     pub(crate) fn bump(&mut self) -> Option<char> {
         let c = self.chars.next()?;
@@ -83,8 +73,8 @@ impl<'a> Cursor<'a> {
     }
 
     /// Eats symbols while predicate returns true or until the end of file is reached.
-    pub(crate) fn eat_while(&mut self, mut predicate: impl FnMut(char) -> bool) {
-        while predicate(self.first()) && !self.is_eof() {
+    pub(crate) fn bump_while(&mut self, mut predicate: impl FnMut(char) -> bool) {
+        while predicate(self.peek()) && !self.is_eof() {
             self.bump();
         }
     }
diff --git a/compiler/rustc_lexer/src/lib.rs b/compiler/rustc_lexer/src/lib.rs
@@ -255,7 +255,7 @@ fn advance_token(cursor: &mut Cursor) -> Token {
     let first_char = cursor.bump().unwrap();
     let token_kind = match first_char {
         // Slash, comment or block comment.
-        '/' => match cursor.first() {
+        '/' => match cursor.peek() {
             '/' => line_comment(cursor),
             '*' => block_comment(cursor),
             _ => Slash,
@@ -265,7 +265,7 @@ fn advance_token(cursor: &mut Cursor) -> Token {
         c if is_whitespace(c) => whitespace(cursor),
 
         // Raw identifier, raw string literal or identifier.
-        'r' => match (cursor.first(), cursor.second()) {
+        'r' => match (cursor.peek(), cursor.peek_second()) {
             ('#', c1) if is_id_start(c1) => raw_ident(cursor),
             ('#', _) | ('"', _) => {
                 let (n_hashes, err) = raw_double_quoted_string(cursor, 1);
@@ -280,7 +280,7 @@ fn advance_token(cursor: &mut Cursor) -> Token {
         },
 
         // Byte literal, byte string literal, raw byte string literal or identifier.
-        'b' => match (cursor.first(), cursor.second()) {
+        'b' => match (cursor.peek(), cursor.peek_second()) {
             ('\'', _) => {
                 cursor.bump();
                 let terminated = single_quoted_string(cursor);
@@ -373,42 +373,42 @@ fn advance_token(cursor: &mut Cursor) -> Token {
 }
 
 fn line_comment(cursor: &mut Cursor) -> TokenKind {
-    debug_assert!(cursor.prev() == '/' && cursor.first() == '/');
+    debug_assert!(cursor.prev() == '/' && cursor.peek() == '/');
     cursor.bump();
 
-    let doc_style = match cursor.first() {
+    let doc_style = match cursor.peek() {
         // `//!` is an inner line doc comment.
         '!' => Some(DocStyle::Inner),
         // `////` (more than 3 slashes) is not considered a doc comment.
-        '/' if cursor.second() != '/' => Some(DocStyle::Outer),
+        '/' if cursor.peek_second() != '/' => Some(DocStyle::Outer),
         _ => None,
     };
 
-    cursor.eat_while(|c| c != '\n');
+    cursor.bump_while(|c| c != '\n');
     LineComment { doc_style }
 }
 
 fn block_comment(cursor: &mut Cursor) -> TokenKind {
-    debug_assert!(cursor.prev() == '/' && cursor.first() == '*');
+    debug_assert!(cursor.prev() == '/' && cursor.peek() == '*');
     cursor.bump();
 
-    let doc_style = match cursor.first() {
+    let doc_style = match cursor.peek() {
         // `/*!` is an inner block doc comment.
         '!' => Some(DocStyle::Inner),
         // `/***` (more than 2 stars) is not considered a doc comment.
         // `/**/` is not considered a doc comment.
-        '*' if !matches!(cursor.second(), '*' | '/') => Some(DocStyle::Outer),
+        '*' if !matches!(cursor.peek_second(), '*' | '/') => Some(DocStyle::Outer),
         _ => None,
     };
 
     let mut depth = 1usize;
     while let Some(c) = cursor.bump() {
         match c {
-            '/' if cursor.first() == '*' => {
+            '/' if cursor.peek() == '*' => {
                 cursor.bump();
                 depth += 1;
             }
-            '*' if cursor.first() == '/' => {
+            '*' if cursor.peek() == '/' => {
                 cursor.bump();
                 depth -= 1;
                 if depth == 0 {
@@ -427,12 +427,12 @@ fn block_comment(cursor: &mut Cursor) -> TokenKind {
 
 fn whitespace(cursor: &mut Cursor) -> TokenKind {
     debug_assert!(is_whitespace(cursor.prev()));
-    cursor.eat_while(is_whitespace);
+    cursor.bump_while(is_whitespace);
     Whitespace
 }
 
 fn raw_ident(cursor: &mut Cursor) -> TokenKind {
-    debug_assert!(cursor.prev() == 'r' && cursor.first() == '#' && is_id_start(cursor.second()));
+    debug_assert!(cursor.prev() == 'r' && cursor.peek() == '#' && is_id_start(cursor.peek_second()));
     // Eat "#" symbol.
     cursor.bump();
     // Eat the identifier part of RawIdent.
@@ -443,16 +443,16 @@ fn raw_ident(cursor: &mut Cursor) -> TokenKind {
 fn ident(cursor: &mut Cursor) -> TokenKind {
     debug_assert!(is_id_start(cursor.prev()));
     // Start is already eaten, eat the rest of identifier.
-    cursor.eat_while(is_id_continue);
+    cursor.bump_while(is_id_continue);
     Ident
 }
 
 /// Eats one identifier.
 pub(crate) fn eat_identifier(cursor: &mut Cursor) {
-    if !is_id_start(cursor.first()) {
+    if !is_id_start(cursor.peek()) {
         return;
     }
     cursor.bump();
 
-    cursor.eat_while(is_id_continue);
+    cursor.bump_while(is_id_continue);
 }
diff --git a/compiler/rustc_lexer/src/literals.rs b/compiler/rustc_lexer/src/literals.rs
@@ -56,7 +56,7 @@ pub(crate) fn number(cursor: &mut Cursor, first_digit: char) -> LiteralKind {
     let mut base = Base::Decimal;
     if first_digit == '0' {
         // Attempt to parse encoding base.
-        let has_digits = match cursor.first() {
+        let has_digits = match cursor.peek() {
             'b' => {
                 base = Base::Binary;
                 cursor.bump();
@@ -90,18 +90,18 @@ pub(crate) fn number(cursor: &mut Cursor, first_digit: char) -> LiteralKind {
         eat_decimal_digits(cursor);
     };
 
-    match cursor.first() {
+    match cursor.peek() {
         // Don't be greedy if this is actually an
         // integer literal followed by field/method access or a range pattern
         // (`0..2` and `12.foo()`)
-        '.' if cursor.second() != '.' && !is_id_start(cursor.second()) => {
+        '.' if cursor.peek_second() != '.' && !is_id_start(cursor.peek_second()) => {
             // might have stuff after the ., and if it does, it needs to start
             // with a number
             cursor.bump();
             let mut empty_exponent = false;
-            if cursor.first().is_digit(10) {
+            if cursor.peek().is_digit(10) {
                 eat_decimal_digits(cursor);
-                match cursor.first() {
+                match cursor.peek() {
                     'e' | 'E' => {
                         cursor.bump();
                         empty_exponent = !eat_float_exponent(cursor);
@@ -123,7 +123,7 @@ pub(crate) fn number(cursor: &mut Cursor, first_digit: char) -> LiteralKind {
 pub(crate) fn eat_decimal_digits(cursor: &mut Cursor) -> bool {
     let mut has_digits = false;
     loop {
-        match cursor.first() {
+        match cursor.peek() {
             '_' => {
                 cursor.bump();
             }
@@ -140,7 +140,7 @@ pub(crate) fn eat_decimal_digits(cursor: &mut Cursor) -> bool {
 pub(crate) fn eat_hexadecimal_digits(cursor: &mut Cursor) -> bool {
     let mut has_digits = false;
     loop {
-        match cursor.first() {
+        match cursor.peek() {
             '_' => {
                 cursor.bump();
             }
@@ -158,7 +158,7 @@ pub(crate) fn eat_hexadecimal_digits(cursor: &mut Cursor) -> bool {
 /// and returns false otherwise.
 fn eat_float_exponent(cursor: &mut Cursor) -> bool {
     debug_assert!(cursor.prev() == 'e' || cursor.prev() == 'E');
-    if cursor.first() == '-' || cursor.first() == '+' {
+    if cursor.peek() == '-' || cursor.peek() == '+' {
         cursor.bump();
     }
     eat_decimal_digits(cursor)
@@ -167,14 +167,14 @@ fn eat_float_exponent(cursor: &mut Cursor) -> bool {
 pub(crate) fn lifetime_or_char(cursor: &mut Cursor) -> TokenKind {
     debug_assert!(cursor.prev() == '\'');
 
-    let can_be_a_lifetime = if cursor.second() == '\'' {
+    let can_be_a_lifetime = if cursor.peek_second() == '\'' {
         // It's surely not a lifetime.
         false
     } else {
         // If the first symbol is valid for identifier, it can be a lifetime.
         // Also check if it's a number for a better error reporting (so '0 will
         // be reported as invalid lifetime and not as unterminated char literal).
-        is_id_start(cursor.first()) || cursor.first().is_digit(10)
+        is_id_start(cursor.peek()) || cursor.peek().is_digit(10)
     };
 
     if !can_be_a_lifetime {
@@ -190,18 +190,18 @@ pub(crate) fn lifetime_or_char(cursor: &mut Cursor) -> TokenKind {
     // Either a lifetime or a character literal with
     // length greater than 1.
 
-    let starts_with_number = cursor.first().is_digit(10);
+    let starts_with_number = cursor.peek().is_digit(10);
 
     // Skip the literal contents.
     // First symbol can be a number (which isn't a valid identifier start),
     // so skip it without any checks.
     cursor.bump();
-    cursor.eat_while(is_id_continue);
+    cursor.bump_while(is_id_continue);
 
     // Check if after skipping literal contents we've met a closing
     // single quote (which means that user attempted to create a
     // string with single quotes).
-    if cursor.first() == '\'' {
+    if cursor.peek() == '\'' {
         cursor.bump();
         let kind = LiteralKind::Char { terminated: true };
         TokenKind::Literal { kind, suffix_start: cursor.len_consumed() }
@@ -213,7 +213,7 @@ pub(crate) fn lifetime_or_char(cursor: &mut Cursor) -> TokenKind {
 pub(crate) fn single_quoted_string(cursor: &mut Cursor) -> bool {
     debug_assert!(cursor.prev() == '\'');
     // Check if it's a one-symbol literal.
-    if cursor.second() == '\'' && cursor.first() != '\\' {
+    if cursor.peek_second() == '\'' && cursor.peek() != '\\' {
         cursor.bump();
         cursor.bump();
         return true;
@@ -223,7 +223,7 @@ pub(crate) fn single_quoted_string(cursor: &mut Cursor) -> bool {
 
     // Parse until either quotes are terminated or error is detected.
     loop {
-        match cursor.first() {
+        match cursor.peek() {
             // Quotes are terminated, finish parsing.
             '\'' => {
                 cursor.bump();
@@ -233,7 +233,7 @@ pub(crate) fn single_quoted_string(cursor: &mut Cursor) -> bool {
             // to the error report.
             '/' => break,
             // Newline without following '\'' means unclosed quote, stop parsing.
-            '\n' if cursor.second() != '\'' => break,
+            '\n' if cursor.peek_second() != '\'' => break,
             // End of file, stop parsing.
             EOF_CHAR if cursor.is_eof() => break,
             // Escaped slash is considered one character, so bump twice.
@@ -260,7 +260,7 @@ pub(crate) fn double_quoted_string(cursor: &mut Cursor) -> bool {
             '"' => {
                 return true;
             }
-            '\\' if cursor.first() == '\\' || cursor.first() == '"' => {
+            '\\' if cursor.peek() == '\\' || cursor.peek() == '"' => {
                 // Bump again to skip escaped character.
                 cursor.bump();
             }
@@ -295,7 +295,7 @@ fn raw_string_unvalidated(cursor: &mut Cursor, prefix_len: usize) -> (usize, Opt
 
     // Count opening '#' symbols.
     let mut eaten = 0;
-    while cursor.first() == '#' {
+    while cursor.peek() == '#' {
         eaten += 1;
         cursor.bump();
     }
@@ -313,7 +313,7 @@ fn raw_string_unvalidated(cursor: &mut Cursor, prefix_len: usize) -> (usize, Opt
     // Skip the string contents and on each '#' character met, check if this is
     // a raw string termination.
     loop {
-        cursor.eat_while(|c| c != '"');
+        cursor.bump_while(|c| c != '"');
 
         if cursor.is_eof() {
             return (
@@ -335,7 +335,7 @@ fn raw_string_unvalidated(cursor: &mut Cursor, prefix_len: usize) -> (usize, Opt
         // `r###"abcde"####` is lexed as a `RawStr { n_hashes: 3 }`
         // followed by a `#` token.
         let mut n_end_hashes = 0;
-        while cursor.first() == '#' && n_end_hashes < n_start_hashes {
+        while cursor.peek() == '#' && n_end_hashes < n_start_hashes {
             n_end_hashes += 1;
             cursor.bump();
         }
