jaclang 0.6.2__py3-none-any.whl → 0.9.5__py3-none-any.whl

jaclang/vendor/mypy/nodes.py

@@ -1,4199 +0,0 @@
-"""Abstract syntax tree node classes (i.e. parse tree)."""
-
-from __future__ import annotations
-
-import os
-from abc import abstractmethod
-from collections import defaultdict
-from enum import Enum, unique
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Callable,
-    Dict,
-    Final,
-    Iterator,
-    List,
-    Optional,
-    Sequence,
-    Tuple,
-    TypeVar,
-    Union,
-    cast,
-)
-from typing_extensions import TypeAlias as _TypeAlias, TypeGuard
-
-from mypy_extensions import trait
-
-import mypy.strconv
-from mypy.options import Options
-from mypy.util import is_typeshed_file, short_type
-from mypy.visitor import ExpressionVisitor, NodeVisitor, StatementVisitor
-
-if TYPE_CHECKING:
-    from mypy.patterns import Pattern
-
-
-class Context:
-    """Base type for objects that are valid as error message locations."""
-
-    __slots__ = ("line", "column", "end_line", "end_column")
-
-    def __init__(self, line: int = -1, column: int = -1) -> None:
-        self.line = line
-        self.column = column
-        self.end_line: int | None = None
-        self.end_column: int | None = None
-
-    def set_line(
-        self,
-        target: Context | int,
-        column: int | None = None,
-        end_line: int | None = None,
-        end_column: int | None = None,
-    ) -> None:
-        """If target is a node, pull line (and column) information
-        into this node. If column is specified, this will override any column
-        information coming from a node.
-        """
-        if isinstance(target, int):
-            self.line = target
-        else:
-            self.line = target.line
-            self.column = target.column
-            self.end_line = target.end_line
-            self.end_column = target.end_column
-
-        if column is not None:
-            self.column = column
-
-        if end_line is not None:
-            self.end_line = end_line
-
-        if end_column is not None:
-            self.end_column = end_column
-
-
-if TYPE_CHECKING:
-    # break import cycle only needed for mypy
-    import mypy.types
-
-
-T = TypeVar("T")
-
-JsonDict: _TypeAlias = Dict[str, Any]
-
-
-# Symbol table node kinds
-#
-# TODO rename to use more descriptive names
-
-LDEF: Final = 0
-GDEF: Final = 1
-MDEF: Final = 2
-
-# Placeholder for a name imported via 'from ... import'. Second phase of
-# semantic will replace this the actual imported reference. This is
-# needed so that we can detect whether a name has been imported during
-# XXX what?
-UNBOUND_IMPORTED: Final = 3
-
-# RevealExpr node kinds
-REVEAL_TYPE: Final = 0
-REVEAL_LOCALS: Final = 1
-
-LITERAL_YES: Final = 2
-LITERAL_TYPE: Final = 1
-LITERAL_NO: Final = 0
-
-node_kinds: Final = {
-    LDEF: "Ldef",
-    GDEF: "Gdef",
-    MDEF: "Mdef",
-    UNBOUND_IMPORTED: "UnboundImported",
-}
-inverse_node_kinds: Final = {_kind: _name for _name, _kind in node_kinds.items()}
-
-
-implicit_module_attrs: Final = {
-    "__name__": "__builtins__.str",
-    "__doc__": None,  # depends on Python version, see semanal.py
-    "__path__": None,  # depends on if the module is a package
-    "__file__": "__builtins__.str",
-    "__package__": "__builtins__.str",
-    "__annotations__": None,  # dict[str, Any] bounded in add_implicit_module_attrs()
-}
-
-
-# These aliases exist because built-in class objects are not subscriptable.
-# For example `list[int]` fails at runtime. Instead List[int] should be used.
-type_aliases: Final = {
-    "typing.List": "builtins.list",
-    "typing.Dict": "builtins.dict",
-    "typing.Set": "builtins.set",
-    "typing.FrozenSet": "builtins.frozenset",
-    "typing.ChainMap": "collections.ChainMap",
-    "typing.Counter": "collections.Counter",
-    "typing.DefaultDict": "collections.defaultdict",
-    "typing.Deque": "collections.deque",
-    "typing.OrderedDict": "collections.OrderedDict",
-    # HACK: a lie in lieu of actual support for PEP 675
-    "typing.LiteralString": "builtins.str",
-}
-
-# This keeps track of the oldest supported Python version where the corresponding
-# alias source is available.
-type_aliases_source_versions: Final = {"typing.LiteralString": (3, 11)}
-
-# This keeps track of aliases in `typing_extensions`, which we treat specially.
-typing_extensions_aliases: Final = {
-    # See: https://github.com/python/mypy/issues/11528
-    "typing_extensions.OrderedDict": "collections.OrderedDict",
-    # HACK: a lie in lieu of actual support for PEP 675
-    "typing_extensions.LiteralString": "builtins.str",
-}
-
-reverse_builtin_aliases: Final = {
-    "builtins.list": "typing.List",
-    "builtins.dict": "typing.Dict",
-    "builtins.set": "typing.Set",
-    "builtins.frozenset": "typing.FrozenSet",
-}
-
-_nongen_builtins: Final = {"builtins.tuple": "typing.Tuple", "builtins.enumerate": ""}
-_nongen_builtins.update((name, alias) for alias, name in type_aliases.items())
-# Drop OrderedDict from this for backward compatibility
-del _nongen_builtins["collections.OrderedDict"]
-# HACK: consequence of hackily treating LiteralString as an alias for str
-del _nongen_builtins["builtins.str"]
-
-
-def get_nongen_builtins(python_version: tuple[int, int]) -> dict[str, str]:
-    # After 3.9 with pep585 generic builtins are allowed
-    return _nongen_builtins if python_version < (3, 9) else {}
-
-
-RUNTIME_PROTOCOL_DECOS: Final = (
-    "typing.runtime_checkable",
-    "typing_extensions.runtime",
-    "typing_extensions.runtime_checkable",
-)
-
-
-class Node(Context):
-    """Common base class for all non-type parse tree nodes."""
-
-    __slots__ = ()
-
-    def __str__(self) -> str:
-        ans = self.accept(mypy.strconv.StrConv(options=Options()))
-        if ans is None:
-            return repr(self)
-        return ans
-
-    def str_with_options(self, options: Options) -> str:
-        ans = self.accept(mypy.strconv.StrConv(options=options))
-        assert ans
-        return ans
-
-    def accept(self, visitor: NodeVisitor[T]) -> T:
-        raise RuntimeError("Not implemented", type(self))
-
-
-@trait
-class Statement(Node):
-    """A statement node."""
-
-    __slots__ = ()
-
-    def accept(self, visitor: StatementVisitor[T]) -> T:
-        raise RuntimeError("Not implemented", type(self))
-
-
-@trait
-class Expression(Node):
-    """An expression node."""
-
-    __slots__ = ()
-
-    def accept(self, visitor: ExpressionVisitor[T]) -> T:
-        raise RuntimeError("Not implemented", type(self))
-
-
-class FakeExpression(Expression):
-    """A dummy expression.
-
-    We need a dummy expression in one place, and can't instantiate Expression
-    because it is a trait and mypyc barfs.
-    """
-
-    __slots__ = ()
-
-
-# TODO:
-# Lvalue = Union['NameExpr', 'MemberExpr', 'IndexExpr', 'SuperExpr', 'StarExpr'
-#                'TupleExpr']; see #1783.
-Lvalue: _TypeAlias = Expression
-
-
-@trait
-class SymbolNode(Node):
-    """Nodes that can be stored in a symbol table."""
-
-    __slots__ = ()
-
-    @property
-    @abstractmethod
-    def name(self) -> str:
-        pass
-
-    # Fully qualified name
-    @property
-    @abstractmethod
-    def fullname(self) -> str:
-        pass
-
-    @abstractmethod
-    def serialize(self) -> JsonDict:
-        pass
-
-    @classmethod
-    def deserialize(cls, data: JsonDict) -> SymbolNode:
-        classname = data[".class"]
-        method = deserialize_map.get(classname)
-        if method is not None:
-            return method(data)
-        raise NotImplementedError(f"unexpected .class {classname}")
-
-
-# Items: fullname, related symbol table node, surrounding type (if any)
-Definition: _TypeAlias = Tuple[str, "SymbolTableNode", Optional["TypeInfo"]]
-
-
-class MypyFile(SymbolNode):
-    """The abstract syntax tree of a single source file."""
-
-    __slots__ = (
-        "_fullname",
-        "path",
-        "defs",
-        "alias_deps",
-        "is_bom",
-        "names",
-        "imports",
-        "ignored_lines",
-        "skipped_lines",
-        "is_stub",
-        "is_cache_skeleton",
-        "is_partial_stub_package",
-        "plugin_deps",
-        "future_import_flags",
-        "_is_typeshed_file",
-    )
-
-    __match_args__ = ("name", "path", "defs")
-
-    # Fully qualified module name
-    _fullname: str
-    # Path to the file (empty string if not known)
-    path: str
-    # Top-level definitions and statements
-    defs: list[Statement]
-    # Type alias dependencies as mapping from target to set of alias full names
-    alias_deps: defaultdict[str, set[str]]
-    # Is there a UTF-8 BOM at the start?
-    is_bom: bool
-    names: SymbolTable
-    # All import nodes within the file (also ones within functions etc.)
-    imports: list[ImportBase]
-    # Lines on which to ignore certain errors when checking.
-    # If the value is empty, ignore all errors; otherwise, the list contains all
-    # error codes to ignore.
-    ignored_lines: dict[int, list[str]]
-    # Lines that were skipped during semantic analysis e.g. due to ALWAYS_FALSE, MYPY_FALSE,
-    # or platform/version checks. Those lines would not be type-checked.
-    skipped_lines: set[int]
-    # Is this file represented by a stub file (.pyi)?
-    is_stub: bool
-    # Is this loaded from the cache and thus missing the actual body of the file?
-    is_cache_skeleton: bool
-    # Does this represent an __init__.pyi stub with a module __getattr__
-    # (i.e. a partial stub package), for such packages we suppress any missing
-    # module errors in addition to missing attribute errors.
-    is_partial_stub_package: bool
-    # Plugin-created dependencies
-    plugin_deps: dict[str, set[str]]
-    # Future imports defined in this file. Populated during semantic analysis.
-    future_import_flags: set[str]
-    _is_typeshed_file: bool | None
-
-    def __init__(
-        self,
-        defs: list[Statement],
-        imports: list[ImportBase],
-        is_bom: bool = False,
-        ignored_lines: dict[int, list[str]] | None = None,
-    ) -> None:
-        super().__init__()
-        self.defs = defs
-        self.line = 1  # Dummy line number
-        self.column = 0  # Dummy column
-        self.imports = imports
-        self.is_bom = is_bom
-        self.alias_deps = defaultdict(set)
-        self.plugin_deps = {}
-        if ignored_lines:
-            self.ignored_lines = ignored_lines
-        else:
-            self.ignored_lines = {}
-        self.skipped_lines = set()
-
-        self.path = ""
-        self.is_stub = False
-        self.is_cache_skeleton = False
-        self.is_partial_stub_package = False
-        self.future_import_flags = set()
-        self._is_typeshed_file = None
-
-    def local_definitions(self) -> Iterator[Definition]:
-        """Return all definitions within the module (including nested).
-
-        This doesn't include imported definitions.
-        """
-        return local_definitions(self.names, self.fullname)
-
-    @property
-    def name(self) -> str:
-        return "" if not self._fullname else self._fullname.split(".")[-1]
-
-    @property
-    def fullname(self) -> str:
-        return self._fullname
-
-    def accept(self, visitor: NodeVisitor[T]) -> T:
-        return visitor.visit_mypy_file(self)
-
-    def is_package_init_file(self) -> bool:
-        return len(self.path) != 0 and os.path.basename(self.path).startswith(
-            "__init__."
-        )
-
-    def is_future_flag_set(self, flag: str) -> bool:
-        return flag in self.future_import_flags
-
-    def is_typeshed_file(self, options: Options) -> bool:
-        # Cache result since this is called a lot
-        if self._is_typeshed_file is None:
-            self._is_typeshed_file = is_typeshed_file(
-                options.abs_custom_typeshed_dir, self.path
-            )
-        return self._is_typeshed_file
-
-    def serialize(self) -> JsonDict:
-        return {
-            ".class": "MypyFile",
-            "_fullname": self._fullname,
-            "names": self.names.serialize(self._fullname),
-            "is_stub": self.is_stub,
-            "path": self.path,
-            "is_partial_stub_package": self.is_partial_stub_package,
-            "future_import_flags": list(self.future_import_flags),
-        }
-
-    @classmethod
-    def deserialize(cls, data: JsonDict) -> MypyFile:
-        assert data[".class"] == "MypyFile", data
-        tree = MypyFile([], [])
-        tree._fullname = data["_fullname"]
-        tree.names = SymbolTable.deserialize(data["names"])
-        tree.is_stub = data["is_stub"]
-        tree.path = data["path"]
-        tree.is_partial_stub_package = data["is_partial_stub_package"]
-        tree.is_cache_skeleton = True
-        tree.future_import_flags = set(data["future_import_flags"])
-        return tree
-
-
-class ImportBase(Statement):
-    """Base class for all import statements."""
-
-    __slots__ = ("is_unreachable", "is_top_level", "is_mypy_only", "assignments")
-
-    is_unreachable: (
-        bool  # Set by semanal.SemanticAnalyzerPass1 if inside `if False` etc.
-    )
-    is_top_level: bool  # Ditto if outside any class or def
-    is_mypy_only: bool  # Ditto if inside `if TYPE_CHECKING` or `if MYPY`
-
-    # If an import replaces existing definitions, we construct dummy assignment
-    # statements that assign the imported names to the names in the current scope,
-    # for type checking purposes. Example:
-    #
-    #     x = 1
-    #     from m import x   <-- add assignment representing "x = m.x"
-    assignments: list[AssignmentStmt]
-
-    def __init__(self) -> None:
-        super().__init__()
-        self.assignments = []
-        self.is_unreachable = False
-        self.is_top_level = False
-        self.is_mypy_only = False
-
-
-class Import(ImportBase):
-    """import m [as n]"""
-
-    __slots__ = ("ids",)
-
-    __match_args__ = ("ids",)
-
-    ids: list[tuple[str, str | None]]  # (module id, as id)
-
-    def __init__(self, ids: list[tuple[str, str | None]]) -> None:
-        super().__init__()
-        self.ids = ids
-
-    def accept(self, visitor: StatementVisitor[T]) -> T:
-        return visitor.visit_import(self)
-
-
-class ImportFrom(ImportBase):
-    """from m import x [as y], ..."""
-
-    __slots__ = ("id", "names", "relative")
-
-    __match_args__ = ("id", "names", "relative")
-
-    id: str
-    relative: int
-    names: list[tuple[str, str | None]]  # Tuples (name, as name)
-
-    def __init__(
-        self, id: str, relative: int, names: list[tuple[str, str | None]]
-    ) -> None:
-        super().__init__()
-        self.id = id
-        self.names = names
-        self.relative = relative
-
-    def accept(self, visitor: StatementVisitor[T]) -> T:
-        return visitor.visit_import_from(self)
-
-
-class ImportAll(ImportBase):
-    """from m import *"""
-
-    __slots__ = ("id", "relative")
-
-    __match_args__ = ("id", "relative")
-
-    id: str
-    relative: int
-
-    def __init__(self, id: str, relative: int) -> None:
-        super().__init__()
-        self.id = id
-        self.relative = relative
-
-    def accept(self, visitor: StatementVisitor[T]) -> T:
-        return visitor.visit_import_all(self)
-
-
-FUNCBASE_FLAGS: Final = ["is_property", "is_class", "is_static", "is_final"]
-
-
-class FuncBase(Node):
-    """Abstract base class for function-like nodes.
-
-    N.B: Although this has SymbolNode subclasses (FuncDef,
-    OverloadedFuncDef), avoid calling isinstance(..., FuncBase) on
-    something that is typed as SymbolNode.  This is to work around
-    mypy bug #3603, in which mypy doesn't understand multiple
-    inheritance very well, and will assume that a SymbolNode
-    cannot be a FuncBase.
-
-    Instead, test against SYMBOL_FUNCBASE_TYPES, which enumerates
-    SymbolNode subclasses that are also FuncBase subclasses.
-    """
-
-    __slots__ = (
-        "type",
-        "unanalyzed_type",
-        "info",
-        "is_property",
-        "is_class",  # Uses "@classmethod" (explicit or implicit)
-        "is_static",  # Uses "@staticmethod" (explicit or implicit)
-        "is_final",  # Uses "@final"
-        "is_explicit_override",  # Uses "@override"
-        "is_type_check_only",  # Uses "@type_check_only"
-        "_fullname",
-    )
-
-    def __init__(self) -> None:
-        super().__init__()
-        # Type signature. This is usually CallableType or Overloaded, but it can be
-        # something else for decorated functions.
-        self.type: mypy.types.ProperType | None = None
-        # Original, not semantically analyzed type (used for reprocessing)
-        self.unanalyzed_type: mypy.types.ProperType | None = None
-        # If method, reference to TypeInfo
-        self.info = FUNC_NO_INFO
-        self.is_property = False
-        self.is_class = False
-        self.is_static = False
-        self.is_final = False
-        self.is_explicit_override = False
-        self.is_type_check_only = False
-        # Name with module prefix
-        self._fullname = ""
-
-    @property
-    @abstractmethod
-    def name(self) -> str:
-        pass
-
-    @property
-    def fullname(self) -> str:
-        return self._fullname
-
-
-OverloadPart: _TypeAlias = Union["FuncDef", "Decorator"]
-
-
-class OverloadedFuncDef(FuncBase, SymbolNode, Statement):
-    """A logical node representing all the variants of a multi-declaration function.
-
-    A multi-declaration function is often an @overload, but can also be a
-    @property with a setter and a/or a deleter.
-
-    This node has no explicit representation in the source program.
-    Overloaded variants must be consecutive in the source file.
-    """
-
-    __slots__ = ("items", "unanalyzed_items", "impl")
-
-    items: list[OverloadPart]
-    unanalyzed_items: list[OverloadPart]
-    impl: OverloadPart | None
-
-    def __init__(self, items: list[OverloadPart]) -> None:
-        super().__init__()
-        self.items = items
-        self.unanalyzed_items = items.copy()
-        self.impl = None
-        if items:
-            # TODO: figure out how to reliably set end position (we don't know the impl here).
-            self.set_line(items[0].line, items[0].column)
-
-    @property
-    def name(self) -> str:
-        if self.items:
-            return self.items[0].name
-        else:
-            # This may happen for malformed overload
-            assert self.impl is not None
-            return self.impl.name
-
-    def accept(self, visitor: StatementVisitor[T]) -> T:
-        return visitor.visit_overloaded_func_def(self)
-
-    def serialize(self) -> JsonDict:
-        return {
-            ".class": "OverloadedFuncDef",
-            "items": [i.serialize() for i in self.items],
-            "type": None if self.type is None else self.type.serialize(),
-            "fullname": self._fullname,
-            "impl": None if self.impl is None else self.impl.serialize(),
-            "flags": get_flags(self, FUNCBASE_FLAGS),
-        }
-
-    @classmethod
-    def deserialize(cls, data: JsonDict) -> OverloadedFuncDef:
-        assert data[".class"] == "OverloadedFuncDef"
-        res = OverloadedFuncDef(
-            [cast(OverloadPart, SymbolNode.deserialize(d)) for d in data["items"]]
-        )
-        if data.get("impl") is not None:
-            res.impl = cast(OverloadPart, SymbolNode.deserialize(data["impl"]))
-            # set line for empty overload items, as not set in __init__
-            if len(res.items) > 0:
-                res.set_line(res.impl.line)
-        if data.get("type") is not None:
-            typ = mypy.types.deserialize_type(data["type"])
-            assert isinstance(typ, mypy.types.ProperType)
-            res.type = typ
-        res._fullname = data["fullname"]
-        set_flags(res, data["flags"])
-        # NOTE: res.info will be set in the fixup phase.
-        return res
-
-
-class Argument(Node):
-    """A single argument in a FuncItem."""
-
-    __slots__ = ("variable", "type_annotation", "initializer", "kind", "pos_only")
-
-    __match_args__ = ("variable", "type_annotation", "initializer", "kind", "pos_only")
-
-    def __init__(
-        self,
-        variable: Var,
-        type_annotation: mypy.types.Type | None,
-        initializer: Expression | None,
-        kind: ArgKind,
-        pos_only: bool = False,
-    ) -> None:
-        super().__init__()
-        self.variable = variable
-        self.type_annotation = type_annotation
-        self.initializer = initializer
-        self.kind = kind  # must be an ARG_* constant
-        self.pos_only = pos_only
-
-    def set_line(
-        self,
-        target: Context | int,
-        column: int | None = None,
-        end_line: int | None = None,
-        end_column: int | None = None,
-    ) -> None:
-        super().set_line(target, column, end_line, end_column)
-
-        if self.initializer and self.initializer.line < 0:
-            self.initializer.set_line(
-                self.line, self.column, self.end_line, self.end_column
-            )
-
-        self.variable.set_line(self.line, self.column, self.end_line, self.end_column)
-
-
-FUNCITEM_FLAGS: Final = FUNCBASE_FLAGS + [
-    "is_overload",
-    "is_generator",
-    "is_coroutine",
-    "is_async_generator",
-    "is_awaitable_coroutine",
-]
-
-
-class FuncItem(FuncBase):
-    """Base class for nodes usable as overloaded function items."""
-
-    __slots__ = (
-        "arguments",  # Note that can be unset if deserialized (type is a lie!)
-        "arg_names",  # Names of arguments
-        "arg_kinds",  # Kinds of arguments
-        "min_args",  # Minimum number of arguments
-        "max_pos",  # Maximum number of positional arguments, -1 if no explicit
-        # limit (*args not included)
-        "body",  # Body of the function
-        "is_overload",  # Is this an overload variant of function with more than
-        # one overload variant?
-        "is_generator",  # Contains a yield statement?
-        "is_coroutine",  # Defined using 'async def' syntax?
-        "is_async_generator",  # Is an async def generator?
-        "is_awaitable_coroutine",  # Decorated with '@{typing,asyncio}.coroutine'?
-        "expanded",  # Variants of function with type variables with values expanded
-    )
-
-    __deletable__ = ("arguments", "max_pos", "min_args")
-
-    def __init__(
-        self,
-        arguments: list[Argument] | None = None,
-        body: Block | None = None,
-        typ: mypy.types.FunctionLike | None = None,
-    ) -> None:
-        super().__init__()
-        self.arguments = arguments or []
-        self.arg_names = [
-            None if arg.pos_only else arg.variable.name for arg in self.arguments
-        ]
-        self.arg_kinds: list[ArgKind] = [arg.kind for arg in self.arguments]
-        self.max_pos: int = self.arg_kinds.count(ARG_POS) + self.arg_kinds.count(
-            ARG_OPT
-        )
-        self.body: Block = body or Block([])
-        self.type = typ
-        self.unanalyzed_type = typ
-        self.is_overload: bool = False
-        self.is_generator: bool = False
-        self.is_coroutine: bool = False
-        self.is_async_generator: bool = False
-        self.is_awaitable_coroutine: bool = False
-        self.expanded: list[FuncItem] = []
-
-        self.min_args = 0
-        for i in range(len(self.arguments)):
-            if self.arguments[i] is None and i < self.max_fixed_argc():
-                self.min_args = i + 1
-
-    def max_fixed_argc(self) -> int:
-        return self.max_pos
-
-    def is_dynamic(self) -> bool:
-        return self.type is None
-
-
-FUNCDEF_FLAGS: Final = FUNCITEM_FLAGS + [
-    "is_decorated",
-    "is_conditional",
-    "is_trivial_body",
-    "is_mypy_only",
-]
-
-# Abstract status of a function
-NOT_ABSTRACT: Final = 0
-# Explicitly abstract (with @abstractmethod or overload without implementation)
-IS_ABSTRACT: Final = 1
-# Implicitly abstract: used for functions with trivial bodies defined in Protocols
-IMPLICITLY_ABSTRACT: Final = 2
-
-
-class FuncDef(FuncItem, SymbolNode, Statement):
-    """Function definition.
-
-    This is a non-lambda function defined using 'def'.
-    """
-
-    __slots__ = (
-        "_name",
-        "is_decorated",
-        "is_conditional",
-        "abstract_status",
-        "original_def",
-        "deco_line",
-        "is_trivial_body",
-        "is_mypy_only",
-        # Present only when a function is decorated with @typing.datasclass_transform or similar
-        "dataclass_transform_spec",
-        "docstring",
-    )
-
-    __match_args__ = ("name", "arguments", "type", "body")
-
-    # Note that all __init__ args must have default values
-    def __init__(
-        self,
-        name: str = "",  # Function name
-        arguments: list[Argument] | None = None,
-        body: Block | None = None,
-        typ: mypy.types.FunctionLike | None = None,
-    ) -> None:
-        super().__init__(arguments, body, typ)
-        self._name = name
-        self.is_decorated = False
-        self.is_conditional = False  # Defined conditionally (within block)?
-        self.abstract_status = NOT_ABSTRACT
-        # Is this an abstract method with trivial body?
-        # Such methods can't be called via super().
-        self.is_trivial_body = False
-        # Original conditional definition
-        self.original_def: None | FuncDef | Var | Decorator = None
-        # Used for error reporting (to keep backward compatibility with pre-3.8)
-        self.deco_line: int | None = None
-        # Definitions that appear in if TYPE_CHECKING are marked with this flag.
-        self.is_mypy_only = False
-        self.dataclass_transform_spec: DataclassTransformSpec | None = None
-        self.docstring: str | None = None
-
-    @property
-    def name(self) -> str:
-        return self._name
-
-    def accept(self, visitor: StatementVisitor[T]) -> T:
-        return visitor.visit_func_def(self)
-
-    def serialize(self) -> JsonDict:
-        # We're deliberating omitting arguments and storing only arg_names and
-        # arg_kinds for space-saving reasons (arguments is not used in later
-        # stages of mypy).
-        # TODO: After a FuncDef is deserialized, the only time we use `arg_names`
-        # and `arg_kinds` is when `type` is None and we need to infer a type. Can
-        # we store the inferred type ahead of time?
-        return {
-            ".class": "FuncDef",
-            "name": self._name,
-            "fullname": self._fullname,
-            "arg_names": self.arg_names,
-            "arg_kinds": [int(x.value) for x in self.arg_kinds],
-            "type": None if self.type is None else self.type.serialize(),
-            "flags": get_flags(self, FUNCDEF_FLAGS),
-            "abstract_status": self.abstract_status,
-            # TODO: Do we need expanded, original_def?
-            "dataclass_transform_spec": (
-                None
-                if self.dataclass_transform_spec is None
-                else self.dataclass_transform_spec.serialize()
-            ),
-        }
-
-    @classmethod
-    def deserialize(cls, data: JsonDict) -> FuncDef:
-        assert data[".class"] == "FuncDef"
-        body = Block([])
-        ret = FuncDef(
-            data["name"],
-            [],
-            body,
-            (
-                None
-                if data["type"] is None
-                else cast(
-                    mypy.types.FunctionLike, mypy.types.deserialize_type(data["type"])
-                )
-            ),
-        )
-        ret._fullname = data["fullname"]
-        set_flags(ret, data["flags"])
-        # NOTE: ret.info is set in the fixup phase.
-        ret.arg_names = data["arg_names"]
-        ret.arg_kinds = [ArgKind(x) for x in data["arg_kinds"]]
-        ret.abstract_status = data["abstract_status"]
-        ret.dataclass_transform_spec = (
-            DataclassTransformSpec.deserialize(data["dataclass_transform_spec"])
-            if data["dataclass_transform_spec"] is not None
-            else None
-        )
-        # Leave these uninitialized so that future uses will trigger an error
-        del ret.arguments
-        del ret.max_pos
-        del ret.min_args
-        return ret
-
-
-# All types that are both SymbolNodes and FuncBases. See the FuncBase
-# docstring for the rationale.
-SYMBOL_FUNCBASE_TYPES = (OverloadedFuncDef, FuncDef)
-
-
-class Decorator(SymbolNode, Statement):
-    """A decorated function.
-
-    A single Decorator object can include any number of function decorators.
-    """
-
-    __slots__ = ("func", "decorators", "original_decorators", "var", "is_overload")
-
-    __match_args__ = ("decorators", "var", "func")
-
-    func: FuncDef  # Decorated function
-    decorators: list[Expression]  # Decorators (may be empty)
-    # Some decorators are removed by semanal, keep the original here.
-    original_decorators: list[Expression]
-    # TODO: This is mostly used for the type; consider replacing with a 'type' attribute
-    var: Var  # Represents the decorated function obj
-    is_overload: bool
-
-    def __init__(self, func: FuncDef, decorators: list[Expression], var: Var) -> None:
-        super().__init__()
-        self.func = func
-        self.decorators = decorators
-        self.original_decorators = decorators.copy()
-        self.var = var
-        self.is_overload = False
-
-    @property
-    def name(self) -> str:
-        return self.func.name
-
-    @property
-    def fullname(self) -> str:
-        return self.func.fullname
-
-    @property
-    def is_final(self) -> bool:
-        return self.func.is_final
-
-    @property
-    def info(self) -> TypeInfo:
-        return self.func.info
-
-    @property
-    def type(self) -> mypy.types.Type | None:
-        return self.var.type
-
-    def accept(self, visitor: StatementVisitor[T]) -> T:
-        return visitor.visit_decorator(self)
-
-    def serialize(self) -> JsonDict:
-        return {
-            ".class": "Decorator",
-            "func": self.func.serialize(),
-            "var": self.var.serialize(),
-            "is_overload": self.is_overload,
-        }
-
-    @classmethod
-    def deserialize(cls, data: JsonDict) -> Decorator:
-        assert data[".class"] == "Decorator"
-        dec = Decorator(
-            FuncDef.deserialize(data["func"]), [], Var.deserialize(data["var"])
-        )
-        dec.is_overload = data["is_overload"]
-        return dec
-
-
-VAR_FLAGS: Final = [
-    "is_self",
-    "is_cls",
-    "is_initialized_in_class",
-    "is_staticmethod",
-    "is_classmethod",
-    "is_property",
-    "is_settable_property",
-    "is_suppressed_import",
-    "is_classvar",
-    "is_abstract_var",
-    "is_final",
-    "final_unset_in_class",
-    "final_set_in_init",
-    "explicit_self_type",
-    "is_ready",
-    "is_inferred",
-    "invalid_partial_type",
-    "from_module_getattr",
-    "has_explicit_value",
-    "allow_incompatible_override",
-]
-
-
-class Var(SymbolNode):
-    """A variable.
-
-    It can refer to global/local variable or a data attribute.
-    """
-
-    __slots__ = (
-        "_name",
-        "_fullname",
-        "info",
-        "type",
-        "final_value",
-        "is_self",
-        "is_cls",
-        "is_ready",
-        "is_inferred",
-        "is_initialized_in_class",
-        "is_staticmethod",
-        "is_classmethod",
-        "is_property",
-        "is_settable_property",
-        "is_classvar",
-        "is_abstract_var",
-        "is_final",
-        "final_unset_in_class",
-        "final_set_in_init",
-        "is_suppressed_import",
-        "explicit_self_type",
-        "from_module_getattr",
-        "has_explicit_value",
-        "allow_incompatible_override",
-        "invalid_partial_type",
-    )
-
-    __match_args__ = ("name", "type", "final_value")
-
-    def __init__(self, name: str, type: mypy.types.Type | None = None) -> None:
-        super().__init__()
-        self._name = name  # Name without module prefix
-        # TODO: Should be Optional[str]
-        self._fullname = ""  # Name with module prefix
-        # TODO: Should be Optional[TypeInfo]
-        self.info = VAR_NO_INFO
-        self.type: mypy.types.Type | None = type  # Declared or inferred type, or None
-        # Is this the first argument to an ordinary method (usually "self")?
-        self.is_self = False
-        # Is this the first argument to a classmethod (typically "cls")?
-        self.is_cls = False
-        self.is_ready = True  # If inferred, is the inferred type available?
-        self.is_inferred = self.type is None
-        # Is this initialized explicitly to a non-None value in class body?
-        self.is_initialized_in_class = False
-        self.is_staticmethod = False
-        self.is_classmethod = False
-        self.is_property = False
-        self.is_settable_property = False
-        self.is_classvar = False
-        self.is_abstract_var = False
-        # Set to true when this variable refers to a module we were unable to
-        # parse for some reason (eg a silenced module)
-        self.is_suppressed_import = False
-        # Was this "variable" (rather a constant) defined as Final[...]?
-        self.is_final = False
-        # If constant value is a simple literal,
-        # store the literal value (unboxed) for the benefit of
-        # tools like mypyc.
-        self.final_value: int | float | complex | bool | str | None = None
-        # Where the value was set (only for class attributes)
-        self.final_unset_in_class = False
-        self.final_set_in_init = False
-        # This is True for a variable that was declared on self with an explicit type:
-        #     class C:
-        #         def __init__(self) -> None:
-        #             self.x: int
-        # This case is important because this defines a new Var, even if there is one
-        # present in a superclass (without explicit type this doesn't create a new Var).
-        # See SemanticAnalyzer.analyze_member_lvalue() for details.
-        self.explicit_self_type = False
-        # If True, this is an implicit Var created due to module-level __getattr__.
-        self.from_module_getattr = False
-        # Var can be created with an explicit value `a = 1` or without one `a: int`,
-        # we need a way to tell which one is which.
-        self.has_explicit_value = False
-        # If True, subclasses can override this with an incompatible type.
-        self.allow_incompatible_override = False
-        # If True, this means we didn't manage to infer full type and fall back to
-        # something like list[Any]. We may decide to not use such types as context.
-        self.invalid_partial_type = False
-
-    @property
-    def name(self) -> str:
-        return self._name
-
-    @property
-    def fullname(self) -> str:
-        return self._fullname
-
-    def accept(self, visitor: NodeVisitor[T]) -> T:
-        return visitor.visit_var(self)
-
-    def serialize(self) -> JsonDict:
-        # TODO: Leave default values out?
-        # NOTE: Sometimes self.is_ready is False here, but we don't care.
-        data: JsonDict = {
-            ".class": "Var",
-            "name": self._name,
-            "fullname": self._fullname,
-            "type": None if self.type is None else self.type.serialize(),
-            "flags": get_flags(self, VAR_FLAGS),
-        }
-        if self.final_value is not None:
-            data["final_value"] = self.final_value
-        return data
-
-    @classmethod
-    def deserialize(cls, data: JsonDict) -> Var:
-        assert data[".class"] == "Var"
-        name = data["name"]
-        type = (
-            None if data["type"] is None else mypy.types.deserialize_type(data["type"])
-        )
-        v = Var(name, type)
-        v.is_ready = False  # Override True default set in __init__
-        v._fullname = data["fullname"]
-        set_flags(v, data["flags"])
-        v.final_value = data.get("final_value")
-        return v
-
-
-class ClassDef(Statement):
-    """Class definition"""
-
-    __slots__ = (
-        "name",
-        "_fullname",
-        "defs",
-        "type_vars",
-        "base_type_exprs",
-        "removed_base_type_exprs",
-        "info",
-        "metaclass",
-        "decorators",
-        "keywords",
-        "analyzed",
-        "has_incompatible_baseclass",
-        "deco_line",
-        "docstring",
-        "removed_statements",
-    )
-
-    __match_args__ = ("name", "defs")
-
-    name: str  # Name of the class without module prefix
-    _fullname: str  # Fully qualified name of the class
-    defs: Block
-    type_vars: list[mypy.types.TypeVarLikeType]
-    # Base class expressions (not semantically analyzed -- can be arbitrary expressions)
-    base_type_exprs: list[Expression]
-    # Special base classes like Generic[...] get moved here during semantic analysis
-    removed_base_type_exprs: list[Expression]
-    info: TypeInfo  # Related TypeInfo
-    metaclass: Expression | None
-    decorators: list[Expression]
-    keywords: dict[str, Expression]
-    analyzed: Expression | None
-    has_incompatible_baseclass: bool
-    # Used by special forms like NamedTuple and TypedDict to store invalid statements
-    removed_statements: list[Statement]
-
-    def __init__(
-        self,
-        name: str,
-        defs: Block,
-        type_vars: list[mypy.types.TypeVarLikeType] | None = None,
-        base_type_exprs: list[Expression] | None = None,
-        metaclass: Expression | None = None,
-        keywords: list[tuple[str, Expression]] | None = None,
-    ) -> None:
-        super().__init__()
-        self.name = name
-        self._fullname = ""
-        self.defs = defs
-        self.type_vars = type_vars or []
-        self.base_type_exprs = base_type_exprs or []
-        self.removed_base_type_exprs = []
-        self.info = CLASSDEF_NO_INFO
-        self.metaclass = metaclass
-        self.decorators = []
-        self.keywords = dict(keywords) if keywords else {}
-        self.analyzed = None
-        self.has_incompatible_baseclass = False
-        # Used for error reporting (to keep backwad compatibility with pre-3.8)
-        self.deco_line: int | None = None
-        self.docstring: str | None = None
-        self.removed_statements = []
-
-    @property
-    def fullname(self) -> str:
-        return self._fullname
-
-    @fullname.setter
-    def fullname(self, v: str) -> None:
-        self._fullname = v
-
-    def accept(self, visitor: StatementVisitor[T]) -> T:
-        return visitor.visit_class_def(self)
-
-    def is_generic(self) -> bool:
-        return self.info.is_generic()
-
-    def serialize(self) -> JsonDict:
-        # Not serialized: defs, base_type_exprs, metaclass, decorators,
-        # analyzed (for named tuples etc.)
-        return {
-            ".class": "ClassDef",
-            "name": self.name,
-            "fullname": self.fullname,
-            "type_vars": [v.serialize() for v in self.type_vars],
-        }
-
-    @classmethod
-    def deserialize(cls, data: JsonDict) -> ClassDef:
-        assert data[".class"] == "ClassDef"
-        res = ClassDef(
-            data["name"],
-            Block([]),
-            # https://github.com/python/mypy/issues/12257
-            [
-                cast(mypy.types.TypeVarLikeType, mypy.types.deserialize_type(v))
-                for v in data["type_vars"]
-            ],
-        )
-        res.fullname = data["fullname"]
-        return res
-
-
-class GlobalDecl(Statement):
-    """Declaration global x, y, ..."""
-
-    __slots__ = ("names",)
-
-    __match_args__ = ("names",)
-
-    names: list[str]
-
-    def __init__(self, names: list[str]) -> None:
-        super().__init__()
-        self.names = names
-
-    def accept(self, visitor: StatementVisitor[T]) -> T:
-        return visitor.visit_global_decl(self)
-
-
-class NonlocalDecl(Statement):
-    """Declaration nonlocal x, y, ..."""
-
-    __slots__ = ("names",)
-
-    __match_args__ = ("names",)
-
-    names: list[str]
-
-    def __init__(self, names: list[str]) -> None:
-        super().__init__()
-        self.names = names
-
-    def accept(self, visitor: StatementVisitor[T]) -> T:
-        return visitor.visit_nonlocal_decl(self)
-
-
-class Block(Statement):
-    __slots__ = ("body", "is_unreachable")
-
-    __match_args__ = ("body", "is_unreachable")
-
-    def __init__(self, body: list[Statement]) -> None:
-        super().__init__()
-        self.body = body
-        # True if we can determine that this block is not executed during semantic
-        # analysis. For example, this applies to blocks that are protected by
-        # something like "if PY3:" when using Python 2. However, some code is
-        # only considered unreachable during type checking and this is not true
-        # in those cases.
-        self.is_unreachable = False
-
-    def accept(self, visitor: StatementVisitor[T]) -> T:
-        return visitor.visit_block(self)
-
-
-# Statements
-
-
-class ExpressionStmt(Statement):
-    """An expression as a statement, such as print(s)."""
-
-    __slots__ = ("expr",)
-
-    __match_args__ = ("expr",)
-
-    expr: Expression
-
-    def __init__(self, expr: Expression) -> None:
-        super().__init__()
-        self.expr = expr
-
-    def accept(self, visitor: StatementVisitor[T]) -> T:
-        return visitor.visit_expression_stmt(self)
-
-
-class AssignmentStmt(Statement):
-    """Assignment statement.
-
-    The same node class is used for single assignment, multiple assignment
-    (e.g. x, y = z) and chained assignment (e.g. x = y = z), assignments
-    that define new names, and assignments with explicit types ("# type: t"
-    or "x: t [= ...]").
-
-    An lvalue can be NameExpr, TupleExpr, ListExpr, MemberExpr, or IndexExpr.
-    """
-
-    __slots__ = (
-        "lvalues",
-        "rvalue",
-        "type",
-        "unanalyzed_type",
-        "new_syntax",
-        "is_alias_def",
-        "is_final_def",
-        "invalid_recursive_alias",
-    )
-
-    __match_args__ = ("lvalues", "rvalues", "type")
-
-    lvalues: list[Lvalue]
-    # This is a TempNode if and only if no rvalue (x: t).
-    rvalue: Expression
-    # Declared type in a comment, may be None.
-    type: mypy.types.Type | None
-    # Original, not semantically analyzed type in annotation (used for reprocessing)
-    unanalyzed_type: mypy.types.Type | None
-    # This indicates usage of PEP 526 type annotation syntax in assignment.
-    new_syntax: bool
-    # Does this assignment define a type alias?
-    is_alias_def: bool
-    # Is this a final definition?
-    # Final attributes can't be re-assigned once set, and can't be overridden
-    # in a subclass. This flag is not set if an attempted declaration was found to
-    # be invalid during semantic analysis. It is still set to `True` if
-    # a final declaration overrides another final declaration (this is checked
-    # during type checking when MROs are known).
-    is_final_def: bool
-    # Stop further processing of this assignment, to prevent flipping back and forth
-    # during semantic analysis passes.
-    invalid_recursive_alias: bool
-
-    def __init__(
-        self,
-        lvalues: list[Lvalue],
-        rvalue: Expression,
-        type: mypy.types.Type | None = None,
-        new_syntax: bool = False,
-    ) -> None:
-        super().__init__()
-        self.lvalues = lvalues
-        self.rvalue = rvalue
-        self.type = type
-        self.unanalyzed_type = type
-        self.new_syntax = new_syntax
-        self.is_alias_def = False
-        self.is_final_def = False
-        self.invalid_recursive_alias = False
-
-    def accept(self, visitor: StatementVisitor[T]) -> T:
-        return visitor.visit_assignment_stmt(self)
-
-
-class OperatorAssignmentStmt(Statement):
-    """Operator assignment statement such as x += 1"""
-
-    __slots__ = ("op", "lvalue", "rvalue")
-
-    __match_args__ = ("lvalue", "op", "rvalue")
-
-    op: str  # TODO: Enum?
-    lvalue: Lvalue
-    rvalue: Expression
-
-    def __init__(self, op: str, lvalue: Lvalue, rvalue: Expression) -> None:
-        super().__init__()
-        self.op = op
-        self.lvalue = lvalue
-        self.rvalue = rvalue
-
-    def accept(self, visitor: StatementVisitor[T]) -> T:
-        return visitor.visit_operator_assignment_stmt(self)
-
-
-class WhileStmt(Statement):
-    __slots__ = ("expr", "body", "else_body")
-
-    __match_args__ = ("expr", "body", "else_body")
-
-    expr: Expression
-    body: Block
-    else_body: Block | None
-
-    def __init__(self, expr: Expression, body: Block, else_body: Block | None) -> None:
-        super().__init__()
-        self.expr = expr
-        self.body = body
-        self.else_body = else_body
-
-    def accept(self, visitor: StatementVisitor[T]) -> T:
-        return visitor.visit_while_stmt(self)
-
-
-class ForStmt(Statement):
-    __slots__ = (
-        "index",
-        "index_type",
-        "unanalyzed_index_type",
-        "inferred_item_type",
-        "inferred_iterator_type",
-        "expr",
-        "body",
-        "else_body",
-        "is_async",
-    )
-
-    __match_args__ = ("index", "index_type", "expr", "body", "else_body")
-
-    # Index variables
-    index: Lvalue
-    # Type given by type comments for index, can be None
-    index_type: mypy.types.Type | None
-    # Original, not semantically analyzed type in annotation (used for reprocessing)
-    unanalyzed_index_type: mypy.types.Type | None
-    # Inferred iterable item type
-    inferred_item_type: mypy.types.Type | None
-    # Inferred iterator type
-    inferred_iterator_type: mypy.types.Type | None
-    # Expression to iterate
-    expr: Expression
-    body: Block
-    else_body: Block | None
-    is_async: bool  # True if `async for ...` (PEP 492, Python 3.5)
-
-    def __init__(
-        self,
-        index: Lvalue,
-        expr: Expression,
-        body: Block,
-        else_body: Block | None,
-        index_type: mypy.types.Type | None = None,
-    ) -> None:
-        super().__init__()
-        self.index = index
-        self.index_type = index_type
-        self.unanalyzed_index_type = index_type
-        self.inferred_item_type = None
-        self.inferred_iterator_type = None
-        self.expr = expr
-        self.body = body
-        self.else_body = else_body
-        self.is_async = False
-
-    def accept(self, visitor: StatementVisitor[T]) -> T:
-        return visitor.visit_for_stmt(self)
-
-
-class ReturnStmt(Statement):
-    __slots__ = ("expr",)
-
-    __match_args__ = ("expr",)
-
-    expr: Expression | None
-
-    def __init__(self, expr: Expression | None) -> None:
-        super().__init__()
-        self.expr = expr
-
-    def accept(self, visitor: StatementVisitor[T]) -> T:
-        return visitor.visit_return_stmt(self)
-
-
-class AssertStmt(Statement):
-    __slots__ = ("expr", "msg")
-
-    __match_args__ = ("expr", "msg")
-
-    expr: Expression
-    msg: Expression | None
-
-    def __init__(self, expr: Expression, msg: Expression | None = None) -> None:
-        super().__init__()
-        self.expr = expr
-        self.msg = msg
-
-    def accept(self, visitor: StatementVisitor[T]) -> T:
-        return visitor.visit_assert_stmt(self)
-
-
-class DelStmt(Statement):
-    __slots__ = ("expr",)
-
-    __match_args__ = ("expr",)
-
-    expr: Lvalue
-
-    def __init__(self, expr: Lvalue) -> None:
-        super().__init__()
-        self.expr = expr
-
-    def accept(self, visitor: StatementVisitor[T]) -> T:
-        return visitor.visit_del_stmt(self)
-
-
-class BreakStmt(Statement):
-    __slots__ = ()
-
-    def accept(self, visitor: StatementVisitor[T]) -> T:
-        return visitor.visit_break_stmt(self)
-
-
-class ContinueStmt(Statement):
-    __slots__ = ()
-
-    def accept(self, visitor: StatementVisitor[T]) -> T:
-        return visitor.visit_continue_stmt(self)
-
-
-class PassStmt(Statement):
-    __slots__ = ()
-
-    def accept(self, visitor: StatementVisitor[T]) -> T:
-        return visitor.visit_pass_stmt(self)
-
-
-class IfStmt(Statement):
-    __slots__ = ("expr", "body", "else_body")
-
-    __match_args__ = ("expr", "body", "else_body")
-
-    expr: list[Expression]
-    body: list[Block]
-    else_body: Block | None
-
-    def __init__(
-        self, expr: list[Expression], body: list[Block], else_body: Block | None
-    ) -> None:
-        super().__init__()
-        self.expr = expr
-        self.body = body
-        self.else_body = else_body
-
-    def accept(self, visitor: StatementVisitor[T]) -> T:
-        return visitor.visit_if_stmt(self)
-
-
-class RaiseStmt(Statement):
-    __slots__ = ("expr", "from_expr")
-
-    __match_args__ = ("expr", "from_expr")
-
-    # Plain 'raise' is a valid statement.
-    expr: Expression | None
-    from_expr: Expression | None
-
-    def __init__(self, expr: Expression | None, from_expr: Expression | None) -> None:
-        super().__init__()
-        self.expr = expr
-        self.from_expr = from_expr
-
-    def accept(self, visitor: StatementVisitor[T]) -> T:
-        return visitor.visit_raise_stmt(self)
-
-
-class TryStmt(Statement):
-    __slots__ = (
-        "body",
-        "types",
-        "vars",
-        "handlers",
-        "else_body",
-        "finally_body",
-        "is_star",
-    )
-
-    __match_args__ = (
-        "body",
-        "types",
-        "vars",
-        "handlers",
-        "else_body",
-        "finally_body",
-        "is_star",
-    )
-
-    body: Block  # Try body
-    # Plain 'except:' also possible
-    types: list[Expression | None]  # Except type expressions
-    vars: list[NameExpr | None]  # Except variable names
-    handlers: list[Block]  # Except bodies
-    else_body: Block | None
-    finally_body: Block | None
-    # Whether this is try ... except* (added in Python 3.11)
-    is_star: bool
-
-    def __init__(
-        self,
-        body: Block,
-        vars: list[NameExpr | None],
-        types: list[Expression | None],
-        handlers: list[Block],
-        else_body: Block | None,
-        finally_body: Block | None,
-    ) -> None:
-        super().__init__()
-        self.body = body
-        self.vars = vars
-        self.types = types
-        self.handlers = handlers
-        self.else_body = else_body
-        self.finally_body = finally_body
-        self.is_star = False
-
-    def accept(self, visitor: StatementVisitor[T]) -> T:
-        return visitor.visit_try_stmt(self)
-
-
-class WithStmt(Statement):
-    __slots__ = (
-        "expr",
-        "target",
-        "unanalyzed_type",
-        "analyzed_types",
-        "body",
-        "is_async",
-    )
-
-    __match_args__ = ("expr", "target", "body")
-
-    expr: list[Expression]
-    target: list[Lvalue | None]
-    # Type given by type comments for target, can be None
-    unanalyzed_type: mypy.types.Type | None
-    # Semantically analyzed types from type comment (TypeList type expanded)
-    analyzed_types: list[mypy.types.Type]
-    body: Block
-    is_async: bool  # True if `async with ...` (PEP 492, Python 3.5)
-
-    def __init__(
-        self,
-        expr: list[Expression],
-        target: list[Lvalue | None],
-        body: Block,
-        target_type: mypy.types.Type | None = None,
-    ) -> None:
-        super().__init__()
-        self.expr = expr
-        self.target = target
-        self.unanalyzed_type = target_type
-        self.analyzed_types = []
-        self.body = body
-        self.is_async = False
-
-    def accept(self, visitor: StatementVisitor[T]) -> T:
-        return visitor.visit_with_stmt(self)
-
-
-class MatchStmt(Statement):
-    __slots__ = ("subject", "patterns", "guards", "bodies")
-
-    __match_args__ = ("subject", "patterns", "guards", "bodies")
-
-    subject: Expression
-    patterns: list[Pattern]
-    guards: list[Expression | None]
-    bodies: list[Block]
-
-    def __init__(
-        self,
-        subject: Expression,
-        patterns: list[Pattern],
-        guards: list[Expression | None],
-        bodies: list[Block],
-    ) -> None:
-        super().__init__()
-        assert len(patterns) == len(guards) == len(bodies)
-        self.subject = subject
-        self.patterns = patterns
-        self.guards = guards
-        self.bodies = bodies
-
-    def accept(self, visitor: StatementVisitor[T]) -> T:
-        return visitor.visit_match_stmt(self)
-
-
-# Expressions
-
-
-class IntExpr(Expression):
-    """Integer literal"""
-
-    __slots__ = ("value",)
-
-    __match_args__ = ("value",)
-
-    value: int  # 0 by default
-
-    def __init__(self, value: int) -> None:
-        super().__init__()
-        self.value = value
-
-    def accept(self, visitor: ExpressionVisitor[T]) -> T:
-        return visitor.visit_int_expr(self)
-
-
-# How mypy uses StrExpr and BytesExpr:
-#
-# b'x' -> BytesExpr
-# 'x', u'x' -> StrExpr
-
-
-class StrExpr(Expression):
-    """String literal"""
-
-    __slots__ = ("value",)
-
-    __match_args__ = ("value",)
-
-    value: str  # '' by default
-
-    def __init__(self, value: str) -> None:
-        super().__init__()
-        self.value = value
-
-    def accept(self, visitor: ExpressionVisitor[T]) -> T:
-        return visitor.visit_str_expr(self)
-
-
-def is_StrExpr_list(seq: list[Expression]) -> TypeGuard[list[StrExpr]]:
-    return all(isinstance(item, StrExpr) for item in seq)
-
-
-class BytesExpr(Expression):
-    """Bytes literal"""
-
-    __slots__ = ("value",)
-
-    __match_args__ = ("value",)
-
-    # Note: we deliberately do NOT use bytes here because it ends up
-    # unnecessarily complicating a lot of the result logic. For example,
-    # we'd have to worry about converting the bytes into a format we can
-    # easily serialize/deserialize to and from JSON, would have to worry
-    # about turning the bytes into a human-readable representation in
-    # error messages...
-    #
-    # It's more convenient to just store the human-readable representation
-    # from the very start.
-    value: str
-
-    def __init__(self, value: str) -> None:
-        super().__init__()
-        self.value = value
-
-    def accept(self, visitor: ExpressionVisitor[T]) -> T:
-        return visitor.visit_bytes_expr(self)
-
-
-class FloatExpr(Expression):
-    """Float literal"""
-
-    __slots__ = ("value",)
-
-    __match_args__ = ("value",)
-
-    value: float  # 0.0 by default
-
-    def __init__(self, value: float) -> None:
-        super().__init__()
-        self.value = value
-
-    def accept(self, visitor: ExpressionVisitor[T]) -> T:
-        return visitor.visit_float_expr(self)
-
-
-class ComplexExpr(Expression):
-    """Complex literal"""
-
-    __slots__ = ("value",)
-
-    __match_args__ = ("value",)
-
-    value: complex
-
-    def __init__(self, value: complex) -> None:
-        super().__init__()
-        self.value = value
-
-    def accept(self, visitor: ExpressionVisitor[T]) -> T:
-        return visitor.visit_complex_expr(self)
-
-
-class EllipsisExpr(Expression):
-    """Ellipsis (...)"""
-
-    __slots__ = ()
-
-    def accept(self, visitor: ExpressionVisitor[T]) -> T:
-        return visitor.visit_ellipsis(self)
-
-
-class StarExpr(Expression):
-    """Star expression"""
-
-    __slots__ = ("expr", "valid")
-
-    __match_args__ = ("expr", "valid")
-
-    expr: Expression
-    valid: bool
-
-    def __init__(self, expr: Expression) -> None:
-        super().__init__()
-        self.expr = expr
-
-        # Whether this starred expression is used in a tuple/list and as lvalue
-        self.valid = False
-
-    def accept(self, visitor: ExpressionVisitor[T]) -> T:
-        return visitor.visit_star_expr(self)
-
-
-class RefExpr(Expression):
-    """Abstract base class for name-like constructs"""
-
-    __slots__ = (
-        "kind",
-        "node",
-        "_fullname",
-        "is_new_def",
-        "is_inferred_def",
-        "is_alias_rvalue",
-        "type_guard",
-    )
-
-    def __init__(self) -> None:
-        super().__init__()
-        # LDEF/GDEF/MDEF/... (None if not available)
-        self.kind: int | None = None
-        # Var, FuncDef or TypeInfo that describes this
-        self.node: SymbolNode | None = None
-        # Fully qualified name (or name if not global)
-        self._fullname = ""
-        # Does this define a new name?
-        self.is_new_def = False
-        # Does this define a new name with inferred type?
-        #
-        # For members, after semantic analysis, this does not take base
-        # classes into consideration at all; the type checker deals with these.
-        self.is_inferred_def = False
-        # Is this expression appears as an rvalue of a valid type alias definition?
-        self.is_alias_rvalue = False
-        # Cache type guard from callable_type.type_guard
-        self.type_guard: mypy.types.Type | None = None
-
-    @property
-    def fullname(self) -> str:
-        return self._fullname
-
-    @fullname.setter
-    def fullname(self, v: str) -> None:
-        self._fullname = v
-
-
-class NameExpr(RefExpr):
-    """Name expression
-
-    This refers to a local name, global name or a module.
-    """
-
-    __slots__ = ("name", "is_special_form")
-
-    __match_args__ = ("name", "node")
-
-    def __init__(self, name: str) -> None:
-        super().__init__()
-        self.name = name  # Name referred to
-        # Is this a l.h.s. of a special form assignment like typed dict or type variable?
-        self.is_special_form = False
-
-    def accept(self, visitor: ExpressionVisitor[T]) -> T:
-        return visitor.visit_name_expr(self)
-
-    def serialize(self) -> JsonDict:
-        assert False, f"Serializing NameExpr: {self}"
-
-
-class MemberExpr(RefExpr):
-    """Member access expression x.y"""
-
-    __slots__ = ("expr", "name", "def_var")
-
-    __match_args__ = ("expr", "name", "node")
-
-    def __init__(self, expr: Expression, name: str) -> None:
-        super().__init__()
-        self.expr = expr
-        self.name = name
-        # The variable node related to a definition through 'self.x = <initializer>'.
-        # The nodes of other kinds of member expressions are resolved during type checking.
-        self.def_var: Var | None = None
-
-    def accept(self, visitor: ExpressionVisitor[T]) -> T:
-        return visitor.visit_member_expr(self)
-
-
-# Kinds of arguments
-@unique
-class ArgKind(Enum):
-    # Positional argument
-    ARG_POS = 0
-    # Positional, optional argument (functions only, not calls)
-    ARG_OPT = 1
-    # *arg argument
-    ARG_STAR = 2
-    # Keyword argument x=y in call, or keyword-only function arg
-    ARG_NAMED = 3
-    # **arg argument
-    ARG_STAR2 = 4
-    # In an argument list, keyword-only and also optional
-    ARG_NAMED_OPT = 5
-
-    def is_positional(self, star: bool = False) -> bool:
-        return self == ARG_POS or self == ARG_OPT or (star and self == ARG_STAR)
-
-    def is_named(self, star: bool = False) -> bool:
-        return (
-            self == ARG_NAMED or self == ARG_NAMED_OPT or (star and self == ARG_STAR2)
-        )
-
-    def is_required(self) -> bool:
-        return self == ARG_POS or self == ARG_NAMED
-
-    def is_optional(self) -> bool:
-        return self == ARG_OPT or self == ARG_NAMED_OPT
-
-    def is_star(self) -> bool:
-        return self == ARG_STAR or self == ARG_STAR2
-
-
-ARG_POS: Final = ArgKind.ARG_POS
-ARG_OPT: Final = ArgKind.ARG_OPT
-ARG_STAR: Final = ArgKind.ARG_STAR
-ARG_NAMED: Final = ArgKind.ARG_NAMED
-ARG_STAR2: Final = ArgKind.ARG_STAR2
-ARG_NAMED_OPT: Final = ArgKind.ARG_NAMED_OPT
-
-
-class CallExpr(Expression):
-    """Call expression.
-
-    This can also represent several special forms that are syntactically calls
-    such as cast(...) and None  # type: ....
-    """
-
-    __slots__ = ("callee", "args", "arg_kinds", "arg_names", "analyzed")
-
-    __match_args__ = ("callee", "args", "arg_kinds", "arg_names")
-
-    def __init__(
-        self,
-        callee: Expression,
-        args: list[Expression],
-        arg_kinds: list[ArgKind],
-        arg_names: list[str | None],
-        analyzed: Expression | None = None,
-    ) -> None:
-        super().__init__()
-        if not arg_names:
-            arg_names = [None] * len(args)
-
-        self.callee = callee
-        self.args = args
-        self.arg_kinds = arg_kinds  # ARG_ constants
-        # Each name can be None if not a keyword argument.
-        self.arg_names: list[str | None] = arg_names
-        # If not None, the node that represents the meaning of the CallExpr. For
-        # cast(...) this is a CastExpr.
-        self.analyzed = analyzed
-
-    def accept(self, visitor: ExpressionVisitor[T]) -> T:
-        return visitor.visit_call_expr(self)
-
-
-class YieldFromExpr(Expression):
-    __slots__ = ("expr",)
-
-    __match_args__ = ("expr",)
-
-    expr: Expression
-
-    def __init__(self, expr: Expression) -> None:
-        super().__init__()
-        self.expr = expr
-
-    def accept(self, visitor: ExpressionVisitor[T]) -> T:
-        return visitor.visit_yield_from_expr(self)
-
-
-class YieldExpr(Expression):
-    __slots__ = ("expr",)
-
-    __match_args__ = ("expr",)
-
-    expr: Expression | None
-
-    def __init__(self, expr: Expression | None) -> None:
-        super().__init__()
-        self.expr = expr
-
-    def accept(self, visitor: ExpressionVisitor[T]) -> T:
-        return visitor.visit_yield_expr(self)
-
-
-class IndexExpr(Expression):
-    """Index expression x[y].
-
-    Also wraps type application such as List[int] as a special form.
-    """
-
-    __slots__ = ("base", "index", "method_type", "analyzed")
-
-    __match_args__ = ("base", "index")
-
-    base: Expression
-    index: Expression
-    # Inferred __getitem__ method type
-    method_type: mypy.types.Type | None
-    # If not None, this is actually semantically a type application
-    # Class[type, ...] or a type alias initializer.
-    analyzed: TypeApplication | TypeAliasExpr | None
-
-    def __init__(self, base: Expression, index: Expression) -> None:
-        super().__init__()
-        self.base = base
-        self.index = index
-        self.method_type = None
-        self.analyzed = None
-
-    def accept(self, visitor: ExpressionVisitor[T]) -> T:
-        return visitor.visit_index_expr(self)
-
-
-class UnaryExpr(Expression):
-    """Unary operation"""
-
-    __slots__ = ("op", "expr", "method_type")
-
-    __match_args__ = ("op", "expr")
-
-    op: str  # TODO: Enum?
-    expr: Expression
-    # Inferred operator method type
-    method_type: mypy.types.Type | None
-
-    def __init__(self, op: str, expr: Expression) -> None:
-        super().__init__()
-        self.op = op
-        self.expr = expr
-        self.method_type = None
-
-    def accept(self, visitor: ExpressionVisitor[T]) -> T:
-        return visitor.visit_unary_expr(self)
-
-
-class AssignmentExpr(Expression):
-    """Assignment expressions in Python 3.8+, like "a := 2"."""
-
-    __slots__ = ("target", "value")
-
-    __match_args__ = ("target", "value")
-
-    def __init__(self, target: Expression, value: Expression) -> None:
-        super().__init__()
-        self.target = target
-        self.value = value
-
-    def accept(self, visitor: ExpressionVisitor[T]) -> T:
-        return visitor.visit_assignment_expr(self)
-
-
-class OpExpr(Expression):
-    """Binary operation.
-
-    The dot (.), [] and comparison operators have more specific nodes.
-    """
-
-    __slots__ = (
-        "op",
-        "left",
-        "right",
-        "method_type",
-        "right_always",
-        "right_unreachable",
-        "analyzed",
-    )
-
-    __match_args__ = ("left", "op", "right")
-
-    op: str  # TODO: Enum?
-    left: Expression
-    right: Expression
-    # Inferred type for the operator method type (when relevant).
-    method_type: mypy.types.Type | None
-    # Per static analysis only: Is the right side going to be evaluated every time?
-    right_always: bool
-    # Per static analysis only: Is the right side unreachable?
-    right_unreachable: bool
-    # Used for expressions that represent a type "X | Y" in some contexts
-    analyzed: TypeAliasExpr | None
-
-    def __init__(
-        self,
-        op: str,
-        left: Expression,
-        right: Expression,
-        analyzed: TypeAliasExpr | None = None,
-    ) -> None:
-        super().__init__()
-        self.op = op
-        self.left = left
-        self.right = right
-        self.method_type = None
-        self.right_always = False
-        self.right_unreachable = False
-        self.analyzed = analyzed
-
-    def accept(self, visitor: ExpressionVisitor[T]) -> T:
-        return visitor.visit_op_expr(self)
-
-
-class ComparisonExpr(Expression):
-    """Comparison expression (e.g. a < b > c < d)."""
-
-    __slots__ = ("operators", "operands", "method_types")
-
-    __match_args__ = ("operands", "operators")
-
-    operators: list[str]
-    operands: list[Expression]
-    # Inferred type for the operator methods (when relevant; None for 'is').
-    method_types: list[mypy.types.Type | None]
-
-    def __init__(self, operators: list[str], operands: list[Expression]) -> None:
-        super().__init__()
-        self.operators = operators
-        self.operands = operands
-        self.method_types = []
-
-    def pairwise(self) -> Iterator[tuple[str, Expression, Expression]]:
-        """If this comparison expr is "a < b is c == d", yields the sequence
-        ("<", a, b), ("is", b, c), ("==", c, d)
-        """
-        for i, operator in enumerate(self.operators):
-            yield operator, self.operands[i], self.operands[i + 1]
-
-    def accept(self, visitor: ExpressionVisitor[T]) -> T:
-        return visitor.visit_comparison_expr(self)
-
-
-class SliceExpr(Expression):
-    """Slice expression (e.g. 'x:y', 'x:', '::2' or ':').
-
-    This is only valid as index in index expressions.
-    """
-
-    __slots__ = ("begin_index", "end_index", "stride")
-
-    __match_args__ = ("begin_index", "end_index", "stride")
-
-    begin_index: Expression | None
-    end_index: Expression | None
-    stride: Expression | None
-
-    def __init__(
-        self,
-        begin_index: Expression | None,
-        end_index: Expression | None,
-        stride: Expression | None,
-    ) -> None:
-        super().__init__()
-        self.begin_index = begin_index
-        self.end_index = end_index
-        self.stride = stride
-
-    def accept(self, visitor: ExpressionVisitor[T]) -> T:
-        return visitor.visit_slice_expr(self)
-
-
-class CastExpr(Expression):
-    """Cast expression cast(type, expr)."""
-
-    __slots__ = ("expr", "type")
-
-    __match_args__ = ("expr", "type")
-
-    expr: Expression
-    type: mypy.types.Type
-
-    def __init__(self, expr: Expression, typ: mypy.types.Type) -> None:
-        super().__init__()
-        self.expr = expr
-        self.type = typ
-
-    def accept(self, visitor: ExpressionVisitor[T]) -> T:
-        return visitor.visit_cast_expr(self)
-
-
-class AssertTypeExpr(Expression):
-    """Represents a typing.assert_type(expr, type) call."""
-
-    __slots__ = ("expr", "type")
-
-    __match_args__ = ("expr", "type")
-
-    expr: Expression
-    type: mypy.types.Type
-
-    def __init__(self, expr: Expression, typ: mypy.types.Type) -> None:
-        super().__init__()
-        self.expr = expr
-        self.type = typ
-
-    def accept(self, visitor: ExpressionVisitor[T]) -> T:
-        return visitor.visit_assert_type_expr(self)
-
-
-class RevealExpr(Expression):
-    """Reveal type expression reveal_type(expr) or reveal_locals() expression."""
-
-    __slots__ = ("expr", "kind", "local_nodes", "is_imported")
-
-    __match_args__ = ("expr", "kind", "local_nodes", "is_imported")
-
-    expr: Expression | None
-    kind: int
-    local_nodes: list[Var] | None
-
-    def __init__(
-        self,
-        kind: int,
-        expr: Expression | None = None,
-        local_nodes: list[Var] | None = None,
-        is_imported: bool = False,
-    ) -> None:
-        super().__init__()
-        self.expr = expr
-        self.kind = kind
-        self.local_nodes = local_nodes
-        self.is_imported = is_imported
-
-    def accept(self, visitor: ExpressionVisitor[T]) -> T:
-        return visitor.visit_reveal_expr(self)
-
-
-class SuperExpr(Expression):
-    """Expression super().name"""
-
-    __slots__ = ("name", "info", "call")
-
-    __match_args__ = ("name", "call", "info")
-
-    name: str
-    info: TypeInfo | None  # Type that contains this super expression
-    call: CallExpr  # The expression super(...)
-
-    def __init__(self, name: str, call: CallExpr) -> None:
-        super().__init__()
-        self.name = name
-        self.call = call
-        self.info = None
-
-    def accept(self, visitor: ExpressionVisitor[T]) -> T:
-        return visitor.visit_super_expr(self)
-
-
-class LambdaExpr(FuncItem, Expression):
-    """Lambda expression"""
-
-    __match_args__ = ("arguments", "arg_names", "arg_kinds", "body")
-
-    @property
-    def name(self) -> str:
-        return "<lambda>"
-
-    def expr(self) -> Expression:
-        """Return the expression (the body) of the lambda."""
-        ret = self.body.body[-1]
-        assert isinstance(ret, ReturnStmt)
-        expr = ret.expr
-        assert expr is not None  # lambda can't have empty body
-        return expr
-
-    def accept(self, visitor: ExpressionVisitor[T]) -> T:
-        return visitor.visit_lambda_expr(self)
-
-    def is_dynamic(self) -> bool:
-        return False
-
-
-class ListExpr(Expression):
-    """List literal expression [...]."""
-
-    __slots__ = ("items",)
-
-    __match_args__ = ("items",)
-
-    items: list[Expression]
-
-    def __init__(self, items: list[Expression]) -> None:
-        super().__init__()
-        self.items = items
-
-    def accept(self, visitor: ExpressionVisitor[T]) -> T:
-        return visitor.visit_list_expr(self)
-
-
-class DictExpr(Expression):
-    """Dictionary literal expression {key: value, ...}."""
-
-    __slots__ = ("items",)
-
-    __match_args__ = ("items",)
-
-    items: list[tuple[Expression | None, Expression]]
-
-    def __init__(self, items: list[tuple[Expression | None, Expression]]) -> None:
-        super().__init__()
-        self.items = items
-
-    def accept(self, visitor: ExpressionVisitor[T]) -> T:
-        return visitor.visit_dict_expr(self)
-
-
-class TupleExpr(Expression):
-    """Tuple literal expression (..., ...)
-
-    Also lvalue sequences (..., ...) and [..., ...]"""
-
-    __slots__ = ("items",)
-
-    __match_args__ = ("items",)
-
-    items: list[Expression]
-
-    def __init__(self, items: list[Expression]) -> None:
-        super().__init__()
-        self.items = items
-
-    def accept(self, visitor: ExpressionVisitor[T]) -> T:
-        return visitor.visit_tuple_expr(self)
-
-
-class SetExpr(Expression):
-    """Set literal expression {value, ...}."""
-
-    __slots__ = ("items",)
-
-    __match_args__ = ("items",)
-
-    items: list[Expression]
-
-    def __init__(self, items: list[Expression]) -> None:
-        super().__init__()
-        self.items = items
-
-    def accept(self, visitor: ExpressionVisitor[T]) -> T:
-        return visitor.visit_set_expr(self)
-
-
-class GeneratorExpr(Expression):
-    """Generator expression ... for ... in ... [ for ...  in ... ] [ if ... ]."""
-
-    __slots__ = ("left_expr", "sequences", "condlists", "is_async", "indices")
-
-    __match_args__ = ("left_expr", "indices", "sequences", "condlists")
-
-    left_expr: Expression
-    sequences: list[Expression]
-    condlists: list[list[Expression]]
-    is_async: list[bool]
-    indices: list[Lvalue]
-
-    def __init__(
-        self,
-        left_expr: Expression,
-        indices: list[Lvalue],
-        sequences: list[Expression],
-        condlists: list[list[Expression]],
-        is_async: list[bool],
-    ) -> None:
-        super().__init__()
-        self.left_expr = left_expr
-        self.sequences = sequences
-        self.condlists = condlists
-        self.indices = indices
-        self.is_async = is_async
-
-    def accept(self, visitor: ExpressionVisitor[T]) -> T:
-        return visitor.visit_generator_expr(self)
-
-
-class ListComprehension(Expression):
-    """List comprehension (e.g. [x + 1 for x in a])"""
-
-    __slots__ = ("generator",)
-
-    __match_args__ = ("generator",)
-
-    generator: GeneratorExpr
-
-    def __init__(self, generator: GeneratorExpr) -> None:
-        super().__init__()
-        self.generator = generator
-
-    def accept(self, visitor: ExpressionVisitor[T]) -> T:
-        return visitor.visit_list_comprehension(self)
-
-
-class SetComprehension(Expression):
-    """Set comprehension (e.g. {x + 1 for x in a})"""
-
-    __slots__ = ("generator",)
-
-    __match_args__ = ("generator",)
-
-    generator: GeneratorExpr
-
-    def __init__(self, generator: GeneratorExpr) -> None:
-        super().__init__()
-        self.generator = generator
-
-    def accept(self, visitor: ExpressionVisitor[T]) -> T:
-        return visitor.visit_set_comprehension(self)
-
-
-class DictionaryComprehension(Expression):
-    """Dictionary comprehension (e.g. {k: v for k, v in a}"""
-
-    __slots__ = ("key", "value", "sequences", "condlists", "is_async", "indices")
-
-    __match_args__ = ("key", "value", "indices", "sequences", "condlists")
-
-    key: Expression
-    value: Expression
-    sequences: list[Expression]
-    condlists: list[list[Expression]]
-    is_async: list[bool]
-    indices: list[Lvalue]
-
-    def __init__(
-        self,
-        key: Expression,
-        value: Expression,
-        indices: list[Lvalue],
-        sequences: list[Expression],
-        condlists: list[list[Expression]],
-        is_async: list[bool],
-    ) -> None:
-        super().__init__()
-        self.key = key
-        self.value = value
-        self.sequences = sequences
-        self.condlists = condlists
-        self.indices = indices
-        self.is_async = is_async
-
-    def accept(self, visitor: ExpressionVisitor[T]) -> T:
-        return visitor.visit_dictionary_comprehension(self)
-
-
-class ConditionalExpr(Expression):
-    """Conditional expression (e.g. x if y else z)"""
-
-    __slots__ = ("cond", "if_expr", "else_expr")
-
-    __match_args__ = ("if_expr", "cond", "else_expr")
-
-    cond: Expression
-    if_expr: Expression
-    else_expr: Expression
-
-    def __init__(
-        self, cond: Expression, if_expr: Expression, else_expr: Expression
-    ) -> None:
-        super().__init__()
-        self.cond = cond
-        self.if_expr = if_expr
-        self.else_expr = else_expr
-
-    def accept(self, visitor: ExpressionVisitor[T]) -> T:
-        return visitor.visit_conditional_expr(self)
-
-
-class TypeApplication(Expression):
-    """Type application expr[type, ...]"""
-
-    __slots__ = ("expr", "types")
-
-    __match_args__ = ("expr", "types")
-
-    expr: Expression
-    types: list[mypy.types.Type]
-
-    def __init__(self, expr: Expression, types: list[mypy.types.Type]) -> None:
-        super().__init__()
-        self.expr = expr
-        self.types = types
-
-    def accept(self, visitor: ExpressionVisitor[T]) -> T:
-        return visitor.visit_type_application(self)
-
-
-# Variance of a type variable. For example, T in the definition of
-# List[T] is invariant, so List[int] is not a subtype of List[object],
-# and also List[object] is not a subtype of List[int].
-#
-# The T in Iterable[T] is covariant, so Iterable[int] is a subtype of
-# Iterable[object], but not vice versa.
-#
-# If T is contravariant in Foo[T], Foo[object] is a subtype of
-# Foo[int], but not vice versa.
-INVARIANT: Final = 0
-COVARIANT: Final = 1
-CONTRAVARIANT: Final = 2
-
-
-class TypeVarLikeExpr(SymbolNode, Expression):
-    """Base class for TypeVarExpr, ParamSpecExpr and TypeVarTupleExpr.
-
-    Note that they are constructed by the semantic analyzer.
-    """
-
-    __slots__ = ("_name", "_fullname", "upper_bound", "default", "variance")
-
-    _name: str
-    _fullname: str
-    # Upper bound: only subtypes of upper_bound are valid as values. By default
-    # this is 'object', meaning no restriction.
-    upper_bound: mypy.types.Type
-    # Default: used to resolve the TypeVar if the default is not explicitly given.
-    # By default this is 'AnyType(TypeOfAny.from_omitted_generics)'. See PEP 696.
-    default: mypy.types.Type
-    # Variance of the type variable. Invariant is the default.
-    # TypeVar(..., covariant=True) defines a covariant type variable.
-    # TypeVar(..., contravariant=True) defines a contravariant type
-    # variable.
-    variance: int
-
-    def __init__(
-        self,
-        name: str,
-        fullname: str,
-        upper_bound: mypy.types.Type,
-        default: mypy.types.Type,
-        variance: int = INVARIANT,
-    ) -> None:
-        super().__init__()
-        self._name = name
-        self._fullname = fullname
-        self.upper_bound = upper_bound
-        self.default = default
-        self.variance = variance
-
-    @property
-    def name(self) -> str:
-        return self._name
-
-    @property
-    def fullname(self) -> str:
-        return self._fullname
-
-
-class TypeVarExpr(TypeVarLikeExpr):
-    """Type variable expression TypeVar(...).
-
-    This is also used to represent type variables in symbol tables.
-
-    A type variable is not valid as a type unless bound in a TypeVarLikeScope.
-    That happens within:
-
-     1. a generic class that uses the type variable as a type argument or
-     2. a generic function that refers to the type variable in its signature.
-    """
-
-    __slots__ = ("values",)
-
-    __match_args__ = ("name", "values", "upper_bound", "default")
-
-    # Value restriction: only types in the list are valid as values. If the
-    # list is empty, there is no restriction.
-    values: list[mypy.types.Type]
-
-    def __init__(
-        self,
-        name: str,
-        fullname: str,
-        values: list[mypy.types.Type],
-        upper_bound: mypy.types.Type,
-        default: mypy.types.Type,
-        variance: int = INVARIANT,
-    ) -> None:
-        super().__init__(name, fullname, upper_bound, default, variance)
-        self.values = values
-
-    def accept(self, visitor: ExpressionVisitor[T]) -> T:
-        return visitor.visit_type_var_expr(self)
-
-    def serialize(self) -> JsonDict:
-        return {
-            ".class": "TypeVarExpr",
-            "name": self._name,
-            "fullname": self._fullname,
-            "values": [t.serialize() for t in self.values],
-            "upper_bound": self.upper_bound.serialize(),
-            "default": self.default.serialize(),
-            "variance": self.variance,
-        }
-
-    @classmethod
-    def deserialize(cls, data: JsonDict) -> TypeVarExpr:
-        assert data[".class"] == "TypeVarExpr"
-        return TypeVarExpr(
-            data["name"],
-            data["fullname"],
-            [mypy.types.deserialize_type(v) for v in data["values"]],
-            mypy.types.deserialize_type(data["upper_bound"]),
-            mypy.types.deserialize_type(data["default"]),
-            data["variance"],
-        )
-
-
-class ParamSpecExpr(TypeVarLikeExpr):
-    __slots__ = ()
-
-    __match_args__ = ("name", "upper_bound", "default")
-
-    def accept(self, visitor: ExpressionVisitor[T]) -> T:
-        return visitor.visit_paramspec_expr(self)
-
-    def serialize(self) -> JsonDict:
-        return {
-            ".class": "ParamSpecExpr",
-            "name": self._name,
-            "fullname": self._fullname,
-            "upper_bound": self.upper_bound.serialize(),
-            "default": self.default.serialize(),
-            "variance": self.variance,
-        }
-
-    @classmethod
-    def deserialize(cls, data: JsonDict) -> ParamSpecExpr:
-        assert data[".class"] == "ParamSpecExpr"
-        return ParamSpecExpr(
-            data["name"],
-            data["fullname"],
-            mypy.types.deserialize_type(data["upper_bound"]),
-            mypy.types.deserialize_type(data["default"]),
-            data["variance"],
-        )
-
-
-class TypeVarTupleExpr(TypeVarLikeExpr):
-    """Type variable tuple expression TypeVarTuple(...)."""
-
-    __slots__ = "tuple_fallback"
-
-    tuple_fallback: mypy.types.Instance
-
-    __match_args__ = ("name", "upper_bound", "default")
-
-    def __init__(
-        self,
-        name: str,
-        fullname: str,
-        upper_bound: mypy.types.Type,
-        tuple_fallback: mypy.types.Instance,
-        default: mypy.types.Type,
-        variance: int = INVARIANT,
-    ) -> None:
-        super().__init__(name, fullname, upper_bound, default, variance)
-        self.tuple_fallback = tuple_fallback
-
-    def accept(self, visitor: ExpressionVisitor[T]) -> T:
-        return visitor.visit_type_var_tuple_expr(self)
-
-    def serialize(self) -> JsonDict:
-        return {
-            ".class": "TypeVarTupleExpr",
-            "name": self._name,
-            "fullname": self._fullname,
-            "upper_bound": self.upper_bound.serialize(),
-            "tuple_fallback": self.tuple_fallback.serialize(),
-            "default": self.default.serialize(),
-            "variance": self.variance,
-        }
-
-    @classmethod
-    def deserialize(cls, data: JsonDict) -> TypeVarTupleExpr:
-        assert data[".class"] == "TypeVarTupleExpr"
-        return TypeVarTupleExpr(
-            data["name"],
-            data["fullname"],
-            mypy.types.deserialize_type(data["upper_bound"]),
-            mypy.types.Instance.deserialize(data["tuple_fallback"]),
-            mypy.types.deserialize_type(data["default"]),
-            data["variance"],
-        )
-
-
-class TypeAliasExpr(Expression):
-    """Type alias expression (rvalue)."""
-
-    __slots__ = ("node",)
-
-    __match_args__ = ("node",)
-
-    node: TypeAlias
-
-    def __init__(self, node: TypeAlias) -> None:
-        super().__init__()
-        self.node = node
-
-    def accept(self, visitor: ExpressionVisitor[T]) -> T:
-        return visitor.visit_type_alias_expr(self)
-
-
-class NamedTupleExpr(Expression):
-    """Named tuple expression namedtuple(...) or NamedTuple(...)."""
-
-    __slots__ = ("info", "is_typed")
-
-    __match_args__ = ("info",)
-
-    # The class representation of this named tuple (its tuple_type attribute contains
-    # the tuple item types)
-    info: TypeInfo
-    is_typed: bool  # whether this class was created with typing(_extensions).NamedTuple
-
-    def __init__(self, info: TypeInfo, is_typed: bool = False) -> None:
-        super().__init__()
-        self.info = info
-        self.is_typed = is_typed
-
-    def accept(self, visitor: ExpressionVisitor[T]) -> T:
-        return visitor.visit_namedtuple_expr(self)
-
-
-class TypedDictExpr(Expression):
-    """Typed dict expression TypedDict(...)."""
-
-    __slots__ = ("info",)
-
-    __match_args__ = ("info",)
-
-    # The class representation of this typed dict
-    info: TypeInfo
-
-    def __init__(self, info: TypeInfo) -> None:
-        super().__init__()
-        self.info = info
-
-    def accept(self, visitor: ExpressionVisitor[T]) -> T:
-        return visitor.visit_typeddict_expr(self)
-
-
-class EnumCallExpr(Expression):
-    """Named tuple expression Enum('name', 'val1 val2 ...')."""
-
-    __slots__ = ("info", "items", "values")
-
-    __match_args__ = ("info", "items", "values")
-
-    # The class representation of this enumerated type
-    info: TypeInfo
-    # The item names (for debugging)
-    items: list[str]
-    values: list[Expression | None]
-
-    def __init__(
-        self, info: TypeInfo, items: list[str], values: list[Expression | None]
-    ) -> None:
-        super().__init__()
-        self.info = info
-        self.items = items
-        self.values = values
-
-    def accept(self, visitor: ExpressionVisitor[T]) -> T:
-        return visitor.visit_enum_call_expr(self)
-
-
-class PromoteExpr(Expression):
-    """Ducktype class decorator expression _promote(...)."""
-
-    __slots__ = ("type",)
-
-    type: mypy.types.ProperType
-
-    def __init__(self, type: mypy.types.ProperType) -> None:
-        super().__init__()
-        self.type = type
-
-    def accept(self, visitor: ExpressionVisitor[T]) -> T:
-        return visitor.visit__promote_expr(self)
-
-
-class NewTypeExpr(Expression):
-    """NewType expression NewType(...)."""
-
-    __slots__ = ("name", "old_type", "info")
-
-    __match_args__ = ("name", "old_type", "info")
-
-    name: str
-    # The base type (the second argument to NewType)
-    old_type: mypy.types.Type | None
-    # The synthesized class representing the new type (inherits old_type)
-    info: TypeInfo | None
-
-    def __init__(
-        self, name: str, old_type: mypy.types.Type | None, line: int, column: int
-    ) -> None:
-        super().__init__(line=line, column=column)
-        self.name = name
-        self.old_type = old_type
-        self.info = None
-
-    def accept(self, visitor: ExpressionVisitor[T]) -> T:
-        return visitor.visit_newtype_expr(self)
-
-
-class AwaitExpr(Expression):
-    """Await expression (await ...)."""
-
-    __slots__ = ("expr",)
-
-    __match_args__ = ("expr",)
-
-    expr: Expression
-
-    def __init__(self, expr: Expression) -> None:
-        super().__init__()
-        self.expr = expr
-
-    def accept(self, visitor: ExpressionVisitor[T]) -> T:
-        return visitor.visit_await_expr(self)
-
-
-# Constants
-
-
-class TempNode(Expression):
-    """Temporary dummy node used during type checking.
-
-    This node is not present in the original program; it is just an artifact
-    of the type checker implementation. It only represents an opaque node with
-    some fixed type.
-    """
-
-    __slots__ = ("type", "no_rhs")
-
-    type: mypy.types.Type
-    # Is this TempNode used to indicate absence of a right hand side in an annotated assignment?
-    # (e.g. for 'x: int' the rvalue is TempNode(AnyType(TypeOfAny.special_form), no_rhs=True))
-    no_rhs: bool
-
-    def __init__(
-        self,
-        typ: mypy.types.Type,
-        no_rhs: bool = False,
-        *,
-        context: Context | None = None,
-    ) -> None:
-        """Construct a dummy node; optionally borrow line/column from context object."""
-        super().__init__()
-        self.type = typ
-        self.no_rhs = no_rhs
-        if context is not None:
-            self.line = context.line
-            self.column = context.column
-
-    def __repr__(self) -> str:
-        return "TempNode:%d(%s)" % (self.line, str(self.type))
-
-    def accept(self, visitor: ExpressionVisitor[T]) -> T:
-        return visitor.visit_temp_node(self)
-
-
-# Special attributes not collected as protocol members by Python 3.12
-# See typing._SPECIAL_NAMES
-EXCLUDED_PROTOCOL_ATTRIBUTES: Final = frozenset(
-    {
-        "__abstractmethods__",
-        "__annotations__",
-        "__dict__",
-        "__doc__",
-        "__init__",
-        "__module__",
-        "__new__",
-        "__slots__",
-        "__subclasshook__",
-        "__weakref__",
-        "__class_getitem__",  # Since Python 3.9
-    }
-)
-
-
-class TypeInfo(SymbolNode):
-    """The type structure of a single class.
-
-    Each TypeInfo corresponds one-to-one to a ClassDef, which
-    represents the AST of the class.
-
-    In type-theory terms, this is a "type constructor", and if the
-    class is generic then it will be a type constructor of higher kind.
-    Where the class is used in an actual type, it's in the form of an
-    Instance, which amounts to a type application of the tycon to
-    the appropriate number of arguments.
-    """
-
-    __slots__ = (
-        "_fullname",
-        "module_name",
-        "defn",
-        "mro",
-        "_mro_refs",
-        "bad_mro",
-        "is_final",
-        "declared_metaclass",
-        "metaclass_type",
-        "names",
-        "is_abstract",
-        "is_protocol",
-        "runtime_protocol",
-        "abstract_attributes",
-        "deletable_attributes",
-        "slots",
-        "assuming",
-        "assuming_proper",
-        "inferring",
-        "is_enum",
-        "fallback_to_any",
-        "meta_fallback_to_any",
-        "type_vars",
-        "has_param_spec_type",
-        "bases",
-        "_promote",
-        "tuple_type",
-        "special_alias",
-        "is_named_tuple",
-        "typeddict_type",
-        "is_newtype",
-        "is_intersection",
-        "metadata",
-        "alt_promote",
-        "has_type_var_tuple_type",
-        "type_var_tuple_prefix",
-        "type_var_tuple_suffix",
-        "self_type",
-        "dataclass_transform_spec",
-        "is_type_check_only",
-    )
-
-    _fullname: str  # Fully qualified name
-    # Fully qualified name for the module this type was defined in. This
-    # information is also in the fullname, but is harder to extract in the
-    # case of nested class definitions.
-    module_name: str
-    defn: ClassDef  # Corresponding ClassDef
-    # Method Resolution Order: the order of looking up attributes. The first
-    # value always to refers to this class.
-    mro: list[TypeInfo]
-    # Used to stash the names of the mro classes temporarily between
-    # deserialization and fixup. See deserialize() for why.
-    _mro_refs: list[str] | None
-    bad_mro: bool  # Could not construct full MRO
-    is_final: bool
-
-    declared_metaclass: mypy.types.Instance | None
-    metaclass_type: mypy.types.Instance | None
-
-    names: SymbolTable  # Names defined directly in this type
-    is_abstract: bool  # Does the class have any abstract attributes?
-    is_protocol: bool  # Is this a protocol class?
-    runtime_protocol: bool  # Does this protocol support isinstance checks?
-    # List of names of abstract attributes together with their abstract status.
-    # The abstract status must be one of `NOT_ABSTRACT`, `IS_ABSTRACT`, `IMPLICITLY_ABSTRACT`.
-    abstract_attributes: list[tuple[str, int]]
-    deletable_attributes: list[str]  # Used by mypyc only
-    # Does this type have concrete `__slots__` defined?
-    # If class does not have `__slots__` defined then it is `None`,
-    # if it has empty `__slots__` then it is an empty set.
-    slots: set[str] | None
-
-    # The attributes 'assuming' and 'assuming_proper' represent structural subtype matrices.
-    #
-    # In languages with structural subtyping, one can keep a global subtype matrix like this:
-    #   . A B C .
-    #   A 1 0 0
-    #   B 1 1 1
-    #   C 1 0 1
-    #   .
-    # where 1 indicates that the type in corresponding row is a subtype of the type
-    # in corresponding column. This matrix typically starts filled with all 1's and
-    # a typechecker tries to "disprove" every subtyping relation using atomic (or nominal) types.
-    # However, we don't want to keep this huge global state. Instead, we keep the subtype
-    # information in the form of list of pairs (subtype, supertype) shared by all Instances
-    # with given supertype's TypeInfo. When we enter a subtype check we push a pair in this list
-    # thus assuming that we started with 1 in corresponding matrix element. Such algorithm allows
-    # to treat recursive and mutually recursive protocols and other kinds of complex situations.
-    #
-    # If concurrent/parallel type checking will be added in future,
-    # then there should be one matrix per thread/process to avoid false negatives
-    # during the type checking phase.
-    assuming: list[tuple[mypy.types.Instance, mypy.types.Instance]]
-    assuming_proper: list[tuple[mypy.types.Instance, mypy.types.Instance]]
-    # Ditto for temporary 'inferring' stack of recursive constraint inference.
-    # It contains Instances of protocol types that appeared as an argument to
-    # constraints.infer_constraints(). We need 'inferring' to avoid infinite recursion for
-    # recursive and mutually recursive protocols.
-    #
-    # We make 'assuming' and 'inferring' attributes here instead of passing they as kwargs,
-    # since this would require to pass them in many dozens of calls. In particular,
-    # there is a dependency infer_constraint -> is_subtype -> is_callable_subtype ->
-    # -> infer_constraints.
-    inferring: list[mypy.types.Instance]
-    # 'inferring' and 'assuming' can't be made sets, since we need to use
-    # is_same_type to correctly treat unions.
-
-    # Classes inheriting from Enum shadow their true members with a __getattr__, so we
-    # have to treat them as a special case.
-    is_enum: bool
-    # If true, any unknown attributes should have type 'Any' instead
-    # of generating a type error.  This would be true if there is a
-    # base class with type 'Any', but other use cases may be
-    # possible. This is similar to having __getattr__ that returns Any
-    # (and __setattr__), but without the __getattr__ method.
-    fallback_to_any: bool
-
-    # Same as above but for cases where metaclass has type Any. This will suppress
-    # all attribute errors only for *class object* access.
-    meta_fallback_to_any: bool
-
-    # Information related to type annotations.
-
-    # Generic type variable names (full names)
-    type_vars: list[str]
-
-    # Whether this class has a ParamSpec type variable
-    has_param_spec_type: bool
-
-    # Direct base classes.
-    bases: list[mypy.types.Instance]
-
-    # Another type which this type will be treated as a subtype of,
-    # even though it's not a subclass in Python.  The non-standard
-    # `@_promote` decorator introduces this, and there are also
-    # several builtin examples, in particular `int` -> `float`.
-    _promote: list[mypy.types.ProperType]
-
-    # This is used for promoting native integer types such as 'i64' to
-    # 'int'. (_promote is used for the other direction.) This only
-    # supports one-step promotions (e.g., i64 -> int, not
-    # i64 -> int -> float, and this isn't used to promote in joins.
-    #
-    # This results in some unintuitive results, such as that even
-    # though i64 is compatible with int and int is compatible with
-    # float, i64 is *not* compatible with float.
-    alt_promote: mypy.types.Instance | None
-
-    # Representation of a Tuple[...] base class, if the class has any
-    # (e.g., for named tuples). If this is not None, the actual Type
-    # object used for this class is not an Instance but a TupleType;
-    # the corresponding Instance is set as the fallback type of the
-    # tuple type.
-    tuple_type: mypy.types.TupleType | None
-
-    # Is this a named tuple type?
-    is_named_tuple: bool
-
-    # If this class is defined by the TypedDict type constructor,
-    # then this is not None.
-    typeddict_type: mypy.types.TypedDictType | None
-
-    # Is this a newtype type?
-    is_newtype: bool
-
-    # Is this a synthesized intersection type?
-    is_intersection: bool
-
-    # This is a dictionary that will be serialized and un-serialized as is.
-    # It is useful for plugins to add their data to save in the cache.
-    metadata: dict[str, JsonDict]
-
-    # Store type alias representing this type (for named tuples and TypedDicts).
-    # Although definitions of these types are stored in symbol tables as TypeInfo,
-    # when a type analyzer will find them, it should construct a TupleType, or
-    # a TypedDict type. However, we can't use the plain types, since if the definition
-    # is recursive, this will create an actual recursive structure of types (i.e. as
-    # internal Python objects) causing infinite recursions everywhere during type checking.
-    # To overcome this, we create a TypeAlias node, that will point to these types.
-    # We store this node in the `special_alias` attribute, because it must be the same node
-    # in case we are doing multiple semantic analysis passes.
-    special_alias: TypeAlias | None
-
-    # Shared type variable for typing.Self in this class (if used, otherwise None).
-    self_type: mypy.types.TypeVarType | None
-
-    # Added if the corresponding class is directly decorated with `typing.dataclass_transform`
-    dataclass_transform_spec: DataclassTransformSpec | None
-
-    # Is set to `True` when class is decorated with `@typing.type_check_only`
-    is_type_check_only: bool
-
-    FLAGS: Final = [
-        "is_abstract",
-        "is_enum",
-        "fallback_to_any",
-        "meta_fallback_to_any",
-        "is_named_tuple",
-        "is_newtype",
-        "is_protocol",
-        "runtime_protocol",
-        "is_final",
-        "is_intersection",
-    ]
-
-    def __init__(self, names: SymbolTable, defn: ClassDef, module_name: str) -> None:
-        """Initialize a TypeInfo."""
-        super().__init__()
-        self._fullname = defn.fullname
-        self.names = names
-        self.defn = defn
-        self.module_name = module_name
-        self.type_vars = []
-        self.has_param_spec_type = False
-        self.has_type_var_tuple_type = False
-        self.bases = []
-        self.mro = []
-        self._mro_refs = None
-        self.bad_mro = False
-        self.declared_metaclass = None
-        self.metaclass_type = None
-        self.is_abstract = False
-        self.abstract_attributes = []
-        self.deletable_attributes = []
-        self.slots = None
-        self.assuming = []
-        self.assuming_proper = []
-        self.inferring = []
-        self.is_protocol = False
-        self.runtime_protocol = False
-        self.type_var_tuple_prefix: int | None = None
-        self.type_var_tuple_suffix: int | None = None
-        self.add_type_vars()
-        self.is_final = False
-        self.is_enum = False
-        self.fallback_to_any = False
-        self.meta_fallback_to_any = False
-        self._promote = []
-        self.alt_promote = None
-        self.tuple_type = None
-        self.special_alias = None
-        self.is_named_tuple = False
-        self.typeddict_type = None
-        self.is_newtype = False
-        self.is_intersection = False
-        self.metadata = {}
-        self.self_type = None
-        self.dataclass_transform_spec = None
-        self.is_type_check_only = False
-
-    def add_type_vars(self) -> None:
-        self.has_type_var_tuple_type = False
-        if self.defn.type_vars:
-            for i, vd in enumerate(self.defn.type_vars):
-                if isinstance(vd, mypy.types.ParamSpecType):
-                    self.has_param_spec_type = True
-                if isinstance(vd, mypy.types.TypeVarTupleType):
-                    assert not self.has_type_var_tuple_type
-                    self.has_type_var_tuple_type = True
-                    self.type_var_tuple_prefix = i
-                    self.type_var_tuple_suffix = len(self.defn.type_vars) - i - 1
-                self.type_vars.append(vd.name)
-        assert not (
-            self.has_param_spec_type and self.has_type_var_tuple_type
-        ), "Mixing type var tuples and param specs not supported yet"
-
-    @property
-    def name(self) -> str:
-        """Short name."""
-        return self.defn.name
-
-    @property
-    def fullname(self) -> str:
-        return self._fullname
-
-    def is_generic(self) -> bool:
-        """Is the type generic (i.e. does it have type variables)?"""
-        return len(self.type_vars) > 0
-
-    def get(self, name: str) -> SymbolTableNode | None:
-        for cls in self.mro:
-            n = cls.names.get(name)
-            if n:
-                return n
-        return None
-
-    def get_containing_type_info(self, name: str) -> TypeInfo | None:
-        for cls in self.mro:
-            if name in cls.names:
-                return cls
-        return None
-
-    @property
-    def protocol_members(self) -> list[str]:
-        # Protocol members are names of all attributes/methods defined in a protocol
-        # and in all its supertypes (except for 'object').
-        members: set[str] = set()
-        assert (
-            self.mro
-        ), "This property can be only accessed after MRO is (re-)calculated"
-        for base in self.mro[:-1]:  # we skip "object" since everyone implements it
-            if base.is_protocol:
-                for name, node in base.names.items():
-                    if isinstance(node.node, (TypeAlias, TypeVarExpr, MypyFile)):
-                        # These are auxiliary definitions (and type aliases are prohibited).
-                        continue
-                    if name in EXCLUDED_PROTOCOL_ATTRIBUTES:
-                        continue
-                    members.add(name)
-        return sorted(members)
-
-    def __getitem__(self, name: str) -> SymbolTableNode:
-        n = self.get(name)
-        if n:
-            return n
-        else:
-            raise KeyError(name)
-
-    def __repr__(self) -> str:
-        return f"<TypeInfo {self.fullname}>"
-
-    def __bool__(self) -> bool:
-        # We defined this here instead of just overriding it in
-        # FakeInfo so that mypyc can generate a direct call instead of
-        # using the generic bool handling.
-        return not isinstance(self, FakeInfo)
-
-    def has_readable_member(self, name: str) -> bool:
-        return self.get(name) is not None
-
-    def get_method(self, name: str) -> FuncBase | Decorator | None:
-        for cls in self.mro:
-            if name in cls.names:
-                node = cls.names[name].node
-                if isinstance(node, FuncBase):
-                    return node
-                elif isinstance(node, Decorator):  # Two `if`s make `mypyc` happy
-                    return node
-                else:
-                    return None
-        return None
-
-    def calculate_metaclass_type(self) -> mypy.types.Instance | None:
-        declared = self.declared_metaclass
-        if declared is not None and not declared.type.has_base("builtins.type"):
-            return declared
-        if self._fullname == "builtins.type":
-            return mypy.types.Instance(self, [])
-        candidates = [
-            s.declared_metaclass
-            for s in self.mro
-            if s.declared_metaclass is not None
-            and s.declared_metaclass.type is not None
-        ]
-        for c in candidates:
-            if all(other.type in c.type.mro for other in candidates):
-                return c
-        return None
-
-    def is_metaclass(self) -> bool:
-        return (
-            self.has_base("builtins.type")
-            or self.fullname == "abc.ABCMeta"
-            or self.fallback_to_any
-        )
-
-    def has_base(self, fullname: str) -> bool:
-        """Return True if type has a base type with the specified name.
-
-        This can be either via extension or via implementation.
-        """
-        for cls in self.mro:
-            if cls.fullname == fullname:
-                return True
-        return False
-
-    def direct_base_classes(self) -> list[TypeInfo]:
-        """Return a direct base classes.
-
-        Omit base classes of other base classes.
-        """
-        return [base.type for base in self.bases]
-
-    def update_tuple_type(self, typ: mypy.types.TupleType) -> None:
-        """Update tuple_type and special_alias as needed."""
-        self.tuple_type = typ
-        alias = TypeAlias.from_tuple_type(self)
-        if not self.special_alias:
-            self.special_alias = alias
-        else:
-            self.special_alias.target = alias.target
-
-    def update_typeddict_type(self, typ: mypy.types.TypedDictType) -> None:
-        """Update typeddict_type and special_alias as needed."""
-        self.typeddict_type = typ
-        alias = TypeAlias.from_typeddict_type(self)
-        if not self.special_alias:
-            self.special_alias = alias
-        else:
-            self.special_alias.target = alias.target
-
-    def __str__(self) -> str:
-        """Return a string representation of the type.
-
-        This includes the most important information about the type.
-        """
-        options = Options()
-        return self.dump(
-            str_conv=mypy.strconv.StrConv(options=options),
-            type_str_conv=mypy.types.TypeStrVisitor(options=options),
-        )
-
-    def dump(
-        self, str_conv: mypy.strconv.StrConv, type_str_conv: mypy.types.TypeStrVisitor
-    ) -> str:
-        """Return a string dump of the contents of the TypeInfo."""
-
-        base: str = ""
-
-        def type_str(typ: mypy.types.Type) -> str:
-            return typ.accept(type_str_conv)
-
-        head = "TypeInfo" + str_conv.format_id(self)
-        if self.bases:
-            base = f"Bases({', '.join(type_str(base) for base in self.bases)})"
-        mro = "Mro({})".format(
-            ", ".join(item.fullname + str_conv.format_id(item) for item in self.mro)
-        )
-        names = []
-        for name in sorted(self.names):
-            description = name + str_conv.format_id(self.names[name].node)
-            node = self.names[name].node
-            if isinstance(node, Var) and node.type:
-                description += f" ({type_str(node.type)})"
-            names.append(description)
-        items = [f"Name({self.fullname})", base, mro, ("Names", names)]
-        if self.declared_metaclass:
-            items.append(f"DeclaredMetaclass({type_str(self.declared_metaclass)})")
-        if self.metaclass_type:
-            items.append(f"MetaclassType({type_str(self.metaclass_type)})")
-        return mypy.strconv.dump_tagged(items, head, str_conv=str_conv)
-
-    def serialize(self) -> JsonDict:
-        # NOTE: This is where all ClassDefs originate, so there shouldn't be duplicates.
-        data = {
-            ".class": "TypeInfo",
-            "module_name": self.module_name,
-            "fullname": self.fullname,
-            "names": self.names.serialize(self.fullname),
-            "defn": self.defn.serialize(),
-            "abstract_attributes": self.abstract_attributes,
-            "type_vars": self.type_vars,
-            "has_param_spec_type": self.has_param_spec_type,
-            "bases": [b.serialize() for b in self.bases],
-            "mro": [c.fullname for c in self.mro],
-            "_promote": [p.serialize() for p in self._promote],
-            "alt_promote": (
-                None if self.alt_promote is None else self.alt_promote.serialize()
-            ),
-            "declared_metaclass": (
-                None
-                if self.declared_metaclass is None
-                else self.declared_metaclass.serialize()
-            ),
-            "metaclass_type": (
-                None if self.metaclass_type is None else self.metaclass_type.serialize()
-            ),
-            "tuple_type": (
-                None if self.tuple_type is None else self.tuple_type.serialize()
-            ),
-            "typeddict_type": (
-                None if self.typeddict_type is None else self.typeddict_type.serialize()
-            ),
-            "flags": get_flags(self, TypeInfo.FLAGS),
-            "metadata": self.metadata,
-            "slots": sorted(self.slots) if self.slots is not None else None,
-            "deletable_attributes": self.deletable_attributes,
-            "self_type": (
-                self.self_type.serialize() if self.self_type is not None else None
-            ),
-            "dataclass_transform_spec": (
-                self.dataclass_transform_spec.serialize()
-                if self.dataclass_transform_spec is not None
-                else None
-            ),
-        }
-        return data
-
-    @classmethod
-    def deserialize(cls, data: JsonDict) -> TypeInfo:
-        names = SymbolTable.deserialize(data["names"])
-        defn = ClassDef.deserialize(data["defn"])
-        module_name = data["module_name"]
-        ti = TypeInfo(names, defn, module_name)
-        ti._fullname = data["fullname"]
-        # TODO: Is there a reason to reconstruct ti.subtypes?
-        ti.abstract_attributes = [
-            (attr[0], attr[1]) for attr in data["abstract_attributes"]
-        ]
-        ti.type_vars = data["type_vars"]
-        ti.has_param_spec_type = data["has_param_spec_type"]
-        ti.bases = [mypy.types.Instance.deserialize(b) for b in data["bases"]]
-        _promote = []
-        for p in data["_promote"]:
-            t = mypy.types.deserialize_type(p)
-            assert isinstance(t, mypy.types.ProperType)
-            _promote.append(t)
-        ti._promote = _promote
-        ti.alt_promote = (
-            None
-            if data["alt_promote"] is None
-            else mypy.types.Instance.deserialize(data["alt_promote"])
-        )
-        ti.declared_metaclass = (
-            None
-            if data["declared_metaclass"] is None
-            else mypy.types.Instance.deserialize(data["declared_metaclass"])
-        )
-        ti.metaclass_type = (
-            None
-            if data["metaclass_type"] is None
-            else mypy.types.Instance.deserialize(data["metaclass_type"])
-        )
-        # NOTE: ti.mro will be set in the fixup phase based on these
-        # names.  The reason we need to store the mro instead of just
-        # recomputing it from base classes has to do with a subtle
-        # point about fine-grained incremental: the cache files might
-        # not be loaded until after a class in the mro has changed its
-        # bases, which causes the mro to change. If we recomputed our
-        # mro, we would compute the *new* mro, which leaves us with no
-        # way to detect that the mro has changed! Thus we need to make
-        # sure to load the original mro so that once the class is
-        # rechecked, it can tell that the mro has changed.
-        ti._mro_refs = data["mro"]
-        ti.tuple_type = (
-            None
-            if data["tuple_type"] is None
-            else mypy.types.TupleType.deserialize(data["tuple_type"])
-        )
-        ti.typeddict_type = (
-            None
-            if data["typeddict_type"] is None
-            else mypy.types.TypedDictType.deserialize(data["typeddict_type"])
-        )
-        ti.metadata = data["metadata"]
-        ti.slots = set(data["slots"]) if data["slots"] is not None else None
-        ti.deletable_attributes = data["deletable_attributes"]
-        set_flags(ti, data["flags"])
-        st = data["self_type"]
-        ti.self_type = (
-            mypy.types.TypeVarType.deserialize(st) if st is not None else None
-        )
-        if data.get("dataclass_transform_spec") is not None:
-            ti.dataclass_transform_spec = DataclassTransformSpec.deserialize(
-                data["dataclass_transform_spec"]
-            )
-        return ti
-
-
-class FakeInfo(TypeInfo):
-    __slots__ = ("msg",)
-
-    # types.py defines a single instance of this class, called types.NOT_READY.
-    # This instance is used as a temporary placeholder in the process of de-serialization
-    # of 'Instance' types. The de-serialization happens in two steps: In the first step,
-    # Instance.type is set to NOT_READY. In the second step (in fixup.py) it is replaced by
-    # an actual TypeInfo. If you see the assertion error below, then most probably something
-    # went wrong during the second step and an 'Instance' that raised this error was not fixed.
-    # Note:
-    # 'None' is not used as a dummy value for two reasons:
-    # 1. This will require around 80-100 asserts to make 'mypy --strict-optional mypy'
-    #    pass cleanly.
-    # 2. If NOT_READY value is accidentally used somewhere, it will be obvious where the value
-    #    is from, whereas a 'None' value could come from anywhere.
-    #
-    # Additionally, this serves as a more general-purpose placeholder
-    # for missing TypeInfos in a number of places where the excuses
-    # for not being Optional are a little weaker.
-    #
-    # TypeInfo defines a __bool__ method that returns False for FakeInfo
-    # so that it can be conveniently tested against in the same way that it
-    # would be if things were properly optional.
-    def __init__(self, msg: str) -> None:
-        self.msg = msg
-
-    def __getattribute__(self, attr: str) -> type:
-        # Handle __class__ so that isinstance still works...
-        if attr == "__class__":
-            return object.__getattribute__(self, attr)  # type: ignore[no-any-return]
-        raise AssertionError(object.__getattribute__(self, "msg"))
-
-
-VAR_NO_INFO: Final[TypeInfo] = FakeInfo("Var is lacking info")
-CLASSDEF_NO_INFO: Final[TypeInfo] = FakeInfo("ClassDef is lacking info")
-FUNC_NO_INFO: Final[TypeInfo] = FakeInfo("FuncBase for non-methods lack info")
-
-
-class TypeAlias(SymbolNode):
-    """
-    A symbol node representing a type alias.
-
-    Type alias is a static concept, in contrast to variables with types
-    like Type[...]. Namely:
-        * type aliases
-            - can be used in type context (annotations)
-            - cannot be re-assigned
-        * variables with type Type[...]
-            - cannot be used in type context
-            - but can be re-assigned
-
-    An alias can be defined only by an assignment to a name (not any other lvalues).
-
-    Such assignment defines an alias by default. To define a variable,
-    an explicit Type[...] annotation is required. As an exception,
-    at non-global scope non-subscripted rvalue creates a variable even without
-    an annotation. This exception exists to accommodate the common use case of
-    class-valued attributes. See SemanticAnalyzerPass2.check_and_set_up_type_alias
-    for details.
-
-    Aliases can be generic. We use bound type variables for generic aliases, similar
-    to classes. Essentially, type aliases work as macros that expand textually.
-    The definition and expansion rules are following:
-
-        1. An alias targeting a generic class without explicit variables act as
-        the given class (this doesn't apply to TypedDict, Tuple and Callable, which
-        are not proper classes but special type constructors):
-
-            A = List
-            AA = List[Any]
-
-            x: A  # same as List[Any]
-            x: A[int]  # same as List[int]
-
-            x: AA  # same as List[Any]
-            x: AA[int]  # Error!
-
-            C = Callable  # Same as Callable[..., Any]
-            T = Tuple  # Same as Tuple[Any, ...]
-
-        2. An alias using explicit type variables in its rvalue expects
-        replacements (type arguments) for these variables. If missing, they
-        are treated as Any, like for other generics:
-
-            B = List[Tuple[T, T]]
-
-            x: B  # same as List[Tuple[Any, Any]]
-            x: B[int]  # same as List[Tuple[int, int]]
-
-            def f(x: B[T]) -> T: ...  # without T, Any would be used here
-
-        3. An alias can be defined using another aliases. In the definition
-        rvalue the Any substitution doesn't happen for top level unsubscripted
-        generic classes:
-
-            A = List
-            B = A  # here A is expanded to List, _not_ List[Any],
-                   # to match the Python runtime behaviour
-            x: B[int]  # same as List[int]
-            C = List[A]  # this expands to List[List[Any]]
-
-            AA = List[T]
-            D = AA  # here AA expands to List[Any]
-            x: D[int]  # Error!
-
-    Note: the fact that we support aliases like `A = List` means that the target
-    type will be initially an instance type with wrong number of type arguments.
-    Such instances are all fixed either during or after main semantic analysis passes.
-    We therefore store the difference between `List` and `List[Any]` rvalues (targets)
-    using the `no_args` flag. See also TypeAliasExpr.no_args.
-
-    Meaning of other fields:
-
-    target: The target type. For generic aliases contains bound type variables
-        as nested types (currently TypeVar and ParamSpec are supported).
-    _fullname: Qualified name of this type alias. This is used in particular
-        to track fine grained dependencies from aliases.
-    alias_tvars: Type variables used to define this alias.
-    normalized: Used to distinguish between `A = List`, and `A = list`. Both
-        are internally stored using `builtins.list` (because `typing.List` is
-        itself an alias), while the second cannot be subscripted because of
-        Python runtime limitation.
-    line and column: Line and column on the original alias definition.
-    eager: If True, immediately expand alias when referred to (useful for aliases
-        within functions that can't be looked up from the symbol table)
-    """
-
-    __slots__ = (
-        "target",
-        "_fullname",
-        "alias_tvars",
-        "no_args",
-        "normalized",
-        "_is_recursive",
-        "eager",
-        "tvar_tuple_index",
-    )
-
-    __match_args__ = ("name", "target", "alias_tvars", "no_args")
-
-    def __init__(
-        self,
-        target: mypy.types.Type,
-        fullname: str,
-        line: int,
-        column: int,
-        *,
-        alias_tvars: list[mypy.types.TypeVarLikeType] | None = None,
-        no_args: bool = False,
-        normalized: bool = False,
-        eager: bool = False,
-    ) -> None:
-        self._fullname = fullname
-        self.target = target
-        if alias_tvars is None:
-            alias_tvars = []
-        self.alias_tvars = alias_tvars
-        self.no_args = no_args
-        self.normalized = normalized
-        # This attribute is manipulated by TypeAliasType. If non-None,
-        # it is the cached value.
-        self._is_recursive: bool | None = None
-        self.eager = eager
-        self.tvar_tuple_index = None
-        for i, t in enumerate(alias_tvars):
-            if isinstance(t, mypy.types.TypeVarTupleType):
-                self.tvar_tuple_index = i
-        super().__init__(line, column)
-
-    @classmethod
-    def from_tuple_type(cls, info: TypeInfo) -> TypeAlias:
-        """Generate an alias to the tuple type described by a given TypeInfo.
-
-        NOTE: this doesn't set type alias type variables (for generic tuple types),
-        they must be set by the caller (when fully analyzed).
-        """
-        assert info.tuple_type
-        # TODO: is it possible to refactor this to set the correct type vars here?
-        return TypeAlias(
-            info.tuple_type.copy_modified(
-                # Create an Instance similar to fill_typevars().
-                fallback=mypy.types.Instance(
-                    info, mypy.types.type_vars_as_args(info.defn.type_vars)
-                )
-            ),
-            info.fullname,
-            info.line,
-            info.column,
-        )
-
-    @classmethod
-    def from_typeddict_type(cls, info: TypeInfo) -> TypeAlias:
-        """Generate an alias to the TypedDict type described by a given TypeInfo.
-
-        NOTE: this doesn't set type alias type variables (for generic TypedDicts),
-        they must be set by the caller (when fully analyzed).
-        """
-        assert info.typeddict_type
-        # TODO: is it possible to refactor this to set the correct type vars here?
-        return TypeAlias(
-            info.typeddict_type.copy_modified(
-                # Create an Instance similar to fill_typevars().
-                fallback=mypy.types.Instance(
-                    info, mypy.types.type_vars_as_args(info.defn.type_vars)
-                )
-            ),
-            info.fullname,
-            info.line,
-            info.column,
-        )
-
-    @property
-    def name(self) -> str:
-        return self._fullname.split(".")[-1]
-
-    @property
-    def fullname(self) -> str:
-        return self._fullname
-
-    @property
-    def has_param_spec_type(self) -> bool:
-        return any(isinstance(v, mypy.types.ParamSpecType) for v in self.alias_tvars)
-
-    def serialize(self) -> JsonDict:
-        data: JsonDict = {
-            ".class": "TypeAlias",
-            "fullname": self._fullname,
-            "target": self.target.serialize(),
-            "alias_tvars": [v.serialize() for v in self.alias_tvars],
-            "no_args": self.no_args,
-            "normalized": self.normalized,
-            "line": self.line,
-            "column": self.column,
-        }
-        return data
-
-    def accept(self, visitor: NodeVisitor[T]) -> T:
-        return visitor.visit_type_alias(self)
-
-    @classmethod
-    def deserialize(cls, data: JsonDict) -> TypeAlias:
-        assert data[".class"] == "TypeAlias"
-        fullname = data["fullname"]
-        alias_tvars = [mypy.types.deserialize_type(v) for v in data["alias_tvars"]]
-        assert all(isinstance(t, mypy.types.TypeVarLikeType) for t in alias_tvars)
-        target = mypy.types.deserialize_type(data["target"])
-        no_args = data["no_args"]
-        normalized = data["normalized"]
-        line = data["line"]
-        column = data["column"]
-        return cls(
-            target,
-            fullname,
-            line,
-            column,
-            alias_tvars=cast(List[mypy.types.TypeVarLikeType], alias_tvars),
-            no_args=no_args,
-            normalized=normalized,
-        )
-
-
-class PlaceholderNode(SymbolNode):
-    """Temporary symbol node that will later become a real SymbolNode.
-
-    These are only present during semantic analysis when using the new
-    semantic analyzer. These are created if some essential dependencies
-    of a definition are not yet complete.
-
-    A typical use is for names imported from a module which is still
-    incomplete (within an import cycle):
-
-      from m import f  # Initially may create PlaceholderNode
-
-    This is particularly important if the imported shadows a name from
-    an enclosing scope or builtins:
-
-      from m import int  # Placeholder avoids mixups with builtins.int
-
-    Another case where this is useful is when there is another definition
-    or assignment:
-
-      from m import f
-      def f() -> None: ...
-
-    In the above example, the presence of PlaceholderNode allows us to
-    handle the second definition as a redefinition.
-
-    They are also used to create PlaceholderType instances for types
-    that refer to incomplete types. Example:
-
-      class C(Sequence[C]): ...
-
-    We create a PlaceholderNode (with becomes_typeinfo=True) for C so
-    that the type C in Sequence[C] can be bound.
-
-    Attributes:
-
-      fullname: Full name of the PlaceholderNode.
-      node: AST node that contains the definition that caused this to
-          be created. This is useful for tracking order of incomplete definitions
-          and for debugging.
-      becomes_typeinfo: If True, this refers something that could later
-          become a TypeInfo. It can't be used with type variables, in
-          particular, as this would cause issues with class type variable
-          detection.
-
-    The long-term purpose of placeholder nodes/types is to evolve into
-    something that can support general recursive types.
-    """
-
-    __slots__ = ("_fullname", "node", "becomes_typeinfo")
-
-    def __init__(
-        self, fullname: str, node: Node, line: int, *, becomes_typeinfo: bool = False
-    ) -> None:
-        self._fullname = fullname
-        self.node = node
-        self.becomes_typeinfo = becomes_typeinfo
-        self.line = line
-
-    @property
-    def name(self) -> str:
-        return self._fullname.split(".")[-1]
-
-    @property
-    def fullname(self) -> str:
-        return self._fullname
-
-    def serialize(self) -> JsonDict:
-        assert False, "PlaceholderNode can't be serialized"
-
-    def accept(self, visitor: NodeVisitor[T]) -> T:
-        return visitor.visit_placeholder_node(self)
-
-
-class SymbolTableNode:
-    """Description of a name binding in a symbol table.
-
-    These are only used as values in module (global), function (local)
-    and class symbol tables (see SymbolTable). The name that is bound is
-    the key in SymbolTable.
-
-    Symbol tables don't contain direct references to AST nodes primarily
-    because there can be multiple symbol table references to a single
-    AST node (due to imports and aliases), and different references can
-    behave differently. This class describes the unique properties of
-    each reference.
-
-    The most fundamental attribute is 'node', which is the AST node that
-    the name refers to.
-
-    The kind is usually one of LDEF, GDEF or MDEF, depending on the scope
-    of the definition. These three kinds can usually be used
-    interchangeably and the difference between local, global and class
-    scopes is mostly descriptive, with no semantic significance.
-    However, some tools that consume mypy ASTs may care about these so
-    they should be correct.
-
-    Attributes:
-        node: AST node of definition. Among others, this can be one of
-            FuncDef, Var, TypeInfo, TypeVarExpr or MypyFile -- or None
-            for cross_ref that hasn't been fixed up yet.
-        kind: Kind of node. Possible values:
-               - LDEF: local definition
-               - GDEF: global (module-level) definition
-               - MDEF: class member definition
-               - UNBOUND_IMPORTED: temporary kind for imported names (we
-                 don't know the final kind yet)
-        module_public: If False, this name won't be imported via
-            'from <module> import *'. This has no effect on names within
-            classes.
-        module_hidden: If True, the name will be never exported (needed for
-            stub files)
-        cross_ref: For deserialized MypyFile nodes, the referenced module
-            name; for other nodes, optionally the name of the referenced object.
-        implicit: Was this defined by assignment to self attribute?
-        plugin_generated: Was this symbol generated by a plugin?
-            (And therefore needs to be removed in aststrip.)
-        no_serialize: Do not serialize this node if True. This is used to prevent
-            keys in the cache that refer to modules on which this file does not
-            depend. Currently this can happen if there is a module not in build
-            used e.g. like this:
-                import a.b.c # type: ignore
-            This will add a submodule symbol to parent module `a` symbol table,
-            but `a.b` is _not_ added as its dependency. Therefore, we should
-            not serialize these symbols as they may not be found during fixup
-            phase, instead they will be re-added during subsequent patch parents
-            phase.
-            TODO: Refactor build.py to make dependency tracking more transparent
-            and/or refactor look-up functions to not require parent patching.
-
-    NOTE: No other attributes should be added to this class unless they
-    are shared by all node kinds.
-    """
-
-    __slots__ = (
-        "kind",
-        "node",
-        "module_public",
-        "module_hidden",
-        "cross_ref",
-        "implicit",
-        "plugin_generated",
-        "no_serialize",
-    )
-
-    def __init__(
-        self,
-        kind: int,
-        node: SymbolNode | None,
-        module_public: bool = True,
-        implicit: bool = False,
-        module_hidden: bool = False,
-        *,
-        plugin_generated: bool = False,
-        no_serialize: bool = False,
-    ) -> None:
-        self.kind = kind
-        self.node = node
-        self.module_public = module_public
-        self.implicit = implicit
-        self.module_hidden = module_hidden
-        self.cross_ref: str | None = None
-        self.plugin_generated = plugin_generated
-        self.no_serialize = no_serialize
-
-    @property
-    def fullname(self) -> str | None:
-        if self.node is not None:
-            return self.node.fullname
-        else:
-            return None
-
-    @property
-    def type(self) -> mypy.types.Type | None:
-        node = self.node
-        if isinstance(node, (Var, SYMBOL_FUNCBASE_TYPES)) and node.type is not None:
-            return node.type
-        elif isinstance(node, Decorator):
-            return node.var.type
-        else:
-            return None
-
-    def copy(self) -> SymbolTableNode:
-        new = SymbolTableNode(
-            self.kind, self.node, self.module_public, self.implicit, self.module_hidden
-        )
-        new.cross_ref = self.cross_ref
-        return new
-
-    def __str__(self) -> str:
-        s = f"{node_kinds[self.kind]}/{short_type(self.node)}"
-        if isinstance(self.node, SymbolNode):
-            s += f" ({self.node.fullname})"
-        # Include declared type of variables and functions.
-        if self.type is not None:
-            s += f" : {self.type}"
-        if self.cross_ref:
-            s += f" cross_ref:{self.cross_ref}"
-        return s
-
-    def serialize(self, prefix: str, name: str) -> JsonDict:
-        """Serialize a SymbolTableNode.
-
-        Args:
-          prefix: full name of the containing module or class; or None
-          name: name of this object relative to the containing object
-        """
-        data: JsonDict = {".class": "SymbolTableNode", "kind": node_kinds[self.kind]}
-        if self.module_hidden:
-            data["module_hidden"] = True
-        if not self.module_public:
-            data["module_public"] = False
-        if self.implicit:
-            data["implicit"] = True
-        if self.plugin_generated:
-            data["plugin_generated"] = True
-        if isinstance(self.node, MypyFile):
-            data["cross_ref"] = self.node.fullname
-        else:
-            assert self.node is not None, f"{prefix}:{name}"
-            if prefix is not None:
-                fullname = self.node.fullname
-                if (
-                    "." in fullname
-                    and fullname != prefix + "." + name
-                    and not (
-                        isinstance(self.node, Var) and self.node.from_module_getattr
-                    )
-                ):
-                    assert not isinstance(
-                        self.node, PlaceholderNode
-                    ), f"Definition of {fullname} is unexpectedly incomplete"
-                    data["cross_ref"] = fullname
-                    return data
-            data["node"] = self.node.serialize()
-        return data
-
-    @classmethod
-    def deserialize(cls, data: JsonDict) -> SymbolTableNode:
-        assert data[".class"] == "SymbolTableNode"
-        kind = inverse_node_kinds[data["kind"]]
-        if "cross_ref" in data:
-            # This will be fixed up later.
-            stnode = SymbolTableNode(kind, None)
-            stnode.cross_ref = data["cross_ref"]
-        else:
-            assert "node" in data, data
-            node = SymbolNode.deserialize(data["node"])
-            stnode = SymbolTableNode(kind, node)
-        if "module_hidden" in data:
-            stnode.module_hidden = data["module_hidden"]
-        if "module_public" in data:
-            stnode.module_public = data["module_public"]
-        if "implicit" in data:
-            stnode.implicit = data["implicit"]
-        if "plugin_generated" in data:
-            stnode.plugin_generated = data["plugin_generated"]
-        return stnode
-
-
-class SymbolTable(Dict[str, SymbolTableNode]):
-    """Static representation of a namespace dictionary.
-
-    This is used for module, class and function namespaces.
-    """
-
-    __slots__ = ()
-
-    def __str__(self) -> str:
-        a: list[str] = []
-        for key, value in self.items():
-            # Filter out the implicit import of builtins.
-            if isinstance(value, SymbolTableNode):
-                if (
-                    value.fullname != "builtins"
-                    and (value.fullname or "").split(".")[-1]
-                    not in implicit_module_attrs
-                ):
-                    a.append("  " + str(key) + " : " + str(value))
-            else:
-                a.append("  <invalid item>")
-        a = sorted(a)
-        a.insert(0, "SymbolTable(")
-        a[-1] += ")"
-        return "\n".join(a)
-
-    def copy(self) -> SymbolTable:
-        return SymbolTable([(key, node.copy()) for key, node in self.items()])
-
-    def serialize(self, fullname: str) -> JsonDict:
-        data: JsonDict = {".class": "SymbolTable"}
-        for key, value in self.items():
-            # Skip __builtins__: it's a reference to the builtins
-            # module that gets added to every module by
-            # SemanticAnalyzerPass2.visit_file(), but it shouldn't be
-            # accessed by users of the module.
-            if key == "__builtins__" or value.no_serialize:
-                continue
-            data[key] = value.serialize(fullname, key)
-        return data
-
-    @classmethod
-    def deserialize(cls, data: JsonDict) -> SymbolTable:
-        assert data[".class"] == "SymbolTable"
-        st = SymbolTable()
-        for key, value in data.items():
-            if key != ".class":
-                st[key] = SymbolTableNode.deserialize(value)
-        return st
-
-
-class DataclassTransformSpec:
-    """Specifies how a dataclass-like transform should be applied. The fields here are based on the
-    parameters accepted by `typing.dataclass_transform`."""
-
-    __slots__ = (
-        "eq_default",
-        "order_default",
-        "kw_only_default",
-        "frozen_default",
-        "field_specifiers",
-    )
-
-    def __init__(
-        self,
-        *,
-        eq_default: bool | None = None,
-        order_default: bool | None = None,
-        kw_only_default: bool | None = None,
-        field_specifiers: tuple[str, ...] | None = None,
-        # Specified outside of PEP 681:
-        # frozen_default was added to CPythonin https://github.com/python/cpython/pull/99958 citing
-        # positive discussion in typing-sig
-        frozen_default: bool | None = None,
-    ) -> None:
-        self.eq_default = eq_default if eq_default is not None else True
-        self.order_default = order_default if order_default is not None else False
-        self.kw_only_default = kw_only_default if kw_only_default is not None else False
-        self.frozen_default = frozen_default if frozen_default is not None else False
-        self.field_specifiers = field_specifiers if field_specifiers is not None else ()
-
-    def serialize(self) -> JsonDict:
-        return {
-            "eq_default": self.eq_default,
-            "order_default": self.order_default,
-            "kw_only_default": self.kw_only_default,
-            "frozen_default": self.frozen_default,
-            "field_specifiers": list(self.field_specifiers),
-        }
-
-    @classmethod
-    def deserialize(cls, data: JsonDict) -> DataclassTransformSpec:
-        return DataclassTransformSpec(
-            eq_default=data.get("eq_default"),
-            order_default=data.get("order_default"),
-            kw_only_default=data.get("kw_only_default"),
-            frozen_default=data.get("frozen_default"),
-            field_specifiers=tuple(data.get("field_specifiers", [])),
-        )
-
-
-def get_flags(node: Node, names: list[str]) -> list[str]:
-    return [name for name in names if getattr(node, name)]
-
-
-def set_flags(node: Node, flags: list[str]) -> None:
-    for name in flags:
-        setattr(node, name, True)
-
-
-def get_member_expr_fullname(expr: MemberExpr) -> str | None:
-    """Return the qualified name representation of a member expression.
-
-    Return a string of form foo.bar, foo.bar.baz, or similar, or None if the
-    argument cannot be represented in this form.
-    """
-    initial: str | None = None
-    if isinstance(expr.expr, NameExpr):
-        initial = expr.expr.name
-    elif isinstance(expr.expr, MemberExpr):
-        initial = get_member_expr_fullname(expr.expr)
-    else:
-        return None
-    return f"{initial}.{expr.name}"
-
-
-deserialize_map: Final = {
-    key: obj.deserialize
-    for key, obj in globals().items()
-    if type(obj) is not FakeInfo
-    and isinstance(obj, type)
-    and issubclass(obj, SymbolNode)
-    and obj is not SymbolNode
-}
-
-
-def check_arg_kinds(
-    arg_kinds: list[ArgKind], nodes: list[T], fail: Callable[[str, T], None]
-) -> None:
-    is_var_arg = False
-    is_kw_arg = False
-    seen_named = False
-    seen_opt = False
-    for kind, node in zip(arg_kinds, nodes):
-        if kind == ARG_POS:
-            if is_var_arg or is_kw_arg or seen_named or seen_opt:
-                fail(
-                    "Required positional args may not appear after default, named or var args",
-                    node,
-                )
-                break
-        elif kind == ARG_OPT:
-            if is_var_arg or is_kw_arg or seen_named:
-                fail(
-                    "Positional default args may not appear after named or var args",
-                    node,
-                )
-                break
-            seen_opt = True
-        elif kind == ARG_STAR:
-            if is_var_arg or is_kw_arg or seen_named:
-                fail("Var args may not appear after named or var args", node)
-                break
-            is_var_arg = True
-        elif kind == ARG_NAMED or kind == ARG_NAMED_OPT:
-            seen_named = True
-            if is_kw_arg:
-                fail("A **kwargs argument must be the last argument", node)
-                break
-        elif kind == ARG_STAR2:
-            if is_kw_arg:
-                fail("You may only have one **kwargs argument", node)
-                break
-            is_kw_arg = True
-
-
-def check_arg_names(
-    names: Sequence[str | None],
-    nodes: list[T],
-    fail: Callable[[str, T], None],
-    description: str = "function definition",
-) -> None:
-    seen_names: set[str | None] = set()
-    for name, node in zip(names, nodes):
-        if name is not None and name in seen_names:
-            fail(f'Duplicate argument "{name}" in {description}', node)
-            break
-        seen_names.add(name)
-
-
-def is_class_var(expr: NameExpr) -> bool:
-    """Return whether the expression is ClassVar[...]"""
-    if isinstance(expr.node, Var):
-        return expr.node.is_classvar
-    return False
-
-
-def is_final_node(node: SymbolNode | None) -> bool:
-    """Check whether `node` corresponds to a final attribute."""
-    return (
-        isinstance(node, (Var, FuncDef, OverloadedFuncDef, Decorator)) and node.is_final
-    )
-
-
-def local_definitions(
-    names: SymbolTable, name_prefix: str, info: TypeInfo | None = None
-) -> Iterator[Definition]:
-    """Iterate over local definitions (not imported) in a symbol table.
-
-    Recursively iterate over class members and nested classes.
-    """
-    # TODO: What should the name be? Or maybe remove it?
-    for name, symnode in names.items():
-        shortname = name
-        if "-redef" in name:
-            # Restore original name from mangled name of multiply defined function
-            shortname = name.split("-redef")[0]
-        fullname = name_prefix + "." + shortname
-        node = symnode.node
-        if node and node.fullname == fullname:
-            yield fullname, symnode, info
-            if isinstance(node, TypeInfo):
-                yield from local_definitions(node.names, fullname, node)