classiq 0.61.0__py3-none-any.whl → 0.63.0__py3-none-any.whl

classiq/model_expansions/closure.py

@@ -1,28 +1,21 @@
 import dataclasses
 import json
-import uuid
-from collections.abc import Collection, Iterator, Sequence
-from contextlib import contextmanager
+from collections.abc import Collection, Sequence
 from dataclasses import dataclass, field
 from functools import singledispatch
-from symtable import Symbol
 from typing import Any, Optional
 
 from typing_extensions import Self
 
 from classiq.interface.exceptions import ClassiqInternalExpansionError
-from classiq.interface.generator.functions.builtins.internal_operators import (
-    All_BUILTINS_OPERATORS,
-)
 from classiq.interface.model.port_declaration import PortDeclaration
 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
 
-from classiq import ClassicalParameterDeclaration
 from classiq.model_expansions.capturing.captured_vars import CapturedVars
 from classiq.model_expansions.expression_renamer import ExpressionRenamer
 from classiq.model_expansions.scope import (
@@ -51,11 +44,6 @@ class Closure:
             if isinstance(param, PortDeclaration)
         }
 
-    @contextmanager
-    def freeze(self) -> Iterator[None]:
-        with self.scope.freeze(), self.captured_vars.freeze():
-            yield
-
 
 @dataclass(frozen=True)
 class GenerativeClosure(Closure):
@@ -79,15 +67,7 @@ class FunctionClosure(Closure):
     # The closure is changing across the interpreter flow so it's closure_id may change
     @property
     def closure_id(self) -> str:
-        # builtins operators have side effects, so  generate a unique id for than
-        # may create a bugs. Therefore, with each call to closure_id a new id is
-        # created
-        if self.is_lambda or self.name in All_BUILTINS_OPERATORS:
-            signature = str(uuid.uuid4())
-        else:
-            signature = _generate_closure_id(
-                self.positional_arg_declarations, self.scope.data.values()
-            )
+        signature = _generate_closure_id(self.scope.data.values())
         return f"{self.name}__{signature}"
 
     @property
@@ -142,70 +122,50 @@ class FunctionClosure(Closure):
     def set_depth(self, depth: int) -> Self:
         return dataclasses.replace(self, _depth=depth)
 
-    def copy_scope(self) -> Self:  # Remove when scoping is normal (CAD-24980)
+    def clone(self) -> Self:
         return dataclasses.replace(
-            self, scope=Scope(self.scope.data, parent=self.scope.parent)
+            self,
+            scope=self.scope.clone(),
+            signature_scope=self.signature_scope.clone(),
+            captured_vars=self.captured_vars.clone(),
         )
 
+    def emit(self) -> QuantumCallable:
+        return self.name
+
 
 @dataclass(frozen=True)
 class GenerativeFunctionClosure(GenerativeClosure, FunctionClosure):
     pass
 
 
-def _generate_closure_id(
-    args_declaration: Sequence[PositionalArg], evaluated_args: Collection[Evaluated]
-) -> str:
-    args_signature: dict = {}
-    for arg_declara, eval_arg in zip(args_declaration, evaluated_args):
-        args_signature |= _generate_arg_id(arg_declara, eval_arg)
+def _generate_closure_id(evaluated_args: Collection[Evaluated]) -> str:
+    args_signature = [
+        _evaluated_arg_to_str(eval_arg.value) for eval_arg in evaluated_args
+    ]
     return json.dumps(args_signature)
 
 
-def _generate_arg_id(
-    arg_declaration: PositionalArg, evaluated_arg: Evaluated
-) -> dict[str, str]:
-    arg_value = evaluated_arg.value
-    arg_name = arg_declaration.name
-    if isinstance(arg_declaration, ClassicalParameterDeclaration):
-        return {arg_name: evaluated_classical_param_to_str(arg_value)}
-    if isinstance(arg_declaration, PortDeclaration):
-        return {arg_name: _evaluated_port_to_str(arg_value)}
-    if isinstance(arg_declaration, QuantumOperandDeclaration):
-        return {arg_name: _evaluated_operand_to_str(arg_value)}
-
-
+@singledispatch
 def _evaluated_arg_to_str(arg: Any) -> str:
     if isinstance(arg, str):
         return arg
