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

classiq/evaluators/qmod_node_evaluators/classical_function_evaluation.py

@@ -0,0 +1,311 @@
+import ast
+from typing import Any, Callable, Optional, Union, cast
+
+import sympy
+
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.generator.functions.classical_function_declaration import (
+    ClassicalFunctionDeclaration,
+)
+from classiq.interface.generator.functions.classical_type import (
+    Bool,
+    ClassicalArray,
+    ClassicalTuple,
+    ClassicalType,
+    Integer,
+    Real,
+)
+from classiq.interface.generator.functions.type_name import TypeName
+from classiq.interface.helpers.backward_compatibility import zip_strict
+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.utils import (
+    SYMPY_SYMBOLS,
+    QmodType,
+    array_len,
+    element_types,
+    get_qmod_type_name,
+)
+
+MIN_MAX_FUNCTION_NAMES = {"min", "Min", "max", "Max"}
+
+
+def _check_classical_array_arg_type(
+    param_type: Union[ClassicalArray, ClassicalTuple], arg_type: ClassicalType
+) -> bool:
+    if not isinstance(arg_type, (ClassicalArray, ClassicalTuple)):
+        return False
+    param_len = array_len(param_type)
+    arg_len = array_len(arg_type)
+    if param_len is not None and arg_len is not None and param_len != arg_len:
+        return False
+    if isinstance(param_type, ClassicalArray):
+        if isinstance(arg_type, ClassicalArray):
+            return check_classical_arg_type(
+                param_type.element_type, arg_type.element_type
+            )
+        return all(
+            check_classical_arg_type(param_type.element_type, arg_element_type)
+            for arg_element_type in arg_type.element_types
+        )
+    if isinstance(arg_type, ClassicalArray):
+        return all(
+            check_classical_arg_type(param_element_type, arg_type.element_type)
+            for param_element_type in param_type.element_types
+        )
+    return all(
+        check_classical_arg_type(param_element_type, arg_element_type)
+        for param_element_type, arg_element_type in zip_strict(
+            param_type.element_types, arg_type.element_types, strict=True
+        )
+    )
+
+
+def check_classical_arg_type(
+    param_type: ClassicalType, arg_type: ClassicalType
+) -> bool:
+    if isinstance(param_type, (Integer, Real)):
+        return isinstance(arg_type, (Integer, Real))
+    if isinstance(param_type, Bool):
+        return isinstance(arg_type, Bool)
+    if isinstance(param_type, (ClassicalArray, ClassicalTuple)):
+        return _check_classical_array_arg_type(param_type, arg_type)
+    if not isinstance(param_type, TypeName):
+        raise ClassiqInternalExpansionError
+    if not isinstance(arg_type, TypeName):
+        return False
+    if param_type.is_enum or param_type.has_classical_struct_decl:
+        return arg_type.name == param_type.name
+    raise ClassiqInternalExpansionError
+
+
+def _check_classical_arg(
+    func_name: str, param_name: str, param_type: ClassicalType, arg_type: QmodType
+) -> None:
+    if not isinstance(arg_type, ClassicalType) or not check_classical_arg_type(
+        param_type, arg_type
+    ):
+        raise ClassiqExpansionError(
+            f"Parameter {param_name!r} of function {func_name!r} expects a "
+            f"{get_qmod_type_name(param_type)} argument, but got a "
+            f"{get_qmod_type_name(arg_type)}"
+        )
+
+
+def check_classical_func_call(
+    expr_val: QmodAnnotatedExpression,
+    node: ast.Call,
+    decl: ClassicalFunctionDeclaration,
+) -> None:
+    expected_num_args = len(decl.param_decls)
+    actual_num_args = len(node.args) + len(node.keywords)
+    if expected_num_args != actual_num_args:
+        raise ClassiqExpansionError(
+            f"Function {decl.name!r} takes {expected_num_args} arguments but "
+            f"{actual_num_args} were given"
+        )
+    params = list(decl.param_decls)
+    assigned_params: set[str] = set()
+    for arg in node.args:
+        param = params.pop(0)
+        assigned_params.add(param.name)
+        _check_classical_arg(
+            decl.name, param.name, param.classical_type, expr_val.get_type(arg)
+        )
+    remaining_params = nameables_to_dict(params)
+    for kwarg in node.keywords:
+        if kwarg.arg is None:
+            raise ClassiqExpansionError("Star argument syntax is not supported")
+        if kwarg.arg not in remaining_params:
+            if kwarg.arg in assigned_params:
+                raise ClassiqExpansionError(
+                    f"Function {decl.name!r} got multiple values for parameter "
+                    f"{kwarg.arg!r}"
+                )
+            raise ClassiqExpansionError(
+                f"Function {decl.name!r} has no parameter named {kwarg.arg}"
+            )
+        assigned_params.add(kwarg.arg)
+        param = remaining_params.pop(kwarg.arg)
+        _check_classical_arg(
+            decl.name, param.name, param.classical_type, expr_val.get_type(kwarg.value)
+        )
+
+
+def eval_symbolic_function(
+    expr_val: QmodAnnotatedExpression,
+    node: ast.Call,
+    decl: ClassicalFunctionDeclaration,
+) -> None:
+    check_classical_func_call(expr_val, node, decl)
+    if decl.return_type is None:
+        raise ClassiqInternalExpansionError
+    expr_val.set_type(node, decl.return_type)
+
+
+def eval_function(
+    expr_val: QmodAnnotatedExpression,
+    node: ast.Call,
+    decl: ClassicalFunctionDeclaration,
+    func: Callable,
+) -> None:
+    eval_symbolic_function(expr_val, node, decl)
+
+    args = node.args
+    kwargs = {kwarg.arg: kwarg.value for kwarg in node.keywords}
+    if None in kwargs:
+        raise ClassiqInternalExpansionError
+    if not all(expr_val.has_value(arg) for arg in args) or not all(
+        expr_val.has_value(kwarg) for kwarg in kwargs.values()
+    ):
+        return
+    arg_values = [expr_val.get_value(arg) for arg in args]
+    kwarg_values = {
+        cast(str, kwarg_name): expr_val.get_value(kwarg_value)
+        for kwarg_name, kwarg_value in kwargs.items()
+    }
+    expr_val.set_value(node, func(*arg_values, **kwarg_values))
+
+
+def try_eval_sympy_function(
+    expr_val: QmodAnnotatedExpression, node: ast.Call, func_name: str
+) -> bool:
+    sympy_func = SYMPY_SYMBOLS.get(func_name)
+    if not isinstance(sympy_func, sympy.FunctionClass):
+        return False
+    _validate_no_kwargs(node)
+    args: Optional[list[Any]] = None
+    sympy_ret_val: Any = None
+    if all(expr_val.has_value(arg) for arg in node.args):
+        args = [expr_val.get_value(arg) for arg in node.args]
+        sympy_ret_val = sympy_func(*args)
+        if not isinstance(sympy_ret_val, sympy.Expr):
+            raise ClassiqInternalExpansionError
+    ret_type: QmodType
+    ret_val: Any = None
+    if hasattr(sympy_func, "is_Boolean") and sympy_func.is_Boolean:
+        ret_type = Bool()
+        if args is not None:
+            ret_val = bool(sympy_ret_val)
+    elif hasattr(sympy_func, "is_Integer") and sympy_func.is_Integer:
+        ret_type = Integer()
+        if args is not None:
+            ret_val = int(sympy_ret_val)
+    else:
+        ret_type = Real()
+        if sympy_ret_val is not None:
+            if sympy_ret_val.is_imaginary:
+                ret_val = complex(sympy_ret_val)
+            elif sympy_ret_val.is_real:
+                ret_val = float(sympy_ret_val)
+            else:
+                raise ClassiqInternalExpansionError
+    expr_val.set_type(node, ret_type)
+    if ret_val is not None:
+        expr_val.set_value(node, ret_val)
+    return True
+
+
+def try_eval_builtin_function(
+    expr_val: QmodAnnotatedExpression, node: ast.Call, func_name: str
+) -> bool:
+    args_are_int = all(isinstance(expr_val.get_type(arg), Integer) for arg in node.args)
+    args_are_real = all(
+        isinstance(expr_val.get_type(arg), (Integer, Real)) for arg in node.args
+    )
+    arg_is_int_list = (
+        len(node.args) == 1
+        and isinstance(
+            arg_type := expr_val.get_type(node.args[0]),
+            (ClassicalArray, ClassicalTuple),
+        )
+        and all(
+            isinstance(element_type, Integer)
+            for element_type in element_types(arg_type)
+        )
+    )
+    arg_is_real_list = (
+        len(node.args) == 1
+        and isinstance(
+            arg_type := expr_val.get_type(node.args[0]),
+            (ClassicalArray, ClassicalTuple),
+        )
+        and all(
+            isinstance(element_type, (Integer, Real))
+            for element_type in element_types(arg_type)
+        )
+    )
+    args_have_values = all(expr_val.has_value(arg) for arg in node.args)
+
+    if func_name in MIN_MAX_FUNCTION_NAMES:
+        if not try_eval_sympy_function(expr_val, node, func_name.capitalize()):
+            return False
+        if args_are_int:
+            expr_val.set_type(node, Integer())
+            if expr_val.has_value(node):
+                expr_val.set_value(node, int(expr_val.get_value(node)))
+        return True
+
+    if func_name == "mod_inverse":
+        _validate_no_kwargs(node)
+        ret_type: QmodType
+        if args_are_int:
+            ret_type = Integer()
+        elif args_are_real:
+            ret_type = Real()
+        else:
+            raise ClassiqExpansionError(
+                "Function 'mod_inverse' expects numeric arguments"
+            )
+        expr_val.set_type(node, ret_type)
+        if args_have_values:
+            sympy_val = sympy.mod_inverse(
+                *[expr_val.get_value(arg) for arg in node.args]
+            )
+            ret_val: Any
+            if args_are_int:
+                ret_val = int(sympy_val)
+            elif isinstance(sympy_val, sympy.Expr) and sympy_val.is_imaginary:
+                ret_val = complex(sympy_val)
+            else:
+                ret_val = float(sympy_val)
+            expr_val.set_value(node, ret_val)
+        return True
+
+    if func_name == "sum":
+        _validate_no_kwargs(node)
+        if arg_is_int_list:
+            ret_type = Integer()
+        elif arg_is_real_list:
+            ret_type = Real()
+        else:
+            raise ClassiqExpansionError("Function 'sum' expects numeric arguments")
+        expr_val.set_type(node, ret_type)
+        if args_have_values:
+            expr_val.set_value(node, sum(expr_val.get_value(node.args[0])))
+        return True
+
+    if func_name == "sqrt":
+        _validate_no_kwargs(node)
+        expr_val.set_type(node, Real())
+        if args_have_values:
+            expr_val.set_value(
+                node, sympy.sqrt(*[expr_val.get_value(arg) for arg in node.args])
+            )
+        return True
+
+    return False
+
+
+def _validate_no_kwargs(node: ast.Call) -> None:
+    if not isinstance(node.func, ast.Name):
+        raise ClassiqInternalExpansionError
+    if len(node.keywords) > 0:
+        raise ClassiqExpansionError(
+            f"Keyword argument syntax is not supported for built-in function "
+            f"{node.func.id!r}"
+        )

classiq/evaluators/qmod_node_evaluators/compare_evaluation.py

@@ -0,0 +1,107 @@
+import ast
+
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.generator.functions.classical_type import (
+    Bool,
+    ClassicalArray,
+    ClassicalTuple,
+    Integer,
+    Real,
+)
+from classiq.interface.generator.functions.type_name import TypeName
+from classiq.interface.model.quantum_type import (
+    QuantumBit,
+    QuantumNumeric,
+    QuantumScalar,
+)
+
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
+from classiq.evaluators.qmod_node_evaluators.list_evaluation import list_allowed
+from classiq.evaluators.qmod_node_evaluators.utils import (
+    QmodType,
+    element_types,
+    get_qmod_type_name,
+    is_classical_integer,
+    is_classical_type,
+    qnum_is_qbit,
+)
+
+
+def comparison_allowed(
+    left: QmodType, right: QmodType, inequality: bool = False
+) -> bool:
+    if isinstance(left, Bool):
+        return isinstance(right, (Bool, QuantumBit)) or (
+            isinstance(right, QuantumNumeric) and qnum_is_qbit(right)
+        )
+    if isinstance(left, Real) or is_classical_integer(left):
+        return isinstance(right, (Real, QuantumScalar)) or is_classical_integer(right)
+    if isinstance(left, (ClassicalArray, ClassicalTuple)):
+        if inequality:
+            return False
+        if not isinstance(right, (ClassicalArray, ClassicalTuple)):
+            return False
+        return list_allowed(element_types(left) + element_types(right))
+    if isinstance(left, TypeName):
+        return (
+            left.has_classical_struct_decl
+            and not inequality
+            and isinstance(right, TypeName)
+            and left.name == right.name
+        ) or (
+            left.is_enum
+            and (
+                isinstance(right, (Integer, Real, QuantumScalar))
+                or (isinstance(right, TypeName) and right.is_enum)
+            )
+        )
+    if isinstance(left, QuantumScalar):
+        return isinstance(right, (Bool, Real, QuantumScalar)) or is_classical_integer(
+            right
+        )
+    raise ClassiqInternalExpansionError
+
+
+def eval_compare(expr_val: QmodAnnotatedExpression, node: ast.Compare) -> None:
+    left = node.left
+    if len(node.ops) != 1 or len(node.comparators) != 1:
+        raise ClassiqExpansionError("Multi-compare expressions are not supported")
+    right = node.comparators[0]
+    op = node.ops[0]
+
+    left_type = expr_val.get_type(left)
+    right_type = expr_val.get_type(right)
+    if not comparison_allowed(left_type, right_type, not isinstance(op, ast.Eq)):
+        raise ClassiqExpansionError(
+            f"Cannot compare {get_qmod_type_name(left_type)} {ast.unparse(left)!r} "
+            f"and {get_qmod_type_name(right_type)} {ast.unparse(right)!r}"
+        )
+    qmod_type: QmodType
+    if not is_classical_type(left_type) or not is_classical_type(right_type):
+        qmod_type = QuantumBit()
+    else:
+        qmod_type = Bool()
+    expr_val.set_type(node, qmod_type)
+
+    if not expr_val.has_value(left) or not expr_val.has_value(right):
+        return
+
+    left_value = expr_val.get_value(left)
+    right_value = expr_val.get_value(right)
+    if isinstance(op, ast.Eq):
+        expr_val.set_value(node, left_value == right_value)
+    elif isinstance(op, ast.NotEq):
+        expr_val.set_value(node, left_value != right_value)
+    elif isinstance(op, ast.Lt):
+        expr_val.set_value(node, left_value < right_value)
+    elif isinstance(op, ast.Gt):
+        expr_val.set_value(node, left_value > right_value)
+    elif isinstance(op, ast.LtE):
+        expr_val.set_value(node, left_value <= right_value)
+    elif isinstance(op, ast.GtE):
+        expr_val.set_value(node, left_value >= right_value)
+    else:
+        raise ClassiqExpansionError(f"Unsupported comparison {type(op).__name__!r}")

classiq/evaluators/qmod_node_evaluators/constant_evaluation.py

@@ -0,0 +1,67 @@
+import ast
+from enum import IntEnum
+from typing import Any
+
+import sympy
+
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+)
+from classiq.interface.generator.functions.classical_type import Bool, Integer, Real
+from classiq.interface.generator.functions.type_name import Enum
+
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
+from classiq.evaluators.qmod_node_evaluators.utils import SYMPY_SYMBOLS, QmodType
+
+
+def eval_enum_member(
+    expr_val: QmodAnnotatedExpression, node: ast.Attribute, enum: type[IntEnum]
+) -> None:
+    enum_name = enum.__name__
+    enum_members = {  # type: ignore[var-annotated]
+        member.name: member for member in list(enum)
+    }
+    attr = node.attr
+    if attr not in enum_members:
+        raise ClassiqExpansionError(f"Enum {enum_name} has no member named {attr!r}")
+
+    expr_val.set_type(node, Enum(name=enum_name))
+    expr_val.set_value(node, enum_members[attr])
+
+
+def eval_constant(expr_val: QmodAnnotatedExpression, node: ast.Constant) -> None:
+    value = node.value
+    expr_val.set_value(node, value)
+    constant_type: QmodType
+    if isinstance(value, bool):
+        constant_type = Bool()
+    elif isinstance(value, int):
+        constant_type = Integer()
+    elif isinstance(value, (float, complex)):
+        constant_type = Real()
+    else:
+        raise ClassiqExpansionError(f"Unsupported constant {str(value)!r}")
+    expr_val.set_type(node, constant_type)
+
+
+def try_eval_sympy_constant(expr_val: QmodAnnotatedExpression, node: ast.Name) -> bool:
+    sympy_val = SYMPY_SYMBOLS.get(node.id)
+    if not isinstance(sympy_val, sympy.Expr) or not sympy_val.is_constant():
+        return False
+    constant_type: QmodType
+    constant_value: Any
+    if sympy_val.is_Integer:
+        constant_type = Integer()
+        constant_value = int(sympy_val)
+    elif sympy_val.is_Boolean:
+        constant_type = Bool()
+        constant_value = bool(sympy_val)
+    elif sympy_val.is_imaginary:
+        constant_type = Real()
+        constant_value = complex(sympy_val)
+    else:
+        constant_type = Real()
+        constant_value = float(sympy_val)
+    expr_val.set_type(node, constant_type)
+    expr_val.set_value(node, constant_value)
+    return True

