feat(slang): state-variable getters, custom errors, and type metadata

Adds the getter/ module synthesizing a getter `sol.func` for each public
state variable off slang's getter type: scalar (value and reference) reads,
keyed mapping/array levels (`sol.map` / `sol.gep` with `no_panic_bounds`),
struct leaves with non-returnable members skipped, and constant initializer
folds. External getter calls (`c.publicVar(keys)` -> static `sol.ext_call`)
and `try` over a getter dispatch through the new `ExternalCallee`
classification, which admits functions and public state variables alike.

`require(cond, E(..))` lowers custom errors through `sol.require`; a
contract namespace delegates value and place access to its members
(`C.x = v`, `Library.CONST`); `type(..)` metadata folds to constants:
integer min/max, name, interfaceId, and creation/runtime code through
`sol.object_code`; error and event `.selector` fold to the selector and
topic constants. Immutable and transient getters are loud `unimplemented!`
arms.

The slang pin moves to the rebased `az-dev-solx-clean`, whose
`compute_interface_id` covers only the functions the interface itself
declares, matching `type(I).interfaceId`.

Author: hedgar2017

Cargo.lock

@@ -94,4 +94,4 @@ features = [
 [workspace.dependencies.slang_solidity_v2]
 git = "https://github.com/NomicFoundation/slang.git"
 # TODO: pin to a release tag instead of a revision.
-rev = "c0c62aea7e0782bc21078450ae7d425699cda725"
+rev = "2640f3b1411a3eece9dbef4a3286a8f24b8dba45"

Cargo.toml

@@ -1,5 +1,5 @@
 //!
-//! The attribute a `sol.func` is reached through.
+//! The internal dispatch attribute a `sol.func` carries.
 //!
 
 use slang_solidity_v2::ast::FunctionDefinition;
@@ -8,14 +8,16 @@ use slang_solidity_v2::ast::NodeId;
 
 use crate::FunctionKind;
 
-/// The attribute a `sol.func` is reached through. A dispatch identifier is never zero, which the
-/// dialect reserves for the null function pointer, since slang numbers nodes from one.
+/// The internal dispatch attribute a `sol.func` carries, if any.
 #[derive(Clone, Copy)]
 pub enum FunctionDispatch {
-    /// The identifier an internal function pointer dispatches to.
+    /// The identifier an internal function pointer dispatches to; never zero, which the dialect
+    /// reserves for the null function pointer, since slang numbers nodes from one.
     Identifier(NodeId),
     /// The dialect kind of a constructor, fallback or receive function.
     Kind(FunctionKind),
+    /// A synthesized state-variable getter, dispatched by its ABI selector alone.
+    Getter,
 }
 
 impl From<&FunctionDefinition> for FunctionDispatch {

solx-mlir/src/context/function/dispatch.rs

@@ -93,6 +93,7 @@ impl<'context> Function<'context> {
             FunctionDispatch::Kind(function_kind) => {
                 operation_builder.kind(function_kind.attribute(context.melior))
             }
+            FunctionDispatch::Getter => operation_builder,
         };
         if let Some(selector_value) = selector {
             operation_builder = operation_builder

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

@@ -45,6 +45,16 @@ sol_dialect_attribute! {
     }
 }
 
+impl StateMutability {
+    /// Whether a callee of this mutability dispatches through a static call.
+    pub fn is_static(self) -> bool {
+        match self {
+            Self::Pure | Self::View => true,
+            Self::NonPayable | Self::Payable => false,
+        }
+    }
+}
+
 impl From<FunctionMutability> for StateMutability {
     fn from(mutability: FunctionMutability) -> Self {
         match mutability {

solx-mlir/src/ir/attributes.rs

@@ -157,6 +157,9 @@ sol_ops! {
     Value::code(address: value) -> value {
         CodeOperation.cont_addr(address).out(memory())
     }
+    Value::object_code(object_name: str) -> value {
+        ObjectCodeOperation.obj_name(str_attr(object_name)).out(memory())
+    }
     Value::bare_call(address: value, gas: value, amount: value, input: value) -> values {
         BareCallOperation.addr(address).gas(gas).val(amount).inp(input)
             .status(boolean()).ret_data(memory())
@@ -265,9 +268,9 @@ sol_ops! {
         DeleteOperation.reference(self)
     }
 
-    Place::gep(self, index: value, element_type: ty) -> place {
+    Place::gep | gep_no_panic_bounds (self, index: value, element_type: ty) -> place {
         GepOperation.base_addr(self).idx(index).addr(gep_of(element_type))
-    }
+    } flagged .no_panic_bounds;
     Place::map(self, key: value, entry_type: ty) -> place {
         MapOperation.mapping(self).key(key).addr(entry_type)
     }

solx-mlir/src/ir/mod.rs

@@ -195,8 +195,12 @@ impl<'context> Type<'context> {
         IntegerType::try_from(self.inner).is_ok()
     }
 
-    /// The bit width of this integer type. Panics on a non-integer type, so a caller must first
-    /// establish the type is an integer through [`Self::is_integer`].
+    /// Whether this is a signed integer type.
+    pub fn is_signed_integer(self) -> bool {
+        IntegerType::try_from(self.inner).is_ok_and(|integer| integer.is_signed())
+    }
+
+    /// The bit width of this integer type.
     pub fn integer_bit_width(self) -> u32 {
         IntegerType::try_from(self.inner)
             .expect("integer_bit_width called on a non-integer type")

solx-mlir/src/ir/type/mod.rs

@@ -64,6 +64,26 @@ impl<'context> Value<'context> {
         Self::constant_from_bigint(&BigInt::one(), result_type, context)
     }
 
+    /// Materialises the smallest value the integer `result_type` admits: `type(T).min`.
+    pub fn minimum(result_type: Type<'context>, context: &Context<'context>) -> Self {
+        let value = if result_type.is_signed_integer() {
+            -(BigInt::one() << (result_type.integer_bit_width() - 1))
+        } else {
+            BigInt::zero()
+        };
+        Self::constant_from_bigint(&value, result_type, context)
+    }
+
+    /// Materialises the largest value the integer `result_type` admits: `type(T).max`.
+    pub fn maximum(result_type: Type<'context>, context: &Context<'context>) -> Self {
+        let value = if result_type.is_signed_integer() {
+            (BigInt::one() << (result_type.integer_bit_width() - 1)) - 1
+        } else {
+            (BigInt::one() << result_type.integer_bit_width()) - 1
+        };
+        Self::constant_from_bigint(&value, result_type, context)
+    }
+
     /// Materialises an `i1` boolean constant.
     pub fn boolean(value: bool, context: &Context<'context>) -> Self {
         Self::constant(i64::from(value), Type::boolean(context.melior), context)

solx-mlir/src/ir/value.rs

@@ -0,0 +1,15 @@
+// RUN: solx --emit-mlir=sol %s | FileCheck %s
+
+// Assignment to a contract-qualified state variable (C.x = v): solc's
+// print-init crashes (SIGSEGV), so this is solx-only.
+
+// CHECK: sol.func @{{.*setNamespace.*}}
+// CHECK: %[[V:.*]] = sol.load %{{[0-9]+}} : !sol.ptr<ui256, Stack>, ui256
+// CHECK: %[[SLOT:.*]] = sol.addr_of @{{x.*}} : !sol.ptr<ui256, Storage>
+// CHECK: sol.store %[[V]], %[[SLOT]] : ui256, !sol.ptr<ui256, Storage>
+
+contract C {
+    uint256 x;
+
+    function setNamespace(uint256 v) public { C.x = v; }
+}

solx-mlir/tests/lit/assignment_namespace_state_var.sol

@@ -0,0 +1,26 @@
+// RUN: solx --emit-mlir=sol %s | FileCheck %s
+
+// Error and event .selector are compile-time constants: solc's print-init
+// crashes (SIGSEGV), so this is solx-only.
+
+// CHECK: sol.func @{{.*error_selector.*}}
+// CHECK:   sol.constant 816952677 : ui32
+// CHECK:   sol.bytes_cast %{{.*}} : ui32 to !sol.fixedbytes<4>
+
+// CHECK: sol.func @{{.*event_selector.*}}
+// CHECK:   sol.constant 48926247962583432353061649299097379571640188309989729032230735130183305912964 : ui256
+// CHECK:   sol.bytes_cast %{{.*}} : ui256 to !sol.fixedbytes<32>
+
+error MyError(uint256 x);
+
+contract C {
+    event MyEvent(uint256 indexed a);
+
+    function error_selector() external pure returns (bytes4) {
+        return MyError.selector;
+    }
+
+    function event_selector() external pure returns (bytes32) {
+        return MyEvent.selector;
+    }
+}