classiq 0.69.0__py3-none-any.whl → 0.71.0__py3-none-any.whl

classiq/model_expansions/capturing/captured_vars.py

@@ -3,15 +3,21 @@ from collections.abc import Sequence
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING
 
+from typing_extensions import Self
+
 from classiq.interface.enum_utils import StrEnum
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
     ClassiqInternalExpansionError,
 )
 from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.classical_type import ClassicalType
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+from classiq.interface.model.classical_parameter_declaration import (
+    ClassicalParameterDeclaration,
+)
 from classiq.interface.model.handle_binding import (
     HandleBinding,
     NestedHandleBinding,
@@ -19,6 +25,7 @@ from classiq.interface.model.handle_binding import (
 )
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_call import ArgValue
+from classiq.interface.model.quantum_function_declaration import PositionalArg
 from classiq.interface.model.quantum_type import QuantumBitvector, QuantumType
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
@@ -28,7 +35,11 @@ from classiq.model_expansions.capturing.mangling_utils import (
     demangle_handle,
     mangle_captured_var_name,
 )
-from classiq.model_expansions.transformers.var_splitter import SymbolPart, SymbolParts
+from classiq.model_expansions.transformers.model_renamer import (
+    HandleRenaming,
+    SymbolRenaming,
+)
+from classiq.model_expansions.transformers.var_splitter import SymbolPart
 
 if TYPE_CHECKING:
     from classiq.model_expansions.closure import FunctionClosure
@@ -72,12 +83,29 @@ class PortDirection(StrEnum):
 
 
 @dataclass(frozen=True)
-class _CapturedHandle:
+class _Captured:
+    defining_function: "FunctionClosure"
+    is_propagated: bool
+
+    def change_defining_function(
+        self, new_defining_function: "FunctionClosure"
+    ) -> Self:
+        return dataclasses.replace(self, defining_function=new_defining_function)
+
+    def set_propagated(self) -> Self:
+        return dataclasses.replace(self, is_propagated=True)
+
+    def update_propagation(self, other_captured_handle: Self) -> Self:
+        if self.is_propagated and not other_captured_handle.is_propagated:
+            return dataclasses.replace(self, is_propagated=False)
+        return self
+
+
+@dataclass(frozen=True)
+class _CapturedHandle(_Captured):
     handle: HandleBinding
     quantum_type: QuantumType
-    defining_function: "FunctionClosure"
     direction: PortDirection
-    is_propagated: bool
 
     @property
     def mangled_name(self) -> str:
@@ -103,27 +131,33 @@ class _CapturedHandle:
     def change_direction(self, new_direction: PortDirection) -> "_CapturedHandle":
         return dataclasses.replace(self, direction=new_direction)
 
-    def change_defining_function(
-        self, new_defining_function: "FunctionClosure"
-    ) -> "_CapturedHandle":
-        return dataclasses.replace(self, defining_function=new_defining_function)
-
-    def set_propagated(self) -> "_CapturedHandle":
-        return dataclasses.replace(self, is_propagated=True)
-
-    def update_propagation(
-        self, other_captured_handle: "_CapturedHandle"
-    ) -> "_CapturedHandle":
-        if self.is_propagated and not other_captured_handle.is_propagated:
-            return dataclasses.replace(self, is_propagated=False)
-        return self
-
     def set_symbol(
         self, handle: HandleBinding, quantum_type: QuantumType
     ) -> "_CapturedHandle":
         return dataclasses.replace(self, handle=handle, quantum_type=quantum_type)
 
 
+@dataclass(frozen=True)
+class _CapturedClassicalVar(_Captured):
+    name: str
+    classical_type: ClassicalType
+    defining_function: "FunctionClosure"
+
+    @property
+    def mangled_name(self) -> str:
+        return mangle_captured_var_name(
+            self.name,
+            self.defining_function.name,
+            self.defining_function.depth,
+        )
+
+    @property
+    def parameter_declaration(self) -> ClassicalParameterDeclaration:
+        return ClassicalParameterDeclaration(
+            name=self.mangled_name, classical_type=self.classical_type
+        )
+
+
 HandleState = tuple[str, "FunctionClosure", bool]
 
 
@@ -131,6 +165,7 @@ HandleState = tuple[str, "FunctionClosure", bool]
 class CapturedVars:
     _captured_handles: list[_CapturedHandle] = field(default_factory=list)
     _handle_states: list[HandleState] = field(default_factory=list)
+    _captured_classical_vars: list[_CapturedClassicalVar] = field(default_factory=list)
 
     def capture_handle(
         self,
@@ -332,16 +367,48 @@ class CapturedVars:
         )
         return merged_handle, merged_quantum_type
 
+    def capture_classical_var(
+        self,
+        var_name: str,
+        var_type: ClassicalType,
+        defining_function: "FunctionClosure",
+    ) -> None:
+        self._capture_classical_var(
+            _CapturedClassicalVar(
+                name=var_name,
+                classical_type=var_type,
+                defining_function=defining_function,
+                is_propagated=False,
+            )
+        )
+
+    def _capture_classical_var(
+        self, captured_classical_var: _CapturedClassicalVar
+    ) -> None:
+        for existing_captured_classical_var in self._captured_classical_vars:
+            if (
+                existing_captured_classical_var.name == captured_classical_var.name
+                and _same_closure(
+                    existing_captured_classical_var.defining_function,
+                    captured_classical_var.defining_function,
+                )
+            ):
+                return
+        self._captured_classical_vars.append(captured_classical_var)
+
     def update(self, other_captured_vars: "CapturedVars") -> None:
         for captured_handle in other_captured_vars._captured_handles:
             self._capture_handle(captured_handle)
+        for captured_classical_var in other_captured_vars._captured_classical_vars:
+            self._capture_classical_var(captured_classical_var)
 
     def negate(self) -> "CapturedVars":
         return CapturedVars(
             _captured_handles=[
                 captured_handle.change_direction(captured_handle.direction.negate())
                 for captured_handle in self._captured_handles
-            ]
+            ],
+            _captured_classical_vars=self._captured_classical_vars,
         )
 
     def filter_vars(self, current_function: "FunctionClosure") -> "CapturedVars":
@@ -352,7 +419,14 @@ class CapturedVars:
                 if not _same_closure(
                     captured_handle.defining_function, current_function
                 )
-            ]
+            ],
+            _captured_classical_vars=[
+                captured_classical_var
+                for captured_classical_var in self._captured_classical_vars
+                if not _same_closure(
+                    captured_classical_var.defining_function, current_function
+                )
+            ],
         )
 
     def filter_var_decls(
@@ -367,7 +441,8 @@ class CapturedVars:
                     current_declared_vars is not None
                     and captured_handle.handle.name not in current_declared_vars
                 )
-            ]
+            ],
+            _captured_classical_vars=self._captured_classical_vars,
         )
 
     def set_propagated(self) -> "CapturedVars":
@@ -375,16 +450,37 @@ class CapturedVars:
             _captured_handles=[
                 captured_handle.set_propagated()
                 for captured_handle in self._captured_handles
-            ]
+            ],
+            _captured_classical_vars=[
+                captured_classical_var.set_propagated()
+                for captured_classical_var in self._captured_classical_vars
+            ],
         )
 
-    def get_captured_ports(self) -> list[PortDeclaration]:
-        return [captured_handle.port for captured_handle in self._captured_handles]
-
-    def get_captured_args(
-        self, current_function: "FunctionClosure"
-    ) -> list[HandleBinding]:
-        return [
+    def get_captured_parameters(self) -> list[PositionalArg]:
+        decls: list[PositionalArg]
+        decls = [
+            captured_classical_var.parameter_declaration
+            for captured_classical_var in self._captured_classical_vars
+        ]
+        decls += [captured_handle.port for captured_handle in self._captured_handles]
+        return decls
+
+    def get_captured_args(self, current_function: "FunctionClosure") -> list[ArgValue]:
+        args: list[ArgValue]
+        args = [
+            Expression(
+                expr=(
+                    captured_classical_var.name
+                    if _same_closure(
+                        current_function, captured_classical_var.defining_function
+                    )
+                    else captured_classical_var.mangled_name
+                )
+            )
+            for captured_classical_var in self._captured_classical_vars
+        ]
+        args += [
             (
                 captured_handle.handle
                 if _same_closure(current_function, captured_handle.defining_function)
@@ -392,9 +488,11 @@ class CapturedVars:
             )
             for captured_handle in self._captured_handles
         ]
+        return args
 
-    def get_captured_mapping(self) -> SymbolParts:
-        return {
+    def get_captured_mapping(self) -> SymbolRenaming:
+        mapping: SymbolRenaming
+        mapping = {
             captured_handle.handle: [
                 SymbolPart(
                     source_handle=captured_handle.handle,
@@ -405,6 +503,17 @@ class CapturedVars:
             for captured_handle in self._captured_handles
             if not captured_handle.is_propagated
         }
+        mapping |= {
+            (handle := HandleBinding(name=captured_classical_var.name)): [
+                HandleRenaming(
+                    source_handle=handle,
+                    target_var_name=captured_classical_var.mangled_name,
+                )
+            ]
+            for captured_classical_var in self._captured_classical_vars
+            if not captured_classical_var.is_propagated
+        }
+        return mapping
 
     def init_var(self, var_name: str, defining_function: "FunctionClosure") -> None:
         self._handle_states.append((var_name, defining_function, False))
@@ -470,6 +579,7 @@ class CapturedVars:
         return CapturedVars(
             _captured_handles=list(self._captured_handles),
             _handle_states=list(self._handle_states),
+            _captured_classical_vars=list(self._captured_classical_vars),
         )
 
     def set(
@@ -492,6 +602,14 @@ class CapturedVars:
                 self._handle_states.append((var, target_func, state))
             else:
                 self._handle_states.append((var, defining_function, state))
+        self._captured_classical_vars = []
+        for captured_classical_var in other._captured_classical_vars:
+            if _same_closure(captured_classical_var.defining_function, source_func):
+                self._captured_classical_vars.append(
+                    captured_classical_var.change_defining_function(target_func)
+                )
+            else:
+                self._captured_classical_vars.append(captured_classical_var)
 
 
 def _same_closure(closure_1: "FunctionClosure", closure_2: "FunctionClosure") -> bool:
@@ -499,11 +617,15 @@ def _same_closure(closure_1: "FunctionClosure", closure_2: "FunctionClosure") ->
 
 
 def validate_args_are_not_propagated(
-    args: Sequence[ArgValue], captured_vars: Sequence[HandleBinding]
+    args: Sequence[ArgValue], captured_vars: Sequence[ArgValue]
 ) -> None:
     if not captured_vars:
         return
-    captured_handles = {demangle_handle(handle) for handle in captured_vars}
+    captured_handles = {
+        demangle_handle(handle)
+        for handle in captured_vars
+        if isinstance(handle, HandleBinding)
+    }
     arg_handles = {
         demangle_handle(arg) for arg in args if isinstance(arg, HandleBinding)
     }

classiq/model_expansions/evaluators/arg_type_match.py

@@ -3,10 +3,12 @@ from enum import Enum
 from typing import Any
 
 from classiq.interface.exceptions import ClassiqExpansionError
-from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
-from classiq.interface.generator.expressions.qmod_struct_instance import (
+from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
     QmodStructInstance,
 )
+from classiq.interface.generator.expressions.proxies.quantum.qmod_sized_proxy import (
+    QmodSizedProxy,
+)
 from classiq.interface.generator.functions.classical_type import (
     StructMetaType,
 )

classiq/model_expansions/evaluators/classical_expression.py

@@ -23,13 +23,13 @@ def evaluate_classical_expression(expr: Expression, scope: Scope) -> Evaluated:
         )
         for name, evaluated in all_symbols
         if isinstance(evaluated.value, QuantumSymbol)
-        and evaluated.value.quantum_type.has_size_in_bits
+        and evaluated.value.quantum_type.is_evaluated
     }
     uninitialized_locals = {
         name
         for name, evaluated in all_symbols
         if isinstance(evaluated.value, QuantumSymbol)
-        and not evaluated.value.quantum_type.has_size_in_bits
+        and not evaluated.value.quantum_type.is_evaluated
     }
 
     ret = evaluate(expr, locals_dict, uninitialized_locals)

classiq/model_expansions/evaluators/classical_type_inference.py

@@ -0,0 +1,70 @@
+from typing import Any, Union
+
+from classiq.interface.exceptions import ClassiqExpansionError
+from classiq.interface.generator.expressions.proxies.classical.classical_array_proxy import (
+    ClassicalArrayProxy,
+)
+from classiq.interface.generator.expressions.proxies.classical.classical_struct_proxy import (
+    ClassicalStructProxy,
+)
+from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
+    QmodStructInstance,
+)
+from classiq.interface.generator.functions.classical_type import (
+    ClassicalArray,
+    ClassicalList,
+    ClassicalType,
+)
+from classiq.interface.generator.functions.type_name import TypeName
+from classiq.interface.generator.types.struct_declaration import StructDeclaration
+
+
+def infer_classical_type(val: Any, classical_type: ClassicalType) -> ClassicalType:
+    if isinstance(classical_type, TypeName):
+        return _infer_classical_struct_type(val, classical_type)
+    if isinstance(classical_type, (ClassicalArray, ClassicalList)):
+        return _infer_classical_array_type(val, classical_type)
+    return classical_type
+
+
+def _infer_classical_struct_type(val: Any, classical_type: TypeName) -> ClassicalType:
+    if not isinstance(val, (QmodStructInstance, ClassicalStructProxy)):
+        return classical_type
+    decl = val.struct_declaration
+    new_fields = {
+        field_name: infer_classical_type(field_val, field_type)
+        for (field_name, field_val), field_type in zip(
+            val.fields.items(),
+            decl.variables.values(),
+            strict=True,
+        )
+    }
+    new_classical_type = TypeName(name=decl.name)
+    new_classical_type.set_classical_struct_decl(
+        StructDeclaration(name=decl.name, variables=new_fields)
+    )
+    return new_classical_type
+
+
+def _infer_classical_array_type(
+    val: Any, classical_type: Union[ClassicalArray, ClassicalList]
+) -> ClassicalType:
+    if isinstance(val, list):
+        val_length = len(val)
+    elif isinstance(val, ClassicalArrayProxy):
+        val_length = val.length
+    else:
+        raise ClassiqExpansionError(f"Array expected, got {str(val)!r}")
+    if isinstance(classical_type, ClassicalArray) and val_length != classical_type.size:
+        raise ClassiqExpansionError(
+            f"Type mismatch: Argument has {val_length} items but "
+            f"{classical_type.size} expected"
+        )
+    return ClassicalArray(
+        element_type=(
+            infer_classical_type(val[0], classical_type.element_type)
+            if val_length > 0
+            else classical_type.element_type
+        ),
+        size=val_length,
+    )

classiq/model_expansions/evaluators/control.py

@@ -8,7 +8,7 @@ from classiq.interface.generator.arith.argument_utils import (
     unsigned_integer_interpretation,
 )
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
-from classiq.interface.generator.expressions.qmod_qscalar_proxy import (
+from classiq.interface.generator.expressions.proxies.quantum.qmod_qscalar_proxy import (
     QmodQNumProxy,
     QmodQScalarProxy,
     QmodSizedProxy,

classiq/model_expansions/evaluators/parameter_types.py

@@ -1,9 +1,10 @@
-from typing import Union
+from typing import TypeVar, Union
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
     ClassiqInternalExpansionError,
 )
+from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.concrete_types import ConcreteQuantumType
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
@@ -11,6 +12,9 @@ from classiq.interface.generator.functions.port_declaration import (
 from classiq.interface.generator.functions.type_name import (
     TypeName,
 )
+from classiq.interface.model.classical_parameter_declaration import (
+    ClassicalParameterDeclaration,
+)
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_declaration import (
     PositionalArg,
@@ -28,11 +32,12 @@ from classiq.model_expansions.evaluators.arg_type_match import check_type_match
 from classiq.model_expansions.evaluators.classical_expression import (
     evaluate_classical_expression,
 )
+from classiq.model_expansions.evaluators.classical_type_inference import (
+    infer_classical_type,
+)
 from classiq.model_expansions.evaluators.quantum_type_utils import (
     copy_type_information,
     set_element_type,
-    set_fraction_digits,
-    set_is_signed,
     set_length,
     set_size,
 )
@@ -127,6 +132,14 @@ def _cast(
 def _evaluate_type_from_arg(
     parameter: PositionalArg, argument: Evaluated, inner_scope: Scope
 ) -> PositionalArg:
+    if isinstance(parameter, ClassicalParameterDeclaration):
+        return ClassicalParameterDeclaration(
+            name=parameter.name,
+            classical_type=infer_classical_type(
+                argument.value, parameter.classical_type
+            ),
+        )
+
     if not isinstance(parameter, PortDeclaration):
         return parameter
 
@@ -162,9 +175,14 @@ def _evaluate_qarray_in_quantum_symbol(
     )
     set_element_type(type_to_update, new_element_type)
     if type_to_update.length is not None:
-        new_length = evaluate_classical_expression(
-            type_to_update.length, scope
-        ).as_type(int)
+        new_length = _eval_expr(
+            type_to_update.length,
+            scope,
+            int,
+            type_to_update.type_name,
+            "length",
+            param_name,
+        )
         set_length(type_to_update, new_length)
     return type_to_update
 
@@ -173,23 +191,61 @@ def _evaluate_qnum_in_quantum_symbol(
     type_to_update: QuantumNumeric, scope: Scope, param_name: str
 ) -> QuantumNumeric:
     if type_to_update.is_signed is not None:
-        new_is_sign = evaluate_classical_expression(
-            type_to_update.is_signed, scope
-        ).as_type(bool)
-        set_is_signed(type_to_update, new_is_sign, param_name)
+        new_is_sign = _eval_expr(
+            type_to_update.is_signed,
+            scope,
+            bool,
+            type_to_update.type_name,
+            "sign",
+            param_name,
+        )
+        type_to_update.is_signed = Expression(expr=str(new_is_sign))
     if type_to_update.fraction_digits is not None:
-        new_fraction_digits = evaluate_classical_expression(
-            type_to_update.fraction_digits, scope
-        ).as_type(int)
-        set_fraction_digits(type_to_update, new_fraction_digits, param_name)
+        new_fraction_digits = _eval_expr(
+            type_to_update.fraction_digits,
+            scope,
+            int,
+            type_to_update.type_name,
+            "fraction digits",
+            param_name,
+        )
+        type_to_update.fraction_digits = Expression(expr=str(new_fraction_digits))
     if type_to_update.size is not None:
-        new_size = evaluate_classical_expression(type_to_update.size, scope).as_type(
-            int
+        new_size = _eval_expr(
+            type_to_update.size,
+            scope,
+            int,
+            type_to_update.type_name,
+            "size",
+            param_name,
         )
         set_size(type_to_update, new_size, param_name)
     return type_to_update
 
 
+_EXPR_TYPE = TypeVar("_EXPR_TYPE")
+
+
+def _eval_expr(
+    expression: Expression,
+    scope: Scope,
+    expected_type: type[_EXPR_TYPE],
+    type_name: str,
+    attr_name: str,
+    param_name: str,
+) -> _EXPR_TYPE:
+    val = evaluate_classical_expression(expression, scope).value
+    if expected_type is int and isinstance(val, float):
+        val = int(val)
+    if not isinstance(val, expected_type):
+        raise ClassiqExpansionError(
+            f"When inferring the type of parameter {param_name!r}: "
+            f"{type_name} {attr_name} must be {expected_type.__name__}, got "
+            f"{str(val)!r}"
+        )
+    return val
+
+
 def _evaluate_qstruct_in_quantum_symbol(
     type_to_update: TypeName, scope: Scope, param_name: str
 ) -> TypeName:

classiq/model_expansions/evaluators/quantum_type_utils.py

@@ -1,5 +1,4 @@
 from collections.abc import Sequence
-from typing import Optional
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
@@ -33,12 +32,11 @@ def copy_type_information(
     if isinstance(to_type, QuantumBit):
         set_size(to_type, from_type.size_in_bits, to_param_name)
     elif isinstance(to_type, QuantumNumeric):
-        set_is_signed(to_type, getattr(from_type, "sign_value", None), to_param_name)
-        set_fraction_digits(
-            to_type,
-            getattr(from_type, "fraction_digits_value", None),
-            to_param_name,
-        )
+        if to_type.size is None and isinstance(from_type, QuantumNumeric):
+            to_type.is_signed = Expression(expr=str(from_type.sign_value))
+            to_type.fraction_digits = Expression(
+                expr=str(from_type.fraction_digits_value)
+            )
         set_size(to_type, from_type.size_in_bits, to_param_name)
     elif isinstance(to_type, QuantumBitvector):
         if isinstance(from_type, QuantumBitvector) and type(  # noqa: E721
@@ -73,8 +71,8 @@ def set_size(quantum_type: QuantumType, size: int, param_name: str) -> None:
     if isinstance(quantum_type, QuantumNumeric):
         quantum_type.size = Expression(expr=str(size))
         if not quantum_type.has_sign or not quantum_type.has_fraction_digits:
-            set_is_signed(quantum_type, False, param_name)
-            set_fraction_digits(quantum_type, 0, param_name)
+            quantum_type.is_signed = Expression(expr="False")
+            quantum_type.fraction_digits = Expression(expr="0")
     elif isinstance(quantum_type, QuantumBitvector):
         if quantum_type.has_length:
             if size % quantum_type.length_value != 0:
@@ -107,54 +105,6 @@ def set_size(quantum_type: QuantumType, size: int, param_name: str) -> None:
             set_size(fields_without_size[0], size - predetermined_size_part, param_name)
 
 
-def set_fraction_digits(
-    quantum_numeric: QuantumNumeric, fraction_digits: Optional[int], param_name: str
-) -> None:
-    if fraction_digits is not None and fraction_digits < 0:
-        raise ClassiqExpansionError(
-            f"Number of fraction digits for {param_name!r} was deduced to be negative: "
-            f"{fraction_digits!r}"
-        )
-
-    if (
-        fraction_digits is not None
-        and quantum_numeric.fraction_digits is not None
-        and quantum_numeric.fraction_digits.is_evaluated()
-        and quantum_numeric.fraction_digits_value != fraction_digits
-    ):
-        raise ClassiqExpansionError(
-            f"Fraction digits mismatch for variable {param_name!r} between declared "
-            f"fraction digits {quantum_numeric.fraction_digits_value!r} and assigned fraction "
-            f"digits {fraction_digits!r}"
-        )
-
-    if not (
-        quantum_numeric.fraction_digits is not None
-        and quantum_numeric.fraction_digits.is_evaluated()
-    ):
-        quantum_numeric.fraction_digits = Expression(expr=str(fraction_digits or 0))
-
-
-def set_is_signed(
-    quantum_numeric: QuantumNumeric, is_signed: Optional[bool], param_name: str
-) -> None:
-    if (
-        is_signed is not None
-        and quantum_numeric.is_signed is not None
-        and quantum_numeric.is_signed.is_evaluated()
-        and quantum_numeric.sign_value != is_signed
-    ):
-        raise ClassiqExpansionError(
-            f"Sign mismatch for variable {param_name!r} between declared sign {quantum_numeric.sign_value!r} and assigned sign {is_signed!r}"
-        )
-
-    if not (
-        quantum_numeric.is_signed is not None
-        and quantum_numeric.is_signed.is_evaluated()
-    ):
-        quantum_numeric.is_signed = Expression(expr=str(is_signed or False))
-
-
 def set_element_type(
     quantum_array: QuantumBitvector, element_type: ConcreteQuantumType
 ) -> None: