classiq 0.38.0__py3-none-any.whl → 0.40.0__py3-none-any.whl

classiq/qmod/native/pretty_printer.py

@@ -11,18 +11,22 @@ from classiq.interface.generator.functions.port_declaration import (
 )
 from classiq.interface.generator.visitor import NodeType, Visitor
 from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.classical_if import ClassicalIf
 from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
 )
+from classiq.interface.model.control import Control
 from classiq.interface.model.handle_binding import (
     HandleBinding,
     SlicedHandleBinding,
     SubscriptHandleBinding,
 )
 from classiq.interface.model.inplace_binary_operation import InplaceBinaryOperation
+from classiq.interface.model.invert import Invert
 from classiq.interface.model.model import Model
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.port_declaration import PortDeclaration
+from classiq.interface.model.power import Power
 from classiq.interface.model.quantum_expressions.amplitude_loading_operation import (
     AmplitudeLoadingOperation,
 )
@@ -37,7 +41,6 @@ from classiq.interface.model.quantum_function_declaration import (
     QuantumFunctionDeclaration,
     QuantumOperandDeclaration,
 )
-from classiq.interface.model.quantum_if_operation import QuantumIfOperation
 from classiq.interface.model.quantum_lambda_function import QuantumLambdaFunction
 from classiq.interface.model.quantum_type import (
     QuantumBit,
@@ -47,11 +50,12 @@ from classiq.interface.model.quantum_type import (
 from classiq.interface.model.quantum_variable_declaration import (
     QuantumVariableDeclaration,
 )
+from classiq.interface.model.repeat import Repeat
 from classiq.interface.model.statement_block import StatementBlock
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
-from classiq.interface.model.within_apply_operation import WithinApplyOperation
+from classiq.interface.model.within_apply_operation import WithinApply
 
 from classiq import Bool, ClassicalList, Integer, Pauli, Real, Struct, StructDeclaration
 from classiq.qmod.native.expression_to_qmod import transform_expression
@@ -208,33 +212,51 @@ class DSLPrettyPrinter(Visitor):
         )
         return f"{self._indent}{func_call.func_name}{f'[{self.visit(func_call.function.index)}]' if isinstance(func_call.function, OperandIdentifier) else ''}{gen_time_arg_list}({quantum_args});\n"
 
-    def visit_QuantumIfOperation(self, op: QuantumIfOperation) -> str:
-        quantum_if = f"{self._indent}quantum_if ({self.visit(op.expression)}) {{\n"
-        operand = op.then
-        if not isinstance(operand, QuantumLambdaFunction):
-            raise AssertionError(
-                "Expected quantum_if to be implemented using a lambda function"
-            )
-        quantum_if += self._visit_body(operand.body)
-        quantum_if += f"{self._indent}}}\n"
-        return quantum_if
-
-    def visit_WithinApplyOperation(self, op: WithinApplyOperation) -> str:
-        action = op.action
-        compute = op.compute
-        if not isinstance(action, QuantumLambdaFunction) or not isinstance(
-            compute, QuantumLambdaFunction
-        ):
-            raise AssertionError(
-                "Expected within-apply to be implemented using a lambda functions"
-            )
+    def visit_Control(self, op: Control) -> str:
+        control = f"{self._indent}control ({self.visit(op.expression)}) {{\n"
+        control += self._visit_body(op.body)
+        control += f"{self._indent}}}\n"
+        return control
+
+    def visit_ClassicalIf(self, op: ClassicalIf) -> str:
+        classical_if = f"{self._indent}if ({self.visit(op.condition)}) {{\n"
+        if not op.then:
+            raise AssertionError('Expected non empty "then" block')
+        classical_if += self._visit_body(op.then)
+
+        if op.else_:
+            classical_if += f"{self._indent}}} else {{\n"
+            classical_if += self._visit_body(op.else_)
+
+        classical_if += f"{self._indent}}}\n"
+        return classical_if
+
+    def visit_WithinApply(self, op: WithinApply) -> str:
         within_apply_code = f"{self._indent}within {{\n"
-        within_apply_code += self._visit_body(compute.body)
+        within_apply_code += self._visit_body(op.compute)
         within_apply_code += f"{self._indent}}} apply {{\n"
-        within_apply_code += self._visit_body(action.body)
+        within_apply_code += self._visit_body(op.action)
         within_apply_code += f"{self._indent}}}\n"
         return within_apply_code
 
+    def visit_Repeat(self, repeat: Repeat) -> str:
+        repeat_code = f"{self._indent}repeat ({self.visit(repeat.iter_var)}: {self.visit(repeat.count)}) {{\n"
+        repeat_code += self._visit_body(repeat.body)
+        repeat_code += f"{self._indent}}}\n"
+        return repeat_code
+
+    def visit_Power(self, power: Power) -> str:
+        power_code = f"{self._indent}power ({self.visit(power.power)}) {{\n"
+        power_code += self._visit_body(power.body)
+        power_code += f"{self._indent}}}\n"
+        return power_code
+
+    def visit_Invert(self, invert: Invert) -> str:
+        invert_code = f"{self._indent}invert {{\n"
+        invert_code += self._visit_body(invert.body)
+        invert_code += f"{self._indent}}}\n"
+        return invert_code
+
     def _visit_body(self, body: StatementBlock) -> str:
         code = ""
         self._level += 1
@@ -280,10 +302,10 @@ class DSLPrettyPrinter(Visitor):
         return var_ref.name
 
     def visit_SlicedHandleBinding(self, var_ref: SlicedHandleBinding) -> str:
-        return str(var_ref)
+        return f"{var_ref.name}[{self.visit(var_ref.start)}:{self.visit(var_ref.end)}]"
 
     def visit_SubscriptHandleBinding(self, var_ref: SubscriptHandleBinding) -> str:
-        return str(var_ref)
+        return f"{var_ref.name}[{self.visit(var_ref.index)}]"
 
     def visit_ArithmeticOperation(self, arith_op: ArithmeticOperation) -> str:
         op = "^=" if arith_op.inplace_result else "="

classiq/qmod/qmod_constant.py

@@ -3,12 +3,16 @@ from typing import Any, Optional
 
 from classiq.interface.generator.constant import Constant
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.functions.classical_type import QStructBase
+from classiq.interface.generator.functions.classical_type import (
+    ClassicalArray,
+    ClassicalList,
+    CStructBase,
+)
 
 from classiq.exceptions import ClassiqError
 from classiq.qmod.declaration_inferrer import python_type_to_qmod
 from classiq.qmod.model_state_container import ModelStateContainer
-from classiq.qmod.qmod_parameter import QParam, QParamStruct
+from classiq.qmod.qmod_parameter import CParam, CParamList, CParamStruct
 
 
 class QConstant:
@@ -57,20 +61,40 @@ class QConstant:
                 value=Expression(expr=expr),
             )
 
-    def __getattr__(self, name: str) -> QParam:
+    def __getattr__(self, name: str) -> CParam:
         self.add_to_model()
 
         py_type = type(self._value)
         if (
             QConstant.CURRENT_QMODULE is None
             or not inspect.isclass(py_type)
-            or not issubclass(py_type, QStructBase)
+            or not issubclass(py_type, CStructBase)
         ):
             return self.__getattribute__(name)
 
-        return QParamStruct.get_field(
+        return CParamStruct.get_field(
             QConstant.CURRENT_QMODULE, self.name, py_type.__name__, name
         )
 
+    def __getitem__(self, item: Any) -> CParam:
+        self.add_to_model()
+
+        assert QConstant.CURRENT_QMODULE is not None
+
+        qmod_type = python_type_to_qmod(
+            self._py_type, qmodule=QConstant.CURRENT_QMODULE
+        )
+        if qmod_type is None:
+            raise ClassiqError("Invalid QMOD type")
+
+        if not isinstance(qmod_type, (ClassicalList, ClassicalArray)):
+            raise ClassiqError("Invalid subscript to non-list constant")
+
+        return CParamList(
+            self.name,
+            qmod_type,
+            QConstant.CURRENT_QMODULE,
+        )[item]
+
     def __str__(self) -> str:
         return self.name

classiq/qmod/qmod_parameter.py

@@ -26,21 +26,54 @@ _T = TypeVar("_T")
 
 
 if TYPE_CHECKING:
+    SymbolicSuperclass = SymbolicExpr
+else:
+    SymbolicSuperclass = Symbolic
 
-    class QParam(SymbolicExpr, Generic[_T]):
-        pass
 
-else:
+class CParam(SymbolicSuperclass):
+    pass
+
+
+class QParam(CParam, Generic[_T]):
+    pass
+
+
+class CInt(CParam):
+    pass
+
+
+class CReal(CParam):
+    pass
+
+
+class CBool(CParam):
+    pass
+
+
+_P = ParamSpec("_P")
+
+
+class ArrayBase(Generic[_P]):
+    # Support comma-separated generic args in older Python versions
+    if sys.version_info[0:2] < (3, 10):
+
+        def __class_getitem__(cls, args) -> _GenericAlias:
+            return _GenericAlias(cls, args)
+
+
+class CArray(CParam, ArrayBase[_P]):
+    if TYPE_CHECKING:
 
-    class QParam(Symbolic, Generic[_T]):
-        pass
+        @property
+        def len(self) -> int: ...
 
 
-class QParamScalar(QParam, SymbolicExpr):
+class CParamScalar(CParam, SymbolicExpr):
     pass
 
 
-class QParamList(QParam):
+class CParamList(CParam):
     def __init__(
         self,
         expr: str,
@@ -51,7 +84,7 @@ class QParamList(QParam):
         self._qmodule = qmodule
         self._list_type = list_type
 
-    def __getitem__(self, key: Any) -> QParam:
+    def __getitem__(self, key: Any) -> CParam:
         return create_param(
             f"({self})[{key}]",
             self._list_type.element_type,
@@ -60,14 +93,15 @@ class QParamList(QParam):
 
     def __len__(self) -> int:
         raise ClassiqValueError(
-            "len(<expr>) is not supported for QMod lists - use <expr>.len() instead"
+            "len(<expr>) is not supported for QMod lists - use <expr>.len instead"
         )
 
-    def len(self) -> QParamScalar:
-        return QParamScalar(f"len({self})")
+    @property
+    def len(self) -> CParamScalar:
+        return CParamScalar(f"get_field({self}, 'len')")
 
 
-class QParamStruct(QParam):
+class CParamStruct(CParam):
     def __init__(
         self, expr: str, struct_type: Struct, *, qmodule: ModelStateContainer
     ) -> None:
@@ -75,8 +109,8 @@ class QParamStruct(QParam):
         self._qmodule = qmodule
         self._struct_type = struct_type
 
-    def __getattr__(self, field_name: str) -> QParam:
-        return QParamStruct.get_field(
+    def __getattr__(self, field_name: str) -> CParam:
+        return CParamStruct.get_field(
             self._qmodule, str(self), self._struct_type.name, field_name
         )
 
@@ -86,7 +120,7 @@ class QParamStruct(QParam):
         variable_name: str,
         struct_name: str,
         field_name: str,
-    ) -> QParam:
+    ) -> CParam:
         struct_decl = StructDeclaration.BUILTIN_STRUCT_DECLARATIONS.get(
             struct_name, qmodule.type_decls.get(struct_name)
         )
@@ -104,27 +138,15 @@ class QParamStruct(QParam):
         )
 
 
-_P = ParamSpec("_P")
-
-
-class ArrayBase(Generic[_P]):
-    # Support comma-separated generic args in older Python versions
-    if sys.version_info[0:2] < (3, 10):
-
-        def __class_getitem__(cls, args) -> _GenericAlias:
-            return _GenericAlias(cls, args)
-
-
-class Array(ArrayBase[_P]):
-    pass
-
-
 def create_param(
     expr_str: str, ctype: ClassicalType, qmodule: ModelStateContainer
-) -> QParam:
+) -> CParam:
     if isinstance(ctype, (ClassicalList, ClassicalArray)):
