feat(slang): emit default constructor with FunctionKind attribute

Skip modifier functions during emission, track whether a constructor
exists, and emit a default empty constructor with FunctionKind::Constructor
when the contract doesn't define one. Map each Slang FunctionKind to
the corresponding Sol dialect FunctionKind attribute on sol.func.

Author: hedgar2017

solx-mlir/sol_attr_stubs.cpp

@@ -32,6 +32,14 @@ MlirAttribute solxCreateStateMutabilityAttr(MlirContext ctx, uint32_t mutability
     return wrap(attr);
 }
 
+MlirAttribute solxCreateFunctionKindAttr(MlirContext ctx, uint32_t kind) {
+    if (kind > 2) abort();
+    auto *context = unwrap(ctx);
+    auto attr = mlir::sol::FunctionKindAttr::get(
+        context, static_cast<mlir::sol::FunctionKind>(kind));
+    return wrap(attr);
+}
+
 MlirAttribute solxCreateEvmVersionAttr(MlirContext ctx, uint32_t version) {
     if (version < 11 || version > 13) abort();
     auto *context = unwrap(ctx);

solx-mlir/src/attributes/function_kind.rs

@@ -0,0 +1,18 @@
+//!
+//! Sol dialect function kind attribute.
+//!
+
+/// Sol dialect function kind.
+///
+/// Maps to the `FunctionKindAttr` values in the C++ Sol dialect.
+/// Regular functions do not carry a kind attribute.
+#[repr(u32)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum FunctionKind {
+    /// Constructor function.
+    Constructor = 0,
+    /// Fallback function.
+    Fallback = 1,
+    /// Receive function.
+    Receive = 2,
+}

solx-mlir/src/attributes/mod.rs

@@ -4,4 +4,5 @@
 
 pub mod cmp_predicate;
 pub mod contract_kind;
+pub mod function_kind;
 pub mod state_mutability;

solx-mlir/src/context/builder.rs

@@ -249,7 +249,7 @@ impl<'context> Builder<'context> {
     }
 
     /// Emits a `sol.func` operation with the given name, parameter types,
-    /// result types, selector, and state mutability.
+    /// result types, selector, state mutability, and optional function kind.
     ///
     /// Returns the entry block of the function body for appending operations.
     ///
