classiq 0.38.0__py3-none-any.whl → 0.65.4__py3-none-any.whl

classiq/model_expansions/interpreters/base_interpreter.py

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

classiq/model_expansions/interpreters/frontend_generative_interpreter.py

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

classiq/model_expansions/interpreters/generative_interpreter.py

@@ -0,0 +1,249 @@
+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 (
+    VariableDeclarationStatement,
+)
+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,
+    ClassicalIfEmitter,
+    QuantumFunctionCallEmitter,
+    RepeatEmitter,
+    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):
+    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)
+
+    @emit.register
+    def emit_quantum_assignment_operation(self, op: QuantumAssignmentOperation) -> None:
+        ShallowEmitter(
+            self, "assignment_operation", components=["expression", "result_var"]
+        ).emit(op)
+
+    @emit.register
+    def emit_inplace_binary_operation(self, op: InplaceBinaryOperation) -> None:
+        ShallowEmitter(
+            self, "inplace_binary_operation", components=["target", "value"]
+        ).emit(op)
+
+    @emit.register
+    def emit_variable_declaration(
+        self, variable_declaration: VariableDeclarationStatement
+    ) -> None:
+        VariableDeclarationStatementEmitter(self).emit(variable_declaration)
+
+    @emit.register
+    def emit_classical_if(self, classical_if: ClassicalIf) -> None:
+        ClassicalIfEmitter(self).emit(classical_if)
+
+    @emit.register
+    def emit_within_apply(self, within_apply: WithinApply) -> None:
+        ShallowEmitter(
+            self,
+            WITHIN_APPLY_NAME,
+            components=["within", "apply", "compute", "action"],
+        ).emit(within_apply)
+
+    @emit.register
+    def emit_invert(self, invert: Invert) -> None:
+        ShallowEmitter(self, INVERT_OPERATOR_NAME, components=["body"]).emit(invert)
+
+    @emit.register
+    def emit_repeat(self, repeat: Repeat) -> None:
+        RepeatEmitter(self).emit(repeat)
+
+    @emit.register
+    def emit_control(self, control: Control) -> None:
+        ShallowEmitter(
+            self,
+            CONTROL_OPERATOR_NAME,
+            components=["expression", "body", "else_block"],
+        ).emit(control)
+
+    @emit.register
+    def emit_power(self, power: Power) -> None:
+        ShallowEmitter(self, CONTROL_OPERATOR_NAME, components=["power", "body"]).emit(
+            power
+        )
+
+    @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/model_tables.py

@@ -0,0 +1,18 @@
+from typing import Optional
+
+from classiq.interface.generator.expressions.handle_identifier import HandleIdentifier
+from classiq.interface.generator.functions.classical_type import QmodPyObject
+
+
+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,9 @@
+from classiq.model_expansions.quantum_operations.bind import BindEmitter
+from classiq.model_expansions.quantum_operations.classicalif import ClassicalIfEmitter
+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,
+)

classiq/model_expansions/quantum_operations/bind.py

@@ -0,0 +1,60 @@
+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:
+        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.emit_statement(
+            BindOperation(in_handles=bind.in_handles, out_handles=bind.out_handles)
+        )