make suggested changes

 - factor out code that determines whether the string beggining with `e_`
   is an exponent or the start of the suffix
 - reduce use of mutable state

Author: richard-uk1

compiler/rustc_lexer/src/lib.rs

@@ -659,53 +659,30 @@ impl Cursor<'_> {
                 // might have stuff after the ., and if it does, it needs to start
                 // with a number
                 self.bump();
+                if !self.first().is_ascii_digit() {
+                    return (Float { base, empty_exponent: false }, None);
+                }
+                self.eat_decimal_digits();
+
                 let mut empty_exponent = false;
-                let mut suffix_start = None;
-                if self.first().is_ascii_digit() {
-                    self.eat_decimal_digits();
-                    // This will be the start of the suffix if there is no exponent
-                    suffix_start = Some(self.pos_within_token());
-                    match (self.first(), self.second()) {
-                        ('e' | 'E', '_') => {
-                            // check if series of `_` is ended by a digit. If yes
-                            // include it in the number as exponent. If no include
-                            // it in suffix.
-                            self.bump();
-                            while matches!(self.first(), '_') {
-                                self.bump();
-                            }
-                            // If we find a digit, then the exponential was valid
-                            // so the suffix will start at the cursor as usual.
-                            if self.first().is_ascii_digit() {
-                                self.eat_decimal_digits();
-                                suffix_start = None;
-                            }
-                        }
-                        ('e' | 'E', '0'..='9' | '+' | '-') => {
-                            // Definitely an exponent (which still can be empty).
-                            self.bump();
-                            empty_exponent = !self.eat_float_exponent();
-                            suffix_start = None;
-                        }
-                        _ => (),
+                let suffix_start = match (self.first(), self.second()) {
+                    ('e' | 'E', '_') => self.eat_underscore_exponent(),
+                    ('e' | 'E', '0'..='9' | '+' | '-') => {
+                        // Definitely an exponent (which still can be empty).
+                        self.bump();
+                        empty_exponent = !self.eat_float_exponent();
+                        None
                     }
-                }
+                    _ => Some(self.pos_within_token()),
+                };
                 (Float { base, empty_exponent }, suffix_start)
             }
             ('e' | 'E', '_') => {
-                // See above block for similar approach.
-                let non_exponent_suffix_start = self.pos_within_token();
-                self.bump();
-                while matches!(self.first(), '_') {
-                    self.bump();
-                }
-                if self.first().is_ascii_digit() {
-                    self.eat_decimal_digits();
-                    (Float { base, empty_exponent: false }, None)
+                if let Some(suffix_start) = self.eat_underscore_exponent() {
+                    // The suffix begins at `e`, meaning the number is an integer.
+                    (Int { base, empty_int: false }, Some(suffix_start))
                 } else {
-                    // No digit means the suffix begins at `e`, meaning the number
-                    // is an integer.
-                    (Int { base, empty_int: false }, Some(non_exponent_suffix_start))
+                    (Float { base, empty_exponent: false }, None)
                 }
             }
             ('e' | 'E', '0'..='9' | '+' | '-') => {
@@ -718,6 +695,35 @@ impl Cursor<'_> {
         }
     }
 
+    /// Try to find and eat an exponent
+    ///
+    /// Assumes the first character is `e`/`E` and second is `_`, and consumes
+    /// `e`/`E` followed by all consecutive `_`s.
+    ///
+    /// Returns `Some` if no exponent was found. In this case, the suffix is partially
+    /// consumed, and began at the return value.
+    fn eat_underscore_exponent(&mut self) -> Option<u32> {
+        debug_assert!(matches!(self.first(), 'e' | 'E'));
+        debug_assert!(matches!(self.second(), '_'));
+        let suffix_start = self.pos_within_token();
+
+        // check if series of `_` is ended by a digit. If yes
+        // include it in the number as exponent. If no include
+        // it in suffix.
+        self.bump();
+        while matches!(self.first(), '_') {
+            self.bump();
+        }
+        // If we find a digit, then the exponential was valid
+        // so the suffix will start at the cursor as usual.
+        if self.first().is_ascii_digit() {
+            self.eat_decimal_digits();
+            None
+        } else {
+            Some(suffix_start)
+        }
+    }
+
     fn lifetime_or_char(&mut self) -> TokenKind {
         debug_assert!(self.prev() == '\'');
 
@@ -1009,23 +1015,18 @@ impl Cursor<'_> {
     }
 
     /// Eats the suffix of the literal, e.g. "u8".
-    ///
-    /// Returns `true` if anything was eaten.
-    fn eat_literal_suffix(&mut self) -> bool {
+    fn eat_literal_suffix(&mut self) {
         self.eat_identifier()
     }
 
     /// Eats the identifier. Note: succeeds on `_`, which isn't a valid
     /// identifier.
-    ///
-    /// Returns `true` if anything was eaten.
-    fn eat_identifier(&mut self) -> bool {
+    fn eat_identifier(&mut self) {
         if !is_id_start(self.first()) {
-            return false;
+            return;
         }
         self.bump();
 
         self.eat_while(is_id_continue);
-        true
     }
 }