classiq 0.84.0__py3-none-any.whl → 0.86.0__py3-none-any.whl

classiq/evaluators/qmod_expression_visitors/qmod_expression_evaluator.py

@@ -0,0 +1,232 @@
+import ast
+from collections.abc import Mapping, Sequence
+from enum import IntEnum
+from typing import Any, Callable, Optional
+
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.generator.arith.machine_precision import (
+    DEFAULT_MACHINE_PRECISION,
+)
+from classiq.interface.generator.functions.classical_function_declaration import (
+    ClassicalFunctionDeclaration,
+)
+from classiq.interface.generator.types.enum_declaration import EnumDeclaration
+from classiq.interface.generator.types.struct_declaration import StructDeclaration
+from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
+
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
+from classiq.evaluators.qmod_node_evaluators.attribute_evaluation import eval_attribute
+from classiq.evaluators.qmod_node_evaluators.binary_op_evaluation import eval_binary_op
+from classiq.evaluators.qmod_node_evaluators.bool_op_evaluation import eval_bool_op
+from classiq.evaluators.qmod_node_evaluators.classical_function_evaluation import (
+    eval_function,
+    eval_symbolic_function,
+    try_eval_builtin_function,
+    try_eval_sympy_function,
+)
+from classiq.evaluators.qmod_node_evaluators.compare_evaluation import eval_compare
+from classiq.evaluators.qmod_node_evaluators.constant_evaluation import (
+    eval_constant,
+    eval_enum_member,
+    try_eval_sympy_constant,
+)
+from classiq.evaluators.qmod_node_evaluators.list_evaluation import eval_list
+from classiq.evaluators.qmod_node_evaluators.measurement_evaluation import (
+    eval_measurement,
+)
+from classiq.evaluators.qmod_node_evaluators.name_evaluation import eval_name
+from classiq.evaluators.qmod_node_evaluators.struct_instantiation_evaluation import (
+    eval_struct_instantiation,
+)
+from classiq.evaluators.qmod_node_evaluators.subscript_evaluation import (
+    eval_quantum_subscript,
+    eval_subscript,
+)
+from classiq.evaluators.qmod_node_evaluators.unary_op_evaluation import eval_unary_op
+from classiq.evaluators.qmod_node_evaluators.utils import is_classical_type
+
+_SUPPORTED_NODES = (
+    ast.BoolOp,
+    ast.BinOp,
+    ast.UnaryOp,
+    ast.Compare,
+    ast.Call,
+    ast.Constant,
+    ast.Attribute,
+    ast.Subscript,
+    ast.Name,
+    ast.List,
+    ast.cmpop,
+    ast.operator,
+    ast.expr_context,
+    ast.keyword,
+    ast.unaryop,
+    ast.boolop,
+    ast.Slice,
+)
+
+
+class QmodExpressionEvaluator(ast.NodeVisitor):
+    def __init__(
+        self,
+        expr_val: QmodAnnotatedExpression,
+        *,
+        machine_precision: int = DEFAULT_MACHINE_PRECISION,
+        classical_struct_declarations: Optional[Sequence[StructDeclaration]] = None,
+        enum_declarations: Optional[Sequence[EnumDeclaration]] = None,
+        classical_function_declarations: Optional[
+            Sequence[ClassicalFunctionDeclaration]
+        ] = None,
+        classical_function_callables: Optional[Mapping[str, Callable]] = None,
+        scope: Optional[dict[str, Any]] = None,
+    ) -> None:
+        self._expr_val = expr_val
+        self._machine_precision = machine_precision
+        self._classical_struct_decls = nameables_to_dict(
+            classical_struct_declarations or []
+        )
+        self._enum_declarations = {decl.name: decl for decl in enum_declarations or []}
+        self._enums: dict[str, type[IntEnum]] = {}
+        self._classical_function_declarations = nameables_to_dict(
+            classical_function_declarations or []
+        )
+        self._classical_function_callables = classical_function_callables or {}
+        self._scope = scope or {}
+
+    def visit(self, node: ast.AST) -> None:
+        if not isinstance(node, _SUPPORTED_NODES):
+            raise ClassiqInternalExpansionError(
+                f"Syntax error: {type(node).__name__!r} is not supported"
+            )
+        super().visit(node)
+
+    def visit_BoolOp(self, node: ast.BoolOp) -> None:
+        super().generic_visit(node)
+        eval_bool_op(self._expr_val, node)
+
+    def visit_BinOp(self, node: ast.BinOp) -> None:
+        super().generic_visit(node)
+        eval_binary_op(self._expr_val, node)
+
+    def visit_UnaryOp(self, node: ast.UnaryOp) -> None:
+        super().generic_visit(node)
+        eval_unary_op(self._expr_val, node)
+
+    def visit_Compare(self, node: ast.Compare) -> None:
+        super().generic_visit(node)
+        eval_compare(self._expr_val, node)
+
+    def visit_Call(self, node: ast.Call) -> None:
+        for arg in node.args:
+            self.visit(arg)
+        for kwarg in node.keywords:
+            self.visit(kwarg)
+
+        func = node.func
+        if not isinstance(func, ast.Name):
+            raise ClassiqExpansionError(
+                f"Function {ast.unparse(node.func)!r} is not supported"
+            )
+        func_name = func.id
+
+        if func_name == "measure":
+            eval_measurement(self._expr_val, node)
+            return
+
+        if func_name in self._classical_struct_decls:
+            eval_struct_instantiation(
+                self._expr_val, node, self._classical_struct_decls[func_name]
+            )
+            return
+
+        if func_name in self._classical_function_callables:
+            if func_name not in self._classical_function_declarations:
+                raise ClassiqInternalExpansionError
+            eval_function(
+                self._expr_val,
+                node,
+                self._classical_function_declarations[func_name],
+                self._classical_function_callables[func_name],
+            )
+            return
+
+        if func_name in self._classical_function_declarations:
+            eval_symbolic_function(
+                self._expr_val, node, self._classical_function_declarations[func_name]
+            )
+            return
+
+        if try_eval_builtin_function(self._expr_val, node, func_name):
+            return
+
+        if try_eval_sympy_function(self._expr_val, node, func_name):
+            return
+
+        raise ClassiqExpansionError(f"{func.id!r} is undefined")
+
+    def visit_Constant(self, node: ast.Constant) -> None:
+        eval_constant(self._expr_val, node)
+
+    def visit_Attribute(self, node: ast.Attribute) -> None:
+        if (
+            isinstance(node.value, ast.Name)
+            and (enum_name := node.value.id) in self._enum_declarations
+        ):
+            if enum_name not in self._enums:
+                self._enums[enum_name] = self._enum_declarations[
+                    enum_name
+                ].create_enum()
+            eval_enum_member(self._expr_val, node, self._enums[enum_name])
+            return
+        super().generic_visit(node)
+        eval_attribute(self._expr_val, node)
+
+    def visit_Subscript(self, node: ast.Subscript) -> None:
+        super().generic_visit(node)
+        if not isinstance(node.slice, ast.Slice) and not is_classical_type(
+            self._expr_val.get_type(node.slice)
+        ):
+            eval_quantum_subscript(self._expr_val, node, self._machine_precision)
+            return
+        eval_subscript(self._expr_val, node)
+
+    def visit_Name(self, node: ast.Name) -> None:
+        if try_eval_sympy_constant(self._expr_val, node):
+            return
+
+        if node.id not in self._scope:
+            raise ClassiqExpansionError(f"Variable {node.id!r} is undefined")
+        eval_name(self._expr_val, node, self._scope[node.id])
+
+    def visit_List(self, node: ast.List) -> None:
+        super().generic_visit(node)
+        eval_list(self._expr_val, node)
+
+
+def evaluate_qmod_expression(
+    expr: str,
+    *,
+    machine_precision: int = DEFAULT_MACHINE_PRECISION,
+    classical_struct_declarations: Optional[Sequence[StructDeclaration]] = None,
+    enum_declarations: Optional[Sequence[EnumDeclaration]] = None,
+    classical_function_declarations: Optional[
+        Sequence[ClassicalFunctionDeclaration]
+    ] = None,
+    classical_function_callables: Optional[Mapping[str, Callable]] = None,
+    scope: Optional[dict[str, Any]] = None,
+) -> QmodAnnotatedExpression:
+    expr_ast = ast.parse(expr, mode="eval").body
+    expr_value = QmodAnnotatedExpression(expr_ast)
+    QmodExpressionEvaluator(
+        expr_value,
+        machine_precision=machine_precision,
+        classical_struct_declarations=classical_struct_declarations,
+        enum_declarations=enum_declarations,
+        classical_function_declarations=classical_function_declarations,
+        classical_function_callables=classical_function_callables,
+        scope=scope,
+    ).visit(expr_value.root)
+    return expr_value

