classiq 0.68.0__py3-none-any.whl → 0.70.0__py3-none-any.whl

classiq/interface/model/quantum_type.py

@@ -11,13 +11,17 @@ from classiq.interface.generator.arith.register_user_input import (
     RegisterUserInput,
 )
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.expressions.qmod_qarray_proxy import QmodQArrayProxy
-from classiq.interface.generator.expressions.qmod_qscalar_proxy import (
+from classiq.interface.generator.expressions.proxies.quantum.qmod_qarray_proxy import (
+    QmodQArrayProxy,
+)
+from classiq.interface.generator.expressions.proxies.quantum.qmod_qscalar_proxy import (
     QmodQBitProxy,
     QmodQNumProxy,
     QmodQScalarProxy,
 )
-from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
+from classiq.interface.generator.expressions.proxies.quantum.qmod_sized_proxy import (
+    QmodSizedProxy,
+)
 from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
 from classiq.interface.model.handle_binding import HandleBinding
 
@@ -213,6 +217,14 @@ class QuantumNumeric(QuantumScalar):
             0 if self.fraction_digits is None else self.fraction_digits.to_int_value()
         )
 
+    @property
+    def is_qbit(self) -> bool:
+        return (
+            self.size_in_bits == 1
+            and self.fraction_digits_value == 0
+            and not self.sign_value
+        )
+
     def _update_size_in_bits_from_declaration(self) -> None:
         if self.size is not None and self.size.is_evaluated():
             self._size_in_bits = self.size.to_int_value()

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/atomic_expression_functions_defs.py

@@ -12,9 +12,15 @@ from classiq.interface.generator.expressions.expression_types import (
     ExpressionValue,
     QmodStructInstance,
 )
-from classiq.interface.generator.expressions.qmod_qscalar_proxy import QmodQNumProxy
-from classiq.interface.generator.expressions.qmod_qstruct_proxy import QmodQStructProxy
-from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
+from classiq.interface.generator.expressions.proxies.quantum.qmod_qscalar_proxy import (
+    QmodQNumProxy,
+)
+from classiq.interface.generator.expressions.proxies.quantum.qmod_qstruct_proxy import (
+    QmodQStructProxy,
+)
+from classiq.interface.generator.expressions.proxies.quantum.qmod_sized_proxy import (
+    QmodSizedProxy,
+)
 from classiq.interface.generator.expressions.type_proxy import TypeProxy
 from classiq.interface.generator.functions.classical_function_declaration import (
     ClassicalFunctionDeclaration,

classiq/model_expansions/evaluators/arg_type_match.py

@@ -3,10 +3,12 @@ from enum import Enum
 from typing import Any
 
 from classiq.interface.exceptions import ClassiqExpansionError
-from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
-from classiq.interface.generator.expressions.qmod_struct_instance import (
+from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
     QmodStructInstance,
 )
+from classiq.interface.generator.expressions.proxies.quantum.qmod_sized_proxy import (
+    QmodSizedProxy,
+)
 from classiq.interface.generator.functions.classical_type import (
     StructMetaType,
 )

classiq/model_expansions/evaluators/classical_expression.py

@@ -23,13 +23,13 @@ def evaluate_classical_expression(expr: Expression, scope: Scope) -> Evaluated:
         )
         for name, evaluated in all_symbols
         if isinstance(evaluated.value, QuantumSymbol)
-        and evaluated.value.quantum_type.has_size_in_bits
+        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.has_size_in_bits
+        and not evaluated.value.quantum_type.is_evaluated
     }
 
     ret = evaluate(expr, locals_dict, uninitialized_locals)

classiq/model_expansions/evaluators/control.py

@@ -8,7 +8,7 @@ from classiq.interface.generator.arith.argument_utils import (
     unsigned_integer_interpretation,
 )
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
-from classiq.interface.generator.expressions.qmod_qscalar_proxy import (
+from classiq.interface.generator.expressions.proxies.quantum.qmod_qscalar_proxy import (
     QmodQNumProxy,
     QmodQScalarProxy,
     QmodSizedProxy,

classiq/model_expansions/evaluators/parameter_types.py

@@ -1,9 +1,10 @@
-from typing import Union
+from typing import TypeVar, Union
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
     ClassiqInternalExpansionError,
 )
+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,
@@ -31,8 +32,6 @@ from classiq.model_expansions.evaluators.classical_expression import (
 from classiq.model_expansions.evaluators.quantum_type_utils import (
     copy_type_information,
     set_element_type,
-    set_fraction_digits,
-    set_is_signed,
     set_length,
     set_size,
 )
@@ -162,9 +161,14 @@ def _evaluate_qarray_in_quantum_symbol(
     )
     set_element_type(type_to_update, new_element_type)
     if type_to_update.length is not None:
-        new_length = evaluate_classical_expression(
-            type_to_update.length, scope
-        ).as_type(int)
+        new_length = _eval_expr(
+            type_to_update.length,
+            scope,
+            int,
+            type_to_update.type_name,
+            "length",
+            param_name,
+        )
         set_length(type_to_update, new_length)
     return type_to_update
 
@@ -173,23 +177,61 @@ def _evaluate_qnum_in_quantum_symbol(
     type_to_update: QuantumNumeric, scope: Scope, param_name: str
 ) -> QuantumNumeric:
     if type_to_update.is_signed is not None:
-        new_is_sign = evaluate_classical_expression(
-            type_to_update.is_signed, scope
-        ).as_type(bool)
-        set_is_signed(type_to_update, new_is_sign, param_name)
+        new_is_sign = _eval_expr(
+            type_to_update.is_signed,
+            scope,
+            bool,
+            type_to_update.type_name,
+            "sign",
+            param_name,
+        )
+        type_to_update.is_signed = Expression(expr=str(new_is_sign))
     if type_to_update.fraction_digits is not None:
-        new_fraction_digits = evaluate_classical_expression(
-            type_to_update.fraction_digits, scope
-        ).as_type(int)
-        set_fraction_digits(type_to_update, new_fraction_digits, param_name)
+        new_fraction_digits = _eval_expr(
+            type_to_update.fraction_digits,
+            scope,
+            int,
+            type_to_update.type_name,
+            "fraction digits",
+            param_name,
+        )
+        type_to_update.fraction_digits = Expression(expr=str(new_fraction_digits))
     if type_to_update.size is not None:
-        new_size = evaluate_classical_expression(type_to_update.size, scope).as_type(
-            int
+        new_size = _eval_expr(
+            type_to_update.size,
+            scope,
+            int,
+            type_to_update.type_name,
+            "size",
+            param_name,
         )
         set_size(type_to_update, new_size, param_name)
     return type_to_update
 
 
+_EXPR_TYPE = TypeVar("_EXPR_TYPE")
+
+
+def _eval_expr(
+    expression: Expression,
+    scope: Scope,
+    expected_type: type[_EXPR_TYPE],
+    type_name: str,
+    attr_name: str,
+    param_name: str,
+) -> _EXPR_TYPE:
+    val = evaluate_classical_expression(expression, scope).value
+    if expected_type is int and isinstance(val, float):
+        val = int(val)
+    if not isinstance(val, expected_type):
+        raise ClassiqExpansionError(
+            f"When inferring the type of parameter {param_name!r}: "
+            f"{type_name} {attr_name} must be {expected_type.__name__}, got "
+            f"{str(val)!r}"
+        )
+    return val
+
+
 def _evaluate_qstruct_in_quantum_symbol(
     type_to_update: TypeName, scope: Scope, param_name: str
 ) -> TypeName:

classiq/model_expansions/evaluators/quantum_type_utils.py

@@ -1,5 +1,4 @@
 from collections.abc import Sequence
-from typing import Optional
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
@@ -33,12 +32,11 @@ def copy_type_information(
     if isinstance(to_type, QuantumBit):
         set_size(to_type, from_type.size_in_bits, to_param_name)
     elif isinstance(to_type, QuantumNumeric):
-        set_is_signed(to_type, getattr(from_type, "sign_value", None), to_param_name)
-        set_fraction_digits(
-            to_type,
-            getattr(from_type, "fraction_digits_value", None),
-            to_param_name,
-        )
+        if to_type.size is None and isinstance(from_type, QuantumNumeric):
+            to_type.is_signed = Expression(expr=str(from_type.sign_value))
+            to_type.fraction_digits = Expression(
+                expr=str(from_type.fraction_digits_value)
+            )
         set_size(to_type, from_type.size_in_bits, to_param_name)
     elif isinstance(to_type, QuantumBitvector):
         if isinstance(from_type, QuantumBitvector) and type(  # noqa: E721
@@ -73,8 +71,8 @@ def set_size(quantum_type: QuantumType, size: int, param_name: str) -> None:
     if isinstance(quantum_type, QuantumNumeric):
         quantum_type.size = Expression(expr=str(size))
         if not quantum_type.has_sign or not quantum_type.has_fraction_digits:
-            set_is_signed(quantum_type, False, param_name)
-            set_fraction_digits(quantum_type, 0, param_name)
+            quantum_type.is_signed = Expression(expr="False")
+            quantum_type.fraction_digits = Expression(expr="0")
     elif isinstance(quantum_type, QuantumBitvector):
         if quantum_type.has_length:
             if size % quantum_type.length_value != 0:
@@ -107,54 +105,6 @@ def set_size(quantum_type: QuantumType, size: int, param_name: str) -> None:
             set_size(fields_without_size[0], size - predetermined_size_part, param_name)
 
 
-def set_fraction_digits(
-    quantum_numeric: QuantumNumeric, fraction_digits: Optional[int], param_name: str
-) -> None:
-    if fraction_digits is not None and fraction_digits < 0:
-        raise ClassiqExpansionError(
-            f"Number of fraction digits for {param_name!r} was deduced to be negative: "
-            f"{fraction_digits!r}"
-        )
-
-    if (
-        fraction_digits is not None
-        and quantum_numeric.fraction_digits is not None
-        and quantum_numeric.fraction_digits.is_evaluated()
-        and quantum_numeric.fraction_digits_value != fraction_digits
-    ):
-        raise ClassiqExpansionError(
-            f"Fraction digits mismatch for variable {param_name!r} between declared "
-            f"fraction digits {quantum_numeric.fraction_digits_value!r} and assigned fraction "
-            f"digits {fraction_digits!r}"
-        )
-
-    if not (
-        quantum_numeric.fraction_digits is not None
-        and quantum_numeric.fraction_digits.is_evaluated()
-    ):
-        quantum_numeric.fraction_digits = Expression(expr=str(fraction_digits or 0))
-
-
-def set_is_signed(
-    quantum_numeric: QuantumNumeric, is_signed: Optional[bool], param_name: str
-) -> None:
-    if (
-        is_signed is not None
-        and quantum_numeric.is_signed is not None
-        and quantum_numeric.is_signed.is_evaluated()
-        and quantum_numeric.sign_value != is_signed
-    ):
-        raise ClassiqExpansionError(
-            f"Sign mismatch for variable {param_name!r} between declared sign {quantum_numeric.sign_value!r} and assigned sign {is_signed!r}"
-        )
-
-    if not (
-        quantum_numeric.is_signed is not None
-        and quantum_numeric.is_signed.is_evaluated()
-    ):
-        quantum_numeric.is_signed = Expression(expr=str(is_signed or False))
-
-
 def set_element_type(
     quantum_array: QuantumBitvector, element_type: ConcreteQuantumType
 ) -> None:

classiq/model_expansions/expression_evaluator.py

@@ -17,7 +17,9 @@ from classiq.interface.generator.expressions.expression_constants import (
 )
 from classiq.interface.generator.expressions.expression_types import ExpressionValue
 from classiq.interface.generator.expressions.non_symbolic_expr import NonSymbolicExpr
-from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
+from classiq.interface.generator.expressions.proxies.quantum.qmod_sized_proxy import (
+    QmodSizedProxy,
+)
 from classiq.interface.generator.expressions.sympy_supported_expressions import (
     SYMPY_SUPPORTED_EXPRESSIONS,
 )

classiq/model_expansions/generative_functions.py

@@ -1,10 +1,29 @@
 from collections.abc import Mapping
+from sys import exc_info
+from types import TracebackType
 from typing import TYPE_CHECKING, Any
 
-from classiq.interface.generator.expressions.qmod_struct_instance import (
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.generator.expressions.proxies.classical.classical_array_proxy import (
+    ClassicalArrayProxy,
+)
+from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
+    ClassicalProxy,
+)
+from classiq.interface.generator.expressions.proxies.classical.classical_scalar_proxy import (
+    ClassicalScalarProxy,
+)
+from classiq.interface.generator.expressions.proxies.classical.classical_struct_proxy import (
+    ClassicalStructProxy,
+)
+from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
     QmodStructInstance,
 )
-from classiq.interface.generator.functions.type_name import Struct
+from classiq.interface.generator.functions.classical_type import ClassicalArray
+from classiq.interface.generator.functions.type_name import Struct, TypeName
 from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.port_declaration import PortDeclaration
@@ -20,9 +39,10 @@ from classiq.model_expansions.closure import (
     GenerativeClosure,
 )
 from classiq.model_expansions.scope import Evaluated, QuantumSymbol
+from classiq.qmod.cparam import CParam
 from classiq.qmod.generative import generative_mode_context, set_frontend_interpreter
 from classiq.qmod.model_state_container import QMODULE
-from classiq.qmod.qmod_parameter import CParamStruct
+from classiq.qmod.qmod_parameter import CParamStruct, create_param
 from classiq.qmod.qmod_variable import QNum, _create_qvar_for_qtype
 from classiq.qmod.quantum_expandable import (
     QTerminalCallable,
@@ -37,6 +57,23 @@ if TYPE_CHECKING:
     )
 
 
+def _unwrap_traceback_frame(e: Exception) -> Exception:
+    fallback_error = ClassiqExpansionError(str(e))
+    traceback = exc_info()[2]
+    if traceback is None:
+        return fallback_error
+    back_frame = traceback.tb_frame.f_back
+    if back_frame is None:
+        return fallback_error
+    back_tb = TracebackType(
+        tb_next=None,
+        tb_frame=back_frame,
+        tb_lasti=back_frame.f_lasti,
+        tb_lineno=back_frame.f_lineno,
+    )
+    return e.with_traceback(back_tb)
+
+
 class LenList(list):
     @property
     def len(self) -> int:
@@ -45,7 +82,10 @@ class LenList(list):
     def __getitem__(self, item: Any) -> Any:
         if isinstance(item, QNum):
             return SymbolicExpr(f"{self}[{item}]", True)
-        return super().__getitem__(item)
+        try:
+            return super().__getitem__(item)
+        except (IndexError, TypeError) as e:
+            raise _unwrap_traceback_frame(e) from None
 
     @classmethod
     def wrap(cls, obj: Any) -> Any:
@@ -54,6 +94,22 @@ class LenList(list):
         return LenList([cls.wrap(item) for item in obj])
 
 
+def _create_qmod_classical_var(proxy: ClassicalProxy) -> CParam:
+    if isinstance(proxy, ClassicalScalarProxy):
+        classical_type = proxy._classical_type
+    elif isinstance(proxy, ClassicalArrayProxy):
+        classical_type = ClassicalArray(
+            element_type=proxy._element_type, size=proxy._length
+        )
+    elif isinstance(proxy, ClassicalStructProxy):
+        classical_type = TypeName(name=proxy._decl.name)
+    else:
+        raise ClassiqInternalExpansionError(
+            f"Unrecognized classical proxy {type(proxy).__name__}"
+        )
+    return create_param(str(proxy.handle), classical_type, QMODULE)
+
+
 def translate_ast_arg_to_python_qmod(param: PositionalArg, evaluated: Evaluated) -> Any:
     if isinstance(param, PortDeclaration):
         quantum_symbol = evaluated.as_type(QuantumSymbol)
@@ -90,6 +146,9 @@ def translate_ast_arg_to_python_qmod(param: PositionalArg, evaluated: Evaluated)
             struct_type=Struct(name=classical_value.struct_declaration.name),
             qmodule=QMODULE,
         )
+    if isinstance(classical_value, ClassicalProxy):
+        return _create_qmod_classical_var(classical_value)
+
     return LenList.wrap(classical_value)
 
 
@@ -148,7 +207,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/quantum_operations/arithmetic/explicit_boolean_expressions.py

@@ -0,0 +1,60 @@
+from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.generator.arith.arithmetic import is_bool
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.model.quantum_expressions.arithmetic_operation import (
+    ArithmeticOperation,
+    ArithmeticOperationKind,
+)
+from classiq.interface.model.quantum_type import QuantumBit, QuantumNumeric
+
+from classiq.model_expansions.scope import QuantumSymbol
+
+
+def validate_assignment_bool_expression(
+    result_symbol: QuantumSymbol, expr: str, op_kind: ArithmeticOperationKind
+) -> None:
+    if not is_bool(expr):
+        return
+    _validate_target_type(result_symbol, expr, op_kind)
+
+
+def _validate_target_type(
+    target_symbol: QuantumSymbol, expr: str, op_kind: ArithmeticOperationKind
+) -> None:
+    supported_types = _supported_types()
+    if target_symbol.quantum_type.qmod_type_name not in supported_types:
+        raise ClassiqValueError(
+            f'The expression has been evaluated to "{expr}" which is a Boolean value. '
+            f"Cannot perform {op_kind.value} operation of Boolean expression to result variable '{target_symbol.handle}' of type {target_symbol.quantum_type.qmod_type_name}. "
+            f"Boolean expressions can only be applied on {' or '.join(supported_types)}."
+        )
+
+
+def convert_assignment_bool_expression(op: ArithmeticOperation) -> None:
+    if not is_bool(op.expression.expr):
+        return
+    op.expression = op.expression.model_copy(
+        update=dict(expr="1" if op.expression.expr == "True" else "0")
+    )
+
+
+def convert_inplace_op_bool_expression(
+    op: ArithmeticOperation, target: QuantumSymbol
+) -> None:
+    if not is_bool(op.expression.expr):
+        return
+    _validate_target_type(target, op.expression.expr, op.operation_kind)
+    op.expression = op.expression.model_copy(
+        update=dict(expr="1" if op.expression.expr == "True" else "0")
+    )
+
+
+def _supported_types() -> tuple[str, ...]:
+    return (
+        QuantumBit().qmod_type_name,
+        QuantumNumeric(
+            size=Expression(expr="1"),
+            is_signed=Expression(expr="False"),
+            fraction_digits=Expression(expr="0"),
+        ).qmod_type_name,
+    )

classiq/model_expansions/quantum_operations/assignment_result_processor.py

@@ -11,6 +11,10 @@ from classiq.interface.model.quantum_expressions.quantum_expression import (
 )
 
 from classiq.model_expansions.evaluators.quantum_type_utils import copy_type_information
+from classiq.model_expansions.quantum_operations.arithmetic.explicit_boolean_expressions import (
+    convert_assignment_bool_expression,
+    validate_assignment_bool_expression,
+)
 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
@@ -24,6 +28,7 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
         ):
             direction = PortDeclarationDirection.Output
             self._update_result_type(op)
+            convert_assignment_bool_expression(op)
         else:
             direction = PortDeclarationDirection.Inout
         self._capture_handle(op.result_var, direction)
@@ -47,6 +52,10 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
             self._machine_precision,
         )
         result_symbol = self._interpreter.evaluate(op.result_var).as_type(QuantumSymbol)
+
+        validate_assignment_bool_expression(
+            result_symbol, op.expression.expr, op.operation_kind
+        )  # must be here, otherwise copy_type_information will throw a non-indicative error
         copy_type_information(
             result_type, result_symbol.quantum_type, str(op.result_var)
         )

classiq/model_expansions/quantum_operations/call_emitter.py

@@ -13,9 +13,6 @@ from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
 from classiq.interface.generator.generated_circuit_data import OperationLevel
-from classiq.interface.model.classical_parameter_declaration import (
-    ClassicalParameterDeclaration,
-)
 from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.port_declaration import PortDeclaration
@@ -162,11 +159,6 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
             back_ref=self._get_back_ref(propagated_debug_info),
         )
         is_allocate_or_free = new_call.func_name == free.func_decl.name
-        parameters = {
-            arg_decl.name: FunctionDebugInfo.param_controller(value=evaluated_arg.value)
-            for arg_decl, evaluated_arg in zip(new_positional_arg_decls, evaluated_args)
-            if isinstance(arg_decl, ClassicalParameterDeclaration)
-        }
 
         port_to_passed_variable_map = {
             arg_decl.name: str(evaluated_arg.value.handle)
@@ -176,11 +168,6 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         self._debug_info[new_call.uuid] = FunctionDebugInfo(
             name=new_call.func_name,
             level=OperationLevel.QMOD_FUNCTION_CALL,
-            parameters=(
-                parameters
-                if propagated_debug_info is None or propagated_debug_info.name == ""
-                else propagated_debug_info.parameters
-            ),
             is_allocate_or_free=is_allocate_or_free,
             port_to_passed_variable_map=port_to_passed_variable_map,
             node=new_call._as_back_ref(),

classiq/model_expansions/quantum_operations/quantum_function_call.py

@@ -1,9 +1,5 @@
 from typing import TYPE_CHECKING
 
-from classiq.interface.exceptions import ClassiqValueError
-from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.model.allocate import Allocate
-from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 
 from classiq.model_expansions.closure import FunctionClosure
@@ -17,21 +13,12 @@ if TYPE_CHECKING:
     from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
 
 
-ALLOCATE_COMPATIBILITY_ERROR_MESSAGE = (
-    "'allocate' expects two argument: The number of qubits to allocate (integer) and "
-    "the variable to be allocated (quantum variable)"
-)
-
-
 class QuantumFunctionCallEmitter(CallEmitter[QuantumFunctionCall]):
     def __init__(self, interpreter: "BaseInterpreter") -> None:
         super().__init__(interpreter)
         self._model = self._interpreter._model
 
     def emit(self, call: QuantumFunctionCall, /) -> bool:
-        if call.function == "allocate":  # FIXME: Remove compatibility (CAD-25935)
-            self._allocate_compatibility(call)
-            return True
         function = self._interpreter.evaluate(call.function).as_type(FunctionClosure)
         args = call.positional_args
         with ErrorManager().call(function.name):
@@ -40,15 +27,6 @@ class QuantumFunctionCallEmitter(CallEmitter[QuantumFunctionCall]):
             )
         return True
 
-    def _allocate_compatibility(self, call: QuantumFunctionCall) -> None:
-        if len(call.positional_args) != 2:
-            raise ClassiqValueError(ALLOCATE_COMPATIBILITY_ERROR_MESSAGE)
-        size, target = call.positional_args
-        if not isinstance(size, Expression) or not isinstance(target, HandleBinding):
-            raise ClassiqValueError(ALLOCATE_COMPATIBILITY_ERROR_MESSAGE)
-        allocate = Allocate(size=size, target=target, source_ref=call.source_ref)
-        self._interpreter.emit_statement(allocate)
-
 
 class DeclarativeQuantumFunctionCallEmitter(
     QuantumFunctionCallEmitter, DeclarativeCallEmitter

classiq/model_expansions/scope.py

@@ -19,7 +19,7 @@ from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.expressions.expression_constants import (
     CPARAM_EXECUTION_SUFFIX_PATTERN,
 )
-from classiq.interface.generator.expressions.qmod_struct_instance import (
+from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
     QmodStructInstance,
 )
 from classiq.interface.generator.functions.type_name import TypeName
@@ -72,9 +72,9 @@ class QuantumSymbol:
         array_length = self.quantum_type.length_value
         if start < 0 or end > array_length:
             raise ClassiqExpansionError(
-                f"Slice [{start}:{end}] is out of bounds of "
-                f"{self.quantum_type.type_name} {str(self.handle)!r} of length "
-                f"{array_length}"
+                f"Slice [{start}:{end}] is out of bounds for "
+                f"{self.quantum_type.type_name.lower()} {str(self.handle)!r} (of "
+                f"length {array_length})"
             )
         return QuantumSymbol(
             handle=SlicedHandleBinding(
@@ -96,8 +96,9 @@ class QuantumSymbol:
         array_length = self.quantum_type.length_value
         if index < 0 or index >= array_length:
             raise ClassiqExpansionError(
-                f"Subscript {index} is out of bounds of {self.quantum_type.type_name} "
-                f"{str(self.handle)!r} of length {array_length}"
+                f"Index {index} is out of bounds for "
+                f"{self.quantum_type.type_name.lower()} {str(self.handle)!r} (of "
+                f"length {array_length})"
             )
         return QuantumSymbol(
             handle=SubscriptHandleBinding(