classiq 0.92.0__py3-none-any.whl → 0.99.0__py3-none-any.whl

classiq/model_expansions/function_builder.py

@@ -1,7 +1,7 @@
 from collections.abc import Iterator, Sequence
 from contextlib import contextmanager
 from dataclasses import dataclass, field
-from typing import Generic, Optional, TypeVar
+from typing import Generic, TypeVar
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
@@ -13,6 +13,7 @@ from classiq.interface.generator.compiler_keywords import (
 )
 from classiq.interface.generator.functions.builtins.internal_operators import (
     BLOCK_OPERATOR_NAME,
+    SKIP_CONTROL_OPERATOR_NAME,
     WITHIN_APPLY_NAME,
 )
 from classiq.interface.model.model import MAIN_FUNCTION_NAME
@@ -39,7 +40,11 @@ from classiq.model_expansions.utils.counted_name_allocator import CountedNameAll
 
 ClosureType = TypeVar("ClosureType", bound=Closure)
 
-BLOCKS_ALLOWED_CAPTURING = (WITHIN_APPLY_NAME, BLOCK_OPERATOR_NAME)
+BLOCKS_ALLOWED_CAPTURING = (
+    WITHIN_APPLY_NAME,
+    BLOCK_OPERATOR_NAME,
+    SKIP_CONTROL_OPERATOR_NAME,
+)
 
 
 @dataclass
@@ -87,6 +92,10 @@ class FunctionContext(OperationContext[FunctionClosure]):
     def is_lambda(self) -> bool:
         return self.closure.is_lambda
 
+    @property
+    def permutation(self) -> bool:
+        return self.closure.permutation
+
 
 class OperationBuilder:
     def __init__(
@@ -95,7 +104,7 @@ class OperationBuilder:
         self._operations: list[OperationContext] = []
         self._blocks: list[str] = []
         self._functions_scope = functions_scope
-        self._current_source_ref: Optional[SourceReference] = None
+        self._current_source_ref: SourceReference | None = None
         self._counted_name_allocator = counted_name_allocator
 
     @property
@@ -201,9 +210,7 @@ class OperationBuilder:
         parent_block.captured_vars.update(captured_vars)
 
     @contextmanager
-    def source_ref_context(
-        self, source_ref: Optional[SourceReference]
-    ) -> Iterator[None]:
+    def source_ref_context(self, source_ref: SourceReference | None) -> Iterator[None]:
         previous_source_ref = self._current_source_ref
         self._current_source_ref = source_ref
         yield
@@ -218,6 +225,7 @@ class OperationBuilder:
             name=name,
             body=function_context.body,
             positional_arg_declarations=params,
+            permutation=function_context.permutation,
         )
 
     def _get_expanded_function_name(self, function_context: FunctionContext) -> str:

classiq/model_expansions/generative_functions.py

@@ -113,10 +113,7 @@ 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})
-        return [QTerminalCallable(inner_decl, index_=idx) for idx in range(len(value))]
+        return QTerminalCallable(param)
     if (
         isinstance(value, QmodStructInstance)
         and not param.classical_type.is_purely_generative
@@ -175,20 +172,18 @@ class _InterpreterExpandable(QFunc):
         scope_func_decls: dict[str, QuantumFunctionDeclaration] = {}
         for name, evaluated in self._interpreter._builder.current_scope.items():
             value = evaluated.value
+            if (
+                isinstance(value, list)
+                and len(value) > 0
+                and isinstance(value[0], FunctionClosure)
+            ):
+                value = value[0]
             if isinstance(value, FunctionClosure):
                 scope_func_decls[name] = QuantumFunctionDeclaration(
                     name=name,
                     positional_arg_declarations=value.positional_arg_declarations,
                 )
                 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=op_param.positional_arg_declarations,
-                )
         return (
             nameables_to_dict(self._interpreter._get_function_declarations())
             | scope_func_decls

classiq/model_expansions/interpreters/base_interpreter.py

@@ -1,10 +1,10 @@
 import ast
 from abc import abstractmethod
 from collections import defaultdict
-from collections.abc import Sequence
+from collections.abc import Callable, Sequence
 from contextlib import nullcontext
 from functools import singledispatchmethod
-from typing import Any, Callable, cast
+from typing import Any, cast
 
 from pydantic import ValidationError
 
@@ -42,9 +42,6 @@ from classiq.interface.model.quantum_statement import QuantumStatement
 
 from classiq.evaluators.classical_expression import process_scope_val
 from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
-from classiq.evaluators.qmod_expression_visitors.qmod_expression_bwc import (
-    QmodExpressionBwc,
-)
 from classiq.evaluators.qmod_expression_visitors.qmod_expression_evaluator import (
     evaluate_qmod_expression,
 )
@@ -214,7 +211,6 @@ class BaseInterpreter:
         if expression.is_evaluated():
             return Evaluated(value=expression.value.value)
         expr_ast = ast.parse(expression.expr, mode="eval").body
-        expr_ast = QmodExpressionBwc().visit(expr_ast)
         expr_val = self._eval_expr(ast.unparse(expr_ast), treat_qnum_as_float)
         if simplify and not expr_val.has_value(expr_val.root):
             simplified_expr = simplify_qmod_expression(expr_val)
@@ -328,7 +324,7 @@ class BaseInterpreter:
     def emit_statement(self, statement: QuantumStatement) -> None:
         source_ref = statement.source_ref
         error_context = (
-            self._error_manager.node_context(statement)
+            self._error_manager.source_ref_context(statement.source_ref)
             if source_ref is not None
             else nullcontext()
         )

classiq/model_expansions/interpreters/frontend_generative_interpreter.py

@@ -41,7 +41,8 @@ class FrontendGenerativeInterpreter(GenerativeInterpreter):
             if module is None or not module.__name__.startswith("classiq."):
                 file_name = os.path.split(frame.filename)[-1]
                 if (
-                    frame.positions is not None
+                    hasattr(frame, "positions")
+                    and 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

classiq/model_expansions/interpreters/generative_interpreter.py

@@ -1,5 +1,5 @@
 from functools import singledispatchmethod
-from typing import Any, Optional
+from typing import Any
 
 import numpy as np
 from numpy.random import permutation
@@ -119,9 +119,9 @@ class GenerativeInterpreter(BaseInterpreter):
     def infer_symbolic_parameters(
         self,
         functions: list[NativeFunctionDefinition],
-        additional_signatures: Optional[
+        additional_signatures: None | (
             list[NamedParamsQuantumFunctionDeclaration]
-        ] = None,
+        ) = None,
     ) -> None:
         pass
 
@@ -134,6 +134,7 @@ class GenerativeInterpreter(BaseInterpreter):
                 function.func_decl.name or "<lambda>"
             ),
             positional_arg_declarations=function.named_func_decl.positional_arg_declarations,
+            permutation=function.named_func_decl.permutation,
         )
 
         closure_class: type[FunctionClosure]
@@ -152,6 +153,7 @@ class GenerativeInterpreter(BaseInterpreter):
         closure = closure_class.create(
             name=func_decl.name,
             positional_arg_declarations=func_decl.positional_arg_declarations,
+            permutation=func_decl.permutation,
             body=function.body,
             scope=Scope(parent=self._builder.current_scope),
             lambda_external_vars=self._builder.current_block.captured_vars,
@@ -245,7 +247,9 @@ class GenerativeInterpreter(BaseInterpreter):
     def emit_variable_declaration(
         self, variable_declaration: VariableDeclarationStatement
     ) -> None:
-        VariableDeclarationStatementEmitter(self).emit(variable_declaration)
+        VariableDeclarationStatementEmitter(
+            self, allow_symbolic_vars=self._symbolic_parameters_switch
+        ).emit(variable_declaration)
 
     @emit.register
     def emit_classical_if(self, classical_if: ClassicalIf) -> None:

classiq/model_expansions/quantum_operations/allocate.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Any, Union
+from typing import TYPE_CHECKING, Any
 
 import sympy
 
@@ -193,7 +193,7 @@ class AllocateEmitter(Emitter[Allocate]):
 
     def _interpret_size(
         self, size: Expression, var_name: str
-    ) -> Union[int, float, sympy.Basic, QmodAnnotatedExpression]:
+    ) -> int | float | sympy.Basic | QmodAnnotatedExpression:
         size_value = self._interpreter.evaluate(size).value
         if not (
             (
@@ -221,7 +221,7 @@ class AllocateEmitter(Emitter[Allocate]):
 
     def _interpret_is_signed(
         self, is_signed: Expression
-    ) -> Union[bool, sympy.Basic, QmodAnnotatedExpression]:
+    ) -> bool | sympy.Basic | QmodAnnotatedExpression:
         is_signed_value = self._interpreter.evaluate(is_signed).value
         if not self._allow_symbolic_attrs and not (
             isinstance(is_signed_value, bool)
@@ -238,7 +238,7 @@ class AllocateEmitter(Emitter[Allocate]):
 
     def _interpret_fraction_digits(
         self, fraction_digits: Expression
-    ) -> Union[int, float, sympy.Expr, QmodAnnotatedExpression]:
+    ) -> int | float | sympy.Expr | QmodAnnotatedExpression:
         fraction_digits_value = self._interpreter.evaluate(fraction_digits).value
         if not self._allow_symbolic_attrs and not (
             isinstance(fraction_digits_value, (int, float))

classiq/model_expansions/quantum_operations/assignment_result_processor.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 from classiq.interface.exceptions import ClassiqExpansionError
 from classiq.interface.generator.expressions.expression import Expression
@@ -62,6 +62,12 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
         if isinstance(result_symbol, ClassicalSymbol):
             return False
         result_type = result_symbol.quantum_type
+        if not isinstance(result_type, QuantumScalar):
+            raise ClassiqExpansionError(
+                f"Cannot assign into a non-scalar quantum variable "
+                f"{str(result_symbol.handle)!r} of type "
+                f"{result_type.raw_qmod_type_name}"
+            )
 
         if not (
             isinstance(op, ArithmeticOperation)
@@ -105,9 +111,7 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
         self._assign_to_inferred_var_and_bind(op, result_type, expression_type)
         return True
 
-    def _infer_expression_type(
-        self, op: ArithmeticOperation
-    ) -> Optional[QuantumScalar]:
+    def _infer_expression_type(self, op: ArithmeticOperation) -> QuantumScalar | None:
         expr = self._evaluate_expression(op.expression)
         expr_val = expr.value.value
         if isinstance(expr_val, QmodAnnotatedExpression):

classiq/model_expansions/quantum_operations/call_emitter.py

@@ -2,7 +2,6 @@ from collections.abc import Sequence
 from itertools import chain, combinations
 from typing import (
     Generic,
-    Optional,
     cast,
 )
 from uuid import UUID
@@ -16,9 +15,7 @@ from classiq.interface.exceptions import ClassiqExpansionError
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
-from classiq.interface.generator.functions.type_modifier import TypeModifier
 from classiq.interface.generator.types.compilation_metadata import CompilationMetadata
-from classiq.interface.helpers.backward_compatibility import zip_strict
 from classiq.interface.helpers.text_utils import are, readable_list, s
 from classiq.interface.model.block import Block
 from classiq.interface.model.classical_parameter_declaration import (
@@ -72,8 +69,8 @@ from classiq.model_expansions.scope import (
     Scope,
 )
 from classiq.model_expansions.transformers.model_renamer import ModelRenamer
-from classiq.model_expansions.transformers.type_modifier_inference import (
-    TypeModifierValidation,
+from classiq.model_expansions.visitors.uncomputation_signature_inference import (
+    infer_and_validate_uncomputation_signature,
 )
 from classiq.qmod.pretty_print.expression_to_python import transform_expression
 from classiq.qmod.semantics.validation.signature_validation import (
@@ -106,7 +103,7 @@ def _validate_cloning(evaluated_args: list[Evaluated]) -> None:
 def _validate_gen_args(
     function: FunctionClosure, evaluated_args: list[Evaluated]
 ) -> None:
-    for param, arg in zip_strict(
+    for param, arg in zip(
         function.positional_arg_declarations, evaluated_args, strict=True
     ):
         if (
@@ -158,7 +155,7 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], ModelR
         self,
         name: str,
         body: Sequence[QuantumStatement],
-        debug_info: Optional[FunctionDebugInfo] = None,
+        debug_info: FunctionDebugInfo | None = None,
     ) -> QuantumFunctionCall:
         wrapping_function = FunctionClosure.create(
             name=self._counted_name_allocator.allocate(name),
@@ -172,7 +169,7 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], ModelR
         self,
         function: FunctionClosure,
         args: list[ArgValue],
-        propagated_debug_info: Optional[FunctionDebugInfo],
+        propagated_debug_info: FunctionDebugInfo | None,
     ) -> QuantumFunctionCall:
         call = self._create_quantum_function_call(
             function, args, propagated_debug_info=propagated_debug_info
@@ -182,8 +179,8 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], ModelR
 
     @staticmethod
     def _get_back_ref(
-        propagated_debug_info: Optional[FunctionDebugInfo],
-    ) -> Optional[UUID]:
+        propagated_debug_info: FunctionDebugInfo | None,
+    ) -> UUID | None:
         if propagated_debug_info is None:
             return None
         if propagated_debug_info.node is None:
@@ -194,7 +191,7 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], ModelR
         self,
         function: FunctionClosure,
         args: list[ArgValue],
-        propagated_debug_info: Optional[FunctionDebugInfo],
+        propagated_debug_info: FunctionDebugInfo | None,
     ) -> QuantumFunctionCall:
         function = function.clone()
         function = function.set_depth(self._builder.current_function.depth + 1)
@@ -218,7 +215,7 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], ModelR
             new_positional_arg_decls = new_declaration.positional_arg_declarations
             evaluated_args = [
                 arg
-                for param, arg in zip_strict(
+                for param, arg in zip(
                     function.positional_arg_declarations, evaluated_args, strict=True
                 )
                 if isinstance(arg.value, QuantumVariable)
@@ -235,7 +232,7 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], ModelR
         )
         new_positional_args = [
             arg.emit(param)
-            for param, arg in zip_strict(
+            for param, arg in zip(
                 new_positional_arg_decls[
                     : len(new_positional_arg_decls) - len(captured_args)
                 ],
@@ -394,6 +391,7 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], ModelR
                 function,
                 evaluated_args,
             ),
+            permutation=function.permutation,
         )
 
     def _validate_call_args(
@@ -425,27 +423,30 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], ModelR
     def _validate_type_modifiers(
         self, func_context: FunctionContext, func_def: NativeFunctionDefinition
     ) -> None:
-        if self._should_override_type_modifiers(func_context):
-            self._override_type_modifiers(func_def)
-
-        unchecked = self._functions_compilation_metadata.get(
+        compilation_metadata = self._functions_compilation_metadata.get(
             func_context.name, CompilationMetadata()
-        ).unchecked
-        TypeModifierValidation(
-            skip_validation=self._interpreter.skip_type_modifier_validation
-        ).run(func_def, unchecked)
+        )
+        infer_and_validate_uncomputation_signature(
+            func_def,
+            disable_perm_check=self._interpreter.skip_type_modifier_validation
+            or compilation_metadata.disable_perm_check,
+            disable_const_checks=self._interpreter.skip_type_modifier_validation
+            or compilation_metadata.disable_const_checks,
+            tighten_signature=self._should_tighten_signature(func_context),
+        )
 
     @staticmethod
-    def _should_override_type_modifiers(func_context: FunctionContext) -> bool:
+    def _should_tighten_signature(func_context: FunctionContext) -> bool:
         """
-        The type modifier can be changed according to the operand passed to the
-        function. For example,
-        apply_to_all(X, q) --> q will be Permutable after expansion
-        apply_to_all(H, q) --> q will be Quantum after expansion
-        This also holds for the intermediate lambda created during the expansion.
-
-        We don't override the type modifier if it's explicitly specified (Permutable or
-        Const), neither in the function declaration nor in the operand declaration.
+        In some cases we want to tighten the function signature (adding "const" or
+        "permutation" modifiers) when possible:
+            - Lambda functions (which are defined without modifiers)
+            - Functions which receive operands and their modifiers depend on the operand
+
+        For example:
+            - apply_to_all(Z, q) --> q will become `const` and the function will become `permutation`
+            - apply_to_all(X, q) --> the function will become `permutation`
+            - apply_to_all(H, q) --> no change
         """
 
         if func_context.is_lambda:
@@ -466,10 +467,3 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], ModelR
                 for param_decl in orig_func.positional_arg_declarations
             )
         )
-
-    @staticmethod
-    def _override_type_modifiers(func_def: NativeFunctionDefinition) -> None:
-        # only override the modifier if it's unspecified (not Permutable or Const)
-        for port in func_def.port_declarations:
-            if port.type_modifier is TypeModifier.Mutable:
-                port.type_modifier = TypeModifier.Inferred

classiq/model_expansions/quantum_operations/declarative_call_emitter.py

@@ -1,5 +1,5 @@
 from itertools import chain
-from typing import TYPE_CHECKING, Generic, Optional
+from typing import TYPE_CHECKING, Generic
 
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
@@ -41,7 +41,7 @@ class DeclarativeCallEmitter(
         return True
 
     def _is_function_purely_declarative(
-        self, function: FunctionClosure, seen_funcs: Optional[set[str]] = None
+        self, function: FunctionClosure, seen_funcs: set[str] | None = None
     ) -> bool:
         if seen_funcs is None:
             seen_funcs = set()

classiq/model_expansions/quantum_operations/emitter.py

@@ -3,9 +3,7 @@ from collections.abc import Sequence
 from typing import (
     TYPE_CHECKING,
     Generic,
-    Optional,
     TypeVar,
-    Union,
 )
 
 from classiq.interface.debug_info.debug_info import (
@@ -113,9 +111,9 @@ class Emitter(Generic[QuantumStatementT], ABC):
         self,
         op: QuantumOperation,
         context_name: str,
-        block_names: Union[None, str, list[str]] = None,
-        params: Optional[Sequence[PositionalArg]] = None,
-        scope: Optional[Scope] = None,
+        block_names: None | str | list[str] = None,
+        params: Sequence[PositionalArg] | None = None,
+        scope: Scope | None = None,
     ) -> OperationContext:
         if isinstance(block_names, str):
             block_names = [block_names]

classiq/model_expansions/quantum_operations/expression_evaluator.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
@@ -24,7 +24,7 @@ class ExpressionEvaluator(Emitter[QuantumOperation]):
         interpreter: "BaseInterpreter",
         expression_name: str,
         *,
-        readable_expression_name: Optional[str] = None,
+        readable_expression_name: str | None = None,
         simplify: bool = False,
         treat_qnum_as_float: bool = False,
         allow_link_time_vars: bool = True,
@@ -73,7 +73,7 @@ class ExpressionEvaluator(Emitter[QuantumOperation]):
                 link_time_vars.append(var_name)
             self._capture_classical_var(var_name, var_type)
         if not self._allow_link_time_vars and len(link_time_vars) > 0:
-            link_time_message = f"link-time variable{s(link_time_vars)} {readable_list(link_time_vars, quote=True)}"
+            link_time_message = f"execution parameter{s(link_time_vars)} {readable_list(link_time_vars, quote=True)}"
         else:
             link_time_message = None
         if not self._allow_runtime_vars and len(runtime_vars) > 0:

classiq/model_expansions/quantum_operations/skip_control_verifier.py

@@ -1,5 +1,4 @@
 from classiq.interface.exceptions import ClassiqExpansionError
-from classiq.interface.helpers.backward_compatibility import zip_strict
 from classiq.interface.model.skip_control import SkipControl
 
 from classiq.model_expansions.function_builder import FunctionContext
@@ -9,7 +8,7 @@ from classiq.model_expansions.quantum_operations.emitter import Emitter
 class SkipControlVerifier(Emitter[SkipControl]):
     def emit(self, skip_control: SkipControl, /) -> bool:
         for op, block in list(
-            zip_strict(self._builder._operations, self._builder._blocks, strict=True)
+            zip(self._builder._operations, self._builder._blocks, strict=True)
         )[::-1]:
             if isinstance(op, FunctionContext):
                 break

classiq/model_expansions/quantum_operations/variable_decleration.py

@@ -1,8 +1,9 @@
-from typing import TYPE_CHECKING, Union, cast
+from typing import TYPE_CHECKING, cast
 
 from classiq.interface.exceptions import ClassiqExpansionError
 from classiq.interface.generator.functions.classical_type import ClassicalType
 from classiq.interface.generator.functions.concrete_types import ConcreteType
+from classiq.interface.helpers.text_utils import readable_list, s
 from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.quantum_type import QuantumType
 from classiq.interface.model.variable_declaration_statement import (
@@ -13,11 +14,21 @@ from classiq.evaluators.parameter_types import (
     evaluate_type_in_classical_symbol,
     evaluate_type_in_quantum_symbol,
 )
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
 from classiq.model_expansions.quantum_operations.emitter import Emitter
 from classiq.model_expansions.scope import ClassicalSymbol, Evaluated, QuantumSymbol
 
+if TYPE_CHECKING:
+    from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
+
 
 class VariableDeclarationStatementEmitter(Emitter[VariableDeclarationStatement]):
+    def __init__(
+        self, interpreter: "BaseInterpreter", allow_symbolic_vars: bool = False
+    ) -> None:
+        super().__init__(interpreter)
+        self._allow_symbolic_vars = allow_symbolic_vars
+
     def emit(self, variable_declaration: VariableDeclarationStatement, /) -> bool:
         var_decl = variable_declaration.model_copy(
             update=dict(back_ref=variable_declaration.uuid)
@@ -27,38 +38,59 @@ class VariableDeclarationStatementEmitter(Emitter[VariableDeclarationStatement])
             raise ClassiqExpansionError(
                 f"Variable {variable_declaration.name!r} is already defined"
             )
-        var_value: Union[QuantumSymbol, ClassicalSymbol]
+        var_value: QuantumSymbol | ClassicalSymbol
         if variable_declaration.is_quantum:
-            if TYPE_CHECKING:
-                assert isinstance(var_decl.qmod_type, QuantumType)
-            updated_quantum_type = evaluate_type_in_quantum_symbol(
-                var_decl.qmod_type,
-                self._current_scope,
-                var_decl.name,
-            )
-            var_decl.qmod_type = updated_quantum_type
-            var_value = QuantumSymbol(
-                handle=HandleBinding(name=var_decl.name),
-                quantum_type=updated_quantum_type,
-            )
-            self._builder.current_block.captured_vars.init_var(
-                var_decl.name, self._builder.current_function
-            )
+            var_value = self._get_quantum_var(var_decl)
         else:
-            if TYPE_CHECKING:
-                assert isinstance(var_decl.qmod_type, ClassicalType)
-            updated_classical_type = evaluate_type_in_classical_symbol(
-                var_decl.qmod_type,
-                self._current_scope,
-                var_decl.name,
-            )
-            var_decl.qmod_type = cast(ConcreteType, updated_classical_type)
-            var_value = ClassicalSymbol(
-                handle=HandleBinding(name=var_decl.name),
-                classical_type=updated_classical_type,
-            )
+            var_value = self._get_classical_var(var_decl)
         self._current_scope[variable_declaration.name] = Evaluated(
             value=var_value, defining_function=self._builder.current_function
         )
         self.emit_statement(var_decl)
         return True
+
+    def _get_quantum_var(self, var_decl: VariableDeclarationStatement) -> QuantumSymbol:
+        updated_quantum_type = evaluate_type_in_quantum_symbol(
+            cast(QuantumType, var_decl.qmod_type),
+            self._current_scope,
+            var_decl.name,
+        )
+        if not self._allow_symbolic_vars:
+            symbolic_variables = list(
+                dict.fromkeys(
+                    classical_var.name
+                    for expr in updated_quantum_type.expressions
+                    if isinstance(expr_val := expr.value.value, QmodAnnotatedExpression)
+                    for classical_var in expr_val.get_classical_vars().values()
+                )
+            )
+            if len(symbolic_variables) > 0:
+                raise ClassiqExpansionError(
+                    f"Variable type is instantiated with non-compile-time "
+                    f"variable{s(symbolic_variables)} "
+                    f"{readable_list(symbolic_variables, quote=True)}"
+                )
+        var_decl.qmod_type = updated_quantum_type
+        var_value = QuantumSymbol(
+            handle=HandleBinding(name=var_decl.name),
+            quantum_type=updated_quantum_type,
+        )
+        self._builder.current_block.captured_vars.init_var(
+            var_decl.name, self._builder.current_function
+        )
+        return var_value
+
+    def _get_classical_var(
+        self, var_decl: VariableDeclarationStatement
+    ) -> ClassicalSymbol:
+        updated_classical_type = evaluate_type_in_classical_symbol(
+            cast(ClassicalType, var_decl.qmod_type),
+            self._current_scope,
+            var_decl.name,
+        )
+        var_decl.qmod_type = cast(ConcreteType, updated_classical_type)
+        var_value = ClassicalSymbol(
+            handle=HandleBinding(name=var_decl.name),
+            classical_type=updated_classical_type,
+        )
+        return var_value