Fix empty-barrier handling in OpenQASM 2 (#10469)

The new parser would allow a `barrier;` statement, implicitly
broadcasting it across all qubits in scope.  This is technically not
supported by the OpenQASM 2 specification, but is a useful
quality-of-life extension to the specification (in the same way that
Qiskit interprets barriers, and the OpenQASM 3 specification defines the
`barrier;` statement).  The precise rule is added to the new parser's
`strict` mode.

The OpenQASM 2 _exporter_ similarly should not have been putting out
`barrier;` statements.  These could only occur in Qiskit when a barrier
was explicitly constructed with zero elements (as opposed to the call
`QuantumCircuit.barrier()`, which has the all-in-scope behaviour), and
consequently have no actual meaning or effect.  The exporter is modified
to simply skip such instructions, for as long as Qiskit permits the
qubitless barrier statement.

crates/qasm2/src/parse.rs

@@ -1351,6 +1351,15 @@ impl State {
             }
             self.check_trailing_comma(comma.as_ref())?;
             qubits
+        } else if self.strict {
+            return Err(QASM2ParseError::new_err(message_generic(
+                Some(&Position::new(
+                    self.current_filename(),
+                    barrier_token.line,
+                    barrier_token.col,
+                )),
+                "[strict] barrier statements must have at least one argument",
+            )));
         } else if let Some(num_gate_qubits) = num_gate_qubits {
             (0..num_gate_qubits).map(QubitId::new).collect::<Vec<_>>()
         } else {

qiskit/circuit/quantumcircuit.py

@@ -1716,6 +1716,10 @@ def qasm(
             elif operation.name == "reset":
                 instruction_qasm = f"reset {bit_labels[instruction.qubits[0]]};"
             elif operation.name == "barrier":
+                if not instruction.qubits:
+                    # Barriers with no operands are invalid in (strict) OQ2, and the statement
+                    # would have no meaning anyway.
+                    continue
                 qargs = ",".join(bit_labels[q] for q in instruction.qubits)
                 instruction_qasm = "barrier;" if not qargs else f"barrier {qargs};"
             else:

releasenotes/notes/qasm2-fix-zero-op-barrier-4af211b119d5b24d.yaml

@@ -0,0 +1,13 @@
+---
+fixes:
+  - |
+    The OpenQASM 2 parser (:func:`.qasm2.load` and :func:`~.qasm2.loads`) running in ``strict`` mode
+    will now correctly emit an error if a ``barrier`` statement has no arguments.  When running in
+    the (default) more permissive mode, an argument-less ``barrier`` statement will continue to
+    cause a barrier on all qubits currently in scope (the qubits a gate definition affects, or all
+    the qubits defined by a program, if the statement is in a gate body or in the global scope,
+    respectively).
+  - |
+    The OpenQASM 2 exporter (:meth:`.QuantumCircuit.qasm`) will now no longer attempt
+    to output ``barrier`` statements that act on no qubits.  Such a barrier statement has no effect
+    in Qiskit either, but is invalid OpenQASM 2.

test/python/circuit/test_circuit_qasm.py

@@ -829,6 +829,23 @@ def test_sequencial_inner_gates_with_same_name(self):
 
         self.assertEqual(qc.qasm(), expected_output)
 
+    def test_empty_barrier(self):
+        """Test that a blank barrier statement in _Qiskit_ acts over all qubits, while an explicitly
+        no-op barrier (assuming Qiskit continues to allow this) is not output to OQ2 at all, since
+        the statement requires an argument in the spec."""
+        qc = QuantumCircuit(QuantumRegister(2, "qr1"), QuantumRegister(3, "qr2"))
+        qc.barrier()  # In Qiskit land, this affects _all_ qubits.
+        qc.barrier([])  # This explicitly affects _no_ qubits (so is totally meaningless).
+
+        expected = """\
+OPENQASM 2.0;
+include "qelib1.inc";
+qreg qr1[2];
+qreg qr2[3];
+barrier qr1[0],qr1[1],qr2[0],qr2[1],qr2[2];
+"""
+        self.assertEqual(qc.qasm(), expected)
+
 
 if __name__ == "__main__":
     unittest.main()

test/python/qasm2/test_parse_errors.py

@@ -865,3 +865,10 @@ def test_required_version_empty(self):
             qiskit.qasm2.QASM2ParseError, r"\[strict\] .*needed a version statement"
         ):
             qiskit.qasm2.loads("", strict=True)
+
+    def test_barrier_requires_args(self):
+        program = "OPENQASM 2.0; qreg q[2]; barrier;"
+        with self.assertRaisesRegex(
+            qiskit.qasm2.QASM2ParseError, r"\[strict\] barrier statements must have at least one"
+        ):
+            qiskit.qasm2.loads(program, strict=True)