classiq 0.89.0__py3-none-any.whl → 0.91.0__py3-none-any.whl

classiq/qmod/builtins/functions/chemistry.py

@@ -1,3 +1,7 @@
+import warnings
+
+from classiq.interface.exceptions import ClassiqDeprecationWarning
+
 from classiq.qmod.builtins.structs import (
     FockHamiltonianProblem,
     MoleculeProblem,
@@ -13,6 +17,16 @@ def molecule_ucc(
     excitations: CArray[CInt],
     qbv: QArray[QBit],
 ) -> None:
+    warnings.warn(
+        (
+            "The function `molecule_ucc` is deprecated and will no "
+            "longer be supported starting on 2025-09-18 at the earliest. "
+            "For more information on Classiq's chemistry application, see "
+            "https://docs.classiq.io/latest/explore/applications/chemistry/classiq_chemistry_application/classiq_chemistry_application/."
+        ),
+        category=ClassiqDeprecationWarning,
+        stacklevel=2,
+    )
     pass
 
 
@@ -22,6 +36,16 @@ def molecule_hva(
     reps: CInt,
     qbv: QArray[QBit],
 ) -> None:
+    warnings.warn(
+        (
+            "The function `molecule_hva` is deprecated and will no "
+            "longer be supported starting on 2025-09-18 at the earliest. "
+            "For more information on Classiq's chemistry application, see "
+            "https://docs.classiq.io/latest/explore/applications/chemistry/classiq_chemistry_application/classiq_chemistry_application/."
+        ),
+        category=ClassiqDeprecationWarning,
+        stacklevel=2,
+    )
     pass
 
 
@@ -30,6 +54,16 @@ def molecule_hartree_fock(
     molecule_problem: MoleculeProblem,
     qbv: QArray[QBit],
 ) -> None:
+    warnings.warn(
+        (
+            "The function `molecule_hartree_fock` is deprecated and will no "
+            "longer be supported starting on 2025-09-18 at the earliest. "
+            "For more information on Classiq's chemistry application, see "
+            "https://docs.classiq.io/latest/explore/applications/chemistry/classiq_chemistry_application/classiq_chemistry_application/."
+        ),
+        category=ClassiqDeprecationWarning,
+        stacklevel=2,
+    )
     pass
 
 
@@ -39,6 +73,16 @@ def fock_hamiltonian_ucc(
     excitations: CArray[CInt],
     qbv: QArray[QBit],
 ) -> None:
+    warnings.warn(
+        (
+            "The function `fock_hamiltonian_ucc` is deprecated and will no "
+            "longer be supported starting on 2025-09-18 at the earliest. "
+            "For more information on Classiq's chemistry application, see "
+            "https://docs.classiq.io/latest/explore/applications/chemistry/classiq_chemistry_application/classiq_chemistry_application/."
+        ),
+        category=ClassiqDeprecationWarning,
+        stacklevel=2,
+    )
     pass
 
 
@@ -48,6 +92,16 @@ def fock_hamiltonian_hva(
     reps: CInt,
     qbv: QArray[QBit],
 ) -> None:
+    warnings.warn(
+        (
+            "The function `fock_hamiltonian_hva` is deprecated and will no "
+            "longer be supported starting on 2025-09-18 at the earliest. "
+            "For more information on Classiq's chemistry application, see "
+            "https://docs.classiq.io/latest/explore/applications/chemistry/classiq_chemistry_application/classiq_chemistry_application/."
+        ),
+        category=ClassiqDeprecationWarning,
+        stacklevel=2,
+    )
     pass
 
 
@@ -56,4 +110,14 @@ def fock_hamiltonian_hartree_fock(
     fock_hamiltonian_problem: FockHamiltonianProblem,
     qbv: QArray[QBit],
 ) -> None:
+    warnings.warn(
+        (
+            "The function `fock_hamiltonian_hartree_fock` is deprecated and will no "
+            "longer be supported starting on 2025-09-18 at the earliest. "
+            "For more information on Classiq's chemistry application, see "
+            "https://docs.classiq.io/latest/explore/applications/chemistry/classiq_chemistry_application/classiq_chemistry_application/."
+        ),
+        category=ClassiqDeprecationWarning,
+        stacklevel=2,
+    )
     pass

classiq/qmod/builtins/functions/exponentiation.py

@@ -14,7 +14,7 @@ from classiq.qmod.qmod_variable import QArray, QBit
 def single_pauli_exponent(
     pauli_string: CArray[Pauli],
     coefficient: CReal,
-    qbv: QArray[QBit, Literal["get_field(pauli_string, 'len')"]],
+    qbv: QArray[QBit, Literal["pauli_string.len"]],
 ) -> None:
     """
     [Qmod core-library function]
@@ -33,9 +33,7 @@ def single_pauli_exponent(
 def commuting_paulis_exponent(
     pauli_operator: CArray[PauliTerm],
     evolution_coefficient: CReal,
-    qbv: QArray[
-        QBit, Literal["get_field(get_field(pauli_operator[0], 'pauli'), 'len')"]
-    ],
+    qbv: QArray[QBit, Literal["pauli_operator[0].pauli.len"]],
 ) -> None:
     """
     [Qmod core-library function]
@@ -113,11 +111,11 @@ def multi_suzuki_trotter(
 @qfunc(external=True)
 def parametric_suzuki_trotter(
     paulis: CArray[CArray[Pauli]],
-    coefficients: CArray[CReal, Literal["get_field(paulis, 'len')"]],
+    coefficients: CArray[CReal, Literal["paulis.len"]],
     evolution_coefficient: CReal,
     order: CInt,
     repetitions: CInt,
-    qbv: QArray[QBit, Literal["get_field(paulis[0], 'len')"]],
+    qbv: QArray[QBit, Literal["paulis[0].len"]],
 ) -> None:
     """
     [Qmod core-library function]
@@ -147,7 +145,7 @@ def sparse_suzuki_trotter(
     evolution_coefficient: CReal,
     order: CInt,
     repetitions: CInt,
-    qbv: QArray[QBit, Literal["get_field(pauli_operator, 'num_qubits')"]],
+    qbv: QArray[QBit, Literal["pauli_operator.num_qubits"]],
 ) -> None:
     """
     [Qmod core-library function]
@@ -174,9 +172,7 @@ def qdrift(
     pauli_operator: CArray[PauliTerm],
     evolution_coefficient: CReal,
     num_qdrift: CInt,
-    qbv: QArray[
-        QBit, Literal["get_field(get_field(pauli_operator[0], 'pauli'), 'len')"]
-    ],
+    qbv: QArray[QBit, Literal["pauli_operator[0].pauli.len"]],
 ) -> None:
     """
     [Qmod core-library function]
@@ -199,9 +195,7 @@ def exponentiation_with_depth_constraint(
     pauli_operator: CArray[PauliTerm],
     evolution_coefficient: CReal,
     max_depth: CInt,
-    qbv: QArray[
-        QBit, Literal["get_field(get_field(pauli_operator[0], 'pauli'), 'len')"]
-    ],
+    qbv: QArray[QBit, Literal["pauli_operator[0].pauli.len"]],
 ) -> None:
     """
     [Qmod core-library function]

classiq/qmod/builtins/functions/qsvm.py

@@ -11,7 +11,7 @@ from classiq.qmod.qmod_variable import QArray, QBit
 @qfunc(external=True)
 def pauli_feature_map(
     feature_map: QSVMFeatureMapPauli,
-    qbv: QArray[QBit, Literal["get_field(feature_map, 'feature_dimension')"]],
+    qbv: QArray[QBit, Literal["feature_map.feature_dimension"]],
 ) -> None:
     pass
 

classiq/qmod/builtins/operations.py

@@ -1,5 +1,6 @@
 import inspect
 import sys
+import warnings
 from collections.abc import Mapping
 from types import FrameType
 from typing import (
@@ -12,7 +13,7 @@ from typing import (
     overload,
 )
 
-from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.exceptions import ClassiqDeprecationWarning, ClassiqValueError
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.builtins.internal_operators import (
     REPEAT_OPERATOR_NAME,
@@ -516,27 +517,58 @@ def invert(stmt_block: Union[QCallable, Callable[[], Statements]]) -> None:
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(invert_stmt)
 
 
+@overload
+def phase(
+    phase_expr: Union[SymbolicExpr, float], theta: Union[SymbolicExpr, float] = 1.0
+) -> None:
+    pass
+
+
+@overload
+def phase(
+    *, expr: Union[SymbolicExpr, float], theta: Union[SymbolicExpr, float] = 1.0
+) -> None:
+    pass
+
+
 @suppress_return_value
-def phase(expr: SymbolicExpr, theta: float = 1.0) -> None:
+def phase(
+    phase_expr: Union[SymbolicExpr, float, None] = None,
+    theta: Union[SymbolicExpr, float] = 1.0,
+    expr: Any = None,
+) -> None:
     """
-    Applies a state-dependent phase shift to the quantum state.
+    Applies a state-dependent or fixed phase shift (Z rotation) to the quantum state.
 
-    This operation multiplies each basis state |x> by a complex phase factor `theta * expr(x)`,
-    where `expr` is a symbolic expression dependent on the state value `x`, and `theta` is a scalar multiplier.
+    This operation multiplies each computational-basis state $|x_1,x_2,\\ldots,x_n\\rangle$
+    by a complex phase factor $\\theta * \\text{phase_expr}(x_1,x_2,\\ldots,x_n)$, where
+    `phase_expr` is a symbolic expression that contains quantum variables $x_1,x_2,\\ldots,x_n$,
+    and `theta` is a scalar multiplier. If `phase_expr` contains no quantum variables,
+    all states are rotated by the same fixed angle.
 
     Args:
-        expr: A symbolic expression that evaluates to an angle (in radians) as a function of the quantum state value `x`.
-        theta: (Optional) A scalar multiplier for the evaluated expression. Defaults to 1.0.
+        phase_expr: A symbolic expression that evaluates to an angle (in radians) as a function of the state of the quantum variables occurring in it, if any, or otherwise a fixed value. Execution parameters are only allowed if no quantum variables occur in the expression.
+        theta: (Optional, allowed only together with quantum expressions) A scalar multiplier for the evaluated expression, optionally containing execution parameters. Defaults to 1.0.
 
     Note:
-        The `phase` operation is equivalent to a Z-rotation up to a global phase. It is commonly used
-        to apply relative phase shifts conditioned on the quantum state.
+        The `phase` statement is a generalization of the `PHASE()` atomic function, and
+        they are equivalent when the phase_expr is a single-qubit variable.
     """
     assert QCallable.CURRENT_EXPANDABLE is not None
+    if expr is not None:
+        warnings.warn(
+            "Parameter 'expr' of function 'phase' has been renamed to "
+            "'phase_expr'. Parameter 'expr' will no longer be supported starting on "
+            "2025-09-19 at the earliest.\nHint: Change `phase(expr=..., theta=...)` to "
+            "`phase(phase_expr=..., theta=...)` or `phase(..., ...)`.",
+            category=ClassiqDeprecationWarning,
+            stacklevel=2,
+        )
+        phase_expr = expr
     source_ref = get_source_ref(sys._getframe(1))
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
         PhaseOperation(
-            expression=Expression(expr=str(expr)),
+            expression=Expression(expr=str(phase_expr)),
             theta=Expression(expr=str(theta)),
             source_ref=source_ref,
         )

classiq/qmod/generative.py

@@ -4,10 +4,8 @@ from typing import TYPE_CHECKING, Any, Optional
 
 from classiq.interface.exceptions import ClassiqError
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
-    AnyClassicalValue,
-)
 
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
 from classiq.qmod.cparam import CParamScalar
 
 if TYPE_CHECKING:
@@ -47,6 +45,6 @@ def get_frontend_interpreter() -> "GenerativeInterpreter":
 
 def interpret_expression(expr: str) -> Any:
     val = get_frontend_interpreter().evaluate(Expression(expr=expr)).value
-    if isinstance(val, AnyClassicalValue):
+    if isinstance(val, QmodAnnotatedExpression):
         return CParamScalar(str(val))
     return val

classiq/qmod/native/pretty_printer.py

@@ -312,7 +312,7 @@ class DSLPrettyPrinter(ModelVisitor):
         return control
 
     def visit_PhaseOperation(self, op: PhaseOperation) -> str:
-        theta = f", {self.visit(op.theta)}" if op.theta else ""
+        theta = f", {self.visit(op.theta)}" if op.theta.expr != "1.0" else ""
         phase = f"{self._indent}phase ({self.visit(op.expression)}{theta});\n"
         return phase
 

classiq/qmod/pretty_print/pretty_printer.py

@@ -461,7 +461,7 @@ class PythonPrettyPrinter(ModelVisitor):
 
     def visit_PhaseOperation(self, op: PhaseOperation) -> str:
         self._imports["phase"] = 1
-        theta = f", {self.visit(op.theta)}" if op.theta is not None else ""
+        theta = f", {self.visit(op.theta)}" if op.theta.expr != "1.0" else ""
         return f"{self._indent}phase({self.visit(op.expression)}{theta})\n"
 
     def visit_ClassicalIf(self, op: ClassicalIf) -> str:

classiq/qmod/qmod_constant.py

@@ -138,7 +138,7 @@ class QConstant(SymbolicExpr):
                 f"Constant {self.name!r} of type {self._py_type.__name__!r} does not "
                 f"have a 'len' property"
             )
-        len_expr = f"get_field({self.name}, 'len')"
+        len_expr = f"{self.name}.len"
         if is_generative_mode():
             return interpret_expression(len_expr)
         return cast(int, CParamScalar(len_expr))

classiq/qmod/qmod_parameter.py

@@ -100,7 +100,7 @@ class CParamList(CParam):
         if is_generative_mode():
             with generative_mode_context(False):
                 return interpret_expression(str(self.len))
-        return CParamScalar(f"get_field({self}, 'len')")
+        return CParamScalar(f"{self}.len")
 
 
 class CParamStruct(CParam):
@@ -135,7 +135,7 @@ class CParamStruct(CParam):
             )
 
         return create_param(
-            f"get_field({variable_name},{field_name!r})",
+            f"{variable_name}.{field_name}",
             field_type.model_copy(deep=True),
             qmodule=qmodule,
         )

classiq/qmod/qmod_variable.py

@@ -31,10 +31,6 @@ from classiq.interface.exceptions import (
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.expressions.non_symbolic_expr import NonSymbolicExpr
-from classiq.interface.generator.expressions.proxies.quantum.qmod_qarray_proxy import (
-    ILLEGAL_SLICE_MSG,
-    ILLEGAL_SLICING_STEP_MSG,
-)
 from classiq.interface.generator.functions.concrete_types import ConcreteQuantumType
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
@@ -83,6 +79,9 @@ from classiq.qmod.utilities import (
     version_portable_get_args,
 )
 
+ILLEGAL_SLICING_STEP_MSG = "Slicing with a step of a quantum variable is not supported"
+ILLEGAL_SLICE_MSG = "Quantum array slice must be of the form [<int-value>:<int-value>]."
+
 
 @contextmanager
 def _no_current_expandable() -> Iterator[None]:
@@ -156,7 +155,7 @@ class QVar(Symbolic):
         if is_generative_mode():
             with generative_mode_context(False):
                 return interpret_expression(str(self.size))
-        return CParamScalar(f"get_field({self}, 'size')")
+        return CParamScalar(f"{self}.size")
 
     @property
     def type_name(self) -> str:
@@ -229,8 +228,8 @@ class QScalar(QVar, SymbolicExpr):
 
     def __ior__(self, other: Any) -> Self:
         if not isinstance(other, SYMBOLIC_TYPES):
-            raise TypeError(
-                f"Invalid argument {other!r} for out-of-place arithmetic operation"
+            raise ClassiqValueError(
+                f"Invalid argument {str(other)!r} for out-of-place arithmetic operation"
             )
 
         self._insert_arith_operation(
@@ -240,8 +239,8 @@ class QScalar(QVar, SymbolicExpr):
 
     def __ixor__(self, other: Any) -> Self:
         if not isinstance(other, SYMBOLIC_TYPES):
-            raise TypeError(
-                f"Invalid argument {other!r} for in-place arithmetic operation"
+            raise ClassiqValueError(
+                f"Invalid argument {str(other)!r} for in-place arithmetic operation"
             )
 
         self._insert_arith_operation(
@@ -251,8 +250,8 @@ class QScalar(QVar, SymbolicExpr):
 
     def __iadd__(self, other: Any) -> Self:
         if not isinstance(other, SYMBOLIC_TYPES):
-            raise TypeError(
-                f"Invalid argument {other!r} for in-place arithmetic operation"
+            raise ClassiqValueError(
+                f"Invalid argument {str(other)!r} for in-place arithmetic operation"
             )
 
         self._insert_arith_operation(
@@ -262,8 +261,8 @@ class QScalar(QVar, SymbolicExpr):
 
     def __imul__(self, other: Any) -> Self:
         if not isinstance(other, SYMBOLIC_TYPES):
-            raise TypeError(
-                f"Invalid argument {other!r} for out of ampltiude encoding operation"
+            raise ClassiqValueError(
+                f"Invalid argument {str(other)!r} for out of ampltiude encoding operation"
             )
 
         self._insert_amplitude_loading(other, get_source_ref(sys._getframe(1)))
@@ -432,7 +431,7 @@ class QNum(Generic[_P], QScalar):
         name: Union[None, str, HandleBinding] = None,
         size: Union[int, CInt, Expression, SymbolicExpr, None] = None,
         is_signed: Union[bool, CBool, Expression, SymbolicExpr, None] = None,
-        fraction_digits: Union[int, CInt, Expression, None] = None,
+        fraction_digits: Union[int, CInt, Expression, SymbolicExpr, None] = None,
         _expr_str: Optional[str] = None,
     ):
         if size is None and (is_signed is not None or fraction_digits is not None):
@@ -485,14 +484,14 @@ class QNum(Generic[_P], QScalar):
         if is_generative_mode():
             with generative_mode_context(False):
                 return interpret_expression(str(self.fraction_digits))
-        return CParamScalar(f"get_field({self}, 'fraction_digits')")
+        return CParamScalar(f"{self}.fraction_digits")
 
     @property
     def is_signed(self) -> Union[CParamScalar, bool]:
         if is_generative_mode():
             with generative_mode_context(False):
                 return interpret_expression(str(self.is_signed))
-        return CParamScalar(f"get_field({self}, 'is_signed')")
+        return CParamScalar(f"{self}.is_signed")
 
     def get_maximal_bounds(self) -> tuple[float, float]:
         if not is_generative_mode():
@@ -594,7 +593,7 @@ class QArray(ArrayBase[_P], QVar, NonSymbolicExpr):
             if is_generative_mode():
                 with generative_mode_context(False):
                     return interpret_expression(str(self.len))
-            return CParamScalar(f"get_field({self}, 'len')")
+            return CParamScalar(f"{self}.len")
 
     @classmethod
     def to_qvar(
@@ -669,7 +668,7 @@ class QStruct(QVar):
                 field_name: field_class.to_qvar(
                     FieldHandleBinding(base_handle=base_handle, field=field_name),
                     field_type,
-                    f"get_field({expr_str if expr_str is not None else str(origin)}, '{field_name}')",
+                    f"{expr_str if expr_str is not None else str(origin)}.{field_name}",
                 )
                 for field_name, (field_class, field_type) in field_types.items()
             }
@@ -723,7 +722,7 @@ def _create_qvar_for_qtype(
                     field_name: _create_qvar_for_qtype(
                         field_type,
                         FieldHandleBinding(base_handle=origin, field=field_name),
-                        f"get_field({expr_str if expr_str is not None else str(origin)}, '{field_name}')",
+                        f"{expr_str if expr_str is not None else str(origin)}.{field_name}",
                     )
                     for field_name, field_type in struct_decl.fields.items()
                 },

classiq/qmod/quantum_expandable.py

@@ -286,7 +286,7 @@ class QTerminalCallable(QCallable):
         def len(self) -> CParamScalar:
             if not self.is_list:
                 raise ClassiqValueError("Cannot get length of a non-list operand")
-            return CParamScalar(f"get_field({self.func_decl.name}, 'len')")
+            return CParamScalar(f"{self.func_decl.name}.len")
 
     @property
     def func_decl(self) -> QuantumFunctionDeclaration:

classiq/qmod/semantics/error_manager.py

@@ -18,6 +18,7 @@ class ErrorManager:
             return
         self._instantiated = True
         self._errors: list[SourceReferencedError] = []
+        self._warnings: list[SourceReferencedError] = []
         self._current_nodes_stack: list[ASTNode] = []
         self._call_stack: list[str] = []
         self._ignore_errors: bool = False
@@ -41,38 +42,56 @@ class ErrorManager:
     def annotated_errors(self) -> list[str]:
         return [str(error) for error in self._errors]
 
+    @property
+    def annotated_warnings(self) -> list[str]:
+        return [str(error) for error in self._warnings]
+
     def add_error(
         self,
         error: str,
         *,
         source_ref: Optional[SourceReference] = None,
         function: Optional[str] = None,
+        warning: bool = False,
     ) -> None:
-        if not self._ignore_errors:
-            self._errors.append(
-                SourceReferencedError(
-                    error=error.replace(CLASSIQ_SLACK_COMMUNITY_LINK, ""),
-                    source_ref=(
-                        source_ref
-                        if source_ref is not None
-                        else self._current_source_ref
-                    ),
-                    function=(
-                        function if function is not None else self.current_function
-                    ),
-                )
-            )
+        if self._ignore_errors:
+            return
+
+        source_ref_error = SourceReferencedError(
+            error=error.replace(CLASSIQ_SLACK_COMMUNITY_LINK, ""),
+            source_ref=(
+                source_ref if source_ref is not None else self._current_source_ref
+            ),
+            function=(function if function is not None else self.current_function),
+        )
+        if warning:
+            self._warnings.append(source_ref_error)
+        else:
+            self._errors.append(source_ref_error)
 
     def get_errors(self) -> list[SourceReferencedError]:
         return self._errors
 
+    def get_warnings(self) -> list[SourceReferencedError]:
+        return self._warnings
+
     def clear(self) -> None:
+        self.clear_errors()
+        self.clear_warnings()
+
+    def clear_errors(self) -> None:
         self._current_nodes_stack = []
         self._errors = []
 
+    def clear_warnings(self) -> None:
+        self._warnings = []
+
     def has_errors(self) -> bool:
         return len(self._errors) > 0
 
+    def has_warnings(self) -> bool:
+        return len(self._warnings) > 0
+
     def report_errors(
         self, error_type: type[Exception], mask: Optional[list[int]] = None
     ) -> None:
@@ -82,7 +101,7 @@ class ErrorManager:
                 if mask is None
                 else [self.annotated_errors[idx] for idx in mask]
             )
-            self.clear()
+            self.clear_errors()
             raise error_type("\n\t" + "\n\t".join(errors))
 
     @property

classiq/qmod/symbolic.py

@@ -11,9 +11,6 @@ from typing import (
 import numpy as np
 
 from classiq.interface.exceptions import ClassiqValueError
-from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
-    subscript_to_str,
-)
 
 from classiq.qmod import model_state_container
 from classiq.qmod.declaration_inferrer import python_type_to_qmod
@@ -309,12 +306,26 @@ def sum(arr: SymbolicTypes) -> CParamScalar:
     return symbolic_function(arr)
 
 
+def _subscript_to_str(index: Any) -> str:
+    if not isinstance(index, slice):
+        return str(index)
+    expr = ""
+    if index.start is not None:
+        expr += str(index.start)
+    expr += ":"
+    if index.stop is not None:
+        expr += str(index.stop)
+    if index.step is not None:
+        expr += f":{index.step}"
+    return expr
+
+
 def subscript(
     array: Union[list, CArray[CReal], np.ndarray],
     index: Any,
 ) -> CParamScalar:
     return CParamScalar(
-        expr=f"{qmod_val_to_expr_str(_unwrap_numpy(array))}[{subscript_to_str(index)}]"
+        expr=f"{qmod_val_to_expr_str(_unwrap_numpy(array))}[{_subscript_to_str(index)}]"
     )
 
 

classiq/qmod/utilities.py

@@ -29,6 +29,7 @@ from classiq.interface.generator.expressions.proxies.classical.qmod_struct_insta
 from classiq.interface.source_reference import SourceReference
 
 if TYPE_CHECKING:
+    from classiq.qmod.cparam import CParam
     from classiq.qmod.qmod_variable import QVar
 
 
@@ -162,7 +163,9 @@ def suppress_return_value(func: Callable[Params, None]) -> Callable[Params, None
     return func
 
 
-Statements = Union[None, list[Union[None, "QVar"]], tuple[Union[None, "QVar"], ...]]
+Statements = Union[
+    None, list[Union[None, "QVar", "CParam"]], tuple[Union[None, "QVar", "CParam"], ...]
+]
 
 
 def _eval_qnum(val: int, size: int, is_signed: bool, fraction_digits: int) -> float: