classiq 0.88.0__py3-none-any.whl → 0.90.0__py3-none-any.whl

classiq/interface/generator/functions/classical_type.py

@@ -2,7 +2,7 @@ from itertools import chain
 from typing import TYPE_CHECKING, Any, Literal, Optional
 
 import pydantic
-from pydantic import ConfigDict, PrivateAttr
+from pydantic import PrivateAttr
 from typing_extensions import Self
 
 from classiq.interface.ast_node import HashableASTNode
@@ -34,8 +34,6 @@ if TYPE_CHECKING:
 class ClassicalType(HashableASTNode):
     _is_generative: bool = PrivateAttr(default=False)
 
-    model_config = ConfigDict(extra="forbid")
-
     def __str__(self) -> str:
         return str(type(self).__name__)
 
@@ -78,6 +76,9 @@ class ClassicalType(HashableASTNode):
     def get_raw_type(self) -> "ConcreteClassicalType":
         return self  # type:ignore[return-value]
 
+    def without_symbolic_attributes(self) -> Self:
+        return self
+
 
 class Integer(ClassicalType):
     kind: Literal["int"]
@@ -203,6 +204,18 @@ class ClassicalArray(ClassicalType):
     def raw_qmod_type_name(self) -> str:
         return "CArray"
 
+    def without_symbolic_attributes(self) -> "ClassicalArray":
+        length = (
+            None
+            if self.length is None
+            or not self.length.is_evaluated()
+            or not self.length.is_constant()
+            else self.length
+        )
+        return ClassicalArray(
+            element_type=self.element_type.without_symbolic_attributes(), length=length
+        )
+
 
 class ClassicalTuple(ClassicalType):
     kind: Literal["tuple"]
@@ -273,6 +286,14 @@ class ClassicalTuple(ClassicalType):
     def raw_qmod_type_name(self) -> str:
         return "CArray"
 
+    def without_symbolic_attributes(self) -> "ClassicalTuple":
+        return ClassicalTuple(
+            element_types=[
+                element_type.without_symbolic_attributes()
+                for element_type in self.element_types
+            ]
+        )
+
 
 class OpaqueHandle(ClassicalType):
     pass

classiq/interface/generator/functions/concrete_types.py

@@ -47,7 +47,7 @@ PythonClassicalPydanticTypes = (Enum,)
 
 ConcreteQuantumType = Annotated[
     Union[QuantumBit, QuantumBitvector, QuantumNumeric, TypeName],
-    Field(discriminator="kind", default_factory=QuantumBitvector),
+    Field(discriminator="kind"),
 ]
 QuantumBitvector.model_rebuild()
 TypeName.model_rebuild()

classiq/interface/generator/functions/function_declaration.py

@@ -1,8 +1,6 @@
 import abc
 from collections.abc import Sequence
 
-from pydantic import ConfigDict
-
 from classiq.interface.model.classical_parameter_declaration import (
     AnonClassicalParameterDeclaration,
 )
@@ -19,7 +17,5 @@ class FunctionDeclaration(Parameter, abc.ABC):
     def param_decls(self) -> Sequence["AnonClassicalParameterDeclaration"]:
         pass
 
-    model_config = ConfigDict(extra="forbid")
-
 
 FunctionDeclaration.model_rebuild()

classiq/interface/generator/functions/type_name.py

@@ -189,6 +189,31 @@ class TypeName(ClassicalType, QuantumType):
             field_type.minimal_size_in_bits for field_type in self.fields.values()
         )
 
+    def without_symbolic_attributes(self) -> "TypeName":
+        if self.has_fields:
+            type_name = TypeName(name=self.name)
+            type_name.set_fields(
+                {
+                    field_name: field_type.without_symbolic_attributes()
+                    for field_name, field_type in self.fields.items()
+                }
+            )
+            return type_name
+        if self.has_classical_struct_decl:
+            type_name = TypeName(name=self.name)
+            type_name.set_classical_struct_decl(
+                self.classical_struct_decl.model_copy(
+                    update=dict(
+                        variables={
+                            field_name: field_type.without_symbolic_attributes()
+                            for field_name, field_type in self.classical_struct_decl.variables.items()
+                        }
+                    )
+                )
+            )
+            return type_name
+        return self
+
 
 class Enum(TypeName):
     pass

classiq/interface/generator/generated_circuit_data.py

@@ -17,6 +17,7 @@ from classiq.interface.generator.register_role import RegisterRole
 from classiq.interface.generator.synthesis_metadata.synthesis_execution_data import (
     ExecutionData,
 )
+from classiq.interface.model.block import Block
 from classiq.interface.model.quantum_expressions.arithmetic_operation import (
     ArithmeticOperationKind,
 )
@@ -210,10 +211,13 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
             )
             name_with_suffix = self.add_suffix_from_generated_name(generated_name, name)
             return name_with_suffix
+        if isinstance(back_ref, Block) and back_ref.label is not None:
+            return back_ref.label
 
         statement_kind: str = back_ref.kind
         if isinstance(back_ref, ArithmeticOperation):
             statement_kind = back_ref.operation_kind.value
+
         return self.add_suffix_from_generated_name(
             generated_name, STATEMENTS_NAME[statement_kind]
         )

classiq/interface/generator/hardware_efficient_ansatz.py

@@ -42,7 +42,7 @@ class HardwareEfficientAnsatz(function_params.FunctionParams):
         "If none specified - use connectivity map from the model hardware settings. "
         "If none specified as well, all qubit pairs will be connected.",
     )
-    num_qubits: pydantic.PositiveInt = pydantic.Field(
+    num_qubits: pydantic.PositiveInt = pydantic.Field(  # type: ignore[assignment]
         default=None,
         description="Number of qubits in the ansatz.",
         validate_default=True,

classiq/interface/generator/preferences/qasm_to_qmod_params.py

@@ -0,0 +1,14 @@
+from pydantic import BaseModel
+
+from classiq.interface.analyzer.result import QasmCode
+from classiq.interface.enum_utils import StrEnum
+
+
+class QmodFormat(StrEnum):
+    NATIVE = "native"
+    PYTHON = "python"
+
+
+class QasmToQmodParams(BaseModel):
+    qasm: QasmCode
+    qmod_format: QmodFormat

classiq/interface/generator/quantum_function_call.py

@@ -130,7 +130,7 @@ class SynthesisQuantumFunctionCall(BaseModel):
         default=True,
         description="False value indicates this call shouldn't be controlled even if the flow is controlled.",
     )
-    inputs: IOType = pydantic.Field(
+    inputs: IOType = pydantic.Field(  # type: ignore[assignment]
         default_factory=dict,
         description="A mapping from the input name to the wire it connects to",
     )
@@ -138,14 +138,14 @@ class SynthesisQuantumFunctionCall(BaseModel):
         default_factory=dict,
         description="A mapping from in/out name to the wires that connect to it",
     )
-    outputs: IOType = pydantic.Field(
+    outputs: IOType = pydantic.Field(  # type: ignore[assignment]
         default_factory=dict,
         description="A mapping from the output name to the wire it connects to",
     )
     power: PydanticPowerType = pydantic.Field(
         default=1, description="Number of successive calls to the operation"
     )
-    name: PydanticNonEmptyString = pydantic.Field(
+    name: PydanticNonEmptyString = pydantic.Field(  # type: ignore[assignment]
         default=None,
         validate_default=True,
         description="The name of the function instance. "

classiq/interface/generator/user_defined_function_params.py

@@ -1,7 +1,6 @@
 from collections.abc import Mapping
 
 import pydantic
-from pydantic import ConfigDict
 
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
 from classiq.interface.generator.function_params import ArithmeticIODict, FunctionParams
@@ -12,8 +11,6 @@ class CustomFunction(FunctionParams):
     A user-defined custom function parameters object.
     """
 
-    model_config = ConfigDict(frozen=True, extra="forbid")
-
     _name: str = pydantic.PrivateAttr(default="")
 
     input_decls: ArithmeticIODict = pydantic.Field(

classiq/interface/helpers/model_normalizer.py

@@ -1,4 +1,3 @@
-import ast
 from typing import Any
 
 from classiq.interface.ast_node import ASTNode
@@ -10,8 +9,6 @@ from classiq.interface.generator.visitor import Transformer, Visitor
 from classiq.interface.model.model import Model
 from classiq.interface.model.port_declaration import AnonPortDeclaration
 
-from classiq.model_expansions.transformers.model_renamer import ExprNormalizer
-
 
 class ModelNormalizer(Visitor):
     def visit(self, node: Any) -> None:
@@ -28,9 +25,6 @@ class ModelNormalizer(Visitor):
         model.functions.sort(key=lambda x: x.name)
         self.generic_visit(model)
 
-    def visit_Expression(self, expr: Expression) -> None:
-        expr.expr = ast.unparse(ExprNormalizer().visit(ast.parse(expr.expr)))
-
     def visit_AnonPortDeclaration(self, decl: AnonPortDeclaration) -> None:
         decl.type_modifier = TypeModifier.Mutable
 

classiq/interface/ide/ide_data.py

@@ -59,7 +59,7 @@ class IDEDataOperation(pydantic.BaseModel):
     _qubits: list = pydantic.PrivateAttr()  # list[Qubit]
 
     displayArgs: str = ""
-    targets: Union[list[IDEQubitDef], list[IDEClassicalBitDef]] = pydantic.Field(
+    targets: Union[list[IDEQubitDef], list[IDEClassicalBitDef]] = pydantic.Field(  # type: ignore[assignment]
         default_factory=list
     )
     controls: list[IDEQubitDef] = list()

classiq/interface/ide/visual_model.py

@@ -171,6 +171,7 @@ class Operation(pydantic.BaseModel):
     expanded: bool = pydantic.Field(default=False)
     show_expanded_label: bool = pydantic.Field(default=False)
     is_low_level_fallback: bool = pydantic.Field(default=False)
+    is_measurement: bool = pydantic.Field(default=False)
 
     model_config = ConfigDict(frozen=True)
 
@@ -207,9 +208,9 @@ class Operation(pydantic.BaseModel):
 
 
 class ProgramVisualModel(VersionedModel):
-    main_operation: Operation = pydantic.Field(default=None)
+    main_operation: Operation = pydantic.Field(default=None)  # type: ignore[assignment]
     id_to_operations: dict[int, Operation] = pydantic.Field(default_factory=dict)
-    main_operation_id: int = pydantic.Field(default=None)
+    main_operation_id: int = pydantic.Field(default=None)  # type: ignore[assignment]
     program_data: ProgramData
 
     @property

classiq/interface/model/block.py

@@ -1,4 +1,6 @@
-from typing import TYPE_CHECKING, Literal
+from typing import TYPE_CHECKING, Literal, Optional
+
+import pydantic
 
 from classiq.interface.model.quantum_statement import QuantumOperation
 
@@ -10,3 +12,5 @@ class Block(QuantumOperation):
     kind: Literal["Block"]
 
     statements: "StatementBlock"
+
+    label: Optional[str] = pydantic.Field(default=None)

classiq/interface/model/handle_binding.py

@@ -19,7 +19,7 @@ def _get_expr_id(expr: Expression) -> str:
 
 
 class HandleBinding(ASTNode):
-    name: str = Field(default=None)
+    name: str = Field(default=None)  # type: ignore[assignment]
     model_config = ConfigDict(frozen=True, extra="forbid")
 
     def __str__(self) -> str:
@@ -349,7 +349,7 @@ class FieldHandleBinding(NestedHandleBinding):
 
     @property
     def qmod_expr(self) -> str:
-        return f"get_field({self.base_handle.qmod_expr}, '{self.field}')"
+        return f"{self.base_handle.qmod_expr}.{self.field}"
 
     @property
     def identifier(self) -> str:

classiq/interface/model/port_declaration.py

@@ -13,10 +13,11 @@ from classiq.interface.generator.functions.type_modifier import (
 )
 from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
 from classiq.interface.model.parameter import Parameter
+from classiq.interface.model.quantum_type import QuantumBitvector
 
 
 class AnonPortDeclaration(Parameter):
-    quantum_type: ConcreteQuantumType
+    quantum_type: ConcreteQuantumType = pydantic.Field(default_factory=QuantumBitvector)
     direction: PortDeclarationDirection
     kind: Literal["PortDeclaration"]
     type_modifier: TypeModifier

classiq/interface/model/quantum_expressions/arithmetic_operation.py

@@ -1,12 +1,9 @@
 from collections.abc import Mapping, Sequence
-from typing import Literal
-
-from pydantic import PrivateAttr
+from typing import Literal, cast
 
 from classiq.interface.enum_utils import StrEnum
 from classiq.interface.generator.arith.arithmetic import (
     ARITHMETIC_EXPRESSION_RESULT_NAME,
-    compute_arithmetic_result_type,
 )
 from classiq.interface.model.handle_binding import (
     ConcreteHandleBinding,
@@ -18,6 +15,9 @@ from classiq.interface.model.quantum_expressions.quantum_expression import (
 from classiq.interface.model.quantum_statement import HandleMetadata
 from classiq.interface.model.quantum_type import QuantumType
 
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
+from classiq.model_expansions.arithmetic import NumericAttributes
+
 
 class ArithmeticOperationKind(StrEnum):
     InplaceAdd = "inplace_add"
@@ -29,7 +29,7 @@ class ArithmeticOperation(QuantumAssignmentOperation):
     kind: Literal["ArithmeticOperation"]
 
     operation_kind: ArithmeticOperationKind
-    _classical_assignment: bool = PrivateAttr(default=False)
+    classical_assignment: bool = False
 
     @property
     def is_inplace(self) -> bool:
@@ -44,16 +44,20 @@ class ArithmeticOperation(QuantumAssignmentOperation):
         machine_precision: int,
     ) -> None:
         super().initialize_var_types(var_types, machine_precision)
-        self._result_type = compute_arithmetic_result_type(
-            self.expression.expr, var_types, machine_precision
-        )
+        expr_val = self.expression.value.value
+        if isinstance(expr_val, QmodAnnotatedExpression):
+            self._result_type = expr_val.get_quantum_type(expr_val.root)
+        else:
+            self._result_type = NumericAttributes.from_constant(
+                cast(float, expr_val), machine_precision
+            ).to_quantum_numeric()
 
     @property
     def wiring_inouts(
         self,
     ) -> Mapping[str, ConcreteHandleBinding]:
         inouts = dict(super().wiring_inouts)
-        if self.is_inplace and not self._classical_assignment:
+        if self.is_inplace and not self.classical_assignment:
             inouts[self.result_name()] = self.result_var
         return inouts
 
@@ -63,7 +67,7 @@ class ArithmeticOperation(QuantumAssignmentOperation):
             HandleMetadata(handle=handle, readable_location="in an expression")
             for handle in self.var_handles
         ]
-        if self.is_inplace and not self._classical_assignment:
+        if self.is_inplace and not self.classical_assignment:
             inouts.append(
                 HandleMetadata(
                     handle=self.result_var,
@@ -74,13 +78,13 @@ class ArithmeticOperation(QuantumAssignmentOperation):
 
     @property
     def wiring_outputs(self) -> Mapping[str, HandleBinding]:
-        if self.is_inplace or self._classical_assignment:
+        if self.is_inplace or self.classical_assignment:
             return {}
         return super().wiring_outputs
 
     @property
     def readable_outputs(self) -> Sequence[HandleMetadata]:
-        if self.is_inplace or self._classical_assignment:
+        if self.is_inplace or self.classical_assignment:
             return []
         return [
             HandleMetadata(

classiq/interface/model/quantum_lambda_function.py

@@ -32,7 +32,7 @@ class QuantumLambdaFunction(ASTNode):
         default=None
     )
 
-    _py_callable: Callable = pydantic.PrivateAttr(default=None)
+    _py_callable: Callable = pydantic.PrivateAttr(default=None)  # type: ignore[assignment]
 
     @property
     def py_callable(self) -> Callable:

classiq/interface/model/quantum_statement.py

@@ -4,7 +4,6 @@ from typing import Any, Callable, Optional
 from uuid import UUID, uuid4
 
 import pydantic
-from pydantic import ConfigDict
 from typing_extensions import Self
 
 from classiq.interface.ast_node import ASTNode
@@ -21,7 +20,6 @@ from classiq.interface.model.handle_binding import (
 
 class QuantumStatement(ASTNode):
     kind: str
-    model_config = ConfigDict(extra="forbid")
     uuid: UUID = pydantic.Field(
         description="A unique identifier for this operation", default_factory=uuid4
     )
@@ -29,12 +27,12 @@ class QuantumStatement(ASTNode):
     def model_copy(
         self,
         *,
-        update: Optional[dict[str, Any]] = None,
+        update: Optional[Mapping[str, Any]] = None,
         deep: bool = False,
         keep_uuid: bool = False,
     ) -> Self:
         if not keep_uuid:
-            update = update or dict()
+            update = dict(update) if update is not None else dict()
             update.setdefault("uuid", uuid4())
         return super().model_copy(update=update, deep=deep)
 

classiq/interface/model/quantum_type.py

@@ -1,7 +1,7 @@
 from typing import TYPE_CHECKING, Any, Literal, Optional
 
 import pydantic
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import BaseModel, Field
 from typing_extensions import Self
 
 from classiq.interface.ast_node import HashableASTNode
@@ -35,8 +35,6 @@ if TYPE_CHECKING:
 
 
 class QuantumType(HashableASTNode):
-    model_config = ConfigDict(extra="forbid")
-
     _size_in_bits: Optional[int] = pydantic.PrivateAttr(default=None)
 
     def _update_size_in_bits_from_declaration(self) -> None:
@@ -92,6 +90,9 @@ class QuantumType(HashableASTNode):
     def expressions(self) -> list[Expression]:
         return []
 
+    def without_symbolic_attributes(self) -> Self:
+        return self
+
 
 class QuantumScalar(QuantumType):
     def get_proxy(self, handle: "HandleBinding") -> QmodQScalarProxy:
@@ -292,6 +293,18 @@ class QuantumBitvector(QuantumType):
             length = 1
         return length * self.element_type.minimal_size_in_bits
 
+    def without_symbolic_attributes(self) -> "QuantumBitvector":
+        length = (
+            None
+            if self.length is None
+            or not self.length.is_evaluated()
+            or not self.length.is_constant()
+            else self.length
+        )
+        return QuantumBitvector(
+            element_type=self.element_type.without_symbolic_attributes(), length=length
+        )
+
 
 class QuantumNumeric(QuantumScalar):
     kind: Literal["qnum"]
@@ -487,9 +500,39 @@ class QuantumNumeric(QuantumScalar):
     def minimal_size_in_bits(self) -> int:
         return self.size_in_bits if self.has_size_in_bits else 1
 
+    def without_symbolic_attributes(self) -> "QuantumNumeric":
+        size = (
+            None
+            if self.size is None
+            or not self.size.is_evaluated()
+            or not self.size.is_constant()
+            else self.size
+        )
+        is_signed = (
+            None
+            if self.is_signed is None
+            or not self.is_signed.is_evaluated()
+            or not self.is_signed.is_constant()
+            else self.is_signed
+        )
+        fraction_digits = (
+            None
+            if self.fraction_digits is None
+            or not self.fraction_digits.is_evaluated()
+            or not self.fraction_digits.is_constant()
+            else self.fraction_digits
+        )
+        if size is None or is_signed is None or fraction_digits is None:
+            is_signed = fraction_digits = None
+        qnum = QuantumNumeric(
+            size=size, is_signed=is_signed, fraction_digits=fraction_digits
+        )
+        qnum.set_bounds(self.get_bounds())
+        return qnum
+
 
 class RegisterQuantumType(BaseModel):
-    quantum_types: "ConcreteQuantumType"
+    quantum_types: "ConcreteQuantumType" = Field(default_factory=QuantumBitvector)
     size: int = Field(default=1)
 
     @property

classiq/interface/server/routes.py

@@ -44,9 +44,6 @@ TASKS_VISUALIZE_SUFFIX = TASKS_SUFFIX + "/visualize"
 TASKS_VISUAL_MODEL_SUFFIX = TASKS_SUFFIX + "/visual_model"
 TASKS_SOLVE_SUFFIX = "/tasks/solve"
 
-CHEMISTRY_QMOD_PATH = "/generate_model/chemistry/qmod"
-
-
 TASK_TRAIN_SUFFIX = TASKS_SUFFIX + "/train"
 TASK_TEST_SUFFIX = TASKS_SUFFIX + "/test"
 TASK_PREDICT_SUFFIX = TASKS_SUFFIX + "/predict"
@@ -75,6 +72,8 @@ CONVERSION_GENERATED_CIRCUIT_TO_EXECUTION_INPUT_SUFFIX = "/execution_input"
 CONVERSION_GENERATED_CIRCUIT_TO_EXECUTION_INPUT_FULL = (
     CONVERSION_PREFIX + CONVERSION_GENERATED_CIRCUIT_TO_EXECUTION_INPUT_SUFFIX
 )
+QASM_TO_QMOD_SUFFIX = "/qasm_to_qmod"
+QASM_TO_QMOD_FULL_PATH = CONVERSION_PREFIX + QASM_TO_QMOD_SUFFIX
 
 STATIC_SEMANTICS_VALIDATION_PATH = "/validate_static_semantics"
 

classiq/model_expansions/atomic_expression_functions_defs.py

@@ -15,6 +15,7 @@ from classiq.interface.generator.expressions.atomic_expression_functions import
 from classiq.interface.generator.expressions.expression_types import (
     ExpressionValue,
     QmodStructInstance,
+    RuntimeConstant,
 )
 from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
     AnyClassicalValue,
@@ -44,14 +45,12 @@ from classiq.interface.generator.functions.classical_type import (
     ClassicalArray,
     ClassicalTuple,
     ClassicalType,
-    OpaqueHandle,
-    QmodPyObject,
     Real,
-    StructMetaType,
 )
 from classiq.interface.generator.functions.type_name import TypeName
 from classiq.interface.helpers.backward_compatibility import zip_strict
 
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
 from classiq.evaluators.qmod_expression_visitors.sympy_wrappers import (
     BitwiseAnd,
     BitwiseNot,
@@ -61,10 +60,6 @@ from classiq.evaluators.qmod_expression_visitors.sympy_wrappers import (
     LShift,
     RShift,
 )
-from classiq.model_expansions.model_tables import (
-    HandleIdentifier,
-    HandleTable,
-)
 from classiq.model_expansions.sympy_conversion.expression_to_sympy import (
     MISSING_SLICE_VALUE_PLACEHOLDER,
 )
@@ -106,10 +101,6 @@ def qmod_val_to_python(val: ExpressionValue, qmod_type: ClassicalType) -> Any:
                 )
             ]
 
-    elif isinstance(qmod_type, OpaqueHandle):
-        if isinstance(val, HandleIdentifier):
-            return HandleTable.get_handle_object(val)
-
     elif isinstance(val, Expr):
         return sympy_to_python(val)
 
@@ -121,10 +112,6 @@ def qmod_val_to_python(val: ExpressionValue, qmod_type: ClassicalType) -> Any:
         if isinstance(val, bool):
             return val
 
-    elif isinstance(qmod_type, StructMetaType):
-        if isinstance(val, TypeProxy):
-            return val.struct_declaration
-
     elif isinstance(val, int):  # other scalars are represented as int
         return val
 
@@ -162,11 +149,6 @@ def python_val_to_qmod(val: Any, qmod_type: ClassicalType) -> ExpressionValue:
             for elem, elem_type in zip_strict(val, qmod_type.element_types, strict=True)
         ]
 
-    if isinstance(qmod_type, OpaqueHandle):
-        if not isinstance(val, QmodPyObject):
-            raise ClassiqInternalExpansionError("Bad value opaque handle")
-        return HandleTable.set_handle_object(val)
-
     return val
 
 
@@ -194,7 +176,7 @@ def get_field(
         QmodSizedProxy, QmodStructInstance, list, ClassicalProxy, AnyClassicalValue
     ],
     field: str,
-) -> ExpressionValue:
+) -> Any:
     if isinstance(proxy, AnyClassicalValue) or (
         isinstance(proxy, Symbol)
         and not isinstance(proxy, QmodSizedProxy)
@@ -244,7 +226,7 @@ def do_div(lhs: Any, rhs: Any) -> Any:
     return res
 
 
-_EXPRESSION_TYPES = get_args(ExpressionValue)
+_EXPRESSION_TYPES = (*get_args(RuntimeConstant), QmodAnnotatedExpression)
 
 
 def _is_qmod_value(val: Any) -> bool:

classiq/model_expansions/capturing/captured_vars.py

@@ -1,3 +1,4 @@
+import ast
 import dataclasses
 from collections.abc import Sequence
 from dataclasses import dataclass, field
@@ -41,6 +42,7 @@ from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
 
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
 from classiq.model_expansions.capturing.mangling_utils import (
     demangle_handle,
     mangle_captured_var_name,
@@ -60,9 +62,11 @@ UNINITIALIZED_VAR_MESSAGE = "Variable '{}' should be initialized here"
 
 def _get_symbol_expr(symbol: str, classical_type: ClassicalType) -> Expression:
     expr = Expression(expr=symbol)
-    expr._evaluated_expr = EvaluatedExpression(
-        value=classical_type.get_classical_proxy(handle=HandleBinding(name=symbol))
-    )
+    expr_val = QmodAnnotatedExpression(ast.Name(id=symbol))
+    expr_val.set_type(expr_val.root, classical_type)
+    expr_val.set_var(expr_val.root, HandleBinding(name=symbol))
+    expr_val.lock()
+    expr._evaluated_expr = EvaluatedExpression(value=expr_val)
     return expr