@@ -263,6 +263,7 @@ impl<'context> Builder<'context> {
         result_types: &[Type<'context>],
         selector: Option<u32>,
         state_mutability: StateMutability,
+        kind: Option<crate::FunctionKind>,
         block: &BlockRef<'context, 'block>,
     ) -> BlockRef<'context, 'block> {
         let function_type = FunctionType::new(self.context, parameter_types, result_types);
@@ -298,6 +299,17 @@ impl<'context> Builder<'context> {
             ),
         ];
 
+        if let Some(function_kind) = kind {
+            // SAFETY: `solxCreateFunctionKindAttr` returns a valid MlirAttribute.
+            let kind_attribute = unsafe {
+                Attribute::from_raw(crate::ffi::solxCreateFunctionKindAttr(
+                    self.context.to_raw(),
+                    function_kind as u32,
+                ))
+            };
+            attributes.push((Identifier::new(self.context, "kind"), kind_attribute));
+        }
+
         if let Some(selector_value) = selector {
             attributes.push((
                 Identifier::new(self.context, "selector"),

solx-mlir/src/ffi.rs

@@ -75,6 +75,9 @@ unsafe extern "C" {
         mutability: u32,
     ) -> mlir_sys::MlirAttribute;
 
+    /// Creates a `FunctionKindAttr` (0=Constructor, 1=Fallback, 2=Receive).
+    pub fn solxCreateFunctionKindAttr(context: MlirContext, kind: u32) -> mlir_sys::MlirAttribute;
+
     /// Creates an `EvmVersionAttr`.
     pub fn solxCreateEvmVersionAttr(context: MlirContext, version: u32) -> mlir_sys::MlirAttribute;
 
@@ -104,8 +107,6 @@ unsafe extern "C" {
 pub fn block_parent_region<'context, 'block>(
     block: &melior::ir::BlockRef<'context, 'block>,
 ) -> melior::ir::RegionRef<'context, 'block> {
-    // SAFETY: The block is attached (guaranteed by melior's ownership model).
-    // `mlirBlockGetParentRegion` returns a non-owning handle to the parent.
     // SAFETY: The block is attached (guaranteed by melior's ownership model).
     // `mlirBlockGetParentRegion` returns a non-owning handle to the parent.
     unsafe {

solx-mlir/src/lib.rs

@@ -16,6 +16,7 @@ pub mod llvm_module;
 
 pub use self::attributes::cmp_predicate::CmpPredicate;
 pub use self::attributes::contract_kind::ContractKind;
+pub use self::attributes::function_kind::FunctionKind;
 pub use self::attributes::state_mutability::StateMutability;
 pub use self::context::Context;
 pub use self::context::builder::Builder;

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

@@ -104,12 +104,23 @@ impl<'state, 'context> FunctionEmitter<'state, 'context> {
 
         let state_mutability = Self::map_state_mutability(function);
 
+        let mlir_kind = match function.kind() {
+            FunctionKind::Constructor => Some(solx_mlir::FunctionKind::Constructor),
+            FunctionKind::Fallback | FunctionKind::Unnamed => {
+                Some(solx_mlir::FunctionKind::Fallback)
+            }
+            FunctionKind::Receive => Some(solx_mlir::FunctionKind::Receive),
+            FunctionKind::Regular => None,
+            FunctionKind::Modifier => unreachable!("modifiers are filtered before emission"),
+        };
+
         let function_entry_block = self.state.builder.emit_sol_func(
             &mlir_name,
             &mlir_parameter_types,
             &result_types,
             selector,
             state_mutability,
+            mlir_kind,
             contract_body,
         );
 

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

@@ -10,6 +10,7 @@ use std::rc::Rc;
 
 use slang_solidity::backend::SemanticAnalysis;
 use slang_solidity::backend::ir::ast::ContractDefinition;
+use slang_solidity::backend::ir::ast::FunctionKind;
 use slang_solidity::cst::NodeId;
 
 use solx_mlir::Context;
@@ -68,18 +69,41 @@ impl<'state, 'context> ContractEmitter<'state, 'context> {
                 .emit_sol_state_var(&format!("slot_{slot}"), *slot, &contract_body);
         }
 
+        let mut has_constructor = false;
         for function in contract.functions() {
+            match function.kind() {
+                FunctionKind::Modifier => continue,
+                FunctionKind::Constructor => has_constructor = true,
+                _ => {}
+            }
             let emitter = FunctionEmitter::new(&self.semantic, self.state, &storage_layout);
             emitter.emit_sol(&function, &contract_body)?;
         }
 
+        // Emit a default constructor if the contract doesn't define one.
+        if !has_constructor {
+            let entry = self.state.builder.emit_sol_func(
+                "constructor()",
+                &[],
+                &[],
+                None,
+                solx_mlir::StateMutability::NonPayable,
+                Some(solx_mlir::FunctionKind::Constructor),
+                &contract_body,
+            );
+            self.state.builder.emit_sol_return(&[], &entry);
+        }
+
         Ok(())
     }
 
     /// Pre-registers all function signatures for call resolution before bodies
     /// are emitted.
     fn pre_register_functions(&mut self, contract: &ContractDefinition) {
         for function in contract.functions() {
+            if matches!(function.kind(), FunctionKind::Modifier) {
+                continue;
+            }
             let name = FunctionEmitter::mlir_base_name(&function);
             let mlir_name = FunctionEmitter::mlir_function_name(&function);
             let parameter_count = function.parameters().len();

solx-slang/src/ast/mod.rs

@@ -46,7 +46,8 @@ impl<'state, 'context> AstEmitter<'state, 'context> {
     /// # Errors
     ///
     /// Returns an error if code generation encounters unsupported constructs.
-    /// Returns `Some(contract_name)` if a contract was emitted, `None` otherwise.
+    /// Returns `Some((contract_name, method_identifiers))` if a contract was
+    /// emitted, `None` otherwise.
     pub fn emit(
         &mut self,
         unit: &SourceUnit,