classiq 0.42.2__py3-none-any.whl → 0.43.1__py3-none-any.whl

classiq/qmod/quantum_function.py

@@ -1,10 +1,11 @@
 import ast
 import functools
+from dataclasses import is_dataclass
+from enum import EnumMeta
 from inspect import isclass
 from typing import Any, Callable, Dict, List, Optional, Tuple, get_origin
 
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
-from classiq.interface.generator.functions.classical_type import CStructBase
 from classiq.interface.generator.model.constraints import Constraints
 from classiq.interface.generator.model.preferences.preferences import Preferences
 from classiq.interface.model.model import Model, SerializedModel
@@ -15,7 +16,7 @@ from classiq.interface.model.quantum_function_declaration import (
 
 from classiq.exceptions import ClassiqError
 from classiq.qmod.classical_function import CFunc
-from classiq.qmod.declaration_inferrer import ENUM_TYPE_MAPPING, infer_func_decl
+from classiq.qmod.declaration_inferrer import infer_func_decl
 from classiq.qmod.qmod_constant import QConstant
 from classiq.qmod.qmod_parameter import CArray, CParam
 from classiq.qmod.qmod_variable import QVar
@@ -71,6 +72,7 @@ class QFunc(QExpandable):
         preferences: Optional[Preferences] = None,
         classical_execution_function: Optional[CFunc] = None,
     ) -> Model:
+        self._qmodule.enum_decls = dict()
         self._qmodule.type_decls = dict()
         self._qmodule.native_defs = dict()
         self._qmodule.constants = dict()
@@ -89,6 +91,7 @@ class QFunc(QExpandable):
         return Model(
             constants=list(self._qmodule.constants.values()),
             functions=list(self._qmodule.native_defs.values()),
+            enums=list(self._qmodule.enum_decls.values()),
             types=list(self._qmodule.type_decls.values()),
             **{key: value for key, value in model_extra_settings if value},
         )
@@ -166,12 +169,13 @@ def _validate_no_gen_params(annotations: Dict[str, Any]) -> None:
             or isclass(annotation)
             and issubclass(annotation, CParam)
             or isclass(annotation)
-            and issubclass(annotation, CStructBase)
+            and is_dataclass(annotation)
+            or isclass(annotation)
+            and isinstance(annotation, EnumMeta)
             or get_origin(annotation) is CArray
             or (get_origin(annotation) or annotation) is QCallable
             or (get_origin(annotation) or annotation) is QCallableList
             or QVar.from_type_hint(annotation) is not None
-            or annotation in ENUM_TYPE_MAPPING
         )
     }
     if _illegal_params:

classiq/qmod/semantics/annotation.py

@@ -0,0 +1,38 @@
+from typing import List, Mapping
+
+from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+from classiq.interface.model.quantum_function_declaration import (
+    QuantumFunctionDeclaration,
+)
+from classiq.interface.model.quantum_lambda_function import (
+    QuantumCallable,
+    QuantumLambdaFunction,
+    QuantumOperand,
+)
+
+from classiq.exceptions import ClassiqError
+
+
+def annotate_function_call_decl(
+    fc: QuantumFunctionCall,
+    function_dict: Mapping[str, QuantumFunctionDeclaration],
+) -> None:
+    if fc._func_decl is None:
+        func_decl = function_dict.get(fc.func_name)
+        if func_decl is None:
+            raise ClassiqError(
+                f"Error resolving function {fc.func_name}, the function is not found in included library."
+            )
+        fc.set_func_decl(func_decl)
+
+    for name, op in fc.operands.items():
+        op_decl = fc.func_decl.operand_declarations[name]
+        for qlambda in _get_lambda_defs(op):
+            if isinstance(qlambda, QuantumLambdaFunction):
+                qlambda.set_op_decl(op_decl)
+
+
+def _get_lambda_defs(operand: QuantumOperand) -> List[QuantumCallable]:
+    if isinstance(operand, list):
+        return operand
+    return [operand]

classiq/qmod/semantics/error_manager.py

@@ -0,0 +1,49 @@
+from contextlib import contextmanager
+from typing import Iterator, List, Type
+
+from classiq.interface.ast_node import ASTNode
+
+
+class ErrorManager:
+    def __new__(cls) -> "ErrorManager":
+        if not hasattr(cls, "_instance"):
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __init__(self) -> None:
+        if hasattr(self, "_instantiated"):
+            return
+        self._instantiated = True
+        self._errors: List[str] = []
+        self._current_nodes_stack: List[ASTNode] = []
+
+    def add_error(self, error: str) -> None:
+        source_referenced_error = (
+            f"{error}\n\t\tat {self._current_nodes_stack[-1].source_ref}"
+            if self._current_nodes_stack
+            and self._current_nodes_stack[-1].source_ref is not None
+            else error
+        )
+        self._errors.append(source_referenced_error)
+
+    def get_errors(self) -> List[str]:
+        return self._errors
+
+    def clear(self) -> None:
+        self._current_nodes_stack = []
+        self._errors = []
+
+    def has_errors(self) -> bool:
+        return len(self._errors) > 0
+
+    def report_errors(self, error_type: Type[Exception]) -> None:
+        if self.has_errors():
+            errors = self._errors
+            self.clear()
+            raise error_type("\n\t" + "\n\t".join(errors))
+
+    @contextmanager
+    def node_context(self, node: ASTNode) -> Iterator[None]:
+        self._current_nodes_stack.append(node)
+        yield
+        self._current_nodes_stack.pop()

classiq/qmod/semantics/static_semantics_visitor.py

@@ -0,0 +1,308 @@
+from contextlib import contextmanager
+from typing import Any, Dict, Iterator, List, Mapping, Type, Union
+
+from classiq.interface.generator.function_params import PortDirection
+from classiq.interface.generator.functions.port_declaration import (
+    PortDeclarationDirection,
+)
+from classiq.interface.generator.visitor import Visitor
+from classiq.interface.model.handle_binding import (
+    HandleBinding,
+    SlicedHandleBinding,
+    SubscriptHandleBinding,
+)
+from classiq.interface.model.model import Model
+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 (
+    QuantumFunctionDeclaration,
+    QuantumOperandDeclaration,
+)
+from classiq.interface.model.quantum_lambda_function import (
+    QuantumLambdaFunction,
+)
+from classiq.interface.model.quantum_statement import QuantumOperation
+from classiq.interface.model.validation_handle import HandleState
+from classiq.interface.model.variable_declaration_statement import (
+    VariableDeclarationStatement,
+)
+from classiq.interface.model.within_apply_operation import WithinApply
+
+from classiq.exceptions import ClassiqSemanticError
+from classiq.qmod.semantics.annotation import annotate_function_call_decl
+from classiq.qmod.semantics.error_manager import ErrorManager
+from classiq.qmod.semantics.validation.func_call_validation import (
+    validate_call_arguments,
+)
+from classiq.qmod.semantics.validation.types_validation import check_duplicate_types
+
+
+class StaticScope:
+
+    def __init__(
+        self,
+        parameters: List[str],
+        operands: Dict[str, QuantumOperandDeclaration],
+        variables_to_states: Dict[str, HandleState],
+    ) -> None:
+        self.parameters = parameters
+        self.operands = operands
+        self.variable_states = variables_to_states
+
+
+class StaticSemanticsVisitor(Visitor):
+    def __init__(
+        self,
+        functions_dict: Dict[str, QuantumFunctionDeclaration],
+        constants: List[str],
+    ) -> None:
+        self._scope: List[StaticScope] = []
+        self._error_manager = ErrorManager()
+        self._functions_dict = functions_dict
+        self._constants = constants
+
+    @property
+    def current_scope(self) -> StaticScope:
+        return self._scope[-1]
+
+    @contextmanager
+    def scoped_visit(self, scope: StaticScope) -> Iterator[None]:
+        self._scope.append(scope)
+        yield
+        self._scope.pop()
+
+    def visit_Model(self, model: Model) -> None:
+        check_duplicate_types([*model.enums, *model.types])
+        self.visit_BaseModel(model)
+
+    def visit_NativeFunctionDefinition(
+        self, func_def: NativeFunctionDefinition
+    ) -> None:
+        if len(func_def.body) == 0:
+            return
+        scope = StaticScope(
+            parameters=list(func_def.param_decls.keys()) + self._constants,
+            operands=dict(func_def.operand_declarations),
+            variables_to_states=initialize_variables_to_state(
+                list(func_def.port_declarations.values())
+            ),
+        )
+        with self.scoped_visit(scope):
+            self.visit(func_def.body)
+            with self._error_manager.node_context(func_def.body[-1]):
+                for port_decl in func_def.port_declarations.values():
+                    handle_state = self.current_scope.variable_states[port_decl.name]
+                    expected_terminal_state = EXPECTED_TERMINAL_STATES.get(
+                        port_decl.direction
+                    )
+                    if (
+                        expected_terminal_state is not None
+                        and handle_state is not expected_terminal_state
+                    ):
+                        self._error_manager.add_error(
+                            f"At the end of the function, port `{port_decl.name}` is expected to be {expected_terminal_state.name.lower()} but it isn't"
+                        )
+
+    def visit_WithinApply(self, within_apply: WithinApply) -> None:
+        initial_variables_to_state = self.current_scope.variable_states.copy()
+        scope = StaticScope(
+            parameters=self.current_scope.parameters,
+            operands=self.current_scope.operands,
+            variables_to_states=self.current_scope.variable_states.copy(),
+        )
+        with self.scoped_visit(scope):
+            self.visit(within_apply.compute)
+            compute_captured_variables = {
+                var
+                for var, state in self.current_scope.variable_states.items()
+                if var in initial_variables_to_state
+                and state != initial_variables_to_state[var]
+            }
+            self.visit(within_apply.action)
+            variables_to_state = self.current_scope.variable_states.copy()
+        self.current_scope.variable_states.update(
+            {
+                var: state
+                for var, state in variables_to_state.items()
+                if var in self.current_scope.variable_states
+                and var not in compute_captured_variables
+            }
+        )
+
+    def visit_QuantumOperation(self, op: QuantumOperation) -> None:
+        with self._error_manager.node_context(op):
+            if isinstance(op, QuantumFunctionCall):
+                annotate_function_call_decl(
+                    op,
+                    {
+                        **self._functions_dict,
+                        **self.current_scope.operands,
+                    },
+                )
+                validate_call_arguments(
+                    op,
+                    {
+                        **self._functions_dict,
+                        **self.current_scope.operands,
+                    },
+                )
+            self._handle_inputs(op.wiring_inputs)
+            self._handle_outputs(op.wiring_outputs)
+            self._handle_inouts(op.wiring_inouts)
+            self.generic_visit(op)
+
+    def visit_VariableDeclarationStatement(
+        self, declaration: VariableDeclarationStatement
+    ) -> None:
+        handle_wiring_state = self.current_scope.variable_states.get(declaration.name)
+        if handle_wiring_state is not None:
+            self._error_manager.add_error(
+                f"Trying to declare a variable of the same name as previously declared variable {declaration.name}"
+            )
+            return
+
+        self.current_scope.variable_states[declaration.name] = HandleState.UNINITIALIZED
+
+    def visit_QuantumLambdaFunction(self, lambda_func: QuantumLambdaFunction) -> None:
+        assert lambda_func.func_decl is not None
+        renamed_parameters = [
+            lambda_func.rename_params.get(param, param)
+            for param in self.current_scope.parameters
+            + list(lambda_func.func_decl.param_decls.keys())
+        ]
+        ports = list(lambda_func.func_decl.port_declarations.values())
+        for i, port in enumerate(ports):
+            ports[i] = port.copy(
+                update={"name": lambda_func.rename_params.get(port.name, port.name)}
+            )
+        variables_to_states = self.current_scope.variable_states.copy()
+        original_operands = {
+            **dict(lambda_func.func_decl.operand_declarations),
+            **self.current_scope.operands,
+        }
+        renamed_operands: Dict[str, QuantumOperandDeclaration] = {}
+        for operand_name, operand_decl in original_operands.items():
+            renamed_name = lambda_func.rename_params.get(operand_name, operand_name)
+            renamed_operands[renamed_name] = operand_decl.copy(
+                update={"name": renamed_name}
+            )
+        scope = StaticScope(
+            parameters=renamed_parameters,
+            operands=renamed_operands,
+            variables_to_states={
+                **variables_to_states,
+                **initialize_variables_to_state(ports),
+            },
+        )
+        with self.scoped_visit(scope):
+            self.generic_visit(lambda_func)
+
+    def _handle_inputs(self, inputs: Mapping[str, HandleBinding]) -> None:
+        for handle_binding in inputs.values():
+            handle_wiring_state = self.current_scope.variable_states[
+                handle_binding.name
+            ]
+            if handle_wiring_state is not HandleState.INITIALIZED:
+                self._error_manager.add_error(
+                    f"Trying to access handle {handle_binding.name!r} as input but it is in incorrect state"
+                )
+                continue
+
+            self.current_scope.variable_states[handle_binding.name] = (
+                HandleState.UNINITIALIZED
+            )
+
+    def _handle_outputs(self, outputs: Mapping[str, HandleBinding]) -> None:
+        for handle_binding in outputs.values():
+            handle_wiring_state = self.current_scope.variable_states[
+                handle_binding.name
+            ]
+
+            if handle_wiring_state is not HandleState.UNINITIALIZED:
+                self._error_manager.add_error(
+                    f"Trying to access handle {handle_binding.name!r} as output but it is in incorrect state"
+                )
+                continue
+
+            self.current_scope.variable_states[handle_binding.name] = (
+                HandleState.INITIALIZED
+            )
+
+    def _handle_inouts(
+        self,
+        inouts: Mapping[
+            str, Union[SlicedHandleBinding, SubscriptHandleBinding, HandleBinding]
+        ],
+    ) -> None:
+        sliced_handles = set()
+        whole_handles = set()
+
+        for handle_binding in inouts.values():
+            handle_wiring_state = self.current_scope.variable_states[
+                handle_binding.name
+            ]
+
+            if handle_wiring_state is not HandleState.INITIALIZED:
+                self._error_manager.add_error(
+                    f"Trying to access handle {handle_binding.name!r} as inout but it is in incorrect state"
+                )
+
+            if isinstance(
+                handle_binding, (SlicedHandleBinding, SubscriptHandleBinding)
+            ):
+                sliced_handles.add(handle_binding.name)
+            else:
+                whole_handles.add(handle_binding.name)
+
+        for handle in sliced_handles & whole_handles:
+            self._error_manager.add_error(
+                f"Invalid use of inout handle {handle!r}, used both in slice or subscript and whole"
+            )
+
+
+def resolve_function_calls(
+    root: Any,
+    quantum_function_dict: Mapping[str, QuantumFunctionDeclaration],
+) -> None:
+    StaticSemanticsVisitor(
+        {
+            **QuantumFunctionDeclaration.BUILTIN_FUNCTION_DECLARATIONS,
+            **quantum_function_dict,
+        },
+        [],
+    ).visit(root)
+
+
+def static_semantics_analysis_pass(
+    model: Model, error_type: Type[Exception] = ClassiqSemanticError
+) -> None:
+    StaticSemanticsVisitor(
+        {
+            **QuantumFunctionDeclaration.BUILTIN_FUNCTION_DECLARATIONS,
+            **model.function_dict,
+        },
+        [const.name for const in model.constants],
+    ).visit(model)
+    ErrorManager().report_errors(error_type)
+
+
+EXPECTED_TERMINAL_STATES: Dict[PortDeclarationDirection, HandleState] = {
+    PortDeclarationDirection.Output: HandleState.INITIALIZED,
+    PortDeclarationDirection.Inout: HandleState.INITIALIZED,
+}
+
+
+def initialize_variables_to_state(
+    port_declarations: List[PortDeclaration],
+) -> Dict[str, HandleState]:
+    variables_to_state: Dict[str, HandleState] = dict()
+
+    for port_decl in port_declarations:
+        variables_to_state[port_decl.name] = (
+            HandleState.INITIALIZED
+            if port_decl.direction.includes_port_direction(PortDirection.Input)
+            else HandleState.UNINITIALIZED
+        )
+
+    return variables_to_state

classiq/qmod/semantics/validation/func_call_validation.py

@@ -0,0 +1,149 @@
+import re
+from typing import Mapping, Set
+
+from classiq.interface.generator.functions.port_declaration import (
+    PortDeclarationDirection,
+)
+from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+from classiq.interface.model.quantum_function_declaration import (
+    QuantumFunctionDeclaration,
+    QuantumOperandDeclaration,
+)
+from classiq.interface.model.quantum_lambda_function import (
+    QuantumLambdaFunction,
+    QuantumOperand,
+)
+
+from classiq.exceptions import ClassiqError
+from classiq.qmod.semantics.error_manager import ErrorManager
+
+
+def validate_call_arguments(
+    fc: QuantumFunctionCall,
+    function_dict: Mapping[str, QuantumFunctionDeclaration],
+) -> None:
+    _check_params_against_declaration(
+        set(fc.params.keys()),
+        set(fc.func_decl.param_decls.keys()),
+        fc.func_decl.name,
+    )
+    _check_ports_against_declaration(fc, fc.func_decl)
+    _check_params_against_declaration(
+        set(fc.operands.keys()),
+        set(fc.func_decl.operand_declarations.keys()),
+        fc.func_name,
+    )
+    _check_operands_against_declaration(fc, fc.func_decl, function_dict)
+
+
+def _check_ports_against_declaration(
+    call: QuantumFunctionCall, decl: QuantumFunctionDeclaration
+) -> None:
+    call_input_names = set(call.inputs.keys())
+
+    _check_params_against_declaration(
+        call_input_names,
+        decl.ports_by_declaration_direction(PortDeclarationDirection.Input),
+        call.func_name,
+    )
+
+    call_output_names = set(call.outputs.keys())
+
+    _check_params_against_declaration(
+        call_output_names,
+        decl.ports_by_declaration_direction(PortDeclarationDirection.Output),
+        call.func_name,
+    )
+
+    inout_params = set(call.inouts.keys())
+
+    _check_params_against_declaration(
+        inout_params,
+        decl.ports_by_declaration_direction(PortDeclarationDirection.Inout),
+        call.func_name,
+    )
+
+
+def _check_operand_against_declaration(
+    call: QuantumFunctionCall,
+    operand_decl: QuantumOperandDeclaration,
+    operand_argument: QuantumOperand,
+    function_dict: Mapping[str, QuantumFunctionDeclaration],
+    in_list: bool = False,
+) -> None:
+    if isinstance(operand_argument, list):
+        if in_list:
+            ErrorManager().add_error(
+                f"{str(operand_argument)!r} argument to {call.func_decl.name!r} is not "
+                f"a valid operand. Nested operand lists are not permitted"
+            )
+            return
+        for arg in operand_argument:
+            _check_operand_against_declaration(
+                call, operand_decl, arg, function_dict, in_list=True
+            )
+        return
+    operand_arg_decl: QuantumFunctionDeclaration
+    if isinstance(operand_argument, str):
+        if operand_argument not in function_dict:
+            ErrorManager().add_error(
+                f"{operand_argument!r} argument to {call.func_decl.name!r} is not a "
+                f"registered function"
+            )
+            return
+        operand_arg_decl = function_dict[operand_argument]
+    elif isinstance(operand_argument, QuantumLambdaFunction):
+        if operand_argument.func_decl is None:
+            return
+        operand_arg_decl = operand_argument.func_decl
+    else:
+        raise ClassiqError(
+            f"{str(operand_argument)!r} argument to {call.func_decl.name!r} is not a "
+            f"valid operand"
+        )
+    num_arg_parameters = len(operand_arg_decl.get_positional_arg_decls())
+    num_decl_parameters = len(operand_decl.get_positional_arg_decls())
+    if num_arg_parameters != num_decl_parameters:
+        ErrorManager().add_error(
+            f"Signature of argument {operand_argument!r} to {call.func_decl.name!r} "
+            f"does not match the signature of parameter {operand_decl.name!r}. "
+            f"{operand_decl.name!r} accepts {num_decl_parameters} parameters but "
+            f"{operand_argument!r} accepts {num_arg_parameters} parameters"
+        )
+
+
+def _check_operands_against_declaration(
+    call: QuantumFunctionCall,
+    decl: QuantumFunctionDeclaration,
+    function_dict: Mapping[str, QuantumFunctionDeclaration],
+) -> None:
+    for operand_parameter, operand_argument in call.operands.items():
+        _check_operand_against_declaration(
+            call,
+            decl.operand_declarations[operand_parameter],
+            operand_argument,
+            function_dict,
+        )
+
+
+def _check_params_against_declaration(
+    call_params: Set[str],
+    param_decls: Set[str],
+    callee_name: str,
+) -> None:
+    unknown_params = call_params - param_decls
+    if any(re.match(r"arg\d+", param) for param in unknown_params):
+        error_msg = (
+            f"Unsupported passing of named function {callee_name!r} as an operand."
+            "\nSuggestion: replace the named function with lambda function."
+        )
+    else:
+        error_msg = f"Unknown parameters {unknown_params} in call to {callee_name!r}."
+    if unknown_params:
+        ErrorManager().add_error(error_msg)
+
+    missing_params = param_decls - call_params
+    if missing_params:
+        ErrorManager().add_error(
+            f"Missing parameters {missing_params} in call to {callee_name!r}."
+        )

classiq/qmod/semantics/validation/types_validation.py

@@ -0,0 +1,21 @@
+from typing import Sequence, Union
+
+from classiq import EnumDeclaration, StructDeclaration
+from classiq.qmod.semantics.error_manager import ErrorManager
+
+
+def check_duplicate_types(
+    types: Sequence[Union[EnumDeclaration, StructDeclaration]]
+) -> None:
+    known_types = {
+        type_.name for type_ in EnumDeclaration.BUILTIN_ENUM_DECLARATIONS.values()
+    }
+    known_types |= {
+        type_.name for type_ in StructDeclaration.BUILTIN_STRUCT_DECLARATIONS.values()
+    }
+    for type_ in types:
+        if type_.name in known_types:
+            with ErrorManager().node_context(type_):
+                ErrorManager().add_error(f"Type {type_.name!r} already exists")
+        else:
+            known_types.add(type_.name)

classiq/qmod/symbolic.py

@@ -25,12 +25,12 @@ from classiq.qmod.qmod_variable import QNum
 from classiq.qmod.symbolic_expr import SymbolicExpr
 from classiq.qmod.symbolic_type import SymbolicTypes
 
-pi = SymbolicExpr("pi")
-E = SymbolicExpr("E")
-I = SymbolicExpr("I")  # noqa: E741
-GoldenRatio = SymbolicExpr("GoldenRatio")
-EulerGamma = SymbolicExpr("EulerGamma")
-Catalan = SymbolicExpr("Catalan")
+pi = SymbolicExpr("pi", False)
+E = SymbolicExpr("E", False)
+I = SymbolicExpr("I", False)  # noqa: E741
+GoldenRatio = SymbolicExpr("GoldenRatio", False)
+EulerGamma = SymbolicExpr("EulerGamma", False)
+Catalan = SymbolicExpr("Catalan", False)
 
 T = TypeVar("T", bound=CParam)