Address some of review comments (formatting, docs, code nitpicks, rem…

…ove recursion error).
python · syastrov · Mar 26, 2020 · Mar 26, 2020 · Mar 26, 2020 · Mar 26, 2020
commit d809e8b6bb44c105ca0576503b696b4583f603ba
diff --git a/docs/source/additional_features.rst b/docs/source/additional_features.rst
@@ -76,17 +76,8 @@ Some functions in the :py:mod:`dataclasses` module, such as :py:func:`~dataclass
 have imprecise (too permissive) types. This will be fixed in future releases.
 
 Calls to :py:func:`~dataclasses.asdict` will return a ``TypedDict`` based on the original dataclass
-definition, transforming it recursively. There are, however, some limitations:
-
-* Subclasses of ``List``, ``Dict``, and ``Tuple`` appearing within dataclasses are transformed into reparameterized
-  versions of the respective base class, rather than a transformed version of the original subclass.
-
-* Recursion (e.g. dataclasses which reference each other) is not supported and results in an error.
-
-* ``NamedTuples`` appearing within dataclasses are transformed to ``Any``
-
-* A more precise return type cannot be inferred for calls where ``dict_factory`` is set.
-
+definition, transforming it recursively. There are, however, some limitations. In particular, a precise return type
+cannot be inferred for recursive dataclasses, and for calls where ``dict_factory`` is set.
 
 Mypy does not yet recognize aliases of :py:func:`dataclasses.dataclass <dataclasses.dataclass>`, and will
 probably never recognize dynamically computed decorators. The following examples

diff --git a/mypy/plugins/common.py b/mypy/plugins/common.py
@@ -9,7 +9,8 @@
 from mypy.semanal import set_callable_name
 from mypy.types import (
     CallableType, Overloaded, Type, TypeVarDef, deserialize_type, get_proper_type,
-    TypedDictType, Instance, TPDICT_FB_NAMES)
+    TypedDictType, Instance, TPDICT_FB_NAMES
+)
 from mypy.typevars import fill_typevars
 from mypy.util import get_unique_redefinition_name
 from mypy.typeops import try_getting_str_literals  # noqa: F401  # Part of public API

diff --git a/mypy/plugins/dataclasses.py b/mypy/plugins/dataclasses.py
@@ -13,11 +13,15 @@
 )
 from mypy.plugin import ClassDefContext, FunctionContext, CheckerPluginInterface
 from mypy.plugin import SemanticAnalyzerPluginInterface
-from mypy.plugins.common import (add_method, _get_decorator_bool_argument,
-                                 make_anonymous_typeddict, deserialize_and_fixup_type)
+from mypy.plugins.common import (
+    add_method, _get_decorator_bool_argument, make_anonymous_typeddict,
+    deserialize_and_fixup_type
+)
 from mypy.server.trigger import make_wildcard_trigger
-from mypy.types import (Instance, NoneType, TypeVarDef, TypeVarType, get_proper_type, Type,
-                        TupleType, UnionType, AnyType, TypeOfAny)
+from mypy.types import (
+    Instance, NoneType, TypeVarDef, TypeVarType, get_proper_type, Type, TupleType, UnionType,
+    AnyType, TypeOfAny
+)
 
 # The set of decorators that generate dataclasses.
 dataclass_makers = {
@@ -380,11 +384,9 @@ def asdict_callback(ctx: FunctionContext) -> Type:
     positional_arg_types = ctx.arg_types[0]
 
     if positional_arg_types:
-        dataclass_instance = positional_arg_types[0]
-        dataclass_instance = get_proper_type(dataclass_instance)
+        dataclass_instance = get_proper_type(positional_arg_types[0])
         if isinstance(dataclass_instance, Instance):
-            info = dataclass_instance.type
-            if is_type_dataclass(info):
+            if is_type_dataclass(dataclass_instance.type):
                 if len(ctx.arg_types) == 1:
                     return _asdictify(ctx.api, ctx.context, dataclass_instance)
                 else:
@@ -424,10 +426,7 @@ def _asdictify_inner(typ: Type, seen_dataclasses: FrozenSet[str]) -> Type:
             info = typ.type
             if is_type_dataclass(info):
                 if info.fullname in seen_dataclasses:
-                    api.fail(
-                        "Recursive types are not supported in call to asdict, so falling back to "
-                        "Dict[str, Any]",
-                        context)
+                    # Recursive types not supported, so fall back to Dict[str, Any]
                     # Note: Would be nicer to fallback to default_return_type, but that is Any
                     # (due to overloads?)
                     return api.named_generic_type('builtins.dict',
@@ -446,14 +445,14 @@ def _asdictify_inner(typ: Type, seen_dataclasses: FrozenSet[str]) -> Type:
                                                 required_keys=set())
             elif info.has_base('builtins.list'):
                 supertype_instance = map_instance_to_supertype(typ, api.named_generic_type(
-                    'builtins.list', []).type)
+                    'builtins.list', [AnyType(TypeOfAny.implementation_artifact)]).type)
                 new_args = _transform_type_args(
                     typ=supertype_instance,
                     transform=lambda arg: _asdictify_inner(arg, seen_dataclasses))
                 return api.named_generic_type('builtins.list', new_args)
             elif info.has_base('builtins.dict'):
                 supertype_instance = map_instance_to_supertype(typ, api.named_generic_type(
-                    'builtins.dict', []).type)
+                    'builtins.dict', [AnyType(TypeOfAny.implementation_artifact), AnyType(TypeOfAny.implementation_artifact)]).type)
                 new_args = _transform_type_args(
                     typ=supertype_instance,
                     transform=lambda arg: _asdictify_inner(arg, seen_dataclasses))

diff --git a/test-data/unit/check-dataclasses.test b/test-data/unit/check-dataclasses.test
@@ -1035,7 +1035,7 @@ class A:
     b: Optional[B] = None
 
 # Recursion is not supported, so fall back
-result = asdict(A(B(C(A()))))  # E: Recursive types are not supported in call to asdict, so falling back to Dict[str, Any]
+result = asdict(A(B(C(A()))))
 reveal_type(result)  # N: Revealed type is 'TypedDict({'b'?: Union[TypedDict({'c'?: TypedDict({'a'?: builtins.dict[builtins.str, Any]})}), None]})'
 
 [typing fixtures/typing-full.pyi]