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

classiq/model_expansions/quantum_operations/allocate.py

@@ -5,6 +5,9 @@ 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.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
@@ -55,7 +58,9 @@ class AllocateEmitter(Emitter[Allocate]):
             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):
+        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(

classiq/model_expansions/quantum_operations/assignment_result_processor.py

@@ -1,6 +1,12 @@
+from classiq.interface.exceptions import ClassiqExpansionError
 from classiq.interface.generator.arith.arithmetic import compute_arithmetic_result_type
-from classiq.interface.generator.functions.port_declaration import (
-    PortDeclarationDirection,
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.model.allocate import Allocate
+from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.handle_binding import (
+    ConcreteHandleBinding,
+    HandleBinding,
+    SubscriptHandleBinding,
 )
 from classiq.interface.model.quantum_expressions.arithmetic_operation import (
     ArithmeticOperation,
@@ -9,6 +15,12 @@ from classiq.interface.model.quantum_expressions.arithmetic_operation import (
 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.variable_declaration_statement import (
+    VariableDeclarationStatement,
+)
+from classiq.interface.model.within_apply_operation import WithinApply
 
 from classiq.model_expansions.evaluators.quantum_type_utils import copy_type_information
 from classiq.model_expansions.quantum_operations.arithmetic.explicit_boolean_expressions import (
@@ -18,26 +30,49 @@ from classiq.model_expansions.quantum_operations.arithmetic.explicit_boolean_exp
 from classiq.model_expansions.quantum_operations.emitter import Emitter
 from classiq.model_expansions.scope import QuantumSymbol
 from classiq.model_expansions.transformers.ast_renamer import rename_variables
+from classiq.qmod.builtins.functions.standard_gates import CX
 
 
 class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
     def emit(self, op: QuantumAssignmentOperation, /) -> bool:
-        if (
+        if not (
             isinstance(op, ArithmeticOperation)
             and op.operation_kind == ArithmeticOperationKind.Assignment
         ):
-            direction = PortDeclarationDirection.Output
-            self._update_result_type(op)
-            convert_assignment_bool_expression(op)
-        else:
-            direction = PortDeclarationDirection.Inout
-        self._capture_handle(op.result_var, direction)
-        return False
-
-    def _update_result_type(self, op: ArithmeticOperation) -> None:
+            return False
+
+        result_symbol = self._interpreter.evaluate(op.result_var).as_type(QuantumSymbol)
+        result_type = result_symbol.quantum_type
+
+        validate_assignment_bool_expression(
+            result_symbol, op.expression.expr, op.operation_kind
+        )
+        convert_assignment_bool_expression(op)
+
+        inferred_result_type = self._infer_result_type(op)
+        if inferred_result_type is None:
+            return False
+
+        if not isinstance(result_type, QuantumNumeric):
+            copy_type_information(
+                inferred_result_type, result_symbol.quantum_type, str(op.result_var)
+            )
+            return False
+
+        self._copy_numeric_attributes(result_type, inferred_result_type)
+        if self._same_numeric_attributes(result_type, inferred_result_type):
+            return False
+
+        self._validate_declared_attributes(
+            result_type, inferred_result_type, str(op.result_var)
+        )
+        self._assign_to_inferred_var_and_bind(op, result_type, inferred_result_type)
+        return True
+
+    def _infer_result_type(self, op: ArithmeticOperation) -> QuantumNumeric | None:
         expr = self._evaluate_expression(op.expression)
         if len(self._get_classical_vars_in_expression(expr)):
-            return
+            return None
         symbols = self._get_symbols_in_expression(expr)
         expr_str = rename_variables(
             expr.expr,
@@ -48,16 +83,180 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
             expr_str = expr_str.replace(
                 symbol.handle.qmod_expr, symbol.handle.identifier
             )
-        result_type = compute_arithmetic_result_type(
+        return compute_arithmetic_result_type(
             expr_str,
             {symbol.handle.identifier: symbol.quantum_type for symbol in symbols},
             self._machine_precision,
         )
-        result_symbol = self._interpreter.evaluate(op.result_var).as_type(QuantumSymbol)
 
-        validate_assignment_bool_expression(
-            result_symbol, op.expression.expr, op.operation_kind
-        )  # must be here, otherwise copy_type_information will throw a non-indicative error
-        copy_type_information(
-            result_type, result_symbol.quantum_type, str(op.result_var)
+    @staticmethod
+    def _copy_numeric_attributes(
+        result_type: QuantumNumeric, inferred_result_type: QuantumNumeric
+    ) -> None:
+        if not result_type.has_size_in_bits:
+            result_type.size = Expression(expr=str(inferred_result_type.size_in_bits))
+        if not result_type.has_sign:
+            result_type.is_signed = Expression(
+                expr=str(inferred_result_type.sign_value)
+            )
+        if not result_type.has_fraction_digits:
+            result_type.fraction_digits = Expression(
+                expr=str(inferred_result_type.fraction_digits_value)
+            )
+
+    @staticmethod
+    def _same_numeric_attributes(
+        result_type: QuantumNumeric, inferred_result_type: QuantumNumeric
+    ) -> bool:
+        return (
+            result_type.size_in_bits == inferred_result_type.size_in_bits
+            and result_type.sign_value == inferred_result_type.sign_value
+            and result_type.fraction_digits_value
+            == inferred_result_type.fraction_digits_value
+        )
+
+    @classmethod
+    def _validate_declared_attributes(
+        cls, result_type: QuantumNumeric, inferred_result_type: QuantumNumeric, var: str
+    ) -> None:
+        result_size, result_sign, result_fractions = (
+            result_type.size_in_bits,
+            result_type.sign_value,
+            result_type.fraction_digits_value,
+        )
+        inferred_size, inferred_sign, inferred_fractions = (
+            inferred_result_type.size_in_bits,
+            inferred_result_type.sign_value,
+            inferred_result_type.fraction_digits_value,
+        )
+        result_integers = result_size - result_fractions
+        inferred_integers = inferred_size - inferred_fractions
+
+        if (
+            (result_integers < inferred_integers)
+            or (result_fractions < inferred_fractions)
+            or (not result_sign and inferred_sign)
+            or (
+                result_sign
+                and not inferred_sign
+                and result_integers == inferred_integers
+            )
+        ):
+            if (
+                not result_sign
+                and result_fractions == 0
+                and not inferred_sign
+                and inferred_fractions == 0
+            ):
+                result_size_str = f"size {result_size}"
+                inferred_size_str = f"size {inferred_size}"
+                hint = f"Hint: increase the size in the declaration of {var!r} or omit it to enable automatic inference."
+            else:
+                result_size_str = f"size {result_size}, {'signed' if result_sign else 'unsigned'}, and {result_fractions} fraction digits"
+                inferred_size_str = f"size {inferred_size}, {'signed' if inferred_sign else 'unsigned'}, and {inferred_fractions} fraction digits"
+                hint = f"Hint: omit the numeric attributes from the declaration of {var!r} to enable automatic inference."
+            raise ClassiqExpansionError(
+                f"Cannot assign an expression with inferred {inferred_size_str} to variable {var!r} with declared {result_size_str}. {hint}"
+            )
+
+    @staticmethod
+    def _craft_size_string(size: int, is_signed: bool, fraction_digits: int) -> str:
+        extra = (
+            f", with {fraction_digits} fraction digits" if fraction_digits > 0 else ""
+        )
+        return f"{size} ({'signed' if is_signed else 'unsigned'}{extra})"
+
+    def _assign_to_inferred_var_and_bind(
+        self,
+        op: ArithmeticOperation,
+        result_type: QuantumNumeric,
+        inferred_result_type: QuantumNumeric,
+    ) -> None:
+        handles: list[HandleBinding] = []
+
+        extra_fraction_digits = (
+            result_type.fraction_digits_value
+            - inferred_result_type.fraction_digits_value
+        )
+        if extra_fraction_digits > 0:
+            handles.append(
+                self._declare_qarray("extra_fraction_digits", extra_fraction_digits)
+            )
+
+        inferred_result_name = self._counted_name_allocator.allocate("inferred_result")
+        inferred_result_handle = HandleBinding(name=inferred_result_name)
+        self._interpreter.emit(
+            VariableDeclarationStatement(
+                name=inferred_result_name, quantum_type=inferred_result_type
+            )
+        )
+        handles.append(inferred_result_handle)
+        modified_op = op.model_copy(update={"result_var": inferred_result_handle})
+        self._interpreter.add_to_debug_info(modified_op)
+        self._interpreter.emit(modified_op)
+
+        result_integer_size = (
+            result_type.size_in_bits - result_type.fraction_digits_value
+        )
+        inferred_result_integer_size = (
+            inferred_result_type.size_in_bits
+            - inferred_result_type.fraction_digits_value
+        )
+        extra_integers = result_integer_size - inferred_result_integer_size
+        if extra_integers > 0:
+            handles.append(self._declare_qarray("extra_integers", extra_integers))
+
+        self._interpreter.emit(
+            BindOperation(in_handles=handles, out_handles=[op.result_var])
+        )
+
+        if (
+            result_type.sign_value
+            and inferred_result_type.sign_value
+            and extra_integers > 0
+        ):
+            sign_idx = result_type.size_in_bits - extra_integers - 1
+            self._sign_extension(op.result_var, sign_idx, result_type.size_in_bits)
+
+    def _declare_qarray(
+        self,
+        prefix: str,
+        size: int,
+        allocate: bool = True,
+    ) -> HandleBinding:
+        name = self._counted_name_allocator.allocate(prefix)
+        handle = HandleBinding(name=name)
+        quantum_type = QuantumBitvector(length=Expression(expr=str(size)))
+        self._interpreter.emit(
+            VariableDeclarationStatement(name=name, quantum_type=quantum_type)
+        )
+        if allocate:
+            self._interpreter.emit(Allocate(target=handle))
+        return handle
+
+    def _sign_extension(
+        self,
+        result_var: ConcreteHandleBinding,
+        sign_idx: int,
+        size: int,
+    ) -> None:
+        aux = self._declare_qarray("inferred_result_aux", size, allocate=False)
+        self._interpreter.emit(
+            WithinApply(
+                compute=[BindOperation(in_handles=[result_var], out_handles=[aux])],
+                action=[
+                    QuantumFunctionCall(
+                        function=CX.func_decl.name,
+                        positional_args=[
+                            SubscriptHandleBinding(
+                                base_handle=aux, index=Expression(expr=str(sign_idx))
+                            ),
+                            SubscriptHandleBinding(
+                                base_handle=aux, index=Expression(expr=str(idx))
+                            ),
+                        ],
+                    )
+                    for idx in range(sign_idx + 1, size)
+                ],
+            )
         )

classiq/model_expansions/quantum_operations/bind.py

@@ -1,3 +1,5 @@
+from typing import TYPE_CHECKING
+
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
     ClassiqInternalExpansionError,
@@ -14,41 +16,21 @@ from classiq.model_expansions.evaluators.quantum_type_utils import (
 from classiq.model_expansions.quantum_operations.emitter import Emitter
 from classiq.model_expansions.scope import Evaluated, QuantumSymbol
 
+if TYPE_CHECKING:
+    from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
+
 
 class BindEmitter(Emitter[BindOperation]):
+    def __init__(
+        self, interpreter: "BaseInterpreter", allow_symbolic_size: bool = False
+    ) -> None:
+        super().__init__(interpreter)
+        self._allow_symbolic_size = allow_symbolic_size
+
     def emit(self, bind: BindOperation, /) -> bool:
         inputs, outputs = self._get_inputs_outputs(bind)
         validate_bind_targets(bind, self._current_scope)
-        unsized_outputs = [
-            output for output in outputs if not output.quantum_type.has_size_in_bits
-        ]
-
-        if len(unsized_outputs) > 1:
-            raise ClassiqExpansionError(
-                f"Cannot perform the split operation {bind.in_handles[0].name} -> {{{', '.join(out_handle.name for out_handle in bind.out_handles)}}}:\n"
-                f"Quantum variables {', '.join(str(out_handle.handle) for out_handle in unsized_outputs)} are used as bind outputs, but their size cannot be inferred."
-            )
-
-        input_size = sum(input.quantum_type.size_in_bits for input in inputs)
-        output_size = sum(
-            output.quantum_type.size_in_bits
-            for output in outputs
-            if output.quantum_type.has_size_in_bits
-        )
-
-        if len(unsized_outputs) == 1:
-            set_size(
-                unsized_outputs[0].quantum_type,
-                input_size - output_size,
-                str(unsized_outputs[0].handle),
-            )
-
-        else:
-            if input_size != output_size:
-                raise ClassiqExpansionError(
-                    f"The total size for the input and output of the bind operation must be the same. The in size is {input_size} and the out size is {output_size}"
-                )
-
+        self._process_var_sizes(bind, inputs, outputs)
         self.emit_statement(
             BindOperation(
                 in_handles=bind.in_handles,
@@ -111,3 +93,45 @@ class BindEmitter(Emitter[BindOperation]):
                     f"{out.value.handle.name!r} on the right-hand side of a bind "
                     f"statement"
                 )
+
+    def _process_var_sizes(
+        self,
+        bind: BindOperation,
+        inputs: list[QuantumSymbol],
+        outputs: list[QuantumSymbol],
+    ) -> None:
+        unsized_inputs = [
+            input for input in inputs if not input.quantum_type.has_size_in_bits
+        ]
+        if len(unsized_inputs) > 0:
+            if self._allow_symbolic_size:
+                return
+            raise ClassiqInternalExpansionError("Uninitialized bind inputs")
+
+        unsized_outputs = [
+            output for output in outputs if not output.quantum_type.has_size_in_bits
+        ]
+        if len(unsized_outputs) > 1:
+            if self._allow_symbolic_size:
+                return
+            raise ClassiqExpansionError(
+                f"Cannot perform the split operation {bind.in_handles[0].name} -> {{{', '.join(out_handle.name for out_handle in bind.out_handles)}}}:\n"
+                f"Quantum variables {', '.join(str(out_handle.handle) for out_handle in unsized_outputs)} are used as bind outputs, but their size cannot be inferred."
+            )
+
+        input_size = sum(input.quantum_type.size_in_bits for input in inputs)
+        output_size = sum(
+            output.quantum_type.size_in_bits
+            for output in outputs
+            if output.quantum_type.has_size_in_bits
+        )
+        if len(unsized_outputs) == 1:
+            set_size(
+                unsized_outputs[0].quantum_type,
+                input_size - output_size,
+                str(unsized_outputs[0].handle),
+            )
+        elif input_size != output_size:
+            raise ClassiqExpansionError(
+                f"The total size for the input and output of the bind operation must be the same. The in size is {input_size} and the out size is {output_size}"
+            )

classiq/model_expansions/quantum_operations/block_evaluator.py

@@ -1,8 +1,14 @@
 from collections.abc import Sequence
 from typing import TYPE_CHECKING
 
+from classiq.interface.generator.functions.builtins.internal_operators import (
+    CLASSICAL_IF_OPERATOR_NAME,
+    REPEAT_OPERATOR_NAME,
+)
+from classiq.interface.model.classical_if import ClassicalIf
 from classiq.interface.model.quantum_function_declaration import PositionalArg
 from classiq.interface.model.quantum_statement import QuantumOperation, QuantumStatement
+from classiq.interface.model.repeat import Repeat
 
 from classiq.model_expansions.closure import Closure
 from classiq.model_expansions.quantum_operations.emitter import Emitter
@@ -88,3 +94,39 @@ class BlockEvaluator(Emitter[QuantumOperation]):
 
     def get_scope(self, op: QuantumOperation) -> Scope:
         return Scope(parent=self._current_scope)
+
+
+class IfElimination(BlockEvaluator):
+    def __init__(self, interpreter: "BaseInterpreter") -> None:
+        super().__init__(interpreter, CLASSICAL_IF_OPERATOR_NAME, "then", "else_")
+
+    def emit(self, op: ClassicalIf, /) -> bool:  # type:ignore[override]
+        cond = op.condition.value.value
+        if not isinstance(cond, bool):
+            return False
+        if op.is_generative():
+            if cond:
+                then_block = op.get_generative_block("then")
+                op.clear_generative_blocks()
+                op.set_generative_block("then", then_block)
+            elif not op.has_generative_block("else_"):
+                op.clear_generative_blocks()
+            else:
+                else_block = op.get_generative_block("else_")
+                op.clear_generative_blocks()
+                op.set_generative_block("else_", else_block)
+        else:
+            if cond:
+                op = op.model_copy(update={"else_": []})
+            else:
+                op = op.model_copy(update={"then": []})
+        return super().emit(op)
+
+
+class RepeatElimination(BlockEvaluator):
+    def __init__(self, interpreter: "BaseInterpreter") -> None:
+        super().__init__(interpreter, REPEAT_OPERATOR_NAME, "body")
+
+    def emit(self, op: Repeat, /) -> bool:  # type:ignore[override]
+        count = op.count.value.value
+        return isinstance(count, int) and count == 0

classiq/model_expansions/quantum_operations/call_emitter.py

@@ -10,7 +10,10 @@ from uuid import UUID
 
 import sympy
 
-from classiq.interface.debug_info.debug_info import FunctionDebugInfo
+from classiq.interface.debug_info.debug_info import (
+    FunctionDebugInfo,
+    calculate_port_to_passed_variable_mapping,
+)
 from classiq.interface.exceptions import ClassiqExpansionError
 from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
     AnyClassicalValue,
@@ -90,13 +93,15 @@ 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 isinstance(arg, (ClassicalProxy, AnyClassicalValue))
+    return False
 
 
 class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSplitter):
@@ -187,11 +192,13 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
             back_ref=self._get_back_ref(propagated_debug_info),
         )
 
-        port_to_passed_variable_map = {
-            arg_decl.name: str(evaluated_arg.value.handle)
-            for arg_decl, evaluated_arg in zip(new_positional_arg_decls, evaluated_args)
-            if isinstance(arg_decl, PortDeclaration)
-        }
+        port_to_passed_variable_map = calculate_port_to_passed_variable_mapping(
+            new_positional_arg_decls,
+            [
+                arg.value.handle if isinstance(arg.value, QuantumSymbol) else None
+                for arg in evaluated_args
+            ],
+        )
         self._debug_info[new_call.uuid] = FunctionDebugInfo(
             name=new_call.func_name,
             port_to_passed_variable_map=port_to_passed_variable_map,

classiq/model_expansions/quantum_operations/composite_emitter.py

@@ -23,5 +23,5 @@ class CompositeEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT]):
         for emitter in self._emitters:
             if emitter.emit(statement):
                 return True
-        self._builder.emit_statement(statement)
+        self.emit_statement(statement)
         return True

classiq/model_expansions/quantum_operations/declarative_call_emitter.py

@@ -1,5 +1,5 @@
 from itertools import chain
-from typing import TYPE_CHECKING, Generic
+from typing import TYPE_CHECKING, Generic, Optional
 
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
@@ -34,13 +34,24 @@ class DeclarativeCallEmitter(
 
         if self._is_function_purely_declarative(
             function
-        ) and self._are_args_purely_declarative(args):
+        ) and self._are_args_purely_declarative(args, function.name):
             self._interpreter.add_purely_declarative_function(function)
             return False
 
         return True
 
-    def _is_function_purely_declarative(self, function: FunctionClosure) -> bool:
+    def _is_function_purely_declarative(
+        self, function: FunctionClosure, seen_funcs: Optional[set[str]] = None
+    ) -> bool:
+        if seen_funcs is None:
+            seen_funcs = set()
+        if function.name in seen_funcs:
+            return True
+        seen_funcs.add(function.name)
+
+        if function.is_atomic:
+            return True
+
         if function.name not in QMODULE.native_defs:
             return False
 
@@ -56,9 +67,9 @@ class DeclarativeCallEmitter(
             return False
 
         dependencies = QMODULE.function_dependencies[function.name]
-        return self._are_identifiers_purely_declarative(dependencies)
+        return self._are_identifiers_purely_declarative(dependencies, seen_funcs)
 
-    def _are_args_purely_declarative(self, args: list[Evaluated]) -> bool:
+    def _are_args_purely_declarative(self, args: list[Evaluated], caller: str) -> bool:
         values = [arg.value for arg in args]
         function_inputs: list[FunctionClosure] = list(
             chain.from_iterable(
@@ -78,10 +89,13 @@ class DeclarativeCallEmitter(
         if any(func.is_lambda for func in function_inputs):
             return False
         dependencies = [func.name for func in function_inputs if not func.is_lambda]
-        return self._are_identifiers_purely_declarative(dependencies)
+        return self._are_identifiers_purely_declarative(dependencies, {caller})
 
-    def _are_identifiers_purely_declarative(self, dependencies: list[str]) -> bool:
-        return not any(
-            isinstance(self._current_scope[dep].value, GenerativeClosure)
+    def _are_identifiers_purely_declarative(
+        self, dependencies: list[str], seen_funcs: set[str]
+    ) -> bool:
+        return all(
+            self._is_function_purely_declarative(self._current_scope[dep].value)
             for dep in dependencies
+            if seen_funcs is None or dep not in seen_funcs
         )

classiq/model_expansions/quantum_operations/emitter.py

@@ -15,6 +15,11 @@ from classiq.interface.debug_info.debug_info import (
     DebugInfoCollection,
 )
 from classiq.interface.exceptions import ClassiqInternalExpansionError
+from classiq.interface.generator.expressions.atomic_expression_functions import (
+    CLASSICAL_ATTRIBUTES,
+    SUPPORTED_CLASSIQ_BUILTIN_FUNCTIONS,
+    SUPPORTED_PYTHON_BUILTIN_FUNCTIONS,
+)
 from classiq.interface.generator.expressions.evaluated_expression import (
     EvaluatedExpression,
 )
@@ -30,7 +35,11 @@ from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
 from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
-from classiq.interface.model.handle_binding import HandleBinding, NestedHandleBinding
+from classiq.interface.model.handle_binding import (
+    FieldHandleBinding,
+    HandleBinding,
+    NestedHandleBinding,
+)
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.quantum_function_declaration import (
     NamedParamsQuantumFunctionDeclaration,
@@ -220,9 +229,17 @@ class Emitter(Generic[QuantumStatementT], ABC):
         handles = dict.fromkeys(
             handle
             for handle in vrc.var_handles
-            if isinstance(self._current_scope[handle.name].value, QuantumSymbol)
+            if handle.name
+            not in SUPPORTED_PYTHON_BUILTIN_FUNCTIONS
+            | SUPPORTED_CLASSIQ_BUILTIN_FUNCTIONS
+            and isinstance(self._current_scope[handle.name].value, QuantumSymbol)
         )
-        return [self._interpreter.evaluate(handle).value for handle in handles]
+        return [
+            self._interpreter.evaluate(handle).value
+            for handle in handles
+            if not isinstance(handle, FieldHandleBinding)
+            or handle.field not in CLASSICAL_ATTRIBUTES
+        ]
 
     def _get_classical_vars_in_expression(
         self, expr: Expression

classiq/model_expansions/quantum_operations/quantum_function_call.py

@@ -49,13 +49,14 @@ class QuantumFunctionCallEmitter(CallEmitter[QuantumFunctionCall]):
             raise ClassiqInternalExpansionError(
                 f"Unexpected lambda list type {type(funcs).__name__!r}"
             )
-        self._interpreter.emit(self._create_recursive_if(call, index, len(funcs)))
+        for stmt in self._create_recursive_if(call, index, len(funcs)):
+            self._interpreter.emit(stmt)
         return True
 
     @staticmethod
     def _create_recursive_if(
         call: QuantumFunctionCall, index: ClassicalScalarProxy, num_funcs: int
-    ) -> QuantumStatement:
+    ) -> list[QuantumStatement]:
         if TYPE_CHECKING:
             assert isinstance(call.function, OperandIdentifier)
         stmt: list[QuantumStatement] = []
@@ -74,7 +75,7 @@ class QuantumFunctionCallEmitter(CallEmitter[QuantumFunctionCall]):
                     else_=stmt,
                 )
             ]
-        return stmt[0]
+        return stmt
 
 
 class DeclarativeQuantumFunctionCallEmitter(