Address second review comments.

- Remove limitation that Python must be 3.8+. - Move fine-grained test of asdict to main fine-grained test file. - Correct fine-grained test of asdict so it actually tests it properly. This doesn't pass currently... - Try to lookup anonymous TypedDict fallback using named_type_or_none, - Add additional dependency only on typing_extensions. - copied from SemanticAnalyzer to TypeChecker.
python · syastrov · Mar 26, 2020 · Mar 26, 2020 · Mar 26, 2020 · Mar 26, 2020
commit d12c665197a8e880ab25ed5619b37294552e3a52
diff --git a/docs/source/additional_features.rst b/docs/source/additional_features.rst
@@ -75,9 +75,9 @@ Caveats/Known Issues
 Some functions in the :py:mod:`dataclasses` module, such as :py:func:`~dataclasses.replace`,
 have imprecise (too permissive) types. This will be fixed in future releases.
 
-In Python version 3.8 and above, calls to :py:func:`~dataclasses.asdict` will return a ``TypedDict`` based on the
-original dataclass 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.
+Calls to :py:func:`~dataclasses.asdict` will return a ``TypedDict`` based on the original dataclass
+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/checker.py b/mypy/checker.py
@@ -24,8 +24,8 @@
     Import, ImportFrom, ImportAll, ImportBase, TypeAlias,
     ARG_POS, ARG_STAR, LITERAL_TYPE, MDEF, GDEF,
     CONTRAVARIANT, COVARIANT, INVARIANT, TypeVarExpr, AssignmentExpr,
-    is_final_node,
-    ARG_NAMED)
+    is_final_node, ARG_NAMED, PlaceholderNode
+)
 from mypy import nodes
 from mypy.literals import literal, literal_hash, Key
 from mypy.typeanal import has_any_from_unimported_type, check_for_explicit_any
@@ -4593,6 +4593,21 @@ def named_type(self, name: str) -> Instance:
         any_type = AnyType(TypeOfAny.from_omitted_generics)
         return Instance(node, [any_type] * len(node.defn.type_vars))
 
+    def named_type_or_none(self, qualified_name: str,
+                           args: Optional[List[Type]] = None) -> Optional[Instance]:
+        sym = self.lookup_qualified(qualified_name)
+        if not sym or isinstance(sym.node, PlaceholderNode):
+            return None
+        node = sym.node
+        if isinstance(node, TypeAlias):
+            assert isinstance(node.target, Instance)  # type: ignore
+            node = node.target.type
+        assert isinstance(node, TypeInfo), node
+        if args is not None:
+            # TODO: assert len(args) == len(node.defn.type_vars)
+            return Instance(node, args)
+        return Instance(node, [AnyType(TypeOfAny.unannotated)] * len(node.defn.type_vars))
+
     def named_generic_type(self, name: str, args: List[Type]) -> Instance:
         """Return an instance with the given name and type arguments.
 

diff --git a/mypy/plugin.py b/mypy/plugin.py
@@ -231,6 +231,10 @@ def named_generic_type(self, name: str, args: List[Type]) -> Instance:
         """Construct an instance of a builtin type with given type arguments."""
         raise NotImplementedError
 
+    def named_type_or_none(self, qualified_name: str,
+                           args: Optional[List[Type]] = None) -> Optional[Instance]:
+        raise NotImplementedError
+
 
 @trait
 class SemanticAnalyzerPluginInterface:

diff --git a/mypy/plugins/common.py b/mypy/plugins/common.py
@@ -7,6 +7,7 @@
 )
 from mypy.plugin import ClassDefContext, SemanticAnalyzerPluginInterface, CheckerPluginInterface
 from mypy.semanal import set_callable_name
+from mypy.semanal_typeddict import get_anonymous_typeddict_type
 from mypy.types import (
     CallableType, Overloaded, Type, TypeVarDef, deserialize_type, get_proper_type,
     TypedDictType, Instance, TPDICT_FB_NAMES
@@ -165,15 +166,6 @@ def deserialize_and_fixup_type(
     return typ
 
 
-def get_anonymous_typeddict_type(api: CheckerPluginInterface) -> Instance:
-    for type_fullname in TPDICT_FB_NAMES:
-        try:
-            return api.named_generic_type(type_fullname, [])
-        except KeyError:
-            continue
-    raise RuntimeError("No TypedDict fallback type found")
-
-
 def make_anonymous_typeddict(api: CheckerPluginInterface, fields: 'OrderedDict[str, Type]',
                              required_keys: Set[str]) -> TypedDictType:
     return TypedDictType(fields, required_keys=required_keys,

diff --git a/mypy/plugins/dataclasses.py b/mypy/plugins/dataclasses.py
@@ -381,15 +381,15 @@ def _collect_field_args(expr: Expression) -> Tuple[bool, Dict[str, Expression]]:
     return False, {}
 
 
-def asdict_callback(ctx: FunctionContext, return_typeddicts: bool = False) -> Type:
-    """Check that calls to asdict pass in a dataclass. Optionally, return TypedDicts."""
+def asdict_callback(ctx: FunctionContext) -> Type:
+    """Check that calls to asdict pass in a dataclass. If possible, return TypedDicts."""
     positional_arg_types = ctx.arg_types[0]
 
     if positional_arg_types:
         dataclass_instance = get_proper_type(positional_arg_types[0])
         if isinstance(dataclass_instance, Instance):
             if is_type_dataclass(dataclass_instance.type):
-                if len(ctx.arg_types) == 1 and return_typeddicts:
+                if len(ctx.arg_types) == 1:
                     return _asdictify(ctx.api, dataclass_instance)
                 else:
                     # We can't infer a more precise type for calls where dict_factory is set.

diff --git a/mypy/plugins/default.py b/mypy/plugins/default.py
@@ -2,7 +2,9 @@
 from typing import Callable, Optional, List, Tuple
 
 from mypy import message_registry
-from mypy.nodes import Expression, StrExpr, IntExpr, DictExpr, UnaryExpr, MypyFile
+from mypy.nodes import (
+    Expression, StrExpr, IntExpr, DictExpr, UnaryExpr, MypyFile, ImportFrom, Import, ImportAll
+)
 from mypy.plugin import (
     Plugin, FunctionContext, MethodContext, MethodSigContext, AttributeContext, ClassDefContext,
     CheckerPluginInterface,
@@ -21,10 +23,7 @@ class DefaultPlugin(Plugin):
     """Type checker plugin that is enabled by default."""
 
     def get_additional_deps(self, file: MypyFile) -> List[Tuple[int, str, int]]:
-        if self.python_version >= (3, 8):
-            # Add module needed for anonymous TypedDict (used to support dataclasses.asdict)
-            return [(10, "typing", -1)]
-        return []
+        return [(10, "typing_extensions", -1)]
 
     def get_function_hook(self, fullname: str
                           ) -> Optional[Callable[[FunctionContext], Type]]:
@@ -38,8 +37,7 @@ def get_function_hook(self, fullname: str
         elif fullname == 'ctypes.Array':
             return ctypes.array_constructor_callback
         elif fullname == 'dataclasses.asdict':
-            return partial(dataclasses.asdict_callback,
-                           return_typeddicts=self.python_version >= (3, 8))
+            return dataclasses.asdict_callback
         return None
 
     def get_method_signature_hook(self, fullname: str

diff --git a/mypy/semanal_typeddict.py b/mypy/semanal_typeddict.py
@@ -1,10 +1,12 @@
 """Semantic analysis of TypedDict definitions."""
 
 from mypy.ordered_dict import OrderedDict
-from typing import Optional, List, Set, Tuple
+from collections import OrderedDict
+from typing import Optional, List, Set, Tuple, Union
 from typing_extensions import Final
 
-from mypy.types import Type, AnyType, TypeOfAny, TypedDictType, TPDICT_NAMES
+from mypy.plugin import CheckerPluginInterface
+from mypy.types import Type, AnyType, TypeOfAny, TypedDictType, TPDICT_NAMES, Instance
 from mypy.nodes import (
     CallExpr, TypedDictExpr, Expression, NameExpr, Context, StrExpr, BytesExpr, UnicodeExpr,
     ClassDef, RefExpr, TypeInfo, AssignmentStmt, PassStmt, ExpressionStmt, EllipsisExpr, TempNode,
@@ -304,10 +306,7 @@ def fail_typeddict_arg(self, message: str,
     def build_typeddict_typeinfo(self, name: str, items: List[str],
                                  types: List[Type],
                                  required_keys: Set[str]) -> TypeInfo:
-        # Prefer typing then typing_extensions if available.
-        fallback = (self.api.named_type_or_none('typing._TypedDict', []) or
-                    self.api.named_type_or_none('typing_extensions._TypedDict', []) or
-                    self.api.named_type_or_none('mypy_extensions._TypedDict', []))
+        fallback = get_anonymous_typeddict_type(self.api)
         assert fallback is not None
         info = self.api.basic_new_typeinfo(name, fallback)
         info.typeddict_type = TypedDictType(OrderedDict(zip(items, types)), required_keys,
@@ -322,3 +321,10 @@ def is_typeddict(self, expr: Expression) -> bool:
 
     def fail(self, msg: str, ctx: Context) -> None:
         self.api.fail(msg, ctx)
+
+def get_anonymous_typeddict_type(
+        api: Union[SemanticAnalyzerInterface, CheckerPluginInterface]) -> Instance:
+    # Prefer typing then typing_extensions if available.
+    return (api.named_type_or_none('typing._TypedDict', []) or
+            api.named_type_or_none('typing_extensions._TypedDict', []) or
+            api.named_type_or_none('mypy_extensions._TypedDict', []))
diff --git a/mypy/test/testfinegrained.py b/mypy/test/testfinegrained.py
@@ -49,7 +49,6 @@ class FineGrainedSuite(DataSuite):
         'fine-grained-modules.test',
         'fine-grained-follow-imports.test',
         'fine-grained-suggest.test',
-        'fine-grained-dataclasses.test',
     ]
 
     # Whether to use the fine-grained cache in the testing. This is overridden

diff --git a/test-data/unit/check-dataclasses.test b/test-data/unit/check-dataclasses.test
@@ -992,7 +992,6 @@ reveal_type(B)  # N: Revealed type is 'def (foo: builtins.int) -> __main__.B'
10BC0
;
 [builtins fixtures/property.pyi]
 
 [case testDataclassesAsdict]
-# flags: --python-version 3.8
 from dataclasses import dataclass, asdict
 from typing import List, Tuple, Dict, Any
 
@@ -1028,9 +1027,11 @@ from dataclasses import dataclass, asdict
 class Foo:
     bar: str
 
-reveal_type(asdict(Foo('bar')))  # N: Revealed type is 'Any'
+reveal_type(asdict(Foo('bar')))  # N: Revealed type is 'TypedDict({'bar': builtins.str})'
 
 [typing fixtures/typing-full.pyi]
+[builtins fixtures/tuple.pyi]
+
 
 [case testDataclassesAsdictPython37]
 # flags: --python-version 3.7
@@ -1040,13 +1041,25 @@ from dataclasses import dataclass, asdict
 class Foo:
     bar: str
 
-reveal_type(asdict(Foo('bar')))  # N: Revealed type is 'Any'
+reveal_type(asdict(Foo('bar')))  # N: Revealed type is 'TypedDict({'bar': builtins.str})'
 
 [typing fixtures/typing-full.pyi]
+[builtins fixtures/tuple.pyi]
 
-[case testDataclassesAsdictRecursion]
+[case testDataclassesAsdictPython38]
 # flags: --python-version 3.8
 from dataclasses import dataclass, asdict
+
+@dataclass
+class Foo:
+    bar: str
+
+reveal_type(asdict(Foo('bar')))  # N: Revealed type is 'TypedDict({'bar': builtins.str})'
+
+[typing fixtures/typing-full.pyi]
+
+[case testDataclassesAsdictRecursion]
+from dataclasses import dataclass, asdict
 from typing import Optional
 
 @dataclass
@@ -1066,10 +1079,10 @@ 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]
+[builtins fixtures/tuple.pyi]
 [builtins fixtures/dict.pyi]
 
 [case testDataclassesAsdictUnions]
-# flags: --python-version 3.8
 from dataclasses import dataclass, asdict
 from typing import Union
 
@@ -1086,7 +1099,6 @@ reveal_type(asdict(Customer("foo")))  # N: Revealed type is 'TypedDict({'card':
 [typing fixtures/typing-full.pyi]
 
 [case testDataclassesAsdictType]
-# flags: --python-version 3.8
 from dataclasses import dataclass, asdict
 from typing import Type
 
@@ -1105,7 +1117,6 @@ reveal_type(asdict(Customer(Card)))  # N: Revealed type is 'TypedDict({'card': T
 
 
 [case testDataclassesAsdictCallable]
-# flags: --python-version 3.8
 from dataclasses import dataclass, asdict
 from typing import Callable
 
@@ -1126,7 +1137,6 @@ reveal_type(asdict(Customer(func)))  # N: Revealed type is 'TypedDict({'card': d
 
 
 [case testDataclassesAsdictList]
-# flags: --python-version 3.8
 from dataclasses import dataclass, asdict
 from typing import List, Any
 
@@ -1157,7 +1167,6 @@ reveal_type(result['list_no_generic']) # N: Revealed type is 'builtins.list[Any]
 

 [case testDataclassesAsdictListSubclass]
-# flags: --python-version 3.8
 from dataclasses import dataclass, asdict
 from typing import List, Any, TypeVar, Generic
 
@@ -1206,7 +1215,6 @@ reveal_type(result['list_subclass_with_constraint']) # N: Revealed type is 'buil
 
 
 [case testDataclassesAsdictDict]
-# flags: --python-version 3.8
 from dataclasses import dataclass, asdict
 from typing import Dict
 
@@ -1227,7 +1235,6 @@ reveal_type(result['participants_by_name']) # N: Revealed type is 'builtins.dict
 [builtins fixtures/dict.pyi]
 
 [case testDataclassesAsdictDictSubclass]
-# flags: --python-version 3.8
 from dataclasses import dataclass, asdict
 from typing import Dict, Generic, TypeVar
 
@@ -1255,7 +1262,6 @@ reveal_type(result['participants_by_name']) # N: Revealed type is 'builtins.dict
 
 
 [case testDataclassesAsdictTuple]
-# flags: --python-version 3.8
 from dataclasses import dataclass, asdict
 from typing import Tuple
 
@@ -1279,7 +1285,6 @@ reveal_type(result['partners']) # N: Revealed type is 'Tuple[TypedDict({'name':
 
 
 [case testDataclassesAsdictTupleSubclass]
-# flags: --python-version 3.8
 from dataclasses import dataclass, asdict
 from typing import Tuple, Generic, TypeVar
 
@@ -1308,7 +1313,6 @@ reveal_type(result['tuple_subclass']) # N: Revealed type is 'Tuple[TypedDict({'n
 [builtins fixtures/tuple.pyi]
 
 [case testDataclassesAsdictNamedTuple]
-# flags: --python-version 3.8
 from dataclasses import dataclass, asdict
 from typing import NamedTuple
 

diff --git a/test-data/unit/fine-grained-dataclasses.test b/test-data/unit/fine-grained-dataclasses.test
diff --git a/test-data/unit/fine-grained.test b/test-data/unit/fine-grained.test
@@ -910,6 +910,35 @@ class A:
 main:3: error: Too few arguments for "C"
 ==
 
+[case testDataclassesAsdictFineGrained]
+# flags: --python-version 3.8
+[file a.py]
+from dataclasses import dataclass
+from b import AttributeInOtherModule
+
+@dataclass
+class MyDataclass:
+    attr: AttributeInOtherModule
+
+my_var: MyDataclass
+
+[file b.py]
+AttributeInOtherModule = str
+[file c.py]
+from dataclasses import asdict
+from a import my_var
+asdict(my_var)['attr'] + "foo"
+
+[file b.py.2]
+AttributeInOtherModule = int
+
+[out]
+==
+c.py:3 error: Unsupported left operand type for + ("int")
+
+[typing fixtures/typing-typeddict.pyi]
+[builtins fixtures/fine_grained.pyi]
+
 [case testAttrsUpdate1]
 [file a.py]
 import attr