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

classiq/model_expansions/closure.py

@@ -1,22 +1,11 @@
 import dataclasses
-import json
-from collections.abc import Collection, Sequence
+from collections.abc import Sequence
 from dataclasses import dataclass, field
-from functools import singledispatch
 from typing import Any, Optional
 
 from typing_extensions import Self
 
 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.helpers.pydantic_model_helpers import nameables_to_dict
 from classiq.interface.model.quantum_function_declaration import (
     NamedParamsQuantumFunctionDeclaration,
@@ -27,10 +16,7 @@ from classiq.interface.model.quantum_statement import QuantumStatement
 
 from classiq.model_expansions.capturing.captured_vars import CapturedVars
 from classiq.model_expansions.scope import (
-    Evaluated,
-    QuantumSymbol,
     Scope,
-    evaluated_to_str as evaluated_classical_param_to_str,
 )
 from classiq.qmod.builtins.functions import permute
 from classiq.qmod.quantum_function import GenerativeQFunc
@@ -67,13 +53,6 @@ class FunctionClosure(Closure):
             raise ClassiqInternalExpansionError
         return self._depth
 
-    # creates a unique id for the function closure based on the arguments values.
-    # The closure is changing across the interpreter flow so it's closure_id may change
-    @property
-    def closure_id(self) -> str:
-        signature = _generate_closure_id(self.scope.data.values())
-        return f"{self.name}__{signature}"
-
     @property
     def body(self) -> Sequence[QuantumStatement]:
         if self.name == permute.func_decl.name:
@@ -134,39 +113,3 @@ class FunctionClosure(Closure):
 @dataclass(frozen=True)
 class GenerativeFunctionClosure(GenerativeClosure, FunctionClosure):
     pass
-
-
-def _generate_closure_id(evaluated_args: Collection[Evaluated]) -> str:
-    args_signature = [
-        _evaluated_arg_to_str(eval_arg.value) for eval_arg in evaluated_args
-    ]
-    return json.dumps(args_signature)
-
-
-@singledispatch
-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:
-    return port.quantum_type.model_dump_json(exclude_none=True, exclude={"name"})
-
-
-def _evaluated_one_operand_to_str(operand: FunctionClosure) -> str:
-    return operand.closure_id
-
-
-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/evaluators/argument_types.py

@@ -13,7 +13,7 @@ from classiq.model_expansions.scope import Evaluated, QuantumVariable
 def add_information_from_output_arguments(
     parameters: Sequence[AnonPositionalArg],
     args: list[Evaluated],
-) -> list[Evaluated]:
+) -> None:
     """
     This function propagates the quantum type information from the output arguments
     to the arguments that were passed to it.
@@ -40,4 +40,3 @@ def add_information_from_output_arguments(
                 argument_as_quantum_symbol.quantum_type,
                 str(argument_as_quantum_symbol),
             )
-    return args

classiq/model_expansions/function_builder.py

@@ -11,15 +11,12 @@ from classiq.interface.generator.compiler_keywords import (
 from classiq.interface.generator.functions.builtins.internal_operators import (
     WITHIN_APPLY_NAME,
 )
-from classiq.interface.generator.functions.type_qualifier import TypeQualifier
 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_declaration import (
     PositionalArg,
-    QuantumOperandDeclaration,
 )
 from classiq.interface.model.quantum_statement import QuantumStatement
 from classiq.interface.model.variable_declaration_statement import (
@@ -215,7 +212,6 @@ class OperationBuilder:
         self, function_context: FunctionContext, params: Sequence[PositionalArg]
     ) -> NativeFunctionDefinition:
         name = self._get_expanded_function_name(function_context)
-        self._override_type_qualifier(function_context, params)
 
         return NativeFunctionDefinition(
             name=name,
@@ -248,44 +244,3 @@ class OperationBuilder:
             raise ClassiqInternalExpansionError("Could not allocate function name")
 
         return name
-
-    def _override_type_qualifier(
-        self, function_context: FunctionContext, params: Sequence[PositionalArg]
-    ) -> 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 function_context.is_lambda:
-            self._update_type_qualifiers(params)
-            return
-
-        orig_name = function_context.name
-        if orig_name == MAIN_FUNCTION_NAME or orig_name not in self.current_scope:
-            return
-
-        orig_func = self.current_scope[orig_name].value
-        if not any(
-            isinstance(param_decl, QuantumOperandDeclaration)
-            for param_decl in orig_func.positional_arg_declarations
-        ):
-            return
-
-        self._update_type_qualifiers(params)
-
-    @staticmethod
-    def _update_type_qualifiers(params: Sequence[PositionalArg]) -> None:
-        # only override the qualifier if it's unspecified (not QFree or Const)
-        for param in params:
-            if (
-                isinstance(param, PortDeclaration)
-                and param.type_qualifier is TypeQualifier.Quantum
-            ):
-                param.type_qualifier = TypeQualifier.Inferred

classiq/model_expansions/interpreters/base_interpreter.py

@@ -104,10 +104,8 @@ class BaseInterpreter:
             main_closure.positional_arg_declarations, main_closure
         )
         context = self._expand_operation(main_closure)
-        self._expanded_functions[main_closure.closure_id] = (
-            self._builder.create_definition(
-                cast(FunctionContext, context), main_closure.positional_arg_declarations
-            )
+        self._expanded_functions[main_closure.name] = self._builder.create_definition(
+            cast(FunctionContext, context), main_closure.positional_arg_declarations
         )
 
     def _get_main_closure(self, main_func: FunctionClosure) -> FunctionClosure:
@@ -275,19 +273,19 @@ class BaseInterpreter:
 
     def _expand_operation(self, operation: Closure) -> OperationContext:
         with self._builder.operation_context(operation) as context:
-            if isinstance(operation, FunctionClosure) and (
-                (func_def := self._expanded_functions.get(operation.closure_id))
-                is not None
-            ):
-                cached_closure = self._top_level_scope[func_def.name].value
-                operation.captured_vars.set(
-                    cached_closure.captured_vars, cached_closure, operation
-                )
-            else:
-                self._expand_body(operation)
+            self._expand_body(operation)
 
         return context
 
+    def _expand_cached_function(
+        self, operation: FunctionClosure, func_def: NativeFunctionDefinition
+    ) -> None:
+        with self._builder.operation_context(operation):
+            cached_closure = self._top_level_scope[func_def.name].value
+            operation.captured_vars.set(
+                cached_closure.captured_vars, cached_closure, operation
+            )
+
     def _expand_body(self, operation: Closure) -> None:
         for block, block_body in operation.blocks.items():
             self._expand_block(block_body, block)

classiq/model_expansions/interpreters/frontend_generative_interpreter.py

@@ -1,17 +1,12 @@
 import inspect
 import os
-from typing import Optional
 
 from pydantic import ValidationError
 
 from classiq.interface.exceptions import ClassiqError
 from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.bind_operation import BindOperation
-from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
-from classiq.interface.model.quantum_function_declaration import (
-    NamedParamsQuantumFunctionDeclaration,
-)
 from classiq.interface.source_reference import SourceReference
 
 from classiq.model_expansions.closure import FunctionClosure, GenerativeFunctionClosure
@@ -24,22 +19,10 @@ from classiq.model_expansions.quantum_operations.quantum_function_call import (
     DeclarativeQuantumFunctionCallEmitter,
 )
 from classiq.model_expansions.scope import Scope
-from classiq.model_expansions.visitors.symbolic_param_inference import (
-    SymbolicParamInference,
-)
 from classiq.qmod.model_state_container import QMODULE
 
 
 class FrontendGenerativeInterpreter(GenerativeInterpreter):
-    def infer_symbolic_parameters(
-        self,
-        functions: list[NativeFunctionDefinition],
-        additional_signatures: Optional[
-            list[NamedParamsQuantumFunctionDeclaration]
-        ] = None,
-    ) -> None:
-        SymbolicParamInference(functions, additional_signatures).infer()
-
     def emit_allocate(self, allocate: Allocate) -> None:
         AllocateEmitter(self, allow_symbolic_size=True).emit(allocate)
 

classiq/model_expansions/quantum_operations/call_emitter.py

@@ -28,16 +28,19 @@ 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.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,7 +52,7 @@ 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,
 )
@@ -63,6 +66,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,6 +76,9 @@ 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.semantics.validation.signature_validation import (
@@ -174,19 +183,22 @@ 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
             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)
+        new_positional_args = [arg.emit() for arg in evaluated_args]
         captured_args = function.captured_vars.filter_vars(function).get_captured_args(
             self._builder.current_function
         )
@@ -229,18 +241,20 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         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]
+        function = function.with_new_declaration(decl)
+        cache_key = get_func_call_cache_key(decl, 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 +284,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 +296,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
@@ -309,26 +326,6 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
             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
-
     def _prepare_fully_typed_declaration(
         self, function: FunctionClosure, evaluated_args: list[Evaluated]
     ) -> NamedParamsQuantumFunctionDeclaration:
@@ -381,3 +378,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,84 @@
+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.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:
+    return port.quantum_type.model_dump_json(exclude_none=True, exclude={"name"})
+
+
+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/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,
@@ -34,6 +36,8 @@ from classiq.interface.model.quantum_type import (
     QuantumType,
 )
 
+from classiq.model_expansions.utils.text_utils import readable_list, s
+
 if TYPE_CHECKING:
     from classiq.model_expansions.closure import FunctionClosure
 
@@ -206,27 +210,33 @@ 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 = list(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)