fix: bug in hugr building when control modifiers are nested

justfile

@@ -92,10 +92,7 @@ recompile-test-hugrs:
     just test_files/guppy_examples/recompile
     @echo "---- Recompiling optimization-target guppy programs ----"
     just test_files/guppy_optimization/recompile
-    @echo "---- Recompiling modifier examples ----"
-    uv run maturin develop --uv
-    just test_files/modifier_examples/r
-    just test_files/run_modifier_examples/r
+    just recompile-modifiers
 
 recompile-modifiers:
     @echo "---- Recompiling modifier examples ----"

test_files/guppy_examples/modifiers.py

@@ -1,7 +1,7 @@
 # /// script
 # requires-python = ">=3.13"
 # dependencies = [
-#     "guppylang ==0.21.13",
+#     "guppylang ==0.21.14",
 # ]
 # ///
 """A simple controlled gate using modifiers"""

test_files/modifier_examples/classical_function1.py

@@ -0,0 +1,42 @@
+# /// script
+# requires-python = ">=3.13"
+# dependencies = [
+#     "guppylang ==0.21.14",
+# ]
+# ///
+"""A simple controlled gate using modifiers"""
+
+from pathlib import Path
+from sys import argv
+import sys
+
+from guppylang import guppy
+from guppylang.std.builtins import dagger
+from guppylang.std.debug import state_result
+from guppylang.std.quantum import discard, qubit, angle
+from guppylang.std.quantum import rx
+
+sys.path.append(str(Path(__file__).resolve().parents[1]))
+
+from guppylang.experimental import enable_experimental_features
+
+enable_experimental_features()
+
+
+@guppy
+def fuu(i: int) -> int:
+    return i + 1
+
+
+@guppy
+def main() -> None:
+    q = qubit()
+    with dagger:
+        rx(q, angle(1 / fuu(2)))
+
+    state_result("r", q)
+    discard(q)
+
+
+program = main.compile()
+Path(argv[0]).with_suffix(".hugr").write_bytes(program.to_bytes())

test_files/modifier_examples/classical_function2.py

@@ -0,0 +1,51 @@
+# /// script
+# requires-python = ">=3.13"
+# dependencies = [
+#     "guppylang ==0.21.14",
+# ]
+# ///
+"""A simple controlled gate using modifiers"""
+
+from pathlib import Path
+from sys import argv
+import sys
+
+from guppylang import guppy
+from guppylang.std.builtins import control, dagger
+from guppylang.std.debug import state_result
+from guppylang.std.quantum import discard, qubit, angle, measure
+from guppylang.std.quantum import h, rx, x
+
+sys.path.append(str(Path(__file__).resolve().parents[1]))
+
+from guppylang.experimental import enable_experimental_features
+
+enable_experimental_features()
+
+
+@guppy
+def fuu(i: int) -> int:
+    q = qubit()
+    x(q)
+    if measure(q):
+        i = i + 1
+    return i
+
+
+@guppy
+def main() -> None:
+    t = qubit()
+    c1 = qubit()
+    h(c1)
+    with control(c1):
+        d = fuu(2)
+        with dagger:
+            rx(t, angle(1 / d))
+
+    state_result("r", c1, t)
+    discard(c1)
+    discard(t)
+
+
+program = main.compile()
+Path(argv[0]).with_suffix(".hugr").write_bytes(program.to_bytes())

test_files/modifier_examples/classical_function3.py

@@ -0,0 +1,55 @@
+# /// script
+# requires-python = ">=3.13"
+# dependencies = [
+#     "guppylang ==0.21.14",
+# ]
+# ///
+"""A simple controlled gate using modifiers"""
+
+from pathlib import Path
+from sys import argv
+import sys
+
+from guppylang import guppy
+from guppylang.std.builtins import control, dagger
+from guppylang.std.debug import state_result
+from guppylang.std.quantum import discard, qubit, angle, measure
+from guppylang.std.quantum import h, rx, x
+
+sys.path.append(str(Path(__file__).resolve().parents[1]))
+
+from guppylang.experimental import enable_experimental_features
+
+enable_experimental_features()
+
+
+@guppy
+def fuu(i: int) -> int:
+    q = qubit()
+    x(q)
+    if measure(q):
+        i = i + 1
+    return i
+
+
+@guppy
+def main() -> None:
+    t = qubit()
+    c1 = qubit()
+    c2 = qubit()
+    h(c1)
+    h(c2)
+    with control(c1):
+        d = fuu(2)
+        with control(c2):
+            with dagger:
+                rx(t, angle(1 / d))
+
+    state_result("r", c1, c2, t)
+    discard(c1)
+    discard(c2)
+    discard(t)
+
+
+program = main.compile()
+Path(argv[0]).with_suffix(".hugr").write_bytes(program.to_bytes())

test_files/modifier_examples/complex_modifier_stress.py