-    return str(uuid.uuid4())
+    if isinstance(arg, QuantumSymbol):
+        return _evaluated_quantum_symbol_to_str(arg)
+    if isinstance(arg, FunctionClosure):
+        return _evaluated_one_operand_to_str(arg)
+    if isinstance(arg, list) and arg and isinstance(arg[0], FunctionClosure):
+        return _evaluated_operands_list_to_str(arg)
+    return evaluated_classical_param_to_str(arg)
 
 
-@singledispatch
-def _evaluated_port_to_str(arg: Any) -> str:
-    return _evaluated_arg_to_str(arg)
-
-
-@_evaluated_port_to_str.register
 def _evaluated_quantum_symbol_to_str(port: QuantumSymbol) -> str:
     return port.quantum_type.model_dump_json(exclude_none=True, exclude={"name"})
 
 
-@_evaluated_port_to_str.register
-def _evaluated_symbol_to_str(port: Symbol) -> str:
-    return repr(port)
-
-
-@singledispatch
-def _evaluated_operand_to_str(arg: Any) -> str:
-    return _evaluated_arg_to_str(arg)
-
-
-@_evaluated_operand_to_str.register
 def _evaluated_one_operand_to_str(operand: FunctionClosure) -> str:
     return operand.closure_id
 
 
-@_evaluated_operand_to_str.register
-def _evaluated_list_operands_to_str(operands: list) -> str:
-    return json.dumps([_evaluated_operand_to_str(ope) for ope in operands])
+def _evaluated_operands_list_to_str(arg: list[FunctionClosure]) -> str:
+    return json.dumps([_evaluated_one_operand_to_str(ope) for ope in arg])

classiq/model_expansions/function_builder.py

@@ -31,6 +31,7 @@ from classiq.model_expansions.capturing.captured_vars import (
 )
 from classiq.model_expansions.closure import Closure, FunctionClosure
 from classiq.model_expansions.scope import Scope
+from classiq.model_expansions.utils.counted_name_allocator import CountedNameAllocator
 
 ClosureType = TypeVar("ClosureType", bound=Closure)
 
@@ -82,16 +83,23 @@ class FunctionContext(OperationContext[FunctionClosure]):
 
 
 class OperationBuilder:
-    def __init__(self, functions_scope: Scope) -> None:
+    def __init__(
+        self, functions_scope: Scope, counted_name_allocator: CountedNameAllocator
+    ) -> None:
         self._operations: list[OperationContext] = []
         self._blocks: list[str] = []
         self._functions_scope = functions_scope
         self._current_source_ref: Optional[SourceReference] = None
+        self._counted_name_allocator = counted_name_allocator
 
     @property
     def current_operation(self) -> Closure:
         return self._operations[-1].closure
 
+    @property
+    def current_scope(self) -> Scope:
+        return self.current_operation.scope
+
     @property
     def current_function(self) -> FunctionClosure:
         return self._get_last_function(self._operations)
@@ -137,7 +145,8 @@ class OperationBuilder:
             validate_captured_directions(
                 captured_vars.filter_vars(
                     self.current_function, self.current_block.variable_declarations
-                )
+                ),
+                report_outin=False,
             )
         self.current_operation.captured_vars.update(
             captured_vars.filter_vars(self.current_function)
@@ -193,13 +202,14 @@ class OperationBuilder:
     ) -> NativeFunctionDefinition:
         name = function_context.name
         if name != MAIN_FUNCTION_NAME:
-            idx = 0
-            new_name = name
-            while idx == 0 or new_name in self._functions_scope:
-                new_name = f"{name}_{LAMBDA_KEYWORD + '_0_0_' if function_context.is_lambda else ''}{EXPANDED_KEYWORD}_{idx}"
-                idx += 1
-            name = new_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")
         new_parameters: list[PortDeclaration] = [
             param
             for param in function_context.positional_arg_declarations

classiq/model_expansions/generative_functions.py

@@ -105,7 +105,21 @@ class _InterpreterExpandable(QFunc):
             positional_arg_declarations=current_operation.positional_arg_declarations,
             body=self._interpreter._builder._current_statements + [stmt],
         )
-        resolve_function_calls(dummy_function, self._get_function_declarations())
+        declarative_functions = {
+            name: func
+            for name, func in self._qmodule.native_defs.items()
+            if name not in self._interpreter._top_level_scope
+        }
+        self._interpreter.update_declarative_functions(
+            declarative_functions, self._qmodule
+        )
+        self._interpreter.update_generative_functions(
+            self._qmodule.generative_functions
+        )
+        func_decls = self._get_function_declarations()
+        for dec_func in declarative_functions.values():
+            resolve_function_calls(dec_func, func_decls)
+        resolve_function_calls(dummy_function, func_decls)
         stmt = dummy_function.body[-1]
         with generative_mode_context(False):
             self._interpreter.emit_statement(stmt)
@@ -116,7 +130,7 @@ class _InterpreterExpandable(QFunc):
                 name=name,
                 positional_arg_declarations=evaluated.value.positional_arg_declarations,
             )
-            for name, evaluated in self._interpreter._current_scope.items()
+            for name, evaluated in self._interpreter._builder.current_scope.items()
             if isinstance(evaluated, Evaluated)
             and isinstance(evaluated.value, FunctionClosure)
         } | nameables_to_dict(self._interpreter._get_function_declarations())

classiq/model_expansions/interpreter.py

@@ -1,6 +1,6 @@
-import copy
-from collections.abc import Iterator, Sequence
-from contextlib import contextmanager, nullcontext
+from collections import defaultdict
+from collections.abc import Sequence
+from contextlib import nullcontext
 from functools import singledispatchmethod
 from typing import Any, Optional, cast
 
@@ -32,7 +32,7 @@ from classiq.interface.model.handle_binding import (
 )
 from classiq.interface.model.inplace_binary_operation import InplaceBinaryOperation
 from classiq.interface.model.invert import Invert
-from classiq.interface.model.model import Model
+from classiq.interface.model.model import MAIN_FUNCTION_NAME, Model
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.phase_operation import PhaseOperation
 from classiq.interface.model.power import Power
@@ -93,11 +93,14 @@ 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,
+    add_functions_to_scope,
+    add_generative_functions_to_scope,
     get_main_renamer,
     init_top_level_scope,
 )
 from classiq.model_expansions.utils.counted_name_allocator import CountedNameAllocator
 from classiq.qmod.builtins.functions import permute
+from classiq.qmod.model_state_container import QMODULE, ModelStateContainer
 from classiq.qmod.quantum_function import GenerativeQFunc
 from classiq.qmod.semantics.error_manager import ErrorManager
 
@@ -107,51 +110,52 @@ class Interpreter:
         self,
         model: Model,
         generative_functions: Optional[list[GenerativeQFunc]] = None,
-        is_frontend: bool = False,
+        is_normalizer: bool = False,
+        is_shallow: bool = False,
     ) -> None:
-        self._is_frontend = is_frontend
+        self._is_normalizer = is_normalizer
+        self._is_shallow = is_shallow
         self._model = model
-        self._current_scope = Scope()
-        self._top_level_scope = self._current_scope
-        self._builder = OperationBuilder(self._top_level_scope)
+        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_top_level_scope(model, generative_functions or [], self._top_level_scope)
         self._main_renamer: Optional[ExpressionRenamer] = (
-            get_main_renamer(self._model.functions) if self._is_frontend else None
+            get_main_renamer(self._get_function_declarations())
+            if self._is_normalizer
+            else None
+        )
+        self._functions_compilation_metadata: dict[str, CompilationMetadata] = dict(
+            self._model.functions_compilation_metadata
         )
-
-        if generative_functions is None:
-            generative_functions = []
-        self._generative_functions = generative_functions
-        init_top_level_scope(model, generative_functions, self._current_scope)
         self._expanded_functions_compilation_metadata: dict[
             str, CompilationMetadata
-        ] = dict()
+        ] = defaultdict(CompilationMetadata)
         self._counted_name_allocator = CountedNameAllocator()
         self._error_manager: ErrorManager = ErrorManager()
 
-    @contextmanager
-    def _scope_guard(self, scope: Scope) -> Iterator[None]:
-        """This manager restores both `scope` and `self._current_scope` to their previous values."""
-        scope_data = copy.copy(scope.data)
-        prev_context_scope_data = copy.copy(self._current_scope.data)
-
-        prev_context_scope = self._current_scope
-        self._current_scope = scope
-        yield
-        prev_context_scope.data = prev_context_scope_data
-        self._current_scope = prev_context_scope
-
-        scope.data = scope_data
-
     def _expand_main_func(self) -> None:
-        main_closure = FunctionClosure.create(
-            name=self._model.main_func.name,
-            positional_arg_declarations=self._model.main_func.positional_arg_declarations,
-            body=self._model.main_func.body,
-            scope=Scope(parent=self._current_scope),
+        main_func = self._top_level_scope[MAIN_FUNCTION_NAME].value
+        closure_constructor: Any
+        if isinstance(main_func, GenerativeFunctionClosure):
+            closure_constructor = GenerativeFunctionClosure
+            extra_args = {
+                "generative_blocks": {"body": main_func.generative_blocks["body"]}
+            }
+        else:
+            closure_constructor = FunctionClosure
+            extra_args = {"body": main_func.body}
+        main_closure = closure_constructor.create(
+            name=main_func.name,
+            positional_arg_declarations=main_func.positional_arg_declarations,
+            scope=Scope(parent=self._top_level_scope),
             expr_renamer=self._main_renamer,
             _depth=0,
+            **extra_args,
         )
 
         add_entry_point_params_to_scope(
@@ -185,9 +189,9 @@ class Interpreter:
             execution_preferences=self._model.execution_preferences,
             functions=list(self._expanded_functions.values()),
             constants=self._model.constants,
-            enums=self._model.enums,
-            types=self._model.types,
-            qstructs=self._model.qstructs,
+            enums=list(QMODULE.enum_decls.values()),
+            types=list(QMODULE.type_decls.values()),
+            qstructs=list(QMODULE.qstruct_decls.values()),
             debug_info=self._model.debug_info,
             functions_compilation_metadata=self._expanded_functions_compilation_metadata,
         )
@@ -198,11 +202,11 @@ class Interpreter:
 
     @evaluate.register
     def evaluate_classical_expression(self, expression: Expression) -> Evaluated:
-        return evaluate_classical_expression(expression, self._current_scope)
+        return evaluate_classical_expression(expression, self._builder.current_scope)
 
     @evaluate.register
     def evaluate_identifier(self, identifier: str) -> Evaluated:
-        return self._current_scope[identifier]
+        return self._builder.current_scope[identifier]
 
     @evaluate.register
     def evaluate_lambda(self, function: QuantumLambdaFunction) -> Evaluated:
@@ -211,7 +215,9 @@ class Interpreter:
             for idx, param in enumerate(function.func_decl.positional_arg_declarations)
         ]
         func_decl = NamedParamsQuantumFunctionDeclaration(
-            name=function.func_decl.name or "<lambda>",
+            name=self._counted_name_allocator.allocate(
+                function.func_decl.name or "<lambda>"
+            ),
             positional_arg_declarations=renamed_params,
         )
 
@@ -233,7 +239,7 @@ class Interpreter:
                 name=func_decl.name,
                 positional_arg_declarations=func_decl.positional_arg_declarations,
                 body=function.body,
-                scope=Scope(parent=self._current_scope),
+                scope=Scope(parent=self._builder.current_scope),
                 is_lambda=True,
                 **extra_args,
             ),
@@ -290,7 +296,7 @@ class Interpreter:
 
     @emit.register
     def emit_quantum_assignment_operation(self, op: QuantumAssignmentOperation) -> None:
-        if self._is_frontend:
+        if self._is_normalizer:
             ShallowEmitter(
                 self, "assignment_operation", components=["expression", "result_var"]
             ).emit(op)
@@ -299,7 +305,7 @@ class Interpreter:
 
     @emit.register
     def emit_inplace_binary_operation(self, op: InplaceBinaryOperation) -> None:
-        if self._is_frontend:
+        if self._is_normalizer:
             ShallowEmitter(
                 self, "inplace_binary_operation", components=["target", "value"]
             ).emit(op)
@@ -318,7 +324,7 @@ class Interpreter:
 
     @emit.register
     def emit_within_apply(self, within_apply: WithinApply) -> None:
-        if self._is_frontend:
+        if self._is_normalizer:
             ShallowEmitter(
                 self,
                 WITHIN_APPLY_NAME,
@@ -329,7 +335,7 @@ class Interpreter:
 
     @emit.register
     def emit_invert(self, invert: Invert) -> None:
-        if self._is_frontend:
+        if self._is_normalizer:
             ShallowEmitter(self, INVERT_OPERATOR_NAME, components=["body"]).emit(invert)
         else:
             InvertEmitter(self).emit(invert)
@@ -340,7 +346,7 @@ class Interpreter:
 
     @emit.register
     def emit_control(self, control: Control) -> None:
-        if self._is_frontend:
+        if self._is_normalizer:
             ShallowEmitter(
                 self,
                 CONTROL_OPERATOR_NAME,
@@ -351,7 +357,7 @@ class Interpreter:
 
     @emit.register
     def emit_power(self, power: Power) -> None:
-        if self._is_frontend:
+        if self._is_normalizer:
             ShallowEmitter(
                 self, CONTROL_OPERATOR_NAME, components=["power", "body"]
             ).emit(power)
@@ -360,7 +366,7 @@ class Interpreter:
 
     @emit.register
     def emit_phase(self, phase: PhaseOperation) -> None:
-        if self._is_frontend:
+        if self._is_normalizer:
             ShallowEmitter(self, "phase", components=["expression", "theta"]).emit(
                 phase
             )
@@ -385,24 +391,23 @@ class Interpreter:
     def _expand_operation(self, operation: Closure) -> OperationContext:
         with self._builder.operation_context(operation) as context:
             if isinstance(operation, FunctionClosure) and (
-                self._expanded_functions.get(operation.closure_id) is not None
+                (func_def := self._expanded_functions.get(operation.closure_id))
+                is not None
             ):
-                pass
+                captured_vars = self._top_level_scope[func_def.name].value.captured_vars
+                operation.captured_vars.update(captured_vars)
             elif isinstance(operation, FunctionClosure) and operation.name == "permute":
                 # special expansion since permute is generative
-                with self._scope_guard(operation.scope):
-                    self._expand_permute()
+                self._expand_permute()
             elif isinstance(operation, GenerativeClosure):
-                with self._scope_guard(operation.scope):
-                    args = [
-                        self.evaluate(param.name)
-                        for param in operation.positional_arg_declarations
-                    ]
-                    emit_generative_statements(self, operation, args)
+                args = [
+                    self.evaluate(param.name)
+                    for param in operation.positional_arg_declarations
+                ]
+                emit_generative_statements(self, operation, args)
             else:
                 for block, block_body in operation.blocks.items():
-                    with self._scope_guard(operation.scope):
-                        self._expand_block(block_body, block)
+                    self._expand_block(block_body, block)
 
         return context
 
@@ -421,11 +426,50 @@ class Interpreter:
         self._expand_block(calls, "body")
 
     def _get_function_declarations(self) -> Sequence[QuantumFunctionDeclaration]:
-        return (
-            self._model.functions
-            + [gen_func.func_decl for gen_func in self._generative_functions]
-            + list(self._expanded_functions.values())
-        )
+        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)
+
+    def update_declarative_functions(
+        self,
+        functions: dict[str, NativeFunctionDefinition],
+        qmodule: ModelStateContainer,
+    ) -> None:
+        add_functions_to_scope(list(functions.values()), self._top_level_scope)
+        for dec_func_name in functions:
+            if dec_func_name in qmodule.functions_compilation_metadata:
+                self._functions_compilation_metadata[dec_func_name] = (
+                    qmodule.functions_compilation_metadata[dec_func_name]
+                )
+
+    def update_generative_functions(
+        self, generative_functions: dict[str, GenerativeQFunc]
+    ) -> None:
+        add_generative_functions_to_scope(
+            list(generative_functions.values()), self._top_level_scope
+        )
+        for name, gen_func in generative_functions.items():
+            if gen_func.compilation_metadata is not None:
+                self._functions_compilation_metadata[name] = (
+                    gen_func.compilation_metadata
+                )
+
+    def add_purely_declarative_function(self, function: FunctionClosure) -> None:
+        functions_to_add = [function.name] + QMODULE.function_dependencies[
+            function.name
+        ]
+        for func in functions_to_add:
+            if func not in self._expanded_functions and func in QMODULE.native_defs:
+                self._expanded_functions[func] = QMODULE.native_defs[func]
+                if func in QMODULE.functions_compilation_metadata:
+                    self._expanded_functions_compilation_metadata[func] = (
+                        QMODULE.functions_compilation_metadata[func]
+                    )

classiq/model_expansions/model_tables.py

@@ -78,10 +78,14 @@ class SymbolTable:
     @classmethod
     def init_user_enums(cls, user_enums: list[EnumDeclaration]) -> None:
         cls.enum_table = EnumTable(user_enums)
+        QMODULE.enum_decls = {enum_decl.name: enum_decl for enum_decl in user_enums}
 
     @classmethod
     def init_user_types(cls, user_types: list[StructDeclaration]) -> None:
         cls.type_table = StructTable(user_types)
+        QMODULE.type_decls = {
+            struct_decl.name: struct_decl for struct_decl in user_types
+        }
 
     @classmethod
     def init_user_qstructs(cls, user_qstructs: list[QStructDeclaration]) -> None: