Implement tests.

Also:
* Fix support for using dict(...) in TypedDict instance constructor.
* Allow instantiation of empty TypedDict.
* Disallow underscore prefix on TypedDict item names.
* Fix TypedDict subtyping.

Author: davidfstr

mypy/checkexpr.py

@@ -192,38 +192,56 @@ def check_typeddict_call(self, callee: TypedDictType,
             item_args = args
             return self.check_typeddict_call_with_kwargs(
                 callee, OrderedDict(zip(item_names, item_args)), context)
-        elif len(args) == 1 and arg_kinds[0] == ARG_POS and isinstance(args[0], DictExpr):
-            # ex: Point({'x': 42, 'y': 1337})
-            # ex: Point(dict(x=42, y=1337))
-            kwargs = args[0]
-            item_name_exprs = [item[0] for item in kwargs.items]
-            item_args = [item[1] for item in kwargs.items]
-
-            item_names = []  # List[str]
-            for item_name_expr in item_name_exprs:
-                if not isinstance(item_name_expr, StrExpr):
-                    self.chk.fail(messages.TYPEDDICT_KEY_MUST_BE_STRING_LITERAL, item_name_expr)
-                    return AnyType()
-                item_names.append(item_name_expr.value)
 
+        if len(args) == 1 and arg_kinds[0] == ARG_POS:
+            unique_arg = args[0]
+            if isinstance(unique_arg, DictExpr):
+                # ex: Point({'x': 42, 'y': 1337})
+                return self.check_typeddict_call_with_dict(callee, unique_arg, context)
+            if isinstance(unique_arg, CallExpr) and isinstance(unique_arg.analyzed, DictExpr):
+                # ex: Point(dict(x=42, y=1337))
+                return self.check_typeddict_call_with_dict(callee, unique_arg.analyzed, context)
+        
+        if len(args) == 0:
+            # ex: EmptyDict()
             return self.check_typeddict_call_with_kwargs(
-                callee, OrderedDict(zip(item_names, item_args)), context)
-        else:
-            self.chk.fail(messages.INVALID_TYPEDDICT_ARGS, context)
-            return AnyType()
+                callee, OrderedDict(), context)
+
+        self.chk.fail(messages.INVALID_TYPEDDICT_ARGS, context)
+        return AnyType()
+    
+    def check_typeddict_call_with_dict(self, callee: TypedDictType,
+                                       kwargs: DictExpr,
+                                       context: Context) -> Type:
+        item_name_exprs = [item[0] for item in kwargs.items]
+        item_args = [item[1] for item in kwargs.items]
+
+        item_names = []  # List[str]
+        for item_name_expr in item_name_exprs:
+            if not isinstance(item_name_expr, StrExpr):
+                self.chk.fail(messages.TYPEDDICT_ITEM_NAME_MUST_BE_STRING_LITERAL, item_name_expr)
+                return AnyType()
+            item_names.append(item_name_expr.value)
+
+        return self.check_typeddict_call_with_kwargs(
+            callee, OrderedDict(zip(item_names, item_args)), context)
 
     def check_typeddict_call_with_kwargs(self, callee: TypedDictType,
                                          kwargs: 'OrderedDict[str, Expression]',
                                          context: Context) -> Type:
         if callee.items.keys() != kwargs.keys():
+            callee_item_names = callee.items.keys()
+            kwargs_item_names = kwargs.keys()
+            missing_item_names = [k for k in callee_item_names if k not in kwargs_item_names]
+            extra_item_names = [k for k in kwargs_item_names if k not in callee_item_names]
+            
             self.chk.fail(
-                'Expected keys {} but found {}. Missing {}. Extra {}.'.format(
-                    list(callee.items.keys()),
-                    list(kwargs.keys()),
-                    # TODO: Ensure order is preserved
-                    callee.items.keys() - kwargs.keys(),
-                    # TODO: Ensure order is preserved
-                    kwargs.keys() - callee.items.keys()),
+                'Expected items {} but found {}. Missing {}. Extra {}.'.format(
+                    list(callee_item_names),
+                    list(kwargs_item_names),
+                    missing_item_names,
+                    extra_item_names
+                ),
                 context)
             return AnyType()
 

mypy/messages.py

@@ -72,9 +72,9 @@
     'Keyword argument only valid with "str" key type in call to "dict"'
 ALL_MUST_BE_SEQ_STR = 'Type of __all__ must be {}, not {}'
 INVALID_TYPEDDICT_ARGS = \
-    'Expected keyword arguments or dictionary literal in TypedDict constructor'
-TYPEDDICT_KEY_MUST_BE_STRING_LITERAL = \
-    'Expected key in TypedDict constructor to be string literal'
+    'Expected keyword arguments, {...}, or dict(...) in TypedDict constructor'
+TYPEDDICT_ITEM_NAME_MUST_BE_STRING_LITERAL = \
+    'Expected TypedDict item name to be string literal'
 
 
 class MessageBuilder:

mypy/semanal.py

@@ -1717,7 +1717,7 @@ def parse_namedtuple_args(self, call: CallExpr,
             types = [AnyType() for _ in items]
         underscore = [item for item in items if item.startswith('_')]
         if underscore:
-            self.fail("namedtuple() Field names cannot start with an underscore: "
+            self.fail("namedtuple() field names cannot start with an underscore: "
                       + ', '.join(underscore), call)
         return items, types, ok
 
@@ -1905,6 +1905,10 @@ def parse_typeddict_args(self, call: CallExpr,
                 "TypedDict() expects a dictionary literal as the second argument", call)
         dictexpr = args[1]
         items, types, ok = self.parse_typeddict_fields_with_types(dictexpr.items, call)
+        underscore = [item for item in items if item.startswith('_')]
+        if underscore:
+            self.fail("TypedDict() item names cannot start with an underscore: "
+                      + ', '.join(underscore), call)
         return items, types, ok
 
     def parse_typeddict_fields_with_types(self, dict_items: List[Tuple[Expression, Expression]],

mypy/subtypes.py

@@ -125,6 +125,10 @@ def visit_instance(self, left: Instance) -> bool:
                                                  self.right,
                                                  self.check_type_parameter):
                 return True
+            if left.type.typeddict_type is not None and is_subtype(left.type.typeddict_type,
+                                                                   self.right,
+                                                                   self.check_type_parameter):
+                return True
             rname = right.type.fullname()
             if not left.type.has_base(rname) and rname != 'builtins.object':
                 return False
@@ -189,14 +193,16 @@ def visit_tuple_type(self, left: TupleType) -> bool:
     def visit_typeddict_type(self, left: TypedDictType) -> bool:
         right = self.right
         if isinstance(right, Instance):
+            if right.type.typeddict_type is not None:
+                return is_subtype(left, right.type.typeddict_type, self.check_type_parameter)
             return is_subtype(left.fallback, right, self.check_type_parameter)
         elif isinstance(right, TypedDictType):
             if not left.names_are_wider_than(right):
                 return False
             for (_, l, r) in left.zip(right):
-                if not is_subtype(l, r, self.check_type_parameter):
+                if not is_subtype(r, l, self.check_type_parameter):
                     return False
-            if not is_subtype(left.fallback, right.fallback, self.check_type_parameter):
+            if not is_subtype(right.fallback, left.fallback, self.check_type_parameter):
                 return False
             return True
         else:

mypy/test/testcheck.py

@@ -54,6 +54,7 @@
     'check-isinstance.test',
     'check-lists.test',
     'check-namedtuple.test',
+    'check-typeddict.test',
     'check-type-aliases.test',
     'check-ignore.test',
     'check-type-promotion.test',

mypy/types.py

@@ -1366,7 +1366,10 @@ def visit_tuple_type(self, t: TupleType) -> str:
     def visit_typeddict_type(self, t: TypedDictType) -> str:
         s = self.keywords_str(t.items.items())
         if t.fallback and t.fallback.type:
-            return 'TypedDict({}, _fallback={})'.format(s, t.fallback.accept(self))
+            if s == '':
+                return 'TypedDict(_fallback={})'.format(t.fallback.accept(self))
+            else:
+                return 'TypedDict({}, _fallback={})'.format(s, t.fallback.accept(self))
         return 'TypedDict({})'.format(s)
 
     def visit_star_type(self, t: StarType) -> str:

test-data/unit/check-namedtuple.test

@@ -23,7 +23,7 @@ x[2] # E: Tuple index out of range
 [case testNamedTupleNoUnderscoreFields]
 from collections import namedtuple
 
-X = namedtuple('X', 'x, _y, _z')  # E: namedtuple() Field names cannot start with an underscore: _y, _z
+X = namedtuple('X', 'x, _y, _z')  # E: namedtuple() field names cannot start with an underscore: _y, _z
 
 [case testNamedTupleAccessingAttributes]
 from collections import namedtuple