classiq 0.75.0__py3-none-any.whl → 0.77.0__py3-none-any.whl

classiq/model_expansions/interpreters/generative_interpreter.py

@@ -1,5 +1,5 @@
 from functools import singledispatchmethod
-from typing import Any
+from typing import Any, Optional
 
 import numpy as np
 from numpy.random import permutation
@@ -61,7 +61,11 @@ from classiq.model_expansions.quantum_operations.allocate import AllocateEmitter
 from classiq.model_expansions.quantum_operations.assignment_result_processor import (
     AssignmentResultProcessor,
 )
-from classiq.model_expansions.quantum_operations.block_evaluator import BlockEvaluator
+from classiq.model_expansions.quantum_operations.block_evaluator import (
+    BlockEvaluator,
+    IfElimination,
+    RepeatElimination,
+)
 from classiq.model_expansions.quantum_operations.composite_emitter import (
     CompositeEmitter,
 )
@@ -100,9 +104,9 @@ class GenerativeInterpreter(BaseInterpreter):
     def infer_symbolic_parameters(
         self,
         functions: list[NativeFunctionDefinition],
-        additional_signatures: (
-            list[NamedParamsQuantumFunctionDeclaration] | None
-        ) = None,
+        additional_signatures: Optional[
+            list[NamedParamsQuantumFunctionDeclaration]
+        ] = None,
     ) -> None:
         pass
 
@@ -152,10 +156,16 @@ class GenerativeInterpreter(BaseInterpreter):
         QuantumFunctionCallEmitter(self).emit(call)
 
     @emit.register
+    def _emit_allocate(self, allocate: Allocate) -> None:
+        return self.emit_allocate(allocate)
+
     def emit_allocate(self, allocate: Allocate) -> None:
         AllocateEmitter(self).emit(allocate)
 
     @emit.register
+    def _emit_bind(self, bind: BindOperation) -> None:
+        self.emit_bind(bind)
+
     def emit_bind(self, bind: BindOperation) -> None:
         BindEmitter(self).emit(bind)
 
@@ -210,6 +220,7 @@ class GenerativeInterpreter(BaseInterpreter):
             self,
             [
                 ExpressionEvaluator(self, "condition"),
+                IfElimination(self),
                 BlockEvaluator(
                     self,
                     CLASSICAL_IF_OPERATOR_NAME,
@@ -243,6 +254,7 @@ class GenerativeInterpreter(BaseInterpreter):
             self,
             [
                 ExpressionEvaluator(self, "count"),
+                RepeatElimination(self),
                 RepeatBlockEvaluator(self, REPEAT_OPERATOR_NAME, "body"),
             ],
         ).emit(repeat)

classiq/model_expansions/quantum_operations/allocate.py

@@ -1,10 +1,13 @@
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Optional
 
 import sympy
 
 from classiq.interface.debug_info.debug_info import FunctionDebugInfo
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
+    AnyClassicalValue,
+)
 from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.handle_binding import NestedHandleBinding
 from classiq.interface.model.quantum_type import QuantumBitvector
@@ -46,7 +49,7 @@ class AllocateEmitter(Emitter[Allocate]):
         self.emit_statement(allocate)
         return True
 
-    def _get_var_size(self, target: QuantumSymbol, size: Expression | None) -> str:
+    def _get_var_size(self, target: QuantumSymbol, size: Optional[Expression]) -> str:
         if size is None:
             if not target.quantum_type.is_evaluated:
                 raise ClassiqValueError(
@@ -55,7 +58,9 @@ class AllocateEmitter(Emitter[Allocate]):
             return str(target.quantum_type.size_in_bits)
 
         size_value = self._interpreter.evaluate(size).value
-        if self._allow_symbolic_size and isinstance(size_value, sympy.Basic):
+        if self._allow_symbolic_size and isinstance(
+            size_value, (sympy.Basic, AnyClassicalValue)
+        ):
             return str(size_value)
         if not isinstance(size_value, (int, float)):
             raise ClassiqValueError(

classiq/model_expansions/quantum_operations/assignment_result_processor.py

@@ -1,6 +1,14 @@
+from typing import Optional
+
+from classiq.interface.exceptions import ClassiqExpansionError
 from classiq.interface.generator.arith.arithmetic import compute_arithmetic_result_type
-from classiq.interface.generator.functions.port_declaration import (
-    PortDeclarationDirection,
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.model.allocate import Allocate
+from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.handle_binding import (
+    ConcreteHandleBinding,
+    HandleBinding,
+    SubscriptHandleBinding,
 )
 from classiq.interface.model.quantum_expressions.arithmetic_operation import (
     ArithmeticOperation,
@@ -9,6 +17,12 @@ from classiq.interface.model.quantum_expressions.arithmetic_operation import (
 from classiq.interface.model.quantum_expressions.quantum_expression import (
     QuantumAssignmentOperation,
 )
+from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+from classiq.interface.model.quantum_type import QuantumBitvector, QuantumNumeric
+from classiq.interface.model.variable_declaration_statement import (
+    VariableDeclarationStatement,
+)
+from classiq.interface.model.within_apply_operation import WithinApply
 
 from classiq.model_expansions.evaluators.quantum_type_utils import copy_type_information
 from classiq.model_expansions.quantum_operations.arithmetic.explicit_boolean_expressions import (
@@ -18,26 +32,49 @@ from classiq.model_expansions.quantum_operations.arithmetic.explicit_boolean_exp
 from classiq.model_expansions.quantum_operations.emitter import Emitter
 from classiq.model_expansions.scope import QuantumSymbol
 from classiq.model_expansions.transformers.ast_renamer import rename_variables
+from classiq.qmod.builtins.functions.standard_gates import CX
 
 
 class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
     def emit(self, op: QuantumAssignmentOperation, /) -> bool:
-        if (
+        if not (
             isinstance(op, ArithmeticOperation)
             and op.operation_kind == ArithmeticOperationKind.Assignment
         ):
-            direction = PortDeclarationDirection.Output
-            self._update_result_type(op)
-            convert_assignment_bool_expression(op)
-        else:
-            direction = PortDeclarationDirection.Inout
-        self._capture_handle(op.result_var, direction)
-        return False
-
-    def _update_result_type(self, op: ArithmeticOperation) -> None:
+            return False
+
+        result_symbol = self._interpreter.evaluate(op.result_var).as_type(QuantumSymbol)
+        result_type = result_symbol.quantum_type
+
+        validate_assignment_bool_expression(
+            result_symbol, op.expression.expr, op.operation_kind
+        )
+        convert_assignment_bool_expression(op)
+
+        inferred_result_type = self._infer_result_type(op)
+        if inferred_result_type is None:
+            return False
+
+        if not isinstance(result_type, QuantumNumeric):
+            copy_type_information(
+                inferred_result_type, result_symbol.quantum_type, str(op.result_var)
+            )
+            return False
+
+        self._copy_numeric_attributes(result_type, inferred_result_type)
+        if self._same_numeric_attributes(result_type, inferred_result_type):
+            return False
+
+        self._validate_declared_attributes(
+            result_type, inferred_result_type, str(op.result_var)
+        )
+        self._assign_to_inferred_var_and_bind(op, result_type, inferred_result_type)
+        return True
+
+    def _infer_result_type(self, op: ArithmeticOperation) -> Optional[QuantumNumeric]:
         expr = self._evaluate_expression(op.expression)
         if len(self._get_classical_vars_in_expression(expr)):
-            return
+            return None
         symbols = self._get_symbols_in_expression(expr)
         expr_str = rename_variables(
             expr.expr,
@@ -48,16 +85,180 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
             expr_str = expr_str.replace(
                 symbol.handle.qmod_expr, symbol.handle.identifier
             )
-        result_type = compute_arithmetic_result_type(
+        return compute_arithmetic_result_type(
             expr_str,
             {symbol.handle.identifier: symbol.quantum_type for symbol in symbols},
             self._machine_precision,
         )
-        result_symbol = self._interpreter.evaluate(op.result_var).as_type(QuantumSymbol)
 
-        validate_assignment_bool_expression(
-            result_symbol, op.expression.expr, op.operation_kind
-        )  # must be here, otherwise copy_type_information will throw a non-indicative error
-        copy_type_information(
-            result_type, result_symbol.quantum_type, str(op.result_var)
+    @staticmethod
+    def _copy_numeric_attributes(
+        result_type: QuantumNumeric, inferred_result_type: QuantumNumeric
+    ) -> None:
+        if not result_type.has_size_in_bits:
+            result_type.size = Expression(expr=str(inferred_result_type.size_in_bits))
+        if not result_type.has_sign:
+            result_type.is_signed = Expression(
+                expr=str(inferred_result_type.sign_value)
+            )
+        if not result_type.has_fraction_digits:
+            result_type.fraction_digits = Expression(
+                expr=str(inferred_result_type.fraction_digits_value)
+            )
+
+    @staticmethod
+    def _same_numeric_attributes(
+        result_type: QuantumNumeric, inferred_result_type: QuantumNumeric
+    ) -> bool:
+        return (
+            result_type.size_in_bits == inferred_result_type.size_in_bits
+            and result_type.sign_value == inferred_result_type.sign_value
+            and result_type.fraction_digits_value
+            == inferred_result_type.fraction_digits_value
+        )
+
+    @classmethod
+    def _validate_declared_attributes(
+        cls, result_type: QuantumNumeric, inferred_result_type: QuantumNumeric, var: str
+    ) -> None:
+        result_size, result_sign, result_fractions = (
+            result_type.size_in_bits,
+            result_type.sign_value,
+            result_type.fraction_digits_value,
+        )
+        inferred_size, inferred_sign, inferred_fractions = (
+            inferred_result_type.size_in_bits,
+            inferred_result_type.sign_value,
+            inferred_result_type.fraction_digits_value,
+        )
+        result_integers = result_size - result_fractions
+        inferred_integers = inferred_size - inferred_fractions
+
+        if (
+            (result_integers < inferred_integers)
+            or (result_fractions < inferred_fractions)
+            or (not result_sign and inferred_sign)
+            or (
+                result_sign
+                and not inferred_sign
+                and result_integers == inferred_integers
+            )
+        ):
+            if (
+                not result_sign
+                and result_fractions == 0
+                and not inferred_sign
+                and inferred_fractions == 0
+            ):
+                result_size_str = f"size {result_size}"
+                inferred_size_str = f"size {inferred_size}"
+                hint = f"Hint: increase the size in the declaration of {var!r} or omit it to enable automatic inference."
+            else:
+                result_size_str = f"size {result_size}, {'signed' if result_sign else 'unsigned'}, and {result_fractions} fraction digits"
+                inferred_size_str = f"size {inferred_size}, {'signed' if inferred_sign else 'unsigned'}, and {inferred_fractions} fraction digits"
+                hint = f"Hint: omit the numeric attributes from the declaration of {var!r} to enable automatic inference."
+            raise ClassiqExpansionError(
+                f"Cannot assign an expression with inferred {inferred_size_str} to variable {var!r} with declared {result_size_str}. {hint}"
+            )
+
+    @staticmethod
+    def _craft_size_string(size: int, is_signed: bool, fraction_digits: int) -> str:
+        extra = (
+            f", with {fraction_digits} fraction digits" if fraction_digits > 0 else ""
+        )
+        return f"{size} ({'signed' if is_signed else 'unsigned'}{extra})"
+
+    def _assign_to_inferred_var_and_bind(
+        self,
+        op: ArithmeticOperation,
+        result_type: QuantumNumeric,
+        inferred_result_type: QuantumNumeric,
+    ) -> None:
+        handles: list[HandleBinding] = []
+
+        extra_fraction_digits = (
+            result_type.fraction_digits_value
+            - inferred_result_type.fraction_digits_value
+        )
+        if extra_fraction_digits > 0:
+            handles.append(
+                self._declare_qarray("extra_fraction_digits", extra_fraction_digits)
+            )
+
+        inferred_result_name = self._counted_name_allocator.allocate("inferred_result")
+        inferred_result_handle = HandleBinding(name=inferred_result_name)
+        self._interpreter.emit(
+            VariableDeclarationStatement(
+                name=inferred_result_name, quantum_type=inferred_result_type
+            )
+        )
+        handles.append(inferred_result_handle)
+        modified_op = op.model_copy(update={"result_var": inferred_result_handle})
+        self._interpreter.add_to_debug_info(modified_op)
+        self._interpreter.emit(modified_op)
+
+        result_integer_size = (
+            result_type.size_in_bits - result_type.fraction_digits_value
+        )
+        inferred_result_integer_size = (
+            inferred_result_type.size_in_bits
+            - inferred_result_type.fraction_digits_value
+        )
+        extra_integers = result_integer_size - inferred_result_integer_size
+        if extra_integers > 0:
+            handles.append(self._declare_qarray("extra_integers", extra_integers))
+
+        self._interpreter.emit(
+            BindOperation(in_handles=handles, out_handles=[op.result_var])
+        )
+
+        if (
+            result_type.sign_value
+            and inferred_result_type.sign_value
+            and extra_integers > 0
+        ):
+            sign_idx = result_type.size_in_bits - extra_integers - 1
+            self._sign_extension(op.result_var, sign_idx, result_type.size_in_bits)
+
+    def _declare_qarray(
+        self,
+        prefix: str,
+        size: int,
+        allocate: bool = True,
+    ) -> HandleBinding:
+        name = self._counted_name_allocator.allocate(prefix)
+        handle = HandleBinding(name=name)
+        quantum_type = QuantumBitvector(length=Expression(expr=str(size)))
+        self._interpreter.emit(
+            VariableDeclarationStatement(name=name, quantum_type=quantum_type)
+        )
+        if allocate:
+            self._interpreter.emit(Allocate(target=handle))
+        return handle
+
+    def _sign_extension(
+        self,
+        result_var: ConcreteHandleBinding,
+        sign_idx: int,
+        size: int,
+    ) -> None:
+        aux = self._declare_qarray("inferred_result_aux", size, allocate=False)
+        self._interpreter.emit(
+            WithinApply(
+                compute=[BindOperation(in_handles=[result_var], out_handles=[aux])],
+                action=[
+                    QuantumFunctionCall(
+                        function=CX.func_decl.name,
+                        positional_args=[
+                            SubscriptHandleBinding(
+                                base_handle=aux, index=Expression(expr=str(sign_idx))
+                            ),
+                            SubscriptHandleBinding(
+                                base_handle=aux, index=Expression(expr=str(idx))
+                            ),
+                        ],
+                    )
+                    for idx in range(sign_idx + 1, size)
+                ],
+            )
         )

classiq/model_expansions/quantum_operations/bind.py

@@ -1,3 +1,5 @@
+from typing import TYPE_CHECKING
+
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
     ClassiqInternalExpansionError,
@@ -14,41 +16,21 @@ from classiq.model_expansions.evaluators.quantum_type_utils import (
 from classiq.model_expansions.quantum_operations.emitter import Emitter
 from classiq.model_expansions.scope import Evaluated, QuantumSymbol
 
+if TYPE_CHECKING:
+    from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
+
 
 class BindEmitter(Emitter[BindOperation]):
+    def __init__(
+        self, interpreter: "BaseInterpreter", allow_symbolic_size: bool = False
+    ) -> None:
+        super().__init__(interpreter)
+        self._allow_symbolic_size = allow_symbolic_size
+
     def emit(self, bind: BindOperation, /) -> bool:
         inputs, outputs = self._get_inputs_outputs(bind)
         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._process_var_sizes(bind, inputs, outputs)
         self.emit_statement(
             BindOperation(
                 in_handles=bind.in_handles,
@@ -111,3 +93,45 @@ class BindEmitter(Emitter[BindOperation]):
                     f"{out.value.handle.name!r} on the right-hand side of a bind "
                     f"statement"
                 )
+
+    def _process_var_sizes(
+        self,
+        bind: BindOperation,
+        inputs: list[QuantumSymbol],
+        outputs: list[QuantumSymbol],
+    ) -> None:
+        unsized_inputs = [
+            input for input in inputs if not input.quantum_type.has_size_in_bits
+        ]
+        if len(unsized_inputs) > 0:
+            if self._allow_symbolic_size:
+                return
+            raise ClassiqInternalExpansionError("Uninitialized bind inputs")
+
+        unsized_outputs = [
+            output for output in outputs if not output.quantum_type.has_size_in_bits
+        ]
+        if len(unsized_outputs) > 1:
+            if self._allow_symbolic_size:
+                return
+            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),
+            )
+        elif 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}"
+            )

classiq/model_expansions/quantum_operations/block_evaluator.py

@@ -1,8 +1,14 @@
 from collections.abc import Sequence
 from typing import TYPE_CHECKING
 
+from classiq.interface.generator.functions.builtins.internal_operators import (
+    CLASSICAL_IF_OPERATOR_NAME,
+    REPEAT_OPERATOR_NAME,
+)
+from classiq.interface.model.classical_if import ClassicalIf
 from classiq.interface.model.quantum_function_declaration import PositionalArg
 from classiq.interface.model.quantum_statement import QuantumOperation, QuantumStatement
+from classiq.interface.model.repeat import Repeat
 
 from classiq.model_expansions.closure import Closure
 from classiq.model_expansions.quantum_operations.emitter import Emitter
@@ -88,3 +94,39 @@ class BlockEvaluator(Emitter[QuantumOperation]):
 
     def get_scope(self, op: QuantumOperation) -> Scope:
         return Scope(parent=self._current_scope)
+
+
+class IfElimination(BlockEvaluator):
+    def __init__(self, interpreter: "BaseInterpreter") -> None:
+        super().__init__(interpreter, CLASSICAL_IF_OPERATOR_NAME, "then", "else_")
+
+    def emit(self, op: ClassicalIf, /) -> bool:  # type:ignore[override]
+        cond = op.condition.value.value
+        if not isinstance(cond, bool):
+            return False
+        if op.is_generative():
+            if cond:
+                then_block = op.get_generative_block("then")
+                op.clear_generative_blocks()
+                op.set_generative_block("then", then_block)
+            elif not op.has_generative_block("else_"):
+                op.clear_generative_blocks()
+            else:
+                else_block = op.get_generative_block("else_")
+                op.clear_generative_blocks()
+                op.set_generative_block("else_", else_block)
+        else:
+            if cond:
+                op = op.model_copy(update={"else_": []})
+            else:
+                op = op.model_copy(update={"then": []})
+        return super().emit(op)
+
+
+class RepeatElimination(BlockEvaluator):
+    def __init__(self, interpreter: "BaseInterpreter") -> None:
+        super().__init__(interpreter, REPEAT_OPERATOR_NAME, "body")
+
+    def emit(self, op: Repeat, /) -> bool:  # type:ignore[override]
+        count = op.count.value.value
+        return isinstance(count, int) and count == 0

classiq/model_expansions/quantum_operations/call_emitter.py

@@ -4,13 +4,17 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Generic,
+    Optional,
     cast,
 )
 from uuid import UUID
 
 import sympy
 
-from classiq.interface.debug_info.debug_info import FunctionDebugInfo
+from classiq.interface.debug_info.debug_info import (
+    FunctionDebugInfo,
+    calculate_port_to_passed_variable_mapping,
+)
 from classiq.interface.exceptions import ClassiqExpansionError
 from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
     AnyClassicalValue,
@@ -59,7 +63,13 @@ from classiq.model_expansions.quantum_operations.emitter import (
     Emitter,
     QuantumStatementT,
 )
-from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
+from classiq.model_expansions.scope import (
+    Evaluated,
+    QuantumSymbol,
+    QuantumSymbolList,
+    QuantumVariable,
+    Scope,
+)
 from classiq.model_expansions.transformers.var_splitter import VarSplitter
 from classiq.model_expansions.utils.text_utils import are, readable_list, s
 from classiq.qmod.semantics.validation.signature_validation import (
@@ -71,11 +81,14 @@ if TYPE_CHECKING:
 
 
 def _validate_cloning(evaluated_args: list[Evaluated]) -> None:
-    handles = [
-        arg.value.handle
+    handles = chain.from_iterable(
+        (
+            [arg.value.handle]
+            if isinstance(arg.value, QuantumSymbol)
+            else arg.value.handles if isinstance(arg.value, QuantumSymbolList) else []
+        )
         for arg in evaluated_args
-        if isinstance(arg.value, QuantumSymbol)
-    ]
+    )
     for handle, other_handle in combinations(handles, 2):
         if handle.overlaps(other_handle):
             if handle == other_handle:
@@ -90,13 +103,15 @@ def _validate_cloning(evaluated_args: list[Evaluated]) -> None:
 
 
 def _is_symbolic(arg: Any) -> bool:
+    if isinstance(arg, (ClassicalProxy, AnyClassicalValue)):
+        return True
     if isinstance(arg, list):
         return any(_is_symbolic(item) for item in arg)
     if isinstance(arg, QmodStructInstance):
         return any(_is_symbolic(item) for item in arg.fields.values())
     if isinstance(arg, sympy.Basic):
         return len(arg.free_symbols) > 0
-    return isinstance(arg, (ClassicalProxy, AnyClassicalValue))
+    return False
 
 
 class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSplitter):
@@ -125,7 +140,7 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         self,
         function: FunctionClosure,
         args: list[ArgValue],
-        propagated_debug_info: FunctionDebugInfo | None,
+        propagated_debug_info: Optional[FunctionDebugInfo],
     ) -> QuantumFunctionCall:
         call = self._create_quantum_function_call(
             function, args, propagated_debug_info=propagated_debug_info
@@ -135,8 +150,8 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
 
     @staticmethod
     def _get_back_ref(
-        propagated_debug_info: FunctionDebugInfo | None,
-    ) -> UUID | None:
+        propagated_debug_info: Optional[FunctionDebugInfo],
+    ) -> Optional[UUID]:
         if propagated_debug_info is None:
             return None
         if propagated_debug_info.node is None:
@@ -147,7 +162,7 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         self,
         function: FunctionClosure,
         args: list[ArgValue],
-        propagated_debug_info: FunctionDebugInfo | None,
+        propagated_debug_info: Optional[FunctionDebugInfo],
     ) -> QuantumFunctionCall:
         function = function.clone()
         function = function.set_depth(self._builder.current_function.depth + 1)
@@ -187,11 +202,13 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
             back_ref=self._get_back_ref(propagated_debug_info),
         )
 
-        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)
-        }
+        port_to_passed_variable_map = calculate_port_to_passed_variable_mapping(
+            new_positional_arg_decls,
+            [
+                arg.value.handle if isinstance(arg.value, QuantumSymbol) else None
+                for arg in evaluated_args
+            ],
+        )
         self._debug_info[new_call.uuid] = FunctionDebugInfo(
             name=new_call.func_name,
             port_to_passed_variable_map=port_to_passed_variable_map,
@@ -274,7 +291,7 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
     ) -> None:
         for parameter, argument in zip(parameters, arguments):
             param_handle = HandleBinding(name=parameter.name)
-            if isinstance(argument.value, QuantumSymbol):
+            if isinstance(argument.value, QuantumVariable):
                 assert isinstance(parameter, PortDeclaration)
                 closure.scope[parameter.name] = Evaluated(
                     QuantumSymbol(
@@ -307,7 +324,7 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         positional_args = [
             arg.emit()
             for arg in evaluated_args
-            if isinstance(arg.value, QuantumSymbol) or _is_symbolic(arg.value)
+            if isinstance(arg.value, QuantumVariable) or _is_symbolic(arg.value)
         ]
 
         return positional_args

classiq/model_expansions/quantum_operations/composite_emitter.py

@@ -23,5 +23,5 @@ class CompositeEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT]):
         for emitter in self._emitters:
             if emitter.emit(statement):
                 return True
-        self._builder.emit_statement(statement)
+        self.emit_statement(statement)
         return True