Add test.

python · pablogsal · Sep 9, 2020 · Jul 10, 2020 · Jul 10, 2020 · Jul 15, 2020
commit 07b5c2934c63dead9641d83b749bdb4542bfd29b
diff --git a/Lib/test/test_isinstance.py b/Lib/test/test_isinstance.py
@@ -4,6 +4,7 @@
 
 import unittest
 import sys
+import typing
 
 
 
@@ -208,6 +209,15 @@ def test_isinstance_abstract(self):
         self.assertEqual(False, isinstance(AbstractChild(), Super))
         self.assertEqual(False, isinstance(AbstractChild(), Child))
 
+    def test_isinstance_with_or_union(self):
+        self.assertEqual(True, isinstance(AbstractChild(), AbstractChild | int))
+        self.assertEqual(False, isinstance(None, str | int))
+        self.assertEqual(True, isinstance(3, str | int))
+        self.assertEqual(True, isinstance("", str | int))
+        self.assertEqual(True, isinstance([], typing.List | typing.Tuple))
+        self.assertEqual(True, isinstance(2, typing.List | int))
+        self.assertEqual(False, isinstance(2, typing.List | typing.Tuple))
+
     def test_subclass_normal(self):
         # normal classes
         self.assertEqual(True, issubclass(Super, Super))
@@ -217,6 +227,8 @@ def test_subclass_normal(self):
         self.assertEqual(True, issubclass(Child, Child))
         self.assertEqual(True, issubclass(Child, Super))
         self.assertEqual(False, issubclass(Child, AbstractSuper))
+        self.assertEqual(True, issubclass(typing.List, typing.List|typing.Tuple))
+        self.assertEqual(False, issubclass(int, typing.List|typing.Tuple))
 
     def test_subclass_abstract(self):
         # abstract classes
@@ -251,6 +263,10 @@ def test_isinstance_recursion_limit(self):
         # blown
         self.assertRaises(RecursionError, blowstack, isinstance, '', str)
 
+    # def test_subclass_with_union(self):
+    #     self.assertEqual(True, issubclass(int, int | float | int))
+    #     self.assertEqual(True, issubclass(str, str | Child | str))
+
     def test_issubclass_refcount_handling(self):
         # bpo-39382: abstract_issubclass() didn't hold item reference while
         # peeking in the bases tuple, in the single inheritance case.

diff --git a/Lib/test/test_types.py b/Lib/test/test_types.py
@@ -2,13 +2,15 @@
 
 from test.support import run_with_locale
 import collections.abc
+from collections import namedtuple
 import inspect
 import pickle
 import locale
 import sys
 import types
 import unittest.mock
 import weakref
+import typing
 
 class TypesTests(unittest.TestCase):
 
@@ -598,7 +600,91 @@ def test_method_descriptor_types(self):
         self.assertIsInstance(int.from_bytes, types.BuiltinMethodType)
         self.assertIsInstance(int.__new__, types.BuiltinMethodType)
 
-
+    def test_or_types_operator(self):
+        self.assertEqual(int | str, typing.Union[int, str])
+        self.assertEqual(int | None, typing.Union[int, None])
+        self.assertEqual(None | int, typing.Union[int, None])
+        self.assertEqual(int | str | list, typing.Union[int, str, list])
+        self.assertEqual(int | (str | list), typing.Union[int, str, list])
+        self.assertEqual(typing.List | typing.Tuple, typing.Union[typing.List, typing.Tuple])
+        self.assertEqual(typing.List[int] | typing.Tuple[int], typing.Union[typing.List[int], typing.Tuple[int]])
+        self.assertEqual(typing.List[int] | None, typing.Union[typing.List[int], None])
+        self.assertEqual(None | typing.List[int], typing.Union[None, typing.List[int]])
+        self.assertEqual(
+            BaseException | \
+            bool | \
+            bytes | \
+            complex | \
+            float | \
+            int | \
+            list | \
+            map | \
+            set,
+            typing.Union[
+                BaseException,
+                bool,
+                bytes,
+                complex,
+                float,
+                int,
+                list,
+                map,
+                set,
+            ])
+        with self.assertRaises(TypeError):
+            int | 3
+        with self.assertRaises(TypeError):
+            3 | int
+
+    def test_or_type_operator_with_TypeVar(self):
+        TV = typing.TypeVar('T')
+        assert TV | str == typing.Union[TV, str]
+        assert str | TV == typing.Union[str, TV]
+
+    def test_or_type_operator_with_forward(self):
+        T = typing.TypeVar('T')
+        ForwardAfter = T | 'Forward'
+        ForwardBefore = 'Forward' | T
+        def forward_after(x: ForwardAfter[int]) -> None: ...
+        def forward_before(x: ForwardBefore[int]) -> None: ...
+        assert typing.get_args(typing.get_type_hints(forward_after)['x']) == (int, Forward)
+        assert typing.get_args(typing.get_type_hints(forward_before)['x']) == (int, Forward)
+
+    def test_or_type_operator_with_Protocol(self):
+        class Proto(typing.Protocol):
+            def meth(self) -> int:
+                ...
+        assert Proto | str == typing.Union[Proto, str]
+
+    def test_or_type_operator_with_Alias(self):
+        assert list | str == typing.Union[list, str]
+        assert typing.List | str == typing.Union[typing.List, str]
+
+    def test_or_type_operator_with_NamedTuple(self):
+        NT=namedtuple('A', ['B', 'C', 'D'])
+        assert NT | str == typing.Union[NT,str]
+
+    def test_or_type_operator_with_TypedDict(self):
+        class Point2D(typing.TypedDict):
+            x: int
+            y: int
+            label: str
+        assert Point2D | str == typing.Union[Point2D, str]
+
+    def test_or_type_operator_with_NewType(self):
+        UserId = typing.NewType('UserId', int)
+        assert UserId | str == typing.Union[UserId, str]
+
+    def test_or_type_operator_with_IO(self):
+        assert typing.IO | str == typing.Union[typing.IO, str]
+
+class Forward: ...
+# T = typing.TypeVar('T')
+# ForwardAfter = T | 'Forward'
+# ForwardBefore = 'Forward' | T
+# def forward_after(x: ForwardAfter[int]) -> None: ...
+# def forward_before(x: ForwardBefore[int]) -> None: ...
+# class Forward: ...
 class MappingProxyTests(unittest.TestCase):
     mappingproxy = types.MappingProxyType
 

