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

classiq/model_expansions/function_builder.py

@@ -0,0 +1,247 @@
+from collections.abc import Iterator, Sequence
+from contextlib import contextmanager
+from dataclasses import dataclass, field
+from typing import Generic, Optional, TypeVar
+
+from classiq.interface.exceptions import ClassiqInternalExpansionError
+from classiq.interface.generator.compiler_keywords import (
+    EXPANDED_KEYWORD,
+    LAMBDA_KEYWORD,
+)
+from classiq.interface.generator.functions.builtins.internal_operators import (
+    WITHIN_APPLY_NAME,
+)
+from classiq.interface.model.model import MAIN_FUNCTION_NAME
+from classiq.interface.model.native_function_definition import (
+    NativeFunctionDefinition,
+)
+from classiq.interface.model.port_declaration import PortDeclaration
+from classiq.interface.model.quantum_function_declaration import (
+    PositionalArg,
+)
+from classiq.interface.model.quantum_statement import QuantumStatement
+from classiq.interface.model.variable_declaration_statement import (
+    VariableDeclarationStatement,
+)
+from classiq.interface.source_reference import SourceReference
+
+from classiq.model_expansions.capturing.captured_vars import (
+    CapturedVars,
+    validate_captured_directions,
+)
+from classiq.model_expansions.closure import (
+    Closure,
+    FunctionClosure,
+    GenerativeFunctionClosure,
+)
+from classiq.model_expansions.evaluators.quantum_type_utils import (
+    is_signature_monomorphic,
+)
+from classiq.model_expansions.scope import Scope
+from classiq.model_expansions.utils.counted_name_allocator import CountedNameAllocator
+
+ClosureType = TypeVar("ClosureType", bound=Closure)
+
+
+@dataclass
+class Block:
+    statements: list[QuantumStatement] = field(default_factory=list)
+    captured_vars: CapturedVars = field(default_factory=CapturedVars)
+
+    @property
+    def variable_declarations(self) -> list[VariableDeclarationStatement]:
+        return [
+            stmt
+            for stmt in self.statements
+            if isinstance(stmt, VariableDeclarationStatement)
+        ]
+
+
+@dataclass
+class OperationContext(Generic[ClosureType]):
+    closure: ClosureType
+    blocks: dict[str, Block] = field(default_factory=dict)
+
+    @property
+    def name(self) -> str:
+        return self.closure.name
+
+    @property
+    def positional_arg_declarations(self) -> Sequence[PositionalArg]:
+        return self.closure.positional_arg_declarations
+
+    def statements(self, block_name: str) -> list[QuantumStatement]:
+        return self.blocks[block_name].statements
+
+
+@dataclass
+class FunctionContext(OperationContext[FunctionClosure]):
+    @classmethod
+    def create(cls, original_function: FunctionClosure) -> "FunctionContext":
+        return cls(original_function, {"body": Block()})
+
+    @property
+    def body(self) -> list[QuantumStatement]:
+        return self.statements("body")
+
+    @property
+    def is_lambda(self) -> bool:
+        return self.closure.is_lambda
+
+
+class OperationBuilder:
+    def __init__(
+        self, functions_scope: Scope, counted_name_allocator: CountedNameAllocator
+    ) -> None:
+        self._operations: list[OperationContext] = []
+        self._blocks: list[str] = []
+        self._functions_scope = functions_scope
+        self._current_source_ref: Optional[SourceReference] = None
+        self._counted_name_allocator = counted_name_allocator
+
+    @property
+    def current_operation(self) -> Closure:
+        return self._operations[-1].closure
+
+    @property
+    def current_scope(self) -> Scope:
+        return self.current_operation.scope
+
+    @property
+    def current_function(self) -> FunctionClosure:
+        return self._get_last_function(self._operations)
+
+    @property
+    def parent_function(self) -> FunctionClosure:
+        return self._get_last_function(self._operations[:-1])
+
+    @staticmethod
+    def _get_last_function(operations: list[OperationContext]) -> FunctionClosure:
+        for operation in reversed(operations):
+            if isinstance(operation.closure, FunctionClosure):
+                return operation.closure
+        raise ClassiqInternalExpansionError("No function found")
+
+    @property
+    def current_block(self) -> Block:
+        return self._operations[-1].blocks[self._blocks[-1]]
+
+    @property
+    def _current_statements(self) -> list[QuantumStatement]:
+        return self.current_block.statements
+
+    def emit_statement(self, statement: QuantumStatement) -> None:
+        if self._current_source_ref is not None:
+            statement.source_ref = self._current_source_ref
+        self._current_statements.append(statement)
+
+    @property
+    def current_statement(self) -> QuantumStatement:
+        return self._current_statements[-1]
+
+    @contextmanager
+    def block_context(self, block_name: str) -> Iterator[None]:
+        self._blocks.append(block_name)
+        self._operations[-1].blocks[block_name] = Block()
+        yield
+        captured_vars = self.current_block.captured_vars
+        if (
+            not isinstance(self.current_operation, FunctionClosure)
+            and self.current_operation.name != WITHIN_APPLY_NAME
+        ):
+            validate_captured_directions(
+                captured_vars.filter_vars(
+                    self.current_function, self.current_block.variable_declarations
+                ),
+                report_outin=False,
+            )
+        self.current_operation.captured_vars.update(
+            captured_vars.filter_vars(self.current_function)
+        )
+        self._blocks.pop()
+
+    @contextmanager
+    def operation_context(
+        self, original_operation: Closure
+    ) -> Iterator[OperationContext]:
+        context: OperationContext
+        if isinstance(original_operation, FunctionClosure):
+            context = FunctionContext.create(original_operation)
+        else:
+            context = OperationContext(closure=original_operation)
+        self._operations.append(context)
+        yield context
+        self._finalize_within_apply()
+        self._propagate_captured_vars()
+        self._operations.pop()
+
+    def _finalize_within_apply(self) -> None:
+        if self.current_operation.name != WITHIN_APPLY_NAME:
+            return
+        within_captured_vars = self._operations[-1].blocks["within"].captured_vars
+        self.current_operation.captured_vars.update(
+            within_captured_vars.filter_vars(self.current_function).negate()
+        )
+
+    def _propagate_captured_vars(self) -> None:
+        captured_vars = self.current_operation.captured_vars
+        if isinstance(self.current_operation, FunctionClosure):
+            captured_vars = captured_vars.set_propagated()
+        validate_captured_directions(captured_vars)
+        if len(self._operations) < 2:
+            return
+        parent_block = self._operations[-2].blocks[self._blocks[-1]]
+        parent_block.captured_vars.update(
+            captured_vars.filter_vars(self.parent_function)
+        )
+
+    @contextmanager
+    def source_ref_context(
+        self, source_ref: Optional[SourceReference]
+    ) -> Iterator[None]:
+        previous_source_ref = self._current_source_ref
+        self._current_source_ref = source_ref
+        yield
+        self._current_source_ref = previous_source_ref
+
+    def create_definition(
+        self, function_context: FunctionContext
+    ) -> NativeFunctionDefinition:
+        name = self._get_expanded_function_name(function_context)
+        new_parameters: list[PortDeclaration] = [
+            param
+            for param in function_context.positional_arg_declarations
+            if isinstance(param, PortDeclaration)
+        ]
+
+        return NativeFunctionDefinition(
+            name=name,
+            body=function_context.body,
+            positional_arg_declarations=new_parameters,
+        )
+
+    def _get_expanded_function_name(self, function_context: FunctionContext) -> str:
+        name = function_context.name
+
+        if name == MAIN_FUNCTION_NAME:
+            return name
+
+        if name in self.current_scope:
+            orig_func = self.current_scope[name].value
+            if (
+                isinstance(orig_func, FunctionClosure)
+                and not isinstance(orig_func, GenerativeFunctionClosure)
+                and is_signature_monomorphic(orig_func.positional_arg_declarations)
+            ):
+                return name
+
+        for _ in self.current_scope:
+            name = self._counted_name_allocator.allocate(
+                f"{name}_{LAMBDA_KEYWORD + '_0_0_' if function_context.is_lambda else ''}{EXPANDED_KEYWORD}"
+            )
+            if name not in self.current_scope:
+                break
+        else:
+            raise ClassiqInternalExpansionError("Could not allocate function name")
+
+        return name

classiq/model_expansions/generative_functions.py

@@ -0,0 +1,158 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any
+
+from classiq.interface.generator.expressions.qmod_struct_instance import (
+    QmodStructInstance,
+)
+from classiq.interface.generator.functions.type_name import Struct
+from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
+from classiq.interface.model.native_function_definition import NativeFunctionDefinition
+from classiq.interface.model.port_declaration import PortDeclaration
+from classiq.interface.model.quantum_function_declaration import (
+    PositionalArg,
+    QuantumFunctionDeclaration,
+    QuantumOperandDeclaration,
+)
+from classiq.interface.model.quantum_statement import QuantumStatement
+
+from classiq.model_expansions.closure import (
+    FunctionClosure,
+    GenerativeClosure,
+)
+from classiq.model_expansions.scope import Evaluated, QuantumSymbol
+from classiq.qmod.generative import generative_mode_context, set_frontend_interpreter
+from classiq.qmod.model_state_container import QMODULE
+from classiq.qmod.qmod_parameter import CParamStruct
+from classiq.qmod.qmod_variable import QNum, _create_qvar_for_qtype
+from classiq.qmod.quantum_callable import QCallable
+from classiq.qmod.quantum_expandable import (
+    QExpandable,
+    QTerminalCallable,
+)
+from classiq.qmod.quantum_function import QFunc
+from classiq.qmod.semantics.annotation.call_annotation import resolve_function_calls
+from classiq.qmod.symbolic_expr import SymbolicExpr
+
+if TYPE_CHECKING:
+    from classiq.model_expansions.interpreters.generative_interpreter import (
+        GenerativeInterpreter,
+    )
+
+
+class LenList(list):
+    @property
+    def len(self) -> int:
+        return len(self)
+
+    def __getitem__(self, item: Any) -> Any:
+        if isinstance(item, QNum):
+            return SymbolicExpr(f"{self}[{item}]", True)
+        return super().__getitem__(item)
+
+    @classmethod
+    def wrap(cls, obj: Any) -> Any:
+        if not isinstance(obj, list):
+            return obj
+        return LenList([cls.wrap(item) for item in obj])
+
+
+def translate_ast_arg_to_python_qmod(param: PositionalArg, evaluated: Evaluated) -> Any:
+    if isinstance(param, PortDeclaration):
+        quantum_symbol = evaluated.as_type(QuantumSymbol)
+        return _create_qvar_for_qtype(
+            quantum_symbol.quantum_type, quantum_symbol.handle
+        )
+    if isinstance(param, QuantumOperandDeclaration):
+        if param.is_list:
+            func_list: list[FunctionClosure] = evaluated.as_type(list)
+            return LenList(
+                [
+                    QTerminalCallable(
+                        QuantumOperandDeclaration(
+                            name=param.name,
+                            positional_arg_declarations=param.positional_arg_declarations,
+                        ),
+                        index_=idx,
+                    )
+                    for idx in range(len(func_list))
+                ]
+            )
+        else:
+            func = evaluated.as_type(FunctionClosure)
+            return QTerminalCallable(
+                QuantumFunctionDeclaration(
+                    name=param.name if func.is_lambda else func.name,
+                    positional_arg_declarations=func.positional_arg_declarations,
+                ),
+            )
+    classical_value = evaluated.value
+    if isinstance(classical_value, QmodStructInstance):
+        return CParamStruct(
+            expr=param.name,
+            struct_type=Struct(name=classical_value.struct_declaration.name),
+            qmodule=QMODULE,
+        )
+    return LenList.wrap(classical_value)
+
+
+class _InterpreterExpandable(QFunc):
+    def __init__(self, interpreter: "GenerativeInterpreter"):
+        super().__init__(lambda: None)
+        self._interpreter = interpreter
+
+    def append_statement_to_body(self, stmt: QuantumStatement) -> None:
+        current_operation = self._interpreter._builder._operations[-1]
+        dummy_function = NativeFunctionDefinition(
+            name=current_operation.name,
+            positional_arg_declarations=current_operation.positional_arg_declarations,
+            body=self._interpreter._builder._current_statements + [stmt],
+        )
+        declarative_functions = {
+            name: func
+            for name, func in self._qmodule.native_defs.items()
+            if name not in self._interpreter._top_level_scope
+        }
+        self._interpreter.update_declarative_functions(
+            declarative_functions, self._qmodule
+        )
+        self._interpreter.update_generative_functions(
+            self._qmodule.generative_functions
+        )
+        func_decls = self._get_function_declarations()
+        for dec_func in declarative_functions.values():
+            resolve_function_calls(dec_func, func_decls)
+        resolve_function_calls(dummy_function, func_decls)
+        stmt = dummy_function.body[-1]
+        with generative_mode_context(False):
+            self._interpreter.emit_statement(stmt)
+
+    def _get_function_declarations(self) -> Mapping[str, QuantumFunctionDeclaration]:
+        return {
+            name: QuantumFunctionDeclaration(
+                name=name,
+                positional_arg_declarations=evaluated.value.positional_arg_declarations,
+            )
+            for name, evaluated in self._interpreter._builder.current_scope.items()
+            if isinstance(evaluated, Evaluated)
+            and isinstance(evaluated.value, FunctionClosure)
+        } | nameables_to_dict(self._interpreter._get_function_declarations())
+
+
+def emit_generative_statements(
+    interpreter: "GenerativeInterpreter",
+    operation: GenerativeClosure,
+    args: list[Evaluated],
+) -> None:
+    python_qmod_args = [
+        translate_ast_arg_to_python_qmod(param, arg)
+        for param, arg in zip(operation.positional_arg_declarations, args)
+    ]
+    interpreter_expandable = _InterpreterExpandable(interpreter)
+    QExpandable.STACK.append(interpreter_expandable)
+    QCallable.CURRENT_EXPANDABLE = interpreter_expandable
+    set_frontend_interpreter(interpreter)
+    for block_name, generative_function in operation.generative_blocks.items():
+        with interpreter._builder.block_context(block_name), generative_mode_context(
+            True
+        ):
+            generative_function._py_callable(*python_qmod_args)

classiq/model_expansions/interpreters/base_interpreter.py

@@ -0,0 +1,263 @@
+import ast
+from abc import abstractmethod
+from collections import defaultdict
+from collections.abc import Sequence
+from contextlib import nullcontext
+from functools import singledispatchmethod
+from typing import Any, Optional, cast
+
+import sympy
+from pydantic import ValidationError
+
+from classiq.interface.exceptions import (
+    ClassiqError,
+    ClassiqExpansionError,
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.generator.constant import Constant
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.types.compilation_metadata import CompilationMetadata
+from classiq.interface.model.handle_binding import (
+    FieldHandleBinding,
+    HandleBinding,
+    SlicedHandleBinding,
+    SubscriptHandleBinding,
+)
+from classiq.interface.model.model import MAIN_FUNCTION_NAME, Model
+from classiq.interface.model.native_function_definition import NativeFunctionDefinition
+from classiq.interface.model.quantum_function_declaration import (
+    QuantumFunctionDeclaration,
+)
+from classiq.interface.model.quantum_lambda_function import (
+    OperandIdentifier,
+    QuantumLambdaFunction,
+)
+from classiq.interface.model.quantum_statement import QuantumStatement
+
+from classiq.model_expansions.closure import (
+    Closure,
+    FunctionClosure,
+)
+from classiq.model_expansions.debug_flag import debug_mode
+from classiq.model_expansions.evaluators.classical_expression import (
+    evaluate_classical_expression,
+)
+from classiq.model_expansions.expression_renamer import ExpressionRenamer
+from classiq.model_expansions.function_builder import (
+    FunctionContext,
+    OperationBuilder,
+    OperationContext,
+)
+from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
+from classiq.model_expansions.scope_initialization import (
+    add_constants_to_scope,
+    add_entry_point_params_to_scope,
+    get_main_renamer,
+    init_builtin_types,
+    init_top_level_scope,
+)
+from classiq.model_expansions.utils.counted_name_allocator import CountedNameAllocator
+from classiq.model_expansions.visitors.variable_references import VarRefCollector
+from classiq.qmod.builtins.enums import BUILTIN_ENUM_DECLARATIONS
+from classiq.qmod.builtins.structs import BUILTIN_STRUCT_DECLARATIONS
+from classiq.qmod.model_state_container import QMODULE
+from classiq.qmod.semantics.error_manager import ErrorManager
+
+
+class BaseInterpreter:
+    def __init__(self, model: Model) -> None:
+        self._model = model
+        self._top_level_scope = Scope()
+        self._counted_name_allocator = CountedNameAllocator()
+        self._builder = OperationBuilder(
+            self._top_level_scope, self._counted_name_allocator
+        )
+        self._expanded_functions: dict[str, NativeFunctionDefinition] = {}
+
+        init_builtin_types()
+        init_top_level_scope(model, self._top_level_scope)
+        self._functions_compilation_metadata: dict[str, CompilationMetadata] = dict(
+            self._model.functions_compilation_metadata
+        )
+        self._expanded_functions_compilation_metadata: dict[
+            str, CompilationMetadata
+        ] = defaultdict(CompilationMetadata)
+        self._counted_name_allocator = CountedNameAllocator()
+        self._error_manager: ErrorManager = ErrorManager()
+
+    def get_main_renamer(self) -> Optional[ExpressionRenamer]:
+        return get_main_renamer(self._get_function_declarations())
+
+    def _expand_main_func(self) -> None:
+        main_closure = self._get_main_closure(
+            self._top_level_scope[MAIN_FUNCTION_NAME].value
+        )
+        add_entry_point_params_to_scope(
+            main_closure.positional_arg_declarations, main_closure
+        )
+        context = self._expand_operation(main_closure)
+        self._expanded_functions[main_closure.closure_id] = (
+            self._builder.create_definition(cast(FunctionContext, context))
+        )
+
+    def _get_main_closure(self, main_func: FunctionClosure) -> FunctionClosure:
+        return FunctionClosure.create(
+            name=main_func.name,
+            positional_arg_declarations=main_func.positional_arg_declarations,
+            scope=Scope(parent=self._top_level_scope),
+            expr_renamer=self.get_main_renamer(),
+            _depth=0,
+            body=main_func.body,
+        )
+
+    def expand(self) -> Model:
+        try:
+            with self._error_manager.call("main"):
+                self._expand_main_func()
+        except Exception as e:
+            if isinstance(e, ClassiqInternalExpansionError) or debug_mode.get():
+                raise e
+            if not isinstance(e, (ClassiqError, ValidationError)):
+                raise ClassiqInternalExpansionError(str(e)) from None
+            prefix = ""
+            if not isinstance(e, ClassiqExpansionError):
+                prefix = f"{type(e).__name__}: "
+            self._error_manager.add_error(f"{prefix}{e}")
+        finally:
+            self._error_manager.report_errors(ClassiqExpansionError)
+
+        return Model(
+            constraints=self._model.constraints,
+            preferences=self._model.preferences,
+            classical_execution_code=self._model.classical_execution_code,
+            execution_preferences=self._model.execution_preferences,
+            functions=list(self._expanded_functions.values()),
+            constants=self._model.constants,
+            enums=[
+                enum_decl
+                for name, enum_decl in QMODULE.enum_decls.items()
+                if name not in BUILTIN_ENUM_DECLARATIONS
+            ],
+            types=[
+                struct_decl
+                for name, struct_decl in QMODULE.type_decls.items()
+                if name not in BUILTIN_STRUCT_DECLARATIONS
+            ],
+            qstructs=list(QMODULE.qstruct_decls.values()),
+            debug_info=self._model.debug_info,
+            functions_compilation_metadata=self._expanded_functions_compilation_metadata,
+        )
+
+    @singledispatchmethod
+    def evaluate(self, expression: Any) -> Evaluated:
+        raise NotImplementedError(f"Cannot evaluate {expression!r}")
+
+    @evaluate.register
+    def evaluate_classical_expression(self, expression: Expression) -> Evaluated:
+        expr = evaluate_classical_expression(expression, self._builder.current_scope)
+        if not isinstance(expr.value, sympy.Basic):
+            return expr
+        vrc = VarRefCollector(ignore_duplicated_handles=True)
+        vrc.visit(ast.parse(str(expr.value)))
+        for handle in vrc.var_handles:
+            if handle.name in self._builder.current_scope and isinstance(
+                self._builder.current_scope[handle.name], QuantumSymbol
+            ):
+                self.evaluate(handle)
+        return expr
+
+    @evaluate.register
+    def evaluate_identifier(self, identifier: str) -> Evaluated:
+        return self._builder.current_scope[identifier]
+
+    @evaluate.register
+    def _evaluate_lambda(self, function: QuantumLambdaFunction) -> Evaluated:
+        return self.evaluate_lambda(function)
+
+    def evaluate_lambda(self, function: QuantumLambdaFunction) -> Evaluated:
+        raise NotImplementedError
+
+    @evaluate.register
+    def evaluate_handle_binding(self, handle_binding: HandleBinding) -> Evaluated:
+        return self.evaluate(handle_binding.name)
+
+    @evaluate.register
+    def evaluate_sliced_handle_binding(
+        self, sliced_handle_binding: SlicedHandleBinding
+    ) -> Evaluated:
+        quantum_variable = self.evaluate(sliced_handle_binding.base_handle).as_type(
+            QuantumSymbol
+        )
+        start = self.evaluate(sliced_handle_binding.start).as_type(int)
+        end = self.evaluate(sliced_handle_binding.end).as_type(int)
+        return Evaluated(value=quantum_variable[start:end])
+
+    @evaluate.register
+    def evaluate_list(self, value: list) -> Evaluated:
+        return Evaluated(value=[self.evaluate(arg).value for arg in value])
+
+    @evaluate.register
+    def evaluate_subscript_handle(self, subscript: SubscriptHandleBinding) -> Evaluated:
+        base_value = self.evaluate(subscript.base_handle)
+        index_value = self.evaluate(subscript.index).as_type(int)
+        return Evaluated(value=base_value.value[index_value])
+
+    @evaluate.register
+    def evaluate_subscript_operand(self, subscript: OperandIdentifier) -> Evaluated:
+        base_value = self.evaluate(subscript.name)
+        index_value = self.evaluate(subscript.index).as_type(int)
+        return Evaluated(value=base_value.value[index_value])
+
+    @evaluate.register
+    def evaluate_field_access(self, field_access: FieldHandleBinding) -> Evaluated:
+        base_value = self.evaluate(field_access.base_handle)
+        return Evaluated(value=base_value.value.fields[field_access.field])
+
+    @abstractmethod
+    def emit(self, statement: QuantumStatement) -> None:
+        pass
+
+    def _expand_block(self, block: Sequence[QuantumStatement], block_name: str) -> None:
+        with self._builder.block_context(block_name):
+            for statement in block:
+                self.emit_statement(statement)
+
+    def emit_statement(self, statement: QuantumStatement) -> None:
+        source_ref = statement.source_ref
+        error_context = (
+            self._error_manager.node_context(statement)
+            if source_ref is not None
+            else nullcontext()
+        )
+        with error_context, self._builder.source_ref_context(source_ref):
+            self.emit(statement)
+
+    def _expand_operation(self, operation: Closure) -> OperationContext:
+        with self._builder.operation_context(operation) as context:
+            if isinstance(operation, FunctionClosure) and (
+                (func_def := self._expanded_functions.get(operation.closure_id))
+                is not None
+            ):
+                captured_vars = self._top_level_scope[func_def.name].value.captured_vars
+                operation.captured_vars.update(captured_vars)
+            else:
+                self._expand_body(operation)
+
+        return context
+
+    def _expand_body(self, operation: Closure) -> None:
+        for block, block_body in operation.blocks.items():
+            self._expand_block(block_body, block)
+
+    def _get_function_declarations(self) -> Sequence[QuantumFunctionDeclaration]:
+        return [
+            QuantumFunctionDeclaration(
+                name=func_closure.name,
+                positional_arg_declarations=func_closure.positional_arg_declarations,
+            )
+            for func in self._top_level_scope.values()
+            if isinstance(func_closure := func.value, FunctionClosure)
+        ]
+
+    def add_constant(self, constant: Constant) -> None:
+        add_constants_to_scope([constant], self._top_level_scope)

classiq/model_expansions/interpreters/frontend_generative_interpreter.py

@@ -0,0 +1,28 @@
+from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+
+from classiq.model_expansions.closure import FunctionClosure, GenerativeFunctionClosure
+from classiq.model_expansions.interpreters.generative_interpreter import (
+    GenerativeInterpreter,
+)
+from classiq.model_expansions.quantum_operations.quantum_function_call import (
+    DeclarativeQuantumFunctionCallEmitter,
+)
+from classiq.model_expansions.scope import Scope
+
+
+class FrontendGenerativeInterpreter(GenerativeInterpreter):
+    def emit_quantum_function_call(self, call: QuantumFunctionCall) -> None:
+        DeclarativeQuantumFunctionCallEmitter(self).emit(call)
+
+    def _get_main_closure(self, main_func: FunctionClosure) -> FunctionClosure:
+        if isinstance(main_func, GenerativeFunctionClosure):
+            return GenerativeFunctionClosure.create(
+                name=main_func.name,
+                positional_arg_declarations=main_func.positional_arg_declarations,
+                scope=Scope(parent=self._top_level_scope),
+                expr_renamer=self.get_main_renamer(),
+                _depth=0,
+                generative_blocks={"body": main_func.generative_blocks["body"]},
+            )
+
+        return super()._get_main_closure(main_func)