fix: add negative integer literals

compiler/noirc_evaluator/src/ssa/ir/types.rs

@@ -127,13 +127,7 @@ impl NumericType {
     /// for the current NumericType.
     pub(crate) fn value_is_within_limits(self, field: FieldElement) -> bool {
         match self {
-            NumericType::Signed { bit_size } => {
-                let min = -(2i128.pow(bit_size - 1));
-                let max = 2u128.pow(bit_size - 1) - 1;
-                // Signed integers are odd since they will overflow the field value
-                field <= max.into() || field >= min.into()
-            }
-            NumericType::Unsigned { bit_size } => {
+            NumericType::Signed { bit_size } | NumericType::Unsigned { bit_size } => {
                 let max = 2u128.pow(bit_size) - 1;
                 field <= max.into()
             }

compiler/noirc_frontend/src/ast/expression.rs

@@ -50,7 +50,13 @@ impl ExpressionKind {
     }
 
     pub fn prefix(operator: UnaryOp, rhs: Expression) -> ExpressionKind {
-        ExpressionKind::Prefix(Box::new(PrefixExpression { operator, rhs }))
+        match (operator, &rhs) {
+            (
+                UnaryOp::Minus,
+                Expression { kind: ExpressionKind::Literal(Literal::Integer(field)), .. },
+            ) => ExpressionKind::Literal(Literal::NegativeInteger(*field)),
+            _ => ExpressionKind::Prefix(Box::new(PrefixExpression { operator, rhs })),
+        }
     }
 
     pub fn array(contents: Vec<Expression>) -> ExpressionKind {
@@ -65,6 +71,7 @@ impl ExpressionKind {
     }
 
     pub fn integer(contents: FieldElement) -> ExpressionKind {
+        // todo!();
         ExpressionKind::Literal(Literal::Integer(contents))
     }
 
@@ -315,6 +322,7 @@ pub enum Literal {
     Array(ArrayLiteral),
     Bool(bool),
     Integer(FieldElement),
+    NegativeInteger(FieldElement),
     Str(String),
     RawStr(String, u8),
     FmtStr(String),
@@ -519,6 +527,7 @@ impl Display for Literal {
             }
             Literal::FmtStr(string) => write!(f, "f\"{string}\""),
             Literal::Unit => write!(f, "()"),
+            Literal::NegativeInteger(integer) => write!(f, "-{}", integer.to_u128()),
         }
     }
 }

compiler/noirc_frontend/src/hir/resolution/resolver.rs

@@ -1203,6 +1203,7 @@ impl<'a> Resolver<'a> {
                     HirLiteral::Array(HirArrayLiteral::Repeated { repeated_element, length })
                 }
                 Literal::Integer(integer) => HirLiteral::Integer(integer),
+                Literal::NegativeInteger(integer) => HirLiteral::NegativeInteger(integer),
                 Literal::Str(str) => HirLiteral::Str(str),
                 Literal::RawStr(str, _) => HirLiteral::Str(str),
                 Literal::FmtStr(str) => self.resolve_fmt_str_literal(str, expr.span),

compiler/noirc_frontend/src/hir/type_check/expr.rs

@@ -114,7 +114,9 @@ impl<'interner> TypeChecker<'interner> {
                         Type::Array(Box::new(length), Box::new(elem_type))
                     }
                     HirLiteral::Bool(_) => Type::Bool,
-                    HirLiteral::Integer(_) => Type::polymorphic_integer(self.interner),
+                    HirLiteral::Integer(_) | HirLiteral::NegativeInteger(_) => {
+                        Type::polymorphic_integer(self.interner)
+                    }
                     HirLiteral::Str(string) => {
                         let len = Type::Constant(string.len() as u64);
                         Type::String(Box::new(len))

compiler/noirc_frontend/src/hir_def/expr.rs

@@ -79,6 +79,7 @@ pub enum HirLiteral {
     Array(HirArrayLiteral),
     Bool(bool),
     Integer(FieldElement),
+    NegativeInteger(FieldElement),
     Str(String),
     FmtStr(String, Vec<ExprId>),
     Unit,

compiler/noirc_frontend/src/monomorphization/mod.rs

@@ -321,6 +321,18 @@ impl<'interner> Monomorphizer<'interner> {
                 let location = self.interner.id_location(expr);
                 Literal(Integer(value, typ, location))
             }
+            HirExpression::Literal(HirLiteral::NegativeInteger(value)) => {
+                let typ = self.convert_type(&self.interner.id_type(expr));
+                let location = self.interner.id_location(expr);
+                match typ {
+                    ast::Type::Field => Literal(Integer(-value, typ, location)),
+                    ast::Type::Integer(_, bit_size) => {
+                        let base = 1_u128 << bit_size;
+                        Literal(Integer(FieldElement::from(base) - value, typ, location))
+                    }
+                    _ => unreachable!("Integer literal must be numeric"),
+                }
+            }
             HirExpression::Literal(HirLiteral::Array(array)) => match array {
                 HirArrayLiteral::Standard(array) => self.standard_array(expr, array),
                 HirArrayLiteral::Repeated { repeated_element, length } => {

test_programs/execution_success/regression_3394/Nargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "regression_3394"
+type = "bin"
+authors = [""]
+
+[dependencies]

test_programs/execution_success/regression_3394/Prover.toml

@@ -0,0 +1 @@
+

test_programs/execution_success/regression_3394/src/main.nr

@@ -0,0 +1,6 @@
+use dep::std;
+
+fn main() {
+    let x : i8 = -128;
+    std::println(x);
+}

tooling/nargo_fmt/src/rewrite/expr.rs

@@ -111,6 +111,7 @@ pub(crate) fn rewrite(
         ),
         ExpressionKind::Literal(literal) => match literal {
             Literal::Integer(_)
+            | Literal::NegativeInteger(_)
             | Literal::Bool(_)
             | Literal::Str(_)
             | Literal::RawStr(..)