classiq 0.89.0__py3-none-any.whl → 0.90.0__py3-none-any.whl

classiq/model_expansions/atomic_expression_functions_defs.py

@@ -15,6 +15,7 @@ from classiq.interface.generator.expressions.atomic_expression_functions import
 from classiq.interface.generator.expressions.expression_types import (
     ExpressionValue,
     QmodStructInstance,
+    RuntimeConstant,
 )
 from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
     AnyClassicalValue,
@@ -44,14 +45,12 @@ from classiq.interface.generator.functions.classical_type import (
     ClassicalArray,
     ClassicalTuple,
     ClassicalType,
-    OpaqueHandle,
-    QmodPyObject,
     Real,
-    StructMetaType,
 )
 from classiq.interface.generator.functions.type_name import TypeName
 from classiq.interface.helpers.backward_compatibility import zip_strict
 
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
 from classiq.evaluators.qmod_expression_visitors.sympy_wrappers import (
     BitwiseAnd,
     BitwiseNot,
@@ -61,10 +60,6 @@ from classiq.evaluators.qmod_expression_visitors.sympy_wrappers import (
     LShift,
     RShift,
 )
-from classiq.model_expansions.model_tables import (
-    HandleIdentifier,
-    HandleTable,
-)
 from classiq.model_expansions.sympy_conversion.expression_to_sympy import (
     MISSING_SLICE_VALUE_PLACEHOLDER,
 )
@@ -106,10 +101,6 @@ def qmod_val_to_python(val: ExpressionValue, qmod_type: ClassicalType) -> Any:
                 )
             ]
 
-    elif isinstance(qmod_type, OpaqueHandle):
-        if isinstance(val, HandleIdentifier):
-            return HandleTable.get_handle_object(val)
-
     elif isinstance(val, Expr):
         return sympy_to_python(val)
 
@@ -121,10 +112,6 @@ def qmod_val_to_python(val: ExpressionValue, qmod_type: ClassicalType) -> Any:
         if isinstance(val, bool):
             return val
 
-    elif isinstance(qmod_type, StructMetaType):
-        if isinstance(val, TypeProxy):
-            return val.struct_declaration
-
     elif isinstance(val, int):  # other scalars are represented as int
         return val
 
@@ -162,11 +149,6 @@ def python_val_to_qmod(val: Any, qmod_type: ClassicalType) -> ExpressionValue:
             for elem, elem_type in zip_strict(val, qmod_type.element_types, strict=True)
         ]
 
-    if isinstance(qmod_type, OpaqueHandle):
-        if not isinstance(val, QmodPyObject):
-            raise ClassiqInternalExpansionError("Bad value opaque handle")
-        return HandleTable.set_handle_object(val)
-
     return val
 
 
@@ -194,7 +176,7 @@ def get_field(
         QmodSizedProxy, QmodStructInstance, list, ClassicalProxy, AnyClassicalValue
     ],
     field: str,