@@ -0,0 +1,133 @@
+# /// script
+# requires-python = ">=3.13"
+# dependencies = [
+#     "guppylang ==0.21.14",
+# ]
+# ///
+"""A stress test for nested control and dagger modifiers."""
+
+from pathlib import Path
+from sys import argv
+import sys
+
+from guppylang import guppy
+from guppylang.std.builtins import array, control, dagger
+from guppylang.std.debug import state_result
+from guppylang.std.quantum import angle, discard, discard_array, measure, qubit
+from guppylang.std.quantum import h, rx, rz, x
+
+sys.path.append(str(Path(__file__).resolve().parents[1]))
+
+from guppylang.experimental import enable_experimental_features
+
+enable_experimental_features()
+
+
+@guppy
+def measured_offset(i: int) -> int:
+    q = qubit()
+    x(q)
+    if measure(q):
+        i = i + 1
+    return i
+
+
+@guppy(unitary=True)
+def rotation(q: qubit) -> None:
+    rx(q, angle(-1 / 7))
+
+
+@guppy(unitary=True)
+def flip(q: qubit) -> None:
+    x(q)
+
+
+@guppy(unitary=True)
+def phase_ladder(q: qubit) -> None:
+    with dagger:
+        rotation(q)
+    x(q)
+    rz(q, angle(1 / 5))
+
+
+@guppy
+def main() -> None:
+    array_controllers: array[qubit, 2] = array(qubit(), qubit())
+    control_a = qubit()
+    control_b = qubit()
+    control_c = qubit()
+    target_a = qubit()
+    target_b = qubit()
+    target_c = qubit()
+
+    h(array_controllers[0])
+    h(array_controllers[1])
+    h(control_a)
+    h(control_b)
+    h(control_c)
+    h(target_a)
+    h(target_b)
+    h(target_c)
+
+    with control(control_a):
+        with dagger:
+            rotation(target_a)
+
+    with control(control_a, control_b):
+        with dagger:
+            phase_ladder(target_a)
+
+    with dagger:
+        with control(control_b):
+            rotation(target_b)
+
+    with control(array_controllers):
+        with dagger:
+            rotation(target_b)
+
+    with control(control_a):
+        denominator = measured_offset(4)
+        with control(control_b, control_c):
+            with dagger:
+                rz(target_c, angle(1 / denominator))
+
+    with dagger:
+        with dagger:
+            with control(control_c):
+                flip(target_c)
+
+    with control(control_a, control_b, control_c):
+        with dagger:
+            rz(target_c, angle(1 / 6))
+
+    with control(control_a, control_b, control_c):
+        a = 3
+        x(target_a)
+        with dagger:
+            rz(target_b, angle(1 / a))
+            with control(array_controllers):
+                rz(target_c, angle(1 / (a + 2)))
+
+    state_result(
+        "r",
+        array_controllers[0],
+        array_controllers[1],
+        control_a,
+        control_b,
+        control_c,
+        target_a,
+        target_b,
+        target_c,
+    )
+
+    discard_array(array_controllers)
+    discard(control_a)
+    discard(control_b)
+    discard(control_c)
+    discard(target_a)
+    discard(target_b)
+    discard(target_c)
+
+
+program = main.compile()
+Path(argv[0]).with_suffix(".hugr").write_bytes(program.to_bytes())

test_files/modifier_examples/ctrl_array_controller.py

@@ -0,0 +1,49 @@
+# /// script
+# requires-python = ">=3.13"
+# dependencies = [
+#     "guppylang ==0.21.14",
+# ]
+# ///
+"""A controlled gate where the controller is an array of qubits"""
+
+from pathlib import Path
+import sys
+
+from guppylang import guppy
+from guppylang.std.builtins import array, control
+from guppylang.std.debug import state_result
+from guppylang.std.quantum import discard, discard_array, qubit
+from guppylang.std.quantum import h, x
+
+sys.path.append(str(Path(__file__).resolve().parents[1]))
+
+from guppylang.experimental import enable_experimental_features
+
+enable_experimental_features()
+
+
+@guppy(unitary=True)
+def bar(q: qubit) -> None:
+    x(q)
+
+
+@guppy
+def main() -> None:
+    controllers: array[qubit, 3] = array(qubit(), qubit(), qubit())
+    t = qubit()
+
+    h(controllers[0])
+    h(controllers[1])
+    h(controllers[2])
+
+    with control(controllers):
+        bar(t)
+
+    state_result("r", controllers[0], controllers[1], controllers[2], t)
+
+    discard_array(controllers)
+    discard(t)
+
+
+program = main.compile()
+Path(sys.argv[0]).with_suffix(".hugr").write_bytes(program.to_bytes())

test_files/modifier_examples/ctrl_on_call.py

@@ -1,7 +1,7 @@
 # /// script
 # requires-python = ">=3.13"
 # dependencies = [
-#     "guppylang ==0.21.13",
+#     "guppylang ==0.21.14",
 # ]
 # ///
 """A simple controlled gate using modifiers"""