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

classiq/interface/generator/generated_circuit_data.py

@@ -2,15 +2,24 @@ import logging
 from typing import Literal, Optional, Union
 
 import pydantic
-from pydantic import ConfigDict
+from pydantic import ConfigDict, Field
 from typing_extensions import TypeAlias
 
+from classiq.interface.debug_info.back_ref_util import is_allocate_or_free_by_backref
 from classiq.interface.enum_utils import StrEnum
 from classiq.interface.generator.control_state import ControlState
 from classiq.interface.generator.register_role import RegisterRole
 from classiq.interface.generator.synthesis_metadata.synthesis_execution_data import (
     ExecutionData,
 )
+from classiq.interface.model.quantum_expressions.quantum_expression import (
+    QuantumExpressionOperation,
+)
+from classiq.interface.model.statement_block import (
+    ConcreteQuantumStatement,
+    QuantumFunctionCall,
+    StatementBlock,
+)
 
 from classiq.model_expansions.capturing.mangling_utils import (
     demangle_capture_name,
@@ -22,7 +31,7 @@ _logger = logging.getLogger(__name__)
 ParameterName = str
 IOQubitMapping: TypeAlias = dict[str, tuple[int, ...]]
 
-CLASSIQ_HIERARCHY_SEPARATOR: Literal["."] = "."
+CLASSIQ_HIERARCHY_SEPARATOR: Literal["__"] = "__"
 
 VISUALIZATION_HIDE_LIST = [
     "apply_to_all",
@@ -119,34 +128,75 @@ class OperationLevel(StrEnum):
     UNKNOWN = "UNKNOWN"
 
 
-class OperationParameter(pydantic.BaseModel):
-    label: str
-    value: Optional[str] = None
+class StatementType(StrEnum):
+    CONTROL = "control"
+    POWER = "power"
+    INVERT = "invert"
+    WITHIN_APPLY = "within_apply"
+    ASSIGNMENT = "assignment"
+    REPEAT = "repeat"
 
 
 class FunctionDebugInfoInterface(pydantic.BaseModel):
-    generated_function: Optional[GeneratedFunction] = pydantic.Field(default=None)
+    generated_function: Optional[GeneratedFunction] = Field(default=None)
     children: list["FunctionDebugInfoInterface"]
     relative_qubits: tuple[int, ...]
-    absolute_qubits: Optional[tuple[int, ...]] = pydantic.Field(default=None)
-    is_basis_gate: Optional[bool] = pydantic.Field(default=None)
-    is_inverse: bool = pydantic.Field(default=False)
-    is_allocate_or_free: bool = pydantic.Field(default=False)
-    level: OperationLevel = pydantic.Field(default=OperationLevel.UNKNOWN)
-    parameters: list[OperationParameter] = list()
-    port_to_passed_variable_map: dict[str, str] = pydantic.Field(default={})
-    release_by_inverse: bool = pydantic.Field(default=False)
+    absolute_qubits: Optional[tuple[int, ...]] = Field(default=None)
+    is_basis_gate: Optional[bool] = Field(default=None)
+    is_inverse: bool = Field(default=False)
+    is_allocate_or_free: bool = Field(default=False)
+    level: OperationLevel = Field(default=OperationLevel.UNKNOWN)
+    port_to_passed_variable_map: dict[str, str] = Field(default={})
+    release_by_inverse: bool = Field(default=False)
+    back_refs: StatementBlock = Field(default_factory=list)
 
     model_config = ConfigDict(extra="allow")
     # Temporary field to store the override debug info for parallel old/new visualization
     override_debug_info: Optional["FunctionDebugInfoInterface"] = None
 
+    @property
+    def is_allocate_or_free_(self) -> bool:
+        """
+        temporary measure to handle the fact that in the current release we do not have
+        the backref, and therefore fallback to the old field of is_allocate_or_free
+        """
+        return (
+            is_allocate_or_free_by_backref(self.back_refs)
+            if bool(self.back_refs)
+            else self.is_allocate_or_free
+        )
+
     @property
     def name(self) -> str:
         if self.generated_function is None:
             return ""
         return self.generated_function.name
 
+    @property
+    def first_back_ref(self) -> Optional[ConcreteQuantumStatement]:
+        return self.back_refs[0] if self.back_refs else None
+
+    @property
+    def level_(self) -> OperationLevel:
+        # Temp fix for currently "supported" statements
+        if self.name in {StatementType.CONTROL, StatementType.POWER}:
+            return OperationLevel.QMOD_STATEMENT
+
+        back_ref = self.first_back_ref
+        if back_ref is None:
+            # This is the expected behavior for the case where there's not back ref.
+            # We will use it once we can rely on the existence of the back ref in
+            # all expected cases (non-engine calls)
+            # return OperationLevel.ENGINE_FUNCTION_CALL
+            return self.level
+        if isinstance(back_ref, QuantumFunctionCall):
+            return OperationLevel.QMOD_FUNCTION_CALL
+        # Temp "fix" for assignment statements until we have a way to fully
+        # distinguish them and to properly display them
+        if isinstance(back_ref, QuantumExpressionOperation):
+            return OperationLevel.ENGINE_FUNCTION_CALL
+        return OperationLevel.QMOD_STATEMENT
+
     @property
     def registers(self) -> list[GeneratedRegister]:
         if self.generated_function is None:
@@ -165,15 +215,6 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
             return list()
         return self.generated_function.control_states
 
-    @staticmethod
-    def create_parameters_from_dict(
-        parameters: dict[str, str]
-    ) -> list[OperationParameter]:
-        return [
-            OperationParameter(label=key, value=value)
-            for key, value in parameters.items()
-        ]
-
     def propagate_absolute_qubits(self) -> "FunctionDebugInfoInterface":
         if self.absolute_qubits is None:
             return self

classiq/interface/generator/quantum_program.py

@@ -1,9 +1,11 @@
 import uuid
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import Optional, Union
+from typing import Any, Optional, Union
 
 import pydantic
+from pydantic import model_validator
+from pydantic_core.core_schema import ValidationInfo
 from typing_extensions import TypeAlias
 
 from classiq.interface.exceptions import (
@@ -36,6 +38,8 @@ from classiq.interface.ide.visual_model import CircuitMetrics
 RegisterName: TypeAlias = str
 InitialConditions: TypeAlias = dict[RegisterName, int]
 
+OMIT_DEBUG_INFO_FLAG = "omit_debug_info"
+
 
 class TranspiledCircuitData(CircuitCodeInterface):
     depth: int
@@ -71,6 +75,19 @@ class QuantumProgram(VersionedModel, CircuitCodeInterface):
     program_id: str = pydantic.Field(default_factory=get_uuid_as_str)
     execution_primitives_input: Optional[PrimitivesInput] = pydantic.Field(default=None)
 
+    @model_validator(mode="before")
+    @classmethod
+    def remove_debug_info(
+        cls, data: dict[str, Any], info: ValidationInfo
+    ) -> dict[str, Any]:
+        if (
+            isinstance(data, dict)
+            and info.context is not None
+            and info.context.get(OMIT_DEBUG_INFO_FLAG, False)
+        ):
+            data.pop("debug_info", None)
+        return data
+
     def _hardware_agnostic_program_code(self) -> CodeAndSyntax:
         circuit_code = self.program_circuit.get_code_by_priority()
         if circuit_code is not None:

classiq/interface/generator/types/builtin_enum_declarations.py

@@ -150,6 +150,7 @@ class Optimizer(IntEnum):
     L_BFGS_B = 3
     NELDER_MEAD = 4
     ADAM = 5
+    SLSQP = 6
 
 
 class Pauli(IntEnum):

classiq/interface/generator/types/enum_declaration.py

@@ -1,5 +1,6 @@
 from collections import Counter
 from enum import Enum, EnumMeta, IntEnum
+from typing import Any, Callable
 
 import pydantic
 
@@ -7,6 +8,33 @@ from classiq.interface.ast_node import HashableASTNode
 from classiq.interface.exceptions import ClassiqValueError
 
 
+def rebuild_dynamic_enum(name: str, members: dict[str, int]) -> type[IntEnum]:
+    """
+    Rebuilds the dynamic enum from its name and members.
+    Returns a new enum type.
+    """
+    new_enum = IntEnum(name, members)  # type: ignore[misc]
+    setattr(new_enum, "__members_data__", members)  # noqa: B010
+    setattr(new_enum, "__reduce_ex__", dynamic_enum_reduce_ex)  # noqa: B010
+    return new_enum
+
+
+def dynamic_enum_reduce_ex(
+    obj: Any, protocol: int
+) -> tuple[Callable[..., type[IntEnum]], tuple[str, dict[str, int]]]:
+    """
+    Custom __reduce_ex__ for dynamic enums.
+    This function will be used when pickling an enum type or one of its members.
+    """
+    # Get the enum type and its member data.
+    enum_type = type(obj)
+    members = getattr(enum_type, "__members_data__", None)
+    if members is None:
+        raise ValueError("Dynamic enum is missing __members_data__ attribute")
+    # Return the callable and arguments needed to rebuild the enum type.
+    return rebuild_dynamic_enum, (enum_type.__name__, members)
+
+
 class EnumDeclaration(HashableASTNode):
     name: str
 
@@ -39,12 +67,15 @@ class EnumDeclaration(HashableASTNode):
 
         return members
 
-    def create_enum(self) -> IntEnum:
-        return IntEnum(self.name, self.members)
+    def create_enum(self) -> type[IntEnum]:
+        dynamic_enum = IntEnum(self.name, self.members)  # type: ignore[misc]
+        setattr(dynamic_enum, "__members_data__", self.members)  # noqa: B010
+        setattr(dynamic_enum, "__reduce_ex__", dynamic_enum_reduce_ex)  # noqa: B010
+        return dynamic_enum
 
 
 def declaration_from_enum(enum_type: EnumMeta) -> EnumDeclaration:
-    members: list[Enum] = list(enum_type)
+    members = _get_members(enum_type)
     return EnumDeclaration(
         name=enum_type.__name__,
         members={
@@ -52,3 +83,14 @@ def declaration_from_enum(enum_type: EnumMeta) -> EnumDeclaration:
             for member in sorted(members, key=lambda member: member.value)
         },
     )
+
+
+def _get_members(enum_type: EnumMeta) -> list[Enum]:
+    members: list[Enum] = list(enum_type)
+    for member in members:
+        if not isinstance(member.value, int):
+            raise ClassiqValueError(
+                f"Member {member.name!r} of enum {enum_type.__name__!r} has a "
+                f"non-integer value {member.value!r}"
+            )
+    return members

classiq/interface/ide/visual_model.py

@@ -7,7 +7,6 @@ from pydantic import ConfigDict
 from classiq.interface.enum_utils import StrEnum
 from classiq.interface.generator.generated_circuit_data import (
     OperationLevel,
-    OperationParameter,
 )
 from classiq.interface.generator.hardware.hardware_data import SynthesisHardwareData
 from classiq.interface.helpers.versioned_model import VersionedModel
@@ -114,7 +113,6 @@ class Operation(pydantic.BaseModel):
     control_qubits: tuple[int, ...] = pydantic.Field(default_factory=tuple)
     auxiliary_qubits: tuple[int, ...]
     target_qubits: tuple[int, ...]
-    parameters: list[OperationParameter] = pydantic.Field(default_factory=list)
     operation_level: OperationLevel
     operation_type: OperationType = pydantic.Field(
         description="Identifies unique operations that are visualized differently"

classiq/interface/model/classical_if.py

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING, Literal
 
-from classiq.interface.ast_node import ASTNodeType, without_statement_blocks
+from classiq.interface.ast_node import ASTNodeType, reset_lists
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.quantum_statement import QuantumOperation
 
@@ -16,4 +16,4 @@ class ClassicalIf(QuantumOperation):
     else_: "StatementBlock"
 
     def _as_back_ref(self: ASTNodeType) -> ASTNodeType:
-        return without_statement_blocks(self, ["then", "else_"])
+        return reset_lists(self, ["then", "else_"])

classiq/interface/model/control.py

@@ -2,7 +2,7 @@ from typing import TYPE_CHECKING, Literal, Optional
 
 import pydantic
 
-from classiq.interface.ast_node import ASTNodeType, without_statement_blocks
+from classiq.interface.ast_node import ASTNodeType, reset_lists
 from classiq.interface.generator.arith.arithmetic import compute_arithmetic_result_type
 from classiq.interface.model.quantum_expressions.quantum_expression import (
     QuantumExpressionOperation,
@@ -46,4 +46,4 @@ class Control(QuantumExpressionOperation):
         )
 
     def _as_back_ref(self: ASTNodeType) -> ASTNodeType:
-        return without_statement_blocks(self, ["body", "else_block"])
+        return reset_lists(self, ["body", "else_block"])

classiq/interface/model/invert.py

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING, Literal
 
-from classiq.interface.ast_node import ASTNodeType, without_statement_blocks
+from classiq.interface.ast_node import ASTNodeType, reset_lists
 from classiq.interface.model.quantum_statement import QuantumOperation
 
 if TYPE_CHECKING:
@@ -13,4 +13,4 @@ class Invert(QuantumOperation):
     body: "StatementBlock"
 
     def _as_back_ref(self: ASTNodeType) -> ASTNodeType:
-        return without_statement_blocks(self, ["body"])
+        return reset_lists(self, ["body"])

classiq/interface/model/power.py

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING, Literal
 
-from classiq.interface.ast_node import ASTNodeType, without_statement_blocks
+from classiq.interface.ast_node import ASTNodeType, reset_lists
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.quantum_statement import QuantumOperation
 
@@ -15,4 +15,4 @@ class Power(QuantumOperation):
     body: "StatementBlock"
 
     def _as_back_ref(self: ASTNodeType) -> ASTNodeType:
-        return without_statement_blocks(self, ["body"])
+        return reset_lists(self, ["body"])

classiq/interface/model/quantum_function_call.py

@@ -7,6 +7,7 @@ from typing import (
 
 import pydantic
 
+from classiq.interface.ast_node import ASTNodeType, reset_lists
 from classiq.interface.exceptions import ClassiqError, ClassiqValueError
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.port_declaration import (
@@ -45,6 +46,9 @@ class QuantumFunctionCall(QuantumOperation):
         default=None
     )
 
+    def _as_back_ref(self: ASTNodeType) -> ASTNodeType:
+        return reset_lists(self, ["positional_args"])
+
     @property
     def func_decl(self) -> QuantumFunctionDeclaration:
         if self._func_decl is None:

classiq/interface/model/quantum_statement.py

@@ -27,7 +27,7 @@ class QuantumStatement(ASTNode):
         *,
         update: Optional[dict[str, Any]] = None,
         deep: bool = False,
-        keep_uuid: bool = False
+        keep_uuid: bool = False,
     ) -> Self:
         if not keep_uuid:
             update = update or dict()

classiq/interface/model/repeat.py

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING, Literal
 
-from classiq.interface.ast_node import ASTNodeType, without_statement_blocks
+from classiq.interface.ast_node import ASTNodeType, reset_lists
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.quantum_statement import QuantumOperation
 
@@ -16,4 +16,4 @@ class Repeat(QuantumOperation):
     body: "StatementBlock"
 
     def _as_back_ref(self: ASTNodeType) -> ASTNodeType:
-        return without_statement_blocks(self, ["body"])
+        return reset_lists(self, ["body"])

classiq/interface/model/statement_block.py

@@ -27,8 +27,8 @@ from classiq.interface.model.within_apply_operation import WithinApply
 
 ConcreteQuantumStatement = Annotated[
     Union[
-        Allocate,
         QuantumFunctionCall,
+        Allocate,
         ArithmeticOperation,
         AmplitudeLoadingOperation,
         VariableDeclarationStatement,

classiq/interface/model/within_apply_operation.py

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING, Literal
 
-from classiq.interface.ast_node import ASTNodeType, without_statement_blocks
+from classiq.interface.ast_node import ASTNodeType, reset_lists
 from classiq.interface.model.quantum_statement import QuantumOperation
 
 if TYPE_CHECKING:
@@ -14,4 +14,4 @@ class WithinApply(QuantumOperation):
     action: "StatementBlock"
 
     def _as_back_ref(self: ASTNodeType) -> ASTNodeType:
-        return without_statement_blocks(self, ["compute", "action"])
+        return reset_lists(self, ["compute", "action"])

classiq/interface/server/routes.py

@@ -7,9 +7,6 @@ PROVIDERS_PREFIX = "/providers"
 
 IQCC_PREFIX = PROVIDERS_PREFIX + "/iqcc"
 
-EXECUTION_NON_VERSIONED_PREFIX = "/execution/v1"
-SYNTHESIS_NON_VERSIONED_PREFIX = "/synthesis/v1"
-
 ANALYZER_CIRCUIT_PAGE = "circuit"
 DEFAULT_IDE_FE_APP = "https://platform.classiq.io/"
 
@@ -58,9 +55,6 @@ TASKS_GENERATE_FULL_PATH = TASKS_GENERATE_SUFFIX
 
 EXECUTION_JOBS_SUFFIX = "/jobs"
 EXECUTION_JOBS_FULL_PATH = EXECUTION_PREFIX + EXECUTION_JOBS_SUFFIX
-EXECUTION_JOBS_NON_VERSIONED_FULL_PATH = (
-    EXECUTION_NON_VERSIONED_PREFIX + EXECUTION_JOBS_SUFFIX
-)
 
 ANALYZER_FULL_PATH = ANALYZER_PREFIX + TASKS_SUFFIX
 ANALYZER_RB_FULL_PATH = ANALYZER_PREFIX + TASK_RB_SUFFIX

classiq/model_expansions/generative_functions.py

@@ -148,7 +148,8 @@ def emit_generative_statements(
     with _InterpreterExpandable(interpreter):
         set_frontend_interpreter(interpreter)
         for block_name, generative_function in operation.generative_blocks.items():
-            with interpreter._builder.block_context(
-                block_name
-            ), generative_mode_context(True):
+            with (
+                interpreter._builder.block_context(block_name),
+                generative_mode_context(True),
+            ):
                 generative_function._py_callable(*python_qmod_args)

classiq/model_expansions/interpreters/generative_interpreter.py

@@ -21,8 +21,11 @@ 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,
+from classiq.interface.model.quantum_expressions.amplitude_loading_operation import (
+    AmplitudeLoadingOperation,
+)
+from classiq.interface.model.quantum_expressions.arithmetic_operation import (
+    ArithmeticOperation,
 )
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_function_declaration import (
@@ -55,7 +58,17 @@ from classiq.model_expansions.quantum_operations import (
     VariableDeclarationStatementEmitter,
 )
 from classiq.model_expansions.quantum_operations.allocate import AllocateEmitter
-from classiq.model_expansions.quantum_operations.shallow_emitter import ShallowEmitter
+from classiq.model_expansions.quantum_operations.assignment_result_processor import (
+    AssignmentResultProcessor,
+)
+from classiq.model_expansions.quantum_operations.block_evaluator import BlockEvaluator
+from classiq.model_expansions.quantum_operations.composite_emitter import (
+    CompositeEmitter,
+)
+from classiq.model_expansions.quantum_operations.expression_evaluator import (
+    ExpressionEvaluator,
+)
+from classiq.model_expansions.quantum_operations.handle_evaluator import HandleEvaluator
 from classiq.model_expansions.scope import Evaluated, Scope
 from classiq.model_expansions.scope_initialization import (
     add_constants_to_scope,
@@ -134,15 +147,39 @@ class GenerativeInterpreter(BaseInterpreter):
         BindEmitter(self).emit(bind)
 
     @emit.register
-    def emit_quantum_assignment_operation(self, op: QuantumAssignmentOperation) -> None:
-        ShallowEmitter(
-            self, "assignment_operation", components=["expression", "result_var"]
+    def emit_amplitude_loading_operation(self, op: AmplitudeLoadingOperation) -> None:
+        CompositeEmitter[AmplitudeLoadingOperation](
+            self,
+            [
+                HandleEvaluator(self, "result_var"),
+                ExpressionEvaluator(self, "expression"),
+                AssignmentResultProcessor(self),
+            ],
+        ).emit(op)
+
+    @emit.register
+    def _emit_arithmetic_operation(self, op: ArithmeticOperation) -> None:
+        self.emit_arithmetic_operation(op)
+
+    def emit_arithmetic_operation(self, op: ArithmeticOperation) -> None:
+        CompositeEmitter[ArithmeticOperation](
+            self,
+            [
+                HandleEvaluator(self, "result_var"),
+                ExpressionEvaluator(self, "expression"),
+                AssignmentResultProcessor(self),
+            ],
         ).emit(op)
 
     @emit.register
     def emit_inplace_binary_operation(self, op: InplaceBinaryOperation) -> None:
-        ShallowEmitter(
-            self, "inplace_binary_operation", components=["target", "value"]
+        CompositeEmitter[InplaceBinaryOperation](
+            self,
+            [
+                HandleEvaluator(self, "target"),
+                HandleEvaluator(self, "value"),
+                ExpressionEvaluator(self, "value"),
+            ],
         ).emit(op)
 
     @emit.register
@@ -157,37 +194,60 @@ class GenerativeInterpreter(BaseInterpreter):
 
     @emit.register
     def emit_within_apply(self, within_apply: WithinApply) -> None:
-        ShallowEmitter(
+        BlockEvaluator(
             self,
             WITHIN_APPLY_NAME,
-            components=["within", "apply", "compute", "action"],
+            "within",
+            "apply",
+            "compute",
+            "action",
         ).emit(within_apply)
 
     @emit.register
     def emit_invert(self, invert: Invert) -> None:
-        ShallowEmitter(self, INVERT_OPERATOR_NAME, components=["body"]).emit(invert)
+        BlockEvaluator(self, INVERT_OPERATOR_NAME, "body").emit(invert)
 
     @emit.register
     def emit_repeat(self, repeat: Repeat) -> None:
         RepeatEmitter(self).emit(repeat)
 
     @emit.register
+    def _emit_control(self, control: Control) -> None:
+        self.emit_control(control)
+
     def emit_control(self, control: Control) -> None:
-        ShallowEmitter(
+        CompositeEmitter[Control](
             self,
-            CONTROL_OPERATOR_NAME,
-            components=["expression", "body", "else_block"],
+            [
+                ExpressionEvaluator(self, "expression"),
+                BlockEvaluator(
+                    self,
+                    CONTROL_OPERATOR_NAME,
+                    "body",
+                    "else_block",
+                ),
+            ],
         ).emit(control)
 
     @emit.register
     def emit_power(self, power: Power) -> None:
-        ShallowEmitter(self, CONTROL_OPERATOR_NAME, components=["power", "body"]).emit(
-            power
-        )
+        CompositeEmitter[Power](
+            self,
+            [
+                ExpressionEvaluator(self, "power"),
+                BlockEvaluator(self, CONTROL_OPERATOR_NAME, "body"),
+            ],
+        ).emit(power)
 
     @emit.register
     def emit_phase(self, phase: PhaseOperation) -> None:
-        ShallowEmitter(self, "phase", components=["expression", "theta"]).emit(phase)
+        CompositeEmitter[PhaseOperation](
+            self,
+            [
+                ExpressionEvaluator(self, "expression"),
+                ExpressionEvaluator(self, "theta"),
+            ],
+        ).emit(phase)
 
     def _expand_body(self, operation: Closure) -> None:
         if isinstance(operation, FunctionClosure) and operation.name == "permute":

classiq/model_expansions/quantum_operations/allocate.py

@@ -12,7 +12,7 @@ from classiq.model_expansions.scope import QuantumSymbol
 
 
 class AllocateEmitter(Emitter[Allocate]):
-    def emit(self, allocate: Allocate, /) -> None:
+    def emit(self, allocate: Allocate, /) -> bool:
         target: QuantumSymbol = self._interpreter.evaluate(allocate.target).as_type(
             QuantumSymbol
         )
@@ -32,6 +32,7 @@ class AllocateEmitter(Emitter[Allocate]):
         )
         self._register_debug_info(allocate)
         self.emit_statement(allocate)
+        return True
 
     def _get_var_size(self, target: QuantumSymbol, size: Expression | None) -> int:
         if size is None:
@@ -70,4 +71,5 @@ class AllocateEmitter(Emitter[Allocate]):
             level=OperationLevel.QMOD_STATEMENT,
             is_allocate_or_free=True,
             port_to_passed_variable_map={"ARG": str(allocate.target)},
+            node=allocate._as_back_ref(),
         )

classiq/model_expansions/quantum_operations/assignment_result_processor.py

@@ -0,0 +1,52 @@
+from classiq.interface.generator.arith.arithmetic import compute_arithmetic_result_type
+from classiq.interface.generator.functions.port_declaration import (
+    PortDeclarationDirection,
+)
+from classiq.interface.model.quantum_expressions.arithmetic_operation import (
+    ArithmeticOperation,
+    ArithmeticOperationKind,
+)
+from classiq.interface.model.quantum_expressions.quantum_expression import (
+    QuantumAssignmentOperation,
+)
+
+from classiq.model_expansions.evaluators.quantum_type_utils import copy_type_information
+from classiq.model_expansions.quantum_operations.emitter import Emitter
+from classiq.model_expansions.scope import QuantumSymbol
+from classiq.model_expansions.transformers.ast_renamer import rename_variables
+
+
+class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
+    def emit(self, op: QuantumAssignmentOperation, /) -> bool:
+        if (
+            isinstance(op, ArithmeticOperation)
+            and op.operation_kind == ArithmeticOperationKind.Assignment
+        ):
+            direction = PortDeclarationDirection.Output
+            self._update_result_type(op)
+        else:
+            direction = PortDeclarationDirection.Inout
+        self._capture_handle(op.result_var, direction)
+        return False
+
+    def _update_result_type(self, op: ArithmeticOperation) -> None:
+        expr = self._evaluate_expression(op.expression)
+        symbols = self._get_symbols_in_expression(expr)
+        expr_str = rename_variables(
+            expr.expr,
+            {str(symbol.handle): symbol.handle.identifier for symbol in symbols}
+            | {symbol.handle.qmod_expr: symbol.handle.identifier for symbol in symbols},
+        )
+        for symbol in symbols:
+            expr_str = expr_str.replace(
+                symbol.handle.qmod_expr, symbol.handle.identifier
+            )
+        result_type = compute_arithmetic_result_type(
+            expr_str,
+            {symbol.handle.identifier: symbol.quantum_type for symbol in symbols},
+            self._machine_precision,
+        )
+        result_symbol = self._interpreter.evaluate(op.result_var).as_type(QuantumSymbol)
+        copy_type_information(
+            result_type, result_symbol.quantum_type, str(op.result_var)
+        )