Apply review comments: clarify docstrings, add test for control flow instructions

Author: ElePT

qiskit/qasm3/exporter.py

@@ -1313,7 +1313,14 @@ def _build_quantum_call_parameters(self, parameters) -> list[ast.Expression]:
 
     def build_defcal_call(self, instruction: CircuitInstruction, defcal: DefcalInstruction):
         """Build a statement associated with a defcal instruction."""
-        # We forbade return types other than `Bool` and `None` in the initialiser.
+        # We forbade return types other than `Bool` and `None` in the initialiser,
+        # but we error so that this breaks if we support the full defcal spec later on.
+        allowed_defcal_types = (None, types.Bool())
+        if defcal.return_type not in allowed_defcal_types:
+            raise QASM3ExporterError(
+                f"The defcal '{defcal.name}' associated with instructions with name '{instruction.name}'"
+                f" returns an unsupported classical type: {defcal.return_type}"
+            )
         returns_bit = defcal.return_type is not None
         # Check simple consistency.
         if (
@@ -1341,7 +1348,8 @@ def build_gate_call(self, instruction: CircuitInstruction):
         This will also push the gate into the symbol table (if required), including recursively
         defining the gate blocks.
 
-        If ``ident`` is given, symbol-resolution will be skipped."""
+        If the operation identifier is found in the symbol table, symbol-resolution will be skipped.
+        """
         operation = instruction.operation
         if hasattr(operation, "_qasm_decomposition"):
             operation = operation._qasm_decomposition()

test/python/qasm3/test_export.py

@@ -2411,6 +2411,36 @@ def test_defcal_overriding_instruction_name(self):
 qubit[1] q;
 h q[0];
 c[0] = measure_2 q[0];
+"""
+        self.assertEqual(expected.strip(), out_qasm.strip())
+
+    def test_defcal_overriding_ctrl_flow_op_name(self):
+        """Test overriding ContinueLoopOp and BreakLoopOp instruction names using defcals."""
+        # These are edge-case control flow ops that don't subclass ControlFlowOp and
+        # therefore can be overwritten using defcals like regular instructions.
+        qc = QuantumCircuit(1, 1)
+        qc.h(0)
+        qc.break_loop()
+        qc.continue_loop()
+
+        defcals = {
+            "break_loop": DefcalInstruction("my_name_break", 0, 1, types.Bool()),
+            "continue_loop": DefcalInstruction("my_name_continue", 0, 1, types.Bool()),
+        }
+        out_qasm = dumps(
+            qc,
+            includes=(),
+            basis_gates=("h", "cx"),
+            disable_constants=True,
+            implicit_defcals=defcals,
+        )
+        expected = """
+OPENQASM 3.0;
+bit[1] c;
+qubit[1] q;
+h q[0];
+c[0] = my_name_break q[0];
+c[0] = my_name_continue q[0];
 """
         self.assertEqual(expected.strip(), out_qasm.strip())