classiq 0.60.0__py3-none-any.whl → 0.61.0__py3-none-any.whl

classiq/model_expansions/expression_evaluator.py

@@ -1,4 +1,5 @@
 import ast
+import re
 from collections.abc import Mapping
 from enum import EnumMeta
 from typing import Any, Optional
@@ -12,7 +13,7 @@ from classiq.interface.generator.expressions.evaluated_expression import (
 )
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.expressions.expression_constants import (
-    CPARAM_EXECUTION_SUFFIX,
+    CPARAM_EXECUTION_SUFFIX_PATTERN,
 )
 from classiq.interface.generator.expressions.expression_types import ExpressionValue
 from classiq.interface.generator.expressions.sympy_supported_expressions import (
@@ -99,7 +100,9 @@ def _validate_undefined_vars(
 
     # Ignore expanded execution parameters
     undefined_vars = {
-        var for var in undefined_vars if not var.endswith(CPARAM_EXECUTION_SUFFIX)
+        var
+        for var in undefined_vars
+        if not re.search(CPARAM_EXECUTION_SUFFIX_PATTERN, var)
     }
 
     if len(undefined_vars) == 1:

classiq/model_expansions/function_builder.py

@@ -20,6 +20,9 @@ from classiq.interface.model.quantum_function_declaration import (
     PositionalArg,
 )
 from classiq.interface.model.quantum_statement import QuantumStatement
+from classiq.interface.model.variable_declaration_statement import (
+    VariableDeclarationStatement,
+)
 from classiq.interface.source_reference import SourceReference
 
 from classiq.model_expansions.capturing.captured_vars import (
@@ -37,6 +40,14 @@ class Block:
     statements: list[QuantumStatement] = field(default_factory=list)
     captured_vars: CapturedVars = field(default_factory=CapturedVars)
 
+    @property
+    def variable_declarations(self) -> list[VariableDeclarationStatement]:
+        return [
+            stmt
+            for stmt in self.statements
+            if isinstance(stmt, VariableDeclarationStatement)
+        ]
+
 
 @dataclass
 class OperationContext(Generic[ClosureType]):
@@ -123,9 +134,13 @@ class OperationBuilder:
             not isinstance(self.current_operation, FunctionClosure)
             and self.current_operation.name != WITHIN_APPLY_NAME
         ):
-            validate_captured_directions(captured_vars)
+            validate_captured_directions(
+                captured_vars.filter_vars(
+                    self.current_function, self.current_block.variable_declarations
+                )
+            )
         self.current_operation.captured_vars.update(
-            captured_vars.filter(self.current_function)
+            captured_vars.filter_vars(self.current_function)
         )
         self._blocks.pop()
 
@@ -149,7 +164,7 @@ class OperationBuilder:
             return
         within_captured_vars = self._operations[-1].blocks["within"].captured_vars
         self.current_operation.captured_vars.update(
-            within_captured_vars.filter(self.current_function).negate()
+            within_captured_vars.filter_vars(self.current_function).negate()
         )
 
     def _propagate_captured_vars(self) -> None:
@@ -160,7 +175,9 @@ class OperationBuilder:
         if len(self._operations) < 2:
             return
         parent_block = self._operations[-2].blocks[self._blocks[-1]]
-        parent_block.captured_vars.update(captured_vars.filter(self.parent_function))
+        parent_block.captured_vars.update(
+            captured_vars.filter_vars(self.parent_function)
+        )
 
     @contextmanager
     def source_ref_context(

classiq/model_expansions/generative_functions.py

@@ -1,31 +1,23 @@
 from collections.abc import Mapping
 from typing import TYPE_CHECKING, Any
 
-from classiq.interface.exceptions import ClassiqInternalExpansionError
 from classiq.interface.generator.expressions.qmod_struct_instance import (
     QmodStructInstance,
 )
 from classiq.interface.generator.functions.type_name import Struct
-from classiq.interface.generator.visitor import Visitor
 from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
 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 (
     PositionalArg,
     QuantumFunctionDeclaration,
     QuantumOperandDeclaration,
 )
-from classiq.interface.model.quantum_lambda_function import (
-    QuantumCallable,
-    QuantumLambdaFunction,
-)
 from classiq.interface.model.quantum_statement import QuantumStatement
 
 from classiq.model_expansions.closure import (
     FunctionClosure,
     GenerativeClosure,
-    GenerativeFunctionClosure,
 )
 from classiq.model_expansions.scope import Evaluated, QuantumSymbol
 from classiq.qmod.generative import generative_mode_context, set_frontend_interpreter
@@ -35,7 +27,6 @@ from classiq.qmod.qmod_variable import QNum, _create_qvar_for_qtype
 from classiq.qmod.quantum_callable import QCallable
 from classiq.qmod.quantum_expandable import (
     QExpandable,
-    QLambdaFunction,
     QTerminalCallable,
 )
 from classiq.qmod.quantum_function import QFunc
@@ -71,12 +62,18 @@ def translate_ast_arg_to_python_qmod(param: PositionalArg, evaluated: Evaluated)
         )
     if isinstance(param, QuantumOperandDeclaration):
         if param.is_list:
-            return QTerminalCallable(
-                QuantumOperandDeclaration(
-                    name=param.name,
-                    positional_arg_declarations=param.positional_arg_declarations,
-                    is_list=True,
-                ),
+            func_list: list[FunctionClosure] = evaluated.as_type(list)
+            return LenList(
+                [
+                    QTerminalCallable(
+                        QuantumOperandDeclaration(
+                            name=param.name,
+                            positional_arg_declarations=param.positional_arg_declarations,
+                        ),
+                        index_=idx,
+                    )
+                    for idx in range(len(func_list))
+                ]
             )
         else:
             func = evaluated.as_type(FunctionClosure)
@@ -143,78 +140,3 @@ def emit_generative_statements(
             True
         ):
             generative_function._py_callable(*python_qmod_args)
-
-
-def emit_operands_as_declarative(
-    interpreter: "Interpreter", param: PositionalArg, arg: Evaluated
-) -> ArgValue:
-    if not isinstance(param, QuantumOperandDeclaration):
-        return arg.emit()
-    value = arg.value
-    if isinstance(value, list):
-        return [
-            _expand_operand_as_declarative(interpreter, param, item) for item in value
-        ]
-    if isinstance(value, GenerativeFunctionClosure):
-        return _expand_operand_as_declarative(interpreter, param, value)
-    if isinstance(value, FunctionClosure):
-        if value.is_lambda:
-            raise ClassiqInternalExpansionError
-        _register_declarative_function(interpreter, value.name)
-        return value.name
-    raise ClassiqInternalExpansionError
-
-
-def _expand_operand_as_declarative(
-    interpreter: "Interpreter",
-    param: QuantumOperandDeclaration,
-    arg: GenerativeFunctionClosure,
-) -> QuantumCallable:
-    if not arg.is_lambda:
-        _register_declarative_function(interpreter, arg.name)
-        return arg.name
-    val = QLambdaFunction(param, arg.generative_blocks["body"]._py_callable)
-    with generative_mode_context(False):
-        val.expand()
-        _DecFuncVisitor(interpreter).visit(val.body)
-    qlambda = QuantumLambdaFunction(
-        pos_rename_params=val.infer_rename_params(),
-        body=val.body,
-    )
-    qlambda.set_op_decl(param)
-    return qlambda
-
-
-def _register_declarative_function(interpreter: "Interpreter", func_name: str) -> None:
-    if func_name in nameables_to_dict(list(interpreter._expanded_functions.values())):
-        return
-
-    for user_gen_func in interpreter._generative_functions:
-        if user_gen_func.func_decl.name == func_name:
-            break
-    else:
-        return
-
-    with generative_mode_context(False):
-        dec_func = QFunc(user_gen_func._py_callable)
-        dec_func.expand()
-        dec_func_def = QMODULE.native_defs[func_name]
-        interpreter._expanded_functions[func_name] = dec_func_def
-        _DecFuncVisitor(interpreter).visit(dec_func_def)
-
-
-class _DecFuncVisitor(Visitor):
-    def __init__(self, interpreter: "Interpreter"):
-        self._interpreter = interpreter
-
-    def visit_QuantumFunctionCall(self, call: QuantumFunctionCall) -> None:
-        _register_declarative_function(self._interpreter, call.func_name)
-        for arg in call.positional_args:
-            if isinstance(arg, str):
-                arg = [arg]
-            if isinstance(arg, list):
-                for possible_func_name in arg:
-                    if isinstance(possible_func_name, str):
-                        _register_declarative_function(
-                            self._interpreter, possible_func_name
-                        )

classiq/model_expansions/interpreter.py

@@ -15,6 +15,11 @@ from classiq.interface.exceptions import (
 )
 from classiq.interface.generator.constant import Constant
 from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.builtins.internal_operators import (
+    CONTROL_OPERATOR_NAME,
+    INVERT_OPERATOR_NAME,
+    WITHIN_APPLY_NAME,
+)
 from classiq.interface.generator.types.compilation_metadata import CompilationMetadata
 from classiq.interface.model.bind_operation import BindOperation
 from classiq.interface.model.classical_if import ClassicalIf
@@ -35,14 +40,16 @@ from classiq.interface.model.quantum_expressions.quantum_expression import (
     QuantumAssignmentOperation,
 )
 from classiq.interface.model.quantum_function_call import (
-    OperandIdentifier,
     QuantumFunctionCall,
 )
 from classiq.interface.model.quantum_function_declaration import (
     NamedParamsQuantumFunctionDeclaration,
     QuantumFunctionDeclaration,
 )
-from classiq.interface.model.quantum_lambda_function import QuantumLambdaFunction
+from classiq.interface.model.quantum_lambda_function import (
+    OperandIdentifier,
+    QuantumLambdaFunction,
+)
 from classiq.interface.model.quantum_statement import QuantumStatement
 from classiq.interface.model.repeat import Repeat
 from classiq.interface.model.variable_declaration_statement import (
@@ -81,6 +88,7 @@ from classiq.model_expansions.quantum_operations import (
     WithinApplyEmitter,
 )
 from classiq.model_expansions.quantum_operations.phase import PhaseEmitter
+from classiq.model_expansions.quantum_operations.shallow_emitter import ShallowEmitter
 from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
 from classiq.model_expansions.scope_initialization import (
     add_constants_to_scope,
@@ -108,7 +116,9 @@ class Interpreter:
         self._builder = OperationBuilder(self._top_level_scope)
         self._expanded_functions: dict[str, NativeFunctionDefinition] = {}
 
-        self._main_renamer: ExpressionRenamer = get_main_renamer(self._model.functions)
+        self._main_renamer: Optional[ExpressionRenamer] = (
+            get_main_renamer(self._model.functions) if self._is_frontend else None
+        )
 
         if generative_functions is None:
             generative_functions = []
@@ -280,11 +290,21 @@ class Interpreter:
 
     @emit.register
     def emit_quantum_assignment_operation(self, op: QuantumAssignmentOperation) -> None:
-        QuantumAssignmentOperationEmitter(self).emit(op)
+        if self._is_frontend:
+            ShallowEmitter(
+                self, "assignment_operation", components=["expression", "result_var"]
+            ).emit(op)
+        else:
+            QuantumAssignmentOperationEmitter(self).emit(op)
 
     @emit.register
-    def emit_inplace_binary_operation(self, operation: InplaceBinaryOperation) -> None:
-        InplaceBinaryOperationEmitter(self).emit(operation)
+    def emit_inplace_binary_operation(self, op: InplaceBinaryOperation) -> None:
+        if self._is_frontend:
+            ShallowEmitter(
+                self, "inplace_binary_operation", components=["target", "value"]
+            ).emit(op)
+        else:
+            InplaceBinaryOperationEmitter(self).emit(op)
 
     @emit.register
     def emit_variable_declaration(
@@ -298,11 +318,21 @@ class Interpreter:
 
     @emit.register
     def emit_within_apply(self, within_apply: WithinApply) -> None:
-        WithinApplyEmitter(self).emit(within_apply)
+        if self._is_frontend:
+            ShallowEmitter(
+                self,
+                WITHIN_APPLY_NAME,
+                components=["within", "apply", "compute", "action"],
+            ).emit(within_apply)
+        else:
+            WithinApplyEmitter(self).emit(within_apply)
 
     @emit.register
     def emit_invert(self, invert: Invert) -> None:
-        InvertEmitter(self).emit(invert)
+        if self._is_frontend:
+            ShallowEmitter(self, INVERT_OPERATOR_NAME, components=["body"]).emit(invert)
+        else:
+            InvertEmitter(self).emit(invert)
 
     @emit.register
     def emit_repeat(self, repeat: Repeat) -> None:
@@ -310,15 +340,32 @@ class Interpreter:
 
     @emit.register
     def emit_control(self, control: Control) -> None:
-        ControlEmitter(self).emit(control)
+        if self._is_frontend:
+            ShallowEmitter(
+                self,
+                CONTROL_OPERATOR_NAME,
+                components=["expression", "body", "else_block"],
+            ).emit(control)
+        else:
+            ControlEmitter(self).emit(control)
 
     @emit.register
     def emit_power(self, power: Power) -> None:
-        PowerEmitter(self).emit(power)
+        if self._is_frontend:
+            ShallowEmitter(
+                self, CONTROL_OPERATOR_NAME, components=["power", "body"]
+            ).emit(power)
+        else:
+            PowerEmitter(self).emit(power)
 
     @emit.register
     def emit_phase(self, phase: PhaseOperation) -> None:
-        PhaseEmitter(self).emit(phase)
+        if self._is_frontend:
+            ShallowEmitter(self, "phase", components=["expression", "theta"]).emit(
+                phase
+            )
+        else:
+            PhaseEmitter(self).emit(phase)
 
     def _expand_block(self, block: Sequence[QuantumStatement], block_name: str) -> None:
         with self._builder.block_context(block_name):

classiq/model_expansions/quantum_operations/call_emitter.py

@@ -3,6 +3,7 @@ from itertools import chain
 from typing import (
     TYPE_CHECKING,
     Generic,
+    Optional,
     cast,
 )
 
@@ -37,7 +38,6 @@ from classiq.model_expansions.evaluators.parameter_types import (
 from classiq.model_expansions.function_builder import (
     FunctionContext,
 )
-from classiq.model_expansions.generative_functions import emit_operands_as_declarative
 from classiq.model_expansions.quantum_operations.emitter import (
     Emitter,
     QuantumStatementT,
@@ -73,14 +73,22 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         return self._create_quantum_function_call(wrapping_function, list())
 
     def _emit_quantum_function_call(
-        self, function: FunctionClosure, args: list[ArgValue]
+        self,
+        function: FunctionClosure,
+        args: list[ArgValue],
+        propagated_debug_info: Optional[FunctionDebugInfo] = None,
     ) -> QuantumFunctionCall:
-        call = self._create_quantum_function_call(function, args)
+        call = self._create_quantum_function_call(
+            function, args, propagated_debug_info=propagated_debug_info
+        )
         self.emit_statement(call)
         return call
 
     def _create_quantum_function_call(
-        self, function: FunctionClosure, args: list[ArgValue]
+        self,
+        function: FunctionClosure,
+        args: list[ArgValue],
+        propagated_debug_info: Optional[FunctionDebugInfo] = None,
     ) -> QuantumFunctionCall:
         function = function.set_depth(self._builder.current_function.depth + 1)
         function = function.copy_scope()
@@ -144,10 +152,14 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
             for arg_decl, evaluated_arg in zip(new_positional_arg_decls, evaluated_args)
             if isinstance(arg_decl, PortDeclaration)
         }
-        self._interpreter._model.debug_info[new_call.uuid] = FunctionDebugInfo(
+        self._debug_info[new_call.uuid] = FunctionDebugInfo(
             name=new_call.func_name,
             level=OperationLevel.QMOD_FUNCTION_CALL,
-            parameters=parameters,
+            parameters=(
+                parameters
+                if propagated_debug_info is None
+                else propagated_debug_info.parameters
+            ),
             is_allocate_or_free=is_allocate_or_free,
             port_to_passed_variable_map=port_to_passed_variable_map,
         )
@@ -203,10 +215,7 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
             new_positional_arg_decls, evaluated_args
         )
         if is_atomic:
-            return [
-                emit_operands_as_declarative(self._interpreter, param, arg)
-                for param, arg in zip(new_positional_arg_decls, evaluated_args)
-            ]
+            return [arg.emit() for arg in evaluated_args]
 
         positional_args = [
             arg.emit() for arg in evaluated_args if isinstance(arg.value, QuantumSymbol)

classiq/model_expansions/quantum_operations/classicalif.py

@@ -26,7 +26,7 @@ class ClassicalIfEmitter(CallEmitter[ClassicalIf]):
         if is_generative:
             if not classical_if.has_generative_block(op_name):
                 return
-            context = self._register_generative_context(classical_if, op_name, op_name)
+            context = self._expand_generative_context(classical_if, op_name, op_name)
             context.blocks["body"] = context.blocks[op_name]
             context.blocks.pop(op_name)
             body = context.statements("body")

classiq/model_expansions/quantum_operations/control.py

@@ -55,19 +55,16 @@ from classiq.qmod.builtins.functions.standard_gates import X
 
 class ControlEmitter(ExpressionOperationEmitter[Control]):
     def emit(self, control: Control, /) -> None:
-        condition = self._evaluate_op_expression(control)
-
+        condition = control.expression
         arrays_with_subscript = self.split_symbols(
             condition, self._counted_name_allocator.allocate
         )
         if len(arrays_with_subscript) > 0:
-            if control.is_generative():
-                control = self._expand_generative_control(control)
             self._emit_with_split(control, condition, arrays_with_subscript)
             return
 
-        control = self._evaluate_types_in_expression(control, condition)
-        condition_val = condition.value.value
+        control = self._evaluate_types_in_expression(control)
+        condition_val = control.expression.value.value
         if isinstance(condition_val, QmodSizedProxy):
             if control.else_block is None:
                 self._validate_canonical_condition(condition_val)
@@ -96,25 +93,9 @@ class ControlEmitter(ExpressionOperationEmitter[Control]):
         )
         return Expression(expr=f"{lhs} == 1")
 
-    def _expand_generative_control(self, control: Control) -> Control:
-        block_names = ["body"]
-        if control.has_generative_block("else_block"):
-            block_names += ["else_block"]
-        context = self._register_generative_context(
-            control, CONTROL_OPERATOR_NAME, block_names
-        )
-        new_blocks = {"body": context.statements("body")}
-        if "else_block" in block_names:
-            new_blocks["else_block"] = context.statements("else_block")
-        return control.model_copy(update=new_blocks)
-
     def _emit_canonical_control(self, control: Control) -> None:
         # canonical means control(q, body) where q is a single quantum variable
-        is_generative = control.is_generative()
-        if is_generative:
-            control = self._expand_generative_control(control)
-
-        if not is_generative and self._should_wrap_control(control):
+        if self._should_wrap_control(control):
             self._emit_wrapped(control)
             return
         self._emit_as_operation(control)
@@ -211,12 +192,6 @@ class ControlEmitter(ExpressionOperationEmitter[Control]):
             compute=[else_compute_call],
             action=[control_else_inner],
         )
-        if control_else_inner.is_generative():
-            control_then.remove_generative_block("else_block")
-            control_else_inner.set_generative_block(
-                "body", control_else_inner.get_generative_block("else_block")
-            )
-            control_else_inner.remove_generative_block("else_block")
         return [control_then, control_else]
 
     def _control_with_x_gates(
@@ -296,8 +271,7 @@ class ControlEmitter(ExpressionOperationEmitter[Control]):
         condition_value = control.expression.value.value
         if not (
             isinstance(condition_value, Boolean)
-            or self._all_vars_boolean(control)
-            and self._is_res_boolean(control)
+            or (self._all_vars_boolean(control) and self._is_res_boolean(control))
         ):
             raise ClassiqExpansionError(_condition_err_msg(condition_value))
 

classiq/model_expansions/quantum_operations/emitter.py

@@ -1,3 +1,4 @@
+import ast
 from abc import abstractmethod
 from typing import (
     TYPE_CHECKING,
@@ -9,6 +10,7 @@ from typing import (
 
 import sympy
 
+from classiq.interface.debug_info.debug_info import DebugInfoCollection
 from classiq.interface.exceptions import ClassiqInternalExpansionError
 from classiq.interface.generator.expressions.evaluated_expression import (
     EvaluatedExpression,
@@ -24,9 +26,8 @@ from classiq.interface.model.quantum_function_declaration import (
 )
 from classiq.interface.model.quantum_statement import QuantumOperation, QuantumStatement
 
-from classiq.model_expansions.closure import Closure, FunctionClosure, GenerativeClosure
+from classiq.model_expansions.closure import Closure, GenerativeClosure
 from classiq.model_expansions.function_builder import (
-    FunctionContext,
     OperationBuilder,
     OperationContext,
 )
@@ -35,6 +36,7 @@ from classiq.model_expansions.sympy_conversion.sympy_to_python import (
     translate_sympy_quantum_expression,
 )
 from classiq.model_expansions.utils.counted_name_allocator import CountedNameAllocator
+from classiq.model_expansions.visitors.variable_references import VarRefCollector
 from classiq.qmod.quantum_function import GenerativeQFunc
 
 if TYPE_CHECKING:
@@ -55,20 +57,12 @@ class Emitter(Generic[QuantumStatementT]):
         self._functions_compilation_metadata = (
             self._interpreter._model.functions_compilation_metadata
         )
-        self._generative_contexts: dict[str, OperationContext] = {}
 
     @abstractmethod
     def emit(self, statement: QuantumStatementT, /) -> None:
         pass
 
     def _expand_operation(self, closure: Closure) -> OperationContext:
-        if closure.name in self._generative_contexts:
-            if isinstance(closure, FunctionClosure):
-                return FunctionContext(
-                    closure=closure,
-                    blocks=self._generative_contexts[closure.name].blocks,
-                )
-            return self._generative_contexts[closure.name]
         return self._interpreter._expand_operation(closure)
 
     @property
@@ -91,7 +85,11 @@ class Emitter(Generic[QuantumStatementT]):
     def _counted_name_allocator(self) -> CountedNameAllocator:
         return self._interpreter._counted_name_allocator
 
-    def _register_generative_context(
+    @property
+    def _debug_info(self) -> DebugInfoCollection:
+        return self._interpreter._model.debug_info
+
+    def _expand_generative_context(
         self,
         op: QuantumOperation,
         context_name: str,
@@ -116,15 +114,19 @@ class Emitter(Generic[QuantumStatementT]):
             },
         )
         context = self._interpreter._expand_operation(gen_closure)
-        self._generative_contexts[context_name] = context
         op.clear_generative_blocks()
         return context
 
-    def _evaluate_expression(self, expression: Expression) -> Expression:
+    def _evaluate_expression(
+        self, expression: Expression, preserve_bool_ops: bool = False
+    ) -> Expression:
         evaluated_expression = self._interpreter.evaluate(expression)
         if isinstance(evaluated_expression.value, sympy.Basic):
             new_expression = Expression(
-                expr=translate_sympy_quantum_expression(evaluated_expression.value)
+                expr=translate_sympy_quantum_expression(
+                    evaluated_expression.value,
+                    preserve_bool_ops=preserve_bool_ops,
+                )
             )
         else:
             new_expression = Expression(expr=str(evaluated_expression.value))
@@ -162,3 +164,14 @@ class Emitter(Generic[QuantumStatementT]):
             defining_function=defining_function,
             direction=direction,
         )
+
+    def capture_handles_in_expression(self, expr: Expression) -> None:
+        vrc = VarRefCollector(ignore_duplicated_handles=True)
+        vrc.visit(ast.parse(expr.expr))
+        handles = dict.fromkeys(
+            handle
+            for handle in vrc.var_handles
+            if isinstance(self._current_scope[handle.name].value, QuantumSymbol)
+        )
+        for handle in handles:
+            self._capture_handle(handle, PortDeclarationDirection.Inout)

classiq/model_expansions/quantum_operations/expression_operation.py

@@ -60,13 +60,11 @@ class ExpressionOperationEmitter(
     ) -> ExpressionOperationT:
         return op
 
-    def _evaluate_op_expression(self, op: ExpressionOperationT) -> Expression:
-        return self._evaluate_expression(op.expression)
-
     def _evaluate_types_in_expression(
-        self, op: ExpressionOperationT, expression: Expression
+        self, op: ExpressionOperationT
     ) -> ExpressionOperationT:
-        op_with_evaluated_types = op.model_copy(update={"expression": expression})
+        new_expression = self._evaluate_expression(op.expression)
+        op_with_evaluated_types = op.model_copy(update={"expression": new_expression})
         vrc = VarRefCollector()
         vrc.visit(ast.parse(op_with_evaluated_types.expression.expr))
         handles = vrc.var_handles