classiq/evaluators/qmod_expression_visitors/qmod_expression_renamer.py

@@ -0,0 +1,44 @@
+from typing import Optional
+
+from classiq.interface.model.handle_binding import HandleBinding, NestedHandleBinding
+
+from classiq.evaluators.qmod_annotated_expression import (
+    QmodAnnotatedExpression,
+    QmodExprNodeId,
+)
+
+
+def rename_handles_in_expression(
+    expr_val: QmodAnnotatedExpression,
+    renaming: dict[HandleBinding, HandleBinding],
+) -> str:
+    if len(renaming) == 0:
+        return expr_val.to_qmod_expr()
+    all_vars = expr_val.get_classical_vars() | expr_val.get_quantum_vars()
+    for node_id, var in all_vars.items():
+        renamed_var = _rename_var(renaming, var)
+        if renamed_var is not None:
+            expr_val.set_var(node_id, renamed_var)
+    return expr_val.to_qmod_expr()
+
+
+def _rename_var(
+    renaming: dict[HandleBinding, HandleBinding], var: HandleBinding
+) -> Optional[HandleBinding]:
+    if (renamed_var := renaming.get(var)) is not None:
+        return renamed_var
+    if not isinstance(var, NestedHandleBinding):
+        return None
+    renamed_inner = _rename_var(renaming, var.base_handle)
+    if renamed_inner is None:
+        return None
+    return var.model_copy(update=dict(base_handle=renamed_inner))
+
+
+def rename_nodes_in_expression(
+    expr_val: QmodAnnotatedExpression,
+    renaming: dict[QmodExprNodeId, HandleBinding],
+) -> str:
+    for node_id, renamed_var in renaming.items():
+        expr_val.set_var(node_id, renamed_var)
+    return expr_val.to_qmod_expr()

classiq/evaluators/qmod_expression_visitors/qmod_expression_simplifier.py

@@ -0,0 +1,308 @@
+import ast
+from typing import Any, Optional, cast
+
+import sympy
+
+from classiq.interface.exceptions import ClassiqInternalExpansionError
+from classiq.interface.generator.arith.arithmetic import compute_arithmetic_result_type
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.model.handle_binding import HandleBinding
+from classiq.interface.model.quantum_type import (
+    QuantumBit,
+    QuantumNumeric,
+    QuantumType,
+)
+
+from classiq.evaluators.qmod_annotated_expression import (
+    QmodAnnotatedExpression,
+    QmodExprNodeId,
+)
+from classiq.evaluators.qmod_expression_visitors.sympy_wrappers import (
+    BitwiseAnd,
+    BitwiseNot,
+    BitwiseOr,
+    BitwiseXor,
+    LShift,
+    RShift,
+)
+from classiq.evaluators.qmod_node_evaluators.utils import QmodType
+
+_SYMPY_WRAPPERS = {
+    wrapper.__name__: wrapper
+    for wrapper in [
+        BitwiseAnd,
+        BitwiseNot,
+        BitwiseOr,
+        BitwiseXor,
+        LShift,
+        RShift,
+    ]
+}
+
+
+class _VarMaskTransformer(ast.NodeTransformer):
+    def __init__(self, expr_val: QmodAnnotatedExpression) -> None:
+        self._expr_val = expr_val
+        self._mask_id = 0
+        self.masks: dict[str, QmodExprNodeId] = {}
+        self._assigned_masks: dict[HandleBinding, str] = {}
+
+    def _create_mask(self) -> str:
+        mask = f"x{self._mask_id}"
+        self._mask_id += 1
+        return mask
+
+    def visit(self, node: ast.AST) -> ast.AST:
+        if self._expr_val.has_value(node):
+            return ast.parse(str(self._expr_val.get_value(node)))
+        if self._expr_val.has_var(node):
+            var = self._expr_val.get_var(node)
+            if var in self._assigned_masks:
+                mask = self._assigned_masks[var]
+            else:
+                mask = self._create_mask()
+                self._assigned_masks[var] = mask
+                self.masks[mask] = id(node)
+            return ast.Name(id=mask)
+        if self._expr_val.has_quantum_subscript(node):
+            mask = self._create_mask()
+            self.masks[mask] = id(node)
+            return ast.Name(id=mask)
+        return self.generic_visit(node)
+
+    def visit_Subscript(self, node: ast.Subscript) -> ast.AST:
+        mask = self._create_mask()
+        self.masks[mask] = id(node)
+        return ast.Name(id=mask)
+
+
+class _InverseVarMaskTransformer(ast.NodeTransformer):
+    def __init__(
+        self, expr_val: QmodAnnotatedExpression, masks: dict[str, QmodExprNodeId]
+    ) -> None:
+        self._expr_val = expr_val
+        self._masks = masks
+
+    def visit_Name(self, node: ast.Name) -> Any:
+        name = node.id
+        if name in self._masks:
+            mask_id = self._masks[name]
+            if not self._expr_val.has_node(mask_id):
+                raise ClassiqInternalExpansionError
+            return ast.Name(id=ast.unparse(self._expr_val.get_node(mask_id)))
+        return node
+
+
+class _SympyCompatibilityTransformer(ast.NodeTransformer):
+    def visit_BoolOp(self, node: ast.BoolOp) -> ast.Call:
+        if len(node.values) != 2:
+            raise ClassiqInternalExpansionError
+        node = cast(ast.BoolOp, self.generic_visit(node))
+        if isinstance(node.op, ast.Or):
+            sympy_func = "Or"
+        else:
+            sympy_func = "And"
+        return ast.Call(func=ast.Name(id=sympy_func), args=node.values, keywords=[])
+
+    def visit_UnaryOp(self, node: ast.UnaryOp) -> Any:
+        node = cast(ast.UnaryOp, self.generic_visit(node))
+        if isinstance(node.op, ast.Not):
+            sympy_func = "Not"
+        elif isinstance(node.op, ast.Invert):
+            sympy_func = BitwiseNot.__name__
+        else:
+            return node
+        return ast.Call(func=ast.Name(id=sympy_func), args=[node.operand], keywords=[])
+
+    def visit_Compare(self, node: ast.Compare) -> ast.Call:
+        if len(node.ops) != 1:
+            raise ClassiqInternalExpansionError
+        node = cast(ast.Compare, self.generic_visit(node))
+        op = node.ops[0]
+        if isinstance(op, ast.Eq):
+            sympy_func = "Eq"
+        elif isinstance(op, ast.NotEq):
+            sympy_func = "Ne"
+        elif isinstance(op, ast.Lt):
+            sympy_func = "Lt"
+        elif isinstance(op, ast.LtE):
+            sympy_func = "Le"
+        elif isinstance(op, ast.Gt):
+            sympy_func = "Gt"
+        elif isinstance(op, ast.GtE):
+            sympy_func = "Ge"
+        else:
+            raise ClassiqInternalExpansionError
+        return ast.Call(
+            func=ast.Name(id=sympy_func),
+            args=[node.left, node.comparators[0]],
+            keywords=[],
+        )
+
+    def visit_BinOp(self, node: ast.BinOp) -> Any:
+        node = cast(ast.BinOp, self.generic_visit(node))
+        if isinstance(node.op, ast.LShift):
+            sympy_func = LShift.__name__
+        elif isinstance(node.op, ast.RShift):
+            sympy_func = RShift.__name__
+        elif isinstance(node.op, ast.BitOr):
+            sympy_func = BitwiseOr.__name__
+        elif isinstance(node.op, ast.BitXor):
+            sympy_func = BitwiseXor.__name__
+        elif isinstance(node.op, ast.BitAnd):
+            sympy_func = BitwiseAnd.__name__
+        else:
+            return node
+        return ast.Call(
+            func=ast.Name(id=sympy_func), args=[node.left, node.right], keywords=[]
+        )
+
+
+class _InverseSympyCompatibilityTransformer(ast.NodeTransformer):
+    def visit_Call(self, node: ast.Call) -> Any:
+        node = cast(ast.Call, self.generic_visit(node))
+        if not isinstance(node.func, ast.Name):
+            raise ClassiqInternalExpansionError
+        func = node.func.id
+
+        if (
+            func
+            in {
+                "Eq",
+                "Ne",
+                "Lt",
+                "Le",
+                "Gt",
+                "Ge",
+                LShift.__name__,
+                RShift.__name__,
+                BitwiseOr.__name__,
+                BitwiseXor.__name__,
+                BitwiseAnd.__name__,
+            }
+            and (len(node.args) != 2 or len(node.keywords) > 0)
+        ) or (
+            func in {BitwiseNot.__name__}
+            and (len(node.args) != 2 or len(node.keywords) > 0)
+        ):
+            raise ClassiqInternalExpansionError
+
+        if func == BitwiseNot.__name__:
+            return ast.UnaryOp(op=ast.Invert, operand=node.args[0])
+
+        if func == "Eq":
+            return ast.Compare(
+                left=node.args[0], ops=[ast.Eq()], comparators=[node.args[1]]
+            )
+        if func == "Ne":
+            return ast.Compare(
+                left=node.args[0], ops=[ast.NotEq()], comparators=[node.args[1]]
+            )
+        if func == "Lt":
+            return ast.Compare(
+                left=node.args[0], ops=[ast.Lt()], comparators=[node.args[1]]
+            )
+        if func == "Le":
+            return ast.Compare(
+                left=node.args[0], ops=[ast.LtE()], comparators=[node.args[1]]
+            )
+        if func == "Gt":
+            return ast.Compare(
+                left=node.args[0], ops=[ast.Gt()], comparators=[node.args[1]]
+            )
+        if func == "GtE":
+            return ast.Compare(
+                left=node.args[0], ops=[ast.GtE()], comparators=[node.args[1]]
+            )
+
+        if func == LShift.__name__:
+            return ast.BinOp(left=node.args[0], op=ast.LShift(), right=node.args[1])
+        if func == RShift.__name__:
+            return ast.BinOp(left=node.args[0], op=ast.RShift(), right=node.args[1])
+        if func == BitwiseOr.__name__:
+            return ast.BinOp(left=node.args[0], op=ast.BitOr(), right=node.args[1])
+        if func == BitwiseXor.__name__:
+            return ast.BinOp(left=node.args[0], op=ast.BitXor(), right=node.args[1])
+        if func == BitwiseAnd.__name__:
+            return ast.BinOp(left=node.args[0], op=ast.BitAnd(), right=node.args[1])
+
+        return node
+
+    def visit_UnaryOp(self, node: ast.UnaryOp) -> Any:
+        node = cast(ast.UnaryOp, self.generic_visit(node))
+
+        if isinstance(node.op, ast.Invert):
+            return ast.UnaryOp(op=ast.Not(), operand=node.operand)
+
+        return node
+
+    def visit_BinOp(self, node: ast.BinOp) -> Any:
+        node = cast(ast.BinOp, self.generic_visit(node))
+
+        if isinstance(node.op, ast.BitOr):
+            return ast.BoolOp(op=ast.Or(), values=[node.left, node.right])
+        if isinstance(node.op, ast.BitAnd):
+            return ast.BoolOp(op=ast.And(), values=[node.left, node.right])
+
+        return node
+
+
+def _get_numeric_type(
+    expr_val: QmodAnnotatedExpression,
+    expr_type: QmodType,
+    simplified_expr: str,
+    masks: dict[str, QmodExprNodeId],
+    machine_precision: int,
+) -> Optional[QuantumNumeric]:
+    if isinstance(expr_type, QuantumBit):
+        return QuantumNumeric(
+            size=Expression(expr="1"),
+            is_signed=Expression(expr="False"),
+            fraction_digits=Expression(expr="0"),
+        )
+    if not isinstance(expr_type, QuantumNumeric):
+        return None
+    if expr_type.is_evaluated:
+        return expr_type
+    var_types = {
+        var_name: expr_val.get_type(node_id) for var_name, node_id in masks.items()
+    }
+    if not all(
+        isinstance(var_type, QuantumBit)
+        or (isinstance(var_type, QuantumNumeric) and var_type.is_instantiated)
+        for var_type in var_types.values()
+    ):
+        return None
+    return compute_arithmetic_result_type(
+        simplified_expr, cast(dict[str, QuantumType], var_types), machine_precision
+    )
+
+
+def simplify_qmod_expression(
+    expr_val: QmodAnnotatedExpression, machine_precision: int
+) -> tuple[str, Optional[QuantumNumeric]]:
+    if expr_val.has_value(expr_val.root):
+        raise ClassiqInternalExpansionError(
+            "This expression is a constant value. No need for simplification"
+        )
+    var_mask_transformer = _VarMaskTransformer(expr_val)
+    masks = var_mask_transformer.masks
+    mask_expr = var_mask_transformer.visit(expr_val.root)
+    sympy_expr = _SympyCompatibilityTransformer().visit(mask_expr)
+    simplified_expr = str(
+        sympy.sympify(ast.unparse(sympy_expr), locals=_SYMPY_WRAPPERS)
+    )
+    restored_expr = _InverseSympyCompatibilityTransformer().visit(
+        ast.parse(simplified_expr, mode="eval")
+    )
+    expr_type = _get_numeric_type(
+        expr_val,
+        expr_val.get_type(expr_val.root),
+        ast.unparse(restored_expr),
+        masks,
+        machine_precision,
+    )
+    restored_expr = _InverseVarMaskTransformer(
+        expr_val, var_mask_transformer.masks
+    ).visit(restored_expr)
+    return ast.unparse(restored_expr), expr_type

