Merge pull request #55 from refcell/nox/int-literals-bug

refcell · web-flow · commit 76aa326b4a58 · 2026-03-09T09:17:12.000-04:00
fix: preserve full 256-bit precision for integer literals
diff --git a/Cargo.toml b/Cargo.toml
@@ -4,7 +4,7 @@ resolver = "2"
 
 [workspace.package]
 description = "Edge Language Compiler Workspace"
-version = "0.1.19"
+version = "0.1.20"
 edition = "2021"
 rust-version = "1.85"
 license = "MIT"
diff --git a/crates/ast/src/lit.rs b/crates/ast/src/lit.rs
@@ -10,7 +10,7 @@ use crate::ty::PrimitiveType;
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Lit {
     /// Integer literal: 42, 42u8, etc.
-    Int(u64, Option<PrimitiveType>, Span),
+    Int([u8; 32], Option<PrimitiveType>, Span),
     /// String literal: "hello"
     Str(String, Span),
     /// Boolean literal: true or false
diff --git a/crates/e2e/tests/main.rs b/crates/e2e/tests/main.rs
@@ -49,3 +49,6 @@ mod types_exec;
 mod utils_exec;
 #[path = "suites/warnings.rs"]
 mod warnings;
+
+#[path = "suites/large_int_literals.rs"]
+mod large_int_literals;
diff --git a/crates/e2e/tests/suites/large_int_literals.rs b/crates/e2e/tests/suites/large_int_literals.rs
@@ -0,0 +1,95 @@
+#![allow(missing_docs)]
+
+use edge_driver::compiler::Compiler;
+
+fn compile_source(src: &str) -> Vec<u8> {
+    let mut compiler = Compiler::from_source(src);
+    let output = compiler.compile().expect("compile failed");
+    output.bytecode.expect("no bytecode produced")
+}
+
+fn contains_bytes(haystack: &[u8], needle: &[u8]) -> bool {
+    haystack.windows(needle.len()).any(|w| w == needle)
+}
+
+fn to_hex(bytes: &[u8]) -> String {
+    bytes.iter().map(|b| format!("{b:02x}")).collect()
+}
+
+fn from_hex(s: &str) -> Vec<u8> {
+    (0..s.len())
+        .step_by(2)
+        .map(|i| u8::from_str_radix(&s[i..i + 2], 16).unwrap())
+        .collect()
+}
+
+#[test]
+fn large_literal_two_pow_64() {
+    let src = r#"
+contract Test {
+    pub fn get() -> u256 {
+        return 18446744073709551616;
+    }
+}
+"#;
+    let bytecode = compile_source(src);
+    let expected: [u8; 9] = [0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00];
+    assert!(
+        contains_bytes(&bytecode, &expected),
+        "bytecode should contain 2^64: {}",
+        to_hex(&bytecode)
+    );
+}
+
+#[test]
+fn large_literal_10_pow_21() {
+    let src = r#"
+contract Test {
+    pub fn get() -> u256 {
+        return 1000000000000000000000;
+    }
+}
+"#;
+    let bytecode = compile_source(src);
+    let expected = from_hex("3635c9adc5dea00000");
+    assert!(
+        contains_bytes(&bytecode, &expected),
+        "bytecode should contain 10^21: {}",
+        to_hex(&bytecode)
+    );
+}
+
+#[test]
+fn large_literal_u256_max() {
+    let src = r#"
+contract Test {
+    pub fn get() -> u256 {
+        return 115792089237316195423570985008687907853269984665640564039457584007913129639935;
+    }
+}
+"#;
+    let bytecode = compile_source(src);
+    let expected = [0xffu8; 32];
+    assert!(
+        contains_bytes(&bytecode, &expected),
+        "bytecode should contain 32 bytes of 0xff for MAX_UINT: {}",
+        to_hex(&bytecode)
+    );
+}
+
+#[test]
+fn small_literal_not_regressed() {
+    let src = r#"
+contract Test {
+    pub fn get() -> u256 {
+        return 42;
+    }
+}
+"#;
+    let bytecode = compile_source(src);
+    assert!(
+        contains_bytes(&bytecode, &[0x60, 0x2a]),
+        "bytecode should contain PUSH1 42: {}",
+        to_hex(&bytecode)
+    );
+}
diff --git a/crates/ir/src/to_egglog/composite.rs b/crates/ir/src/to_egglog/composite.rs
@@ -456,7 +456,9 @@ impl AstToEgglog {
     fn try_const_index(expr: &edge_ast::Expr) -> Option<u64> {
         match expr {
             edge_ast::Expr::Literal(lit) => match lit.as_ref() {
-                edge_ast::lit::Lit::Int(val, _, _) => Some(*val),
+                edge_ast::lit::Lit::Int(bytes, _, _) => {
+                    Some(u64::from_be_bytes(bytes[24..32].try_into().unwrap()))
+                }
                 _ => None,
             },
             edge_ast::Expr::Paren(inner, _) => Self::try_const_index(inner),
diff --git a/crates/ir/src/to_egglog/expr.rs b/crates/ir/src/to_egglog/expr.rs
@@ -316,20 +316,28 @@ impl AstToEgglog {
                         {
                             // Evaluate start index (must be a constant for now)
                             if let edge_ast::Expr::Literal(lit) = index.as_ref() {
-                                if let edge_ast::Lit::Int(start, _, _) = lit.as_ref() {
+                                if let edge_ast::Lit::Int(start_bytes, _, _) = lit.as_ref() {
+                                    let start =
+                                        u64::from_be_bytes(start_bytes[24..32].try_into().unwrap())
+                                            as usize;
                                     let new_base = ast_helpers::add(
                                         base_expr,
                                         ast_helpers::const_int(
-                                            (*start as usize * 32) as i64,
+                                            (start * 32) as i64,
                                             self.current_ctx.clone(),
                                         ),
                                     );
                                     // Compute slice length from end index
                                     let slice_len = end_index.as_ref().map_or(0, |end_idx| {
                                         if let edge_ast::Expr::Literal(end_lit) = end_idx.as_ref() {
-                                            if let edge_ast::Lit::Int(end, _, _) = end_lit.as_ref()
+                                            if let edge_ast::Lit::Int(end_bytes, _, _) =
+                                                end_lit.as_ref()
                                             {
-                                                (*end as usize) - (*start as usize)
+                                                let end = u64::from_be_bytes(
+                                                    end_bytes[24..32].try_into().unwrap(),
+                                                )
+                                                    as usize;
+                                                end - start
                                             } else {
                                                 0
                                             }
@@ -464,16 +472,40 @@ impl AstToEgglog {
     /// Lower a literal value.
     pub(crate) fn lower_literal(&self, lit: &edge_ast::Lit) -> Result<RcExpr, IrError> {
         match lit {
-            edge_ast::Lit::Int(val, maybe_ty, _span) => {
+            edge_ast::Lit::Int(bytes, maybe_ty, _span) => {
                 let ty = maybe_ty
                     .as_ref()
                     .map(|pt| self.lower_primitive_type(pt))
                     .unwrap_or(EvmType::Base(EvmBaseType::UIntT(256)));
-                Ok(Rc::new(EvmExpr::Const(
-                    EvmConstant::SmallInt(*val as i64),
-                    ty,
-                    self.current_ctx.clone(),
-                )))
+                // Check if value fits in SmallInt (first 24 bytes are zero and high bit of remaining 8 is not set)
+                let is_small = bytes[..24].iter().all(|&b| b == 0) && (bytes[24] & 0x80) == 0;
+                if is_small {
+                    let mut val: u64 = 0;
+                    for &b in &bytes[24..] {
+                        val = (val << 8) | (b as u64);
+                    }
+                    Ok(Rc::new(EvmExpr::Const(
+                        EvmConstant::SmallInt(val as i64),
+                        ty,
+                        self.current_ctx.clone(),
+                    )))
+                } else {
+                    let hex_str: String = bytes
+                        .iter()
+                        .skip_while(|&&b| b == 0)
+                        .map(|b| format!("{b:02x}"))
+                        .collect();
+                    let hex_str = if hex_str.is_empty() {
+                        "00".to_string()
+                    } else {
+                        hex_str
+                    };
+                    Ok(Rc::new(EvmExpr::Const(
+                        EvmConstant::LargeInt(hex_str),
+                        ty,
+                        self.current_ctx.clone(),
+                    )))
+                }
             }
             edge_ast::Lit::Bool(val, _span) => {
                 Ok(ast_helpers::const_bool(*val, self.current_ctx.clone()))
diff --git a/crates/ir/src/to_egglog/types.rs b/crates/ir/src/to_egglog/types.rs
@@ -60,8 +60,9 @@ impl AstToEgglog {
     /// Extract fixed array length from a type expression (literal integer).
     pub(crate) fn extract_array_length(len_expr: &edge_ast::Expr) -> Option<usize> {
         if let edge_ast::Expr::Literal(lit) = len_expr {
-            if let edge_ast::Lit::Int(n, _, _) = lit.as_ref() {
-                return Some(*n as usize);
+            if let edge_ast::Lit::Int(bytes, _, _) = lit.as_ref() {
+                let n = u64::from_be_bytes(bytes[24..32].try_into().unwrap());
+                return Some(n as usize);
             }
         }
         None
diff --git a/crates/parser/src/parser.rs b/crates/parser/src/parser.rs
@@ -1678,12 +1678,10 @@ impl Parser {
         match kind {
             TokenKind::Literal(lit_bytes) => {
                 let token = self.advance();
-                // Extract the actual integer value from the literal bytes
-                let mut value: u128 = 0;
-                for byte in &lit_bytes {
-                    value = (value << 8) | (*byte as u128);
-                }
-                let lit = Lit::Int(value as u64, None, token.span);
+                let mut bytes = [0u8; 32];
+                let len = lit_bytes.len().min(32);
+                bytes[32 - len..].copy_from_slice(&lit_bytes[lit_bytes.len() - len..]);
+                let lit = Lit::Int(bytes, None, token.span);
                 Ok(Expr::Literal(Box::new(lit)))
             }
             TokenKind::StringLiteral(s) => {
diff --git a/crates/parser/tests/parser_tests.rs b/crates/parser/tests/parser_tests.rs
@@ -1,5 +1,6 @@
 //! Integration tests for the Edge language parser.
 
+use edge_ast::Lit;
 use edge_parser::parse;
 
 // ─── Empty Program ──────────────────────────────────────────────────
@@ -461,3 +462,49 @@ fn parse_match_statement() {
         edge_ast::Stmt::Match(..)
     ));
 }
+
+// ─── Large Integer Literals (Issue #40) ─────────────────────────────
+
+/// Helper: parse "let x: u256 = <literal>;" and extract the Lit from the initializer.
+fn parse_int_literal(literal: &str) -> [u8; 32] {
+    let src = format!("let x: u256 = {literal};");
+    let program = parse(&src).unwrap_or_else(|e| panic!("parse failed: {e:?}"));
+    assert_eq!(program.stmts.len(), 1);
+    if let edge_ast::Stmt::VarDecl(_, _, Some(init), _) = &program.stmts[0] {
+        {
+            if let edge_ast::Expr::Literal(lit) = init.as_ref() {
+                if let Lit::Int(bytes, _, _) = lit.as_ref() {
+                    return *bytes;
+                }
+            }
+        }
+    }
+    panic!("expected Lit::Int in initializer");
+}
+
+#[test]
+fn int_literal_two_pow_64_not_truncated() {
+    // 2^64 = 18446744073709551616; must NOT be truncated to 0
+    let bytes = parse_int_literal("18446744073709551616");
+    // 2^64 in big-endian [u8;32]: byte[23] = 0x01, rest zeros
+    let mut expected = [0u8; 32];
+    expected[23] = 1;
+    assert_eq!(bytes, expected, "2^64 was truncated!");
+}
+
+#[test]
+fn int_literal_u256_max() {
+    // 2^256 - 1: all bytes 0xff
+    let bytes = parse_int_literal(
+        "115792089237316195423570985008687907853269984665640564039457584007913129639935",
+    );
+    assert_eq!(bytes, [0xffu8; 32], "2^256-1 bytes should all be 0xff");
+}
+
+#[test]
+fn int_literal_small_value_preserved() {
+    let bytes = parse_int_literal("42");
+    let mut expected = [0u8; 32];
+    expected[31] = 42;
+    assert_eq!(bytes, expected);
+}
diff --git a/crates/typeck/Cargo.toml b/crates/typeck/Cargo.toml
@@ -16,9 +16,12 @@ indexmap = { workspace = true }
 tiny-keccak = { workspace = true }
 alloy-primitives = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
+ruint = { workspace = true }
 
 [dev-dependencies]
 edge-driver = { workspace = true }
+edge-lexer = { workspace = true }
+edge-parser = { workspace = true }
 serde_json = { workspace = true }
 
 [lints]
diff --git a/crates/typeck/src/checker.rs b/crates/typeck/src/checker.rs
diff --git a/crates/typeck/tests/const_eval.rs b/crates/typeck/tests/const_eval.rs

Original file line number	Diff line number	Diff line change
`@@ -60,8 +60,9 @@ impl AstToEgglog {`
`60`	`60`	`/// Extract fixed array length from a type expression (literal integer).`
`61`	`61`	`pub(crate) fn extract_array_length(len_expr: &edge_ast::Expr) -> Option<usize> {`
`62`	`62`	`if let edge_ast::Expr::Literal(lit) = len_expr {`
`63`		`- if let edge_ast::Lit::Int(n, _, _) = lit.as_ref() {`
`64`		`- return Some(*n as usize);`
	`63`	`+ if let edge_ast::Lit::Int(bytes, _, _) = lit.as_ref() {`
	`64`	`+ let n = u64::from_be_bytes(bytes[24..32].try_into().unwrap());`
	`65`	`+ return Some(n as usize);`
`65`	`66`	`}`
`66`	`67`	`}`
`67`	`68`	`None`