[Python-checkins] bpo-41428: Implementation for PEP 604 (GH-21515)
Maggie Moss
webhook-mailer at python.org
Tue Sep 15 09:45:18 EDT 2020
https://github.com/python/cpython/commit/1b4552c5e8e925f24c15f707050f22c977171125
commit: 1b4552c5e8e925f24c15f707050f22c977171125
branch: master
author: Maggie Moss <MaggieMoss at users.noreply.github.com>
committer: GitHub <noreply at github.com>
date: 2020-09-09T21:23:24+01:00
summary:
bpo-41428: Implementation for PEP 604 (GH-21515)
See https://www.python.org/dev/peps/pep-0604/ for more information.
Co-authored-by: Pablo Galindo <pablogsal at gmail.com>
files:
A Include/internal/pycore_unionobject.h
A Misc/NEWS.d/next/Core and Builtins/2020-07-28-22-43-27.bpo-41428.FM6xsI.rst
A Objects/unionobject.c
M Lib/test/test_isinstance.py
M Lib/test/test_types.py
M Lib/test/test_typing.py
M Lib/types.py
M Lib/typing.py
M Makefile.pre.in
M Objects/abstract.c
M Objects/typeobject.c
M PCbuild/pythoncore.vcxproj
M PCbuild/pythoncore.vcxproj.filters
diff --git a/Include/internal/pycore_unionobject.h b/Include/internal/pycore_unionobject.h
new file mode 100644
index 0000000000000..fa8ba6ed944c1
--- /dev/null
+++ b/Include/internal/pycore_unionobject.h
@@ -0,0 +1,17 @@
+#ifndef Py_INTERNAL_UNIONOBJECT_H
+#define Py_INTERNAL_UNIONOBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef Py_BUILD_CORE
+# error "this header requires Py_BUILD_CORE define"
+#endif
+
+PyAPI_FUNC(PyObject *) _Py_Union(PyObject *args);
+PyAPI_DATA(PyTypeObject) _Py_UnionType;
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_INTERNAL_UNIONOBJECT_H */
diff --git a/Lib/test/test_isinstance.py b/Lib/test/test_isinstance.py
index 53639e984e48a..91e79c295481d 100644
--- 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,25 @@ 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.assertTrue(isinstance(Super(), Super | int))
+ self.assertFalse(isinstance(None, str | int))
+ self.assertTrue(isinstance(3, str | int))
+ self.assertTrue(isinstance("", str | int))
+ self.assertTrue(isinstance([], typing.List | typing.Tuple))
+ self.assertTrue(isinstance(2, typing.List | int))
+ self.assertFalse(isinstance(2, typing.List | typing.Tuple))
+ self.assertTrue(isinstance(None, int | None))
+ self.assertFalse(isinstance(3.14, int | str))
+ with self.assertRaises(TypeError):
+ isinstance(2, list[int])
+ with self.assertRaises(TypeError):
+ isinstance(2, list[int] | int)
+ with self.assertRaises(TypeError):
+ isinstance(2, int | str | list[int] | float)
+
+
+
def test_subclass_normal(self):
# normal classes
self.assertEqual(True, issubclass(Super, Super))
@@ -217,6 +237,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.assertTrue(issubclass(typing.List, typing.List|typing.Tuple))
+ self.assertFalse(issubclass(int, typing.List|typing.Tuple))
def test_subclass_abstract(self):
# abstract classes
@@ -251,6 +273,16 @@ def test_isinstance_recursion_limit(self):
# blown
self.assertRaises(RecursionError, blowstack, isinstance, '', str)
+ def test_subclass_with_union(self):
+ self.assertTrue(issubclass(int, int | float | int))
+ self.assertTrue(issubclass(str, str | Child | str))
+ self.assertFalse(issubclass(dict, float|str))
+ self.assertFalse(issubclass(object, float|str))
+ with self.assertRaises(TypeError):
+ issubclass(2, Child | Super)
+ with self.assertRaises(TypeError):
+ issubclass(int, list[int] | Child)
+
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
index 49dc5bf40e3ed..f499fb9c8c51a 100644
--- a/Lib/test/test_types.py
+++ b/Lib/test/test_types.py
@@ -2,6 +2,7 @@
from test.support import run_with_locale
import collections.abc
+from collections import namedtuple
import inspect
import pickle
import locale
@@ -9,6 +10,12 @@
import types
import unittest.mock
import weakref
+import typing
+
+class Example:
+ pass
+
+class Forward: ...
class TypesTests(unittest.TestCase):
@@ -598,6 +605,113 @@ 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.assertNotEqual(int | list, typing.Union[int, str])
+ self.assertEqual(str | int, 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(str | (int | 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(str | float | int | complex | int, (int | str) | (float | complex))
+ self.assertEqual(typing.Union[str, int, typing.List[int]], str | int | typing.List[int])
+ self.assertEqual(int | int, 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
+ with self.assertRaises(TypeError):
+ Example() | int
+ with self.assertRaises(TypeError):
+ (int | str) < typing.Union[str, int]
+ with self.assertRaises(TypeError):
+ (int | str) < (int | bool)
+ with self.assertRaises(TypeError):
+ (int | str) <= (int | str)
+ with self.assertRaises(TypeError):
+ # Check that we don't crash if typing.Union does not have a tuple in __args__
+ x = typing.Union[str, int]
+ x.__args__ = [str, int]
+ (int | str ) == x
+
+ 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]
+
+ def test_or_type_operator_with_SpecialForm(self):
+ assert typing.Any | str == typing.Union[typing.Any, str]
+ assert typing.NoReturn | str == typing.Union[typing.NoReturn, str]
+ assert typing.Optional[int] | str == typing.Union[typing.Optional[int], str]
+ assert typing.Optional[int] | str == typing.Union[int, str, None]
+ assert typing.Union[int, bool] | str == typing.Union[int, bool, str]
+
+ def test_or_type_repr(self):
+ assert repr(int | None) == "int | None"
+ assert repr(int | typing.GenericAlias(list, int)) == "int | list[int]"
class MappingProxyTests(unittest.TestCase):
mappingproxy = types.MappingProxyType
diff --git a/Lib/test/test_typing.py b/Lib/test/test_typing.py
index b3be99141afca..05140fc61b9bf 100644
--- a/Lib/test/test_typing.py
+++ b/Lib/test/test_typing.py
@@ -244,8 +244,6 @@ 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(Union[int, str], int)
@@ -347,10 +345,6 @@ 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_no_eval_union(self):
u = Union[int, str]
def f(x: u): ...
diff --git a/Lib/types.py b/Lib/types.py
index ad2020ec69b63..9642e7212caac 100644
--- a/Lib/types.py
+++ b/Lib/types.py
@@ -294,6 +294,7 @@ def wrapped(*args, **kwargs):
GenericAlias = type(list[int])
+Union = type(int | str)
__all__ = [n for n in globals() if n[:1] != '_']
diff --git a/Lib/typing.py b/Lib/typing.py
index 2899a0213d434..2aedbeb852a71 100644
--- a/Lib/typing.py
+++ b/Lib/typing.py
@@ -117,7 +117,6 @@
# namespace, but excluded from __all__ because they might stomp on
# legitimate imports of those modules.
-
def _type_check(arg, msg, is_argument=True):
"""Check that the argument is a type, and return it (internal helper).
@@ -145,7 +144,7 @@ def _type_check(arg, msg, is_argument=True):
return arg
if isinstance(arg, _SpecialForm) or arg in (Generic, Protocol):
raise TypeError(f"Plain {arg} is not valid as type argument")
- if isinstance(arg, (type, TypeVar, ForwardRef)):
+ if isinstance(arg, (type, TypeVar, ForwardRef, types.Union)):
return arg
if not callable(arg):
raise TypeError(f"{msg} Got {arg!r:.100}.")
@@ -205,7 +204,7 @@ def _remove_dups_flatten(parameters):
# Flatten out Union[Union[...], ...].
params = []
for p in parameters:
- if isinstance(p, _UnionGenericAlias):
+ if isinstance(p, (_UnionGenericAlias, types.Union)):
params.extend(p.__args__)
elif isinstance(p, tuple) and len(p) > 0 and p[0] is Union:
params.extend(p[1:])
@@ -586,6 +585,12 @@ 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 __repr__(self):
if self.__covariant__:
prefix = '+'
@@ -693,6 +698,12 @@ 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]
+
@_tp_cache
def __getitem__(self, params):
if self.__origin__ in (Generic, Protocol):
@@ -792,6 +803,11 @@ def __subclasscheck__(self, cls):
def __reduce__(self):
return self._name
+ def __or__(self, right):
+ return Union[self, right]
+
+ def __ror__(self, right):
+ return Union[self, right]
class _CallableGenericAlias(_GenericAlias, _root=True):
def __repr__(self):
@@ -878,6 +894,15 @@ def __repr__(self):
return f'typing.Optional[{_type_repr(args[0])}]'
return super().__repr__()
+ def __instancecheck__(self, obj):
+ return self.__subclasscheck__(type(obj))
+
+ def __subclasscheck__(self, cls):
+ for arg in self.__args__:
+ if issubclass(cls, arg):
+ return True
+
+
class Generic:
"""Abstract base class for generic types.
diff --git a/Makefile.pre.in b/Makefile.pre.in
index 5d3ac705a3625..921bd08ea505d 100644
--- a/Makefile.pre.in
+++ b/Makefile.pre.in
@@ -432,6 +432,7 @@ OBJECT_OBJS= \
Objects/typeobject.o \
Objects/unicodeobject.o \
Objects/unicodectype.o \
+ Objects/unionobject.o \
Objects/weakrefobject.o
##########################################################################
@@ -1128,6 +1129,7 @@ PYTHON_HEADERS= \
$(srcdir)/Include/internal/pycore_sysmodule.h \
$(srcdir)/Include/internal/pycore_traceback.h \
$(srcdir)/Include/internal/pycore_tuple.h \
+ $(srcdir)/Include/internal/pycore_unionobject.h \
$(srcdir)/Include/internal/pycore_warnings.h \
$(DTRACE_HEADERS)
diff --git a/Misc/NEWS.d/next/Core and Builtins/2020-07-28-22-43-27.bpo-41428.FM6xsI.rst b/Misc/NEWS.d/next/Core and Builtins/2020-07-28-22-43-27.bpo-41428.FM6xsI.rst
new file mode 100644
index 0000000000000..a6652de927511
--- /dev/null
+++ b/Misc/NEWS.d/next/Core and Builtins/2020-07-28-22-43-27.bpo-41428.FM6xsI.rst
@@ -0,0 +1 @@
+Implement PEP 604. This supports (int | str) etc. in place of Union[str, int].
\ No newline at end of file
diff --git a/Objects/abstract.c b/Objects/abstract.c
index 7bd72c9b5dcc2..c471f184f6c84 100644
--- a/Objects/abstract.c
+++ b/Objects/abstract.c
@@ -1,6 +1,7 @@
/* Abstract Object Interface (many thanks to Jim Fulton) */
#include "Python.h"
+#include "pycore_unionobject.h" // _Py_UnionType && _Py_Union()
#include "pycore_abstract.h" // _PyIndex_Check()
#include "pycore_ceval.h" // _Py_EnterRecursiveCall()
#include "pycore_pyerrors.h" // _PyErr_Occurred()
@@ -839,7 +840,6 @@ binary_op(PyObject *v, PyObject *w, const int op_slot, const char *op_name)
Py_TYPE(w)->tp_name);
return NULL;
}
-
return binop_type_error(v, w, op_name);
}
return result;
@@ -2412,7 +2412,6 @@ object_isinstance(PyObject *inst, PyObject *cls)
PyObject *icls;
int retval;
_Py_IDENTIFIER(__class__);
-
if (PyType_Check(cls)) {
retval = PyObject_TypeCheck(inst, (PyTypeObject *)cls);
if (retval == 0) {
@@ -2432,7 +2431,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 a union"))
return -1;
retval = _PyObject_LookupAttrId(inst, &PyId___class__, &icls);
if (icls != NULL) {
@@ -2525,10 +2524,14 @@ recursive_issubclass(PyObject *derived, PyObject *cls)
if (!check_class(derived,
"issubclass() arg 1 must be a class"))
return -1;
- if (!check_class(cls,
- "issubclass() arg 2 must be a class"
- " or tuple of classes"))
+
+ PyTypeObject *type = Py_TYPE(cls);
+ int is_union = (PyType_Check(type) && type == &_Py_UnionType);
+ if (!is_union && !check_class(cls,
+ "issubclass() arg 2 must be a class,"
+ " a tuple of classes, or a union.")) {
return -1;
+ }
return abstract_issubclass(derived, cls);
}
diff --git a/Objects/typeobject.c b/Objects/typeobject.c
index 74040757a0702..3bb2c338fe0b5 100644
--- a/Objects/typeobject.c
+++ b/Objects/typeobject.c
@@ -6,6 +6,7 @@
#include "pycore_object.h"
#include "pycore_pyerrors.h"
#include "pycore_pystate.h" // _PyThreadState_GET()
+#include "pycore_unionobject.h" // _Py_Union()
#include "frameobject.h"
#include "structmember.h" // PyMemberDef
@@ -3753,6 +3754,21 @@ type_is_gc(PyTypeObject *type)
return type->tp_flags & Py_TPFLAGS_HEAPTYPE;
}
+static PyObject *
+type_or(PyTypeObject* self, PyObject* param) {
+ PyObject *tuple = PyTuple_Pack(2, self, param);
+ if (tuple == NULL) {
+ return NULL;
+ }
+ PyObject *new_union = _Py_Union(tuple);
+ Py_DECREF(tuple);
+ return new_union;
+}
+
+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 */
@@ -3764,7 +3780,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 */
@@ -5598,7 +5614,6 @@ PyType_Ready(PyTypeObject *type)
add_subclass((PyTypeObject *)b, type) < 0)
goto error;
}
-
/* All done -- set the ready flag */
type->tp_flags =
(type->tp_flags & ~Py_TPFLAGS_READYING) | Py_TPFLAGS_READY;
diff --git a/Objects/unionobject.c b/Objects/unionobject.c
new file mode 100644
index 0000000000000..0ef7abb4c55c2
--- /dev/null
+++ b/Objects/unionobject.c
@@ -0,0 +1,464 @@
+// types.Union -- used to represent e.g. Union[int, str], int | str
+#include "Python.h"
+#include "pycore_unionobject.h"
+#include "structmember.h"
+
+
+typedef struct {
+ PyObject_HEAD
+ PyObject *args;
+} unionobject;
+
+static void
+unionobject_dealloc(PyObject *self)
+{
+ unionobject *alias = (unionobject *)self;
+
+ Py_XDECREF(alias->args);
+ self->ob_type->tp_free(self);
+}
+
+static Py_hash_t
+union_hash(PyObject *self)
+{
+ unionobject *alias = (unionobject *)self;
+ Py_hash_t h1 = PyObject_Hash(alias->args);
+ if (h1 == -1) {
+ return -1;
+ }
+ return h1;
+}
+
+static int
+is_generic_alias_in_args(PyObject *args) {
+ Py_ssize_t nargs = PyTuple_GET_SIZE(args);
+ for (Py_ssize_t iarg = 0; iarg < nargs; iarg++) {
+ PyObject *arg = PyTuple_GET_ITEM(args, iarg);
+ if (Py_TYPE(arg) == &Py_GenericAliasType) {
+ return 0;
+ }
+ }
+ return 1;
+}
+
+static PyObject *
+union_instancecheck(PyObject *self, PyObject *instance)
+{
+ unionobject *alias = (unionobject *) self;
+ Py_ssize_t nargs = PyTuple_GET_SIZE(alias->args);
+ if (!is_generic_alias_in_args(alias->args)) {
+ PyErr_SetString(PyExc_TypeError,
+ "isinstance() argument 2 cannot contain a parameterized generic");
+ return NULL;
+ }
+ for (Py_ssize_t iarg = 0; iarg < nargs; iarg++) {
+ PyObject *arg = PyTuple_GET_ITEM(alias->args, iarg);
+ if (arg == Py_None) {
+ arg = (PyObject *)&_PyNone_Type;
+ }
+ if (PyType_Check(arg) && PyObject_IsInstance(instance, arg) != 0) {
+ Py_RETURN_TRUE;
+ }
+ }
+ Py_RETURN_FALSE;
+}
+
+static PyObject *
+union_subclasscheck(PyObject *self, PyObject *instance)
+{
+ if (!PyType_Check(instance)) {
+ PyErr_SetString(PyExc_TypeError, "issubclass() arg 1 must be a class");
+ return NULL;
+ }
+ unionobject *alias = (unionobject *)self;
+ if (!is_generic_alias_in_args(alias->args)) {
+ PyErr_SetString(PyExc_TypeError,
+ "issubclass() argument 2 cannot contain a parameterized generic");
+ return NULL;
+ }
+ Py_ssize_t nargs = PyTuple_GET_SIZE(alias->args);
+ for (Py_ssize_t iarg = 0; iarg < nargs; iarg++) {
+ PyObject *arg = PyTuple_GET_ITEM(alias->args, iarg);
+ if (PyType_Check(arg) && (PyType_IsSubtype((PyTypeObject *)instance, (PyTypeObject *)arg) != 0)) {
+ Py_RETURN_TRUE;
+ }
+ }
+ Py_RETURN_FALSE;
+}
+
+static int
+is_typing_module(PyObject *obj) {
+ PyObject *module = PyObject_GetAttrString(obj, "__module__");
+ if (module == NULL) {
+ return -1;
+ }
+ int is_typing = PyUnicode_Check(module) && _PyUnicode_EqualToASCIIString(module, "typing");
+ Py_DECREF(module);
+ return is_typing;
+}
+
+static int
+is_typing_name(PyObject *obj, char *name)
+{
+ PyTypeObject *type = Py_TYPE(obj);
+ if (strcmp(type->tp_name, name) != 0) {
+ return 0;
+ }
+ return is_typing_module(obj);
+}
+
+static PyObject *
+union_richcompare(PyObject *a, PyObject *b, int op)
+{
+ PyObject *result = NULL;
+ if (op != Py_EQ && op != Py_NE) {
+ result = Py_NotImplemented;
+ Py_INCREF(result);
+ return result;
+ }
+
+ PyTypeObject *type = Py_TYPE(b);
+
+ PyObject* a_set = PySet_New(((unionobject*)a)->args);
+ if (a_set == NULL) {
+ return NULL;
+ }
+ PyObject* b_set = PySet_New(NULL);
+ if (b_set == NULL) {
+ goto exit;
+ }
+
+ // Populate b_set with the data from the right object
+ int is_typing_union = is_typing_name(b, "_UnionGenericAlias");
+ if (is_typing_union < 0) {
+ goto exit;
+ }
+ if (is_typing_union) {
+ PyObject *b_args = PyObject_GetAttrString(b, "__args__");
+ if (b_args == NULL) {
+ goto exit;
+ }
+ if (!PyTuple_CheckExact(b_args)) {
+ Py_DECREF(b_args);
+ PyErr_SetString(PyExc_TypeError, "__args__ argument of typing.Union object is not a tuple");
+ goto exit;
+ }
+ Py_ssize_t b_arg_length = PyTuple_GET_SIZE(b_args);
+ for (Py_ssize_t i = 0; i < b_arg_length; i++) {
+ PyObject* arg = PyTuple_GET_ITEM(b_args, i);
+ if (arg == (PyObject *)&_PyNone_Type) {
+ arg = Py_None;
+ }
+ if (PySet_Add(b_set, arg) == -1) {
+ Py_DECREF(b_args);
+ goto exit;
+ }
+ }
+ Py_DECREF(b_args);
+ } else if (type == &_Py_UnionType) {
+ PyObject* args = ((unionobject*) b)->args;
+ Py_ssize_t arg_length = PyTuple_GET_SIZE(args);
+ for (Py_ssize_t i = 0; i < arg_length; i++) {
+ PyObject* arg = PyTuple_GET_ITEM(args, i);
+ if (PySet_Add(b_set, arg) == -1) {
+ goto exit;
+ }
+ }
+ } else {
+ if (PySet_Add(b_set, b) == -1) {
+ goto exit;
+ }
+ }
+ result = PyObject_RichCompare(a_set, b_set, op);
+exit:
+ Py_XDECREF(a_set);
+ Py_XDECREF(b_set);
+ return result;
+}
+
+static PyObject*
+flatten_args(PyObject* args)
+{
+ int arg_length = PyTuple_GET_SIZE(args);
+ int total_args = 0;
+ // Get number of total args once it's flattened.
+ for (Py_ssize_t i = 0; i < arg_length; i++) {
+ PyObject *arg = PyTuple_GET_ITEM(args, i);
+ PyTypeObject* arg_type = Py_TYPE(arg);
+ if (arg_type == &_Py_UnionType) {
+ total_args += PyTuple_GET_SIZE(((unionobject*) arg)->args);
+ } else {
+ total_args++;
+ }
+ }
+ // Create new tuple of flattened args.
+ PyObject *flattened_args = PyTuple_New(total_args);
+ if (flattened_args == NULL) {
+ return NULL;
+ }
+ Py_ssize_t pos = 0;
+ for (Py_ssize_t i = 0; i < arg_length; i++) {
+ PyObject *arg = PyTuple_GET_ITEM(args, i);
+ PyTypeObject* arg_type = Py_TYPE(arg);
+ if (arg_type == &_Py_UnionType) {
+ PyObject* nested_args = ((unionobject*)arg)->args;
+ int nested_arg_length = PyTuple_GET_SIZE(nested_args);
+ for (int j = 0; j < nested_arg_length; j++) {
+ PyObject* nested_arg = PyTuple_GET_ITEM(nested_args, j);
+ Py_INCREF(nested_arg);
+ PyTuple_SET_ITEM(flattened_args, pos, nested_arg);
+ pos++;
+ }
+ } else {
+ Py_INCREF(arg);
+ PyTuple_SET_ITEM(flattened_args, pos, arg);
+ pos++;
+ }
+ }
+ return flattened_args;
+}
+
+static PyObject*
+dedup_and_flatten_args(PyObject* args)
+{
+ args = flatten_args(args);
+ if (args == NULL) {
+ return NULL;
+ }
+ Py_ssize_t arg_length = PyTuple_GET_SIZE(args);
+ PyObject *new_args = PyTuple_New(arg_length);
+ if (new_args == NULL) {
+ return NULL;
+ }
+ // Add unique elements to an array.
+ int added_items = 0;
+ for (Py_ssize_t i = 0; i < arg_length; i++) {
+ int is_duplicate = 0;
+ PyObject* i_element = PyTuple_GET_ITEM(args, i);
+ for (Py_ssize_t j = i + 1; j < arg_length; j++) {
+ PyObject* j_element = PyTuple_GET_ITEM(args, j);
+ if (i_element == j_element) {
+ is_duplicate = 1;
+ }
+ }
+ if (!is_duplicate) {
+ Py_INCREF(i_element);
+ PyTuple_SET_ITEM(new_args, added_items, i_element);
+ added_items++;
+ }
+ }
+ Py_DECREF(args);
+ _PyTuple_Resize(&new_args, added_items);
+ return new_args;
+}
+
+static int
+is_typevar(PyObject *obj)
+{
+ return is_typing_name(obj, "TypeVar");
+}
+
+static int
+is_special_form(PyObject *obj)
+{
+ return is_typing_name(obj, "_SpecialForm");
+}
+
+static int
+is_new_type(PyObject *obj)
+{
+ PyTypeObject *type = Py_TYPE(obj);
+ if (type != &PyFunction_Type) {
+ return 0;
+ }
+ return is_typing_module(obj);
+}
+
+static int
+is_unionable(PyObject *obj)
+{
+ if (obj == Py_None) {
+ return 1;
+ }
+ PyTypeObject *type = Py_TYPE(obj);
+ return (
+ is_typevar(obj) ||
+ is_new_type(obj) ||
+ is_special_form(obj) ||
+ PyType_Check(obj) ||
+ type == &Py_GenericAliasType ||
+ type == &_Py_UnionType);
+}
+
+static PyObject *
+type_or(PyTypeObject* self, PyObject* param)
+{
+ PyObject *tuple = PyTuple_Pack(2, self, param);
+ if (tuple == NULL) {
+ return NULL;
+ }
+ PyObject *new_union = _Py_Union(tuple);
+ Py_DECREF(tuple);
+ return new_union;
+}
+
+static int
+union_repr_item(_PyUnicodeWriter *writer, PyObject *p)
+{
+ _Py_IDENTIFIER(__module__);
+ _Py_IDENTIFIER(__qualname__);
+ _Py_IDENTIFIER(__origin__);
+ _Py_IDENTIFIER(__args__);
+ PyObject *qualname = NULL;
+ PyObject *module = NULL;
+ PyObject *r = NULL;
+ int err;
+
+ int has_origin = _PyObject_HasAttrId(p, &PyId___origin__);
+ if (has_origin < 0) {
+ goto exit;
+ }
+
+ if (has_origin) {
+ int has_args = _PyObject_HasAttrId(p, &PyId___args__);
+ if (has_args < 0) {
+ goto exit;
+ }
+ if (has_args) {
+ // It looks like a GenericAlias
+ goto use_repr;
+ }
+ }
+
+ if (_PyObject_LookupAttrId(p, &PyId___qualname__, &qualname) < 0) {
+ goto exit;
+ }
+ if (qualname == NULL) {
+ goto use_repr;
+ }
+ if (_PyObject_LookupAttrId(p, &PyId___module__, &module) < 0) {
+ goto exit;
+ }
+ if (module == NULL || module == Py_None) {
+ goto use_repr;
+ }
+
+ // Looks like a class
+ if (PyUnicode_Check(module) &&
+ _PyUnicode_EqualToASCIIString(module, "builtins"))
+ {
+ // builtins don't need a module name
+ r = PyObject_Str(qualname);
+ goto exit;
+ }
+ else {
+ r = PyUnicode_FromFormat("%S.%S", module, qualname);
+ goto exit;
+ }
+
+use_repr:
+ r = PyObject_Repr(p);
+exit:
+ Py_XDECREF(qualname);
+ Py_XDECREF(module);
+ if (r == NULL) {
+ return -1;
+ }
+ err = _PyUnicodeWriter_WriteStr(writer, r);
+ Py_DECREF(r);
+ return err;
+}
+
+static PyObject *
+union_repr(PyObject *self)
+{
+ unionobject *alias = (unionobject *)self;
+ Py_ssize_t len = PyTuple_GET_SIZE(alias->args);
+
+ _PyUnicodeWriter writer;
+ _PyUnicodeWriter_Init(&writer);
+ for (Py_ssize_t i = 0; i < len; i++) {
+ if (i > 0 && _PyUnicodeWriter_WriteASCIIString(&writer, " | ", 3) < 0) {
+ goto error;
+ }
+ PyObject *p = PyTuple_GET_ITEM(alias->args, i);
+ if (union_repr_item(&writer, p) < 0) {
+ goto error;
+ }
+ }
+ return _PyUnicodeWriter_Finish(&writer);
+error:
+ _PyUnicodeWriter_Dealloc(&writer);
+ return NULL;
+}
+
+static PyMemberDef union_members[] = {
+ {"__args__", T_OBJECT, offsetof(unionobject, args), READONLY},
+ {0}
+};
+
+static PyMethodDef union_methods[] = {
+ {"__instancecheck__", union_instancecheck, METH_O},
+ {"__subclasscheck__", union_subclasscheck, METH_O},
+ {0}};
+
+static PyNumberMethods union_as_number = {
+ .nb_or = (binaryfunc)type_or, // Add __or__ function
+};
+
+PyTypeObject _Py_UnionType = {
+ PyVarObject_HEAD_INIT(&PyType_Type, 0)
+ .tp_name = "types.Union",
+ .tp_doc = "Represent a PEP 604 union type\n"
+ "\n"
+ "E.g. for int | str",
+ .tp_basicsize = sizeof(unionobject),
+ .tp_dealloc = unionobject_dealloc,
+ .tp_alloc = PyType_GenericAlloc,
+ .tp_free = PyObject_Del,
+ .tp_flags = Py_TPFLAGS_DEFAULT,
+ .tp_hash = union_hash,
+ .tp_getattro = PyObject_GenericGetAttr,
+ .tp_members = union_members,
+ .tp_methods = union_methods,
+ .tp_richcompare = union_richcompare,
+ .tp_as_number = &union_as_number,
+ .tp_repr = union_repr,
+};
+
+PyObject *
+_Py_Union(PyObject *args)
+{
+ assert(PyTuple_CheckExact(args));
+
+ unionobject* result = NULL;
+
+ // Check arguments are unionable.
+ int nargs = PyTuple_GET_SIZE(args);
+ for (Py_ssize_t iarg = 0; iarg < nargs; iarg++) {
+ PyObject *arg = PyTuple_GET_ITEM(args, iarg);
+ if (arg == NULL) {
+ return NULL;
+ }
+ int is_arg_unionable = is_unionable(arg);
+ if (is_arg_unionable < 0) {
+ return NULL;
+ }
+ if (!is_arg_unionable) {
+ Py_INCREF(Py_NotImplemented);
+ return Py_NotImplemented;
+ }
+ }
+
+ result = PyObject_New(unionobject, &_Py_UnionType);
+ if (result == NULL) {
+ return NULL;
+ }
+
+ result->args = dedup_and_flatten_args(args);
+ if (result->args == NULL) {
+ Py_DECREF(result);
+ return NULL;
+ }
+ return (PyObject*)result;
+}
diff --git a/PCbuild/pythoncore.vcxproj b/PCbuild/pythoncore.vcxproj
index 295b5e21eba5c..266a193c1e86a 100644
--- a/PCbuild/pythoncore.vcxproj
+++ b/PCbuild/pythoncore.vcxproj
@@ -196,6 +196,7 @@
<ClInclude Include="..\Include\internal\pycore_sysmodule.h" />
<ClInclude Include="..\Include\internal\pycore_traceback.h" />
<ClInclude Include="..\Include\internal\pycore_tuple.h" />
+ <ClInclude Include="..\Include\internal\pycore_unionobject.h" />
<ClInclude Include="..\Include\internal\pycore_warnings.h" />
<ClInclude Include="..\Include\interpreteridobject.h" />
<ClInclude Include="..\Include\intrcheck.h" />
@@ -412,6 +413,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" />
diff --git a/PCbuild/pythoncore.vcxproj.filters b/PCbuild/pythoncore.vcxproj.filters
index ec82e42f61e8b..22d9b79157698 100644
--- a/PCbuild/pythoncore.vcxproj.filters
+++ b/PCbuild/pythoncore.vcxproj.filters
@@ -573,6 +573,9 @@
<ClInclude Include="..\Include\internal\pycore_tuple.h">
<Filter>Include\internal</Filter>
</ClInclude>
+ <ClInclude Include="..\Include\internal\pycore_unionobject.h">
+ <Filter>Include\internal</Filter>
+ </ClInclude>
<ClInclude Include="$(zlibDir)\crc32.h">
<Filter>Modules\zlib</Filter>
</ClInclude>
@@ -1175,6 +1178,9 @@
<ClCompile Include="..\Objects\genericaliasobject.c">
<Filter>Objects</Filter>
</ClCompile>
+ <ClCompile Include="..\Objects\unionobject.c">
+ <Filter>Objects</Filter>
+ </ClCompile>
</ItemGroup>
<ItemGroup>
<ResourceCompile Include="..\PC\python_nt.rc">
More information about the Python-checkins
mailing list