classiq 0.66.1__py3-none-any.whl → 0.67.0__py3-none-any.whl

classiq/qmod/semantics/validation/func_call_validation.py

@@ -1,99 +0,0 @@
-from collections.abc import Mapping
-
-from classiq.interface.exceptions import ClassiqError
-from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.model.handle_binding import HandleBinding
-from classiq.interface.model.quantum_function_call import QuantumFunctionCall
-from classiq.interface.model.quantum_function_declaration import (
-    AnonQuantumFunctionDeclaration,
-    AnonQuantumOperandDeclaration,
-    QuantumFunctionDeclaration,
-)
-from classiq.interface.model.quantum_lambda_function import (
-    OperandIdentifier,
-    QuantumLambdaFunction,
-    QuantumOperand,
-)
-
-from classiq.qmod.semantics.error_manager import ErrorManager
-
-
-def validate_call_arguments(
-    fc: QuantumFunctionCall,
-    function_dict: Mapping[str, QuantumFunctionDeclaration],
-) -> None:
-    pos_args = fc.positional_args
-    pos_params = fc.func_decl.positional_arg_declarations
-    if len(pos_args) != len(pos_params):
-        ErrorManager().add_error(
-            f"Function {fc.func_name} takes {len(pos_params)} arguments but "
-            f"{len(pos_args)} were given."
-        )
-    for arg, param in zip(pos_args, pos_params):
-        if not isinstance(arg, (Expression, HandleBinding)) and isinstance(
-            param, AnonQuantumOperandDeclaration
-        ):
-            _check_operand_against_declaration(param, arg, function_dict, fc.func_name)
-    check_no_overlapping_quantum_args(fc.ports, fc.func_name)
-
-
-def _check_operand_against_declaration(
-    operand_decl: AnonQuantumOperandDeclaration,
-    operand_argument: QuantumOperand,
-    function_dict: Mapping[str, QuantumFunctionDeclaration],
-    func_name: str,
-    in_list: bool = False,
-) -> None:
-    if isinstance(operand_argument, list):
-        if in_list:
-            ErrorManager().add_error(
-                f"{str(operand_argument)!r} argument to {func_name!r} is not "
-                f"a valid operand. Nested operand lists are not permitted."
-            )
-            return
-        for arg in operand_argument:
-            _check_operand_against_declaration(
-                operand_decl, arg, function_dict, func_name, in_list=True
-            )
-        return
-    operand_arg_decl: AnonQuantumFunctionDeclaration
-    operand_argument_for_decl = operand_argument
-    if isinstance(operand_argument_for_decl, OperandIdentifier):
-        operand_argument_for_decl = operand_argument_for_decl.name
-    if isinstance(operand_argument_for_decl, str):
-        if operand_argument_for_decl not in function_dict:
-            ErrorManager().add_error(
-                f"{operand_argument!r} argument to {func_name!r} is not a "
-                f"registered function."
-            )
-            return
-        operand_arg_decl = function_dict[operand_argument_for_decl]
-    elif isinstance(operand_argument_for_decl, QuantumLambdaFunction):
-        operand_arg_decl = operand_argument_for_decl.func_decl
-    else:
-        raise ClassiqError(
-            f"{str(operand_argument)!r} argument to {func_name!r} is not a "
-            f"valid operand."
-        )
-    num_arg_parameters = len(operand_arg_decl.positional_arg_declarations)
-    num_decl_parameters = len(operand_decl.positional_arg_declarations)
-    if num_arg_parameters != num_decl_parameters:
-        ErrorManager().add_error(
-            f"Signature of argument {operand_argument!r} to {func_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_no_overlapping_quantum_args(
-    args: list[HandleBinding], func_name: str
-) -> None:
-    for idx, arg in enumerate(args):
-        for other_arg in args[idx + 1 :]:
-            if arg.overlaps(other_arg):
-                ErrorManager().add_error(
-                    f"Cannot use the same part of variable {arg.name!r} in multiple "
-                    f"arguments to function {func_name!r}."
-                )
-                break

classiq/qmod/semantics/validation/handle_validation.py

@@ -1,85 +0,0 @@
-from typing import TYPE_CHECKING, Optional, Union
-
-from classiq.interface.generator.functions.type_name import TypeName
-from classiq.interface.model.handle_binding import (
-    ConcreteHandleBinding,
-    FieldHandleBinding,
-    HandleBinding,
-    NestedHandleBinding,
-    SlicedHandleBinding,
-    SubscriptHandleBinding,
-)
-from classiq.interface.model.quantum_type import QuantumBitvector, QuantumType
-
-import classiq.qmod.semantics.error_manager as error_manager
-from classiq.qmod.model_state_container import QMODULE
-
-if TYPE_CHECKING:
-    from classiq.qmod.semantics.static_semantics_visitor import StaticScope
-
-
-def resolve_handle(scope: "StaticScope", handle: HandleBinding) -> None:
-    if handle.name not in scope.variables_to_types:
-        error_manager.append_error(handle, f"Variable {handle.name!r} is undefined.")
-        return
-    _resolve_handle_recursively(scope.variables_to_types[handle.name], handle)
-
-
-def _resolve_handle_recursively(
-    qtype: QuantumType, handle: ConcreteHandleBinding
-) -> Optional[QuantumType]:
-    if isinstance(handle, NestedHandleBinding):
-        return _resolve_nested_handle(qtype, handle)
-    return qtype
-
-
-def _resolve_nested_handle(
-    qtype: QuantumType, handle: NestedHandleBinding
-) -> Optional[QuantumType]:
-    nested_qtype = _resolve_handle_recursively(qtype, handle.base_handle)
-    if nested_qtype is None:
-        return None
-    if isinstance(handle, (SubscriptHandleBinding, SlicedHandleBinding)):
-        return _resolve_subscript_sliced_handle(nested_qtype, handle)
-    if TYPE_CHECKING:
-        assert isinstance(handle, FieldHandleBinding)
-    return _resolve_field_handle(nested_qtype, handle)
-
-
-def _resolve_subscript_sliced_handle(
-    qtype: QuantumType, handle: Union[SubscriptHandleBinding, SlicedHandleBinding]
-) -> Optional[QuantumType]:
-    if not isinstance(qtype, QuantumBitvector):
-        error_manager.append_error(handle, f"{qtype.type_name} is not subscriptable.")
-        return None
-    return qtype.element_type if isinstance(handle, SubscriptHandleBinding) else qtype
-
-
-def _validate_field_access(qtype: QuantumType, handle: FieldHandleBinding) -> bool:
-    if not isinstance(qtype, TypeName):
-        error_manager.append_error(handle, f"{qtype.type_name} has no fields.")
-        return False
-    if qtype.name not in QMODULE.qstruct_decls:
-        error_manager.append_error(
-            handle, f"{qtype.type_name} is not a quantum struct."
-        )
-        return False
-    if handle.field not in qtype.fields:
-        error_manager.append_error(
-            handle,
-            f"Struct {qtype.type_name} has no field {handle.field!r}. "
-            f"Available fields: {', '.join(qtype.fields.keys())}",
-        )
-        return False
-
-    return True
-
-
-def _resolve_field_handle(
-    qtype: QuantumType, handle: FieldHandleBinding
-) -> Optional[QuantumType]:
-    if _validate_field_access(qtype, handle):
-        if TYPE_CHECKING:
-            assert isinstance(qtype, TypeName)
-        return qtype.fields[handle.field]
-    return None