-) -> ExpressionValue:
+) -> Any:
     if isinstance(proxy, AnyClassicalValue) or (
         isinstance(proxy, Symbol)
         and not isinstance(proxy, QmodSizedProxy)
@@ -244,7 +226,7 @@ def do_div(lhs: Any, rhs: Any) -> Any:
     return res
 
 
-_EXPRESSION_TYPES = get_args(ExpressionValue)
+_EXPRESSION_TYPES = (*get_args(RuntimeConstant), QmodAnnotatedExpression)
 
 
 def _is_qmod_value(val: Any) -> bool:

classiq/model_expansions/capturing/captured_vars.py

@@ -1,3 +1,4 @@
+import ast
 import dataclasses
 from collections.abc import Sequence
 from dataclasses import dataclass, field
@@ -41,6 +42,7 @@ from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
 
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
 from classiq.model_expansions.capturing.mangling_utils import (
     demangle_handle,
     mangle_captured_var_name,
@@ -60,9 +62,11 @@ UNINITIALIZED_VAR_MESSAGE = "Variable '{}' should be initialized here"
 
 def _get_symbol_expr(symbol: str, classical_type: ClassicalType) -> Expression:
     expr = Expression(expr=symbol)
-    expr._evaluated_expr = EvaluatedExpression(
-        value=classical_type.get_classical_proxy(handle=HandleBinding(name=symbol))
-    )
+    expr_val = QmodAnnotatedExpression(ast.Name(id=symbol))
+    expr_val.set_type(expr_val.root, classical_type)
+    expr_val.set_var(expr_val.root, HandleBinding(name=symbol))
+    expr_val.lock()
+    expr._evaluated_expr = EvaluatedExpression(value=expr_val)
     return expr
 
 

classiq/model_expansions/closure.py

@@ -11,6 +11,7 @@ from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
 from classiq.interface.model.quantum_function_declaration import (
     NamedParamsQuantumFunctionDeclaration,
     PositionalArg,
+    QuantumOperandDeclaration,
 )
 from classiq.interface.model.quantum_lambda_function import QuantumCallable
 from classiq.interface.model.quantum_statement import QuantumStatement
@@ -111,6 +112,13 @@ class FunctionClosure(Closure):
     def emit(self) -> QuantumCallable:
         return self.name
 
+    def as_operand_declaration(self, is_list: bool) -> QuantumOperandDeclaration:
+        return QuantumOperandDeclaration(
+            name=self.name,
+            positional_arg_declarations=self.positional_arg_declarations,
+            is_list=is_list,
+        )
+
 
 @dataclass(frozen=True)
 class GenerativeFunctionClosure(GenerativeClosure, FunctionClosure):

classiq/model_expansions/interpreters/base_interpreter.py

@@ -4,7 +4,7 @@ from collections import defaultdict
 from collections.abc import Sequence
 from contextlib import nullcontext
 from functools import singledispatchmethod
-from typing import Any, cast
+from typing import Any, Callable, cast
 
 from pydantic import ValidationError
 
@@ -16,10 +16,8 @@ from classiq.interface.exceptions import (
     ClassiqExpansionError,
     ClassiqInternalExpansionError,
 )
-from classiq.interface.generator.expressions.atomic_expression_functions import (
-    CLASSICAL_ATTRIBUTES,
-)
 from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.expression_types import ExpressionValue
 from classiq.interface.generator.functions.classical_function_declaration import (
     ClassicalFunctionDeclaration,
 )
@@ -42,8 +40,20 @@ from classiq.interface.model.quantum_lambda_function import (
 )
 from classiq.interface.model.quantum_statement import QuantumStatement
 
-from classiq.evaluators.classical_expression import (
-    evaluate_classical_expression,
+from classiq.evaluators.classical_expression import process_scope_val
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
+from classiq.evaluators.qmod_expression_visitors.qmod_expression_bwc import (
+    QmodExpressionBwc,
+)
+from classiq.evaluators.qmod_expression_visitors.qmod_expression_evaluator import (
+    evaluate_qmod_expression,
+)
+from classiq.evaluators.qmod_expression_visitors.qmod_expression_simplifier import (
+    simplify_qmod_expression,
+)
+from classiq.evaluators.qmod_node_evaluators.utils import is_classical_integer
+from classiq.evaluators.qmod_type_inference.classical_type_inference import (
+    infer_classical_type,
 )
 from classiq.model_expansions.closure import (
     Closure,
@@ -67,7 +77,6 @@ from classiq.model_expansions.scope_initialization import (
     init_top_level_scope,
 )
 from classiq.model_expansions.utils.counted_name_allocator import CountedNameAllocator
-from classiq.model_expansions.visitors.variable_references import VarRefCollector
 from classiq.qmod.builtins.constants import __all__ as builtin_constants
 from classiq.qmod.builtins.enums import BUILTIN_ENUM_DECLARATIONS
 from classiq.qmod.builtins.structs import BUILTIN_STRUCT_DECLARATIONS
@@ -75,7 +84,17 @@ from classiq.qmod.model_state_container import QMODULE
 from classiq.qmod.semantics.annotation.qstruct_annotator import QStructAnnotator
 from classiq.qmod.semantics.error_manager import ErrorManager
 from classiq.qmod.semantics.validation.model_validation import validate_model
-from classiq.qmod.utilities import qmod_val_to_expr_str
+
+
+def _validate_index(val: ExpressionValue, subject: str) -> None:
+    if isinstance(val, QmodAnnotatedExpression):
+        val_type = val.get_type(val.root)
+    else:
+        val_type = infer_classical_type(val)
+    if not is_classical_integer(val_type):
+        raise ClassiqExpansionError(
+            f"{subject} indices must be integers, not {val_type.raw_qmod_type_name}"
+        )
 
 
 class BaseInterpreter:
@@ -130,6 +149,12 @@ class BaseInterpreter:
         try:
             with self._error_manager.call("main"):
                 self._expand_main_func()
+        except RecursionError:
+            self._error_manager.add_error(
+                "RecursionError: maximum recursion depth exceeded. Tip: If your "
+                "program contains recursive functions, check for base cases using a "
+                "Python if-statement (instead of Qmod's `if_`)"
+            )
         except Exception as e:
             if isinstance(e, ClassiqInternalExpansionError) or debug_mode.get():
                 raise e
@@ -175,22 +200,56 @@ class BaseInterpreter:
     def evaluate(self, expression: Any) -> Evaluated:
         raise NotImplementedError(f"Cannot evaluate {expression!r}")
 
+    def get_foreign_functions(self) -> dict[str, Callable]:
+        return {}
+
     @evaluate.register
-    def evaluate_classical_expression(self, expression: Expression) -> Evaluated:
-        expr = evaluate_classical_expression(expression, self._builder.current_scope)
-        vrc = VarRefCollector(ignore_duplicated_handles=True, unevaluated=True)
-        vrc.visit(ast.parse(qmod_val_to_expr_str(expr.value)))
-        for handle in vrc.var_handles:
-            if handle.name in self._builder.current_scope and isinstance(
-                self._builder.current_scope[handle.name].value, QuantumSymbol
-            ):
+    def evaluate_classical_expression(
+        self,
+        expression: Expression,
+        *,
+        simplify: bool = False,
+        treat_qnum_as_float: bool = False,
+    ) -> Evaluated:
+        if expression.is_evaluated():
+            return Evaluated(value=expression.value.value)
+        expr_ast = ast.parse(expression.expr, mode="eval").body
+        expr_ast = QmodExpressionBwc().visit(expr_ast)
+        expr_val = self._eval_expr(ast.unparse(expr_ast), treat_qnum_as_float)
+        if simplify and not expr_val.has_value(expr_val.root):
+            simplified_expr = simplify_qmod_expression(expr_val)
+            expr_val = self._eval_expr(simplified_expr, treat_qnum_as_float)
+        if expr_val.has_value(expr_val.root):
+            value = expr_val.get_value(expr_val.root)
+        else:
+            value = expr_val
+
+        return Evaluated(value=value)
+
+    def _eval_expr(
+        self, expr: str, treat_qnum_as_float: bool
+    ) -> QmodAnnotatedExpression:
+        return evaluate_qmod_expression(
+            expr,
+            treat_qnum_as_float=treat_qnum_as_float,
+            machine_precision=self._model.preferences.machine_precision,
+            classical_struct_declarations=list(QMODULE.type_decls.values()),
+            enum_declarations=list(QMODULE.enum_decls.values()),
+            classical_function_declarations=list(
+                ClassicalFunctionDeclaration.FOREIGN_FUNCTION_DECLARATIONS.values()
+            ),
+            classical_function_callables=self.get_foreign_functions(),
+            scope={
+                name: processed_val
+                for name in list(self._builder.current_scope)
                 if (
-                    isinstance(handle, FieldHandleBinding)
-                    and handle.field in CLASSICAL_ATTRIBUTES
-                ):
-                    handle = handle.base_handle
-                self.evaluate(handle)
-        return expr
+                    processed_val := process_scope_val(
+                        self._builder.current_scope[name].value
+                    )
+                )
+                is not None
+            },
+        )
 
     @evaluate.register
     def evaluate_identifier(self, identifier: str) -> Evaluated:
@@ -216,6 +275,8 @@ class BaseInterpreter:
         )
         start = self.evaluate(sliced_handle_binding.start).value
         end = self.evaluate(sliced_handle_binding.end).value
+        _validate_index(start, "Slice")
+        _validate_index(end, "Slice")
         return Evaluated(value=quantum_variable[start:end])
 
     @evaluate.register
@@ -232,6 +293,7 @@ class BaseInterpreter:
     def evaluate_subscript_operand(self, subscript: OperandIdentifier) -> Evaluated:
         base_value = self.evaluate(subscript.name)
         index_value = self.evaluate(subscript.index).as_type(int)
+        _validate_index(index_value, "Array")
         return Evaluated(value=base_value.value[index_value])
 
     @evaluate.register

classiq/model_expansions/interpreters/frontend_generative_interpreter.py

@@ -45,7 +45,7 @@ class FrontendGenerativeInterpreter(GenerativeInterpreter):
         return super()._get_main_closure(main_func)
 
     def process_exception(self, e: Exception) -> None:
-        if not isinstance(e, (ClassiqError, ValidationError)):
+        if not isinstance(e, (ClassiqError, ValidationError, RecursionError)):
             frame = inspect.trace()[-1]
             module = inspect.getmodule(frame[0])
             if module is None or not module.__name__.startswith("classiq."):

classiq/model_expansions/interpreters/generative_interpreter.py

@@ -183,7 +183,9 @@ class GenerativeInterpreter(BaseInterpreter):
             self,
             [
                 HandleEvaluator(self, "result_var"),
-                ExpressionEvaluator(self, "expression"),
+                ExpressionEvaluator(
+                    self, "expression", simplify=True, treat_qnum_as_float=True
+                ),
                 AssignmentResultProcessor(self),
             ],
         ).emit(op)
@@ -197,7 +199,7 @@ class GenerativeInterpreter(BaseInterpreter):
             self,
             [
                 HandleEvaluator(self, "result_var"),
-                ExpressionEvaluator(self, "expression"),
+                ExpressionEvaluator(self, "expression", simplify=True),
                 ClassicalVarEmitter(self),
                 AssignmentResultProcessor(self),
             ],
@@ -210,7 +212,7 @@ class GenerativeInterpreter(BaseInterpreter):
             [
                 HandleEvaluator(self, "target"),
                 HandleEvaluator(self, "value"),
-                ExpressionEvaluator(self, "value"),
+                ExpressionEvaluator(self, "value", simplify=True),
             ],
         ).emit(op)
 
@@ -276,7 +278,7 @@ class GenerativeInterpreter(BaseInterpreter):
         CompositeEmitter[Control](
             self,
             [
-                ExpressionEvaluator(self, "expression"),
+                ExpressionEvaluator(self, "expression", simplify=True),
                 BlockEvaluator(
                     self,
                     CONTROL_OPERATOR_NAME,
@@ -301,7 +303,7 @@ class GenerativeInterpreter(BaseInterpreter):
         CompositeEmitter[PhaseOperation](
             self,
             [
-                ExpressionEvaluator(self, "expression"),
+                ExpressionEvaluator(self, "expression", simplify=True),
                 ExpressionEvaluator(self, "theta"),
             ],
         ).emit(phase)

classiq/model_expansions/quantum_operations/allocate.py

@@ -1,10 +1,16 @@
-from typing import TYPE_CHECKING, Union
+from typing import TYPE_CHECKING, Any, Union
 
 import sympy
 
 from classiq.interface.debug_info.debug_info import FunctionDebugInfo
 from classiq.interface.exceptions import ClassiqExpansionError, ClassiqValueError
+from classiq.interface.generator.expressions.evaluated_expression import (
+    EvaluatedExpression,
+)
 from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.expression_types import ExpressionValue
+from classiq.interface.generator.functions.classical_type import Bool, Integer, Real
+from classiq.interface.helpers.text_utils import s
 from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.handle_binding import NestedHandleBinding
 from classiq.interface.model.quantum_type import (
@@ -12,6 +18,8 @@ from classiq.interface.model.quantum_type import (
     QuantumNumeric,
 )
 
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
+from classiq.evaluators.qmod_node_evaluators.utils import get_sympy_type
 from classiq.evaluators.qmod_type_inference.quantum_type_inference import (
     inject_quantum_type_attributes_inplace,
 )
@@ -22,6 +30,13 @@ if TYPE_CHECKING:
     from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
 
 
+def _assign_attr(
+    op_update_dict: dict[str, Expression], attr: str, size_value: ExpressionValue
+) -> None:
+    op_update_dict[attr] = Expression(expr=str(size_value))
+    op_update_dict[attr]._evaluated_expr = EvaluatedExpression(value=size_value)
+
+
 class AllocateEmitter(Emitter[Allocate]):
     def __init__(
         self, interpreter: "BaseInterpreter", allow_symbolic_attrs: bool = False
@@ -86,7 +101,7 @@ class AllocateEmitter(Emitter[Allocate]):
             raise ClassiqValueError(
                 f"Could not infer the size of variable {str(target.handle)!r}"
             )
-        op_update_dict["size"] = Expression(expr=expr)
+        op_update_dict["size"] = self._evaluate_expression(Expression(expr=expr))
 
     def _handle_with_size(
         self,
@@ -95,10 +110,10 @@ class AllocateEmitter(Emitter[Allocate]):
         op_update_dict: dict[str, Expression],
     ) -> None:
         size_value = self._interpret_size(size, str(target.handle))
-        op_update_dict["size"] = Expression(expr=str(size_value))
+        _assign_attr(op_update_dict, "size", size_value)
 
         if not isinstance(
-            size_value, sympy.Basic
+            size_value, QmodAnnotatedExpression
         ) and not inject_quantum_type_attributes_inplace(
             QuantumBitvector(length=op_update_dict["size"]), target.quantum_type
         ):
@@ -122,16 +137,19 @@ class AllocateEmitter(Emitter[Allocate]):
             )
 
         size_value = self._interpret_size(size, var_name)
-        op_update_dict["size"] = Expression(expr=str(size_value))
+        _assign_attr(op_update_dict, "size", size_value)
         is_signed_value = self._interpret_is_signed(is_signed)
-        op_update_dict["is_signed"] = Expression(expr=str(is_signed_value))
+        _assign_attr(op_update_dict, "is_signed", is_signed_value)
         fraction_digits_value = self._interpret_fraction_digits(fraction_digits)
-        op_update_dict["fraction_digits"] = Expression(expr=str(fraction_digits_value))
+        _assign_attr(op_update_dict, "fraction_digits", fraction_digits_value)
+        self._validate_numeric_atrributes(
+            var_name, size_value, is_signed_value, fraction_digits_value
+        )
 
         if not (
-            isinstance(size_value, sympy.Basic)
-            or isinstance(is_signed_value, sympy.Basic)
-            or isinstance(fraction_digits_value, sympy.Basic)
+            isinstance(size_value, QmodAnnotatedExpression)
+            or isinstance(is_signed_value, QmodAnnotatedExpression)
+            or isinstance(fraction_digits_value, QmodAnnotatedExpression)
         ) and not inject_quantum_type_attributes_inplace(
             QuantumNumeric(
                 size=op_update_dict["size"],
@@ -145,24 +163,73 @@ class AllocateEmitter(Emitter[Allocate]):
                 f"{var_name!r} of type {target.quantum_type.qmod_type_name}"
             )
 
+    def _validate_numeric_atrributes(
+        self,
+        var_name: str,
+        size_value: Any,
+        is_signed_value: Any,
+        fraction_digits_value: Any,
+    ) -> None:
+        if (
+            isinstance(size_value, int)
+            and isinstance(is_signed_value, bool)
+            and isinstance(fraction_digits_value, int)
+        ):
+            if size_value < 0:
+                raise ClassiqValueError(
+                    f"Cannot allocate {size_value} qubit{s(size_value)} for variable "
+                    f"{var_name!r}"
+                )
+            if fraction_digits_value < 0:
+                raise ClassiqValueError(
+                    f"Variable {var_name!r} cannot have a negative number of fraction "
+                    f"digits (got {fraction_digits_value})"
+                )
+            if size_value < fraction_digits_value:
+                raise ClassiqValueError(
+                    f"Cannot allocate {size_value} qubit{s(size_value)} for variable "
+                    f"{var_name!r} with {fraction_digits_value} fraction digits"
+                )
+
     def _interpret_size(
         self, size: Expression, var_name: str
-    ) -> Union[int, float, sympy.Basic]:
+    ) -> Union[int, float, sympy.Basic, QmodAnnotatedExpression]:
         size_value = self._interpreter.evaluate(size).value
-        if not self._allow_symbolic_attrs and not isinstance(size_value, (int, float)):
-            if size.expr == f"{var_name}.size":
-                raise ClassiqValueError(
-                    f"Could not infer the size of variable {var_name!r}"
-                )
+        if not (
+            (
+                isinstance(size_value, QmodAnnotatedExpression)
+                and isinstance(size_value.get_type(size_value.root), (Integer, Real))
+            )
+            or isinstance(size_value, (int, float))
+            or (
+                isinstance(size_value, sympy.Basic)
+                and isinstance(get_sympy_type(size_value), (Integer, Real))
+            )
+        ):
             raise ClassiqValueError(
                 f"The number of allocated qubits must be an integer. Got "
                 f"{str(size_value)!r}"
             )
+        if (
+            isinstance(size_value, QmodAnnotatedExpression)
+            and not self._allow_symbolic_attrs
+        ):
+            raise ClassiqValueError(
+                f"Could not infer the size of variable {var_name!r}"
+            )
         return size_value
 
-    def _interpret_is_signed(self, is_signed: Expression) -> Union[bool, sympy.Basic]:
+    def _interpret_is_signed(
+        self, is_signed: Expression
+    ) -> Union[bool, sympy.Basic, QmodAnnotatedExpression]:
         is_signed_value = self._interpreter.evaluate(is_signed).value
-        if not self._allow_symbolic_attrs and not isinstance(is_signed_value, bool):
+        if not self._allow_symbolic_attrs and not (
+            isinstance(is_signed_value, bool)
+            or (
+                isinstance(is_signed_value, sympy.Basic)
+                and isinstance(get_sympy_type(is_signed_value), Bool)
+            )
+        ):
             raise ClassiqValueError(
                 f"The sign of a variable must be boolean. Got "
                 f"{str(is_signed_value)!r}"
@@ -171,10 +238,14 @@ class AllocateEmitter(Emitter[Allocate]):
 
     def _interpret_fraction_digits(
         self, fraction_digits: Expression
-    ) -> Union[int, float, sympy.Basic]:
+    ) -> Union[int, float, sympy.Expr, QmodAnnotatedExpression]:
         fraction_digits_value = self._interpreter.evaluate(fraction_digits).value
-        if not self._allow_symbolic_attrs and not isinstance(
-            fraction_digits_value, (int, float)
+        if not self._allow_symbolic_attrs and not (
+            isinstance(fraction_digits_value, (int, float))
+            or (
+                isinstance(fraction_digits_value, sympy.Expr)
+                and fraction_digits_value.is_integer
+            )
         ):
             raise ClassiqValueError(
                 f"The fraction digits of a variable must be an integer. Got "

classiq/model_expansions/quantum_operations/assignment_result_processor.py

@@ -1,7 +1,6 @@
 from typing import TYPE_CHECKING, Optional
 
 from classiq.interface.exceptions import ClassiqExpansionError
-from classiq.interface.generator.arith.arithmetic import compute_arithmetic_result_type
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.bind_operation import BindOperation
@@ -20,23 +19,31 @@ from classiq.interface.model.quantum_expressions.quantum_expression import (
     QuantumAssignmentOperation,
 )
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
-from classiq.interface.model.quantum_type import QuantumBitvector, QuantumNumeric
+from classiq.interface.model.quantum_type import (
+    QuantumBitvector,
+    QuantumNumeric,
+    QuantumScalar,
+)
 from classiq.interface.model.statement_block import StatementBlock
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
 from classiq.interface.model.within_apply_operation import WithinApply
 
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
 from classiq.evaluators.qmod_type_inference.quantum_type_inference import (
     inject_quantum_type_attributes_inplace,
 )
+from classiq.model_expansions.arithmetic import NumericAttributes
+from classiq.model_expansions.arithmetic_compute_result_attrs import (
+    compute_result_attrs_assign,
+)
 from classiq.model_expansions.quantum_operations.arithmetic.explicit_boolean_expressions import (
     convert_assignment_bool_expression,
     validate_assignment_bool_expression,
 )
 from classiq.model_expansions.quantum_operations.emitter import Emitter
 from classiq.model_expansions.scope import ClassicalSymbol
-from classiq.model_expansions.transformers.ast_renamer import rename_variables
 from classiq.qmod.builtins.functions.standard_gates import CX
 
 if TYPE_CHECKING:
@@ -100,33 +107,27 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
 
     def _infer_expression_type(
         self, op: ArithmeticOperation
-    ) -> Optional[QuantumNumeric]:
+    ) -> Optional[QuantumScalar]:
         expr = self._evaluate_expression(op.expression)
-        if len(self._get_classical_vars_in_expression(expr)):
-            return None
-
-        symbols = self._get_symbols_in_expression(expr)
-        if any(not symbol.quantum_type.is_instantiated for symbol in symbols):
+        expr_val = expr.value.value
+        if isinstance(expr_val, QmodAnnotatedExpression):
+            root_type = expr_val.get_type(expr_val.root)
+            if isinstance(root_type, QuantumScalar) and root_type.is_instantiated:
+                root_type = compute_result_attrs_assign(
+                    NumericAttributes.from_type_or_constant(root_type),
+                    self._machine_precision,
+                ).to_quantum_numeric()
+                return root_type
             return None
-
-        expr_str = rename_variables(
-            expr.expr,
-            {str(symbol.handle): symbol.handle.identifier for symbol in symbols}
-            | {symbol.handle.qmod_expr: symbol.handle.identifier for symbol in symbols},
-        )
-        for symbol in symbols:
-            expr_str = expr_str.replace(
-                symbol.handle.qmod_expr, symbol.handle.identifier
-            )
-        return compute_arithmetic_result_type(
-            expr_str,
-            {symbol.handle.identifier: symbol.quantum_type for symbol in symbols},
-            self._machine_precision,
-        )
+        if isinstance(expr_val, (int, float)):
+            return NumericAttributes.from_constant(
+                expr_val, self._machine_precision
+            ).to_quantum_numeric()
+        return None
 
     @staticmethod
     def _same_numeric_attributes(
-        result_type: QuantumNumeric, expression_type: QuantumNumeric
+        result_type: QuantumNumeric, expression_type: QuantumScalar
     ) -> bool:
         return (
             result_type.size_in_bits == expression_type.size_in_bits
@@ -137,7 +138,7 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
 
     @classmethod
     def _validate_declared_attributes(
-        cls, result_type: QuantumNumeric, expression_type: QuantumNumeric, var: str
+        cls, result_type: QuantumNumeric, expression_type: QuantumScalar, var: str
     ) -> None:
         result_size, result_sign, result_fractions = (
             result_type.size_in_bits,
@@ -183,7 +184,7 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
         self,
         op: ArithmeticOperation,
         result_type: QuantumNumeric,
-        expression_type: QuantumNumeric,
+        expression_type: QuantumScalar,
     ) -> None:
         stmts: StatementBlock = []
         handles: list[HandleBinding] = []