classiq 0.77.0__py3-none-any.whl → 0.79.0__py3-none-any.whl

classiq/model_expansions/quantum_operations/bounds.py

@@ -0,0 +1,30 @@
+from typing import TYPE_CHECKING
+
+from classiq.interface.exceptions import ClassiqExpansionError
+from classiq.interface.model.bounds import SetBoundsStatement
+
+from classiq.model_expansions.quantum_operations.bind import Emitter
+from classiq.model_expansions.scope import QuantumSymbol
+from classiq.qmod.qmod_variable import QuantumNumeric
+
+if TYPE_CHECKING:
+    from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
+
+
+class SetBoundsEmitter(Emitter[SetBoundsStatement]):
+    def __init__(
+        self, interpreter: "BaseInterpreter", keep_statement: bool = True
+    ) -> None:
+        super().__init__(interpreter)
+        self._keep_statement = keep_statement
+
+    def emit(self, op: SetBoundsStatement, /) -> bool:
+        target = self._interpreter.evaluate(op.target).as_type(QuantumSymbol)
+        if not isinstance(target.quantum_type, QuantumNumeric):
+            raise ClassiqExpansionError(
+                f"Cannot set bounds of a non-numeric variable {op.target.qmod_expr!r}"
+            )
+        target.quantum_type.set_bounds(op.bounds)
+        if self._keep_statement:
+            self.emit_statement(op)
+        return True

classiq/model_expansions/quantum_operations/call_emitter.py

@@ -28,16 +28,20 @@ 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.helpers.backward_compatibility import zip_strict
 from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
 )
 from classiq.interface.model.handle_binding import HandleBinding
+from classiq.interface.model.model import MAIN_FUNCTION_NAME
 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 (
     NamedParamsQuantumFunctionDeclaration,
     PositionalArg,
+    QuantumOperandDeclaration,
 )
 from classiq.interface.model.quantum_statement import QuantumStatement
 from classiq.interface.model.variable_declaration_statement import (
@@ -49,9 +53,10 @@ from classiq.model_expansions.capturing.captured_vars import (
     UNINITIALIZED_VAR_MESSAGE,
     validate_args_are_not_propagated,
 )
-from classiq.model_expansions.closure import FunctionClosure
+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,
@@ -63,6 +68,9 @@ from classiq.model_expansions.quantum_operations.emitter import (
     Emitter,
     QuantumStatementT,
 )
+from classiq.model_expansions.quantum_operations.function_calls_cache import (
+    get_func_call_cache_key,
+)
 from classiq.model_expansions.scope import (
     Evaluated,
     QuantumSymbol,
@@ -70,8 +78,12 @@ from classiq.model_expansions.scope import (
     QuantumVariable,
     Scope,
 )
+from classiq.model_expansions.transformers.type_qualifier_inference import (
+    TypeQualifierInference,
+)
 from classiq.model_expansions.transformers.var_splitter import VarSplitter
 from classiq.model_expansions.utils.text_utils import are, readable_list, s
+from classiq.qmod.pretty_print.expression_to_python import transform_expression
 from classiq.qmod.semantics.validation.signature_validation import (
     validate_function_signature,
 )
@@ -114,6 +126,24 @@ def _is_symbolic(arg: Any) -> bool:
     return False
 
 
+def _validate_gen_args(
+    function: FunctionClosure, evaluated_args: list[Evaluated]
+) -> None:
+    for param, arg in zip_strict(
+        function.positional_arg_declarations, evaluated_args, strict=True
+    ):
+        if (
+            isinstance(param, ClassicalParameterDeclaration)
+            and param.classical_type.is_purely_generative
+            and _is_symbolic(arg.value)
+        ):
+            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}"
+            )
+
+
 class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSplitter):
     def __init__(self, interpreter: "BaseInterpreter") -> None:
         Emitter.__init__(self, interpreter)
@@ -174,22 +204,38 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         )
         new_positional_arg_decls = new_declaration.positional_arg_declarations
         if not self.should_expand_function(function, evaluated_args):
-            is_atomic = True
             new_declaration = self._expanded_functions_by_name.get(
                 function.name, new_declaration
             )
         else:
-            is_atomic = False
+            # FIXME: enable for BE (CLS-2390)
+            if type(self._interpreter).__name__ == "FrontendGenerativeInterpreter":
+                _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)
+            ]
 
-        new_positional_args = self._get_new_positional_args(
-            evaluated_args, is_atomic, new_positional_arg_decls
-        )
+        add_information_from_output_arguments(new_positional_arg_decls, evaluated_args)
+        handle_args_numeric_bounds(new_positional_arg_decls, evaluated_args)
         captured_args = function.captured_vars.filter_vars(function).get_captured_args(
             self._builder.current_function
         )
+        new_positional_args = [
+            arg.emit(param)
+            for param, arg in zip_strict(
+                new_positional_arg_decls[
+                    : len(new_positional_arg_decls) - len(captured_args)
+                ],
+                evaluated_args,
+                strict=True,
+            )
+        ]
         validate_args_are_not_propagated(
             new_positional_args,
             captured_args,
@@ -228,19 +274,23 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         decl: NamedParamsQuantumFunctionDeclaration,
         function: FunctionClosure,
     ) -> NamedParamsQuantumFunctionDeclaration:
-        self._add_params_to_scope(decl.positional_arg_declarations, args, function)
-        context = self._expand_operation(function.with_new_declaration(decl))
-        function_context = cast(FunctionContext, context)
-        closure_id = function_context.closure.closure_id
-        if closure_id in self._expanded_functions:
-            function_def = self._expanded_functions[closure_id]
+        inferred_args = self._add_params_to_scope(
+            decl.positional_arg_declarations, args, function
+        )
+        function = function.with_new_declaration(decl)
+        cache_key = get_func_call_cache_key(decl, inferred_args)
+        if cache_key in self._expanded_functions:
+            function_def = self._expanded_functions[cache_key]
+            self._expand_cached_function(function, function_def)
             self._expanded_functions_compilation_metadata[
                 function_def.name
             ].occurrences_number += 1
             return function_def
 
+        context = self._expand_operation(function)
+        function_context = cast(FunctionContext, context)
         function_def = self._create_function_definition(function_context, args)
-        self._expanded_functions[closure_id] = 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)
         )
@@ -270,6 +320,7 @@ 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))
@@ -281,6 +332,8 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
             rewrite_mapping |= captured_vars.get_classical_captured_mapping()
         func_def.body = self.rewrite(func_def.body, rewrite_mapping)
 
+        self._override_type_qualifier(function_context, func_def)
+
         return func_def
 
     @staticmethod
@@ -288,12 +341,13 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         parameters: Sequence[PositionalArg],
         arguments: Sequence[Evaluated],
         closure: FunctionClosure,
-    ) -> None:
+    ) -> list[Evaluated]:
+        inferred_args: list[Evaluated] = []
         for parameter, argument in zip(parameters, arguments):
             param_handle = HandleBinding(name=parameter.name)
             if isinstance(argument.value, QuantumVariable):
                 assert isinstance(parameter, PortDeclaration)
-                closure.scope[parameter.name] = Evaluated(
+                inferred_arg = Evaluated(
                     QuantumSymbol(
                         handle=param_handle,
                         quantum_type=parameter.quantum_type,
@@ -302,32 +356,15 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
                 )
             elif _is_symbolic(argument.value):
                 assert isinstance(parameter, ClassicalParameterDeclaration)
-                closure.scope[parameter.name] = Evaluated(
+                inferred_arg = Evaluated(
                     value=parameter.classical_type.get_classical_proxy(param_handle),
                     defining_function=closure,
                 )
             else:
-                closure.scope[parameter.name] = argument
-
-    def _get_new_positional_args(
-        self,
-        evaluated_args: list[Evaluated],
-        is_atomic: bool,
-        new_positional_arg_decls: Sequence[PositionalArg],
-    ) -> list[ArgValue]:
-        evaluated_args = add_information_from_output_arguments(
-            new_positional_arg_decls, evaluated_args
-        )
-        if is_atomic:
-            return [arg.emit() for arg in evaluated_args]
-
-        positional_args = [
-            arg.emit()
-            for arg in evaluated_args
-            if isinstance(arg.value, QuantumVariable) or _is_symbolic(arg.value)
-        ]
-
-        return positional_args
+                inferred_arg = argument
+            closure.scope[parameter.name] = inferred_arg
+            inferred_args.append(inferred_arg)
+        return inferred_args
 
     def _prepare_fully_typed_declaration(
         self, function: FunctionClosure, evaluated_args: list[Evaluated]
@@ -381,3 +418,45 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
                 raise ClassiqExpansionError(UNINITIALIZED_VAR_MESSAGE.format(var_name))
             if var_state and param.direction == PortDeclarationDirection.Output:
                 raise ClassiqExpansionError(INITIALIZED_VAR_MESSAGE.format(var_name))
+
+    def _override_type_qualifier(
+        self, func_context: FunctionContext, func_def: NativeFunctionDefinition
+    ) -> None:
+        """
+        The type qualifier 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(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
+        Const), neither in the function declaration nor in the operand declaration.
+        """
+
+        if func_context.is_lambda:
+            self._update_type_qualifiers(func_def)
+            return
+
+        orig_name = func_context.name
+        if (
+            orig_name == MAIN_FUNCTION_NAME
+            or orig_name not in func_context.closure.scope
+        ):
+            return
+
+        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)
+
+    @staticmethod
+    def _update_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

@@ -47,7 +47,7 @@ from classiq.interface.model.quantum_function_declaration import (
 )
 from classiq.interface.model.quantum_statement import QuantumOperation, QuantumStatement
 
-from classiq.model_expansions.closure import Closure, GenerativeClosure
+from classiq.model_expansions.closure import Closure, FunctionClosure, GenerativeClosure
 from classiq.model_expansions.function_builder import (
     OperationBuilder,
     OperationContext,
@@ -87,6 +87,11 @@ class Emitter(Generic[QuantumStatementT], ABC):
     def _expand_operation(self, closure: Closure) -> OperationContext:
         return self._interpreter._expand_operation(closure)
 
+    def _expand_cached_function(
+        self, closure: FunctionClosure, func_def: NativeFunctionDefinition
+    ) -> None:
+        return self._interpreter._expand_cached_function(closure, func_def)
+
     @property
     def _builder(self) -> OperationBuilder:
         return self._interpreter._builder

classiq/model_expansions/quantum_operations/function_calls_cache.py

@@ -0,0 +1,91 @@
+import json
+from typing import Any
+
+from classiq.interface.exceptions import ClassiqInternalExpansionError
+from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
+    ClassicalProxy,
+)
+from classiq.interface.generator.expressions.proxies.classical.classical_struct_proxy import (
+    ClassicalStructProxy,
+)
+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,
+)
+from classiq.interface.model.quantum_type import QuantumNumeric
+
+from classiq.model_expansions.closure import FunctionClosure
+from classiq.model_expansions.scope import (
+    Evaluated,
+    QuantumSymbol,
+    evaluated_to_str as evaluated_classical_param_to_str,
+)
+
+
+def get_func_call_cache_key(
+    decl: NamedParamsQuantumFunctionDeclaration,
+    args: list[Evaluated],
+) -> str:
+    if len(decl.positional_arg_declarations) != len(args):
+        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)}"
+
+
+def _evaluated_args_to_str(evaluated_args: list[Evaluated]) -> str:
+    args_signature = [
+        _evaluated_arg_to_str(eval_arg.value) for eval_arg in evaluated_args
+    ]
+    return json.dumps(args_signature)
+
+
+def _evaluated_arg_to_str(arg: Any) -> str:
+    if isinstance(arg, str):
+        return arg
+    if isinstance(arg, QuantumSymbol):
+        return _evaluated_quantum_symbol_to_str(arg)
+    if isinstance(arg, FunctionClosure):
+        return _evaluated_one_operand_to_str(arg)
+    if isinstance(arg, list) and arg and isinstance(arg[0], FunctionClosure):
+        return _evaluated_operands_list_to_str(arg)
+    if isinstance(arg, ClassicalProxy):
+        if isinstance(arg, ClassicalStructProxy):
+            return repr(arg.struct_declaration)
+        return repr(get_proxy_type(arg))
+    return evaluated_classical_param_to_str(arg)
+
+
+def _evaluated_quantum_symbol_to_str(port: QuantumSymbol) -> str:
+    res = port.quantum_type.model_dump_json(exclude_none=True, exclude={"name"})
+    if (
+        isinstance(port.quantum_type, QuantumNumeric)
+        and (bounds := port.quantum_type.get_bounds()) is not None
+    ):
+        res += f"_{float(bounds[0])}_{float(bounds[1])}"
+    return res
+
+
+def _evaluated_one_operand_to_str(operand: FunctionClosure) -> str:
+    return operand.name
+
+
+def _evaluated_operands_list_to_str(arg: list[FunctionClosure]) -> str:
+    return json.dumps([_evaluated_one_operand_to_str(ope) for ope in arg])

classiq/model_expansions/quantum_operations/quantum_function_call.py

@@ -1,10 +1,9 @@
 from typing import TYPE_CHECKING
 
+import sympy
+
 from classiq.interface.exceptions import ClassiqInternalExpansionError
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.expressions.proxies.classical.classical_scalar_proxy import (
-    ClassicalScalarProxy,
-)
 from classiq.interface.model.classical_if import ClassicalIf
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_lambda_function import OperandIdentifier
@@ -29,7 +28,7 @@ class QuantumFunctionCallEmitter(CallEmitter[QuantumFunctionCall]):
     def emit(self, call: QuantumFunctionCall, /) -> bool:
         if isinstance(call.function, OperandIdentifier):
             index_val = self._interpreter.evaluate(call.function.index).value
-            if isinstance(index_val, ClassicalScalarProxy):
+            if isinstance(index_val, sympy.Basic):
                 return self._emit_symbolic_lambda_list(call, index_val)
         function = self._interpreter.evaluate(call.function).as_type(FunctionClosure)
         args = call.positional_args
@@ -40,7 +39,7 @@ class QuantumFunctionCallEmitter(CallEmitter[QuantumFunctionCall]):
         return True
 
     def _emit_symbolic_lambda_list(
-        self, call: QuantumFunctionCall, index: ClassicalScalarProxy
+        self, call: QuantumFunctionCall, index: sympy.Basic
     ) -> bool:
         if TYPE_CHECKING:
             assert isinstance(call.function, OperandIdentifier)
@@ -55,7 +54,7 @@ class QuantumFunctionCallEmitter(CallEmitter[QuantumFunctionCall]):
 
     @staticmethod
     def _create_recursive_if(
-        call: QuantumFunctionCall, index: ClassicalScalarProxy, num_funcs: int
+        call: QuantumFunctionCall, index: sympy.Basic, num_funcs: int
     ) -> list[QuantumStatement]:
         if TYPE_CHECKING:
             assert isinstance(call.function, OperandIdentifier)

classiq/model_expansions/scope.py

@@ -3,7 +3,9 @@ from collections import UserDict
 from collections.abc import Iterator
 from dataclasses import dataclass
 from functools import singledispatch
-from typing import TYPE_CHECKING, Any, Optional, TypeVar, Union
+from typing import TYPE_CHECKING, Any, NoReturn, Optional, TypeVar, Union
+
+import sympy
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
@@ -29,11 +31,18 @@ from classiq.interface.model.handle_binding import (
     SubscriptHandleBinding,
 )
 from classiq.interface.model.quantum_function_call import ArgValue
+from classiq.interface.model.quantum_function_declaration import (
+    AnonPositionalArg,
+    AnonQuantumOperandDeclaration,
+)
 from classiq.interface.model.quantum_type import (
     QuantumBitvector,
+    QuantumNumeric,
     QuantumType,
 )
 
+from classiq.model_expansions.utils.text_utils import readable_list, s
+
 if TYPE_CHECKING:
     from classiq.model_expansions.closure import FunctionClosure
 
@@ -180,6 +189,9 @@ class QuantumSymbolList(QuantumVariable):
             length = Expression(
                 expr=str(sum(symbol.quantum_type.size_in_bits for symbol in symbols))
             )
+        for symbol in symbols:
+            if isinstance(symbol.quantum_type, QuantumNumeric):
+                symbol.quantum_type.reset_bounds()
         return QuantumSymbolList(
             handles=handles, quantum_type=QuantumBitvector(length=length)
         )
@@ -206,37 +218,45 @@ def _evaluated_to_str_struct_literal(value: QmodStructInstance) -> str:
     return f"struct_literal({value.struct_declaration.name}, {', '.join(f'{k}={evaluated_to_str(v)}' for k, v in value.fields.items())})"
 
 
+def _raise_type_error(val: Any, t: type, location_hint: Optional[str]) -> NoReturn:
+    if isinstance(val, sympy.Basic) and len(val.free_symbols) > 0:
+        symbolic_vars = sorted(map(str, val.free_symbols))
+        suffix = f" {location_hint}" if location_hint is not None else ""
+        raise ClassiqExpansionError(
+            f"Cannot use execution parameter{s(symbolic_vars)} {readable_list(symbolic_vars, quote=True)} in a compile-time context{suffix}"
+        )
+    raise ClassiqExpansionError(f"Invalid access to expression {val!r} as {t}")
+
+
 @dataclass(frozen=True)
 class Evaluated:  # FIXME: Merge with EvaluatedExpression if possible
     value: Any
     defining_function: Optional["FunctionClosure"] = None
 
-    def as_type(self, t: type[T]) -> T:
+    def as_type(self, t: type[T], location_hint: Optional[str] = None) -> T:
         if t is int:
-            return self._as_int()  # type: ignore[return-value]
+            return self._as_int(location_hint)  # type: ignore[return-value]
 
         if not isinstance(self.value, t):
-            raise ClassiqExpansionError(
-                f"Invalid access to expression {self.value!r} as {t}"
-            )
+            _raise_type_error(self.value, t, location_hint)
 
         return self.value
 
-    def _as_int(self) -> int:
+    def _as_int(self, location_hint: Optional[str]) -> int:
         if not isinstance(self.value, (int, float)):
-            raise ClassiqExpansionError(
-                f"Invalid access to expression {self.value!r} as {int}"
-            )
+            _raise_type_error(self.value, int, location_hint)
 
         return int(self.value)
 
-    def emit(self) -> ArgValue:
+    def emit(self, param: Optional[AnonPositionalArg] = None) -> ArgValue:
         from classiq.model_expansions.closure import FunctionClosure
 
         if isinstance(self.value, (QuantumVariable, FunctionClosure)):
             return self.value.emit()
-        if isinstance(self.value, list) and all(
-            isinstance(item, FunctionClosure) for item in self.value
+        if (
+            isinstance(param, AnonQuantumOperandDeclaration)
+            and isinstance(self.value, list)
+            and all(isinstance(item, FunctionClosure) for item in self.value)
         ):
             return [item.emit() for item in self.value]
 

classiq/model_expansions/scope_initialization.py

@@ -1,12 +1,7 @@
 from collections.abc import Sequence
 
-from classiq.interface.exceptions import ClassiqError, ClassiqInternalExpansionError
+from classiq.interface.exceptions import ClassiqError
 from classiq.interface.generator.constant import Constant
-from classiq.interface.generator.functions.classical_type import (
-    ClassicalArray,
-    ClassicalList,
-)
-from classiq.interface.generator.functions.concrete_types import ConcreteClassicalType
 from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
 )
@@ -138,11 +133,3 @@ def init_top_level_scope(model: Model, scope: Scope) -> None:
 def init_builtin_types() -> None:
     QMODULE.enum_decls |= BUILTIN_ENUM_DECLARATIONS
     QMODULE.type_decls |= BUILTIN_STRUCT_DECLARATIONS
-
-
-def _get_shape(classical_type: ConcreteClassicalType) -> tuple[int, ...]:
-    if isinstance(classical_type, ClassicalList):
-        raise ClassiqInternalExpansionError("Unexpected classical list")
-    if isinstance(classical_type, ClassicalArray):
-        return classical_type.size, *_get_shape(classical_type.element_type)
-    return ()