Carry sign through literals

Author: oli-obk

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,12 +1966,22 @@ 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,
         }
     }
+
+    pub fn is_negative(&self) -> bool {
+        match self {
+            LitKind::Int(_, LitIntType::Signed(_, negative) | LitIntType::Unsuffixed(negative)) => {
+                *negative
+            }
+            LitKind::Float(f, _) => f.as_str().starts_with('-'),
+            _ => false,
+        }
+    }
 }
 
 // N.B., If you change this, you'll probably want to change the corresponding

compiler/rustc_ast/src/util/literal.rs

@@ -36,20 +36,35 @@ 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.
+    /// 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> {
         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 +86,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 +204,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 +291,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 +313,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 +332,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 +346,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

@@ -138,11 +138,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),
@@ -419,8 +430,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

@@ -225,7 +225,7 @@ fn parse_repr_align(
 }
 
 fn parse_alignment(node: &LitKind) -> Result<Align, &'static str> {
-    if let LitKind::Int(literal, LitIntType::Unsuffixed) = node {
+    if let LitKind::Int(literal, 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

@@ -320,7 +320,7 @@ pub(crate) enum IncorrectReprFormatGenericCause<'a> {
         name: &'a str,
 
         #[skip_arg]
-        int: u128,
+        int: String,
     },
 
     #[suggestion(
@@ -342,11 +342,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

@@ -750,8 +750,9 @@ fn check_link_ordinal(tcx: TyCtxt<'_>, attr: &hir::Attribute) -> Option<u16> {
         tcx.dcx().emit_err(errors::InvalidLinkOrdinalNargs { span: attr.span() });
         return None;
     };
-    if let Some(MetaItemLit { kind: LitKind::Int(ordinal, LitIntType::Unsuffixed), .. }) =
-        sole_meta_list.lit()
+    if let Some(MetaItemLit {
+        kind: LitKind::Int(ordinal, LitIntType::Unsuffixed(false)), ..
+    }) = sole_meta_list.lit()
     {
         // 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)