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

classiq/model_expansions/quantum_operations/emitter.py

@@ -1,61 +1,38 @@
 from abc import abstractmethod
-from collections.abc import Sequence
 from typing import (
     TYPE_CHECKING,
     Generic,
     Optional,
     TypeVar,
     Union,
-    cast,
 )
 
 import sympy
 
-from classiq.interface.debug_info.debug_info import FunctionDebugInfo
 from classiq.interface.generator.expressions.evaluated_expression import (
     EvaluatedExpression,
 )
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.generated_circuit_data import OperationLevel
-from classiq.interface.model.classical_parameter_declaration import (
-    ClassicalParameterDeclaration,
-)
-from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
-from classiq.interface.model.port_declaration import PortDeclaration
-from classiq.interface.model.quantum_function_call import ArgValue, QuantumFunctionCall
 from classiq.interface.model.quantum_function_declaration import (
     NamedParamsQuantumFunctionDeclaration,
-    PositionalArg,
 )
 from classiq.interface.model.quantum_statement import QuantumOperation, QuantumStatement
-from classiq.interface.model.variable_declaration_statement import (
-    VariableDeclarationStatement,
-)
 
 from classiq.model_expansions.capturing.propagated_var_stack import (
     PropagatedVarStack,
-    validate_args_are_not_propagated,
 )
 from classiq.model_expansions.closure import Closure, FunctionClosure, GenerativeClosure
-from classiq.model_expansions.evaluators.argument_types import (
-    add_information_from_output_arguments,
-)
-from classiq.model_expansions.evaluators.parameter_types import (
-    evaluate_parameter_types_from_args,
-)
 from classiq.model_expansions.function_builder import (
     FunctionContext,
     OperationBuilder,
     OperationContext,
 )
-from classiq.model_expansions.generative_functions import emit_operands_as_declarative
-from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
+from classiq.model_expansions.scope import 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.qmod.builtins.functions import allocate, free
 from classiq.qmod.quantum_function import GenerativeQFunc
 
 if TYPE_CHECKING:
@@ -116,168 +93,6 @@ class Emitter(Generic[QuantumStatementT]):
     def _counted_name_allocator(self) -> CountedNameAllocator:
         return self._interpreter._counted_name_allocator
 
