classiq 0.56.1__py3-none-any.whl → 0.58.0__py3-none-any.whl

classiq/model_expansions/quantum_operations/expression_operation.py

@@ -1,79 +1,59 @@
 import ast
-from abc import abstractmethod
-from itertools import chain
-from typing import TYPE_CHECKING, TypeVar, Union
+from typing import TYPE_CHECKING, Generic, TypeVar, Union
 
-from classiq.interface.exceptions import (
-    ClassiqExpansionError,
-    ClassiqInternalExpansionError,
-)
 from classiq.interface.generator.expressions.evaluated_expression import (
     EvaluatedExpression,
 )
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.functions.type_name import TypeName
-from classiq.interface.generator.visitor import NodeType, Transformer
-from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.generator.visitor import NodeType
 from classiq.interface.model.control import Control
-from classiq.interface.model.handle_binding import (
-    FieldHandleBinding,
-    HandleBinding,
-    SlicedHandleBinding,
-    SubscriptHandleBinding,
-)
 from classiq.interface.model.quantum_expressions.quantum_expression import (
     QuantumAssignmentOperation,
     QuantumExpressionOperation,
 )
 from classiq.interface.model.quantum_type import (
-    QuantumBit,
-    QuantumBitvector,
     QuantumNumeric,
-    QuantumType,
-)
-from classiq.interface.model.variable_declaration_statement import (
-    VariableDeclarationStatement,
 )
 from classiq.interface.model.within_apply_operation import WithinApply
 
-from classiq.model_expansions.quantum_operations.emitter import Emitter
+from classiq.model_expansions.quantum_operations.call_emitter import CallEmitter
 from classiq.model_expansions.scope import QuantumSymbol
+from classiq.model_expansions.transformers.var_splitter import (
+    SymbolParts,
+    VarSplitter,
+)
 from classiq.model_expansions.visitors.variable_references import VarRefCollector
 
+if TYPE_CHECKING:
+    from classiq.model_expansions.interpreter import Interpreter
+
 ExpressionOperationT = TypeVar("ExpressionOperationT", bound=QuantumExpressionOperation)
 AST_NODE = TypeVar("AST_NODE", bound=NodeType)
 
 
-class ExpressionOperationEmitter(Emitter[ExpressionOperationT]):
-    @abstractmethod
-    def emit(self, op: ExpressionOperationT, /) -> None:
-        pass
+class ExpressionOperationEmitter(
+    Generic[ExpressionOperationT], CallEmitter[ExpressionOperationT], VarSplitter
+):
+    def __init__(self, interpreter: "Interpreter") -> None:
+        CallEmitter.__init__(self, interpreter)  # type:ignore[arg-type]
+        VarSplitter.__init__(self, interpreter._current_scope)
 
     def _emit_with_split(
         self,
         op: ExpressionOperationT,
         expression: Expression,
-        symbols_to_split: dict[QuantumSymbol, set[HandleBinding]],
+        symbol_parts: SymbolParts,
     ) -> None:
-        symbols_parts, bind_ops = self._get_bind_ops(symbols_to_split)
+        for var_decl in self.get_var_decls(symbol_parts):
+            self._interpreter.emit_statement(var_decl)
+        bind_ops = self.get_bind_ops(symbol_parts)
 
-        for symbol_parts in symbols_parts:
-            for symbol, symbol_part_var_name in symbol_parts:
-                if symbol.handle.identifier not in self._current_scope:
-                    self._interpreter.emit_statement(
-                        VariableDeclarationStatement(
-                            name=symbol_part_var_name,
-                            quantum_type=symbol.quantum_type,
-                        )
-                    )
-
-        symbol_mapping = {
-            symbol.handle: (symbol_part_var_name, symbol.quantum_type)
-            for symbol, symbol_part_var_name in chain.from_iterable(symbols_parts)
-        }
-        new_expression = self._update_op_expression(symbol_mapping, expression)
+        new_expression = self.rewrite(expression, symbol_parts)
+        new_expression._evaluated_expr = EvaluatedExpression(
+            value=self._interpreter.evaluate(new_expression).value
+        )
         new_op = op.model_copy(update=dict(expression=new_expression))
