classiq 0.66.1__py3-none-any.whl → 0.68.0__py3-none-any.whl

classiq/open_library/functions/discrete_sine_cosine_transform.py

@@ -1,13 +1,11 @@
 from classiq.open_library.functions.qft_functions import qft
-from classiq.open_library.functions.utility_functions import (
-    apply_to_all,
-    modular_increment,
-)
+from classiq.open_library.functions.utility_functions import apply_to_all
 from classiq.qmod.builtins.functions.standard_gates import PHASE, H, S, X, Z
 from classiq.qmod.builtins.operations import (
     allocate,
     bind,
     control,
+    inplace_add,
     invert,
     repeat,
     within_apply,
@@ -30,8 +28,13 @@ def _qct_d_operator(x: QNum, q: QBit) -> None:
 
 @qfunc
 def _qct_pi_operator(x: QArray[QBit], q: QBit) -> None:
-    control(q == 1, lambda: apply_to_all(X, x))
-    control(q == 1, lambda: modular_increment(1, x))
+    control(
+        q == 1,
+        lambda: [  # type:ignore[arg-type]
+            apply_to_all(X, x),
+            inplace_add(1, x),  # type:ignore[arg-type, func-returns-value]
+        ],
+    )
 
 
 def _t_operator(x: QArray) -> None:
@@ -63,7 +66,7 @@ def _d1_operator(x: QArray[QBit], q: QBit) -> None:
 
 
 def _pi2_operator(x: QArray[QBit], q: QBit) -> None:
-    control(q == 1, lambda: modular_increment(1, x))
+    control(q == 1, lambda: inplace_add(1, x))  # type:ignore[arg-type]
 
 
 def _j_operator(q: QBit) -> None:
@@ -76,7 +79,7 @@ def _b_t_operator(q: QBit) -> None:
 
 
 def _d0dt_operator(x: QArray, q: QBit) -> None:
-    x_num: QNum = QNum("x_num", x.len, False, 0)
+    x_num: QNum = QNum(size=x.len)
     bind(x, x_num)
     _b_t_operator(q)
     control(x_num == 0, lambda: _j_operator(q))
@@ -140,7 +143,7 @@ def qct_qst_type2(x: QArray[QBit], q: QBit) -> None:
         x: The LSB part of the qubit array to apply the transform to.
         q: The MSB of the qubit array to apply the transform to.
     """
-    extended_state: QArray = QArray("extended_state")
+    extended_state: QArray = QArray()
     _vn_operator(x, q)
     bind([x, q], extended_state)
     qft(extended_state)
@@ -159,8 +162,8 @@ def qct_type2(x: QArray[QBit]) -> None:
     Args:
         x: The qubit array to apply the transform to.
     """
-    q = QBit("q")
-    within_apply(lambda: allocate(1, q), lambda: qct_qst_type2(x, q))
+    q = QBit()
+    within_apply(lambda: allocate(q), lambda: qct_qst_type2(x, q))
 
 
 @qfunc
@@ -174,8 +177,8 @@ def qst_type2(x: QArray[QBit]) -> None:
     Args:
         x: The qubit array to apply the transform to.
     """
-    q = QBit("q")
+    q = QBit()
     within_apply(
-        lambda: (allocate(1, q), X(q)),  # type:ignore[arg-type]
+        lambda: (allocate(q), X(q)),  # type:ignore[arg-type]
         lambda: qct_qst_type2(x, q),
     )

classiq/open_library/functions/grover.py

@@ -40,9 +40,9 @@ def phase_oracle(
         predicate: A predicate function that takes a QArray of QBits and sets a single QBit |1> if the predicate is true, and |0> otherwise.
         target: The target QArray of QBits to apply the phase oracle to.
     """
-    aux = QBit("aux")
+    aux = QBit()
     within_apply(
-        within=lambda: (allocate(1, aux), X(aux), H(aux)),  # type:ignore[arg-type]
+        within=lambda: (allocate(aux), X(aux), H(aux)),  # type:ignore[arg-type]
         apply=lambda: predicate(target, aux),
     )
 
@@ -56,16 +56,16 @@ def reflect_about_zero(packed_vars: QArray[QBit]) -> None:
     besides the |0> state). Implements the operator $S_0$:
 
     $$
-    \begin{equation}
-    S_0|{x}\rangle = (-1)^{(x\ne0)}|{x}\rangle= (2|{0}\rangle\\langle{0}|-I)|{x}\rangle
+    \\begin{equation}
+    S_0|{x}\\rangle = (-1)^{(x\\ne0)}|{x}\\rangle= (2|{0}\\rangle\\langle{0}|-I)|{x}\\rangle
     \\end{equation}
     $$
 
     Args:
         packed_vars: The quantum state to reflect.
     """
-    msbs: QNum = QNum("msbs", packed_vars.len - 1, False, 0)
-    lsb = QBit("lsb")
+    msbs: QNum = QNum(size=packed_vars.len - 1)
+    lsb = QBit()
     bind(packed_vars, [msbs, lsb])
     within_apply(
         lambda: (X(lsb), H(lsb)),  # type:ignore[arg-type]
@@ -85,7 +85,7 @@ def grover_diffuser(
     is the `space_transform` parameter. It is defined as:
 
     $$
-    \begin{equation}
+    \\begin{equation}
     D = A S_0 A^{\\dagger}
     \\end{equation}
     $$
@@ -118,15 +118,15 @@ def grover_operator(
     $$
 
     where $S_{\\psi_1}$ is a reflection about marked states, and $S_{\\psi_0}$ is a reflection
-    about a given state defined by $|\\psi_0\rangle = A|0\rangle$.
+    about a given state defined by $|\\psi_0\\rangle = A|0\\rangle$.
 
     Args:
         oracle: A unitary operator which adds a phase of (-1) to marked states.
-        space_transform: The operator which creates $|\\psi_0\rangle$, the initial state, used by the diffuser to reflect about it.
+        space_transform: The operator which creates $|\\psi_0\\rangle$, the initial state, used by the diffuser to reflect about it.
         packed_vars: The state to which to apply the grover operator.
     """
     oracle(packed_vars)
-    grover_diffuser(lambda qba: space_transform(qba), packed_vars)
+    grover_diffuser(space_transform, packed_vars)
     U(0, 0, 0, pi, packed_vars[0])
 
 
@@ -149,9 +149,5 @@ def grover_search(
     hadamard_transform(packed_vars)
     power(
         reps,
-        lambda: grover_operator(
-            lambda qba: oracle(qba),
-            lambda qba: hadamard_transform(qba),
-            packed_vars,
-        ),
+        lambda: grover_operator(oracle, hadamard_transform, packed_vars),
     )

classiq/open_library/functions/modular_exponentiation.py

@@ -11,24 +11,18 @@ from classiq.qmod.builtins.operations import (
 )
 from classiq.qmod.cparam import CInt
 from classiq.qmod.qfunc import qfunc
-from classiq.qmod.qmod_variable import QArray, QBit, QNum
+from classiq.qmod.qmod_variable import QArray, QBit
 from classiq.qmod.symbolic import min, mod_inverse
 
 
 @qfunc
 def _check_msb(ref: CInt, x: QArray[QBit], aux: QBit) -> None:
     within_apply(
-        lambda: invert(lambda: qft_no_swap(x)), lambda: _ctrl_x(ref, x[0], aux)
+        lambda: invert(lambda: qft_no_swap(x)),
+        lambda: control(x[0] == ref, lambda: X(aux)),
     )
 
 
-@qfunc
-def _ctrl_x(
-    ref: CInt, ctrl: QNum, aux: QBit
-) -> None:  # TODO: remove qfunc when expressions of QBit is supported
-    control(ctrl == ref, lambda: X(aux))
-
-
 @qfunc
 def qft_space_add_const(value: CInt, phi_b: QArray[QBit]) -> None:
     """
@@ -72,12 +66,12 @@ def cc_modular_add(n: CInt, a: CInt, phi_b: QArray[QBit], c1: QBit, c2: QBit) ->
         c2: a control qubit.
 
     """
-    ctrl: QArray[QBit] = QArray("ctrl")
-    aux = QBit("aux")
+    ctrl: QArray[QBit] = QArray()
+    aux = QBit()
 
     within_apply(
         lambda: (  # type:ignore[arg-type]
-            allocate(1, aux),
+            allocate(aux),
             bind([c1, c2], ctrl),  # type:ignore[func-returns-value]
         ),
         lambda: (  # type:ignore[arg-type]
@@ -162,7 +156,7 @@ def inplace_c_modular_multiply(n: CInt, a: CInt, x: QArray[QBit], ctrl: QBit) ->
         x: The quantum factor.
         ctrl: The control bit.
     """
-    b: QArray[QBit] = QArray("b")
+    b: QArray[QBit] = QArray()
 
     within_apply(
         lambda: allocate(x.len + 1, b),

classiq/open_library/functions/state_preparation.py

@@ -3,12 +3,9 @@ from typing import Literal
 
 from classiq.interface.exceptions import ClassiqDeprecationWarning
 
-from classiq.open_library.functions.utility_functions import (
-    hadamard_transform,
-    modular_increment,
-)
+from classiq.open_library.functions.utility_functions import hadamard_transform
 from classiq.qmod.builtins.functions.standard_gates import CX, IDENTITY, RY, H, X
-from classiq.qmod.builtins.operations import allocate, control, if_, repeat
+from classiq.qmod.builtins.operations import allocate, control, if_, inplace_add, repeat
 from classiq.qmod.cparam import CBool, CInt
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_variable import Output, QArray, QBit, QNum
@@ -48,7 +45,7 @@ def allocate_num(
     allocate(num_qubits, out)
 
 
-def prepare_uniform_trimmed_state_apply_rotation(
+def _prepare_uniform_trimmed_state_apply_rotation(
     size_lsb: CInt, lsbs_val: CInt, rotation_var: QBit
 ) -> None:
     # max hold for the case where the value is on the left side
@@ -68,7 +65,7 @@ def _prepare_uniform_trimmed_state_step(
         lsbs_val != 0,  # stop condition
         lambda: control(
             ctrl_var == ctrl_val,
-            lambda: prepare_uniform_trimmed_state_apply_rotation(
+            lambda: _prepare_uniform_trimmed_state_apply_rotation(
                 size_lsb, lsbs_val, rotation_var
             ),
         ),
@@ -102,7 +99,7 @@ def prepare_uniform_trimmed_state(m: CInt, q: QArray[QBit]) -> None:
     if_(
         m < 2**q.len,
         # initial step without control
-        lambda: prepare_uniform_trimmed_state_apply_rotation(
+        lambda: _prepare_uniform_trimmed_state_apply_rotation(
             q.len - 1,  # type:ignore[arg-type]
             m,
             q[q.len - 1],
@@ -122,7 +119,7 @@ def prepare_uniform_trimmed_state(m: CInt, q: QArray[QBit]) -> None:
 
 
 @qfunc
-def prepare_uniform_interval_state(start: CInt, end: CInt, q: QArray[QBit]) -> None:
+def prepare_uniform_interval_state(start: CInt, end: CInt, q: QNum) -> None:
     """
     [Qmod Classiq-library function]
 
@@ -144,7 +141,7 @@ def prepare_uniform_interval_state(start: CInt, end: CInt, q: QArray[QBit]) -> N
         2. The synthesis engine automatically handles the allocation, either by drawing new qubits from the available pool or by reusing existing ones.
     """
     prepare_uniform_trimmed_state(end - start, q)
-    modular_increment(start, q)
+    inplace_add(start, q)
 
 
 @qfunc
@@ -199,7 +196,9 @@ def prepare_exponential_state(rate: CInt, q: QArray[QBit]) -> None:
 
 
 @qfunc
-def prepare_bell_state(state_num: CInt, q: Output[QArray[QBit, Literal[2]]]) -> None:
+def prepare_bell_state(
+    state_num: CInt, qpair: Output[QArray[QBit, Literal[2]]]
+) -> None:
     """
     [Qmod Classiq-library function]
 
@@ -207,7 +206,7 @@ def prepare_bell_state(state_num: CInt, q: Output[QArray[QBit, Literal[2]]]) ->
 
     Args:
         state_num: The number of the Bell state to be prepared. Must be an integer between 0 and 3.
-        q: The quantum variable that will receive the initialized state. Must be uninitialized.
+        qpair: The quantum variable that will receive the initialized state. Must be uninitialized.
 
     Bell States:
         The four Bell states are defined as follows (each state correlates to an integer between 0 and 3 as defined by the `state_num` argument):
@@ -241,11 +240,11 @@ def prepare_bell_state(state_num: CInt, q: Output[QArray[QBit, Literal[2]]]) ->
 
 
     """
-    allocate(2, q)
-    if_(logical_or(state_num == 1, state_num == 3), lambda: X(q[0]))
-    if_(logical_or(state_num == 2, state_num == 3), lambda: X(q[1]))
-    H(q[0])
-    CX(q[0], q[1])
+    allocate(qpair)
+    if_(logical_or(state_num == 1, state_num == 3), lambda: X(qpair[0]))
+    if_(logical_or(state_num == 2, state_num == 3), lambda: X(qpair[1]))
+    H(qpair[0])
+    CX(qpair[0], qpair[1])
 
 
 @qfunc

classiq/open_library/functions/swap_test.py

@@ -21,7 +21,7 @@ def swap_test(state1: QArray[QBit], state2: QArray[QBit], test: Output[QBit]) ->
         state2: A quantum state to check its overlap with state1.
         test: A qubit for which the probability of measuring 0 is $0.5*(|\\langle state1 | state2 \\rangle |^2+1)$
     """
-    allocate(1, test)
+    allocate(test)
     H(test)
     control(test, lambda: repeat(state1.len, lambda i: SWAP(state1[i], state2[i])))
     H(test)

classiq/open_library/functions/utility_functions.py

@@ -1,5 +1,8 @@
+import warnings
 from typing import Annotated
 
+from classiq.interface.exceptions import ClassiqDeprecationWarning
+
 from classiq.open_library.functions.qft_functions import qft
 from classiq.qmod.builtins.functions.standard_gates import PHASE, H
 from classiq.qmod.builtins.operations import bind, repeat, within_apply
@@ -44,7 +47,7 @@ def hadamard_transform(target: QArray[QBit]) -> None:
         target:  qubits to apply to Hadamard transform to.
 
     """
-    apply_to_all(H, target)
+    repeat(target.len, lambda index: H(target[index]))
 
 
 @qfunc
@@ -69,7 +72,12 @@ def modular_increment(a: CInt, x: QNum) -> None:
         x: A quantum number that is assumed to be non-negative integer.
 
     """
-    array_cast: QArray = QArray("array_cast")
+    warnings.warn(
+        "Function 'modular_increment' is deprecated. Use in-place-add statement in the form '<var> += <expression>'  or 'inplace_add(<expression>, <var>)' instead.",
+        ClassiqDeprecationWarning,
+        stacklevel=1,
+    )
+    array_cast: QArray = QArray()
     within_apply(
         lambda: (  # type:ignore[arg-type]
             bind(x, array_cast),  # type:ignore[func-returns-value]

classiq/qmod/builtins/functions/__init__.py

@@ -4,6 +4,7 @@ from .benchmarking import *
 from .chemistry import *
 from .exponentiation import *
 from .finance import *
+from .mid_circuit_measurement import *
 from .operators import *
 from .qsvm import *
 from .standard_gates import *
@@ -66,6 +67,7 @@ CORE_LIB_DECLS = [
         suzuki_trotter,
         qdrift,
         exponentiation_with_depth_constraint,
+        RESET,
     )
 ]
 
@@ -129,6 +131,7 @@ __all__ = [  # noqa: RUF022
     "single_pauli_exponent",
     "suzuki_trotter",
     "unitary",
+    "RESET",
 ]
 BUILTIN_FUNCTION_DECLARATIONS = {
     func_decl.name: func_decl for func_decl in STD_QMOD_OPERATORS + CORE_LIB_DECLS

classiq/qmod/builtins/functions/chemistry.py

@@ -1,5 +1,3 @@
-from typing import Literal
-
 from classiq.qmod.builtins.structs import (
     FockHamiltonianProblem,
     MoleculeProblem,
@@ -13,12 +11,7 @@ from classiq.qmod.qmod_variable import QArray, QBit
 def molecule_ucc(
     molecule_problem: MoleculeProblem,
     excitations: CArray[CInt],
-    qbv: QArray[
-        QBit,
-        Literal[
-            "get_field(get_field(molecule_problem_to_hamiltonian(molecule_problem)[0], 'pauli'), 'len')"
-        ],
-    ],
+    qbv: QArray[QBit],
 ) -> None:
     pass
 
@@ -27,12 +20,7 @@ def molecule_ucc(
 def molecule_hva(
     molecule_problem: MoleculeProblem,
     reps: CInt,
-    qbv: QArray[
-        QBit,
-        Literal[
-            "get_field(get_field(molecule_problem_to_hamiltonian(molecule_problem)[0], 'pauli'), 'len')"
-        ],
-    ],
+    qbv: QArray[QBit],
 ) -> None:
     pass
 
@@ -40,12 +28,7 @@ def molecule_hva(
 @qfunc(external=True)
 def molecule_hartree_fock(
     molecule_problem: MoleculeProblem,
-    qbv: QArray[
-        QBit,
-        Literal[
-            "get_field(get_field(molecule_problem_to_hamiltonian(molecule_problem)[0], 'pauli'), 'len')"
-        ],
-    ],
+    qbv: QArray[QBit],
 ) -> None:
     pass
 
@@ -54,12 +37,7 @@ def molecule_hartree_fock(
 def fock_hamiltonian_ucc(
     fock_hamiltonian_problem: FockHamiltonianProblem,
     excitations: CArray[CInt],
-    qbv: QArray[
-        QBit,
-        Literal[
-            "get_field(get_field(fock_hamiltonian_problem_to_hamiltonian(fock_hamiltonian_problem)[0], 'pauli'), 'len')"
-        ],
-    ],
+    qbv: QArray[QBit],
 ) -> None:
     pass
 
@@ -68,12 +46,7 @@ def fock_hamiltonian_ucc(
 def fock_hamiltonian_hva(
     fock_hamiltonian_problem: FockHamiltonianProblem,
     reps: CInt,
-    qbv: QArray[
-        QBit,
-        Literal[
-            "get_field(get_field(fock_hamiltonian_problem_to_hamiltonian(fock_hamiltonian_problem)[0], 'pauli'), 'len')"
-        ],
-    ],
+    qbv: QArray[QBit],
 ) -> None:
     pass
 
@@ -81,11 +54,6 @@ def fock_hamiltonian_hva(
 @qfunc(external=True)
 def fock_hamiltonian_hartree_fock(
     fock_hamiltonian_problem: FockHamiltonianProblem,
-    qbv: QArray[
-        QBit,
-        Literal[
-            "get_field(get_field(fock_hamiltonian_problem_to_hamiltonian(fock_hamiltonian_problem)[0], 'pauli'), 'len')"
-        ],
-    ],
+    qbv: QArray[QBit],
 ) -> None:
     pass

classiq/qmod/builtins/functions/mid_circuit_measurement.py

@@ -0,0 +1,15 @@
+from classiq.qmod.qfunc import qfunc
+from classiq.qmod.qmod_variable import QBit
+
+
+@qfunc(external=True)
+def RESET(target: QBit) -> None:
+    """
+    Resets the target qubit to the |0> state.
+
+    Performed by measuring the qubit and applying an X gate if necessary.
+
+    Args:
+        target: the qubit to reset
+    """
+    pass

classiq/qmod/quantum_expandable.py

@@ -1,5 +1,6 @@
 import inspect
 from abc import ABC
+from collections.abc import Generator, Iterable
 from dataclasses import is_dataclass
 from enum import Enum as PythonEnum
 from types import TracebackType
@@ -67,7 +68,10 @@ from classiq.qmod.qmod_variable import (
 from classiq.qmod.quantum_callable import QCallable, QExpandableInterface
 from classiq.qmod.symbolic_expr import SymbolicExpr
 from classiq.qmod.type_attribute_remover import decl_without_type_attributes
-from classiq.qmod.utilities import mangle_keyword, qmod_val_to_expr_str
+from classiq.qmod.utilities import (
+    mangle_keyword,
+    qmod_val_to_expr_str,
+)
 
 ArgType = Union[CParam, QVar, QCallable]
 
@@ -371,11 +375,14 @@ def prepare_arg(
 def _validate_classical_arg(
     arg: Any, arg_decl: AnonClassicalParameterDeclaration, func_name: Optional[str]
 ) -> None:
-    is_native_or_compatible_type = not isinstance(
-        arg, (*NativePythonClassicalTypes, CParam, SymbolicExpr, Basic, PythonEnum)
-    ) and not is_dataclass(
-        arg
-    )  # type: ignore[unreachable]
+    is_native_or_compatible_type = (
+        not isinstance(
+            arg,
+            (*NativePythonClassicalTypes, CParam, SymbolicExpr, Basic, PythonEnum),
+        )
+        and not _is_legal_iterable(arg)
+        and not is_dataclass(arg)  # type: ignore[unreachable]
+    )
     try:
         is_pydantic_classical_type = isinstance(
             arg, pydantic.BaseModel
@@ -481,3 +488,20 @@ def _create_quantum_function_call(
     return QuantumFunctionCall(
         function=function_ident, positional_args=prepared_args, source_ref=source_ref_
     )
+
+
+_FORBIDDEN_ITERABLES = (set, dict, str, Generator)
+
+
+def _is_legal_iterable(arg: Any) -> bool:
+    if not isinstance(arg, Iterable) or isinstance(arg, _FORBIDDEN_ITERABLES):
+        return False
+    return all(_is_legal_iterable_element(e) for e in arg)
+
+
+def _is_legal_iterable_element(arg: Any) -> bool:
+    if isinstance(arg, _FORBIDDEN_ITERABLES):
+        return False
+    if isinstance(arg, Iterable):
+        return all(_is_legal_iterable_element(e) for e in arg)
+    return True

classiq/qmod/quantum_function.py

@@ -31,6 +31,7 @@ from classiq.qmod.qmod_parameter import CArray, CParam
 from classiq.qmod.qmod_variable import QVar
 from classiq.qmod.quantum_callable import QCallable, QCallableList
 from classiq.qmod.quantum_expandable import QExpandable, QTerminalCallable
+from classiq.qmod.semantics.annotation.qstruct_annotator import QStructAnnotator
 from classiq.qmod.utilities import mangle_keyword
 
 
@@ -161,6 +162,9 @@ class QFunc(BaseQFunc):
         )
 
         generative_functions = list(self._qmodule.generative_functions.values())
+        QStructAnnotator().visit(model_stub)
+        for gen_func in generative_functions:
+            QStructAnnotator().visit(gen_func.func_decl)
         resolve_function_calls(
             model_stub,
             dict(model_stub.function_dict)

classiq/qmod/semantics/annotation/call_annotation.py

@@ -1,6 +1,6 @@
 from collections.abc import Iterator, Mapping
 from contextlib import contextmanager
-from typing import Any
+from typing import Any, Optional
 
 from classiq.interface.exceptions import ClassiqError
 from classiq.interface.generator.expressions.expression import Expression
@@ -11,6 +11,7 @@ from classiq.interface.generator.functions.port_declaration import (
 from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
 )
+from classiq.interface.model.model import Model
 from classiq.interface.model.model_visitor import ModelVisitor
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.port_declaration import PortDeclaration
@@ -108,8 +109,13 @@ class _CallLambdaAnnotator(ModelVisitor):
 
 def resolve_function_calls(
     root: Any,
-    quantum_function_dict: Mapping[str, QuantumFunctionDeclaration],
+    quantum_function_dict: Optional[Mapping[str, QuantumFunctionDeclaration]] = None,
 ) -> None:
+    if quantum_function_dict is None:
+        quantum_function_dict = {}
+    quantum_function_dict = dict(quantum_function_dict)
+    if isinstance(root, Model):
+        quantum_function_dict |= root.function_dict
     all_functions: Mapping[str, QuantumFunctionDeclaration] = {
         **BUILTIN_FUNCTION_DECLARATIONS,
         **quantum_function_dict,

classiq/qmod/semantics/annotation/model_annotation.py

@@ -0,0 +1,9 @@
+from classiq.interface.model.model import Model
+
+from classiq.qmod.semantics.annotation.call_annotation import resolve_function_calls
+from classiq.qmod.semantics.annotation.qstruct_annotator import QStructAnnotator
+
+
+def annotate_model(model: Model) -> None:
+    QStructAnnotator().visit(model)
+    resolve_function_calls(model)

classiq/qmod/semantics/error_manager.py

@@ -94,9 +94,3 @@ class ErrorManager:
         self._call_stack.append(func_name)
         yield
         self._call_stack.pop()
-
-
-def append_error(node: ASTNode, message: str) -> None:
-    instance = ErrorManager()
-    with instance.node_context(node):
-        instance.add_error(message)