bpo-44863: In TypedDict allow inherit from Generic and preserve bases

Lib/test/_typed_dict_helper.py

@@ -10,9 +10,14 @@ class Bar(_typed_dict_helper.Foo, total=False):
 
 from __future__ import annotations
 
-from typing import Optional, TypedDict
+from typing import Generic, Optional, TypedDict, TypeVar
 
 OptionalIntType = Optional[int]
 
 class Foo(TypedDict):
     a: OptionalIntType
+
+T = TypeVar("T")
+
+class FooGeneric(TypedDict, Generic[T]):
+    a: Optional[T]

Lib/test/test_typing.py

@@ -2947,9 +2947,16 @@ class Point2D(TypedDict):
     x: int
     y: int
 
+class Point2DGeneric(Generic[T], TypedDict):
+    a: T
+    b: T
+
 class Bar(_typed_dict_helper.Foo, total=False):
     b: int
 
+class BarGeneric(_typed_dict_helper.FooGeneric[T], total=False):
+    b: int
+
 class LabelPoint2D(Point2D, Label): ...
 
 class Options(TypedDict, total=False):
@@ -4157,6 +4164,17 @@ def test_pickle(self):
             EmpDnew = pickle.loads(ZZ)
             self.assertEqual(EmpDnew({'name': 'jane', 'id': 37}), jane)
 
+    def test_pickle_generic(self):
+        point = Point2DGeneric(a=5.0, b=3.0)
+        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+            z = pickle.dumps(point, proto)
+            point2 = pickle.loads(z)
+            self.assertEqual(point2, point)
+            self.assertEqual(point2, {'a': 5.0, 'b': 3.0})
+            ZZ = pickle.dumps(Point2DGeneric, proto)
+            Point2DGenericNew = pickle.loads(ZZ)
+            self.assertEqual(Point2DGenericNew({'a': 5.0, 'b': 3.0}), point)
+
     def test_optional(self):
         EmpD = TypedDict('EmpD', name=str, id=int)
 
@@ -4228,6 +4246,65 @@ def test_get_type_hints(self):
             {'a': typing.Optional[int], 'b': int}
         )
 
+    def test_get_type_hints_generic(self):
+        self.assertEqual(
+            get_type_hints(BarGeneric[int]), 
+            {'a': typing.Optional[T], 'b': int}
+        )
+
+    def test_generic_inheritance(self):
+        class A(TypedDict, Generic[T]):
+            a: T
+
+        self.assertEqual(A.__bases__, (Generic, dict,))
+        self.assertEqual(A.__parameters__, (T,))
+        self.assertEqual(A[str].__parameters__, ())
+        self.assertEqual(A[str].__args__, (str,))
+
+        class B(A[KT], total=False):
+            b: KT
+
+        self.assertEqual(B.__bases__, (Generic, dict,))
+        self.assertEqual(B.__total__, False)
+        self.assertEqual(B.__parameters__, (KT, ))
+        self.assertEqual(B.__optional_keys__, frozenset(['b']))
+        self.assertEqual(B.__required_keys__, frozenset(['a']))
+
+        self.assertEqual(B[str].__parameters__, ())
+        self.assertEqual(B[str].__args__, (str,))
+        self.assertEqual(B[str].__optional_keys__, frozenset(['b']))
+        self.assertEqual(B[str].__required_keys__, frozenset(['a']))
+
+        class C(B[int]):
+            c: int
+
+        self.assertEqual(C.__bases__, (dict,))
+        self.assertEqual(C.__total__, True)
+        self.assertEqual(C.__optional_keys__, frozenset(['b']))
+        self.assertEqual(C.__required_keys__, frozenset(['a', 'c']))
+        assert C.__annotations__ == {
+            'a': T,
+            'b': KT,
+            'c': int,
+        }
+        with self.assertRaises(TypeError):
+            C[str]
+
+        class WithImplicitAny(B):
+            c: int
+
+        self.assertEqual(WithImplicitAny.__bases__, (dict,))
+        self.assertEqual(WithImplicitAny.__total__, True)
+        self.assertEqual(WithImplicitAny.__optional_keys__, frozenset(['b']))
+        self.assertEqual(WithImplicitAny.__required_keys__, frozenset(['a', 'c']))
+        assert WithImplicitAny.__annotations__ == {
+            'a': T,
+            'b': KT,
+            'c': int,
+        }
+        with self.assertRaises(TypeError):
+            WithImplicitAny[str]
+
 
 class IOTests(BaseTestCase):
 

Lib/typing.py

@@ -2252,10 +2252,12 @@ def __new__(cls, name, bases, ns, total=True):
         Subclasses and instances of TypedDict return actual dictionaries.
         """
         for base in bases:
-            if type(base) is not _TypedDictMeta:
+            if not (type(base) is _TypedDictMeta or base is Generic):
                 raise TypeError('cannot inherit from both a TypedDict type '
                                 'and a non-TypedDict base class')
-        tp_dict = type.__new__(_TypedDictMeta, name, (dict,), ns)
+
+        generic_base = (Generic,) if _collect_type_vars(ns.get("__orig_bases__", ())) else ()
+        tp_dict = type.__new__(_TypedDictMeta, name, (*generic_base, dict,), ns)
 
         annotations = {}
         own_annotations = ns.get('__annotations__', {})
@@ -2294,6 +2296,15 @@ def __subclasscheck__(cls, other):
 
     __instancecheck__ = __subclasscheck__
 
+    def __getitem__(cls, params):
+        if not isinstance(params, tuple):
+            params = (params,)
+        msg = "Parameters to generic types must be types."
+        params = tuple(_type_check(p, msg) for p in params)
+        nparams = len(cls.__dict__.get("__parameters__", ()))
+        _check_generic(cls, params, nparams)
+        return types.GenericAlias(cls, params)
+
 
 def TypedDict(typename, fields=None, /, *, total=True, **kwargs):
     """A simple typed namespace. At runtime it is equivalent to a plain dict.

Misc/NEWS.d/next/Library/2021-09-03-07-56-48.bpo-44863.udgz95.rst

@@ -0,0 +1,4 @@
+Allow ``TypedDict`` subclasses to also include ``Generic`` as a base class
+in class based syntax. Thereby allowing the user to define a ``Generic
+TypedDict``, just like a user defined ``Generic class`` but with
+``TypedDict`` semantics.