classiq 0.43.3__py3-none-any.whl → 0.45.0__py3-none-any.whl

classiq/qmod/quantum_callable.py

@@ -12,13 +12,13 @@ from typing import (  # type: ignore[attr-defined]
 
 from typing_extensions import ParamSpec
 
-from classiq.interface.ast_node import SourceReference
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_function_declaration import (
-    QuantumFunctionDeclaration,
+    AnonQuantumFunctionDeclaration,
 )
 from classiq.interface.model.quantum_statement import QuantumStatement
 from classiq.interface.model.quantum_type import QuantumType
+from classiq.interface.source_reference import SourceReference
 
 from classiq.qmod.qmod_parameter import CInt
 from classiq.qmod.utilities import get_source_ref
@@ -58,7 +58,7 @@ class QCallable(Generic[P], ABC):
 
     @property
     @abstractmethod
-    def func_decl(self) -> QuantumFunctionDeclaration:
+    def func_decl(self) -> AnonQuantumFunctionDeclaration:
         raise NotImplementedError
 
     # Support comma-separated generic args in older Python versions

classiq/qmod/quantum_expandable.py

@@ -20,24 +20,23 @@ from typing import (
 from sympy import Basic
 from typing_extensions import Self
 
-from classiq.interface.ast_node import SourceReference
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.functions.classical_type import (
-    PythonClassicalTypes,
-)
+from classiq.interface.generator.functions.concrete_types import PythonClassicalTypes
 from classiq.interface.model.classical_parameter_declaration import (
-    ClassicalParameterDeclaration,
+    AnonClassicalParameterDeclaration,
 )
-from classiq.interface.model.port_declaration import PortDeclaration
+from classiq.interface.model.port_declaration import AnonPortDeclaration
 from classiq.interface.model.quantum_function_call import (
     ArgValue,
     OperandIdentifier,
     QuantumFunctionCall,
 )
 from classiq.interface.model.quantum_function_declaration import (
-    PositionalArg,
+    AnonPositionalArg,
+    AnonQuantumFunctionDeclaration,
+    AnonQuantumOperandDeclaration,
     QuantumFunctionDeclaration,
-    QuantumOperandDeclaration,
 )
 from classiq.interface.model.quantum_lambda_function import QuantumLambdaFunction
 from classiq.interface.model.quantum_statement import QuantumStatement
@@ -45,14 +44,25 @@ from classiq.interface.model.quantum_type import QuantumType
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
+from classiq.interface.source_reference import SourceReference
 
-from classiq.exceptions import ClassiqValueError
 from classiq.qmod.model_state_container import QMODULE, ModelStateContainer
 from classiq.qmod.qmod_constant import QConstant
-from classiq.qmod.qmod_parameter import CInt, CParam, CParamScalar, create_param
-from classiq.qmod.qmod_variable import QVar, create_qvar_for_port_decl
+from classiq.qmod.qmod_parameter import (
+    CInt,
+    CParam,
+    CParamScalar,
+    create_param,
+    get_qmod_type,
+)
+from classiq.qmod.qmod_variable import (
+    QVar,
+    create_qvar_for_port_decl,
+    set_symbolic_qvar_properties,
+)
 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
 
 ArgType = Union[CParam, QVar, QCallable]
@@ -89,11 +99,11 @@ class QExpandable(QCallable, QExpandableInterface, ABC):
 
     def expand(self) -> None:
         if self not in QExpandable.STACK:
-            with self:
+            with self, set_symbolic_qvar_properties(True):
                 self._py_callable(*self._get_positional_args())
 
-    def infer_rename_params(self) -> Dict[str, str]:
-        return {}
+    def infer_rename_params(self) -> Optional[List[str]]:
+        return None
 
     def add_local_handle(
         self,
@@ -112,60 +122,94 @@ class QExpandable(QCallable, QExpandableInterface, ABC):
 
     def _get_positional_args(self) -> List[ArgType]:
         result: List[ArgType] = []
-        for arg in self.func_decl.get_positional_arg_decls():
-            rename_dict = self.infer_rename_params()
-            actual_name = rename_dict.get(arg.name, arg.name)
-            if isinstance(arg, ClassicalParameterDeclaration):
+        for idx, arg in enumerate(self.func_decl.positional_arg_declarations):
+            rename_params = self.infer_rename_params()
+            actual_name = (
+                rename_params[idx] if rename_params is not None else arg.get_name()
+            )
+            if isinstance(arg, AnonClassicalParameterDeclaration):
                 result.append(
                     create_param(actual_name, arg.classical_type, self._qmodule)
                 )
-            elif isinstance(arg, PortDeclaration):
+            elif isinstance(arg, AnonPortDeclaration):
                 result.append(create_qvar_for_port_decl(arg, actual_name))
             else:
-                assert isinstance(arg, QuantumOperandDeclaration)
-                result.append(QTerminalCallable(arg))
+                assert isinstance(arg, AnonQuantumOperandDeclaration)
+                result.append(QTerminalCallable(arg, idx))
         return result
 
     def create_quantum_function_call(
         self, source_ref_: SourceReference, *args: Any, **kwargs: Any
     ) -> QuantumFunctionCall:
+        func_decl = self.func_decl
+        if not isinstance(func_decl, QuantumFunctionDeclaration):
+            raise NotImplementedError
         return _create_quantum_function_call(
-            self.func_decl, None, source_ref_, *args, **kwargs
+            func_decl, None, source_ref_, *args, **kwargs
         )
 
 
 class QLambdaFunction(QExpandable):
-    def __init__(self, decl: QuantumFunctionDeclaration, py_callable: Callable) -> None:
+    def __init__(
+        self, decl: AnonQuantumFunctionDeclaration, py_callable: Callable
+    ) -> None:
         py_callable.__annotations__.pop("return", None)
         super().__init__(py_callable)
         self._decl = decl
 
     @property
-    def func_decl(self) -> QuantumFunctionDeclaration:
+    def func_decl(self) -> AnonQuantumFunctionDeclaration:
         return self._decl
 
-    def infer_rename_params(self) -> Dict[str, str]:
-        py_params = inspect.getfullargspec(self._py_callable)
-        decl_params = self.func_decl.get_positional_arg_decls()
-        return {
-            decl_param.name: py_param
-            for decl_param, py_param in zip(decl_params, py_params.args)
-            if decl_param.name != py_param
-        }
+    def infer_rename_params(self) -> List[str]:
+        return inspect.getfullargspec(self._py_callable).args
 
 
 class QTerminalCallable(QCallable):
+    @overload
     def __init__(
         self,
         decl: QuantumFunctionDeclaration,
+        param_idx: Optional[int] = None,
         index_: Optional[Union[int, CParamScalar]] = None,
     ) -> None:
-        self._decl = decl
+        pass
+
+    @overload
+    def __init__(
+        self,
+        decl: AnonQuantumFunctionDeclaration,
+        param_idx: int,
+        index_: Optional[Union[int, CParamScalar]] = None,
+    ) -> None:
+        pass
+
+    def __init__(
+        self,
+        decl: AnonQuantumFunctionDeclaration,
+        param_idx: Optional[int] = None,
+        index_: Optional[Union[int, CParamScalar]] = None,
+    ) -> None:
+        self._decl = self._override_decl_name(decl, param_idx)
         self._index = index_
 
+    @staticmethod
+    def _override_decl_name(
+        decl: AnonQuantumFunctionDeclaration, param_idx: Optional[int]
+    ) -> QuantumFunctionDeclaration:
+        if (
+            not isinstance(QCallable.CURRENT_EXPANDABLE, QLambdaFunction)
+            or param_idx is None
+        ):
+            return decl.rename(decl.get_name())
+        rename_params = QCallable.CURRENT_EXPANDABLE.infer_rename_params()
+        return decl.rename(new_name=rename_params[param_idx])
+
     @property
     def is_list(self) -> bool:
-        return isinstance(self._decl, QuantumOperandDeclaration) and self._decl.is_list
+        return (
+            isinstance(self._decl, AnonQuantumOperandDeclaration) and self._decl.is_list
+        )
 
     def __getitem__(self, key: Union[slice, int, CInt]) -> "QTerminalCallable":
         if not self.is_list:
@@ -174,7 +218,7 @@ class QTerminalCallable(QCallable):
             raise NotImplementedError("Operand lists don't support slicing")
         if isinstance(key, CParam) and not isinstance(key, CParamScalar):
             raise ClassiqValueError("Non-classical parameter for slicing")
-        return QTerminalCallable(self._decl, key)
+        return QTerminalCallable(self._decl, index_=key)
 
     def __len__(self) -> int:
         raise ClassiqValueError(
@@ -212,43 +256,54 @@ class QTerminalCallable(QCallable):
 
 @overload
 def prepare_arg(
-    arg_decl: PositionalArg, val: Union[QCallable, Callable[..., None]], func_name: str
+    arg_decl: AnonPositionalArg,
+    val: Union[QCallable, Callable[..., None]],
+    func_name: Optional[str],
+    param_name: str,
 ) -> QuantumLambdaFunction: ...
 
 
 @overload
-def prepare_arg(arg_decl: PositionalArg, val: Any, func_name: str) -> ArgValue: ...
+def prepare_arg(
+    arg_decl: AnonPositionalArg, val: Any, func_name: Optional[str], param_name: str
+) -> ArgValue: ...
 
 
-def prepare_arg(arg_decl: PositionalArg, val: Any, func_name: str) -> ArgValue:
+def prepare_arg(
+    arg_decl: AnonPositionalArg, val: Any, func_name: Optional[str], param_name: str
+) -> ArgValue:
     if isinstance(val, QConstant):
         val.add_to_model()
         return Expression(expr=str(val.name))
-    if isinstance(arg_decl, ClassicalParameterDeclaration):
+    if isinstance(arg_decl, AnonClassicalParameterDeclaration):
         _validate_classical_arg(val, arg_decl, func_name)
         return Expression(expr=qmod_val_to_expr_str(val))
-    elif isinstance(arg_decl, PortDeclaration):
+    elif isinstance(arg_decl, AnonPortDeclaration):
         if not isinstance(val, QVar):
+            func_name_message = (
+                "" if func_name is None else f" of function {func_name!r}"
+            )
             raise ClassiqValueError(
-                f"Argument {str(val)!r} to parameter {arg_decl.name!r} of function "
-                f"{func_name!r} has incompatible type; expected quantum variable"
+                f"Argument {str(val)!r} to parameter {param_name!r}{func_name_message} "
+                f"has incompatible type; expected quantum variable"
             )
         return val.get_handle_binding()
     else:
         if isinstance(val, list):
             if not all(isinstance(v, QCallable) or callable(v) for v in val):
                 raise ClassiqValueError(
-                    f"Quantum operand {arg_decl.name!r} cannot be initialized with a "
+                    f"Quantum operand {param_name!r} cannot be initialized with a "
                     f"list of non-callables"
                 )
             val = cast(List[Union[QCallable, Callable[[Any], None]]], val)
-            return [prepare_arg(arg_decl, v, func_name) for v in val]
+            return [prepare_arg(arg_decl, v, func_name, param_name) for v in val]
 
         if not isinstance(val, QCallable):
-            val = QLambdaFunction(arg_decl, val)
+            new_arg_decl = decl_without_type_attributes(arg_decl)
+            val = QLambdaFunction(new_arg_decl, val)
             val.expand()
             return QuantumLambdaFunction(
-                rename_params=val.infer_rename_params(),
+                pos_rename_params=val.infer_rename_params(),
                 body=val.body,
             )
 
@@ -258,7 +313,7 @@ def prepare_arg(arg_decl: PositionalArg, val: Any, func_name: str) -> ArgValue:
 
 
 def _validate_classical_arg(
-    arg: Any, arg_decl: ClassicalParameterDeclaration, func_name: str
+    arg: Any, arg_decl: AnonClassicalParameterDeclaration, func_name: Optional[str]
 ) -> None:
     if (
         not isinstance(
@@ -268,15 +323,16 @@ def _validate_classical_arg(
         or isinstance(arg, SymbolicExpr)
         and arg.is_quantum
     ):
+        func_name_message = "" if func_name is None else f" of function {func_name!r}"
         raise ClassiqValueError(
-            f"Argument {str(arg)!r} to parameter {arg_decl.name!r} of function "
-            f"{func_name!r} has incompatible type; expected "
-            f"{arg_decl.classical_type.qmod_type.__name__}"
+            f"Argument {str(arg)!r} to parameter {arg_decl.name!r}{func_name_message} "
+            f"has incompatible type; expected "
+            f"{get_qmod_type(arg_decl.classical_type).__name__}"
         )
 
 
 def _get_operand_hint_args(
-    func: QuantumFunctionDeclaration, param: PositionalArg, param_value: str
+    func: AnonQuantumFunctionDeclaration, param: AnonPositionalArg, param_value: str
 ) -> str:
     return ", ".join(
         [
@@ -285,39 +341,43 @@ def _get_operand_hint_args(
                 if decl.name == param.name
                 else f"{decl.name}=..."
             )
-            for decl in func.get_positional_arg_decls()
+            for decl in func.positional_arg_declarations
         ]
     )
 
 
-def _get_operand_hint(func: QuantumFunctionDeclaration, param: PositionalArg) -> str:
+def _get_operand_hint(
+    func: AnonQuantumFunctionDeclaration, param: AnonPositionalArg
+) -> str:
     return (
-        f"\nHint: To create an operand, do not call quantum gates directly "
-        f"`{func.name}({_get_operand_hint_args(func, param, 'H(q)')})`. "
-        f"Instead, use a lambda function "
-        f"`{func.name}({_get_operand_hint_args(func, param, 'lambda: H(q)')})` "
-        f"or a quantum function "
-        f"`{func.name}({_get_operand_hint_args(func, param, 'my_func')})`"
+        f"\nHint: To call a function under {func.name!r} use a lambda function as in "
+        f"'{func.name}({_get_operand_hint_args(func, param, 'lambda: f(q)')})' "
+        f"or pass the quantum function directly as in "
+        f"'{func.name}({_get_operand_hint_args(func, param, 'f')})'."
     )
 
 
 def _prepare_args(
-    decl: QuantumFunctionDeclaration, arg_list: List[Any], kwargs: Dict[str, Any]
+    decl: AnonQuantumFunctionDeclaration, arg_list: List[Any], kwargs: Dict[str, Any]
 ) -> List[ArgValue]:
     result = []
-    for arg_decl in decl.get_positional_arg_decls():
+    for idx, arg_decl in enumerate(decl.positional_arg_declarations):
+        arg = None
         if arg_list:
             arg = arg_list.pop(0)
-        else:
+        elif arg_decl.name is not None:
             arg = kwargs.pop(mangle_keyword(arg_decl.name), None)
         if arg is None:
-            error_message = (
-                f"{decl.name!r} is missing required argument for {arg_decl.name!r}"
-            )
-            if isinstance(arg_decl, QuantumOperandDeclaration):
+            if arg_decl.name is not None:
+                param_name = repr(arg_decl.name)
+            else:
+                param_name = f"#{idx + 1}"
+            error_message = f"Missing required argument for parameter {param_name}"
+            if isinstance(arg_decl, AnonQuantumOperandDeclaration):
                 error_message += _get_operand_hint(decl, arg_decl)
             raise ClassiqValueError(error_message)
-        result.append(prepare_arg(arg_decl, arg, decl.name))
+        param_name = arg_decl.name if arg_decl.name is not None else f"#{idx + 1}"
+        result.append(prepare_arg(arg_decl, arg, decl.name, param_name))
 
     return result
 
@@ -329,7 +389,7 @@ def _create_quantum_function_call(
     *args: Any,
     **kwargs: Any,
 ) -> QuantumFunctionCall:
-    arg_decls = decl_.get_positional_arg_decls()
+    arg_decls = decl_.positional_arg_declarations
     arg_list = list(args)
     prepared_args = _prepare_args(decl_, arg_list, kwargs)
 

classiq/qmod/quantum_function.py

@@ -5,27 +5,30 @@ from enum import EnumMeta
 from inspect import isclass
 from typing import Any, Callable, Dict, List, Optional, Tuple, get_origin
 
+from classiq.interface.exceptions import ClassiqError
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
 from classiq.interface.generator.model.constraints import Constraints
 from classiq.interface.generator.model.preferences.preferences import Preferences
 from classiq.interface.model.model import Model, SerializedModel
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.quantum_function_declaration import (
+    NamedParamsQuantumFunctionDeclaration,
     QuantumFunctionDeclaration,
 )
 
-from classiq.exceptions import ClassiqError
 from classiq.qmod.classical_function import CFunc
 from classiq.qmod.declaration_inferrer import infer_func_decl
+from classiq.qmod.model_state_container import QMODULE
 from classiq.qmod.qmod_constant import QConstant
 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.utilities import mangle_keyword, unmangle_keyword
+from classiq.qmod.write_qmod import write_qmod
 
 
-def _lookup_qfunc(name: str) -> Optional[QuantumFunctionDeclaration]:
+def _lookup_qfunc(name: str) -> Optional[NamedParamsQuantumFunctionDeclaration]:
     # FIXME: to be generalized to existing user-defined functions
     return QuantumFunctionDeclaration.BUILTIN_FUNCTION_DECLARATIONS.get(name)
 
@@ -36,15 +39,21 @@ def create_model(
     execution_preferences: Optional[ExecutionPreferences] = None,
     preferences: Optional[Preferences] = None,
     classical_execution_function: Optional[CFunc] = None,
+    out_file: Optional[str] = None,
 ) -> SerializedModel:
     if entry_point.func_decl.name != "main":
         raise ClassiqError(
             f"The entry point function must be named 'main', got '{entry_point.func_decl.name}'"
         )
-    return entry_point.create_model(
+    result = entry_point.create_model(
         constraints, execution_preferences, preferences, classical_execution_function
     ).get_model()
 
+    if out_file is not None:
+        write_qmod(result, out_file)
+
+    return result
+
 
 class QFunc(QExpandable):
     FRAME_DEPTH = 2
@@ -55,7 +64,7 @@ class QFunc(QExpandable):
         functools.update_wrapper(self, py_callable)
 
     @property
-    def func_decl(self) -> QuantumFunctionDeclaration:
+    def func_decl(self) -> NamedParamsQuantumFunctionDeclaration:
         return self._qmodule.native_defs.get(
             self._py_callable.__name__,
             infer_func_decl(self._py_callable, qmodule=self._qmodule),
@@ -74,6 +83,7 @@ class QFunc(QExpandable):
     ) -> Model:
         self._qmodule.enum_decls = dict()
         self._qmodule.type_decls = dict()
+        self._qmodule.qstruct_decls = dict()
         self._qmodule.native_defs = dict()
         self._qmodule.constants = dict()
         QConstant.set_current_model(self._qmodule)
@@ -93,6 +103,7 @@ class QFunc(QExpandable):
             functions=list(self._qmodule.native_defs.values()),
             enums=list(self._qmodule.enum_decls.values()),
             types=list(self._qmodule.type_decls.values()),
+            qstructs=list(self._qmodule.qstruct_decls.values()),
             **{key: value for key, value in model_extra_settings if value},
         )
 
@@ -138,7 +149,7 @@ class ExternalQFunc(QTerminalCallable):
 
         py_callable.__annotations__.pop("return", None)
         if py_callable.__annotations__.keys() != {
-            mangle_keyword(arg.name) for arg in decl.get_positional_arg_decls()
+            mangle_keyword(arg.name) for arg in decl.positional_arg_declarations
         }:
             raise ClassiqError(
                 f"Parameter type hints for {py_callable.__name__!r} do not match imported declaration"
@@ -147,6 +158,14 @@ class ExternalQFunc(QTerminalCallable):
         functools.update_wrapper(self, py_callable)
 
 
+class GenerativeQFunc(QTerminalCallable):
+    func_decl: NamedParamsQuantumFunctionDeclaration
+
+    def __init__(self, py_callable: Callable) -> None:
+        super().__init__(infer_func_decl(py_callable, QMODULE))
+        self.py_callable = py_callable
+
+
 ILLEGAL_PARAM_ERROR = "Unsupported type hint '{annotation}' for argument '{name}'."
 
 

classiq/qmod/semantics/annotation.py

@@ -1,17 +1,15 @@
-from typing import List, Mapping
+from typing import Mapping
 
+from classiq.interface.exceptions import ClassiqError
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_function_declaration import (
+    AnonQuantumOperandDeclaration,
     QuantumFunctionDeclaration,
 )
 from classiq.interface.model.quantum_lambda_function import (
-    QuantumCallable,
     QuantumLambdaFunction,
-    QuantumOperand,
 )
 
-from classiq.exceptions import ClassiqError
-
 
 def annotate_function_call_decl(
     fc: QuantumFunctionCall,
@@ -25,14 +23,14 @@ def annotate_function_call_decl(
             )
         fc.set_func_decl(func_decl)
 
-    for name, op in fc.operands.items():
-        op_decl = fc.func_decl.operand_declarations[name]
-        for qlambda in _get_lambda_defs(op):
+    for arg, param in zip(fc.positional_args, fc.func_decl.positional_arg_declarations):
+        if not isinstance(param, AnonQuantumOperandDeclaration):
+            continue
+        args: list
+        if isinstance(arg, list):
+            args = arg
+        else:
+            args = [arg]
+        for qlambda in args:
             if isinstance(qlambda, QuantumLambdaFunction):
-                qlambda.set_op_decl(op_decl)
-
-
-def _get_lambda_defs(operand: QuantumOperand) -> List[QuantumCallable]:
-    if isinstance(operand, list):
-        return operand
-    return [operand]
+                qlambda.set_op_decl(param)

classiq/qmod/semantics/error_manager.py

@@ -1,7 +1,8 @@
 from contextlib import contextmanager
-from typing import Iterator, List, Type
+from typing import Iterator, List, Optional, Type
 
 from classiq.interface.ast_node import ASTNode
+from classiq.interface.source_reference import SourceReferencedError
 
 
 class ErrorManager:
@@ -14,19 +15,28 @@ class ErrorManager:
         if hasattr(self, "_instantiated"):
             return
         self._instantiated = True
-        self._errors: List[str] = []
+        self._errors: List[SourceReferencedError] = []
         self._current_nodes_stack: List[ASTNode] = []
+        self._call_stack: List[str] = []
+
+    @property
+    def annotated_errors(self) -> List[str]:
+        return [str(error) for error in self._errors]
 
     def add_error(self, error: str) -> None:
-        source_referenced_error = (
-            f"{error}\n\t\tat {self._current_nodes_stack[-1].source_ref}"
-            if self._current_nodes_stack
-            and self._current_nodes_stack[-1].source_ref is not None
-            else error
+        self._errors.append(
+            SourceReferencedError(
+                error=error,
+                source_ref=(
+                    self._current_nodes_stack[-1].source_ref
+                    if self._current_nodes_stack
+                    else None
+                ),
+                function=self.current_function,
+            )
         )
-        self._errors.append(source_referenced_error)
 
-    def get_errors(self) -> List[str]:
+    def get_errors(self) -> List[SourceReferencedError]:
         return self._errors
 
     def clear(self) -> None:
@@ -38,12 +48,28 @@ class ErrorManager:
 
     def report_errors(self, error_type: Type[Exception]) -> None:
         if self.has_errors():
-            errors = self._errors
+            errors = self.annotated_errors
             self.clear()
             raise error_type("\n\t" + "\n\t".join(errors))
 
+    @property
+    def current_function(self) -> Optional[str]:
+        return self._call_stack[-1] if self._call_stack else None
+
     @contextmanager
     def node_context(self, node: ASTNode) -> Iterator[None]:
         self._current_nodes_stack.append(node)
         yield
         self._current_nodes_stack.pop()
+
+    @contextmanager
+    def call(self, func_name: str) -> Iterator[None]:
+        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)