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

classiq/model_expansions/quantum_operations/classical_var_emitter.py

@@ -1,5 +1,6 @@
 import re
 
+from classiq.interface.exceptions import ClassiqExpansionError
 from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.quantum_expressions.arithmetic_operation import (
     ArithmeticOperation,
@@ -14,9 +15,12 @@ class ClassicalVarEmitter(Emitter[ArithmeticOperation]):
         result_symbol = self._interpreter.evaluate(op.result_var).value
         if not isinstance(result_symbol, ClassicalSymbol):
             return False
-        op._classical_assignment = True
+        op.classical_assignment = True
         match = re.search(r"measure\((.*?)\)", op.expression.expr)
         if match is not None:
-            op.set_var_handles([HandleBinding(name=match.group(1))])
+            var = match.group(1)
+            if "[" in var or "." in var:
+                raise ClassiqExpansionError("'measure' must receive a whole variable")
+            op.set_var_handles([HandleBinding(name=var)])
         self.emit_statement(op)
         return True

classiq/model_expansions/quantum_operations/emitter.py

@@ -1,4 +1,3 @@
-import ast
 from abc import ABC, abstractmethod
 from collections.abc import Sequence
 from typing import (
@@ -9,17 +8,10 @@ from typing import (
     Union,
 )
 
-import sympy
-
 from classiq.interface.debug_info.debug_info import (
     DebugInfoCollection,
 )
 from classiq.interface.exceptions import ClassiqInternalExpansionError
-from classiq.interface.generator.expressions.atomic_expression_functions import (
-    CLASSICAL_ATTRIBUTES,
-    SUPPORTED_CLASSIQ_BUILTIN_FUNCTIONS,
-    SUPPORTED_PYTHON_BUILTIN_FUNCTIONS,
-)
 from classiq.interface.generator.expressions.evaluated_expression import (
     EvaluatedExpression,
 )
@@ -47,17 +39,14 @@ from classiq.interface.model.quantum_function_declaration import (
 )
 from classiq.interface.model.quantum_statement import QuantumOperation, QuantumStatement
 
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
 from classiq.model_expansions.closure import Closure, FunctionClosure, GenerativeClosure
 from classiq.model_expansions.function_builder import (
     OperationBuilder,
     OperationContext,
 )
 from classiq.model_expansions.scope import QuantumSymbol, Scope
-from classiq.model_expansions.sympy_conversion.sympy_to_python import (
-    translate_sympy_quantum_expression,
-)
 from classiq.model_expansions.utils.counted_name_allocator import CountedNameAllocator
-from classiq.model_expansions.visitors.variable_references import VarRefCollector
 from classiq.qmod.quantum_function import GenerativeQFunc
 
 if TYPE_CHECKING:
@@ -153,22 +142,18 @@ class Emitter(Generic[QuantumStatementT], ABC):
         return context
 
     def _evaluate_expression(
-        self, expression: Expression, preserve_bool_ops: bool = False
+        self,
+        expression: Expression,
+        *,
+        simplify: bool = False,
+        treat_qnum_as_float: bool = False,
     ) -> Expression:
-        evaluated_expression = self._interpreter.evaluate(expression)
-        if isinstance(evaluated_expression.value, sympy.Basic):
-            new_expression = Expression(
-                expr=translate_sympy_quantum_expression(
-                    evaluated_expression.value,
-                    preserve_bool_ops=preserve_bool_ops,
-                )
-            )
-        else:
-            new_expression = Expression(expr=str(evaluated_expression.value))
-        new_expression._evaluated_expr = EvaluatedExpression(
-            value=evaluated_expression.value
-        )
-        return new_expression
+        expr_val = self._interpreter.evaluate(
+            expression, simplify=simplify, treat_qnum_as_float=treat_qnum_as_float
+        ).value
+        new_expr = Expression(expr=str(expr_val))
+        new_expr._evaluated_expr = EvaluatedExpression(value=expr_val)
+        return new_expr
 
     def emit_statement(self, statement: QuantumStatement) -> None:
         self._update_captured_classical_vars(statement)
@@ -196,10 +181,8 @@ class Emitter(Generic[QuantumStatementT], ABC):
     ) -> None:
         if handle.name not in self._current_scope:
             return
-        if not handle.is_constant():
-            self._update_captured_classical_vars_in_expression(
-                Expression(expr=str(handle))
-            )
+        for expr in handle.expressions():
+            self._update_captured_classical_vars_in_expression(expr)
         while isinstance(handle, NestedHandleBinding) and not handle.is_constant():
             handle = handle.base_handle
         defining_function = self._current_scope[handle.name].defining_function
@@ -237,52 +220,39 @@ class Emitter(Generic[QuantumStatementT], ABC):
         )
 
     def _get_symbols_in_expression(self, expr: Expression) -> list[QuantumSymbol]:
-        vrc = VarRefCollector(ignore_duplicated_handles=True, unevaluated=True)
-        vrc.visit(ast.parse(expr.expr))
-        handles = dict.fromkeys(
-            handle
-            for handle in vrc.var_handles
-            if handle.name
-            not in SUPPORTED_PYTHON_BUILTIN_FUNCTIONS
-            | SUPPORTED_CLASSIQ_BUILTIN_FUNCTIONS
-            and isinstance(self._current_scope[handle.name].value, QuantumSymbol)
-        )
+        expr_val = expr.value.value
+        if not isinstance(expr_val, QmodAnnotatedExpression):
+            return []
         return [
-            self._interpreter.evaluate(handle).value
-            for handle in handles
-            if not isinstance(handle, FieldHandleBinding)
-            or handle.field not in CLASSICAL_ATTRIBUTES
+            QuantumSymbol(handle=var, quantum_type=expr_val.get_quantum_type(node_id))
+            for node_id, var in expr_val.get_quantum_vars().items()
         ]
 
     def _get_classical_vars_in_expression(
         self, expr: Expression
     ) -> list[tuple[str, ClassicalType]]:
-        vrc = VarRefCollector(
-            ignore_duplicated_handles=True, ignore_sympy_symbols=True, unevaluated=True
-        )
-        vrc.visit(ast.parse(expr.expr))
-        return list(
-            {
-                handle.name: get_proxy_type(proxy)
-                for handle in vrc.var_handles
-                if handle.name in self._current_scope
-                and isinstance(
-                    proxy := self._current_scope[handle.name].value, ClassicalProxy
-                )
-            }.items()
+        if not expr.is_evaluated():
+            raise ClassiqInternalExpansionError
+        expr_val = expr.value.value
+        if not isinstance(expr_val, QmodAnnotatedExpression):
+            return []
+        classical_vars = list(
+            dict.fromkeys(var.name for var in expr_val.get_classical_vars().values())
         )
+        return [
+            (var, get_proxy_type(proxy))
+            for var in classical_vars
+            if var in self._current_scope
+            and isinstance(proxy := self._current_scope[var].value, ClassicalProxy)
+        ]
 
     def _get_quantum_type_attributes_in_expression(
         self, expr: Expression
     ) -> list[FieldHandleBinding]:
-        vrc = VarRefCollector(ignore_duplicated_handles=True, unevaluated=True)
-        vrc.visit(ast.parse(expr.expr))
-        return list(
-            dict.fromkeys(
-                handle
-                for handle in vrc.var_handles
-                if isinstance(handle, FieldHandleBinding)
-                and handle.field in CLASSICAL_ATTRIBUTES
-                and isinstance(self._current_scope[handle.name].value, QuantumSymbol)
-            )
-        )
+        expr_val = expr.value.value
+        if not isinstance(expr_val, QmodAnnotatedExpression):
+            return []
+        return [
+            FieldHandleBinding(base_handle=type_attr.value, field=type_attr.attr)
+            for type_attr in expr_val.get_quantum_type_attributes().values()
+        ]

classiq/model_expansions/quantum_operations/expression_evaluator.py

@@ -13,16 +13,27 @@ if TYPE_CHECKING:
 
 
 class ExpressionEvaluator(Emitter[QuantumOperation]):
-    def __init__(self, interpreter: "BaseInterpreter", expression_name: str) -> None:
+    def __init__(
+        self,
+        interpreter: "BaseInterpreter",
+        expression_name: str,
+        *,
+        simplify: bool = False,
+        treat_qnum_as_float: bool = False,
+    ) -> None:
         super().__init__(interpreter)
         self._expression_name = expression_name
+        self._simplify = simplify
+        self._treat_qnum_as_float = treat_qnum_as_float
 
     def emit(self, op: QuantumOperation, /) -> bool:
         expression = getattr(op, self._expression_name)
         if not isinstance(expression, Expression) or expression.is_evaluated():
             return False
         evaluated_expression = self._evaluate_expression(
-            expression, preserve_bool_ops=True
+            expression,
+            simplify=self._simplify,
+            treat_qnum_as_float=self._treat_qnum_as_float,
         )
         for symbol in self._get_symbols_in_expression(evaluated_expression):
             self._capture_handle(symbol.handle, PortDeclarationDirection.Inout)

classiq/model_expansions/quantum_operations/quantum_function_call.py

@@ -1,7 +1,5 @@
 from typing import TYPE_CHECKING
 
-import sympy
-
 from classiq.interface.exceptions import ClassiqInternalExpansionError
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.classical_if import ClassicalIf
@@ -9,6 +7,7 @@ from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_lambda_function import OperandIdentifier
 from classiq.interface.model.quantum_statement import QuantumStatement
 
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
 from classiq.model_expansions.closure import FunctionClosure
 from classiq.model_expansions.quantum_operations.call_emitter import CallEmitter
 from classiq.model_expansions.quantum_operations.declarative_call_emitter import (
@@ -28,7 +27,7 @@ class QuantumFunctionCallEmitter(CallEmitter[QuantumFunctionCall]):
     def emit(self, call: QuantumFunctionCall, /) -> bool:
         if isinstance(call.function, OperandIdentifier):
             index_val = self._interpreter.evaluate(call.function.index).value
-            if isinstance(index_val, sympy.Basic):
+            if isinstance(index_val, QmodAnnotatedExpression):
                 return self._emit_symbolic_lambda_list(call, index_val)
         function = self._interpreter.evaluate(call.function).as_type(FunctionClosure)
         args = call.positional_args
@@ -39,7 +38,7 @@ class QuantumFunctionCallEmitter(CallEmitter[QuantumFunctionCall]):
         return True
 
     def _emit_symbolic_lambda_list(
-        self, call: QuantumFunctionCall, index: sympy.Basic
+        self, call: QuantumFunctionCall, index: QmodAnnotatedExpression
     ) -> bool:
         if TYPE_CHECKING:
             assert isinstance(call.function, OperandIdentifier)
@@ -54,7 +53,7 @@ class QuantumFunctionCallEmitter(CallEmitter[QuantumFunctionCall]):
 
     @staticmethod
     def _create_recursive_if(
-        call: QuantumFunctionCall, index: sympy.Basic, num_funcs: int
+        call: QuantumFunctionCall, index: QmodAnnotatedExpression, num_funcs: int
     ) -> list[QuantumStatement]:
         if TYPE_CHECKING:
             assert isinstance(call.function, OperandIdentifier)

classiq/model_expansions/quantum_operations/variable_decleration.py

@@ -1,7 +1,8 @@
-from typing import TYPE_CHECKING, Union
+from typing import TYPE_CHECKING, Union, cast
 
 from classiq.interface.exceptions import ClassiqExpansionError
 from classiq.interface.generator.functions.classical_type import ClassicalType
+from classiq.interface.generator.functions.concrete_types import ConcreteType
 from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.quantum_type import QuantumType
 from classiq.interface.model.variable_declaration_statement import (
@@ -30,13 +31,15 @@ class VariableDeclarationStatementEmitter(Emitter[VariableDeclarationStatement])
         if variable_declaration.is_quantum:
             if TYPE_CHECKING:
                 assert isinstance(var_decl.qmod_type, QuantumType)
+            updated_quantum_type = evaluate_type_in_quantum_symbol(
+                var_decl.qmod_type,
+                self._current_scope,
+                var_decl.name,
+            )
+            var_decl.qmod_type = updated_quantum_type
             var_value = QuantumSymbol(
                 handle=HandleBinding(name=var_decl.name),
-                quantum_type=evaluate_type_in_quantum_symbol(
-                    var_decl.qmod_type,
-                    self._current_scope,
-                    var_decl.name,
-                ),
+                quantum_type=updated_quantum_type,
             )
             self._builder.current_block.captured_vars.init_var(
                 var_decl.name, self._builder.current_function
@@ -44,13 +47,15 @@ class VariableDeclarationStatementEmitter(Emitter[VariableDeclarationStatement])
         else:
             if TYPE_CHECKING:
                 assert isinstance(var_decl.qmod_type, ClassicalType)
+            updated_classical_type = evaluate_type_in_classical_symbol(
+                var_decl.qmod_type,
+                self._current_scope,
+                var_decl.name,
+            )
+            var_decl.qmod_type = cast(ConcreteType, updated_classical_type)
             var_value = ClassicalSymbol(
                 handle=HandleBinding(name=var_decl.name),
-                classical_type=evaluate_type_in_classical_symbol(
-                    var_decl.qmod_type,
-                    self._current_scope,
-                    var_decl.name,
-                ),
+                classical_type=updated_classical_type,
             )
         self._current_scope[variable_declaration.name] = Evaluated(
             value=var_value, defining_function=self._builder.current_function

classiq/model_expansions/scope.py

@@ -15,9 +15,6 @@ from classiq.interface.generator.expressions.evaluated_expression import (
     EvaluatedExpression,
 )
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.expressions.proxies.classical.classical_scalar_proxy import (
-    ClassicalScalarProxy,
-)
 from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
     QmodStructInstance,
 )
@@ -43,6 +40,9 @@ from classiq.interface.model.quantum_type import (
     QuantumType,
 )
 
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
+from classiq.evaluators.qmod_node_evaluators.utils import get_sympy_val
+
 if TYPE_CHECKING:
     from classiq.model_expansions.closure import FunctionClosure
 
@@ -69,7 +69,7 @@ class QuantumSymbol(QuantumVariable):
         return self.handle
 
     def __getitem__(
-        self, item: Union[slice, int, ClassicalScalarProxy]
+        self, item: Union[slice, int, QmodAnnotatedExpression]
     ) -> "QuantumSymbol":
         if isinstance(item, slice):
             return self._slice(item.start, item.stop)
@@ -77,8 +77,8 @@ class QuantumSymbol(QuantumVariable):
 
     def _slice(
         self,
-        start: Union[int, ClassicalScalarProxy],
-        end: Union[int, ClassicalScalarProxy],
+        start: Union[int, QmodAnnotatedExpression],
+        end: Union[int, QmodAnnotatedExpression],
     ) -> "QuantumSymbol":
         if not isinstance(self.quantum_type, QuantumBitvector):
             raise ClassiqExpansionError(
@@ -100,19 +100,27 @@ class QuantumSymbol(QuantumVariable):
                 f"{self.quantum_type.type_name.lower()} {str(self.handle)!r} (of "
                 f"length {self.quantum_type.length_value})"
             )
+        start_expr = Expression(expr=str(start))
+        start_expr._evaluated_expr = EvaluatedExpression(value=start)
+        end_expr = Expression(expr=str(end))
+        end_expr._evaluated_expr = EvaluatedExpression(value=end)
+        if isinstance(start, int) and isinstance(end, int):
+            length_expr = Expression(expr=str(end - start))
+        else:
+            length_expr = None
         return QuantumSymbol(
             handle=SlicedHandleBinding(
                 base_handle=self.handle,
-                start=Expression(expr=str(start)),
-                end=Expression(expr=str(end)),
+                start=start_expr,
+                end=end_expr,
             ),
             quantum_type=QuantumBitvector(
                 element_type=self.quantum_type.element_type,
-                length=Expression(expr=str(end - start)),
+                length=length_expr,
             ),
         )
 
-    def _subscript(self, index: Union[int, ClassicalScalarProxy]) -> "QuantumSymbol":
+    def _subscript(self, index: Union[int, QmodAnnotatedExpression]) -> "QuantumSymbol":
         if not isinstance(self.quantum_type, QuantumBitvector):
             raise ClassiqExpansionError(
                 f"{self.quantum_type.type_name} is not subscriptable"
@@ -135,11 +143,10 @@ class QuantumSymbol(QuantumVariable):
                 f"{self.quantum_type.type_name.lower()} {str(self.handle)!r}"
                 f"{length_suffix}"
             )
+        index_expr = Expression(expr=str(index))
+        index_expr._evaluated_expr = EvaluatedExpression(value=index)
         return QuantumSymbol(
-            handle=SubscriptHandleBinding(
-                base_handle=self.handle,
-                index=Expression(expr=str(index)),
-            ),
+            handle=SubscriptHandleBinding(base_handle=self.handle, index=index_expr),
             quantum_type=self.quantum_type.element_type,
         )
 
@@ -204,11 +211,15 @@ class QuantumSymbolList(QuantumVariable):
 
 
 @dataclass(frozen=True)
-class ClassicalSymbol:
-    handle: HandleBinding
+class ClassicalVariable:
     classical_type: ClassicalType
 
 
+@dataclass(frozen=True)
+class ClassicalSymbol(ClassicalVariable):
+    handle: HandleBinding
+
+
 @singledispatch
 def evaluated_to_str(value: Any) -> str:
     return str(value)
@@ -225,8 +236,8 @@ def _evaluated_to_str_struct_literal(value: QmodStructInstance) -> str:
 
 
 def _raise_type_error(val: Any, t: type, location_hint: Optional[str]) -> NoReturn:
-    if isinstance(val, sympy.Basic) and len(val.free_symbols) > 0:
-        symbolic_vars = sorted(map(str, val.free_symbols))
+    if isinstance(val, QmodAnnotatedExpression) and len(val.get_classical_vars()) > 0:
+        symbolic_vars = sorted(map(str, val.get_classical_vars().values()))
         suffix = f" {location_hint}" if location_hint is not None else ""
         raise ClassiqExpansionError(
             f"Cannot use execution parameter{s(symbolic_vars)} {readable_list(symbolic_vars, quote=True)} in a compile-time context{suffix}"
@@ -240,19 +251,15 @@ class Evaluated:  # FIXME: Merge with EvaluatedExpression if possible
     defining_function: Optional["FunctionClosure"] = None
 
     def as_type(self, t: type[T], location_hint: Optional[str] = None) -> T:
-        if t is int:
-            return self._as_int(location_hint)  # type: ignore[return-value]
-
-        if not isinstance(self.value, t):
+        value = self.value
+        if isinstance(value, sympy.Basic):
+            value = get_sympy_val(value)
+        if t is int and isinstance(value, float):
+            value = int(value)
+        if not isinstance(value, t):
             _raise_type_error(self.value, t, location_hint)
 
-        return self.value
-
-    def _as_int(self, location_hint: Optional[str]) -> int:
-        if not isinstance(self.value, (int, float)):
-            _raise_type_error(self.value, int, location_hint)
-
-        return int(self.value)
+        return value
 
     def emit(self, param: Optional[AnonPositionalArg] = None) -> ArgValue:
         from classiq.model_expansions.closure import FunctionClosure

classiq/model_expansions/scope_initialization.py

@@ -11,9 +11,7 @@ from classiq.interface.model.native_function_definition import NativeFunctionDef
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_declaration import PositionalArg
 
-from classiq.evaluators.classical_expression import (
-    evaluate_classical_expression,
-)
+from classiq.evaluators.classical_expression import evaluate_classical_expression
 from classiq.evaluators.parameter_types import (
     evaluate_type_in_quantum_symbol,
 )
@@ -33,9 +31,8 @@ from classiq.qmod.semantics.annotation.qstruct_annotator import QStructAnnotator
 
 def add_constants_to_scope(constants: list[Constant], scope: Scope) -> None:
     for constant in constants:
-        scope[constant.name] = Evaluated(
-            value=evaluate_classical_expression(constant.value, scope).value
-        )
+        expr_val = evaluate_classical_expression(constant.value, scope).value
+        scope[constant.name] = Evaluated(value=expr_val)
 
 
 def add_functions_to_scope(

classiq/model_expansions/sympy_conversion/sympy_to_python.py

@@ -16,11 +16,15 @@ from sympy.logic.boolalg import BooleanAtom
 from sympy.printing.pycode import PythonCodePrinter
 
 from classiq.interface.exceptions import ClassiqInternalExpansionError
-from classiq.interface.generator.expressions.expression_types import ExpressionValue
+from classiq.interface.generator.expressions.expression_types import (
+    ExpressionValue,
+    RuntimeConstant,
+)
 from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
     AnyClassicalValue,
 )
 
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
 from classiq.evaluators.qmod_expression_visitors.sympy_wrappers import LogicalXor
 
 
@@ -48,7 +52,7 @@ def sympy_to_python(
     if value is None:
         value = False
 
-    if not isinstance(value, get_args(ExpressionValue)):
+    if not isinstance(value, (*get_args(RuntimeConstant), QmodAnnotatedExpression)):
         raise ClassiqInternalExpansionError(
             f"Invalid evaluated expression {value} of type {type(value)}"
         )

classiq/model_expansions/transformers/model_renamer.py

@@ -1,26 +1,27 @@
-import ast
 import re
 from collections.abc import Mapping, Sequence
 from dataclasses import dataclass
-from functools import cmp_to_key
 from typing import TypeVar, cast
 
-from classiq.interface.exceptions import ClassiqInternalExpansionError
+from classiq.interface.generator.expressions.atomic_expression_functions import (
+    CLASSICAL_ATTRIBUTES,
+)
 from classiq.interface.generator.expressions.evaluated_expression import (
     EvaluatedExpression,
 )
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
-    AnyClassicalValue,
-)
 from classiq.interface.generator.visitor import NodeType
-from classiq.interface.model.handle_binding import HandleBinding
+from classiq.interface.model.handle_binding import FieldHandleBinding, HandleBinding
 from classiq.interface.model.model_visitor import ModelTransformer
 from classiq.interface.model.quantum_expressions.quantum_expression import (
     QuantumExpressionOperation,
 )
 
-from classiq.model_expansions.visitors.variable_references import VarRefCollector
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
+from classiq.evaluators.qmod_expression_visitors.qmod_expression_renamer import (
+    replace_expression_type_attrs,
+    replace_expression_vars,
+)
 
 AST_NODE = TypeVar("AST_NODE", bound=NodeType)
 
@@ -39,31 +40,6 @@ def _handle_contains_handle(handle: HandleBinding, other_handle: HandleBinding)
     return 0
 
 
-class ExprNormalizer(ast.NodeTransformer):
-    def visit_Call(self, node: ast.Call) -> ast.AST:
-        if not isinstance(node.func, ast.Name):
-            return self.generic_visit(node)
-        if node.func.id == "get_field":
-            if (
-                len(node.args) != 2
-                or not isinstance(node.args[1], ast.Constant)
-                or not isinstance(node.args[1].value, str)
-            ):
-                raise ClassiqInternalExpansionError("Unexpected 'get_field' arguments")
-            return ast.Attribute(
-                value=self.visit(node.args[0]), attr=node.args[1].value
-            )
-        if node.func.id == "do_subscript":
-            if len(node.args) != 2:
-                raise ClassiqInternalExpansionError(
-                    "Unexpected 'do_subscript' arguments"
-                )
-            return ast.Subscript(
-                value=self.visit(node.args[0]), slice=self.visit(node.args[1])
-            )
-        return self.generic_visit(node)
-
-
 @dataclass(frozen=True)
 class HandleRenaming:
     source_handle: HandleBinding
@@ -80,38 +56,33 @@ SymbolRenaming = Mapping[HandleBinding, Sequence[HandleRenaming]]
 def rewrite_expression(
     symbol_mapping: SymbolRenaming, expression: Expression
 ) -> Expression:
-    normalized_expr = ExprNormalizer().visit(ast.parse(expression.expr))
-    vrc = VarRefCollector(
-        ignore_duplicated_handles=True, ignore_sympy_symbols=True, unevaluated=True
-    )
-    vrc.visit(normalized_expr)
-
-    handle_names = {
-        part.source_handle: part.target_var_handle
-        for source, parts in symbol_mapping.items()
-        if source.name in expression.expr
-        for part in parts
+    if len(symbol_mapping) == 0:
+        return expression
+    expr_val = expression.value.value
+    if not isinstance(expr_val, QmodAnnotatedExpression):
+        return expression
+
+    type_attr_mapping = {
+        (source_handle.base_handle, source_attr): renaming.target_var_handle
+        for renamings in symbol_mapping.values()
+        for renaming in renamings
+        if isinstance(source_handle := renaming.source_handle, FieldHandleBinding)
+        and (source_attr := source_handle.field) in CLASSICAL_ATTRIBUTES
     }
-    new_expr_str = ast.unparse(normalized_expr)
-    sorted_handles = sorted(
-        vrc.var_handles,
-        key=cmp_to_key(  # type:ignore[misc]
-            lambda handle, other_handle: _handle_contains_handle(other_handle, handle)
-        ),
-    )
-    for handle in sorted_handles:
-        new_handle = handle.collapse()
-        for handle_to_replace, replacement in handle_names.items():
-            if new_handle.name == handle_to_replace.name:
-                new_handle = new_handle.replace_prefix(handle_to_replace, replacement)
-        new_expr_str = _replace_full_word(str(handle), str(new_handle), new_expr_str)
-
-    new_expr = Expression(expr=new_expr_str)
-    if not new_expr.is_evaluated():
-        new_expr._evaluated_expr = EvaluatedExpression(
-            value=AnyClassicalValue(new_expr_str)
-        )
-    return new_expr
+    expr_val = replace_expression_type_attrs(expr_val, type_attr_mapping)
+
+    var_mapping = {
+        source_handle: renaming.target_var_handle
+        for renamings in symbol_mapping.values()
+        for renaming in renamings
+        if not isinstance(source_handle := renaming.source_handle, FieldHandleBinding)
+        or source_handle.field not in CLASSICAL_ATTRIBUTES
+    }
+    expr_val = replace_expression_vars(expr_val, var_mapping)
+
+    renamed_expr = Expression(expr=str(expr_val))
+    renamed_expr._evaluated_expr = EvaluatedExpression(value=expr_val)
+    return renamed_expr
 
 
 class _ReplaceSplitVarsHandles(ModelTransformer):

classiq/model_expansions/transformers/type_modifier_inference.py

@@ -1,4 +1,3 @@
-import ast
 import functools
 import itertools
 import warnings
@@ -37,7 +36,7 @@ from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.within_apply_operation import WithinApply
 from classiq.interface.source_reference import SourceReference
 
-from classiq.model_expansions.visitors.variable_references import VarRefCollector
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
 
 
 def _inconsistent_type_modifier_error(
@@ -302,11 +301,12 @@ class TypeModifierValidation(ModelVisitor):
 
     @staticmethod
     def _extract_expr_vars(expr_op: QuantumExpressionOperation) -> list[str]:
-        vrc = VarRefCollector(
-            ignore_duplicated_handles=True, ignore_sympy_symbols=True, unevaluated=True
+        expr_val = expr_op.expression.value.value
+        if not isinstance(expr_val, QmodAnnotatedExpression):
+            return []
+        return list(
+            dict.fromkeys(var.name for var in expr_val.get_quantum_vars().values())
         )
-        vrc.visit(ast.parse(expr_op.expression.expr))
-        return [handle.name for handle in vrc.var_handles]
 
     def visit_ArithmeticOperation(self, arith: ArithmeticOperation) -> None:
         with self.source_reference_context(arith.source_ref):