diff --git a/Lib/test/test_typing.py b/Lib/test/test_typing.py
@@ -244,8 +244,8 @@ def test_subclass_error(self):
             issubclass(int, Union)
         with self.assertRaises(TypeError):
             issubclass(Union, int)
-        with self.assertRaises(TypeError):
-            issubclass(int, Union[int, str])
+        # with self.assertRaises(TypeError):
+        #     issubclass(int, Union[int, str])
         with self.assertRaises(TypeError):
             issubclass(Union[int, str], int)
 
@@ -347,9 +347,9 @@ def test_empty(self):
         with self.assertRaises(TypeError):
             Union[()]
 
-    def test_union_instance_type_error(self):
-        with self.assertRaises(TypeError):
-            isinstance(42, Union[int, str])
+    # def test_union_instance_type_error(self):
+    #     with self.assertRaises(TypeError):
+    #         isinstance(42, Union[int, str])
 
     def test_no_eval_union(self):
         u = Union[int, str]

diff --git a/Lib/typing.py b/Lib/typing.py
@@ -578,6 +578,13 @@ def __init__(self, name, *constraints, bound=None,
         if def_mod != 'typing':
             self.__module__ = def_mod
 
+    def __or__(self,right):
+        return Union[self,right]
+    def __ror__(self,right):
+        return Union[self,right]
+    def __invert__(self):
+        return Union[self,None]
+
     def __repr__(self):
         if self.__covariant__:
             prefix = '+'
@@ -685,6 +692,13 @@ def __eq__(self, other):
     def __hash__(self):
         return hash((self.__origin__, self.__args__))
 
+    def __or__(self,right):
+        return Union[self,right]
+    def __ror__(self,right):
+        return Union[self,right]
+    def __invert__(self):
+        return Union[self,None]
+
     @_tp_cache
     def __getitem__(self, params):
         if self.__origin__ in (Generic, Protocol):

diff --git a/Makefile.pre.in b/Makefile.pre.in
@@ -429,6 +429,7 @@ OBJECT_OBJS=	\
 		Objects/typeobject.o \
 		Objects/unicodeobject.o \
 		Objects/unicodectype.o \
+		Objects/unionobject.o \
 		Objects/weakrefobject.o
 
 ##########################################################################

diff --git a/Objects/abstract.c b/Objects/abstract.c
@@ -2469,6 +2469,40 @@ abstract_issubclass(PyObject *derived, PyObject *cls)
     }
 }
 
