Tipragot
628be439b8
Cela permet de ne pas avoir de problèmes de compatibilité car python est dans le git.
1116 lines
45 KiB
Python
1116 lines
45 KiB
Python
"""Plugin that provides support for dataclasses."""
|
|
|
|
from __future__ import annotations
|
|
|
|
from typing import TYPE_CHECKING, Final, Iterator, Literal
|
|
|
|
from mypy import errorcodes, message_registry
|
|
from mypy.expandtype import expand_type, expand_type_by_instance
|
|
from mypy.meet import meet_types
|
|
from mypy.messages import format_type_bare
|
|
from mypy.nodes import (
|
|
ARG_NAMED,
|
|
ARG_NAMED_OPT,
|
|
ARG_OPT,
|
|
ARG_POS,
|
|
ARG_STAR,
|
|
ARG_STAR2,
|
|
MDEF,
|
|
Argument,
|
|
AssignmentStmt,
|
|
Block,
|
|
CallExpr,
|
|
ClassDef,
|
|
Context,
|
|
DataclassTransformSpec,
|
|
Expression,
|
|
FuncDef,
|
|
FuncItem,
|
|
IfStmt,
|
|
JsonDict,
|
|
NameExpr,
|
|
Node,
|
|
PlaceholderNode,
|
|
RefExpr,
|
|
Statement,
|
|
SymbolTableNode,
|
|
TempNode,
|
|
TypeAlias,
|
|
TypeInfo,
|
|
TypeVarExpr,
|
|
Var,
|
|
)
|
|
from mypy.plugin import ClassDefContext, FunctionSigContext, SemanticAnalyzerPluginInterface
|
|
from mypy.plugins.common import (
|
|
_get_callee_type,
|
|
_get_decorator_bool_argument,
|
|
add_attribute_to_class,
|
|
add_method_to_class,
|
|
deserialize_and_fixup_type,
|
|
)
|
|
from mypy.semanal_shared import find_dataclass_transform_spec, require_bool_literal_argument
|
|
from mypy.server.trigger import make_wildcard_trigger
|
|
from mypy.state import state
|
|
from mypy.typeops import map_type_from_supertype, try_getting_literals_from_type
|
|
from mypy.types import (
|
|
AnyType,
|
|
CallableType,
|
|
FunctionLike,
|
|
Instance,
|
|
LiteralType,
|
|
NoneType,
|
|
ProperType,
|
|
TupleType,
|
|
Type,
|
|
TypeOfAny,
|
|
TypeVarType,
|
|
UninhabitedType,
|
|
UnionType,
|
|
get_proper_type,
|
|
)
|
|
from mypy.typevars import fill_typevars
|
|
|
|
if TYPE_CHECKING:
|
|
from mypy.checker import TypeChecker
|
|
|
|
# The set of decorators that generate dataclasses.
|
|
dataclass_makers: Final = {"dataclass", "dataclasses.dataclass"}
|
|
|
|
|
|
SELF_TVAR_NAME: Final = "_DT"
|
|
_TRANSFORM_SPEC_FOR_DATACLASSES: Final = DataclassTransformSpec(
|
|
eq_default=True,
|
|
order_default=False,
|
|
kw_only_default=False,
|
|
frozen_default=False,
|
|
field_specifiers=("dataclasses.Field", "dataclasses.field"),
|
|
)
|
|
_INTERNAL_REPLACE_SYM_NAME: Final = "__mypy-replace"
|
|
_INTERNAL_POST_INIT_SYM_NAME: Final = "__mypy-post_init"
|
|
|
|
|
|
class DataclassAttribute:
|
|
def __init__(
|
|
self,
|
|
name: str,
|
|
alias: str | None,
|
|
is_in_init: bool,
|
|
is_init_var: bool,
|
|
has_default: bool,
|
|
line: int,
|
|
column: int,
|
|
type: Type | None,
|
|
info: TypeInfo,
|
|
kw_only: bool,
|
|
is_neither_frozen_nor_nonfrozen: bool,
|
|
api: SemanticAnalyzerPluginInterface,
|
|
) -> None:
|
|
self.name = name
|
|
self.alias = alias
|
|
self.is_in_init = is_in_init
|
|
self.is_init_var = is_init_var
|
|
self.has_default = has_default
|
|
self.line = line
|
|
self.column = column
|
|
self.type = type # Type as __init__ argument
|
|
self.info = info
|
|
self.kw_only = kw_only
|
|
self.is_neither_frozen_nor_nonfrozen = is_neither_frozen_nor_nonfrozen
|
|
self._api = api
|
|
|
|
def to_argument(
|
|
self, current_info: TypeInfo, *, of: Literal["__init__", "replace", "__post_init__"]
|
|
) -> Argument:
|
|
if of == "__init__":
|
|
arg_kind = ARG_POS
|
|
if self.kw_only and self.has_default:
|
|
arg_kind = ARG_NAMED_OPT
|
|
elif self.kw_only and not self.has_default:
|
|
arg_kind = ARG_NAMED
|
|
elif not self.kw_only and self.has_default:
|
|
arg_kind = ARG_OPT
|
|
elif of == "replace":
|
|
arg_kind = ARG_NAMED if self.is_init_var and not self.has_default else ARG_NAMED_OPT
|
|
elif of == "__post_init__":
|
|
# We always use `ARG_POS` without a default value, because it is practical.
|
|
# Consider this case:
|
|
#
|
|
# @dataclass
|
|
# class My:
|
|
# y: dataclasses.InitVar[str] = 'a'
|
|
# def __post_init__(self, y: str) -> None: ...
|
|
#
|
|
# We would be *required* to specify `y: str = ...` if default is added here.
|
|
# But, most people won't care about adding default values to `__post_init__`,
|
|
# because it is not designed to be called directly, and duplicating default values
|
|
# for the sake of type-checking is unpleasant.
|
|
arg_kind = ARG_POS
|
|
return Argument(
|
|
variable=self.to_var(current_info),
|
|
type_annotation=self.expand_type(current_info),
|
|
initializer=None,
|
|
kind=arg_kind,
|
|
)
|
|
|
|
def expand_type(self, current_info: TypeInfo) -> Type | None:
|
|
if self.type is not None and self.info.self_type is not None:
|
|
# In general, it is not safe to call `expand_type()` during semantic analyzis,
|
|
# however this plugin is called very late, so all types should be fully ready.
|
|
# Also, it is tricky to avoid eager expansion of Self types here (e.g. because
|
|
# we serialize attributes).
|
|
with state.strict_optional_set(self._api.options.strict_optional):
|
|
return expand_type(
|
|
self.type, {self.info.self_type.id: fill_typevars(current_info)}
|
|
)
|
|
return self.type
|
|
|
|
def to_var(self, current_info: TypeInfo) -> Var:
|
|
return Var(self.alias or self.name, self.expand_type(current_info))
|
|
|
|
def serialize(self) -> JsonDict:
|
|
assert self.type
|
|
return {
|
|
"name": self.name,
|
|
"alias": self.alias,
|
|
"is_in_init": self.is_in_init,
|
|
"is_init_var": self.is_init_var,
|
|
"has_default": self.has_default,
|
|
"line": self.line,
|
|
"column": self.column,
|
|
"type": self.type.serialize(),
|
|
"kw_only": self.kw_only,
|
|
"is_neither_frozen_nor_nonfrozen": self.is_neither_frozen_nor_nonfrozen,
|
|
}
|
|
|
|
@classmethod
|
|
def deserialize(
|
|
cls, info: TypeInfo, data: JsonDict, api: SemanticAnalyzerPluginInterface
|
|
) -> DataclassAttribute:
|
|
data = data.copy()
|
|
typ = deserialize_and_fixup_type(data.pop("type"), api)
|
|
return cls(type=typ, info=info, **data, api=api)
|
|
|
|
def expand_typevar_from_subtype(self, sub_type: TypeInfo) -> None:
|
|
"""Expands type vars in the context of a subtype when an attribute is inherited
|
|
from a generic super type."""
|
|
if self.type is not None:
|
|
with state.strict_optional_set(self._api.options.strict_optional):
|
|
self.type = map_type_from_supertype(self.type, sub_type, self.info)
|
|
|
|
|
|
class DataclassTransformer:
|
|
"""Implement the behavior of @dataclass.
|
|
|
|
Note that this may be executed multiple times on the same class, so
|
|
everything here must be idempotent.
|
|
|
|
This runs after the main semantic analysis pass, so you can assume that
|
|
there are no placeholders.
|
|
"""
|
|
|
|
def __init__(
|
|
self,
|
|
cls: ClassDef,
|
|
# Statement must also be accepted since class definition itself may be passed as the reason
|
|
# for subclass/metaclass-based uses of `typing.dataclass_transform`
|
|
reason: Expression | Statement,
|
|
spec: DataclassTransformSpec,
|
|
api: SemanticAnalyzerPluginInterface,
|
|
) -> None:
|
|
self._cls = cls
|
|
self._reason = reason
|
|
self._spec = spec
|
|
self._api = api
|
|
|
|
def transform(self) -> bool:
|
|
"""Apply all the necessary transformations to the underlying
|
|
dataclass so as to ensure it is fully type checked according
|
|
to the rules in PEP 557.
|
|
"""
|
|
info = self._cls.info
|
|
attributes = self.collect_attributes()
|
|
if attributes is None:
|
|
# Some definitions are not ready. We need another pass.
|
|
return False
|
|
for attr in attributes:
|
|
if attr.type is None:
|
|
return False
|
|
decorator_arguments = {
|
|
"init": self._get_bool_arg("init", True),
|
|
"eq": self._get_bool_arg("eq", self._spec.eq_default),
|
|
"order": self._get_bool_arg("order", self._spec.order_default),
|
|
"frozen": self._get_bool_arg("frozen", self._spec.frozen_default),
|
|
"slots": self._get_bool_arg("slots", False),
|
|
"match_args": self._get_bool_arg("match_args", True),
|
|
}
|
|
py_version = self._api.options.python_version
|
|
|
|
# If there are no attributes, it may be that the semantic analyzer has not
|
|
# processed them yet. In order to work around this, we can simply skip generating
|
|
# __init__ if there are no attributes, because if the user truly did not define any,
|
|
# then the object default __init__ with an empty signature will be present anyway.
|
|
if (
|
|
decorator_arguments["init"]
|
|
and ("__init__" not in info.names or info.names["__init__"].plugin_generated)
|
|
and attributes
|
|
):
|
|
args = [
|
|
attr.to_argument(info, of="__init__")
|
|
for attr in attributes
|
|
if attr.is_in_init and not self._is_kw_only_type(attr.type)
|
|
]
|
|
|
|
if info.fallback_to_any:
|
|
# Make positional args optional since we don't know their order.
|
|
# This will at least allow us to typecheck them if they are called
|
|
# as kwargs
|
|
for arg in args:
|
|
if arg.kind == ARG_POS:
|
|
arg.kind = ARG_OPT
|
|
|
|
nameless_var = Var("")
|
|
args = [
|
|
Argument(nameless_var, AnyType(TypeOfAny.explicit), None, ARG_STAR),
|
|
*args,
|
|
Argument(nameless_var, AnyType(TypeOfAny.explicit), None, ARG_STAR2),
|
|
]
|
|
|
|
add_method_to_class(
|
|
self._api, self._cls, "__init__", args=args, return_type=NoneType()
|
|
)
|
|
|
|
if (
|
|
decorator_arguments["eq"]
|
|
and info.get("__eq__") is None
|
|
or decorator_arguments["order"]
|
|
):
|
|
# Type variable for self types in generated methods.
|
|
obj_type = self._api.named_type("builtins.object")
|
|
self_tvar_expr = TypeVarExpr(
|
|
SELF_TVAR_NAME,
|
|
info.fullname + "." + SELF_TVAR_NAME,
|
|
[],
|
|
obj_type,
|
|
AnyType(TypeOfAny.from_omitted_generics),
|
|
)
|
|
info.names[SELF_TVAR_NAME] = SymbolTableNode(MDEF, self_tvar_expr)
|
|
|
|
# Add <, >, <=, >=, but only if the class has an eq method.
|
|
if decorator_arguments["order"]:
|
|
if not decorator_arguments["eq"]:
|
|
self._api.fail('"eq" must be True if "order" is True', self._reason)
|
|
|
|
for method_name in ["__lt__", "__gt__", "__le__", "__ge__"]:
|
|
# Like for __eq__ and __ne__, we want "other" to match
|
|
# the self type.
|
|
obj_type = self._api.named_type("builtins.object")
|
|
order_tvar_def = TypeVarType(
|
|
SELF_TVAR_NAME,
|
|
info.fullname + "." + SELF_TVAR_NAME,
|
|
id=-1,
|
|
values=[],
|
|
upper_bound=obj_type,
|
|
default=AnyType(TypeOfAny.from_omitted_generics),
|
|
)
|
|
order_return_type = self._api.named_type("builtins.bool")
|
|
order_args = [
|
|
Argument(Var("other", order_tvar_def), order_tvar_def, None, ARG_POS)
|
|
]
|
|
|
|
existing_method = info.get(method_name)
|
|
if existing_method is not None and not existing_method.plugin_generated:
|
|
assert existing_method.node
|
|
self._api.fail(
|
|
f'You may not have a custom "{method_name}" method when "order" is True',
|
|
existing_method.node,
|
|
)
|
|
|
|
add_method_to_class(
|
|
self._api,
|
|
self._cls,
|
|
method_name,
|
|
args=order_args,
|
|
return_type=order_return_type,
|
|
self_type=order_tvar_def,
|
|
tvar_def=order_tvar_def,
|
|
)
|
|
|
|
parent_decorator_arguments = []
|
|
for parent in info.mro[1:-1]:
|
|
parent_args = parent.metadata.get("dataclass")
|
|
|
|
# Ignore parent classes that directly specify a dataclass transform-decorated metaclass
|
|
# when searching for usage of the frozen parameter. PEP 681 states that a class that
|
|
# directly specifies such a metaclass must be treated as neither frozen nor non-frozen.
|
|
if parent_args and not _has_direct_dataclass_transform_metaclass(parent):
|
|
parent_decorator_arguments.append(parent_args)
|
|
|
|
if decorator_arguments["frozen"]:
|
|
if any(not parent["frozen"] for parent in parent_decorator_arguments):
|
|
self._api.fail("Cannot inherit frozen dataclass from a non-frozen one", info)
|
|
self._propertize_callables(attributes, settable=False)
|
|
self._freeze(attributes)
|
|
else:
|
|
if any(parent["frozen"] for parent in parent_decorator_arguments):
|
|
self._api.fail("Cannot inherit non-frozen dataclass from a frozen one", info)
|
|
self._propertize_callables(attributes)
|
|
|
|
if decorator_arguments["slots"]:
|
|
self.add_slots(info, attributes, correct_version=py_version >= (3, 10))
|
|
|
|
self.reset_init_only_vars(info, attributes)
|
|
|
|
if (
|
|
decorator_arguments["match_args"]
|
|
and (
|
|
"__match_args__" not in info.names or info.names["__match_args__"].plugin_generated
|
|
)
|
|
and py_version >= (3, 10)
|
|
):
|
|
str_type = self._api.named_type("builtins.str")
|
|
literals: list[Type] = [
|
|
LiteralType(attr.name, str_type) for attr in attributes if attr.is_in_init
|
|
]
|
|
match_args_type = TupleType(literals, self._api.named_type("builtins.tuple"))
|
|
add_attribute_to_class(self._api, self._cls, "__match_args__", match_args_type)
|
|
|
|
self._add_dataclass_fields_magic_attribute()
|
|
|
|
if self._spec is _TRANSFORM_SPEC_FOR_DATACLASSES:
|
|
self._add_internal_replace_method(attributes)
|
|
if "__post_init__" in info.names:
|
|
self._add_internal_post_init_method(attributes)
|
|
|
|
info.metadata["dataclass"] = {
|
|
"attributes": [attr.serialize() for attr in attributes],
|
|
"frozen": decorator_arguments["frozen"],
|
|
}
|
|
|
|
return True
|
|
|
|
def _add_internal_replace_method(self, attributes: list[DataclassAttribute]) -> None:
|
|
"""
|
|
Stashes the signature of 'dataclasses.replace(...)' for this specific dataclass
|
|
to be used later whenever 'dataclasses.replace' is called for this dataclass.
|
|
"""
|
|
add_method_to_class(
|
|
self._api,
|
|
self._cls,
|
|
_INTERNAL_REPLACE_SYM_NAME,
|
|
args=[attr.to_argument(self._cls.info, of="replace") for attr in attributes],
|
|
return_type=NoneType(),
|
|
is_staticmethod=True,
|
|
)
|
|
|
|
def _add_internal_post_init_method(self, attributes: list[DataclassAttribute]) -> None:
|
|
add_method_to_class(
|
|
self._api,
|
|
self._cls,
|
|
_INTERNAL_POST_INIT_SYM_NAME,
|
|
args=[
|
|
attr.to_argument(self._cls.info, of="__post_init__")
|
|
for attr in attributes
|
|
if attr.is_init_var
|
|
],
|
|
return_type=NoneType(),
|
|
)
|
|
|
|
def add_slots(
|
|
self, info: TypeInfo, attributes: list[DataclassAttribute], *, correct_version: bool
|
|
) -> None:
|
|
if not correct_version:
|
|
# This means that version is lower than `3.10`,
|
|
# it is just a non-existent argument for `dataclass` function.
|
|
self._api.fail(
|
|
'Keyword argument "slots" for "dataclass" '
|
|
"is only valid in Python 3.10 and higher",
|
|
self._reason,
|
|
)
|
|
return
|
|
|
|
generated_slots = {attr.name for attr in attributes}
|
|
if (info.slots is not None and info.slots != generated_slots) or info.names.get(
|
|
"__slots__"
|
|
):
|
|
# This means we have a slots conflict.
|
|
# Class explicitly specifies a different `__slots__` field.
|
|
# And `@dataclass(slots=True)` is used.
|
|
# In runtime this raises a type error.
|
|
self._api.fail(
|
|
'"{}" both defines "__slots__" and is used with "slots=True"'.format(
|
|
self._cls.name
|
|
),
|
|
self._cls,
|
|
)
|
|
return
|
|
info.slots = generated_slots
|
|
|
|
# Now, insert `.__slots__` attribute to class namespace:
|
|
slots_type = TupleType(
|
|
[self._api.named_type("builtins.str") for _ in generated_slots],
|
|
self._api.named_type("builtins.tuple"),
|
|
)
|
|
add_attribute_to_class(self._api, self._cls, "__slots__", slots_type)
|
|
|
|
def reset_init_only_vars(self, info: TypeInfo, attributes: list[DataclassAttribute]) -> None:
|
|
"""Remove init-only vars from the class and reset init var declarations."""
|
|
for attr in attributes:
|
|
if attr.is_init_var:
|
|
if attr.name in info.names:
|
|
del info.names[attr.name]
|
|
else:
|
|
# Nodes of superclass InitVars not used in __init__ cannot be reached.
|
|
assert attr.is_init_var
|
|
for stmt in info.defn.defs.body:
|
|
if isinstance(stmt, AssignmentStmt) and stmt.unanalyzed_type:
|
|
lvalue = stmt.lvalues[0]
|
|
if isinstance(lvalue, NameExpr) and lvalue.name == attr.name:
|
|
# Reset node so that another semantic analysis pass will
|
|
# recreate a symbol node for this attribute.
|
|
lvalue.node = None
|
|
|
|
def _get_assignment_statements_from_if_statement(
|
|
self, stmt: IfStmt
|
|
) -> Iterator[AssignmentStmt]:
|
|
for body in stmt.body:
|
|
if not body.is_unreachable:
|
|
yield from self._get_assignment_statements_from_block(body)
|
|
if stmt.else_body is not None and not stmt.else_body.is_unreachable:
|
|
yield from self._get_assignment_statements_from_block(stmt.else_body)
|
|
|
|
def _get_assignment_statements_from_block(self, block: Block) -> Iterator[AssignmentStmt]:
|
|
for stmt in block.body:
|
|
if isinstance(stmt, AssignmentStmt):
|
|
yield stmt
|
|
elif isinstance(stmt, IfStmt):
|
|
yield from self._get_assignment_statements_from_if_statement(stmt)
|
|
|
|
def collect_attributes(self) -> list[DataclassAttribute] | None:
|
|
"""Collect all attributes declared in the dataclass and its parents.
|
|
|
|
All assignments of the form
|
|
|
|
a: SomeType
|
|
b: SomeOtherType = ...
|
|
|
|
are collected.
|
|
|
|
Return None if some dataclass base class hasn't been processed
|
|
yet and thus we'll need to ask for another pass.
|
|
"""
|
|
cls = self._cls
|
|
|
|
# First, collect attributes belonging to any class in the MRO, ignoring duplicates.
|
|
#
|
|
# We iterate through the MRO in reverse because attrs defined in the parent must appear
|
|
# earlier in the attributes list than attrs defined in the child. See:
|
|
# https://docs.python.org/3/library/dataclasses.html#inheritance
|
|
#
|
|
# However, we also want attributes defined in the subtype to override ones defined
|
|
# in the parent. We can implement this via a dict without disrupting the attr order
|
|
# because dicts preserve insertion order in Python 3.7+.
|
|
found_attrs: dict[str, DataclassAttribute] = {}
|
|
found_dataclass_supertype = False
|
|
for info in reversed(cls.info.mro[1:-1]):
|
|
if "dataclass_tag" in info.metadata and "dataclass" not in info.metadata:
|
|
# We haven't processed the base class yet. Need another pass.
|
|
return None
|
|
if "dataclass" not in info.metadata:
|
|
continue
|
|
|
|
# Each class depends on the set of attributes in its dataclass ancestors.
|
|
self._api.add_plugin_dependency(make_wildcard_trigger(info.fullname))
|
|
found_dataclass_supertype = True
|
|
|
|
for data in info.metadata["dataclass"]["attributes"]:
|
|
name: str = data["name"]
|
|
|
|
attr = DataclassAttribute.deserialize(info, data, self._api)
|
|
# TODO: We shouldn't be performing type operations during the main
|
|
# semantic analysis pass, since some TypeInfo attributes might
|
|
# still be in flux. This should be performed in a later phase.
|
|
attr.expand_typevar_from_subtype(cls.info)
|
|
found_attrs[name] = attr
|
|
|
|
sym_node = cls.info.names.get(name)
|
|
if sym_node and sym_node.node and not isinstance(sym_node.node, Var):
|
|
self._api.fail(
|
|
"Dataclass attribute may only be overridden by another attribute",
|
|
sym_node.node,
|
|
)
|
|
|
|
# Second, collect attributes belonging to the current class.
|
|
current_attr_names: set[str] = set()
|
|
kw_only = self._get_bool_arg("kw_only", self._spec.kw_only_default)
|
|
for stmt in self._get_assignment_statements_from_block(cls.defs):
|
|
# Any assignment that doesn't use the new type declaration
|
|
# syntax can be ignored out of hand.
|
|
if not stmt.new_syntax:
|
|
continue
|
|
|
|
# a: int, b: str = 1, 'foo' is not supported syntax so we
|
|
# don't have to worry about it.
|
|
lhs = stmt.lvalues[0]
|
|
if not isinstance(lhs, NameExpr):
|
|
continue
|
|
|
|
sym = cls.info.names.get(lhs.name)
|
|
if sym is None:
|
|
# There was probably a semantic analysis error.
|
|
continue
|
|
|
|
node = sym.node
|
|
assert not isinstance(node, PlaceholderNode)
|
|
|
|
if isinstance(node, TypeAlias):
|
|
self._api.fail(
|
|
("Type aliases inside dataclass definitions are not supported at runtime"),
|
|
node,
|
|
)
|
|
# Skip processing this node. This doesn't match the runtime behaviour,
|
|
# but the only alternative would be to modify the SymbolTable,
|
|
# and it's a little hairy to do that in a plugin.
|
|
continue
|
|
|
|
assert isinstance(node, Var)
|
|
|
|
# x: ClassVar[int] is ignored by dataclasses.
|
|
if node.is_classvar:
|
|
continue
|
|
|
|
# x: InitVar[int] is turned into x: int and is removed from the class.
|
|
is_init_var = False
|
|
node_type = get_proper_type(node.type)
|
|
if (
|
|
isinstance(node_type, Instance)
|
|
and node_type.type.fullname == "dataclasses.InitVar"
|
|
):
|
|
is_init_var = True
|
|
node.type = node_type.args[0]
|
|
|
|
if self._is_kw_only_type(node_type):
|
|
kw_only = True
|
|
|
|
has_field_call, field_args = self._collect_field_args(stmt.rvalue)
|
|
|
|
is_in_init_param = field_args.get("init")
|
|
if is_in_init_param is None:
|
|
is_in_init = self._get_default_init_value_for_field_specifier(stmt.rvalue)
|
|
else:
|
|
is_in_init = bool(self._api.parse_bool(is_in_init_param))
|
|
|
|
has_default = False
|
|
# Ensure that something like x: int = field() is rejected
|
|
# after an attribute with a default.
|
|
if has_field_call:
|
|
has_default = (
|
|
"default" in field_args
|
|
or "default_factory" in field_args
|
|
# alias for default_factory defined in PEP 681
|
|
or "factory" in field_args
|
|
)
|
|
|
|
# All other assignments are already type checked.
|
|
elif not isinstance(stmt.rvalue, TempNode):
|
|
has_default = True
|
|
|
|
if not has_default and self._spec is _TRANSFORM_SPEC_FOR_DATACLASSES:
|
|
# Make all non-default dataclass attributes implicit because they are de-facto
|
|
# set on self in the generated __init__(), not in the class body. On the other
|
|
# hand, we don't know how custom dataclass transforms initialize attributes,
|
|
# so we don't treat them as implicit. This is required to support descriptors
|
|
# (https://github.com/python/mypy/issues/14868).
|
|
sym.implicit = True
|
|
|
|
is_kw_only = kw_only
|
|
# Use the kw_only field arg if it is provided. Otherwise use the
|
|
# kw_only value from the decorator parameter.
|
|
field_kw_only_param = field_args.get("kw_only")
|
|
if field_kw_only_param is not None:
|
|
value = self._api.parse_bool(field_kw_only_param)
|
|
if value is not None:
|
|
is_kw_only = value
|
|
else:
|
|
self._api.fail('"kw_only" argument must be a boolean literal', stmt.rvalue)
|
|
|
|
if sym.type is None and node.is_final and node.is_inferred:
|
|
# This is a special case, assignment like x: Final = 42 is classified
|
|
# annotated above, but mypy strips the `Final` turning it into x = 42.
|
|
# We do not support inferred types in dataclasses, so we can try inferring
|
|
# type for simple literals, and otherwise require an explicit type
|
|
# argument for Final[...].
|
|
typ = self._api.analyze_simple_literal_type(stmt.rvalue, is_final=True)
|
|
if typ:
|
|
node.type = typ
|
|
else:
|
|
self._api.fail(
|
|
"Need type argument for Final[...] with non-literal default in dataclass",
|
|
stmt,
|
|
)
|
|
node.type = AnyType(TypeOfAny.from_error)
|
|
|
|
alias = None
|
|
if "alias" in field_args:
|
|
alias = self._api.parse_str_literal(field_args["alias"])
|
|
if alias is None:
|
|
self._api.fail(
|
|
message_registry.DATACLASS_FIELD_ALIAS_MUST_BE_LITERAL,
|
|
stmt.rvalue,
|
|
code=errorcodes.LITERAL_REQ,
|
|
)
|
|
|
|
current_attr_names.add(lhs.name)
|
|
with state.strict_optional_set(self._api.options.strict_optional):
|
|
init_type = self._infer_dataclass_attr_init_type(sym, lhs.name, stmt)
|
|
found_attrs[lhs.name] = DataclassAttribute(
|
|
name=lhs.name,
|
|
alias=alias,
|
|
is_in_init=is_in_init,
|
|
is_init_var=is_init_var,
|
|
has_default=has_default,
|
|
line=stmt.line,
|
|
column=stmt.column,
|
|
type=init_type,
|
|
info=cls.info,
|
|
kw_only=is_kw_only,
|
|
is_neither_frozen_nor_nonfrozen=_has_direct_dataclass_transform_metaclass(
|
|
cls.info
|
|
),
|
|
api=self._api,
|
|
)
|
|
|
|
all_attrs = list(found_attrs.values())
|
|
if found_dataclass_supertype:
|
|
all_attrs.sort(key=lambda a: a.kw_only)
|
|
|
|
# Third, ensure that arguments without a default don't follow
|
|
# arguments that have a default and that the KW_ONLY sentinel
|
|
# is only provided once.
|
|
found_default = False
|
|
found_kw_sentinel = False
|
|
for attr in all_attrs:
|
|
# If we find any attribute that is_in_init, not kw_only, and that
|
|
# doesn't have a default after one that does have one,
|
|
# then that's an error.
|
|
if found_default and attr.is_in_init and not attr.has_default and not attr.kw_only:
|
|
# If the issue comes from merging different classes, report it
|
|
# at the class definition point.
|
|
context: Context = cls
|
|
if attr.name in current_attr_names:
|
|
context = Context(line=attr.line, column=attr.column)
|
|
self._api.fail(
|
|
"Attributes without a default cannot follow attributes with one", context
|
|
)
|
|
|
|
found_default = found_default or (attr.has_default and attr.is_in_init)
|
|
if found_kw_sentinel and self._is_kw_only_type(attr.type):
|
|
context = cls
|
|
if attr.name in current_attr_names:
|
|
context = Context(line=attr.line, column=attr.column)
|
|
self._api.fail(
|
|
"There may not be more than one field with the KW_ONLY type", context
|
|
)
|
|
found_kw_sentinel = found_kw_sentinel or self._is_kw_only_type(attr.type)
|
|
return all_attrs
|
|
|
|
def _freeze(self, attributes: list[DataclassAttribute]) -> None:
|
|
"""Converts all attributes to @property methods in order to
|
|
emulate frozen classes.
|
|
"""
|
|
info = self._cls.info
|
|
for attr in attributes:
|
|
# Classes that directly specify a dataclass_transform metaclass must be neither frozen
|
|
# non non-frozen per PEP681. Though it is surprising, this means that attributes from
|
|
# such a class must be writable even if the rest of the class heirarchy is frozen. This
|
|
# matches the behavior of Pyright (the reference implementation).
|
|
if attr.is_neither_frozen_nor_nonfrozen:
|
|
continue
|
|
|
|
sym_node = info.names.get(attr.name)
|
|
if sym_node is not None:
|
|
var = sym_node.node
|
|
if isinstance(var, Var):
|
|
var.is_property = True
|
|
else:
|
|
var = attr.to_var(info)
|
|
var.info = info
|
|
var.is_property = True
|
|
var._fullname = info.fullname + "." + var.name
|
|
info.names[var.name] = SymbolTableNode(MDEF, var)
|
|
|
|
def _propertize_callables(
|
|
self, attributes: list[DataclassAttribute], settable: bool = True
|
|
) -> None:
|
|
"""Converts all attributes with callable types to @property methods.
|
|
|
|
This avoids the typechecker getting confused and thinking that
|
|
`my_dataclass_instance.callable_attr(foo)` is going to receive a
|
|
`self` argument (it is not).
|
|
|
|
"""
|
|
info = self._cls.info
|
|
for attr in attributes:
|
|
if isinstance(get_proper_type(attr.type), CallableType):
|
|
var = attr.to_var(info)
|
|
var.info = info
|
|
var.is_property = True
|
|
var.is_settable_property = settable
|
|
var._fullname = info.fullname + "." + var.name
|
|
info.names[var.name] = SymbolTableNode(MDEF, var)
|
|
|
|
def _is_kw_only_type(self, node: Type | None) -> bool:
|
|
"""Checks if the type of the node is the KW_ONLY sentinel value."""
|
|
if node is None:
|
|
return False
|
|
node_type = get_proper_type(node)
|
|
if not isinstance(node_type, Instance):
|
|
return False
|
|
return node_type.type.fullname == "dataclasses.KW_ONLY"
|
|
|
|
def _add_dataclass_fields_magic_attribute(self) -> None:
|
|
attr_name = "__dataclass_fields__"
|
|
any_type = AnyType(TypeOfAny.explicit)
|
|
# For `dataclasses`, use the type `dict[str, Field[Any]]` for accuracy. For dataclass
|
|
# transforms, it's inaccurate to use `Field` since a given transform may use a completely
|
|
# different type (or none); fall back to `Any` there.
|
|
#
|
|
# In either case, we're aiming to match the Typeshed stub for `is_dataclass`, which expects
|
|
# the instance to have a `__dataclass_fields__` attribute of type `dict[str, Field[Any]]`.
|
|
if self._spec is _TRANSFORM_SPEC_FOR_DATACLASSES:
|
|
field_type = self._api.named_type_or_none("dataclasses.Field", [any_type]) or any_type
|
|
else:
|
|
field_type = any_type
|
|
attr_type = self._api.named_type(
|
|
"builtins.dict", [self._api.named_type("builtins.str"), field_type]
|
|
)
|
|
var = Var(name=attr_name, type=attr_type)
|
|
var.info = self._cls.info
|
|
var._fullname = self._cls.info.fullname + "." + attr_name
|
|
var.is_classvar = True
|
|
self._cls.info.names[attr_name] = SymbolTableNode(
|
|
kind=MDEF, node=var, plugin_generated=True
|
|
)
|
|
|
|
def _collect_field_args(self, expr: Expression) -> tuple[bool, dict[str, Expression]]:
|
|
"""Returns a tuple where the first value represents whether or not
|
|
the expression is a call to dataclass.field and the second is a
|
|
dictionary of the keyword arguments that field() was called with.
|
|
"""
|
|
if (
|
|
isinstance(expr, CallExpr)
|
|
and isinstance(expr.callee, RefExpr)
|
|
and expr.callee.fullname in self._spec.field_specifiers
|
|
):
|
|
# field() only takes keyword arguments.
|
|
args = {}
|
|
for name, arg, kind in zip(expr.arg_names, expr.args, expr.arg_kinds):
|
|
if not kind.is_named():
|
|
if kind.is_named(star=True):
|
|
# This means that `field` is used with `**` unpacking,
|
|
# the best we can do for now is not to fail.
|
|
# TODO: we can infer what's inside `**` and try to collect it.
|
|
message = 'Unpacking **kwargs in "field()" is not supported'
|
|
elif self._spec is not _TRANSFORM_SPEC_FOR_DATACLASSES:
|
|
# dataclasses.field can only be used with keyword args, but this
|
|
# restriction is only enforced for the *standardized* arguments to
|
|
# dataclass_transform field specifiers. If this is not a
|
|
# dataclasses.dataclass class, we can just skip positional args safely.
|
|
continue
|
|
else:
|
|
message = '"field()" does not accept positional arguments'
|
|
self._api.fail(message, expr)
|
|
return True, {}
|
|
assert name is not None
|
|
args[name] = arg
|
|
return True, args
|
|
return False, {}
|
|
|
|
def _get_bool_arg(self, name: str, default: bool) -> bool:
|
|
# Expressions are always CallExprs (either directly or via a wrapper like Decorator), so
|
|
# we can use the helpers from common
|
|
if isinstance(self._reason, Expression):
|
|
return _get_decorator_bool_argument(
|
|
ClassDefContext(self._cls, self._reason, self._api), name, default
|
|
)
|
|
|
|
# Subclass/metaclass use of `typing.dataclass_transform` reads the parameters from the
|
|
# class's keyword arguments (ie `class Subclass(Parent, kwarg1=..., kwarg2=...)`)
|
|
expression = self._cls.keywords.get(name)
|
|
if expression is not None:
|
|
return require_bool_literal_argument(self._api, expression, name, default)
|
|
return default
|
|
|
|
def _get_default_init_value_for_field_specifier(self, call: Expression) -> bool:
|
|
"""
|
|
Find a default value for the `init` parameter of the specifier being called. If the
|
|
specifier's type signature includes an `init` parameter with a type of `Literal[True]` or
|
|
`Literal[False]`, return the appropriate boolean value from the literal. Otherwise,
|
|
fall back to the standard default of `True`.
|
|
"""
|
|
if not isinstance(call, CallExpr):
|
|
return True
|
|
|
|
specifier_type = _get_callee_type(call)
|
|
if specifier_type is None:
|
|
return True
|
|
|
|
parameter = specifier_type.argument_by_name("init")
|
|
if parameter is None:
|
|
return True
|
|
|
|
literals = try_getting_literals_from_type(parameter.typ, bool, "builtins.bool")
|
|
if literals is None or len(literals) != 1:
|
|
return True
|
|
|
|
return literals[0]
|
|
|
|
def _infer_dataclass_attr_init_type(
|
|
self, sym: SymbolTableNode, name: str, context: Context
|
|
) -> Type | None:
|
|
"""Infer __init__ argument type for an attribute.
|
|
|
|
In particular, possibly use the signature of __set__.
|
|
"""
|
|
default = sym.type
|
|
if sym.implicit:
|
|
return default
|
|
t = get_proper_type(sym.type)
|
|
|
|
# Perform a simple-minded inference from the signature of __set__, if present.
|
|
# We can't use mypy.checkmember here, since this plugin runs before type checking.
|
|
# We only support some basic scanerios here, which is hopefully sufficient for
|
|
# the vast majority of use cases.
|
|
if not isinstance(t, Instance):
|
|
return default
|
|
setter = t.type.get("__set__")
|
|
if setter:
|
|
if isinstance(setter.node, FuncDef):
|
|
super_info = t.type.get_containing_type_info("__set__")
|
|
assert super_info
|
|
if setter.type:
|
|
setter_type = get_proper_type(
|
|
map_type_from_supertype(setter.type, t.type, super_info)
|
|
)
|
|
else:
|
|
return AnyType(TypeOfAny.unannotated)
|
|
if isinstance(setter_type, CallableType) and setter_type.arg_kinds == [
|
|
ARG_POS,
|
|
ARG_POS,
|
|
ARG_POS,
|
|
]:
|
|
return expand_type_by_instance(setter_type.arg_types[2], t)
|
|
else:
|
|
self._api.fail(
|
|
f'Unsupported signature for "__set__" in "{t.type.name}"', context
|
|
)
|
|
else:
|
|
self._api.fail(f'Unsupported "__set__" in "{t.type.name}"', context)
|
|
|
|
return default
|
|
|
|
|
|
def add_dataclass_tag(info: TypeInfo) -> None:
|
|
# The value is ignored, only the existence matters.
|
|
info.metadata["dataclass_tag"] = {}
|
|
|
|
|
|
def dataclass_tag_callback(ctx: ClassDefContext) -> None:
|
|
"""Record that we have a dataclass in the main semantic analysis pass.
|
|
|
|
The later pass implemented by DataclassTransformer will use this
|
|
to detect dataclasses in base classes.
|
|
"""
|
|
add_dataclass_tag(ctx.cls.info)
|
|
|
|
|
|
def dataclass_class_maker_callback(ctx: ClassDefContext) -> bool:
|
|
"""Hooks into the class typechecking process to add support for dataclasses."""
|
|
transformer = DataclassTransformer(
|
|
ctx.cls, ctx.reason, _get_transform_spec(ctx.reason), ctx.api
|
|
)
|
|
return transformer.transform()
|
|
|
|
|
|
def _get_transform_spec(reason: Expression) -> DataclassTransformSpec:
|
|
"""Find the relevant transform parameters from the decorator/parent class/metaclass that
|
|
triggered the dataclasses plugin.
|
|
|
|
Although the resulting DataclassTransformSpec is based on the typing.dataclass_transform
|
|
function, we also use it for traditional dataclasses.dataclass classes as well for simplicity.
|
|
In those cases, we return a default spec rather than one based on a call to
|
|
`typing.dataclass_transform`.
|
|
"""
|
|
if _is_dataclasses_decorator(reason):
|
|
return _TRANSFORM_SPEC_FOR_DATACLASSES
|
|
|
|
spec = find_dataclass_transform_spec(reason)
|
|
assert spec is not None, (
|
|
"trying to find dataclass transform spec, but reason is neither dataclasses.dataclass nor "
|
|
"decorated with typing.dataclass_transform"
|
|
)
|
|
return spec
|
|
|
|
|
|
def _is_dataclasses_decorator(node: Node) -> bool:
|
|
if isinstance(node, CallExpr):
|
|
node = node.callee
|
|
if isinstance(node, RefExpr):
|
|
return node.fullname in dataclass_makers
|
|
return False
|
|
|
|
|
|
def _has_direct_dataclass_transform_metaclass(info: TypeInfo) -> bool:
|
|
return (
|
|
info.declared_metaclass is not None
|
|
and info.declared_metaclass.type.dataclass_transform_spec is not None
|
|
)
|
|
|
|
|
|
def _fail_not_dataclass(ctx: FunctionSigContext, t: Type, parent_t: Type) -> None:
|
|
t_name = format_type_bare(t, ctx.api.options)
|
|
if parent_t is t:
|
|
msg = (
|
|
f'Argument 1 to "replace" has a variable type "{t_name}" not bound to a dataclass'
|
|
if isinstance(t, TypeVarType)
|
|
else f'Argument 1 to "replace" has incompatible type "{t_name}"; expected a dataclass'
|
|
)
|
|
else:
|
|
pt_name = format_type_bare(parent_t, ctx.api.options)
|
|
msg = (
|
|
f'Argument 1 to "replace" has type "{pt_name}" whose item "{t_name}" is not bound to a dataclass'
|
|
if isinstance(t, TypeVarType)
|
|
else f'Argument 1 to "replace" has incompatible type "{pt_name}" whose item "{t_name}" is not a dataclass'
|
|
)
|
|
|
|
ctx.api.fail(msg, ctx.context)
|
|
|
|
|
|
def _get_expanded_dataclasses_fields(
|
|
ctx: FunctionSigContext, typ: ProperType, display_typ: ProperType, parent_typ: ProperType
|
|
) -> list[CallableType] | None:
|
|
"""
|
|
For a given type, determine what dataclasses it can be: for each class, return the field types.
|
|
For generic classes, the field types are expanded.
|
|
If the type contains Any or a non-dataclass, returns None; in the latter case, also reports an error.
|
|
"""
|
|
if isinstance(typ, AnyType):
|
|
return None
|
|
elif isinstance(typ, UnionType):
|
|
ret: list[CallableType] | None = []
|
|
for item in typ.relevant_items():
|
|
item = get_proper_type(item)
|
|
item_types = _get_expanded_dataclasses_fields(ctx, item, item, parent_typ)
|
|
if ret is not None and item_types is not None:
|
|
ret += item_types
|
|
else:
|
|
ret = None # but keep iterating to emit all errors
|
|
return ret
|
|
elif isinstance(typ, TypeVarType):
|
|
return _get_expanded_dataclasses_fields(
|
|
ctx, get_proper_type(typ.upper_bound), display_typ, parent_typ
|
|
)
|
|
elif isinstance(typ, Instance):
|
|
replace_sym = typ.type.get_method(_INTERNAL_REPLACE_SYM_NAME)
|
|
if replace_sym is None:
|
|
_fail_not_dataclass(ctx, display_typ, parent_typ)
|
|
return None
|
|
replace_sig = replace_sym.type
|
|
assert isinstance(replace_sig, ProperType)
|
|
assert isinstance(replace_sig, CallableType)
|
|
return [expand_type_by_instance(replace_sig, typ)]
|
|
else:
|
|
_fail_not_dataclass(ctx, display_typ, parent_typ)
|
|
return None
|
|
|
|
|
|
# TODO: we can potentially get the function signature hook to allow returning a union
|
|
# and leave this to the regular machinery of resolving a union of callables
|
|
# (https://github.com/python/mypy/issues/15457)
|
|
def _meet_replace_sigs(sigs: list[CallableType]) -> CallableType:
|
|
"""
|
|
Produces the lowest bound of the 'replace' signatures of multiple dataclasses.
|
|
"""
|
|
args = {
|
|
name: (typ, kind)
|
|
for name, typ, kind in zip(sigs[0].arg_names, sigs[0].arg_types, sigs[0].arg_kinds)
|
|
}
|
|
|
|
for sig in sigs[1:]:
|
|
sig_args = {
|
|
name: (typ, kind)
|
|
for name, typ, kind in zip(sig.arg_names, sig.arg_types, sig.arg_kinds)
|
|
}
|
|
for name in (*args.keys(), *sig_args.keys()):
|
|
sig_typ, sig_kind = args.get(name, (UninhabitedType(), ARG_NAMED_OPT))
|
|
sig2_typ, sig2_kind = sig_args.get(name, (UninhabitedType(), ARG_NAMED_OPT))
|
|
args[name] = (
|
|
meet_types(sig_typ, sig2_typ),
|
|
ARG_NAMED_OPT if sig_kind == sig2_kind == ARG_NAMED_OPT else ARG_NAMED,
|
|
)
|
|
|
|
return sigs[0].copy_modified(
|
|
arg_names=list(args.keys()),
|
|
arg_types=[typ for typ, _ in args.values()],
|
|
arg_kinds=[kind for _, kind in args.values()],
|
|
)
|
|
|
|
|
|
def replace_function_sig_callback(ctx: FunctionSigContext) -> CallableType:
|
|
"""
|
|
Returns a signature for the 'dataclasses.replace' function that's dependent on the type
|
|
of the first positional argument.
|
|
"""
|
|
if len(ctx.args) != 2:
|
|
# Ideally the name and context should be callee's, but we don't have it in FunctionSigContext.
|
|
ctx.api.fail(f'"{ctx.default_signature.name}" has unexpected type annotation', ctx.context)
|
|
return ctx.default_signature
|
|
|
|
if len(ctx.args[0]) != 1:
|
|
return ctx.default_signature # leave it to the type checker to complain
|
|
|
|
obj_arg = ctx.args[0][0]
|
|
obj_type = get_proper_type(ctx.api.get_expression_type(obj_arg))
|
|
inst_type_str = format_type_bare(obj_type, ctx.api.options)
|
|
|
|
replace_sigs = _get_expanded_dataclasses_fields(ctx, obj_type, obj_type, obj_type)
|
|
if replace_sigs is None:
|
|
return ctx.default_signature
|
|
replace_sig = _meet_replace_sigs(replace_sigs)
|
|
|
|
return replace_sig.copy_modified(
|
|
arg_names=[None, *replace_sig.arg_names],
|
|
arg_kinds=[ARG_POS, *replace_sig.arg_kinds],
|
|
arg_types=[obj_type, *replace_sig.arg_types],
|
|
ret_type=obj_type,
|
|
fallback=ctx.default_signature.fallback,
|
|
name=f"{ctx.default_signature.name} of {inst_type_str}",
|
|
)
|
|
|
|
|
|
def is_processed_dataclass(info: TypeInfo | None) -> bool:
|
|
return info is not None and "dataclass" in info.metadata
|
|
|
|
|
|
def check_post_init(api: TypeChecker, defn: FuncItem, info: TypeInfo) -> None:
|
|
if defn.type is None:
|
|
return
|
|
assert isinstance(defn.type, FunctionLike)
|
|
|
|
ideal_sig_method = info.get_method(_INTERNAL_POST_INIT_SYM_NAME)
|
|
assert ideal_sig_method is not None and ideal_sig_method.type is not None
|
|
ideal_sig = ideal_sig_method.type
|
|
assert isinstance(ideal_sig, ProperType) # we set it ourselves
|
|
assert isinstance(ideal_sig, CallableType)
|
|
ideal_sig = ideal_sig.copy_modified(name="__post_init__")
|
|
|
|
api.check_override(
|
|
override=defn.type,
|
|
original=ideal_sig,
|
|
name="__post_init__",
|
|
name_in_super="__post_init__",
|
|
supertype="dataclass",
|
|
original_class_or_static=False,
|
|
override_class_or_static=False,
|
|
node=defn,
|
|
)
|