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

classiq/model_expansions/evaluators/quantum_type_utils.py

@@ -67,7 +67,7 @@ def set_size(quantum_type: QuantumType, size: int, param_name: str) -> None:
 
     if quantum_type.has_size_in_bits and quantum_type.size_in_bits != size:
         raise ClassiqExpansionError(
-            f"Size mismatch for port {param_name!r} between declared size {quantum_type.size_in_bits} and assigned size {size}"
+            f"Size mismatch for variable {param_name!r} between declared size {quantum_type.size_in_bits} and assigned size {size}"
         )
 
     if isinstance(quantum_type, QuantumNumeric):
@@ -79,7 +79,7 @@ def set_size(quantum_type: QuantumType, size: int, param_name: str) -> None:
         if quantum_type.has_length:
             if size % quantum_type.length_value != 0:
                 raise ClassiqExpansionError(
-                    f"Size mismatch for port {param_name!r}. Cannot fit {size} "
+                    f"Size mismatch for variable {param_name!r}. Cannot fit {size} "
                     f"qubits into an array of {quantum_type.length_value} elements."
                 )
             set_size(
@@ -123,7 +123,7 @@ def set_fraction_digits(
         and quantum_numeric.fraction_digits_value != fraction_digits
     ):
         raise ClassiqExpansionError(
-            f"Fraction digits mismatch for port {param_name!r} between declared "
+            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}"
         )
