classiq 0.64.0__py3-none-any.whl → 0.65.1__py3-none-any.whl

classiq/model_expansions/interpreters/base_interpreter.py

@@ -1,3 +1,4 @@
+import ast
 from abc import abstractmethod
 from collections import defaultdict
 from collections.abc import Sequence
@@ -5,8 +6,7 @@ from contextlib import nullcontext
 from functools import singledispatchmethod
 from typing import Any, Optional, cast
 
-import numpy as np
-from numpy.random import permutation
+import sympy
 from pydantic import ValidationError
 
 from classiq.interface.exceptions import (
@@ -25,11 +25,7 @@ from classiq.interface.model.handle_binding import (
 )
 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_call import (
-    QuantumFunctionCall,
-)
 from classiq.interface.model.quantum_function_declaration import (
-    NamedParamsQuantumFunctionDeclaration,
     QuantumFunctionDeclaration,
 )
 from classiq.interface.model.quantum_lambda_function import (
@@ -41,8 +37,6 @@ from classiq.interface.model.quantum_statement import QuantumStatement
 from classiq.model_expansions.closure import (
     Closure,
     FunctionClosure,
-    GenerativeClosure,
-    GenerativeFunctionClosure,
 )
 from classiq.model_expansions.debug_flag import debug_mode
 from classiq.model_expansions.evaluators.classical_expression import (
@@ -54,32 +48,24 @@ from classiq.model_expansions.function_builder import (
     OperationBuilder,
     OperationContext,
 )
-from classiq.model_expansions.generative_functions import emit_generative_statements
 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,
-    add_functions_to_scope,
-    add_generative_functions_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.functions import permute
 from classiq.qmod.builtins.structs import BUILTIN_STRUCT_DECLARATIONS
-from classiq.qmod.model_state_container import QMODULE, ModelStateContainer
-from classiq.qmod.quantum_function import GenerativeQFunc
+from classiq.qmod.model_state_container import QMODULE
 from classiq.qmod.semantics.error_manager import ErrorManager
 
 
 class BaseInterpreter:
-    def __init__(
-        self,
-        model: Model,
-        generative_functions: Optional[list[GenerativeQFunc]] = None,
-    ) -> None:
+    def __init__(self, model: Model) -> None:
         self._model = model
         self._top_level_scope = Scope()
         self._counted_name_allocator = CountedNameAllocator()
@@ -89,7 +75,7 @@ class BaseInterpreter:
         self._expanded_functions: dict[str, NativeFunctionDefinition] = {}
 
         init_builtin_types()
-        init_top_level_scope(model, generative_functions or [], self._top_level_scope)
+        init_top_level_scope(model, self._top_level_scope)
         self._functions_compilation_metadata: dict[str, CompilationMetadata] = dict(
             self._model.functions_compilation_metadata
         )
@@ -99,33 +85,13 @@ class BaseInterpreter:
         self._counted_name_allocator = CountedNameAllocator()
         self._error_manager: ErrorManager = ErrorManager()
 
-    @property
-    def is_shallow(self) -> bool:
-        return False
-
     def get_main_renamer(self) -> Optional[ExpressionRenamer]:
         return get_main_renamer(self._get_function_declarations())
 
     def _expand_main_func(self) -> None:
-        main_func = self._top_level_scope[MAIN_FUNCTION_NAME].value
-        closure_constructor: Any
-        if isinstance(main_func, GenerativeFunctionClosure):
-            closure_constructor = GenerativeFunctionClosure
-            extra_args = {
-                "generative_blocks": {"body": main_func.generative_blocks["body"]}
-            }
-        else:
-            closure_constructor = FunctionClosure
-            extra_args = {"body": main_func.body}
-        main_closure = closure_constructor.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,
-            **extra_args,
+        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
         )
@@ -134,6 +100,16 @@ class BaseInterpreter:
             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"):
@@ -178,49 +154,28 @@ class BaseInterpreter:
 
     @evaluate.register
     def evaluate_classical_expression(self, expression: Expression) -> Evaluated:
-        return evaluate_classical_expression(expression, self._builder.current_scope)
+        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:
-        renamed_params = [
-            param.rename(function.pos_rename_params[idx])
-            for idx, param in enumerate(function.func_decl.positional_arg_declarations)
-        ]
-        func_decl = NamedParamsQuantumFunctionDeclaration(
-            name=self._counted_name_allocator.allocate(
-                function.func_decl.name or "<lambda>"
-            ),
-            positional_arg_declarations=renamed_params,
-        )
-
-        closure_class: type[FunctionClosure]
-        extra_args: dict[str, Any]
-        if function.is_generative():
-            closure_class = GenerativeFunctionClosure
-            extra_args = {
-                "generative_blocks": {
-                    "body": GenerativeQFunc(function.py_callable, func_decl),
-                }
-            }
-        else:
-            closure_class = FunctionClosure
-            extra_args = {}
+    def _evaluate_lambda(self, function: QuantumLambdaFunction) -> Evaluated:
+        return self.evaluate_lambda(function)
 
-        return Evaluated(
-            value=closure_class.create(
-                name=func_decl.name,
-                positional_arg_declarations=func_decl.positional_arg_declarations,
-                body=function.body,
-                scope=Scope(parent=self._builder.current_scope),
-                is_lambda=True,
-                **extra_args,
-            ),
-            defining_function=self._builder.current_function,
-        )
+    def evaluate_lambda(self, function: QuantumLambdaFunction) -> Evaluated:
+        raise NotImplementedError
 
     @evaluate.register
     def evaluate_handle_binding(self, handle_binding: HandleBinding) -> Evaluated:
@@ -285,34 +240,14 @@ class BaseInterpreter:
             ):
                 captured_vars = self._top_level_scope[func_def.name].value.captured_vars
                 operation.captured_vars.update(captured_vars)
-            elif isinstance(operation, FunctionClosure) and operation.name == "permute":
-                # special expansion since permute is generative
-                self._expand_permute()
-            elif isinstance(operation, GenerativeClosure):
-                args = [
-                    self.evaluate(param.name)
-                    for param in operation.positional_arg_declarations
-                ]
-                emit_generative_statements(self, operation, args)
             else:
-                for block, block_body in operation.blocks.items():
-                    self._expand_block(block_body, block)
+                self._expand_body(operation)
 
         return context
 
-    def _expand_permute(self) -> None:
-        functions = self.evaluate("functions").as_type(list)
-        functions_permutation = permutation(np.array(range(len(functions))))
-        calls: list[QuantumFunctionCall] = []
-        for function_index in functions_permutation:
-            permute_call = QuantumFunctionCall(
-                function=OperandIdentifier(
-                    name="functions", index=Expression(expr=f"{function_index}")
-                )
-            )
-            permute_call.set_func_decl(permute.func_decl)
-            calls.append(permute_call)
-        self._expand_block(calls, "body")
+    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 [
@@ -326,39 +261,3 @@ class BaseInterpreter:
 
     def add_constant(self, constant: Constant) -> None:
         add_constants_to_scope([constant], self._top_level_scope)
-
-    def update_declarative_functions(
-        self,
-        functions: dict[str, NativeFunctionDefinition],
-        qmodule: ModelStateContainer,
-    ) -> None:
-        add_functions_to_scope(list(functions.values()), self._top_level_scope)
-        for dec_func_name in functions:
-            if dec_func_name in qmodule.functions_compilation_metadata:
-                self._functions_compilation_metadata[dec_func_name] = (
-                    qmodule.functions_compilation_metadata[dec_func_name]
-                )
-
-    def update_generative_functions(
-        self, generative_functions: dict[str, GenerativeQFunc]
-    ) -> None:
-        add_generative_functions_to_scope(
-            list(generative_functions.values()), self._top_level_scope
-        )
-        for name, gen_func in generative_functions.items():
-            if gen_func.compilation_metadata is not None:
-                self._functions_compilation_metadata[name] = (
-                    gen_func.compilation_metadata
-                )
-
-    def add_purely_declarative_function(self, function: FunctionClosure) -> None:
-        functions_to_add = [function.name] + QMODULE.function_dependencies[
-            function.name
-        ]
-        for func in functions_to_add:
-            if func not in self._expanded_functions and func in QMODULE.native_defs:
-                self._expanded_functions[func] = QMODULE.native_defs[func]
-                if func in QMODULE.functions_compilation_metadata:
-                    self._expanded_functions_compilation_metadata[func] = (
-                        QMODULE.functions_compilation_metadata[func]
-                    )

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)

classiq/model_expansions/interpreters/generative_interpreter.py

@@ -1,21 +1,36 @@
 from functools import singledispatchmethod
+from typing import Any
 
+import numpy as np
+from numpy.random import permutation
+
+from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.builtins.internal_operators import (
     CONTROL_OPERATOR_NAME,
     INVERT_OPERATOR_NAME,
     WITHIN_APPLY_NAME,
 )
+from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.bind_operation import BindOperation
 from classiq.interface.model.classical_if import ClassicalIf
 from classiq.interface.model.control import Control
 from classiq.interface.model.inplace_binary_operation import InplaceBinaryOperation
 from classiq.interface.model.invert import Invert
+from classiq.interface.model.model import Model
+from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.phase_operation import PhaseOperation
 from classiq.interface.model.power import Power
 from classiq.interface.model.quantum_expressions.quantum_expression import (
     QuantumAssignmentOperation,
 )
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+from classiq.interface.model.quantum_function_declaration import (
+    NamedParamsQuantumFunctionDeclaration,
+)
+from classiq.interface.model.quantum_lambda_function import (
+    OperandIdentifier,
+    QuantumLambdaFunction,
+)
 from classiq.interface.model.quantum_statement import QuantumStatement
 from classiq.interface.model.repeat import Repeat
 from classiq.interface.model.variable_declaration_statement import (
@@ -23,6 +38,13 @@ from classiq.interface.model.variable_declaration_statement import (
 )
 from classiq.interface.model.within_apply_operation import WithinApply
 
+from classiq.model_expansions.closure import (
+    Closure,
+    FunctionClosure,
+    GenerativeClosure,
+    GenerativeFunctionClosure,
+)
+from classiq.model_expansions.generative_functions import emit_generative_statements
 from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
 from classiq.model_expansions.quantum_operations import (
     BindEmitter,
@@ -32,21 +54,77 @@ from classiq.model_expansions.quantum_operations import (
     VariableDeclarationStatementEmitter,
 )
 from classiq.model_expansions.quantum_operations.shallow_emitter import ShallowEmitter
+from classiq.model_expansions.scope import Evaluated, Scope
+from classiq.model_expansions.scope_initialization import (
+    add_functions_to_scope,
+    add_generative_functions_to_scope,
+)
+from classiq.qmod.builtins.functions import permute
+from classiq.qmod.model_state_container import QMODULE, ModelStateContainer
+from classiq.qmod.quantum_function import GenerativeQFunc
 
 
 class GenerativeInterpreter(BaseInterpreter):
-    @property
-    def is_shallow(self) -> bool:
-        return True
+    def __init__(
+        self,
+        model: Model,
+        generative_functions: list[GenerativeQFunc],
+    ) -> None:
+        super().__init__(model)
+        add_generative_functions_to_scope(generative_functions, self._top_level_scope)
+
+    def evaluate_lambda(self, function: QuantumLambdaFunction) -> Evaluated:
+        renamed_params = [
+            param.rename(function.pos_rename_params[idx])
+            for idx, param in enumerate(function.func_decl.positional_arg_declarations)
+        ]
+        func_decl = NamedParamsQuantumFunctionDeclaration(
+            name=self._counted_name_allocator.allocate(
+                function.func_decl.name or "<lambda>"
+            ),
+            positional_arg_declarations=renamed_params,
+        )
+
+        closure_class: type[FunctionClosure]
+        extra_args: dict[str, Any]
+        if function.is_generative():
+            closure_class = GenerativeFunctionClosure
+            extra_args = {
+                "generative_blocks": {
+                    "body": GenerativeQFunc(function.py_callable, func_decl),
+                }
+            }
+        else:
+            closure_class = FunctionClosure
+            extra_args = {}
+
+        return Evaluated(
+            value=closure_class.create(
+                name=func_decl.name,
+                positional_arg_declarations=func_decl.positional_arg_declarations,
+                body=function.body,
+                scope=Scope(parent=self._builder.current_scope),
+                is_lambda=True,
+                **extra_args,
+            ),
+            defining_function=self._builder.current_function,
+        )
 
     @singledispatchmethod
     def emit(self, statement: QuantumStatement) -> None:  # type:ignore[override]
         raise NotImplementedError(f"Cannot emit {statement!r}")
 
     @emit.register
+    def _emit_quantum_function_call(self, call: QuantumFunctionCall) -> None:
+        self.emit_quantum_function_call(call)
+
     def emit_quantum_function_call(self, call: QuantumFunctionCall) -> None:
         QuantumFunctionCallEmitter(self).emit(call)
 
+    @emit.register
+    def emit_allocate(self, allocate: Allocate) -> None:
+        ShallowEmitter(self, "allocate", components=["size", "target"]).emit(allocate)
+
     @emit.register
     def emit_bind(self, bind: BindOperation) -> None:
         BindEmitter(self).emit(bind)
@@ -106,3 +184,66 @@ class GenerativeInterpreter(BaseInterpreter):
     @emit.register
     def emit_phase(self, phase: PhaseOperation) -> None:
         ShallowEmitter(self, "phase", components=["expression", "theta"]).emit(phase)
+
+    def _expand_body(self, operation: Closure) -> None:
+        if isinstance(operation, FunctionClosure) and operation.name == "permute":
+            # special expansion since permute is generative
+            self._expand_permute()
+        elif isinstance(operation, GenerativeClosure):
+            args = [
+                self.evaluate(param.name)
+                for param in operation.positional_arg_declarations
+            ]
+            emit_generative_statements(self, operation, args)
+        else:
+            super()._expand_body(operation)
+
+    def _expand_permute(self) -> None:
+        functions = self.evaluate("functions").as_type(list)
+        functions_permutation = permutation(np.array(range(len(functions))))
+        calls: list[QuantumFunctionCall] = []
+        for function_index in functions_permutation:
+            permute_call = QuantumFunctionCall(
+                function=OperandIdentifier(
+                    name="functions", index=Expression(expr=f"{function_index}")
+                )
+            )
+            permute_call.set_func_decl(permute.func_decl)
+            calls.append(permute_call)
+        self._expand_block(calls, "body")
+
+    def update_generative_functions(
+        self, generative_functions: dict[str, GenerativeQFunc]
+    ) -> None:
+        add_generative_functions_to_scope(
+            list(generative_functions.values()), self._top_level_scope
+        )
+        for name, gen_func in generative_functions.items():
+            if gen_func.compilation_metadata is not None:
+                self._functions_compilation_metadata[name] = (
+                    gen_func.compilation_metadata
+                )
+
+    def update_declarative_functions(
+        self,
+        functions: dict[str, NativeFunctionDefinition],
+        qmodule: ModelStateContainer,
+    ) -> None:
+        add_functions_to_scope(list(functions.values()), self._top_level_scope)
+        for dec_func_name in functions:
+            if dec_func_name in qmodule.functions_compilation_metadata:
+                self._functions_compilation_metadata[dec_func_name] = (
+                    qmodule.functions_compilation_metadata[dec_func_name]
+                )
+
+    def add_purely_declarative_function(self, function: FunctionClosure) -> None:
+        functions_to_add = [function.name] + QMODULE.function_dependencies[
+            function.name
+        ]
+        for func in functions_to_add:
+            if func not in self._expanded_functions and func in QMODULE.native_defs:
+                self._expanded_functions[func] = QMODULE.native_defs[func]
+                if func in QMODULE.functions_compilation_metadata:
+                    self._expanded_functions_compilation_metadata[func] = (
+                        QMODULE.functions_compilation_metadata[func]
+                    )

classiq/model_expansions/quantum_operations/call_emitter.py

@@ -8,9 +8,6 @@ from typing import (
 )
 
 from classiq.interface.debug_info.debug_info import FunctionDebugInfo
-from classiq.interface.generator.functions.port_declaration import (
-    PortDeclarationDirection,
-)
 from classiq.interface.generator.generated_circuit_data import OperationLevel
 from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
@@ -23,10 +20,6 @@ from classiq.interface.model.quantum_function_declaration import (
     NamedParamsQuantumFunctionDeclaration,
     PositionalArg,
 )
-from classiq.interface.model.quantum_lambda_function import (
-    OperandIdentifier,
-    QuantumLambdaFunction,
-)
 from classiq.interface.model.quantum_statement import QuantumStatement
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
@@ -35,7 +28,7 @@ from classiq.interface.model.variable_declaration_statement import (
 from classiq.model_expansions.capturing.captured_vars import (
     validate_args_are_not_propagated,
 )
-from classiq.model_expansions.closure import FunctionClosure, GenerativeClosure
+from classiq.model_expansions.closure import FunctionClosure
 from classiq.model_expansions.evaluators.argument_types import (
     add_information_from_output_arguments,
 )
@@ -52,7 +45,6 @@ from classiq.model_expansions.quantum_operations.emitter import (
 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
-from classiq.qmod.model_state_container import QMODULE
 
 if TYPE_CHECKING:
     from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
@@ -105,45 +97,16 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
             function, evaluated_args
         )
         new_positional_arg_decls = new_declaration.positional_arg_declarations
-        is_atomic = function.is_atomic
-        if (
-            self._interpreter.is_shallow
-            and self._is_function_purely_declarative(function)
-            and self._are_args_purely_declarative(args)
-        ):
+        if not self.should_expand_function(function, evaluated_args):
             is_atomic = True
-            self._interpreter.add_purely_declarative_function(function)
-        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
+            new_declaration = self._expanded_functions_by_name.get(
+                function.name, new_declaration
             )
-            context = self._expand_operation(
-                function.with_new_declaration(new_declaration)
+        else:
+            is_atomic = False
+            new_declaration = self._expand_function(
+                evaluated_args, new_declaration, function
             )
-            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._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
-                    )
-            else:
-                self._expanded_functions_compilation_metadata[
-                    function_def.name
-                ].occurrences_number += 1
-
-            new_declaration = function_def
-            new_function_name = function_def.name
 
         new_positional_args = self._get_new_positional_args(
             evaluated_args, is_atomic, new_positional_arg_decls
@@ -154,8 +117,7 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         validate_args_are_not_propagated(new_positional_args, captured_args)
         new_positional_args.extend(captured_args)
         new_call = QuantumFunctionCall(
-            function=new_function_name,
-            positional_args=new_positional_args,
+            function=new_declaration.name, positional_args=new_positional_args
         )
         is_allocate_or_free = (
             new_call.func_name == allocate.func_decl.name
@@ -186,6 +148,40 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         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:
@@ -268,47 +264,3 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
                 evaluated_args,
             ),
         )
-
-    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[ArgValue]) -> bool:
-        if any(
-            isinstance(arg, (OperandIdentifier, QuantumLambdaFunction))
-            or (
-                isinstance(arg, list)
-                and any(
-                    isinstance(item, (OperandIdentifier, QuantumLambdaFunction))
-                    for item in arg
-                )
-            )
-            for arg in args
-        ):
-            return False
-
-        dependencies = [arg for arg in args if isinstance(arg, str)]
-        dependencies += [
-            cast(str, item) for arg in args if isinstance(arg, list) for item in arg
-        ]
-        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
-        )