-        return QParamList(expr_str, ctype, qmodule=qmodule)
+        return CParamList(expr_str, ctype, qmodule=qmodule)
     elif isinstance(ctype, Struct):
-        return QParamStruct(expr_str, ctype, qmodule=qmodule)
+        return CParamStruct(expr_str, ctype, qmodule=qmodule)
     else:
-        return QParamScalar(expr_str)
+        return CParamScalar(expr_str)
+
+
+Array = CArray

classiq/qmod/qmod_struct.py

@@ -3,7 +3,7 @@ from typing import Any, Type
 
 from typing_extensions import dataclass_transform
 
-from classiq.interface.generator.functions.classical_type import QStructBase
+from classiq.interface.generator.functions.classical_type import CStructBase
 
 
 def _qmod_val_to_expr_str(val: Any) -> str:
@@ -30,7 +30,7 @@ def struct(user_class: Type) -> Type:
 
     user_dataclass = type(
         user_class.__name__,
-        (QStructBase, dataclasses.dataclass(user_class)),
+        (CStructBase, dataclasses.dataclass(user_class)),
         dict(),
     )
     user_dataclass.__repr__ = _new_repr  # type:ignore[assignment]

classiq/qmod/qmod_variable.py

@@ -1,8 +1,7 @@
 import abc
 import sys
 from contextlib import contextmanager
-from typing import _GenericAlias  # type: ignore[attr-defined]
-from typing import (
+from typing import (  # type: ignore[attr-defined]
     TYPE_CHECKING,
     Any,
     ForwardRef,
@@ -14,6 +13,7 @@ from typing import (
     Type,
     TypeVar,
     Union,
+    _GenericAlias,
     get_args,
     get_origin,
     overload,
@@ -21,11 +21,16 @@ from typing import (
 
 from typing_extensions import Annotated, ParamSpec, Self, _AnnotatedAlias
 
+from classiq.interface.ast_node import SourceReference
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
-from classiq.interface.model.handle_binding import HandleBinding, SlicedHandleBinding
+from classiq.interface.model.handle_binding import (
+    HandleBinding,
+    SlicedHandleBinding,
+    SubscriptHandleBinding,
+)
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_expressions.amplitude_loading_operation import (
     AmplitudeLoadingOperation,
@@ -41,15 +46,16 @@ from classiq.interface.model.quantum_type import (
 )
 
 from classiq.exceptions import ClassiqValueError
-from classiq.qmod.qmod_parameter import ArrayBase, QParam, QParamScalar
+from classiq.qmod.qmod_parameter import ArrayBase, CBool, CInt, CParam, CParamScalar
 from classiq.qmod.quantum_callable import QCallable
 from classiq.qmod.symbolic_expr import Symbolic, SymbolicExpr
 from classiq.qmod.symbolic_type import SymbolicTypes
-from classiq.qmod.utilities import version_portable_get_args
+from classiq.qmod.utilities import get_source_ref, version_portable_get_args
 
 ILLEGAL_SLICING_STEP_MSG = "Slicing with a step of a quantum variable is not supported"
 SLICE_OUT_OF_BOUNDS_MSG = "Slice end index out of bounds"
 UNSUPPORTED_ELEMENT_TYPE = "Only QBit is supported as element type for QArray"
+QARRAY_ELEMENT_NOT_SUBSCRIPTABLE = "Subscripting an element in QArray is illegal"
 
 
 def _is_input_output_typehint(type_hint: Any) -> bool:
@@ -77,8 +83,9 @@ def _no_current_expandable() -> Iterator[None]:
         QCallable.CURRENT_EXPANDABLE = current_expandable
 
 
-class QVar:
+class QVar(Symbolic):
     def __init__(self, name: str) -> None:
+        super().__init__(name)
         self._name = name
         if QCallable.CURRENT_EXPANDABLE is not None:
             QCallable.CURRENT_EXPANDABLE.add_local_handle(
@@ -115,6 +122,9 @@ class QVar:
         assert type_hint == cls or get_origin(type_hint) == cls
         return PortDeclarationDirection.Inout
 
+    def __str__(self) -> str:
+        return str(self.get_handle_binding())
+
 
 _Q = TypeVar("_Q", bound=QVar)
 Output = Annotated[_Q, PortDeclarationDirection.Output]
@@ -126,7 +136,9 @@ class QScalar(QVar, SymbolicExpr):
         QVar.__init__(self, name)
         SymbolicExpr.__init__(self, name)
 
-    def _insert_arith_operation(self, expr: SymbolicTypes, inplace: bool) -> None:
+    def _insert_arith_operation(
+        self, expr: SymbolicTypes, inplace: bool, source_ref: SourceReference
+    ) -> None:
         # Fixme: Arithmetic operations are not yet supported on slices (see CAD-12670)
         if TYPE_CHECKING:
             assert QCallable.CURRENT_EXPANDABLE is not None
@@ -135,16 +147,20 @@ class QScalar(QVar, SymbolicExpr):
                 expression=Expression(expr=str(expr)),
                 result_var=self.get_handle_binding(),
                 inplace_result=inplace,
+                source_ref=source_ref,
             )
         )
 
-    def _insert_amplitude_loading(self, expr: SymbolicTypes) -> None:
+    def _insert_amplitude_loading(
+        self, expr: SymbolicTypes, source_ref: SourceReference
+    ) -> None:
         if TYPE_CHECKING:
             assert QCallable.CURRENT_EXPANDABLE is not None
         QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
             AmplitudeLoadingOperation(
                 expression=Expression(expr=str(expr)),
                 result_var=self.get_handle_binding(),
+                source_ref=source_ref,
             )
         )
 
@@ -157,7 +173,7 @@ class QScalar(QVar, SymbolicExpr):
                 f"Invalid argument {other!r} for out-of-place arithmetic operation"
             )
 
-        self._insert_arith_operation(other, False)
+        self._insert_arith_operation(other, False, get_source_ref(sys._getframe(1)))
         return self
 
     def __ixor__(self, other: Any) -> Self:
@@ -166,7 +182,7 @@ class QScalar(QVar, SymbolicExpr):
                 f"Invalid argument {other!r} for in-place arithmetic operation"
             )
 
-        self._insert_arith_operation(other, True)
+        self._insert_arith_operation(other, True, get_source_ref(sys._getframe(1)))
         return self
 
     def __imul__(self, other: Any) -> Self:
@@ -175,7 +191,7 @@ class QScalar(QVar, SymbolicExpr):
                 f"Invalid argument {other!r} for out of ampltiude encoding operation"
             )
 
