classiq 0.74.0__py3-none-any.whl → 0.76.0__py3-none-any.whl

classiq/interface/debug_info/debug_info.py

@@ -1,5 +1,5 @@
-from collections.abc import Mapping
-from typing import Optional, Union
+from collections.abc import Mapping, Sequence
+from typing import Optional, Union, cast
 from uuid import UUID
 
 from pydantic import BaseModel, Field
@@ -7,10 +7,13 @@ from pydantic import BaseModel, Field
 from classiq.interface.debug_info import back_ref_util
 from classiq.interface.generator.generated_circuit_data import (
     FunctionDebugInfoInterface,
-    OperationLevel,
     StatementType,
 )
 from classiq.interface.model.block import Block
+from classiq.interface.model.handle_binding import ConcreteHandleBinding
+from classiq.interface.model.port_declaration import PortDeclaration
+from classiq.interface.model.quantum_function_call import ArgValue
+from classiq.interface.model.quantum_function_declaration import PositionalArg
 from classiq.interface.model.statement_block import ConcreteQuantumStatement
 
 ParameterValue = Union[float, int, str, None]
@@ -18,21 +21,15 @@ ParameterValue = Union[float, int, str, None]
 
 class FunctionDebugInfo(BaseModel):
     name: str
-    level: OperationLevel = Field(default=OperationLevel.UNKNOWN)
     statement_type: Union[StatementType, None] = None
-    is_allocate_or_free: bool = Field(default=False)
     is_inverse: bool = Field(default=False)
     release_by_inverse: bool = Field(default=False)
     port_to_passed_variable_map: dict[str, str] = Field(default_factory=dict)
     node: Optional[ConcreteQuantumStatement] = None
 
     @property
-    def is_allocate_or_free_(self) -> bool:
-        return (
-            back_ref_util.is_allocate_or_free(self.node)
-            if self.node is not None
-            else self.is_allocate_or_free
-        )
+    def is_allocate_or_free(self) -> bool:
+        return back_ref_util.is_allocate_or_free(self.node) if self.node else False
 
     def update_map_from_port_mapping(self, port_mapping: Mapping[str, str]) -> None:
         new_port_to_passed_variable_map = self.port_to_passed_variable_map.copy()
@@ -103,7 +100,15 @@ def new_function_debug_info_by_node(
 ) -> FunctionDebugInfo:
     return FunctionDebugInfo(
         name="",
-        parameters=dict(),
-        level=OperationLevel.QMOD_STATEMENT,
         node=node._as_back_ref(),
     )
+
+
+def calculate_port_to_passed_variable_mapping(
+    arg_decls: Sequence[PositionalArg], args: Sequence[Union[ArgValue, None]]
+) -> dict[str, str]:
+    return {
+        arg_decl.name: str(cast(ConcreteHandleBinding, arg))
+        for arg_decl, arg in zip(arg_decls, args)
+        if isinstance(arg_decl, PortDeclaration)
+    }

classiq/interface/executor/user_budget.py

@@ -0,0 +1,56 @@
+import datetime
+from collections import defaultdict
+from typing import Optional
+
+import pydantic
+from pydantic import ConfigDict, Field
+
+from classiq.interface.helpers.versioned_model import VersionedModel
+
+
+class UserBudget(VersionedModel):
+    provider: str
+    currency_code: str
+    organization: Optional[str] = Field(default=None)
+    available_budget: float
+    used_budget: float
+    last_allocation_date: datetime.datetime
+
+    model_config = ConfigDict(extra="ignore")
+
+
+class UserBudgets(VersionedModel):
+    budgets: list[UserBudget] = pydantic.Field(default=[])
+
+    def print_budgets(self) -> None:
+        def format_header() -> str:
+            return f"| {'Provider':<20} | {'Available Budget':<18} | {'Used Budget':<18} | {'Currency':<8} |"
+
+        def format_row(
+            provider: str, available: float, used: float, currency: str
+        ) -> str:
+            return f"| {provider:<20} | {available:<18.0f} | {used:<18.0f} | {currency:<8} |"
+
+        table_data: dict = defaultdict(
+            lambda: {"used": 0.0, "available": 0.0, "currency": "USD"}
+        )
+
+        for budget in self.budgets:
+            provider = budget.provider
+            table_data[provider]["available"] += budget.available_budget
+            table_data[provider]["used"] += budget.used_budget
+            table_data[provider]["currency"] = budget.currency_code
+
+        line = "=" * 77
+        print(line)  # noqa: T201
+        print(format_header())  # noqa: T201
+        print(line)  # noqa: T201
+
+        for provider, values in table_data.items():
+            print(  # noqa: T201
+                format_row(
+                    provider, values["available"], values["used"], values["currency"]
+                )
+            )
+
+        print(line)  # noqa: T201

classiq/interface/generator/application_apis/finance_declarations.py

@@ -10,6 +10,7 @@ from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
 from classiq.interface.generator.functions.type_name import Struct
+from classiq.interface.generator.functions.type_qualifier import TypeQualifier
 from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
 )
@@ -55,11 +56,13 @@ def _generate_finance_function(
                     )
                 ),
                 direction=PortDeclarationDirection.Inout,
+                type_qualifier=TypeQualifier.Quantum,
             ),
             PortDeclaration(
                 name=OBJECTIVE_PORT_NAME,
                 quantum_type=QuantumBit(),
                 direction=PortDeclarationDirection.Inout,
+                type_qualifier=TypeQualifier.Quantum,
             ),
         ],
     )

classiq/interface/generator/expressions/atomic_expression_functions.py

@@ -15,6 +15,7 @@ SUPPORTED_CLASSIQ_BUILTIN_FUNCTIONS = {
     "molecule_problem_to_hamiltonian",
     "fock_hamiltonian_problem_to_hamiltonian",
     "molecule_ground_state_solution_post_process",
+    "mod_inverse",
 }
 
 SUPPORTED_CLASSIQ_SYMPY_WRAPPERS = {
@@ -23,6 +24,8 @@ SUPPORTED_CLASSIQ_SYMPY_WRAPPERS = {
     "BitwiseNot",
     "BitwiseOr",
     "LogicalXor",
+    "RShift",
+    "LShift",
 }
 
 SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS = {

classiq/interface/generator/expressions/proxies/classical/any_classical_value.py

@@ -1,135 +1,41 @@
+import inspect
 from typing import Any
 
+import sympy
 
-class AnyClassicalValue:
-    def __init__(self, expr: str) -> None:
-        self._expr = expr
+_SYMPY_MEMBERS = [name for name, _ in inspect.getmembers(sympy.Symbol)] + ["precedence"]
 
-    def __str__(self) -> str:
-        return self._expr
 
-    def __repr__(self) -> str:
-        return str(self)
+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 __getitem__(self, item: Any) -> "AnyClassicalValue":
-        if isinstance(item, slice):
-            subscript = ""
-            if item.start is not None:
-                subscript += str(item.start)
-            subscript += ":"
-            if item.stop is not None:
-                subscript += str(item.stop)
-            if item.step is not None:
-                subscript += f":{item.stop}"
-            item = subscript
-        return AnyClassicalValue(f"{self}[{item}]")
-
-    @staticmethod
-    def _binary_op(lhs: Any, rhs: Any, op: str) -> "AnyClassicalValue":
-        return AnyClassicalValue(f"{lhs} {op} {rhs}")
-
-    @staticmethod
-    def _unary_op(arg: Any, op: str) -> "AnyClassicalValue":
-        return AnyClassicalValue(f"{op}({arg})")
-
-    def __add__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(self, other, "+")
-
-    def __sub__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(self, other, "-")
-
-    def __mul__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(self, other, "*")
-
-    def __truediv__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(self, other, "/")
-
-    def __floordiv__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(self, other, "//")
-
-    def __mod__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(self, other, "%")
-
-    def __pow__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(self, other, "**")
-
-    def __lshift__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(self, other, "<<")
-
-    def __rshift__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(self, other, ">>")
-
-    def __and__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(self, other, "&")
-
-    def __xor__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(self, other, "^")
-
-    def __or__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(self, other, "|")
-
-    def __radd__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(other, self, "+")
-
-    def __rsub__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(other, self, "-")
 
-    def __rmul__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(other, self, "*")
+class AnyClassicalValue(sympy.Symbol):
 
-    def __rtruediv__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(other, self, "/")
+    is_commutative = None
+    is_infinite = None
+    is_finite = None
+    is_extended_real = None
 
-    def __rfloordiv__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(other, self, "//")
-
-    def __rmod__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(other, self, "%")
-
-    def __rpow__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(other, self, "**")
-
-    def __rlshift__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(other, self, "<<")
-
-    def __rrshift__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(other, self, ">>")
-
-    def __rand__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(other, self, "&")
-
-    def __rxor__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(other, self, "^")
-
-    def __ror__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(other, self, "|")
-
-    def __lt__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(self, other, "<")
-
-    def __le__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(self, other, "<=")
-
-    def __eq__(self, other: Any) -> "AnyClassicalValue":  # type:ignore[override]
-        return AnyClassicalValue._binary_op(self, other, "==")
-
-    def __ne__(self, other: Any) -> "AnyClassicalValue":  # type: ignore[override]
-        return AnyClassicalValue._binary_op(self, other, "!=")
-
-    def __gt__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(self, other, ">")
-
-    def __ge__(self, other: Any) -> "AnyClassicalValue":
-        return AnyClassicalValue._binary_op(self, other, ">=")
-
-    def __neg__(self) -> "AnyClassicalValue":
-        return AnyClassicalValue._unary_op(self, "-")
-
-    def __pos__(self) -> "AnyClassicalValue":
-        return AnyClassicalValue._unary_op(self, "+")
+    def __getitem__(self, item: Any) -> "AnyClassicalValue":
+        if isinstance(item, slice):
+            return AnyClassicalValue(f"{self}[{subscript_to_str(item)}]")
+        return AnyClassicalValue(f"do_subscript({self}, {item})")
 
-    def __abs__(self) -> "AnyClassicalValue":
-        return AnyClassicalValue._unary_op(self, "abs")
+    def __getattribute__(self, attr: str) -> Any:
+        if attr.startswith("_") or attr in _SYMPY_MEMBERS:
+            return super().__getattribute__(attr)
+        return AnyClassicalValue(f"get_field({self}, '{attr}')")
 
-    def __invert__(self) -> "AnyClassicalValue":
-        return AnyClassicalValue._unary_op(self, "~")
+    def __len__(self) -> "AnyClassicalValue":
+        return self.len

classiq/interface/generator/expressions/proxies/classical/classical_array_proxy.py

@@ -1,11 +1,16 @@
 from collections.abc import Mapping
-from typing import TYPE_CHECKING, Union
+from typing import TYPE_CHECKING, Any, Union
 
+import sympy
 from sympy import Integer
+from typing_extensions import TypeGuard
 
-from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.exceptions import ClassiqIndexError
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.expressions.non_symbolic_expr import NonSymbolicExpr
+from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
+    AnyClassicalValue,
+)
 from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
     ClassicalProxy,
 )
@@ -22,9 +27,20 @@ if TYPE_CHECKING:
     )
 
 
+def _is_int(val: Any) -> TypeGuard[Union[int, sympy.Basic]]:
+    if isinstance(val, AnyClassicalValue):
+        return False
+    if isinstance(val, sympy.Basic):
+        return val.is_Number
+    return isinstance(val, int)
+
+
 class ClassicalArrayProxy(NonSymbolicExpr, ClassicalProxy):
     def __init__(
-        self, handle: HandleBinding, element_type: "ConcreteClassicalType", length: int
+        self,
+        handle: HandleBinding,
+        element_type: "ConcreteClassicalType",
+        length: "ExpressionValue",
     ) -> None:
         super().__init__(handle)
         self._element_type = element_type
@@ -39,39 +55,47 @@ class ClassicalArrayProxy(NonSymbolicExpr, ClassicalProxy):
         return "Array"
 
     @property
-    def length(self) -> int:
+    def length(self) -> "ExpressionValue":
         return self._length
 
-    def __getitem__(self, key: Union[slice, int, Integer]) -> ClassicalProxy:
+    def __getitem__(
+        self, key: Union[slice, int, Integer, ClassicalProxy]
+    ) -> ClassicalProxy:
         return (
             self._get_slice(key) if isinstance(key, slice) else self._get_subscript(key)
         )
 
     def _get_slice(self, slice_: slice) -> ClassicalProxy:
-        start = int(slice_.start)
-        stop = int(slice_.stop)
-        if start >= stop:
-            raise ClassiqValueError("Array slice has non-positive length")
-        if start < 0 or stop > self._length:
-            raise ClassiqValueError("Array slice is out of bounds")
+        start_ = slice_.start
+        stop_ = slice_.stop
+        if _is_int(start_) and _is_int(stop_):
+            start = int(start_)
+            stop = int(stop_)
+            if start >= stop:
+                raise ClassiqIndexError("Array slice has non-positive length")
+            if start < 0 or (isinstance(self._length, int) and stop > self._length):
+                raise ClassiqIndexError("Array slice is out of bounds")
         return ClassicalArrayProxy(
             SlicedHandleBinding(
                 base_handle=self.handle,
-                start=Expression(expr=str(start)),
-                end=Expression(expr=str(stop)),
+                start=Expression(expr=str(start_)),
+                end=Expression(expr=str(stop_)),
             ),
             self._element_type,
-            stop - start,
+            stop_ - start_,
         )
 
-    def _get_subscript(self, index_: Union[int, Integer]) -> ClassicalProxy:
-        index = int(index_)
-        if index < 0:
-            raise ClassiqValueError(
-                "Array index is out of bounds (negative indices are not supported)"
-            )
-        if index >= self._length:
-            raise ClassiqValueError("Array index is out of bounds")
+    def _get_subscript(
+        self, index_: Union[int, Integer, ClassicalProxy]
+    ) -> ClassicalProxy:
+        if _is_int(index_):
+            index = int(index_)
+            if index < 0:
+                raise ClassiqIndexError(
+                    "Array index is out of bounds (negative indices are not supported)"
+                )
+            if isinstance(self._length, int) and index >= self._length:
+                raise ClassiqIndexError("Array index is out of bounds")
         return self._element_type.get_classical_proxy(
             SubscriptHandleBinding(
                 base_handle=self._handle, index=Expression(expr=str(index_))

classiq/interface/generator/expressions/proxies/classical/qmod_struct_instance.py

@@ -25,6 +25,13 @@ class QmodStructInstance:
     def fields(self) -> Mapping[str, Any]:
         return types.MappingProxyType(self._fields)
 
+    def __getattr__(self, item: str) -> Any:
+        if item == "_fields":
+            return super().__getattribute__(item)
+        if item in self._fields:
+            return self._fields[item]
+        return super().__getattribute__(item)
+
     def __str__(self) -> str:
         return repr(self)
 

classiq/interface/generator/expressions/proxies/classical/utils.py

@@ -13,22 +13,23 @@ from classiq.interface.generator.expressions.proxies.classical.classical_struct_
 )
 from classiq.interface.generator.functions.classical_type import (
     ClassicalArray,
+    ClassicalList,
     ClassicalType,
 )
-from classiq.interface.generator.functions.type_name import TypeName
+from classiq.interface.generator.functions.type_name import Struct
 
 
 def get_proxy_type(proxy: ClassicalProxy) -> ClassicalType:
     if isinstance(proxy, ClassicalScalarProxy):
-        classical_type = proxy._classical_type
-    elif isinstance(proxy, ClassicalArrayProxy):
-        classical_type = ClassicalArray(
-            element_type=proxy._element_type, size=proxy.length
-        )
-    elif isinstance(proxy, ClassicalStructProxy):
-        classical_type = TypeName(name=proxy._decl.name)
-    else:
-        raise ClassiqInternalExpansionError(
-            f"Unrecognized classical proxy {type(proxy).__name__}"
-        )
-    return classical_type
+        return proxy._classical_type
+    if isinstance(proxy, ClassicalArrayProxy):
+        if not isinstance(proxy.length, int):
+            return ClassicalList(element_type=proxy._element_type)
+        return ClassicalArray(element_type=proxy._element_type, size=proxy.length)
+    if isinstance(proxy, ClassicalStructProxy):
+        classical_type = Struct(name=proxy._decl.name)
+        classical_type.set_classical_struct_decl(proxy._decl)
+        return classical_type
+    raise ClassiqInternalExpansionError(
+        f"Unrecognized classical proxy {type(proxy).__name__}"
+    )

classiq/interface/generator/expressions/proxies/quantum/qmod_qscalar_proxy.py

@@ -1,7 +1,8 @@
 from collections.abc import Mapping
-from typing import Any
+from typing import Any, Optional
 
 from sympy import Symbol
+from typing_extensions import Self
 
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.expressions.proxies.quantum.qmod_sized_proxy import (
@@ -12,11 +13,17 @@ from classiq.interface.model.handle_binding import HandleBinding
 
 class QmodQScalarProxy(Symbol, QmodSizedProxy):
     def __new__(cls, handle: HandleBinding, **assumptions: bool) -> "QmodQScalarProxy":
-        return super().__new__(cls, str(handle), **assumptions)
+        return super().__new__(cls, handle.qmod_expr, **assumptions)
 
     def __init__(self, handle: HandleBinding, size: int) -> None:
         super().__init__(handle, size)
 
+    def __copy__(self) -> Self:
+        return self
+
+    def __deepcopy__(self, memo: Optional[dict]) -> Self:
+        return self
+
 
 class QmodQBitProxy(QmodQScalarProxy):
     def __init__(self, handle: HandleBinding) -> None:

classiq/interface/generator/expressions/proxies/quantum/qmod_sized_proxy.py

@@ -15,7 +15,10 @@ class QmodSizedProxy:
         return self._size
 
     def __str__(self) -> str:
-        return str(self.handle)
+        return self.handle.qmod_expr
+
+    def __repr__(self) -> str:
+        return str(self)
 
     @property
     def type_name(self) -> str:

classiq/interface/generator/expressions/sympy_supported_expressions.py

@@ -33,6 +33,7 @@ MATHEMATICAL_FUNCTIONS: list[str] = [
     "Max",
     "Min",
     "mod_inverse",
+    "Mod",
 ]
 SPECIAL_FUNCTIONS: list[str] = [
     "erf",

classiq/interface/generator/functions/classical_type.py

@@ -5,6 +5,10 @@ from pydantic import ConfigDict, PrivateAttr
 from typing_extensions import Self
 
 from classiq.interface.ast_node import HashableASTNode
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
+    AnyClassicalValue,
+)
 from classiq.interface.generator.expressions.proxies.classical.classical_array_proxy import (
     ClassicalArrayProxy,
 )
@@ -39,9 +43,22 @@ class ClassicalType(HashableASTNode):
     def is_generative(self) -> bool:
         return self._is_generative
 
+    @property
+    def is_purely_declarative(self) -> bool:
+        return not self._is_generative
+
     def get_classical_proxy(self, handle: HandleBinding) -> ClassicalProxy:
         return ClassicalScalarProxy(handle, self)
 
+    @property
+    def expressions(self) -> list[Expression]:
+        return []
+
+    def clear_flags(self) -> Self:
+        res = self.model_copy()
+        res._is_generative = False
+        return res
+
 
 class Integer(ClassicalType):
     kind: Literal["int"]
@@ -80,7 +97,17 @@ class ClassicalList(ClassicalType):
         return values_with_discriminator(values, "kind", "list")
 
     def get_classical_proxy(self, handle: HandleBinding) -> ClassicalProxy:
-        raise NotImplementedError
+        return ClassicalArrayProxy(
+            handle, self.element_type, AnyClassicalValue(f"get_field({handle}, 'len')")
+        )
+
+    @property
+    def expressions(self) -> list[Expression]:
+        return self.element_type.expressions
+
+    @property
+    def is_purely_declarative(self) -> bool:
+        return super().is_purely_declarative and self.element_type.is_purely_declarative
 
 
 class StructMetaType(ClassicalType):
@@ -108,6 +135,14 @@ class ClassicalArray(ClassicalType):
     def get_classical_proxy(self, handle: HandleBinding) -> ClassicalProxy:
         return ClassicalArrayProxy(handle, self.element_type, self.size)
 
+    @property
+    def expressions(self) -> list[Expression]:
+        return self.element_type.expressions
+
+    @property
+    def is_purely_declarative(self) -> bool:
+        return super().is_purely_declarative and self.element_type.is_purely_declarative
+
 
 class OpaqueHandle(ClassicalType):
     pass

classiq/interface/generator/functions/type_name.py

@@ -9,6 +9,9 @@ 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_scalar_proxy import (
+    ClassicalScalarProxy,
+)
 from classiq.interface.generator.expressions.proxies.classical.classical_struct_proxy import (
     ClassicalStructProxy,
 )
@@ -109,18 +112,42 @@ class TypeName(ClassicalType, QuantumType):
         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")
+        if self.is_enum:
+            return ClassicalScalarProxy(handle, self)
+        if TYPE_CHECKING:
+            assert self._classical_struct_decl is not None
         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()
+        if self.has_fields:
+            return list(
+                chain.from_iterable(
+                    field_type.expressions for field_type in self.fields.values()
+                )
+            )
+        if self.has_classical_struct_decl:
+            return list(
+                chain.from_iterable(
+                    field_type.expressions
+                    for field_type in self.classical_struct_decl.variables.values()
+                )
             )
+        return []
+
+    @property
+    def is_purely_declarative(self) -> bool:
+        if self.is_enum:
+            return False
+        return super().is_purely_declarative and all(
+            field_type.is_purely_declarative
+            for field_type in self.classical_struct_decl.variables.values()
         )
 
+    @property
+    def is_enum(self) -> bool:
+        return not self.has_fields and not self.has_classical_struct_decl
+
 
 class Enum(TypeName):
     pass