feat: add graph visualization for compiled programs

doc/releases/changelog-dev.md

@@ -2,6 +2,16 @@
 
 <h3>New features since last release</h3>
 
+* Compiled programs can be visualized.
+  [(#2213)](https://github.com/PennyLaneAI/catalyst/pull/2213)
+  [(#2229)](https://github.com/PennyLaneAI/catalyst/pull/2229)
+  [(#2214)](https://github.com/PennyLaneAI/catalyst/pull/2214)
+  [(#2246)](https://github.com/PennyLaneAI/catalyst/pull/2246)
+  [(#2231)](https://github.com/PennyLaneAI/catalyst/pull/2231)
+  [(#2285)](https://github.com/PennyLaneAI/catalyst/pull/2285)
+  [(#2234)](https://github.com/PennyLaneAI/catalyst/pull/2234)
+  [(#2218)](https://github.com/PennyLaneAI/catalyst/pull/2218)
+
 * Catalyst now features a unified compilation framework, which enables users and developers to design
   and implement compilation passes in Python in addition to C++, on the same Catalyst IR. The Python
   interface relies on the xDSL library to represent and manipulate programs (analogous to the MLIR library

frontend/catalyst/compiler.py

@@ -381,11 +381,11 @@ def to_llvmir(*args, stdin=None, options: Optional[CompileOptions] = None):
 
 
 def to_mlir_opt(
-    *args, stdin=None, options: Optional[CompileOptions] = None, using_python_compiler=False
+    *args, stdin=None, options: Optional[CompileOptions] = None, using_unified_compiler=False
 ):
     """echo ${input} | catalyst --tool=opt *args *opts -"""
     # Check if we need to use the Python interface for xDSL passes
-    if using_python_compiler:
+    if using_unified_compiler:
         # Use the Python interface path for xDSL passes
         # pylint: disable-next=import-outside-toplevel
         from catalyst.python_interface import Compiler as UnifiedCompiler
@@ -547,7 +547,7 @@ def check_nested_operations(op):
             return False
 
     @debug_logger
-    def is_using_python_compiler(self, mlir_module=None):
+    def is_using_unified_compiler(self, mlir_module=None):
         """Returns true if we need the Python interface path.
 
         This happens when:
@@ -649,7 +649,7 @@ def run(self, mlir_module, *args, **kwargs):
         Returns:
             (str): filename of shared object
         """
-        using_python_compiler = self.is_using_python_compiler(mlir_module)
+        using_python_compiler = self.is_using_unified_compiler(mlir_module)
         workspace = args[0] if args else kwargs.get("workspace")
         module_name = str(mlir_module.operation.attributes["sym_name"]).replace('"', "")
         ir = mlir_module.operation.get_asm(

frontend/catalyst/jit.py

@@ -582,13 +582,13 @@ def mlir_opt(self):
         """Obtain the MLIR representation after optimization"""
         if not self.mlir_module:
             return None
-        using_python_compiler = self.compiler.is_using_python_compiler(self.mlir_module)
+        using_unified_compiler = self.compiler.is_using_unified_compiler(self.mlir_module)
         stdin = self.mlir_module.operation.get_asm(
-            print_generic_op_form=using_python_compiler,
+            print_generic_op_form=using_unified_compiler,
             enable_debug_info=self.compile_options.use_nameloc,
         )
         return to_mlir_opt(
-            stdin=stdin, options=self.compile_options, using_python_compiler=using_python_compiler
+            stdin=stdin, options=self.compile_options, using_unified_compiler=using_unified_compiler
         )
 
     @debug_logger

frontend/catalyst/python_interface/dialects/__init__.py

@@ -14,10 +14,35 @@
 
 """This submodule contains xDSL dialects for the unified compiler."""
 
+from .catalyst import Catalyst
+from .mbqc import MBQC
+from .qec import QEC
+from .quantum import Quantum
+from .stablehlo import StableHLO
+from .transform import Transform
+
+__all__ = ["Catalyst", "MBQC", "Quantum", "QEC", "StableHLO", "Transform"]
+
+# Copyright 2025 Xanadu Quantum Technologies Inc.
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""This submodule contains xDSL dialects for the unified compiler."""
+
 from .catalyst import Catalyst
 from .mbqc import MBQC
 from .qec import QEC
 from .quantum import Quantum
 from .stablehlo import StableHLO
 
 __all__ = ["Catalyst", "MBQC", "Quantum", "QEC", "StableHLO"]

frontend/catalyst/python_interface/dialects/transform.py

@@ -0,0 +1,122 @@
+# Copyright 2025 Xanadu Quantum Technologies Inc.
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+This file contains an updated version of the transform dialect.
+As of the time of writing, xDSL uses the MLIR released with LLVM's
+version 20.1.7. However, https://github.com/PennyLaneAI/catalyst/pull/1916
+will be updating MLIR where the transform dialect has the
+`apply_registered_pass` operation re-defined.
+
+See the following changelog on the above PR
+
+    Things related to transform.apply_registered_pass op:
+
+    It now takes in a dynamic_options
+
+    [MLIR][Transform] Allow ApplyRegisteredPassOp to take options as
+    a param llvm/llvm-project#142683. We don't need to use this as all our pass options are static.
+    https://github.com/llvm/llvm-project/pull/142683
+
+    The options it takes in are now dictionaries instead of strings
+    [MLIR][Transform] apply_registered_pass op's options as a dict llvm/llvm-project#143159
+    https://github.com/llvm/llvm-project/pull/143159
+
+This file will re-define the apply_registered_pass operation in xDSL
+and the transform dialect.
+
+Once xDSL moves to a newer version of MLIR, these changes should
+be contributed upstream.
+"""
+
+from xdsl.dialects.builtin import Dialect
+from xdsl.dialects.transform import ApplyRegisteredPassOp as xApplyRegisteredPassOp
+from xdsl.dialects.transform import (
+    DictionaryAttr,
+    StringAttr,
+)
+from xdsl.dialects.transform import Transform as xTransform
+from xdsl.dialects.transform import (
+    TransformHandleType,
+    irdl_op_definition,
+    operand_def,
+    prop_def,
+    result_def,
+)
+from xdsl.ir import Attribute, SSAValue
+from xdsl.irdl import IRDLOperation, ParsePropInAttrDict
+
+
+# pylint: disable=line-too-long
+@irdl_op_definition
+class ApplyRegisteredPassOp(IRDLOperation):
+    """
+    See external [documentation](https://mlir.llvm.org/docs/Dialects/Transform/#transformapply_registered_pass-transformapplyregisteredpassop).
+    """
+
+    name = "transform.apply_registered_pass"
+
+    options = prop_def(DictionaryAttr, default_value=DictionaryAttr({}))
+    pass_name = prop_def(StringAttr)
+    target = operand_def(TransformHandleType)
+    result = result_def(TransformHandleType)
+    # While this assembly format doesn't match
+    # the one in upstream MLIR,
+    # this is because xDSL currently lacks CustomDirectives
+    # https://mlir.llvm.org/docs/DefiningDialects/Operations/#custom-directives
+    # https://github.com/xdslproject/xdsl/pull/4829
+    # However, storing the property in the attribute should still work
+    # specially when parsing and printing in generic format.
+    # Which is how Catalyst and XDSL currently communicate at the moment.
+    # TODO: Add test.
+    assembly_format = "$pass_name `to` $target attr-dict `:` functional-type(operands, results)"
+    irdl_options = [ParsePropInAttrDict()]
+
+    def __init__(
+        self,
+        pass_name: str | StringAttr,
+        target: SSAValue,
+        options: dict[str | StringAttr, Attribute | str | bool | int] | None = None,
+    ):
+        if isinstance(pass_name, str):
+            pass_name = StringAttr(pass_name)
+
+        if isinstance(options, dict):
+            options = DictionaryAttr(options)
+
+        super().__init__(
+            properties={
+                "pass_name": pass_name,
+                "options": options,
+            },
+            operands=[target],
+            result_types=[target.type],
+        )
+
+
+# Copied over from xDSL's sources
+# the main difference will be the use
+# of a different ApplyRegisteredPassOp
+operations = list(xTransform.operations)
+del operations[operations.index(xApplyRegisteredPassOp)]
+operations.append(ApplyRegisteredPassOp)
+
+Transform = Dialect(
+    "transform",
+    [
+        *operations,
+    ],
+    [
+        *xTransform.attributes,
+    ],
+)