Circuit diagrams: classical wires should be rendered if grouped operation contains a measurement (#2799)

### BEFORE

<img width="849" height="692" alt="image"
src="https://github.com/user-attachments/assets/a12ae5f2-f2b9-4252-b7ec-2cb9a94f7fba"
/>


### AFTER

<img width="843" height="696" alt="image"
src="https://github.com/user-attachments/assets/56f07ca4-cf94-479b-9a04-b2a7d0e9f895"
/>

---------

Co-authored-by: Copilot <198982749+Copilot@users.noreply.github.com>

Author: minestarks

source/compiler/qsc_circuit/src/builder/tests.rs

@@ -405,3 +405,84 @@ fn qubit_labels_for_preallocated_qubits() {
     "#]]
     .assert_eq(&circuit.to_string());
 }
+
+#[test]
+fn measurement_target_propagated_to_group() {
+    let mut c = FakeCompilation::default();
+    let mut builder = CircuitTracer::new(
+        TracerConfig {
+            max_operations: usize::MAX,
+            source_locations: false,
+            group_by_scope: true,
+        },
+        &FakeCompilation::user_package_ids(),
+    );
+
+    builder.qubit_allocate(&[], 0);
+
+    builder.gate(&[c.user_code_frame("Main", 1)], "H", false, &[0], &[], None);
+
+    builder.measure(&[c.user_code_frame("Main", 2)], "M", 0, &0.into());
+
+    let circuit = builder.finish(&c);
+
+    // Verify that there's a grouped operation, with a measurement operation
+    // inside it, and that the measurement target register is also propagated
+    // to the group operation.
+
+    // Get the group
+
+    let mut group_ops = circuit.component_grid.iter().flat_map(|col| {
+        col.components.iter().filter_map(|c| {
+            if let Operation::Unitary(u) = c
+                && !u.children.is_empty()
+            {
+                Some(u)
+            } else {
+                None
+            }
+        })
+    });
+
+    let group_op = group_ops
+        .next()
+        .expect("expected to find grouped operation");
+    assert!(
+        group_ops.next().is_none(),
+        "expected only one grouped operation"
+    );
+
+    // Get the measurement operation
+
+    let mut measurement_ops = group_op.children.iter().filter_map(|col| {
+        col.components.iter().find_map(|c| {
+            if let Operation::Measurement(m) = c {
+                Some(m)
+            } else {
+                None
+            }
+        })
+    });
+
+    let measurement_op = measurement_ops
+        .next()
+        .expect("expected to find measurement operation");
+    assert!(
+        measurement_ops.next().is_none(),
+        "expected only one measurement operation"
+    );
+
+    // Now verify that the measurement qubit and result registers exist in the parent
+    // group operation's targets as well.
+    group_op
+        .targets
+        .iter()
+        .find(|reg| *reg == &measurement_op.qubits[0])
+        .expect("expected measurement qubit in group operation's targets");
+
+    group_op
+        .targets
+        .iter()
+        .find(|reg| *reg == &measurement_op.results[0])
+        .expect("expected measurement result in group operation's targets");
+}

source/npm/qsharp/test/circuits-cases/intersecting-wires.qs

@@ -0,0 +1,52 @@
+operation Main() : Unit {
+    use qs = Qubit[5];
+    M(qs[0]);
+    // Crossing a qubit wire
+    Foo([qs[2], qs[4]]);
+    // Crossing a classical wire
+    Foo(qs[0..1]);
+    // Crossing both qubit and classical wires
+    Foo([qs[2], qs[0]]);
+    // Spanning adjacent qubits
+    Foo(qs[3..4]);
+    // Crossing classical wire and adjacent qubits
+    Foo(qs[0..2]);
+
+    // Some more classical wires to intersect
+    M(qs[2]);
+    M(qs[2]);
+
+    // Spanning all qubit wires, one classical wire extending
+    // from the box, and crossing the other classical wires
+    BoxWithMeasurements(qs);
+
+    use q1 = Qubit();
+    use q2 = Qubit();
+    Bar(q1);
+    Bar(q2);
+    Foo2(q1);
+    Bar(q1);
+    Foo2(q1);
+    Foo2(q2);
+    Bar(q2);
+    Foo2(q2);
+}
+
+operation Foo2(q : Qubit) : Unit {
+    Bar(q);
+    MResetZ(q);
+}
+
+operation Bar(q : Qubit) : Unit {
+    X(q);
+    Y(q);
+}
+
+operation BoxWithMeasurements(qs: Qubit[]) : Unit {
+    M(qs[2]);
+    Foo(qs);
+}
+
+operation Foo(qs : Qubit[]) : Unit {
+    body intrinsic;
+}