NVIDIA · bettinaheim · Sep 30, 2025 · Sep 30, 2025 · Oct 1, 2025 · Oct 2, 2025
diff --git a/python/cudaq/kernel/ast_bridge.py b/python/cudaq/kernel/ast_bridge.py
diff --git a/python/extension/CUDAQuantumExtension.cpp b/python/extension/CUDAQuantumExtension.cpp
@@ -281,6 +281,11 @@ PYBIND11_MODULE(_quakeDialects, m) {
   cudaqRuntime.def("isTerminator", [](MlirOperation op) {
     return unwrap(op)->hasTrait<mlir::OpTrait::IsTerminator>();
   });
+  // TODO: This is needed because with LLVM 16, it seems that the MLIR
+  // Python bindings do not expose cc::ArrayType::getSize to Python.
+  // This should be replaced by the automatically generated binding
+  // once it is available.
+  cudaqRuntime.def("ArrayTypeGetSize", &cudaq::cc::ArrayType::getSize);
 
   auto ahsSubmodule = cudaqRuntime.def_submodule("ahs");
   cudaq::bindAnalogHamiltonian(ahsSubmodule);

diff --git a/python/tests/kernel/test_kernel_features.py b/python/tests/kernel/test_kernel_features.py
@@ -839,6 +839,124 @@ def kernel6():
     assert len(counts) == 1
     assert '0101' in counts
 
+    @cudaq.kernel
+    def kernel7():
+        qubits = cudaq.qvector(5)
+        r = [i for i in range(2, 5)]
+        for i in r:
+            x(qubits[i])
+
+    counts = cudaq.sample(kernel7)
+    assert len(counts) == 1
+    assert '00111' in counts
+
+    @cudaq.kernel
+    def kernel8():
+        qubits = cudaq.qvector(5)
+        r = [i for i in range(2, 6, 2)]
+        for i in r:
+            x(qubits[i])
+
+    counts = cudaq.sample(kernel8)
+    assert len(counts) == 1
+    assert '00101' in counts
+
+    @cudaq.kernel
+    def kernel9():
+        qubits = cudaq.qvector(5)
+        r = [i for i in range(6, 2, 2)]
+        for i in r:
+            x(qubits[i])
+
+    counts = cudaq.sample(kernel9)
+    assert len(counts) == 1
+    assert '00000' in counts
+
+    @cudaq.kernel
+    def kernel10():
+        qubits = cudaq.qvector(5)
+        r = [i for i in range(3, 0, -2)]
+        for i in r:
+            x(qubits[i])
+
+    counts = cudaq.sample(kernel10)
+    assert len(counts) == 1
+    assert '01010' in counts
+
+    @cudaq.kernel
+    def kernel11():
+        qubits = cudaq.qvector(5)
+        r = [i for i in range(-5, -2, -2)]
+        for i in r:
+            x(qubits[i])
+
+    counts = cudaq.sample(kernel11)
+    assert len(counts) == 1
+    assert '00000' in counts
+
+    @cudaq.kernel
+    def kernel12():
+        qubits = cudaq.qvector(5)
+        r = [i for i in range(-1, -5, -2)]
+        for i in r:
+            x(qubits[-i])
+
+    counts = cudaq.sample(kernel12)
+    assert len(counts) == 1
+    assert '01010' in counts
+
+    @cudaq.kernel
+    def kernel13():
+        qubits = cudaq.qvector(5)
+        r = [i for i in range(1, -4, -1)]
+        for i in r:
+            if i < 0:
+                x(qubits[-i])
+            else:
+                x(qubits[i])
+
+    counts = cudaq.sample(kernel13)
+    assert len(counts) == 1
+    assert '10110' in counts
+
+    @cudaq.kernel
+    def kernel14():
+        qubits = cudaq.qvector(5)
+        r = [i for i in range(-2, 6, 2)]
+        for i in r:
+            if i < 0:
+                x(qubits[-i])
+            else:
+                x(qubits[i])
+
+    counts = cudaq.sample(kernel14)
+    assert len(counts) == 1
+    assert '10001' in counts
+
+    @cudaq.kernel
+    def kernel15():
+        qubits = cudaq.qvector(5)
+        r = [i for i in range(1, 4, 0)]
+        for i in r:
+            x(qubits[i])
+
+    with pytest.raises(RuntimeError) as e:
+        cudaq.sample(kernel15)
+    assert "range step value must be non-zero" in str(e.value)
+    assert "offending source -> range(1, 4, 0)" in str(e.value)
+
+    @cudaq.kernel
+    def kernel16(v : int):
+        qubits = cudaq.qvector(5)
+        r = [i for i in range(1, 4, v)]
+        for i in r:
+            x(qubits[i])
+
+    with pytest.raises(RuntimeError) as e:
+        cudaq.sample(kernel16)
+    assert "range step value must be a constant" in str(e.value)
+    assert "offending source -> range(1, 4, v)" in str(e.value)
+
 
 def test_array_value_assignment():
 
@@ -1558,7 +1676,8 @@ def test_kernel():
 
     with pytest.raises(RuntimeError) as e:
         test_kernel.compile()
-    assert 'invalid assignment detected.' in repr(e)
+    assert 'no valid value was created' in repr(e)
+    assert '(offending source -> state_reg = cudaq.qubit)' in repr(e)
 
 
 def test_cast_error_1451():
@@ -2151,8 +2270,9 @@ def less_arguments():
 
     with pytest.raises(RuntimeError) as error:
         print(less_arguments)
-    assert 'invalid number of arguments (1) passed to rx (requires at least 2 arguments)' in repr(
+    assert 'missing argument for target operand' in repr(
         error)
+    assert '(offending source -> rx(3.14))' in repr(error)
 
     @cudaq.kernel
     def wrong_arguments():

diff --git a/python/tests/kernel/test_run_async_kernel.py b/python/tests/kernel/test_run_async_kernel.py
@@ -743,7 +743,7 @@ def simple_dataclass_int_bool_error() -> MyClass:
 
     with pytest.raises(RuntimeError) as e:
         cudaq.run_async(simple_dataclass_int_bool_error, shots_count=2).get()
-    assert 'invalid number of arguments passed in call to MyClass (0 vs required 2)' in repr(
+    assert 'invalid number of arguments' in repr(
         e)
 
     @cudaq.kernel
@@ -752,7 +752,7 @@ def simple_dataclass_int_bool_error() -> MyClass:
 
     with pytest.raises(RuntimeError) as e:
         cudaq.run_async(simple_dataclass_int_bool_error, shots_count=2).get()
-    assert 'invalid number of arguments passed in call to MyClass (0 vs required 2)' in repr(
+    assert 'invalid number of arguments' in repr(
         e)
 
 

diff --git a/python/tests/kernel/test_run_kernel.py b/python/tests/kernel/test_run_kernel.py
@@ -311,7 +311,7 @@ def incrementer(i: int) -> int:
     def kernel_with_list_arg(arg: list[int]) -> list[int]:
         result = arg
         for i in result:
-            incrementer(i)
+            incrementer(i) # FIXME: THIS IS NOT HOW PYTHON SHOULD BEHAVE...!
         return result
 
     @cudaq.kernel

diff --git a/python/tests/mlir/ast_elif.py b/python/tests/mlir/ast_elif.py
@@ -19,7 +19,7 @@ def test_elif():
     def cost(thetas: np.ndarray):  # can pass 1D ndarray or list
         q = cudaq.qvector(4)
         for i, theta in enumerate(thetas):
-            if i % 2.0:  # asserting we convert 2.0 to 2
+            if i % 2.0:  # asserting we convert i to float
                 ry(theta, q[i % 4])
             else:
                 rx(theta, q[i % 4])
@@ -44,10 +44,10 @@ def cost(thetas: np.ndarray):  # can pass 1D ndarray or list
 # CHECK:             %[[VAL_10:.*]] = cc.stdvec_data %[[VAL_0]] : (!cc.stdvec<f64>) -> !cc.ptr<!cc.array<f64 x ?>>
 # CHECK:             %[[VAL_11:.*]] = cc.compute_ptr %[[VAL_10]]{{\[}}%[[VAL_9]]] : (!cc.ptr<!cc.array<f64 x ?>>, i64) -> !cc.ptr<f64>
 # CHECK:             %[[VAL_12:.*]] = arith.constant 2.000000e+00 : f64
-# CHECK:             %[[VAL_13:.*]] = arith.fptosi %[[VAL_12]] : f64 to i64
-# CHECK:             %[[VAL_14:.*]] = arith.remui %[[VAL_9]], %[[VAL_13]] : i64
-# CHECK:             %[[VAL_15:.*]] = arith.constant 0 : i64
-# CHECK:             %[[VAL_16:.*]] = arith.cmpi ne, %[[VAL_14]], %[[VAL_15]] : i64
+# CHECK:             %[[VAL_13:.*]] = cc.cast signed %[[VAL_9]] : (i64) -> f64
+# CHECK:             %[[VAL_14:.*]] = arith.remf %[[VAL_13]], %[[VAL_12]] : f64
+# CHECK:             %[[VAL_15:.*]] = arith.constant 0.000000e+00 : f64
+# CHECK:             %[[VAL_16:.*]] = arith.cmpf une, %[[VAL_14]], %[[VAL_15]] : f64
 # CHECK:             cc.if(%[[VAL_16]]) {
 # CHECK:               %[[VAL_17:.*]] = cc.load %[[VAL_11]] : !cc.ptr<f64>
 # CHECK:               %[[VAL_18:.*]] = arith.constant 4 : i64
@@ -72,7 +72,8 @@ def cost(thetas: np.ndarray):  # can pass 1D ndarray or list
 
 # CHECK-LABEL:   func.func @__nvqpp__mlirgen__cost(
 # CHECK-SAME:      %[[VAL_0:.*]]: !cc.stdvec<f64>) attributes {"cudaq-entrypoint", "cudaq-kernel"} {
-# CHECK-DAG:       %[[VAL_1:.*]] = arith.constant 2 : i64
+# CHECK-DAG:       %[[VAL:.*]] = arith.constant 0.000000e+00 : f64
+# CHECK-DAG:       %[[VAL_1:.*]] = arith.constant 2.000000e+00 : f64
 # CHECK-DAG:       %[[VAL_2:.*]] = arith.constant 1 : i64
 # CHECK-DAG:       %[[VAL_3:.*]] = arith.constant 0 : i64
 # CHECK-DAG:       %[[VAL_4:.*]] = arith.constant 4 : i64
@@ -85,24 +86,25 @@ def cost(thetas: np.ndarray):  # can pass 1D ndarray or list
 # CHECK:           ^bb0(%[[VAL_10:.*]]: i64):
 # CHECK:             %[[VAL_11:.*]] = cc.stdvec_data %[[VAL_0]] : (!cc.stdvec<f64>) -> !cc.ptr<!cc.array<f64 x ?>>
 # CHECK:             %[[VAL_12:.*]] = cc.compute_ptr %[[VAL_11]]{{\[}}%[[VAL_10]]] : (!cc.ptr<!cc.array<f64 x ?>>, i64) -> !cc.ptr<f64>
-# CHECK:             %[[VAL_13:.*]] = arith.remui %[[VAL_10]], %[[VAL_1]] : i64
-# CHECK:             %[[VAL_14:.*]] = arith.cmpi ne, %[[VAL_13]], %[[VAL_3]] : i64
-# CHECK:             cc.if(%[[VAL_14]]) {
-# CHECK:               %[[VAL_15:.*]] = cc.load %[[VAL_12]] : !cc.ptr<f64>
-# CHECK:               %[[VAL_16:.*]] = arith.remui %[[VAL_10]], %[[VAL_4]] : i64
-# CHECK:               %[[VAL_17:.*]] = quake.extract_ref %[[VAL_5]]{{\[}}%[[VAL_16]]] : (!quake.veq<4>, i64) -> !quake.ref
-# CHECK:               quake.ry (%[[VAL_15]]) %[[VAL_17]] : (f64, !quake.ref) -> ()
+# CHECK:             %[[VAL_13:.*]] = cc.cast signed %[[VAL_10]] : (i64) -> f64
+# CHECK:             %[[VAL_14:.*]] = arith.remf %[[VAL_13]], %[[VAL_1]] : f64
+# CHECK:             %[[VAL_15:.*]] = arith.cmpf une, %[[VAL_14]], %[[VAL]] : f64
+# CHECK:             cc.if(%[[VAL_15]]) {
+# CHECK:               %[[VAL_16:.*]] = cc.load %[[VAL_12]] : !cc.ptr<f64>
+# CHECK:               %[[VAL_17:.*]] = arith.remui %[[VAL_10]], %[[VAL_4]] : i64
+# CHECK:               %[[VAL_18:.*]] = quake.extract_ref %[[VAL_5]]{{\[}}%[[VAL_17]]] : (!quake.veq<4>, i64) -> !quake.ref
+# CHECK:               quake.ry (%[[VAL_16]]) %[[VAL_18]] : (f64, !quake.ref) -> ()
 # CHECK:             } else {
-# CHECK:               %[[VAL_18:.*]] = cc.load %[[VAL_12]] : !cc.ptr<f64>
-# CHECK:               %[[VAL_19:.*]] = arith.remui %[[VAL_10]], %[[VAL_4]] : i64
-# CHECK:               %[[VAL_20:.*]] = quake.extract_ref %[[VAL_5]]{{\[}}%[[VAL_19]]] : (!quake.veq<4>, i64) -> !quake.ref
-# CHECK:               quake.rx (%[[VAL_18]]) %[[VAL_20]] : (f64, !quake.ref) -> ()
+# CHECK:               %[[VAL_19:.*]] = cc.load %[[VAL_12]] : !cc.ptr<f64>
+# CHECK:               %[[VAL_20:.*]] = arith.remui %[[VAL_10]], %[[VAL_4]] : i64
+# CHECK:               %[[VAL_21:.*]] = quake.extract_ref %[[VAL_5]]{{\[}}%[[VAL_20]]] : (!quake.veq<4>, i64) -> !quake.ref
+# CHECK:               quake.rx (%[[VAL_19]]) %[[VAL_21]] : (f64, !quake.ref) -> ()
 # CHECK:             }
 # CHECK:             cc.continue %[[VAL_10]] : i64
 # CHECK:           } step {
-# CHECK:           ^bb0(%[[VAL_21:.*]]: i64):
-# CHECK:             %[[VAL_22:.*]] = arith.addi %[[VAL_21]], %[[VAL_2]] : i64
-# CHECK:             cc.continue %[[VAL_22]] : i64
+# CHECK:           ^bb0(%[[VAL_22:.*]]: i64):
+# CHECK:             %[[VAL_23:.*]] = arith.addi %[[VAL_22]], %[[VAL_2]] : i64
+# CHECK:             cc.continue %[[VAL_23]] : i64
 # CHECK:           } {invariant}
 # CHECK:           return
-# CHECK:         }
+# CHECK:         }
diff --git a/python/tests/mlir/ast_list_comprehension.py b/python/tests/mlir/ast_list_comprehension.py
@@ -271,8 +271,8 @@ def kernel3() -> float:
 
 
 # CHECK-LABEL:   func.func @__nvqpp__mlirgen__kernel1() -> i1 attributes {"cudaq-entrypoint", "cudaq-kernel"}
-# CHECK:            %[[VAL_0:.*]] = arith.constant 1 : i64
-# CHECK:            %[[VAL_1:.*]] = arith.constant true
+# CHECK-DAG:        %[[VAL_0:.*]] = arith.constant 1 : i64
+# CHECK-DAG:        %[[VAL_1:.*]] = arith.constant true
 # CHECK:            %[[VAL_2:.*]] = cc.alloca !cc.array<!cc.stdvec<i1> x 5>
 # CHECK:            %[[VAL_3:.*]] = cc.alloca !cc.array<i1 x 1>
 # CHECK:            %[[VAL_4:.*]] = cc.cast %[[VAL_3]] : (!cc.ptr<!cc.array<i1 x 1>>) -> !cc.ptr<!cc.array<i1 x ?>>
@@ -283,8 +283,8 @@ def kernel3() -> float:
 # CHECK:            cc.store %[[VAL_6]], %[[VAL_7]] : !cc.ptr<!cc.stdvec<i1>>
 
 # CHECK-LABEL:   func.func @__nvqpp__mlirgen__kernel2() -> f64 attributes {"cudaq-entrypoint", "cudaq-kernel"}
-# CHECK:            %[[VAL_0:.*]] = arith.constant 1 : i64
-# CHECK:            %[[VAL_1:.*]] = arith.constant 1.000000e+00 : f64
+# CHECK-DAG:        %[[VAL_0:.*]] = arith.constant 1 : i64
+# CHECK-DAG:        %[[VAL_1:.*]] = arith.constant 1.000000e+00 : f64
 # CHECK:            %[[VAL_2:.*]] = cc.alloca !cc.array<!cc.stdvec<f64> x 5>
 # CHECK:            %[[VAL_3:.*]] = cc.alloca !cc.array<f64 x 1>
 # CHECK:            %[[VAL_4:.*]] = cc.cast %[[VAL_3]] : (!cc.ptr<!cc.array<f64 x 1>>) -> !cc.ptr<!cc.array<f64 x ?>>
@@ -295,8 +295,8 @@ def kernel3() -> float:
 # CHECK:            cc.store %[[VAL_6]], %[[VAL_7]] : !cc.ptr<!cc.stdvec<f64>>
 
 # CHECK-LABEL:   func.func @__nvqpp__mlirgen__kernel3() -> f64 attributes {"cudaq-entrypoint", "cudaq-kernel"}
-# CHECK:            %[[VAL_0:.*]] = arith.constant 1 : i64
-# CHECK:            %[[VAL_1:.*]] = complex.constant [0.000000e+00, 1.000000e+00] : complex<f64>
+# CHECK-DAG:        %[[VAL_0:.*]] = arith.constant 1 : i64
+# CHECK-DAG:        %[[VAL_1:.*]] = complex.constant [0.000000e+00, 1.000000e+00] : complex<f64>
 # CHECK:            %[[VAL_2:.*]] = cc.alloca !cc.array<!cc.stdvec<complex<f64>> x 5>
 # CHECK:            %[[VAL_3:.*]] = cc.alloca !cc.array<complex<f64> x 1>
 # CHECK:            %[[VAL_4:.*]] = cc.cast %[[VAL_3]] : (!cc.ptr<!cc.array<complex<f64> x 1>>) -> !cc.ptr<!cc.array<complex<f64> x ?>>

diff --git a/python/tests/mlir/ast_while_loop.py b/python/tests/mlir/ast_while_loop.py
@@ -23,8 +23,10 @@ def cost():
             ry(np.pi, q[i])
             i -= 1
 
+    counts = cudaq.sample(cost)
+    assert len(counts) == 1
+    assert '011111' in counts
     print(cost)
-    # cost()
 
 
 # CHECK-LABEL:   func.func @__nvqpp__mlirgen__cost() attributes {"cudaq-entrypoint", "cudaq-kernel"} {
@@ -62,12 +64,16 @@ def cost():
             ry(np.pi, q[i])
             i -= 1
 
+    counts = cudaq.sample(cost)
+    assert len(counts) == 1
+    assert '000111' in counts
     print(cost)
 
 
 # CHECK-LABEL:   func.func @__nvqpp__mlirgen__cost() attributes {"cudaq-entrypoint", "cudaq-kernel"} {
 # CHECK-DAG:           %[[VAL_0:.*]] = arith.constant 1 : i64
 # CHECK-DAG:           %[[VAL_1:.*]] = arith.constant 3.1415926535897931 : f64
+# CHECK-DAG:           %[[VAL_10:.*]] = arith.constant 2 : i64
 # CHECK-DAG:           %[[VAL_2:.*]] = arith.constant 14 : i64
 # CHECK-DAG:           %[[VAL_3:.*]] = arith.constant false
 # CHECK-DAG:           %[[VAL_4:.*]] = arith.constant 0 : i64
@@ -77,16 +83,22 @@ def cost():
 # CHECK:           cc.store %[[VAL_5]], %[[VAL_7]] : !cc.ptr<i64>
 # CHECK:           cc.loop while {
 # CHECK:             %[[VAL_8:.*]] = cc.load %[[VAL_7]] : !cc.ptr<i64>
-# CHECK:             %[[VAL_9:.*]] = arith.cmpi sgt, %[[VAL_8]], %[[VAL_4]] : i64
-# CHECK:             %[[VAL_10:.*]] = arith.cmpi eq, %[[VAL_9]], %[[VAL_3]] : i1
-# CHECK:             %[[VAL_11:.*]] = cc.if(%[[VAL_10]]) -> i1 {
+# CHECK:             %[[VAL_9:.*]] = arith.cmpi sle, %[[VAL_8]], %[[VAL_4]] : i64
+# CHECK:             %[[VAL_11:.*]] = cc.if(%[[VAL_9]]) -> i1 {
 # CHECK:               cc.continue %[[VAL_3]] : i1
 # CHECK:             } else {
 # CHECK:               %[[VAL_12:.*]] = cc.load %[[VAL_7]] : !cc.ptr<i64>
-# CHECK:               %[[VAL_13:.*]] = arith.cmpi slt, %[[VAL_12]], %[[VAL_2]] : i64
-# CHECK:               cc.continue %[[VAL_13]] : i1
+# CHECK:               %[[VAL_13:.*]] = arith.cmpi sge, %[[VAL_12]], %[[VAL_2]] : i64
+# CHECK:               %[[VAL_20:.*]] = cc.if(%[[VAL_13]]) -> i1 {
+# CHECK:                 cc.continue %[[VAL_3]] : i1
+# CHECK:               } else {
+# CHECK:                 %[[VAL_21:.*]] = cc.load %[[VAL_7]] : !cc.ptr<i64>
+# CHECK:                 %[[VAL_22:.*]] = arith.cmpi ne, %[[VAL_21]], %[[VAL_10]] : i64
+# CHECK:                 cc.continue %[[VAL_22]] : i1
+# CHECK:               }
+# CHECK:               cc.continue %[[VAL_20:.*]]
 # CHECK:             }
-# CHECK:             cc.condition %[[VAL_14:.*]]
+# CHECK:             cc.condition %[[VAL_11:.*]]
 # CHECK:           } do {
 # CHECK:             %[[VAL_15:.*]] = cc.load %[[VAL_7]] : !cc.ptr<i64>
 # CHECK:             %[[VAL_16:.*]] = quake.extract_ref %[[VAL_6]]{{\[}}%[[VAL_15]]] : (!quake.veq<6>, i64) -> !quake.ref

diff --git a/python/tests/mlir/bug_1875.py b/python/tests/mlir/bug_1875.py
@@ -49,9 +49,8 @@ def kernel_break():
 # CHECK:           %[[VAL_7:.*]] = quake.mz %[[VAL_3]] name "aux_2" : (!quake.ref) -> !quake.measure
 # CHECK:           %[[VAL_8:.*]] = quake.discriminate %[[VAL_7]] : (!quake.measure) -> i1
 # CHECK:           %[[VAL_9:.*]] = cc.cast unsigned %[[VAL_6]] : (i1) -> i64
-# CHECK:           %[[VAL_10:.*]] = arith.cmpi eq, %[[VAL_9]], %[[VAL_1]] : i64
-# CHECK:           %[[VAL_11:.*]] = arith.cmpi eq, %[[VAL_10]], %[[VAL_0]] : i1
-# CHECK:           %[[VAL_12:.*]] = cc.if(%[[VAL_11]]) -> i1 {
+# CHECK:           %[[VAL_10:.*]] = arith.cmpi ne, %[[VAL_9]], %[[VAL_1]] : i64
+# CHECK:           %[[VAL_12:.*]] = cc.if(%[[VAL_10]]) -> i1 {
 # CHECK:             cc.continue %[[VAL_0]] : i1
 # CHECK:           } else {
 # CHECK:             %[[VAL_13:.*]] = cc.cast unsigned %[[VAL_8]] : (i1) -> i64