classiq/evaluators/qmod_node_evaluators/list_evaluation.py

@@ -0,0 +1,107 @@
+import ast
+from typing import Optional, cast
+
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+)
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.classical_type import (
+    Bool,
+    ClassicalArray,
+    ClassicalTuple,
+    ClassicalType,
+    Real,
+)
+from classiq.interface.generator.functions.type_name import TypeName
+from classiq.interface.model.quantum_type import QuantumBitvector, QuantumType
+
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
+from classiq.evaluators.qmod_node_evaluators.utils import (
+    element_types,
+    is_classical_integer,
+    is_classical_type,
+)
+
+
+def _list_allowed(left: ClassicalType, right: ClassicalType) -> bool:
+    for type_1, type_2 in ((left, right), (right, left)):
+        if isinstance(type_1, Real) or is_classical_integer(type_1):
+            return isinstance(type_2, Real) or is_classical_integer(type_2)
+
+    if isinstance(left, Bool):
+        return isinstance(right, Bool)
+
+    if isinstance(left, (ClassicalArray, ClassicalTuple)) and isinstance(
+        right, (ClassicalArray, ClassicalTuple)
+    ):
+        return list_allowed(element_types(left) + element_types(right))
+
+    if isinstance(left, TypeName) and left.has_classical_struct_decl:
+        return isinstance(right, TypeName) and left.name == right.name
+
+    return False
+
+
+def _has_empty_tuple(classical_type: ClassicalType) -> bool:
+    if isinstance(classical_type, ClassicalArray):
+        return _has_empty_tuple(classical_type.element_type)
+    if isinstance(classical_type, ClassicalTuple):
+        return len(classical_type.element_types) == 0 or any(
+            _has_empty_tuple(element_type)
+            for element_type in classical_type.element_types
+        )
+    return False
+
+
+def list_allowed(classical_types: list[ClassicalType]) -> bool:
+    if len(classical_types) < 2:
+        return True
+
+    element_without_empty_tuple: Optional[ClassicalType] = None
+    for classical_type in classical_types:
+        if not _has_empty_tuple(classical_type):
+            element_without_empty_tuple = classical_type
+            break
+
+    if element_without_empty_tuple is not None:
+        return all(
+            element_without_empty_tuple is other_type
+            or _list_allowed(element_without_empty_tuple, other_type)
+            for other_type in classical_types
+        )
+    # FIXME: optimize using ClassicalTuple.raw_type (CLS-3163)
+    return all(
+        element_type is other_type or _list_allowed(classical_types[0], other_type)
+        for i, element_type in enumerate(classical_types[:-1])
+        for other_type in classical_types[i + 1 :]
+    )
+
+
+def eval_list(expr_val: QmodAnnotatedExpression, node: ast.List) -> None:
+    item_types = [expr_val.get_type(item) for item in node.elts]
+    are_classical = [is_classical_type(item_type) for item_type in item_types]
+    all_classical = all(are_classical)
+    all_quantum = not any(are_classical)
+    if not all_classical and not all_quantum:
+        raise ClassiqExpansionError(
+            "Lists cannot contain both classical and quantum expressions"
+        )
+    if len(item_types) > 0 and all_quantum:
+        expr_val.set_concatenation(node, node.elts)
+        if all(
+            cast(QuantumType, item_type).has_size_in_bits for item_type in item_types
+        ):
+            total_size = sum(
+                [cast(QuantumType, item_type).size_in_bits for item_type in item_types]
+            )
+            concat_type = QuantumBitvector(length=Expression(expr=str(total_size)))
+        else:
+            concat_type = QuantumBitvector()
+        expr_val.set_type(node, concat_type)
+        return
+    if not list_allowed(cast(list[ClassicalType], item_types)):
+        raise ClassiqExpansionError("All list items must have the same type")
+
+    if all(expr_val.has_value(item) for item in node.elts):
+        expr_val.set_value(node, [expr_val.get_value(item) for item in node.elts])
+    expr_val.set_type(node, ClassicalTuple(element_types=item_types))

classiq/evaluators/qmod_node_evaluators/measurement_evaluation.py

@@ -0,0 +1,25 @@
+import ast
+
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+)
+from classiq.interface.generator.functions.classical_type import (
+    Bool,
+)
+from classiq.interface.model.quantum_type import QuantumBit
+
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
+from classiq.evaluators.qmod_node_evaluators.utils import (
+    is_classical_type,
+)
+
+
+def eval_measurement(expr_val: QmodAnnotatedExpression, node: ast.Call) -> None:
+    if len(node.args) != 1 or len(node.keywords) != 0:
+        raise ClassiqExpansionError("'measure' expects one positional argument")
+    arg_type = expr_val.get_type(node.args[0])
+    if is_classical_type(arg_type):
+        raise ClassiqExpansionError("'measure' expects a quantum input")
+    if not isinstance(arg_type, QuantumBit):
+        raise ClassiqExpansionError("Currently, 'measure' only supports quantum bits")
+    expr_val.set_type(node, Bool())

classiq/evaluators/qmod_node_evaluators/name_evaluation.py

@@ -0,0 +1,50 @@
+import ast
+from typing import Any
+
+from classiq.interface.exceptions import (
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
+    QmodStructInstance,
+)
+from classiq.interface.generator.functions.classical_type import (
+    Bool,
+    ClassicalTuple,
+    ClassicalType,
+    Integer,
+    Real,
+)
+from classiq.interface.generator.functions.type_name import Struct
+from classiq.interface.model.handle_binding import HandleBinding
+from classiq.interface.model.quantum_type import QuantumType
+
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
+
+
+def _infer_classical_type(value: Any) -> ClassicalType:
+    if isinstance(value, bool):
+        return Bool()
+    if isinstance(value, int):
+        return Integer()
+    if isinstance(value, (float, complex)):
+        return Real()
+    if isinstance(value, list):
+        return ClassicalTuple(
+            element_types=[_infer_classical_type(item) for item in value]
+        )
+    if isinstance(value, QmodStructInstance):
+        classical_type = Struct(name=value.struct_declaration.name)
+        classical_type.set_classical_struct_decl(value.struct_declaration)
+        return classical_type
+    raise ClassiqInternalExpansionError
+
+
+def eval_name(expr_val: QmodAnnotatedExpression, node: ast.Name, value: Any) -> None:
+    if isinstance(value, (bool, int, float, complex, list, QmodStructInstance)):
+        expr_val.set_type(node, _infer_classical_type(value))
+        expr_val.set_value(node, value)
+    elif isinstance(value, (ClassicalType, QuantumType)):
+        expr_val.set_type(node, value)
+        expr_val.set_var(node, HandleBinding(name=node.id))
+    else:
+        raise ClassiqInternalExpansionError