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

classiq/model_expansions/quantum_operations/emitter.py

@@ -1,5 +1,15 @@
 from abc import abstractmethod
-from typing import TYPE_CHECKING, Generic, List, Sequence, TypeVar, cast
+from typing import (
+    TYPE_CHECKING,
+    Dict,
+    Generic,
+    List,
+    Optional,
+    Sequence,
+    TypeVar,
+    Union,
+    cast,
+)
 
 from classiq.interface.debug_info.debug_info import FunctionDebugInfo
 from classiq.interface.ide.visual_model import OperationLevel
@@ -14,7 +24,7 @@ from classiq.interface.model.quantum_function_declaration import (
     NamedParamsQuantumFunctionDeclaration,
     PositionalArg,
 )
-from classiq.interface.model.quantum_statement import QuantumStatement
+from classiq.interface.model.quantum_statement import QuantumOperation, QuantumStatement
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
@@ -23,7 +33,7 @@ from classiq.model_expansions.capturing.propagated_var_stack import (
     PropagatedVarStack,
     validate_args_are_not_propagated,
 )
-from classiq.model_expansions.closure import FunctionClosure
+from classiq.model_expansions.closure import Closure, FunctionClosure, GenerativeClosure
 from classiq.model_expansions.evaluators.argument_types import (
     add_information_from_output_arguments,
 )
@@ -33,10 +43,13 @@ from classiq.model_expansions.evaluators.parameter_types import (
 from classiq.model_expansions.function_builder import (
     FunctionContext,
     OperationBuilder,
+    OperationContext,
 )
+from classiq.model_expansions.generative_functions import emit_operands_as_declarative
 from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
 from classiq.model_expansions.utils.counted_name_allocator import CountedNameAllocator
 from classiq.qmod.builtins.functions import allocate, free
+from classiq.qmod.quantum_function import GenerativeQFunc
 
 if TYPE_CHECKING:
     from classiq.model_expansions.interpreter import Interpreter
@@ -50,13 +63,24 @@ class Emitter(Generic[QuantumStatementT]):
         self._interpreter = interpreter
 
         self._scope_guard = self._interpreter._scope_guard
-        self._expand_operation = self._interpreter._expand_operation
         self._machine_precision = self._interpreter._model.preferences.machine_precision
 
+        self._generative_contexts: Dict[str, OperationContext] = {}
+
     @abstractmethod
     def emit(self, statement: QuantumStatementT, /) -> None:
         pass
 
+    def _expand_operation(self, closure: Closure) -> OperationContext:
+        if closure.name in self._generative_contexts:
+            if isinstance(closure, FunctionClosure):
+                return FunctionContext(
+                    closure=closure,
+                    blocks=self._generative_contexts[closure.name].blocks,
+                )
+            return self._generative_contexts[closure.name]
+        return self._interpreter._expand_operation(closure)
+
     @property
     def _propagated_var_stack(self) -> PropagatedVarStack:
         return self._interpreter._propagated_var_stack
@@ -131,16 +155,22 @@ class Emitter(Generic[QuantumStatementT]):
             or new_call.func_name == free.func_decl.name
         )
         parameters = {
-            arg_decl.name: FunctionDebugInfo.param_controller(value=valuated_arg.value)
-            for arg_decl, valuated_arg in zip(new_positional_arg_decls, evaluated_args)
+            arg_decl.name: FunctionDebugInfo.param_controller(value=evaluated_arg.value)
+            for arg_decl, evaluated_arg in zip(new_positional_arg_decls, evaluated_args)
             if isinstance(arg_decl, ClassicalParameterDeclaration)
         }
 
+        port_to_passed_variable_map = {
+            arg_decl.name: evaluated_arg.value.handle.name
+            for arg_decl, evaluated_arg in zip(new_positional_arg_decls, evaluated_args)
+            if isinstance(arg_decl, PortDeclaration)
+        }
         self._interpreter._model.debug_info[new_call.uuid] = FunctionDebugInfo(
             name=new_call.func_name,
             level=OperationLevel.QMOD_FUNCTION_CALL,
             parameters=parameters,
             is_allocate_or_free=is_allocate_or_free,
+            port_to_passed_variable_map=port_to_passed_variable_map,
         )
         if is_atomic:
             new_call.set_func_decl(new_declaration)
@@ -175,7 +205,10 @@ class Emitter(Generic[QuantumStatementT]):
             new_positional_arg_decls, evaluated_args
         )
         if is_atomic:
-            return [arg.emit() for arg in evaluated_args]
+            return [
+                emit_operands_as_declarative(self._interpreter, param, arg)
+                for param, arg in zip(new_positional_arg_decls, evaluated_args)
+            ]
 
         positional_args = [
             arg.emit() for arg in evaluated_args if isinstance(arg.value, QuantumSymbol)
@@ -213,3 +246,31 @@ class Emitter(Generic[QuantumStatementT]):
                     evaluated_args,
                 ),
             )
+
+    def _register_generative_context(
+        self,
+        op: QuantumOperation,
+        context_name: str,
+        block_names: Union[None, str, List[str]] = None,
+        func_decl: Optional[NamedParamsQuantumFunctionDeclaration] = None,
+    ) -> OperationContext:
+        if isinstance(block_names, str):
+            block_names = [block_names]
+        block_names = block_names or ["body"]
+        func_decl = func_decl or NamedParamsQuantumFunctionDeclaration(
+            name=context_name
+        )
+        gen_closure = GenerativeClosure(
+            name=func_decl.name,
+            scope=Scope(parent=self._interpreter._current_scope),
+            blocks={},
+            generative_blocks={
+                block_name: GenerativeQFunc(
+                    op.get_generative_block(block_name), func_decl
+                )
+                for block_name in block_names
+            },
+        )
+        context = self._interpreter._expand_operation(gen_closure)
+        self._generative_contexts[context_name] = context
+        return context

classiq/model_expansions/quantum_operations/expression_operation.py

@@ -58,17 +58,20 @@ class ExpressionOperationEmitter(Emitter[ExpressionOperationT]):
         symbols_parts, bind_ops = self._get_bind_ops(symbols_to_split)
 
         for symbol_parts in symbols_parts:
-            for symbol in symbol_parts:
+            for symbol, symbol_part_var_name in symbol_parts:
                 if symbol.handle.identifier not in self._current_scope:
                     self._interpreter.emit_statement(
                         VariableDeclarationStatement(
-                            name=symbol.handle.identifier,
+                            name=symbol_part_var_name,
                             quantum_type=symbol.quantum_type,
                         )
                     )
 
         new_expression = self._update_op_expression(
-            {symbol.handle: symbol for symbol in chain.from_iterable(symbols_parts)},
+            {
+                symbol.handle: symbol_part_var_name
+                for symbol, symbol_part_var_name in chain.from_iterable(symbols_parts)
+            },
             expression,
         )
         new_op = op.copy(update=dict(expression=new_expression))
@@ -83,7 +86,7 @@ class ExpressionOperationEmitter(Emitter[ExpressionOperationT]):
 
     def _update_op_expression(
         self,
-        symbol_parts: Dict[HandleBinding, QuantumSymbol],
+        symbol_parts: Dict[HandleBinding, str],
         expression: Expression,
     ) -> Expression:
         vrc = VarRefCollector(ignore_duplicated_handles=True)
@@ -94,7 +97,7 @@ class ExpressionOperationEmitter(Emitter[ExpressionOperationT]):
             collapsed_handle = handle.collapse()
             if collapsed_handle in symbol_parts:
                 new_expr_str = new_expr_str.replace(
-                    str(handle), symbol_parts[collapsed_handle].handle.identifier
+                    str(handle), symbol_parts[collapsed_handle]
                 )
         self._check_all_handles_were_replaced(new_expr_str)
 
@@ -115,32 +118,38 @@ class ExpressionOperationEmitter(Emitter[ExpressionOperationT]):
             ):
                 raise ClassiqInternalExpansionError(f"Did not replace handle {handle}")
 
-    @staticmethod
     def _get_bind_ops(
+        self,
         symbols_to_split: List[QuantumSymbol],
-    ) -> Tuple[List[List[QuantumSymbol]], List[BindOperation]]:
+    ) -> Tuple[List[List[Tuple[QuantumSymbol, str]]], List[BindOperation]]:
         bind_ops = []
         symbols_parts = []
         for symbol in symbols_to_split:
-            symbol_parts = ExpressionOperationEmitter._get_symbol_parts(symbol)
+            symbol_parts = self._get_symbol_parts(symbol)
             symbols_parts.append(symbol_parts)
             bind_ops.append(
                 BindOperation(
                     in_handles=[symbol.handle],
                     out_handles=[
-                        HandleBinding(name=symbol_part.handle.identifier)
-                        for symbol_part in symbol_parts
+                        HandleBinding(name=symbol_part_var_name)
+                        for _, symbol_part_var_name in symbol_parts
                     ],
                 )
             )
         return symbols_parts, bind_ops
 