classiq/evaluators/qmod_node_evaluators/attribute_evaluation.py

@@ -0,0 +1,112 @@
+import ast
+from collections.abc import Mapping
+
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
+    QmodStructInstance,
+)
+from classiq.interface.generator.functions.classical_type import (
+    Bool,
+    ClassicalArray,
+    ClassicalTuple,
+    Integer,
+)
+from classiq.interface.generator.functions.type_name import TypeName
+from classiq.interface.model.handle_binding import FieldHandleBinding
+from classiq.interface.model.quantum_type import (
+    QuantumBitvector,
+    QuantumNumeric,
+    QuantumType,
+)
+
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
+from classiq.evaluators.qmod_node_evaluators.utils import QmodType, get_qmod_type_name
+
+
+def _eval_type_attribute(
+    expr_val: QmodAnnotatedExpression, node: ast.Attribute
+) -> None:
+    subject = node.value
+    attr = node.attr
+
+    subject_type = expr_val.get_type(subject)
+    if isinstance(subject_type, QuantumType) and attr == "size":
+        expr_val.set_type(node, Integer())
+        if subject_type.has_size_in_bits:
+            expr_val.set_value(node, subject_type.size_in_bits)
+        else:
+            expr_val.set_quantum_type_attr(node, subject, attr)
+        return
+    if isinstance(subject_type, (ClassicalArray, QuantumBitvector)) and attr == "len":
+        expr_val.set_type(node, Integer())
+        if subject_type.has_length:
+            expr_val.set_value(node, subject_type.length_value)
+        elif isinstance(subject_type, QuantumType):
+            expr_val.set_quantum_type_attr(node, subject, attr)
+        return
+    if isinstance(subject_type, ClassicalTuple) and attr == "len":
+        expr_val.set_type(node, Integer())
+        expr_val.set_value(node, len(subject_type.element_types))
+        return
+    if isinstance(subject_type, QuantumNumeric):
+        if attr == "is_signed":
+            expr_val.set_type(node, Bool())
+            if subject_type.has_sign:
+                expr_val.set_value(node, subject_type.sign_value)
+            elif subject_type.has_size_in_bits:
+                expr_val.set_value(node, False)
+            else:
+                expr_val.set_quantum_type_attr(node, subject, attr)
+            return
+        if attr == "fraction_digits":
+            expr_val.set_type(node, Integer())
+            if subject_type.has_fraction_digits:
+                expr_val.set_value(node, subject_type.fraction_digits_value)
+            elif subject_type.has_size_in_bits:
+                expr_val.set_value(node, 0)
+            else:
+                expr_val.set_quantum_type_attr(node, subject, attr)
+            return
+    raise ClassiqExpansionError(
+        f"{get_qmod_type_name(subject_type)} has no attribute {attr!r}"
+    )
+
+
+def eval_attribute(expr_val: QmodAnnotatedExpression, node: ast.Attribute) -> None:
+    subject = node.value
+    attr = node.attr
+
+    subject_type = expr_val.get_type(subject)
+    if not isinstance(subject_type, TypeName) or (
+        subject_type.has_fields and attr == "size"
+    ):
+        _eval_type_attribute(expr_val, node)
+        return
+    subject_fields: Mapping[str, QmodType]
+    if subject_type.has_classical_struct_decl:
+        subject_fields = subject_type.classical_struct_decl.variables
+    elif subject_type.has_fields:
+        subject_fields = subject_type.fields
+    else:
+        raise ClassiqInternalExpansionError
+    if attr not in subject_fields:
+        raise ClassiqExpansionError(
+            f"{get_qmod_type_name(subject_type)} has no field {attr!r}"
+        )
+    expr_val.set_type(node, subject_fields[attr])
+
+    if expr_val.has_value(subject):
+        subject_value = expr_val.get_value(subject)
+        if (
+            not isinstance(subject_value, QmodStructInstance)
+            or attr not in subject_value.fields
+        ):
+            raise ClassiqInternalExpansionError
+        expr_val.set_value(node, subject_value.fields[attr])
+    elif expr_val.has_var(subject):
+        subject_var = expr_val.get_var(subject)
+        expr_val.set_var(node, FieldHandleBinding(base_handle=subject_var, field=attr))
+        expr_val.remove_var(subject)