Auto merge of rust-lang#136860 - oli-obk:signed-literals, r=<try>

Give integer literals a sign instead of relying on negation expressions

r? `@ghost`

A lot of situations in the compiler check for unary negation of literals, which I want to replace entirely at some point. I think the only place that should have to handle such things is the overflowing literals lint to detect double negation. Everywhere else we should just have the concept of negative literals.

Author: bors

compiler/rustc_ast/src/ast.rs

@@ -1874,11 +1874,13 @@ impl StrLit {
 #[derive(HashStable_Generic)]
 pub enum LitIntType {
     /// e.g. `42_i32`.
-    Signed(IntTy),
+    /// The bool signals whether the literal is negated
+    Signed(IntTy, bool),
     /// e.g. `42_u32`.
     Unsigned(UintTy),
     /// e.g. `42`.
-    Unsuffixed,
+    /// The bool signals whether the literal is negated
+    Unsuffixed(bool),
 }
 
 /// Type of the float literal based on provided suffix.
@@ -1913,7 +1915,7 @@ pub enum LitKind {
     Char(char),
     /// An integer literal (`1`).
     Int(Pu128, LitIntType),
-    /// A float literal (`1.0`, `1f64` or `1E10f64`). The pre-suffix part is
+    /// A float literal (`1.0`, `-1.0`, `1f64` or `1E10f64`). The pre-suffix part is
     /// stored as a symbol rather than `f64` so that `LitKind` can impl `Eq`
     /// and `Hash`.
     Float(Symbol, LitFloatType),
@@ -1964,7 +1966,7 @@ impl LitKind {
             | LitKind::CStr(..)
             | LitKind::Byte(..)
             | LitKind::Char(..)
-            | LitKind::Int(_, LitIntType::Unsuffixed)
+            | LitKind::Int(_, LitIntType::Unsuffixed(_))
             | LitKind::Float(_, LitFloatType::Unsuffixed)
             | LitKind::Bool(..)
             | LitKind::Err(_) => false,

compiler/rustc_ast/src/util/literal.rs

@@ -36,20 +36,32 @@ pub enum LitError {
     InvalidSuffix(Symbol),
     InvalidIntSuffix(Symbol),
     InvalidFloatSuffix(Symbol),
+    InvalidNegation(token::LitKind),
     NonDecimalFloat(u32), // u32 is the base
     IntTooLarge(u32),     // u32 is the base
 }
 
 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)
+    }
+
+    /// Converts literal token into a semantic literal.
+    pub fn from_token_lit_maybe_negated(
+        lit: token::Lit,
+        negated: bool,
+    ) -> 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) {
+            return Err(LitError::InvalidNegation(kind));
+        }
+
         // For byte/char/string literals, chars and escapes have already been
         // checked in the lexer (in `cook_lexer_literal`). So we can assume all
         // chars and escapes are valid here.
@@ -71,8 +83,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),
-            token::Float => return float_lit(symbol, suffix),
+            token::Integer => return integer_lit(symbol, suffix, negated),
+            token::Float => return float_lit(symbol, suffix, negated),
 
             token::Str => {
                 // If there are no characters requiring special treatment we can
@@ -189,14 +201,21 @@ impl fmt::Display for LitKind {
                 let symbol = str::from_utf8(bytes).unwrap();
                 write!(f, "cr{delim}\"{symbol}\"{delim}", delim = "#".repeat(n as usize),)?;
             }
-            LitKind::Int(n, ty) => {
-                write!(f, "{n}")?;
-                match ty {
-                    ast::LitIntType::Unsigned(ty) => write!(f, "{}", ty.name())?,
-                    ast::LitIntType::Signed(ty) => write!(f, "{}", ty.name())?,
-                    ast::LitIntType::Unsuffixed => {}
+            LitKind::Int(n, ty) => match ty {
+                ast::LitIntType::Unsigned(ty) => write!(f, "{n}{}", ty.name())?,
+                ast::LitIntType::Signed(ty, negated) => {
+                    if negated {
+                        write!(f, "-")?;
+                    }
+                    write!(f, "{n}{}", ty.name())?
                 }
-            }
+                ast::LitIntType::Unsuffixed(negated) => {
+                    if negated {
+                        write!(f, "-")?;
+                    }
+                    write!(f, "{n}")?;
+                }
+            },
             LitKind::Float(symbol, ty) => {
                 write!(f, "{symbol}")?;
                 match ty {
@@ -269,11 +288,13 @@ fn filtered_float_lit(
     symbol: Symbol,
     suffix: Option<Symbol>,
     base: u32,
+    negated: bool,
 ) -> Result<LitKind, LitError> {
-    debug!("filtered_float_lit: {:?}, {:?}, {:?}", symbol, suffix, base);
+    debug!(?symbol, ?suffix, ?base, ?negated);
     if base != 10 {
         return Err(LitError::NonDecimalFloat(base));
     }
+    let symbol = if negated { Symbol::intern(&format!("-{}", symbol.as_str())) } else { symbol };
     Ok(match suffix {
         Some(suffix) => LitKind::Float(
             symbol,
@@ -289,12 +310,12 @@ fn filtered_float_lit(
     })
 }
 
-fn float_lit(symbol: Symbol, suffix: Option<Symbol>) -> Result<LitKind, LitError> {
+fn float_lit(symbol: Symbol, suffix: Option<Symbol>, negated: bool) -> Result<LitKind, LitError> {
     debug!("float_lit: {:?}, {:?}", symbol, suffix);
-    filtered_float_lit(strip_underscores(symbol), suffix, 10)
+    filtered_float_lit(strip_underscores(symbol), suffix, 10, negated)
 }
 
-fn integer_lit(symbol: Symbol, suffix: Option<Symbol>) -> Result<LitKind, LitError> {
+fn integer_lit(symbol: Symbol, suffix: Option<Symbol>, negated: bool) -> Result<LitKind, LitError> {
     debug!("integer_lit: {:?}, {:?}", symbol, suffix);
     let symbol = strip_underscores(symbol);
     let s = symbol.as_str();
@@ -308,12 +329,12 @@ fn integer_lit(symbol: Symbol, suffix: Option<Symbol>) -> Result<LitKind, LitErr
 
     let ty = match suffix {
         Some(suf) => match suf {
-            sym::isize => ast::LitIntType::Signed(ast::IntTy::Isize),
-            sym::i8 => ast::LitIntType::Signed(ast::IntTy::I8),
-            sym::i16 => ast::LitIntType::Signed(ast::IntTy::I16),
-            sym::i32 => ast::LitIntType::Signed(ast::IntTy::I32),
-            sym::i64 => ast::LitIntType::Signed(ast::IntTy::I64),
-            sym::i128 => ast::LitIntType::Signed(ast::IntTy::I128),
+            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::usize => ast::LitIntType::Unsigned(ast::UintTy::Usize),
             sym::u8 => ast::LitIntType::Unsigned(ast::UintTy::U8),
             sym::u16 => ast::LitIntType::Unsigned(ast::UintTy::U16),
@@ -322,11 +343,18 @@ fn integer_lit(symbol: Symbol, suffix: Option<Symbol>) -> Result<LitKind, LitErr
             sym::u128 => ast::LitIntType::Unsigned(ast::UintTy::U128),
             // `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),
+            _ if suf.as_str().starts_with('f') => {
+                return filtered_float_lit(symbol, suffix, base, negated);
+            }
             _ => return Err(LitError::InvalidIntSuffix(suf)),
         },
-        _ => ast::LitIntType::Unsuffixed,
+        _ => ast::LitIntType::Unsuffixed(negated),
     };
+    if let ast::LitIntType::Unsigned(_) = ty
+        && negated
+    {
+        return Err(LitError::InvalidNegation(token::Integer));
+    }
 
     let s = &s[if base != 10 { 2 } else { 0 }..];
     u128::from_str_radix(s, base)

compiler/rustc_ast_lowering/src/expr.rs

@@ -139,11 +139,22 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     hir::ExprKind::Binary(binop, lhs, rhs)
                 }
                 ExprKind::Unary(op, ohs) => {
+                    if let UnOp::Neg = op {
+                        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)),
+                                span: self.lower_span(e.span),
+                            };
+                        }
+                    }
                     let op = self.lower_unop(*op);
                     let ohs = self.lower_expr(ohs);
                     hir::ExprKind::Unary(op, ohs)
                 }
-                ExprKind::Lit(token_lit) => hir::ExprKind::Lit(self.lower_lit(token_lit, e.span)),
+                ExprKind::Lit(token_lit) => {
+                    hir::ExprKind::Lit(self.lower_lit(token_lit, e.span, false))
+                }
                 ExprKind::IncludedBytes(bytes) => {
                     let lit = self.arena.alloc(respan(
                         self.lower_span(e.span),
@@ -420,8 +431,9 @@ impl<'hir> LoweringContext<'_, 'hir> {
         &mut self,
         token_lit: &token::Lit,
         span: Span,
+        negated: bool,
     ) -> &'hir Spanned<LitKind> {
-        let lit_kind = match LitKind::from_token_lit(*token_lit) {
+        let lit_kind = match LitKind::from_token_lit_maybe_negated(*token_lit, negated) {
             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,12 +30,11 @@ impl<'hir> LoweringContext<'_, 'hir> {
             Ok(LitKind::Int(n, ty)) => {
                 match ty {
                     // unsuffixed integer literals are assumed to be i32's
-                    LitIntType::Unsuffixed => {
-                        (n <= i32::MAX as u128).then_some(Symbol::intern(&n.to_string()))
-                    }
-                    LitIntType::Signed(int_ty) => {
+                    LitIntType::Unsuffixed(negated) => (!negated && n <= i32::MAX as u128)
+                        .then_some(Symbol::intern(&n.to_string())),
+                    LitIntType::Signed(int_ty, negated) => {
                         let max_literal = self.int_ty_max(int_ty);
-                        (n <= max_literal).then_some(Symbol::intern(&n.to_string()))
+                        (!negated && 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

@@ -391,18 +391,14 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         let span = self.lower_span(expr.span);
         let err = |guar| hir::PatExprKind::Lit {
             lit: self.arena.alloc(respan(span, LitKind::Err(guar))),
-            negated: false,
         };
         let kind = match &expr.kind {
-            ExprKind::Lit(lit) => {
-                hir::PatExprKind::Lit { lit: self.lower_lit(lit, span), negated: false }
-            }
+            ExprKind::Lit(lit) => hir::PatExprKind::Lit { lit: self.lower_lit(lit, span, false) },
             ExprKind::ConstBlock(c) => hir::PatExprKind::ConstBlock(self.lower_const_block(c)),
             ExprKind::IncludedBytes(bytes) => hir::PatExprKind::Lit {
                 lit: self
                     .arena
                     .alloc(respan(span, LitKind::ByteStr(Arc::clone(bytes), StrStyle::Cooked))),
-                negated: false,
             },
             ExprKind::Err(guar) => err(*guar),
             ExprKind::Dummy => span_bug!(span, "lowered ExprKind::Dummy"),
@@ -416,7 +412,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), negated: true }
+                hir::PatExprKind::Lit { lit: self.lower_lit(lit, span, true) }
             }
             _ => {
                 let pattern_from_macro = expr.is_approximately_pattern();

compiler/rustc_attr_parsing/src/attributes/repr.rs

@@ -196,7 +196,7 @@ fn int_type_of_word(s: Symbol) -> Option<IntType> {
 }
 
 pub fn parse_alignment(node: &ast::LitKind) -> Result<Align, &'static str> {
-    if let ast::LitKind::Int(literal, ast::LitIntType::Unsuffixed) = node {
+    if let ast::LitKind::Int(literal, ast::LitIntType::Unsuffixed(false)) = 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

@@ -298,7 +298,7 @@ pub(crate) enum IncorrectReprFormatGenericCause<'a> {
         name: &'a str,
 
         #[skip_arg]
-        int: u128,
+        int: String,
     },
 
     #[suggestion(
@@ -320,11 +320,13 @@ 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) => {
-                Some(Self::Int { span, name, int: int.get() })
-            }
-            ast::LitKind::Str(symbol, _) => Some(Self::Symbol { span, name, symbol: *symbol }),
+        match *kind {
+            ast::LitKind::Int(int, ast::LitIntType::Unsuffixed(negated)) => Some(Self::Int {
+                span,
+                name,
+                int: if negated { 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

@@ -51,7 +51,7 @@ 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 | LitIntType::Unsigned(UintTy::U8))) => {
+        Ok(LitKind::Int(val, LitIntType::Unsuffixed(false) | LitIntType::Unsigned(UintTy::U8))) => {
             assert!(val.get() > u8::MAX.into()); // must be an error
             dcx.emit_err(ConcatBytesOob { span })
         }
@@ -79,7 +79,7 @@ fn handle_array_element(
             match LitKind::from_token_lit(token_lit) {
                 Ok(LitKind::Int(
                     val,
-                    LitIntType::Unsuffixed | LitIntType::Unsigned(UintTy::U8),
+                    LitIntType::Unsuffixed(false) | LitIntType::Unsigned(UintTy::U8),
                 )) if let Ok(val) = u8::try_from(val.get()) => {
                     return Some(val);
                 }

compiler/rustc_codegen_ssa/src/codegen_attrs.rs

@@ -777,8 +777,9 @@ fn check_link_ordinal(tcx: TyCtxt<'_>, attr: &hir::Attribute) -> Option<u16> {
         }
         _ => None,
     };
-    if let Some(MetaItemLit { kind: LitKind::Int(ordinal, LitIntType::Unsuffixed), .. }) =
-        sole_meta_list
+    if let Some(MetaItemLit {
+        kind: LitKind::Int(ordinal, LitIntType::Unsuffixed(false)), ..
+    }) = sole_meta_list
     {
         // According to the table at
         // https://docs.microsoft.com/en-us/windows/win32/debug/pe-format#import-header, the

compiler/rustc_expand/src/mbe/metavar_expr.rs

@@ -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) = lit_kind
+        && let LitKind::Int(n_u128, LitIntType::Unsuffixed(false)) = lit_kind
         && let Ok(n_usize) = usize::try_from(n_u128.get())
     {
         Ok(n_usize)