bloqade-circuit 0.1.0__py3-none-any.whl

bloqade/qasm2/dialects/uop/_emit.py

@@ -0,0 +1,211 @@
+from kirin import interp
+
+from bloqade.qasm2.parse import ast
+from bloqade.qasm2.emit.gate import EmitQASM2Gate, EmitQASM2Frame
+
+from . import stmts
+from ._dialect import dialect
+
+
+@dialect.register(key="emit.qasm2.gate")
+class UOp(interp.MethodTable):
+
+    @interp.impl(stmts.CX)
+    def emit_cx(
+        self,
+        emit: EmitQASM2Gate,
+        frame: EmitQASM2Frame,
+        stmt: stmts.CX,
+    ):
+        ctrl = emit.assert_node((ast.Bit, ast.Name), frame.get(stmt.ctrl))
+        qarg = emit.assert_node((ast.Bit, ast.Name), frame.get(stmt.qarg))
+        frame.body.append(ast.CXGate(ctrl=ctrl, qarg=qarg))
+        return ()
+
+    @interp.impl(stmts.UGate)
+    def emit_ugate(
+        self,
+        emit: EmitQASM2Gate,
+        frame: EmitQASM2Frame,
+        stmt: stmts.UGate,
+    ):
+        theta = emit.assert_node(ast.Expr, frame.get(stmt.theta))
+        phi = emit.assert_node(ast.Expr, frame.get(stmt.phi))
+        lam = emit.assert_node(ast.Expr, frame.get(stmt.lam))
+        qarg = emit.assert_node((ast.Bit, ast.Name), frame.get(stmt.qarg))
+        frame.body.append(ast.UGate(theta=theta, phi=phi, lam=lam, qarg=qarg))
+        return ()
+
+    @interp.impl(stmts.Barrier)
+    def emit_barrier(
+        self,
+        emit: EmitQASM2Gate,
+        frame: EmitQASM2Frame,
+        stmt: stmts.Barrier,
+    ):
+        qargs = [
+            emit.assert_node((ast.Bit, ast.Name), frame.get(qarg))
+            for qarg in stmt.qargs
+        ]
+        frame.body.append(ast.Barrier(qargs=qargs))
+        return ()
+
+    @interp.impl(stmts.SX)
+    @interp.impl(stmts.SXdag)
+    @interp.impl(stmts.Id)
+    @interp.impl(stmts.H)
+    @interp.impl(stmts.X)
+    @interp.impl(stmts.Y)
+    @interp.impl(stmts.Z)
+    @interp.impl(stmts.S)
+    @interp.impl(stmts.Sdag)
+    @interp.impl(stmts.T)
+    @interp.impl(stmts.Tdag)
+    def emit_single_qubit_gate(
+        self, emit: EmitQASM2Gate, frame: EmitQASM2Frame, stmt: stmts.SingleQubitGate
+    ):
+        qarg = emit.assert_node((ast.Bit, ast.Name), frame.get(stmt.qarg))
+        frame.body.append(
+            ast.Instruction(name=ast.Name(stmt.name), params=[], qargs=[qarg])
+        )
+        return ()
+
+    @interp.impl(stmts.RX)
+    @interp.impl(stmts.RY)
+    @interp.impl(stmts.RZ)
+    def emit_rotation(
+        self,
+        emit: EmitQASM2Gate,
+        frame: EmitQASM2Frame,
+        stmt: stmts.RX | stmts.RY | stmts.RZ,
+    ):
+        theta = emit.assert_node(ast.Expr, frame.get(stmt.theta))
+        qarg = emit.assert_node((ast.Bit, ast.Name), frame.get(stmt.qarg))
+        frame.body.append(
+            ast.Instruction(name=ast.Name(stmt.name), params=[theta], qargs=[qarg])
+        )
+        return ()
+
+    @interp.impl(stmts.U1)
+    def emit_u1(self, emit: EmitQASM2Gate, frame: EmitQASM2Frame, stmt: stmts.U1):
+        lam = emit.assert_node(ast.Expr, frame.get(stmt.lam))
+        qarg = emit.assert_node((ast.Bit, ast.Name), frame.get(stmt.qarg))
+        frame.body.append(
+            ast.Instruction(name=ast.Name(stmt.name), params=[lam], qargs=[qarg])
+        )
+        return ()
+
+    @interp.impl(stmts.U2)
+    def emit_u2(self, emit: EmitQASM2Gate, frame: EmitQASM2Frame, stmt: stmts.U2):
+        phi = emit.assert_node(ast.Expr, frame.get(stmt.phi))
+        lam = emit.assert_node(ast.Expr, frame.get(stmt.lam))
+        qarg = emit.assert_node((ast.Bit, ast.Name), frame.get(stmt.qarg))
+        frame.body.append(
+            ast.Instruction(name=ast.Name(stmt.name), params=[phi, lam], qargs=[qarg])
+        )
+        return ()
+
+    @interp.impl(stmts.Swap)
+    @interp.impl(stmts.CSX)
+    @interp.impl(stmts.CZ)
+    @interp.impl(stmts.CY)
+    @interp.impl(stmts.CH)
+    def emit_two_qubit_gate(
+        self, emit: EmitQASM2Gate, frame: EmitQASM2Frame, stmt: stmts.CZ
+    ):
+        ctrl = emit.assert_node((ast.Bit, ast.Name), frame.get(stmt.ctrl))
+        qarg = emit.assert_node((ast.Bit, ast.Name), frame.get(stmt.qarg))
+        frame.body.append(
+            ast.Instruction(name=ast.Name(stmt.name), params=[], qargs=[ctrl, qarg])
+        )
+        return ()
+
+    @interp.impl(stmts.CCX)
+    def emit_ccx(self, emit: EmitQASM2Gate, frame: EmitQASM2Frame, stmt: stmts.CCX):
+        ctrl1 = emit.assert_node((ast.Bit, ast.Name), frame.get(stmt.ctrl1))
+        ctrl2 = emit.assert_node((ast.Bit, ast.Name), frame.get(stmt.ctrl2))
+        qarg = emit.assert_node((ast.Bit, ast.Name), frame.get(stmt.qarg))
+        frame.body.append(
+            ast.Instruction(
+                name=ast.Name(stmt.name), params=[], qargs=[ctrl1, ctrl2, qarg]
+            )
+        )
+        return ()
+
+    @interp.impl(stmts.CSwap)
+    def emit_cswap(self, emit: EmitQASM2Gate, frame: EmitQASM2Frame, stmt: stmts.CSwap):
+        ctrl = emit.assert_node((ast.Bit, ast.Name), frame.get(stmt.ctrl))
+        qarg1 = emit.assert_node((ast.Bit, ast.Name), frame.get(stmt.qarg1))
+        qarg2 = emit.assert_node((ast.Bit, ast.Name), frame.get(stmt.qarg2))
+        frame.body.append(
+            ast.Instruction(
+                name=ast.Name(stmt.name), params=[], qargs=[ctrl, qarg1, qarg2]
+            )
+        )
+        return ()
+
+    @interp.impl(stmts.CRZ)
+    @interp.impl(stmts.CRY)
+    @interp.impl(stmts.CRX)
+    def emit_cr(self, emit: EmitQASM2Gate, frame: EmitQASM2Frame, stmt: stmts.CRX):
+        lam = emit.assert_node(ast.Expr, frame.get(stmt.lam))
+        ctrl = emit.assert_node((ast.Bit, ast.Name), frame.get(stmt.ctrl))
+        qarg = emit.assert_node((ast.Bit, ast.Name), frame.get(stmt.qarg))
+        frame.body.append(
+            ast.Instruction(name=ast.Name(stmt.name), params=[lam], qargs=[ctrl, qarg])
+        )
+        return ()
+
+    @interp.impl(stmts.CU1)
+    def emit_cu1(self, emit: EmitQASM2Gate, frame: EmitQASM2Frame, stmt: stmts.CU1):
+        lam = emit.assert_node(ast.Expr, frame.get(stmt.lam))
+        ctrl = emit.assert_node((ast.Bit, ast.Name), frame.get(stmt.ctrl))
+        qarg = emit.assert_node((ast.Bit, ast.Name), frame.get(stmt.qarg))
+        frame.body.append(
+            ast.Instruction(name=ast.Name(stmt.name), params=[lam], qargs=[ctrl, qarg])
+        )
+        return ()
+
+    @interp.impl(stmts.CU3)
+    def emit_cu3(self, emit: EmitQASM2Gate, frame: EmitQASM2Frame, stmt: stmts.CU3):
+        theta = emit.assert_node(ast.Expr, frame.get(stmt.theta))
+        phi = emit.assert_node(ast.Expr, frame.get(stmt.phi))
+        lam = emit.assert_node(ast.Expr, frame.get(stmt.lam))
+        ctrl = emit.assert_node((ast.Bit, ast.Name), frame.get(stmt.ctrl))
+        qarg = emit.assert_node((ast.Bit, ast.Name), frame.get(stmt.qarg))
+        frame.body.append(
+            ast.Instruction(
+                name=ast.Name(stmt.name), params=[theta, phi, lam], qargs=[ctrl, qarg]
+            )
+        )
+        return ()
+
+    @interp.impl(stmts.CU)
+    def emit_cu(self, emit: EmitQASM2Gate, frame: EmitQASM2Frame, stmt: stmts.CU):
+        theta = emit.assert_node(ast.Expr, frame.get(stmt.theta))
+        phi = emit.assert_node(ast.Expr, frame.get(stmt.phi))
+        lam = emit.assert_node(ast.Expr, frame.get(stmt.lam))
+        gamma = emit.assert_node(ast.Expr, frame.get(stmt.gamma))
+        ctrl = emit.assert_node((ast.Bit, ast.Name), frame.get(stmt.ctrl))
+        qarg = emit.assert_node((ast.Bit, ast.Name), frame.get(stmt.qarg))
+        frame.body.append(
+            ast.Instruction(
+                name=ast.Name(stmt.name),
+                params=[theta, phi, lam, gamma],
+                qargs=[ctrl, qarg],
+            )
+        )
+        return ()
+
+    @interp.impl(stmts.RZZ)
+    @interp.impl(stmts.RXX)
+    def emit_r2q(self, emit: EmitQASM2Gate, frame: EmitQASM2Frame, stmt: stmts.RZZ):
+        theta = emit.assert_node(ast.Expr, frame.get(stmt.theta))
+        ctrl = emit.assert_node((ast.Bit, ast.Name), frame.get(stmt.ctrl))
+        qarg = emit.assert_node((ast.Bit, ast.Name), frame.get(stmt.qarg))
+        frame.body.append(
+            ast.Instruction(
+                name=ast.Name(stmt.name), params=[theta], qargs=[ctrl, qarg]
+            )
+        )
+        return ()

bloqade/qasm2/dialects/uop/schedule.py

@@ -0,0 +1,89 @@
+from kirin import interp
+from kirin.analysis import ForwardFrame
+
+from bloqade.squin.analysis.schedule import DagScheduleAnalysis
+
+from . import stmts
+from ._dialect import dialect
+
+
+@dialect.register(key="qasm2.schedule.dag")
+class UOp(interp.MethodTable):
+
+    @interp.impl(stmts.Id)
+    @interp.impl(stmts.SXdag)
+    @interp.impl(stmts.SX)
+    @interp.impl(stmts.X)
+    @interp.impl(stmts.Y)
+    @interp.impl(stmts.Z)
+    @interp.impl(stmts.H)
+    @interp.impl(stmts.S)
+    @interp.impl(stmts.Sdag)
+    @interp.impl(stmts.T)
+    @interp.impl(stmts.Tdag)
+    @interp.impl(stmts.RX)
+    @interp.impl(stmts.RY)
+    @interp.impl(stmts.RZ)
+    @interp.impl(stmts.U1)
+    @interp.impl(stmts.U2)
+    @interp.impl(stmts.UGate)
+    def single_qubit_gate(
+        self,
+        interp: DagScheduleAnalysis,
+        frame: ForwardFrame,
+        stmt: stmts.SingleQubitGate,
+    ):
+        interp.update_dag(stmt, [stmt.qarg])
+        return ()
+
+    @interp.impl(stmts.RXX)
+    @interp.impl(stmts.RZZ)
+    @interp.impl(stmts.CX)
+    @interp.impl(stmts.CY)
+    @interp.impl(stmts.CZ)
+    @interp.impl(stmts.CH)
+    @interp.impl(stmts.CRZ)
+    @interp.impl(stmts.CRY)
+    @interp.impl(stmts.CRX)
+    @interp.impl(stmts.CU1)
+    @interp.impl(stmts.CU3)
+    @interp.impl(stmts.CU)
+    @interp.impl(stmts.CSX)
+    def two_qubit_ctrl_gate(
+        self,
+        interp: DagScheduleAnalysis,
+        frame: ForwardFrame,
+        stmt: stmts.TwoQubitCtrlGate,
+    ):
+        interp.update_dag(stmt, [stmt.ctrl, stmt.qarg])
+        return ()
+
+    @interp.impl(stmts.CCX)
+    def ccx_gate(
+        self,
+        interp: DagScheduleAnalysis,
+        frame: ForwardFrame,
+        stmt: stmts.CCX,
+    ):
+        interp.update_dag(stmt, [stmt.ctrl1, stmt.ctrl2, stmt.qarg])
+        return ()
+
+    @interp.impl(stmts.CSwap)
+    def cswap_gate(
+        self,
+        interp: DagScheduleAnalysis,
+        frame: ForwardFrame,
+        stmt: stmts.CSwap,
+    ):
+        interp.update_dag(stmt, [stmt.ctrl, stmt.qarg1, stmt.qarg2])
+        return ()
+
+    @interp.impl(stmts.Barrier)
+    def barrier(
+        self,
+        interp: DagScheduleAnalysis,
+        frame: ForwardFrame,
+        stmt: stmts.Barrier,
+    ):
+        interp.update_dag(stmt, stmt.qargs)
+        return ()

