classiq 0.53.0__py3-none-any.whl → 0.54.0__py3-none-any.whl

classiq/model_expansions/function_builder.py

@@ -1,6 +1,7 @@
+from collections.abc import Iterable, Iterator, Sequence
 from contextlib import contextmanager
 from dataclasses import dataclass, field
-from typing import Dict, Generic, Iterable, Iterator, List, Optional, Sequence, TypeVar
+from typing import Generic, Optional, TypeVar
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
@@ -18,6 +19,7 @@ from classiq.interface.generator.functions.port_declaration import (
 )
 from classiq.interface.model.model import MAIN_FUNCTION_NAME
 from classiq.interface.model.native_function_definition import (
+    FunctionSynthesisData,
     NativeFunctionDefinition,
 )
 from classiq.interface.model.port_declaration import PortDeclaration
@@ -35,14 +37,14 @@ ClosureType = TypeVar("ClosureType", bound=Closure)
 
 @dataclass
 class Block:
-    statements: List[QuantumStatement] = field(default_factory=list)
-    captured_vars: List[PortDeclaration] = field(default_factory=list)
+    statements: list[QuantumStatement] = field(default_factory=list)
+    captured_vars: list[PortDeclaration] = field(default_factory=list)
 
 
 @dataclass
 class OperationContext(Generic[ClosureType]):
     closure: ClosureType
-    blocks: Dict[str, Block] = field(default_factory=dict)
+    blocks: dict[str, Block] = field(default_factory=dict)
 
     @property
     def name(self) -> str:
@@ -52,7 +54,7 @@ class OperationContext(Generic[ClosureType]):
     def positional_arg_declarations(self) -> Sequence[PositionalArg]:
         return self.closure.positional_arg_declarations
 
-    def statements(self, block_name: str) -> List[QuantumStatement]:
+    def statements(self, block_name: str) -> list[QuantumStatement]:
         return self.blocks[block_name].statements
 
 
@@ -63,22 +65,26 @@ class FunctionContext(OperationContext[FunctionClosure]):
         return cls(original_function, {"body": Block()})
 
     @property
-    def body(self) -> List[QuantumStatement]:
+    def body(self) -> list[QuantumStatement]:
         return self.statements("body")
 
     @property
-    def captured_vars(self) -> List[PortDeclaration]:
+    def captured_vars(self) -> list[PortDeclaration]:
         return self.blocks["body"].captured_vars
 
     @property
     def is_lambda(self) -> bool:
         return self.closure.is_lambda
 
+    @property
+    def synthesis_data(self) -> FunctionSynthesisData:
+        return self.closure.synthesis_data
+
 
 class OperationBuilder:
     def __init__(self) -> None:
-        self._operations: List[OperationContext] = []
-        self._blocks: List[str] = []
+        self._operations: list[OperationContext] = []
+        self._blocks: list[str] = []
         self._counter = 0
 
     @property
@@ -93,7 +99,7 @@ class OperationBuilder:
         raise ClassiqInternalExpansionError("No function found")
 
     @property
-    def _current_statements(self) -> List[QuantumStatement]:
+    def _current_statements(self) -> list[QuantumStatement]:
         return self._operations[-1].blocks[self._blocks[-1]].statements
 
     def emit_statement(self, statement: QuantumStatement) -> None:
@@ -160,7 +166,7 @@ class OperationBuilder:
             name = f"{name}_{LAMBDA_KEYWORD + '_0_0_' if function_context.is_lambda else ''}{EXPANDED_KEYWORD}_{self._counter}"
             self._counter += 1
 
-        new_parameters: List[PortDeclaration] = [
+        new_parameters: list[PortDeclaration] = [
             param
             for param in function_context.positional_arg_declarations
             if isinstance(param, PortDeclaration)
@@ -170,10 +176,11 @@ class OperationBuilder:
             name=name,
             body=function_context.body,
             positional_arg_declarations=new_parameters,
+            synthesis_data=function_context.synthesis_data,
         )
 
 
-def validate_captured_vars(captured_vars: List[PortDeclaration]) -> None:
+def validate_captured_vars(captured_vars: list[PortDeclaration]) -> None:
     if input_captured := [
         demangle_name(var.name)
         for var in captured_vars

classiq/model_expansions/generative_functions.py

@@ -1,4 +1,5 @@
-from typing import TYPE_CHECKING, Any, List, Mapping
+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 (
@@ -127,7 +128,7 @@ class _InterpreterExpandable(QFunc):
 def emit_generative_statements(
     interpreter: "Interpreter",
     operation: GenerativeClosure,
-    args: List[Evaluated],
+    args: list[Evaluated],
 ) -> None:
     python_qmod_args = [
         translate_ast_arg_to_python_qmod(param, arg)

classiq/model_expansions/interpreter.py

@@ -1,7 +1,8 @@
 import copy
+from collections.abc import Iterator, Sequence
 from contextlib import contextmanager, nullcontext
 from functools import singledispatchmethod
-from typing import Any, Iterator, List, Optional, Sequence, Tuple, Type, cast
+from typing import Any, Optional, cast
 
 import numpy as np
 from numpy.random import permutation
@@ -45,6 +46,7 @@ from classiq.interface.model.variable_declaration_statement import (
 )
 from classiq.interface.model.within_apply_operation import WithinApply
 
+from classiq.model_expansions.call_to_model_converter import BlockFunctionInfo
 from classiq.model_expansions.capturing.propagated_var_stack import PropagatedVarStack
 from classiq.model_expansions.closure import (
     Closure,
@@ -88,7 +90,7 @@ from classiq.qmod.builtins.functions import permute
 from classiq.qmod.quantum_function import GenerativeQFunc
 from classiq.qmod.semantics.error_manager import ErrorManager
 
-STATEMENT_TYPES_FOR_SOURCE_REFERENCE_PROPAGATION: Tuple[Type[QuantumStatement], ...] = (
+STATEMENT_TYPES_FOR_SOURCE_REFERENCE_PROPAGATION: tuple[type[QuantumStatement], ...] = (
     QuantumFunctionCall,
     VariableDeclarationStatement,
     QuantumAssignmentOperation,
@@ -99,14 +101,14 @@ class Interpreter:
     def __init__(
         self,
         model: Model,
-        generative_functions: Optional[List[GenerativeQFunc]] = None,
+        generative_functions: Optional[list[GenerativeQFunc]] = None,
         is_frontend: bool = False,
     ) -> None:
         self._is_frontend = is_frontend
         self._model = model
         self._current_scope = Scope()
         self._builder = OperationBuilder()
-        self._expanded_functions: List[NativeFunctionDefinition] = []
+        self._expanded_functions: list[NativeFunctionDefinition] = []
         self._propagated_var_stack = PropagatedVarStack(
             self._current_scope, self._builder
         )
@@ -120,6 +122,7 @@ class Interpreter:
 
         self._counted_name_allocator = CountedNameAllocator()
         self._error_manager: ErrorManager = ErrorManager()
+        self._synthesized_separately_blocks: dict[str, BlockFunctionInfo] = {}
 
     @contextmanager
     def _scope_guard(self, scope: Scope) -> Iterator[None]:
@@ -154,9 +157,10 @@ class Interpreter:
             self._builder.create_definition(cast(FunctionContext, context))
         )
 
-    def expand(self) -> Model:
+    def expand(self) -> tuple[Model, dict[str, BlockFunctionInfo]]:
         try:
             with self._error_manager.call("main"):
+                self._synthesized_separately_blocks = {}
                 self._expand_main_func()
         except Exception as e:
             if isinstance(e, ClassiqInternalExpansionError) or debug_mode.get():
@@ -168,17 +172,20 @@ class Interpreter:
         finally:
             self._error_manager.report_errors(ClassiqExpansionError)
 
-        return Model(
-            constraints=self._model.constraints,
-            preferences=self._model.preferences,
-            classical_execution_code=self._model.classical_execution_code,
-            execution_preferences=self._model.execution_preferences,
-            functions=self._expanded_functions,
-            constants=self._model.constants,
-            enums=self._model.enums,
-            types=self._model.types,
-            qstructs=self._model.qstructs,
-            debug_info=self._model.debug_info,
+        return (
+            Model(
+                constraints=self._model.constraints,
+                preferences=self._model.preferences,
+                classical_execution_code=self._model.classical_execution_code,
+                execution_preferences=self._model.execution_preferences,
+                functions=self._expanded_functions,
+                constants=self._model.constants,
+                enums=self._model.enums,
+                types=self._model.types,
+                qstructs=self._model.qstructs,
+                debug_info=self._model.debug_info,
+            ),
+            self._synthesized_separately_blocks,
         )
 
     @singledispatchmethod
@@ -196,7 +203,7 @@ class Interpreter:
     @evaluate.register
     def evaluate_lambda(self, function: QuantumLambdaFunction) -> Evaluated:
         renamed_params = [
-            param.rename(function.get_rename_params()[idx])
+            param.rename(function.pos_rename_params[idx])
             for idx, param in enumerate(function.func_decl.positional_arg_declarations)
         ]
         func_decl = NamedParamsQuantumFunctionDeclaration(
@@ -204,7 +211,7 @@ class Interpreter:
             positional_arg_declarations=renamed_params,
         )
 
-        closure_class: Type[FunctionClosure]
+        closure_class: type[FunctionClosure]
         extra_args: dict[str, Any]
         if function.is_generative():
             closure_class = GenerativeFunctionClosure
@@ -339,7 +346,12 @@ class Interpreter:
 
     def _expand_operation(self, operation: Closure) -> OperationContext:
         with self._builder.operation_context(operation) as context:
-            if isinstance(operation, FunctionClosure) and operation.name == "permute":
+            if (
+                isinstance(operation, FunctionClosure)
+                and operation.synthesis_data.should_synthesize_separately
+            ):
+                pass
+            elif isinstance(operation, FunctionClosure) and operation.name == "permute":
                 # special expansion since permute is generative
                 with self._scope_guard(operation.scope):
                     self._expand_permute()

classiq/model_expansions/model_tables.py

@@ -1,6 +1,6 @@
 from abc import ABC, abstractmethod
 from enum import IntEnum
-from typing import ClassVar, Dict, Generic, List, Optional, TypeVar
+from typing import ClassVar, Generic, Optional, TypeVar
 
 from classiq.interface.generator.expressions.handle_identifier import HandleIdentifier
 from classiq.interface.generator.functions.classical_type import QmodPyObject
@@ -18,15 +18,15 @@ DeclarationType = TypeVar(
 
 
 class TypeTable(Generic[DeclarationType], ABC):
-    def __init__(self, user_types: List[DeclarationType]) -> None:
-        self._all_types: Dict[str, DeclarationType] = self.builtins.copy()
+    def __init__(self, user_types: list[DeclarationType]) -> None:
+        self._all_types: dict[str, DeclarationType] = self.builtins.copy()
         for t in user_types:
             assert t.name not in self._all_types  # FIXME: issue user error (CAD-7856)
             self._all_types[t.name] = t
 
     @property
     @abstractmethod
-    def builtins(self) -> Dict[str, DeclarationType]:
+    def builtins(self) -> dict[str, DeclarationType]:
         pass
 
     def __getitem__(self, key: str) -> DeclarationType:
@@ -38,20 +38,20 @@ class TypeTable(Generic[DeclarationType], ABC):
     def __contains__(self, key: str) -> bool:
         return key in self._all_types
 
-    def all_types(self) -> Dict[str, DeclarationType]:
+    def all_types(self) -> dict[str, DeclarationType]:
         return self._all_types
 
 
 class EnumTable(TypeTable[EnumDeclaration]):
-    def __init__(self, user_types: List[EnumDeclaration]) -> None:
+    def __init__(self, user_types: list[EnumDeclaration]) -> None:
         super().__init__(user_types)
 
     @property
-    def builtins(self) -> Dict[str, EnumDeclaration]:
+    def builtins(self) -> dict[str, EnumDeclaration]:
         return BUILTIN_ENUM_DECLARATIONS
 
     @property
-    def enums(self) -> Dict[str, IntEnum]:
+    def enums(self) -> dict[str, IntEnum]:
         return {
             enum_decl.name: enum_decl.create_enum()
             for enum_decl in self.all_types().values()
@@ -60,13 +60,13 @@ class EnumTable(TypeTable[EnumDeclaration]):
 
 class StructTable(TypeTable[StructDeclaration]):
     @property
-    def builtins(self) -> Dict[str, StructDeclaration]:
+    def builtins(self) -> dict[str, StructDeclaration]:
         return BUILTIN_STRUCT_DECLARATIONS
 
 
 class QStructTable(TypeTable[QStructDeclaration]):
     @property
-    def builtins(self) -> Dict[str, QStructDeclaration]:
+    def builtins(self) -> dict[str, QStructDeclaration]:
         return {}
 
 
@@ -76,15 +76,15 @@ class SymbolTable:
     qstruct_table: ClassVar[QStructTable] = QStructTable([])
 
     @classmethod
-    def init_user_enums(cls, user_enums: List[EnumDeclaration]) -> None:
+    def init_user_enums(cls, user_enums: list[EnumDeclaration]) -> None:
         cls.enum_table = EnumTable(user_enums)
 
     @classmethod
-    def init_user_types(cls, user_types: List[StructDeclaration]) -> None:
+    def init_user_types(cls, user_types: list[StructDeclaration]) -> None:
         cls.type_table = StructTable(user_types)
 
     @classmethod
-    def init_user_qstructs(cls, user_qstructs: List[QStructDeclaration]) -> None:
+    def init_user_qstructs(cls, user_qstructs: list[QStructDeclaration]) -> None:
         cls.qstruct_table = QStructTable(user_qstructs)
         QMODULE.qstruct_decls = {
             qstruct_decl.name: qstruct_decl for qstruct_decl in user_qstructs
@@ -92,7 +92,7 @@ class SymbolTable:
 
 
 class HandleTable:
-    _handle_map: Dict[HandleIdentifier, QmodPyObject] = {}
+    _handle_map: dict[HandleIdentifier, QmodPyObject] = {}
 
     @classmethod
     def get_handle_object(cls, hid: HandleIdentifier) -> Optional[QmodPyObject]:

classiq/model_expansions/quantum_operations/bind.py

@@ -1,5 +1,3 @@
-from typing import List
-
 from classiq.interface.exceptions import ClassiqExpansionError
 from classiq.interface.model.bind_operation import BindOperation
 
@@ -18,11 +16,11 @@ class BindEmitter(Emitter[BindOperation]):
     def emit(self, bind: BindOperation, /) -> None:
         with self._propagated_var_stack.capture_variables(bind):
             pass
-        inputs: List[QuantumSymbol] = [
+        inputs: list[QuantumSymbol] = [
             self._interpreter.evaluate(arg).as_type(QuantumSymbol)
             for arg in bind.in_handles
         ]
-        outputs: List[QuantumSymbol] = [
+        outputs: list[QuantumSymbol] = [
             self._interpreter.evaluate(arg).as_type(QuantumSymbol)
             for arg in bind.out_handles
         ]

classiq/model_expansions/quantum_operations/classicalif.py

@@ -1,4 +1,4 @@
-from typing import Sequence
+from collections.abc import Sequence
 
 from classiq.interface.model.classical_if import ClassicalIf
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall

classiq/model_expansions/quantum_operations/control.py

@@ -1,5 +1,3 @@
-from typing import List, Tuple
-
 from sympy import Equality
 from sympy.logic.boolalg import Boolean
 from typing_extensions import TypeGuard
@@ -160,7 +158,7 @@ class ControlEmitter(ExpressionOperationEmitter[Control]):
     def _emit_with_x_gates(
         self, control: Control, ctrl: QmodSizedProxy, ctrl_state: str
     ) -> None:
-        compute_op: List[ConcreteQuantumStatement] = []
+        compute_op: list[ConcreteQuantumStatement] = []
 
         x_gate_value = self._get_x_gate_value(ctrl_state)
         if x_gate_value != 0:
@@ -194,7 +192,7 @@ class ControlEmitter(ExpressionOperationEmitter[Control]):
 
     def _get_array_cast_ops(
         self, ctrl: QmodQNumProxy
-    ) -> Tuple[VariableDeclarationStatement, BindOperation]:
+    ) -> tuple[VariableDeclarationStatement, BindOperation]:
         array_cast = self._counted_name_allocator.allocate(
             f"{ctrl.handle}{ARRAY_CAST_SUFFIX}"
         )

classiq/model_expansions/quantum_operations/emitter.py

@@ -1,11 +1,9 @@
 from abc import abstractmethod
+from collections.abc import Sequence
 from typing import (
     TYPE_CHECKING,
-    Dict,
     Generic,
-    List,
     Optional,
-    Sequence,
     TypeVar,
     Union,
     cast,
@@ -18,7 +16,7 @@ from classiq.interface.generator.expressions.evaluated_expression import (
     EvaluatedExpression,
 )
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.ide.visual_model import OperationLevel
+from classiq.interface.generator.generated_circuit_data import OperationLevel
 from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
 )
@@ -63,7 +61,6 @@ from classiq.qmod.quantum_function import GenerativeQFunc
 if TYPE_CHECKING:
     from classiq.model_expansions.interpreter import Interpreter
 
-
 QuantumStatementT = TypeVar("QuantumStatementT", bound=QuantumStatement)
 
 
@@ -74,7 +71,7 @@ class Emitter(Generic[QuantumStatementT]):
         self._scope_guard = self._interpreter._scope_guard
         self._machine_precision = self._interpreter._model.preferences.machine_precision
 
-        self._generative_contexts: Dict[str, OperationContext] = {}
+        self._generative_contexts: dict[str, OperationContext] = {}
 
     @abstractmethod
     def emit(self, statement: QuantumStatementT, /) -> None:
@@ -103,7 +100,7 @@ class Emitter(Generic[QuantumStatementT]):
         return self._interpreter._current_scope
 
     @property
-    def _expanded_functions(self) -> List[NativeFunctionDefinition]:
+    def _expanded_functions(self) -> list[NativeFunctionDefinition]:
         return self._interpreter._expanded_functions
 
     @property
@@ -125,14 +122,14 @@ class Emitter(Generic[QuantumStatementT]):
         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]
     ) -> QuantumFunctionCall:
         call = self._create_quantum_function_call(function, args)
         self._builder.emit_statement(call)
         return call
 
     def _create_quantum_function_call(
-        self, function: FunctionClosure, args: List[ArgValue]
+        self, function: FunctionClosure, args: list[ArgValue]
     ) -> QuantumFunctionCall:
         evaluated_args = [self._interpreter.evaluate(arg) for arg in args]
         new_declaration = self._prepare_fully_typed_declaration(
@@ -206,10 +203,10 @@ class Emitter(Generic[QuantumStatementT]):
 
     def _get_new_positional_args(
         self,
-        evaluated_args: List[Evaluated],
+        evaluated_args: list[Evaluated],
         is_atomic: bool,
         new_positional_arg_decls: Sequence[PositionalArg],
-    ) -> List[ArgValue]:
+    ) -> list[ArgValue]:
         evaluated_args = add_information_from_output_arguments(
             new_positional_arg_decls, evaluated_args
         )
@@ -230,7 +227,7 @@ class Emitter(Generic[QuantumStatementT]):
         return positional_args
 
     def _prepare_fully_typed_declaration(
-        self, function: FunctionClosure, evaluated_args: List[Evaluated]
+        self, function: FunctionClosure, evaluated_args: list[Evaluated]
     ) -> NamedParamsQuantumFunctionDeclaration:
         """
         Given, for example,
@@ -260,7 +257,7 @@ class Emitter(Generic[QuantumStatementT]):
         self,
         op: QuantumOperation,
         context_name: str,
-        block_names: Union[None, str, List[str]] = None,
+        block_names: Union[None, str, list[str]] = None,
         func_decl: Optional[NamedParamsQuantumFunctionDeclaration] = None,
     ) -> OperationContext:
         if isinstance(block_names, str):

classiq/model_expansions/quantum_operations/expression_operation.py

@@ -1,7 +1,7 @@
 import ast
 from abc import abstractmethod
 from itertools import chain
-from typing import TYPE_CHECKING, Dict, List, Tuple, TypeVar
+from typing import TYPE_CHECKING, TypeVar
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
@@ -26,6 +26,7 @@ from classiq.interface.model.quantum_type import (
     QuantumBit,
     QuantumBitvector,
     QuantumNumeric,
+    QuantumType,
 )
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
@@ -48,7 +49,7 @@ class ExpressionOperationEmitter(Emitter[ExpressionOperationT]):
         self,
         op: ExpressionOperationT,
         expression: Expression,
-        symbols_to_split: List[QuantumSymbol],
+        symbols_to_split: list[QuantumSymbol],
     ) -> None:
         symbols_parts, bind_ops = self._get_bind_ops(symbols_to_split)
 
@@ -62,14 +63,13 @@ class ExpressionOperationEmitter(Emitter[ExpressionOperationT]):
                         )
                     )
 
-        new_expression = self._update_op_expression(
-            {
-                symbol.handle: symbol_part_var_name
-                for symbol, symbol_part_var_name in chain.from_iterable(symbols_parts)
-            },
-            expression,
-        )
+        symbol_mapping = {
+            symbol.handle: (symbol_part_var_name, symbol.quantum_type)
+            for symbol, symbol_part_var_name in chain.from_iterable(symbols_parts)
+        }
+        new_expression = self._update_op_expression(symbol_mapping, expression)
         new_op = op.model_copy(update=dict(expression=new_expression))
+        new_op = self._get_updated_op_split_symbols(new_op, symbol_mapping)
 
         self._interpreter.emit_statement(
             WithinApply(
@@ -79,9 +79,16 @@ class ExpressionOperationEmitter(Emitter[ExpressionOperationT]):
             )
         )
 
+    @staticmethod
+    def _get_updated_op_split_symbols(
+        op: ExpressionOperationT,
+        symbol_mapping: dict[HandleBinding, tuple[str, QuantumType]],
+    ) -> ExpressionOperationT:
+        return op
+
     def _update_op_expression(
         self,
-        symbol_parts: Dict[HandleBinding, str],
+        symbol_mapping: dict[HandleBinding, tuple[str, QuantumType]],
         expression: Expression,
     ) -> Expression:
         vrc = VarRefCollector(ignore_duplicated_handles=True)
@@ -90,9 +97,9 @@ class ExpressionOperationEmitter(Emitter[ExpressionOperationT]):
         new_expr_str = expression.expr
         for handle in vrc.var_handles:
             collapsed_handle = handle.collapse()
-            if collapsed_handle in symbol_parts:
+            if collapsed_handle in symbol_mapping:
                 new_expr_str = new_expr_str.replace(
-                    str(handle), symbol_parts[collapsed_handle]
+                    str(handle), symbol_mapping[collapsed_handle][0]
                 )
         self._check_all_handles_were_replaced(new_expr_str)
 
@@ -115,8 +122,8 @@ class ExpressionOperationEmitter(Emitter[ExpressionOperationT]):
 
     def _get_bind_ops(
         self,
-        symbols_to_split: List[QuantumSymbol],
-    ) -> Tuple[List[List[Tuple[QuantumSymbol, str]]], List[BindOperation]]:
+        symbols_to_split: list[QuantumSymbol],
+    ) -> tuple[list[list[tuple[QuantumSymbol, str]]], list[BindOperation]]:
         bind_ops = []
         symbols_parts = []
         for symbol in symbols_to_split:
@@ -135,7 +142,7 @@ class ExpressionOperationEmitter(Emitter[ExpressionOperationT]):
 
     def _get_symbol_parts(
         self, symbol: QuantumSymbol
-    ) -> List[Tuple[QuantumSymbol, str]]:
+    ) -> list[tuple[QuantumSymbol, str]]:
         quantum_type = symbol.quantum_type
 
         if isinstance(quantum_type, (QuantumBit, QuantumNumeric)):
@@ -169,7 +176,7 @@ class ExpressionOperationEmitter(Emitter[ExpressionOperationT]):
             )
         )
 
-    def _get_symbols_to_split(self, expression: Expression) -> List[QuantumSymbol]:
+    def _get_symbols_to_split(self, expression: Expression) -> list[QuantumSymbol]:
         vrc = VarRefCollector(ignore_duplicated_handles=True)
         vrc.visit(ast.parse(expression.expr))
         symbol_names_to_split = dict.fromkeys(