Change reveal_type() representation of TypedDicts (#3598)

Change the formatting to be closer to the TypedDict definition syntax
and preserve TypedDict name when constructing using TD(...) for better
reveal_type output.

Note that this uses a new representation `'key'?: type` for
non-required keys.

Fixes #3590.

Author: JukkaL

docs/source/kinds_of_types.rst

@@ -1027,6 +1027,11 @@ value of type ``Awaitable[T]``:
    my_coroutine = countdown_1("Millennium Falcon", 5)
    reveal_type(my_coroutine)  # has type 'Awaitable[str]'
 
+.. note::
+
+    :ref:`reveal_type() <reveal-type>` displays the inferred static type of
+    an expression.
+
 If you want to use coroutines in older versions of Python that do not support
 the ``async def`` syntax, you can instead use the ``@asyncio.coroutine``
 decorator to convert a generator into a coroutine.
@@ -1284,6 +1289,14 @@ just need to be careful with it, as it could result in a ``KeyError``.
 Requiring ``get()`` everywhere would be too cumbersome. (Note that you
 are free to use ``get()`` with total TypedDicts as well.)
 
+Keys that aren't required are shown with a ``?`` in error messages:
+
+.. code-block:: python
+
+   # Revealed type is 'TypedDict('GuiOptions', {'language'?: builtins.str,
+   #                                            'color'?: builtins.str})'
+   reveal_type(options)
+
 Totality also affects structural compatibility. You can't use a partial
 TypedDict when a total one is expected. Also, a total typed dict is not
 valid when a partial one is expected.

mypy/checkexpr.py

@@ -188,8 +188,10 @@ def visit_call_expr(self, e: CallExpr, allow_none_return: bool = False) -> Type:
             return self.accept(e.analyzed, self.type_context[-1])
         if isinstance(e.callee, NameExpr) and isinstance(e.callee.node, TypeInfo) and \
                 e.callee.node.typeddict_type is not None:
-            return self.check_typeddict_call(e.callee.node.typeddict_type,
-                                             e.arg_kinds, e.arg_names, e.args, e)
+            # Use named fallback for better error messages.
+            typeddict_type = e.callee.node.typeddict_type.copy_modified(
+                fallback=Instance(e.callee.node, []))
+            return self.check_typeddict_call(typeddict_type, e.arg_kinds, e.arg_names, e.args, e)
         if isinstance(e.callee, NameExpr) and e.callee.name in ('isinstance', 'issubclass'):
             for typ in mypy.checker.flatten(e.args[1]):
                 if isinstance(typ, NameExpr):
@@ -303,7 +305,6 @@ def check_typeddict_call_with_kwargs(self, callee: TypedDictType,
                 context=context)
             return AnyType()
 
-        items = OrderedDict()  # type: OrderedDict[str, Type]
         for (item_name, item_expected_type) in callee.items.items():
             if item_name in kwargs:
                 item_value = kwargs[item_name]
@@ -312,12 +313,8 @@ def check_typeddict_call_with_kwargs(self, callee: TypedDictType,
                     msg=messages.INCOMPATIBLE_TYPES,
                     lvalue_name='TypedDict item "{}"'.format(item_name),
                     rvalue_name='expression')
-            items[item_name] = item_expected_type
 
-        mapping_value_type = join.join_type_list(list(items.values()))
-        fallback = self.chk.named_generic_type('typing.Mapping',
-                                               [self.chk.str_type(), mapping_value_type])
-        return TypedDictType(items, set(callee.required_keys), fallback)
+        return callee
 
     # Types and methods that can be used to infer partial types.
     item_args = {'builtins.list': ['append'],

mypy/types.py

@@ -1533,19 +1533,22 @@ def visit_tuple_type(self, t: TupleType) -> str:
         return 'Tuple[{}]'.format(s)
 
     def visit_typeddict_type(self, t: TypedDictType) -> str:
-        s = self.keywords_str(t.items.items())
-        if t.required_keys == set(t.items):
-            keys_str = ''
-        elif t.required_keys == set():
-            keys_str = ', _total=False'
-        else:
-            keys_str = ', _required_keys=[{}]'.format(', '.join(sorted(t.required_keys)))
+        def item_str(name: str, typ: str) -> str:
+            if name in t.required_keys:
+                return '{!r}: {}'.format(name, typ)
+            else:
+                return '{!r}?: {}'.format(name, typ)
+
+        s = '{' + ', '.join(item_str(name, typ.accept(self))
+                            for name, typ in t.items.items()) + '}'
+        prefix = ''
+        suffix = ''
         if t.fallback and t.fallback.type:
-            if s == '':
-                return 'TypedDict(_fallback={}{})'.format(t.fallback.accept(self), keys_str)
+            if t.fallback.type.fullname() != 'typing.Mapping':
+                prefix = repr(t.fallback.type.fullname()) + ', '
             else:
-                return 'TypedDict({}, _fallback={}{})'.format(s, t.fallback.accept(self), keys_str)
-        return 'TypedDict({})'.format(s)
+                suffix = ', fallback={}'.format(t.fallback.accept(self))
+        return 'TypedDict({}{}{})'.format(prefix, s, suffix)
 
     def visit_star_type(self, t: StarType) -> str:
         s = t.type.accept(self)
@@ -1580,15 +1583,6 @@ def list_str(self, a: List[Type]) -> str:
                 res.append(str(t))
         return ', '.join(res)
 
-    def keywords_str(self, a: Iterable[Tuple[str, Type]]) -> str:
-        """Convert keywords to strings (pretty-print types)
-        and join the results with commas.
-        """
-        return ', '.join([
-            '{}={}'.format(name, t.accept(self))
-            for (name, t) in a
-        ])
-
 
 class TypeQuery(SyntheticTypeVisitor[T]):
     """Visitor for performing queries of types.

test-data/unit/check-classes.test

@@ -3365,8 +3365,8 @@ x: TD
 x1 = TD({'x': []})
 y: NM
 y1 = NM(x=[])
-reveal_type(x) # E: Revealed type is 'TypedDict(x=builtins.list[Any], _fallback=__main__.TD)'
-reveal_type(x1) # E: Revealed type is 'TypedDict(x=builtins.list[Any], _fallback=typing.Mapping[builtins.str, builtins.list[Any]])'
+reveal_type(x) # E: Revealed type is 'TypedDict('__main__.TD', {'x': builtins.list[Any]})'
+reveal_type(x1) # E: Revealed type is 'TypedDict('__main__.TD', {'x': builtins.list[Any]})'
 reveal_type(y) # E: Revealed type is 'Tuple[builtins.list[Any], fallback=__main__.NM]'
 reveal_type(y1) # E: Revealed type is 'Tuple[builtins.list[Any], fallback=__main__.NM]'
 [builtins fixtures/dict.pyi]

test-data/unit/check-incremental.test

@@ -1901,11 +1901,11 @@ A = TypedDict('A', {'x': int, 'y': str})
 x: A
 [builtins fixtures/dict.pyi]
 [out1]
-main:2: error: Revealed type is 'TypedDict(x=builtins.int, y=builtins.str, _fallback=b.A)'
-main:4: error: Revealed type is 'TypedDict(x=builtins.int, y=builtins.str, _fallback=b.A)'
+main:2: error: Revealed type is 'TypedDict('b.A', {'x': builtins.int, 'y': builtins.str})'
+main:4: error: Revealed type is 'TypedDict('b.A', {'x': builtins.int, 'y': builtins.str})'
 [out2]
-main:2: error: Revealed type is 'TypedDict(x=builtins.int, y=builtins.str, _fallback=b.A)'
-main:4: error: Revealed type is 'TypedDict(x=builtins.int, y=builtins.str, _fallback=b.A)'
+main:2: error: Revealed type is 'TypedDict('b.A', {'x': builtins.int, 'y': builtins.str})'
+main:4: error: Revealed type is 'TypedDict('b.A', {'x': builtins.int, 'y': builtins.str})'
 
 [case testSerializeMetaclass]
 import b

test-data/unit/check-serialize.test

@@ -1018,12 +1018,12 @@ class C:
         self.c = A
 [builtins fixtures/dict.pyi]
 [out1]
-main:2: error: Revealed type is 'TypedDict(x=builtins.int, _fallback=typing.Mapping[builtins.str, builtins.int])'
-main:3: error: Revealed type is 'TypedDict(x=builtins.int, _fallback=ntcrash.C.A@4)'
+main:2: error: Revealed type is 'TypedDict('ntcrash.C.A@4', {'x': builtins.int})'
+main:3: error: Revealed type is 'TypedDict('ntcrash.C.A@4', {'x': builtins.int})'
 main:4: error: Revealed type is 'def () -> ntcrash.C.A@4'
 [out2]
-main:2: error: Revealed type is 'TypedDict(x=builtins.int, _fallback=typing.Mapping[builtins.str, builtins.int])'
-main:3: error: Revealed type is 'TypedDict(x=builtins.int, _fallback=ntcrash.C.A@4)'
+main:2: error: Revealed type is 'TypedDict('ntcrash.C.A@4', {'x': builtins.int})'
+main:3: error: Revealed type is 'TypedDict('ntcrash.C.A@4', {'x': builtins.int})'
 main:4: error: Revealed type is 'def () -> ntcrash.C.A@4'
 
 [case testSerializeNonTotalTypedDict]
@@ -1035,9 +1035,9 @@ D = TypedDict('D', {'x': int, 'y': str}, total=False)
 d: D
 [builtins fixtures/dict.pyi]
 [out1]
-main:2: error: Revealed type is 'TypedDict(x=builtins.int, y=builtins.str, _fallback=m.D, _total=False)'
+main:2: error: Revealed type is 'TypedDict('m.D', {'x'?: builtins.int, 'y'?: builtins.str})'
 [out2]
-main:2: error: Revealed type is 'TypedDict(x=builtins.int, y=builtins.str, _fallback=m.D, _total=False)'
+main:2: error: Revealed type is 'TypedDict('m.D', {'x'?: builtins.int, 'y'?: builtins.str})'
 
 --
 -- Modules