+static PyObject*
+union_to_tuple(PyObject* cls) {
+    //printf("union_to_tuple");
+    if (!strcmp(Py_TYPE(cls)->tp_name,"_GenericAlias")) {
+        PyObject* origin = PyObject_GetAttrString(cls, "__origin__");
+        //printf("origin = %p\n",origin);
+        if (origin == NULL) {
+            printf("origin == NULL, return cls");
+            return cls;
+        }
+        //printf("X origin = %s\n",Py_TYPE(cls)->tp_name);
+        if (PyObject_HasAttrString(origin, "_name")) {
+            PyObject* name = PyObject_GetAttrString(origin, "_name");
+            if (name==NULL) {
+                printf("_name = NULL\n");
+                Py_DECREF(origin);
+                return cls;
+            }
+            //printf("name = %s\n",Py_TYPE(name)->tp_name);
+            const char* data = (char*)PyUnicode_1BYTE_DATA(name);
+            //printf("DATA=%s\n",data);
+            if (data != NULL && !strcmp(data,"Union")) {
+                PyObject* new_cls = PyObject_GetAttrString(cls, "__args__");
+                if (new_cls != NULL) {
+                    cls = new_cls;
+                }
+            }
+            Py_DECREF(name);
+        }
+        Py_DECREF(origin);
+    }
+    return cls;
+}
+
 static int
 check_class(PyObject *cls, const char *error)
 {
@@ -2511,7 +2545,7 @@ object_isinstance(PyObject *inst, PyObject *cls)
     }
     else {
         if (!check_class(cls,
-            "isinstance() arg 2 must be a type or tuple of types"))
+            "isinstance() arg 2 must be a type, a tuple of types or union"))
             return -1;
         retval = _PyObject_LookupAttrId(inst, &PyId___class__, &icls);
         if (icls != NULL) {
@@ -2537,7 +2571,7 @@ object_recursive_isinstance(PyThreadState *tstate, PyObject *inst, PyObject *cls
     if (PyType_CheckExact(cls)) {
         return object_isinstance(inst, cls);
     }
-
+    cls = union_to_tuple(cls);
     if (PyTuple_Check(cls)) {
         /* Not a general sequence -- that opens up the road to
            recursion and stack overflow. */
@@ -2626,6 +2660,8 @@ object_issubclass(PyThreadState *tstate, PyObject *derived, PyObject *cls)
         return recursive_issubclass(derived, cls);
     }
 
+    cls = union_to_tuple(cls);
+
     if (PyTuple_Check(cls)) {
 
         if (_Py_EnterRecursiveCall(tstate, " in __subclasscheck__")) {

diff --git a/Objects/typeobject.c b/Objects/typeobject.c
@@ -3741,6 +3741,47 @@ type_is_gc(PyTypeObject *type)
     return type->tp_flags & Py_TPFLAGS_HEAPTYPE;
 }
 
+static PyObject *
+type_or(PyTypeObject* self, PyObject* param) {
+    PyObject* typing=PyImport_ImportModule("typing");
+    PyTypeObject* genericAlias = (PyTypeObject*)PyObject_GetAttrString(typing,"_GenericAlias");
+    PyTypeObject* typeVar = (PyTypeObject*)PyObject_GetAttrString(typing,"TypeVar");
+
+    // Check param is a PyType or GenericAlias
+    if ((param == NULL) ||
+        (
+         (param != Py_None) &&
+         ! PyType_IsSubtype(genericAlias, Py_TYPE(param)) &&
+         ! PyType_IsSubtype(typeVar, Py_TYPE(param)) &&
+         (PyObject_IsInstance(param, (PyObject *) &PyType_Type) != 1)
+        )
+            ) {
+        PyErr_SetString(PyExc_TypeError, "'type' expected");
+        Py_DECREF(typeVar);
+        Py_DECREF(genericAlias);
+        Py_DECREF(typing);
+        return NULL;
+    }
+
+    // 1. Create a tuple with types
+    PyObject *tuple=PyTuple_Pack(2,self, param);
+    // 2. Create Union with tuple
+    PyObject* unionType = PyObject_GetAttrString(typing,"Union");
+    PyObject *newUnion=PyObject_GetItem(unionType, tuple);
+    // 3. Clean memory
+    Py_DECREF(typeVar);
+    Py_DECREF(genericAlias);
+    Py_DECREF(typing);
+    Py_DECREF(unionType);
+    Py_DECREF(tuple);
+    // 4. Return instance
+    return newUnion;
+}
+
+static PyNumberMethods type_as_number = {
+        .nb_or = (binaryfunc)type_or, // Add __or__ function
+};
+
 PyTypeObject PyType_Type = {
     PyVarObject_HEAD_INIT(&PyType_Type, 0)
     "type",                                     /* tp_name */
@@ -3752,7 +3793,7 @@ PyTypeObject PyType_Type = {
     0,                                          /* tp_setattr */
     0,                                          /* tp_as_async */
     (reprfunc)type_repr,                        /* tp_repr */
-    0,                                          /* tp_as_number */
+    &type_as_number,                            /* tp_as_number */
     0,                                          /* tp_as_sequence */
     0,                                          /* tp_as_mapping */
     0,                                          /* tp_hash */

diff --git a/PCbuild/pythoncore.vcxproj b/PCbuild/pythoncore.vcxproj
@@ -412,6 +412,7 @@
     <ClCompile Include="..\Objects\typeobject.c" />
     <ClCompile Include="..\Objects\unicodectype.c" />
     <ClCompile Include="..\Objects\unicodeobject.c" />
+    <ClCompile Include="..\Objects\unionobject.c" />
     <ClCompile Include="..\Objects\weakrefobject.c" />
     <ClCompile Include="..\Parser\myreadline.c" />
     <ClCompile Include="..\Parser\tokenizer.c" />