-        self._insert_amplitude_loading(other)
+        self._insert_amplitude_loading(other, get_source_ref(sys._getframe(1)))
         return self
 
 
@@ -202,18 +218,18 @@ class QNum(Generic[_P], QScalar):
     def __init__(
         self,
         name: str,
-        size: Union[int, QParam[int]],
-        is_signed: Union[bool, QParam[bool]],
-        fraction_digits: Union[int, QParam[int]],
+        size: Union[int, CInt],
+        is_signed: Union[bool, CBool],
+        fraction_digits: Union[int, CInt],
     ):
         pass
 
     def __init__(
         self,
         name: str,
-        size: Union[int, QParam[int], None] = None,
-        is_signed: Union[bool, QParam[bool], None] = None,
-        fraction_digits: Union[int, QParam[int], None] = None,
+        size: Union[int, CInt, None] = None,
+        is_signed: Union[bool, CBool, None] = None,
+        fraction_digits: Union[int, CInt, None] = None,
     ):
         if (
             size is None
@@ -239,8 +255,8 @@ class QNum(Generic[_P], QScalar):
         type_args = type_args[0]
         if len(type_args) != 3:
             raise ClassiqValueError(
-                "QNum receives three type arguments: QNum[size: int | QParam[int], "
-                "is_signed: bool | QParam[bool], fraction_digits: int | QParam[int]]"
+                "QNum receives three type arguments: QNum[size: int | CInt, "
+                "is_signed: bool | CBool, fraction_digits: int | CInt]"
             )
         return cls.QMOD_TYPE(
             size=Expression(expr=get_type_hint_expr(type_args[0])),
@@ -256,16 +272,16 @@ class QNum(Generic[_P], QScalar):
         )
 
     @property
-    def size(self) -> QParamScalar:
-        return QParamScalar(f"len({self._name})")
+    def size(self) -> CParamScalar:
+        return CParamScalar(f"get_field({self._name}, 'size')")
 
     @property
-    def fraction_digits(self) -> QParamScalar:
-        return QParamScalar(f"fraction_digits({self._name})")
+    def fraction_digits(self) -> CParamScalar:
+        return CParamScalar(f"get_field({self._name}, 'fraction_digits')")
 
     @property
-    def is_signed(self) -> QParamScalar:
-        return QParamScalar(f"is_signed({self._name})")
+    def is_signed(self) -> CParamScalar:
+        return CParamScalar(f"get_field({self._name}, 'is_signed')")
 
     # Support comma-separated generic args in older Python versions
     if sys.version_info[0:2] < (3, 10):
@@ -279,35 +295,53 @@ class QArray(ArrayBase[_P], QVar):
         self,
         name: str,
         element_type: _GenericAlias = QBit,
-        length: Optional[Union[int, QParam[int]]] = None,
+        length: Optional[Union[int, CInt]] = None,
+        # TODO [CAD-18620]: improve type hints
         slice_: Optional[Tuple[int, int]] = None,
+        index_: Optional[Union[int, CInt]] = None,
     ) -> None:
         if element_type is not QBit:
             raise ClassiqValueError(UNSUPPORTED_ELEMENT_TYPE)
         self._element_type = element_type
         self._length = length
         self._slice = slice_
+        self._index = index_
         super().__init__(name)
 
     def get_handle_binding(self) -> HandleBinding:
-        if self._slice is None:
-            return HandleBinding(name=self._name)
-        return SlicedHandleBinding(
-            name=self._name,
-            start=Expression(expr=str(self._slice[0])),
-            end=Expression(expr=str(self._slice[1])),
-        )
+        if self._index is not None:
+            return SubscriptHandleBinding(
+                name=self._name,
+                index=Expression(expr=str(self._index)),
+            )
+
+        if self._slice is not None:
+            return SlicedHandleBinding(
+                name=self._name,
+                start=Expression(expr=str(self._slice[0])),
+                end=Expression(expr=str(self._slice[1])),
+            )
+
+        return HandleBinding(name=self._name)
+
+    def __getitem__(self, key: Union[slice, int, CInt]) -> "QArray":
+        if self._index is not None:
+            raise ClassiqValueError(QARRAY_ELEMENT_NOT_SUBSCRIPTABLE)
+
+        # TODO [CAD-18620]: improve type hints
+        new_index: Optional[Any] = None
 
-    def __getitem__(self, key: Union[slice, int, QParam]) -> "QArray":
-        offset = self._slice[0] if self._slice is not None else 0
         if isinstance(key, slice):
             if key.step is not None:
                 raise ClassiqValueError(ILLEGAL_SLICING_STEP_MSG)
-            new_slice = (offset + key.start, offset + key.stop)
+            new_slice = self._get_new_slice(key.start, key.stop)
+
         else:
-            if isinstance(key, QParam) and not isinstance(key, QParamScalar):
+            if isinstance(key, CParam) and not isinstance(key, CParamScalar):
                 raise ClassiqValueError("Non-classical parameter for slicing")
-            new_slice = (offset + key, offset + key + 1)
+            new_slice = self._get_new_slice(key, key + 1)
+            new_index = new_slice[0]
+
         if (
             self._slice is not None
             and not isinstance(new_slice[1], Symbolic)
@@ -322,23 +356,33 @@ class QArray(ArrayBase[_P], QVar):
             raise ClassiqValueError(SLICE_OUT_OF_BOUNDS_MSG)
         # prevent addition to local handles, since this is used for slicing existing local handles
         with _no_current_expandable():
-            return QArray(self._name, length=self._length, slice_=new_slice)
+            return QArray(
+                self._name, length=self._length, slice_=new_slice, index_=new_index
+            )
+
+    # TODO [CAD-18620]: improve type hints
+    def _get_new_slice(self, start: Any, end: Any) -> Tuple[Any, Any]:
+        if self._slice is not None:
+            return (self._slice[0] + start, self._slice[0] + end)
+        return (start, end)
 
     def __len__(self) -> int:
         raise ClassiqValueError(
-            "len(<var>) is not supported for quantum variables - use <var>.len() instead"
+            "len(<var>) is not supported for quantum variables - use <var>.len instead"
         )
 
     if TYPE_CHECKING:
 
+        @property
         def len(self) -> int: ...
 
     else:
 
-        def len(self) -> QParamScalar:
+        @property
+        def len(self) -> CParamScalar:
             if self._length is not None:
-                return QParamScalar(f"{self._length}")
-            return QParamScalar(f"len({self._name})")
+                return CParamScalar(f"{self._length}")
+            return CParamScalar(f"get_field({self._name}, 'len')")
 
     @classmethod
     def to_qmod_quantum_type(cls, type_hint: Any) -> QuantumType: