classiq 0.65.4__py3-none-any.whl → 0.66.0__py3-none-any.whl

classiq/model_expansions/scope_initialization.py

@@ -1,22 +1,19 @@
 from collections.abc import Sequence
-from typing import TYPE_CHECKING
+from typing import Any
 
 from classiq.interface.exceptions import ClassiqError
 from classiq.interface.generator.constant import Constant
 from classiq.interface.generator.expressions.expression_constants import (
     CPARAM_EXECUTION_SUFFIX,
+    RESERVED_EXPRESSIONS,
 )
-from classiq.interface.model.classical_parameter_declaration import (
-    ClassicalParameterDeclaration,
-)
+from classiq.interface.generator.functions.concrete_types import ConcreteClassicalType
 from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.model import MAIN_FUNCTION_NAME, Model
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_declaration import (
-    NamedParamsQuantumFunctionDeclaration,
     PositionalArg,
-    QuantumFunctionDeclaration,
 )
 
 from classiq.model_expansions.closure import FunctionClosure, GenerativeFunctionClosure
@@ -26,7 +23,6 @@ from classiq.model_expansions.evaluators.classical_expression import (
 from classiq.model_expansions.evaluators.parameter_types import (
     evaluate_type_in_quantum_symbol,
 )
-from classiq.model_expansions.expression_renamer import ExpressionRenamer
 from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
 from classiq.qmod.builtins import BUILTIN_CONSTANTS
 from classiq.qmod.builtins.enums import BUILTIN_ENUM_DECLARATIONS
@@ -39,19 +35,6 @@ from classiq.qmod.model_state_container import QMODULE
 from classiq.qmod.quantum_function import GenerativeQFunc
 
 
-def get_main_renamer(
-    func_decls: Sequence[QuantumFunctionDeclaration],
-) -> ExpressionRenamer:
-    for func_decl in func_decls:
-        if func_decl.name == MAIN_FUNCTION_NAME:
-            if TYPE_CHECKING:
-                assert isinstance(func_decl, NamedParamsQuantumFunctionDeclaration)
-            return ExpressionRenamer.from_positional_arg_declarations(
-                func_decl.positional_arg_declarations, CPARAM_EXECUTION_SUFFIX
-            )
-    return ExpressionRenamer(var_mapping={})
-
-
 def add_constants_to_scope(constants: list[Constant], scope: Scope) -> None:
     for constant in constants:
         scope[constant.name] = Evaluated(
@@ -122,21 +105,17 @@ def add_entry_point_params_to_scope(
     parameters: Sequence[PositionalArg], main_closure: FunctionClosure
 ) -> None:
     for parameter in parameters:
-        if isinstance(parameter, PortDeclaration):
-            main_closure.scope[parameter.name] = Evaluated(
-                value=QuantumSymbol(
-                    handle=HandleBinding(name=parameter.name),
-                    quantum_type=evaluate_type_in_quantum_symbol(
-                        parameter.quantum_type, main_closure.scope, parameter.name
-                    ),
+        if not isinstance(parameter, PortDeclaration):
+            continue
+        main_closure.scope[parameter.name] = Evaluated(
+            value=QuantumSymbol(
+                handle=HandleBinding(name=parameter.name),
+                quantum_type=evaluate_type_in_quantum_symbol(
+                    parameter.quantum_type, main_closure.scope, parameter.name
                 ),
-                defining_function=main_closure,
-            )
-        elif isinstance(parameter, ClassicalParameterDeclaration):
-            main_closure.scope[parameter.name] = Evaluated(
-                value=parameter.classical_type.as_symbolic(parameter.name),
-                defining_function=main_closure,
-            )
+            ),
+            defining_function=main_closure,
+        )
 
 
 def init_top_level_scope(model: Model, scope: Scope) -> None:
@@ -148,3 +127,39 @@ def init_top_level_scope(model: Model, scope: Scope) -> None:
 def init_builtin_types() -> None:
     QMODULE.enum_decls |= BUILTIN_ENUM_DECLARATIONS
     QMODULE.type_decls |= BUILTIN_STRUCT_DECLARATIONS
+
+
+def _rename_exec_param(param_name: str) -> str:
+    if param_name in RESERVED_EXPRESSIONS:
+        return param_name
+    return param_name + CPARAM_EXECUTION_SUFFIX
+
+
+def _add_exec_param_parts_to_scope(param_val: Any, scope: Scope) -> None:
+    if not isinstance(param_val, list):
+        scope[str(param_val)] = Evaluated(value=param_val)
+        return
+    for param_part in param_val:
+        _add_exec_param_parts_to_scope(param_part, scope)
+
+
+def init_exec_params(model: Model, scope: Scope) -> dict[str, ConcreteClassicalType]:
+    if model.execution_parameters is not None:
+        exec_params = {
+            param_name: (param_name, param_type)
+            for param_name, param_type in model.execution_parameters.items()
+        }
+    else:
+        exec_params = {
+            param.name: (_rename_exec_param(param.name), param.classical_type)
+            for param in model.function_dict.get(
+                "_dec_main", model.main_func
+            ).param_decls
+        }
+    for param_name, (param_rename, param_type) in exec_params.items():
+        param_val = param_type.as_symbolic(param_rename)
+        scope[param_name] = Evaluated(value=param_val)
+        scope[param_rename] = Evaluated(value=param_val)
+        if isinstance(param_val, list):
+            _add_exec_param_parts_to_scope(param_val, scope)
+    return dict(exec_params.values())

classiq/model_expansions/transformers/model_renamer.py

@@ -0,0 +1,98 @@
+import ast
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from typing import TypeVar, cast
+
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.visitor import NodeType
+from classiq.interface.model.handle_binding import HandleBinding
+from classiq.interface.model.model_visitor import ModelTransformer
+from classiq.interface.model.quantum_expressions.quantum_expression import (
+    QuantumExpressionOperation,
+)
+
+from classiq.model_expansions.visitors.variable_references import VarRefCollector
+
+AST_NODE = TypeVar("AST_NODE", bound=NodeType)
+
+
+@dataclass(frozen=True)
+class HandleRenaming:
+    source_handle: HandleBinding
+    target_var_name: str
+
+    @property
+    def target_var_handle(self) -> HandleBinding:
+        return HandleBinding(name=self.target_var_name)
+
+
+SymbolRenaming = Mapping[HandleBinding, Sequence[HandleRenaming]]
+
+
+class ModelRenamer:
+    def rewrite(self, subject: AST_NODE, symbol_mapping: SymbolRenaming) -> AST_NODE:
+        if len(symbol_mapping) == 0:
+            return subject
+        handle_replacements = {
+            part.source_handle: part.target_var_handle
+            for parts in symbol_mapping.values()
+            for part in parts
+        }
+
+        class ReplaceSplitVars(ModelTransformer):
+            @staticmethod
+            def visit_HandleBinding(handle: HandleBinding) -> HandleBinding:
+                handle = handle.collapse()
+                for handle_to_replace, replacement in handle_replacements.items():
+                    handle = handle.replace_prefix(handle_to_replace, replacement)
+                return handle
+
+            @staticmethod
+            def visit_Expression(expr: Expression) -> Expression:
+                return self._rewrite_expression(symbol_mapping, expr)
+
+            def visit_QuantumExpressionOperation(
+                self, op: QuantumExpressionOperation
+            ) -> QuantumExpressionOperation:
+                op = cast(QuantumExpressionOperation, self.generic_visit(op))
+                previous_var_handles = list(op._var_handles)
+                op._var_handles = self.visit(op._var_handles)
+                op._var_types = {
+                    new_handle.name: op._var_types.get(
+                        new_handle.name, op._var_types[previous_handle.name]
+                    )
+                    for previous_handle, new_handle in zip(
+                        previous_var_handles, op._var_handles
+                    )
+                }
+                return op
+
+        return ReplaceSplitVars().visit(subject)
+
+    def _rewrite_expression(
+        self,
+        symbol_mapping: SymbolRenaming,
+        expression: Expression,
+    ) -> Expression:
+        vrc = VarRefCollector(ignore_duplicated_handles=True)
+        vrc.visit(ast.parse(expression.expr))
+
+        handle_names = {
+            part.source_handle: part.target_var_handle
+            for parts in symbol_mapping.values()
+            for part in parts
+        }
+        new_expr_str = expression.expr
+        for handle in vrc.var_handles:
+            new_handle = handle.collapse()
+            for handle_to_replace, replacement in handle_names.items():
+                new_handle = new_handle.replace_prefix(handle_to_replace, replacement)
+            new_expr_str = new_expr_str.replace(str(handle), str(new_handle))
+            if handle.qmod_expr != str(handle):
+                new_expr_str = new_expr_str.replace(
+                    handle.qmod_expr, new_handle.qmod_expr
+                )
+
+        new_expr = Expression(expr=new_expr_str)
+        new_expr._evaluated_expr = expression._evaluated_expr
+        return new_expr

classiq/model_expansions/transformers/var_splitter.py

@@ -1,14 +1,13 @@
 import ast
 from dataclasses import dataclass
 from itertools import chain
-from typing import TYPE_CHECKING, Callable, Optional, TypeVar, cast
+from typing import TYPE_CHECKING, Callable, Optional
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
     ClassiqInternalExpansionError,
 )
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.visitor import NodeType, Transformer
 from classiq.interface.model.bind_operation import BindOperation
 from classiq.interface.model.handle_binding import (
     HandleBinding,
@@ -16,9 +15,6 @@ from classiq.interface.model.handle_binding import (
     SlicedHandleBinding,
     SubscriptHandleBinding,
 )
-from classiq.interface.model.quantum_expressions.quantum_expression import (
-    QuantumExpressionOperation,
-)
 from classiq.interface.model.quantum_type import (
     QuantumBitvector,
     QuantumScalar,
@@ -29,27 +25,23 @@ from classiq.interface.model.variable_declaration_statement import (
 )
 
 from classiq.model_expansions.scope import QuantumSymbol, Scope
+from classiq.model_expansions.transformers.model_renamer import (
+    HandleRenaming,
+    ModelRenamer,
+)
 from classiq.model_expansions.visitors.variable_references import VarRefCollector
 
-AST_NODE = TypeVar("AST_NODE", bound=NodeType)
-
 
 @dataclass(frozen=True)
-class SymbolPart:
-    source_handle: HandleBinding
-    target_var_name: str
+class SymbolPart(HandleRenaming):
     target_var_type: QuantumType
 
-    @property
-    def target_var_handle(self) -> HandleBinding:
-        return HandleBinding(name=self.target_var_name)
-
 
 SymbolParts = dict[HandleBinding, list[SymbolPart]]
 PartNamer = Callable[[str], str]
 
 
-class VarSplitter:
+class VarSplitter(ModelRenamer):
     def __init__(self, scope: Scope):
         self._scope = scope
 
@@ -230,70 +222,3 @@ class VarSplitter:
             )
             for part in chain.from_iterable(symbol_parts.values())
         ]
-
-    def rewrite(self, subject: AST_NODE, symbol_mapping: SymbolParts) -> AST_NODE:
-        if len(symbol_mapping) == 0:
-            return subject
-        handle_replacements = {
-            part.source_handle: part.target_var_handle
-            for parts in symbol_mapping.values()
-            for part in parts
-        }
-
-        class ReplaceSplitVars(Transformer):
-            @staticmethod
-            def visit_HandleBinding(handle: HandleBinding) -> HandleBinding:
-                handle = handle.collapse()
-                for handle_to_replace, replacement in handle_replacements.items():
-                    handle = handle.replace_prefix(handle_to_replace, replacement)
-                return handle
-
-            @staticmethod
-            def visit_Expression(expr: Expression) -> Expression:
-                return self._rewrite_expression(symbol_mapping, expr)
-
-            def visit_QuantumExpressionOperation(
-                self, op: QuantumExpressionOperation
-            ) -> QuantumExpressionOperation:
-                op = cast(QuantumExpressionOperation, self.generic_visit(op))
-                previous_var_handles = list(op._var_handles)
-                op._var_handles = self.visit(op._var_handles)
-                op._var_types = {
-                    new_handle.name: op._var_types.get(
-                        new_handle.name, op._var_types[previous_handle.name]
-                    )
-                    for previous_handle, new_handle in zip(
-                        previous_var_handles, op._var_handles
-                    )
-                }
-                return op
-
-        return ReplaceSplitVars().visit(subject)
-
-    def _rewrite_expression(
-        self,
-        symbol_mapping: SymbolParts,
-        expression: Expression,
-    ) -> Expression:
-        vrc = VarRefCollector(ignore_duplicated_handles=True)
-        vrc.visit(ast.parse(expression.expr))
-
-        handle_names = {
-            part.source_handle: part.target_var_handle
-            for parts in symbol_mapping.values()
-            for part in parts
-        }
-        new_expr_str = expression.expr
-        for handle in vrc.var_handles:
-            new_handle = handle.collapse()
-            for handle_to_replace, replacement in handle_names.items():
-                new_handle = new_handle.replace_prefix(handle_to_replace, replacement)
-            new_expr_str = new_expr_str.replace(str(handle), str(new_handle))
-            if handle.qmod_expr != str(handle):
-                new_expr_str = new_expr_str.replace(
-                    handle.qmod_expr, new_handle.qmod_expr
-                )
-
-        new_expr = Expression(expr=new_expr_str)
-        new_expr._evaluated_expr = expression._evaluated_expr
-        return new_expr

classiq/open_library/functions/grover.py

@@ -25,14 +25,14 @@ def phase_oracle(
     Creates a phase oracle operator based on a predicate function.
 
     Applies a predicate function and marks "good" and "bad" states with a phase flip.
-    If the predicate is marked as $\\chi$, and the oracle is marked as $S_\\chi$, then:
+    If the predicate is marked as $\\chi$, and the oracle is marked as $S_{\\chi}$, then:
 
 
     $$
-    S_\\chi\\lvert x \rangle =
-    \begin{cases}
-    -\\lvert x \rangle & \text{if } \\chi(x) = 1 \\
-     \\phantom{-} \\lvert x \rangle & \text{if } \\chi(x) = 0
+    S_{\\chi}\\lvert x \\rangle =
+    \\begin{cases}
+    -\\lvert x \\rangle & \\text{if } \\chi(x) = 1 \\\\
+    \\phantom{-} \\lvert x \\rangle & \\text{if } \\chi(x) = 0
     \\end{cases}
     $$
 

classiq/qmod/builtins/__init__.py

@@ -12,7 +12,7 @@ from .enums import *  # noqa: F403
 from .enums import __all__ as _builtin_enums
 from .functions import *  # noqa: F403
 from .functions import __all__ as _builtin_functions
-from .operations import *  # type:ignore[assignment] # noqa: F403
+from .operations import *  # noqa: F403
 from .operations import __all__ as _builtin_operations
 from .structs import *  # noqa: F403
 from .structs import __all__ as _builtin_structs

classiq/qmod/builtins/functions/__init__.py

@@ -58,7 +58,6 @@ CORE_LIB_DECLS = [
         real_xor_constant,
         U,
         CCX,
-        allocate,
         free,
         randomized_benchmarking,
         inplace_prepare_state,
@@ -103,7 +102,6 @@ __all__ = [  # noqa: RUF022
     "Y",
     "Z",
     "add",
-    "allocate",
     "apply",
     "bloch_sphere_feature_map",
     "exponentiation_with_depth_constraint",

classiq/qmod/builtins/functions/allocation.py

@@ -1,35 +1,10 @@
 from typing import Literal
 
 from classiq.qmod.qfunc import qfunc
-from classiq.qmod.qmod_parameter import CArray, CInt, CReal
+from classiq.qmod.qmod_parameter import CArray, CReal
 from classiq.qmod.qmod_variable import Input, Output, QArray, QBit
 
 
-@qfunc(external=True)
-def allocate(
-    num_qubits: CInt, out: Output[QArray[QBit, Literal["num_qubits"]]]
-) -> None:
-    """
-    [Qmod core-library function]
-
-    Allocates the specified number of qubits to a given quantum variable and initializes
-    them in the zero state:
-
-    $$
-        \\left|\\text{out}\\right\\rangle = \\left|0\\right\\rangle^{\\otimes \\text{num_qubits}}
-    $$
-
-    Args:
-        num_qubits: The number of qubits to allocate. Must be a positive integer.
-        out: The quantum variable that will receive the allocated qubits. Must be uninitialized before allocation.
-
-    Notes:
-        1. If the output variable has been declared with a specific number of qubits, the number of qubits allocated must match the declared number.
-        2. The synthesis engine automatically handles the allocation, either by drawing new qubits from the available pool or by reusing existing ones.
-    """
-    pass
-
-
 @qfunc(external=True)
 def free(in_: Input[QArray[QBit]]) -> None:
     """

classiq/qmod/builtins/operations.py

@@ -65,15 +65,21 @@ def allocate(out: Output[QVar]) -> None:
 
 def allocate(*args: Any, **kwargs: Any) -> None:
     """
-    Initialize a quantum variable.
+    Initialize a quantum variable to a new quantum object in the zero state:
 
-    If 'num_qubits' is specified, 'num_qubits' qubits will be allocated for variable
-    'out'. Otherwise, the number of qubits will be inferred according to the type of
-    'out'.
+    $$
+        \\left|\\text{out}\\right\\rangle = \\left|0\\right\\rangle^{\\otimes \\text{num_qubits}}
+    $$
+
+    If 'num_qubits' is not specified, it will be inferred according to the type of 'out'.
 
     Args:
-        size: The number of qubits to be allocated (optional)
-        out: The target variable
+        num_qubits: The number of qubits to allocate (positive integer, optional).
+        out: The quantum variable that will receive the allocated qubits. Must be uninitialized before allocation.
+
+    Notes:
+        1. If the output variable has been declared with a specific number of qubits, the number of qubits allocated must match the declared number.
+        2. The synthesis engine automatically handles the allocation, either by drawing new qubits from the available pool or by reusing existing ones.
     """
     assert QCallable.CURRENT_EXPANDABLE is not None
     source_ref = get_source_ref(sys._getframe(1))

classiq/qmod/generative.py

@@ -6,10 +6,12 @@ from classiq.interface.exceptions import ClassiqError
 from classiq.interface.generator.expressions.expression import Expression
 
 if TYPE_CHECKING:
-    from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
+    from classiq.model_expansions.interpreters.generative_interpreter import (
+        GenerativeInterpreter,
+    )
 
 _GENERATIVE_MODE: bool = False
-_FRONTEND_INTERPRETER: Optional["BaseInterpreter"] = None
+_FRONTEND_INTERPRETER: Optional["GenerativeInterpreter"] = None
 
 
 def is_generative_mode() -> bool:
@@ -27,12 +29,12 @@ def generative_mode_context(generative: bool) -> Iterator[None]:
         _GENERATIVE_MODE = previous
 
 
-def set_frontend_interpreter(interpreter: "BaseInterpreter") -> None:
+def set_frontend_interpreter(interpreter: "GenerativeInterpreter") -> None:
     global _FRONTEND_INTERPRETER
     _FRONTEND_INTERPRETER = interpreter
 
 
-def get_frontend_interpreter() -> "BaseInterpreter":
+def get_frontend_interpreter() -> "GenerativeInterpreter":
     if _FRONTEND_INTERPRETER is None:
         raise ClassiqError("Interpreter was not set")
     return _FRONTEND_INTERPRETER

classiq/qmod/native/pretty_printer.py

@@ -21,7 +21,7 @@ from classiq.interface.generator.functions.type_name import TypeName
 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.generator.visitor import NodeType, Visitor
+from classiq.interface.generator.visitor import NodeType
 from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.bind_operation import BindOperation
 from classiq.interface.model.classical_if import ClassicalIf
@@ -38,6 +38,7 @@ from classiq.interface.model.handle_binding import (
 from classiq.interface.model.inplace_binary_operation import InplaceBinaryOperation
 from classiq.interface.model.invert import Invert
 from classiq.interface.model.model import Model
+from classiq.interface.model.model_visitor import ModelVisitor
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.phase_operation import PhaseOperation
 from classiq.interface.model.port_declaration import (
@@ -85,7 +86,7 @@ from classiq.qmod.semantics.annotation.call_annotation import resolve_function_c
 from classiq.qmod.utilities import DEFAULT_DECIMAL_PRECISION
 
 
-class DSLPrettyPrinter(Visitor):
+class DSLPrettyPrinter(ModelVisitor):
     def __init__(
         self,
         decimal_precision: Optional[int] = DEFAULT_DECIMAL_PRECISION,

classiq/qmod/pretty_print/pretty_printer.py

@@ -41,6 +41,7 @@ from classiq.interface.model.handle_binding import (
 from classiq.interface.model.inplace_binary_operation import InplaceBinaryOperation
 from classiq.interface.model.invert import Invert
 from classiq.interface.model.model import Model
+from classiq.interface.model.model_visitor import ModelVisitor
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.phase_operation import PhaseOperation
 from classiq.interface.model.port_declaration import AnonPortDeclaration
@@ -120,7 +121,7 @@ class VariableDeclarationAssignment(Visitor):
         return qtype.name, []
 
 
-class PythonPrettyPrinter(Visitor):
+class PythonPrettyPrinter(ModelVisitor):
     def __init__(self, decimal_precision: int = DEFAULT_DECIMAL_PRECISION) -> None:
         self._level = 0
         self._decimal_precision = decimal_precision
@@ -407,6 +408,7 @@ class PythonPrettyPrinter(Visitor):
         return ", ".join(self.visit(arg) for arg in func_call.positional_args)
 
     def visit_Allocate(self, allocate: Allocate) -> str:
+        self._imports["allocate"] = 1
         if allocate.size is not None:
             size = f"{self.visit(allocate.size)}, "
         else:

classiq/qmod/qmod_variable.py

@@ -22,6 +22,7 @@ from typing_extensions import ParamSpec, Self, _AnnotatedAlias
 
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.non_symbolic_expr import NonSymbolicExpr
 from classiq.interface.generator.expressions.qmod_qarray_proxy import (
     ILLEGAL_SLICE_MSG,
     ILLEGAL_SLICING_STEP_MSG,
@@ -185,6 +186,10 @@ class QVar(Symbolic):
                 return interpret_expression(str(self.size))
         return CParamScalar(f"get_field({self}, 'size')")
 
+    @property
+    def type_name(self) -> str:
+        return self.get_qmod_type().type_name
+
 
 _Q = TypeVar("_Q", bound=QVar)
 Output = Annotated[_Q, PortDeclarationDirection.Output]
@@ -414,7 +419,7 @@ class QNum(Generic[_P], QScalar):
             return _GenericAlias(cls, args)
 
 
-class QArray(ArrayBase[_P], QVar):
+class QArray(ArrayBase[_P], QVar, NonSymbolicExpr):
     CONSTRUCTOR_DEPTH: int = 3
 
     # TODO [CAD-18620]: improve type hints

classiq/qmod/semantics/annotation/call_annotation.py

@@ -3,8 +3,17 @@ from contextlib import contextmanager
 from typing import Any
 
 from classiq.interface.exceptions import ClassiqError
-from classiq.interface.generator.visitor import Visitor
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.classical_type import Integer
+from classiq.interface.generator.functions.port_declaration import (
+    PortDeclarationDirection,
+)
+from classiq.interface.model.classical_parameter_declaration import (
+    ClassicalParameterDeclaration,
+)
+from classiq.interface.model.model_visitor import ModelVisitor
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
+from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_function_declaration import (
     AnonQuantumOperandDeclaration,
@@ -14,17 +23,36 @@ from classiq.interface.model.quantum_function_declaration import (
 from classiq.interface.model.quantum_lambda_function import (
     QuantumLambdaFunction,
 )
+from classiq.interface.model.quantum_type import QuantumBitvector
 
 from classiq.qmod.builtins.functions import BUILTIN_FUNCTION_DECLARATIONS
 from classiq.qmod.semantics.annotation.qstruct_annotator import QStructAnnotator
 from classiq.qmod.semantics.error_manager import ErrorManager
 from classiq.qmod.semantics.lambdas import get_renamed_parameters
 
+ALLOCATE_DECL_FOR_COMPATIBILITY = QuantumFunctionDeclaration(
+    name="allocate",
+    positional_arg_declarations=[
+        ClassicalParameterDeclaration(
+            name="num_qubits",
+            classical_type=Integer(),
+        ),
+        PortDeclaration(
+            name="out",
+            quantum_type=QuantumBitvector(length=Expression(expr="num_qubits")),
+            direction=PortDeclarationDirection.Output,
+        ),
+    ],
+)
+
 
 def _annotate_function_call_decl(
     fc: QuantumFunctionCall,
     function_dict: Mapping[str, QuantumFunctionDeclaration],
 ) -> None:
+    if fc.function == "allocate":  # FIXME: Remove compatibility (CAD-25935)
+        fc.set_func_decl(ALLOCATE_DECL_FOR_COMPATIBILITY)
+        return
     if fc._func_decl is None:
         func_decl = function_dict.get(fc.func_name)
         if func_decl is None:
@@ -46,7 +74,7 @@ def _annotate_function_call_decl(
                 qlambda.set_op_decl(param)
 
 
-class _CallLambdaAnnotator(Visitor):
+class _CallLambdaAnnotator(ModelVisitor):
     def __init__(
         self, quantum_functions: Mapping[str, QuantumFunctionDeclaration]
     ) -> None:

classiq/qmod/semantics/annotation/qstruct_annotator.py

@@ -1,10 +1,10 @@
 from classiq.interface.generator.functions.type_name import TypeName
-from classiq.interface.generator.visitor import Visitor
+from classiq.interface.model.model_visitor import ModelVisitor
 
 from classiq.qmod.model_state_container import QMODULE
 
 
-class QStructAnnotator(Visitor):
+class QStructAnnotator(ModelVisitor):
     def __init__(self) -> None:
         self._visited: set[TypeName] = set()