"""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 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",

)

__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]

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()

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 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"

"_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

# 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: