feat(slang): cast function call arguments to match parameter types

Store declared parameter types in function signatures and emit sol.cast
for each argument whose type differs from the callee's declared parameter
type. Also clean up inline melior:: paths across solx-slang by adding
proper use imports.

Author: hedgar2017

solx-mlir/src/context/function.rs

@@ -9,8 +9,8 @@ use melior::ir::Type;
 pub struct Function<'context> {
     /// The mangled MLIR function name.
     pub mlir_name: String,
-    /// Number of parameters.
-    pub parameter_count: usize,
+    /// Parameter types (MLIR-interned, exact types from the function signature).
+    pub parameter_types: Vec<Type<'context>>,
     /// Return types (MLIR-interned, exact types from the function signature).
     pub return_types: Vec<Type<'context>>,
 }
@@ -19,12 +19,12 @@ impl<'context> Function<'context> {
     /// Creates a new function metadata entry.
     pub fn new(
         mlir_name: String,
-        parameter_count: usize,
+        parameter_types: Vec<Type<'context>>,
         return_types: Vec<Type<'context>>,
     ) -> Self {
         Self {
             mlir_name,
-            parameter_count,
+            parameter_types,
             return_types,
         }
     }

solx-mlir/src/context/mod.rs

@@ -169,18 +169,19 @@ impl<'context> Context<'context> {
         &mut self,
         bare_name: &str,
         mlir_name: String,
-        parameter_count: usize,
+        parameter_types: Vec<Type<'context>>,
         return_types: Vec<Type<'context>>,
     ) {
         self.function_signatures
             .entry(bare_name.to_owned())
             .or_default()
-            .push(Function::new(mlir_name, parameter_count, return_types));
+            .push(Function::new(mlir_name, parameter_types, return_types));
     }
 
     /// Resolves a function call by bare name and argument count.
     ///
-    /// Returns the mangled MLIR name and the declared return types.
+    /// Returns the mangled MLIR name, declared parameter types, and return
+    /// types.
     ///
     /// # Errors
     ///
@@ -189,19 +190,23 @@ impl<'context> Context<'context> {
         &self,
         bare_name: &str,
         argument_count: usize,
-    ) -> anyhow::Result<(&str, &[Type<'context>])> {
+    ) -> anyhow::Result<(&str, &[Type<'context>], &[Type<'context>])> {
         let signatures = self
             .function_signatures
             .get(bare_name)
             .ok_or_else(|| anyhow::anyhow!("undefined function: {bare_name}"))?;
         // TODO: resolve overloads by parameter types, not just arity
         let matches: Vec<_> = signatures
             .iter()
-            .filter(|signature| signature.parameter_count == argument_count)
+            .filter(|signature| signature.parameter_types.len() == argument_count)
             .collect();
         match matches.len() {
             0 => anyhow::bail!("no overload of '{bare_name}' takes {argument_count} arguments"),
-            1 => Ok((matches[0].mlir_name.as_str(), &matches[0].return_types)),
+            1 => Ok((
+                matches[0].mlir_name.as_str(),
+                &matches[0].parameter_types,
+                &matches[0].return_types,
+            )),
             _ => {
                 let overloads: Vec<&str> = matches
                     .iter()

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

@@ -119,11 +119,17 @@ impl<'emitter, 'state, 'context, 'block> CallEmitter<'emitter, 'state, 'context,
             current_block = next_block;
         }
 
-        let (mlir_name, return_types) = self
+        let (mlir_name, parameter_types, return_types) = self
             .expression_emitter
             .state
             .resolve_function(&callee_name, argument_values.len())?;
 
+        // Cast arguments to match the callee's declared parameter types.
+        let builder = &self.expression_emitter.state.builder;
+        for (value, &param_type) in argument_values.iter_mut().zip(parameter_types) {
+            *value = builder.emit_sol_cast(*value, param_type, &current_block);
+        }
+
         if return_types.is_empty() {
             self.expression_emitter.state.builder.emit_sol_call(
                 mlir_name,

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

@@ -2,9 +2,12 @@
 //! Solidity type conversion classification and dispatch.
 //!
 
+use melior::ir::BlockRef;
 use melior::ir::Type;
+use melior::ir::Value;
 use melior::ir::ValueLike;
 use melior::ir::r#type::IntegerType;
+use melior::Context;
 use slang_solidity::backend::ir::ast::Type as SlangType;
 
 /// Classification of Solidity type conversions.
@@ -24,7 +27,7 @@ impl<'context> TypeConversion<'context> {
     /// Maps a Slang semantic type to an MLIR type.
     pub fn resolve_slang_type(
         slang_type: &SlangType,
-        context: &'context melior::Context,
+        context: &'context Context,
         builder: &solx_mlir::Builder<'context>,
     ) -> Type<'context> {
         match slang_type {
@@ -63,10 +66,10 @@ impl<'context> TypeConversion<'context> {
     /// Emits the conversion, returning the cast value.
     pub fn emit<'block>(
         self,
-        value: melior::ir::Value<'context, 'block>,
+        value: Value<'context, 'block>,
         builder: &solx_mlir::Builder<'context>,
-        block: &melior::ir::BlockRef<'context, 'block>,
-    ) -> melior::ir::Value<'context, 'block>
+        block: &BlockRef<'context, 'block>,
+    ) -> Value<'context, 'block>
     where
         'context: 'block,
     {
@@ -77,7 +80,7 @@ impl<'context> TypeConversion<'context> {
             }
             Self::Address => {
                 let address_type = builder.types.sol_address;
-                let truncated = if melior::ir::r#type::IntegerType::try_from(value.r#type()).is_ok()
+                let truncated = if IntegerType::try_from(value.r#type()).is_ok()
                 {
                     let ui160 = builder.types.ui160;
                     builder.emit_sol_cast(value, ui160, block)

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

@@ -7,6 +7,7 @@ use std::str::FromStr;
 use melior::ir::Location;
 use melior::ir::Value;
 use melior::ir::operation::Operation;
+use melior::Context;
 
 use solx_mlir::CmpPredicate;
 use solx_mlir::ods::sol::AddOperation;
@@ -130,7 +131,7 @@ impl Operator {
     pub fn emit_sol_binary_operation<'context>(
         self,
         checked: bool,
-        context: &'context melior::Context,
+        context: &'context Context,
         location: Location<'context>,
         lhs: Value<'context, '_>,
         rhs: Value<'context, '_>,

solx-slang/src/ast/contract/function/mod.rs

@@ -9,7 +9,9 @@ use std::collections::HashMap;
 use std::rc::Rc;
 
 use melior::ir::BlockLike;
+use melior::ir::BlockRef;
 use melior::ir::Type;
+use melior::ir::Value;
 use slang_solidity::backend::SemanticAnalysis;
 use slang_solidity::backend::abi::AbiEntry;
 use slang_solidity::backend::ir::ast::ElementaryType;
@@ -64,7 +66,7 @@ impl<'state, 'context> FunctionEmitter<'state, 'context> {
     pub fn emit_sol(
         &self,
         function: &FunctionDefinition,
-        contract_body: &melior::ir::BlockRef<'context, '_>,
+        contract_body: &BlockRef<'context, '_>,
     ) -> anyhow::Result<String> {
         let Some(ref body) = function.body() else {
             // Abstract or interface function — no codegen needed.
@@ -133,7 +135,7 @@ impl<'state, 'context> FunctionEmitter<'state, 'context> {
                 .map(|id| id.name())
                 .unwrap_or_else(|| "_".to_owned());
             let parameter_type = mlir_parameter_types[index];
-            let parameter_value: melior::ir::Value<'context, '_> =
+            let parameter_value: Value<'context, '_> =
                 function_entry_block.argument(index)?.into();
             let pointer = self
                 .state
@@ -259,7 +261,7 @@ impl<'state, 'context> FunctionEmitter<'state, 'context> {
     fn emit_default_return(
         &self,
         result_types: &[Type<'context>],
-        block: &melior::ir::BlockRef<'context, '_>,
+        block: &BlockRef<'context, '_>,
     ) {
         if block.terminator().is_some() {
             return;

solx-slang/src/ast/contract/function/statement/control_flow.rs

@@ -2,7 +2,9 @@
 //! Control flow statement lowering: if/else, for, while, do-while.
 //!
 
+use melior::ir::Block;
 use melior::ir::BlockRef;
+use melior::ir::Region;
 use melior::ir::RegionLike;
 
 use slang_solidity::backend::ir::ast::ForStatementCondition;
@@ -257,8 +259,8 @@ impl<'state, 'context, 'block> StatementEmitter<'state, 'context, 'block> {
     /// Appends a dead block with `sol.yield` to a region whose live block
     /// already terminated (e.g. with `sol.return`). Matches the solc pattern
     /// where each `sol.if` region always ends with a `sol.yield` block.
-    fn emit_dead_yield(&self, region: &melior::ir::Region<'context>) {
-        let dead_block = melior::ir::Block::new(&[]);
+    fn emit_dead_yield(&self, region: &Region<'context>) {
+        let dead_block = Block::new(&[]);
         self.state.builder.emit_sol_yield(&dead_block);
         region.append_block(dead_block);
     }

solx-slang/src/ast/contract/mod.rs

@@ -107,8 +107,18 @@ impl<'state, 'context> ContractEmitter<'state, 'context> {
             }
             let name = FunctionEmitter::mlir_base_name(&function);
             let mlir_name = FunctionEmitter::mlir_function_name(&function);
-            let parameter_count = function.parameters().len();
-            let return_types: Vec<melior::ir::Type<'_>> = function
+            let parameter_types = function
+                .parameters()
+                .iter()
+                .map(|param| {
+                    TypeConversion::resolve_slang_type(
+                        &param.get_type().expect("parameter type binding resolved"),
+                        self.state.builder.context,
+                        &self.state.builder,
+                    )
+                })
+                .collect();
+            let return_types = function
                 .returns()
                 .map(|returns| {
                     returns
@@ -125,7 +135,7 @@ impl<'state, 'context> ContractEmitter<'state, 'context> {
                 .unwrap_or_default();
 
             self.state
-                .register_function_signature(&name, mlir_name, parameter_count, return_types);
+                .register_function_signature(&name, mlir_name, parameter_types, return_types);
         }
     }