Ensure that regular classes get into the type-function memo.

There's a tricky bug where SerializationContext memoizes types based on their
type identity.  Its very important that any class that gets serialized that's
produced by a TypeFunction gets serialized by noting the type function and
its arguments rather than by serializing the class itself. Otherwise, depending
on whether you have called the TypeFunction or deserialized an instance of it,
the memo inside the serialization library can have different versions of the
type, which leads to all kinds of chaos.

This bug exposes another possible bug, where if a type function defines
two types internally, only one of them will be registered by the type
function memo. This is something we need to think about more deeply to really
fix. For now the rules for type functions are:

TypeFunction can either return a type that is primitive, a type that is
a compound of primitives (e.g. OneOf, NamedTuple, Tuple, ListOf, etc),
a type that is named by looking at __module__ and __name__ and finding
that type in that location, or by returning a single class type, inheriting
from object or Class respectively.

Author: braxtonmckee

typed_python/SerializationContext.py

@@ -488,10 +488,19 @@ def representationFor(self, inst):
             return (threading.RLock, ())
 
         if isinstance(inst, type):
-            # only serialize Class and Alternative objects from type functions.
+            # only serialize Class, Alternative, named tuple subclass, and actual python class
+            # objects from type functions.
+
             # otherwise, we'll end up changing how we serialize things like 'int',
             # if they ever make their way into a type function.
-            if getattr(inst, '__typed_python_category__', None) in ('Class', 'Alternative'):
+
+            # note that we need to ensure that type functions don't make two classes and
+            # return only one of them.
+            if (
+                getattr(inst, '__typed_python_category__', None) in ('Class', 'Alternative')
+                or not issubclass(inst, Type)
+                or (issubclass(inst, NamedTuple) and inst.__bases__[0] != NamedTuple)
+            ):
                 funcArgsAndKwargs = isTypeFunctionType(inst)
 
                 if funcArgsAndKwargs is not None:

typed_python/type_function_test.py

@@ -38,6 +38,18 @@ def f(self, x):
     return A
 
 
+@TypeFunction
+def RegularPythonClass(T):
+    class RegularPythonClass:
+        def __init__(self):
+            self.T = T
+
+        def methodName(self):
+            pass
+
+    return RegularPythonClass
+
+
 class TypeFunctionTest(unittest.TestCase):
     def test_basic(self):
         @TypeFunction
@@ -372,3 +384,8 @@ def __init__(self, y):
 
         assert issubclass(Temp(int), Temp)
         assert issubclass(Temp, TypeFunction)
+
+    def test_serialize_regular_class_output(self):
+        C = RegularPythonClass(int)
+
+        assert b'methodName' not in SerializationContext().withoutCompression().serialize(C)

typed_python/types_serialization_test.py

@@ -1888,6 +1888,11 @@ def test_serialize_methods_on_named_classes(self):
 
         self.assertIs(m1, m2)
 
+    def test_serialize_frozenset(self):
+        sc = SerializationContext()
+
+        assert sc.nameForObject(frozenset) is not None
+
     def test_serialize_entrypointed_modulelevel_functions(self):
         sc = SerializationContext()