core: add CallableOpInterface and use in interpreter

docs/Toy/toy/__main__.py

@@ -83,7 +83,7 @@ def main(path: Path, emit: str):
     if emit == "interpret":
         interpreter = Interpreter(module_op)
         interpreter.register_implementations(ToyFunctions())
-        interpreter.run_op("main", ())
+        interpreter.call_op("main", ())
         return
 
     print(f"Unknown option {emit}")

docs/Toy/toy/dialects/toy.py

@@ -48,7 +48,13 @@
 from xdsl.utils.exceptions import VerifyException
 from xdsl.utils.hints import isa
 
-from xdsl.traits import Pure, OpTrait, SymbolOpInterface, IsTerminator
+from xdsl.traits import (
+    CallableOpInterface,
+    Pure,
+    OpTrait,
+    SymbolOpInterface,
+    IsTerminator,
+)
 
 TensorTypeF64: TypeAlias = TensorType[Float64Type]
 UnrankedTensorTypeF64: TypeAlias = UnrankedTensorType[Float64Type]
@@ -167,6 +173,13 @@ def verify_(self):
                         )
 
 
+class FuncOpCallableInterface(CallableOpInterface):
+    @classmethod
+    def get_callable_region(cls, op: Operation) -> Region:
+        assert isinstance(op, FuncOp)
+        return op.body
+
+
 @irdl_op_definition
 class FuncOp(IRDLOperation):
     """
@@ -191,7 +204,7 @@ class FuncOp(IRDLOperation):
     function_type: FunctionType = attr_def(FunctionType)
     sym_visibility: StringAttr | None = opt_attr_def(StringAttr)
 
-    traits = frozenset((SymbolOpInterface(),))
+    traits = frozenset((SymbolOpInterface(), FuncOpCallableInterface()))
 
     def __init__(
         self,

docs/Toy/toy/interpreter.py

@@ -52,17 +52,6 @@ def run_print(
         interpreter.print(f"{args[0]}")
         return ()
 
-    @impl(toy.FuncOp)
-    def run_func(
-        self, interpreter: Interpreter, op: toy.FuncOp, args: tuple[Any, ...]
-    ) -> tuple[Any, ...]:
-        results = interpreter.run_ssacfg_region(op.body, args, op.sym_name.data)
-        interpreter.interpreter_assert(
-            results is not None, f"Expected toy.func region to have a terminator"
-        )
-        assert results is not None
-        return results
-
     @impl(toy.ConstantOp)
     def run_const(
         self, interpreter: Interpreter, op: toy.ConstantOp, args: tuple[Any, ...]
@@ -118,7 +107,7 @@ def run_return(
     def run_generic_call(
         self, interpreter: Interpreter, op: toy.GenericCallOp, args: tuple[Any, ...]
     ) -> tuple[Any, ...]:
-        return interpreter.run_op(op.callee.string_value(), args)
+        return interpreter.call_op(op.callee.string_value(), args)
 
     @impl(toy.TransposeOp)
     def run_transpose(

xdsl/interpreter.py

@@ -16,7 +16,7 @@
 from xdsl.dialects.builtin import ModuleOp
 from xdsl.ir import OperationInvT, SSAValue, Operation
 from xdsl.ir.core import Block, Region
-from xdsl.traits import IsTerminator, SymbolOpInterface
+from xdsl.traits import CallableOpInterface, IsTerminator, SymbolOpInterface
 from xdsl.utils.exceptions import InterpretationError
 
 
@@ -323,13 +323,39 @@ def run_op(self, op: Operation | str, inputs: PythonValues) -> PythonValues:
         """
         Calls the implementation for the given operation.
         """
-        # TODO: replace this with CallableOp trait implementation.
         if isinstance(op, str):
             op = self.get_op_for_symbol(op)
 
         result = self._impls.run(self, op, inputs)
         return result.values
 
+    def call_op(self, op: Operation | str, inputs: PythonValues) -> PythonValues:
+        """
+        Calls the implementation for the given operation.
+        """
+        if isinstance(op, str):
+            name = op
+            op = self.get_op_for_symbol(op)
+        else:
+            name = "unknown"
+
+        interface = op.get_trait(CallableOpInterface)
+
+        self.interpreter_assert(
+            interface is not None,
+            f"Operation {op.name} does not have trait CallableOpInterface",
+        )
+        assert interface is not None
+
+        body = interface.get_callable_region(op)
+
+        results = self.run_ssacfg_region(body, inputs, name)
+        self.interpreter_assert(
+            results is not None, f"Expected {op.name} body to have a terminator"
+        )
+        assert results is not None
+        return results
+
     def run_block(self, block: Block, args: PythonValues) -> PythonValues | None:
         """
         Interpret a basic block, using `args` as the block argument values.

xdsl/traits.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 from dataclasses import dataclass, field
+import abc
 from xdsl.utils.exceptions import VerifyException
 from typing import (
     TYPE_CHECKING,
@@ -150,3 +151,21 @@ def verify(self, op: Operation) -> None:
                 f'Operation {op.name} must have a "sym_name" attribute of type '
                 f"`StringAttr` to conform to {SymbolOpInterface.__name__}"
             )
+
+
+class CallableOpInterface(OpTrait, abc.ABC):
+    """
+    Interface for function-like Operations that can be called in a generic way.
+
+    Please see MLIR documentation for CallOpInterface and CallableOpInterface for more
+    information.
+
+    https://mlir.llvm.org/docs/Interfaces/#callinterfaces
+    """
+
+    @classmethod
+    def get_callable_region(cls, op: Operation) -> Region:
+        """
+        Returns the body of the operation
+        """
+        raise NotImplementedError