-        new_op = self._get_updated_op_split_symbols(new_op, symbol_mapping)
+        new_op = self._get_updated_op_split_symbols(new_op, symbol_parts)
 
         self._interpreter.emit_statement(
             WithinApply(
@@ -86,125 +66,10 @@ class ExpressionOperationEmitter(Emitter[ExpressionOperationT]):
     def _get_updated_op_split_symbols(
         self,
         op: ExpressionOperationT,
-        symbol_mapping: dict[HandleBinding, tuple[str, QuantumType]],
+        symbol_mapping: SymbolParts,
     ) -> ExpressionOperationT:
         return op
 
-    def _update_op_expression(
-        self,
-        symbol_mapping: dict[HandleBinding, tuple[str, QuantumType]],
-        expression: Expression,
-    ) -> Expression:
-        vrc = VarRefCollector(ignore_duplicated_handles=True)
-        vrc.visit(ast.parse(expression.expr))
-
-        new_expr_str = expression.expr
-        for handle in vrc.var_handles:
-            collapsed_handle = handle.collapse()
-            if collapsed_handle in symbol_mapping:
-                new_expr_str = new_expr_str.replace(
-                    str(handle), symbol_mapping[collapsed_handle][0]
-                )
-        self._check_all_handles_were_replaced(new_expr_str)
-
-        new_expr = Expression(expr=new_expr_str)
-        new_expr._evaluated_expr = EvaluatedExpression(
-            value=self._interpreter.evaluate(new_expr).value
-        )
-        return new_expr
-
-    def _check_all_handles_were_replaced(self, new_expr_str: str) -> None:
-        vrc = VarRefCollector(ignore_duplicated_handles=True)
-        vrc.visit(ast.parse(new_expr_str))
-        for handle in self._get_handles(vrc):
-            if isinstance(
-                handle,
-                (SubscriptHandleBinding, SlicedHandleBinding, FieldHandleBinding),
-            ):
-                raise ClassiqInternalExpansionError(f"Did not replace handle {handle}")
-
-    def _get_bind_ops(
-        self,
-        symbols_to_split: dict[QuantumSymbol, set[HandleBinding]],
-    ) -> tuple[list[list[tuple[QuantumSymbol, str]]], list[BindOperation]]:
-        bind_ops = []
-        symbols_parts = []
-        for symbol, target_parts in symbols_to_split.items():
-            symbol_parts = self._get_symbol_parts(symbol, target_parts)
-            symbols_parts.append(symbol_parts)
-            bind_ops.append(
-                BindOperation(
-                    in_handles=[symbol.handle],
-                    out_handles=[
-                        HandleBinding(name=symbol_part_var_name)
-                        for _, symbol_part_var_name in symbol_parts
-                    ],
-                )
-            )
-        return symbols_parts, bind_ops
-
-    def _get_symbol_parts(
-        self, symbol: QuantumSymbol, target_parts: set[HandleBinding]
-    ) -> list[tuple[QuantumSymbol, str]]:
-        quantum_type = symbol.quantum_type
-
-        if all(
-            symbol.handle == target_part or symbol.handle not in target_part.prefixes()
-            for target_part in target_parts
-        ) or isinstance(quantum_type, (QuantumBit, QuantumNumeric)):
-            return [
-                (
-                    symbol,
-                    self._counted_name_allocator.allocate(symbol.handle.identifier),
-                )
-            ]
-
-        if isinstance(quantum_type, QuantumBitvector):
-            if not quantum_type.has_length:
-                raise ClassiqExpansionError(
-                    f"Could not determine the length of quantum array "
-                    f"{symbol.handle}."
-                )
-            return list(
-                chain.from_iterable(
-                    self._get_symbol_parts(symbol[idx], target_parts)
-                    for idx in range(quantum_type.length_value)
-                )
-            )
-
-        if TYPE_CHECKING:
-            assert isinstance(quantum_type, TypeName)
-
-        return list(
-            chain.from_iterable(
-                self._get_symbol_parts(field_symbol, target_parts)
-                for field_symbol in symbol.fields.values()
-            )
-        )
-
-    def _get_symbols_to_split(
-        self, expression: Expression
-    ) -> dict[QuantumSymbol, set[HandleBinding]]:
-        vrc = VarRefCollector(ignore_duplicated_handles=True)
-        vrc.visit(ast.parse(expression.expr))
-        symbol_names_to_split = dict.fromkeys(
-            handle.name
-            for handle in self._get_handles(vrc)
-            if isinstance(handle, (SubscriptHandleBinding, FieldHandleBinding))
-        )
-        return {
-            symbol: {
-                handle.collapse()
-                for handle in vrc.var_handles
-                if handle.name == symbol.handle.name
-            }
-            for symbol_name in symbol_names_to_split
-            if isinstance(
-                symbol := self._current_scope[symbol_name].value,
-                QuantumSymbol,
-            )
-        }
-
     def _evaluate_op_expression(self, op: ExpressionOperationT) -> Expression:
         return self._evaluate_expression(op.expression)
 
@@ -248,31 +113,3 @@ class ExpressionOperationEmitter(Emitter[ExpressionOperationT]):
             isinstance(op.result_type, QuantumNumeric)
             and (op.result_type.sign_value or op.result_type.fraction_digits_value > 0)
         )
-
-    def _get_handles(self, collector: VarRefCollector) -> list[HandleBinding]:
-        return [
-            handle
-            for handle in collector.var_handles
-            if isinstance(self._interpreter.evaluate(handle.name).value, QuantumSymbol)
-        ]
-
-    def _rewrite(
-        self,
-        subject: AST_NODE,
-        symbol_mapping: dict[HandleBinding, tuple[str, QuantumType]],
-    ) -> AST_NODE:
-        class ReplaceSplitVars(Transformer):
-            @staticmethod
-            def visit_HandleBinding(handle: HandleBinding) -> HandleBinding:
-                handle = handle.collapse()
-                for handle_to_replace, replacement in symbol_mapping.items():
-                    handle = handle.replace_prefix(
-                        handle_to_replace, HandleBinding(name=replacement[0])
-                    )
-                return handle
-
-            @staticmethod
-            def visit_Expression(expr: Expression) -> Expression:
-                return self._update_op_expression(symbol_mapping, expr)
-
-        return ReplaceSplitVars().visit(subject)

classiq/model_expansions/quantum_operations/inplace_binary_operation.py

@@ -31,7 +31,7 @@ from classiq.model_expansions.evaluators.parameter_types import (
 from classiq.model_expansions.evaluators.quantum_type_utils import (
     validate_inplace_binary_op_vars,
 )
-from classiq.model_expansions.quantum_operations.emitter import Emitter
+from classiq.model_expansions.quantum_operations.call_emitter import CallEmitter
 from classiq.model_expansions.scope import QuantumSymbol, Scope
 from classiq.qmod.builtins.functions import (
     CX,
@@ -59,7 +59,7 @@ def _binary_function_declaration(
     }[constant][op]
 
 
-class InplaceBinaryOperationEmitter(Emitter[InplaceBinaryOperation]):
+class InplaceBinaryOperationEmitter(CallEmitter[InplaceBinaryOperation]):
     def emit(self, op: InplaceBinaryOperation, /) -> None:
         if isinstance(op.value, Expression):
             self._emit_constant_operation(op)

classiq/model_expansions/quantum_operations/invert.py

@@ -4,11 +4,11 @@ from classiq.interface.generator.functions.builtins.internal_operators import (
 from classiq.interface.model.invert import Invert
 
 from classiq.model_expansions.closure import Closure
-from classiq.model_expansions.quantum_operations.emitter import Emitter
+from classiq.model_expansions.quantum_operations.call_emitter import CallEmitter
 from classiq.model_expansions.scope import Scope
 
 
-class InvertEmitter(Emitter[Invert]):
+class InvertEmitter(CallEmitter[Invert]):
     def emit(self, invert: Invert, /) -> None:
         with self._propagated_var_stack.capture_variables(invert):
             self._emit_propagated(invert)

classiq/model_expansions/quantum_operations/phase.py

@@ -41,7 +41,9 @@ class PhaseEmitter(ExpressionOperationEmitter[PhaseOperation]):
     def emit(self, phase_op: PhaseOperation, /) -> None:
         phase_expression = self._evaluate_op_expression(phase_op)
         phase_op = phase_op.model_copy(update=dict(expression=phase_expression))
-        arrays_with_subscript = self._get_symbols_to_split(phase_op.expression)
+        arrays_with_subscript = self.split_symbols(
+            phase_op.expression, self._counted_name_allocator.allocate
+        )
         if len(arrays_with_subscript) > 0:
             self._emit_with_split(phase_op, phase_op.expression, arrays_with_subscript)
             return

classiq/model_expansions/quantum_operations/power.py

@@ -13,11 +13,11 @@ from classiq.interface.generator.functions.builtins.internal_operators import (
 from classiq.interface.model.power import Power
 
 from classiq.model_expansions.closure import Closure
-from classiq.model_expansions.quantum_operations.emitter import Emitter
+from classiq.model_expansions.quantum_operations.call_emitter import CallEmitter
 from classiq.model_expansions.scope import Scope
 
 
-class PowerEmitter(Emitter[Power]):
+class PowerEmitter(CallEmitter[Power]):
     _power_value: Union[int, sympy.Basic]
     _power_expr: Expression
 

classiq/model_expansions/quantum_operations/quantum_assignment_operation.py

@@ -20,10 +20,7 @@ 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 (
-    QuantumNumeric,
-    QuantumType,
-)
+from classiq.interface.model.quantum_type import QuantumNumeric
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
@@ -35,6 +32,7 @@ from classiq.model_expansions.quantum_operations.expression_operation import (
     ExpressionOperationEmitter,
 )
 from classiq.model_expansions.scope import QuantumSymbol
+from classiq.model_expansions.transformers.var_splitter import SymbolParts
 from classiq.model_expansions.visitors.boolean_expression_transformers import (
     BooleanExpressionFuncLibAdapter,
     BooleanExpressionOptimizer,
@@ -70,7 +68,9 @@ class QuantumAssignmentOperationEmitter(
         new_expression = self._evaluate_op_expression(op)
         if self._skip_assignment(op, new_expression.expr):
             return
-        arrays_with_subscript = self._get_symbols_to_split(new_expression)
+        arrays_with_subscript = self.split_symbols(
+            new_expression, self._counted_name_allocator.allocate
+        )
         if len(arrays_with_subscript) > 0:
             self._emit_with_split(op, new_expression, arrays_with_subscript)
             return
@@ -230,12 +230,10 @@ class QuantumAssignmentOperationEmitter(
         return True
 
     def _get_updated_op_split_symbols(
-        self,
-        op: QuantumAssignmentOperation,
-        symbol_mapping: dict[HandleBinding, tuple[str, QuantumType]],
+        self, op: QuantumAssignmentOperation, symbol_parts: SymbolParts
     ) -> QuantumAssignmentOperation:
         return op.model_copy(
-            update=dict(result_var=self._rewrite(op.result_var, symbol_mapping))
+            update=dict(result_var=self.rewrite(op.result_var, symbol_parts))
         )
 
 

classiq/model_expansions/quantum_operations/quantum_function_call.py

@@ -3,14 +3,14 @@ from typing import TYPE_CHECKING
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 
 from classiq.model_expansions.closure import FunctionClosure
-from classiq.model_expansions.quantum_operations.emitter import Emitter
+from classiq.model_expansions.quantum_operations.call_emitter import CallEmitter
 from classiq.qmod.semantics.error_manager import ErrorManager
 
 if TYPE_CHECKING:
     from classiq.model_expansions.interpreter import Interpreter
 
 
-class QuantumFunctionCallEmitter(Emitter[QuantumFunctionCall]):
+class QuantumFunctionCallEmitter(CallEmitter[QuantumFunctionCall]):
     def __init__(self, interpreter: "Interpreter") -> None:
         super().__init__(interpreter)
         self._model = self._interpreter._model

classiq/model_expansions/quantum_operations/repeat.py

@@ -10,12 +10,12 @@ from classiq.interface.model.classical_parameter_declaration import (
 from classiq.interface.model.repeat import Repeat
 
 from classiq.model_expansions.closure import FunctionClosure, GenerativeFunctionClosure
-from classiq.model_expansions.quantum_operations.emitter import Emitter
+from classiq.model_expansions.quantum_operations.call_emitter import CallEmitter
 from classiq.model_expansions.scope import Scope
 from classiq.qmod.quantum_function import GenerativeQFunc
 
 
-class RepeatEmitter(Emitter[Repeat]):
+class RepeatEmitter(CallEmitter[Repeat]):
     def emit(self, repeat: Repeat, /) -> None:
         count = self._interpreter.evaluate(repeat.count).as_type(int)
         if count < 0:

classiq/model_expansions/transformers/var_splitter.py

@@ -0,0 +1,237 @@
+import ast
+from dataclasses import dataclass
+from itertools import chain
+from typing import TYPE_CHECKING, Callable, TypeVar
+
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.visitor import NodeType, Transformer
+from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.handle_binding import (
+    HandleBinding,
+    NestedHandleBinding,
+    SlicedHandleBinding,
+)
+from classiq.interface.model.quantum_type import (
+    QuantumBitvector,
+    QuantumScalar,
+    QuantumType,
+)
+from classiq.interface.model.variable_declaration_statement import (
+    VariableDeclarationStatement,
+)
+
+from classiq.model_expansions.scope import QuantumSymbol, Scope
+from classiq.model_expansions.visitors.variable_references import VarRefCollector
+
+AST_NODE = TypeVar("AST_NODE", bound=NodeType)
+
+
+@dataclass(frozen=True)
+class SymbolPart:
+    source_handle: HandleBinding
+    target_var_name: str
+    target_var_type: QuantumType
+
+    @property
+    def target_var_handle(self) -> HandleBinding:
+        return HandleBinding(name=self.target_var_name)
+
+
+SymbolParts = dict[QuantumSymbol, list[SymbolPart]]
+PartNamer = Callable[[str], str]
+
+
+class VarSplitter:
+    def __init__(self, scope: Scope):
+        self._scope = scope
+
+    def split_symbols(self, expression: Expression, namer: PartNamer) -> SymbolParts:
+        vrc = VarRefCollector(ignore_duplicated_handles=True)
+        vrc.visit(ast.parse(expression.expr))
+        symbol_names_to_split = dict.fromkeys(
+            handle.name
+            for handle in self._get_handles(vrc)
+            if isinstance(handle, NestedHandleBinding)
+        )
+
+        symbol_handles = {
+            symbol: list(
+                dict.fromkeys(
+                    handle.collapse()
+                    for handle in vrc.var_handles
+                    if handle.name == symbol.handle.name
+                )
+            )
+            for symbol_name in symbol_names_to_split
+            if isinstance(
+                symbol := self._scope[symbol_name].value,
+                QuantumSymbol,
+            )
+        }
+
+        return {
+            symbol: [
+                SymbolPart(
+                    source_handle=part.handle,
+                    target_var_name=namer(part.handle.identifier),
+                    target_var_type=part.quantum_type,
+                )
+                for part in self._get_symbol_parts(symbol, handles)
+            ]
+            for symbol, handles in symbol_handles.items()
+        }
+
+    def _get_handles(self, collector: VarRefCollector) -> list[HandleBinding]:
+        return [
+            handle
+            for handle in collector.var_handles
+            if isinstance(self._scope[handle.name].value, QuantumSymbol)
+        ]
+
+    def _get_symbol_parts(
+        self, symbol: QuantumSymbol, target_parts: list[HandleBinding]
+    ) -> list[QuantumSymbol]:
+        for i in range(len(target_parts)):
+            for j in range(i + 1, len(target_parts)):
+                if target_parts[i].overlaps(target_parts[j]):
+                    raise ClassiqInternalExpansionError(
+                        f"Handles {str(target_parts[i])!r} and "
+                        f"{str(target_parts[j])!r} overlapping in expression"
+                    )
+        return self._get_symbol_parts_unsafe(symbol, target_parts)
+
+    def _get_symbol_parts_unsafe(
+        self, symbol: QuantumSymbol, target_parts: list[HandleBinding]
+    ) -> list[QuantumSymbol]:
+        if all(
+            symbol.handle == target_part or symbol.handle not in target_part.prefixes()
+            for target_part in target_parts
+        ) or isinstance(symbol.quantum_type, QuantumScalar):
+            return [symbol]
+
+        if isinstance(symbol.quantum_type, QuantumBitvector):
+            return self._get_array_parts(symbol, target_parts)
+
+        return self._get_struct_parts(symbol, target_parts)
+
+    def _get_array_parts(
+        self, symbol: QuantumSymbol, target_parts: list[HandleBinding]
+    ) -> list[QuantumSymbol]:
+        if TYPE_CHECKING:
+            assert isinstance(symbol.quantum_type, QuantumBitvector)
+
+        if not symbol.quantum_type.has_length:
+            raise ClassiqExpansionError(
+                f"Could not determine the length of quantum array " f"{symbol.handle}."
+            )
+        target_slices = {
+            target_part.start.to_int_value(): target_part.end.to_int_value()
+            for target_part in target_parts
+            if isinstance(target_part, SlicedHandleBinding)
+            and symbol.handle == target_part.base_handle
+        }
+
+        symbol_parts: list[QuantumSymbol] = []
+        idx = 0
+        while idx < symbol.quantum_type.length_value:
+            if idx in target_slices:
+                stop = target_slices[idx]
+                if stop <= idx:
+                    raise ClassiqInternalExpansionError(
+                        f"Illegal sliced handle {str(symbol[idx: stop].handle)!r}"
+                    )
+                symbol_parts.append(symbol[idx:stop])
+                idx = stop
+            else:
+                symbol_parts.extend(
+                    self._get_symbol_parts_unsafe(symbol[idx], target_parts)
+                )
+                idx += 1
+
+        return symbol_parts
+
+    def _get_struct_parts(
+        self, symbol: QuantumSymbol, target_parts: list[HandleBinding]
+    ) -> list[QuantumSymbol]:
+        return list(
+            chain.from_iterable(
+                self._get_symbol_parts_unsafe(field_symbol, target_parts)
+                for field_symbol in symbol.fields.values()
+            )
+        )
+
+    @staticmethod
+    def get_bind_ops(symbol_parts: SymbolParts) -> list[BindOperation]:
+        return [
+            BindOperation(
+                in_handles=[symbol.handle],
+                out_handles=[part.target_var_handle for part in parts],
+            )
+            for symbol, parts in symbol_parts.items()
+        ]
+
+    @staticmethod
+    def get_var_decls(symbol_parts: SymbolParts) -> list[VariableDeclarationStatement]:
+        return [
+            VariableDeclarationStatement(
+                name=part.target_var_name,
+                quantum_type=part.target_var_type,
+            )
+            for part in chain.from_iterable(symbol_parts.values())
+        ]
+
+    def _check_all_handles_were_replaced(self, new_expr_str: str) -> None:
+        vrc = VarRefCollector(ignore_duplicated_handles=True)
+        vrc.visit(ast.parse(new_expr_str))
+        for handle in self._get_handles(vrc):
+            if isinstance(handle, NestedHandleBinding):
+                raise ClassiqInternalExpansionError(f"Did not replace handle {handle}")
+
+    def rewrite(self, subject: AST_NODE, symbol_mapping: SymbolParts) -> AST_NODE:
+        handle_replacements = {
+            part.source_handle: part.target_var_handle
+            for parts in symbol_mapping.values()
+            for part in parts
+        }
+
+        class ReplaceSplitVars(Transformer):
+            @staticmethod
+            def visit_HandleBinding(handle: HandleBinding) -> HandleBinding:
+                handle = handle.collapse()
+                for handle_to_replace, replacement in handle_replacements.items():
+                    handle = handle.replace_prefix(handle_to_replace, replacement)
+                return handle
+
+            @staticmethod
+            def visit_Expression(expr: Expression) -> Expression:
+                return self._rewrite_expression(symbol_mapping, expr)
+
+        return ReplaceSplitVars().visit(subject)
+
+    def _rewrite_expression(
+        self,
+        symbol_mapping: SymbolParts,
+        expression: Expression,
+    ) -> Expression:
+        vrc = VarRefCollector(ignore_duplicated_handles=True)
+        vrc.visit(ast.parse(expression.expr))
+
+        handle_names = {
+            part.source_handle: part.target_var_name
+            for parts in symbol_mapping.values()
+            for part in parts
+        }
+        new_expr_str = expression.expr
+        for handle in vrc.var_handles:
+            collapsed_handle = handle.collapse()
+            if collapsed_handle in handle_names:
+                new_expr_str = new_expr_str.replace(
+                    str(handle), handle_names[collapsed_handle]
+                )
+        self._check_all_handles_were_replaced(new_expr_str)
+
+        return Expression(expr=new_expr_str)

classiq/qmod/builtins/classical_functions.py

@@ -1,5 +1,6 @@
 # This file was generated automatically - do not edit manually
 
+
 from classiq.qmod.qmod_parameter import CArray, CBool, CInt, CReal
 from classiq.qmod.symbolic import symbolic_function
 

classiq/qmod/builtins/functions/state_preparation.py

@@ -415,7 +415,7 @@ def inplace_prepare_int(value: CInt, target: QArray[QBit]) -> None:
 @qfunc(external=True)
 def prepare_int(
     value: CInt,
-    out: Output[QNum[Literal["floor(log(value, 2)) + 1"], Literal[False], Literal[0]]],
+    out: Output[QNum[Literal["floor(log(value, 2)) + 1"]]],
 ) -> None:
     """
     [Qmod Classiq-library function]