[python][test] Migrate Python tests + bridge widening for measure_handle single-API

Three concerns share this commit because they are exercised by the same
test sweep:

(1) Python MLIR FileCheck migrations (4 files):
    Mechanical type rename `!quake.measure` -> `!cc.measure_handle` in
    `bug_1777.py` and `call_qpu.py`; structural refresh in `bug_1775.py`
    and `bug_1875.py` for the new `cc.if`-carries-handle / short-circuit
    `else`-discriminate IR shape that the rewired bridge produces.

(2) New `test_measure_handle.py` (25 tests, 23 active + 2 skipped on
    pre-existing bridge gaps `IfExp` / `AnnAssign`):
    host-scope rejection, scalar / vector mz emission shape, every
    bool-coercion site (`if`/`while`/`not`/`bool()`/`==`/`!=`/`return`),
    `and`/`or` short-circuit RHS-discriminate placement, `to_bools`
    vector lowering, `to_integer(to_bools(...))` composition,
    `to_integer(handles)` rejection, `discriminating an unbound
    measure_handle` for the default-constructed pattern, and the
    `measure_handle cannot cross the host-device boundary; entry-point
    kernels must discriminate first` diagnostic for direct + transitive
    handle positions.

(3) Existing test migrations + a narrow bridge fix the sweep exposed:
    Full pytest sweep on `python/tests/kernel/` after the bridge rewire
    surfaced 11 failing tests that previously relied on `mz` returning
    bool. Migrations:
    * `test_to_integer.py`: compose `to_integer(to_bools(mz(q)))`.
    * `test_assignments.py::test_disallow_value_updates`: invert the
      now-supported reassign-handle-across-scopes case (the test's own
      TODO from before predicted exactly this).
    * `test_assignments.py::test_inner_functions`: explicit
      `bool(mz(q))` for the tuple-return aggregate-element case
      (FIXME inline; aggregate-element typing does not currently
      auto-discriminate).
    * `test_kernel_features.py::test_mid_circuit_measurements`:
      declare `result` slots as `bool` so the bridge's handle->i1/i8
      path discriminates element stores.
    * `test_run_kernel.py` (3 tests): explicit `int(bool(mz(q)))` for
      handle-in-arithmetic; change `-> int` returning `mz(q)` to
      `-> bool`.
    * `test_kernel_shift_operators.py` (5 tests): bulk-discriminate
      with `cudaq.to_bools(mz(q))` so shift operands are integer-typed.

    Bridge fix in `changeOperandToType`: also auto-discriminate when
    the target type is `i8` (Python's storage representation for
    `bool`-element lists / dataclass slots), not just `i1`. After
    discriminate the recursive call promotes i1->i8 via the existing
    cast logic.

Sanity gate: full `python/tests/kernel/` pytest sweep is 620 passed,
47 skipped, 1 xfailed (all pre-existing). Python MLIR lit suite runs
94/94 green.

Co-authored-by: Cursor <cursoragent@cursor.com>
Signed-off-by: Pradnya Khalate <pkhalate@nvidia.com>

Author: khalatepradnya

python/cudaq/kernel/ast_bridge.py

