classiq 0.45.1__py3-none-any.whl → 0.46.1__py3-none-any.whl

classiq/model_expansions/model_tables.py

@@ -0,0 +1,105 @@
+from abc import ABC, abstractmethod
+from enum import IntEnum
+from typing import ClassVar, Dict, Generic, List, Optional, TypeVar
+
+from classiq.interface.generator.expressions.handle_identifier import HandleIdentifier
+from classiq.interface.generator.functions.classical_type import QmodPyObject
+from classiq.interface.generator.types.enum_declaration import EnumDeclaration
+from classiq.interface.generator.types.qstruct_declaration import QStructDeclaration
+from classiq.interface.generator.types.struct_declaration import StructDeclaration
+
+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
+
+DeclarationType = TypeVar(
+    "DeclarationType", EnumDeclaration, StructDeclaration, QStructDeclaration
+)
+
+
+class TypeTable(Generic[DeclarationType], ABC):
+    def __init__(self, user_types: List[DeclarationType]) -> None:
+        self._all_types: Dict[str, DeclarationType] = self.builtins.copy()
+        for t in user_types:
+            assert t.name not in self._all_types  # FIXME: issue user error (CAD-7856)
+            self._all_types[t.name] = t
+
+    @property
+    @abstractmethod
+    def builtins(self) -> Dict[str, DeclarationType]:
+        pass
+
+    def __getitem__(self, key: str) -> DeclarationType:
+        return self._all_types[key]
+
+    def __setitem__(self, key: str, value: DeclarationType) -> None:
+        self._all_types[key] = value
+
+    def __contains__(self, key: str) -> bool:
+        return key in self._all_types
+
+    def all_types(self) -> Dict[str, DeclarationType]:
+        return self._all_types
+
+
+class EnumTable(TypeTable[EnumDeclaration]):
+    def __init__(self, user_types: List[EnumDeclaration]) -> None:
+        super().__init__(user_types)
+
+    @property
+    def builtins(self) -> Dict[str, EnumDeclaration]:
+        return BUILTIN_ENUM_DECLARATIONS
+
+    @property
+    def enums(self) -> Dict[str, IntEnum]:
+        return {
+            enum_decl.name: enum_decl.create_enum()
+            for enum_decl in self.all_types().values()
+        }
+
+
+class StructTable(TypeTable[StructDeclaration]):
+    @property
+    def builtins(self) -> Dict[str, StructDeclaration]:
+        return BUILTIN_STRUCT_DECLARATIONS
+
+
+class QStructTable(TypeTable[QStructDeclaration]):
+    @property
+    def builtins(self) -> Dict[str, QStructDeclaration]:
+        return {}
+
+
+class SymbolTable:
+    enum_table: ClassVar[EnumTable] = EnumTable([])
+    type_table: ClassVar[StructTable] = StructTable([])
+    qstruct_table: ClassVar[QStructTable] = QStructTable([])
+
+    @classmethod
+    def init_user_enums(cls, user_enums: List[EnumDeclaration]) -> None:
+        cls.enum_table = EnumTable(user_enums)
+
+    @classmethod
+    def init_user_types(cls, user_types: List[StructDeclaration]) -> None:
+        cls.type_table = StructTable(user_types)
+
+    @classmethod
+    def init_user_qstructs(cls, user_qstructs: List[QStructDeclaration]) -> None:
+        cls.qstruct_table = QStructTable(user_qstructs)
+        QMODULE.qstruct_decls = {
+            qstruct_decl.name: qstruct_decl for qstruct_decl in user_qstructs
+        }
+
+
+class HandleTable:
+    _handle_map: Dict[HandleIdentifier, QmodPyObject] = {}
+
+    @classmethod
+    def get_handle_object(cls, hid: HandleIdentifier) -> Optional[QmodPyObject]:
+        return cls._handle_map.get(hid)
+
+    @classmethod
+    def set_handle_object(cls, qmod_object: QmodPyObject) -> HandleIdentifier:
+        hid = HandleIdentifier(id(qmod_object))
+        cls._handle_map[hid] = qmod_object
+        return hid

classiq/model_expansions/quantum_operations/__init__.py

@@ -0,0 +1,19 @@
+from classiq.model_expansions.quantum_operations.bind import BindEmitter
+from classiq.model_expansions.quantum_operations.classicalif import ClassicalIfEmitter
+from classiq.model_expansions.quantum_operations.control import ControlEmitter
+from classiq.model_expansions.quantum_operations.inplace_binary_operation import (
+    InplaceBinaryOperationEmitter,
+)
+from classiq.model_expansions.quantum_operations.invert import InvertEmitter
+from classiq.model_expansions.quantum_operations.power import PowerEmitter
+from classiq.model_expansions.quantum_operations.quantum_assignment_operation import (
+    QuantumAssignmentOperationEmitter,
+)
+from classiq.model_expansions.quantum_operations.quantum_function_call import (
+    QuantumFunctionCallEmitter,
+)
+from classiq.model_expansions.quantum_operations.repeat import RepeatEmitter
+from classiq.model_expansions.quantum_operations.variable_decleration import (
+    VariableDeclarationStatementEmitter,
+)
+from classiq.model_expansions.quantum_operations.within_apply import WithinApplyEmitter

classiq/model_expansions/quantum_operations/bind.py

@@ -0,0 +1,64 @@
+from typing import List
+
+from classiq.interface.exceptions import ClassiqExpansionError
+from classiq.interface.model.bind_operation import BindOperation
+
+from classiq.model_expansions.evaluators.parameter_types import (
+    evaluate_types_in_quantum_symbols,
+)
+from classiq.model_expansions.evaluators.quantum_type_utils import (
+    set_size,
+    validate_bind_targets,
+)
+from classiq.model_expansions.quantum_operations.emitter import Emitter
+from classiq.model_expansions.scope import QuantumSymbol
+
+
+class BindEmitter(Emitter[BindOperation]):
+    def emit(self, bind: BindOperation, /) -> None:
+        with self._propagated_var_stack.capture_variables(bind):
+            pass
+        inputs: List[QuantumSymbol] = [
+            self._interpreter.evaluate(arg).as_type(QuantumSymbol)
+            for arg in bind.in_handles
+        ]
+        outputs: List[QuantumSymbol] = [
+            self._interpreter.evaluate(arg).as_type(QuantumSymbol)
+            for arg in bind.out_handles
+        ]
+        inputs = evaluate_types_in_quantum_symbols(inputs, self._current_scope)
+        outputs = evaluate_types_in_quantum_symbols(outputs, self._current_scope)
+        validate_bind_targets(bind, self._current_scope)
+        unsized_outputs = [
+            output for output in outputs if not output.quantum_type.has_size_in_bits
+        ]
+
+        if len(unsized_outputs) > 1:
+            raise ClassiqExpansionError(
+                f"Cannot perform the split operation {bind.in_handles[0].name} -> {{{', '.join(out_handle.name for out_handle in bind.out_handles)}}}:\n"
+                f"Quantum variables {', '.join(str(out_handle.handle) for out_handle in unsized_outputs)} are used as bind outputs, but their size cannot be inferred."
+            )
+
+        input_size = sum(input.quantum_type.size_in_bits for input in inputs)
+        output_size = sum(
+            output.quantum_type.size_in_bits
+            for output in outputs
+            if output.quantum_type.has_size_in_bits
+        )
+
+        if len(unsized_outputs) == 1:
+            set_size(
+                unsized_outputs[0].quantum_type,
+                input_size - output_size,
+                str(unsized_outputs[0].handle),
+            )
+
+        else:
+            if input_size != output_size:
+                raise ClassiqExpansionError(
+                    f"The total size for the input and output of the bind operation must be the same. The in size is {input_size} and the out size is {output_size}"
+                )
+
+        self._builder.emit_statement(
+            BindOperation(in_handles=bind.in_handles, out_handles=bind.out_handles)
+        )

classiq/model_expansions/quantum_operations/classicalif.py

@@ -0,0 +1,39 @@
+from typing import List
+
+from classiq.interface.model.classical_if import ClassicalIf
+from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+from classiq.interface.model.statement_block import ConcreteQuantumStatement
+
+from classiq.model_expansions.closure import FunctionClosure
+from classiq.model_expansions.quantum_operations.emitter import Emitter
+from classiq.model_expansions.scope import Scope
+
+
+def _is_all_identity_calls(body: List[ConcreteQuantumStatement]) -> bool:
+    return all(
+        isinstance(stmt, QuantumFunctionCall) and stmt.func_name.lower() == "identity"
+        for stmt in body
+    )
+
+
+class ClassicalIfEmitter(Emitter[ClassicalIf]):
+    def emit(self, classical_if: ClassicalIf, /) -> None:
+        condition = self._interpreter.evaluate(classical_if.condition).as_type(bool)
+        body: List[ConcreteQuantumStatement] = (
+            classical_if.then if condition else classical_if.else_
+        )
+        if _is_all_identity_calls(body):
+            return
+
+        if not self._should_wrap(body):
+            for stmt in body:
+                self._interpreter.emit_statement(stmt)
+            return
+
+        then_else_func = FunctionClosure.create(
+            name="then" if condition else "else",
+            body=body,
+            scope=Scope(parent=self._current_scope),
+        )
+        with self._propagated_var_stack.capture_variables(classical_if):
+            self._emit_quantum_function_call(then_else_func, list())

classiq/model_expansions/quantum_operations/control.py

@@ -0,0 +1,235 @@
+from typing import List, Tuple
+
+from sympy import Equality
+from sympy.logic.boolalg import Boolean
+from typing_extensions import TypeGuard
+
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.generator.compiler_keywords import INPLACE_ARITH_AUX_VAR_PREFIX
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.expression_types import ExpressionValue
+from classiq.interface.generator.expressions.qmod_qscalar_proxy import QmodQNumProxy
+from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
+from classiq.interface.generator.functions.builtins.internal_operators import (
+    CONTROL_OPERATOR_NAME,
+)
+from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.control import Control
+from classiq.interface.model.handle_binding import HANDLE_ID_SEPARATOR, HandleBinding
+from classiq.interface.model.quantum_expressions.arithmetic_operation import (
+    ArithmeticOperation,
+)
+from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+from classiq.interface.model.quantum_type import QuantumBit, QuantumBitvector
+from classiq.interface.model.statement_block import ConcreteQuantumStatement
+from classiq.interface.model.variable_declaration_statement import (
+    VariableDeclarationStatement,
+)
+from classiq.interface.model.within_apply_operation import WithinApply
+
+from classiq.model_expansions.capturing.propagated_var_stack import (
+    validate_args_are_not_propagated,
+)
+from classiq.model_expansions.closure import Closure
+from classiq.model_expansions.evaluators.control import (
+    resolve_num_condition,
+    type_name,
+)
+from classiq.model_expansions.quantum_operations.expression_operation import (
+    ExpressionOperationEmitter,
+)
+from classiq.model_expansions.scope import Scope
+from classiq.qmod.builtins.functions import inplace_prepare_int
+
+ARRAY_CAST_SUFFIX = HANDLE_ID_SEPARATOR + "array_cast"
+
+
+class ControlEmitter(ExpressionOperationEmitter[Control]):
+    def emit(self, control: Control, /) -> None:
+        condition = self._evaluate_op_expression(control)
+        control = control.copy(update=dict(expression=condition))
+
+        arrays_with_subscript = self._get_symbols_to_split(condition)
+        if len(arrays_with_subscript) > 0:
+            self._emit_with_split(control, condition, arrays_with_subscript)
+            return
+
+        condition_val = condition.value.value
+        if isinstance(condition_val, QmodSizedProxy):
+            self._validate_canonical_condition(condition_val)
+            self._emit_canonical_control(control)
+            return
+
+        self._validate_condition(condition_val)
+        self._emit_with_boolean(control)
+
+    def _emit_canonical_control(self, control: Control) -> None:
+        # canonical means control(q, body) where q is a single quantum variable
+        control = self._evaluate_types_in_expression(control, control.expression)
+        if self._should_wrap_control(control):
+            self._emit_wrapped(control)
+            return
+        self._emit_as_operation(control)
+
+    def _should_wrap_control(self, control: Control) -> bool:
+        # TODO we can return back to the general case (as in _should_wrap function)
+        #  once we implement the "smart control" pass to blocks:
+        #  Control(q, body) -> WithinApply(
+        #       compute=aux:=QBit(), allocate(1, aux), Control(q, [X(aux)]),
+        #       action=Control(aux, body)
+        #  )
+        #  We also need to be able to nest multiple Control statements to a single one
+        return len(control.body) > 1
+
+    def _emit_as_operation(self, control: Control) -> None:
+        control_operation = Closure(
+            name=CONTROL_OPERATOR_NAME,
+            blocks=dict(body=control.body),
+            scope=Scope(parent=self._current_scope),
+        )
+        with self._propagated_var_stack.capture_variables(control):
+            context = self._expand_operation(control_operation)
+            validate_args_are_not_propagated(
+                control.var_handles,
+                self._propagated_var_stack.get_propagated_variables(),
+            )
+        self._update_control_state(control)
+        self._builder.emit_statement(
+            control.copy(update=dict(body=context.statements("body")))
+        )
+
+    def _emit_wrapped(self, control: Control) -> None:
+        with self._propagated_var_stack.capture_variables(control):
+            wrapping_function = self._create_expanded_wrapping_function(
+                CONTROL_OPERATOR_NAME, control.body
+            )
+            validate_args_are_not_propagated(
+                control.var_handles,
+                self._propagated_var_stack.get_propagated_variables(),
+            )
+        self._update_control_state(control)
+        self._builder.emit_statement(
+            control.copy(update=dict(body=[wrapping_function]))
+        )
+
+    @staticmethod
+    def _update_control_state(control: Control) -> None:
+        condition_val = control.expression.value.value
+        if not isinstance(condition_val, QmodSizedProxy):
+            raise ClassiqInternalExpansionError("Control is not in canonical form")
+        control.set_ctrl_size(condition_val.size)
+
+    def _emit_with_boolean(self, control: Control) -> None:
+        condition_val = control.expression.value.value
+        if self._is_simple_equality(condition_val):
+            ctrl, ctrl_state = resolve_num_condition(condition_val)
+            self._emit_with_x_gates(control, ctrl, ctrl_state)
+        else:
+            self._emit_with_arithmetic(control)
+
+    @staticmethod
+    def _is_simple_equality(condition_val: ExpressionValue) -> TypeGuard[Equality]:
+        # Note that we don't support equalities with non-integer values yet
+        return isinstance(condition_val, Equality) and (
+            (
+                condition_val.args[0].is_Atom
+                and not isinstance(condition_val.args[0], QmodSizedProxy)
+                and isinstance(condition_val.args[1], QmodSizedProxy)
+            )
+            or (
+                condition_val.args[1].is_Atom
+                and not isinstance(condition_val.args[1], QmodSizedProxy)
+                and isinstance(condition_val.args[0], QmodSizedProxy)
+            )
+        )
+
+    def _create_canonical_control_op(
+        self, control: Control, handle_name: str
+    ) -> Control:
+        handle_expr = self._interpreter.evaluate(Expression(expr=handle_name)).emit()
+        return control.copy(update=dict(expression=handle_expr))
+
+    def _emit_with_x_gates(
+        self, control: Control, ctrl: QmodSizedProxy, ctrl_state: str
+    ) -> None:
+        compute_op: List[ConcreteQuantumStatement] = []
+
+        x_gate_value = self._get_x_gate_value(ctrl_state)
+        if x_gate_value != 0:
+            prepare_int_call = QuantumFunctionCall(
+                function=inplace_prepare_int.func_decl.name,
+                positional_args=[Expression(expr=str(x_gate_value)), ctrl.handle],
+            )
+            prepare_int_call.set_func_decl(inplace_prepare_int.func_decl)
+            compute_op.append(prepare_int_call)
+
+        if isinstance(ctrl, QmodQNumProxy):
+            # Canonical control does not accept QNum, so we have to cast it
+            cast_decl, bind_op = self._get_array_cast_ops(ctrl)
+            self._interpreter.emit_statement(cast_decl)
+            compute_op.append(bind_op)
+            control_op = self._create_canonical_control_op(control, str(cast_decl.name))
+        else:
+            control_op = self._create_canonical_control_op(control, str(ctrl.handle))
+
+        self._interpreter.emit_statement(
+            WithinApply(compute=compute_op, action=[control_op])
+        )
+
+    @staticmethod
+    def _get_x_gate_value(ctrl_state: str) -> int:
+        x_gate_value = 0
+        for idx, bit in enumerate(ctrl_state):
+            x_gate_value += int(bit == "0") << idx
+        return x_gate_value
+
+    def _get_array_cast_ops(
+        self, ctrl: QmodQNumProxy
+    ) -> Tuple[VariableDeclarationStatement, BindOperation]:
+        array_cast = self._counted_name_allocator.allocate(
+            f"{ctrl.handle}{ARRAY_CAST_SUFFIX}"
+        )
+        cast_decl = VariableDeclarationStatement(
+            name=array_cast, quantum_type=QuantumBitvector()
+        )
+        bind_op = BindOperation(
+            in_handles=[ctrl.handle], out_handles=[HandleBinding(name=array_cast)]
+        )
+        return cast_decl, bind_op
+
+    def _emit_with_arithmetic(self, control: Control) -> None:
+        aux_var = self._counted_name_allocator.allocate(INPLACE_ARITH_AUX_VAR_PREFIX)
+        self._interpreter.emit_statement(
+            VariableDeclarationStatement(name=aux_var, quantum_type=QuantumBit())
+        )
+        arith_expression = ArithmeticOperation(
+            result_var=HandleBinding(name=aux_var),
+            expression=control.expression,
+            inplace_result=False,
+        )
+        self._interpreter.emit_statement(
+            WithinApply(
+                compute=[arith_expression],
+                action=[self._create_canonical_control_op(control, aux_var)],
+            )
+        )
+
+    @staticmethod
+    def _validate_condition(condition_val: ExpressionValue) -> None:
+        if not isinstance(condition_val, Boolean):
+            raise ClassiqExpansionError(_condition_err_msg(condition_val))
+
+    @staticmethod
+    def _validate_canonical_condition(condition_val: ExpressionValue) -> None:
+        if isinstance(condition_val, QmodQNumProxy):
+            raise ClassiqExpansionError(_condition_err_msg(condition_val))
+
+
+def _condition_err_msg(condition_val: ExpressionValue) -> str:
+    return (
+        f"Control condition {str(condition_val)!r} must be a qubit, an array of "
+        f"qubits, or a boolean expression, but is {type_name(condition_val)}"
+    )

classiq/model_expansions/quantum_operations/emitter.py

@@ -0,0 +1,215 @@
+from abc import abstractmethod
+from typing import TYPE_CHECKING, Generic, List, Sequence, TypeVar, cast
+
+from classiq.interface.debug_info.debug_info import FunctionDebugInfo
+from classiq.interface.ide.visual_model 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.propagated_var_stack import (
+    PropagatedVarStack,
+    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,
+    OperationBuilder,
+)
+from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
+from classiq.model_expansions.utils.counted_name_allocator import CountedNameAllocator
+from classiq.qmod.builtins.functions import allocate, free
+
+if TYPE_CHECKING:
+    from classiq.model_expansions.interpreter import Interpreter
+
+
+QuantumStatementT = TypeVar("QuantumStatementT", bound=QuantumStatement)
+
+
+class Emitter(Generic[QuantumStatementT]):
+    def __init__(self, interpreter: "Interpreter") -> None:
+        self._interpreter = interpreter
+
+        self._scope_guard = self._interpreter._scope_guard
+        self._expand_operation = self._interpreter._expand_operation
+        self._machine_precision = self._interpreter._model.preferences.machine_precision
+
+    @abstractmethod
+    def emit(self, statement: QuantumStatementT, /) -> None:
+        pass
+
+    @property
+    def _propagated_var_stack(self) -> PropagatedVarStack:
+        return self._interpreter._propagated_var_stack
+
+    @property
+    def _builder(self) -> OperationBuilder:
+        return self._interpreter._builder
+
+    @property
+    def _current_scope(self) -> Scope:
+        return self._interpreter._current_scope
+
+    @property
+    def _expanded_functions(self) -> List[NativeFunctionDefinition]:
+        return self._interpreter._expanded_functions
+
+    @property
+    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
+        if not is_atomic:  # perform monomorphization
+            self._add_params_to_scope(
+                new_positional_arg_decls, evaluated_args, function
+            )
+            context = self._expand_operation(
+                function.with_new_declaration(new_declaration)
+            )
+            self._expanded_functions.append(
+                self._builder.create_definition(cast(FunctionContext, context))
+            )
+        new_positional_args = self._get_new_positional_args(
+            evaluated_args, is_atomic, new_positional_arg_decls
+        )
+        new_call = QuantumFunctionCall(
+            function=(
+                new_declaration.name if is_atomic else self._expanded_functions[-1].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=valuated_arg.value)
+            for arg_decl, valuated_arg in zip(new_positional_arg_decls, evaluated_args)
+            if isinstance(arg_decl, ClassicalParameterDeclaration)
+        }
+
+        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,
+        )
+        if is_atomic:
+            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 [arg.emit() for arg in 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()
+        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,
+                ),
+            )