classiq 0.63.1__py3-none-any.whl → 0.65.1__py3-none-any.whl

classiq/model_expansions/capturing/captured_vars.py

@@ -34,6 +34,10 @@ if TYPE_CHECKING:
     from classiq.model_expansions.closure import FunctionClosure
 
 
+ALREADY_ALLOCATED_MESSAGE = "Cannot allocate variable '{}', it is already initialized"
+ALREADY_FREED_MESSAGE = "Cannot free variable '{}', it is already uninitialized"
+
+
 class PortDirection(StrEnum):
     Input = "input"
     Inout = "inout"
@@ -141,7 +145,14 @@ class CapturedVars:
             isinstance(captured_handle.handle, NestedHandleBinding)
             and captured_handle.direction != PortDirection.Inout
         ):
-            raise ClassiqInternalExpansionError("Captured nested handles must be inout")
+            verb = (
+                "free"
+                if captured_handle.direction == PortDirection.Input
+                else "allocate"
+            )
+            raise ClassiqExpansionError(
+                f"Cannot partially {verb} variable {captured_handle.handle.name}"
+            )
 
         new_captured_handles = []
         for existing_captured_handle in self._captured_handles:
@@ -174,7 +185,9 @@ class CapturedVars:
                 return captured_handle.change_direction(PortDirection.Inout)
             if captured_handle.direction == PortDirection.Outin:
                 return captured_handle.change_direction(PortDirection.Input)
-            raise ClassiqInternalExpansionError("Captured handle is already freed")
+            raise ClassiqExpansionError(
+                ALREADY_FREED_MESSAGE.format(captured_handle.handle)
+            )
         if existing_captured_handle.direction == PortDirection.Output:
             if captured_handle.direction == PortDirection.Input:
                 return captured_handle.change_direction(PortDirection.Outin)
@@ -182,8 +195,8 @@ class CapturedVars:
                 PortDirection.Output,
                 PortDirection.Outin,
             ):
-                raise ClassiqInternalExpansionError(
-                    "Captured handle is already allocated"
+                raise ClassiqExpansionError(
+                    ALREADY_ALLOCATED_MESSAGE.format(captured_handle.handle)
                 )
             return captured_handle.change_direction(PortDirection.Output)
         if existing_captured_handle.direction == PortDirection.Inout:
@@ -191,14 +204,16 @@ class CapturedVars:
                 PortDirection.Output,
                 PortDirection.Outin,
             ):
-                raise ClassiqInternalExpansionError(
-                    "Captured handle is already allocated"
+                raise ClassiqExpansionError(
+                    ALREADY_ALLOCATED_MESSAGE.format(captured_handle.handle)
                 )
         elif captured_handle.direction in (
             PortDirection.Input,
             PortDirection.Inout,
         ):
-            raise ClassiqInternalExpansionError("Captured handle is already freed")
+            raise ClassiqExpansionError(
+                ALREADY_FREED_MESSAGE.format(captured_handle.handle)
+            )
         return captured_handle
 
     def _intersect_handles(
@@ -211,7 +226,9 @@ class CapturedVars:
                 PortDirection.Input,
                 PortDirection.Outin,
             ):
-                raise ClassiqInternalExpansionError("Captured handle is already freed")
+                raise ClassiqExpansionError(
+                    ALREADY_FREED_MESSAGE.format(captured_handle.handle)
+                )
             return existing_captured_handle
 
         if existing_captured_handle.handle in captured_handle.handle:
@@ -219,8 +236,8 @@ class CapturedVars:
                 PortDirection.Output,
                 PortDirection.Outin,
             ):
-                raise ClassiqInternalExpansionError(
-                    "Captured handle is already allocated"
+                raise ClassiqExpansionError(
+                    ALREADY_ALLOCATED_MESSAGE.format(captured_handle.handle)
                 )
             return captured_handle
 

classiq/model_expansions/evaluators/arg_type_match.py

@@ -25,8 +25,8 @@ from classiq.interface.model.quantum_function_declaration import (
 
 from classiq.model_expansions.closure import FunctionClosure
 from classiq.model_expansions.evaluators.type_type_match import check_signature_match
-from classiq.model_expansions.model_tables import SymbolTable
 from classiq.model_expansions.scope import Evaluated, QuantumSymbol
+from classiq.qmod.model_state_container import QMODULE
 from classiq.qmod.qmod_parameter import CInt, get_qmod_type
 
 
@@ -122,11 +122,11 @@ def _check_classical_type_match(
     type_name = _resolve_type_name(classical_type)
     type_is_struct = (
         isinstance(classical_type, TypeName)
-        and classical_type.name in SymbolTable.type_table
+        and classical_type.name in QMODULE.type_decls
     )
     type_is_enum = (
         isinstance(classical_type, TypeName)
-        and classical_type.name in SymbolTable.enum_table
+        and classical_type.name in QMODULE.enum_decls
     )
     arg_is_qvar = isinstance(argument, QmodSizedProxy)
     arg_is_builtin = argument.__class__.__module__ == "builtins"
@@ -153,9 +153,6 @@ def _resolve_type_name(classical_type: ConcreteClassicalType) -> str:
         type_name = get_qmod_type(classical_type).__name__
     if not isinstance(classical_type, TypeName):
         return type_name
-    if (
-        type_name not in SymbolTable.type_table
-        and type_name not in SymbolTable.enum_table
-    ):
+    if type_name not in QMODULE.type_decls and type_name not in QMODULE.enum_decls:
         raise ClassiqExpansionError(f"Undefined type {type_name}")
     return type_name

classiq/model_expansions/evaluators/quantum_type_utils.py

@@ -1,3 +1,4 @@
+from collections.abc import Sequence
 from typing import Optional
 
 from classiq.interface.exceptions import (
@@ -10,10 +11,14 @@ from classiq.interface.generator.functions.type_name import (
     TypeName,
 )
 from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.inplace_binary_operation import BinaryOperation
+from classiq.interface.model.port_declaration import PortDeclaration
+from classiq.interface.model.quantum_function_declaration import PositionalArg
 from classiq.interface.model.quantum_type import (
     QuantumBit,
     QuantumBitvector,
     QuantumNumeric,
+    QuantumScalar,
     QuantumType,
 )
 
@@ -209,14 +214,26 @@ def validate_bind_targets(bind: BindOperation, scope: Scope) -> None:
         )
 
 
-def validate_inplace_binary_op_vars(
-    value_var: QuantumSymbol, target_var: QuantumSymbol, operation_name: str
-) -> None:
-    if not isinstance(value_var.quantum_type, QuantumNumeric):
+def get_inplace_op_scalar_as_numeric(
+    var: QuantumSymbol, operation: BinaryOperation, var_kind: str
+) -> QuantumNumeric:
+    if not isinstance(var.quantum_type, QuantumScalar):
         raise ClassiqExpansionError(
-            f"Cannot perform `{operation_name}` operation with non numeric value {value_var.handle}"
+            f"Cannot perform inplace {operation.name.lower()} with non-scalar {var_kind} {var.handle}"
         )
-    if not isinstance(target_var.quantum_type, QuantumNumeric):
-        raise ClassiqExpansionError(
-            f"Cannot perform `{operation_name}` operation with non numeric target {target_var.handle}"
+    if isinstance(var.quantum_type, QuantumNumeric):
+        return var.quantum_type
+    if isinstance(var.quantum_type, QuantumBit):
+        return QuantumNumeric(
+            size=Expression(expr="1"),
+            is_signed=Expression(expr="False"),
+            fraction_digits=Expression(expr="0"),
         )
+    raise ClassiqInternalExpansionError(f"Unexpected scalar type {var.quantum_type}")
+
+
+def is_signature_monomorphic(params: Sequence[PositionalArg]) -> bool:
+    return all(
+        isinstance(param, PortDeclaration) and param.quantum_type.is_evaluated
+        for param in params
+    )

classiq/model_expansions/expression_evaluator.py

@@ -24,12 +24,13 @@ from classiq.model_expansions.atomic_expression_functions_defs import (
     ATOMIC_EXPRESSION_FUNCTIONS,
     qmod_val_to_python,
 )
-from classiq.model_expansions.model_tables import SymbolTable
 from classiq.model_expansions.sympy_conversion.expression_to_sympy import (
     translate_to_sympy,
 )
 from classiq.model_expansions.sympy_conversion.sympy_to_python import sympy_to_python
 from classiq.qmod import symbolic
+from classiq.qmod.builtins.enums import BUILTIN_ENUM_DECLARATIONS
+from classiq.qmod.model_state_container import QMODULE
 
 
 def evaluate_constants(constants: list[Constant]) -> dict[str, EvaluatedExpression]:
@@ -56,7 +57,12 @@ def evaluate(
 ) -> EvaluatedExpression:
     model_locals: dict[str, ExpressionValue] = {}
     model_locals.update(ATOMIC_EXPRESSION_FUNCTIONS)
-    model_locals.update(SymbolTable.enum_table.enums)
+    model_locals.update(
+        {
+            enum_decl.name: enum_decl.create_enum()
+            for enum_decl in (QMODULE.enum_decls | BUILTIN_ENUM_DECLARATIONS).values()
+        }
+    )
     # locals override builtin-functions
     model_locals.update({name: expr.value for name, expr in locals_dict.items()})
     uninitialized_locals = uninitialized_locals or set()

classiq/model_expansions/function_builder.py

@@ -29,7 +29,14 @@ from classiq.model_expansions.capturing.captured_vars import (
     CapturedVars,
     validate_captured_directions,
 )
-from classiq.model_expansions.closure import Closure, FunctionClosure
+from classiq.model_expansions.closure import (
+    Closure,
+    FunctionClosure,
+    GenerativeFunctionClosure,
+)
+from classiq.model_expansions.evaluators.quantum_type_utils import (
+    is_signature_monomorphic,
+)
 from classiq.model_expansions.scope import Scope
 from classiq.model_expansions.utils.counted_name_allocator import CountedNameAllocator
 
@@ -200,16 +207,7 @@ class OperationBuilder:
     def create_definition(
         self, function_context: FunctionContext
     ) -> NativeFunctionDefinition:
-        name = function_context.name
-        if name != MAIN_FUNCTION_NAME:
-            for _ in self.current_scope:
-                name = self._counted_name_allocator.allocate(
-                    f"{name}_{LAMBDA_KEYWORD + '_0_0_' if function_context.is_lambda else ''}{EXPANDED_KEYWORD}"
-                )
-                if name not in self.current_scope:
-                    break
-            else:
-                raise ClassiqInternalExpansionError("Could not allocate function name")
+        name = self._get_expanded_function_name(function_context)
         new_parameters: list[PortDeclaration] = [
             param
             for param in function_context.positional_arg_declarations
@@ -221,3 +219,29 @@ class OperationBuilder:
             body=function_context.body,
             positional_arg_declarations=new_parameters,
         )
+
+    def _get_expanded_function_name(self, function_context: FunctionContext) -> str:
+        name = function_context.name
+
+        if name == MAIN_FUNCTION_NAME:
+            return name
+
+        if name in self.current_scope:
+            orig_func = self.current_scope[name].value
+            if (
+                isinstance(orig_func, FunctionClosure)
+                and not isinstance(orig_func, GenerativeFunctionClosure)
+                and is_signature_monomorphic(orig_func.positional_arg_declarations)
+            ):
+                return name
+
+        for _ in self.current_scope:
+            name = self._counted_name_allocator.allocate(
+                f"{name}_{LAMBDA_KEYWORD + '_0_0_' if function_context.is_lambda else ''}{EXPANDED_KEYWORD}"
+            )
+            if name not in self.current_scope:
+                break
+        else:
+            raise ClassiqInternalExpansionError("Could not allocate function name")
+
+        return name

classiq/model_expansions/generative_functions.py

@@ -30,11 +30,13 @@ from classiq.qmod.quantum_expandable import (
     QTerminalCallable,
 )
 from classiq.qmod.quantum_function import QFunc
-from classiq.qmod.semantics.static_semantics_visitor import resolve_function_calls
+from classiq.qmod.semantics.annotation.call_annotation import resolve_function_calls
 from classiq.qmod.symbolic_expr import SymbolicExpr
 
 if TYPE_CHECKING:
-    from classiq.model_expansions.interpreter import Interpreter
+    from classiq.model_expansions.interpreters.generative_interpreter import (
+        GenerativeInterpreter,
+    )
 
 
 class LenList(list):
@@ -94,7 +96,7 @@ def translate_ast_arg_to_python_qmod(param: PositionalArg, evaluated: Evaluated)
 
 
 class _InterpreterExpandable(QFunc):
-    def __init__(self, interpreter: "Interpreter"):
+    def __init__(self, interpreter: "GenerativeInterpreter"):
         super().__init__(lambda: None)
         self._interpreter = interpreter
 
@@ -137,7 +139,7 @@ class _InterpreterExpandable(QFunc):
 
 
 def emit_generative_statements(
-    interpreter: "Interpreter",
+    interpreter: "GenerativeInterpreter",
     operation: GenerativeClosure,
     args: list[Evaluated],
 ) -> None:

classiq/model_expansions/interpreters/base_interpreter.py

@@ -0,0 +1,263 @@
+import ast
+from abc import abstractmethod
+from collections import defaultdict
+from collections.abc import Sequence
+from contextlib import nullcontext
+from functools import singledispatchmethod
+from typing import Any, Optional, cast
+
+import sympy
+from pydantic import ValidationError
+
+from classiq.interface.exceptions import (
+    ClassiqError,
+    ClassiqExpansionError,
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.generator.constant import Constant
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.types.compilation_metadata import CompilationMetadata
+from classiq.interface.model.handle_binding import (
+    FieldHandleBinding,
+    HandleBinding,
+    SlicedHandleBinding,
+    SubscriptHandleBinding,
+)
+from classiq.interface.model.model import MAIN_FUNCTION_NAME, Model
+from classiq.interface.model.native_function_definition import NativeFunctionDefinition
+from classiq.interface.model.quantum_function_declaration import (
+    QuantumFunctionDeclaration,
+)
+from classiq.interface.model.quantum_lambda_function import (
+    OperandIdentifier,
+    QuantumLambdaFunction,
+)
+from classiq.interface.model.quantum_statement import QuantumStatement
+
+from classiq.model_expansions.closure import (
+    Closure,
+    FunctionClosure,
+)
+from classiq.model_expansions.debug_flag import debug_mode
+from classiq.model_expansions.evaluators.classical_expression import (
+    evaluate_classical_expression,
+)
+from classiq.model_expansions.expression_renamer import ExpressionRenamer
+from classiq.model_expansions.function_builder import (
+    FunctionContext,
+    OperationBuilder,
+    OperationContext,
+)
+from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
+from classiq.model_expansions.scope_initialization import (
+    add_constants_to_scope,
+    add_entry_point_params_to_scope,
+    get_main_renamer,
+    init_builtin_types,
+    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.enums import BUILTIN_ENUM_DECLARATIONS
+from classiq.qmod.builtins.structs import BUILTIN_STRUCT_DECLARATIONS
+from classiq.qmod.model_state_container import QMODULE
+from classiq.qmod.semantics.error_manager import ErrorManager
+
+
+class BaseInterpreter:
+    def __init__(self, model: Model) -> None:
+        self._model = model
+        self._top_level_scope = Scope()
+        self._counted_name_allocator = CountedNameAllocator()
+        self._builder = OperationBuilder(
+            self._top_level_scope, self._counted_name_allocator
+        )
+        self._expanded_functions: dict[str, NativeFunctionDefinition] = {}
+
+        init_builtin_types()
+        init_top_level_scope(model, self._top_level_scope)
+        self._functions_compilation_metadata: dict[str, CompilationMetadata] = dict(
+            self._model.functions_compilation_metadata
+        )
+        self._expanded_functions_compilation_metadata: dict[
+            str, CompilationMetadata
+        ] = defaultdict(CompilationMetadata)
+        self._counted_name_allocator = CountedNameAllocator()
+        self._error_manager: ErrorManager = ErrorManager()
+
+    def get_main_renamer(self) -> Optional[ExpressionRenamer]:
+        return get_main_renamer(self._get_function_declarations())
+
+    def _expand_main_func(self) -> None:
+        main_closure = self._get_main_closure(
+            self._top_level_scope[MAIN_FUNCTION_NAME].value
+        )
+        add_entry_point_params_to_scope(
+            main_closure.positional_arg_declarations, main_closure
+        )
+        context = self._expand_operation(main_closure)
+        self._expanded_functions[main_closure.closure_id] = (
+            self._builder.create_definition(cast(FunctionContext, context))
+        )
+
+    def _get_main_closure(self, main_func: FunctionClosure) -> FunctionClosure:
+        return FunctionClosure.create(
+            name=main_func.name,
+            positional_arg_declarations=main_func.positional_arg_declarations,
+            scope=Scope(parent=self._top_level_scope),
+            expr_renamer=self.get_main_renamer(),
+            _depth=0,
+            body=main_func.body,
+        )
+
+    def expand(self) -> Model:
+        try:
+            with self._error_manager.call("main"):
+                self._expand_main_func()
+        except Exception as e:
+            if isinstance(e, ClassiqInternalExpansionError) or debug_mode.get():
+                raise e
+            if not isinstance(e, (ClassiqError, ValidationError)):
+                raise ClassiqInternalExpansionError(str(e)) from None
+            prefix = ""
+            if not isinstance(e, ClassiqExpansionError):
+                prefix = f"{type(e).__name__}: "
+            self._error_manager.add_error(f"{prefix}{e}")
+        finally:
+            self._error_manager.report_errors(ClassiqExpansionError)
+
+        return Model(
+            constraints=self._model.constraints,
+            preferences=self._model.preferences,
+            classical_execution_code=self._model.classical_execution_code,
+            execution_preferences=self._model.execution_preferences,
+            functions=list(self._expanded_functions.values()),
+            constants=self._model.constants,
+            enums=[
+                enum_decl
+                for name, enum_decl in QMODULE.enum_decls.items()
+                if name not in BUILTIN_ENUM_DECLARATIONS
+            ],
+            types=[
+                struct_decl
+                for name, struct_decl in QMODULE.type_decls.items()
+                if name not in BUILTIN_STRUCT_DECLARATIONS
+            ],
+            qstructs=list(QMODULE.qstruct_decls.values()),
+            debug_info=self._model.debug_info,
+            functions_compilation_metadata=self._expanded_functions_compilation_metadata,
+        )
+
+    @singledispatchmethod
+    def evaluate(self, expression: Any) -> Evaluated:
+        raise NotImplementedError(f"Cannot evaluate {expression!r}")
+
+    @evaluate.register
+    def evaluate_classical_expression(self, expression: Expression) -> Evaluated:
+        expr = evaluate_classical_expression(expression, self._builder.current_scope)
+        if not isinstance(expr.value, sympy.Basic):
+            return expr
+        vrc = VarRefCollector(ignore_duplicated_handles=True)
+        vrc.visit(ast.parse(str(expr.value)))
+        for handle in vrc.var_handles:
+            if handle.name in self._builder.current_scope and isinstance(
+                self._builder.current_scope[handle.name], QuantumSymbol
+            ):
+                self.evaluate(handle)
+        return expr
+
+    @evaluate.register
+    def evaluate_identifier(self, identifier: str) -> Evaluated:
+        return self._builder.current_scope[identifier]
+
+    @evaluate.register
+    def _evaluate_lambda(self, function: QuantumLambdaFunction) -> Evaluated:
+        return self.evaluate_lambda(function)
+
+    def evaluate_lambda(self, function: QuantumLambdaFunction) -> Evaluated:
+        raise NotImplementedError
+
+    @evaluate.register
+    def evaluate_handle_binding(self, handle_binding: HandleBinding) -> Evaluated:
+        return self.evaluate(handle_binding.name)
+
+    @evaluate.register
+    def evaluate_sliced_handle_binding(
+        self, sliced_handle_binding: SlicedHandleBinding
+    ) -> Evaluated:
+        quantum_variable = self.evaluate(sliced_handle_binding.base_handle).as_type(
+            QuantumSymbol
+        )
+        start = self.evaluate(sliced_handle_binding.start).as_type(int)
+        end = self.evaluate(sliced_handle_binding.end).as_type(int)
+        return Evaluated(value=quantum_variable[start:end])
+
+    @evaluate.register
+    def evaluate_list(self, value: list) -> Evaluated:
+        return Evaluated(value=[self.evaluate(arg).value for arg in value])
+
+    @evaluate.register
+    def evaluate_subscript_handle(self, subscript: SubscriptHandleBinding) -> Evaluated:
+        base_value = self.evaluate(subscript.base_handle)
+        index_value = self.evaluate(subscript.index).as_type(int)
+        return Evaluated(value=base_value.value[index_value])
+
+    @evaluate.register
+    def evaluate_subscript_operand(self, subscript: OperandIdentifier) -> Evaluated:
+        base_value = self.evaluate(subscript.name)
+        index_value = self.evaluate(subscript.index).as_type(int)
+        return Evaluated(value=base_value.value[index_value])
+
+    @evaluate.register
+    def evaluate_field_access(self, field_access: FieldHandleBinding) -> Evaluated:
+        base_value = self.evaluate(field_access.base_handle)
+        return Evaluated(value=base_value.value.fields[field_access.field])
+
+    @abstractmethod
+    def emit(self, statement: QuantumStatement) -> None:
+        pass
+
+    def _expand_block(self, block: Sequence[QuantumStatement], block_name: str) -> None:
+        with self._builder.block_context(block_name):
+            for statement in block:
+                self.emit_statement(statement)
+
+    def emit_statement(self, statement: QuantumStatement) -> None:
+        source_ref = statement.source_ref
+        error_context = (
+            self._error_manager.node_context(statement)
+            if source_ref is not None
+            else nullcontext()
+        )
+        with error_context, self._builder.source_ref_context(source_ref):
+            self.emit(statement)
+
+    def _expand_operation(self, operation: Closure) -> OperationContext:
+        with self._builder.operation_context(operation) as context:
+            if isinstance(operation, FunctionClosure) and (
+                (func_def := self._expanded_functions.get(operation.closure_id))
+                is not None
+            ):
+                captured_vars = self._top_level_scope[func_def.name].value.captured_vars
+                operation.captured_vars.update(captured_vars)
+            else:
+                self._expand_body(operation)
+
+        return context
+
+    def _expand_body(self, operation: Closure) -> None:
+        for block, block_body in operation.blocks.items():
+            self._expand_block(block_body, block)
+
+    def _get_function_declarations(self) -> Sequence[QuantumFunctionDeclaration]:
+        return [
+            QuantumFunctionDeclaration(
+                name=func_closure.name,
+                positional_arg_declarations=func_closure.positional_arg_declarations,
+            )
+            for func in self._top_level_scope.values()
+            if isinstance(func_closure := func.value, FunctionClosure)
+        ]
+
+    def add_constant(self, constant: Constant) -> None:
+        add_constants_to_scope([constant], self._top_level_scope)

classiq/model_expansions/interpreters/frontend_generative_interpreter.py

@@ -0,0 +1,28 @@
+from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+
+from classiq.model_expansions.closure import FunctionClosure, GenerativeFunctionClosure
+from classiq.model_expansions.interpreters.generative_interpreter import (
+    GenerativeInterpreter,
+)
+from classiq.model_expansions.quantum_operations.quantum_function_call import (
+    DeclarativeQuantumFunctionCallEmitter,
+)
+from classiq.model_expansions.scope import Scope
+
+
+class FrontendGenerativeInterpreter(GenerativeInterpreter):
+    def emit_quantum_function_call(self, call: QuantumFunctionCall) -> None:
+        DeclarativeQuantumFunctionCallEmitter(self).emit(call)
+
+    def _get_main_closure(self, main_func: FunctionClosure) -> FunctionClosure:
+        if isinstance(main_func, GenerativeFunctionClosure):
+            return GenerativeFunctionClosure.create(
+                name=main_func.name,
+                positional_arg_declarations=main_func.positional_arg_declarations,
+                scope=Scope(parent=self._top_level_scope),
+                expr_renamer=self.get_main_renamer(),
+                _depth=0,
+                generative_blocks={"body": main_func.generative_blocks["body"]},
+            )
+
+        return super()._get_main_closure(main_func)