Use an enum for the sign instead of a bool

Author: oli-obk

compiler/rustc_ast/src/ast.rs

@@ -1869,18 +1869,31 @@ impl StrLit {
     }
 }
 
+#[derive(Clone, Copy, Encodable, Decodable, Debug, Hash, Eq, PartialEq)]
+#[derive(HashStable_Generic)]
+pub enum Sign {
+    /// A `-` in front of a literal.
+    Neg,
+    /// No sign. There are no leading `+` in front of literals.
+    None,
+}
+
+impl Sign {
+    pub fn is_neg(&self) -> bool {
+        matches!(self, Self::Neg)
+    }
+}
+
 /// Type of the integer literal based on provided suffix.
 #[derive(Clone, Copy, Encodable, Decodable, Debug, Hash, Eq, PartialEq)]
 #[derive(HashStable_Generic)]
 pub enum LitIntType {
     /// e.g. `42_i32`.
-    /// The bool signals whether the literal is negated
-    Signed(IntTy, bool),
+    Signed(IntTy, Sign),
     /// e.g. `42_u32`.
     Unsigned(UintTy),
     /// e.g. `42`.
-    /// The bool signals whether the literal is negated
-    Unsuffixed(bool),
+    Unsuffixed(Sign),
 }
 
 /// Type of the float literal based on provided suffix.
