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

classiq/evaluators/argument_types.py

@@ -1,5 +1,6 @@
 from collections.abc import Sequence
 
+from classiq.interface.exceptions import ClassiqExpansionError
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
@@ -8,7 +9,9 @@ from classiq.interface.model.port_declaration import AnonPortDeclaration
 from classiq.interface.model.quantum_function_declaration import AnonPositionalArg
 from classiq.interface.model.quantum_type import QuantumNumeric
 
-from classiq.evaluators.quantum_type_utils import copy_type_information
+from classiq.evaluators.qmod_type_inference.quantum_type_inference import (
+    inject_quantum_type_attributes_inplace,
+)
 from classiq.model_expansions.scope import Evaluated, QuantumVariable
 
 
@@ -36,11 +39,17 @@ def add_information_from_output_arguments(
         if parameter.direction != PortDeclarationDirection.Output:
             continue
 
-        if parameter.quantum_type.is_evaluated:
-            copy_type_information(
-                parameter.quantum_type,
-                argument_as_quantum_symbol.quantum_type,
-                str(argument_as_quantum_symbol),
+        if (
+            parameter.quantum_type.is_evaluated
+            and not inject_quantum_type_attributes_inplace(
+                parameter.quantum_type, argument_as_quantum_symbol.quantum_type
+            )
+        ):
+            raise ClassiqExpansionError(
+                f"Argument {str(argument_as_quantum_symbol)!r} of type "
+                f"{argument_as_quantum_symbol.quantum_type.qmod_type_name} is "
+                f"incompatible with parameter {parameter.name!r} of type "
+                f"{parameter.quantum_type.qmod_type_name}"
             )
 
 

classiq/evaluators/parameter_types.py

@@ -45,11 +45,8 @@ from classiq.evaluators.classical_expression import (
 from classiq.evaluators.classical_type_inference import (
     infer_classical_type,
 )
-from classiq.evaluators.quantum_type_utils import (
-    copy_type_information,
-    set_element_type,
-    set_length,
-    set_size,
+from classiq.evaluators.qmod_type_inference.quantum_type_inference import (
+    inject_quantum_type_attributes,
 )
 from classiq.model_expansions.closure import FunctionClosure
 from classiq.model_expansions.scope import (
@@ -100,7 +97,7 @@ def _update_scope(
     quantum_var = argument.as_type(QuantumVariable)
     casted_argument = _cast(
         parameter.quantum_type,
-        quantum_var.quantum_type,
+        quantum_var,
         parameter.name,
     )
     closure.scope[parameter.name] = Evaluated(
@@ -134,12 +131,17 @@ def _update_operand_signature_environment(
 
 
 def _cast(
-    parameter_type: QuantumType, argument_type: QuantumType, param_name: str
+    parameter_type: QuantumType, argument: QuantumVariable, param_name: str
 ) -> QuantumSymbol:
-    updated_quantum_type = parameter_type.model_copy()
-    _inject_quantum_arg_info_to_type(updated_quantum_type, argument_type, param_name)
+    updated_type = inject_quantum_type_attributes(argument.quantum_type, parameter_type)
+    if updated_type is None:
+        raise ClassiqExpansionError(
+            f"Argument {str(argument)!r} of type "
+            f"{argument.quantum_type.qmod_type_name} is incompatible with parameter "
+            f"{param_name!r} of type {parameter_type.qmod_type_name}"
+        )
     return QuantumSymbol(
-        handle=HandleBinding(name=param_name), quantum_type=updated_quantum_type
+        handle=HandleBinding(name=param_name), quantum_type=updated_type
     )
 
 
@@ -168,11 +170,17 @@ def _evaluate_type_from_arg(
         parameter.quantum_type.model_copy(), inner_scope, parameter.name
     )
     if parameter.direction != PortDeclarationDirection.Output:
-        updated_quantum_type = _inject_quantum_arg_info_to_type(
-            updated_quantum_type,
-            argument.as_type(QuantumVariable).quantum_type,
-            parameter.name,
+        arg_type = argument.as_type(QuantumVariable).quantum_type
+        updated_output_quantum_type = inject_quantum_type_attributes(
+            arg_type, updated_quantum_type
         )
+        if updated_output_quantum_type is None:
+            raise ClassiqExpansionError(
+                f"Argument {str(argument.value)!r} of type "
+                f"{arg_type.qmod_type_name} is incompatible with parameter "
+                f"{parameter.name!r} of type {updated_quantum_type.qmod_type_name}"
+            )
+        updated_quantum_type = updated_output_quantum_type
     return parameter.model_copy(update={"quantum_type": updated_quantum_type})
 
 
@@ -196,7 +204,7 @@ def _evaluate_qarray_in_quantum_symbol(
     new_element_type = evaluate_type_in_quantum_symbol(
         type_to_update.element_type, scope, param_name
     )
-    set_element_type(type_to_update, new_element_type)
+    type_to_update.element_type = new_element_type
     if type_to_update.length is not None:
         new_length = _eval_expr(
             type_to_update.length,
@@ -207,13 +215,26 @@ def _evaluate_qarray_in_quantum_symbol(
             param_name,
         )
         if new_length is not None:
-            set_length(type_to_update, new_length)
+            type_to_update.length = Expression(expr=str(new_length))
     return type_to_update
 
 
 def _evaluate_qnum_in_quantum_symbol(
     type_to_update: QuantumNumeric, scope: Scope, param_name: str
 ) -> QuantumNumeric:
+    if type_to_update.size is None:
+        return type_to_update
+    new_size = _eval_expr(
+        type_to_update.size,
+        scope,
+        int,
+        type_to_update.type_name,
+        "size",
+        param_name,
+    )
+    if new_size is not None:
+        type_to_update.size = Expression(expr=str(new_size))
+
     if type_to_update.is_signed is not None:
         new_is_sign = _eval_expr(
             type_to_update.is_signed,
@@ -225,6 +246,9 @@ def _evaluate_qnum_in_quantum_symbol(
         )
         if new_is_sign is not None:
             type_to_update.is_signed = Expression(expr=str(new_is_sign))
+    else:
+        type_to_update.is_signed = Expression(expr="False")
+
     if type_to_update.fraction_digits is not None:
         new_fraction_digits = _eval_expr(
             type_to_update.fraction_digits,
@@ -236,17 +260,9 @@ def _evaluate_qnum_in_quantum_symbol(
         )
         if new_fraction_digits is not None:
             type_to_update.fraction_digits = Expression(expr=str(new_fraction_digits))
-    if type_to_update.size is not None:
-        new_size = _eval_expr(
-            type_to_update.size,
-            scope,
-            int,
-            type_to_update.type_name,
-            "size",
-            param_name,
-        )
-        if new_size is not None:
-            set_size(type_to_update, new_size, param_name)
+    else:
+        type_to_update.fraction_digits = Expression(expr="0")
+
     return type_to_update
 
 
@@ -302,18 +318,6 @@ def evaluate_types_in_quantum_symbols(
     ]
 
 
-def _inject_quantum_arg_info_to_type(
-    parameter_type: QuantumType, argument_type: QuantumType, param_name: str
-) -> QuantumType:
-    if argument_type.has_size_in_bits:
-        copy_type_information(
-            argument_type,
-            parameter_type,
-            param_name,
-        )
-    return parameter_type
-
-
 def evaluate_type_in_classical_symbol(
     type_to_update: ClassicalType, scope: Scope, param_name: str
 ) -> ClassicalType:

classiq/evaluators/qmod_annotated_expression.py

@@ -1,10 +1,22 @@
 import ast
-from collections.abc import Sequence
+from collections.abc import Mapping, Sequence
 from dataclasses import dataclass
+from enum import Enum
 from typing import Any, Union, cast
 
+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 (
+    ClassicalType,
+)
 from classiq.interface.model.handle_binding import HandleBinding
+from classiq.interface.model.quantum_type import QuantumType
 
+from classiq.evaluators.qmod_expression_visitors.out_of_place_node_transformer import (
+    OutOfPlaceNodeTransformer,
+)
 from classiq.evaluators.qmod_node_evaluators.utils import QmodType, is_classical_type
 
 QmodExprNodeId = int
@@ -27,13 +39,31 @@ class ConcatenationAnnotation:
     elements: list[QmodExprNodeId]
 
 
-class _ExprInliner(ast.NodeTransformer):
+def qmod_val_to_str(val: Any) -> str:
+    if isinstance(val, QmodStructInstance):
+        fields = ", ".join(
+            f"{field_name}={qmod_val_to_str(field_val)}"
+            for field_name, field_val in val.fields.items()
+        )
+        return f"struct_literal({val.struct_declaration.name}, {fields})"
+    if isinstance(val, list):
+        return f"[{', '.join(qmod_val_to_str(item) for item in val)}]"
+    if isinstance(val, Enum):
+        return Enum.__str__(val)
+    if isinstance(val, (int, float, bool, complex)):
+        return str(val)
+    raise ClassiqInternalExpansionError(
+        f"Unrecognized value {str(val)!r} of type {type(val)}"
+    )
+
+
+class _ExprInliner(OutOfPlaceNodeTransformer):
     def __init__(self, expr_val: "QmodAnnotatedExpression") -> None:
         self._expr_val = expr_val
 
     def visit(self, node: ast.AST) -> Any:
         if self._expr_val.has_value(node):
-            return ast.Name(id=str(self._expr_val.get_value(node)))
+            return ast.Name(id=qmod_val_to_str(self._expr_val.get_value(node)))
         if self._expr_val.has_var(node):
             return ast.Name(id=str(self._expr_val.get_var(node)))
         return super().visit(node)
@@ -52,8 +82,9 @@ class QmodAnnotatedExpression:
             QmodExprNodeId, QuantumTypeAttributeAnnotation
         ] = {}
         self._concatenations: dict[QmodExprNodeId, ConcatenationAnnotation] = {}
+        self._locked = False
 
-    def to_qmod_expr(self) -> str:
+    def __str__(self) -> str:
         return ast.unparse(_ExprInliner(self).visit(self.root))
 
     def has_node(self, node_id: QmodExprNodeId) -> bool:
@@ -63,6 +94,8 @@ class QmodAnnotatedExpression:
         return self._node_mapping[node_id]
 
     def set_value(self, node: Union[ast.AST, QmodExprNodeId], value: Any) -> None:
+        if self._locked:
+            raise ClassiqInternalExpansionError("QAE is locked")
         if isinstance(node, ast.AST):
             node = id(node)
         self._values[node] = value
@@ -80,6 +113,8 @@ class QmodAnnotatedExpression:
     def set_type(
         self, node: Union[ast.AST, QmodExprNodeId], qmod_type: QmodType
     ) -> None:
+        if self._locked:
+            raise ClassiqInternalExpansionError("QAE is locked")
         if isinstance(node, ast.AST):
             node_id = id(node)
             self._node_mapping[node_id] = node
@@ -91,7 +126,25 @@ class QmodAnnotatedExpression:
             node = id(node)
         return self._types[node]
 
+    def get_quantum_type(self, node: Union[ast.AST, QmodExprNodeId]) -> QuantumType:
+        if isinstance(node, ast.AST):
+            node = id(node)
+        qmod_type = self._types[node]
+        if is_classical_type(qmod_type):
+            raise ClassiqInternalExpansionError
+        return cast(QuantumType, qmod_type)
+
+    def get_classical_type(self, node: Union[ast.AST, QmodExprNodeId]) -> ClassicalType:
+        if isinstance(node, ast.AST):
+            node = id(node)
+        qmod_type = self._types[node]
+        if not is_classical_type(qmod_type):
+            raise ClassiqInternalExpansionError
+        return cast(ClassicalType, qmod_type)
+
     def set_var(self, node: Union[ast.AST, QmodExprNodeId], var: HandleBinding) -> None:
+        if self._locked:
+            raise ClassiqInternalExpansionError("QAE is locked")
         var = var.collapse()
         if isinstance(node, ast.AST):
             node = id(node)
@@ -119,6 +172,8 @@ class QmodAnnotatedExpression:
         return node in self._quantum_vars
 
     def remove_var(self, node: Union[ast.AST, QmodExprNodeId]) -> None:
+        if self._locked:
+            raise ClassiqInternalExpansionError("QAE is locked")
         if isinstance(node, ast.AST):
             node = id(node)
         if node in self._classical_vars:
@@ -132,6 +187,8 @@ class QmodAnnotatedExpression:
         value: Union[ast.AST, QmodExprNodeId],
         index: Union[ast.AST, QmodExprNodeId],
     ) -> None:
+        if self._locked:
+            raise ClassiqInternalExpansionError("QAE is locked")
         if isinstance(node, ast.AST):
             node = id(node)
         if isinstance(value, ast.AST):
@@ -149,7 +206,7 @@ class QmodAnnotatedExpression:
 
     def get_quantum_subscripts(
         self,
-    ) -> dict[QmodExprNodeId, QuantumSubscriptAnnotation]:
+    ) -> Mapping[QmodExprNodeId, QuantumSubscriptAnnotation]:
         return self._quantum_subscripts
 
     def set_quantum_type_attr(
@@ -158,6 +215,8 @@ class QmodAnnotatedExpression:
         value: Union[ast.AST, QmodExprNodeId],
         attr: str,
     ) -> None:
+        if self._locked:
+            raise ClassiqInternalExpansionError("QAE is locked")
         if isinstance(node, ast.AST):
             node = id(node)
         if isinstance(value, ast.AST):
@@ -173,7 +232,7 @@ class QmodAnnotatedExpression:
 
     def get_quantum_type_attributes(
         self,
-    ) -> dict[QmodExprNodeId, QuantumTypeAttributeAnnotation]:
+    ) -> Mapping[QmodExprNodeId, QuantumTypeAttributeAnnotation]:
         return self._quantum_type_attrs
 
     def set_concatenation(
@@ -181,27 +240,68 @@ class QmodAnnotatedExpression:
         node: Union[ast.AST, QmodExprNodeId],
         elements: Sequence[Union[ast.AST, QmodExprNodeId]],
     ) -> None:
+        if self._locked:
+            raise ClassiqInternalExpansionError("QAE is locked")
         if isinstance(node, ast.AST):
             node = id(node)
-        elements = cast(
-            list[QmodExprNodeId],
-            [
-                id(element) if isinstance(element, ast.AST) else element
-                for element in elements
-            ],
-        )
-        self._concatenations[node] = ConcatenationAnnotation(elements=elements)
+        inlined_elements: list[QmodExprNodeId] = []
+        for element in elements:
+            if isinstance(element, ast.AST):
+                element = id(element)
+            if element not in self._concatenations:
+                inlined_elements.append(element)
+            else:
+                inlined_elements.extend(self._concatenations.pop(element).elements)
+        self._concatenations[node] = ConcatenationAnnotation(elements=inlined_elements)
 
     def has_concatenation(self, node: Union[ast.AST, QmodExprNodeId]) -> bool:
         if isinstance(node, ast.AST):
             node = id(node)
         return node in self._concatenations
 
-    def get_concatenations(self) -> dict[QmodExprNodeId, ConcatenationAnnotation]:
+    def get_concatenations(self) -> Mapping[QmodExprNodeId, ConcatenationAnnotation]:
         return self._concatenations
 
-    def get_classical_vars(self) -> dict[QmodExprNodeId, HandleBinding]:
+    def get_classical_vars(self) -> Mapping[QmodExprNodeId, HandleBinding]:
         return self._classical_vars
 
-    def get_quantum_vars(self) -> dict[QmodExprNodeId, HandleBinding]:
+    def get_quantum_vars(self) -> Mapping[QmodExprNodeId, HandleBinding]:
         return self._quantum_vars
+
+    def clear_node_data(self, node: Union[ast.AST, QmodExprNodeId]) -> None:
+        if isinstance(node, ast.AST):
+            node = id(node)
+        self._node_mapping.pop(node, None)
+        self._values.pop(node, None)
+        self._types.pop(node, None)
+        self._classical_vars.pop(node, None)
+        self._quantum_vars.pop(node, None)
+        qs = self._quantum_subscripts.pop(node, None)
+        if qs is not None:
+            self.clear_node_data(qs.value)
+            self.clear_node_data(qs.index)
+        qta = self._quantum_type_attrs.pop(node, None)
+        if qta is not None:
+            self.clear_node_data(qta.value)
+        cnct = self._concatenations.pop(node, None)
+        if cnct is not None:
+            for element in cnct.elements:
+                self.clear_node_data(element)
+
+    def _add_data_from(self, other: "QmodAnnotatedExpression") -> None:
+        self._node_mapping |= other._node_mapping
+        self._values |= other._values
+        self._types |= other._types
+        self._classical_vars |= other._classical_vars
+        self._quantum_vars |= other._quantum_vars
+        self._quantum_subscripts |= other._quantum_subscripts
+        self._quantum_type_attrs |= other._quantum_type_attrs
+        self._concatenations |= other._concatenations
+
+    def clone(self) -> "QmodAnnotatedExpression":
+        expr_val = QmodAnnotatedExpression(self.root)
+        expr_val._add_data_from(self)
+        return expr_val
+
+    def lock(self) -> None:
+        self._locked = True

classiq/evaluators/qmod_expression_visitors/out_of_place_node_transformer.py

@@ -0,0 +1,19 @@
+import ast
+from typing import Any
+
+
+class OutOfPlaceNodeTransformer(ast.NodeVisitor):
+    def generic_visit(self, node: ast.AST) -> ast.AST:
+        new_fields: dict[str, Any] = {}
+        for field, field_val in ast.iter_fields(node):
+            if isinstance(field_val, list):
+                new_fields[field] = [
+                    new_val
+                    for item in field_val
+                    if (new_val := self.visit(item)) is not None
+                ]
+            elif isinstance(field_val, ast.AST):
+                new_fields[field] = self.visit(field_val)
+            else:
+                new_fields[field] = field_val
+        return type(node)(**new_fields)

classiq/evaluators/qmod_expression_visitors/qmod_expression_bwc.py

@@ -73,11 +73,6 @@ class QmodExpressionBwc(ast.NodeTransformer):
                 return node
             return ast.Compare(left=args[0], ops=[ast.GtE()], comparators=[args[1]])
 
-        if func == "struct_literal":
-            if num_args != 1:
-                return node
-            return ast.Call(func=node.args[0], args=[], keywords=node.keywords)
-
         if func == "do_subscript":
             if num_args != 2 or num_kwargs != 0:
                 return node

classiq/evaluators/qmod_expression_visitors/qmod_expression_evaluator.py

@@ -1,7 +1,7 @@
 import ast
 from collections.abc import Mapping, Sequence
 from enum import IntEnum
-from typing import Any, Callable, Optional
+from typing import Any, Callable, Optional, cast
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
@@ -31,13 +31,16 @@ from classiq.evaluators.qmod_node_evaluators.compare_evaluation import eval_comp
 from classiq.evaluators.qmod_node_evaluators.constant_evaluation import (
     eval_constant,
     eval_enum_member,
+    try_eval_qmod_literal,
     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.min_max_evaluation import eval_min_max_op
 from classiq.evaluators.qmod_node_evaluators.name_evaluation import eval_name
+from classiq.evaluators.qmod_node_evaluators.piecewise_evaluation import eval_piecewise
 from classiq.evaluators.qmod_node_evaluators.struct_instantiation_evaluation import (
     eval_struct_instantiation,
 )
@@ -74,6 +77,7 @@ class QmodExpressionEvaluator(ast.NodeVisitor):
         self,
         expr_val: QmodAnnotatedExpression,
         *,
+        treat_qnum_as_float: bool = False,
         machine_precision: int = DEFAULT_MACHINE_PRECISION,
         classical_struct_declarations: Optional[Sequence[StructDeclaration]] = None,
         enum_declarations: Optional[Sequence[EnumDeclaration]] = None,
@@ -84,6 +88,7 @@ class QmodExpressionEvaluator(ast.NodeVisitor):
         scope: Optional[dict[str, Any]] = None,
     ) -> None:
         self._expr_val = expr_val
+        self._treat_qnum_as_float = treat_qnum_as_float
         self._machine_precision = machine_precision
         self._classical_struct_decls = nameables_to_dict(
             classical_struct_declarations or []
@@ -98,8 +103,8 @@ class QmodExpressionEvaluator(ast.NodeVisitor):
 
     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"
+            raise ClassiqExpansionError(
+                f"Syntax error: {type(node).__name__!r} is not a valid Qmod expression"
             )
         super().visit(node)
 
@@ -109,22 +114,19 @@ class QmodExpressionEvaluator(ast.NodeVisitor):
 
     def visit_BinOp(self, node: ast.BinOp) -> None:
         super().generic_visit(node)
-        eval_binary_op(self._expr_val, node)
+        eval_binary_op(
+            self._expr_val, node, self._treat_qnum_as_float, self._machine_precision
+        )
 
     def visit_UnaryOp(self, node: ast.UnaryOp) -> None:
         super().generic_visit(node)
-        eval_unary_op(self._expr_val, node)
+        eval_unary_op(self._expr_val, node, self._machine_precision)
 
     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(
@@ -132,16 +134,42 @@ class QmodExpressionEvaluator(ast.NodeVisitor):
             )
         func_name = func.id
 
+        if func_name == "Piecewise":
+            self._eval_piecewise(node)
+            return
+
+        for kwarg in node.keywords:
+            self.visit(kwarg)
+
+        if (
+            func_name == "struct_literal"
+            and len(node.args) == 1
+            and isinstance(node.args[0], ast.Name)
+            and (struct_name := node.args[0].id) in self._classical_struct_decls
+        ):
+            eval_struct_instantiation(
+                self._expr_val, node, self._classical_struct_decls[struct_name]
+            )
+            return
+
+        for arg in node.args:
+            self.visit(arg)
+
         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]
+        if func_name in ("min", "max"):
+            eval_min_max_op(
+                self._expr_val,
+                node,
+                func_name,
+                self._treat_qnum_as_float,
+                self._machine_precision,
             )
             return
 
+        # FIXME: Remove (CLS-3241)
         if func_name in self._classical_function_callables:
             if func_name not in self._classical_function_declarations:
                 raise ClassiqInternalExpansionError
@@ -153,6 +181,7 @@ class QmodExpressionEvaluator(ast.NodeVisitor):
             )
             return
 
+        # FIXME: Remove (CLS-3241)
         if func_name in self._classical_function_declarations:
             eval_symbolic_function(
                 self._expr_val, node, self._classical_function_declarations[func_name]
@@ -167,6 +196,21 @@ class QmodExpressionEvaluator(ast.NodeVisitor):
 
         raise ClassiqExpansionError(f"{func.id!r} is undefined")
 
+    def _eval_piecewise(self, node: ast.Call) -> None:
+        if (
+            len(node.args) == 0
+            or len(node.keywords) != 0
+            or not all(
+                isinstance(arg, ast.Tuple) and len(arg.elts) == 2 for arg in node.args
+            )
+        ):
+            raise ClassiqExpansionError("Malformed Piecewise expression")
+        args = [(arg.elts[0], arg.elts[1]) for arg in cast(list[ast.Tuple], node.args)]
+        for value, cond in args:
+            self.visit(value)
+            self.visit(cond)
+        eval_piecewise(self._expr_val, node, args)
+
     def visit_Constant(self, node: ast.Constant) -> None:
         eval_constant(self._expr_val, node)
 
@@ -194,12 +238,15 @@ class QmodExpressionEvaluator(ast.NodeVisitor):
         eval_subscript(self._expr_val, node)
 
     def visit_Name(self, node: ast.Name) -> None:
+        if node.id in self._scope:
+            eval_name(self._expr_val, node, self._scope[node.id])
+            return
         if try_eval_sympy_constant(self._expr_val, node):
             return
+        if try_eval_qmod_literal(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])
+        raise ClassiqExpansionError(f"Variable {node.id!r} is undefined")
 
     def visit_List(self, node: ast.List) -> None:
         super().generic_visit(node)
@@ -209,6 +256,7 @@ class QmodExpressionEvaluator(ast.NodeVisitor):
 def evaluate_qmod_expression(
     expr: str,
     *,
+    treat_qnum_as_float: bool = False,
     machine_precision: int = DEFAULT_MACHINE_PRECISION,
     classical_struct_declarations: Optional[Sequence[StructDeclaration]] = None,
     enum_declarations: Optional[Sequence[EnumDeclaration]] = None,
@@ -222,6 +270,7 @@ def evaluate_qmod_expression(
     expr_value = QmodAnnotatedExpression(expr_ast)
     QmodExpressionEvaluator(
         expr_value,
+        treat_qnum_as_float=treat_qnum_as_float,
         machine_precision=machine_precision,
         classical_struct_declarations=classical_struct_declarations,
         enum_declarations=enum_declarations,
@@ -229,4 +278,5 @@ def evaluate_qmod_expression(
         classical_function_callables=classical_function_callables,
         scope=scope,
     ).visit(expr_value.root)
+    expr_value.lock()
     return expr_value