classiq 0.88.0__py3-none-any.whl → 0.90.0__py3-none-any.whl

classiq/model_expansions/closure.py

@@ -11,6 +11,7 @@ from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
 from classiq.interface.model.quantum_function_declaration import (
     NamedParamsQuantumFunctionDeclaration,
     PositionalArg,
+    QuantumOperandDeclaration,
 )
 from classiq.interface.model.quantum_lambda_function import QuantumCallable
 from classiq.interface.model.quantum_statement import QuantumStatement
@@ -111,6 +112,13 @@ class FunctionClosure(Closure):
     def emit(self) -> QuantumCallable:
         return self.name
 
+    def as_operand_declaration(self, is_list: bool) -> QuantumOperandDeclaration:
+        return QuantumOperandDeclaration(
+            name=self.name,
+            positional_arg_declarations=self.positional_arg_declarations,
+            is_list=is_list,
+        )
+
 
 @dataclass(frozen=True)
 class GenerativeFunctionClosure(GenerativeClosure, FunctionClosure):

classiq/model_expansions/interpreters/base_interpreter.py

@@ -4,7 +4,7 @@ from collections import defaultdict
 from collections.abc import Sequence
 from contextlib import nullcontext
 from functools import singledispatchmethod
-from typing import Any, cast
+from typing import Any, Callable, cast
 
 from pydantic import ValidationError
 
@@ -16,10 +16,8 @@ from classiq.interface.exceptions import (
     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.expressions.expression_types import ExpressionValue
 from classiq.interface.generator.functions.classical_function_declaration import (
     ClassicalFunctionDeclaration,
 )
@@ -42,8 +40,20 @@ from classiq.interface.model.quantum_lambda_function import (
 )
 from classiq.interface.model.quantum_statement import QuantumStatement
 
-from classiq.evaluators.classical_expression import (
-    evaluate_classical_expression,
+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,
+)
+from classiq.evaluators.qmod_expression_visitors.qmod_expression_simplifier import (
+    simplify_qmod_expression,
+)
+from classiq.evaluators.qmod_node_evaluators.utils import is_classical_integer
+from classiq.evaluators.qmod_type_inference.classical_type_inference import (
+    infer_classical_type,
 )
 from classiq.model_expansions.closure import (
     Closure,
@@ -67,7 +77,6 @@ from classiq.model_expansions.scope_initialization import (
     init_top_level_scope,
 )
 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
@@ -75,7 +84,17 @@ from classiq.qmod.model_state_container import QMODULE
 from classiq.qmod.semantics.annotation.qstruct_annotator import QStructAnnotator
 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
+
+
+def _validate_index(val: ExpressionValue, subject: str) -> None:
+    if isinstance(val, QmodAnnotatedExpression):
+        val_type = val.get_type(val.root)
+    else:
+        val_type = infer_classical_type(val)
+    if not is_classical_integer(val_type):
+        raise ClassiqExpansionError(
+            f"{subject} indices must be integers, not {val_type.raw_qmod_type_name}"
+        )
 
 
 class BaseInterpreter:
@@ -130,6 +149,12 @@ class BaseInterpreter:
         try:
             with self._error_manager.call("main"):
                 self._expand_main_func()
+        except RecursionError:
+            self._error_manager.add_error(
+                "RecursionError: maximum recursion depth exceeded. Tip: If your "
+                "program contains recursive functions, check for base cases using a "
+                "Python if-statement (instead of Qmod's `if_`)"
+            )
         except Exception as e:
             if isinstance(e, ClassiqInternalExpansionError) or debug_mode.get():
                 raise e
@@ -175,22 +200,56 @@ class BaseInterpreter:
     def evaluate(self, expression: Any) -> Evaluated:
         raise NotImplementedError(f"Cannot evaluate {expression!r}")
 
+    def get_foreign_functions(self) -> dict[str, Callable]:
+        return {}
+
     @evaluate.register
-    def evaluate_classical_expression(self, expression: Expression) -> Evaluated:
-        expr = evaluate_classical_expression(expression, self._builder.current_scope)
-        vrc = VarRefCollector(ignore_duplicated_handles=True, unevaluated=True)
-        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].value, QuantumSymbol
-            ):
+    def evaluate_classical_expression(
+        self,
+        expression: Expression,
+        *,
+        simplify: bool = False,
+        treat_qnum_as_float: bool = False,
+    ) -> Evaluated:
+        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)
+            expr_val = self._eval_expr(simplified_expr, treat_qnum_as_float)
+        if expr_val.has_value(expr_val.root):
+            value = expr_val.get_value(expr_val.root)
+        else:
+            value = expr_val
+
+        return Evaluated(value=value)
+
+    def _eval_expr(
+        self, expr: str, treat_qnum_as_float: bool
+    ) -> QmodAnnotatedExpression:
+        return evaluate_qmod_expression(
+            expr,
+            treat_qnum_as_float=treat_qnum_as_float,
+            machine_precision=self._model.preferences.machine_precision,
+            classical_struct_declarations=list(QMODULE.type_decls.values()),
+            enum_declarations=list(QMODULE.enum_decls.values()),
+            classical_function_declarations=list(
+                ClassicalFunctionDeclaration.FOREIGN_FUNCTION_DECLARATIONS.values()
+            ),
+            classical_function_callables=self.get_foreign_functions(),
+            scope={
+                name: processed_val
+                for name in list(self._builder.current_scope)
                 if (
-                    isinstance(handle, FieldHandleBinding)
-                    and handle.field in CLASSICAL_ATTRIBUTES
-                ):
-                    handle = handle.base_handle
-                self.evaluate(handle)
-        return expr
+                    processed_val := process_scope_val(
+                        self._builder.current_scope[name].value
+                    )
+                )
+                is not None
+            },
+        )
 
     @evaluate.register
     def evaluate_identifier(self, identifier: str) -> Evaluated:
@@ -216,6 +275,8 @@ class BaseInterpreter:
         )
         start = self.evaluate(sliced_handle_binding.start).value
         end = self.evaluate(sliced_handle_binding.end).value
+        _validate_index(start, "Slice")
+        _validate_index(end, "Slice")
         return Evaluated(value=quantum_variable[start:end])
 
     @evaluate.register
@@ -232,6 +293,7 @@ class BaseInterpreter:
     def evaluate_subscript_operand(self, subscript: OperandIdentifier) -> Evaluated:
         base_value = self.evaluate(subscript.name)
         index_value = self.evaluate(subscript.index).as_type(int)
+        _validate_index(index_value, "Array")
         return Evaluated(value=base_value.value[index_value])
 
     @evaluate.register

classiq/model_expansions/interpreters/frontend_generative_interpreter.py

@@ -45,7 +45,7 @@ class FrontendGenerativeInterpreter(GenerativeInterpreter):
         return super()._get_main_closure(main_func)
 
     def process_exception(self, e: Exception) -> None:
-        if not isinstance(e, (ClassiqError, ValidationError)):
+        if not isinstance(e, (ClassiqError, ValidationError, RecursionError)):
             frame = inspect.trace()[-1]
             module = inspect.getmodule(frame[0])
             if module is None or not module.__name__.startswith("classiq."):

classiq/model_expansions/interpreters/generative_interpreter.py

@@ -183,7 +183,9 @@ class GenerativeInterpreter(BaseInterpreter):
             self,
             [
                 HandleEvaluator(self, "result_var"),
-                ExpressionEvaluator(self, "expression"),
+                ExpressionEvaluator(
+                    self, "expression", simplify=True, treat_qnum_as_float=True
+                ),
                 AssignmentResultProcessor(self),
             ],
         ).emit(op)
@@ -197,7 +199,7 @@ class GenerativeInterpreter(BaseInterpreter):
             self,
             [
                 HandleEvaluator(self, "result_var"),
-                ExpressionEvaluator(self, "expression"),
+                ExpressionEvaluator(self, "expression", simplify=True),
                 ClassicalVarEmitter(self),
                 AssignmentResultProcessor(self),
             ],
@@ -210,7 +212,7 @@ class GenerativeInterpreter(BaseInterpreter):
             [
                 HandleEvaluator(self, "target"),
                 HandleEvaluator(self, "value"),
-                ExpressionEvaluator(self, "value"),
+                ExpressionEvaluator(self, "value", simplify=True),
             ],
         ).emit(op)
 
@@ -276,7 +278,7 @@ class GenerativeInterpreter(BaseInterpreter):
         CompositeEmitter[Control](
             self,
             [
-                ExpressionEvaluator(self, "expression"),
+                ExpressionEvaluator(self, "expression", simplify=True),
                 BlockEvaluator(
                     self,
                     CONTROL_OPERATOR_NAME,
@@ -301,7 +303,7 @@ class GenerativeInterpreter(BaseInterpreter):
         CompositeEmitter[PhaseOperation](
             self,
             [
-                ExpressionEvaluator(self, "expression"),
+                ExpressionEvaluator(self, "expression", simplify=True),
                 ExpressionEvaluator(self, "theta"),
             ],
         ).emit(phase)

classiq/model_expansions/quantum_operations/allocate.py

@@ -1,10 +1,16 @@
-from typing import TYPE_CHECKING, Union
+from typing import TYPE_CHECKING, Any, Union
 
 import sympy
 
 from classiq.interface.debug_info.debug_info import FunctionDebugInfo
 from classiq.interface.exceptions import ClassiqExpansionError, ClassiqValueError
+from classiq.interface.generator.expressions.evaluated_expression import (
+    EvaluatedExpression,
+)
 from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.expression_types import ExpressionValue
+from classiq.interface.generator.functions.classical_type import Bool, Integer, Real
+from classiq.interface.helpers.text_utils import s
 from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.handle_binding import NestedHandleBinding
 from classiq.interface.model.quantum_type import (
@@ -12,6 +18,8 @@ from classiq.interface.model.quantum_type import (
     QuantumNumeric,
 )
 
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
+from classiq.evaluators.qmod_node_evaluators.utils import get_sympy_type
 from classiq.evaluators.qmod_type_inference.quantum_type_inference import (
     inject_quantum_type_attributes_inplace,
 )
@@ -22,6 +30,13 @@ if TYPE_CHECKING:
     from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
 
 
+def _assign_attr(
+    op_update_dict: dict[str, Expression], attr: str, size_value: ExpressionValue
+) -> None:
+    op_update_dict[attr] = Expression(expr=str(size_value))
+    op_update_dict[attr]._evaluated_expr = EvaluatedExpression(value=size_value)
+
+
 class AllocateEmitter(Emitter[Allocate]):
     def __init__(
         self, interpreter: "BaseInterpreter", allow_symbolic_attrs: bool = False
@@ -86,7 +101,7 @@ class AllocateEmitter(Emitter[Allocate]):
             raise ClassiqValueError(
                 f"Could not infer the size of variable {str(target.handle)!r}"
             )
-        op_update_dict["size"] = Expression(expr=expr)
+        op_update_dict["size"] = self._evaluate_expression(Expression(expr=expr))
 
     def _handle_with_size(
         self,
@@ -95,10 +110,10 @@ class AllocateEmitter(Emitter[Allocate]):
         op_update_dict: dict[str, Expression],
     ) -> None:
         size_value = self._interpret_size(size, str(target.handle))
-        op_update_dict["size"] = Expression(expr=str(size_value))
+        _assign_attr(op_update_dict, "size", size_value)
 
         if not isinstance(
-            size_value, sympy.Basic
+            size_value, QmodAnnotatedExpression
         ) and not inject_quantum_type_attributes_inplace(
             QuantumBitvector(length=op_update_dict["size"]), target.quantum_type
         ):
@@ -122,16 +137,19 @@ class AllocateEmitter(Emitter[Allocate]):
             )
 
         size_value = self._interpret_size(size, var_name)
-        op_update_dict["size"] = Expression(expr=str(size_value))
+        _assign_attr(op_update_dict, "size", size_value)
         is_signed_value = self._interpret_is_signed(is_signed)
-        op_update_dict["is_signed"] = Expression(expr=str(is_signed_value))
+        _assign_attr(op_update_dict, "is_signed", is_signed_value)
         fraction_digits_value = self._interpret_fraction_digits(fraction_digits)
-        op_update_dict["fraction_digits"] = Expression(expr=str(fraction_digits_value))
+        _assign_attr(op_update_dict, "fraction_digits", fraction_digits_value)
+        self._validate_numeric_atrributes(
+            var_name, size_value, is_signed_value, fraction_digits_value
+        )
 
         if not (
-            isinstance(size_value, sympy.Basic)
-            or isinstance(is_signed_value, sympy.Basic)
-            or isinstance(fraction_digits_value, sympy.Basic)
+            isinstance(size_value, QmodAnnotatedExpression)
+            or isinstance(is_signed_value, QmodAnnotatedExpression)
+            or isinstance(fraction_digits_value, QmodAnnotatedExpression)
         ) and not inject_quantum_type_attributes_inplace(
             QuantumNumeric(
                 size=op_update_dict["size"],
@@ -145,24 +163,73 @@ class AllocateEmitter(Emitter[Allocate]):
                 f"{var_name!r} of type {target.quantum_type.qmod_type_name}"
             )
 
+    def _validate_numeric_atrributes(
+        self,
+        var_name: str,
+        size_value: Any,
+        is_signed_value: Any,
+        fraction_digits_value: Any,
+    ) -> None:
+        if (
+            isinstance(size_value, int)
+            and isinstance(is_signed_value, bool)
+            and isinstance(fraction_digits_value, int)
+        ):
+            if size_value < 0:
+                raise ClassiqValueError(
+                    f"Cannot allocate {size_value} qubit{s(size_value)} for variable "
+                    f"{var_name!r}"
+                )
+            if fraction_digits_value < 0:
+                raise ClassiqValueError(
+                    f"Variable {var_name!r} cannot have a negative number of fraction "
+                    f"digits (got {fraction_digits_value})"
+                )
+            if size_value < fraction_digits_value:
+                raise ClassiqValueError(
+                    f"Cannot allocate {size_value} qubit{s(size_value)} for variable "
+                    f"{var_name!r} with {fraction_digits_value} fraction digits"
+                )
+
     def _interpret_size(
         self, size: Expression, var_name: str
-    ) -> Union[int, float, sympy.Basic]:
+    ) -> Union[int, float, sympy.Basic, QmodAnnotatedExpression]:
         size_value = self._interpreter.evaluate(size).value
-        if not self._allow_symbolic_attrs and not isinstance(size_value, (int, float)):
-            if size.expr == f"{var_name}.size":
-                raise ClassiqValueError(
-                    f"Could not infer the size of variable {var_name!r}"
-                )
+        if not (
+            (
+                isinstance(size_value, QmodAnnotatedExpression)
+                and isinstance(size_value.get_type(size_value.root), (Integer, Real))
+            )
+            or isinstance(size_value, (int, float))
+            or (
+                isinstance(size_value, sympy.Basic)
+                and isinstance(get_sympy_type(size_value), (Integer, Real))
+            )
+        ):
             raise ClassiqValueError(
                 f"The number of allocated qubits must be an integer. Got "
                 f"{str(size_value)!r}"
             )
+        if (
+            isinstance(size_value, QmodAnnotatedExpression)
+            and not self._allow_symbolic_attrs
+        ):
+            raise ClassiqValueError(
+                f"Could not infer the size of variable {var_name!r}"
+            )
         return size_value
 
-    def _interpret_is_signed(self, is_signed: Expression) -> Union[bool, sympy.Basic]:
+    def _interpret_is_signed(
+        self, is_signed: Expression
+    ) -> Union[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):
+        if not self._allow_symbolic_attrs and not (
+            isinstance(is_signed_value, bool)
+            or (
+                isinstance(is_signed_value, sympy.Basic)
+                and isinstance(get_sympy_type(is_signed_value), Bool)
+            )
+        ):
             raise ClassiqValueError(
                 f"The sign of a variable must be boolean. Got "
                 f"{str(is_signed_value)!r}"
@@ -171,10 +238,14 @@ class AllocateEmitter(Emitter[Allocate]):
 
     def _interpret_fraction_digits(
         self, fraction_digits: Expression
-    ) -> Union[int, float, sympy.Basic]:
+    ) -> Union[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)
+        if not self._allow_symbolic_attrs and not (
+            isinstance(fraction_digits_value, (int, float))
+            or (
+                isinstance(fraction_digits_value, sympy.Expr)
+                and fraction_digits_value.is_integer
+            )
         ):
             raise ClassiqValueError(
                 f"The fraction digits of a variable must be an integer. Got "

classiq/model_expansions/quantum_operations/assignment_result_processor.py

@@ -1,7 +1,6 @@
 from typing import TYPE_CHECKING, Optional
 
 from classiq.interface.exceptions import ClassiqExpansionError
-from classiq.interface.generator.arith.arithmetic import compute_arithmetic_result_type
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.bind_operation import BindOperation
@@ -20,23 +19,31 @@ from classiq.interface.model.quantum_expressions.quantum_expression import (
     QuantumAssignmentOperation,
 )
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
-from classiq.interface.model.quantum_type import QuantumBitvector, QuantumNumeric
+from classiq.interface.model.quantum_type import (
+    QuantumBitvector,
+    QuantumNumeric,
+    QuantumScalar,
+)
 from classiq.interface.model.statement_block import StatementBlock
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
 from classiq.interface.model.within_apply_operation import WithinApply
 
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
 from classiq.evaluators.qmod_type_inference.quantum_type_inference import (
     inject_quantum_type_attributes_inplace,
 )
+from classiq.model_expansions.arithmetic import NumericAttributes
+from classiq.model_expansions.arithmetic_compute_result_attrs import (
+    compute_result_attrs_assign,
+)
 from classiq.model_expansions.quantum_operations.arithmetic.explicit_boolean_expressions import (
     convert_assignment_bool_expression,
     validate_assignment_bool_expression,
 )
 from classiq.model_expansions.quantum_operations.emitter import Emitter
 from classiq.model_expansions.scope import ClassicalSymbol
-from classiq.model_expansions.transformers.ast_renamer import rename_variables
 from classiq.qmod.builtins.functions.standard_gates import CX
 
 if TYPE_CHECKING:
@@ -100,33 +107,27 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
 
     def _infer_expression_type(
         self, op: ArithmeticOperation
-    ) -> Optional[QuantumNumeric]:
+    ) -> Optional[QuantumScalar]:
         expr = self._evaluate_expression(op.expression)
-        if len(self._get_classical_vars_in_expression(expr)):
-            return None
-
-        symbols = self._get_symbols_in_expression(expr)
-        if any(not symbol.quantum_type.is_instantiated for symbol in symbols):
+        expr_val = expr.value.value
+        if isinstance(expr_val, QmodAnnotatedExpression):
+            root_type = expr_val.get_type(expr_val.root)
+            if isinstance(root_type, QuantumScalar) and root_type.is_instantiated:
+                root_type = compute_result_attrs_assign(
+                    NumericAttributes.from_type_or_constant(root_type),
+                    self._machine_precision,
+                ).to_quantum_numeric()
+                return root_type
             return None
-
-        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_str = expr_str.replace(
-                symbol.handle.qmod_expr, symbol.handle.identifier
-            )
-        return compute_arithmetic_result_type(
-            expr_str,
-            {symbol.handle.identifier: symbol.quantum_type for symbol in symbols},
-            self._machine_precision,
-        )
+        if isinstance(expr_val, (int, float)):
+            return NumericAttributes.from_constant(
+                expr_val, self._machine_precision
+            ).to_quantum_numeric()
+        return None
 
     @staticmethod
     def _same_numeric_attributes(
-        result_type: QuantumNumeric, expression_type: QuantumNumeric
+        result_type: QuantumNumeric, expression_type: QuantumScalar
     ) -> bool:
         return (
             result_type.size_in_bits == expression_type.size_in_bits
@@ -137,7 +138,7 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
 
     @classmethod
     def _validate_declared_attributes(
-        cls, result_type: QuantumNumeric, expression_type: QuantumNumeric, var: str
+        cls, result_type: QuantumNumeric, expression_type: QuantumScalar, var: str
     ) -> None:
         result_size, result_sign, result_fractions = (
             result_type.size_in_bits,
@@ -183,7 +184,7 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
         self,
         op: ArithmeticOperation,
         result_type: QuantumNumeric,
-        expression_type: QuantumNumeric,
+        expression_type: QuantumScalar,
     ) -> None:
         stmts: StatementBlock = []
         handles: list[HandleBinding] = []

classiq/model_expansions/quantum_operations/call_emitter.py

@@ -1,29 +1,18 @@
 from collections.abc import Sequence
 from itertools import chain, combinations
 from typing import (
-    Any,
     Generic,
     Optional,
     cast,
 )
 from uuid import UUID
 
-import sympy
-
 from classiq.interface.debug_info.debug_info import (
     FunctionDebugInfo,
     calculate_port_to_passed_variable_mapping,
+    new_function_debug_info_by_node,
 )
 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_proxy import (
-    ClassicalProxy,
-)
-from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
-    QmodStructInstance,
-)
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
@@ -31,6 +20,7 @@ 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 (
     ClassicalParameterDeclaration,
 )
@@ -56,6 +46,7 @@ from classiq.evaluators.argument_types import (
 from classiq.evaluators.parameter_types import (
     evaluate_parameter_types_from_args,
 )
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
 from classiq.model_expansions.capturing.captured_vars import (
     INITIALIZED_VAR_MESSAGE,
     UNINITIALIZED_VAR_MESSAGE,
@@ -73,6 +64,7 @@ from classiq.model_expansions.quantum_operations.function_calls_cache import (
     get_func_call_cache_key,
 )
 from classiq.model_expansions.scope import (
+    ClassicalSymbol,
     Evaluated,
     QuantumSymbol,
     QuantumSymbolList,
@@ -111,18 +103,6 @@ def _validate_cloning(evaluated_args: list[Evaluated]) -> None:
             )
 
 
-def _is_symbolic(arg: Any) -> bool:
-    if isinstance(arg, (ClassicalProxy, AnyClassicalValue)):
-        return True
-    if isinstance(arg, list):
-        return any(_is_symbolic(item) for item in arg)
-    if isinstance(arg, QmodStructInstance):
-        return any(_is_symbolic(item) for item in arg.fields.values())
-    if isinstance(arg, sympy.Basic):
-        return len(arg.free_symbols) > 0
-    return False
-
-
 def _validate_gen_args(
     function: FunctionClosure, evaluated_args: list[Evaluated]
 ) -> None:
@@ -132,7 +112,7 @@ def _validate_gen_args(
         if (
             isinstance(param, ClassicalParameterDeclaration)
             and not param.classical_type.is_purely_declarative
-            and _is_symbolic(arg.value)
+            and isinstance(arg.value, QmodAnnotatedExpression)
         ):
             readable_expr = transform_expression(str(arg.value), {}, {}, one_line=True)
             raise ClassiqExpansionError(
@@ -141,6 +121,27 @@ def _validate_gen_args(
             )
 
 
+def _validate_runtime_args(args: list[Evaluated], scope: Scope) -> None:
+    for arg in args:
+        arg_val = arg.value
+        if not isinstance(arg_val, QmodAnnotatedExpression):
+            continue
+        classical_vars = dict.fromkeys(
+            var.name for var in arg_val.get_classical_vars().values()
+        )
+        runtime_classical_vars = [
+            var
+            for var in classical_vars
+            if isinstance(scope[var].value, ClassicalSymbol)
+        ]
+        if len(runtime_classical_vars) > 0:
+            raise ClassiqExpansionError(
+                f"Passing runtime variable{s(runtime_classical_vars)} "
+                f"{readable_list(runtime_classical_vars, quote=True)} as function call "
+                f"arguments is not supported"
+            )
+
+
 class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], ModelRenamer):
     @staticmethod
     def _should_wrap(body: Sequence[QuantumStatement]) -> bool:
@@ -148,6 +149,11 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], ModelR
         # I'm sure there are better ways to handle it, but this is the simplest way to do it for now
         return any(isinstance(stmt, VariableDeclarationStatement) for stmt in body)
 
+    def _create_block_labeled_ref(self, label: str) -> FunctionDebugInfo:
+        bake_ref_node = Block(statements=[], label=label)
+        self._interpreter.add_to_debug_info(statement=bake_ref_node)
+        return new_function_debug_info_by_node(bake_ref_node)
+
     def _create_expanded_wrapping_function(
         self,
         name: str,
@@ -195,6 +201,7 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], ModelR
         self._validate_call_args(function.positional_arg_declarations, args)
         evaluated_args = [self._interpreter.evaluate(arg) for arg in args]
         _validate_cloning(evaluated_args)
+        _validate_runtime_args(evaluated_args, self._current_scope)
         new_declaration = self._prepare_fully_typed_declaration(
             function, evaluated_args
         )
@@ -385,7 +392,6 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], ModelR
             name=function.name,
             positional_arg_declarations=evaluate_parameter_types_from_args(
                 function,
-                function.signature_scope,
                 evaluated_args,
             ),
         )