classiq 0.82.1__py3-none-any.whl → 0.84.0__py3-none-any.whl

classiq/model_expansions/capturing/captured_vars.py

@@ -10,6 +10,9 @@ from classiq.interface.exceptions import (
     ClassiqExpansionError,
     ClassiqInternalExpansionError,
 )
+from classiq.interface.generator.expressions.evaluated_expression import (
+    EvaluatedExpression,
+)
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.classical_type import (
     CLASSICAL_ATTRIBUTES_TYPES,
@@ -18,7 +21,7 @@ from classiq.interface.generator.functions.classical_type import (
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
-from classiq.interface.generator.functions.type_qualifier import TypeQualifier
+from classiq.interface.generator.functions.type_modifier import TypeModifier
 from classiq.interface.helpers.text_utils import are, readable_list, s, they
 from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
@@ -56,6 +59,14 @@ INITIALIZED_VAR_MESSAGE = "Variable '{}' should be uninitialized here"
 UNINITIALIZED_VAR_MESSAGE = "Variable '{}' should be initialized here"
 
 
+def _get_symbol_expr(symbol: str, classical_type: ClassicalType) -> Expression:
+    expr = Expression(expr=symbol)
+    expr._evaluated_expr = EvaluatedExpression(
+        value=classical_type.get_classical_proxy(handle=HandleBinding(name=symbol))
+    )
+    return expr
+
+
 class PortDirection(StrEnum):
     Input = "input"
     Inout = "inout"
@@ -138,7 +149,7 @@ class _CapturedHandle(_Captured):
             name=self.mangled_name,
             quantum_type=self.quantum_type,
             direction=self.direction.dump(),
-            type_qualifier=TypeQualifier.Inferred,  # TODO https://classiq.atlassian.net/browse/CLS-1830
+            type_modifier=TypeModifier.Inferred,
         )
 
     def is_same_var(self, other: "_CapturedHandle") -> bool:
@@ -556,24 +567,26 @@ class CapturedVars:
     def get_captured_args(self, current_function: "FunctionClosure") -> list[ArgValue]:
         args: list[ArgValue]
         args = [
-            Expression(
-                expr=(
+            _get_symbol_expr(
+                (
                     captured_classical_var.name
                     if _same_closure(
                         current_function, captured_classical_var.defining_function
                     )
                     else captured_classical_var.mangled_name
-                )
+                ),
+                captured_classical_var.classical_type,
             )
             for captured_classical_var in self._captured_classical_vars
         ]
         args += [
-            Expression(
-                expr=(
+            _get_symbol_expr(
+                (
                     str(captured_qta.handle)
                     if _same_closure(current_function, captured_qta.defining_function)
                     else captured_qta.mangled_name
-                )
+                ),
+                captured_qta.classical_type,
             )
             for captured_qta in self._captured_quantum_type_attributes
         ]

classiq/model_expansions/interpreters/base_interpreter.py

@@ -39,14 +39,14 @@ from classiq.interface.model.quantum_lambda_function import (
 )
 from classiq.interface.model.quantum_statement import QuantumStatement
 
+from classiq.evaluators.classical_expression import (
+    evaluate_classical_expression,
+)
 from classiq.model_expansions.closure import (
     Closure,
     FunctionClosure,
 )
 from classiq.model_expansions.debug_flag import debug_mode
-from classiq.model_expansions.evaluators.classical_expression import (
-    evaluate_classical_expression,
-)
 from classiq.model_expansions.function_builder import (
     FunctionContext,
     OperationBuilder,

classiq/model_expansions/quantum_operations/allocate.py

@@ -12,7 +12,7 @@ from classiq.interface.model.quantum_type import (
     QuantumNumeric,
 )
 
-from classiq.model_expansions.evaluators.quantum_type_utils import copy_type_information
+from classiq.evaluators.quantum_type_utils import copy_type_information
 from classiq.model_expansions.quantum_operations.emitter import Emitter
 from classiq.model_expansions.scope import QuantumSymbol
 

classiq/model_expansions/quantum_operations/assignment_result_processor.py

@@ -24,7 +24,7 @@ from classiq.interface.model.variable_declaration_statement import (
 )
 from classiq.interface.model.within_apply_operation import WithinApply
 
-from classiq.model_expansions.evaluators.quantum_type_utils import copy_type_information
+from classiq.evaluators.quantum_type_utils import copy_type_information
 from classiq.model_expansions.quantum_operations.arithmetic.explicit_boolean_expressions import (
     convert_assignment_bool_expression,
     validate_assignment_bool_expression,

classiq/model_expansions/quantum_operations/bind.py

@@ -8,10 +8,10 @@ from classiq.interface.exceptions import (
 from classiq.interface.model.bind_operation import BindOperation
 from classiq.interface.model.quantum_type import QuantumNumeric
 
-from classiq.model_expansions.evaluators.parameter_types import (
+from classiq.evaluators.parameter_types import (
     evaluate_types_in_quantum_symbols,
 )
-from classiq.model_expansions.evaluators.quantum_type_utils import (
+from classiq.evaluators.quantum_type_utils import (
     set_size,
     validate_bind_targets,
 )

classiq/model_expansions/quantum_operations/call_emitter.py

@@ -28,7 +28,7 @@ from classiq.interface.generator.expressions.proxies.classical.qmod_struct_insta
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
-from classiq.interface.generator.functions.type_qualifier import TypeQualifier
+from classiq.interface.generator.functions.type_modifier import TypeModifier
 from classiq.interface.generator.types.compilation_metadata import CompilationMetadata
 from classiq.interface.helpers.backward_compatibility import zip_strict
 from classiq.interface.helpers.text_utils import are, readable_list, s
@@ -50,19 +50,19 @@ from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
 
+from classiq.evaluators.argument_types import (
+    add_information_from_output_arguments,
+    handle_args_numeric_bounds,
+)
+from classiq.evaluators.parameter_types import (
+    evaluate_parameter_types_from_args,
+)
 from classiq.model_expansions.capturing.captured_vars import (
     INITIALIZED_VAR_MESSAGE,
     UNINITIALIZED_VAR_MESSAGE,
     validate_args_are_not_propagated,
 )
 from classiq.model_expansions.closure import Closure, FunctionClosure
-from classiq.model_expansions.evaluators.argument_types import (
-    add_information_from_output_arguments,
-    handle_args_numeric_bounds,
-)
-from classiq.model_expansions.evaluators.parameter_types import (
-    evaluate_parameter_types_from_args,
-)
 from classiq.model_expansions.function_builder import (
     FunctionContext,
 )
@@ -80,8 +80,8 @@ from classiq.model_expansions.scope import (
     QuantumVariable,
     Scope,
 )
-from classiq.model_expansions.transformers.type_qualifier_inference import (
-    TypeQualifierValidation,
+from classiq.model_expansions.transformers.type_modifier_inference import (
+    TypeModifierValidation,
 )
 from classiq.model_expansions.transformers.var_splitter import VarSplitter
 from classiq.qmod.pretty_print.expression_to_python import transform_expression
@@ -135,13 +135,13 @@ def _validate_gen_args(
     ):
         if (
             isinstance(param, ClassicalParameterDeclaration)
-            and param.classical_type.is_purely_generative
+            and not param.classical_type.is_purely_declarative
             and _is_symbolic(arg.value)
         ):
+            readable_expr = transform_expression(str(arg.value), {}, {}, one_line=True)
             raise ClassiqExpansionError(
-                f"Parameter {param.name!r} is used in a compile-time expression "
-                f"context but is passed a runtime expression "
-                f"{transform_expression(str(arg.value), {}, {}, one_line=True)!r}"
+                f"Cannot pass symbolic expression {readable_expr!r} as Python-type "
+                f"parameter {param.name!r}"
             )
 
 
@@ -209,17 +209,21 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
                 function.name, new_declaration
             )
         else:
-            # FIXME: enable for BE (CLS-2390)
-            if type(self._interpreter).__name__ == "FrontendGenerativeInterpreter":
-                _validate_gen_args(function, evaluated_args)
+            _validate_gen_args(function, evaluated_args)
             new_declaration = self._expand_function(
                 evaluated_args, new_declaration, function
             )
             new_positional_arg_decls = new_declaration.positional_arg_declarations
             evaluated_args = [
                 arg
-                for arg in evaluated_args
-                if isinstance(arg.value, QuantumVariable) or _is_symbolic(arg.value)
+                for param, arg in zip_strict(
+                    function.positional_arg_declarations, evaluated_args, strict=True
+                )
+                if isinstance(arg.value, QuantumVariable)
+                or (
+                    isinstance(param, ClassicalParameterDeclaration)
+                    and param.classical_type.is_purely_declarative
+                )
             ]
 
         add_information_from_output_arguments(new_positional_arg_decls, evaluated_args)
@@ -291,7 +295,7 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         context = self._expand_operation(function)
         function_context = cast(FunctionContext, context)
         function_def = self._create_function_definition(function_context, args)
-        self._validate_type_qualifiers(function_context, function_def)
+        self._validate_type_modifiers(function_context, function_def)
         self._expanded_functions[cache_key] = function_def
         self._top_level_scope[function_def.name] = Evaluated(
             value=function_context.closure.with_new_declaration(function_def)
@@ -312,7 +316,7 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
             if isinstance(param, PortDeclaration)
             or (
                 isinstance(param, ClassicalParameterDeclaration)
-                and _is_symbolic(arg.value)
+                and param.classical_type.is_purely_declarative
             )
         ]
         func_def = self._builder.create_definition(function_context, params)
@@ -350,8 +354,10 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
                     ),
                     defining_function=closure,
                 )
-            elif _is_symbolic(argument.value):
-                assert isinstance(parameter, ClassicalParameterDeclaration)
+            elif (
+                isinstance(parameter, ClassicalParameterDeclaration)
+                and parameter.classical_type.is_purely_declarative
+            ):
                 inferred_arg = Evaluated(
                     value=parameter.classical_type.get_classical_proxy(param_handle),
                     defining_function=closure,
@@ -415,29 +421,29 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
             if var_state and param.direction == PortDeclarationDirection.Output:
                 raise ClassiqExpansionError(INITIALIZED_VAR_MESSAGE.format(var_name))
 
-    def _validate_type_qualifiers(
+    def _validate_type_modifiers(
         self, func_context: FunctionContext, func_def: NativeFunctionDefinition
     ) -> None:
-        if self._should_override_type_qualifiers(func_context):
-            self._override_type_qualifiers(func_def)
+        if self._should_override_type_modifiers(func_context):
+            self._override_type_modifiers(func_def)
 
         unchecked = self._functions_compilation_metadata.get(
             func_context.name, CompilationMetadata()
         ).unchecked
-        TypeQualifierValidation(
+        TypeModifierValidation(
             skip_validation=self._interpreter.skip_type_modifier_validation
-        ).run(func_def.port_declarations, func_def.body, unchecked)
+        ).run(func_def, unchecked)
 
     @staticmethod
-    def _should_override_type_qualifiers(func_context: FunctionContext) -> bool:
+    def _should_override_type_modifiers(func_context: FunctionContext) -> bool:
         """
-        The type qualifier can be changed according to the operand passed to the
+        The type modifier can be changed according to the operand passed to the
         function. For example,
-        apply_to_all(X, q) --> q will be QFree after expansion
+        apply_to_all(X, q) --> q will be Permutable after expansion
         apply_to_all(H, q) --> q will be Quantum after expansion
         This also holds for the intermediate lambda created during the expansion.
 
-        We don't override the type qualifier if it's explicitly specified (QFree or
+        We don't override the type modifier if it's explicitly specified (Permutable or
         Const), neither in the function declaration nor in the operand declaration.
         """
 
@@ -461,8 +467,8 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         )
 
     @staticmethod
-    def _override_type_qualifiers(func_def: NativeFunctionDefinition) -> None:
-        # only override the qualifier if it's unspecified (not QFree or Const)
+    def _override_type_modifiers(func_def: NativeFunctionDefinition) -> None:
+        # only override the modifier if it's unspecified (not Permutable or Const)
         for port in func_def.port_declarations:
-            if port.type_qualifier is TypeQualifier.Quantum:
-                port.type_qualifier = TypeQualifier.Inferred
+            if port.type_modifier is TypeModifier.Mutable:
+                port.type_modifier = TypeModifier.Inferred

classiq/model_expansions/quantum_operations/variable_decleration.py

@@ -4,7 +4,7 @@ from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
 
-from classiq.model_expansions.evaluators.parameter_types import (
+from classiq.evaluators.parameter_types import (
     evaluate_type_in_quantum_symbol,
 )
 from classiq.model_expansions.quantum_operations.emitter import Emitter

classiq/model_expansions/scope_initialization.py

@@ -11,13 +11,13 @@ from classiq.interface.model.native_function_definition import NativeFunctionDef
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_declaration import PositionalArg
 
-from classiq.model_expansions.closure import FunctionClosure, GenerativeFunctionClosure
-from classiq.model_expansions.evaluators.classical_expression import (
+from classiq.evaluators.classical_expression import (
     evaluate_classical_expression,
 )
-from classiq.model_expansions.evaluators.parameter_types import (
+from classiq.evaluators.parameter_types import (
     evaluate_type_in_quantum_symbol,
 )
+from classiq.model_expansions.closure import FunctionClosure, GenerativeFunctionClosure
 from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
 from classiq.qmod.builtins import BUILTIN_CONSTANTS
 from classiq.qmod.builtins.enums import BUILTIN_ENUM_DECLARATIONS

classiq/model_expansions/transformers/model_renamer.py

@@ -6,7 +6,13 @@ from functools import cmp_to_key
 from typing import TypeVar, cast
 
 from classiq.interface.exceptions import ClassiqInternalExpansionError
+from classiq.interface.generator.expressions.evaluated_expression import (
+    EvaluatedExpression,
+)
 from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
+    AnyClassicalValue,
+)
 from classiq.interface.generator.visitor import NodeType
 from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.model_visitor import ModelTransformer
@@ -71,7 +77,7 @@ class HandleRenaming:
 SymbolRenaming = Mapping[HandleBinding, Sequence[HandleRenaming]]
 
 
-def _rewrite_expression(
+def rewrite_expression(
     symbol_mapping: SymbolRenaming, expression: Expression
 ) -> Expression:
     normalized_expr = ExprNormalizer().visit(ast.parse(expression.expr))
@@ -82,7 +88,8 @@ def _rewrite_expression(
 
     handle_names = {
         part.source_handle: part.target_var_handle
-        for parts in symbol_mapping.values()
+        for source, parts in symbol_mapping.items()
+        if source.name in expression.expr
         for part in parts
     }
     new_expr_str = ast.unparse(normalized_expr)
@@ -95,11 +102,15 @@ def _rewrite_expression(
     for handle in sorted_handles:
         new_handle = handle.collapse()
         for handle_to_replace, replacement in handle_names.items():
-            new_handle = new_handle.replace_prefix(handle_to_replace, replacement)
+            if new_handle.name == handle_to_replace.name:
+                new_handle = new_handle.replace_prefix(handle_to_replace, replacement)
         new_expr_str = _replace_full_word(str(handle), str(new_handle), new_expr_str)
 
     new_expr = Expression(expr=new_expr_str)
-    new_expr._evaluated_expr = expression._evaluated_expr
+    if not new_expr.is_evaluated():
+        new_expr._evaluated_expr = EvaluatedExpression(
+            value=AnyClassicalValue(new_expr_str)
+        )
     return new_expr
 
 
@@ -123,7 +134,7 @@ class _ReplaceSplitVarsExpressions(ModelTransformer):
         self._symbol_mapping = symbol_mapping
 
     def visit_Expression(self, expr: Expression) -> Expression:
-        return _rewrite_expression(self._symbol_mapping, expr)
+        return rewrite_expression(self._symbol_mapping, expr)
 
     def visit_QuantumExpressionOperation(
         self, op: QuantumExpressionOperation