classiq 0.84.0__py3-none-any.whl → 0.86.0__py3-none-any.whl

classiq/model_expansions/arithmetic_compute_result_attrs.py

@@ -0,0 +1,71 @@
+from classiq.model_expansions.arithmetic import NumericAttributes
+
+
+def compute_result_attrs_assign(
+    source: NumericAttributes,
+    machine_precision: int,
+) -> NumericAttributes:
+    if machine_precision >= source.fraction_digits:
+        return source
+
+    trimmed_digits = source.fraction_digits - machine_precision
+    return NumericAttributes(
+        size=source.size - trimmed_digits,
+        is_signed=source.is_signed,
+        fraction_digits=machine_precision,
+        bounds=source.bounds,
+        trim_bounds=True,
+    )
+
+
+def compute_result_attrs_bitwise_invert(
+    arg: NumericAttributes,
+    machine_precision: int,
+) -> NumericAttributes:
+    fraction_digits = min(arg.fraction_digits, machine_precision)
+    trimmed_bits = arg.fraction_digits - fraction_digits
+    return NumericAttributes(
+        size=arg.size - trimmed_bits,
+        is_signed=arg.is_signed,
+        fraction_digits=fraction_digits,
+    )
+
+
+def compute_result_attrs_negate(
+    arg: NumericAttributes,
+    machine_precision: int,
+) -> NumericAttributes:
+    lb = -arg.ub
+    ub = -arg.lb
+
+    if arg.size == 1:
+        return NumericAttributes(
+            size=1,
+            is_signed=lb < 0,
+            fraction_digits=arg.fraction_digits,
+            bounds=(lb, ub),
+        )
+    else:
+        return NumericAttributes.from_bounds(
+            lb, ub, arg.fraction_digits, machine_precision
+        )
+
+
+def compute_result_attrs_add(
+    left: NumericAttributes,
+    right: NumericAttributes,
+    machine_precision: int,
+) -> NumericAttributes:
+    lb = left.lb + right.lb
+    ub = left.ub + right.ub
+    fraction_places = max(left.fraction_digits, right.fraction_digits)
+    return NumericAttributes.from_bounds(lb, ub, fraction_places, machine_precision)
+
+
+def compute_result_attrs_subtract(
+    left: NumericAttributes,
+    right: NumericAttributes,
+    machine_precision: int,
+) -> NumericAttributes:
+    tmp = compute_result_attrs_negate(right, machine_precision)
+    return compute_result_attrs_add(left, tmp, machine_precision)

classiq/model_expansions/atomic_expression_functions_defs.py

@@ -9,6 +9,9 @@ from classiq.interface.exceptions import (
     ClassiqExpansionError,
     ClassiqInternalExpansionError,
 )
+from classiq.interface.generator.expressions.atomic_expression_functions import (
+    MEASUREMENT_FUNCTIONS,
+)
 from classiq.interface.generator.expressions.expression_types import (
     ExpressionValue,
     QmodStructInstance,
@@ -49,11 +52,7 @@ from classiq.interface.generator.functions.classical_type import (
 from classiq.interface.generator.functions.type_name import TypeName
 from classiq.interface.helpers.backward_compatibility import zip_strict
 
-from classiq.model_expansions.model_tables import (
-    HandleIdentifier,
-    HandleTable,
-)
-from classiq.model_expansions.sympy_conversion.arithmetics import (
+from classiq.evaluators.qmod_expression_visitors.sympy_wrappers import (
     BitwiseAnd,
     BitwiseNot,
     BitwiseOr,
@@ -62,6 +61,10 @@ from classiq.model_expansions.sympy_conversion.arithmetics import (
     LShift,
     RShift,
 )
+from classiq.model_expansions.model_tables import (
+    HandleIdentifier,
+    HandleTable,
+)
 from classiq.model_expansions.sympy_conversion.expression_to_sympy import (
     MISSING_SLICE_VALUE_PLACEHOLDER,
 )
@@ -398,7 +401,8 @@ def _symbolic_function(func: str) -> Callable:
 
 
 QMOD_CLASSICAL_FUNCTIONS = [
-    _symbolic_function(func) for func in qmod_classical_functions
+    _symbolic_function(func)
+    for func in qmod_classical_functions + list(MEASUREMENT_FUNCTIONS)
 ]
 
 ATOMIC_EXPRESSION_FUNCTIONS = {

classiq/model_expansions/function_builder.py

@@ -9,6 +9,7 @@ from classiq.interface.generator.compiler_keywords import (
     LAMBDA_KEYWORD,
 )
 from classiq.interface.generator.functions.builtins.internal_operators import (
+    BLOCK_OPERATOR_NAME,
     WITHIN_APPLY_NAME,
 )
 from classiq.interface.model.model import MAIN_FUNCTION_NAME
@@ -35,6 +36,8 @@ from classiq.model_expansions.utils.counted_name_allocator import CountedNameAll
 
 ClosureType = TypeVar("ClosureType", bound=Closure)
 
+BLOCKS_ALLOWED_CAPTURING = (WITHIN_APPLY_NAME, BLOCK_OPERATOR_NAME)
+
 
 @dataclass
 class Block:
@@ -142,7 +145,7 @@ class OperationBuilder:
         captured_vars = self.current_block.captured_vars
         if (
             not isinstance(self.current_operation, FunctionClosure)
-            and self.current_operation.name != WITHIN_APPLY_NAME
+            and self.current_operation.name not in BLOCKS_ALLOWED_CAPTURING
         ):
             validate_captured_directions(
                 captured_vars.filter_var_decls(

classiq/model_expansions/generative_functions.py

@@ -20,6 +20,7 @@ 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
+from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_function_declaration import (
     PositionalArg,
     QuantumFunctionDeclaration,
@@ -32,6 +33,7 @@ from classiq.model_expansions.closure import (
     GenerativeClosure,
 )
 from classiq.model_expansions.scope import Evaluated
+from classiq.qmod.builtins.functions import __all__ as all_builtin_func_names
 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
@@ -50,6 +52,9 @@ if TYPE_CHECKING:
     )
 
 
+ALL_STANDARD_GATES = {func for func in all_builtin_func_names if func.isupper()}
+
+
 def _unwrap_traceback_frame(e: Exception) -> Exception:
     fallback_error = ClassiqExpansionError(str(e))
     traceback = exc_info()[2]
@@ -130,6 +135,15 @@ class _InterpreterExpandable(QFunc):
         self._interpreter = interpreter
 
     def append_statement_to_body(self, stmt: QuantumStatement) -> None:
+        if (
+            not isinstance(stmt, QuantumFunctionCall)
+            or stmt.func_name not in ALL_STANDARD_GATES
+        ):
+            stmt = self._annotate_statement(stmt)
+        with generative_mode_context(False):
+            self._interpreter.emit_statement(stmt)
+
+    def _annotate_statement(self, stmt: QuantumStatement) -> QuantumStatement:
         current_operation = self._interpreter._builder._operations[-1]
         dummy_function = NativeFunctionDefinition(
             name=current_operation.name,
@@ -155,8 +169,7 @@ class _InterpreterExpandable(QFunc):
         )
         resolve_function_calls(dummy_function, func_decls)
         stmt = dummy_function.body[-1]
-        with generative_mode_context(False):
-            self._interpreter.emit_statement(stmt)
+        return stmt
 
     def _get_function_declarations(self) -> Mapping[str, QuantumFunctionDeclaration]:
         scope_func_decls: dict[str, QuantumFunctionDeclaration] = {}

classiq/model_expansions/interpreters/base_interpreter.py

@@ -20,6 +20,9 @@ from classiq.interface.generator.expressions.atomic_expression_functions import
     CLASSICAL_ATTRIBUTES,
 )
 from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.classical_function_declaration import (
+    ClassicalFunctionDeclaration,
+)
 from classiq.interface.generator.types.compilation_metadata import CompilationMetadata
 from classiq.interface.model.handle_binding import (
     FieldHandleBinding,
@@ -69,6 +72,7 @@ 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.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
@@ -89,6 +93,9 @@ class BaseInterpreter:
 
         init_builtin_types()
         init_top_level_scope(model, self._top_level_scope)
+        QStructAnnotator().visit(
+            ClassicalFunctionDeclaration.FOREIGN_FUNCTION_DECLARATIONS
+        )
         self._functions_compilation_metadata: dict[str, CompilationMetadata] = dict(
             self._model.functions_compilation_metadata
         )

classiq/model_expansions/interpreters/generative_interpreter.py

@@ -7,6 +7,7 @@ from numpy.random import permutation
 from classiq.interface.generator.constant import Constant
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.builtins.internal_operators import (
+    BLOCK_OPERATOR_NAME,
     CLASSICAL_IF_OPERATOR_NAME,
     CONTROL_OPERATOR_NAME,
     INVERT_OPERATOR_NAME,
@@ -15,6 +16,7 @@ from classiq.interface.generator.functions.builtins.internal_operators import (
 )
 from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.block import Block
 from classiq.interface.model.bounds import SetBoundsStatement
 from classiq.interface.model.classical_if import ClassicalIf
 from classiq.interface.model.control import Control
@@ -68,6 +70,9 @@ from classiq.model_expansions.quantum_operations.block_evaluator import (
     RepeatElimination,
 )
 from classiq.model_expansions.quantum_operations.bounds import SetBoundsEmitter
+from classiq.model_expansions.quantum_operations.classical_var_emitter import (
+    ClassicalVarEmitter,
+)
 from classiq.model_expansions.quantum_operations.composite_emitter import (
     CompositeEmitter,
 )
@@ -87,6 +92,7 @@ from classiq.model_expansions.scope_initialization import (
 from classiq.qmod.builtins.functions import permute
 from classiq.qmod.model_state_container import ModelStateContainer
 from classiq.qmod.quantum_function import GenerativeQFunc
+from classiq.qmod.semantics.annotation.qstruct_annotator import QStructAnnotator
 
 
 class GenerativeInterpreter(BaseInterpreter):
@@ -192,6 +198,7 @@ class GenerativeInterpreter(BaseInterpreter):
             [
                 HandleEvaluator(self, "result_var"),
                 ExpressionEvaluator(self, "expression"),
+                ClassicalVarEmitter(self),
                 AssignmentResultProcessor(self),
             ],
         ).emit(op)
@@ -303,9 +310,18 @@ class GenerativeInterpreter(BaseInterpreter):
     def emit_set_bounds(self, op: SetBoundsStatement) -> None:
         CompositeEmitter[SetBoundsStatement](
             self,
-            [HandleEvaluator(self, "target"), SetBoundsEmitter(self)],
+            [
+                ExpressionEvaluator(self, "lower_bound"),
+                ExpressionEvaluator(self, "upper_bound"),
+                HandleEvaluator(self, "target"),
+                SetBoundsEmitter(self),
+            ],
         ).emit(op)
 
+    @emit.register
+    def emit_block(self, block: Block) -> None:
+        BlockEvaluator(self, BLOCK_OPERATOR_NAME, "statements").emit(block)
+
     def _expand_body(self, operation: Closure) -> None:
         if isinstance(operation, FunctionClosure) and operation.name == "permute":
             # special expansion since permute is generative
@@ -358,4 +374,5 @@ class GenerativeInterpreter(BaseInterpreter):
                 )
 
     def add_constant(self, constant: Constant) -> None:
+        QStructAnnotator().visit(constant.const_type)
         add_constants_to_scope([constant], self._top_level_scope)

classiq/model_expansions/quantum_operations/assignment_result_processor.py

@@ -1,10 +1,12 @@
-from typing import Optional
+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
+from classiq.interface.model.block import Block
+from classiq.interface.model.bounds import SetBoundsStatement
 from classiq.interface.model.handle_binding import (
     ConcreteHandleBinding,
     HandleBinding,
@@ -19,6 +21,7 @@ from classiq.interface.model.quantum_expressions.quantum_expression import (
 )
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_type import QuantumBitvector, QuantumNumeric
+from classiq.interface.model.statement_block import StatementBlock
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
@@ -30,14 +33,25 @@ from classiq.model_expansions.quantum_operations.arithmetic.explicit_boolean_exp
     validate_assignment_bool_expression,
 )
 from classiq.model_expansions.quantum_operations.emitter import Emitter
-from classiq.model_expansions.scope import QuantumSymbol
+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:
+    from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
+
 
 class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
+    def __init__(
+        self, interpreter: "BaseInterpreter", replace_assignment_if_needed: bool = False
+    ) -> None:
+        super().__init__(interpreter)
+        self._replace_assignment_if_needed = replace_assignment_if_needed
+
     def emit(self, op: QuantumAssignmentOperation, /) -> bool:
-        result_symbol = self._interpreter.evaluate(op.result_var).as_type(QuantumSymbol)
+        result_symbol = self._interpreter.evaluate(op.result_var).value
+        if isinstance(result_symbol, ClassicalSymbol):
+            return False
         result_type = result_symbol.quantum_type
 
         if not (
@@ -70,9 +84,11 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
         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)
-        result_type.set_bounds(inferred_result_type.get_bounds())
-        return True
+        if self._replace_assignment_if_needed:
+            self._assign_to_inferred_var_and_bind(op, result_type, inferred_result_type)
+            return True
+        else:
+            return False
 
     def _infer_result_type(self, op: ArithmeticOperation) -> Optional[QuantumNumeric]:
         expr = self._evaluate_expression(op.expression)
@@ -182,6 +198,7 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
         result_type: QuantumNumeric,
         inferred_result_type: QuantumNumeric,
     ) -> None:
+        stmts: StatementBlock = []
         handles: list[HandleBinding] = []
 
         extra_fraction_digits = (
@@ -190,20 +207,22 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
         )
         if extra_fraction_digits > 0:
             handles.append(
-                self._declare_qarray("extra_fraction_digits", extra_fraction_digits)
+                self._declare_qarray(
+                    "extra_fraction_digits", extra_fraction_digits, stmts
+                )
             )
 
         inferred_result_name = self._counted_name_allocator.allocate("inferred_result")
         inferred_result_handle = HandleBinding(name=inferred_result_name)
-        self._interpreter.emit(
+        stmts.append(
             VariableDeclarationStatement(
-                name=inferred_result_name, quantum_type=inferred_result_type
+                name=inferred_result_name, qmod_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)
+        stmts.append(modified_op)
 
         result_integer_size = (
             result_type.size_in_bits - result_type.fraction_digits_value
@@ -214,11 +233,11 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
         )
         extra_integers = result_integer_size - inferred_result_integer_size
         if extra_integers > 0:
-            handles.append(self._declare_qarray("extra_integers", extra_integers))
+            handles.append(
+                self._declare_qarray("extra_integers", extra_integers, stmts)
+            )
 
-        self._interpreter.emit(
-            BindOperation(in_handles=handles, out_handles=[op.result_var])
-        )
+        stmts.append(BindOperation(in_handles=handles, out_handles=[op.result_var]))
 
         if (
             result_type.sign_value
@@ -226,22 +245,44 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
             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)
+            self._sign_extension(
+                op.result_var, sign_idx, result_type.size_in_bits, stmts
+            )
+
+        if (inferred_bounds := inferred_result_type.get_bounds()) is not None:
+            lower_bound = Expression(expr=str(inferred_bounds[0]))
+            upper_bound = Expression(expr=str(inferred_bounds[1]))
+        else:
+            lower_bound, upper_bound = None, None
+        stmts.append(
+            SetBoundsStatement(
+                target=op.result_var,
+                lower_bound=lower_bound,
+                upper_bound=upper_bound,
+            )
+        )
+
+        self._interpreter.emit(
+            Block(
+                statements=stmts,
+                uuid=op.uuid,
+                back_ref=op.back_ref,
+            )
+        )
 
     def _declare_qarray(
         self,
         prefix: str,
         size: int,
+        stmts: StatementBlock,
         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)
-        )
+        stmts.append(VariableDeclarationStatement(name=name, qmod_type=quantum_type))
         if allocate:
-            self._interpreter.emit(Allocate(target=handle))
+            stmts.append(Allocate(target=handle))
         return handle
 
     def _sign_extension(
@@ -249,9 +290,10 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
         result_var: ConcreteHandleBinding,
         sign_idx: int,
         size: int,
+        stmts: StatementBlock,
     ) -> None:
-        aux = self._declare_qarray("inferred_result_aux", size, allocate=False)
-        self._interpreter.emit(
+        aux = self._declare_qarray("inferred_result_aux", size, stmts, allocate=False)
+        stmts.append(
             WithinApply(
                 compute=[BindOperation(in_handles=[result_var], out_handles=[aux])],
                 action=[

classiq/model_expansions/quantum_operations/bounds.py

@@ -24,7 +24,13 @@ class SetBoundsEmitter(Emitter[SetBoundsStatement]):
             raise ClassiqExpansionError(
                 f"Cannot set bounds of a non-numeric variable {op.target.qmod_expr!r}"
             )
-        target.quantum_type.set_bounds(op.bounds)
+
+        if op.lower_bound is not None and op.upper_bound is not None:
+            target.quantum_type.set_bounds(
+                (op.lower_bound.to_float_value(), op.upper_bound.to_float_value())
+            )
+        else:
+            target.quantum_type.reset_bounds()
         if self._keep_statement:
             self.emit_statement(op)
         return True

classiq/model_expansions/quantum_operations/call_emitter.py

@@ -157,7 +157,10 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         return any(isinstance(stmt, VariableDeclarationStatement) for stmt in body)
 
     def _create_expanded_wrapping_function(
-        self, name: str, body: Sequence[QuantumStatement]
+        self,
+        name: str,
+        body: Sequence[QuantumStatement],
+        debug_info: Optional[FunctionDebugInfo] = None,
     ) -> QuantumFunctionCall:
         wrapping_function = FunctionClosure.create(
             name=self._counted_name_allocator.allocate(name),
@@ -165,7 +168,7 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
             scope=Scope(parent=self._current_scope),
             lambda_external_vars=self._builder.current_block.captured_vars,
         )
-        return self._create_quantum_function_call(wrapping_function, list(), None)
+        return self._create_quantum_function_call(wrapping_function, list(), debug_info)
 
     def _emit_quantum_function_call(
         self,

classiq/model_expansions/quantum_operations/classical_var_emitter.py

@@ -0,0 +1,16 @@
+from classiq.interface.model.quantum_expressions.arithmetic_operation import (
+    ArithmeticOperation,
+)
+
+from classiq.model_expansions.quantum_operations.emitter import Emitter
+from classiq.model_expansions.scope import ClassicalSymbol
+
+
+class ClassicalVarEmitter(Emitter[ArithmeticOperation]):
+    def emit(self, op: ArithmeticOperation, /) -> bool:
+        result_symbol = self._interpreter.evaluate(op.result_var).value
+        if not isinstance(result_symbol, ClassicalSymbol):
+            return False
+        op._classical_assignment = True
+        self.emit_statement(op)
+        return True

classiq/model_expansions/quantum_operations/variable_decleration.py

@@ -1,14 +1,19 @@
+from typing import TYPE_CHECKING, Union
+
 from classiq.interface.exceptions import ClassiqExpansionError
+from classiq.interface.generator.functions.classical_type import ClassicalType
 from classiq.interface.model.handle_binding import HandleBinding
+from classiq.interface.model.quantum_type import QuantumType
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
 
 from classiq.evaluators.parameter_types import (
+    evaluate_type_in_classical_symbol,
     evaluate_type_in_quantum_symbol,
 )
 from classiq.model_expansions.quantum_operations.emitter import Emitter
-from classiq.model_expansions.scope import Evaluated, QuantumSymbol
+from classiq.model_expansions.scope import ClassicalSymbol, Evaluated, QuantumSymbol
 
 
 class VariableDeclarationStatementEmitter(Emitter[VariableDeclarationStatement]):
@@ -16,24 +21,39 @@ class VariableDeclarationStatementEmitter(Emitter[VariableDeclarationStatement])
         var_decl = variable_declaration.model_copy(
             update=dict(back_ref=variable_declaration.uuid)
         )
-        var_decl.quantum_type = variable_declaration.quantum_type.model_copy()
+        var_decl.qmod_type = variable_declaration.qmod_type.model_copy()
         if variable_declaration.name in self._current_scope:
             raise ClassiqExpansionError(
                 f"Variable {variable_declaration.name!r} is already defined"
             )
-        self._current_scope[variable_declaration.name] = Evaluated(
-            value=QuantumSymbol(
+        var_value: Union[QuantumSymbol, ClassicalSymbol]
+        if variable_declaration.is_quantum:
+            if TYPE_CHECKING:
+                assert isinstance(var_decl.qmod_type, QuantumType)
+            var_value = QuantumSymbol(
                 handle=HandleBinding(name=var_decl.name),
                 quantum_type=evaluate_type_in_quantum_symbol(
-                    var_decl.quantum_type,
+                    var_decl.qmod_type,
                     self._current_scope,
                     var_decl.name,
                 ),
-            ),
-            defining_function=self._builder.current_function,
-        )
-        self._builder.current_block.captured_vars.init_var(
-            var_decl.name, self._builder.current_function
+            )
+            self._builder.current_block.captured_vars.init_var(
+                var_decl.name, self._builder.current_function
+            )
+        else:
+            if TYPE_CHECKING:
+                assert isinstance(var_decl.qmod_type, ClassicalType)
+            var_value = ClassicalSymbol(
+                handle=HandleBinding(name=var_decl.name),
+                classical_type=evaluate_type_in_classical_symbol(
+                    var_decl.qmod_type,
+                    self._current_scope,
+                    var_decl.name,
+                ),
+            )
+        self._current_scope[variable_declaration.name] = Evaluated(
+            value=var_value, defining_function=self._builder.current_function
         )
         self.emit_statement(var_decl)
         return True

classiq/model_expansions/scope.py

@@ -21,6 +21,7 @@ from classiq.interface.generator.expressions.proxies.classical.classical_scalar_
 from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
     QmodStructInstance,
 )
+from classiq.interface.generator.functions.classical_type import ClassicalType
 from classiq.interface.generator.functions.type_name import TypeName
 from classiq.interface.helpers.text_utils import readable_list, s
 from classiq.interface.model.handle_binding import (
@@ -202,6 +203,12 @@ class QuantumSymbolList(QuantumVariable):
         return str(self.handles)
 
 
+@dataclass(frozen=True)
+class ClassicalSymbol:
+    handle: HandleBinding
+    classical_type: ClassicalType
+
+
 @singledispatch
 def evaluated_to_str(value: Any) -> str:
     return str(value)

classiq/model_expansions/scope_initialization.py

@@ -28,6 +28,7 @@ from classiq.qmod.builtins.functions import (
 from classiq.qmod.builtins.structs import BUILTIN_STRUCT_DECLARATIONS
 from classiq.qmod.model_state_container import QMODULE
 from classiq.qmod.quantum_function import GenerativeQFunc
+from classiq.qmod.semantics.annotation.qstruct_annotator import QStructAnnotator
 
 
 def add_constants_to_scope(constants: list[Constant], scope: Scope) -> None:
@@ -133,3 +134,4 @@ def init_top_level_scope(model: Model, scope: Scope) -> None:
 def init_builtin_types() -> None:
     QMODULE.enum_decls |= BUILTIN_ENUM_DECLARATIONS
     QMODULE.type_decls |= BUILTIN_STRUCT_DECLARATIONS
+    QStructAnnotator().visit(BUILTIN_STRUCT_DECLARATIONS)

classiq/model_expansions/sympy_conversion/sympy_to_python.py

@@ -21,7 +21,7 @@ from classiq.interface.generator.expressions.proxies.classical.any_classical_val
     AnyClassicalValue,
 )
 
-from classiq.model_expansions.sympy_conversion.arithmetics import LogicalXor
+from classiq.evaluators.qmod_expression_visitors.sympy_wrappers import LogicalXor
 
 
 def sympy_to_python(

classiq/model_expansions/transformers/type_modifier_inference.py

@@ -16,6 +16,7 @@ from classiq.interface.generator.functions.port_declaration import (
 from classiq.interface.generator.functions.type_modifier import TypeModifier
 from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.block import Block
 from classiq.interface.model.control import Control
 from classiq.interface.model.invert import Invert
 from classiq.interface.model.model_visitor import ModelVisitor
@@ -352,6 +353,10 @@ class TypeModifierValidation(ModelVisitor):
                 self.visit(within_apply.compute)
             self.visit(within_apply.action)
 
+    def visit_Block(self, block: Block) -> None:
+        with self.source_reference_context(block.source_ref):
+            self.visit(block.statements)
+
 
 def _merge_overlapping(bound_vars: Sequence[Collection[str]]) -> list[set[str]]:
     """

classiq/model_expansions/transformers/var_splitter.py

@@ -218,7 +218,7 @@ class VarSplitter(ModelRenamer):
         return [
             VariableDeclarationStatement(
                 name=part.target_var_name,
-                quantum_type=part.target_var_type,
+                qmod_type=part.target_var_type,
             )
             for part in chain.from_iterable(symbol_parts.values())
         ]

classiq/model_expansions/visitors/boolean_expression_transformers.py

@@ -4,7 +4,7 @@ from typing import TYPE_CHECKING, Union
 
 from classiq.interface.exceptions import ClassiqInternalExpansionError
 
-from classiq.model_expansions.sympy_conversion.arithmetics import LogicalXor
+from classiq.evaluators.qmod_expression_visitors.sympy_wrappers import LogicalXor
 
 
 class BooleanExpressionOptimizer(ast.NodeTransformer):