classiq 0.83.0__py3-none-any.whl → 0.85.0__py3-none-any.whl

classiq/interface/ide/visual_model.py

@@ -1,5 +1,8 @@
+import json
 from collections import Counter
+from collections.abc import Iterator
 from functools import cached_property
+from itertools import count
 from typing import Any, Optional
 
 import pydantic
@@ -13,6 +16,26 @@ from classiq.interface.generator.hardware.hardware_data import SynthesisHardware
 from classiq.interface.helpers.versioned_model import VersionedModel
 
 
+class OperationIdCounter:
+    _op_id_counter: Iterator[int] = count()
+
+    def next_id(self) -> int:
+        return next(self._op_id_counter)
+
+    def reset_operation_counter(self) -> None:
+        self._op_id_counter = count()
+
+
+_operation_id_counter = OperationIdCounter()
+
+
+def reset_operation_counter() -> None:
+    """
+    Call this at the start of every new task to restart ids at 0.
+    """
+    _operation_id_counter.reset_operation_counter()
+
+
 class OperationType(StrEnum):
     REGULAR = "REGULAR"
     INVISIBLE = "INVISIBLE"
@@ -108,9 +131,12 @@ class AtomicGate(StrEnum):
 
 class Operation(pydantic.BaseModel):
     name: str
+    _id: int = pydantic.PrivateAttr(default_factory=_operation_id_counter.next_id)
     qasm_name: str = pydantic.Field(default="")
     details: str = pydantic.Field(default="")
-    children: list["Operation"]
+    children: list["Operation"] = pydantic.Field(default_factory=list)
+    # children_ids is optional in order to support backwards compatibility.
+    children_ids: list[int] = pydantic.Field(default_factory=list)
     operation_data: Optional[OperationData] = None
     operation_links: OperationLinks
     control_qubits: tuple[int, ...] = pydantic.Field(default_factory=tuple)
@@ -118,7 +144,7 @@ class Operation(pydantic.BaseModel):
     target_qubits: tuple[int, ...]
     operation_level: OperationLevel
     operation_type: OperationType = pydantic.Field(
-        description="Identifies unique operations that are visualized differently"
+        description="Identifies unique operations that are visualized differently",
     )
     gate: AtomicGate = pydantic.Field(
         default=AtomicGate.UNKNOWN, description="Gate type"
@@ -127,7 +153,46 @@ class Operation(pydantic.BaseModel):
     expanded: bool = pydantic.Field(default=False)
     show_expanded_label: bool = pydantic.Field(default=False)
 
+    @property
+    def id(self) -> int:
+        return self._id
+
+    def __hash__(self) -> int:
+        """
+        using a custom hashable_dict in order to compare the operation
+        with the qubits in order
+        """
+        js = json.dumps(
+            self._hashable_dict(),
+            sort_keys=True,
+            default=lambda o: o.value if hasattr(o, "value") else str(o),
+        )
+        return hash(js)
+
+    def __eq__(self, other: object) -> bool:
+        return (
+            isinstance(other, Operation)
+            and self._hashable_dict() == other._hashable_dict()
+        )
+
+    def _hashable_dict(self) -> dict:
+        data = self.model_dump(
+            exclude_none=True,
+        )
+        # force qubit order for equality
+        for key in ("target_qubits", "auxiliary_qubits", "control_qubits"):
+            data[key] = sorted(data[key])
+        return data
+
 
 class ProgramVisualModel(VersionedModel):
-    main_operation: Operation
+    main_operation: Operation = pydantic.Field(default=None)
+    id_to_operations: dict[int, Operation] = pydantic.Field(default_factory=dict)
+    main_operation_id: int = pydantic.Field(default=None)
     program_data: ProgramData
+
+    @property
+    def main_op_from_mapping(self) -> Operation:
+        if self.main_operation_id is None:
+            raise ValueError("Main operation ID is not set.")
+        return self.id_to_operations[self.main_operation_id]

classiq/interface/model/bounds.py

@@ -1,6 +1,6 @@
 from typing import Literal, Optional
 
-from classiq.interface.helpers.custom_pydantic_types import PydanticFloatTuple
+from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.handle_binding import ConcreteHandleBinding
 from classiq.interface.model.quantum_statement import QuantumOperation
 
@@ -9,4 +9,14 @@ class SetBoundsStatement(QuantumOperation):
     kind: Literal["SetBoundsStatement"]
 
     target: ConcreteHandleBinding
-    bounds: Optional[PydanticFloatTuple]
+    lower_bound: Optional[Expression]
+    upper_bound: Optional[Expression]
+
+    @property
+    def expressions(self) -> list[Expression]:
+        exprs = []
+        if self.lower_bound is not None:
+            exprs.append(self.lower_bound)
+        if self.upper_bound is not None:
+            exprs.append(self.upper_bound)
+        return exprs

classiq/interface/model/model.py

@@ -185,11 +185,16 @@ class Model(VersionedModel, ASTNode):
         return constants
 
     def dump_no_metadata(self) -> dict[str, Any]:
-        return self.model_dump(
-            exclude={
-                "constraints",
-                "execution_preferences",
-                "preferences",
-                "functions_compilation_metadata",
-            },
+        compilation_metadata_with_unchecked = {
+            name: CompilationMetadata(unchecked=comp_metadata.unchecked)
+            for name, comp_metadata in self.functions_compilation_metadata.items()
+            if len(comp_metadata.unchecked) > 0
+        }
+        model = self.model_copy(
+            update={
+                "functions_compilation_metadata": compilation_metadata_with_unchecked,
+            }
+        )
+        return model.model_dump(
+            exclude={"constraints", "execution_preferences", "preferences"},
         )

classiq/interface/model/port_declaration.py

@@ -1,4 +1,4 @@
-from typing import Any, Literal, Optional
+from typing import Any, Literal
 
 import pydantic
 from pydantic_core.core_schema import ValidationInfo
@@ -10,7 +10,6 @@ from classiq.interface.generator.functions.port_declaration import (
 )
 from classiq.interface.generator.functions.type_modifier import (
     TypeModifier,
-    TypeQualifier,
 )
 from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
 from classiq.interface.model.parameter import Parameter
@@ -19,35 +18,14 @@ from classiq.interface.model.parameter import Parameter
 class AnonPortDeclaration(Parameter):
     quantum_type: ConcreteQuantumType
     direction: PortDeclarationDirection
-    type_qualifier: Optional[TypeQualifier] = pydantic.Field(
-        default=None, exclude=True
-    )  # TODO remove after BWC breaking release https://classiq.atlassian.net/browse/CLS-2777
     kind: Literal["PortDeclaration"]
-    type_modifier: TypeModifier = pydantic.Field(default=None)
+    type_modifier: TypeModifier
 
     @pydantic.model_validator(mode="before")
     @classmethod
     def _set_kind(cls, values: Any) -> dict[str, Any]:
         return values_with_discriminator(values, "kind", "PortDeclaration")
 
-    @pydantic.model_validator(mode="before")
-    @classmethod
-    def _set_type_modifier(cls, values: Any) -> dict[str, Any]:
-        if values.get("type_modifier") is None:
-            type_qualifier = values.get("type_qualifier")
-            if type_qualifier is not None:
-                if isinstance(type_qualifier, TypeQualifier):
-                    values["type_modifier"] = type_qualifier.to_modifier()
-                elif isinstance(type_qualifier, str):
-                    values["type_modifier"] = TypeQualifier(
-                        type_qualifier
-                    ).to_modifier()
-                else:
-                    raise pydantic.ValidationError("Missing a type modifier")
-            else:
-                raise pydantic.ValidationError("Missing a type modifier")
-        return values
-
     @pydantic.field_validator("direction", mode="before")
     @classmethod
     def _direction_validator(

classiq/interface/model/quantum_expressions/arithmetic_operation.py

@@ -1,6 +1,8 @@
 from collections.abc import Mapping, Sequence
 from typing import Literal
 
+from pydantic import PrivateAttr
+
 from classiq.interface.enum_utils import StrEnum
 from classiq.interface.generator.arith.arithmetic import (
     ARITHMETIC_EXPRESSION_RESULT_NAME,
@@ -27,6 +29,7 @@ class ArithmeticOperation(QuantumAssignmentOperation):
     kind: Literal["ArithmeticOperation"]
 
     operation_kind: ArithmeticOperationKind
+    _classical_assignment: bool = PrivateAttr(default=False)
 
     @property
     def is_inplace(self) -> bool:
@@ -50,7 +53,7 @@ class ArithmeticOperation(QuantumAssignmentOperation):
         self,
     ) -> Mapping[str, ConcreteHandleBinding]:
         inouts = dict(super().wiring_inouts)
-        if self.is_inplace:
+        if self.is_inplace and not self._classical_assignment:
             inouts[self.result_name()] = self.result_var
         return inouts
 
@@ -60,7 +63,7 @@ class ArithmeticOperation(QuantumAssignmentOperation):
             HandleMetadata(handle=handle, readable_location="in an expression")
             for handle in self.var_handles
         ]
-        if self.is_inplace:
+        if self.is_inplace and not self._classical_assignment:
             inouts.append(
                 HandleMetadata(
                     handle=self.result_var,
@@ -71,13 +74,13 @@ class ArithmeticOperation(QuantumAssignmentOperation):
 
     @property
     def wiring_outputs(self) -> Mapping[str, HandleBinding]:
-        if self.is_inplace:
+        if self.is_inplace or self._classical_assignment:
             return {}
         return super().wiring_outputs
 
     @property
     def readable_outputs(self) -> Sequence[HandleMetadata]:
-        if self.is_inplace:
+        if self.is_inplace or self._classical_assignment:
             return []
         return [
             HandleMetadata(

classiq/interface/model/variable_declaration_statement.py

@@ -1,15 +1,42 @@
-from typing import Literal
+from typing import Any, Literal, Optional
+
+import pydantic
 
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.model.quantum_statement import QuantumStatement
-from classiq.interface.model.quantum_variable_declaration import (
-    QuantumVariableDeclaration,
+from classiq.interface.generator.functions.concrete_types import (
+    ConcreteQuantumType,
+    ConcreteType,
 )
+from classiq.interface.model.quantum_statement import QuantumStatement
+from classiq.interface.model.quantum_type import QuantumType
 
 
-class VariableDeclarationStatement(QuantumStatement, QuantumVariableDeclaration):
+class VariableDeclarationStatement(QuantumStatement):
     kind: Literal["VariableDeclarationStatement"]
 
+    name: str
+    quantum_type: Optional[ConcreteQuantumType] = None
+    qmod_type: ConcreteType
+
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _set_qmod_type(cls, values: Any) -> dict[str, Any]:
+        if isinstance(values, dict):
+            if "quantum_type" in values and (
+                "qmod_type" not in values or values["qmod_type"] is None
+            ):
+                values["qmod_type"] = values["quantum_type"]
+                values["quantum_type"] = None
+            return values
+        if values.quantum_type is not None and values.qmod_type is None:
+            values.qmod_type = values.quantum_type
+            values.quantum_type = None
+        return values
+
     @property
     def expressions(self) -> list[Expression]:
-        return self.quantum_type.expressions
+        return self.qmod_type.expressions
+
+    @property
+    def is_quantum(self) -> bool:
+        return isinstance(self.qmod_type, QuantumType)

classiq/{qmod/native → interface/pretty_print}/expression_to_qmod.py

@@ -6,7 +6,7 @@ from typing import Callable, Optional
 
 import numpy as np
 
-from classiq.qmod.utilities import DEFAULT_DECIMAL_PRECISION
+from classiq.interface.constants import DEFAULT_DECIMAL_PRECISION
 
 IDENTIFIER = re.compile(r"[a-zA-Z_]\w*")
 BINARY_OPS: Mapping[type[ast.operator], str] = {
@@ -40,6 +40,10 @@ COMPARE_OPS: Mapping[type[ast.cmpop], str] = {
 LIST_FORMAT_CHAR_LIMIT = 20
 
 
+class PrettyPrinterError(AssertionError):
+    pass
+
+
 @dataclass
 class ASTToQMODCode:
     level: int
@@ -59,10 +63,13 @@ class ASTToQMODCode:
         elif isinstance(node, ast.Attribute):
             # Enum attribute access
             if not isinstance(node.value, ast.Name) or not isinstance(node.attr, str):
-                raise AssertionError("Error parsing enum attribute access")
+                raise PrettyPrinterError("Error parsing enum attribute access")
             if not (IDENTIFIER.match(node.value.id) and IDENTIFIER.match(node.attr)):
-                raise AssertionError("Error parsing enum attribute access")
-            return f"{node.value.id!s}::{node.attr!s}"
+                raise PrettyPrinterError("Error parsing enum attribute access")
+            # FIXME: identify enum member accesses by type name (CLS-2858)
+            if len(node.value.id) > 0 and node.value.id[0].isupper():
+                return f"{node.value.id!s}::{node.attr!s}"
+            return f"{node.value.id!s}.{node.attr!s}"
         elif isinstance(node, ast.Name):
             return node.id
         elif isinstance(node, ast.Num):
@@ -91,7 +98,7 @@ class ASTToQMODCode:
             )
         elif isinstance(node, ast.Compare):
             if len(node.ops) != 1 or len(node.comparators) != 1:
-                raise AssertionError("Error parsing comparison expression.")
+                raise PrettyPrinterError("Error parsing comparison expression.")
             return "({} {} {})".format(
                 self.ast_to_code(node.left),
                 COMPARE_OPS[type(node.ops[0])],
@@ -108,20 +115,20 @@ class ASTToQMODCode:
         elif isinstance(node, ast.Slice):
             # A QMOD expression does not support slice step
             if node.lower is None or node.upper is None or node.step is not None:
-                raise AssertionError("Error parsing slice expression.")
+                raise PrettyPrinterError("Error parsing slice expression.")
             return f"{self.ast_to_code(node.lower)}:{self.ast_to_code(node.upper)}"
         elif isinstance(node, ast.Call):
             func = self.ast_to_code(node.func)
             if func == "get_field":
                 if len(node.args) != 2:
-                    raise AssertionError("Error parsing struct field access.")
+                    raise PrettyPrinterError("Error parsing struct field access.")
                 field = str(self.ast_to_code(node.args[1])).replace("'", "")
                 if not IDENTIFIER.match(field):
-                    raise AssertionError("Error parsing struct field access.")
+                    raise PrettyPrinterError("Error parsing struct field access.")
                 return f"{self.ast_to_code(node.args[0])}.{field}"
             elif func == "struct_literal":
                 if len(node.args) != 1 or not isinstance(node.args[0], ast.Name):
-                    raise AssertionError("Error parsing struct literal.")
+                    raise PrettyPrinterError("Error parsing struct literal.")
                 keywords = node.keywords
                 initializer_list = self.indent_items(
                     lambda: [
@@ -133,7 +140,7 @@ class ASTToQMODCode:
                 return f"{self.ast_to_code(node.args[0])} {{{initializer_list}}}"
             elif func == "do_subscript":
                 if len(node.args) != 2:
-                    raise AssertionError("Error parsing array access.")
+                    raise PrettyPrinterError("Error parsing array access.")
                 return f"{self.ast_to_code(node.args[0])}[{self.ast_to_code(node.args[1])}]"
             else:
                 return "{}({})".format(
@@ -142,7 +149,7 @@ class ASTToQMODCode:
         elif isinstance(node, ast.Expr):
             return self._cleaned_ast_to_code(node.value)
         else:
-            raise AssertionError("Error parsing expression: unsupported AST node.")
+            raise PrettyPrinterError("Error parsing expression: unsupported AST node.")
 
     def indent_items(self, items: Callable[[], list[str]]) -> str:
         should_indent = (

classiq/interface/server/routes.py

@@ -91,3 +91,7 @@ IQCC_LIST_AUTH_TARGETS_FULL_PATH = IQCC_PREFIX + IQCC_LIST_AUTH_TARGETS_SUFFIX
 
 USER_BUDGETS_SUFFIX = "/all"
 USER_BUDGETS_FULL_PATH = USER_BUDGETS_PREFIX + USER_BUDGETS_SUFFIX
+USER_BUDGET_SET_LIMIT_SUFFIX = "/set_limit"
+USER_BUDGET_SET_LIMIT_FULL_PATH = USER_BUDGETS_PREFIX + USER_BUDGET_SET_LIMIT_SUFFIX
+USER_BUDGET_CLEAR_LIMIT_SUFFIX = "/clear_limit"
+USER_BUDGET_CLEAR_LIMIT_FULL_PATH = USER_BUDGETS_PREFIX + USER_BUDGET_CLEAR_LIMIT_SUFFIX

classiq/model_expansions/atomic_expression_functions_defs.py

@@ -9,6 +9,9 @@ from classiq.interface.exceptions import (
     ClassiqExpansionError,
     ClassiqInternalExpansionError,
 )
+from classiq.interface.generator.expressions.atomic_expression_functions import (
+    MEASUREMENT_FUNCTIONS,
+)
 from classiq.interface.generator.expressions.expression_types import (
     ExpressionValue,
     QmodStructInstance,
@@ -39,7 +42,6 @@ from classiq.interface.generator.functions.classical_function_declaration import
 from classiq.interface.generator.functions.classical_type import (
     Bool,
     ClassicalArray,
-    ClassicalList,
     ClassicalTuple,
     ClassicalType,
     OpaqueHandle,
@@ -91,7 +93,7 @@ def qmod_val_to_python(val: ExpressionValue, qmod_type: ClassicalType) -> Any:
         if isinstance(val, (Enum, int)):
             return val
 
-    elif isinstance(qmod_type, (ClassicalArray, ClassicalList)):
+    elif isinstance(qmod_type, ClassicalArray):
         if isinstance(val, list):
             return [qmod_val_to_python(elem, qmod_type.element_type) for elem in val]
 
@@ -145,9 +147,9 @@ def python_val_to_qmod(val: Any, qmod_type: ClassicalType) -> ExpressionValue:
             field_name: python_val_to_qmod(val[field_name], field_type)
             for field_name, field_type in struct_decl.variables.items()
         }
-        return QmodStructInstance(struct_decl.model_copy(), qmod_dict)
+        return QmodStructInstance(struct_decl.model_copy(deep=True), qmod_dict)
 
-    if isinstance(qmod_type, (ClassicalList, ClassicalArray)):
+    if isinstance(qmod_type, ClassicalArray):
         if not isinstance(val, list):
             raise ClassiqInternalExpansionError("Bad value for list")
         return [python_val_to_qmod(elem, qmod_type.element_type) for elem in val]
@@ -182,7 +184,7 @@ def python_call_wrapper(func: Callable, *args: ExpressionValue) -> Any:
 
 def struct_literal(struct_type_symbol: Symbol, **kwargs: Any) -> QmodStructInstance:
     return QmodStructInstance(
-        QMODULE.type_decls[struct_type_symbol.name].model_copy(),
+        QMODULE.type_decls[struct_type_symbol.name].model_copy(deep=True),
         {field: sympy_to_python(field_value) for field, field_value in kwargs.items()},
     )
 
@@ -330,6 +332,40 @@ def mod_inverse(a: Any, b: Any) -> Any:
     return sympy.mod_inverse(a, b)
 
 
+def min_wrapper(*vals: Any) -> Any:
+    try:
+        return sympy.Min(*vals)
+    except ValueError:
+        return AnyClassicalValue(f"Min({', '.join(map(str, vals))})")
+
+
+min_wrapper.__name__ = "min"
+
+
+def Min_wrapper(*vals: Any) -> Any:  # noqa: N802
+    return min_wrapper(*vals)
+
+
+Min_wrapper.__name__ = "Min"
+
+
+def max_wrapper(*vals: Any) -> Any:
+    try:
+        return sympy.Max(*vals)
+    except ValueError:
+        return AnyClassicalValue(f"Max({', '.join(map(str, vals))})")
+
+
+max_wrapper.__name__ = "max"
+
+
+def Max_wrapper(*vals: Any) -> Any:  # noqa: N802
+    return max_wrapper(*vals)
+
+
+Max_wrapper.__name__ = "Max"
+
+
 CORE_LIB_FUNCTIONS_LIST: list[Callable] = [
     print,
     do_sum,
@@ -347,6 +383,10 @@ CORE_LIB_FUNCTIONS_LIST: list[Callable] = [
     RShift,
     LShift,
     mod_inverse,
+    min_wrapper,
+    Min_wrapper,
+    max_wrapper,
+    Max_wrapper,
 ]
 
 
@@ -361,7 +401,8 @@ def _symbolic_function(func: str) -> Callable:
 
 
 QMOD_CLASSICAL_FUNCTIONS = [
-    _symbolic_function(func) for func in qmod_classical_functions
+    _symbolic_function(func)
+    for func in qmod_classical_functions + list(MEASUREMENT_FUNCTIONS)
 ]
 
 ATOMIC_EXPRESSION_FUNCTIONS = {

classiq/model_expansions/function_builder.py

@@ -9,6 +9,7 @@ from classiq.interface.generator.compiler_keywords import (
     LAMBDA_KEYWORD,
 )
 from classiq.interface.generator.functions.builtins.internal_operators import (
+    BLOCK_OPERATOR_NAME,
     WITHIN_APPLY_NAME,
 )
 from classiq.interface.model.model import MAIN_FUNCTION_NAME
@@ -35,6 +36,8 @@ from classiq.model_expansions.utils.counted_name_allocator import CountedNameAll
 
 ClosureType = TypeVar("ClosureType", bound=Closure)
 
+BLOCKS_ALLOWED_CAPTURING = (WITHIN_APPLY_NAME, BLOCK_OPERATOR_NAME)
+
 
 @dataclass
 class Block:
@@ -142,7 +145,7 @@ class OperationBuilder:
         captured_vars = self.current_block.captured_vars
         if (
             not isinstance(self.current_operation, FunctionClosure)
-            and self.current_operation.name != WITHIN_APPLY_NAME
+            and self.current_operation.name not in BLOCKS_ALLOWED_CAPTURING
         ):
             validate_captured_directions(
                 captured_vars.filter_var_decls(

classiq/model_expansions/interpreters/base_interpreter.py

@@ -39,14 +39,14 @@ from classiq.interface.model.quantum_lambda_function import (
 )
 from classiq.interface.model.quantum_statement import QuantumStatement
 
+from classiq.evaluators.classical_expression import (
+    evaluate_classical_expression,
+)
 from classiq.model_expansions.closure import (
     Closure,
     FunctionClosure,
 )
 from classiq.model_expansions.debug_flag import debug_mode
-from classiq.model_expansions.evaluators.classical_expression import (
-    evaluate_classical_expression,
-)
 from classiq.model_expansions.function_builder import (
     FunctionContext,
     OperationBuilder,

classiq/model_expansions/interpreters/generative_interpreter.py

@@ -7,6 +7,7 @@ from numpy.random import permutation
 from classiq.interface.generator.constant import Constant
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.builtins.internal_operators import (
+    BLOCK_OPERATOR_NAME,
     CLASSICAL_IF_OPERATOR_NAME,
     CONTROL_OPERATOR_NAME,
     INVERT_OPERATOR_NAME,
@@ -15,6 +16,7 @@ from classiq.interface.generator.functions.builtins.internal_operators import (
 )
 from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.block import Block
 from classiq.interface.model.bounds import SetBoundsStatement
 from classiq.interface.model.classical_if import ClassicalIf
 from classiq.interface.model.control import Control
@@ -68,6 +70,9 @@ from classiq.model_expansions.quantum_operations.block_evaluator import (
     RepeatElimination,
 )
 from classiq.model_expansions.quantum_operations.bounds import SetBoundsEmitter
+from classiq.model_expansions.quantum_operations.classical_var_emitter import (
+    ClassicalVarEmitter,
+)
 from classiq.model_expansions.quantum_operations.composite_emitter import (
     CompositeEmitter,
 )
@@ -192,6 +197,7 @@ class GenerativeInterpreter(BaseInterpreter):
             [
                 HandleEvaluator(self, "result_var"),
                 ExpressionEvaluator(self, "expression"),
+                ClassicalVarEmitter(self),
                 AssignmentResultProcessor(self),
             ],
         ).emit(op)
@@ -303,9 +309,18 @@ class GenerativeInterpreter(BaseInterpreter):
     def emit_set_bounds(self, op: SetBoundsStatement) -> None:
         CompositeEmitter[SetBoundsStatement](
             self,
-            [HandleEvaluator(self, "target"), SetBoundsEmitter(self)],
+            [
+                ExpressionEvaluator(self, "lower_bound"),
+                ExpressionEvaluator(self, "upper_bound"),
+                HandleEvaluator(self, "target"),
+                SetBoundsEmitter(self),
+            ],
         ).emit(op)
 
+    @emit.register
+    def emit_block(self, block: Block) -> None:
+        BlockEvaluator(self, BLOCK_OPERATOR_NAME, "statements").emit(block)
+
     def _expand_body(self, operation: Closure) -> None:
         if isinstance(operation, FunctionClosure) and operation.name == "permute":
             # special expansion since permute is generative

classiq/model_expansions/quantum_operations/allocate.py

@@ -12,7 +12,7 @@ from classiq.interface.model.quantum_type import (
     QuantumNumeric,
 )
 
-from classiq.model_expansions.evaluators.quantum_type_utils import copy_type_information
+from classiq.evaluators.quantum_type_utils import copy_type_information
 from classiq.model_expansions.quantum_operations.emitter import Emitter
 from classiq.model_expansions.scope import QuantumSymbol