Implement is_optional_symbol for MLIR compliance.

tests/test_traits.py

@@ -25,9 +25,10 @@
     attr_def,
     irdl_op_definition,
     operand_def,
+    opt_attr_def,
     result_def,
 )
-from xdsl.traits import SymbolOpInterface
+from xdsl.traits import OptionalSymbolOpInterface, SymbolOpInterface
 from xdsl.utils.exceptions import VerifyException
 from xdsl.utils.test_value import TestSSAValue
 
@@ -295,3 +296,31 @@ class SymNameOp(IRDLOperation):
 
     op2 = SymNameOp(attributes={"sym_name": StringAttr("symbol_name")})
     op2.verify()
+
+
+def test_optional_symbol_op_interface():
+    """
+    Test that operations that conform to OptionalSymbolOpInterface have necessary attributes.
+    """
+
+    @irdl_op_definition
+    class OptionalSymNameOp(IRDLOperation):
+        name = "no_sym_name"
+
+        sym_name = opt_attr_def(StringAttr)
+
+        traits = frozenset((OptionalSymbolOpInterface(),))
+
+    non_symbol = OptionalSymNameOp()
+    interface = non_symbol.get_trait(SymbolOpInterface)
+    assert interface is not None
+    assert interface.is_optional_symbol(non_symbol)
+    non_symbol.verify()
+    assert SymbolOpInterface.get_sym_attr_name(non_symbol) is None
+
+    symbol = OptionalSymNameOp(attributes={"sym_name": StringAttr("main")})
+    interface = symbol.get_trait(SymbolOpInterface)
+    assert interface is not None
+    assert interface.is_optional_symbol(symbol)
+    symbol.verify()
+    assert SymbolOpInterface.get_sym_attr_name(symbol) == StringAttr("main")

xdsl/dialects/builtin.py

@@ -53,7 +53,7 @@
     var_region_def,
     var_result_def,
 )
-from xdsl.traits import IsolatedFromAbove, NoTerminator
+from xdsl.traits import IsolatedFromAbove, NoTerminator, OptionalSymbolOpInterface
 from xdsl.utils.exceptions import VerifyException
 
 if TYPE_CHECKING:
@@ -1217,7 +1217,9 @@ class ModuleOp(IRDLOperation):
 
     body: Region = region_def("single_block")
 
-    traits = frozenset([IsolatedFromAbove(), NoTerminator()])
+    traits = frozenset(
+        [IsolatedFromAbove(), NoTerminator(), OptionalSymbolOpInterface()]
+    )
 
     def __init__(
         self,

xdsl/interpreter.py

@@ -372,7 +372,8 @@ def symbol_table(self) -> dict[str, Operation]:
             for op in self.module.walk():
                 if op.has_trait(SymbolOpInterface):
                     symbol = SymbolOpInterface.get_sym_attr_name(op)
-                    self._symbol_table[symbol.data] = op
+                    if symbol:
+                        self._symbol_table[symbol.data] = op
         return self._symbol_table
 
     def get_values(self, values: Iterable[SSAValue]) -> tuple[Any, ...]:

xdsl/traits.py

@@ -212,21 +212,38 @@ class SymbolOpInterface(OpTrait):
     """
 
     @staticmethod
-    def get_sym_attr_name(op: Operation) -> StringAttr:
+    def get_sym_attr_name(op: Operation) -> StringAttr | None:
         """
         Returns the symbol of the operation
         """
         # import builtin here to avoid circular import
         from xdsl.dialects.builtin import StringAttr
 
+        concrete = op.get_trait(SymbolOpInterface)
+        assert concrete is not None
+        if concrete.is_optional_symbol(op) and "sym_name" not in op.attributes:
+            return None
         attr = op.attributes["sym_name"]
         assert isinstance(attr, StringAttr)
         return attr
 
+    @staticmethod
+    def is_optional_symbol(op: Operation) -> bool:
+        """
+        Returns true if this operation optionally defines a symbol based on the
+        presence of the symbol name.
+        """
+        return False
+
     def verify(self, op: Operation) -> None:
         # import builtin here to avoid circular import
         from xdsl.dialects.builtin import StringAttr
 
+        # If this is an optional symbol, bail out early if possible.
+        concrete = op.get_trait(SymbolOpInterface)
+        assert concrete is not None
+        if concrete.is_optional_symbol(op) and "sym_name" not in op.attributes:
+            return
         if "sym_name" not in op.attributes or not isinstance(
             op.attributes["sym_name"], StringAttr
         ):
@@ -236,6 +253,16 @@ def verify(self, op: Operation) -> None:
             )
 
 
+class OptionalSymbolOpInterface(SymbolOpInterface):
+    """
+    Helper interface specialization for an optional Symbol.
+    """
+
+    @staticmethod
+    def is_optional_symbol(op: Operation) -> bool:
+        return True
+
+
 class CallableOpInterface(OpTrait, abc.ABC):
     """
     Interface for function-like Operations that can be called in a generic way.