@@ -624,15 +624,17 @@ def changeOperandToType(self, ty, operand, allowDemotion=False):
         """
         if ty == operand.type:
             return operand
-        # `measure_handle -> bool` is the user-defined coercion sanctioned by
-        # the spec; insert a `quake.discriminate` then continue with the
-        # usual promotion/demotion rules. This catches `bool b = mz(q)`,
-        # `return mz(q)` from a `-> bool` kernel, bool-typed function-call
-        # arguments, and the recursive call from `__arithmetic_to_bool`.
-        # Spec `measure_handle.bs` (Python API; IR Representation).
-        if (IntegerType.isinstance(ty) and IntegerType(ty).width == 1 and
+        # `measure_handle -> bool` is a user-defined coercion: insert a
+        # `quake.discriminate` then continue with the usual promotion /
+        # demotion rules. This catches `bool b = mz(q)`, `return mz(q)`
+        # from a `-> bool` kernel, bool-typed function-call arguments,
+        # the recursive call from `__arithmetic_to_bool`, and element-
+        # stores into a `list[bool]` (which the bridge backs with `i8`
+        # element storage but logically owns as bool).
+        if (IntegerType.isinstance(ty) and IntegerType(ty).width in (1, 8) and
                 cc.MeasureHandleType.isinstance(operand.type)):
-            return self.__discriminateIfMeasureHandle(operand, self.currentNode)
+            disc = self.__discriminateIfMeasureHandle(operand, self.currentNode)
+            return self.changeOperandToType(ty, disc, allowDemotion)
         if (cc.StdvecType.isinstance(ty) and
                 cc.StdvecType.getElementType(ty) == self.getIntegerType(1) and
                 cc.StdvecType.isinstance(operand.type) and
@@ -847,10 +849,10 @@ def __isProvablyUnboundHandleSource(self, value):
         `VisitCastExpr::CK_UserDefinedConversion` (search for "Push a
         placeholder i1 so the enclosing statement's value stack stays
         balanced"). The C++ check examines the pattern
-        `cc.load(cc.alloca)` and reports the diagnostic if the alloca has
+        `cc.load(cc.alloca)` and reports the diagnostic if the `alloca` has
         no `cc.store` users; in Python the AST bridge stores the
-        default-constructed `cc.UndefOp` value into the alloca (so the
-        alloca always has at least one store), so we instead check that
+        default-constructed `cc.UndefOp` value into the `alloca` (so the
+        `alloca` always has at least one store), so we instead check that
         the only stored values come from `cc.UndefOp`. We also catch the
         direct `cc.UndefOp -> bool` flow (e.g. the spec example
         `bool(cudaq.measure_handle())`).
@@ -3653,7 +3655,7 @@ def check_vector_init():
                         # Spec §C++ API / Python API: `cudaq.to_bools` is
                         # the bulk counterpart to the per-element
                         # `measure_handle -> bool` coercion. Lower to a
-                        # vectorized `quake.discriminate` on the handle
+                        # vector form `quake.discriminate` on the handle
                         # vector. Mirrors `to_bools` in
                         # `lib/Frontend/nvqpp/ConvertExpr.cpp`.
                         if len(node.args) != 1 or node.keywords:

python/tests/kernel/test_assignments.py

@@ -1150,25 +1150,23 @@ def test1() -> list[bool]:
     assert 'variable defined in parent scope cannot be modified' in str(e.value)
     assert '(offending source -> c = qs[1])' in str(e.value)
 
-    # TODO: The reason we cannot currently support this is
-    # because we store measurement results as values in the
-    # symbol table. This should be changed and supported when
-    # we do the change to properly distinguish measurement
-    # types from booleans.
-    with pytest.raises(RuntimeError) as e:
-
-        @cudaq.kernel
-        def test2() -> bool:
-            qs = cudaq.qvector(2)
-            res = mz(qs[0])
-            if True:
-                x(qs[1])
-                res = mz(qs[1])
-            return res
+    # Reassigning a `measure_handle`-typed variable across scopes is
+    # supported now that `mz` returns `cudaq.measure_handle` instead of
+    # `bool`: the symbol-table slot has handle type, the inner-scope
+    # store binds a fresh handle, and the bool-coercion at `return res`
+    # discriminates exactly once. Previously this case was disallowed
+    # because measurement results were stored as raw `i1` values in the
+    # symbol table.
+    @cudaq.kernel
+    def test2() -> bool:
+        qs = cudaq.qvector(2)
+        res = mz(qs[0])
+        if True:
+            x(qs[1])
+            res = mz(qs[1])
+        return res
 
-        test2()
-    assert 'variable defined in parent scope cannot be modified' in str(e.value)
-    assert '(offending source -> res = mz(qs[1]))' in str(e.value)
+    test2()
 
 
 def test_var_scopes():
@@ -1391,7 +1389,8 @@ def fct():
                 x(q)
 
         fct()
-        return i, mz(q)
+        # FIXME: aggregate-element typing does not currently auto-discriminate, so coerce explicitly.
+        return i, bool(mz(q))
 
     out = cudaq.run(test1, True, False, shots_count=10)
     assert all(res == (True, False) for res in out)

python/tests/kernel/test_kernel_features.py

@@ -2720,7 +2720,7 @@ def test_mid_circuit_measurements():
 
     @cudaq.kernel
     def callee(register: cudaq.qview) -> list[bool]:
-        result = [0, 0, 0, 0, 0, 0, 0, 0]
+        result = [False, False, False, False, False, False, False, False]
         for i in range(4):
             j = i * 2
             if i % 2 == 0:

python/tests/kernel/test_kernel_shift_operators.py

@@ -76,7 +76,7 @@ def test_run_with_integer_left_shift_operator():
     @cudaq.kernel
     def kernel(n: int) -> int:
         q = cudaq.qvector(n)
-        m = mz(q)
+        m = cudaq.to_bools(mz(q))
         r = 0
         for i in range(n):
             r = r & (m[i] << i)
@@ -96,7 +96,7 @@ def test_run_with_non_integer_left_shift_operator():
         @cudaq.kernel
         def kernel(n: int) -> int:
             q = cudaq.qvector(n)
-            m = mz(q)
+            m = cudaq.to_bools(mz(q))
             r = 0
             for i in range(n):
                 r = r & (m[i] << 1.0)
@@ -113,7 +113,7 @@ def test_run_with_integer_right_shift_operator():
     @cudaq.kernel
     def kernel(n: int) -> int:
         q = cudaq.qvector(n)
-        m = mz(q)
+        m = cudaq.to_bools(mz(q))
         r = 0
         for i in range(n):
             r = r & (m[i] >> i)
@@ -131,7 +131,7 @@ def test_run_with_integer_bitwise_or_operator():
     @cudaq.kernel
     def kernel(n: int) -> int:
         q = cudaq.qvector(n)
-        m = mz(q)
+        m = cudaq.to_bools(mz(q))
         r = 0
         for i in range(n):
             r = r | (m[i] >> i)
@@ -149,7 +149,7 @@ def test_run_with_integer_bitwise_xor_operator():
     @cudaq.kernel
     def kernel(n: int) -> int:
         q = cudaq.qvector(n)
-        m = mz(q)
+        m = cudaq.to_bools(mz(q))
         r = 0
         for i in range(n):
             r = r ^ (m[i] >> i)