classiq 0.60.1__py3-none-any.whl → 0.62.0__py3-none-any.whl

classiq/interface/model/quantum_function_declaration.py

@@ -9,6 +9,7 @@ from typing import (
 import pydantic
 from pydantic import SerializeAsAny
 from pydantic_core.core_schema import ValidationInfo
+from typing_extensions import Self
 
 from classiq.interface.exceptions import ClassiqInternalError
 from classiq.interface.generator.arith.register_user_input import RegisterUserInput
@@ -171,6 +172,12 @@ class AnonQuantumOperandDeclaration(AnonQuantumFunctionDeclaration):
         new_instance_data["kind"] = "QuantumOperandDeclaration"
         return QuantumOperandDeclaration(**new_instance_data)
 
+    @property
+    def element_declaration(self) -> Self:
+        if not self.is_list:
+            raise ClassiqInternalError
+        return self.model_copy(update={"is_list": False})
+
 
 AnonQuantumFunctionDeclaration.model_rebuild()
 

classiq/interface/model/quantum_lambda_function.py

@@ -4,6 +4,7 @@ import pydantic
 
 from classiq.interface.ast_node import ASTNode
 from classiq.interface.exceptions import ClassiqError
+from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.quantum_function_declaration import (
     AnonQuantumOperandDeclaration,
 )
@@ -52,5 +53,13 @@ class QuantumLambdaFunction(ASTNode):
         self._func_decl = fd
 
 
-QuantumCallable = Union[str, QuantumLambdaFunction]
+class OperandIdentifier(ASTNode):
+    name: str
+    index: Expression
+
+    def __str__(self) -> str:
+        return f"{self.name}[{self.index.expr}]"
+
+
+QuantumCallable = Union[str, OperandIdentifier, QuantumLambdaFunction]
 QuantumOperand = Union[QuantumCallable, list[QuantumCallable]]

classiq/interface/model/quantum_type.py

@@ -159,7 +159,9 @@ class QuantumNumeric(QuantumScalar):
     def _validate_fields(self) -> Self:
         has_sign = self.is_signed is not None
         has_fraction_digits = self.fraction_digits is not None
-        if has_sign and not has_fraction_digits or not has_sign and has_fraction_digits:
+        if (has_sign and not has_fraction_digits) or (
+            not has_sign and has_fraction_digits
+        ):
             raise ClassiqValueError(
                 "Assign neither or both of is_signed and fraction_digits"
             )

classiq/model_expansions/atomic_expression_functions_defs.py

@@ -61,7 +61,7 @@ def qmod_val_to_python(val: ExpressionValue, qmod_type: ClassicalType) -> Any:
                 for field_name, field_type in val.struct_declaration.variables.items()
             }
 
-        if isinstance(val, Enum):
+        if isinstance(val, (Enum, int)):
             return val
 
     elif isinstance(qmod_type, ClassicalList):
@@ -147,6 +147,8 @@ def get_field(
     proxy: Union[QmodSizedProxy, QmodStructInstance, QmodQStructProxy, list],
     field: str,
 ) -> ExpressionValue:
+    if isinstance(proxy, type) and issubclass(proxy, Enum):
+        return getattr(proxy, field)
     if isinstance(proxy, Symbol) and not isinstance(proxy, QmodSizedProxy):
         raise ClassiqExpansionError(
             f"Cannot evaluate '{proxy}.{field}': Variable {str(proxy)!r} is not "

classiq/model_expansions/capturing/captured_vars.py

@@ -1,8 +1,7 @@
 import dataclasses
-from collections.abc import Iterator, Sequence
-from contextlib import contextmanager
+from collections.abc import Sequence
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Optional
 
 from classiq.interface.enum_utils import StrEnum
 from classiq.interface.exceptions import (
@@ -16,12 +15,14 @@ from classiq.interface.model.handle_binding import HandleBinding, NestedHandleBi
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_call import ArgValue
 from classiq.interface.model.quantum_type import QuantumType
+from classiq.interface.model.variable_declaration_statement import (
+    VariableDeclarationStatement,
+)
 
 from classiq.model_expansions.capturing.mangling_utils import (
     demangle_handle,
     mangle_captured_var_name,
 )
-from classiq.model_expansions.scope import QuantumSymbol
 from classiq.model_expansions.transformers.var_splitter import SymbolPart, SymbolParts
 
 if TYPE_CHECKING:
@@ -71,7 +72,11 @@ class _CapturedHandle:
 
     @property
     def mangled_name(self) -> str:
-        return mangle_captured_var_name(self.handle.identifier, self.defining_function)
+        return mangle_captured_var_name(
+            self.handle.identifier,
+            self.defining_function.name,
+            self.defining_function.depth,
+        )
 
     @property
     def port(self) -> PortDeclaration:
@@ -211,7 +216,16 @@ class CapturedVars:
             ]
         )
 
-    def filter(self, current_function: "FunctionClosure") -> "CapturedVars":
+    def filter_vars(
+        self,
+        current_function: "FunctionClosure",
+        current_declarations: Optional[list[VariableDeclarationStatement]] = None,
+    ) -> "CapturedVars":
+        current_declared_vars = (
+            None
+            if current_declarations is None
+            else {decl.name for decl in current_declarations}
+        )
         return CapturedVars(
             _captured_handles=[
                 captured_handle
@@ -219,6 +233,10 @@ class CapturedVars:
                 if not _same_closure(
                     captured_handle.defining_function, current_function
                 )
+                or (
+                    current_declared_vars is not None
+                    and captured_handle.handle.name not in current_declared_vars
+                )
             ]
         )
 
@@ -247,10 +265,7 @@ class CapturedVars:
 
     def get_captured_mapping(self) -> SymbolParts:
         return {
-            QuantumSymbol(
-                handle=captured_handle.handle,
-                quantum_type=captured_handle.quantum_type,
-            ): [
+            captured_handle.handle: [
                 SymbolPart(
                     source_handle=captured_handle.handle,
                     target_var_name=captured_handle.mangled_name,
@@ -261,11 +276,8 @@ class CapturedVars:
             if not captured_handle.is_propagated
         }
 
-    @contextmanager
-    def freeze(self) -> Iterator[None]:
-        previous = self._captured_handles
-        yield
-        self._captured_handles = previous
+    def clone(self) -> "CapturedVars":
+        return CapturedVars(_captured_handles=list(self._captured_handles))
 
 
 def _same_closure(closure_1: "FunctionClosure", closure_2: "FunctionClosure") -> bool:
@@ -295,7 +307,9 @@ def validate_args_are_not_propagated(
         )
 
 
-def validate_captured_directions(captured_vars: CapturedVars) -> None:
+def validate_captured_directions(
+    captured_vars: CapturedVars, report_outin: bool = True
+) -> None:
     captured_inputs = [
         captured_handle.handle.name
         for captured_handle in captured_vars._captured_handles
@@ -304,7 +318,12 @@ def validate_captured_directions(captured_vars: CapturedVars) -> None:
     captured_outputs = [
         captured_handle.handle.name
         for captured_handle in captured_vars._captured_handles
-        if captured_handle.direction == PortDirection.Output
+        if captured_handle.direction
+        in (
+            (PortDirection.Output, PortDirection.Outin)
+            if report_outin
+            else (PortDirection.Output,)
+        )
     ]
     if len(captured_inputs) > 0:
         raise ClassiqExpansionError(

classiq/model_expansions/capturing/mangling_utils.py

@@ -1,12 +1,9 @@
 import re
-from typing import TYPE_CHECKING
+from typing import Optional
 
 from classiq.interface.generator.compiler_keywords import CAPTURE_SUFFIX
 from classiq.interface.model.handle_binding import HANDLE_ID_SEPARATOR, HandleBinding
 
-if TYPE_CHECKING:
-    from classiq.model_expansions.closure import FunctionClosure
-
 IDENTIFIER_PATTERN = r"[a-zA-Z_][a-zA-Z0-9_]*"
 CAPTURE_PATTERN = re.compile(
     rf"({IDENTIFIER_PATTERN}){CAPTURE_SUFFIX}{IDENTIFIER_PATTERN}__\d*"
@@ -15,24 +12,34 @@ ARRAY_CAST_SUFFIX = HANDLE_ID_SEPARATOR + "array_cast"
 
 
 def mangle_captured_var_name(
-    var_name: str, defining_function: "FunctionClosure"
+    var_name: str, function_name: str, function_depth: int
 ) -> str:
-    return (
-        f"{var_name}{CAPTURE_SUFFIX}{defining_function.name}__{defining_function.depth}"
-    )
+    return f"{var_name}{CAPTURE_SUFFIX}{function_name}__{function_depth}"
 
 
-def demangle_name(name: str) -> str:
-    match = re.match(CAPTURE_PATTERN, name)
+def _match_capture_pattern(name: str) -> Optional[re.Match[str]]:
+    return re.match(CAPTURE_PATTERN, name)
+
+
+def is_captured_var_name(name: str) -> bool:
+    return _match_capture_pattern(name) is not None
+
+
+def demangle_capture_name(name: str) -> str:
+    match = _match_capture_pattern(name)
     return match.group(1) if match else name
 
 
 def demangle_handle(handle: HandleBinding) -> HandleBinding:
-    name = handle.name
+    demangled_name = demangle_name(handle.name)
+    return handle.rename(demangled_name)
+
+
+def demangle_name(name: str) -> str:
     if HANDLE_ID_SEPARATOR not in name:
-        return handle
+        return name
     if ARRAY_CAST_SUFFIX in name:
-        return HandleBinding(name=name.split(ARRAY_CAST_SUFFIX)[0])
+        return name.split(ARRAY_CAST_SUFFIX)[0]
     name = re.sub(r"([^_])_\d+$", r"\1", name)
     name_parts = name.split(HANDLE_ID_SEPARATOR)
     new_name_parts = [name_parts[0]]
@@ -44,5 +51,6 @@ def demangle_handle(handle: HandleBinding) -> HandleBinding:
             new_name_parts.append(f"[{part_left}:{part_right}]")
         else:
             new_name_parts.append(f".{part}")
-    new_name_parts = list(map(demangle_name, new_name_parts))
-    return handle.rename("".join(new_name_parts))
+    new_name_parts = list(map(demangle_capture_name, new_name_parts))
+    new_name = "".join(new_name_parts)
+    return new_name

classiq/model_expansions/closure.py

@@ -1,8 +1,7 @@
 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
@@ -51,11 +50,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):
@@ -142,9 +136,12 @@ 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(),
         )
 
 

classiq/model_expansions/evaluators/arg_type_match.py

@@ -135,13 +135,13 @@ def _check_classical_type_match(
     arg_struct_name = None if not arg_is_struct else argument.struct_declaration.name
     if (
         arg_is_qvar
-        or arg_is_builtin
-        and (type_is_struct or type_is_enum)
-        or arg_is_struct
-        and (not type_is_struct or arg_struct_name != type_name)
-        or arg_is_enum
-        and get_qmod_type(classical_type) != CInt
-        and (not type_is_enum or type(argument).__name__ != type_name)
+        or (arg_is_builtin and (type_is_struct or type_is_enum))
+        or (arg_is_struct and (not type_is_struct or arg_struct_name != type_name))
+        or (
+            arg_is_enum
+            and get_qmod_type(classical_type) != CInt
+            and (not type_is_enum or type(argument).__name__ != type_name)
+        )
     ):
         raise ClassiqExpansionError(error_message)
 

classiq/model_expansions/expression_evaluator.py

@@ -1,4 +1,5 @@
 import ast
+import re
 from collections.abc import Mapping
 from enum import EnumMeta
 from typing import Any, Optional
@@ -12,7 +13,7 @@ from classiq.interface.generator.expressions.evaluated_expression import (
 )
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.expressions.expression_constants import (
-    CPARAM_EXECUTION_SUFFIX,
+    CPARAM_EXECUTION_SUFFIX_PATTERN,
 )
 from classiq.interface.generator.expressions.expression_types import ExpressionValue
 from classiq.interface.generator.expressions.sympy_supported_expressions import (
@@ -99,7 +100,9 @@ def _validate_undefined_vars(
 
     # Ignore expanded execution parameters
     undefined_vars = {
-        var for var in undefined_vars if not var.endswith(CPARAM_EXECUTION_SUFFIX)
+        var
+        for var in undefined_vars
+        if not re.search(CPARAM_EXECUTION_SUFFIX_PATTERN, var)
     }
 
     if len(undefined_vars) == 1:

classiq/model_expansions/function_builder.py

@@ -20,6 +20,9 @@ from classiq.interface.model.quantum_function_declaration import (
     PositionalArg,
 )
 from classiq.interface.model.quantum_statement import QuantumStatement
+from classiq.interface.model.variable_declaration_statement import (
+    VariableDeclarationStatement,
+)
 from classiq.interface.source_reference import SourceReference
 
 from classiq.model_expansions.capturing.captured_vars import (
@@ -37,6 +40,14 @@ class Block:
     statements: list[QuantumStatement] = field(default_factory=list)
     captured_vars: CapturedVars = field(default_factory=CapturedVars)
 
+    @property
+    def variable_declarations(self) -> list[VariableDeclarationStatement]:
+        return [
+            stmt
+            for stmt in self.statements
+            if isinstance(stmt, VariableDeclarationStatement)
+        ]
+
 
 @dataclass
 class OperationContext(Generic[ClosureType]):
@@ -81,6 +92,10 @@ class OperationBuilder:
     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)
@@ -123,9 +138,14 @@ class OperationBuilder:
             not isinstance(self.current_operation, FunctionClosure)
             and self.current_operation.name != WITHIN_APPLY_NAME
         ):
-            validate_captured_directions(captured_vars)
+            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(self.current_function)
+            captured_vars.filter_vars(self.current_function)
         )
         self._blocks.pop()
 
@@ -149,7 +169,7 @@ class OperationBuilder:
             return
         within_captured_vars = self._operations[-1].blocks["within"].captured_vars
         self.current_operation.captured_vars.update(
-            within_captured_vars.filter(self.current_function).negate()
+            within_captured_vars.filter_vars(self.current_function).negate()
         )
 
     def _propagate_captured_vars(self) -> None:
@@ -160,7 +180,9 @@ class OperationBuilder:
         if len(self._operations) < 2:
             return
         parent_block = self._operations[-2].blocks[self._blocks[-1]]
-        parent_block.captured_vars.update(captured_vars.filter(self.parent_function))
+        parent_block.captured_vars.update(
+            captured_vars.filter_vars(self.parent_function)
+        )
 
     @contextmanager
     def source_ref_context(

classiq/model_expansions/generative_functions.py

@@ -1,31 +1,23 @@
 from collections.abc import Mapping
 from typing import TYPE_CHECKING, Any
 
-from classiq.interface.exceptions import ClassiqInternalExpansionError
 from classiq.interface.generator.expressions.qmod_struct_instance import (
     QmodStructInstance,
 )
 from classiq.interface.generator.functions.type_name import Struct
-from classiq.interface.generator.visitor import Visitor
 from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
 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 ArgValue, QuantumFunctionCall
 from classiq.interface.model.quantum_function_declaration import (
     PositionalArg,
     QuantumFunctionDeclaration,
     QuantumOperandDeclaration,
 )
-from classiq.interface.model.quantum_lambda_function import (
-    QuantumCallable,
-    QuantumLambdaFunction,
-)
 from classiq.interface.model.quantum_statement import QuantumStatement
 
 from classiq.model_expansions.closure import (
     FunctionClosure,
     GenerativeClosure,
-    GenerativeFunctionClosure,
 )
 from classiq.model_expansions.scope import Evaluated, QuantumSymbol
 from classiq.qmod.generative import generative_mode_context, set_frontend_interpreter
@@ -35,7 +27,6 @@ from classiq.qmod.qmod_variable import QNum, _create_qvar_for_qtype
 from classiq.qmod.quantum_callable import QCallable
 from classiq.qmod.quantum_expandable import (
     QExpandable,
-    QLambdaFunction,
     QTerminalCallable,
 )
 from classiq.qmod.quantum_function import QFunc
@@ -71,12 +62,18 @@ def translate_ast_arg_to_python_qmod(param: PositionalArg, evaluated: Evaluated)
         )
     if isinstance(param, QuantumOperandDeclaration):
         if param.is_list:
-            return QTerminalCallable(
-                QuantumOperandDeclaration(
-                    name=param.name,
-                    positional_arg_declarations=param.positional_arg_declarations,
-                    is_list=True,
-                ),
+            func_list: list[FunctionClosure] = evaluated.as_type(list)
+            return LenList(
+                [
+                    QTerminalCallable(
+                        QuantumOperandDeclaration(
+                            name=param.name,
+                            positional_arg_declarations=param.positional_arg_declarations,
+                        ),
+                        index_=idx,
+                    )
+                    for idx in range(len(func_list))
+                ]
             )
         else:
             func = evaluated.as_type(FunctionClosure)
@@ -119,7 +116,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())
@@ -143,78 +140,3 @@ def emit_generative_statements(
             True
         ):
             generative_function._py_callable(*python_qmod_args)
-
-
-def emit_operands_as_declarative(
-    interpreter: "Interpreter", param: PositionalArg, arg: Evaluated
-) -> ArgValue:
-    if not isinstance(param, QuantumOperandDeclaration):
-        return arg.emit()
-    value = arg.value
-    if isinstance(value, list):
-        return [
-            _expand_operand_as_declarative(interpreter, param, item) for item in value
-        ]
-    if isinstance(value, GenerativeFunctionClosure):
-        return _expand_operand_as_declarative(interpreter, param, value)
-    if isinstance(value, FunctionClosure):
-        if value.is_lambda:
-            raise ClassiqInternalExpansionError
-        _register_declarative_function(interpreter, value.name)
-        return value.name
-    raise ClassiqInternalExpansionError
-
-
-def _expand_operand_as_declarative(
-    interpreter: "Interpreter",
-    param: QuantumOperandDeclaration,
-    arg: GenerativeFunctionClosure,
-) -> QuantumCallable:
-    if not arg.is_lambda:
-        _register_declarative_function(interpreter, arg.name)
-        return arg.name
-    val = QLambdaFunction(param, arg.generative_blocks["body"]._py_callable)
-    with generative_mode_context(False):
-        val.expand()
-        _DecFuncVisitor(interpreter).visit(val.body)
-    qlambda = QuantumLambdaFunction(
-        pos_rename_params=val.infer_rename_params(),
-        body=val.body,
-    )
-    qlambda.set_op_decl(param)
-    return qlambda
-
-
-def _register_declarative_function(interpreter: "Interpreter", func_name: str) -> None:
-    if func_name in nameables_to_dict(list(interpreter._expanded_functions.values())):
-        return
-
-    for user_gen_func in interpreter._generative_functions:
-        if user_gen_func.func_decl.name == func_name:
-            break
-    else:
-        return
-
-    with generative_mode_context(False):
-        dec_func = QFunc(user_gen_func._py_callable)
-        dec_func.expand()
-        dec_func_def = QMODULE.native_defs[func_name]
-        interpreter._expanded_functions[func_name] = dec_func_def
-        _DecFuncVisitor(interpreter).visit(dec_func_def)
-
-
-class _DecFuncVisitor(Visitor):
-    def __init__(self, interpreter: "Interpreter"):
-        self._interpreter = interpreter
-
-    def visit_QuantumFunctionCall(self, call: QuantumFunctionCall) -> None:
-        _register_declarative_function(self._interpreter, call.func_name)
-        for arg in call.positional_args:
-            if isinstance(arg, str):
-                arg = [arg]
-            if isinstance(arg, list):
-                for possible_func_name in arg:
-                    if isinstance(possible_func_name, str):
-                        _register_declarative_function(
-                            self._interpreter, possible_func_name
-                        )