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

classiq/qmod/qmod_variable.py

@@ -22,6 +22,7 @@ from typing_extensions import ParamSpec, Self, _AnnotatedAlias
 
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.non_symbolic_expr import NonSymbolicExpr
 from classiq.interface.generator.expressions.qmod_qarray_proxy import (
     ILLEGAL_SLICE_MSG,
     ILLEGAL_SLICING_STEP_MSG,
@@ -185,6 +186,10 @@ class QVar(Symbolic):
                 return interpret_expression(str(self.size))
         return CParamScalar(f"get_field({self}, 'size')")
 
+    @property
+    def type_name(self) -> str:
+        return self.get_qmod_type().type_name
+
 
 _Q = TypeVar("_Q", bound=QVar)
 Output = Annotated[_Q, PortDeclarationDirection.Output]
@@ -414,7 +419,7 @@ class QNum(Generic[_P], QScalar):
             return _GenericAlias(cls, args)
 
 
-class QArray(ArrayBase[_P], QVar):
+class QArray(ArrayBase[_P], QVar, NonSymbolicExpr):
     CONSTRUCTOR_DEPTH: int = 3
 
     # TODO [CAD-18620]: improve type hints

classiq/qmod/semantics/annotation/call_annotation.py

@@ -3,8 +3,17 @@ from contextlib import contextmanager
 from typing import Any
 
 from classiq.interface.exceptions import ClassiqError
-from classiq.interface.generator.visitor import Visitor
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.classical_type import Integer
+from classiq.interface.generator.functions.port_declaration import (
+    PortDeclarationDirection,
+)
+from classiq.interface.model.classical_parameter_declaration import (
+    ClassicalParameterDeclaration,
+)
+from classiq.interface.model.model_visitor import ModelVisitor
 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 (
     AnonQuantumOperandDeclaration,
@@ -14,17 +23,36 @@ from classiq.interface.model.quantum_function_declaration import (
 from classiq.interface.model.quantum_lambda_function import (
     QuantumLambdaFunction,
 )
+from classiq.interface.model.quantum_type import QuantumBitvector
 
 from classiq.qmod.builtins.functions import BUILTIN_FUNCTION_DECLARATIONS
 from classiq.qmod.semantics.annotation.qstruct_annotator import QStructAnnotator
 from classiq.qmod.semantics.error_manager import ErrorManager
 from classiq.qmod.semantics.lambdas import get_renamed_parameters
 
+ALLOCATE_DECL_FOR_COMPATIBILITY = QuantumFunctionDeclaration(
+    name="allocate",
+    positional_arg_declarations=[
+        ClassicalParameterDeclaration(
+            name="num_qubits",
+            classical_type=Integer(),
+        ),
+        PortDeclaration(
+            name="out",
+            quantum_type=QuantumBitvector(length=Expression(expr="num_qubits")),
+            direction=PortDeclarationDirection.Output,
+        ),
+    ],
+)
+
 
 def _annotate_function_call_decl(
     fc: QuantumFunctionCall,
     function_dict: Mapping[str, QuantumFunctionDeclaration],
 ) -> None:
+    if fc.function == "allocate":  # FIXME: Remove compatibility (CAD-25935)
+        fc.set_func_decl(ALLOCATE_DECL_FOR_COMPATIBILITY)
+        return
     if fc._func_decl is None:
         func_decl = function_dict.get(fc.func_name)
         if func_decl is None:
@@ -46,7 +74,7 @@ def _annotate_function_call_decl(
                 qlambda.set_op_decl(param)
 
 
-class _CallLambdaAnnotator(Visitor):
+class _CallLambdaAnnotator(ModelVisitor):
     def __init__(
         self, quantum_functions: Mapping[str, QuantumFunctionDeclaration]
     ) -> None:

classiq/qmod/semantics/annotation/qstruct_annotator.py

@@ -1,10 +1,10 @@
 from classiq.interface.generator.functions.type_name import TypeName
-from classiq.interface.generator.visitor import Visitor
+from classiq.interface.model.model_visitor import ModelVisitor
 
 from classiq.qmod.model_state_container import QMODULE
 
 
-class QStructAnnotator(Visitor):
+class QStructAnnotator(ModelVisitor):
     def __init__(self) -> None:
         self._visited: set[TypeName] = set()
 

classiq/qmod/semantics/error_manager.py

@@ -4,7 +4,7 @@ from typing import Optional
 
 from classiq.interface.ast_node import ASTNode
 from classiq.interface.exceptions import CLASSIQ_SLACK_COMMUNITY_LINK
-from classiq.interface.source_reference import SourceReferencedError
+from classiq.interface.source_reference import SourceReference, SourceReferencedError
 
 
 class ErrorManager:
@@ -22,6 +22,12 @@ class ErrorManager:
         self._call_stack: list[str] = []
         self._ignore_errors: bool = False
 
+    @property
+    def _current_source_ref(self) -> Optional[SourceReference]:
+        if self._current_nodes_stack:
+            return self._current_nodes_stack[-1].source_ref
+        return None
+
     @contextmanager
     def ignore_errors_context(self) -> Iterator[None]:
         previous = self._ignore_errors
@@ -35,17 +41,25 @@ class ErrorManager:
     def annotated_errors(self) -> list[str]:
         return [str(error) for error in self._errors]
 
-    def add_error(self, error: str) -> None:
+    def add_error(
+        self,
+        error: str,
+        *,
+        source_ref: Optional[SourceReference] = None,
+        function: Optional[str] = None
+    ) -> None:
         if not self._ignore_errors:
             self._errors.append(
                 SourceReferencedError(
                     error=error.replace(CLASSIQ_SLACK_COMMUNITY_LINK, ""),
                     source_ref=(
-                        self._current_nodes_stack[-1].source_ref
-                        if self._current_nodes_stack
-                        else None
+                        source_ref
+                        if source_ref is not None
+                        else self._current_source_ref
+                    ),
+                    function=(
+                        function if function is not None else self.current_function
                     ),
-                    function=self.current_function,
                 )
             )
 

classiq/qmod/semantics/static_semantics_visitor.py

@@ -13,7 +13,6 @@ from classiq.interface.generator.functions.concrete_types import ConcreteQuantum
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
-from classiq.interface.generator.visitor import Visitor
 from classiq.interface.model.handle_binding import (
     FieldHandleBinding,
     HandleBinding,
@@ -22,6 +21,7 @@ from classiq.interface.model.handle_binding import (
 )
 from classiq.interface.model.inplace_binary_operation import InplaceBinaryOperation
 from classiq.interface.model.model import Model
+from classiq.interface.model.model_visitor import ModelVisitor
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_expressions.quantum_expression import (
@@ -50,26 +50,11 @@ from classiq.qmod.semantics.annotation.call_annotation import resolve_function_c
 from classiq.qmod.semantics.annotation.qstruct_annotator import QStructAnnotator
 from classiq.qmod.semantics.error_manager import ErrorManager
 from classiq.qmod.semantics.lambdas import get_renamed_parameters
-from classiq.qmod.semantics.validation.constants_validation import (
-    check_duplicate_constants,
-)
 from classiq.qmod.semantics.validation.func_call_validation import (
     check_no_overlapping_quantum_args,
     validate_call_arguments,
 )
-from classiq.qmod.semantics.validation.function_name_collisions_validation import (
-    _check_function_name_collisions,
-)
 from classiq.qmod.semantics.validation.handle_validation import resolve_handle
-from classiq.qmod.semantics.validation.main_validation import validate_main_function
-from classiq.qmod.semantics.validation.types_validation import (
-    check_cstruct_has_fields,
-    check_duplicate_types,
-    check_qstruct_fields_are_defined,
-    check_qstruct_flexibility,
-    check_qstruct_has_fields,
-    check_qstruct_is_not_recursive,
-)
 
 HANDLE_BINDING_PART_MESSAGE = {
     SubscriptHandleBinding: "array subscript",
@@ -92,7 +77,7 @@ class StaticScope:
         self.variables_to_types = variables_to_types
 
 
-class StaticSemanticsVisitor(Visitor):
+class StaticSemanticsVisitor(ModelVisitor):
     def __init__(
         self,
         functions_dict: Mapping[str, QuantumFunctionDeclaration],
@@ -114,17 +99,6 @@ class StaticSemanticsVisitor(Visitor):
         self._scope.pop()
 
     def visit_Model(self, model: Model) -> None:
-        check_duplicate_types([*model.enums, *model.types, *model.qstructs])
-        check_duplicate_constants(model.constants)
-        for qstruct in model.qstructs:
-            check_qstruct_has_fields(qstruct)
-            if check_qstruct_fields_are_defined(
-                qstruct
-            ) and check_qstruct_is_not_recursive(qstruct):
-                check_qstruct_flexibility(qstruct)
-        for cstruct in model.types:
-            check_cstruct_has_fields(cstruct)
-        validate_main_function(model.main_func)
         self.visit_BaseModel(model)
 
     def visit_NativeFunctionDefinition(
@@ -141,16 +115,6 @@ class StaticSemanticsVisitor(Visitor):
             },
         )
         with self.scoped_visit(scope), self._error_manager.call(func_def.name):
-            parameter_declaration_names = [
-                decl.name for decl in func_def.positional_arg_declarations
-            ]
-            seen_names: set[str] = set()
-            for name in parameter_declaration_names:
-                if name in seen_names:
-                    self._error_manager.add_error(
-                        f"duplicate parameter declaration name {name!r}"
-                    )
-                seen_names.add(name)
             if len(func_def.body) == 0:
                 return
             self.visit(func_def.body)
@@ -165,7 +129,7 @@ class StaticSemanticsVisitor(Visitor):
                         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"
+                            f"At the end of the function, variable {port_decl.name!r} is expected to be {expected_terminal_state.name.lower()} but it isn't"
                         )
 
     def visit_WithinApply(self, within_apply: WithinApply) -> None:
@@ -351,7 +315,6 @@ class StaticSemanticsVisitor(Visitor):
 def static_semantics_analysis_pass(
     model: Model, error_type: Optional[type[Exception]] = ClassiqSemanticError
 ) -> None:
-    _check_function_name_collisions(model, error_type)
     QStructAnnotator().visit(model)
     functions = {**BUILTIN_FUNCTION_DECLARATIONS, **model.function_dict}
     resolve_function_calls(model, functions)

classiq/qmod/semantics/validation/constants_validation.py

@@ -1,16 +1,15 @@
 from collections.abc import Sequence
 
+from classiq.interface.exceptions import ClassiqExpansionError
 from classiq.interface.generator.constant import Constant
 
 from classiq.qmod.builtins import BUILTIN_CONSTANTS
-from classiq.qmod.semantics.error_manager import ErrorManager
 
 
 def check_duplicate_constants(constants: Sequence[Constant]) -> None:
     known_constants = {constant.name: constant for constant in BUILTIN_CONSTANTS}
     for constant in constants:
         if constant.name in known_constants:
-            with ErrorManager().node_context(constant):
-                ErrorManager().add_error(f"Constant {constant.name!r} already exists")
+            raise ClassiqExpansionError(f"Constant {constant.name!r} already exists")
         else:
             known_constants[constant.name] = constant

classiq/qmod/semantics/validation/function_name_collisions_validation.py

@@ -1,23 +1,20 @@
-from typing import Optional
-
+from classiq.interface.exceptions import ClassiqExpansionError
 from classiq.interface.model.model import Model
 
 from classiq.qmod.builtins.functions import CORE_LIB_DECLS
 
 
-def _check_function_name_collisions(
-    model: Model, error_type: Optional[type[Exception]]
-) -> None:
-    if error_type is None:
-        return
+def check_function_name_collisions(model: Model) -> None:
     redefined_functions = [
         function.name
         for function in CORE_LIB_DECLS
         if function.name in model.function_dict
     ]
     if len(redefined_functions) == 1:
-        raise error_type(
+        raise ClassiqExpansionError(
             f"Cannot redefine built-in function {redefined_functions[0]!r}"
         )
     elif len(redefined_functions) > 1:
-        raise error_type(f"Cannot redefine built-in functions: {redefined_functions}")
+        raise ClassiqExpansionError(
+            f"Cannot redefine built-in functions: {redefined_functions}"
+        )

classiq/qmod/semantics/validation/main_validation.py

@@ -1,3 +1,4 @@
+from classiq.interface.exceptions import ClassiqExpansionError
 from classiq.interface.generator.functions.classical_type import (
     ClassicalArray,
     ClassicalList,
@@ -7,7 +8,6 @@ from classiq.interface.model.native_function_definition import NativeFunctionDef
 from classiq.interface.model.quantum_function_declaration import PositionalArg
 
 from classiq import ClassicalParameterDeclaration
-from classiq.qmod.semantics.error_manager import append_error
 
 
 def validate_main_function(func: NativeFunctionDefinition) -> None:
@@ -24,8 +24,7 @@ def _validate_main_classical_param_type(
     param: ConcreteClassicalType, param_name: str
 ) -> None:
     if isinstance(param, ClassicalList):
-        append_error(
-            param,
+        raise ClassiqExpansionError(
             f"Classical array parameter {param_name!r} of function 'main' must must "
             f"specify array length",
         )

classiq/qmod/semantics/validation/model_validation.py

@@ -0,0 +1,25 @@
+from classiq.interface.model.model import Model
+
+from classiq.qmod.semantics.validation.constants_validation import (
+    check_duplicate_constants,
+)
+from classiq.qmod.semantics.validation.function_name_collisions_validation import (
+    check_function_name_collisions,
+)
+from classiq.qmod.semantics.validation.main_validation import validate_main_function
+from classiq.qmod.semantics.validation.types_validation import (
+    check_duplicate_types,
+    validate_cstruct,
+    validate_qstruct,
+)
+
+
+def validate_model(model: Model) -> None:
+    check_duplicate_types([*model.enums, *model.types, *model.qstructs])
+    check_duplicate_constants(model.constants)
+    for qstruct in model.qstructs:
+        validate_qstruct(qstruct)
+    for cstruct in model.types:
+        validate_cstruct(cstruct)
+    validate_main_function(model.main_func)
+    check_function_name_collisions(model)

classiq/qmod/semantics/validation/signature_validation.py

@@ -0,0 +1,24 @@
+from collections import Counter
+from collections.abc import Sequence
+
+from classiq.interface.exceptions import ClassiqExpansionError
+from classiq.interface.model.quantum_function_declaration import (
+    AnonPositionalArg,
+    AnonQuantumOperandDeclaration,
+)
+
+
+def _check_duplicate_param_names(params: Sequence[AnonPositionalArg]) -> None:
+    param_names = [param.name for param in params if param.name is not None]
+    duplicates = [
+        param_name for param_name, count in Counter(param_names).items() if count > 1
+    ]
+    if len(duplicates) > 0:
+        raise ClassiqExpansionError(f"Duplicate parameter name {duplicates[0]!r}")
+
+
+def validate_function_signature(params: Sequence[AnonPositionalArg]) -> None:
+    _check_duplicate_param_names(params)
+    for param in params:
+        if isinstance(param, AnonQuantumOperandDeclaration):
+            validate_function_signature(param.positional_arg_declarations)

classiq/qmod/semantics/validation/types_validation.py

@@ -1,6 +1,7 @@
 from collections.abc import Sequence
 from typing import Union
 
+from classiq.interface.exceptions import ClassiqExpansionError
 from classiq.interface.generator.functions.type_name import TypeName
 from classiq.interface.generator.types.enum_declaration import EnumDeclaration
 from classiq.interface.generator.types.qstruct_declaration import QStructDeclaration
@@ -10,7 +11,8 @@ from classiq.interface.model.quantum_type import QuantumBitvector
 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
+
+TYPE_EXISTS_ERROR_MESSAGE = "Type {!r} already exists"
 
 
 def check_duplicate_types(
@@ -20,13 +22,12 @@ def check_duplicate_types(
     known_types |= {type_.name for type_ in 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")
+            raise ClassiqExpansionError(TYPE_EXISTS_ERROR_MESSAGE.format(type_.name))
         else:
             known_types.add(type_.name)
 
 
-def check_qstruct_flexibility(qstruct: QStructDeclaration) -> None:
+def _check_qstruct_flexibility(qstruct: QStructDeclaration) -> None:
     _check_qstruct_no_array_without_size_and_element_size(qstruct)
     _check_qstruct_at_most_one_type_without_size(qstruct)
 
@@ -42,12 +43,11 @@ def _check_qstruct_no_array_without_size_and_element_size(
         and not field_type.element_type.has_size_in_bits
     ]
     if len(offending_array_fields) > 0:
-        with ErrorManager().node_context(qstruct):
-            ErrorManager().add_error(
-                f"Quantum struct {qstruct.name} contains arrays whose neither length "
-                f"nor element size are constants. Offending fields: "
-                f"{', '.join(offending_array_fields)}"
-            )
+        raise ClassiqExpansionError(
+            f"Quantum struct {qstruct.name} contains arrays whose neither length "
+            f"nor element size are constants. Offending fields: "
+            f"{', '.join(offending_array_fields)}"
+        )
 
 
 def _check_qstruct_at_most_one_type_without_size(qstruct: QStructDeclaration) -> None:
@@ -57,46 +57,31 @@ def _check_qstruct_at_most_one_type_without_size(qstruct: QStructDeclaration) ->
         if not field_type.has_size_in_bits
     ]
     if len(fields_without_size) > 1:
-        with ErrorManager().node_context(qstruct):
-            ErrorManager().add_error(
-                f"Quantum struct {qstruct.name} has more than one field whose size is "
-                f"not constant. Offending fields: {', '.join(fields_without_size)}"
-            )
+        raise ClassiqExpansionError(
+            f"Quantum struct {qstruct.name} has more than one field whose size is "
+            f"not constant. Offending fields: {', '.join(fields_without_size)}"
+        )
 
 
-def check_qstruct_fields_are_defined(qstruct: QStructDeclaration) -> bool:
-    all_defined = True
+def _check_qstruct_fields_are_defined(qstruct: QStructDeclaration) -> None:
     for field_type in qstruct.fields.values():
         if (
             isinstance(field_type, TypeName)
             and field_type.name not in QMODULE.qstruct_decls
         ):
-            with ErrorManager().node_context(field_type):
-                ErrorManager().add_error(
-                    f"Quantum struct {field_type.name!r} is not defined."
-                )
-            all_defined = False
-    return all_defined
-
-
-def check_qstruct_has_fields(qstruct: QStructDeclaration) -> None:
-    if len(qstruct.fields) == 0:
-        with ErrorManager().node_context(qstruct):
-            ErrorManager().add_error(
-                f"Quantum struct {qstruct.name!r} must have at least one field."
+            raise ClassiqExpansionError(
+                f"Quantum struct {field_type.name!r} is not defined."
             )
 
 
-def check_cstruct_has_fields(cstruct: StructDeclaration) -> None:
-    if len(cstruct.variables) == 0:
-        with ErrorManager().node_context(cstruct):
-            ErrorManager().add_error(
-                f"Classical struct {cstruct.name!r} must have at least one field."
-            )
+def _check_qstruct_has_fields(qstruct: QStructDeclaration) -> None:
+    if len(qstruct.fields) == 0:
+        raise ClassiqExpansionError(
+            f"Quantum struct {qstruct.name!r} must have at least one field."
+        )
 
 
-def check_qstruct_is_not_recursive(qstruct: QStructDeclaration) -> bool:
-    non_recursive = True
+def _check_qstruct_is_not_recursive(qstruct: QStructDeclaration) -> None:
     for main_field_name, main_field in qstruct.fields.items():
         if (
             not isinstance(main_field, TypeName)
@@ -109,13 +94,10 @@ def check_qstruct_is_not_recursive(qstruct: QStructDeclaration) -> bool:
         while stack:
             qstruct = stack.pop()
             if qstruct.name in seen_qstructs:
-                with ErrorManager().node_context(qstruct):
-                    ErrorManager().add_error(
-                        f"Declaration of field {main_field_name!r} in quantum struct "
-                        f"{qstruct.name!r} creates a recursive definition."
-                    )
-                non_recursive = False
-                break
+                raise ClassiqExpansionError(
+                    f"Declaration of field {main_field_name!r} in quantum struct "
+                    f"{qstruct.name!r} creates a recursive definition."
+                )
             seen_qstructs.add(qstruct.name)
             stack.extend(
                 [
@@ -125,4 +107,21 @@ def check_qstruct_is_not_recursive(qstruct: QStructDeclaration) -> bool:
                     and field.name in QMODULE.qstruct_decls
                 ]
             )
-    return non_recursive
+
+
+def validate_qstruct(qstruct: QStructDeclaration) -> None:
+    _check_qstruct_has_fields(qstruct)
+    _check_qstruct_fields_are_defined(qstruct)
+    _check_qstruct_is_not_recursive(qstruct)
+    _check_qstruct_flexibility(qstruct)
+
+
+def _check_cstruct_has_fields(cstruct: StructDeclaration) -> None:
+    if len(cstruct.variables) == 0:
+        raise ClassiqExpansionError(
+            f"Classical struct {cstruct.name!r} must have at least one field."
+        )
+
+
+def validate_cstruct(cstruct: StructDeclaration) -> None:
+    _check_cstruct_has_fields(cstruct)

classiq/qmod/utilities.py

@@ -7,6 +7,9 @@ from enum import Enum as PythonEnum
 from types import FrameType
 from typing import Any, ForwardRef, Literal, Optional, get_args, get_origin, overload
 
+from classiq.interface.generator.expressions.qmod_struct_instance import (
+    QmodStructInstance,
+)
 from classiq.interface.source_reference import SourceReference
 
 DEFAULT_DECIMAL_PRECISION = 4
@@ -89,6 +92,15 @@ def qmod_val_to_expr_str(val: Any) -> str:
         )
         return f"struct_literal({type(val).__name__}, {kwargs_str})"
 
+    if isinstance(val, QmodStructInstance):
+        kwargs_str = ", ".join(
+            [
+                f"{field_name}={qmod_val_to_expr_str(field_val)}"
+                for field_name, field_val in val.fields.items()
+            ]
+        )
+        return f"struct_literal({val.struct_declaration.name}, {kwargs_str})"
+
     if isinstance(val, list):
         elements_str = ", ".join([qmod_val_to_expr_str(elem) for elem in val])
         return f"[{elements_str}]"

{classiq-0.65.4.dist-info → classiq-0.66.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: classiq
-Version: 0.65.4
+Version: 0.66.1
 Summary: Classiq's Python SDK for quantum computing
 Home-page: https://classiq.io
 License: Proprietary