classiq 0.69.0__py3-none-any.whl → 0.71.0__py3-none-any.whl

classiq/interface/generator/functions/classical_type.py

@@ -1,30 +1,31 @@
-from typing import TYPE_CHECKING, Any, Literal, Union
+from typing import TYPE_CHECKING, Any, Literal
 
 import pydantic
 from pydantic import ConfigDict, PrivateAttr
-from sympy import IndexedBase, Symbol
 from typing_extensions import Self
 
 from classiq.interface.ast_node import HashableASTNode
-from classiq.interface.generator.expressions.expression_types import RuntimeExpression
+from classiq.interface.generator.expressions.proxies.classical.classical_array_proxy import (
+    ClassicalArrayProxy,
+)
+from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
+    ClassicalProxy,
+)
+from classiq.interface.generator.expressions.proxies.classical.classical_scalar_proxy import (
+    ClassicalScalarProxy,
+)
 from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
+from classiq.interface.model.handle_binding import HandleBinding
 
 if TYPE_CHECKING:
     from classiq.interface.generator.functions.concrete_types import (
         ConcreteClassicalType,
     )
 
-CLASSICAL_ATTRIBUTES = {"len", "size", "is_signed", "fraction_digits"}
-
-NamedSymbol = Union[IndexedBase, Symbol]
-
 
 class ClassicalType(HashableASTNode):
     _is_generative: bool = PrivateAttr(default=False)
 
-    def as_symbolic(self, name: str) -> Union[NamedSymbol, list[NamedSymbol]]:
-        return Symbol(name)
-
     model_config = ConfigDict(extra="forbid")
 
     def __str__(self) -> str:
@@ -38,13 +39,13 @@ class ClassicalType(HashableASTNode):
     def is_generative(self) -> bool:
         return self._is_generative
 
+    def get_classical_proxy(self, handle: HandleBinding) -> ClassicalProxy:
+        return ClassicalScalarProxy(handle, self)
+
 
 class Integer(ClassicalType):
     kind: Literal["int"]
 
-    def as_symbolic(self, name: str) -> Symbol:
-        return Symbol(name, integer=True)
-
     @pydantic.model_validator(mode="before")
     @classmethod
     def _set_kind(cls, values: Any) -> dict[str, Any]:
@@ -54,9 +55,6 @@ class Integer(ClassicalType):
 class Real(ClassicalType):
     kind: Literal["real"]
 
-    def as_symbolic(self, name: str) -> Symbol:
-        return Symbol(name, real=True)
-
     @pydantic.model_validator(mode="before")
     @classmethod
     def _set_kind(cls, values: Any) -> dict[str, Any]:
@@ -76,14 +74,14 @@ class ClassicalList(ClassicalType):
     kind: Literal["list"]
     element_type: "ConcreteClassicalType"
 
-    def as_symbolic(self, name: str) -> Symbol:
-        return IndexedBase(name)
-
     @pydantic.model_validator(mode="before")
     @classmethod
     def _set_kind(cls, values: Any) -> dict[str, Any]:
         return values_with_discriminator(values, "kind", "list")
 
+    def get_classical_proxy(self, handle: HandleBinding) -> ClassicalProxy:
+        raise NotImplementedError
+
 
 class StructMetaType(ClassicalType):
     kind: Literal["type_proxy"]
@@ -93,20 +91,23 @@ class StructMetaType(ClassicalType):
     def _set_kind(cls, values: Any) -> dict[str, Any]:
         return values_with_discriminator(values, "kind", "type_proxy")
 
+    def get_classical_proxy(self, handle: HandleBinding) -> ClassicalProxy:
+        raise NotImplementedError
+
 
 class ClassicalArray(ClassicalType):
     kind: Literal["array"]
     element_type: "ConcreteClassicalType"
-    size: pydantic.PositiveInt
-
-    def as_symbolic(self, name: str) -> list:
-        return [self.element_type.as_symbolic(f"{name}_{i}") for i in range(self.size)]
+    size: int
 
     @pydantic.model_validator(mode="before")
     @classmethod
     def _set_kind(cls, values: Any) -> dict[str, Any]:
         return values_with_discriminator(values, "kind", "array")
 
+    def get_classical_proxy(self, handle: HandleBinding) -> ClassicalProxy:
+        return ClassicalArrayProxy(handle, self.element_type, self.size)
+
 
 class OpaqueHandle(ClassicalType):
     pass
@@ -148,12 +149,5 @@ class IQAERes(OpaqueHandle):
         return values_with_discriminator(values, "kind", "iqae_result")
 
 
-def as_symbolic(symbols: dict[str, ClassicalType]) -> dict[str, RuntimeExpression]:
-    return {
-        param_name: param_type.as_symbolic(param_name)
-        for param_name, param_type in symbols.items()
-    }
-
-
 class QmodPyObject:
     pass

classiq/interface/generator/functions/type_name.py

@@ -1,10 +1,20 @@
 from collections.abc import Mapping
+from itertools import chain
 from typing import TYPE_CHECKING, Any, Literal, Optional
 
 import pydantic
 
 from classiq.interface.exceptions import ClassiqExpansionError
-from classiq.interface.generator.expressions.qmod_qstruct_proxy import QmodQStructProxy
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
+    ClassicalProxy,
+)
+from classiq.interface.generator.expressions.proxies.classical.classical_struct_proxy import (
+    ClassicalStructProxy,
+)
+from classiq.interface.generator.expressions.proxies.quantum.qmod_qstruct_proxy import (
+    QmodQStructProxy,
+)
 from classiq.interface.generator.functions.classical_type import (
     ClassicalType,
 )
@@ -16,6 +26,7 @@ from classiq.interface.model.quantum_type import (
 
 if TYPE_CHECKING:
     from classiq.interface.generator.functions.concrete_types import ConcreteQuantumType
+    from classiq.interface.generator.types.struct_declaration import StructDeclaration
 
 
 class TypeName(ClassicalType, QuantumType):
@@ -24,6 +35,9 @@ class TypeName(ClassicalType, QuantumType):
     _assigned_fields: Optional[Mapping[str, "ConcreteQuantumType"]] = (
         pydantic.PrivateAttr(default=None)
     )
+    _classical_struct_decl: Optional["StructDeclaration"] = pydantic.PrivateAttr(
+        default=None
+    )
 
     @pydantic.model_validator(mode="before")
     @classmethod
@@ -40,7 +54,7 @@ class TypeName(ClassicalType, QuantumType):
             )
 
     def get_proxy(self, handle: "HandleBinding") -> "QmodQStructProxy":
-        from classiq.interface.generator.expressions.qmod_qstruct_proxy import (
+        from classiq.interface.generator.expressions.proxies.quantum.qmod_qstruct_proxy import (
             QmodQStructProxy,
         )
 
@@ -81,6 +95,32 @@ class TypeName(ClassicalType, QuantumType):
             field_type.is_evaluated for field_type in self.fields.values()
         )
 
+    @property
+    def has_classical_struct_decl(self) -> bool:
+        return self._classical_struct_decl is not None
+
+    @property
+    def classical_struct_decl(self) -> "StructDeclaration":
+        if self._classical_struct_decl is None:
+            raise ClassiqExpansionError(f"Type {self.name!r} is undefined")
+        return self._classical_struct_decl
+
+    def set_classical_struct_decl(self, decl: "StructDeclaration") -> None:
+        self._classical_struct_decl = decl
+
+    def get_classical_proxy(self, handle: HandleBinding) -> ClassicalProxy:
+        if self._classical_struct_decl is None:
+            raise ClassiqExpansionError(f"Type {self.name!r} is undefined")
+        return ClassicalStructProxy(handle, self._classical_struct_decl)
+
+    @property
+    def expressions(self) -> list[Expression]:
+        return list(
+            chain.from_iterable(
+                field_type.expressions for field_type in self.fields.values()
+            )
+        )
+
 
 class Enum(TypeName):
     pass

classiq/interface/generator/functions/type_qualifier.py

@@ -0,0 +1,7 @@
+from classiq.interface.enum_utils import StrEnum
+
+
+class TypeQualifier(StrEnum):
+    Const = "const"
+    QFree = "qfree"
+    Quantum = "quantum"

classiq/interface/generator/generated_circuit_data.py

@@ -1,4 +1,5 @@
 import logging
+import re
 from typing import Literal, Optional, Union
 
 import pydantic
@@ -7,6 +8,9 @@ from typing_extensions import TypeAlias
 
 from classiq.interface.debug_info.back_ref_util import is_allocate_or_free_by_backref
 from classiq.interface.enum_utils import StrEnum
