classiq 0.66.0__py3-none-any.whl → 0.67.0__py3-none-any.whl

classiq/model_expansions/capturing/captured_vars.py

@@ -1,7 +1,7 @@
 import dataclasses
 from collections.abc import Sequence
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 from classiq.interface.enum_utils import StrEnum
 from classiq.interface.exceptions import (
@@ -34,8 +34,8 @@ if TYPE_CHECKING:
     from classiq.model_expansions.closure import FunctionClosure
 
 
-ALREADY_ALLOCATED_MESSAGE = "Cannot allocate variable '{}', it is already initialized"
-ALREADY_FREED_MESSAGE = "Cannot free variable '{}', it is already uninitialized"
+INITIALIZED_VAR_MESSAGE = "Variable '{}' should be uninitialized here"
+UNINITIALIZED_VAR_MESSAGE = "Variable '{}' should be initialized here"
 
 
 class PortDirection(StrEnum):
@@ -103,6 +103,11 @@ class _CapturedHandle:
     def change_direction(self, new_direction: PortDirection) -> "_CapturedHandle":
         return dataclasses.replace(self, direction=new_direction)
 
+    def change_defining_function(
+        self, new_defining_function: "FunctionClosure"
+    ) -> "_CapturedHandle":
+        return dataclasses.replace(self, defining_function=new_defining_function)
+
     def set_propagated(self) -> "_CapturedHandle":
         return dataclasses.replace(self, is_propagated=True)
 
@@ -119,9 +124,13 @@ class _CapturedHandle:
         return dataclasses.replace(self, handle=handle, quantum_type=quantum_type)
 
 
+HandleState = tuple[str, "FunctionClosure", bool]
+
+
 @dataclass
 class CapturedVars:
     _captured_handles: list[_CapturedHandle] = field(default_factory=list)
+    _handle_states: list[HandleState] = field(default_factory=list)
 
     def capture_handle(
         self,
@@ -151,9 +160,25 @@ class CapturedVars:
                 else "allocate"
             )
             raise ClassiqExpansionError(
-                f"Cannot partially {verb} variable {captured_handle.handle.name}"
+                f"Cannot {verb} partial variable {str(captured_handle.handle)!r}"
             )
 
+        # A handle should be in either _captured_handles or _handle_states, but never
+        # both
+
+        new_handle_states = []
+        for var_name, defining_function, handle_state in self._handle_states:
+            if captured_handle.handle.name == var_name and _same_closure(
+                captured_handle.defining_function, defining_function
+            ):
+                # verify variable state
+                self._conjugate_direction(
+                    handle_state, captured_handle.direction, var_name
+                )
+            else:
+                new_handle_states.append((var_name, defining_function, handle_state))
+        self._handle_states = new_handle_states
+
         new_captured_handles = []
         for existing_captured_handle in self._captured_handles:
             if not existing_captured_handle.is_same_var(captured_handle):
@@ -163,8 +188,12 @@ class CapturedVars:
                 existing_captured_handle
             )
             if existing_captured_handle.handle == captured_handle.handle:
-                captured_handle = self._conjugate_direction(
-                    existing_captured_handle, captured_handle
+                captured_handle = captured_handle.change_direction(
+                    self._conjugate_direction(
+                        existing_captured_handle.direction,
+                        captured_handle.direction,
+                        str(captured_handle.handle),
+                    )
                 )
             elif captured_handle.handle.overlaps(existing_captured_handle.handle):
                 captured_handle = self._intersect_handles(
@@ -177,44 +206,43 @@ class CapturedVars:
 
     def _conjugate_direction(
         self,
-        existing_captured_handle: _CapturedHandle,
-        captured_handle: _CapturedHandle,
-    ) -> _CapturedHandle:
-        if existing_captured_handle.direction == PortDirection.Input:
-            if captured_handle.direction == PortDirection.Output:
-                return captured_handle.change_direction(PortDirection.Inout)
-            if captured_handle.direction == PortDirection.Outin:
-                return captured_handle.change_direction(PortDirection.Input)
-            raise ClassiqExpansionError(
-                ALREADY_FREED_MESSAGE.format(captured_handle.handle)
+        source_direction: PortDirection | bool,
+        target_direction: PortDirection,
+        var_name: str,
+    ) -> PortDirection:
+        if isinstance(source_direction, bool):
+            source_direction = (
+                PortDirection.Inout if source_direction else PortDirection.Outin
             )
-        if existing_captured_handle.direction == PortDirection.Output:
-            if captured_handle.direction == PortDirection.Input:
-                return captured_handle.change_direction(PortDirection.Outin)
-            if captured_handle.direction in (
-                PortDirection.Output,
-                PortDirection.Outin,
-            ):
-                raise ClassiqExpansionError(
-                    ALREADY_ALLOCATED_MESSAGE.format(captured_handle.handle)
-                )
-            return captured_handle.change_direction(PortDirection.Output)
-        if existing_captured_handle.direction == PortDirection.Inout:
-            if captured_handle.direction in (
+
+        if source_direction == PortDirection.Input:
+            if target_direction == PortDirection.Output:
+                return PortDirection.Inout
+            if target_direction == PortDirection.Outin:
+                return PortDirection.Input
+            raise ClassiqExpansionError(UNINITIALIZED_VAR_MESSAGE.format(var_name))
+
+        if source_direction == PortDirection.Output:
+            if target_direction == PortDirection.Input:
+                return PortDirection.Outin
+            if target_direction in (
                 PortDirection.Output,
                 PortDirection.Outin,
             ):
-                raise ClassiqExpansionError(
-                    ALREADY_ALLOCATED_MESSAGE.format(captured_handle.handle)
-                )
-        elif captured_handle.direction in (
-            PortDirection.Input,
-            PortDirection.Inout,
-        ):
-            raise ClassiqExpansionError(
-                ALREADY_FREED_MESSAGE.format(captured_handle.handle)
-            )
-        return captured_handle
+                raise ClassiqExpansionError(INITIALIZED_VAR_MESSAGE.format(var_name))
+            return PortDirection.Output
+
+        if source_direction == PortDirection.Inout:
+            if target_direction in (PortDirection.Input, PortDirection.Inout):
+                return target_direction
+            raise ClassiqExpansionError(INITIALIZED_VAR_MESSAGE.format(var_name))
+
+        if source_direction == PortDirection.Outin:
+            if target_direction in (PortDirection.Output, PortDirection.Outin):
+                return target_direction
+            raise ClassiqExpansionError(UNINITIALIZED_VAR_MESSAGE.format(var_name))
+
+        raise ClassiqInternalExpansionError(f"Unexpected direction {source_direction}")
 
     def _intersect_handles(
         self,
@@ -227,7 +255,7 @@ class CapturedVars:
                 PortDirection.Outin,
             ):
                 raise ClassiqExpansionError(
-                    ALREADY_FREED_MESSAGE.format(captured_handle.handle)
+                    UNINITIALIZED_VAR_MESSAGE.format(captured_handle.handle)
                 )
             return existing_captured_handle
 
@@ -237,7 +265,7 @@ class CapturedVars:
                 PortDirection.Outin,
             ):
                 raise ClassiqExpansionError(
-                    ALREADY_ALLOCATED_MESSAGE.format(captured_handle.handle)
+                    INITIALIZED_VAR_MESSAGE.format(captured_handle.handle)
                 )
             return captured_handle
 
@@ -316,16 +344,7 @@ class CapturedVars:
             ]
         )
 
-    def filter_vars(
-        self,
-        current_function: "FunctionClosure",
-        current_declarations: Optional[list[VariableDeclarationStatement]] = None,
-    ) -> "CapturedVars":
-        current_declared_vars = (
-            None
-            if current_declarations is None
-            else {decl.name for decl in current_declarations}
-        )
+    def filter_vars(self, current_function: "FunctionClosure") -> "CapturedVars":
         return CapturedVars(
             _captured_handles=[
                 captured_handle
@@ -333,7 +352,18 @@ class CapturedVars:
                 if not _same_closure(
                     captured_handle.defining_function, current_function
                 )
-                or (
+            ]
+        )
+
+    def filter_var_decls(
+        self, current_declarations: list[VariableDeclarationStatement]
+    ) -> "CapturedVars":
+        current_declared_vars = {decl.name for decl in current_declarations}
+        return CapturedVars(
+            _captured_handles=[
+                captured_handle
+                for captured_handle in self._captured_handles
+                if (
                     current_declared_vars is not None
                     and captured_handle.handle.name not in current_declared_vars
                 )
@@ -376,8 +406,92 @@ class CapturedVars:
             if not captured_handle.is_propagated
         }
 
+    def init_var(self, var_name: str, defining_function: "FunctionClosure") -> None:
+        self._handle_states.append((var_name, defining_function, False))
+
+    def init_params(self, func: "FunctionClosure") -> None:
+        ports = {
+            param.name: param.direction
+            for param in func.positional_arg_declarations
+            if isinstance(param, PortDeclaration)
+        }
+        new_handle_states = [
+            handle_state
+            for handle_state in self._handle_states
+            if handle_state[0] not in ports
+        ]
+        for var_name, direction in ports.items():
+            new_handle_states.append(
+                (
+                    var_name,
+                    func,
+                    PortDirection.load(direction)
+                    in (PortDirection.Input, PortDirection.Inout),
+                )
+            )
+        self._handle_states = new_handle_states
+
+    def _get_handle_states(self) -> list[HandleState]:
+        return self._handle_states + list(
+            {
+                (
+                    captured_handle.handle.name,
+                    captured_handle.defining_function.depth,
+                ): (
+                    captured_handle.handle.name,
+                    captured_handle.defining_function,
+                    captured_handle.direction
+                    in (PortDirection.Output, PortDirection.Inout),
+                )
+                for captured_handle in self._captured_handles
+            }.values()
+        )
+
+    def set_parent(self, parent: "CapturedVars") -> None:
+        self._handle_states += parent._get_handle_states()
+
+    def get_state(self, var_name: str, defining_function: "FunctionClosure") -> bool:
+        for name, func, state in self._handle_states:
+            if name == var_name and _same_closure(func, defining_function):
+                return state
+        for captured_handle in self._captured_handles:
+            if captured_handle.handle.name == var_name and _same_closure(
+                captured_handle.defining_function, defining_function
+            ):
+                return captured_handle.direction in (
+                    PortDirection.Output,
+                    PortDirection.Inout,
+                )
+        raise ClassiqInternalExpansionError(
+            f"Cannot find {var_name!r} from {defining_function.name!r}"
+        )
+
     def clone(self) -> "CapturedVars":
-        return CapturedVars(_captured_handles=list(self._captured_handles))
+        return CapturedVars(
+            _captured_handles=list(self._captured_handles),
+            _handle_states=list(self._handle_states),
+        )
+
+    def set(
+        self,
+        other: "CapturedVars",
+        source_func: "FunctionClosure",
+        target_func: "FunctionClosure",
+    ) -> None:
+        self._captured_handles = []
+        for captured_handle in other._captured_handles:
+            if _same_closure(captured_handle.defining_function, source_func):
+                self._captured_handles.append(
+                    captured_handle.change_defining_function(target_func)
+                )
+            else:
+                self._captured_handles.append(captured_handle)
+        self._handle_states = []
+        for var, defining_function, state in other._handle_states:
+            if _same_closure(defining_function, source_func):
+                self._handle_states.append((var, target_func, state))
+            else:
+                self._handle_states.append((var, defining_function, state))
 
 
 def _same_closure(closure_1: "FunctionClosure", closure_2: "FunctionClosure") -> bool:
@@ -433,3 +547,19 @@ def validate_captured_directions(
         raise ClassiqExpansionError(
             f"Captured quantum variables {captured_outputs!r} cannot be used as outputs"
         )
+
+
+def validate_end_state(func: "FunctionClosure", captured_vars: CapturedVars) -> None:
+    for param in func.positional_arg_declarations:
+        if isinstance(param, PortDeclaration):
+            state = captured_vars.get_state(param.name, func)
+            expected_state = param.direction in (
+                PortDeclarationDirection.Output,
+                PortDeclarationDirection.Inout,
+            )
+            if state != expected_state:
+                status = "initialized" if expected_state else "uninitialized"
+                raise ClassiqExpansionError(
+                    f"At the end of function {func.name}, variable {param.name!r} "
+                    f"should be {status}"
+                )

classiq/model_expansions/closure.py

@@ -83,18 +83,21 @@ class FunctionClosure(Closure):
         scope: Scope,
         body: Optional[Sequence[QuantumStatement]] = None,
         positional_arg_declarations: Sequence[PositionalArg] = tuple(),
-        is_lambda: bool = False,
+        lambda_external_vars: Optional[CapturedVars] = None,
         is_atomic: bool = False,
         **kwargs: Any,
     ) -> Self:
         blocks = {"body": body} if body is not None else {}
+        captured_vars = CapturedVars()
+        if lambda_external_vars is not None:
+            captured_vars.set_parent(lambda_external_vars)
         return cls(
             name,
             blocks,
             scope,
             positional_arg_declarations,
-            CapturedVars(),
-            is_lambda,
+            captured_vars,
+            lambda_external_vars is not None,
             is_atomic,
             **kwargs,
         )

classiq/model_expansions/evaluators/control.py

@@ -4,6 +4,10 @@ from sympy import Equality
 from sympy.core.numbers import Number
 
 from classiq.interface.exceptions import ClassiqExpansionError
+from classiq.interface.generator.arith.argument_utils import (
+    unsigned_integer_interpretation,
+)
+from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
 from classiq.interface.generator.expressions.qmod_qscalar_proxy import (
     QmodQNumProxy,
     QmodQScalarProxy,
@@ -31,14 +35,15 @@ def resolve_num_condition(condition: Equality) -> tuple[QmodSizedProxy, str]:
 def _calculate_ctrl_state(ctrl: QmodSizedProxy, ctrl_val: float) -> str:
     is_signed, fraction_places = _get_numeric_attributes(ctrl)
 
-    integer_ctrl_val = _get_integer_ctrl_val(ctrl, ctrl_val, fraction_places)
-
-    _validate_control_value_sign(ctrl, integer_ctrl_val, is_signed)
-    _validate_control_var_qubits(
-        ctrl, integer_ctrl_val, is_signed, fraction_places, ctrl_val
+    reg = RegisterArithmeticInfo(
+        size=ctrl.size, is_signed=is_signed, fraction_places=fraction_places
     )
+    uint_ctrl_val = unsigned_integer_interpretation(ctrl_val, reg)
 
-    return _to_twos_complement(integer_ctrl_val, ctrl.size)
+    _validate_control_value_sign(ctrl, ctrl_val, is_signed)
+    _validate_control_var_qubits(ctrl, uint_ctrl_val, fraction_places, ctrl_val)
+
+    return _to_twos_complement(uint_ctrl_val, ctrl.size)
 
 
 def _get_numeric_attributes(ctrl: QmodSizedProxy) -> tuple[bool, int]:
@@ -49,20 +54,8 @@ def _get_numeric_attributes(ctrl: QmodSizedProxy) -> tuple[bool, int]:
     )
 
 
-def _get_integer_ctrl_val(
-    ctrl: QmodSizedProxy, ctrl_val: float, fraction_places: int
-) -> int:
-    unfractioned_ctrl_val = ctrl_val * 2**fraction_places
-    if unfractioned_ctrl_val != int(unfractioned_ctrl_val):
-        raise ClassiqExpansionError(
-            f"Variable {str(ctrl)!r} doesne't have enough fraction digits to "
-            f"represent control value {ctrl_val}"
-        )
-    return int(unfractioned_ctrl_val)
-
-
 def _validate_control_value_sign(
-    ctrl: QmodSizedProxy, ctrl_val: int, is_signed: bool
+    ctrl: QmodSizedProxy, ctrl_val: float, is_signed: bool
 ) -> None:
     if not is_signed and ctrl_val < 0:
         raise ClassiqExpansionError(
@@ -74,18 +67,17 @@ def _validate_control_value_sign(
 def _validate_control_var_qubits(
     ctrl: QmodSizedProxy,
     ctrl_val: int,
-    is_signed: bool,
     fraction_places: int,
     orig_ctrl_val: float,
 ) -> None:
-    required_qubits = _min_bit_length(ctrl_val, is_signed)
+    required_qubits = _min_unsigned_bit_length(ctrl_val)
     fraction_places_message = (
         f" with {fraction_places} fraction digits" if fraction_places else ""
     )
     if ctrl.size < required_qubits:
         raise ClassiqExpansionError(
             f"Variable {str(ctrl)!r} has {ctrl.size} qubits{fraction_places_message} but control value "
-            f"{str(orig_ctrl_val if fraction_places else ctrl_val)!r} requires at least {required_qubits} qubits{fraction_places_message}"
+            f"{str(orig_ctrl_val if fraction_places else int(orig_ctrl_val))!r} requires at least {required_qubits} qubits{fraction_places_message}"
         )
 
 
@@ -116,22 +108,6 @@ def _min_unsigned_bit_length(number: int) -> int:
         raise e
 
 
-def _min_signed_bit_length(number: int) -> int:
-    pos_val = abs(number)
-    is_whole = pos_val & (pos_val - 1) == 0
-    if number <= 0 and is_whole:
-        return _min_unsigned_bit_length(pos_val)
-    return _min_unsigned_bit_length(pos_val) + 1
-
-
-def _min_bit_length(number: int, is_signed: bool) -> int:
-    return (
-        _min_signed_bit_length(number)
-        if is_signed
-        else _min_unsigned_bit_length(number)
-    )
-
-
 def _to_twos_complement(value: int, bits: int) -> str:
     if value >= 0:
         return bin(value)[2:].zfill(bits)[::-1]

classiq/model_expansions/function_builder.py

@@ -28,6 +28,7 @@ from classiq.interface.source_reference import SourceReference
 from classiq.model_expansions.capturing.captured_vars import (
     CapturedVars,
     validate_captured_directions,
+    validate_end_state,
 )
 from classiq.model_expansions.closure import (
     Closure,
@@ -142,7 +143,9 @@ class OperationBuilder:
     @contextmanager
     def block_context(self, block_name: str) -> Iterator[None]:
         self._blocks.append(block_name)
-        self._operations[-1].blocks[block_name] = Block()
+        block = Block()
+        block.captured_vars.set_parent(self.current_operation.captured_vars)
+        self._operations[-1].blocks[block_name] = block
         yield
         captured_vars = self.current_block.captured_vars
         if (
@@ -150,14 +153,12 @@ class OperationBuilder:
             and self.current_operation.name != WITHIN_APPLY_NAME
         ):
             validate_captured_directions(
-                captured_vars.filter_vars(
-                    self.current_function, self.current_block.variable_declarations
+                captured_vars.filter_var_decls(
+                    self.current_block.variable_declarations
                 ),
                 report_outin=False,
             )
-        self.current_operation.captured_vars.update(
-            captured_vars.filter_vars(self.current_function)
-        )
+        self.current_operation.captured_vars.update(captured_vars)
         self._blocks.pop()
 
     @contextmanager
@@ -167,11 +168,17 @@ class OperationBuilder:
         context: OperationContext
         if isinstance(original_operation, FunctionClosure):
             context = FunctionContext.create(original_operation)
+            context.closure.captured_vars.init_params(original_operation)
         else:
             context = OperationContext(closure=original_operation)
+            context.closure.captured_vars.set_parent(self.current_block.captured_vars)
         self._operations.append(context)
         yield context
         self._finalize_within_apply()
+        if isinstance(self.current_operation, FunctionClosure):
+            validate_end_state(
+                self.current_operation, self.current_operation.captured_vars
+            )
         self._propagate_captured_vars()
         self._operations.pop()
 
@@ -179,21 +186,19 @@ class OperationBuilder:
         if self.current_operation.name != WITHIN_APPLY_NAME:
             return
         within_captured_vars = self._operations[-1].blocks["within"].captured_vars
-        self.current_operation.captured_vars.update(
-            within_captured_vars.filter_vars(self.current_function).negate()
-        )
+        self.current_operation.captured_vars.update(within_captured_vars.negate())
 
     def _propagate_captured_vars(self) -> None:
         captured_vars = self.current_operation.captured_vars
         if isinstance(self.current_operation, FunctionClosure):
-            captured_vars = captured_vars.set_propagated()
-        validate_captured_directions(captured_vars)
+            captured_vars = captured_vars.filter_vars(
+                self.current_function
+            ).set_propagated()
+            validate_captured_directions(captured_vars)
         if len(self._operations) < 2:
             return
         parent_block = self._operations[-2].blocks[self._blocks[-1]]
-        parent_block.captured_vars.update(
-            captured_vars.filter_vars(self.parent_function)
-        )
+        parent_block.captured_vars.update(captured_vars)
 
     @contextmanager
     def source_ref_context(

classiq/model_expansions/generative_functions.py

@@ -24,9 +24,7 @@ from classiq.qmod.generative import generative_mode_context, set_frontend_interp
 from classiq.qmod.model_state_container import QMODULE
 from classiq.qmod.qmod_parameter import CParamStruct
 from classiq.qmod.qmod_variable import QNum, _create_qvar_for_qtype
-from classiq.qmod.quantum_callable import QCallable
 from classiq.qmod.quantum_expandable import (
-    QExpandable,
     QTerminalCallable,
 )
 from classiq.qmod.quantum_function import QFunc
@@ -147,12 +145,10 @@ def emit_generative_statements(
         translate_ast_arg_to_python_qmod(param, arg)
         for param, arg in zip(operation.positional_arg_declarations, args)
     ]
-    interpreter_expandable = _InterpreterExpandable(interpreter)
-    QExpandable.STACK.append(interpreter_expandable)
-    QCallable.CURRENT_EXPANDABLE = interpreter_expandable
-    set_frontend_interpreter(interpreter)
-    for block_name, generative_function in operation.generative_blocks.items():
-        with interpreter._builder.block_context(block_name), generative_mode_context(
-            True
-        ):
-            generative_function._py_callable(*python_qmod_args)
+    with _InterpreterExpandable(interpreter):
+        set_frontend_interpreter(interpreter)
+        for block_name, generative_function in operation.generative_blocks.items():
+            with interpreter._builder.block_context(
+                block_name
+            ), generative_mode_context(True):
+                generative_function._py_callable(*python_qmod_args)

classiq/model_expansions/interpreters/base_interpreter.py

@@ -144,7 +144,7 @@ class BaseInterpreter:
 
     def process_exception(self, e: Exception) -> None:
         if not isinstance(e, (ClassiqError, ValidationError)):
-            raise ClassiqInternalExpansionError(str(e)) from None
+            raise ClassiqInternalExpansionError(str(e)) from e
         prefix = ""
         if not isinstance(e, ClassiqExpansionError):
             prefix = f"{type(e).__name__}: "
@@ -212,8 +212,15 @@ class BaseInterpreter:
 
     @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])
+        base_value = self.evaluate(field_access.base_handle).as_type(QuantumSymbol)
+        fields = base_value.fields
+        field_name = field_access.field
+        if field_name not in fields:
+            raise ClassiqExpansionError(
+                f"Struct {base_value.quantum_type.type_name} has no field "
+                f"{field_name!r}. Available fields: {', '.join(fields.keys())}"
+            )
+        return Evaluated(value=fields[field_name])
 
     @abstractmethod
     def emit(self, statement: QuantumStatement) -> None:
@@ -251,8 +258,10 @@ class BaseInterpreter:
                 (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)
+                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)
 

classiq/model_expansions/interpreters/generative_interpreter.py

@@ -101,15 +101,16 @@ class GenerativeInterpreter(BaseInterpreter):
             closure_class = FunctionClosure
             extra_args = {}
 
+        closure = 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),
+            lambda_external_vars=self._builder.current_block.captured_vars,
+            **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,
-            ),
+            value=closure,
             defining_function=self._builder.current_function,
         )
 

classiq/model_expansions/quantum_operations/allocate.py

@@ -13,7 +13,6 @@ from classiq.model_expansions.scope import QuantumSymbol
 
 class AllocateEmitter(Emitter[Allocate]):
     def emit(self, allocate: Allocate, /) -> None:
-        self._register_debug_info(allocate)
         target: QuantumSymbol = self._interpreter.evaluate(allocate.target).as_type(
             QuantumSymbol
         )
@@ -25,8 +24,13 @@ class AllocateEmitter(Emitter[Allocate]):
 
         size = self._get_var_size(target, allocate.size)
         allocate = allocate.model_copy(
-            update=dict(size=Expression(expr=str(size)), target=target.handle)
+            update=dict(
+                size=Expression(expr=str(size)),
+                target=target.handle,
+                back_ref=allocate.uuid,
+            )
         )
+        self._register_debug_info(allocate)
         self.emit_statement(allocate)
 
     def _get_var_size(self, target: QuantumSymbol, size: Expression | None) -> int: