feat(slang): narrow literal types via slang's evaluator

Replaces solx's digit-counting width heuristic and hand-built MLIR
attribute strings with slang's CompileConstantEvaluator and LiteralKind
width/sign info. Unifies integer constant emission through
Builder::emit_constant(&BigInt, Type), which dispatches to
sol.address_cast, arith.constant, or sol.constant by target type.
Narrows signed negative literals to their minimum signed width, and
lowers rational decimal literals (1.5 ether, 0.5 gwei) that reduce to
integers after unit multiplication.

Author: hedgar2017

Cargo.lock

@@ -11,6 +11,7 @@ cc = "1.2.60"
 
 [dependencies]
 anyhow.workspace = true
+num.workspace = true
 melior = { git = "https://github.com/NomicFoundation/melior", rev = "62a909e2ff67fcc19f7f42dc4fb70c3e03376bd2", features = ["ods-dialects", "helpers"] }
 # mlir-sys 210 wraps LLVM 21.0 C API; llvm-sys (via inkwell) targets 21.1.
 # Both are built from the same LLVM source tree (LLVM_SYS_211_PREFIX ==

solx-mlir/Cargo.toml

@@ -27,6 +27,7 @@ use melior::ir::attribute::TypeAttribute;
 use melior::ir::operation::OperationLike;
 use melior::ir::r#type::FunctionType;
 use melior::ir::r#type::IntegerType;
+use num::BigInt;
 
 use crate::CmpPredicate;
 use crate::StateMutability;
@@ -223,92 +224,77 @@ impl<'context> Builder<'context> {
             .into()
     }
 
-    /// Emits a `sol.constant` of the given type from a decimal string.
+    /// Emits a typed integer constant, selecting the dialect by target type.
     ///
-    /// # Errors
+    /// `i1` is the signless boolean type owned by the arith dialect; every
+    /// other integer type is signed or unsigned and belongs to the sol
+    /// dialect. This is the single entry point for MLIR integer constants
+    /// that carry a `BigInt`-sized value.
+    ///
+    /// # Panics
     ///
-    /// Returns an error if the string cannot be parsed as an MLIR integer attribute.
-    pub fn emit_sol_constant_from_decimal_str<'block, B>(
+    /// Panics if the MLIR attribute parser rejects the `{value} : {type}`
+    /// rendering. For well-typed callers this is unreachable because the
+    /// type is a melior `IntegerType` and the value is a `BigInt` that
+    /// always has a canonical decimal representation.
+    pub fn emit_constant<'block, B>(
         &self,
-        value: &str,
+        value: &BigInt,
         result_type: Type<'context>,
         block: &B,
-    ) -> anyhow::Result<Value<'context, 'block>>
+    ) -> Value<'context, 'block>
     where
         B: BlockLike<'context, 'block>,
         'context: 'block,
     {
+        if result_type == self.types.sol_address {
+            let integer = self.emit_constant(value, self.types.ui160, block);
+            return self.emit_sol_address_cast(integer, result_type, block);
+        }
+        if TypeFactory::integer_bit_width(result_type) == solx_utils::BIT_LENGTH_BOOLEAN as u32 {
+            let boolean_attribute =
+                IntegerAttribute::new(result_type, i64::from(*value != BigInt::ZERO)).into();
+            return block
+                .append_operation(melior::dialect::arith::constant(
+                    self.context,
+                    boolean_attribute,
+                    self.unknown_location,
+                ))
+                .result(0)
+                .expect("arith.constant always produces one result")
+                .into();
+        }
+        // melior does not expose a `BigInt`-accepting attribute constructor,
+        // so we round-trip through the MLIR attribute parser to avoid
+        // truncating values wider than 64 bits.
         let attribute = Attribute::parse(self.context, &format!("{value} : {result_type}"))
-            .ok_or_else(|| anyhow::anyhow!("invalid {result_type} decimal literal: {value}"))?;
+            .expect("BigInt value and melior integer type always parse as an MLIR attribute");
         self.emit_constant_operation(attribute, result_type, block)
+            .expect("well-typed BigInt constant never fails emission")
     }
 
-    /// Emits a `sol.constant` of the given type from a hex string (without `0x` prefix).
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if the string cannot be parsed as an MLIR integer attribute.
-    pub fn emit_sol_constant_from_hex_str<'block, B>(
-        &self,
-        hexadecimal: &str,
-        result_type: Type<'context>,
-        block: &B,
-    ) -> anyhow::Result<Value<'context, 'block>>
+    /// Emits an `i1` boolean constant.
+    pub fn emit_bool<'block, B>(&self, value: bool, block: &B) -> Value<'context, 'block>
     where
         B: BlockLike<'context, 'block>,
         'context: 'block,
     {
-        let attribute = Attribute::parse(self.context, &format!("0x{hexadecimal} : {result_type}"))
-            .ok_or_else(|| anyhow::anyhow!("invalid {result_type} hex literal: 0x{hexadecimal}"))?;
-        self.emit_constant_operation(attribute, result_type, block)
+        self.emit_constant(&BigInt::from(u8::from(value)), self.types.i1, block)
     }
 
     /// Emits an all-ones `sol.constant` for the given integer type.
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if the constant cannot be parsed as an MLIR integer attribute.
     pub fn emit_sol_constant_all_ones<'block, B>(
         &self,
         integer_type: Type<'context>,
         block: &B,
-    ) -> anyhow::Result<Value<'context, 'block>>
-    where
-        B: BlockLike<'context, 'block>,
-        'context: 'block,
-    {
-        let bit_width = TypeFactory::integer_bit_width(integer_type);
-        let all_ones_hex = "f".repeat(bit_width as usize / 4);
-        self.emit_sol_constant_from_hex_str(&all_ones_hex, integer_type, block)
-    }
-
-    /// Emits an `arith.constant` for a signless `i1` boolean value.
-    ///
-    /// Boolean (`i1`) is signless in MLIR, so it uses `arith.constant`
-    /// instead of `sol.constant` (which is for signed/unsigned int types).
-    ///
-    /// # Panics
-    ///
-    /// Panics if the MLIR operation cannot be constructed.
-    pub fn emit_arith_constant_bool<'block, B>(
-        &self,
-        value: bool,
-        block: &B,
     ) -> Value<'context, 'block>
     where
         B: BlockLike<'context, 'block>,
         'context: 'block,
     {
-        let i1_type = IntegerType::new(self.context, solx_utils::BIT_LENGTH_BOOLEAN as u32).into();
-        block
-            .append_operation(melior::dialect::arith::constant(
-                self.context,
-                IntegerAttribute::new(i1_type, i64::from(value)).into(),
-                self.unknown_location,
-            ))
-            .result(0)
-            .expect("arith.constant always produces one result")
-            .into()
+        let bit_width = TypeFactory::integer_bit_width(integer_type);
+        let all_ones = (BigInt::from(1u32) << bit_width) - BigInt::from(1u32);
+        self.emit_constant(&all_ones, integer_type, block)
     }
 
     // ==== Terminators ====

solx-mlir/src/context/builder/mod.rs

@@ -11,12 +11,13 @@ doctest = false
 
 [dependencies]
 anyhow.workspace = true
+num.workspace = true
 serde_json.workspace = true
 semver.workspace = true
 # `__private_testing_utils` is required by `__private_backend_api` internals
 # (binder/types access in node_extensions). Both are unstable Slang APIs.
 # TODO: pin to a release tag instead of branch = "main"
-slang_solidity = { git = "https://github.com/NomicFoundation/slang.git", rev = "a01bc76b742173941cea1aff0b3b68a9006b38b8", features = ["__private_backend_api", "__private_testing_utils"] }
+slang_solidity = { git = "https://github.com/NomicFoundation/slang.git", rev = "68051e76eec565d2eec5deb41ae8c7a565340651", features = ["__private_backend_api", "__private_testing_utils"] }
 melior = { git = "https://github.com/NomicFoundation/melior", rev = "62a909e2ff67fcc19f7f42dc4fb70c3e03376bd2", features = ["ods-dialects", "helpers"] }
 
 solx-codegen-evm = { path = "../solx-codegen-evm" }

solx-slang/Cargo.toml

@@ -105,7 +105,7 @@ impl<'state, 'context, 'block> ExpressionEmitter<'state, 'context, 'block> {
                 let all_ones = self
                     .state
                     .builder
-                    .emit_sol_constant_all_ones(operand_type, &block)?;
+                    .emit_sol_constant_all_ones(operand_type, &block);
                 let result = block
                     .append_operation(
                         XorOperation::builder(
@@ -132,7 +132,7 @@ impl<'state, 'context, 'block> ExpressionEmitter<'state, 'context, 'block> {
                     .state
                     .builder
                     .emit_sol_cmp(value, zero, CmpPredicate::Eq, &block);
-                let result_type = target_type.unwrap_or_else(|| self.state.builder.types.ui256);
+                let result_type = target_type.unwrap_or(self.state.builder.types.ui256);
                 let result = TypeConversion::from_target_type(result_type, &self.state.builder)
                     .emit(cmp, &self.state.builder, &block);
                 Ok((result, block))

solx-slang/src/ast/contract/function/expression/arithmetic.rs

@@ -5,6 +5,7 @@
 use melior::ir::Type;
 use melior::ir::ValueLike;
 use melior::ir::r#type::IntegerType;
+use slang_solidity::backend::ir::ast::LiteralKind;
 use slang_solidity::backend::ir::ast::StateVariableDefinition;
 use slang_solidity::backend::ir::ast::Type as SlangType;
 
@@ -41,7 +42,33 @@ impl<'context> TypeConversion<'context> {
                 solx_utils::BIT_LENGTH_BOOLEAN as u32,
             )),
             SlangType::Address(_) => builder.types.sol_address,
-            SlangType::Literal(_) => builder.types.ui256,
+            SlangType::Literal(literal_type) => match literal_type.kind() {
+                LiteralKind::Zero => Type::from(IntegerType::unsigned(
+                    builder.context,
+                    solx_utils::BIT_LENGTH_BYTE as u32,
+                )),
+                LiteralKind::Address => builder.types.sol_address,
+                LiteralKind::DecimalInteger {
+                    bytes,
+                    signed: true,
+                } => {
+                    let bits = bytes * solx_utils::BIT_LENGTH_BYTE as u32;
+                    Type::from(IntegerType::signed(builder.context, bits))
+                }
+                LiteralKind::DecimalInteger {
+                    bytes,
+                    signed: false,
+                }
+                | LiteralKind::HexInteger { bytes } => {
+                    let bits = bytes * solx_utils::BIT_LENGTH_BYTE as u32;
+                    Type::from(IntegerType::unsigned(builder.context, bits))
+                }
+                kind @ (LiteralKind::Rational
+                | LiteralKind::HexString { .. }
+                | LiteralKind::String { .. }) => {
+                    panic!("MLIR type resolution is not supported for literal kind {kind:?}")
+                }
+            },
             _ => unimplemented!("unsupported Slang type"),
         }
     }

solx-slang/src/ast/contract/function/expression/call/type_conversion.rs

@@ -67,7 +67,7 @@ impl<'state, 'context, 'block> ExpressionEmitter<'state, 'context, 'block> {
 
         let i1_type = self.state.builder.types.i1;
         let result_ptr = self.state.builder.emit_sol_alloca(i1_type, &block);
-        let false_value = self.state.builder.emit_arith_constant_bool(false, &block);
+        let false_value = self.state.builder.emit_bool(false, &block);
         self.state
             .builder
             .emit_sol_store(false_value, result_ptr, &block);
@@ -111,7 +111,7 @@ impl<'state, 'context, 'block> ExpressionEmitter<'state, 'context, 'block> {
 
         let i1_type = self.state.builder.types.i1;
         let result_ptr = self.state.builder.emit_sol_alloca(i1_type, &block);
-        let true_value = self.state.builder.emit_arith_constant_bool(true, &block);
+        let true_value = self.state.builder.emit_bool(true, &block);
         self.state
             .builder
             .emit_sol_store(true_value, result_ptr, &block);