-    @staticmethod
-    def _should_wrap(body: Sequence[QuantumStatement]) -> bool:
-        # This protects shadowing of captured variables (i.e, bad user code) by wrapping the body in a function
-        # I'm sure there are better ways to handle it, but this is the simplest way to do it for now
-        return any(isinstance(stmt, VariableDeclarationStatement) for stmt in body)
-
-    def _create_expanded_wrapping_function(
-        self, name: str, body: Sequence[QuantumStatement]
-    ) -> QuantumFunctionCall:
-        wrapping_function = FunctionClosure.create(
-            name=name, body=body, scope=Scope(parent=self._current_scope)
-        )
-        return self._create_quantum_function_call(wrapping_function, list())
-
-    def _emit_quantum_function_call(
-        self, function: FunctionClosure, args: list[ArgValue]
-    ) -> QuantumFunctionCall:
-        call = self._create_quantum_function_call(function, args)
-        self._builder.emit_statement(call)
-        return call
-
-    def _create_quantum_function_call(
-        self, function: FunctionClosure, args: list[ArgValue]
-    ) -> QuantumFunctionCall:
-        evaluated_args = [self._interpreter.evaluate(arg) for arg in args]
-        new_declaration = self._prepare_fully_typed_declaration(
-            function, evaluated_args
-        )
-        new_positional_arg_decls = new_declaration.positional_arg_declarations
-        is_atomic = function.is_atomic
-        new_function_name = function.name
-        if not is_atomic:  # perform monomorphization per interpreted parameters set
-            self._add_params_to_scope(
-                new_positional_arg_decls, evaluated_args, function
-            )
-            context = self._expand_operation(
-                function.with_new_declaration(new_declaration)
-            )
-            function_context = cast(FunctionContext, context)
-            closure_id = function_context.closure.closure_id
-            function_def = self._expanded_functions.get(closure_id)
-            if function_def is None:
-                function_def = self._builder.create_definition(function_context)
-                self._expanded_functions[closure_id] = function_def
-                self._top_level_scope[function_def.name] = Evaluated(
-                    value=function_context.closure.with_new_declaration(function_def)
-                )
-            new_declaration = function_def
-            new_function_name = function_def.name
-            compilation_metadata = self._functions_compilation_metadata.get(
-                function.name
-            )
-            if compilation_metadata is not None:
-                self._expanded_functions_compilation_metadata[new_function_name] = (
-                    compilation_metadata
-                )
-
-        new_positional_args = self._get_new_positional_args(
-            evaluated_args, is_atomic, new_positional_arg_decls
-        )
-        new_call = QuantumFunctionCall(
-            function=new_function_name,
-            positional_args=new_positional_args,
-        )
-        is_allocate_or_free = (
-            new_call.func_name == allocate.func_decl.name
-            or new_call.func_name == free.func_decl.name
-        )
-        parameters = {
-            arg_decl.name: FunctionDebugInfo.param_controller(value=evaluated_arg.value)
-            for arg_decl, evaluated_arg in zip(new_positional_arg_decls, evaluated_args)
-            if isinstance(arg_decl, ClassicalParameterDeclaration)
-        }
-
-        port_to_passed_variable_map = {
-            arg_decl.name: str(evaluated_arg.value.handle)
-            for arg_decl, evaluated_arg in zip(new_positional_arg_decls, evaluated_args)
-            if isinstance(arg_decl, PortDeclaration)
-        }
-        self._interpreter._model.debug_info[new_call.uuid] = FunctionDebugInfo(
-            name=new_call.func_name,
-            level=OperationLevel.QMOD_FUNCTION_CALL,
-            parameters=parameters,
-            is_allocate_or_free=is_allocate_or_free,
-            port_to_passed_variable_map=port_to_passed_variable_map,
-        )
-        new_call.set_func_decl(new_declaration)
-        return new_call
-
-    @staticmethod
-    def _add_params_to_scope(
-        parameters: Sequence[PositionalArg],
-        arguments: Sequence[Evaluated],
-        closure: FunctionClosure,
-    ) -> None:
-        for parameter, argument in zip(parameters, arguments):
-            if isinstance(argument.value, QuantumSymbol):
-                assert isinstance(parameter, PortDeclaration)
-                closure.scope[parameter.name] = Evaluated(
-                    QuantumSymbol(
-                        handle=HandleBinding(name=parameter.name),
-                        quantum_type=parameter.quantum_type,
-                    ),
-                    defining_function=closure,
-                )
-            else:
-                closure.scope[parameter.name] = argument
-
-    def _get_new_positional_args(
-        self,
-        evaluated_args: list[Evaluated],
-        is_atomic: bool,
-        new_positional_arg_decls: Sequence[PositionalArg],
-    ) -> list[ArgValue]:
-        evaluated_args = add_information_from_output_arguments(
-            new_positional_arg_decls, evaluated_args
-        )
-        if is_atomic:
-            return [
-                emit_operands_as_declarative(self._interpreter, param, arg)
-                for param, arg in zip(new_positional_arg_decls, evaluated_args)
-            ]
-
-        positional_args = [
-            arg.emit() for arg in evaluated_args if isinstance(arg.value, QuantumSymbol)
-        ]
-
-        propagated_variables = self._propagated_var_stack.get_propagated_variables(
-            flatten=True
-        )
-        validate_args_are_not_propagated(positional_args, propagated_variables)
-        positional_args.extend(propagated_variables)
-
-        return positional_args
-
-    def _prepare_fully_typed_declaration(
-        self, function: FunctionClosure, evaluated_args: list[Evaluated]
-    ) -> NamedParamsQuantumFunctionDeclaration:
-        """
-        Given, for example,
-        def my_func(x: int, q: QArray["x"], p: QArray[]) -> None:
-        ...
-        def main(...):
-            ...
-            allocate(5, s)
-            my_func(3, r, s)
-        The code below will evaluate x to be 3, q to be of size 3 and p to be of size 5.
-        Note that it requires a scope for the parameter declaration space, which is
-        different from the call scope. For example, the former uses r,s and the latter
-        uses p, q.
-        """
-        with self._scope_guard(Scope(parent=self._current_scope)):
-            # The signature scope is passed as a separate argument to avoid contaminating the statement execution scope
-            return NamedParamsQuantumFunctionDeclaration(
-                name=function.name,
-                positional_arg_declarations=evaluate_parameter_types_from_args(
-                    function,
-                    function.signature_scope,
-                    evaluated_args,
-                ),
-            )
-
     def _register_generative_context(
         self,
         op: QuantumOperation,

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: