classiq 0.80.1__py3-none-any.whl → 0.82.0__py3-none-any.whl

classiq/model_expansions/function_builder.py

@@ -29,14 +29,7 @@ from classiq.model_expansions.capturing.captured_vars import (
     validate_captured_directions,
     validate_end_state,
 )
-from classiq.model_expansions.closure import (
-    Closure,
-    FunctionClosure,
-    GenerativeFunctionClosure,
-)
-from classiq.model_expansions.evaluators.quantum_type_utils import (
-    is_signature_monomorphic,
-)
+from classiq.model_expansions.closure import Closure, FunctionClosure
 from classiq.model_expansions.scope import Scope
 from classiq.model_expansions.utils.counted_name_allocator import CountedNameAllocator
 
@@ -225,15 +218,6 @@ class OperationBuilder:
         if name == MAIN_FUNCTION_NAME:
             return name
 
-        if name in self.current_scope:
-            orig_func = self.current_scope[name].value
-            if (
-                isinstance(orig_func, FunctionClosure)
-                and not isinstance(orig_func, GenerativeFunctionClosure)
-                and is_signature_monomorphic(orig_func.positional_arg_declarations)
-            ):
-                return name
-
         for _ in self.current_scope:
             name = self._counted_name_allocator.allocate(
                 f"{name}_{LAMBDA_KEYWORD + '_0_0_' if function_context.is_lambda else ''}{EXPANDED_KEYWORD}"

classiq/model_expansions/interpreters/base_interpreter.py

@@ -75,6 +75,8 @@ from classiq.qmod.utilities import qmod_val_to_expr_str
 
 
 class BaseInterpreter:
+    skip_type_modifier_validation: bool = False
+
     def __init__(self, model: Model) -> None:
         validate_model(model)
         self._model = model

classiq/model_expansions/quantum_operations/allocate.py

@@ -76,11 +76,15 @@ class AllocateEmitter(Emitter[Allocate]):
         target: QuantumSymbol,
         op_update_dict: dict[str, Expression],
     ) -> None:
-        if not target.quantum_type.is_evaluated:
+        if target.quantum_type.is_evaluated:
+            expr = str(target.quantum_type.size_in_bits)
+        elif self._allow_symbolic_attrs:
+            expr = f"{target.handle}.size"
+        else:
             raise ClassiqValueError(
                 f"Could not infer the size of variable {str(target.handle)!r}"
             )
-        op_update_dict["size"] = Expression(expr=str(target.quantum_type.size_in_bits))
+        op_update_dict["size"] = Expression(expr=expr)
 
     def _handle_with_size(
         self,
@@ -88,7 +92,7 @@ class AllocateEmitter(Emitter[Allocate]):
         size: Expression,
         op_update_dict: dict[str, Expression],
     ) -> None:
-        size_value = self._interpret_size(size)
+        size_value = self._interpret_size(size, str(target.handle))
         op_update_dict["size"] = Expression(expr=str(size_value))
 
         if not isinstance(size_value, sympy.Basic):
@@ -106,12 +110,13 @@ class AllocateEmitter(Emitter[Allocate]):
         fraction_digits: Expression,
         op_update_dict: dict[str, Expression],
     ) -> None:
+        var_name = str(target.handle)
         if not isinstance(target.quantum_type, QuantumNumeric):
             raise ClassiqValueError(
-                f"Non-numeric variable {str(target.handle)!r} cannot be allocated with numeric attributes"
+                f"Non-numeric variable {var_name!r} cannot be allocated with numeric attributes"
             )
 
-        size_value = self._interpret_size(size)
+        size_value = self._interpret_size(size, var_name)
         op_update_dict["size"] = Expression(expr=str(size_value))
         is_signed_value = self._interpret_is_signed(is_signed)
         op_update_dict["is_signed"] = Expression(expr=str(is_signed_value))
@@ -130,12 +135,18 @@ class AllocateEmitter(Emitter[Allocate]):
                     fraction_digits=op_update_dict["fraction_digits"],
                 ),
                 target.quantum_type,
-                str(target.handle),
+                var_name,
             )
 
-    def _interpret_size(self, size: Expression) -> Union[int, float, sympy.Basic]:
+    def _interpret_size(
+        self, size: Expression, var_name: str
+    ) -> Union[int, float, sympy.Basic]:
         size_value = self._interpreter.evaluate(size).value
         if not self._allow_symbolic_attrs and not isinstance(size_value, (int, float)):
+            if size.expr == f"{var_name}.size":
+                raise ClassiqValueError(
+                    f"Could not infer the size of variable {var_name!r}"
+                )
             raise ClassiqValueError(
                 f"The number of allocated qubits must be an integer. Got "
                 f"{str(size_value)!r}"

classiq/model_expansions/quantum_operations/assignment_result_processor.py

@@ -78,7 +78,11 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
         expr = self._evaluate_expression(op.expression)
         if len(self._get_classical_vars_in_expression(expr)):
             return None
+
         symbols = self._get_symbols_in_expression(expr)
+        if any(not symbol.quantum_type.is_instantiated for symbol in symbols):
+            return None
+
         expr_str = rename_variables(
             expr.expr,
             {str(symbol.handle): symbol.handle.identifier for symbol in symbols}

classiq/model_expansions/quantum_operations/bind.py

@@ -31,7 +31,8 @@ class BindEmitter(Emitter[BindOperation]):
 
     def emit(self, bind: BindOperation, /) -> bool:
         inputs, outputs = self._get_inputs_outputs(bind)
-        validate_bind_targets(bind, self._current_scope, self._allow_symbolic_size)
+        if not self._allow_symbolic_size:
+            validate_bind_targets(bind, self._current_scope)
         self._process_var_sizes(bind, inputs, outputs)
 
         for symbol in chain(inputs, outputs):

classiq/model_expansions/quantum_operations/call_emitter.py

@@ -29,6 +29,7 @@ from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
 from classiq.interface.generator.functions.type_qualifier import TypeQualifier
+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
 from classiq.interface.model.classical_parameter_declaration import (
@@ -80,7 +81,7 @@ from classiq.model_expansions.scope import (
     Scope,
 )
 from classiq.model_expansions.transformers.type_qualifier_inference import (
-    TypeQualifierInference,
+    TypeQualifierValidation,
 )
 from classiq.model_expansions.transformers.var_splitter import VarSplitter
 from classiq.qmod.pretty_print.expression_to_python import transform_expression
@@ -290,6 +291,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._expanded_functions[cache_key] = function_def
         self._top_level_scope[function_def.name] = Evaluated(
             value=function_context.closure.with_new_declaration(function_def)
@@ -320,20 +322,14 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         )
         captured_ports = captured_vars.get_captured_parameters()
         if len(captured_ports) == 0:
-            self._override_type_qualifier(function_context, func_def)
             return func_def
         func_def.positional_arg_declarations = list(
             chain.from_iterable((func_def.positional_arg_declarations, captured_ports))
         )
 
-        rewrite_mapping = dict(captured_vars.get_propagated_captured_mapping())
-        if function_context.is_lambda:
-            rewrite_mapping |= captured_vars.get_immediate_captured_mapping()
-            rewrite_mapping |= captured_vars.get_classical_captured_mapping()
+        rewrite_mapping = captured_vars.get_captured_mapping(function_context.is_lambda)
         func_def.body = self.rewrite(func_def.body, rewrite_mapping)
 
-        self._override_type_qualifier(function_context, func_def)
-
         return func_def
 
     @staticmethod
@@ -419,9 +415,21 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
             if var_state and param.direction == PortDeclarationDirection.Output:
                 raise ClassiqExpansionError(INITIALIZED_VAR_MESSAGE.format(var_name))
 
-    def _override_type_qualifier(
+    def _validate_type_qualifiers(
         self, func_context: FunctionContext, func_def: NativeFunctionDefinition
     ) -> None:
+        if self._should_override_type_qualifiers(func_context):
+            self._override_type_qualifiers(func_def)
+
+        unchecked = self._functions_compilation_metadata.get(
+            func_context.name, CompilationMetadata()
+        ).unchecked
+        TypeQualifierValidation(
+            skip_validation=self._interpreter.skip_type_modifier_validation
+        ).run(func_def.port_declarations, func_def.body, unchecked)
+
+    @staticmethod
+    def _should_override_type_qualifiers(func_context: FunctionContext) -> bool:
         """
         The type qualifier can be changed according to the operand passed to the
         function. For example,
@@ -434,29 +442,27 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         """
 
         if func_context.is_lambda:
-            self._update_type_qualifiers(func_def)
-            return
+            return True
 
         orig_name = func_context.name
         if (
             orig_name == MAIN_FUNCTION_NAME
             or orig_name not in func_context.closure.scope
         ):
-            return
+            return False
 
         orig_func = func_context.closure.scope[orig_name].value
-        if isinstance(orig_func, Closure) and not any(
-            isinstance(param_decl, QuantumOperandDeclaration)
-            for param_decl in orig_func.positional_arg_declarations
-        ):
-            return
-
-        self._update_type_qualifiers(func_def)
+        return not (
+            isinstance(orig_func, Closure)
+            and not any(
+                isinstance(param_decl, QuantumOperandDeclaration)
+                for param_decl in orig_func.positional_arg_declarations
+            )
+        )
 
     @staticmethod
-    def _update_type_qualifiers(func_def: NativeFunctionDefinition) -> None:
+    def _override_type_qualifiers(func_def: NativeFunctionDefinition) -> None:
         # only override the qualifier if it's unspecified (not QFree or Const)
         for port in func_def.port_declarations:
             if port.type_qualifier is TypeQualifier.Quantum:
                 port.type_qualifier = TypeQualifier.Inferred
-        TypeQualifierInference().run(func_def.port_declarations, func_def.body)

classiq/model_expansions/quantum_operations/emitter.py

@@ -184,6 +184,8 @@ class Emitter(Generic[QuantumStatementT], ABC):
     def _update_captured_classical_vars_in_expression(self, expr: Expression) -> None:
         for var_name, var_type in self._get_classical_vars_in_expression(expr):
             self._capture_classical_var(var_name, var_type)
+        for handle in self._get_quantum_type_attributes_in_expression(expr):
+            self._capture_quantum_type_attribute(handle)
 
     def _update_captured_vars(self, op: QuantumOperation) -> None:
         for handle, direction in op.handles_with_directions:
@@ -223,6 +225,17 @@ class Emitter(Generic[QuantumStatementT], ABC):
             defining_function=defining_function,
         )
 
+    def _capture_quantum_type_attribute(self, handle: FieldHandleBinding) -> None:
+        if handle.name not in self._current_scope:
+            return
+        defining_function = self._current_scope[handle.name].defining_function
+        if defining_function is None:
+            raise ClassiqInternalExpansionError
+        self._builder.current_block.captured_vars.capture_quantum_type_attribute(
+            handle=handle,
+            defining_function=defining_function,
+        )
+
     def _get_symbols_in_expression(self, expr: Expression) -> list[QuantumSymbol]:
         vrc = VarRefCollector(ignore_duplicated_handles=True, unevaluated=True)
         vrc.visit(ast.parse(expr.expr))
@@ -258,3 +271,18 @@ class Emitter(Generic[QuantumStatementT], ABC):
                 )
             }.items()
         )
+
+    def _get_quantum_type_attributes_in_expression(
+        self, expr: Expression
+    ) -> list[FieldHandleBinding]:
+        vrc = VarRefCollector(ignore_duplicated_handles=True, unevaluated=True)
+        vrc.visit(ast.parse(expr.expr))
+        return list(
+            dict.fromkeys(
+                handle
+                for handle in vrc.var_handles
+                if isinstance(handle, FieldHandleBinding)
+                and handle.field in CLASSICAL_ATTRIBUTES
+                and isinstance(self._current_scope[handle.name].value, QuantumSymbol)
+            )
+        )

classiq/model_expansions/quantum_operations/function_calls_cache.py

@@ -11,10 +11,6 @@ from classiq.interface.generator.expressions.proxies.classical.classical_struct_
 from classiq.interface.generator.expressions.proxies.classical.utils import (
     get_proxy_type,
 )
-from classiq.interface.generator.functions.port_declaration import (
-    PortDeclarationDirection,
-)
-from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_declaration import (
     NamedParamsQuantumFunctionDeclaration,
 )
@@ -36,18 +32,7 @@ def get_func_call_cache_key(
         raise ClassiqInternalExpansionError(
             "Mismatch between number of args to number of arg declarations"
         )
-
-    # output arguments cannot affect the morphization of the function, as their
-    # attributes are defined locally by the function, according to other arguments
-    non_outputs_args = [
-        arg
-        for arg_decl, arg in zip(decl.positional_arg_declarations, args)
-        if not (
-            isinstance(arg_decl, PortDeclaration)
-            and arg_decl.direction is PortDeclarationDirection.Output
-        )
-    ]
-    return f"{decl.name}__{_evaluated_args_to_str(non_outputs_args)}"
+    return f"{decl.name}__{_evaluated_args_to_str(args)}"
 
 
 def _evaluated_args_to_str(evaluated_args: list[Evaluated]) -> str: