Merge branch '2023-03-06-dataclasses-replace' of https://github.com/ikonst/mypy into 2023-03-06-dataclasses-replace

Author: ikonst

docs/source/error_code_list.rst

@@ -344,7 +344,7 @@ Check that assignment target is not a method [method-assign]
 
 In general, assigning to a method on class object or instance (a.k.a.
 monkey-patching) is ambiguous in terms of types, since Python's static type
-system cannot express difference between bound and unbound callable types.
+system cannot express the difference between bound and unbound callable types.
 Consider this example:
 
 .. code-block:: python
@@ -355,18 +355,18 @@ Consider this example:
 
    def h(self: A) -> None: pass
 
-   A.f = h  # type of h is Callable[[A], None]
-   A().f()  # this works
-   A.f = A().g  # type of A().g is Callable[[], None]
-   A().f()  # but this also works at runtime
+   A.f = h  # Type of h is Callable[[A], None]
+   A().f()  # This works
+   A.f = A().g  # Type of A().g is Callable[[], None]
+   A().f()  # ...but this also works at runtime
 
 To prevent the ambiguity, mypy will flag both assignments by default. If this
-error code is disabled, mypy will treat all method assignments r.h.s. as unbound,
-so the second assignment will still generate an error.
+error code is disabled, mypy will treat the assigned value in all method assignments as unbound,
+so only the second assignment will still generate an error.
 
 .. note::
 
-    This error code is a sub-error code of a wider ``[assignment]`` code.
+    This error code is a subcode of the more general ``[assignment]`` code.
 
 Check type variable values [type-var]
 -------------------------------------
@@ -456,11 +456,11 @@ Example:
 Check TypedDict items [typeddict-item]
 --------------------------------------
 
-When constructing a ``TypedDict`` object, mypy checks that each key and value is compatible
-with the ``TypedDict`` type that is inferred from the surrounding context.
+When constructing a TypedDict object, mypy checks that each key and value is compatible
+with the TypedDict type that is inferred from the surrounding context.
 
-When getting a ``TypedDict`` item, mypy checks that the key
-exists. When assigning to a ``TypedDict``, mypy checks that both the
+When getting a TypedDict item, mypy checks that the key
+exists. When assigning to a TypedDict, mypy checks that both the
 key and the value are valid.
 
 Example:
@@ -480,10 +480,13 @@ Example:
 Check TypedDict Keys [typeddict-unknown-key]
 --------------------------------------------
 
-When constructing a ``TypedDict`` object, mypy checks whether the definition
-contains unknown keys. For convenience's sake, mypy will not generate an error
-when a ``TypedDict`` has extra keys if it's passed to a function as an argument.
-However, it will generate an error when these are created. Example:
+When constructing a TypedDict object, mypy checks whether the
+definition contains unknown keys, to catch invalid keys and
+misspellings. On the other hand, mypy will not generate an error when
+a previously constructed TypedDict value with extra keys is passed
+to a function as an argument, since TypedDict values support
+structural subtyping ("static duck typing") and the keys are assumed
+to have been validated at the point of construction. Example:
 
 .. code-block:: python
 
@@ -502,23 +505,23 @@ However, it will generate an error when these are created. Example:
     a: Point = {"x": 1, "y": 4}
     b: Point3D = {"x": 2, "y": 5, "z": 6}
 
-    # OK
-    add_x_coordinates(a, b)
+    add_x_coordinates(a, b)  # OK
+
     # Error: Extra key "z" for TypedDict "Point"  [typeddict-unknown-key]
     add_x_coordinates(a, {"x": 1, "y": 4, "z": 5})
 
-
-Setting an unknown value on a ``TypedDict`` will also generate this error:
+Setting a TypedDict item using an unknown key will also generate this
+error, since it could be a misspelling:
 
 .. code-block:: python
 
     a: Point = {"x": 1, "y": 2}
     # Error: Extra key "z" for TypedDict "Point"  [typeddict-unknown-key]
     a["z"] = 3
 
-
-Whereas reading an unknown value will generate the more generic/serious
-``typeddict-item``:
+Reading an unknown key will generate the more general (and serious)
+``typeddict-item`` error, which is likely to result in an exception at
+runtime:
 
 .. code-block:: python
 
@@ -528,7 +531,7 @@ Whereas reading an unknown value will generate the more generic/serious
 
 .. note::
 
-    This error code is a sub-error code of a wider ``[typeddict-item]`` code.
+    This error code is a subcode of the wider ``[typeddict-item]`` code.
 
 Check that type of target is known [has-type]
 ---------------------------------------------
@@ -810,8 +813,8 @@ Check that literal is used where expected [literal-required]
 There are some places where only a (string) literal value is expected for
 the purposes of static type checking, for example a ``TypedDict`` key, or
 a ``__match_args__`` item. Providing a ``str``-valued variable in such contexts
-will result in an error. Note however, in many cases you can use ``Final``,
-or ``Literal`` variables, for example:
+will result in an error. Note that in many cases you can also use ``Final``
+or ``Literal`` variables. Example:
 
 .. code-block:: python
 

docs/source/error_codes.rst

@@ -114,13 +114,13 @@ So one can e.g. enable some code globally, disable it for all tests in
 the corresponding config section, and then re-enable it with an inline
 comment in some specific test.
 
-Sub-error codes of other error codes
-------------------------------------
+Subcodes of error codes
+-----------------------
 
-In rare cases (mostly for backwards compatibility reasons), some error
-code may be covered by another, wider error code. For example, an error with
+In some cases, mostly for backwards compatibility reasons, an error
+code may be covered also by another, wider error code. For example, an error with
 code ``[method-assign]`` can be ignored by ``# type: ignore[assignment]``.
 Similar logic works for disabling error codes globally. If a given error code
-is a sub code of another one, it must mentioned in the docs for the narrower
-code. This hierarchy is not nested, there cannot be sub-error codes of other
-sub-error codes.
+is a subcode of another one, it will be mentioned in the documentation for the narrower
+code. This hierarchy is not nested: there cannot be subcodes of other
+subcodes.

mypy/plugins/dataclasses.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import Optional
+from typing import Iterator, Optional
 from typing_extensions import Final
 
 from mypy import errorcodes, message_registry
@@ -18,12 +18,14 @@
     MDEF,
     Argument,
     AssignmentStmt,
+    Block,
     CallExpr,
     ClassDef,
     Context,
     DataclassTransformSpec,
     Expression,
     FuncDef,
+    IfStmt,
     JsonDict,
     NameExpr,
     Node,
@@ -413,6 +415,22 @@ def reset_init_only_vars(self, info: TypeInfo, attributes: list[DataclassAttribu
                             # 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.
 
@@ -471,10 +489,10 @@ def collect_attributes(self) -> list[DataclassAttribute] | None:
         # 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 cls.defs.body:
+        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 (isinstance(stmt, AssignmentStmt) and stmt.new_syntax):
+            if not stmt.new_syntax:
                 continue
 
             # a: int, b: str = 1, 'foo' is not supported syntax so we

mypy/stubtest.py

@@ -25,7 +25,7 @@
 from contextlib import redirect_stderr, redirect_stdout
 from functools import singledispatch
 from pathlib import Path
-from typing import Any, Generic, Iterator, TypeVar, Union, cast
+from typing import Any, Generic, Iterator, TypeVar, Union
 from typing_extensions import get_origin
 
 import mypy.build
@@ -476,10 +476,7 @@ def verify_typeinfo(
     to_check = set(stub.names)
     # Check all public things on the runtime class
     to_check.update(
-        # cast to workaround mypyc complaints
-        m
-        for m in cast(Any, vars)(runtime)
-        if not is_probably_private(m) and m not in IGNORABLE_CLASS_DUNDERS
+        m for m in vars(runtime) if not is_probably_private(m) and m not in IGNORABLE_CLASS_DUNDERS
     )
     # Special-case the __init__ method for Protocols
     #

mypy/types.py

@@ -950,7 +950,8 @@ def __init__(
 
     def accept(self, visitor: TypeVisitor[T]) -> T:
         assert isinstance(visitor, SyntheticTypeVisitor)
-        return cast(T, visitor.visit_callable_argument(self))
+        ret: T = visitor.visit_callable_argument(self)
+        return ret
 
     def serialize(self) -> JsonDict:
         assert False, "Synthetic types don't serialize"
@@ -975,7 +976,8 @@ def __init__(self, items: list[Type], line: int = -1, column: int = -1) -> None:
 
     def accept(self, visitor: TypeVisitor[T]) -> T:
         assert isinstance(visitor, SyntheticTypeVisitor)
-        return cast(T, visitor.visit_type_list(self))
+        ret: T = visitor.visit_type_list(self)
+        return ret
 
     def serialize(self) -> JsonDict:
         assert False, "Synthetic types don't serialize"
@@ -2489,7 +2491,8 @@ def simple_name(self) -> str:
 
     def accept(self, visitor: TypeVisitor[T]) -> T:
         assert isinstance(visitor, SyntheticTypeVisitor)
-        return cast(T, visitor.visit_raw_expression_type(self))
+        ret: T = visitor.visit_raw_expression_type(self)
+        return ret
 
     def serialize(self) -> JsonDict:
         assert False, "Synthetic types don't serialize"
@@ -2736,7 +2739,8 @@ class EllipsisType(ProperType):
 
     def accept(self, visitor: TypeVisitor[T]) -> T:
         assert isinstance(visitor, SyntheticTypeVisitor)
-        return cast(T, visitor.visit_ellipsis_type(self))
+        ret: T = visitor.visit_ellipsis_type(self)
+        return ret
 
     def serialize(self) -> JsonDict:
         assert False, "Synthetic types don't serialize"
@@ -2845,7 +2849,8 @@ def __init__(self, fullname: str | None, args: list[Type], line: int) -> None:
 
     def accept(self, visitor: TypeVisitor[T]) -> T:
         assert isinstance(visitor, SyntheticTypeVisitor)
-        return cast(T, visitor.visit_placeholder_type(self))
+        ret: T = visitor.visit_placeholder_type(self)
+        return ret
 
     def __hash__(self) -> int:
         return hash((self.fullname, tuple(self.args)))