classiq 0.74.0__py3-none-any.whl → 0.76.0__py3-none-any.whl

classiq/model_expansions/evaluators/classical_type_inference.py

@@ -1,6 +1,9 @@
 from typing import Any, Union
 
 from classiq.interface.exceptions import ClassiqExpansionError
+from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
+    AnyClassicalValue,
+)
 from classiq.interface.generator.expressions.proxies.classical.classical_array_proxy import (
     ClassicalArrayProxy,
 )
@@ -17,6 +20,7 @@ from classiq.interface.generator.functions.classical_type import (
 )
 from classiq.interface.generator.functions.type_name import TypeName
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
+from classiq.interface.helpers.backward_compatibility import zip_strict
 
 
 def infer_classical_type(val: Any, classical_type: ClassicalType) -> ClassicalType:
@@ -33,7 +37,7 @@ def _infer_classical_struct_type(val: Any, classical_type: TypeName) -> Classica
     decl = val.struct_declaration
     new_fields = {
         field_name: infer_classical_type(field_val, field_type)
-        for (field_name, field_val), field_type in zip(
+        for (field_name, field_val), field_type in zip_strict(
             val.fields.items(),
             decl.variables.values(),
             strict=True,
@@ -49,13 +53,20 @@ def _infer_classical_struct_type(val: Any, classical_type: TypeName) -> Classica
 def _infer_classical_array_type(
     val: Any, classical_type: Union[ClassicalArray, ClassicalList]
 ) -> ClassicalType:
-    if isinstance(val, list):
-        val_length = len(val)
-    elif isinstance(val, ClassicalArrayProxy):
+    if isinstance(val, ClassicalArrayProxy):
         val_length = val.length
+    elif isinstance(val, list):
+        val_length = len(val)
+    elif isinstance(val, AnyClassicalValue):
+        return classical_type
     else:
         raise ClassiqExpansionError(f"Array expected, got {str(val)!r}")
-    if isinstance(classical_type, ClassicalArray) and val_length != classical_type.size:
+    if (
+        isinstance(classical_type, ClassicalArray)
+        and isinstance(val_length, int)
+        and isinstance(classical_type.size, int)
+        and val_length != classical_type.size
+    ):
         raise ClassiqExpansionError(
             f"Type mismatch: Argument has {val_length} items but "
             f"{classical_type.size} expected"
@@ -63,7 +74,7 @@ def _infer_classical_array_type(
     return ClassicalArray(
         element_type=(
             infer_classical_type(val[0], classical_type.element_type)
-            if val_length > 0
+            if not isinstance(val_length, int) or val_length > 0
             else classical_type.element_type
         ),
         size=val_length,

classiq/model_expansions/evaluators/parameter_types.py

@@ -1,10 +1,15 @@
-from typing import TypeVar, Union
+from typing import Optional, TypeVar, Union
+
+import sympy
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
     ClassiqInternalExpansionError,
 )
 from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
+    AnyClassicalValue,
+)
 from classiq.interface.generator.functions.concrete_types import ConcreteQuantumType
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
@@ -178,7 +183,8 @@ def _evaluate_qarray_in_quantum_symbol(
             "length",
             param_name,
         )
-        set_length(type_to_update, new_length)
+        if new_length is not None:
+            set_length(type_to_update, new_length)
     return type_to_update
 
 
@@ -194,7 +200,8 @@ def _evaluate_qnum_in_quantum_symbol(
             "sign",
             param_name,
         )
-        type_to_update.is_signed = Expression(expr=str(new_is_sign))
+        if new_is_sign is not None:
+            type_to_update.is_signed = Expression(expr=str(new_is_sign))
     if type_to_update.fraction_digits is not None:
         new_fraction_digits = _eval_expr(
             type_to_update.fraction_digits,
@@ -204,7 +211,8 @@ def _evaluate_qnum_in_quantum_symbol(
             "fraction digits",
             param_name,
         )
-        type_to_update.fraction_digits = Expression(expr=str(new_fraction_digits))
+        if new_fraction_digits is not None:
+            type_to_update.fraction_digits = Expression(expr=str(new_fraction_digits))
     if type_to_update.size is not None:
         new_size = _eval_expr(
             type_to_update.size,
@@ -214,7 +222,8 @@ def _evaluate_qnum_in_quantum_symbol(
             "size",
             param_name,
         )
-        set_size(type_to_update, new_size, param_name)
+        if new_size is not None:
+            set_size(type_to_update, new_size, param_name)
     return type_to_update
 
 
@@ -228,17 +237,21 @@ def _eval_expr(
     type_name: str,
     attr_name: str,
     param_name: str,
-) -> _EXPR_TYPE:
+) -> Optional[_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
+    if isinstance(val, expected_type):
+        return val
+    if isinstance(val, AnyClassicalValue) or (
+        isinstance(val, sympy.Basic) and len(val.free_symbols) > 0
+    ):
+        return None
+    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}"
+    )
 
 
 def _evaluate_qstruct_in_quantum_symbol(

classiq/model_expansions/evaluators/type_type_match.py

@@ -85,7 +85,7 @@ def _check_classical_type_match(
 ) -> None:
     if (
         not isinstance(op_param, AnonClassicalParameterDeclaration)
-        or decl_param.classical_type.set_generative()
-        != op_param.classical_type.set_generative()
+        or decl_param.classical_type.clear_flags()
+        != op_param.classical_type.clear_flags()
     ):
         raise ClassiqExpansionError(error_message)

classiq/model_expansions/expression_evaluator.py

@@ -73,7 +73,7 @@ def evaluate(
     try:
         sympify_result = sympify(sympy_expr, locals=model_locals)
     except (TypeError, IndexError) as e:
-        raise ClassiqExpansionError(str(e)) from None
+        raise ClassiqExpansionError(str(e)) from e
     except AttributeError as e:
         if isinstance(e.obj, EnumMeta):
             raise ClassiqExpansionError(

classiq/model_expansions/generative_functions.py

@@ -16,7 +16,7 @@ from classiq.interface.generator.expressions.proxies.classical.utils import (
     get_proxy_type,
 )
 from classiq.interface.generator.functions.type_name import Struct
-from classiq.interface.helpers.datastructures import get_sdk_compatible_python_object
+from classiq.interface.helpers.datastructures import LenList
 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
@@ -31,16 +31,18 @@ from classiq.model_expansions.closure import (
     FunctionClosure,
     GenerativeClosure,
 )
-from classiq.model_expansions.scope import Evaluated, QuantumSymbol
+from classiq.model_expansions.scope import Evaluated
 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, create_param
-from classiq.qmod.qmod_variable import _create_qvar_for_qtype
+from classiq.qmod.qmod_variable import QScalar, _create_qvar_for_qtype
 from classiq.qmod.quantum_expandable import (
     QTerminalCallable,
 )
 from classiq.qmod.quantum_function import QFunc
 from classiq.qmod.semantics.annotation.call_annotation import resolve_function_calls
+from classiq.qmod.symbolic_expr import SymbolicExpr, SymbolicSubscriptAndField
+from classiq.qmod.utilities import qmod_val_to_expr_str
 
 if TYPE_CHECKING:
     from classiq.model_expansions.interpreters.generative_interpreter import (
@@ -65,33 +67,61 @@ def _unwrap_traceback_frame(e: Exception) -> Exception:
     return e.with_traceback(back_tb)
 
 
-def translate_ast_arg_to_python_qmod(param: PositionalArg, evaluated: Evaluated) -> Any:
-    if isinstance(param, PortDeclaration):
-        quantum_symbol = evaluated.as_type(QuantumSymbol)
-        return _create_qvar_for_qtype(
-            quantum_symbol.quantum_type, quantum_symbol.handle
+class SymbolicList(LenList):
+    def __getitem__(self, index: Any) -> Any:
+        if isinstance(index, (QScalar, SymbolicExpr)) or (
+            isinstance(index, slice)
+            and any(
+                isinstance(slice_part, (QScalar, SymbolicExpr))
+                for slice_part in (index.start, index.stop, index.step)
+            )
+        ):
+            return SymbolicSubscriptAndField(
+                qmod_val_to_expr_str(self), is_quantum=False
+            )[index]
+        try:
+            return super().__getitem__(index)
+        except (IndexError, TypeError) as e:
+            raise _unwrap_traceback_frame(e) from None
+
+
+def translate_classical_ast_arg_to_python_qmod(value: Any) -> Any:
+    if isinstance(value, QmodStructInstance):
+        return QmodStructInstance(
+            value.struct_declaration,
+            {
+                field_name: translate_classical_ast_arg_to_python_qmod(field_value)
+                for field_name, field_value in value.fields.items()
+            },
+        )
+    if isinstance(value, list):
+        return SymbolicList(
+            [translate_classical_ast_arg_to_python_qmod(item) for item in value]
         )
+    if isinstance(value, ClassicalProxy):
+        return create_param(str(value.handle), get_proxy_type(value), QMODULE)
+
+    return value
+
+
+def translate_ast_arg_to_python_qmod(param: PositionalArg, value: Any) -> Any:
+    if isinstance(param, PortDeclaration):
+        return _create_qvar_for_qtype(value.quantum_type, value.handle)
     if isinstance(param, QuantumOperandDeclaration):
         if not param.is_list or not param.is_generative:
             return QTerminalCallable(param)
         inner_decl = param.model_copy(update={"is_list": False})
-        func_list: list[FunctionClosure] = evaluated.as_type(list)
-        return [
-            QTerminalCallable(inner_decl, index_=idx) for idx in range(len(func_list))
-        ]
-    classical_value = evaluated.value
-    if isinstance(classical_value, QmodStructInstance):
+        return [QTerminalCallable(inner_decl, index_=idx) for idx in range(len(value))]
+    if (
+        isinstance(value, QmodStructInstance)
+        and param.classical_type.is_purely_declarative
+    ):
+        classical_type = Struct(name=value.struct_declaration.name)
+        classical_type.set_classical_struct_decl(value.struct_declaration)
         return CParamStruct(
-            expr=param.name,
-            struct_type=Struct(name=classical_value.struct_declaration.name),
-            qmodule=QMODULE,
-        )
-    if isinstance(classical_value, ClassicalProxy):
-        return create_param(
-            str(classical_value.handle), get_proxy_type(classical_value), QMODULE
+            expr=param.name, struct_type=classical_type, qmodule=QMODULE
         )
-
-    return get_sdk_compatible_python_object(classical_value)
+    return translate_classical_ast_arg_to_python_qmod(value)
 
 
 class _InterpreterExpandable(QFunc):
@@ -111,15 +141,18 @@ class _InterpreterExpandable(QFunc):
             for name, func in self._qmodule.native_defs.items()
             if name not in self._interpreter._top_level_scope
         }
+        generative_functions = self._qmodule.generative_functions
         self._interpreter.update_declarative_functions(
             declarative_functions, self._qmodule
         )
-        self._interpreter.update_generative_functions(
-            self._qmodule.generative_functions
-        )
+        self._interpreter.update_generative_functions(generative_functions)
         func_decls = self._get_function_declarations()
         for dec_func in declarative_functions.values():
             resolve_function_calls(dec_func, func_decls)
+        self._interpreter.infer_symbolic_parameters(
+            list(declarative_functions.values()),
+            [func.func_decl for func in generative_functions.values()],
+        )
         resolve_function_calls(dummy_function, func_decls)
         stmt = dummy_function.body[-1]
         with generative_mode_context(False):
@@ -134,14 +167,14 @@ class _InterpreterExpandable(QFunc):
                     name=name,
                     positional_arg_declarations=value.positional_arg_declarations,
                 )
-            elif (
-                isinstance(value, list)
-                and len(value) > 0
-                and isinstance(value[0], FunctionClosure)
-            ):
+                continue
+            op_param = self._interpreter._builder.current_function.parameters_dict.get(
+                name
+            )
+            if isinstance(op_param, QuantumOperandDeclaration):
                 scope_func_decls[name] = QuantumFunctionDeclaration(
                     name=name,
-                    positional_arg_declarations=value[0].positional_arg_declarations,
+                    positional_arg_declarations=op_param.positional_arg_declarations,
                 )
         return (
             nameables_to_dict(self._interpreter._get_function_declarations())
@@ -155,7 +188,7 @@ def emit_generative_statements(
     args: list[Evaluated],
 ) -> None:
     python_qmod_args = [
-        translate_ast_arg_to_python_qmod(param, arg)
+        translate_ast_arg_to_python_qmod(param, arg.value)
         for param, arg in zip(operation.positional_arg_declarations, args)
     ]
     with _InterpreterExpandable(interpreter):

classiq/model_expansions/interpreters/base_interpreter.py

@@ -6,17 +6,20 @@ from contextlib import nullcontext
 from functools import singledispatchmethod
 from typing import Any, cast
 
-import sympy
 from pydantic import ValidationError
 
-from classiq.interface.debug_info.debug_info import FunctionDebugInfo
+from classiq.interface.debug_info.debug_info import (
+    new_function_debug_info_by_node,
+)
 from classiq.interface.exceptions import (
     ClassiqError,
     ClassiqExpansionError,
     ClassiqInternalExpansionError,
 )
+from classiq.interface.generator.expressions.atomic_expression_functions import (
+    CLASSICAL_ATTRIBUTES,
+)
 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,
@@ -56,11 +59,13 @@ from classiq.model_expansions.scope_initialization import (
 )
 from classiq.model_expansions.utils.counted_name_allocator import CountedNameAllocator
 from classiq.model_expansions.visitors.variable_references import VarRefCollector
+from classiq.qmod.builtins.constants import __all__ as builtin_constants
 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
+from classiq.qmod.utilities import qmod_val_to_expr_str
 
 
 class BaseInterpreter:
@@ -125,7 +130,11 @@ class BaseInterpreter:
             classical_execution_code=self._model.classical_execution_code,
             execution_preferences=self._model.execution_preferences,
             functions=list(self._expanded_functions.values()),
-            constants=self._model.constants,
+            constants=[
+                const
+                for name, const in QMODULE.constants.items()
+                if name not in builtin_constants
+            ],
             enums=[
                 enum_decl
                 for name, enum_decl in QMODULE.enum_decls.items()
@@ -156,14 +165,17 @@ class BaseInterpreter:
     @evaluate.register
     def evaluate_classical_expression(self, expression: Expression) -> Evaluated:
         expr = evaluate_classical_expression(expression, self._builder.current_scope)
-        if not isinstance(expr.value, sympy.Basic):
-            return expr
         vrc = VarRefCollector(ignore_duplicated_handles=True, unevaluated=True)
-        vrc.visit(ast.parse(str(expr.value)))
+        vrc.visit(ast.parse(qmod_val_to_expr_str(expr.value)))
         for handle in vrc.var_handles:
             if handle.name in self._builder.current_scope and isinstance(
-                self._builder.current_scope[handle.name], QuantumSymbol
+                self._builder.current_scope[handle.name].value, QuantumSymbol
             ):
+                if (
+                    isinstance(handle, FieldHandleBinding)
+                    and handle.field in CLASSICAL_ATTRIBUTES
+                ):
+                    handle = handle.base_handle
                 self.evaluate(handle)
         return expr
 
@@ -237,20 +249,16 @@ 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(),
-            )
+        self.add_to_debug_info(statement)
         with error_context, self._builder.source_ref_context(source_ref):
             self.emit(statement)
 
+    def add_to_debug_info(self, statement: QuantumStatement) -> None:
+        if statement.uuid not in self._model.debug_info:
+            self._model.debug_info[statement.uuid] = new_function_debug_info_by_node(
+                statement  # type: ignore[arg-type]
+            )
+
     def _expand_operation(self, operation: Closure) -> OperationContext:
         with self._builder.operation_context(operation) as context:
             if isinstance(operation, FunctionClosure) and (

classiq/model_expansions/interpreters/frontend_generative_interpreter.py

@@ -4,21 +4,47 @@ import os
 from pydantic import ValidationError
 
 from classiq.interface.exceptions import ClassiqError
+from classiq.interface.model.allocate import Allocate
+from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+from classiq.interface.model.quantum_function_declaration import (
+    NamedParamsQuantumFunctionDeclaration,
+)
 from classiq.interface.source_reference import SourceReference
 
 from classiq.model_expansions.closure import FunctionClosure, GenerativeFunctionClosure
 from classiq.model_expansions.interpreters.generative_interpreter import (
     GenerativeInterpreter,
 )
+from classiq.model_expansions.quantum_operations import BindEmitter
+from classiq.model_expansions.quantum_operations.allocate import AllocateEmitter
 from classiq.model_expansions.quantum_operations.quantum_function_call import (
     DeclarativeQuantumFunctionCallEmitter,
 )
 from classiq.model_expansions.scope import Scope
+from classiq.model_expansions.visitors.symbolic_param_inference import (
+    SymbolicParamInference,
+)
 from classiq.qmod.model_state_container import QMODULE
 
 
 class FrontendGenerativeInterpreter(GenerativeInterpreter):
+    def infer_symbolic_parameters(
+        self,
+        functions: list[NativeFunctionDefinition],
+        additional_signatures: (
+            list[NamedParamsQuantumFunctionDeclaration] | None
+        ) = None,
+    ) -> None:
+        SymbolicParamInference(functions, additional_signatures).infer()
+
+    def emit_allocate(self, allocate: Allocate) -> None:
+        AllocateEmitter(self, allow_symbolic_size=True).emit(allocate)
+
+    def emit_bind(self, bind: BindOperation) -> None:
+        BindEmitter(self, allow_symbolic_size=True).emit(bind)
+
     def emit_quantum_function_call(self, call: QuantumFunctionCall) -> None:
         DeclarativeQuantumFunctionCallEmitter(self).emit(call)
 

classiq/model_expansions/interpreters/generative_interpreter.py

@@ -61,7 +61,11 @@ from classiq.model_expansions.quantum_operations.allocate import AllocateEmitter
 from classiq.model_expansions.quantum_operations.assignment_result_processor import (
     AssignmentResultProcessor,
 )
-from classiq.model_expansions.quantum_operations.block_evaluator import BlockEvaluator
+from classiq.model_expansions.quantum_operations.block_evaluator import (
+    BlockEvaluator,
+    IfElimination,
+    RepeatElimination,
+)
 from classiq.model_expansions.quantum_operations.composite_emitter import (
     CompositeEmitter,
 )
@@ -93,6 +97,18 @@ class GenerativeInterpreter(BaseInterpreter):
         add_generative_functions_to_scope(
             generative_functions, self._top_level_scope, override_atomic=True
         )
+        self.infer_symbolic_parameters(
+            model.functions, [gen_func.func_decl for gen_func in generative_functions]
+        )
+
+    def infer_symbolic_parameters(
+        self,
+        functions: list[NativeFunctionDefinition],
+        additional_signatures: (
+            list[NamedParamsQuantumFunctionDeclaration] | None
+        ) = None,
+    ) -> None:
+        pass
 
     def evaluate_lambda(self, function: QuantumLambdaFunction) -> Evaluated:
         func_decl = NamedParamsQuantumFunctionDeclaration(
@@ -140,10 +156,16 @@ class GenerativeInterpreter(BaseInterpreter):
         QuantumFunctionCallEmitter(self).emit(call)
 
     @emit.register
+    def _emit_allocate(self, allocate: Allocate) -> None:
+        return self.emit_allocate(allocate)
+
     def emit_allocate(self, allocate: Allocate) -> None:
         AllocateEmitter(self).emit(allocate)
 
     @emit.register
+    def _emit_bind(self, bind: BindOperation) -> None:
+        self.emit_bind(bind)
+
     def emit_bind(self, bind: BindOperation) -> None:
         BindEmitter(self).emit(bind)
 
@@ -198,6 +220,7 @@ class GenerativeInterpreter(BaseInterpreter):
             self,
             [
                 ExpressionEvaluator(self, "condition"),
+                IfElimination(self),
                 BlockEvaluator(
                     self,
                     CLASSICAL_IF_OPERATOR_NAME,
@@ -231,6 +254,7 @@ class GenerativeInterpreter(BaseInterpreter):
             self,
             [
                 ExpressionEvaluator(self, "count"),
+                RepeatElimination(self),
                 RepeatBlockEvaluator(self, REPEAT_OPERATOR_NAME, "body"),
             ],
         ).emit(repeat)

classiq/model_expansions/quantum_operations/allocate.py

@@ -1,7 +1,13 @@
+from typing import TYPE_CHECKING
+
+import sympy
+
 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.generator.expressions.proxies.classical.any_classical_value import (
+    AnyClassicalValue,
+)
 from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.handle_binding import NestedHandleBinding
 from classiq.interface.model.quantum_type import QuantumBitvector
@@ -10,8 +16,17 @@ from classiq.model_expansions.evaluators.quantum_type_utils import copy_type_inf
 from classiq.model_expansions.quantum_operations.emitter import Emitter
 from classiq.model_expansions.scope import QuantumSymbol
 
+if TYPE_CHECKING:
+    from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
+
 
 class AllocateEmitter(Emitter[Allocate]):
+    def __init__(
+        self, interpreter: "BaseInterpreter", allow_symbolic_size: bool = False
+    ) -> None:
+        super().__init__(interpreter)
+        self._allow_symbolic_size = allow_symbolic_size
+
     def emit(self, allocate: Allocate, /) -> bool:
         target: QuantumSymbol = self._interpreter.evaluate(allocate.target).as_type(
             QuantumSymbol
@@ -22,10 +37,10 @@ class AllocateEmitter(Emitter[Allocate]):
                 f"Cannot allocate partial quantum variable {str(target.handle)!r}"
             )
 
-        size = self._get_var_size(target, allocate.size)
+        size_expr = self._get_var_size(target, allocate.size)
         allocate = allocate.model_copy(
             update=dict(
-                size=Expression(expr=str(size)),
+                size=Expression(expr=size_expr),
                 target=target.handle,
                 back_ref=allocate.uuid,
             )
@@ -34,27 +49,31 @@ class AllocateEmitter(Emitter[Allocate]):
         self.emit_statement(allocate)
         return True
 
-    def _get_var_size(self, target: QuantumSymbol, size: Expression | None) -> int:
+    def _get_var_size(self, target: QuantumSymbol, size: Expression | None) -> str:
         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
+            return str(target.quantum_type.size_in_bits)
 
         size_value = self._interpreter.evaluate(size).value
+        if self._allow_symbolic_size and isinstance(
+            size_value, (sympy.Basic, AnyClassicalValue)
+        ):
+            return str(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)
+        size_expr = str(size_value)
         copy_type_information(
-            QuantumBitvector(length=Expression(expr=str(size_value))),
+            QuantumBitvector(length=Expression(expr=size_expr)),
             target.quantum_type,
             str(target.handle),
         )
-        return size_value
+        return size_expr
 
     def _register_debug_info(self, allocate: Allocate) -> None:
         if (
@@ -67,9 +86,6 @@ class AllocateEmitter(Emitter[Allocate]):
             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)},
             node=allocate._as_back_ref(),
         )