Circuit diagrams: Show source code links for grouped operations (#2826)

Enables source code links for grouped operations, just as with simple
gates.

<img width="826" height="612" alt="image"
src="https://github.com/user-attachments/assets/30d39007-1709-4410-a50d-4443b69fd83b"
/>

Author: minestarks

source/compiler/qsc_circuit/src/builder.rs

@@ -1113,7 +1113,7 @@ impl OperationListBuilder {
         }
     }
 
-    fn push_op(&mut self, mut op: OperationOrGroup, unfiltered_call_stack: Vec<LocationMetadata>) {
+    fn push_op(&mut self, op: OperationOrGroup, unfiltered_call_stack: Vec<LocationMetadata>) {
         if self.max_ops_exceeded || self.operations.len() >= self.max_ops {
             // Stop adding gates and leave the circuit as is
             self.max_ops_exceeded = true;
@@ -1126,21 +1126,13 @@ impl OperationListBuilder {
             vec![]
         };
 
-        if self.source_locations
-            && let Some(called_at) = op_call_stack.last()
-        {
-            op.set_location(called_at.source_location());
-        }
-
         add_scoped_op(
             &mut self.operations,
             &ScopeStack::top(),
             op,
-            if self.group_by_scope {
-                &op_call_stack
-            } else {
-                &[]
-            },
+            &op_call_stack,
+            self.group_by_scope,
+            self.source_locations,
         );
     }
 
@@ -1299,9 +1291,17 @@ impl LexicalScope {
 fn add_scoped_op(
     current_container: &mut Vec<OperationOrGroup>,
     current_scope_stack: &ScopeStack,
-    op: OperationOrGroup,
+    mut op: OperationOrGroup,
     op_call_stack: &[LocationMetadata],
+    group_by_scope: bool,
+    set_source_location: bool,
 ) {
+    if set_source_location && let Some(called_at) = op_call_stack.last() {
+        op.set_location(called_at.source_location());
+    }
+
+    let op_call_stack = if group_by_scope { op_call_stack } else { &[] };
+
     let relative_stack = strip_scope_stack_prefix(
         op_call_stack,
         current_scope_stack,
@@ -1321,7 +1321,14 @@ fn add_scoped_op(
                 let last_op_children = last_op.children_mut().expect("operation should be a group");
 
                 // Recursively add to the children
-                add_scoped_op(last_op_children, &last_scope_stack, op, op_call_stack);
+                add_scoped_op(
+                    last_op_children,
+                    &last_scope_stack,
+                    op,
+                    op_call_stack,
+                    group_by_scope,
+                    set_source_location,
+                );
 
                 return;
             }
@@ -1338,7 +1345,14 @@ fn add_scoped_op(
                 .1
                 .to_vec();
             // Recursively add the new scope group to the current container
-            add_scoped_op(current_container, current_scope_stack, scope_group, &parent);
+            add_scoped_op(
+                current_container,
+                current_scope_stack,
+                scope_group,
+                &parent,
+                group_by_scope,
+                set_source_location,
+            );
 
             return;
         }

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

@@ -499,3 +499,35 @@ fn measurement_target_propagated_to_group() {
         .find(|reg| *reg == &measurement_op.results[0])
         .expect("expected measurement result in group operation's targets");
 }
+
+#[test]
+fn source_locations_for_groups() {
+    let mut c = FakeCompilation::default();
+    let mut builder = CircuitTracer::new(
+        TracerConfig {
+            max_operations: 10,
+            source_locations: true,
+            group_by_scope: true,
+            prune_classical_qubits: false,
+        },
+        &FakeCompilation::user_package_ids(),
+    );
+
+    builder.qubit_allocate(&[], 0);
+
+    builder.gate(
+        &[c.user_code_frame("Main", 10), c.user_code_frame("Foo", 10)],
+        "X",
+        false,
+        &[0],
+        &[],
+        None,
+    );
+
+    let circuit = builder.finish(&c);
+
+    expect![[r#"
+        q_0    ─ [ [Main] ─── [ [Foo@user_code.qs:0:10] ── X@user_code.qs:0:10 ─── ] ──── ] ──
+    "#]]
+    .assert_eq(&circuit.display_with_groups().to_string());
+}

source/compiler/qsc_circuit/src/circuit.rs

@@ -345,6 +345,7 @@ pub struct Qubit {
 }
 
 #[derive(Clone, Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
 /// The schema of `Metadata` may change and its contents
 /// are never meant to be persisted in a .qsc file.
 pub struct Metadata {
@@ -424,32 +425,30 @@ impl Row {
         self.add(column, CircuitObject::Object(gate_label.clone()));
     }
 
-    fn add_gate(
-        &mut self,
-        column: usize,
-        gate: &str,
-        args: &[String],
-        is_adjoint: bool,
-        source: Option<&SourceLocation>,
-    ) {
+    fn add_gate(&mut self, column: usize, operation: &Operation) {
+        let gate_label = self.operation_label(operation);
+
+        self.add_object(column, gate_label.as_str());
+    }
+
+    fn operation_label(&self, operation: &Operation) -> String {
         let mut gate_label = String::new();
-        gate_label.push_str(gate);
-        if is_adjoint {
+        gate_label.push_str(&operation.gate());
+        if operation.is_adjoint() {
             gate_label.push('\'');
         }
 
-        if !args.is_empty() {
-            let args = args.join(", ");
+        if !operation.args().is_empty() {
+            let args = operation.args().join(", ");
             let _ = write!(&mut gate_label, "({args})");
         }
 
         if self.render_locations
-            && let Some(SourceLocation::Resolved(loc)) = source
+            && let Some(SourceLocation::Resolved(loc)) = operation.source_location()
         {
             let _ = write!(&mut gate_label, "@{}:{}:{}", loc.file, loc.line, loc.column);
         }
-
-        self.add_object(column, gate_label.as_str());
+        gate_label
     }
 
     fn add_vertical(&mut self, column: usize) {
@@ -897,13 +896,7 @@ fn add_operation_to_rows(
         {
             row.start_classical(column);
         } else {
-            row.add_gate(
-                column,
-                &operation.gate(),
-                &operation.args(),
-                operation.is_adjoint(),
-                operation.source_location(),
-            );
+            row.add_gate(column, operation);
         }
     }
 
@@ -944,15 +937,8 @@ fn add_box_start(operation: &Operation, rows: &mut [Row], target_rows: &[usize],
     for i in target_rows {
         if first {
             first = false;
-            rows[*i].add_object(
-                column,
-                format!(
-                    "[ [{}{}]",
-                    operation.gate(),
-                    if operation.is_adjoint() { "'" } else { "" },
-                )
-                .as_str(),
-            );
+            let label = rows[*i].operation_label(operation);
+            rows[*i].add_object(column, format!("[ [{label}]").as_str());
         } else {
             rows[*i].add_object(column, "[");
         }