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

classiq/interface/model/quantum_variable_declaration.py

@@ -1,29 +1,7 @@
-from typing import Any, Mapping, Optional
-
-import pydantic
-
 from classiq.interface.ast_node import ASTNode
-from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.concrete_types import ConcreteQuantumType
-from classiq.interface.model.quantum_type import (
-    QuantumBitvector,
-    QuantumNumeric,
-)
 
 
 class QuantumVariableDeclaration(ASTNode):
     name: str
     quantum_type: ConcreteQuantumType
-    size: Optional[Expression] = pydantic.Field(default=None, exclude=True)
-
-    @pydantic.validator("size")
-    def _propagate_size_to_type(
-        cls, size: Optional[Expression], values: Mapping[str, Any]
-    ) -> Optional[Expression]:
-        if size is not None:
-            quantum_type = values.get("quantum_type")
-            if isinstance(quantum_type, QuantumBitvector):
-                quantum_type.length = size
-            elif isinstance(quantum_type, QuantumNumeric):
-                quantum_type.size = size
-        return size

classiq/interface/model/statement_block.py

@@ -9,6 +9,7 @@ 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.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.amplitude_loading_operation import (
     AmplitudeLoadingOperation,
@@ -38,6 +39,7 @@ ConcreteQuantumStatement = Annotated[
         ClassicalIf,
         Control,
         WithinApply,
+        PhaseOperation,
     ],
     Field(..., discriminator="kind"),
 ]
@@ -52,3 +54,4 @@ Invert.update_forward_refs(StatementBlock=StatementBlock)
 WithinApply.update_forward_refs(StatementBlock=StatementBlock)
 ClassicalIf.update_forward_refs(StatementBlock=StatementBlock)
 NativeFunctionDefinition.update_forward_refs(StatementBlock=StatementBlock)
+PhaseOperation.update_forward_refs(StatementBlock=StatementBlock)

classiq/interface/server/global_versions.py

@@ -1,13 +1,13 @@
-from datetime import date, datetime
-from typing import Any, Dict, Union
+from datetime import date
+from typing import Any, Dict
 
 import pydantic
 from pydantic import BaseModel
 
 
 class DeprecationInfo(BaseModel):
-    deprecation_date: Union[datetime, date] = pydantic.Field()
-    removal_date: Union[datetime, date] = pydantic.Field()
+    deprecation_date: date = pydantic.Field()
+    removal_date: date = pydantic.Field()
 
 
 class GlobalVersions(BaseModel):

classiq/interface/server/routes.py

@@ -17,9 +17,6 @@ ANALYZER_HC_TABLE_GRAPH_FULL_PATH = ANALYZER_PREFIX + ANALYZER_HC_TABLE_GRAPH
 
 ANALYZER_HC_GRAPH_NEW = "/graphs/hardware_connectivity/new"
 
-ANALYZER_OPTIONAL_DEVICES = "/graphs/available_devices"
-ANALYZER_OPTIONAL_DEVICES_FULL_PATH = ANALYZER_PREFIX + ANALYZER_OPTIONAL_DEVICES
-
 TASKS_SUFFIX = "/tasks"
 RB = "/rb"
 ANALYZER_DATA_TASK = f"{TASKS_SUFFIX}/data"

classiq/model_expansions/capturing/propagated_var_stack.py

@@ -15,7 +15,7 @@ from classiq.interface.model.quantum_function_call import ArgValue
 from classiq.interface.model.quantum_statement import QuantumOperation
 
 from classiq.model_expansions.capturing.mangling_utils import mangle_captured_var_name
-from classiq.model_expansions.closure import FunctionClosure
+from classiq.model_expansions.closure import FunctionClosure, GenerativeFunctionClosure
 from classiq.model_expansions.function_builder import OperationBuilder
 from classiq.model_expansions.scope import QuantumSymbol, Scope
 
@@ -144,7 +144,10 @@ class PropagatedVarStack:
     def _get_propagated_var_name(self, var: PropagatedVariable) -> str:
         if (
             var.defining_function == self._builder.current_function.name
-            or self._no_name_conflict(var)
+            or not isinstance(
+                self._builder.current_function, GenerativeFunctionClosure
+            )  # FIXME doesn't work for all cases (CAD-22663)
+            and self._no_name_conflict(var)
         ):
             handle_name = var.name
             if var in self._to_mangle:

classiq/model_expansions/closure.py

@@ -40,6 +40,11 @@ class Closure:
         }
 
 
+@dataclass(frozen=True)
+class GenerativeClosure(Closure):
+    generative_blocks: Dict[str, GenerativeQFunc] = None  # type:ignore[assignment]
+
+
 @dataclass(frozen=True)
 class FunctionClosure(Closure):
     is_lambda: bool = False
@@ -101,8 +106,8 @@ class FunctionClosure(Closure):
 
 
 @dataclass(frozen=True)
-class GenerativeFunctionClosure(FunctionClosure):
-    generative_function: GenerativeQFunc = None  # type:ignore[assignment]
+class GenerativeFunctionClosure(GenerativeClosure, FunctionClosure):
+    pass
 
 
 NestedFunctionClosureT = Union[FunctionClosure, List["NestedFunctionClosureT"]]

classiq/model_expansions/evaluators/quantum_type_utils.py

@@ -10,7 +10,6 @@ from classiq.interface.generator.functions.type_name import (
     TypeName,
 )
 from classiq.interface.model.bind_operation import BindOperation
-from classiq.interface.model.inplace_binary_operation import BinaryOperation
 from classiq.interface.model.quantum_type import (
     QuantumBit,
     QuantumBitvector,
@@ -227,9 +226,3 @@ def validate_inplace_binary_op_vars(
         raise ClassiqExpansionError(
             f"Cannot perform `{operation_name}` operation with non numeric target {target_var.handle}"
         )
-    if operation_name != BinaryOperation.Xor.value and (
-        value_var.quantum_type.sign_value or target_var.quantum_type.sign_value
-    ):
-        raise ClassiqExpansionError(
-            f"Cannot perform `{operation_name}` operation with signed variables"
-        )

classiq/model_expansions/generative_functions.py

@@ -1,51 +1,82 @@
-from typing import TYPE_CHECKING, Any, List
+from typing import TYPE_CHECKING, Any, List, Mapping
 
+from classiq.interface.exceptions import ClassiqInternalExpansionError
 from classiq.interface.generator.expressions.qmod_struct_instance import (
     QmodStructInstance,
 )
 from classiq.interface.generator.functions.type_name import Struct
+from classiq.interface.generator.visitor import Visitor
 from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
 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 (
     PositionalArg,
     QuantumFunctionDeclaration,
     QuantumOperandDeclaration,
 )
+from classiq.interface.model.quantum_lambda_function import (
+    QuantumCallable,
+    QuantumLambdaFunction,
+)
 from classiq.interface.model.quantum_statement import QuantumStatement
 
-from classiq.model_expansions.closure import FunctionClosure, GenerativeFunctionClosure
+from classiq.model_expansions.closure import (
+    FunctionClosure,
+    GenerativeClosure,
+    GenerativeFunctionClosure,
+)
 from classiq.model_expansions.scope import Evaluated, QuantumSymbol
 from classiq.qmod.generative import generative_mode_context, set_frontend_interpreter
 from classiq.qmod.model_state_container import QMODULE
 from classiq.qmod.qmod_parameter import CParamStruct
-from classiq.qmod.qmod_variable import get_qvar
+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_expandable import (
+    QExpandable,
+    QLambdaFunction,
+    QTerminalCallable,
+)
 from classiq.qmod.quantum_function import QFunc
 from classiq.qmod.semantics.static_semantics_visitor import resolve_function_calls
+from classiq.qmod.symbolic_expr import SymbolicExpr
 
 if TYPE_CHECKING:
     from classiq.model_expansions.interpreter import Interpreter
 
 
+class LenList(list):
+    @property
+    def len(self) -> int:
+        return len(self)
+
+    def __getitem__(self, item: Any) -> Any:
+        if isinstance(item, QNum):
+            return SymbolicExpr(f"{self}[{item}]", True)
+        return super().__getitem__(item)
+
+    @classmethod
+    def wrap(cls, obj: Any) -> Any:
+        if not isinstance(obj, list):
+            return obj
+        return LenList([cls.wrap(item) for item in obj])
+
+
 def translate_ast_arg_to_python_qmod(param: PositionalArg, evaluated: Evaluated) -> Any:
     if isinstance(param, PortDeclaration):
         quantum_symbol = evaluated.as_type(QuantumSymbol)
-        return get_qvar(quantum_symbol.quantum_type, quantum_symbol.handle)
+        return _create_qvar_for_qtype(
+            quantum_symbol.quantum_type, quantum_symbol.handle
+        )
     if isinstance(param, QuantumOperandDeclaration):
         if param.is_list:
-            func_list: List[FunctionClosure] = evaluated.as_type(list)
-            return [
-                QTerminalCallable(
-                    QuantumFunctionDeclaration(
-                        name=param.name,
-                        positional_arg_declarations=param.positional_arg_declarations,
-                    ),
-                    index_=idx,
-                )
-                for idx, func in enumerate(func_list)
-            ]
+            return QTerminalCallable(
+                QuantumOperandDeclaration(
+                    name=param.name,
+                    positional_arg_declarations=param.positional_arg_declarations,
+                    is_list=True,
+                ),
+            )
         else:
             func = evaluated.as_type(FunctionClosure)
             return QTerminalCallable(
@@ -61,7 +92,7 @@ def translate_ast_arg_to_python_qmod(param: PositionalArg, evaluated: Evaluated)
             struct_type=Struct(name=classical_value.struct_declaration.name),
             qmodule=QMODULE,
         )
-    return classical_value
+    return LenList.wrap(classical_value)
 
 
 class _InterpreterExpandable(QFunc):
@@ -70,23 +101,32 @@ class _InterpreterExpandable(QFunc):
         self._interpreter = interpreter
 
     def append_statement_to_body(self, stmt: QuantumStatement) -> None:
-        current_function = self._interpreter._builder.current_function
+        current_operation = self._interpreter._builder._operations[-1]
         dummy_function = NativeFunctionDefinition(
-            name=current_function.name,
-            positional_arg_declarations=current_function.positional_arg_declarations,
+            name=current_operation.name,
+            positional_arg_declarations=current_operation.positional_arg_declarations,
             body=self._interpreter._builder._current_statements + [stmt],
         )
-        resolve_function_calls(
-            dummy_function,
-            nameables_to_dict(self._interpreter._get_function_declarations()),
-        )
+        resolve_function_calls(dummy_function, self._get_function_declarations())
         stmt = dummy_function.body[-1]
-        self._interpreter.emit_statement(stmt)
+        with generative_mode_context(False):
+            self._interpreter.emit_statement(stmt)
+
+    def _get_function_declarations(self) -> Mapping[str, QuantumFunctionDeclaration]:
+        return {
+            name: QuantumFunctionDeclaration(
+                name=name,
+                positional_arg_declarations=evaluated.value.positional_arg_declarations,
+            )
+            for name, evaluated in self._interpreter._current_scope.items()
+            if isinstance(evaluated, Evaluated)
+            and isinstance(evaluated.value, FunctionClosure)
+        } | nameables_to_dict(self._interpreter._get_function_declarations())
 
 
 def emit_generative_statements(
     interpreter: "Interpreter",
-    operation: GenerativeFunctionClosure,
+    operation: GenerativeClosure,
     args: List[Evaluated],
 ) -> None:
     python_qmod_args = [
@@ -97,5 +137,83 @@ def emit_generative_statements(
     QExpandable.STACK.append(interpreter_expandable)
     QCallable.CURRENT_EXPANDABLE = interpreter_expandable
     set_frontend_interpreter(interpreter)
-    with interpreter._builder.block_context("body"), generative_mode_context(True):
-        operation.generative_function._py_callable(*python_qmod_args)
+    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)
+
+
+def emit_operands_as_declarative(
+    interpreter: "Interpreter", param: PositionalArg, arg: Evaluated
+) -> ArgValue:
+    if not isinstance(param, QuantumOperandDeclaration):
+        return arg.emit()
+    value = arg.value
+    if isinstance(value, list):
+        return [
+            _expand_operand_as_declarative(interpreter, param, item) for item in value
+        ]
+    if isinstance(value, GenerativeFunctionClosure):
+        return _expand_operand_as_declarative(interpreter, param, value)
+    if isinstance(value, FunctionClosure):
+        if value.is_lambda:
+            raise ClassiqInternalExpansionError
+        _register_declarative_function(interpreter, value.name)
+        return value.name
+    raise ClassiqInternalExpansionError
+
+
+def _expand_operand_as_declarative(
+    interpreter: "Interpreter",
+    param: QuantumOperandDeclaration,
+    arg: GenerativeFunctionClosure,
+) -> QuantumCallable:
+    if not arg.is_lambda:
+        _register_declarative_function(interpreter, arg.name)
+        return arg.name
+    val = QLambdaFunction(param, arg.generative_blocks["body"]._py_callable)
+    with generative_mode_context(False):
+        val.expand()
+        _DecFuncVisitor(interpreter).visit(val.body)
+    qlambda = QuantumLambdaFunction(
+        pos_rename_params=val.infer_rename_params(),
+        body=val.body,
+    )
+    qlambda.set_op_decl(param)
+    return qlambda
+
+
+def _register_declarative_function(interpreter: "Interpreter", func_name: str) -> None:
+    if func_name in nameables_to_dict(interpreter._expanded_functions):
+        return
+
+    for user_gen_func in interpreter._generative_functions:
+        if user_gen_func.func_decl.name == func_name:
+            break
+    else:
+        return
+
+    with generative_mode_context(False):
+        dec_func = QFunc(user_gen_func._py_callable)
+        dec_func.expand()
+        dec_func_def = QMODULE.native_defs[func_name]
+        interpreter._expanded_functions.append(dec_func_def)
+        _DecFuncVisitor(interpreter).visit(dec_func_def)
+
+
+class _DecFuncVisitor(Visitor):
+    def __init__(self, interpreter: "Interpreter"):
+        self._interpreter = interpreter
+
+    def visit_QuantumFunctionCall(self, call: QuantumFunctionCall) -> None:
+        _register_declarative_function(self._interpreter, call.func_name)
+        for arg in call.positional_args:
+            if isinstance(arg, str):
+                arg = [arg]
+            if isinstance(arg, list):
+                for possible_func_name in arg:
+                    if isinstance(possible_func_name, str):
+                        _register_declarative_function(
+                            self._interpreter, possible_func_name
+                        )

classiq/model_expansions/interpreter.py

@@ -24,6 +24,7 @@ from classiq.interface.model.inplace_binary_operation import InplaceBinaryOperat
 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,
@@ -48,6 +49,7 @@ from classiq.model_expansions.capturing.propagated_var_stack import PropagatedVa
 from classiq.model_expansions.closure import (
     Closure,
     FunctionClosure,
+    GenerativeClosure,
     GenerativeFunctionClosure,
 )
 from classiq.model_expansions.debug_flag import debug_mode
@@ -74,6 +76,7 @@ from classiq.model_expansions.quantum_operations import (
     VariableDeclarationStatementEmitter,
     WithinApplyEmitter,
 )
+from classiq.model_expansions.quantum_operations.phase import PhaseEmitter
 from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
 from classiq.model_expansions.scope_initialization import (
     add_entry_point_params_to_scope,
@@ -82,7 +85,6 @@ from classiq.model_expansions.scope_initialization import (
 )
 from classiq.model_expansions.utils.counted_name_allocator import CountedNameAllocator
 from classiq.qmod.builtins.functions import permute
-from classiq.qmod.generative import is_generative_mode
 from classiq.qmod.quantum_function import GenerativeQFunc
 from classiq.qmod.semantics.error_manager import ErrorManager
 
@@ -95,8 +97,12 @@ STATEMENT_TYPES_FOR_SOURCE_REFERENCE_PROPAGATION: Tuple[Type[QuantumStatement],
 
 class Interpreter:
     def __init__(
-        self, model: Model, generative_functions: Optional[List[GenerativeQFunc]] = None
+        self,
+        model: Model,
+        generative_functions: Optional[List[GenerativeQFunc]] = None,
+        is_frontend: bool = False,
     ) -> None:
+        self._is_frontend = is_frontend
         self._model = model
         self._current_scope = Scope()
         self._builder = OperationBuilder()
@@ -200,10 +206,12 @@ class Interpreter:
 
         closure_class: Type[FunctionClosure]
         extra_args: dict[str, Any]
-        if is_generative_mode():
+        if function.is_generative():
             closure_class = GenerativeFunctionClosure
             extra_args = {
-                "generative_function": GenerativeQFunc(function.py_callable, func_decl)
+                "generative_blocks": {
+                    "body": GenerativeQFunc(function.py_callable, func_decl),
+                }
             }
         else:
             closure_class = FunctionClosure
@@ -307,6 +315,10 @@ class Interpreter:
     def emit_power(self, power: Power) -> None:
         PowerEmitter(self).emit(power)
 
+    @emit.register
+    def emit_phase(self, phase: PhaseOperation) -> None:
+        PhaseEmitter(self).emit(phase)
+
     def _expand_block(self, block: Sequence[QuantumStatement], block_name: str) -> None:
         with self._builder.block_context(block_name):
             for statement in block:
@@ -331,7 +343,7 @@ class Interpreter:
                 # special expansion since permute is generative
                 with self._scope_guard(operation.scope):
                     self._expand_permute()
-            elif isinstance(operation, GenerativeFunctionClosure):
+            elif isinstance(operation, GenerativeClosure):
                 with self._scope_guard(operation.scope):
                     args = [
                         self.evaluate(param.name)

classiq/model_expansions/quantum_operations/classicalif.py

@@ -1,15 +1,15 @@
-from typing import List
+from typing import Sequence
 
 from classiq.interface.model.classical_if import ClassicalIf
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
-from classiq.interface.model.statement_block import ConcreteQuantumStatement
+from classiq.interface.model.quantum_statement import QuantumStatement
 
 from classiq.model_expansions.closure import FunctionClosure
 from classiq.model_expansions.quantum_operations.emitter import Emitter
 from classiq.model_expansions.scope import Scope
 
 
-def _is_all_identity_calls(body: List[ConcreteQuantumStatement]) -> bool:
+def _is_all_identity_calls(body: Sequence[QuantumStatement]) -> bool:
     return all(
         isinstance(stmt, QuantumFunctionCall) and stmt.func_name.lower() == "identity"
         for stmt in body
@@ -18,22 +18,39 @@ def _is_all_identity_calls(body: List[ConcreteQuantumStatement]) -> bool:
 
 class ClassicalIfEmitter(Emitter[ClassicalIf]):
     def emit(self, classical_if: ClassicalIf, /) -> None:
+        with self._propagated_var_stack.capture_variables(classical_if):
+            self._emit_propagated(classical_if)
+
+    def _emit_propagated(self, classical_if: ClassicalIf) -> None:
         condition = self._interpreter.evaluate(classical_if.condition).as_type(bool)
-        body: List[ConcreteQuantumStatement] = (
-            classical_if.then if condition else classical_if.else_
-        )
+        op_name = "then" if condition else "else"
+        is_generative = classical_if.is_generative()
+
+        body: Sequence[QuantumStatement]
+        if is_generative:
+            if not classical_if.has_generative_block(op_name):
+                return
+            context = self._register_generative_context(classical_if, op_name, op_name)
+            context.blocks["body"] = context.blocks[op_name]
+            context.blocks.pop(op_name)
+            body = context.statements("body")
+        else:
+            body = classical_if.then if condition else classical_if.else_
+
         if _is_all_identity_calls(body):
             return
 
         if not self._should_wrap(body):
             for stmt in body:
-                self._interpreter.emit_statement(stmt)
+                if is_generative:
+                    self._interpreter._builder.emit_statement(stmt)
+                else:
+                    self._interpreter.emit_statement(stmt)
             return
 
         then_else_func = FunctionClosure.create(
-            name="then" if condition else "else",
+            name=op_name,
             body=body,
             scope=Scope(parent=self._current_scope),
         )
-        with self._propagated_var_stack.capture_variables(classical_if):
-            self._emit_quantum_function_call(then_else_func, list())
+        self._emit_quantum_function_call(then_else_func, list())

classiq/model_expansions/quantum_operations/control.py

@@ -21,6 +21,7 @@ from classiq.interface.model.control import Control
 from classiq.interface.model.handle_binding import HANDLE_ID_SEPARATOR, HandleBinding
 from classiq.interface.model.quantum_expressions.arithmetic_operation import (
     ArithmeticOperation,
+    ArithmeticOperationKind,
 )
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_type import QuantumBit, QuantumBitvector
@@ -69,6 +70,14 @@ class ControlEmitter(ExpressionOperationEmitter[Control]):
     def _emit_canonical_control(self, control: Control) -> None:
         # canonical means control(q, body) where q is a single quantum variable
         control = self._evaluate_types_in_expression(control, control.expression)
+        with self._propagated_var_stack.capture_variables(control):
+            self._emit_propagated(control)
+
+    def _emit_propagated(self, control: Control) -> None:
+        if control.is_generative():
+            context = self._register_generative_context(control, CONTROL_OPERATOR_NAME)
+            control = control.copy(update={"body": context.statements("body")})
+
         if self._should_wrap_control(control):
             self._emit_wrapped(control)
             return
@@ -90,26 +99,24 @@ class ControlEmitter(ExpressionOperationEmitter[Control]):
             blocks=dict(body=control.body),
             scope=Scope(parent=self._current_scope),
         )
-        with self._propagated_var_stack.capture_variables(control):
-            context = self._expand_operation(control_operation)
-            validate_args_are_not_propagated(
-                control.var_handles,
-                self._propagated_var_stack.get_propagated_variables(),
-            )
+        context = self._expand_operation(control_operation)
+        validate_args_are_not_propagated(
+            control.var_handles,
+            self._propagated_var_stack.get_propagated_variables(),
+        )
         self._update_control_state(control)
         self._builder.emit_statement(
             control.copy(update=dict(body=context.statements("body")))
         )
 
     def _emit_wrapped(self, control: Control) -> None:
-        with self._propagated_var_stack.capture_variables(control):
-            wrapping_function = self._create_expanded_wrapping_function(
-                CONTROL_OPERATOR_NAME, control.body
-            )
-            validate_args_are_not_propagated(
-                control.var_handles,
-                self._propagated_var_stack.get_propagated_variables(),
-            )
+        wrapping_function = self._create_expanded_wrapping_function(
+            CONTROL_OPERATOR_NAME, control.body
+        )
+        validate_args_are_not_propagated(
+            control.var_handles,
+            self._propagated_var_stack.get_propagated_variables(),
+        )
         self._update_control_state(control)
         self._builder.emit_statement(
             control.copy(update=dict(body=[wrapping_function]))
@@ -208,7 +215,7 @@ class ControlEmitter(ExpressionOperationEmitter[Control]):
         arith_expression = ArithmeticOperation(
             result_var=HandleBinding(name=aux_var),
             expression=control.expression,
-            inplace_result=False,
+            operation_kind=ArithmeticOperationKind.Assignment,
         )
         self._interpreter.emit_statement(
             WithinApply(