classiq 0.43.3__py3-none-any.whl → 0.45.0__py3-none-any.whl

classiq/qmod/declaration_inferrer.py

@@ -1,68 +1,76 @@
 import dataclasses
 import inspect
+import sys
 from enum import EnumMeta
 from typing import (
     Any,
     Callable,
-    Dict,
     List,
+    Literal,
     Optional,
+    Sequence,
+    Tuple,
     Type,
     get_args,
     get_origin,
+    overload,
 )
 
 from typing_extensions import _AnnotatedAlias
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.functions.classical_type import (
     Bool,
     ClassicalArray,
     ClassicalList,
-    ConcreteClassicalType,
-    Enum,
     Integer,
     Real,
-    Struct,
 )
+from classiq.interface.generator.functions.concrete_types import ConcreteClassicalType
+from classiq.interface.generator.functions.port_declaration import (
+    PortDeclarationDirection,
+)
+from classiq.interface.generator.functions.type_name import Enum
 from classiq.interface.generator.types.enum_declaration import (
     EnumDeclaration,
     declaration_from_enum,
 )
 from classiq.interface.model.classical_parameter_declaration import (
-    ClassicalParameterDeclaration,
+    AnonClassicalParameterDeclaration,
 )
-from classiq.interface.model.port_declaration import PortDeclaration
+from classiq.interface.model.port_declaration import AnonPortDeclaration
 from classiq.interface.model.quantum_function_declaration import (
+    AnonPositionalArg,
+    AnonQuantumOperandDeclaration,
+    NamedParamsQuantumFunctionDeclaration,
     PositionalArg,
-    QuantumFunctionDeclaration,
-    QuantumOperandDeclaration,
 )
 
-from classiq import StructDeclaration
-from classiq.exceptions import ClassiqValueError
+from classiq import Struct, StructDeclaration
 from classiq.qmod.model_state_container import ModelStateContainer
-from classiq.qmod.qmod_parameter import CArray, CBool, CInt, CParam, CReal
+from classiq.qmod.qmod_parameter import CArray, CBool, CInt, CReal
 from classiq.qmod.qmod_variable import QVar, get_type_hint_expr
-from classiq.qmod.quantum_callable import QCallable, QCallableList
+from classiq.qmod.quantum_callable import QCallableList
 from classiq.qmod.utilities import unmangle_keyword, version_portable_get_args
 
-OPERAND_ARG_NAME = "arg{i}"
+if sys.version_info[0:2] >= (3, 9):
+    from typing import Annotated
 
 
 def python_type_to_qmod(
     py_type: type, *, qmodule: ModelStateContainer
 ) -> Optional[ConcreteClassicalType]:
-    if py_type == int or py_type is CInt:
+    if py_type is int or py_type is CInt:
         return Integer()
-    elif py_type == float or py_type is CReal:
+    elif py_type in (float, complex) or py_type is CReal:
         return Real()
-    elif py_type == bool or py_type is CBool:
+    elif py_type is bool or py_type is CBool:
         return Bool()
-    elif get_origin(py_type) == list:
-        return ClassicalList(
-            element_type=python_type_to_qmod(get_args(py_type)[0], qmodule=qmodule)
-        )
-    elif get_origin(py_type) == CArray:
+    elif get_origin(py_type) is list:
+        element_type = python_type_to_qmod(get_args(py_type)[0], qmodule=qmodule)
+        if element_type is not None:
+            return ClassicalList(element_type=element_type)
+    elif get_origin(py_type) is CArray:
         array_args = version_portable_get_args(py_type)
         if len(array_args) == 1:
             return ClassicalList(
@@ -112,72 +120,109 @@ def _add_qmod_struct(py_type: Type, *, qmodule: ModelStateContainer) -> None:
     )
 
 
-def _extract_port_decl(name: str, py_type: Any) -> PortDeclaration:
+def _extract_port_decl(name: Optional[str], py_type: Any) -> AnonPortDeclaration:
     # FIXME: CAD-13409
     qtype: Type[QVar] = QVar.from_type_hint(py_type)  # type:ignore[assignment]
     direction = qtype.port_direction(py_type)
     if isinstance(py_type, _AnnotatedAlias):
         py_type = py_type.__args__[0]
-    return PortDeclaration(
-        name=name,
+    param = AnonPortDeclaration(
+        name=None,
         direction=direction,
         quantum_type=qtype.to_qmod_quantum_type(py_type),
     )
+    if name is not None:
+        param = param.rename(name)
+    return param
 
 
 def _extract_operand_decl(
-    name: str, py_type: Any, qmodule: ModelStateContainer
-) -> QuantumOperandDeclaration:
-    qc_args = version_portable_get_args(py_type)
-    arg_dict = {
-        OPERAND_ARG_NAME.format(i=i): arg_type for i, arg_type in enumerate(qc_args)
-    }
-    return QuantumOperandDeclaration(
+    name: Optional[str], py_type: Any, qmodule: ModelStateContainer
+) -> AnonQuantumOperandDeclaration:
+    is_list = (get_origin(py_type) or py_type) is QCallableList
+    if get_origin(py_type) is list:
+        is_list = True
+        py_type = version_portable_get_args(py_type)
+    type_args = version_portable_get_args(py_type)
+    param_decls = [_extract_operand_param(arg_type) for arg_type in type_args]
+    param = AnonQuantumOperandDeclaration(
         name=name,
-        positional_arg_declarations=_extract_positional_args(arg_dict, qmodule=qmodule),
-        is_list=(get_origin(py_type) or py_type) is QCallableList,
+        positional_arg_declarations=_extract_positional_args(
+            param_decls, qmodule=qmodule
+        ),
+        is_list=is_list,
+    )
+    if name is not None:
+        param = param.rename(name)
+    return param
+
+
+def _extract_operand_param(py_type: Any) -> Tuple[Optional[str], Any]:
+    if sys.version_info[0:2] < (3, 9) or get_origin(py_type) is not Annotated:
+        return None, py_type
+    args = get_args(py_type)
+    if len(args) == 2:
+        if isinstance(args[1], PortDeclarationDirection):
+            return None, py_type
+        elif isinstance(args[1], str):
+            return args[1], args[0]
+        elif get_origin(args[1]) is Literal:
+            return version_portable_get_args(args[1])[0], args[0]
+    elif len(args) == 3 and isinstance(args[1], PortDeclarationDirection):
+        if isinstance(args[2], str):
+            return args[2], Annotated[args[0], args[1]]
+        elif get_origin(args[2]) is Literal:
+            return version_portable_get_args(args[2])[0], Annotated[args[0], args[1]]
+    raise ClassiqValueError(
+        f"Operand parameter declaration must be of the form <param-type> or "
+        f"Annotated[<param-type>, <param-name>]. Got {py_type}"
     )
 
 
+@overload
 def _extract_positional_args(
-    args: Dict[str, Any], qmodule: ModelStateContainer
-) -> List[PositionalArg]:
-    result: List[PositionalArg] = []
-    for name, py_type in args.items():
+    args: Sequence[Tuple[str, Any]], qmodule: ModelStateContainer
+) -> Sequence[PositionalArg]:
+    pass
+
+
+@overload
+def _extract_positional_args(
+    args: Sequence[Tuple[Optional[str], Any]], qmodule: ModelStateContainer
+) -> Sequence[AnonPositionalArg]:
+    pass
+
+
+def _extract_positional_args(
+    args: Sequence[Tuple[Optional[str], Any]], qmodule: ModelStateContainer
+) -> Sequence[AnonPositionalArg]:
+    result: List[AnonPositionalArg] = []
+    for name, py_type in args:
         if name == "return":
             continue
         name = unmangle_keyword(name)
-        if (
-            inspect.isclass(py_type)
-            and (
-                issubclass(py_type, CParam)
-                or dataclasses.is_dataclass(py_type)
-                or isinstance(py_type, EnumMeta)
-            )
-            or get_origin(py_type) == CArray
-        ):
-            result.append(
-                ClassicalParameterDeclaration(
-                    name=name,
-                    classical_type=python_type_to_qmod(py_type, qmodule=qmodule),
-                )
+        classical_type = python_type_to_qmod(py_type, qmodule=qmodule)
+        if classical_type is not None:
+            param = AnonClassicalParameterDeclaration(
+                name=None,
+                classical_type=classical_type,
             )
+            if name is not None:
+                param = param.rename(name)
+            result.append(param)
         elif QVar.from_type_hint(py_type) is not None:
             result.append(_extract_port_decl(name, py_type))
         else:
-            assert (get_origin(py_type) or py_type) is QCallable or (
-                get_origin(py_type) or py_type
-            ) is QCallableList
             result.append(_extract_operand_decl(name, py_type, qmodule=qmodule))
     return result
 
 
 def infer_func_decl(
     py_func: Callable, qmodule: ModelStateContainer
-) -> QuantumFunctionDeclaration:
-    return QuantumFunctionDeclaration(
+) -> NamedParamsQuantumFunctionDeclaration:
+    return NamedParamsQuantumFunctionDeclaration(
         name=unmangle_keyword(py_func.__name__),
         positional_arg_declarations=_extract_positional_args(
-            py_func.__annotations__, qmodule=qmodule
+            list(py_func.__annotations__.items()), qmodule=qmodule
         ),
     )

classiq/qmod/expression_query.py

@@ -15,7 +15,7 @@ def get_expression_numeric_attributes(
 ) -> Tuple[int, bool, int]:
     res_type = compute_arithmetic_result_type(
         expr_str=str(expr),
-        var_types={var._name: var.get_qmod_type() for var in vars},
+        var_types={str(var.get_handle_binding()): var.get_qmod_type() for var in vars},
         machine_precision=machine_precision,
     )
     if TYPE_CHECKING:

classiq/qmod/model_state_container.py

@@ -2,6 +2,7 @@ from typing import Dict
 
 from classiq.interface.generator.constant import Constant
 from classiq.interface.generator.types.enum_declaration import EnumDeclaration
+from classiq.interface.generator.types.qstruct_declaration import QStructDeclaration
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 
 from classiq import StructDeclaration
@@ -10,6 +11,7 @@ from classiq import StructDeclaration
 class ModelStateContainer:
     enum_decls: Dict[str, EnumDeclaration]
     type_decls: Dict[str, StructDeclaration]
+    qstruct_decls: Dict[str, QStructDeclaration]
     native_defs: Dict[str, NativeFunctionDefinition]
     constants: Dict[str, Constant]
 

classiq/qmod/native/pretty_printer.py

@@ -1,24 +1,29 @@
-from typing import Dict, List, Optional
+from typing import Dict, List, Mapping, Optional, Union
 
 from classiq.interface.generator.constant import Constant
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.classical_type import (
     ClassicalArray,
+)
+from classiq.interface.generator.functions.concrete_types import (
     ConcreteClassicalType,
-    TypeName,
+    ConcreteQuantumType,
 )
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+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
 from classiq.interface.generator.visitor import NodeType, Visitor
 from classiq.interface.model.bind_operation import BindOperation
 from classiq.interface.model.classical_if import ClassicalIf
 from classiq.interface.model.classical_parameter_declaration import (
-    ClassicalParameterDeclaration,
+    AnonClassicalParameterDeclaration,
 )
 from classiq.interface.model.control import Control
 from classiq.interface.model.handle_binding import (
+    FieldHandleBinding,
     HandleBinding,
     SlicedHandleBinding,
     SubscriptHandleBinding,
@@ -27,7 +32,9 @@ from classiq.interface.model.inplace_binary_operation import InplaceBinaryOperat
 from classiq.interface.model.invert import Invert
 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.port_declaration import (
+    AnonPortDeclaration,
+)
 from classiq.interface.model.power import Power
 from classiq.interface.model.quantum_expressions.amplitude_loading_operation import (
     AmplitudeLoadingOperation,
@@ -40,6 +47,8 @@ from classiq.interface.model.quantum_function_call import (
     QuantumFunctionCall,
 )
 from classiq.interface.model.quantum_function_declaration import (
+    AnonQuantumFunctionDeclaration,
+    AnonQuantumOperandDeclaration,
     QuantumFunctionDeclaration,
     QuantumOperandDeclaration,
 )
@@ -59,7 +68,13 @@ from classiq.interface.model.variable_declaration_statement import (
 )
 from classiq.interface.model.within_apply_operation import WithinApply
 
-from classiq import Bool, ClassicalList, Integer, Real, StructDeclaration
+from classiq import (
+    Bool,
+    ClassicalList,
+    Integer,
+    Real,
+    StructDeclaration,
+)
 from classiq.qmod.native.expression_to_qmod import transform_expression
 from classiq.qmod.semantics.static_semantics_visitor import (
     static_semantics_analysis_pass,
@@ -82,36 +97,37 @@ class DSLPrettyPrinter(Visitor):
 
     def visit_Model(self, model: Model) -> str:
         # FIXME - CAD-20149: Remove this line once the froggies are removed, and the visit of lambdas can be done without accessing the func_decl property (with rename_params values only).
-        static_semantics_analysis_pass(model)
+        static_semantics_analysis_pass(model, None)
         enum_decls = [self.visit(enum_decl) for enum_decl in model.enums]
         struct_decls = [self.visit(struct_decl) for struct_decl in model.types]
+        qstruct_decls = [self.visit(qstruct_decl) for qstruct_decl in model.qstructs]
         func_defs = [self.visit(func_def) for func_def in model.functions]
         constants = [self.visit(constant) for constant in model.constants]
         classical_code = (
-            f"cscope ```\n{model.classical_execution_code}\n```"
+            [f"cscope ```\n{model.classical_execution_code}\n```\n"]
             if model.classical_execution_code
-            else ""
+            else []
         )
+
         return "\n".join(
-            [*constants, *enum_decls, *struct_decls, *func_defs, classical_code]
+            [
+                *constants,
+                *enum_decls,
+                *struct_decls,
+                *qstruct_decls,
+                *func_defs,
+                *classical_code,
+            ]
         )
 
     def visit_Constant(self, constant: Constant) -> str:
         return f"{self._indent}{self.visit(constant.name)}: {self.visit(constant.const_type)} = {self.visit(constant.value)};\n"
 
-    def _visit_arg_decls(self, func_def: QuantumFunctionDeclaration) -> str:
-        gen_time_args = ", ".join(
-            self.visit(arg_decl)
-            for arg_decl in func_def.get_positional_arg_decls()
-            if not isinstance(arg_decl, PortDeclaration)
-        )
-        quantum_args = ", ".join(
-            self.visit(arg_decl)
-            for arg_decl in func_def.get_positional_arg_decls()
-            if isinstance(arg_decl, PortDeclaration)
+    def _visit_arg_decls(self, func_def: AnonQuantumFunctionDeclaration) -> str:
+        positional_args = ", ".join(
+            self.visit(arg_decl) for arg_decl in func_def.positional_arg_declarations
         )
-        gen_time_arg_list = f"<{gen_time_args}>" if gen_time_args else ""
-        return f"{gen_time_arg_list}({quantum_args})"
+        return f"({positional_args})"
 
     def visit_QuantumFunctionDeclaration(
         self, func_decl: QuantumFunctionDeclaration
@@ -133,7 +149,12 @@ class DSLPrettyPrinter(Visitor):
     def visit_StructDeclaration(self, struct_decl: StructDeclaration) -> str:
         return f"struct {struct_decl.name} {{\n{self._visit_variables(struct_decl.variables)}}}\n"
 
-    def _visit_variables(self, variables: Dict[str, ConcreteClassicalType]) -> str:
+    def visit_QStructDeclaration(self, qstruct_decl: QStructDeclaration) -> str:
+        return f"qstruct {qstruct_decl.name} {{\n{self._visit_variables(qstruct_decl.fields)}}}\n"
+
+    def _visit_variables(
+        self, variables: Mapping[str, Union[ConcreteClassicalType, ConcreteQuantumType]]
+    ) -> str:
         self._level += 1
         variables_str = "".join(
             f"{self._indent}{self.visit(field_name)}: {self.visit(var_decl)};\n"
@@ -147,13 +168,14 @@ class DSLPrettyPrinter(Visitor):
     ) -> str:
         return f"{var_decl.name}: {self.visit(var_decl.quantum_type)}"
 
-    def visit_PortDeclaration(self, port_decl: PortDeclaration) -> str:
+    def visit_AnonPortDeclaration(self, port_decl: AnonPortDeclaration) -> str:
         dir_str = (
             f"{port_decl.direction} "
             if port_decl.direction != PortDeclarationDirection.Inout
             else ""
         )
-        return f"{dir_str}{self.visit_QuantumVariableDeclaration(port_decl)}"
+        param_name = f"{port_decl.name}: " if port_decl.name is not None else ""
+        return f"{dir_str}{param_name}{self.visit(port_decl.quantum_type)}"
 
     def visit_QuantumBit(self, qtype: QuantumBit) -> str:
         return "qbit"
@@ -179,10 +201,11 @@ class DSLPrettyPrinter(Visitor):
 
         return f"qnum{params}"
 
-    def visit_ClassicalParameterDeclaration(
-        self, cparam: ClassicalParameterDeclaration
+    def visit_AnonClassicalParameterDeclaration(
+        self, cparam: AnonClassicalParameterDeclaration
     ) -> str:
-        return f"{cparam.name}: {self.visit(cparam.classical_type)}"
+        param_name = f"{cparam.name}: " if cparam.name is not None else ""
+        return f"{param_name}{self.visit(cparam.classical_type)}"
 
     def visit_Integer(self, ctint: Integer) -> str:
         return "int"
@@ -207,10 +230,16 @@ class DSLPrettyPrinter(Visitor):
     ) -> str:
         return f"{self._indent}{self.visit_QuantumVariableDeclaration(local_decl)};\n"
 
+    def visit_AnonQuantumOperandDeclaration(
+        self, op_decl: AnonQuantumOperandDeclaration
+    ) -> str:
+        param_name = f"{op_decl.name}: " if op_decl.name is not None else ""
+        return f"{param_name}qfunc{[] if op_decl.is_list else ''} {self._visit_arg_decls(op_decl)}"
+
     def visit_QuantumOperandDeclaration(
         self, op_decl: QuantumOperandDeclaration
     ) -> str:
-        return f"{op_decl.name}: qfunc{[] if op_decl.is_list else ''} {self._visit_arg_decls(op_decl)}"
+        return self.visit_AnonQuantumOperandDeclaration(op_decl)
 
     def visit_NativeFunctionDefinition(self, func_def: NativeFunctionDefinition) -> str:
         self._level += 1
@@ -219,18 +248,10 @@ class DSLPrettyPrinter(Visitor):
         return f"{self.visit_QuantumFunctionDeclaration(func_def)} {{\n{body}}}\n"
 
     def visit_QuantumFunctionCall(self, func_call: QuantumFunctionCall) -> str:
-        gen_time_args = ", ".join(
-            self.visit(arg_decl)
-            for arg_decl in func_call.get_positional_args()
-            if not isinstance(arg_decl, HandleBinding)
-        )
-        gen_time_arg_list = f"<{gen_time_args}>" if gen_time_args else ""
-        quantum_args = ", ".join(
-            self.visit(arg_decl)
-            for arg_decl in func_call.get_positional_args()
-            if isinstance(arg_decl, HandleBinding)
+        positional_args = ", ".join(
+            self.visit(arg_decl) for arg_decl in func_call.positional_args
         )
-        return f"{self._indent}{func_call.func_name}{f'[{self.visit(func_call.function.index)}]' if isinstance(func_call.function, OperandIdentifier) else ''}{gen_time_arg_list}({quantum_args});\n"
+        return f"{self._indent}{func_call.func_name}{f'[{self.visit(func_call.function.index)}]' if isinstance(func_call.function, OperandIdentifier) else ''}({positional_args});\n"
 
     def visit_Control(self, op: Control) -> str:
         control = f"{self._indent}control ({self.visit(op.expression)}) {{\n"
@@ -301,29 +322,26 @@ class DSLPrettyPrinter(Visitor):
         )
 
     def visit_QuantumLambdaFunction(self, qlambda: QuantumLambdaFunction) -> str:
-        assert qlambda.func_decl is not None
-        gen_time_args = ", ".join(
-            qlambda.rename_params.get(arg_decl.name, arg_decl.name)
-            for arg_decl in qlambda.func_decl.get_positional_arg_decls()
-            if not isinstance(arg_decl, PortDeclaration)
-        )
-        quantum_args = ", ".join(
-            qlambda.rename_params.get(arg_decl.name, arg_decl.name)
-            for arg_decl in qlambda.func_decl.get_positional_arg_decls()
-            if isinstance(arg_decl, PortDeclaration)
+        positional_args = ", ".join(
+            qlambda.get_rename_params()[idx]
+            for idx, arg_decl in enumerate(
+                qlambda.func_decl.positional_arg_declarations
+            )
         )
-        gen_time_arg_list = f"<{gen_time_args}>" if gen_time_args else ""
         body = self._visit_body(qlambda.body)
-        return f"lambda{gen_time_arg_list}({quantum_args}) {{\n{body}{self._indent}}}"
+        return f"lambda({positional_args}) {{\n{body}{self._indent}}}"
 
     def visit_HandleBinding(self, var_ref: HandleBinding) -> str:
         return var_ref.name
 
     def visit_SlicedHandleBinding(self, var_ref: SlicedHandleBinding) -> str:
-        return f"{var_ref.name}[{self.visit(var_ref.start)}:{self.visit(var_ref.end)}]"
+        return f"{self.visit(var_ref.base_handle)}[{self.visit(var_ref.start)}:{self.visit(var_ref.end)}]"
 
     def visit_SubscriptHandleBinding(self, var_ref: SubscriptHandleBinding) -> str:
-        return f"{var_ref.name}[{self.visit(var_ref.index)}]"
+        return f"{self.visit(var_ref.base_handle)}[{self.visit(var_ref.index)}]"
+
+    def visit_FieldHandleBinding(self, var_ref: FieldHandleBinding) -> str:
+        return f"{self.visit(var_ref.base_handle)}.{self.visit(var_ref.field)}"
 
     def visit_ArithmeticOperation(self, arith_op: ArithmeticOperation) -> str:
         op = "^=" if arith_op.inplace_result else "="