classiq 0.76.0__py3-none-any.whl → 0.78.0__py3-none-any.whl

classiq/model_expansions/evaluators/parameter_types.py

@@ -20,6 +20,7 @@ from classiq.interface.generator.functions.type_name import (
 from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
 )
+from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_declaration import (
     PositionalArg,
@@ -46,7 +47,12 @@ from classiq.model_expansions.evaluators.quantum_type_utils import (
     set_length,
     set_size,
 )
-from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
+from classiq.model_expansions.scope import (
+    Evaluated,
+    QuantumSymbol,
+    QuantumVariable,
+    Scope,
+)
 
 
 def evaluate_parameter_types_from_args(
@@ -83,10 +89,10 @@ def _update_scope(
         return
     if parameter.direction is PortDeclarationDirection.Output:
         return
-    quantum_symbol = argument.as_type(QuantumSymbol)
+    quantum_var = argument.as_type(QuantumVariable)
     casted_argument = _cast(
         parameter.quantum_type,
-        quantum_symbol,
+        quantum_var.quantum_type,
         parameter.name,
     )
     closure.scope[parameter.name] = Evaluated(
@@ -120,12 +126,12 @@ def _update_operand_signature_environment(
 
 
 def _cast(
-    quantum_type: QuantumType, quantum_symbol: QuantumSymbol, param_name: str
+    parameter_type: QuantumType, argument_type: QuantumType, param_name: str
 ) -> QuantumSymbol:
-    updated_quantum_type = quantum_type.model_copy()
-    _inject_quantum_arg_info_to_type(updated_quantum_type, quantum_symbol, param_name)
+    updated_quantum_type = parameter_type.model_copy()
+    _inject_quantum_arg_info_to_type(updated_quantum_type, argument_type, param_name)
     return QuantumSymbol(
-        handle=quantum_symbol.handle, quantum_type=updated_quantum_type
+        handle=HandleBinding(name=param_name), quantum_type=updated_quantum_type
     )
 
 
@@ -148,7 +154,9 @@ def _evaluate_type_from_arg(
     )
     if parameter.direction != PortDeclarationDirection.Output:
         updated_quantum_type = _inject_quantum_arg_info_to_type(
-            updated_quantum_type, argument.as_type(QuantumSymbol), parameter.name
+            updated_quantum_type,
+            argument.as_type(QuantumVariable).quantum_type,
+            parameter.name,
         )
     return parameter.model_copy(update={"quantum_type": updated_quantum_type})
 
@@ -280,11 +288,11 @@ def evaluate_types_in_quantum_symbols(
 
 
 def _inject_quantum_arg_info_to_type(
-    parameter_type: QuantumType, quantum_symbol: QuantumSymbol, param_name: str
+    parameter_type: QuantumType, argument_type: QuantumType, param_name: str
 ) -> QuantumType:
-    if quantum_symbol.quantum_type.has_size_in_bits:
+    if argument_type.has_size_in_bits:
         copy_type_information(
-            quantum_symbol.quantum_type,
+            argument_type,
             parameter_type,
             param_name,
         )

classiq/model_expansions/expression_evaluator.py

@@ -1,7 +1,7 @@
 import ast
 from collections.abc import Mapping
 from enum import EnumMeta
-from typing import Any, Optional
+from typing import Any
 
 from sympy import SympifyError, sympify
 
@@ -50,11 +50,25 @@ def evaluate_constants_as_python(constants: list[Constant]) -> dict[str, Any]:
     }
 
 
+def _quick_eval(expr: str) -> Any:
+    try:
+        return int(expr)
+    except ValueError:
+        pass
+    try:
+        return float(expr)
+    except ValueError:
+        pass
+    return None
+
+
 def evaluate(
-    expr: Expression,
-    locals_dict: Mapping[str, EvaluatedExpression],
-    uninitialized_locals: Optional[set[str]] = None,
+    expr: Expression, locals_dict: Mapping[str, EvaluatedExpression]
 ) -> EvaluatedExpression:
+    val = _quick_eval(expr.expr)
+    if val is not None:
+        return EvaluatedExpression(value=val)
+
     model_locals: dict[str, ExpressionValue] = {}
     model_locals.update(ATOMIC_EXPRESSION_FUNCTIONS)
     model_locals.update(
@@ -65,9 +79,8 @@ def evaluate(
     )
     # locals override builtin-functions
     model_locals.update({name: expr.value for name, expr in locals_dict.items()})
-    uninitialized_locals = uninitialized_locals or set()
 
-    _validate_undefined_vars(expr.expr, model_locals, uninitialized_locals)
+    _validate_undefined_vars(expr.expr, model_locals)
 
     sympy_expr = translate_to_sympy(expr.expr)
     try:
@@ -95,11 +108,8 @@ def evaluate(
 
 
 def _validate_undefined_vars(
-    expr: str,
-    model_locals: dict[str, ExpressionValue],
-    uninitialized_locals: Optional[set[str]],
+    expr: str, model_locals: dict[str, ExpressionValue]
 ) -> None:
-    uninitialized_locals = uninitialized_locals or set()
     id_visitor = _VarsCollector()
     id_visitor.visit(ast.parse(expr))
     identifiers = id_visitor.vars
@@ -108,7 +118,6 @@ def _validate_undefined_vars(
         - model_locals.keys()
         - set(SYMPY_SUPPORTED_EXPRESSIONS)
         - set(symbolic.__all__)
-        - uninitialized_locals
     )
 
     if len(undefined_vars) == 1:

classiq/model_expansions/generative_functions.py

@@ -134,7 +134,7 @@ class _InterpreterExpandable(QFunc):
         dummy_function = NativeFunctionDefinition(
             name=current_operation.name,
             positional_arg_declarations=current_operation.positional_arg_declarations,
-            body=self._interpreter._builder._current_statements + [stmt],
+            body=[stmt],
         )
         declarative_functions = {
             name: func

classiq/model_expansions/interpreters/base_interpreter.py

@@ -24,6 +24,7 @@ from classiq.interface.generator.types.compilation_metadata import CompilationMe
 from classiq.interface.model.handle_binding import (
     FieldHandleBinding,
     HandleBinding,
+    HandlesList,
     SlicedHandleBinding,
     SubscriptHandleBinding,
 )
@@ -51,7 +52,12 @@ from classiq.model_expansions.function_builder import (
     OperationBuilder,
     OperationContext,
 )
-from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
+from classiq.model_expansions.scope import (
+    Evaluated,
+    QuantumSymbol,
+    QuantumSymbolList,
+    Scope,
+)
 from classiq.model_expansions.scope_initialization import (
     add_entry_point_params_to_scope,
     init_builtin_types,
@@ -98,10 +104,8 @@ class BaseInterpreter:
             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), main_closure.positional_arg_declarations
-            )
+        self._expanded_functions[main_closure.name] = self._builder.create_definition(
+            cast(FunctionContext, context), main_closure.positional_arg_declarations
         )
 
     def _get_main_closure(self, main_func: FunctionClosure) -> FunctionClosure:
@@ -233,6 +237,14 @@ class BaseInterpreter:
             )
         return Evaluated(value=fields[field_name])
 
+    @evaluate.register
+    def evaluate_handles_list(self, handles_list: HandlesList) -> Evaluated:
+        return Evaluated(
+            value=QuantumSymbolList.from_symbols(
+                [self.evaluate(handle).value for handle in handles_list.handles]
+            )
+        )
+
     @abstractmethod
     def emit(self, statement: QuantumStatement) -> None:
         pass
@@ -261,19 +273,19 @@ class BaseInterpreter:
 
     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
-            ):
-                cached_closure = self._top_level_scope[func_def.name].value
-                operation.captured_vars.set(
-                    cached_closure.captured_vars, cached_closure, operation
-                )
-            else:
-                self._expand_body(operation)
+            self._expand_body(operation)
 
         return context
 
+    def _expand_cached_function(
+        self, operation: FunctionClosure, func_def: NativeFunctionDefinition
+    ) -> None:
+        with self._builder.operation_context(operation):
+            cached_closure = self._top_level_scope[func_def.name].value
+            operation.captured_vars.set(
+                cached_closure.captured_vars, cached_closure, operation
+            )
+
     def _expand_body(self, operation: Closure) -> None:
         for block, block_body in operation.blocks.items():
             self._expand_block(block_body, block)

classiq/model_expansions/interpreters/frontend_generative_interpreter.py

@@ -6,11 +6,7 @@ from pydantic import ValidationError
 from classiq.interface.exceptions import ClassiqError
 from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.bind_operation import BindOperation
-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,
-)
 from classiq.interface.source_reference import SourceReference
 
 from classiq.model_expansions.closure import FunctionClosure, GenerativeFunctionClosure
@@ -23,22 +19,10 @@ from classiq.model_expansions.quantum_operations.quantum_function_call import (
     DeclarativeQuantumFunctionCallEmitter,
 )
 from classiq.model_expansions.scope import Scope
-from classiq.model_expansions.visitors.symbolic_param_inference import (
-    SymbolicParamInference,
-)
 from classiq.qmod.model_state_container import QMODULE
 
 
 class FrontendGenerativeInterpreter(GenerativeInterpreter):
-    def infer_symbolic_parameters(
-        self,
-        functions: list[NativeFunctionDefinition],
-        additional_signatures: (
-            list[NamedParamsQuantumFunctionDeclaration] | None
-        ) = None,
-    ) -> None:
-        SymbolicParamInference(functions, additional_signatures).infer()
-
     def emit_allocate(self, allocate: Allocate) -> None:
         AllocateEmitter(self, allow_symbolic_size=True).emit(allocate)
 

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
@@ -104,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
 

classiq/model_expansions/quantum_operations/allocate.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Optional
 
 import sympy
 
@@ -49,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(

classiq/model_expansions/quantum_operations/assignment_result_processor.py

@@ -1,3 +1,5 @@
+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.expressions.expression import Expression
@@ -69,7 +71,7 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
         self._assign_to_inferred_var_and_bind(op, result_type, inferred_result_type)
         return True
 
-    def _infer_result_type(self, op: ArithmeticOperation) -> QuantumNumeric | None:
+    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 None

classiq/model_expansions/quantum_operations/call_emitter.py

@@ -4,6 +4,7 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Generic,
+    Optional,
     cast,
 )
 from uuid import UUID
@@ -27,16 +28,19 @@ from classiq.interface.generator.expressions.proxies.classical.qmod_struct_insta
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+from classiq.interface.generator.functions.type_qualifier import TypeQualifier
 from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
 )
 from classiq.interface.model.handle_binding import HandleBinding
+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_call import ArgValue, QuantumFunctionCall
 from classiq.interface.model.quantum_function_declaration import (
     NamedParamsQuantumFunctionDeclaration,
     PositionalArg,
+    QuantumOperandDeclaration,
 )
 from classiq.interface.model.quantum_statement import QuantumStatement
 from classiq.interface.model.variable_declaration_statement import (
@@ -48,7 +52,7 @@ from classiq.model_expansions.capturing.captured_vars import (
     UNINITIALIZED_VAR_MESSAGE,
     validate_args_are_not_propagated,
 )
-from classiq.model_expansions.closure import FunctionClosure
+from classiq.model_expansions.closure import Closure, FunctionClosure
 from classiq.model_expansions.evaluators.argument_types import (
     add_information_from_output_arguments,
 )
@@ -62,7 +66,19 @@ from classiq.model_expansions.quantum_operations.emitter import (
     Emitter,
     QuantumStatementT,
 )
-from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
+from classiq.model_expansions.quantum_operations.function_calls_cache import (
+    get_func_call_cache_key,
+)
+from classiq.model_expansions.scope import (
+    Evaluated,
+    QuantumSymbol,
+    QuantumSymbolList,
+    QuantumVariable,
+    Scope,
+)
+from classiq.model_expansions.transformers.type_qualifier_inference import (
+    TypeQualifierInference,
+)
 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 (
@@ -74,11 +90,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:
@@ -130,7 +149,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
@@ -140,8 +159,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:
@@ -152,7 +171,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)
@@ -164,19 +183,22 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         )
         new_positional_arg_decls = new_declaration.positional_arg_declarations
         if not self.should_expand_function(function, evaluated_args):
-            is_atomic = True
             new_declaration = self._expanded_functions_by_name.get(
                 function.name, new_declaration
             )
         else:
-            is_atomic = False
             new_declaration = self._expand_function(
                 evaluated_args, new_declaration, function
             )
+            new_positional_arg_decls = new_declaration.positional_arg_declarations
+            evaluated_args = [
+                arg
+                for arg in evaluated_args
+                if isinstance(arg.value, QuantumVariable) or _is_symbolic(arg.value)
+            ]
 
-        new_positional_args = self._get_new_positional_args(
-            evaluated_args, is_atomic, new_positional_arg_decls
-        )
+        add_information_from_output_arguments(new_positional_arg_decls, evaluated_args)
+        new_positional_args = [arg.emit() for arg in evaluated_args]
         captured_args = function.captured_vars.filter_vars(function).get_captured_args(
             self._builder.current_function
         )
@@ -219,18 +241,20 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         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]
+        function = function.with_new_declaration(decl)
+        cache_key = get_func_call_cache_key(decl, args)
+        if cache_key in self._expanded_functions:
+            function_def = self._expanded_functions[cache_key]
+            self._expand_cached_function(function, function_def)
             self._expanded_functions_compilation_metadata[
                 function_def.name
             ].occurrences_number += 1
             return function_def
 
+        context = self._expand_operation(function)
+        function_context = cast(FunctionContext, context)
         function_def = self._create_function_definition(function_context, args)
-        self._expanded_functions[closure_id] = function_def
+        self._expanded_functions[cache_key] = function_def
         self._top_level_scope[function_def.name] = Evaluated(
             value=function_context.closure.with_new_declaration(function_def)
         )
@@ -260,6 +284,7 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         )
         captured_ports = captured_vars.get_captured_parameters()
         if len(captured_ports) == 0:
+            self._override_type_qualifier(function_context, func_def)
             return func_def
         func_def.positional_arg_declarations = list(
             chain.from_iterable((func_def.positional_arg_declarations, captured_ports))
@@ -271,6 +296,8 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
             rewrite_mapping |= captured_vars.get_classical_captured_mapping()
         func_def.body = self.rewrite(func_def.body, rewrite_mapping)
 
+        self._override_type_qualifier(function_context, func_def)
+
         return func_def
 
     @staticmethod
@@ -281,7 +308,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(
@@ -299,26 +326,6 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
             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) or _is_symbolic(arg.value)
-        ]
-
-        return positional_args
-
     def _prepare_fully_typed_declaration(
         self, function: FunctionClosure, evaluated_args: list[Evaluated]
     ) -> NamedParamsQuantumFunctionDeclaration:
@@ -371,3 +378,45 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
                 raise ClassiqExpansionError(UNINITIALIZED_VAR_MESSAGE.format(var_name))
             if var_state and param.direction == PortDeclarationDirection.Output:
                 raise ClassiqExpansionError(INITIALIZED_VAR_MESSAGE.format(var_name))
+
+    def _override_type_qualifier(
+        self, func_context: FunctionContext, func_def: NativeFunctionDefinition
+    ) -> None:
+        """
+        The type qualifier can be changed according to the operand passed to the
+        function. For example,
+        apply_to_all(X, q) --> q will be QFree after expansion
+        apply_to_all(H, q) --> q will be Quantum after expansion
+        This also holds for the intermediate lambda created during the expansion.
+
+        We don't override the type qualifier if it's explicitly specified (QFree or
+        Const), neither in the function declaration nor in the operand declaration.
+        """
+
+        if func_context.is_lambda:
+            self._update_type_qualifiers(func_def)
+            return
+
+        orig_name = func_context.name
+        if (
+            orig_name == MAIN_FUNCTION_NAME
+            or orig_name not in func_context.closure.scope
+        ):
+            return
+
+        orig_func = func_context.closure.scope[orig_name].value
+        if isinstance(orig_func, Closure) and not any(
+            isinstance(param_decl, QuantumOperandDeclaration)
+            for param_decl in orig_func.positional_arg_declarations
+        ):
+            return
+
+        self._update_type_qualifiers(func_def)
+
+    @staticmethod
+    def _update_type_qualifiers(func_def: NativeFunctionDefinition) -> None:
+        # only override the qualifier if it's unspecified (not QFree or Const)
+        for port in func_def.port_declarations:
+            if port.type_qualifier is TypeQualifier.Quantum:
+                port.type_qualifier = TypeQualifier.Inferred
+        TypeQualifierInference().run(func_def.port_declarations, func_def.body)

classiq/model_expansions/quantum_operations/emitter.py

@@ -47,7 +47,7 @@ from classiq.interface.model.quantum_function_declaration import (
 )
 from classiq.interface.model.quantum_statement import QuantumOperation, QuantumStatement
 
-from classiq.model_expansions.closure import Closure, GenerativeClosure
+from classiq.model_expansions.closure import Closure, FunctionClosure, GenerativeClosure
 from classiq.model_expansions.function_builder import (
     OperationBuilder,
     OperationContext,
@@ -87,6 +87,11 @@ class Emitter(Generic[QuantumStatementT], ABC):
     def _expand_operation(self, closure: Closure) -> OperationContext:
         return self._interpreter._expand_operation(closure)
 
+    def _expand_cached_function(
+        self, closure: FunctionClosure, func_def: NativeFunctionDefinition
+    ) -> None:
+        return self._interpreter._expand_cached_function(closure, func_def)
+
     @property
     def _builder(self) -> OperationBuilder:
         return self._interpreter._builder
@@ -181,12 +186,7 @@ class Emitter(Generic[QuantumStatementT], ABC):
             self._capture_classical_var(var_name, var_type)
 
     def _update_captured_vars(self, op: QuantumOperation) -> None:
-        handles = (
-            [(handle, PortDeclarationDirection.Input) for handle in op.inputs]
-            + [(handle, PortDeclarationDirection.Output) for handle in op.outputs]
-            + [(handle, PortDeclarationDirection.Inout) for handle in op.inouts]
-        )
-        for handle, direction in handles:
+        for handle, direction in op.handles_with_directions:
             self._capture_handle(handle, direction)
 
     def _capture_handle(