@@ -145,7 +145,7 @@ def set_is_signed(
         and quantum_numeric.sign_value != is_signed
     ):
         raise ClassiqExpansionError(
-            f"Sign mismatch for port {param_name!r} between declared sign {quantum_numeric.sign_value!r} and assigned sign {is_signed!r}"
+            f"Sign mismatch for variable {param_name!r} between declared sign {quantum_numeric.sign_value!r} and assigned sign {is_signed!r}"
         )
 
     if not (
@@ -175,7 +175,7 @@ def set_length_by_size(
 
     if quantum_array.has_size_in_bits and quantum_array.size_in_bits != size:
         raise ClassiqExpansionError(
-            f"Size mismatch for port {param_name!r} between declared size "
+            f"Size mismatch for variable {param_name!r} between declared size "
             f"{quantum_array.size_in_bits} ({quantum_array.length_value} elements of "
             f"size {quantum_array.element_type.size_in_bits}) and assigned size {size}."
         )
@@ -188,7 +188,7 @@ def set_length_by_size(
 
     if size % element_size != 0:
         raise ClassiqExpansionError(
-            f"Size mismatch for port {param_name!r}. Cannot fit elements of type "
+            f"Size mismatch for variable {param_name!r}. Cannot fit elements of type "
             f"{quantum_array.element_type.qmod_type_name} (size {element_size}) into "
             f"{size} qubits."
         )

classiq/model_expansions/expression_evaluator.py

@@ -4,7 +4,7 @@ from collections.abc import Mapping
 from enum import EnumMeta
 from typing import Any, Optional
 
-from sympy import sympify
+from sympy import SympifyError, sympify
 
 from classiq.interface.exceptions import ClassiqExpansionError
 from classiq.interface.generator.constant import Constant
@@ -16,6 +16,8 @@ from classiq.interface.generator.expressions.expression_constants import (
     CPARAM_EXECUTION_SUFFIX_PATTERN,
 )
 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.sympy_supported_expressions import (
     SYMPY_SUPPORTED_EXPRESSIONS,
 )
@@ -81,6 +83,13 @@ def evaluate(
                 f"{', '.join(e.obj.__members__)}"
             ) from e
         raise
+    except SympifyError as e:
+        expr = e.expr
+        if isinstance(expr, QmodSizedProxy) and isinstance(expr, NonSymbolicExpr):
+            raise ClassiqExpansionError(
+                f"{expr.type_name} {str(expr)!r} does not support arithmetic operations"
+            ) from e
+        raise
 
     return EvaluatedExpression(
         value=sympy_to_python(sympify_result, locals=model_locals)

classiq/model_expansions/interpreters/base_interpreter.py

@@ -4,18 +4,19 @@ from collections import defaultdict
 from collections.abc import Sequence
 from contextlib import nullcontext
 from functools import singledispatchmethod
-from typing import Any, Optional, cast
+from typing import Any, cast
 
 import sympy
 from pydantic import ValidationError
 
+from classiq.interface.debug_info.debug_info import FunctionDebugInfo
 from classiq.interface.exceptions import (
     ClassiqError,
     ClassiqExpansionError,
     ClassiqInternalExpansionError,
 )
-from classiq.interface.generator.constant import Constant
 from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.generated_circuit_data import OperationLevel
 from classiq.interface.generator.types.compilation_metadata import CompilationMetadata
 from classiq.interface.model.handle_binding import (
     FieldHandleBinding,
@@ -42,7 +43,6 @@ from classiq.model_expansions.debug_flag import debug_mode
 from classiq.model_expansions.evaluators.classical_expression import (
     evaluate_classical_expression,
 )
-from classiq.model_expansions.expression_renamer import ExpressionRenamer
 from classiq.model_expansions.function_builder import (
     FunctionContext,
     OperationBuilder,
@@ -50,10 +50,9 @@ from classiq.model_expansions.function_builder import (
 )
 from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
 from classiq.model_expansions.scope_initialization import (
-    add_constants_to_scope,
     add_entry_point_params_to_scope,
-    get_main_renamer,
     init_builtin_types,
+    init_exec_params,
     init_top_level_scope,
 )
 from classiq.model_expansions.utils.counted_name_allocator import CountedNameAllocator
@@ -62,10 +61,12 @@ from classiq.qmod.builtins.enums import BUILTIN_ENUM_DECLARATIONS
 from classiq.qmod.builtins.structs import BUILTIN_STRUCT_DECLARATIONS
 from classiq.qmod.model_state_container import QMODULE
 from classiq.qmod.semantics.error_manager import ErrorManager
+from classiq.qmod.semantics.validation.model_validation import validate_model
 
 
 class BaseInterpreter:
     def __init__(self, model: Model) -> None:
+        validate_model(model)
         self._model = model
         self._top_level_scope = Scope()
         self._counted_name_allocator = CountedNameAllocator()
@@ -76,6 +77,7 @@ class BaseInterpreter:
 
         init_builtin_types()
         init_top_level_scope(model, self._top_level_scope)
+        self._exec_params = init_exec_params(model, self._top_level_scope)
         self._functions_compilation_metadata: dict[str, CompilationMetadata] = dict(
             self._model.functions_compilation_metadata
         )
@@ -85,9 +87,6 @@ class BaseInterpreter:
         self._counted_name_allocator = CountedNameAllocator()
         self._error_manager: ErrorManager = ErrorManager()
 
-    def get_main_renamer(self) -> Optional[ExpressionRenamer]:
-        return get_main_renamer(self._get_function_declarations())
-
     def _expand_main_func(self) -> None:
         main_closure = self._get_main_closure(
             self._top_level_scope[MAIN_FUNCTION_NAME].value
@@ -105,7 +104,6 @@ class BaseInterpreter:
             name=main_func.name,
             positional_arg_declarations=main_func.positional_arg_declarations,
             scope=Scope(parent=self._top_level_scope),
-            expr_renamer=self.get_main_renamer(),
             _depth=0,
             body=main_func.body,
         )
@@ -117,12 +115,7 @@ class BaseInterpreter:
         except Exception as e:
             if isinstance(e, ClassiqInternalExpansionError) or debug_mode.get():
                 raise e
-            if not isinstance(e, (ClassiqError, ValidationError)):
-                raise ClassiqInternalExpansionError(str(e)) from None
-            prefix = ""
-            if not isinstance(e, ClassiqExpansionError):
-                prefix = f"{type(e).__name__}: "
-            self._error_manager.add_error(f"{prefix}{e}")
+            self.process_exception(e)
         finally:
             self._error_manager.report_errors(ClassiqExpansionError)
 
@@ -146,8 +139,17 @@ class BaseInterpreter:
             qstructs=list(QMODULE.qstruct_decls.values()),
             debug_info=self._model.debug_info,
             functions_compilation_metadata=self._expanded_functions_compilation_metadata,
+            execution_parameters=self._exec_params,
         )
 
+    def process_exception(self, e: Exception) -> None:
+        if not isinstance(e, (ClassiqError, ValidationError)):
+            raise ClassiqInternalExpansionError(str(e)) from None
+        prefix = ""
+        if not isinstance(e, ClassiqExpansionError):
+            prefix = f"{type(e).__name__}: "
+        self._error_manager.add_error(f"{prefix}{e}")
+
     @singledispatchmethod
     def evaluate(self, expression: Any) -> Evaluated:
         raise NotImplementedError(f"Cannot evaluate {expression!r}")
@@ -229,6 +231,17 @@ class BaseInterpreter:
             if source_ref is not None
             else nullcontext()
         )
+        if statement.uuid not in self._model.debug_info:
+            self._model.debug_info[statement.uuid] = FunctionDebugInfo(
+                name="",
+                parameters={},
+                level=OperationLevel.QMOD_STATEMENT,
+                statement_type=None,
+                is_allocate_or_free=False,
+                is_inverse=False,
+                port_to_passed_variable_map={},
+                node=statement._as_back_ref(),
+            )
         with error_context, self._builder.source_ref_context(source_ref):
             self.emit(statement)
 
@@ -258,6 +271,3 @@ class BaseInterpreter:
             for func in self._top_level_scope.values()
             if isinstance(func_closure := func.value, FunctionClosure)
         ]
-
-    def add_constant(self, constant: Constant) -> None:
-        add_constants_to_scope([constant], self._top_level_scope)

classiq/model_expansions/interpreters/frontend_generative_interpreter.py

@@ -1,4 +1,11 @@
+import inspect
+import os
+
+from pydantic import ValidationError
+
+from classiq.interface.exceptions import ClassiqError
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+from classiq.interface.source_reference import SourceReference
 
 from classiq.model_expansions.closure import FunctionClosure, GenerativeFunctionClosure
 from classiq.model_expansions.interpreters.generative_interpreter import (
@@ -8,6 +15,7 @@ from classiq.model_expansions.quantum_operations.quantum_function_call import (
     DeclarativeQuantumFunctionCallEmitter,
 )
 from classiq.model_expansions.scope import Scope
+from classiq.qmod.model_state_container import QMODULE
 
 
 class FrontendGenerativeInterpreter(GenerativeInterpreter):
@@ -20,9 +28,58 @@ class FrontendGenerativeInterpreter(GenerativeInterpreter):
                 name=main_func.name,
                 positional_arg_declarations=main_func.positional_arg_declarations,
                 scope=Scope(parent=self._top_level_scope),
-                expr_renamer=self.get_main_renamer(),
                 _depth=0,
                 generative_blocks={"body": main_func.generative_blocks["body"]},
             )
 
         return super()._get_main_closure(main_func)
+
+    def process_exception(self, e: Exception) -> None:
+        if not isinstance(e, (ClassiqError, ValidationError)):
+            frame = inspect.trace()[-1]
+            module = inspect.getmodule(frame[0])
+            if module is None or not module.__name__.startswith("classiq."):
+                file_name = os.path.split(frame.filename)[-1]
+                if (
+                    frame.positions is not None
+                    and frame.positions.lineno is not None
+                    and frame.positions.col_offset is not None
+                    and frame.positions.end_lineno is not None
+                    and frame.positions.end_col_offset is not None
+                ):
+                    source_ref = SourceReference(
+                        start_line=frame.positions.lineno - 1,
+                        start_column=frame.positions.col_offset - 1,
+                        end_line=frame.positions.end_lineno - 1,
+                        end_column=frame.positions.end_col_offset - 1,
+                        file_name=file_name,
+                    )
+                else:
+                    source_ref = SourceReference(
+                        start_line=frame.lineno - 1,
+                        start_column=frame.lineno - 1,
+                        end_line=-1,
+                        end_column=-1,
+                        file_name=file_name,
+                    )
+                e_str = f": {e}" if str(e) else ""
+                self._error_manager.add_error(
+                    f"{type(e).__name__}{e_str}",
+                    source_ref=source_ref,
+                    function=frame.function,
+                )
+                return
+
+        super().process_exception(e)
+
+    def add_purely_declarative_function(self, function: FunctionClosure) -> None:
+        functions_to_add = [function.name] + QMODULE.function_dependencies[
+            function.name
+        ]
+        for func in functions_to_add:
+            if func not in self._expanded_functions and func in QMODULE.native_defs:
+                self._expanded_functions[func] = QMODULE.native_defs[func]
+                if func in QMODULE.functions_compilation_metadata:
+                    self._expanded_functions_compilation_metadata[func] = (
+                        QMODULE.functions_compilation_metadata[func]
+                    )

classiq/model_expansions/interpreters/generative_interpreter.py

@@ -4,6 +4,7 @@ from typing import Any
 import numpy as np
 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 (
     CONTROL_OPERATOR_NAME,
@@ -53,14 +54,16 @@ from classiq.model_expansions.quantum_operations import (
     RepeatEmitter,
     VariableDeclarationStatementEmitter,
 )
+from classiq.model_expansions.quantum_operations.allocate import AllocateEmitter
 from classiq.model_expansions.quantum_operations.shallow_emitter import ShallowEmitter
 from classiq.model_expansions.scope import Evaluated, Scope
 from classiq.model_expansions.scope_initialization import (
+    add_constants_to_scope,
     add_functions_to_scope,
     add_generative_functions_to_scope,
 )
 from classiq.qmod.builtins.functions import permute
-from classiq.qmod.model_state_container import QMODULE, ModelStateContainer
+from classiq.qmod.model_state_container import ModelStateContainer
 from classiq.qmod.quantum_function import GenerativeQFunc
 
 
@@ -123,7 +126,7 @@ class GenerativeInterpreter(BaseInterpreter):
 
     @emit.register
     def emit_allocate(self, allocate: Allocate) -> None:
-        ShallowEmitter(self, "allocate", components=["size", "target"]).emit(allocate)
+        AllocateEmitter(self).emit(allocate)
 
     @emit.register
     def emit_bind(self, bind: BindOperation) -> None:
@@ -236,14 +239,5 @@ class GenerativeInterpreter(BaseInterpreter):
                     qmodule.functions_compilation_metadata[dec_func_name]
                 )
 
-    def add_purely_declarative_function(self, function: FunctionClosure) -> None:
-        functions_to_add = [function.name] + QMODULE.function_dependencies[
-            function.name
-        ]
-        for func in functions_to_add:
-            if func not in self._expanded_functions and func in QMODULE.native_defs:
-                self._expanded_functions[func] = QMODULE.native_defs[func]
-                if func in QMODULE.functions_compilation_metadata:
-                    self._expanded_functions_compilation_metadata[func] = (
-                        QMODULE.functions_compilation_metadata[func]
-                    )
+    def add_constant(self, constant: Constant) -> None:
+        add_constants_to_scope([constant], self._top_level_scope)

classiq/model_expansions/quantum_operations/allocate.py

@@ -0,0 +1,69 @@
+from classiq.interface.debug_info.debug_info import FunctionDebugInfo
+from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.generated_circuit_data import OperationLevel
+from classiq.interface.model.allocate import Allocate
+from classiq.interface.model.handle_binding import NestedHandleBinding
+from classiq.interface.model.quantum_type import QuantumBitvector
+
+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
+
+
+class AllocateEmitter(Emitter[Allocate]):
+    def emit(self, allocate: Allocate, /) -> None:
+        self._register_debug_info(allocate)
+        target: QuantumSymbol = self._interpreter.evaluate(allocate.target).as_type(
+            QuantumSymbol
+        )
+
+        if isinstance(target.handle, NestedHandleBinding):
+            raise ClassiqValueError(
+                f"Cannot allocate partial quantum variable {str(target.handle)!r}"
+            )
+
+        size = self._get_var_size(target, allocate.size)
+        allocate = allocate.model_copy(
+            update=dict(size=Expression(expr=str(size)), target=target.handle)
+        )
+        self.emit_statement(allocate)
+
+    def _get_var_size(self, target: QuantumSymbol, size: Expression | None) -> int:
+        if size is None:
+            if not target.quantum_type.is_evaluated:
+                raise ClassiqValueError(
+                    f"Could not infer the size of variable {str(target.handle)!r}"
+                )
+            return target.quantum_type.size_in_bits
+
+        size_value = self._interpreter.evaluate(size).value
+        if not isinstance(size_value, (int, float)):
+            raise ClassiqValueError(
+                f"The number of allocated qubits must be an integer. Got "
+                f"{str(size_value)!r}"
+            )
+        size_value = int(size_value)
+        copy_type_information(
+            QuantumBitvector(length=Expression(expr=str(size_value))),
+            target.quantum_type,
+            str(target.handle),
+        )
+        return size_value
+
+    def _register_debug_info(self, allocate: Allocate) -> None:
+        if (
+            allocate.uuid in self._debug_info
+            and self._debug_info[allocate.uuid].name != ""
+        ):
+            return
+        parameters: dict[str, str] = {}
+        if allocate.size is not None:
+            parameters["num_qubits"] = allocate.size.expr
+        self._debug_info[allocate.uuid] = FunctionDebugInfo(
+            name="allocate",
+            parameters=parameters,
+            level=OperationLevel.QMOD_STATEMENT,
+            is_allocate_or_free=True,
+            port_to_passed_variable_map={"ARG": str(allocate.target)},
+        )

classiq/model_expansions/quantum_operations/call_emitter.py

@@ -44,7 +44,10 @@ from classiq.model_expansions.quantum_operations.emitter import (
 )
 from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
 from classiq.model_expansions.transformers.var_splitter import VarSplitter
-from classiq.qmod.builtins.functions import allocate, free
+from classiq.qmod.builtins.functions import free
+from classiq.qmod.semantics.validation.signature_validation import (
+    validate_function_signature,
+)
 
 if TYPE_CHECKING:
     from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
@@ -119,10 +122,7 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         new_call = QuantumFunctionCall(
             function=new_declaration.name, positional_args=new_positional_args
         )
-        is_allocate_or_free = (
-            new_call.func_name == allocate.func_decl.name
-            or new_call.func_name == free.func_decl.name
-        )
+        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)
@@ -139,7 +139,7 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
             level=OperationLevel.QMOD_FUNCTION_CALL,
             parameters=(
                 parameters
-                if propagated_debug_info is None
+                if propagated_debug_info is None or propagated_debug_info.name == ""
                 else propagated_debug_info.parameters
             ),
             is_allocate_or_free=is_allocate_or_free,
@@ -255,6 +255,7 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         different from the call scope. For example, the former uses r,s and the latter
         uses p, q.
         """
+        validate_function_signature(function.positional_arg_declarations)
         # The signature scope is passed as a separate argument to avoid contaminating the statement execution scope
         return NamedParamsQuantumFunctionDeclaration(
             name=function.name,

classiq/model_expansions/quantum_operations/declarative_call_emitter.py

@@ -13,17 +13,17 @@ from classiq.model_expansions.scope import Evaluated
 from classiq.qmod.model_state_container import QMODULE
 
 if TYPE_CHECKING:
-    from classiq.model_expansions.interpreters.generative_interpreter import (
-        GenerativeInterpreter,
+    from classiq.model_expansions.interpreters.frontend_generative_interpreter import (
+        FrontendGenerativeInterpreter,
     )
 
 
 class DeclarativeCallEmitter(
     Generic[QuantumStatementT], CallEmitter[QuantumStatementT]
 ):
-    _interpreter: "GenerativeInterpreter"
+    _interpreter: "FrontendGenerativeInterpreter"
 
-    def __init__(self, interpreter: "GenerativeInterpreter") -> None:
+    def __init__(self, interpreter: "FrontendGenerativeInterpreter") -> None:
         super().__init__(interpreter)
 
     def should_expand_function(

classiq/model_expansions/quantum_operations/emitter.py

@@ -1,5 +1,4 @@
-import ast
-from abc import abstractmethod
+from abc import ABC, abstractmethod
 from typing import (
     TYPE_CHECKING,
     Generic,
@@ -37,7 +36,6 @@ from classiq.model_expansions.sympy_conversion.sympy_to_python import (
     translate_sympy_quantum_expression,
 )
 from classiq.model_expansions.utils.counted_name_allocator import CountedNameAllocator
-from classiq.model_expansions.visitors.variable_references import VarRefCollector
 from classiq.qmod.quantum_function import GenerativeQFunc
 
 if TYPE_CHECKING:
@@ -46,7 +44,7 @@ if TYPE_CHECKING:
 QuantumStatementT = TypeVar("QuantumStatementT", bound=QuantumStatement)
 
 
-class Emitter(Generic[QuantumStatementT]):
+class Emitter(Generic[QuantumStatementT], ABC):
     def __init__(self, interpreter: "BaseInterpreter") -> None:
         self._interpreter = interpreter
 
@@ -168,14 +166,3 @@ class Emitter(Generic[QuantumStatementT]):
             defining_function=defining_function,
             direction=direction,
         )
-
-    def capture_handles_in_expression(self, expr: Expression) -> None:
-        vrc = VarRefCollector(ignore_duplicated_handles=True)
-        vrc.visit(ast.parse(expr.expr))
-        handles = dict.fromkeys(
-            handle
-            for handle in vrc.var_handles
-            if isinstance(self._current_scope[handle.name].value, QuantumSymbol)
-        )
-        for handle in handles:
-            self._capture_handle(handle, PortDeclarationDirection.Inout)

classiq/model_expansions/quantum_operations/quantum_function_call.py

@@ -1,5 +1,9 @@
 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
@@ -13,12 +17,21 @@ 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, /) -> None:
+        if call.function == "allocate":  # FIXME: Remove compatibility (CAD-25935)
+            self._allocate_compatibility(call)
+            return
         function = self._interpreter.evaluate(call.function).as_type(FunctionClosure)
         args = call.positional_args
         with ErrorManager().call(function.name):
@@ -26,6 +39,15 @@ class QuantumFunctionCallEmitter(CallEmitter[QuantumFunctionCall]):
                 function, args, self._debug_info.get(call.uuid)
             )
 
+    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/quantum_operations/shallow_emitter.py

@@ -6,7 +6,6 @@ from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
-from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.quantum_expressions.arithmetic_operation import (
     ArithmeticOperation,
@@ -18,10 +17,7 @@ from classiq.interface.model.quantum_expressions.quantum_expression import (
 from classiq.interface.model.quantum_statement import QuantumOperation, QuantumStatement
 
 from classiq.model_expansions.closure import Closure
-from classiq.model_expansions.evaluators.quantum_type_utils import (
-    copy_type_information,
-    set_size,
-)
+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, Scope
 from classiq.model_expansions.transformers.ast_renamer import rename_variables
@@ -65,7 +61,8 @@ class ShallowEmitter(Emitter[QuantumOperation]):
         for expression_name in expressions:
             expression = getattr(op, expression_name)
             expression = self._evaluate_expression(expression, preserve_bool_ops=True)
-            self.capture_handles_in_expression(expression)
+            for symbol in self._get_symbols_in_expression(expression):
+                self._capture_handle(symbol.handle, PortDeclarationDirection.Inout)
             expanded_components[expression_name] = expression
 
         for handle_name in handles:
@@ -77,8 +74,6 @@ class ShallowEmitter(Emitter[QuantumOperation]):
         op = op.model_copy(update=expanded_components)
         if isinstance(op, QuantumAssignmentOperation):
             self._post_process_assignment(op)
-        if isinstance(op, Allocate):
-            self._post_process_allocate(op)
         self._builder.emit_statement(op)
 
     def _post_process_assignment(self, op: QuantumAssignmentOperation) -> None:
@@ -92,19 +87,6 @@ class ShallowEmitter(Emitter[QuantumOperation]):
             direction = PortDeclarationDirection.Inout
         self._capture_handle(op.result_var, direction)
 
-    def _post_process_allocate(self, allocate: Allocate) -> None:
-        target_symbol = self._interpreter.evaluate(allocate.target).value
-        if not isinstance(target_symbol, QuantumSymbol):
-            return
-        self._capture_handle(target_symbol.handle, PortDeclarationDirection.Output)
-        if allocate.size is None or not allocate.size.is_evaluated():
-            return
-        set_size(
-            target_symbol.quantum_type,
-            allocate.size.to_int_value(),
-            str(target_symbol.handle),
-        )
-
     def _split_components(
         self, op: QuantumOperation
     ) -> tuple[list[str], list[str], list[str]]:
@@ -152,25 +134,19 @@ class ShallowEmitter(Emitter[QuantumOperation]):
         }
 
     def _update_result_type(self, op: ArithmeticOperation) -> None:
-        expr = str(self._evaluate_expression(op.expression))
-        vrc = VarRefCollector(ignore_duplicated_handles=True)
-        vrc.visit(ast.parse(expr))
-        symbols: list[QuantumSymbol] = [
-            symbol
-            for handle in vrc.var_handles
-            if isinstance(
-                symbol := self._interpreter.evaluate(handle).value, QuantumSymbol
-            )
-        ]
-        expr = rename_variables(
-            expr,
+        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 = expr.replace(symbol.handle.qmod_expr, symbol.handle.identifier)
+            expr_str = expr_str.replace(
+                symbol.handle.qmod_expr, symbol.handle.identifier
+            )
         result_type = compute_arithmetic_result_type(
-            expr,
+            expr_str,
             {symbol.handle.identifier: symbol.quantum_type for symbol in symbols},
             self._machine_precision,
         )
@@ -178,3 +154,13 @@ class ShallowEmitter(Emitter[QuantumOperation]):
         copy_type_information(
             result_type, result_symbol.quantum_type, str(op.result_var)
         )
+
+    def _get_symbols_in_expression(self, expr: Expression) -> list[QuantumSymbol]:
+        vrc = VarRefCollector(ignore_duplicated_handles=True)
+        vrc.visit(ast.parse(expr.expr))
+        handles = dict.fromkeys(
+            handle
+            for handle in vrc.var_handles
+            if isinstance(self._current_scope[handle.name].value, QuantumSymbol)
+        )
+        return [self._interpreter.evaluate(handle).value for handle in handles]