+from classiq.interface.generator.compiler_keywords import (
+    generate_original_function_name,
+)
 from classiq.interface.generator.control_state import ControlState
 from classiq.interface.generator.register_role import RegisterRole
 from classiq.interface.generator.synthesis_metadata.synthesis_execution_data import (
@@ -32,6 +36,11 @@ ParameterName = str
 IOQubitMapping: TypeAlias = dict[str, tuple[int, ...]]
 
 CLASSIQ_HIERARCHY_SEPARATOR: Literal["__"] = "__"
+QASM_SEPARATOR = "_"
+SPLIT_MARKER: str = "part"
+PART_SUFFIX_REGEX = re.compile(
+    rf".+{QASM_SEPARATOR}{SPLIT_MARKER}{QASM_SEPARATOR}(\d+)$"
+)
 
 VISUALIZATION_HIDE_LIST = [
     "apply_to_all",
@@ -74,7 +83,7 @@ class GeneratedRegister(pydantic.BaseModel):
     @staticmethod
     def demangle_name(name: str) -> str:
         if is_captured_var_name(name):
-            return demangle_capture_name(name)
+            name = demangle_capture_name(name)
         return demangle_name(name)
 
 
@@ -168,9 +177,18 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
 
     @property
     def name(self) -> str:
-        if self.generated_function is None:
-            return ""
-        return self.generated_function.name
+        generated_name = self.generated_function.name if self.generated_function else ""
+        # Temp fix for currently "supported" statements (same as for level_ property)
+        if generated_name in {StatementType.CONTROL, StatementType.POWER}:
+            return generated_name
+        if self.first_back_ref and isinstance(self.first_back_ref, QuantumFunctionCall):
+            name = generate_original_function_name(self.first_back_ref.func_name)
+            if part_match := PART_SUFFIX_REGEX.match(generated_name):
+                suffix = f" [{part_match.group(1)}]"
+            else:
+                suffix = ""
+            return f"{name}{suffix}"
+        return generated_name
 
     @property
     def first_back_ref(self) -> Optional[ConcreteQuantumStatement]:

classiq/interface/generator/model/preferences/preferences.py

@@ -47,6 +47,7 @@ class QuantumFormat(StrEnum):
     IONQ = "ionq"
     CIRQ_JSON = "cirq_json"
     QASM_CIRQ_COMPATIBLE = "qasm_cirq_compatible"
+    EXECUTION_SERIALIZATION = "_execution_serialization"
 
 
 _SERVICE_PROVIDER_TO_FORMAT: dict[Provider, QuantumFormat] = {

classiq/interface/generator/quantum_function_call.py

@@ -40,7 +40,10 @@ from classiq.interface.generator.slice_parsing_utils import (
     SLICING,
     parse_io_slicing,
 )
-from classiq.interface.generator.synthesis_execution_parameter import PydanticPowerType
+from classiq.interface.generator.synthesis_execution_parameter import (
+    ClassicalArg,
+    PydanticPowerType,
+)
 from classiq.interface.generator.user_defined_function_params import CustomFunction
 from classiq.interface.helpers.custom_pydantic_types import PydanticNonEmptyString
 from classiq.interface.helpers.hashable_pydantic_base_model import (
@@ -148,6 +151,10 @@ class SynthesisQuantumFunctionCall(BaseModel):
         description="The name of the function instance. "
         "If not set, determined automatically.",
     )
+    caller_parameters: Optional[list[str]] = pydantic.Field(default=None)
+    parameter_assignments: Optional[dict[str, ClassicalArg]] = pydantic.Field(
+        default=None
+    )
     source_id: Optional[UUID] = pydantic.Field(default=None)
     arithmetic_id: Optional[str] = pydantic.Field(default=None)
     inverse_op_id: Optional[UUID] = pydantic.Field(default=None)

classiq/interface/generator/quantum_program.py

@@ -117,7 +117,6 @@ class QuantumProgram(VersionedModel, CircuitCodeInterface):
         instruction_set: Optional[QuantumInstructionSet] = None,
     ) -> quantum_code.QuantumCode:
         initial_values = initial_values or self.initial_values
-
         if instruction_set is not None:
             code, syntax = (
                 self.program_circuit.get_code(instruction_set),

classiq/interface/generator/synthesis_execution_parameter.py

@@ -6,3 +6,4 @@ from classiq.interface.backend.pydantic_backend import PydanticExecutionParamete
 
 PydanticIntSynthesisExecutionParameter = Union[PydanticExecutionParameter, int]
 PydanticPowerType: TypeAlias = PydanticIntSynthesisExecutionParameter
+ClassicalArg = Union[float, str]

classiq/interface/generator/types/compilation_metadata.py

@@ -4,3 +4,4 @@ from pydantic import BaseModel, Field, NonNegativeInt
 class CompilationMetadata(BaseModel):
     should_synthesize_separately: bool = Field(default=False)
     occurrences_number: NonNegativeInt = Field(default=1)
+    atomic_qualifiers: list[str] = Field(default_factory=list)

classiq/interface/ide/visual_model.py

@@ -97,6 +97,7 @@ class AtomicGate(StrEnum):
     SWAP = "SWAP"
     IDENTITY = "IDENTITY"
     U = "U"
+    RESET = "RESET"
 
     @property
     def is_control_gate(self) -> bool:

classiq/interface/interface_version.py

@@ -1 +1 @@
-INTERFACE_VERSION = "8"
+INTERFACE_VERSION = "9"

classiq/interface/model/allocate.py

@@ -14,3 +14,10 @@ class Allocate(QuantumOperation):
     @property
     def wiring_outputs(self) -> Mapping[str, HandleBinding]:
         return {"out": self.target}
+
+    @property
+    def expressions(self) -> list[Expression]:
+        exprs = []
+        if self.size is not None:
+            exprs.append(self.size)
+        return exprs

classiq/interface/model/block.py

@@ -0,0 +1,12 @@
+from typing import TYPE_CHECKING, Literal
+
+from classiq.interface.model.quantum_statement import QuantumOperation
+
+if TYPE_CHECKING:
+    from classiq.interface.model.statement_block import StatementBlock
+
+
+class Block(QuantumOperation):
+    kind: Literal["Block"]
+
+    statements: "StatementBlock"

classiq/interface/model/classical_if.py

@@ -17,3 +17,7 @@ class ClassicalIf(QuantumOperation):
 
     def _as_back_ref(self: ASTNodeType) -> ASTNodeType:
         return reset_lists(self, ["then", "else_"])
+
+    @property
+    def expressions(self) -> list[Expression]:
+        return [self.condition]

classiq/interface/model/inplace_binary_operation.py

@@ -41,3 +41,7 @@ class InplaceBinaryOperation(QuantumOperation):
                 )
             )
         return readable_inouts
+
+    @property
+    def expressions(self) -> list[Expression]:
+        return [self.value] if isinstance(self.value, Expression) else []

classiq/interface/model/model.py

@@ -103,7 +103,9 @@ class Model(VersionedModel, ASTNode):
     functions_compilation_metadata: dict[str, CompilationMetadata] = pydantic.Field(
         default_factory=dict
     )
-    execution_parameters: Optional[dict[str, ConcreteClassicalType]] = None
+    execution_parameters: Optional[dict[str, ConcreteClassicalType]] = pydantic.Field(
+        default=None, exclude=True
+    )
 
     @property
     def main_func(self) -> NativeFunctionDefinition:

classiq/interface/model/native_function_definition.py

@@ -10,13 +10,6 @@ if TYPE_CHECKING:
     from classiq.interface.model.statement_block import StatementBlock
 
 
-class FunctionSynthesisData(pydantic.BaseModel):
-    should_synthesize_separately: bool = pydantic.Field(
-        default=False,
-        description="Whether the function should be synthesized separately.",
-    )
-
-
 class NativeFunctionDefinition(NamedParamsQuantumFunctionDeclaration):
     """
     Facilitates the creation of a user-defined composite function
@@ -28,6 +21,3 @@ class NativeFunctionDefinition(NamedParamsQuantumFunctionDeclaration):
     body: "StatementBlock" = pydantic.Field(
         default_factory=list, description="List of function calls to perform."
     )
-    synthesis_data: FunctionSynthesisData = pydantic.Field(
-        default_factory=FunctionSynthesisData, deprecated=True, exclude=True
-    )

classiq/interface/model/phase_operation.py

@@ -9,3 +9,7 @@ from classiq.interface.model.quantum_expressions.quantum_expression import (
 class PhaseOperation(QuantumExpressionOperation):
     kind: Literal["PhaseOperation"]
     theta: Expression
+
+    @property
+    def expressions(self) -> list[Expression]:
+        return super().expressions + [self.theta]

classiq/interface/model/port_declaration.py

@@ -8,6 +8,7 @@ from classiq.interface.generator.functions.concrete_types import ConcreteQuantum
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+from classiq.interface.generator.functions.type_qualifier import TypeQualifier
 from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
 from classiq.interface.model.parameter import Parameter
 
@@ -15,6 +16,8 @@ from classiq.interface.model.parameter import Parameter
 class AnonPortDeclaration(Parameter):
     quantum_type: ConcreteQuantumType
     direction: PortDeclarationDirection
+    # TODO remove default after BWC-breaking version
+    type_qualifier: TypeQualifier = pydantic.Field(default=TypeQualifier.Quantum)
     kind: Literal["PortDeclaration"]
 
     @pydantic.model_validator(mode="before")

classiq/interface/model/power.py

@@ -16,3 +16,7 @@ class Power(QuantumOperation):
 
     def _as_back_ref(self: ASTNodeType) -> ASTNodeType:
         return reset_lists(self, ["body"])
+
+    @property
+    def expressions(self) -> list[Expression]:
+        return [self.power]

classiq/interface/model/quantum_expressions/quantum_expression.py

@@ -46,6 +46,10 @@ class QuantumExpressionOperation(QuantumOperation):
     def wiring_inouts(self) -> Mapping[str, ConcreteHandleBinding]:
         return nameables_to_dict(self.var_handles)
 
+    @property
+    def expressions(self) -> list[Expression]:
+        return [self.expression]
+
 
 class QuantumAssignmentOperation(QuantumExpressionOperation):
     result_var: ConcreteHandleBinding = pydantic.Field(

classiq/interface/model/quantum_function_call.py

@@ -170,6 +170,10 @@ class QuantumFunctionCall(QuantumOperation):
             param for param in self.positional_args if isinstance(param, HandleBinding)
         ]
 
+    @property
+    def expressions(self) -> list[Expression]:
+        return [arg for arg in self.positional_args if isinstance(arg, Expression)]
+
     def _get_handles_by_direction(
         self, direction: PortDeclarationDirection
     ) -> list[tuple[int, AnonPortDeclaration, HandleBinding]]:

classiq/interface/model/quantum_function_declaration.py

@@ -87,7 +87,7 @@ class AnonQuantumFunctionDeclaration(FunctionDeclaration):
         ]
 
     @property
-    def param_names(self) -> Sequence[str]:
+    def param_names(self) -> list[str]:
         return [param.get_name() for param in self.param_decls]
 
     @property

classiq/interface/model/quantum_statement.py

@@ -8,6 +8,7 @@ from pydantic import ConfigDict
 from typing_extensions import Self
 
 from classiq.interface.ast_node import ASTNode
+from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
 from classiq.interface.model.handle_binding import (
     ConcreteHandleBinding,
@@ -39,6 +40,10 @@ class QuantumStatement(ASTNode):
     def _set_kind(cls, values: Any) -> dict[str, Any]:
         return values_with_discriminator(values, "kind", cls.__name__)
 
+    @property
+    def expressions(self) -> list[Expression]:
+        return []
+
 
 @dataclass
 class HandleMetadata:

classiq/interface/model/quantum_type.py

@@ -11,13 +11,17 @@ from classiq.interface.generator.arith.register_user_input import (
     RegisterUserInput,
 )
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.expressions.qmod_qarray_proxy import QmodQArrayProxy
-from classiq.interface.generator.expressions.qmod_qscalar_proxy import (
+from classiq.interface.generator.expressions.proxies.quantum.qmod_qarray_proxy import (
+    QmodQArrayProxy,
+)
+from classiq.interface.generator.expressions.proxies.quantum.qmod_qscalar_proxy import (
     QmodQBitProxy,
     QmodQNumProxy,
     QmodQScalarProxy,
 )
-from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
+from classiq.interface.generator.expressions.proxies.quantum.qmod_sized_proxy import (
+    QmodSizedProxy,
+)
 from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
 from classiq.interface.model.handle_binding import HandleBinding
 
@@ -67,6 +71,10 @@ class QuantumType(HashableASTNode):
     def is_evaluated(self) -> bool:
         raise NotImplementedError
 
+    @property
+    def expressions(self) -> list[Expression]:
+        return []
+
 
 class QuantumScalar(QuantumType):
     def get_proxy(self, handle: "HandleBinding") -> QmodQScalarProxy:
@@ -170,6 +178,13 @@ class QuantumBitvector(QuantumType):
             and self.element_type.is_evaluated
         )
 
+    @property
+    def expressions(self) -> list[Expression]:
+        exprs = self.element_type.expressions
+        if self.length is not None:
+            exprs.append(self.length)
+        return exprs
+
 
 class QuantumNumeric(QuantumScalar):
     kind: Literal["qnum"]
@@ -213,6 +228,14 @@ class QuantumNumeric(QuantumScalar):
             0 if self.fraction_digits is None else self.fraction_digits.to_int_value()
         )
 
+    @property
+    def is_qbit(self) -> bool:
+        return (
+            self.size_in_bits == 1
+            and self.fraction_digits_value == 0
+            and not self.sign_value
+        )
+
     def _update_size_in_bits_from_declaration(self) -> None:
         if self.size is not None and self.size.is_evaluated():
             self._size_in_bits = self.size.to_int_value()
@@ -253,6 +276,17 @@ class QuantumNumeric(QuantumScalar):
             self.fraction_digits is not None and not self.fraction_digits.is_evaluated()
         )
 
+    @property
+    def expressions(self) -> list[Expression]:
+        exprs = []
+        if self.size is not None:
+            exprs.append(self.size)
+        if self.is_signed is not None:
+            exprs.append(self.is_signed)
+        if self.fraction_digits is not None:
+            exprs.append(self.fraction_digits)
+        return exprs
+
 
 class RegisterQuantumType(BaseModel):
     quantum_types: "ConcreteQuantumType"

classiq/interface/model/repeat.py

@@ -17,3 +17,7 @@ class Repeat(QuantumOperation):
 
     def _as_back_ref(self: ASTNodeType) -> ASTNodeType:
         return reset_lists(self, ["body"])
+
+    @property
+    def expressions(self) -> list[Expression]:
+        return [self.count]

classiq/interface/model/statement_block.py

@@ -4,6 +4,7 @@ from pydantic import Field
 
 from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.block import Block
 from classiq.interface.model.classical_if import ClassicalIf
 from classiq.interface.model.control import Control
 from classiq.interface.model.inplace_binary_operation import InplaceBinaryOperation
@@ -41,12 +42,14 @@ ConcreteQuantumStatement = Annotated[
         Control,
         WithinApply,
         PhaseOperation,
+        Block,
     ],
     Field(..., discriminator="kind"),
 ]
 
 StatementBlock = list[ConcreteQuantumStatement]
 
+Block.model_rebuild()
 Control.model_rebuild()
 QuantumLambdaFunction.model_rebuild()
 Repeat.model_rebuild()

classiq/interface/model/variable_declaration_statement.py

@@ -1,5 +1,6 @@
 from typing import Literal
 
+from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.quantum_statement import QuantumStatement
 from classiq.interface.model.quantum_variable_declaration import (
     QuantumVariableDeclaration,
@@ -8,3 +9,7 @@ from classiq.interface.model.quantum_variable_declaration import (
 
 class VariableDeclarationStatement(QuantumStatement, QuantumVariableDeclaration):
     kind: Literal["VariableDeclarationStatement"]
+
+    @property
+    def expressions(self) -> list[Expression]:
+        return self.quantum_type.expressions

classiq/model_expansions/atomic_expression_functions_defs.py

@@ -12,9 +12,15 @@ from classiq.interface.generator.expressions.expression_types import (
     ExpressionValue,
     QmodStructInstance,
 )
-from classiq.interface.generator.expressions.qmod_qscalar_proxy import QmodQNumProxy
-from classiq.interface.generator.expressions.qmod_qstruct_proxy import QmodQStructProxy
-from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
+from classiq.interface.generator.expressions.proxies.quantum.qmod_qscalar_proxy import (
+    QmodQNumProxy,
+)
+from classiq.interface.generator.expressions.proxies.quantum.qmod_qstruct_proxy import (
+    QmodQStructProxy,
+)
+from classiq.interface.generator.expressions.proxies.quantum.qmod_sized_proxy import (
+    QmodSizedProxy,
+)
 from classiq.interface.generator.expressions.type_proxy import TypeProxy
 from classiq.interface.generator.functions.classical_function_declaration import (
     ClassicalFunctionDeclaration,