classiq 0.38.0__py3-none-any.whl → 0.65.3__py3-none-any.whl

classiq/model_expansions/quantum_operations/call_emitter.py

@@ -0,0 +1,266 @@
+from collections.abc import Sequence
+from itertools import chain
+from typing import (
+    TYPE_CHECKING,
+    Generic,
+    Optional,
+    cast,
+)
+
+from classiq.interface.debug_info.debug_info import FunctionDebugInfo
+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 QuantumStatement
+from classiq.interface.model.variable_declaration_statement import (
+    VariableDeclarationStatement,
+)
+
+from classiq.model_expansions.capturing.captured_vars import (
+    validate_args_are_not_propagated,
+)
+from classiq.model_expansions.closure import FunctionClosure
+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,
+)
+from classiq.model_expansions.quantum_operations.emitter import (
+    Emitter,
+    QuantumStatementT,
+)
+from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
+from classiq.model_expansions.transformers.var_splitter import VarSplitter
+from classiq.qmod.builtins.functions import allocate, free
+
+if TYPE_CHECKING:
+    from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
+
+
+class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSplitter):
+    def __init__(self, interpreter: "BaseInterpreter") -> None:
+        Emitter.__init__(self, interpreter)
+        VarSplitter.__init__(self, interpreter._builder.current_scope)
+
+    @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=self._counted_name_allocator.allocate(name),
+            body=body,
+            scope=Scope(parent=self._current_scope),
+            is_lambda=True,
+        )
+        return self._create_quantum_function_call(wrapping_function, list())
+
+    def _emit_quantum_function_call(
+        self,
+        function: FunctionClosure,
+        args: list[ArgValue],
+        propagated_debug_info: Optional[FunctionDebugInfo] = None,
+    ) -> QuantumFunctionCall:
+        call = self._create_quantum_function_call(
+            function, args, propagated_debug_info=propagated_debug_info
+        )
+        self.emit_statement(call)
+        return call
+
+    def _create_quantum_function_call(
+        self,
+        function: FunctionClosure,
+        args: list[ArgValue],
+        propagated_debug_info: Optional[FunctionDebugInfo] = None,
+    ) -> QuantumFunctionCall:
+        function = function.clone()
+        function = function.set_depth(self._builder.current_function.depth + 1)
+        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
+        if not self.should_expand_function(function, evaluated_args):
+            is_atomic = True
+            new_declaration = self._expanded_functions_by_name.get(
+                function.name, new_declaration
+            )
+        else:
+            is_atomic = False
+            new_declaration = self._expand_function(
+                evaluated_args, new_declaration, function
+            )
+
+        new_positional_args = self._get_new_positional_args(
+            evaluated_args, is_atomic, new_positional_arg_decls
+        )
+        captured_args = function.captured_vars.get_captured_args(
+            self._builder.current_function
+        )
+        validate_args_are_not_propagated(new_positional_args, captured_args)
+        new_positional_args.extend(captured_args)
+        new_call = QuantumFunctionCall(
+            function=new_declaration.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._debug_info[new_call.uuid] = FunctionDebugInfo(
+            name=new_call.func_name,
+            level=OperationLevel.QMOD_FUNCTION_CALL,
+            parameters=(
+                parameters
+                if propagated_debug_info is None
+                else propagated_debug_info.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
+
+    def should_expand_function(
+        self, function: FunctionClosure, args: list[Evaluated]
+    ) -> bool:
+        return not function.is_atomic
+
+    def _expand_function(
+        self,
+        args: list[Evaluated],
+        decl: NamedParamsQuantumFunctionDeclaration,
+        function: FunctionClosure,
+    ) -> NamedParamsQuantumFunctionDeclaration:
+        self._add_params_to_scope(decl.positional_arg_declarations, args, function)
+        context = self._expand_operation(function.with_new_declaration(decl))
+        function_context = cast(FunctionContext, context)
+        closure_id = function_context.closure.closure_id
+        if closure_id in self._expanded_functions:
+            function_def = self._expanded_functions[closure_id]
+            self._expanded_functions_compilation_metadata[
+                function_def.name
+            ].occurrences_number += 1
+            return function_def
+
+        function_def = self._create_function_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)
+        )
+        compilation_metadata = self._functions_compilation_metadata.get(function.name)
+        if compilation_metadata is not None:
+            self._expanded_functions_compilation_metadata[function_def.name] = (
+                compilation_metadata
+            )
+        return function_def
+
+    def _create_function_definition(
+        self, function_context: FunctionContext
+    ) -> NativeFunctionDefinition:
+        func_def = self._builder.create_definition(function_context)
+
+        captured_ports = function_context.closure.captured_vars.get_captured_ports()
+        if len(captured_ports) == 0:
+            return func_def
+        func_def.positional_arg_declarations = list(
+            chain.from_iterable((func_def.positional_arg_declarations, captured_ports))
+        )
+
+        if not function_context.is_lambda:
+            return func_def
+        func_def.body = self.rewrite(
+            func_def.body, function_context.closure.captured_vars.get_captured_mapping()
+        )
+
+        return func_def
+
+    @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 [arg.emit() for arg in evaluated_args]
+
+        positional_args = [
+            arg.emit() for arg in evaluated_args if isinstance(arg.value, QuantumSymbol)
+        ]
+
+        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.
+        """
+        # 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,
+            ),
+        )

classiq/model_expansions/quantum_operations/classicalif.py

@@ -0,0 +1,53 @@
+from collections.abc import Sequence
+
+from classiq.interface.model.classical_if import ClassicalIf
+from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+from classiq.interface.model.quantum_statement import QuantumStatement
+
+from classiq.model_expansions.closure import FunctionClosure
+from classiq.model_expansions.quantum_operations.call_emitter import CallEmitter
+from classiq.model_expansions.scope import Scope
+
+
+def _is_all_identity_calls(body: Sequence[QuantumStatement]) -> bool:
+    return all(
+        isinstance(stmt, QuantumFunctionCall) and stmt.func_name.lower() == "identity"
+        for stmt in body
+    )
+
+
+class ClassicalIfEmitter(CallEmitter[ClassicalIf]):
+    def emit(self, classical_if: ClassicalIf, /) -> None:
+        condition = self._interpreter.evaluate(classical_if.condition).as_type(bool)
+        op_name = "then" if condition else "else"
+        is_generative = classical_if.is_generative()
+
+        body: Sequence[QuantumStatement]
+        if is_generative:
+            if not classical_if.has_generative_block(op_name):
+                return
+            context = self._expand_generative_context(classical_if, op_name, op_name)
+            context.blocks["body"] = context.blocks[op_name]
+            context.blocks.pop(op_name)
+            body = context.statements("body")
+        else:
+            body = classical_if.then if condition else classical_if.else_
+
+        if _is_all_identity_calls(body):
+            return
+
+        if is_generative or not self._should_wrap(body):
+            for stmt in body:
+                if is_generative:
+                    self._interpreter._builder.emit_statement(stmt)
+                else:
+                    self._interpreter.emit_statement(stmt)
+            return
+
+        then_else_func = FunctionClosure.create(
+            name=self._counted_name_allocator.allocate("then" if condition else "else"),
+            body=body,
+            scope=Scope(parent=self._current_scope),
+            is_lambda=True,
+        )
+        self._emit_quantum_function_call(then_else_func, list())

classiq/model_expansions/quantum_operations/declarative_call_emitter.py

@@ -0,0 +1,87 @@
+from itertools import chain
+from typing import TYPE_CHECKING, Generic
+
+from classiq.interface.generator.functions.port_declaration import (
+    PortDeclarationDirection,
+)
+from classiq.interface.model.port_declaration import PortDeclaration
+
+from classiq.model_expansions.closure import FunctionClosure, GenerativeClosure
+from classiq.model_expansions.quantum_operations.call_emitter import CallEmitter
+from classiq.model_expansions.quantum_operations.emitter import QuantumStatementT
+from classiq.model_expansions.scope import Evaluated
+from classiq.qmod.model_state_container import QMODULE
+
+if TYPE_CHECKING:
+    from classiq.model_expansions.interpreters.generative_interpreter import (
+        GenerativeInterpreter,
+    )
+
+
+class DeclarativeCallEmitter(
+    Generic[QuantumStatementT], CallEmitter[QuantumStatementT]
+):
+    _interpreter: "GenerativeInterpreter"
+
+    def __init__(self, interpreter: "GenerativeInterpreter") -> None:
+        super().__init__(interpreter)
+
+    def should_expand_function(
+        self, function: FunctionClosure, args: list[Evaluated]
+    ) -> bool:
+        if not super().should_expand_function(function, args):
+            return False
+
+        if self._is_function_purely_declarative(
+            function
+        ) and self._are_args_purely_declarative(args):
+            self._interpreter.add_purely_declarative_function(function)
+            return False
+
+        return True
+
+    def _is_function_purely_declarative(self, function: FunctionClosure) -> bool:
+        if function.name not in QMODULE.native_defs:
+            return False
+
+        if isinstance(function, GenerativeClosure):
+            return False
+
+        if any(
+            not param.quantum_type.is_instantiated
+            for param in function.positional_arg_declarations
+            if isinstance(param, PortDeclaration)
+            and param.direction == PortDeclarationDirection.Output
+        ):
+            return False
+
+        dependencies = QMODULE.function_dependencies[function.name]
+        return self._are_identifiers_purely_declarative(dependencies)
+
+    def _are_args_purely_declarative(self, args: list[Evaluated]) -> bool:
+        values = [arg.value for arg in args]
+        function_inputs: list[FunctionClosure] = list(
+            chain.from_iterable(
+                (
+                    [arg]
+                    if isinstance(arg, FunctionClosure)
+                    else (
+                        arg
+                        if isinstance(arg, list)
+                        and any(isinstance(item, FunctionClosure) for item in arg)
+                        else []
+                    )
+                )
+                for arg in values
+            )
+        )
+        if any(func.is_lambda for func in function_inputs):
+            return False
+        dependencies = [func.name for func in function_inputs if not func.is_lambda]
+        return self._are_identifiers_purely_declarative(dependencies)
+
+    def _are_identifiers_purely_declarative(self, dependencies: list[str]) -> bool:
+        return not any(
+            isinstance(self._current_scope[dep].value, GenerativeClosure)
+            for dep in dependencies
+        )

classiq/model_expansions/quantum_operations/emitter.py

@@ -0,0 +1,181 @@
+import ast
+from abc import abstractmethod
+from typing import (
+    TYPE_CHECKING,
+    Generic,
+    Optional,
+    TypeVar,
+    Union,
+)
+
+import sympy
+
+from classiq.interface.debug_info.debug_info import DebugInfoCollection
+from classiq.interface.exceptions import ClassiqInternalExpansionError
+from classiq.interface.generator.expressions.evaluated_expression import (
+    EvaluatedExpression,
+)
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.port_declaration import (
+    PortDeclarationDirection,
+)
+from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
+from classiq.interface.model.handle_binding import HandleBinding
+from classiq.interface.model.native_function_definition import NativeFunctionDefinition
+from classiq.interface.model.quantum_function_declaration import (
+    NamedParamsQuantumFunctionDeclaration,
+)
+from classiq.interface.model.quantum_statement import QuantumOperation, QuantumStatement
+
+from classiq.model_expansions.closure import Closure, 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:
+    from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
+
+QuantumStatementT = TypeVar("QuantumStatementT", bound=QuantumStatement)
+
+
+class Emitter(Generic[QuantumStatementT]):
+    def __init__(self, interpreter: "BaseInterpreter") -> None:
+        self._interpreter = interpreter
+
+        self._machine_precision = self._interpreter._model.preferences.machine_precision
+        self._expanded_functions_compilation_metadata = (
+            self._interpreter._expanded_functions_compilation_metadata
+        )
+        self._functions_compilation_metadata = (
+            self._interpreter._functions_compilation_metadata
+        )
+
+    @abstractmethod
+    def emit(self, statement: QuantumStatementT, /) -> None:
+        pass
+
+    def _expand_operation(self, closure: Closure) -> OperationContext:
+        return self._interpreter._expand_operation(closure)
+
+    @property
+    def _builder(self) -> OperationBuilder:
+        return self._interpreter._builder
+
+    @property
+    def _current_scope(self) -> Scope:
+        return self._builder.current_scope
+
+    @property
+    def _top_level_scope(self) -> Scope:
+        return self._interpreter._top_level_scope
+
+    @property
+    def _expanded_functions(self) -> dict[str, NativeFunctionDefinition]:
+        return self._interpreter._expanded_functions
+
+    @property
+    def _expanded_functions_by_name(self) -> dict[str, NativeFunctionDefinition]:
+        return nameables_to_dict(list(self._interpreter._expanded_functions.values()))
+
+    @property
+    def _counted_name_allocator(self) -> CountedNameAllocator:
+        return self._interpreter._counted_name_allocator
+
+    @property
+    def _debug_info(self) -> DebugInfoCollection:
+        return self._interpreter._model.debug_info
+
+    def _expand_generative_context(
+        self,
+        op: QuantumOperation,
+        context_name: str,
+        block_names: Union[None, str, list[str]] = None,
+        func_decl: Optional[NamedParamsQuantumFunctionDeclaration] = None,
+    ) -> OperationContext:
+        if isinstance(block_names, str):
+            block_names = [block_names]
+        block_names = block_names or ["body"]
+        func_decl = func_decl or NamedParamsQuantumFunctionDeclaration(
+            name=context_name
+        )
+        gen_closure = GenerativeClosure(
+            name=func_decl.name,
+            scope=Scope(parent=self._interpreter._builder.current_scope),
+            blocks={},
+            generative_blocks={
+                block_name: GenerativeQFunc(
+                    op.get_generative_block(block_name), func_decl
+                )
+                for block_name in block_names
+            },
+        )
+        context = self._interpreter._expand_operation(gen_closure)
+        op.clear_generative_blocks()
+        return context
+
+    def _evaluate_expression(
+        self, expression: Expression, preserve_bool_ops: 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
+
+    def emit_statement(self, statement: QuantumStatement) -> None:
+        if isinstance(statement, QuantumOperation):
+            self._update_captured_vars(statement)
+        self._builder.emit_statement(statement)
+
+    def _update_captured_vars(self, op: QuantumOperation) -> None:
+        handles = (
+            [(handle, PortDeclarationDirection.Input) for handle in op.inputs]
+            + [(handle, PortDeclarationDirection.Output) for handle in op.outputs]
+            + [(handle, PortDeclarationDirection.Inout) for handle in op.inouts]
+        )
+        for handle, direction in handles:
+            self._capture_handle(handle, direction)
+
+    def _capture_handle(
+        self, handle: HandleBinding, direction: PortDeclarationDirection
+    ) -> None:
+        if handle.name not in self._current_scope:
+            return
+        defining_function = self._current_scope[handle.name].defining_function
+        if defining_function is None:
+            raise ClassiqInternalExpansionError
+        symbol: QuantumSymbol = self._interpreter.evaluate(handle).value
+        self._builder.current_block.captured_vars.capture_handle(
+            handle=symbol.handle,
+            quantum_type=symbol.quantum_type,
+            defining_function=defining_function,
+            direction=direction,
+        )
+
+    def capture_handles_in_expression(self, expr: Expression) -> None:
+        vrc = VarRefCollector(ignore_duplicated_handles=True)
+        vrc.visit(ast.parse(expr.expr))
+        handles = dict.fromkeys(
+            handle
+            for handle in vrc.var_handles
+            if isinstance(self._current_scope[handle.name].value, QuantumSymbol)
+        )
+        for handle in handles:
+            self._capture_handle(handle, PortDeclarationDirection.Inout)

classiq/model_expansions/quantum_operations/quantum_function_call.py

@@ -0,0 +1,33 @@
+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.call_emitter import CallEmitter
+from classiq.model_expansions.quantum_operations.declarative_call_emitter import (
+    DeclarativeCallEmitter,
+)
+from classiq.qmod.semantics.error_manager import ErrorManager
+
+if TYPE_CHECKING:
+    from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
+
+
+class QuantumFunctionCallEmitter(CallEmitter[QuantumFunctionCall]):
+    def __init__(self, interpreter: "BaseInterpreter") -> None:
+        super().__init__(interpreter)
+        self._model = self._interpreter._model
+
+    def emit(self, call: QuantumFunctionCall, /) -> None:
+        function = self._interpreter.evaluate(call.function).as_type(FunctionClosure)
+        args = call.positional_args
+        with ErrorManager().call(function.name):
+            self._emit_quantum_function_call(
+                function, args, self._debug_info.get(call.uuid)
+            )
+
+
+class DeclarativeQuantumFunctionCallEmitter(
+    QuantumFunctionCallEmitter, DeclarativeCallEmitter
+):
+    pass

classiq/model_expansions/quantum_operations/repeat.py

@@ -0,0 +1,56 @@
+from classiq.interface.exceptions import ClassiqExpansionError
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.builtins.internal_operators import (
+    REPEAT_OPERATOR_NAME,
+)
+from classiq.interface.generator.functions.classical_type import Integer
+from classiq.interface.model.classical_parameter_declaration import (
+    ClassicalParameterDeclaration,
+)
+from classiq.interface.model.repeat import Repeat
+
+from classiq.model_expansions.closure import FunctionClosure, GenerativeFunctionClosure
+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(CallEmitter[Repeat]):
+    def emit(self, repeat: Repeat, /) -> None:
+        count = self._interpreter.evaluate(repeat.count).as_type(int)
+        if count < 0:
+            raise ClassiqExpansionError(
+                f"repeat count must be non-negative, got {count}"
+            )
+        op_name = self._counted_name_allocator.allocate(REPEAT_OPERATOR_NAME)
+        for i in range(count):
+            self._emit_iteration(repeat, i, op_name)
+
+    def _emit_iteration(self, repeat: Repeat, i: int, op_name: str) -> None:
+        closure_constructor: type[FunctionClosure]
+        extra_args: dict
+        if repeat.is_generative():
+            closure_constructor = GenerativeFunctionClosure
+            extra_args = {
+                "generative_blocks": {
+                    "body": GenerativeQFunc(
+                        repeat.get_generative_block("body"),
+                    ),
+                }
+            }
+        else:
+            closure_constructor = FunctionClosure
+            extra_args = {}
+        iteration_function = closure_constructor.create(
+            name=op_name,
+            positional_arg_declarations=[
+                ClassicalParameterDeclaration(
+                    name=repeat.iter_var, classical_type=Integer()
+                )
+            ],
+            body=repeat.body,
+            scope=Scope(parent=self._current_scope),
+            is_lambda=True,
+            **extra_args,
+        )
+        self._emit_quantum_function_call(iteration_function, [Expression(expr=str(i))])