classiq 0.43.2__py3-none-any.whl → 0.44.0__py3-none-any.whl

classiq/interface/model/bind_operation.py

@@ -1,9 +1,9 @@
-from typing import List, Literal, Mapping
+from typing import List, Literal, Mapping, Sequence
 
 import pydantic
 
-from classiq.interface.model.handle_binding import HandleBinding
-from classiq.interface.model.quantum_statement import QuantumOperation
+from classiq.interface.model.handle_binding import ConcreteHandleBinding, HandleBinding
+from classiq.interface.model.quantum_statement import HandleMetadata, QuantumOperation
 
 from classiq.exceptions import ClassiqValueError
 
@@ -14,8 +14,8 @@ BIND_OUTPUT_NAME = "bind_output"
 class BindOperation(QuantumOperation):
     kind: Literal["BindOperation"]
 
-    in_handles: List[HandleBinding]
-    out_handles: List[HandleBinding]
+    in_handles: List[ConcreteHandleBinding]
+    out_handles: List[ConcreteHandleBinding]
 
     @property
     def wiring_inputs(self) -> Mapping[str, HandleBinding]:
@@ -23,6 +23,16 @@ class BindOperation(QuantumOperation):
             f"{BIND_INPUT_NAME}_{i}": handle for i, handle in enumerate(self.in_handles)
         }
 
+    @property
+    def readable_inputs(self) -> Sequence[HandleMetadata]:
+        return [
+            HandleMetadata(
+                handle=handle,
+                readable_location="on the left-hand side of a bind statement",
+            )
+            for handle in self.in_handles
+        ]
+
     @property
     def wiring_outputs(self) -> Mapping[str, HandleBinding]:
         return {
@@ -30,6 +40,16 @@ class BindOperation(QuantumOperation):
             for i, handle in enumerate(self.out_handles)
         }
 
+    @property
+    def readable_outputs(self) -> Sequence[HandleMetadata]:
+        return [
+            HandleMetadata(
+                handle=handle,
+                readable_location="on the right-hand side of a bind statement",
+            )
+            for handle in self.out_handles
+        ]
+
     @pydantic.validator("in_handles", "out_handles")
     def validate_handle(cls, handles: List[HandleBinding]) -> List[HandleBinding]:
         for handle in handles:

classiq/interface/model/classical_parameter_declaration.py

@@ -2,15 +2,14 @@ from typing import Any, Dict, Literal
 
 import pydantic
 
-from classiq.interface.ast_node import ASTNode
-from classiq.interface.generator.functions.classical_type import ConcreteClassicalType
+from classiq.interface.generator.functions.concrete_types import ConcreteClassicalType
 from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
+from classiq.interface.model.parameter import Parameter
 
 
-class ClassicalParameterDeclaration(ASTNode):
+class AnonClassicalParameterDeclaration(Parameter):
     kind: Literal["ClassicalParameterDeclaration"]
 
-    name: str
     classical_type: ConcreteClassicalType
 
     @pydantic.root_validator(pre=True)
@@ -20,4 +19,8 @@ class ClassicalParameterDeclaration(ASTNode):
         )
 
     def rename(self, new_name: str) -> "ClassicalParameterDeclaration":
-        return self.copy(update=dict(name=new_name))
+        return ClassicalParameterDeclaration(**{**self.__dict__, "name": new_name})
+
+
+class ClassicalParameterDeclaration(AnonClassicalParameterDeclaration):
+    name: str

classiq/interface/model/control.py

@@ -14,11 +14,11 @@ class Control(QuantumExpressionOperation):
     kind: Literal["Control"]
     body: "StatementBlock"
 
-    _ctrl_state: str = pydantic.PrivateAttr(default="")
+    _ctrl_size: int = pydantic.PrivateAttr(default=0)
 
     @property
-    def ctrl_state(self) -> str:
-        return self._ctrl_state
+    def ctrl_size(self) -> int:
+        return self._ctrl_size
 
-    def set_ctrl_state(self, ctrl_state: str) -> None:
-        self._ctrl_state = ctrl_state
+    def set_ctrl_size(self, ctrl_size: int) -> None:
+        self._ctrl_size = ctrl_size

classiq/interface/model/handle_binding.py

@@ -1,13 +1,17 @@
-from typing import Union
+from itertools import chain
+from typing import TYPE_CHECKING, Any, Dict, Sequence, Union
 
-from pydantic import Extra
+import pydantic
+from pydantic import Extra, Field
 
 from classiq.interface.ast_node import ASTNode
 from classiq.interface.generator.expressions.expression import Expression
 
+HANDLE_ID_SEPARATOR = "___"
+
 
 class HandleBinding(ASTNode):
-    name: str
+    name: str = Field(default=None)
 
     class Config:
         frozen = True
@@ -19,8 +23,49 @@ class HandleBinding(ASTNode):
     def is_bindable(self) -> bool:
         return True
 
+    @property
+    def identifier(self) -> str:
+        return self.name
+
+    def collapse(self) -> "HandleBinding":
+        return self
+
+    def prefixes(self) -> Sequence["HandleBinding"]:
+        """
+        Split the handle into prefixes:
+        a.b[0].c --> [a, a.b, a.b[0], a.b[0].c]
+        """
+        return [self]
+
+    def _tail_overlaps(self, other_handle: "HandleBinding") -> bool:
+        return self.name == other_handle.name
+
+    def overlaps(self, other_handle: "HandleBinding") -> bool:
+        self_prefixes = self.collapse().prefixes()
+        other_prefixes = other_handle.collapse().prefixes()
+        return all(
+            self_prefix._tail_overlaps(other_prefix)
+            for self_prefix, other_prefix in zip(self_prefixes, other_prefixes)
+        )
+
+
+class NestedHandleBinding(HandleBinding):
+    base_handle: "ConcreteHandleBinding"
+
+    @pydantic.root_validator(pre=False)
+    def _set_name(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        if "base_handle" in values:
+            values["name"] = values["base_handle"].name
+        return values
+
+    def is_bindable(self) -> bool:
+        return False
+
+    def prefixes(self) -> Sequence["HandleBinding"]:
+        return list(chain.from_iterable([self.base_handle.prefixes(), [self]]))
+
 
-class SubscriptHandleBinding(HandleBinding):
+class SubscriptHandleBinding(NestedHandleBinding):
     index: Expression
 
     class Config:
@@ -28,13 +73,52 @@ class SubscriptHandleBinding(HandleBinding):
         extra = Extra.forbid
 
     def __str__(self) -> str:
-        return f"{self.name}[{self.index}]"
-
-    def is_bindable(self) -> bool:
+        return f"{self.base_handle}[{self.index}]"
+
+    @property
+    def identifier(self) -> str:
+        return f"{self.base_handle.identifier}{HANDLE_ID_SEPARATOR}{self.index}"
+
+    def collapse(self) -> HandleBinding:
+        if isinstance(self.base_handle, SlicedHandleBinding):
+            return SubscriptHandleBinding(
+                base_handle=self.base_handle.base_handle,
+                index=self._get_collapsed_index(),
+            ).collapse()
+        return SubscriptHandleBinding(
+            base_handle=self.base_handle.collapse(),
+            index=self.index,
+        )
+
+    def _get_collapsed_index(self) -> Expression:
+        if TYPE_CHECKING:
+            assert isinstance(self.base_handle, SlicedHandleBinding)
+        if self.index.is_evaluated() and self.base_handle.start.is_evaluated():
+            return Expression(
+                expr=str(
+                    self.base_handle.start.to_int_value() + self.index.to_int_value()
+                )
+            )
+        return Expression(expr=f"({self.base_handle.start})+({self.index})")
+
+    def _tail_overlaps(self, other_handle: "HandleBinding") -> bool:
+        if isinstance(other_handle, SubscriptHandleBinding):
+            return self.index == other_handle.index
+        if (
+            isinstance(other_handle, SlicedHandleBinding)
+            and self.index.is_evaluated()
+            and other_handle.start.is_evaluated()
+            and other_handle.end.is_evaluated()
+        ):
+            return (
+                other_handle.start.to_int_value()
+                <= self.index.to_int_value()
+                < other_handle.end.to_int_value()
+            )
         return False
 
 
-class SlicedHandleBinding(HandleBinding):
+class SlicedHandleBinding(NestedHandleBinding):
     start: Expression
     end: Expression
 
@@ -43,12 +127,101 @@ class SlicedHandleBinding(HandleBinding):
         extra = Extra.forbid
 
     def __str__(self) -> str:
-        return f"{self.name}[{self.start}:{self.end}]"
-
-    def is_bindable(self) -> bool:
+        return f"{self.base_handle}[{self.start}:{self.end}]"
+
+    @property
+    def identifier(self) -> str:
+        return (
+            f"{self.base_handle.identifier}{HANDLE_ID_SEPARATOR}{self.start}_{self.end}"
+        )
+
+    def collapse(self) -> HandleBinding:
+        if isinstance(self.base_handle, SlicedHandleBinding):
+            return SubscriptHandleBinding(
+                base_handle=self.base_handle.base_handle,
+                start=self._get_collapsed_start(),
+                end=self._get_collapsed_stop(),
+            ).collapse()
+        return SlicedHandleBinding(
+            base_handle=self.base_handle.collapse(),
+            start=self.start,
+            end=self.end,
+        )
+
+    def _tail_overlaps(self, other_handle: "HandleBinding") -> bool:
+        if not self.start.is_evaluated() or not self.end.is_evaluated():
+            return False
+        start = self.start.to_int_value()
+        end = self.end.to_int_value()
+        if (
+            isinstance(other_handle, SubscriptHandleBinding)
+            and other_handle.index.is_evaluated()
+        ):
+            return start <= other_handle.index.to_int_value() < end
+        if (
+            isinstance(other_handle, SlicedHandleBinding)
+            and other_handle.start.is_evaluated()
+            and other_handle.end.is_evaluated()
+        ):
+            other_start = other_handle.start.to_int_value()
+            other_end = other_handle.end.to_int_value()
+            return start <= other_start < end or other_start <= start < other_end
         return False
 
+    def _get_collapsed_start(self) -> Expression:
+        if TYPE_CHECKING:
+            assert isinstance(self.base_handle, SlicedHandleBinding)
+        if self.start.is_evaluated() and self.base_handle.start.is_evaluated():
+            return Expression(
+                expr=str(
+                    self.base_handle.start.to_int_value() + self.start.to_int_value()
+                )
+            )
+        return Expression(expr=f"({self.base_handle.start})+({self.start})")
+
+    def _get_collapsed_stop(self) -> Expression:
+        if TYPE_CHECKING:
+            assert isinstance(self.base_handle, SlicedHandleBinding)
+        if self.end.is_evaluated() and self.base_handle.end.is_evaluated():
+            return Expression(
+                expr=str(self.base_handle.end.to_int_value() - self.end.to_int_value())
+            )
+        return Expression(expr=f"({self.base_handle.end})-({self.end})")
+
+
+class FieldHandleBinding(NestedHandleBinding):
+    field: str
+
+    class Config:
+        frozen = True
+        extra = Extra.forbid
+
+    def __str__(self) -> str:
+        return f"{self.base_handle}.{self.field}"
+
+    @property
+    def identifier(self) -> str:
+        return f"{self.base_handle.identifier}{HANDLE_ID_SEPARATOR}{self.field}"
+
+    def collapse(self) -> HandleBinding:
+        return FieldHandleBinding(
+            base_handle=self.base_handle.collapse(),
+            field=self.field,
+        )
+
+    def _tail_overlaps(self, other_handle: "HandleBinding") -> bool:
+        return (
+            isinstance(other_handle, FieldHandleBinding)
+            and self.field == other_handle.field
+        )
+
 
 ConcreteHandleBinding = Union[
-    HandleBinding, SubscriptHandleBinding, SlicedHandleBinding
+    HandleBinding,
+    SubscriptHandleBinding,
+    SlicedHandleBinding,
+    FieldHandleBinding,
 ]
+SubscriptHandleBinding.update_forward_refs(ConcreteHandleBinding=ConcreteHandleBinding)
+SlicedHandleBinding.update_forward_refs(ConcreteHandleBinding=ConcreteHandleBinding)
+FieldHandleBinding.update_forward_refs(ConcreteHandleBinding=ConcreteHandleBinding)

classiq/interface/model/inplace_binary_operation.py

@@ -1,4 +1,4 @@
-from typing import Literal, Mapping
+from typing import Literal, Mapping, Sequence
 
 from classiq.interface.generator.functions.builtins.core_library import (
     INTEGER_XOR_FUNCTION,
@@ -7,9 +7,9 @@ from classiq.interface.generator.functions.builtins.core_library import (
 from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
 from classiq.interface.model.handle_binding import ConcreteHandleBinding, HandleBinding
 from classiq.interface.model.quantum_function_declaration import (
-    QuantumFunctionDeclaration,
+    NamedParamsQuantumFunctionDeclaration,
 )
-from classiq.interface.model.quantum_statement import QuantumOperation
+from classiq.interface.model.quantum_statement import HandleMetadata, QuantumOperation
 
 from classiq._internals.enum_utils import StrEnum
 
@@ -19,7 +19,7 @@ class BinaryOperation(StrEnum):
     Xor = "inplace_xor"
 
     @property
-    def internal_function_declaration(self) -> QuantumFunctionDeclaration:
+    def internal_function_declaration(self) -> NamedParamsQuantumFunctionDeclaration:
         return {
             BinaryOperation.Addition: MODULAR_ADD_FUNCTION,
             BinaryOperation.Xor: INTEGER_XOR_FUNCTION,
@@ -36,3 +36,15 @@ class InplaceBinaryOperation(QuantumOperation):
     @property
     def wiring_inouts(self) -> Mapping[str, HandleBinding]:
         return nameables_to_dict([self.target, self.value])
+
+    @property
+    def readable_inouts(self) -> Sequence[HandleMetadata]:
+        suffix = f" of an in-place {self.operation.name.lower()} statement"
+        return [
+            HandleMetadata(
+                handle=self.target, readable_location=f"as the target{suffix}"
+            ),
+            HandleMetadata(
+                handle=self.value, readable_location=f"as the value{suffix}"
+            ),
+        ]

classiq/interface/model/model.py

@@ -1,9 +1,10 @@
 from collections import Counter
-from typing import Dict, List, Literal, NewType, Set
+from typing import List, Literal, Mapping, NewType, Set
 
 import pydantic
 
 from classiq.interface.ast_node import ASTNode
+from classiq.interface.debug_info.debug_info import DebugInfoCollection
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
 from classiq.interface.generator.constant import Constant
 from classiq.interface.generator.functions.port_declaration import (
@@ -13,12 +14,15 @@ from classiq.interface.generator.model.constraints import Constraints
 from classiq.interface.generator.model.preferences.preferences import Preferences
 from classiq.interface.generator.quantum_function_call import SUFFIX_RANDOMIZER
 from classiq.interface.generator.types.enum_declaration import EnumDeclaration
+from classiq.interface.generator.types.qstruct_declaration import QStructDeclaration
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
 from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
 from classiq.interface.helpers.versioned_model import VersionedModel
-from classiq.interface.model.native_function_definition import NativeFunctionDefinition
+from classiq.interface.model.native_function_definition import (
+    NativeFunctionDefinition,
+)
 from classiq.interface.model.quantum_function_declaration import (
-    QuantumFunctionDeclaration,
+    NamedParamsQuantumFunctionDeclaration,
 )
 from classiq.interface.model.statement_block import StatementBlock
 
@@ -73,6 +77,11 @@ class Model(VersionedModel, ASTNode):
         description="user-defined structs",
     )
 
+    qstructs: List[QStructDeclaration] = pydantic.Field(
+        default_factory=list,
+        description="user-defined quantum structs",
+    )
+
     classical_execution_code: str = pydantic.Field(
         description="The classical execution code of the model", default=""
     )
@@ -88,6 +97,10 @@ class Model(VersionedModel, ASTNode):
     )
     preferences: Preferences = pydantic.Field(default_factory=Preferences)
 
+    debug_info: DebugInfoCollection = pydantic.Field(
+        default_factory=DebugInfoCollection
+    )
+
     @property
     def main_func(self) -> NativeFunctionDefinition:
         return self.function_dict[MAIN_FUNCTION_NAME]  # type:ignore[return-value]
@@ -109,7 +122,7 @@ class Model(VersionedModel, ASTNode):
         return direction
 
     @property
-    def function_dict(self) -> Dict[str, QuantumFunctionDeclaration]:
+    def function_dict(self) -> Mapping[str, NamedParamsQuantumFunctionDeclaration]:
         return nameables_to_dict(self.functions)
 
     @pydantic.validator("functions", always=True)
@@ -149,7 +162,7 @@ class Model(VersionedModel, ASTNode):
             raise ClassiqValueError("The model must contain a `main` function")
         if any(
             pd.direction != PortDeclarationDirection.Output
-            for pd in function_dict[MAIN_FUNCTION_NAME].port_declarations.values()
+            for pd in function_dict[MAIN_FUNCTION_NAME].port_declarations
         ):
             raise ClassiqValueError("Function 'main' cannot declare quantum inputs")
 
@@ -169,3 +182,13 @@ class Model(VersionedModel, ASTNode):
                 f"{multiply_defined_constants}"
             )
         return constants
+
+    def json_no_preferences_and_constraints(self) -> str:
+        return self.json(
+            indent=2,
+            exclude={
+                "constraints",
+                "execution_preferences",
+                "preferences",
+            },
+        )

classiq/interface/model/native_function_definition.py

@@ -1,12 +1,16 @@
+from typing import TYPE_CHECKING
+
 import pydantic
 
 from classiq.interface.model.quantum_function_declaration import (
-    QuantumFunctionDeclaration,
+    NamedParamsQuantumFunctionDeclaration,
 )
-from classiq.interface.model.statement_block import StatementBlock
+
+if TYPE_CHECKING:
+    from classiq.interface.model.statement_block import StatementBlock
 
 
-class NativeFunctionDefinition(QuantumFunctionDeclaration):
+class NativeFunctionDefinition(NamedParamsQuantumFunctionDeclaration):
     """
     Facilitates the creation of a user-defined composite function
 
@@ -14,6 +18,6 @@ class NativeFunctionDefinition(QuantumFunctionDeclaration):
     objects from other classes.
     """
 
-    body: StatementBlock = pydantic.Field(
+    body: "StatementBlock" = pydantic.Field(
         default_factory=list, description="List of function calls to perform."
     )

classiq/interface/model/parameter.py

@@ -0,0 +1,14 @@
+from typing import Optional
+
+from classiq.interface.ast_node import ASTNode
+
+from classiq.exceptions import ClassiqError
+
+
+class Parameter(ASTNode):
+    name: Optional[str]
+
+    def get_name(self) -> str:
+        if self.name is None:
+            raise ClassiqError("Cannot resolve parameter name")
+        return self.name

classiq/interface/model/port_declaration.py

@@ -1,11 +1,14 @@
-from typing import Any, Dict, Literal, Mapping
+from typing import Any, Dict, Literal, Mapping, Optional
 
 import pydantic
 
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.concrete_types import ConcreteQuantumType
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
 from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
+from classiq.interface.model.parameter import Parameter
 from classiq.interface.model.quantum_variable_declaration import (
     QuantumVariableDeclaration,
 )
@@ -13,9 +16,11 @@ from classiq.interface.model.quantum_variable_declaration import (
 from classiq.exceptions import ClassiqValueError
 
 
-class PortDeclaration(QuantumVariableDeclaration):
+class AnonPortDeclaration(Parameter):
     kind: Literal["PortDeclaration"]
 
+    quantum_type: ConcreteQuantumType
+    size: Optional[Expression] = pydantic.Field(default=None)
     direction: PortDeclarationDirection
 
     @pydantic.root_validator(pre=True)
@@ -32,3 +37,16 @@ class PortDeclaration(QuantumVariableDeclaration):
                 raise ClassiqValueError("Port declaration is missing a type")
 
         return direction
+
+    @pydantic.validator("size")
+    def _propagate_size_to_type(
+        cls, size: Optional[Expression], values: Mapping[str, Any]
+    ) -> Optional[Expression]:
+        return QuantumVariableDeclaration._propagate_size_to_type(size, values)
+
+    def rename(self, new_name: str) -> "PortDeclaration":
+        return PortDeclaration(**{**self.__dict__, "name": new_name})
+
+
+class PortDeclaration(AnonPortDeclaration):
+    name: str

classiq/interface/model/quantum_expressions/amplitude_loading_operation.py

@@ -1,4 +1,4 @@
-from typing import Dict, Literal, Mapping, Union
+from typing import Dict, Literal, Mapping, Sequence
 
 import pydantic
 
@@ -7,13 +7,13 @@ from classiq.interface.generator.amplitude_loading import (
     TARGET_OUTPUT_NAME,
 )
 from classiq.interface.model.handle_binding import (
+    ConcreteHandleBinding,
     HandleBinding,
-    SlicedHandleBinding,
-    SubscriptHandleBinding,
 )
 from classiq.interface.model.quantum_expressions.quantum_expression import (
     QuantumAssignmentOperation,
 )
+from classiq.interface.model.quantum_statement import HandleMetadata
 from classiq.interface.model.quantum_type import QuantumBit, QuantumNumeric, QuantumType
 
 from classiq.exceptions import ClassiqValueError
@@ -33,14 +33,29 @@ class AmplitudeLoadingOperation(QuantumAssignmentOperation):
     @property
     def wiring_inouts(
         self,
-    ) -> Mapping[
-        str, Union[SlicedHandleBinding, SubscriptHandleBinding, HandleBinding]
-    ]:
+    ) -> Mapping[str, ConcreteHandleBinding]:
         inouts = {self.result_name(): self.result_var}
         if len(self.var_handles) == 1:
             inouts[AMPLITUDE_IO_NAME] = self.var_handles[0]
         return inouts
 
+    @property
+    def readable_inouts(self) -> Sequence[HandleMetadata]:
+        inouts = [
+            HandleMetadata(
+                handle=self.result_var,
+                readable_location="on the left-hand side of an in-place assignment",
+            )
+        ]
+        if len(self.var_handles) == 1:
+            inouts.append(
+                HandleMetadata(
+                    handle=self.var_handles[0],
+                    readable_location="in an expression",
+                )
+            )
+        return inouts
+
     @property
     def wiring_outputs(self) -> Mapping[str, HandleBinding]:
         return {}

classiq/interface/model/quantum_expressions/arithmetic_operation.py

@@ -1,4 +1,4 @@
-from typing import Dict, Literal, Mapping, Union
+from typing import Dict, Literal, Mapping, Sequence
 
 import pydantic
 
@@ -7,13 +7,13 @@ from classiq.interface.generator.arith.arithmetic import (
     compute_arithmetic_result_type,
 )
 from classiq.interface.model.handle_binding import (
+    ConcreteHandleBinding,
     HandleBinding,
-    SlicedHandleBinding,
-    SubscriptHandleBinding,
 )
 from classiq.interface.model.quantum_expressions.quantum_expression import (
     QuantumAssignmentOperation,
 )
+from classiq.interface.model.quantum_statement import HandleMetadata
 from classiq.interface.model.quantum_type import QuantumType
 
 
@@ -37,20 +37,44 @@ class ArithmeticOperation(QuantumAssignmentOperation):
     @property
     def wiring_inouts(
         self,
-    ) -> Mapping[
-        str, Union[SlicedHandleBinding, SubscriptHandleBinding, HandleBinding]
-    ]:
+    ) -> Mapping[str, ConcreteHandleBinding]:
         inouts = dict(super().wiring_inouts)
         if self.inplace_result:
             inouts[self.result_name()] = self.result_var
         return inouts
 
+    @property
+    def readable_inouts(self) -> Sequence[HandleMetadata]:
+        inouts = [
+            HandleMetadata(handle=handle, readable_location="in an expression")
+            for handle in self.var_handles
+        ]
+        if self.inplace_result:
+            inouts.append(
+                HandleMetadata(
+                    handle=self.result_var,
+                    readable_location="on the left-hand side of an in-place assignment",
+                )
+            )
+        return inouts
+
     @property
     def wiring_outputs(self) -> Mapping[str, HandleBinding]:
         if self.inplace_result:
             return {}
         return super().wiring_outputs
 
+    @property
+    def readable_outputs(self) -> Sequence[HandleMetadata]:
+        if self.inplace_result:
+            return []
+        return [
+            HandleMetadata(
+                handle=self.result_var,
+                readable_location="on the left-hand side of an assignment",
+            )
+        ]
+
     @classmethod
     def result_name(cls) -> str:
         return ARITHMETIC_EXPRESSION_RESULT_NAME