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

classiq/interface/generator/expressions/proxies/quantum/qmod_qarray_proxy.py

@@ -1,7 +1,7 @@
 from collections.abc import Mapping
 from typing import TYPE_CHECKING, Any, Union
 
-from sympy import Integer
+import sympy
 
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.expressions.expression import Expression
@@ -28,22 +28,20 @@ class QmodQArrayProxy(NonSymbolicExpr, QmodSizedProxy):
         self,
         handle: HandleBinding,
         element_type: "QuantumType",
-        element_size: int,
-        length: int,
+        element_size: Union[int, sympy.Basic],
+        length: Union[int, sympy.Basic],
     ) -> None:
         super().__init__(handle, element_size * length)
         self._length = length
         self._element_type = element_type
         self._element_size = element_size
 
-    def __getitem__(self, key: Union[slice, int, Integer]) -> "QmodSizedProxy":
+    def __getitem__(self, key: Any) -> "QmodSizedProxy":
         return (
             self._get_slice(key) if isinstance(key, slice) else self._get_subscript(key)
         )
 
-    def _get_subscript(self, index: Union[int, Integer]) -> "QmodSizedProxy":
-        if isinstance(index, Integer):
-            index = int(index)
+    def _get_subscript(self, index: Any) -> "QmodSizedProxy":
         return self._element_type.get_proxy(
             SubscriptHandleBinding(
                 base_handle=self.handle,
@@ -54,13 +52,6 @@ class QmodQArrayProxy(NonSymbolicExpr, QmodSizedProxy):
     def _get_slice(self, slice_: slice) -> "QmodSizedProxy":
         if slice_.step is not None:
             raise ClassiqValueError(ILLEGAL_SLICING_STEP_MSG)
-        if isinstance(slice_.start, Integer):
-            slice_ = slice(int(slice_.start), slice_.stop)
-        if isinstance(slice_.stop, Integer):
-            slice_ = slice(slice_.start, int(slice_.stop))
-        if not isinstance(slice_.start, int) or not isinstance(slice_.stop, int):
-            raise ClassiqValueError(ILLEGAL_SLICE_MSG)
-
         return QmodQArrayProxy(
             SlicedHandleBinding(
                 base_handle=self.handle,
@@ -77,7 +68,7 @@ class QmodQArrayProxy(NonSymbolicExpr, QmodSizedProxy):
         return "Quantum array"
 
     @property
-    def len(self) -> int:
+    def len(self) -> Union[int, sympy.Basic]:
         return self._length
 
     @property

classiq/interface/generator/expressions/proxies/quantum/qmod_qscalar_proxy.py

@@ -1,6 +1,7 @@
 from collections.abc import Mapping
-from typing import Any, Optional
+from typing import Any, Optional, Union
 
+import sympy
 from sympy import Symbol
 from typing_extensions import Self
 
@@ -36,10 +37,18 @@ class QmodQBitProxy(QmodQScalarProxy):
 
 class QmodQNumProxy(QmodQScalarProxy):
     def __init__(
-        self, handle: HandleBinding, size: int, fraction_digits: int, is_signed: bool
+        self,
+        handle: HandleBinding,
+        size: Union[int, sympy.Basic],
+        fraction_digits: Union[int, sympy.Basic],
+        is_signed: Union[bool, sympy.Basic],
     ) -> None:
         super().__init__(handle, size)
-        if fraction_digits > size:
+        if (
+            isinstance(fraction_digits, int)
+            and isinstance(size, int)
+            and fraction_digits > size
+        ):
             raise ClassiqValueError(
                 f"Quantum numeric of size {size} cannot have {fraction_digits} "
                 f"fraction digits"
@@ -52,11 +61,11 @@ class QmodQNumProxy(QmodQScalarProxy):
         return "Quantum numeric"
 
     @property
-    def fraction_digits(self) -> int:
+    def fraction_digits(self) -> Union[int, sympy.Basic]:
         return self._fraction_digits
 
     @property
-    def is_signed(self) -> bool:
+    def is_signed(self) -> Union[bool, sympy.Basic]:
         return self._is_signed
 
     @property

classiq/interface/generator/expressions/proxies/quantum/qmod_sized_proxy.py

@@ -1,17 +1,19 @@
 from collections.abc import Mapping
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Union
+
+import sympy
 
 if TYPE_CHECKING:
     from classiq.interface.model.handle_binding import HandleBinding
 
 
 class QmodSizedProxy:
-    def __init__(self, handle: "HandleBinding", size: int) -> None:
+    def __init__(self, handle: "HandleBinding", size: Union[int, sympy.Basic]) -> None:
         self._handle = handle
         self._size = size
 
     @property
-    def size(self) -> int:
+    def size(self) -> Union[int, sympy.Basic]:
         return self._size
 
     def __str__(self) -> str:

classiq/interface/generator/generated_circuit_data.py

@@ -145,6 +145,8 @@ class StatementType(StrEnum):
     POWER = "power"
     INVERT = "invert"
     WITHIN_APPLY = "within apply"
+    WITHIN = "within"
+    APPLY = "apply"
     ASSIGN = "assign"
     ASSIGN_AMPLITUDE = "assign amplitude"
     PHASE = "phase"
@@ -161,6 +163,9 @@ STATEMENTS_NAME: dict[str, StatementType] = {
     "Power": StatementType.POWER,
     "Invert": StatementType.INVERT,
     "WithinApply": StatementType.WITHIN_APPLY,
+    "Compute": StatementType.WITHIN,
+    "Action": StatementType.APPLY,
+    "Uncompute": StatementType.WITHIN,
     ArithmeticOperationKind.Assignment.value: StatementType.ASSIGN,
     "InplaceBinaryOperation": StatementType.ASSIGN,
     "AmplitudeLoadingOperation": StatementType.ASSIGN_AMPLITUDE,
@@ -176,6 +181,7 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
     children: list["FunctionDebugInfoInterface"]
     relative_qubits: tuple[int, ...]
     absolute_qubits: Optional[tuple[int, ...]] = Field(default=None)
+    control_variable: Optional[str] = Field(default=None)
     is_basis_gate: Optional[bool] = Field(default=None)
     is_inverse: bool = Field(default=False)
     is_unitary: bool = Field(default=True, exclude=True)
@@ -205,14 +211,21 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
 
         if isinstance(back_ref, QuantumFunctionCall):
             name = generate_original_function_name(back_ref.func_name)
-            if part_match := PART_SUFFIX_REGEX.match(generated_name):
-                name += f" [{part_match.group(1)}]"
-            return name.removeprefix(ARITH_ENGINE_PREFIX)
+            return self.add_suffix_from_generated_name(generated_name, name)
 
         statement_kind: str = back_ref.kind
         if isinstance(back_ref, ArithmeticOperation):
             statement_kind = back_ref.operation_kind.value
-        return STATEMENTS_NAME[statement_kind]
+        return self.add_suffix_from_generated_name(
+            generated_name, STATEMENTS_NAME[statement_kind]
+        )
+
+    def add_suffix_from_generated_name(self, generated_name: str, name: str) -> str:
+        if part_match := PART_SUFFIX_REGEX.match(generated_name):
+            suffix = f" [{part_match.group(1)}]"
+        else:
+            suffix = ""
+        return f"{name}{suffix}"
 
     @property
     def first_back_ref(self) -> Optional[ConcreteQuantumStatement]:
@@ -347,9 +360,7 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
         if role is RegisterRole.INPUT:
             return RegisterRole.OUTPUT
         if role is RegisterRole.EXPLICIT_ZERO_INPUT or role is RegisterRole.ZERO_INPUT:
-            if self.release_by_inverse:
-                return RegisterRole.ZERO_OUTPUT
-            return RegisterRole.OUTPUT
+            return RegisterRole.ZERO_OUTPUT
         if role is RegisterRole.AUXILIARY:
             return RegisterRole.AUXILIARY
         if role is RegisterRole.OUTPUT or role is RegisterRole.GARBAGE_OUTPUT:

classiq/interface/ide/visual_model.py

@@ -15,6 +15,7 @@ from classiq.interface.helpers.versioned_model import VersionedModel
 
 class OperationType(StrEnum):
     REGULAR = "REGULAR"
+    INVISIBLE = "INVISIBLE"
     ALLOCATE = "ALLOCATE"
     FREE = "FREE"
     BIND = "BIND"
@@ -124,6 +125,7 @@ class Operation(pydantic.BaseModel):
     )
     is_daggered: bool = pydantic.Field(default=False)
     expanded: bool = pydantic.Field(default=False)
+    show_expanded_label: bool = pydantic.Field(default=False)
 
 
 class ProgramVisualModel(VersionedModel):

classiq/interface/model/handle_binding.py

@@ -355,3 +355,11 @@ ConcreteHandleBinding = Union[
 SubscriptHandleBinding.model_rebuild()
 SlicedHandleBinding.model_rebuild()
 FieldHandleBinding.model_rebuild()
+
+
+class HandlesList(ASTNode):
+    handles: list["GeneralHandle"]
+
+
+GeneralHandle = Union[ConcreteHandleBinding, HandlesList]
+HandlesList.model_rebuild()

classiq/interface/model/model.py

@@ -1,6 +1,6 @@
 from collections import Counter
 from collections.abc import Mapping
-from typing import Any, Literal, NewType, Optional
+from typing import Any, Literal, NewType
 
 import pydantic
 
@@ -9,7 +9,6 @@ from classiq.interface.debug_info.debug_info import DebugInfoCollection
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
 from classiq.interface.generator.constant import Constant
-from classiq.interface.generator.functions.concrete_types import ConcreteClassicalType
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
@@ -103,9 +102,6 @@ class Model(VersionedModel, ASTNode):
     functions_compilation_metadata: dict[str, CompilationMetadata] = pydantic.Field(
         default_factory=dict
     )
-    execution_parameters: Optional[dict[str, ConcreteClassicalType]] = pydantic.Field(
-        default=None, exclude=True
-    )
 
     @property
     def main_func(self) -> NativeFunctionDefinition:
@@ -184,11 +180,12 @@ class Model(VersionedModel, ASTNode):
             )
         return constants
 
-    def dump_no_preferences_and_constraints(self) -> dict[str, Any]:
+    def dump_no_metadata(self) -> dict[str, Any]:
         return self.model_dump(
             exclude={
                 "constraints",
                 "execution_preferences",
                 "preferences",
+                "functions_compilation_metadata",
             },
         )

classiq/interface/model/quantum_function_call.py

@@ -1,4 +1,5 @@
 from collections.abc import Iterable, Mapping, Sequence
+from itertools import chain
 from typing import (
     Literal,
     Optional,
@@ -15,7 +16,9 @@ from classiq.interface.generator.functions.port_declaration import (
 )
 from classiq.interface.model.handle_binding import (
     ConcreteHandleBinding,
+    GeneralHandle,
     HandleBinding,
+    HandlesList,
 )
 from classiq.interface.model.port_declaration import AnonPortDeclaration
 from classiq.interface.model.quantum_function_declaration import (
@@ -31,6 +34,7 @@ ArgValue = Union[
     Expression,
     QuantumOperand,
     ConcreteHandleBinding,
+    HandlesList,
 ]
 
 
@@ -146,6 +150,26 @@ class QuantumFunctionCall(QuantumOperation):
             )
         ]
 
+    @property
+    def handles_with_directions(
+        self,
+    ) -> Iterable[tuple[HandleBinding, PortDeclarationDirection]]:
+        return [(handle, param.direction) for handle, param in self.handles_with_params]
+
+    @property
+    def handles_with_params(
+        self,
+    ) -> Iterable[tuple[HandleBinding, AnonPortDeclaration]]:
+        return [
+            (handle, param)
+            for arg, param in zip(
+                self.positional_args, self.func_decl.positional_arg_declarations
+            )
+            if isinstance(param, AnonPortDeclaration)
+            and isinstance(arg, (HandleBinding, HandlesList))
+            for handle in _get_handles(arg)
+        ]
+
     @property
     def params(self) -> list[Expression]:
         return [
@@ -161,7 +185,7 @@ class QuantumFunctionCall(QuantumOperation):
         return [
             param
             for param in self.positional_args
-            if not isinstance(param, (Expression, HandleBinding))
+            if not isinstance(param, (Expression, HandleBinding, HandlesList))
         ]
 
     @property
@@ -224,3 +248,9 @@ class QuantumFunctionCall(QuantumOperation):
             f" for parameter {param_name}" if len(self.positional_args) > 1 else ""
         )
         return f"as an argument{param_text} of function {self.func_name!r}"
+
+
+def _get_handles(var: GeneralHandle) -> Iterable[HandleBinding]:
+    if isinstance(var, HandleBinding):
+        return [var]
+    return chain.from_iterable(_get_handles(item) for item in var.handles)

classiq/interface/model/quantum_statement.py

@@ -1,4 +1,4 @@
-from collections.abc import Mapping, Sequence
+from collections.abc import Iterable, Mapping, Sequence
 from dataclasses import dataclass
 from typing import Any, Callable, Optional
 from uuid import UUID, uuid4
@@ -9,6 +9,9 @@ from typing_extensions import Self
 
 from classiq.interface.ast_node import ASTNode
 from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.port_declaration import (
+    PortDeclarationDirection,
+)
 from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
 from classiq.interface.model.handle_binding import (
     ConcreteHandleBinding,
@@ -90,6 +93,16 @@ class QuantumOperation(QuantumStatement):
     def readable_outputs(self) -> Sequence[HandleMetadata]:
         return [HandleMetadata(handle=handle) for handle in self.outputs]
 
+    @property
+    def handles_with_directions(
+        self,
+    ) -> Iterable[tuple[HandleBinding, PortDeclarationDirection]]:
+        return (
+            [(handle, PortDeclarationDirection.Input) for handle in self.inputs]
+            + [(handle, PortDeclarationDirection.Output) for handle in self.outputs]
+            + [(handle, PortDeclarationDirection.Inout) for handle in self.inouts]
+        )
+
     def set_generative_block(self, block_name: str, py_callable: Callable) -> None:
         self._generative_blocks[block_name] = py_callable
 

classiq/interface/source_reference.py

@@ -33,11 +33,16 @@ class SourceReference(HashablePydanticBaseModel):
     file_name: Optional[str] = pydantic.Field(default=None)
 
     def __str__(self) -> str:
-        file_string = _prepare_file_string(self.file_name) if self.file_name else ""
+        return f"{self.file_string()}{self.ref_inside_file()}"
+
+    def file_string(self) -> str:
+        return _prepare_file_string(self.file_name) if self.file_name else ""
+
+    def ref_inside_file(self) -> str:
         start_character_string = (
             f" character {self.start_column + 1}" if self.start_column > 0 else ""
         )
-        return f"{file_string}line {self.start_line + 1}{start_character_string}"
+        return f"line {self.start_line + 1}{start_character_string}"
 
 
 class SourceReferencedError(pydantic.BaseModel):

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, Callable
+from typing import TYPE_CHECKING, Callable, Union, cast
 
 from typing_extensions import Self
 
@@ -21,6 +21,7 @@ from classiq.interface.model.classical_parameter_declaration import (
 )
 from classiq.interface.model.handle_binding import (
     HandleBinding,
+    HandlesList,
     NestedHandleBinding,
     SlicedHandleBinding,
 )
@@ -254,7 +255,7 @@ class CapturedVars:
 
     def _conjugate_direction(
         self,
-        source_direction: PortDirection | bool,
+        source_direction: Union[PortDirection, bool],
         target_direction: PortDirection,
         var_name: str,
     ) -> PortDirection:
@@ -653,12 +654,9 @@ def validate_args_are_not_propagated(
         for handle in captured_vars
         if isinstance(handle, HandleBinding)
     }
-    arg_handles = {
-        demangle_handle(arg) for arg in args if isinstance(arg, HandleBinding)
-    }
     violating_handles = [
         f"{str(arg_handle)!r}"
-        for arg_handle in arg_handles
+        for arg_handle in _get_all_handles(args)
         if any(
             arg_handle.overlaps(captured_handle) for captured_handle in captured_handles
         )
@@ -669,6 +667,18 @@ def validate_args_are_not_propagated(
         )
 
 
+def _get_all_handles(args: Sequence[ArgValue]) -> set[HandleBinding]:
+    arg_handles: set[HandleBinding] = set()
+    for arg in args:
+        if isinstance(arg, HandleBinding):
+            arg_handles.add(demangle_handle(arg))
+        elif isinstance(arg, HandlesList):
+            arg_handles |= set(
+                map(demangle_handle, cast(list[HandleBinding], arg.handles))
+            )
+    return arg_handles
+
+
 def validate_captured_directions(
     captured_vars: CapturedVars, report_outin: bool = True
 ) -> None:

classiq/model_expansions/closure.py

@@ -1,22 +1,11 @@
 import dataclasses
-import json
-from collections.abc import Collection, Sequence
+from collections.abc import Sequence
 from dataclasses import dataclass, field
-from functools import singledispatch
 from typing import Any, Optional
 
 from typing_extensions import Self
 
 from classiq.interface.exceptions import ClassiqInternalExpansionError
-from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
-    ClassicalProxy,
-)
-from classiq.interface.generator.expressions.proxies.classical.classical_struct_proxy import (
-    ClassicalStructProxy,
-)
-from classiq.interface.generator.expressions.proxies.classical.utils import (
-    get_proxy_type,
-)
 from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
 from classiq.interface.model.quantum_function_declaration import (
     NamedParamsQuantumFunctionDeclaration,
@@ -27,10 +16,7 @@ from classiq.interface.model.quantum_statement import QuantumStatement
 
 from classiq.model_expansions.capturing.captured_vars import CapturedVars
 from classiq.model_expansions.scope import (
-    Evaluated,
-    QuantumSymbol,
     Scope,
-    evaluated_to_str as evaluated_classical_param_to_str,
 )
 from classiq.qmod.builtins.functions import permute
 from classiq.qmod.quantum_function import GenerativeQFunc
@@ -67,13 +53,6 @@ class FunctionClosure(Closure):
             raise ClassiqInternalExpansionError
         return self._depth
 
-    # creates a unique id for the function closure based on the arguments values.
-    # The closure is changing across the interpreter flow so it's closure_id may change
-    @property
-    def closure_id(self) -> str:
-        signature = _generate_closure_id(self.scope.data.values())
-        return f"{self.name}__{signature}"
-
     @property
     def body(self) -> Sequence[QuantumStatement]:
         if self.name == permute.func_decl.name:
@@ -134,39 +113,3 @@ class FunctionClosure(Closure):
 @dataclass(frozen=True)
 class GenerativeFunctionClosure(GenerativeClosure, FunctionClosure):
     pass
-
-
-def _generate_closure_id(evaluated_args: Collection[Evaluated]) -> str:
-    args_signature = [
-        _evaluated_arg_to_str(eval_arg.value) for eval_arg in evaluated_args
-    ]
-    return json.dumps(args_signature)
-
-
-@singledispatch
-def _evaluated_arg_to_str(arg: Any) -> str:
-    if isinstance(arg, str):
-        return arg
-    if isinstance(arg, QuantumSymbol):
-        return _evaluated_quantum_symbol_to_str(arg)
-    if isinstance(arg, FunctionClosure):
-        return _evaluated_one_operand_to_str(arg)
-    if isinstance(arg, list) and arg and isinstance(arg[0], FunctionClosure):
-        return _evaluated_operands_list_to_str(arg)
-    if isinstance(arg, ClassicalProxy):
-        if isinstance(arg, ClassicalStructProxy):
-            return repr(arg.struct_declaration)
-        return repr(get_proxy_type(arg))
-    return evaluated_classical_param_to_str(arg)
-
-
-def _evaluated_quantum_symbol_to_str(port: QuantumSymbol) -> str:
-    return port.quantum_type.model_dump_json(exclude_none=True, exclude={"name"})
-
-
-def _evaluated_one_operand_to_str(operand: FunctionClosure) -> str:
-    return operand.closure_id
-
-
-def _evaluated_operands_list_to_str(arg: list[FunctionClosure]) -> str:
-    return json.dumps([_evaluated_one_operand_to_str(ope) for ope in arg])

classiq/model_expansions/evaluators/arg_type_match.py

@@ -27,7 +27,7 @@ from classiq.interface.model.quantum_function_declaration import (
 
 from classiq.model_expansions.closure import FunctionClosure
 from classiq.model_expansions.evaluators.type_type_match import check_signature_match
-from classiq.model_expansions.scope import Evaluated, QuantumSymbol
+from classiq.model_expansions.scope import Evaluated, QuantumVariable
 from classiq.qmod.model_state_container import QMODULE
 from classiq.qmod.qmod_parameter import CInt, get_qmod_type
 
@@ -77,7 +77,7 @@ def check_arg_type_match(
 
 
 def _check_qvar_type_match(argument: Any, error_message: str) -> None:
-    if not isinstance(argument, QuantumSymbol):
+    if not isinstance(argument, QuantumVariable):
         raise ClassiqExpansionError(error_message)
 
 

classiq/model_expansions/evaluators/argument_types.py

@@ -7,13 +7,13 @@ from classiq.interface.model.port_declaration import AnonPortDeclaration
 from classiq.interface.model.quantum_function_declaration import AnonPositionalArg
 
 from classiq.model_expansions.evaluators.quantum_type_utils import copy_type_information
-from classiq.model_expansions.scope import Evaluated, QuantumSymbol
+from classiq.model_expansions.scope import Evaluated, QuantumVariable
 
 
 def add_information_from_output_arguments(
     parameters: Sequence[AnonPositionalArg],
     args: list[Evaluated],
-) -> list[Evaluated]:
+) -> None:
     """
     This function propagates the quantum type information from the output arguments
     to the arguments that were passed to it.
@@ -29,7 +29,7 @@ def add_information_from_output_arguments(
         if not isinstance(parameter, AnonPortDeclaration):
             continue
 
-        argument_as_quantum_symbol = argument.as_type(QuantumSymbol)
+        argument_as_quantum_symbol = argument.as_type(QuantumVariable)
 
         if parameter.direction != PortDeclarationDirection.Output:
             continue
@@ -38,6 +38,5 @@ def add_information_from_output_arguments(
             copy_type_information(
                 parameter.quantum_type,
                 argument_as_quantum_symbol.quantum_type,
-                str(argument_as_quantum_symbol.handle),
+                str(argument_as_quantum_symbol),
             )
-    return args

classiq/model_expansions/evaluators/classical_expression.py

@@ -5,6 +5,9 @@ from classiq.interface.generator.expressions.evaluated_expression import (
 )
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.expressions.expression_types import ExpressionValue
+from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
+    AnyClassicalValue,
+)
 from classiq.interface.model.handle_binding import HandleBinding
 
 from classiq.model_expansions.expression_evaluator import evaluate
@@ -19,18 +22,15 @@ def evaluate_classical_expression(expr: Expression, scope: Scope) -> Evaluated:
         if isinstance(evaluated.value, get_args(ExpressionValue))
     } | {
         name: EvaluatedExpression(
-            value=evaluated.value.quantum_type.get_proxy(HandleBinding(name=name))
+            value=(
+                evaluated.value.quantum_type.get_proxy(HandleBinding(name=name))
+                if evaluated.value.quantum_type.is_evaluated
+                else AnyClassicalValue(name)
+            )
         )
         for name, evaluated in all_symbols
         if isinstance(evaluated.value, QuantumSymbol)
-        and evaluated.value.quantum_type.is_evaluated
-    }
-    uninitialized_locals = {
-        name
-        for name, evaluated in all_symbols
-        if isinstance(evaluated.value, QuantumSymbol)
-        and not evaluated.value.quantum_type.is_evaluated
     }
 
-    ret = evaluate(expr, locals_dict, uninitialized_locals)
+    ret = evaluate(expr, locals_dict)
     return Evaluated(value=ret.value)