bloqade-circuit 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

bloqade/qasm2/rewrite/heuristic_noise.py

@@ -1,17 +1,17 @@
-from typing import Dict, List, Tuple
+from typing import Dict, List, Tuple, cast
 from dataclasses import field, dataclass
 
 from kirin import ir
-from kirin.rewrite import abc as result_abc, result
-from kirin.dialects import py, ilist
+from kirin.rewrite import abc as rewrite_abc
+from kirin.dialects import ilist
 
 from bloqade.noise import native
 from bloqade.analysis import address
-from bloqade.qasm2.dialects import uop, core, glob, parallel
+from bloqade.qasm2.dialects import uop, glob, parallel
 
 
 @dataclass
-class NoiseRewriteRule(result_abc.RewriteRule):
+class NoiseRewriteRule(rewrite_abc.RewriteRule):
     """
     NOTE: This pass is not guaranteed to be supported long-term in bloqade. We will be
     moving towards a more general approach to noise modeling in the future.
@@ -24,12 +24,18 @@ class NoiseRewriteRule(result_abc.RewriteRule):
     noise_model: native.MoveNoiseModelABC = field(
         default_factory=native.TwoRowZoneModel
     )
-    qubit_ssa_value: Dict[int, ir.SSAValue] = field(default_factory=dict, init=False)
 
-    def rewrite_Statement(self, node: ir.Statement) -> result.RewriteResult:
-        if isinstance(node, core.QRegNew):
-            return self.rewrite_qreg_new(node)
-        elif isinstance(node, uop.SingleQubitGate):
+    def __post_init__(self):
+        self.qubit_ssa_value: Dict[int, ir.SSAValue] = {}
+        for ssa_value, addr in self.address_analysis.items():
+            if (
+                isinstance(addr, address.AddressQubit)
+                and ssa_value not in self.qubit_ssa_value
+            ):
+                self.qubit_ssa_value[addr.data] = ssa_value
+
+    def rewrite_Statement(self, node: ir.Statement) -> rewrite_abc.RewriteResult:
+        if isinstance(node, uop.SingleQubitGate):
             return self.rewrite_single_qubit_gate(node)
         elif isinstance(node, uop.CZ):
             return self.rewrite_cz_gate(node)
@@ -40,25 +46,7 @@ class NoiseRewriteRule(result_abc.RewriteRule):
         elif isinstance(node, glob.UGate):
             return self.rewrite_global_single_qubit_gate(node)
         else:
-            return result.RewriteResult()
-
-    def rewrite_qreg_new(self, node: core.QRegNew):
-
-        addr = self.address_analysis[node.result]
-        if not isinstance(addr, address.AddressReg):
-            return result.RewriteResult()
-
-        has_done_something = False
-        for idx_val, qid in enumerate(addr.data):
-            if qid not in self.qubit_ssa_value:
-                has_done_something = True
-                idx = py.constant.Constant(value=idx_val)
-                qubit = core.QRegGet(node.result, idx=idx.result)
-                self.qubit_ssa_value[qid] = qubit.result
-                qubit.insert_after(node)
-                idx.insert_after(node)
-
-        return result.RewriteResult(has_done_something=has_done_something)
+            return rewrite_abc.RewriteResult()
 
     def insert_single_qubit_noise(
         self,
@@ -71,7 +59,7 @@ class NoiseRewriteRule(result_abc.RewriteRule):
         )
         native.AtomLossChannel(qargs, prob=probs[3]).insert_before(node)
 
-        return result.RewriteResult(has_done_something=True)
+        return rewrite_abc.RewriteResult(has_done_something=True)
 
     def rewrite_single_qubit_gate(self, node: uop.SingleQubitGate):
         probs = (
@@ -86,13 +74,13 @@ class NoiseRewriteRule(result_abc.RewriteRule):
     def rewrite_global_single_qubit_gate(self, node: glob.UGate):
         addrs = self.address_analysis[node.registers]
         if not isinstance(addrs, address.AddressTuple):
-            return result.RewriteResult()
+            return rewrite_abc.RewriteResult()
 
         qargs = []
 
         for addr in addrs.data:
             if not isinstance(addr, address.AddressReg):
-                return result.RewriteResult()
+                return rewrite_abc.RewriteResult()
 
             for qid in addr.data:
                 qargs.append(self.qubit_ssa_value[qid])
@@ -109,10 +97,10 @@ class NoiseRewriteRule(result_abc.RewriteRule):
     def rewrite_parallel_single_qubit_gate(self, node: parallel.RZ | parallel.UGate):
         addrs = self.address_analysis[node.qargs]
         if not isinstance(addrs, address.AddressTuple):
-            return result.RewriteResult()
+            return rewrite_abc.RewriteResult()
 
         if not all(isinstance(addr, address.AddressQubit) for addr in addrs.data):
-            return result.RewriteResult()
+            return rewrite_abc.RewriteResult()
 
         probs = (
             self.gate_noise_params.local_px,
@@ -213,7 +201,7 @@ class NoiseRewriteRule(result_abc.RewriteRule):
             new_node.insert_before(node)
             has_done_something = True
 
-        return result.RewriteResult(has_done_something=has_done_something)
+        return rewrite_abc.RewriteResult(has_done_something=has_done_something)
 
     def rewrite_parallel_cz_gate(self, node: parallel.CZ):
         ctrls = self.address_analysis[node.ctrls]
@@ -226,8 +214,12 @@ class NoiseRewriteRule(result_abc.RewriteRule):
             and isinstance(qargs, address.AddressTuple)
             and all(isinstance(addr, address.AddressQubit) for addr in qargs.data)
         ):
-            ctrl_qubits = list(map(lambda addr: addr.data, ctrls.data))
-            qarg_qubits = list(map(lambda addr: addr.data, qargs.data))
+            ctrl_qubits = list(
+                map(lambda addr: cast(address.AddressQubit, addr).data, ctrls.data)
+            )
+            qarg_qubits = list(
+                map(lambda addr: cast(address.AddressQubit, addr).data, qargs.data)
+            )
             rest = sorted(
                 set(self.qubit_ssa_value.keys()) - set(ctrl_qubits + qarg_qubits)
             )
@@ -244,4 +236,4 @@ class NoiseRewriteRule(result_abc.RewriteRule):
             new_node.insert_before(node)
             has_done_something = True
 
-        return result.RewriteResult(has_done_something=has_done_something)
+        return rewrite_abc.RewriteResult(has_done_something=has_done_something)

bloqade/qasm2/rewrite/insert_qubits.py

@@ -0,0 +1,34 @@
+from kirin import ir
+from kirin.rewrite import abc as rewrite_abc
+from kirin.dialects import py
+
+
+class InsertGetQubit(rewrite_abc.RewriteRule):
+
+    def rewrite_Statement(self, node: ir.Statement) -> rewrite_abc.RewriteResult:
+        from bloqade.qasm2 import core
+
+        if (
+            not isinstance(node, core.QRegNew)
+            or not isinstance(n_qubits_stmt := node.n_qubits.owner, py.Constant)
+            or not isinstance(n_qubits := n_qubits_stmt.value.unwrap(), int)
+            or (block := node.parent_block) is None
+        ):
+            return rewrite_abc.RewriteResult()
+
+        n_qubits_stmt.detach()
+        node.detach()
+        if block.first_stmt is None:
+            block.stmts.append(n_qubits_stmt)
+            block.stmts.append(node)
+        else:
+            node.insert_before(block.first_stmt)
+            n_qubits_stmt.insert_before(block.first_stmt)
+
+        for idx_val in range(n_qubits):
+            idx = py.constant.Constant(value=idx_val)
+            qubit = core.QRegGet(node.result, idx=idx.result)
+            qubit.insert_after(node)
+            idx.insert_after(node)
+
+        return rewrite_abc.RewriteResult(has_done_something=True)

bloqade/qasm2/rewrite/native_gates.py

@@ -10,7 +10,7 @@ import cirq.contrib.qasm_import
 import cirq.transformers.target_gatesets
 import cirq.transformers.target_gatesets.compilation_target_gateset
 from kirin import ir
-from kirin.rewrite import abc, result
+from kirin.rewrite import abc
 from kirin.dialects import py
 from cirq.circuits.qasm_output import QasmUGate
 from cirq.transformers.target_gatesets.compilation_target_gateset import (
@@ -70,7 +70,7 @@ class CU(cirq.Gate):
         return "*", "CU"
 
 
-def around(val):
+def around(val) -> float:
     return float(np.around(val, 14))
 
 
@@ -78,7 +78,7 @@ def one_qubit_gate_to_u3_angles(op: cirq.Operation) -> tuple[float, float, float
     lam, theta, phi = (  # Z angle, Y angle, then Z angle
         cirq.deconstruct_single_qubit_matrix_into_angles(cirq.unitary(op))
     )
-    return tuple(map(around, (theta, phi, lam)))
+    return around(theta), around(phi), around(lam)
 
 
 @dataclass
@@ -111,25 +111,25 @@ class RydbergGateSetRewriteRule(abc.RewriteRule):
         else:
             return py.constant.Constant(value=math.pi)
 
-    def rewrite_Statement(self, node: ir.Statement) -> result.RewriteResult:
+    def rewrite_Statement(self, node: ir.Statement) -> abc.RewriteResult:
         # only deal with uop
         if type(node) in uop.dialect.stmts:
             return getattr(self, f"rewrite_{node.name}")(node)
 
-        return result.RewriteResult()
+        return abc.RewriteResult()
 
-    def rewrite_barrier(self, node: uop.Barrier) -> result.RewriteResult:
-        return result.RewriteResult()
+    def rewrite_barrier(self, node: uop.Barrier) -> abc.RewriteResult:
+        return abc.RewriteResult()
 
-    def rewrite_cz(self, node: uop.CZ) -> result.RewriteResult:
-        return result.RewriteResult()
+    def rewrite_cz(self, node: uop.CZ) -> abc.RewriteResult:
+        return abc.RewriteResult()
 
-    def rewrite_CX(self, node: uop.CX) -> result.RewriteResult:
+    def rewrite_CX(self, node: uop.CX) -> abc.RewriteResult:
         return self._rewrite_2q_ctrl_gates(
             cirq.CX(self.cached_qubits[0], self.cached_qubits[1]), node
         )
 
-    def rewrite_cy(self, node: uop.CY) -> result.RewriteResult:
+    def rewrite_cy(self, node: uop.CY) -> abc.RewriteResult:
         return self._rewrite_2q_ctrl_gates(
             cirq.ControlledGate(cirq.Y, 1)(
                 self.cached_qubits[0], self.cached_qubits[1]
@@ -137,92 +137,92 @@ class RydbergGateSetRewriteRule(abc.RewriteRule):
             node,
         )
 
-    def rewrite_U(self, node: uop.UGate) -> result.RewriteResult:
-        return result.RewriteResult()
+    def rewrite_U(self, node: uop.UGate) -> abc.RewriteResult:
+        return abc.RewriteResult()
 
-    def rewrite_id(self, node: uop.Id) -> result.RewriteResult:
+    def rewrite_id(self, node: uop.Id) -> abc.RewriteResult:
         node.delete()  # just delete the identity gate
-        return result.RewriteResult(has_done_something=True)
+        return abc.RewriteResult(has_done_something=True)
 
-    def rewrite_h(self, node: uop.H) -> result.RewriteResult:
+    def rewrite_h(self, node: uop.H) -> abc.RewriteResult:
         return self._rewrite_1q_gates(cirq.H(self.cached_qubits[0]), node)
 
-    def rewrite_x(self, node: uop.X) -> result.RewriteResult:
+    def rewrite_x(self, node: uop.X) -> abc.RewriteResult:
         return self._rewrite_1q_gates(cirq.X(self.cached_qubits[0]), node)
 
-    def rewrite_y(self, node: uop.Y) -> result.RewriteResult:
+    def rewrite_y(self, node: uop.Y) -> abc.RewriteResult:
         return self._rewrite_1q_gates(cirq.Y(self.cached_qubits[0]), node)
 
-    def rewrite_z(self, node: uop.Z) -> result.RewriteResult:
+    def rewrite_z(self, node: uop.Z) -> abc.RewriteResult:
         return self._rewrite_1q_gates(cirq.Z(self.cached_qubits[0]), node)
 
-    def rewrite_s(self, node: uop.S) -> result.RewriteResult:
+    def rewrite_s(self, node: uop.S) -> abc.RewriteResult:
         return self._rewrite_1q_gates(cirq.S(self.cached_qubits[0]), node)
 
-    def rewrite_sdg(self, node: uop.Sdag) -> result.RewriteResult:
+    def rewrite_sdg(self, node: uop.Sdag) -> abc.RewriteResult:
         return self._rewrite_1q_gates(cirq.S(self.cached_qubits[0]) ** -1, node)
 
-    def rewrite_t(self, node: uop.T) -> result.RewriteResult:
+    def rewrite_t(self, node: uop.T) -> abc.RewriteResult:
         return self._rewrite_1q_gates(cirq.T(self.cached_qubits[0]), node)
 
-    def rewrite_tdg(self, node: uop.Tdag) -> result.RewriteResult:
+    def rewrite_tdg(self, node: uop.Tdag) -> abc.RewriteResult:
         return self._rewrite_1q_gates(cirq.T(self.cached_qubits[0]) ** -1, node)
 
-    def rewrite_sx(self, node: uop.SX) -> result.RewriteResult:
+    def rewrite_sx(self, node: uop.SX) -> abc.RewriteResult:
         return self._rewrite_1q_gates(
             cirq.XPowGate(exponent=0.5).on(self.cached_qubits[0]), node
         )
 
-    def rewrite_sxdg(self, node: uop.SXdag) -> result.RewriteResult:
+    def rewrite_sxdg(self, node: uop.SXdag) -> abc.RewriteResult:
         return self._rewrite_1q_gates(
             cirq.XPowGate(exponent=-0.5).on(self.cached_qubits[0]), node
         )
 
-    def rewrite_u1(self, node: uop.U1) -> result.RewriteResult:
+    def rewrite_u1(self, node: uop.U1) -> abc.RewriteResult:
         theta = node.lam
         (phi := self.const_float(value=0.0)).insert_before(node)
         node.replace_by(
             uop.UGate(qarg=node.qarg, theta=phi.result, phi=phi.result, lam=theta)
         )
-        return result.RewriteResult(has_done_something=True)
+        return abc.RewriteResult(has_done_something=True)
 
-    def rewrite_u2(self, node: uop.U2) -> result.RewriteResult:
+    def rewrite_u2(self, node: uop.U2) -> abc.RewriteResult:
         phi = node.phi
         lam = node.lam
         (theta := self.const_float(value=math.pi / 2)).insert_before(node)
         node.replace_by(uop.UGate(qarg=node.qarg, theta=theta.result, phi=phi, lam=lam))
-        return result.RewriteResult(has_done_something=True)
+        return abc.RewriteResult(has_done_something=True)
 
-    def rewrite_rx(self, node: uop.RX) -> result.RewriteResult:
+    def rewrite_rx(self, node: uop.RX) -> abc.RewriteResult:
         theta = node.theta
         (phi := self.const_float(value=math.pi / 2)).insert_before(node)
         (lam := self.const_float(value=-math.pi / 2)).insert_before(node)
         node.replace_by(
             uop.UGate(qarg=node.qarg, theta=theta, phi=phi.result, lam=lam.result)
         )
-        return result.RewriteResult(has_done_something=True)
+        return abc.RewriteResult(has_done_something=True)
 
-    def rewrite_ry(self, node: uop.RY) -> result.RewriteResult:
+    def rewrite_ry(self, node: uop.RY) -> abc.RewriteResult:
         theta = node.theta
         (phi := self.const_float(value=0.0)).insert_before(node)
         node.replace_by(
             uop.UGate(qarg=node.qarg, theta=theta, phi=phi.result, lam=phi.result)
         )
-        return result.RewriteResult(has_done_something=True)
+        return abc.RewriteResult(has_done_something=True)
 
-    def rewrite_rz(self, node: uop.RZ) -> result.RewriteResult:
+    def rewrite_rz(self, node: uop.RZ) -> abc.RewriteResult:
         theta = node.theta
         (phi := self.const_float(value=0.0)).insert_before(node)
         node.replace_by(
             uop.UGate(qarg=node.qarg, theta=phi.result, phi=phi.result, lam=theta)
         )
-        return result.RewriteResult(has_done_something=True)
+        return abc.RewriteResult(has_done_something=True)
 
-    def rewrite_crx(self, node: uop.CRX) -> result.RewriteResult:
+    def rewrite_crx(self, node: uop.CRX) -> abc.RewriteResult:
         lam = self._get_const_value(node.lam)
 
         if lam is None:
-            return result.RewriteResult()
+            return abc.RewriteResult()
 
         return self._rewrite_2q_ctrl_gates(
             cirq.ControlledGate(cirq.Rx(rads=lam), 1).on(
@@ -231,11 +231,11 @@ class RydbergGateSetRewriteRule(abc.RewriteRule):
             node,
         )
 
-    def rewrite_cry(self, node: uop.CRY) -> result.RewriteResult:
+    def rewrite_cry(self, node: uop.CRY) -> abc.RewriteResult:
         lam = self._get_const_value(node.lam)
 
         if lam is None:
-            return result.RewriteResult()
+            return abc.RewriteResult()
 
         return self._rewrite_2q_ctrl_gates(
             cirq.ControlledGate(cirq.Ry(rads=lam), 1).on(
@@ -244,11 +244,11 @@ class RydbergGateSetRewriteRule(abc.RewriteRule):
             node,
         )
 
-    def rewrite_crz(self, node: uop.CRZ) -> result.RewriteResult:
+    def rewrite_crz(self, node: uop.CRZ) -> abc.RewriteResult:
         lam = self._get_const_value(node.lam)
 
         if lam is None:
-            return result.RewriteResult()
+            return abc.RewriteResult()
 
         return self._rewrite_2q_ctrl_gates(
             cirq.ControlledGate(cirq.Rz(rads=lam), 1).on(
@@ -257,12 +257,12 @@ class RydbergGateSetRewriteRule(abc.RewriteRule):
             node,
         )
 
-    def rewrite_cu1(self, node: uop.CU1) -> result.RewriteResult:
+    def rewrite_cu1(self, node: uop.CU1) -> abc.RewriteResult:
 
         lam = self._get_const_value(node.lam)
 
         if lam is None:
-            return result.RewriteResult()
+            return abc.RewriteResult()
 
         # cirq.ControlledGate(u3(0, 0, lambda))
         return self._rewrite_2q_ctrl_gates(
@@ -273,14 +273,13 @@ class RydbergGateSetRewriteRule(abc.RewriteRule):
         )
         pass
 
-    def rewrite_cu3(self, node: uop.CU3) -> result.RewriteResult:
+    def rewrite_cu3(self, node: uop.CU3) -> abc.RewriteResult:
 
         theta = self._get_const_value(node.theta)
         lam = self._get_const_value(node.lam)
         phi = self._get_const_value(node.phi)
-
-        if not all((theta, phi, lam)):
-            return result.RewriteResult()
+        if theta is None or lam is None or phi is None:
+            return abc.RewriteResult()
 
         # cirq.ControlledGate(u3(theta, lambda phi))
         return self._rewrite_2q_ctrl_gates(
@@ -290,7 +289,7 @@ class RydbergGateSetRewriteRule(abc.RewriteRule):
             node,
         )
 
-    def rewrite_cu(self, node: uop.CU) -> result.RewriteResult:
+    def rewrite_cu(self, node: uop.CU) -> abc.RewriteResult:
 
         gamma = self._get_const_value(node.gamma)
         theta = self._get_const_value(node.theta)
@@ -304,12 +303,12 @@ class RydbergGateSetRewriteRule(abc.RewriteRule):
             node,
         )
 
-    def rewrite_rxx(self, node: uop.RXX) -> result.RewriteResult:
+    def rewrite_rxx(self, node: uop.RXX) -> abc.RewriteResult:
 
         theta = self._get_const_value(node.theta)
 
         if theta is None:
-            return result.RewriteResult()
+            return abc.RewriteResult()
 
         # even though the XX gate is not controlled,
         # the end U + CZ decomposition that happens internally means
@@ -320,11 +319,11 @@ class RydbergGateSetRewriteRule(abc.RewriteRule):
             node,
         )
 
-    def rewrite_rzz(self, node: uop.RZZ) -> result.RewriteResult:
+    def rewrite_rzz(self, node: uop.RZZ) -> abc.RewriteResult:
         theta = self._get_const_value(node.theta)
 
         if theta is None:
-            return result.RewriteResult()
+            return abc.RewriteResult()
 
         return self._rewrite_2q_ctrl_gates(
             cirq.ZZPowGate(exponent=theta / math.pi).on(
@@ -391,7 +390,7 @@ class RydbergGateSetRewriteRule(abc.RewriteRule):
 
     def _rewrite_1q_gates(
         self, cirq_gate: cirq.Operation, node: uop.SingleQubitGate
-    ) -> result.RewriteResult:
+    ) -> abc.RewriteResult:
         new_gate_stmts = self._generate_1q_gate_stmts(cirq_gate, node.qarg)
         return self._rewrite_gate_stmts(new_gate_stmts, node)
 
@@ -427,7 +426,7 @@ class RydbergGateSetRewriteRule(abc.RewriteRule):
 
     def _rewrite_2q_ctrl_gates(
         self, cirq_gate: cirq.Operation, node: uop.TwoQubitCtrlGate
-    ) -> result.RewriteResult:
+    ) -> abc.RewriteResult:
         new_gate_stmts = self._generate_2q_ctrl_gate_stmts(
             cirq_gate, [node.ctrl, node.qarg]
         )
@@ -444,4 +443,4 @@ class RydbergGateSetRewriteRule(abc.RewriteRule):
             stmt.insert_after(node)
             node = stmt
 
-        return result.RewriteResult(has_done_something=True)
+        return abc.RewriteResult(has_done_something=True)

bloqade/qasm2/rewrite/parallel_to_uop.py

@@ -2,7 +2,7 @@ from typing import Dict, List, Optional
 from dataclasses import dataclass
 
 from kirin import ir
-from kirin.rewrite import abc, result
+from kirin.rewrite import abc
 
 from bloqade.analysis import address
 from bloqade.qasm2.dialects import uop, parallel
@@ -13,11 +13,11 @@ class ParallelToUOpRule(abc.RewriteRule):
     id_map: Dict[int, ir.SSAValue]
     address_analysis: Dict[ir.SSAValue, address.Address]
 
-    def rewrite_Statement(self, node: ir.Statement) -> result.RewriteResult:
+    def rewrite_Statement(self, node: ir.Statement) -> abc.RewriteResult:
         if type(node) in parallel.dialect.stmts:
             return getattr(self, f"rewrite_{node.name}")(node)
 
-        return result.RewriteResult()
+        return abc.RewriteResult()
 
     def get_qubit_ssa(self, ilist_ref: ir.SSAValue) -> Optional[List[ir.SSAValue]]:
         addr = self.address_analysis.get(ilist_ref)
@@ -40,7 +40,7 @@ class ParallelToUOpRule(abc.RewriteRule):
         qargs = self.get_qubit_ssa(node.qargs)
 
         if ctrls is None or qargs is None:
-            return result.RewriteResult()
+            return abc.RewriteResult()
 
         for ctrl, qarg in zip(ctrls, qargs):
             new_node = uop.CZ(ctrl, qarg)
@@ -48,7 +48,7 @@ class ParallelToUOpRule(abc.RewriteRule):
 
         node.delete()
 
-        return result.RewriteResult(has_done_something=True)
+        return abc.RewriteResult(has_done_something=True)
 
     def rewrite_u(self, node: ir.Statement):
         assert isinstance(node, parallel.UGate)
@@ -56,7 +56,7 @@ class ParallelToUOpRule(abc.RewriteRule):
         qargs = self.get_qubit_ssa(node.qargs)
 
         if qargs is None:
-            return result.RewriteResult()
+            return abc.RewriteResult()
 
         for qarg in qargs:
             new_node = uop.UGate(qarg, theta=node.theta, phi=node.phi, lam=node.lam)
@@ -64,7 +64,7 @@ class ParallelToUOpRule(abc.RewriteRule):
 
         node.delete()
 
-        return result.RewriteResult(has_done_something=True)
+        return abc.RewriteResult(has_done_something=True)
 
     def rewrite_rz(self, node: ir.Statement):
         assert isinstance(node, parallel.RZ)
@@ -72,7 +72,7 @@ class ParallelToUOpRule(abc.RewriteRule):
         qargs = self.get_qubit_ssa(node.qargs)
 
         if qargs is None:
-            return result.RewriteResult()
+            return abc.RewriteResult()
 
         for qarg in qargs:
             new_node = uop.RZ(qarg, theta=node.theta)
@@ -80,4 +80,4 @@ class ParallelToUOpRule(abc.RewriteRule):
 
         node.delete()
 
-        return result.RewriteResult(has_done_something=True)
+        return abc.RewriteResult(has_done_something=True)