only return offset when different to default

Co-authored-by: Vadim Petrochenkov <vadim.petrochenkov@gmail.com>

Author: richard-uk1

compiler/rustc_lexer/src/lib.rs

@@ -410,7 +410,10 @@ impl Cursor<'_> {
             // Numeric literal.
             c @ '0'..='9' => {
                 let (literal_kind, suffix_start) = self.number(c);
-                TokenKind::Literal { kind: literal_kind, suffix_start }
+                TokenKind::Literal {
+                    kind: literal_kind,
+                    suffix_start: suffix_start.unwrap_or(self.pos_within_token()),
+                }
             }
 
             // Guarded string literal prefix: `#"` or `##`
@@ -604,9 +607,9 @@ impl Cursor<'_> {
         }
     }
 
-    /// Parses a number and in `.1` returns the offset of the literal suffix
-    /// (this will be at the end of the token if there is no suffix)
-    fn number(&mut self, first_digit: char) -> (LiteralKind, u32) {
+    /// Parses a number and in `.1` returns the offset of the literal suffix if
+    /// different from the output of `.pos_within_token()`.
+    fn number(&mut self, first_digit: char) -> (LiteralKind, Option<u32>) {
         debug_assert!('0' <= self.prev() && self.prev() <= '9');
         let mut base = Base::Decimal;
         if first_digit == '0' {
@@ -617,26 +620,26 @@ impl Cursor<'_> {
                     self.bump();
                     if !self.eat_decimal_digits() {
                         let suffix_start = self.pos_within_token();
-                        self.eat_literal_suffix();
-                        return (Int { base, empty_int: true }, suffix_start);
+                        let offset = self.eat_literal_suffix().then_some(suffix_start);
+                        return (Int { base, empty_int: true }, offset);
                     }
                 }
                 'o' => {
                     base = Base::Octal;
                     self.bump();
                     if !self.eat_decimal_digits() {
                         let suffix_start = self.pos_within_token();
-                        self.eat_literal_suffix();
-                        return (Int { base, empty_int: true }, suffix_start);
+                        let offset = self.eat_literal_suffix().then_some(suffix_start);
+                        return (Int { base, empty_int: true }, offset);
                     }
                 }
                 'x' => {
                     base = Base::Hexadecimal;
                     self.bump();
                     if !self.eat_hexadecimal_digits() {
                         let suffix_start = self.pos_within_token();
-                        self.eat_literal_suffix();
-                        return (Int { base, empty_int: true }, suffix_start);
+                        let offset = self.eat_literal_suffix().then_some(suffix_start);
+                        return (Int { base, empty_int: true }, offset);
                     }
                 }
                 // Not a base prefix; consume additional digits.
@@ -650,8 +653,8 @@ impl Cursor<'_> {
                 // Just a 0.
                 _ => {
                     let suffix_start = self.pos_within_token();
-                    self.eat_literal_suffix();
-                    return (Int { base, empty_int: false }, suffix_start);
+                    let offset = self.eat_literal_suffix().then_some(suffix_start);
+                    return (Int { base, empty_int: false }, offset);
                 }
             }
         } else {
@@ -696,8 +699,8 @@ impl Cursor<'_> {
                         _ => (),
                     }
                 }
-                self.eat_literal_suffix();
-                (Float { base, empty_exponent }, suffix_start)
+                let offset = self.eat_literal_suffix().then_some(suffix_start);
+                (Float { base, empty_exponent }, offset)
             }
             ('e' | 'E', '_') => {
                 // See above block for similar approach.
@@ -710,25 +713,27 @@ impl Cursor<'_> {
                     self.eat_decimal_digits();
                     let suffix_start = self.pos_within_token();
                     self.eat_literal_suffix();
-                    (Float { base, empty_exponent: false }, suffix_start)
+                    let offset = self.eat_literal_suffix().then_some(suffix_start);
+                    (Float { base, empty_exponent: false }, offset)
                 } else {
                     // No digit means suffix, and therefore int
                     self.eat_literal_suffix();
-                    (Int { base, empty_int: false }, non_exponent_suffix_start)
+                    let offset = self.eat_literal_suffix().then_some(non_exponent_suffix_start);
+                    (Int { base, empty_int: false }, offset)
                 }
             }
             ('e' | 'E', '0'..='9' | '+' | '-') => {
                 // // Definitely an exponent (which still can be empty).
                 self.bump();
                 let empty_exponent = !self.eat_float_exponent();
                 let suffix_start = self.pos_within_token();
-                self.eat_literal_suffix();
-                (Float { base, empty_exponent }, suffix_start)
+                let offset = self.eat_literal_suffix().then_some(suffix_start);
+                (Float { base, empty_exponent }, offset)
             }
             _ => {
                 let suffix_start = self.pos_within_token();
-                self.eat_literal_suffix();
-                (Int { base, empty_int: false }, suffix_start)
+                let offset = self.eat_literal_suffix().then_some(suffix_start);
+                (Int { base, empty_int: false }, offset)
             }
         }
     }
@@ -1023,19 +1028,24 @@ impl Cursor<'_> {
         self.eat_decimal_digits()
     }
 
-    // Eats the suffix of the literal, e.g. "u8".
-    fn eat_literal_suffix(&mut self) {
-        self.eat_identifier();
+    /// Eats the suffix of the literal, e.g. "u8".
+    ///
+    /// Returns `true` if anything was eaten.
+    fn eat_literal_suffix(&mut self) -> bool {
+        self.eat_identifier()
     }
 
-    // Eats the identifier. Note: succeeds on `_`, which isn't a valid
-    // identifier.
-    fn eat_identifier(&mut self) {
+    /// Eats the identifier. Note: succeeds on `_`, which isn't a valid
+    /// identifier.
+    ///
+    /// Returns `true` if anything was eaten.
+    fn eat_identifier(&mut self) -> bool {
         if !is_id_start(self.first()) {
-            return;
+            return false;
         }
         self.bump();
 
         self.eat_while(is_id_continue);
+        true
     }
 }