Introduce LitKind::suffix

Author: camsteffen

compiler/rustc_ast/src/ast.rs

@@ -1872,28 +1872,24 @@ impl LitKind {
         matches!(self, LitKind::Int(..) | LitKind::Float(..))
     }
 
-    /// Returns `true` if this literal has no suffix.
-    /// Note: this will return true for literals with prefixes such as raw strings and byte strings.
-    pub fn is_unsuffixed(&self) -> bool {
-        !self.is_suffixed()
-    }
-
-    /// Returns `true` if this literal has a suffix.
-    pub fn is_suffixed(&self) -> bool {
+    pub fn suffix(&self) -> Option<Symbol> {
         match *self {
-            // suffixed variants
-            LitKind::Int(_, LitIntType::Signed(..) | LitIntType::Unsigned(..))
-            | LitKind::Float(_, LitFloatType::Suffixed(..)) => true,
-            // unsuffixed variants
+            LitKind::Int(_, kind) => match kind {
+                LitIntType::Signed(ty) => Some(ty.name()),
+                LitIntType::Unsigned(ty) => Some(ty.name()),
+                LitIntType::Unsuffixed => None,
+            },
+            LitKind::Float(_, kind) => match kind {
+                LitFloatType::Suffixed(ty) => Some(ty.name()),
+                LitFloatType::Unsuffixed => None,
+            },
             LitKind::Str(..)
             | LitKind::ByteStr(..)
             | LitKind::CStr(..)
             | LitKind::Byte(..)
             | LitKind::Char(..)
-            | LitKind::Int(_, LitIntType::Unsuffixed)
-            | LitKind::Float(_, LitFloatType::Unsuffixed)
             | LitKind::Bool(..)
-            | LitKind::Err => false,
+            | LitKind::Err => None,
         }
     }
 }

compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs

@@ -2806,7 +2806,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             },
         ));
         let literal_is_ty_suffixed = |expr: &hir::Expr<'_>| {
-            if let hir::ExprKind::Lit(lit) = &expr.kind { lit.node.is_suffixed() } else { false }
+            if let hir::ExprKind::Lit(lit) = &expr.kind {
+                lit.node.suffix().is_some()
+            } else {
+                false
+            }
         };
         let is_negative_int =
             |expr: &hir::Expr<'_>| matches!(expr.kind, hir::ExprKind::Unary(hir::UnOp::Neg, ..));

compiler/rustc_parse/src/parser/attr.rs

@@ -326,7 +326,7 @@ impl<'a> Parser<'a> {
         let lit = self.parse_meta_item_lit()?;
         debug!("checking if {:?} is unsuffixed", lit);
 
-        if !lit.kind.is_unsuffixed() {
+        if lit.kind.suffix().is_some() {
             self.dcx().emit_err(SuffixedLiteralInAttribute { span: lit.span });
         }
 

src/tools/clippy/clippy_lints/src/redundant_type_annotations.rs

@@ -197,7 +197,7 @@ impl LateLintPass<'_> for RedundantTypeAnnotations {
                         },
                         LitKind::Int(..) | LitKind::Float(..) => {
                             // If the initialization value is a suffixed literal we lint
-                            if init_lit.node.is_suffixed() {
+                            if init_lit.node.suffix().is_some() {
                                 span_lint(cx, REDUNDANT_TYPE_ANNOTATIONS, local.span, "redundant type annotation");
                             }
                         },