@@ -1975,8 +1988,8 @@ impl LitKind {
 
     pub fn is_negative(&self) -> bool {
         match self {
-            LitKind::Int(_, LitIntType::Signed(_, negative) | LitIntType::Unsuffixed(negative)) => {
-                *negative
+            LitKind::Int(_, LitIntType::Signed(_, sign) | LitIntType::Unsuffixed(sign)) => {
+                sign.is_neg()
             }
             LitKind::Float(f, _) => f.as_str().starts_with('-'),
             _ => false,

compiler/rustc_ast/src/util/literal.rs

@@ -8,6 +8,7 @@ use rustc_lexer::unescape::{
 use rustc_span::{Span, Symbol, kw, sym};
 use tracing::debug;
 
+use crate::Sign;
 use crate::ast::{self, LitKind, MetaItemLit, StrStyle};
 use crate::token::{self, Token};
 
@@ -44,24 +45,21 @@ pub enum LitError {
 impl LitKind {
     /// Converts literal token into a semantic literal.
     pub fn from_token_lit(lit: token::Lit) -> Result<LitKind, LitError> {
-        Self::from_token_lit_maybe_negated(lit, false)
+        Self::from_token_lit_maybe_negated(lit, Sign::None)
     }
 
     /// Converts literal token into a semantic literal.
     /// May optionally include a sign, and will error if a literal
     /// other than integer or float literals is negated.
-    pub fn from_token_lit_maybe_negated(
-        lit: token::Lit,
-        negated: bool,
-    ) -> Result<LitKind, LitError> {
+    pub fn from_token_lit_maybe_negated(lit: token::Lit, sign: Sign) -> Result<LitKind, LitError> {
         let token::Lit { kind, symbol, suffix } = lit;
         if let Some(suffix) = suffix
             && !kind.may_have_suffix()
         {
             return Err(LitError::InvalidSuffix(suffix));
         }
 
-        if negated && !matches!(kind, token::Integer | token::Float) {
+        if sign.is_neg() && !matches!(kind, token::Integer | token::Float) {
             return Err(LitError::InvalidNegation(kind));
         }
 
@@ -86,8 +84,8 @@ impl LitKind {
 
             // There are some valid suffixes for integer and float literals,
             // so all the handling is done internally.
-            token::Integer => return integer_lit(symbol, suffix, negated),
-            token::Float => return float_lit(symbol, suffix, negated),
+            token::Integer => return integer_lit(symbol, suffix, sign),
+            token::Float => return float_lit(symbol, suffix, sign),
 
             token::Str => {
                 // If there are no characters requiring special treatment we can
@@ -206,14 +204,14 @@ impl fmt::Display for LitKind {
             }
             LitKind::Int(n, ty) => match ty {
                 ast::LitIntType::Unsigned(ty) => write!(f, "{n}{}", ty.name())?,
-                ast::LitIntType::Signed(ty, negated) => {
-                    if negated {
+                ast::LitIntType::Signed(ty, sign) => {
+                    if sign.is_neg() {
                         write!(f, "-")?;
                     }
                     write!(f, "{n}{}", ty.name())?
                 }
-                ast::LitIntType::Unsuffixed(negated) => {
-                    if negated {
+                ast::LitIntType::Unsuffixed(sign) => {
+                    if sign.is_neg() {
                         write!(f, "-")?;
                     }
                     write!(f, "{n}")?;
@@ -291,13 +289,14 @@ fn filtered_float_lit(
     symbol: Symbol,
     suffix: Option<Symbol>,
     base: u32,
-    negated: bool,
+    sign: Sign,
 ) -> Result<LitKind, LitError> {
-    debug!(?symbol, ?suffix, ?base, ?negated);
+    debug!(?symbol, ?suffix, ?base, ?sign);
     if base != 10 {
         return Err(LitError::NonDecimalFloat(base));
     }
-    let symbol = if negated { Symbol::intern(&format!("-{}", symbol.as_str())) } else { symbol };
+    let symbol =
+        if sign.is_neg() { Symbol::intern(&format!("-{}", symbol.as_str())) } else { symbol };
     Ok(match suffix {
         Some(suffix) => LitKind::Float(
             symbol,
@@ -313,12 +312,12 @@ fn filtered_float_lit(
     })
 }
 
-fn float_lit(symbol: Symbol, suffix: Option<Symbol>, negated: bool) -> Result<LitKind, LitError> {
+fn float_lit(symbol: Symbol, suffix: Option<Symbol>, sign: Sign) -> Result<LitKind, LitError> {
     debug!("float_lit: {:?}, {:?}", symbol, suffix);
-    filtered_float_lit(strip_underscores(symbol), suffix, 10, negated)
+    filtered_float_lit(strip_underscores(symbol), suffix, 10, sign)
 }
 
-fn integer_lit(symbol: Symbol, suffix: Option<Symbol>, negated: bool) -> Result<LitKind, LitError> {
+fn integer_lit(symbol: Symbol, suffix: Option<Symbol>, sign: Sign) -> Result<LitKind, LitError> {
     debug!("integer_lit: {:?}, {:?}", symbol, suffix);
     let symbol = strip_underscores(symbol);
     let s = symbol.as_str();
@@ -332,12 +331,12 @@ fn integer_lit(symbol: Symbol, suffix: Option<Symbol>, negated: bool) -> Result<
 
     let ty = match suffix {
         Some(suf) => match suf {
-            sym::isize => ast::LitIntType::Signed(ast::IntTy::Isize, negated),
-            sym::i8 => ast::LitIntType::Signed(ast::IntTy::I8, negated),
-            sym::i16 => ast::LitIntType::Signed(ast::IntTy::I16, negated),
-            sym::i32 => ast::LitIntType::Signed(ast::IntTy::I32, negated),
-            sym::i64 => ast::LitIntType::Signed(ast::IntTy::I64, negated),
-            sym::i128 => ast::LitIntType::Signed(ast::IntTy::I128, negated),
+            sym::isize => ast::LitIntType::Signed(ast::IntTy::Isize, sign),
+            sym::i8 => ast::LitIntType::Signed(ast::IntTy::I8, sign),
+            sym::i16 => ast::LitIntType::Signed(ast::IntTy::I16, sign),
+            sym::i32 => ast::LitIntType::Signed(ast::IntTy::I32, sign),
+            sym::i64 => ast::LitIntType::Signed(ast::IntTy::I64, sign),
+            sym::i128 => ast::LitIntType::Signed(ast::IntTy::I128, sign),
             sym::usize => ast::LitIntType::Unsigned(ast::UintTy::Usize),
             sym::u8 => ast::LitIntType::Unsigned(ast::UintTy::U8),
             sym::u16 => ast::LitIntType::Unsigned(ast::UintTy::U16),
@@ -347,14 +346,14 @@ fn integer_lit(symbol: Symbol, suffix: Option<Symbol>, negated: bool) -> Result<
             // `1f64` and `2f32` etc. are valid float literals, and
             // `fxxx` looks more like an invalid float literal than invalid integer literal.
             _ if suf.as_str().starts_with('f') => {
-                return filtered_float_lit(symbol, suffix, base, negated);
+                return filtered_float_lit(symbol, suffix, base, sign);
             }
             _ => return Err(LitError::InvalidIntSuffix(suf)),
         },
-        _ => ast::LitIntType::Unsuffixed(negated),
+        _ => ast::LitIntType::Unsuffixed(sign),
     };
     if let ast::LitIntType::Unsigned(_) = ty
-        && negated
+        && sign.is_neg()
     {
         return Err(LitError::InvalidNegation(token::Integer));
     }

compiler/rustc_ast_lowering/src/expr.rs

@@ -142,7 +142,11 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         if let ExprKind::Lit(token_lit) = &ohs.kind {
                             return hir::Expr {
                                 hir_id: expr_hir_id,
-                                kind: hir::ExprKind::Lit(self.lower_lit(token_lit, e.span, true)),
+                                kind: hir::ExprKind::Lit(self.lower_lit(
+                                    token_lit,
+                                    e.span,
+                                    Sign::Neg,
+                                )),
                                 span: self.lower_span(e.span),
                             };
                         }
@@ -152,7 +156,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     hir::ExprKind::Unary(op, ohs)
                 }
                 ExprKind::Lit(token_lit) => {
-                    hir::ExprKind::Lit(self.lower_lit(token_lit, e.span, false))
+                    hir::ExprKind::Lit(self.lower_lit(token_lit, e.span, Sign::None))
                 }
                 ExprKind::IncludedBytes(bytes) => {
                     let lit = self.arena.alloc(respan(
@@ -430,9 +434,9 @@ impl<'hir> LoweringContext<'_, 'hir> {
         &mut self,
         token_lit: &token::Lit,
         span: Span,
-        negated: bool,
+        sign: Sign,
     ) -> &'hir Spanned<LitKind> {
-        let lit_kind = match LitKind::from_token_lit_maybe_negated(*token_lit, negated) {
+        let lit_kind = match LitKind::from_token_lit_maybe_negated(*token_lit, sign) {
             Ok(lit_kind) => lit_kind,
             Err(err) => {
                 let guar = report_lit_error(&self.tcx.sess.psess, err, *token_lit, span);

compiler/rustc_ast_lowering/src/format.rs

@@ -30,11 +30,13 @@ impl<'hir> LoweringContext<'_, 'hir> {
             Ok(LitKind::Int(n, ty)) => {
                 match ty {
                     // unsuffixed integer literals are assumed to be i32's
-                    LitIntType::Unsuffixed(negated) => (!negated && n <= i32::MAX as u128)
+                    LitIntType::Unsuffixed(sign) => (matches!(sign, Sign::None)
+                        && n <= i32::MAX as u128)
                         .then_some(Symbol::intern(&n.to_string())),
-                    LitIntType::Signed(int_ty, negated) => {
+                    LitIntType::Signed(int_ty, sign) => {
                         let max_literal = self.int_ty_max(int_ty);
-                        (!negated && n <= max_literal).then_some(Symbol::intern(&n.to_string()))
+                        (matches!(sign, Sign::None) && n <= max_literal)
+                            .then_some(Symbol::intern(&n.to_string()))
                     }
                     LitIntType::Unsigned(uint_ty) => {
                         let max_literal = self.uint_ty_max(uint_ty);

compiler/rustc_ast_lowering/src/pat.rs

@@ -393,7 +393,9 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             lit: self.arena.alloc(respan(span, LitKind::Err(guar))),
         };
         let kind = match &expr.kind {
-            ExprKind::Lit(lit) => hir::PatExprKind::Lit { lit: self.lower_lit(lit, span, false) },
+            ExprKind::Lit(lit) => {
+                hir::PatExprKind::Lit { lit: self.lower_lit(lit, span, Sign::None) }
+            }
             ExprKind::ConstBlock(c) => hir::PatExprKind::ConstBlock(self.lower_const_block(c)),
             ExprKind::IncludedBytes(bytes) => hir::PatExprKind::Lit {
                 lit: self
@@ -412,7 +414,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 None,
             )),
             ExprKind::Unary(UnOp::Neg, inner) if let ExprKind::Lit(lit) = &inner.kind => {
-                hir::PatExprKind::Lit { lit: self.lower_lit(lit, span, true) }
+                hir::PatExprKind::Lit { lit: self.lower_lit(lit, span, Sign::Neg) }
             }
             _ => {
                 let pattern_from_macro = expr.is_approximately_pattern();

compiler/rustc_attr_parsing/src/attributes/repr.rs

@@ -1,5 +1,5 @@
 use rustc_abi::Align;
-use rustc_ast::{IntTy, LitIntType, LitKind, UintTy};
+use rustc_ast::{IntTy, LitIntType, LitKind, Sign, UintTy};
 use rustc_attr_data_structures::{AttributeKind, IntType, ReprAttr};
 use rustc_span::{Span, Symbol, sym};
 
@@ -225,7 +225,7 @@ fn parse_repr_align(
 }
 
 fn parse_alignment(node: &LitKind) -> Result<Align, &'static str> {
-    if let LitKind::Int(literal, LitIntType::Unsuffixed(false)) = node {
+    if let LitKind::Int(literal, LitIntType::Unsuffixed(Sign::None)) = node {
         // `Align::from_bytes` accepts 0 as an input, check is_power_of_two() first
         if literal.get().is_power_of_two() {
             // Only possible error is larger than 2^29

compiler/rustc_attr_parsing/src/session_diagnostics.rs

@@ -343,10 +343,10 @@ pub(crate) enum IncorrectReprFormatGenericCause<'a> {
 impl<'a> IncorrectReprFormatGenericCause<'a> {
     pub(crate) fn from_lit_kind(span: Span, kind: &ast::LitKind, name: &'a str) -> Option<Self> {
         match *kind {
-            ast::LitKind::Int(int, ast::LitIntType::Unsuffixed(negated)) => Some(Self::Int {
+            ast::LitKind::Int(int, ast::LitIntType::Unsuffixed(sign)) => Some(Self::Int {
                 span,
                 name,
-                int: if negated { format!("-{}", int.get()) } else { int.get().to_string() },
+                int: if sign.is_neg() { format!("-{}", int.get()) } else { int.get().to_string() },
             }),
             ast::LitKind::Str(symbol, _) => Some(Self::Symbol { span, name, symbol }),
             _ => None,

compiler/rustc_builtin_macros/src/concat_bytes.rs

@@ -1,6 +1,6 @@
 use rustc_ast::ptr::P;
 use rustc_ast::tokenstream::TokenStream;
-use rustc_ast::{ExprKind, LitIntType, LitKind, UintTy, token};
+use rustc_ast::{ExprKind, LitIntType, LitKind, Sign, UintTy, token};
 use rustc_expand::base::{DummyResult, ExpandResult, ExtCtxt, MacEager, MacroExpanderResult};
 use rustc_session::errors::report_lit_error;
 use rustc_span::{ErrorGuaranteed, Span};
@@ -51,7 +51,10 @@ fn invalid_type_err(
                 snippet.map(|snippet| ConcatBytesInvalidSuggestion::IntLit { span, snippet });
             dcx.emit_err(ConcatBytesInvalid { span, lit_kind: "numeric", sugg })
         }
-        Ok(LitKind::Int(val, LitIntType::Unsuffixed(false) | LitIntType::Unsigned(UintTy::U8))) => {
+        Ok(LitKind::Int(
+            val,
+            LitIntType::Unsuffixed(Sign::None) | LitIntType::Unsigned(UintTy::U8),
+        )) => {
             assert!(val.get() > u8::MAX.into()); // must be an error
             dcx.emit_err(ConcatBytesOob { span })
         }
@@ -79,7 +82,7 @@ fn handle_array_element(
             match LitKind::from_token_lit(token_lit) {
                 Ok(LitKind::Int(
                     val,
-                    LitIntType::Unsuffixed(false) | LitIntType::Unsigned(UintTy::U8),
+                    LitIntType::Unsuffixed(Sign::None) | LitIntType::Unsigned(UintTy::U8),
                 )) if let Ok(val) = u8::try_from(val.get()) => {
                     return Some(val);
                 }

compiler/rustc_codegen_ssa/src/codegen_attrs.rs

@@ -4,7 +4,7 @@ use rustc_abi::ExternAbi;
 use rustc_ast::expand::autodiff_attrs::{
     AutoDiffAttrs, DiffActivity, DiffMode, valid_input_activity, valid_ret_activity,
 };
-use rustc_ast::{MetaItem, MetaItemInner, attr};
+use rustc_ast::{MetaItem, MetaItemInner, Sign, attr};
 use rustc_attr_parsing::ReprAttr::ReprAlign;
 use rustc_attr_parsing::{AttributeKind, InlineAttr, InstructionSetAttr, OptimizeAttr};
 use rustc_data_structures::fx::FxHashMap;
@@ -751,7 +751,8 @@ fn check_link_ordinal(tcx: TyCtxt<'_>, attr: &hir::Attribute) -> Option<u16> {
         return None;
     };
     if let Some(MetaItemLit {
-        kind: LitKind::Int(ordinal, LitIntType::Unsuffixed(false)), ..
+        kind: LitKind::Int(ordinal, LitIntType::Unsuffixed(Sign::None)),
+        ..
     }) = sole_meta_list.lit()
     {
         // According to the table at

compiler/rustc_expand/src/mbe/metavar_expr.rs

@@ -1,6 +1,6 @@
 use rustc_ast::token::{self, Delimiter, IdentIsRaw, Lit, Token, TokenKind};
 use rustc_ast::tokenstream::{TokenStream, TokenStreamIter, TokenTree};
-use rustc_ast::{LitIntType, LitKind};
+use rustc_ast::{LitIntType, LitKind, Sign};
 use rustc_ast_pretty::pprust;
 use rustc_errors::{Applicability, PResult};
 use rustc_macros::{Decodable, Encodable};
@@ -191,7 +191,7 @@ fn parse_depth<'psess>(
             .struct_span_err(span, "meta-variable expression depth must be a literal"));
     };
     if let Ok(lit_kind) = LitKind::from_token_lit(*lit)
-        && let LitKind::Int(n_u128, LitIntType::Unsuffixed(false)) = lit_kind
+        && let LitKind::Int(n_u128, LitIntType::Unsuffixed(Sign::None)) = lit_kind
         && let Ok(n_usize) = usize::try_from(n_u128.get())
     {
         Ok(n_usize)