bloqade/qasm2/dialects/uop/stmts.py

@@ -0,0 +1,325 @@
+from kirin import ir, lowering
+from kirin.decl import info, statement
+
+from bloqade.qasm2.types import QubitType
+from bloqade.qasm2.dialects.expr.stmts import PyNum
+
+from ._dialect import dialect
+
+
+# trait
+@statement
+class SingleQubitGate(ir.Statement):
+    """Base class for single qubit gates."""
+
+    traits = frozenset({lowering.FromPythonCall()})
+    qarg: ir.SSAValue = info.argument(QubitType)
+    """qarg (Qubit): The qubit argument."""
+
+
+@statement
+class TwoQubitCtrlGate(ir.Statement):
+    traits = frozenset({lowering.FromPythonCall()})
+    ctrl: ir.SSAValue = info.argument(QubitType)
+    """ctrl (Qubit): The control qubit."""
+    qarg: ir.SSAValue = info.argument(QubitType)
+    """qarg (Qubit): The target qubit."""
+
+
+@statement(dialect=dialect)
+class CX(TwoQubitCtrlGate):
+    """Alias for the CNOT or CH gate operations."""
+
+    name = "CX"  # Note this is capitalized
+
+
+@statement(dialect=dialect)
+class UGate(SingleQubitGate):
+    """Apply A general single qubit unitary gate."""
+
+    name = "U"
+    theta: ir.SSAValue = info.argument(PyNum)
+    """theta (float): The theta parameter."""
+    phi: ir.SSAValue = info.argument(PyNum)
+    """phi (float): The phi parameter."""
+    lam: ir.SSAValue = info.argument(PyNum)
+    """lam (float): The lambda parameter."""
+
+
+@statement(dialect=dialect)
+class Barrier(ir.Statement):
+    """Apply the Barrier statement."""
+
+    name = "barrier"
+    traits = frozenset({lowering.FromPythonCall()})
+    qargs: tuple[ir.SSAValue, ...] = info.argument(QubitType)
+    """qargs: tuple of qubits to apply the barrier to."""
+
+
+# qelib1.inc as statements
+
+
+@statement(dialect=dialect)
+class Id(SingleQubitGate):
+    """Apply the Identity gate."""
+
+    name = "id"
+
+
+@statement(dialect=dialect)
+class H(SingleQubitGate):
+    """Apply the Hadamard gate."""
+
+    name = "h"
+
+
+@statement(dialect=dialect)
+class X(SingleQubitGate):
+    """Apply the X gate."""
+
+    name = "x"
+
+
+@statement(dialect=dialect)
+class Y(SingleQubitGate):
+    """Apply the Y gate."""
+
+    name = "y"
+
+
+@statement(dialect=dialect)
+class Z(SingleQubitGate):
+    """Apply the Z gate."""
+
+    name = "z"
+
+
+@statement(dialect=dialect)
+class S(SingleQubitGate):
+    """Apply the S gate."""
+
+    name = "s"
+
+
+@statement(dialect=dialect)
+class Sdag(SingleQubitGate):
+    """Apply the hermitian conj of S gate."""
+
+    name = "sdg"
+
+
+@statement(dialect=dialect)
+class SX(SingleQubitGate):
+    """Apply the quantum Sqrt(X) gate."""
+
+    name = "sx"
+
+
+@statement(dialect=dialect)
+class SXdag(SingleQubitGate):
+    """Apply the dagger of quantum Sqrt(X) gate."""
+
+    name = "sxdg"
+
+
+@statement(dialect=dialect)
+class T(SingleQubitGate):
+    """Apply the T gate."""
+
+    name = "t"
+
+
+@statement(dialect=dialect)
+class Tdag(SingleQubitGate):
+    """Apply the hermitian conj of T gate."""
+
+    name = "tdg"
+
+
+@statement(dialect=dialect)
+class RX(SingleQubitGate):
+    """Apply the RX gate."""
+
+    name = "rx"
+    theta: ir.SSAValue = info.argument(PyNum)
+    """theta (float): The angle of rotation around x axis."""
+
+
+@statement(dialect=dialect)
+class RY(SingleQubitGate):
+    """Apply the RY gate."""
+
+    name = "ry"
+    theta: ir.SSAValue = info.argument(PyNum)
+    """theta (float): The angle of rotation around y axis."""
+
+
+@statement(dialect=dialect)
+class RZ(SingleQubitGate):
+    """Apply the RZ gate."""
+
+    name = "rz"
+    theta: ir.SSAValue = info.argument(PyNum)
+    """theta (float): the angle of rotation around Z axis."""
+
+
+@statement(dialect=dialect)
+class U1(SingleQubitGate):
+    """Apply the U1 gate."""
+
+    name = "u1"
+    lam: ir.SSAValue = info.argument(PyNum)
+    """lam (float): The lambda parameter."""
+
+
+@statement(dialect=dialect)
+class U2(SingleQubitGate):
+    """Apply the U2 gate."""
+
+    name = "u2"
+    phi: ir.SSAValue = info.argument(PyNum)
+    """phi (float): The phi parameter."""
+    lam: ir.SSAValue = info.argument(PyNum)
+    """lam (float): The lambda parameter."""
+
+
+@statement(dialect=dialect)
+class CZ(TwoQubitCtrlGate):
+    """Apply the Controlled-Z gate."""
+
+    name = "cz"
+
+
+@statement(dialect=dialect)
+class CY(TwoQubitCtrlGate):
+    """Apply the Controlled-Y gate."""
+
+    name = "cy"
+
+
+@statement(dialect=dialect)
+class CSX(TwoQubitCtrlGate):
+    """Apply the Controlled-Sqrt(X) gate."""
+
+    name = "csx"
+
+
+@statement(dialect=dialect)
+class Swap(TwoQubitCtrlGate):
+    """Apply the Swap gate."""
+
+    name = "swap"
+
+
+@statement(dialect=dialect)
+class CH(TwoQubitCtrlGate):
+    """Apply the Controlled-H gate."""
+
+    name = "ch"
+
+
+@statement(dialect=dialect)
+class CCX(ir.Statement):
+    """Apply the doubly controlled X gate."""
+
+    name = "ccx"
+    traits = frozenset({lowering.FromPythonCall()})
+    ctrl1: ir.SSAValue = info.argument(QubitType)
+    """ctrl1 (Qubit): The first control qubit."""
+    ctrl2: ir.SSAValue = info.argument(QubitType)
+    """ctrl2 (Qubit): The second control qubit."""
+    qarg: ir.SSAValue = info.argument(QubitType)
+    """qarg (Qubit): The target qubit."""
+
+
+@statement(dialect=dialect)
+class CSwap(ir.Statement):
+    """Apply the controlled swap gate."""
+
+    name = "ccx"
+    traits = frozenset({lowering.FromPythonCall()})
+    ctrl: ir.SSAValue = info.argument(QubitType)
+    """ctrl (Qubit): The control qubit."""
+    qarg1: ir.SSAValue = info.argument(QubitType)
+    """qarg1 (Qubit): The first target qubit."""
+    qarg2: ir.SSAValue = info.argument(QubitType)
+    """qarg2 (Qubit): The second target qubit."""
+
+
+@statement(dialect=dialect)
+class CRX(TwoQubitCtrlGate):
+    """Apply the Controlled-RX gate."""
+
+    name = "crx"
+    lam: ir.SSAValue = info.argument(PyNum)
+    """lam (float): The angle to rotate around the X axis."""
+
+
+@statement(dialect=dialect)
+class CRY(TwoQubitCtrlGate):
+    """Apply the Controlled-RY gate."""
+
+    name = "cry"
+    lam: ir.SSAValue = info.argument(PyNum)
+    """lam (float): The angle to rotate around the Y axis."""
+
+
+@statement(dialect=dialect)
+class CRZ(TwoQubitCtrlGate):
+    """Apply the Controlled-RZ gate."""
+
+    name = "crz"
+    lam: ir.SSAValue = info.argument(PyNum)
+    """lam (float): The angle to rotate around the Z axis."""
+
+
+@statement(dialect=dialect)
+class CU1(TwoQubitCtrlGate):
+    """Apply the Controlled-U1 gate."""
+
+    name = "cu1"
+    lam: ir.SSAValue = info.argument(PyNum)
+    """lam (float): The lambda parameter."""
+
+
+@statement(dialect=dialect)
+class CU3(TwoQubitCtrlGate):
+    """Apply the Controlled-U3 gate."""
+
+    name = "cu3"
+    theta: ir.SSAValue = info.argument(PyNum)
+    phi: ir.SSAValue = info.argument(PyNum)
+    """phi (float): The phi parameter."""
+    lam: ir.SSAValue = info.argument(PyNum)
+    """lam (float): The lambda parameter."""
+
+
+@statement(dialect=dialect)
+class CU(TwoQubitCtrlGate):
+    """Apply the Controlled-U gate."""
+
+    name = "cu"
+    theta: ir.SSAValue = info.argument(PyNum)
+    phi: ir.SSAValue = info.argument(PyNum)
+    """phi (float): The phi parameter."""
+    lam: ir.SSAValue = info.argument(PyNum)
+    """lam (float): The lambda parameter."""
+    gamma: ir.SSAValue = info.argument(PyNum)
+
+
+@statement(dialect=dialect)
+class RXX(TwoQubitCtrlGate):
+    """Apply the XX rotation gate."""
+
+    name = "rxx"
+    theta: ir.SSAValue = info.argument(PyNum)
+    """theta (float): The angle of rotation around the X axis."""
+
+
+@statement(dialect=dialect)
+class RZZ(TwoQubitCtrlGate):
+    """Apply the ZZ rotation gate."""
+
+    name = "rzz"
+    theta: ir.SSAValue = info.argument(PyNum)
+    """theta (float): The angle of rotation around the Z axis."""

bloqade/qasm2/emit/__init__.py

@@ -0,0 +1 @@
+from .target import QASM2 as QASM2

bloqade/qasm2/emit/base.py

@@ -0,0 +1,72 @@
+from abc import ABC
+from typing import Generic, TypeVar, overload
+from dataclasses import field, dataclass
+
+from kirin import ir, idtable
+from kirin.emit import EmitABC, EmitError, EmitFrame
+from typing_extensions import Self
+
+from bloqade.qasm2.parse import ast
+
+StmtType = TypeVar("StmtType", bound=ast.Node)
+EmitNode = TypeVar("EmitNode", bound=ast.Node)
+
+
+@dataclass
+class EmitQASM2Frame(EmitFrame[ast.Node | None], Generic[StmtType]):
+    body: list[StmtType] = field(default_factory=list)
+
+
+@dataclass
+class EmitQASM2Base(
+    EmitABC[EmitQASM2Frame[StmtType], ast.Node | None], ABC, Generic[StmtType, EmitNode]
+):
+    void = None
+    prefix: str = field(default="", kw_only=True)
+    prefix_if_none: str = field(default="var_", kw_only=True)
+
+    output: EmitNode | None = field(init=False)
+    ssa_id: idtable.IdTable[ir.SSAValue] = field(init=False)
+
+    def initialize(self) -> Self:
+        super().initialize()
+        self.output: EmitNode | None = None
+        self.ssa_id = idtable.IdTable[ir.SSAValue](
+            prefix=self.prefix, prefix_if_none=self.prefix_if_none
+        )
+        return self
+
+    def new_frame(self, code: ir.Statement) -> EmitQASM2Frame:
+        return EmitQASM2Frame.from_func_like(code)
+
+    def run_method(
+        self, method: ir.Method, args: tuple[ast.Node | None, ...]
+    ) -> tuple[EmitQASM2Frame[StmtType], ast.Node | None]:
+        return self.run_callable(method.code, (ast.Name(method.sym_name),) + args)
+
+    def emit_block(self, frame: EmitQASM2Frame, block: ir.Block) -> ast.Node | None:
+        for stmt in block.stmts:
+            result = self.eval_stmt(frame, stmt)
+            if isinstance(result, tuple):
+                frame.set_values(stmt.results, result)
+        return None
+
+    A = TypeVar("A")
+    B = TypeVar("B")
+
+    @overload
+    def assert_node(self, typ: type[A], node: ast.Node | None) -> A: ...
+
+    @overload
+    def assert_node(
+        self, typ: tuple[type[A], type[B]], node: ast.Node | None
+    ) -> A | B: ...
+
+    def assert_node(
+        self,
+        typ: type[A] | tuple[type[A], type[B]],
+        node: ast.Node | None,
+    ) -> A | B:
+        if not isinstance(node, typ):
+            raise EmitError(f"expected {typ}, got {type(node)}")
+        return node