-    @staticmethod
-    def _get_symbol_parts(symbol: QuantumSymbol) -> List[QuantumSymbol]:
+    def _get_symbol_parts(
+        self, symbol: QuantumSymbol
+    ) -> List[Tuple[QuantumSymbol, str]]:
         quantum_type = symbol.quantum_type
 
         if isinstance(quantum_type, (QuantumBit, QuantumNumeric)):
-            return [symbol]
+            return [
+                (
+                    symbol,
+                    self._counted_name_allocator.allocate(symbol.handle.identifier),
+                )
+            ]
 
         if isinstance(quantum_type, QuantumBitvector):
             if not quantum_type.has_length:
@@ -150,7 +159,7 @@ class ExpressionOperationEmitter(Emitter[ExpressionOperationT]):
                 )
             return list(
                 chain.from_iterable(
-                    ExpressionOperationEmitter._get_symbol_parts(symbol[idx])
+                    self._get_symbol_parts(symbol[idx])
                     for idx in range(quantum_type.length_value)
                 )
             )
@@ -160,7 +169,7 @@ class ExpressionOperationEmitter(Emitter[ExpressionOperationT]):
 
         return list(
             chain.from_iterable(
-                ExpressionOperationEmitter._get_symbol_parts(field_symbol)
+                self._get_symbol_parts(field_symbol)
                 for field_symbol in symbol.fields.values()
             )
         )
@@ -204,7 +213,7 @@ class ExpressionOperationEmitter(Emitter[ExpressionOperationT]):
         op_with_evaluated_types = op.copy(update={"expression": expression})
         vrc = VarRefCollector()
         vrc.visit(ast.parse(op_with_evaluated_types.expression.expr))
-        handles = list(vrc.var_handles)
+        handles = vrc.var_handles
         op_with_evaluated_types.set_var_handles(handles)
         op_with_evaluated_types.initialize_var_types(
             {

classiq/model_expansions/quantum_operations/inplace_binary_operation.py

@@ -1,6 +1,5 @@
-from typing import TYPE_CHECKING, List, Optional, Sequence, Tuple
+from typing import TYPE_CHECKING, List, Tuple
 
-from classiq.interface.exceptions import ClassiqInternalExpansionError
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
@@ -25,6 +24,7 @@ from classiq.interface.model.quantum_type import (
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
+from classiq.interface.model.within_apply_operation import WithinApply
 
 from classiq.model_expansions.closure import FunctionClosure
 from classiq.model_expansions.evaluators.parameter_types import (
@@ -35,7 +35,7 @@ from classiq.model_expansions.evaluators.quantum_type_utils import (
 )
 from classiq.model_expansions.quantum_operations.emitter import Emitter
 from classiq.model_expansions.scope import QuantumSymbol, Scope
-from classiq.qmod.builtins.functions import integer_xor, modular_add
+from classiq.qmod.builtins.functions import CX, allocate, integer_xor, modular_add
 
 
 def _binary_function_declaration(
@@ -59,16 +59,13 @@ class InplaceBinaryOperationEmitter(Emitter[InplaceBinaryOperation]):
             assert isinstance(value_var.quantum_type, QuantumNumeric)
             assert isinstance(target_var.quantum_type, QuantumNumeric)
 
-        sign_diff = int(value_var.quantum_type.sign_value) - int(
-            target_var.quantum_type.sign_value
-        )
         frac_digits_diff = (
             value_var.quantum_type.fraction_digits_value
             - target_var.quantum_type.fraction_digits_value
         )
         if (
-            sign_diff + frac_digits_diff == value_var.quantum_type.size_in_bits
-            or -sign_diff - frac_digits_diff == target_var.quantum_type.size_in_bits
+            frac_digits_diff == value_var.quantum_type.size_in_bits
+            or -frac_digits_diff == target_var.quantum_type.size_in_bits
         ):
             with self._propagated_var_stack.capture_variables(op):
                 return
@@ -97,7 +94,6 @@ class InplaceBinaryOperationEmitter(Emitter[InplaceBinaryOperation]):
             body=_build_inplace_binary_operation(
                 value_var=value_var,
                 target_var=target_var,
-                frac_digits_diff=frac_digits_diff,
                 internal_function_declaration=_binary_function_declaration(
                     op.operation
                 ),
@@ -113,53 +109,60 @@ class InplaceBinaryOperationEmitter(Emitter[InplaceBinaryOperation]):
 def _build_inplace_binary_operation(
     value_var: QuantumSymbol,
     target_var: QuantumSymbol,
-    frac_digits_diff: int,
     internal_function_declaration: NamedParamsQuantumFunctionDeclaration,
 ) -> List[QuantumStatement]:
     if TYPE_CHECKING:
         assert isinstance(value_var.quantum_type, QuantumNumeric)
         assert isinstance(target_var.quantum_type, QuantumNumeric)
 
-    value_overlap_var, value_sign_var, value_bind_targets = _get_inplace_bind_targets(
-        "value", value_var, frac_digits_diff
+    frac_digits_diff = (
+        value_var.quantum_type.fraction_digits_value
+        - target_var.quantum_type.fraction_digits_value
     )
-    target_overlap_var, target_sign_var, target_bind_targets = (
-        _get_inplace_bind_targets("target", target_var, -frac_digits_diff)
+    size_diff = (
+        value_var.quantum_type.size_in_bits - target_var.quantum_type.size_in_bits
     )
 
-    value_pre_ops, value_post_ops = _get_inplace_pre_post_ops(
-        value_var, value_bind_targets
+    target_overlap_var, target_var_decls, target_bind_ops = (
+        _trim_superfluous_fraction_digits("target", target_var, -frac_digits_diff)
     )
-    target_pre_ops, target_post_ops = _get_inplace_pre_post_ops(
-        target_var, target_bind_targets
+    value_overlap_var, value_trim_var_decls, value_bind_ops = (
+        _trim_superfluous_fraction_digits("value", value_var, frac_digits_diff)
     )
+    (
+        value_padded_var,
+        value_pad_var_decls,
+        value_pad_pre_bind_ops,
+        value_pad_init_ops,
+        value_post_bind_ops,
+    ) = _pad_with_sign_bit("value", value_overlap_var, size_diff)
 
-    binary_ops = []
-    if value_overlap_var is not None and target_overlap_var is not None:
-        binary_ops.append(
-            _internal_inplace_binary_operation_function_call(
-                internal_function_declaration,
-                value_overlap_var.handle,
-                target_overlap_var.handle,
-            )
-        )
-    if value_sign_var is not None and target_sign_var is not None:
-        binary_ops.append(
-            _internal_inplace_binary_operation_function_call(
-                internal_function_declaration,
-                value_sign_var.handle,
-                target_sign_var.handle,
-            )
-        )
-    if len(binary_ops) == 0:
-        raise ClassiqInternalExpansionError("Bug in unrolling inplace operation")
+    op_call = _internal_inplace_binary_operation_function_call(
+        internal_function_declaration,
+        value_padded_var.handle,
+        target_overlap_var.handle,
+    )
 
     return [
-        *value_pre_ops,
-        *target_pre_ops,
-        *binary_ops,
-        *target_post_ops,
-        *value_post_ops,
+        *target_var_decls,
+        *value_trim_var_decls,
+        *value_pad_var_decls,
+        WithinApply(
+            compute=[
+                *target_bind_ops,
+                *value_bind_ops,
+                *value_pad_pre_bind_ops,
+            ],
+            action=[
+                *value_pad_init_ops,
+                WithinApply(
+                    compute=[
+                        *value_post_bind_ops,
+                    ],
+                    action=[op_call],
+                ),
+            ],
+        ),
     ]
 
 
@@ -176,75 +179,144 @@ def _internal_inplace_binary_operation_function_call(
     return internal_function_call
 
 
-def _get_inplace_bind_targets(
+def _trim_superfluous_fraction_digits(
     kind: str, var: QuantumSymbol, frac_digits_diff: int
-) -> Tuple[Optional[QuantumSymbol], Optional[QuantumSymbol], List[QuantumSymbol]]:
+) -> Tuple[QuantumSymbol, List[VariableDeclarationStatement], List[BindOperation]]:
+    if frac_digits_diff <= 0:
+        return var, [], []
+
     quantum_type = var.quantum_type
     if TYPE_CHECKING:
         assert isinstance(quantum_type, QuantumNumeric)
 
-    if not quantum_type.sign_value and frac_digits_diff <= 0:
-        return var, None, []
-
-    significand_overlap = (
-        quantum_type.size_in_bits
-        - quantum_type.fraction_digits_value
-        - int(quantum_type.sign_value)
+    trimmed_fraction_digits_var = QuantumSymbol(
+        handle=HandleBinding(name=f"trimmed_{kind}_fraction_digits"),
+        quantum_type=QuantumBitvector(
+            length=Expression(expr=str(frac_digits_diff)),
+        ),
     )
-    fraction_overlap = quantum_type.fraction_digits_value - max(0, frac_digits_diff)
-    if significand_overlap + fraction_overlap == 0 and quantum_type.size_in_bits == 1:
-        assert quantum_type.sign_value
-        return None, var, []
-
-    bind_targets = []
+    overlap_var = QuantumSymbol(
+        handle=HandleBinding(name=f"{kind}_overlap"),
+        quantum_type=QuantumNumeric(
+            size=Expression(expr=str(quantum_type.size_in_bits - frac_digits_diff)),
+            is_signed=quantum_type.is_signed,
+            fraction_digits=Expression(expr="0"),
+        ),
+    )
+    bind_targets = trimmed_fraction_digits_var, overlap_var
 
-    if frac_digits_diff > 0:
-        bind_targets.append(
-            QuantumSymbol(
-                handle=HandleBinding(name=f"trimmed_{kind}_fraction_digits"),
-                quantum_type=QuantumBitvector(
-                    length=Expression(expr=str(frac_digits_diff)),
-                ),
-            )
+    split_var_declarations = [
+        VariableDeclarationStatement(
+            name=var.handle.name,
+            quantum_type=var.quantum_type,
         )
+        for var in bind_targets
+    ]
+    bind_op = BindOperation(
+        in_handles=[var.handle],
+        out_handles=[var.handle for var in bind_targets],
+    )
 
-    overlap_var = None
-    if significand_overlap + fraction_overlap > 0:
-        overlap_var = QuantumSymbol(
-            handle=HandleBinding(name=f"{kind}_overlap"),
-            quantum_type=QuantumNumeric(
-                size=Expression(expr=str(significand_overlap + fraction_overlap)),
-                is_signed=Expression(expr="False"),
-                fraction_digits=Expression(expr=str(fraction_overlap)),
-            ),
-        )
-        bind_targets.append(overlap_var)
+    return overlap_var, split_var_declarations, [bind_op]
 
-    sign_var = None
-    if quantum_type.sign_value:
-        sign_var = QuantumSymbol(
-            handle=HandleBinding(name=f"trimmed_{kind}_sign"),
-            quantum_type=QuantumBit(),
-        )
-        bind_targets.append(sign_var)
 
-    return overlap_var, sign_var, bind_targets
+def _pad_with_sign_bit(kind: str, var: QuantumSymbol, size_diff: int) -> Tuple[
+    QuantumSymbol,
+    List[VariableDeclarationStatement],
+    List[QuantumStatement],
+    List[QuantumFunctionCall],
+    List[BindOperation],
+]:
+    quantum_type = var.quantum_type
+    if TYPE_CHECKING:
+        assert isinstance(quantum_type, QuantumNumeric)
 
+    if not quantum_type.sign_value or size_diff >= 0:
+        return var, [], [], [], []
 
-def _get_inplace_pre_post_ops(
-    var: QuantumSymbol, bind_targets: List[QuantumSymbol]
-) -> Tuple[Sequence[QuantumStatement], Sequence[QuantumStatement]]:
-    if len(bind_targets) == 0:
-        return [], []
+    significand_var, sign_var, sign_split_bind = _split_sign(kind, var)
+    padding_var, padding_allocation = _allocate_padding(kind, size_diff)
+    padding_init_ops = _init_padding(sign_var, padding_var, size_diff)
 
-    value_bind_op = BindOperation(
-        in_handles=[var.handle],
-        out_handles=[var.handle for var in bind_targets],
+    padded_var = QuantumSymbol(
+        handle=HandleBinding(name=f"padded_{kind}"),
+        quantum_type=QuantumNumeric(
+            size=Expression(expr=str(quantum_type.size_in_bits - size_diff)),
+            is_signed=Expression(expr="False"),
+            fraction_digits=Expression(expr="0"),
+        ),
     )
-    return [
+    padding_rebind = BindOperation(
+        in_handles=[significand_var.handle, sign_var.handle, padding_var.handle],
+        out_handles=[padded_var.handle],
+    )
+
+    var_decls = [
         VariableDeclarationStatement(
             name=var.handle.name,
             quantum_type=var.quantum_type,
         )
-        for var in bind_targets
-    ] + [value_bind_op], [value_bind_op.reversed()]
+        for var in (significand_var, sign_var, padding_var, padded_var)
+    ]
+
+    return (
+        padded_var,
+        var_decls,
+        [sign_split_bind, padding_allocation],
+        padding_init_ops,
+        [padding_rebind],
+    )
+
+
+def _init_padding(
+    sign_var: QuantumSymbol, padding_var: QuantumSymbol, size_diff: int
+) -> List[QuantumFunctionCall]:
+    padding_init_ops = [
+        QuantumFunctionCall(
+            function=CX.func_decl.name,
+            positional_args=[sign_var.handle, padding_var[idx].handle],
+        )
+        for idx in range(-size_diff)
+    ]
+    for cx_call in padding_init_ops:
+        cx_call.set_func_decl(CX.func_decl)
+    return padding_init_ops
+
+
+def _allocate_padding(
+    kind: str, size_diff: int
+) -> Tuple[QuantumSymbol, QuantumFunctionCall]:
+    padding_var = QuantumSymbol(
+        handle=HandleBinding(name=f"{kind}_sign_padding"),
+        quantum_type=QuantumBitvector(
+            length=Expression(expr=str(-size_diff)),
+        ),
+    )
+    padding_allocation = QuantumFunctionCall(
+        function=allocate.func_decl.name,
+        positional_args=[Expression(expr=str(-size_diff)), padding_var.handle],
+    )
+    padding_allocation.set_func_decl(allocate.func_decl)
+    return padding_var, padding_allocation
+
+
+def _split_sign(
+    kind: str, var: QuantumSymbol
+) -> Tuple[QuantumSymbol, QuantumSymbol, BindOperation]:
+    significand_var = QuantumSymbol(
+        handle=HandleBinding(name=f"{kind}_significand"),
+        quantum_type=QuantumNumeric(
+            size=Expression(expr=str(var.quantum_type.size_in_bits - 1)),
+            is_signed=Expression(expr="False"),
+            fraction_digits=Expression(expr="0"),
+        ),
+    )
+    sign_var = QuantumSymbol(
+        handle=HandleBinding(name=f"{kind}_sign_bit"),
+        quantum_type=QuantumBit(),
+    )
+    sign_split_bind = BindOperation(
+        in_handles=[var.handle],
+        out_handles=[significand_var.handle, sign_var.handle],
+    )
+    return significand_var, sign_var, sign_split_bind

classiq/model_expansions/quantum_operations/invert.py

@@ -10,6 +10,14 @@ from classiq.model_expansions.scope import Scope
 
 class InvertEmitter(Emitter[Invert]):
     def emit(self, invert: Invert, /) -> None:
+        with self._propagated_var_stack.capture_variables(invert):
+            self._emit_propagated(invert)
+
+    def _emit_propagated(self, invert: Invert, /) -> None:
+        if invert.is_generative():
+            context = self._register_generative_context(invert, INVERT_OPERATOR_NAME)
+            invert = invert.copy(update={"body": context.statements("body")})
+
         if self._should_wrap(invert.body):
             self._emit_wrapped(invert)
             return
@@ -22,17 +30,15 @@ class InvertEmitter(Emitter[Invert]):
             blocks={"body": invert.body},
             scope=Scope(parent=self._current_scope),
         )
-        with self._propagated_var_stack.capture_variables(invert):
-            context = self._expand_operation(invert_operation)
+        context = self._expand_operation(invert_operation)
         self._builder.emit_statement(
             Invert(body=context.statements("body"), source_ref=invert.source_ref)
         )
 
     def _emit_wrapped(self, invert: Invert) -> None:
-        with self._propagated_var_stack.capture_variables(invert):
-            wrapping_function = self._create_expanded_wrapping_function(
-                INVERT_OPERATOR_NAME, invert.body
-            )
+        wrapping_function = self._create_expanded_wrapping_function(
+            INVERT_OPERATOR_NAME, invert.body
+        )
         self._builder.emit_statement(
             Invert(body=[wrapping_function], source_ref=invert.source_ref)
         )