mirror of
https://github.com/python/cpython.git
synced 2024-12-06 00:05:32 +08:00
5d3553b0a8
In is_typing_name(), va_end() is not always called before the function returns. It is undefined behavior to call va_start() without also calling va_end().
708 lines
19 KiB
C
708 lines
19 KiB
C
// types.GenericAlias -- used to represent e.g. list[int].
|
|
|
|
#include "Python.h"
|
|
#include "pycore_object.h"
|
|
#include "pycore_unionobject.h" // _Py_union_as_number
|
|
#include "structmember.h" // PyMemberDef
|
|
|
|
typedef struct {
|
|
PyObject_HEAD
|
|
PyObject *origin;
|
|
PyObject *args;
|
|
PyObject *parameters;
|
|
PyObject* weakreflist;
|
|
} gaobject;
|
|
|
|
static void
|
|
ga_dealloc(PyObject *self)
|
|
{
|
|
gaobject *alias = (gaobject *)self;
|
|
|
|
_PyObject_GC_UNTRACK(self);
|
|
if (alias->weakreflist != NULL) {
|
|
PyObject_ClearWeakRefs((PyObject *)alias);
|
|
}
|
|
Py_XDECREF(alias->origin);
|
|
Py_XDECREF(alias->args);
|
|
Py_XDECREF(alias->parameters);
|
|
Py_TYPE(self)->tp_free(self);
|
|
}
|
|
|
|
static int
|
|
ga_traverse(PyObject *self, visitproc visit, void *arg)
|
|
{
|
|
gaobject *alias = (gaobject *)self;
|
|
Py_VISIT(alias->origin);
|
|
Py_VISIT(alias->args);
|
|
Py_VISIT(alias->parameters);
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
ga_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;
|
|
PyObject *tmp;
|
|
int err;
|
|
|
|
if (p == Py_Ellipsis) {
|
|
// The Ellipsis object
|
|
r = PyUnicode_FromString("...");
|
|
goto done;
|
|
}
|
|
|
|
if (_PyObject_LookupAttrId(p, &PyId___origin__, &tmp) < 0) {
|
|
goto done;
|
|
}
|
|
if (tmp != NULL) {
|
|
Py_DECREF(tmp);
|
|
if (_PyObject_LookupAttrId(p, &PyId___args__, &tmp) < 0) {
|
|
goto done;
|
|
}
|
|
if (tmp != NULL) {
|
|
Py_DECREF(tmp);
|
|
// It looks like a GenericAlias
|
|
goto use_repr;
|
|
}
|
|
}
|
|
|
|
if (_PyObject_LookupAttrId(p, &PyId___qualname__, &qualname) < 0) {
|
|
goto done;
|
|
}
|
|
if (qualname == NULL) {
|
|
goto use_repr;
|
|
}
|
|
if (_PyObject_LookupAttrId(p, &PyId___module__, &module) < 0) {
|
|
goto done;
|
|
}
|
|
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 done;
|
|
}
|
|
else {
|
|
r = PyUnicode_FromFormat("%S.%S", module, qualname);
|
|
goto done;
|
|
}
|
|
|
|
use_repr:
|
|
r = PyObject_Repr(p);
|
|
|
|
done:
|
|
Py_XDECREF(qualname);
|
|
Py_XDECREF(module);
|
|
if (r == NULL) {
|
|
// error if any of the above PyObject_Repr/PyUnicode_From* fail
|
|
err = -1;
|
|
}
|
|
else {
|
|
err = _PyUnicodeWriter_WriteStr(writer, r);
|
|
Py_DECREF(r);
|
|
}
|
|
return err;
|
|
}
|
|
|
|
static PyObject *
|
|
ga_repr(PyObject *self)
|
|
{
|
|
gaobject *alias = (gaobject *)self;
|
|
Py_ssize_t len = PyTuple_GET_SIZE(alias->args);
|
|
|
|
_PyUnicodeWriter writer;
|
|
_PyUnicodeWriter_Init(&writer);
|
|
|
|
if (ga_repr_item(&writer, alias->origin) < 0) {
|
|
goto error;
|
|
}
|
|
if (_PyUnicodeWriter_WriteASCIIString(&writer, "[", 1) < 0) {
|
|
goto error;
|
|
}
|
|
for (Py_ssize_t i = 0; i < len; i++) {
|
|
if (i > 0) {
|
|
if (_PyUnicodeWriter_WriteASCIIString(&writer, ", ", 2) < 0) {
|
|
goto error;
|
|
}
|
|
}
|
|
PyObject *p = PyTuple_GET_ITEM(alias->args, i);
|
|
if (ga_repr_item(&writer, p) < 0) {
|
|
goto error;
|
|
}
|
|
}
|
|
if (len == 0) {
|
|
// for something like tuple[()] we should print a "()"
|
|
if (_PyUnicodeWriter_WriteASCIIString(&writer, "()", 2) < 0) {
|
|
goto error;
|
|
}
|
|
}
|
|
if (_PyUnicodeWriter_WriteASCIIString(&writer, "]", 1) < 0) {
|
|
goto error;
|
|
}
|
|
return _PyUnicodeWriter_Finish(&writer);
|
|
error:
|
|
_PyUnicodeWriter_Dealloc(&writer);
|
|
return NULL;
|
|
}
|
|
|
|
/* Checks if a variable number of names are from typing.py.
|
|
* If any one of the names are found, return 1, else 0.
|
|
**/
|
|
static inline int
|
|
is_typing_name(PyObject *obj, int num, ...)
|
|
{
|
|
va_list names;
|
|
va_start(names, num);
|
|
|
|
PyTypeObject *type = Py_TYPE(obj);
|
|
int hit = 0;
|
|
for (int i = 0; i < num; ++i) {
|
|
if (!strcmp(type->tp_name, va_arg(names, const char *))) {
|
|
hit = 1;
|
|
break;
|
|
}
|
|
}
|
|
va_end(names);
|
|
if (!hit) {
|
|
return 0;
|
|
}
|
|
PyObject *module = PyObject_GetAttrString((PyObject *)type, "__module__");
|
|
if (module == NULL) {
|
|
return -1;
|
|
}
|
|
int res = PyUnicode_Check(module)
|
|
&& _PyUnicode_EqualToASCIIString(module, "typing");
|
|
Py_DECREF(module);
|
|
|
|
return res;
|
|
}
|
|
|
|
// isinstance(obj, (TypeVar, ParamSpec)) without importing typing.py.
|
|
// Returns -1 for errors.
|
|
static inline int
|
|
is_typevarlike(PyObject *obj)
|
|
{
|
|
return is_typing_name(obj, 2, "TypeVar", "ParamSpec");
|
|
}
|
|
|
|
static inline int
|
|
is_paramspec(PyObject *obj)
|
|
{
|
|
return is_typing_name(obj, 1, "ParamSpec");
|
|
}
|
|
|
|
// Index of item in self[:len], or -1 if not found (self is a tuple)
|
|
static Py_ssize_t
|
|
tuple_index(PyObject *self, Py_ssize_t len, PyObject *item)
|
|
{
|
|
for (Py_ssize_t i = 0; i < len; i++) {
|
|
if (PyTuple_GET_ITEM(self, i) == item) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
static int
|
|
tuple_add(PyObject *self, Py_ssize_t len, PyObject *item)
|
|
{
|
|
if (tuple_index(self, len, item) < 0) {
|
|
Py_INCREF(item);
|
|
PyTuple_SET_ITEM(self, len, item);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static PyObject *
|
|
make_parameters(PyObject *args)
|
|
{
|
|
Py_ssize_t nargs = PyTuple_GET_SIZE(args);
|
|
Py_ssize_t len = nargs;
|
|
PyObject *parameters = PyTuple_New(len);
|
|
if (parameters == NULL)
|
|
return NULL;
|
|
Py_ssize_t iparam = 0;
|
|
for (Py_ssize_t iarg = 0; iarg < nargs; iarg++) {
|
|
PyObject *t = PyTuple_GET_ITEM(args, iarg);
|
|
int typevar = is_typevarlike(t);
|
|
if (typevar < 0) {
|
|
Py_DECREF(parameters);
|
|
return NULL;
|
|
}
|
|
if (typevar) {
|
|
iparam += tuple_add(parameters, iparam, t);
|
|
}
|
|
else {
|
|
_Py_IDENTIFIER(__parameters__);
|
|
PyObject *subparams;
|
|
if (_PyObject_LookupAttrId(t, &PyId___parameters__, &subparams) < 0) {
|
|
Py_DECREF(parameters);
|
|
return NULL;
|
|
}
|
|
if (subparams && PyTuple_Check(subparams)) {
|
|
Py_ssize_t len2 = PyTuple_GET_SIZE(subparams);
|
|
Py_ssize_t needed = len2 - 1 - (iarg - iparam);
|
|
if (needed > 0) {
|
|
len += needed;
|
|
if (_PyTuple_Resize(¶meters, len) < 0) {
|
|
Py_DECREF(subparams);
|
|
Py_DECREF(parameters);
|
|
return NULL;
|
|
}
|
|
}
|
|
for (Py_ssize_t j = 0; j < len2; j++) {
|
|
PyObject *t2 = PyTuple_GET_ITEM(subparams, j);
|
|
iparam += tuple_add(parameters, iparam, t2);
|
|
}
|
|
}
|
|
Py_XDECREF(subparams);
|
|
}
|
|
}
|
|
if (iparam < len) {
|
|
if (_PyTuple_Resize(¶meters, iparam) < 0) {
|
|
Py_XDECREF(parameters);
|
|
return NULL;
|
|
}
|
|
}
|
|
return parameters;
|
|
}
|
|
|
|
/* If obj is a generic alias, substitute type variables params
|
|
with substitutions argitems. For example, if obj is list[T],
|
|
params is (T, S), and argitems is (str, int), return list[str].
|
|
If obj doesn't have a __parameters__ attribute or that's not
|
|
a non-empty tuple, return a new reference to obj. */
|
|
static PyObject *
|
|
subs_tvars(PyObject *obj, PyObject *params, PyObject **argitems)
|
|
{
|
|
_Py_IDENTIFIER(__parameters__);
|
|
PyObject *subparams;
|
|
if (_PyObject_LookupAttrId(obj, &PyId___parameters__, &subparams) < 0) {
|
|
return NULL;
|
|
}
|
|
if (subparams && PyTuple_Check(subparams) && PyTuple_GET_SIZE(subparams)) {
|
|
Py_ssize_t nparams = PyTuple_GET_SIZE(params);
|
|
Py_ssize_t nsubargs = PyTuple_GET_SIZE(subparams);
|
|
PyObject *subargs = PyTuple_New(nsubargs);
|
|
if (subargs == NULL) {
|
|
Py_DECREF(subparams);
|
|
return NULL;
|
|
}
|
|
for (Py_ssize_t i = 0; i < nsubargs; ++i) {
|
|
PyObject *arg = PyTuple_GET_ITEM(subparams, i);
|
|
Py_ssize_t iparam = tuple_index(params, nparams, arg);
|
|
if (iparam >= 0) {
|
|
arg = argitems[iparam];
|
|
}
|
|
// convert all the lists inside args to tuples to help
|
|
// with caching in other libaries
|
|
if (PyList_CheckExact(arg)) {
|
|
arg = PyList_AsTuple(arg);
|
|
}
|
|
else {
|
|
Py_INCREF(arg);
|
|
}
|
|
PyTuple_SET_ITEM(subargs, i, arg);
|
|
}
|
|
|
|
obj = PyObject_GetItem(obj, subargs);
|
|
|
|
Py_DECREF(subargs);
|
|
}
|
|
else {
|
|
Py_INCREF(obj);
|
|
}
|
|
Py_XDECREF(subparams);
|
|
return obj;
|
|
}
|
|
|
|
static PyObject *
|
|
ga_getitem(PyObject *self, PyObject *item)
|
|
{
|
|
gaobject *alias = (gaobject *)self;
|
|
// do a lookup for __parameters__ so it gets populated (if not already)
|
|
if (alias->parameters == NULL) {
|
|
alias->parameters = make_parameters(alias->args);
|
|
if (alias->parameters == NULL) {
|
|
return NULL;
|
|
}
|
|
}
|
|
Py_ssize_t nparams = PyTuple_GET_SIZE(alias->parameters);
|
|
if (nparams == 0) {
|
|
return PyErr_Format(PyExc_TypeError,
|
|
"There are no type variables left in %R",
|
|
self);
|
|
}
|
|
int is_tuple = PyTuple_Check(item);
|
|
Py_ssize_t nitems = is_tuple ? PyTuple_GET_SIZE(item) : 1;
|
|
PyObject **argitems = is_tuple ? &PyTuple_GET_ITEM(item, 0) : &item;
|
|
// A special case in PEP 612 where if X = Callable[P, int],
|
|
// then X[int, str] == X[[int, str]].
|
|
if (nparams == 1 && nitems > 1 && is_tuple &&
|
|
is_paramspec(PyTuple_GET_ITEM(alias->parameters, 0))) {
|
|
argitems = &item;
|
|
}
|
|
else {
|
|
if (nitems != nparams) {
|
|
return PyErr_Format(PyExc_TypeError,
|
|
"Too %s arguments for %R",
|
|
nitems > nparams ? "many" : "few",
|
|
self);
|
|
}
|
|
}
|
|
/* Replace all type variables (specified by alias->parameters)
|
|
with corresponding values specified by argitems.
|
|
t = list[T]; t[int] -> newargs = [int]
|
|
t = dict[str, T]; t[int] -> newargs = [str, int]
|
|
t = dict[T, list[S]]; t[str, int] -> newargs = [str, list[int]]
|
|
*/
|
|
Py_ssize_t nargs = PyTuple_GET_SIZE(alias->args);
|
|
PyObject *newargs = PyTuple_New(nargs);
|
|
if (newargs == NULL) {
|
|
return NULL;
|
|
}
|
|
for (Py_ssize_t iarg = 0; iarg < nargs; iarg++) {
|
|
PyObject *arg = PyTuple_GET_ITEM(alias->args, iarg);
|
|
int typevar = is_typevarlike(arg);
|
|
if (typevar < 0) {
|
|
Py_DECREF(newargs);
|
|
return NULL;
|
|
}
|
|
if (typevar) {
|
|
Py_ssize_t iparam = tuple_index(alias->parameters, nparams, arg);
|
|
assert(iparam >= 0);
|
|
arg = argitems[iparam];
|
|
// convert lists to tuples to help with caching in other libaries.
|
|
if (PyList_CheckExact(arg)) {
|
|
arg = PyList_AsTuple(arg);
|
|
}
|
|
else {
|
|
Py_INCREF(arg);
|
|
}
|
|
}
|
|
else {
|
|
arg = subs_tvars(arg, alias->parameters, argitems);
|
|
if (arg == NULL) {
|
|
Py_DECREF(newargs);
|
|
return NULL;
|
|
}
|
|
}
|
|
PyTuple_SET_ITEM(newargs, iarg, arg);
|
|
}
|
|
|
|
PyObject *res = Py_GenericAlias(alias->origin, newargs);
|
|
|
|
Py_DECREF(newargs);
|
|
return res;
|
|
}
|
|
|
|
static PyMappingMethods ga_as_mapping = {
|
|
.mp_subscript = ga_getitem,
|
|
};
|
|
|
|
static Py_hash_t
|
|
ga_hash(PyObject *self)
|
|
{
|
|
gaobject *alias = (gaobject *)self;
|
|
// TODO: Hash in the hash for the origin
|
|
Py_hash_t h0 = PyObject_Hash(alias->origin);
|
|
if (h0 == -1) {
|
|
return -1;
|
|
}
|
|
Py_hash_t h1 = PyObject_Hash(alias->args);
|
|
if (h1 == -1) {
|
|
return -1;
|
|
}
|
|
return h0 ^ h1;
|
|
}
|
|
|
|
static PyObject *
|
|
ga_call(PyObject *self, PyObject *args, PyObject *kwds)
|
|
{
|
|
gaobject *alias = (gaobject *)self;
|
|
PyObject *obj = PyObject_Call(alias->origin, args, kwds);
|
|
if (obj != NULL) {
|
|
if (PyObject_SetAttrString(obj, "__orig_class__", self) < 0) {
|
|
if (!PyErr_ExceptionMatches(PyExc_AttributeError) &&
|
|
!PyErr_ExceptionMatches(PyExc_TypeError))
|
|
{
|
|
Py_DECREF(obj);
|
|
return NULL;
|
|
}
|
|
PyErr_Clear();
|
|
}
|
|
}
|
|
return obj;
|
|
}
|
|
|
|
static const char* const attr_exceptions[] = {
|
|
"__origin__",
|
|
"__args__",
|
|
"__parameters__",
|
|
"__mro_entries__",
|
|
"__reduce_ex__", // needed so we don't look up object.__reduce_ex__
|
|
"__reduce__",
|
|
NULL,
|
|
};
|
|
|
|
static PyObject *
|
|
ga_getattro(PyObject *self, PyObject *name)
|
|
{
|
|
gaobject *alias = (gaobject *)self;
|
|
if (PyUnicode_Check(name)) {
|
|
for (const char * const *p = attr_exceptions; ; p++) {
|
|
if (*p == NULL) {
|
|
return PyObject_GetAttr(alias->origin, name);
|
|
}
|
|
if (_PyUnicode_EqualToASCIIString(name, *p)) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return PyObject_GenericGetAttr(self, name);
|
|
}
|
|
|
|
static PyObject *
|
|
ga_richcompare(PyObject *a, PyObject *b, int op)
|
|
{
|
|
if (!PyObject_TypeCheck(a, &Py_GenericAliasType) ||
|
|
!PyObject_TypeCheck(b, &Py_GenericAliasType) ||
|
|
(op != Py_EQ && op != Py_NE))
|
|
{
|
|
Py_RETURN_NOTIMPLEMENTED;
|
|
}
|
|
|
|
if (op == Py_NE) {
|
|
PyObject *eq = ga_richcompare(a, b, Py_EQ);
|
|
if (eq == NULL)
|
|
return NULL;
|
|
Py_DECREF(eq);
|
|
if (eq == Py_True) {
|
|
Py_RETURN_FALSE;
|
|
}
|
|
else {
|
|
Py_RETURN_TRUE;
|
|
}
|
|
}
|
|
|
|
gaobject *aa = (gaobject *)a;
|
|
gaobject *bb = (gaobject *)b;
|
|
int eq = PyObject_RichCompareBool(aa->origin, bb->origin, Py_EQ);
|
|
if (eq < 0) {
|
|
return NULL;
|
|
}
|
|
if (!eq) {
|
|
Py_RETURN_FALSE;
|
|
}
|
|
return PyObject_RichCompare(aa->args, bb->args, Py_EQ);
|
|
}
|
|
|
|
static PyObject *
|
|
ga_mro_entries(PyObject *self, PyObject *args)
|
|
{
|
|
gaobject *alias = (gaobject *)self;
|
|
return PyTuple_Pack(1, alias->origin);
|
|
}
|
|
|
|
static PyObject *
|
|
ga_instancecheck(PyObject *self, PyObject *Py_UNUSED(ignored))
|
|
{
|
|
PyErr_SetString(PyExc_TypeError,
|
|
"isinstance() argument 2 cannot be a parameterized generic");
|
|
return NULL;
|
|
}
|
|
|
|
static PyObject *
|
|
ga_subclasscheck(PyObject *self, PyObject *Py_UNUSED(ignored))
|
|
{
|
|
PyErr_SetString(PyExc_TypeError,
|
|
"issubclass() argument 2 cannot be a parameterized generic");
|
|
return NULL;
|
|
}
|
|
|
|
static PyObject *
|
|
ga_reduce(PyObject *self, PyObject *Py_UNUSED(ignored))
|
|
{
|
|
gaobject *alias = (gaobject *)self;
|
|
return Py_BuildValue("O(OO)", Py_TYPE(alias),
|
|
alias->origin, alias->args);
|
|
}
|
|
|
|
static PyObject *
|
|
ga_dir(PyObject *self, PyObject *Py_UNUSED(ignored))
|
|
{
|
|
gaobject *alias = (gaobject *)self;
|
|
PyObject *dir = PyObject_Dir(alias->origin);
|
|
if (dir == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
PyObject *dir_entry = NULL;
|
|
for (const char * const *p = attr_exceptions; ; p++) {
|
|
if (*p == NULL) {
|
|
break;
|
|
}
|
|
else {
|
|
dir_entry = PyUnicode_FromString(*p);
|
|
if (dir_entry == NULL) {
|
|
goto error;
|
|
}
|
|
int contains = PySequence_Contains(dir, dir_entry);
|
|
if (contains < 0) {
|
|
goto error;
|
|
}
|
|
if (contains == 0 && PyList_Append(dir, dir_entry) < 0) {
|
|
goto error;
|
|
}
|
|
|
|
Py_CLEAR(dir_entry);
|
|
}
|
|
}
|
|
return dir;
|
|
|
|
error:
|
|
Py_DECREF(dir);
|
|
Py_XDECREF(dir_entry);
|
|
return NULL;
|
|
}
|
|
|
|
static PyMethodDef ga_methods[] = {
|
|
{"__mro_entries__", ga_mro_entries, METH_O},
|
|
{"__instancecheck__", ga_instancecheck, METH_O},
|
|
{"__subclasscheck__", ga_subclasscheck, METH_O},
|
|
{"__reduce__", ga_reduce, METH_NOARGS},
|
|
{"__dir__", ga_dir, METH_NOARGS},
|
|
{0}
|
|
};
|
|
|
|
static PyMemberDef ga_members[] = {
|
|
{"__origin__", T_OBJECT, offsetof(gaobject, origin), READONLY},
|
|
{"__args__", T_OBJECT, offsetof(gaobject, args), READONLY},
|
|
{0}
|
|
};
|
|
|
|
static PyObject *
|
|
ga_parameters(PyObject *self, void *unused)
|
|
{
|
|
gaobject *alias = (gaobject *)self;
|
|
if (alias->parameters == NULL) {
|
|
alias->parameters = make_parameters(alias->args);
|
|
if (alias->parameters == NULL) {
|
|
return NULL;
|
|
}
|
|
}
|
|
Py_INCREF(alias->parameters);
|
|
return alias->parameters;
|
|
}
|
|
|
|
static PyGetSetDef ga_properties[] = {
|
|
{"__parameters__", ga_parameters, (setter)NULL, "Type variables in the GenericAlias.", NULL},
|
|
{0}
|
|
};
|
|
|
|
/* A helper function to create GenericAlias' args tuple and set its attributes.
|
|
* Returns 1 on success, 0 on failure.
|
|
*/
|
|
static inline int
|
|
setup_ga(gaobject *alias, PyObject *origin, PyObject *args) {
|
|
if (!PyTuple_Check(args)) {
|
|
args = PyTuple_Pack(1, args);
|
|
if (args == NULL) {
|
|
return 0;
|
|
}
|
|
}
|
|
else {
|
|
Py_INCREF(args);
|
|
}
|
|
|
|
Py_INCREF(origin);
|
|
alias->origin = origin;
|
|
alias->args = args;
|
|
alias->parameters = NULL;
|
|
alias->weakreflist = NULL;
|
|
return 1;
|
|
}
|
|
|
|
static PyObject *
|
|
ga_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
|
|
{
|
|
if (!_PyArg_NoKeywords("GenericAlias", kwds)) {
|
|
return NULL;
|
|
}
|
|
if (!_PyArg_CheckPositional("GenericAlias", PyTuple_GET_SIZE(args), 2, 2)) {
|
|
return NULL;
|
|
}
|
|
PyObject *origin = PyTuple_GET_ITEM(args, 0);
|
|
PyObject *arguments = PyTuple_GET_ITEM(args, 1);
|
|
gaobject *self = (gaobject *)type->tp_alloc(type, 0);
|
|
if (self == NULL) {
|
|
return NULL;
|
|
}
|
|
if (!setup_ga(self, origin, arguments)) {
|
|
type->tp_free((PyObject *)self);
|
|
return NULL;
|
|
}
|
|
return (PyObject *)self;
|
|
}
|
|
|
|
static PyNumberMethods ga_as_number = {
|
|
.nb_or = (binaryfunc)_Py_union_type_or, // Add __or__ function
|
|
};
|
|
|
|
// TODO:
|
|
// - argument clinic?
|
|
// - __doc__?
|
|
// - cache?
|
|
PyTypeObject Py_GenericAliasType = {
|
|
PyVarObject_HEAD_INIT(&PyType_Type, 0)
|
|
.tp_name = "types.GenericAlias",
|
|
.tp_doc = "Represent a PEP 585 generic type\n"
|
|
"\n"
|
|
"E.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).",
|
|
.tp_basicsize = sizeof(gaobject),
|
|
.tp_dealloc = ga_dealloc,
|
|
.tp_repr = ga_repr,
|
|
.tp_as_number = &ga_as_number, // allow X | Y of GenericAlias objs
|
|
.tp_as_mapping = &ga_as_mapping,
|
|
.tp_hash = ga_hash,
|
|
.tp_call = ga_call,
|
|
.tp_getattro = ga_getattro,
|
|
.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE,
|
|
.tp_traverse = ga_traverse,
|
|
.tp_richcompare = ga_richcompare,
|
|
.tp_weaklistoffset = offsetof(gaobject, weakreflist),
|
|
.tp_methods = ga_methods,
|
|
.tp_members = ga_members,
|
|
.tp_alloc = PyType_GenericAlloc,
|
|
.tp_new = ga_new,
|
|
.tp_free = PyObject_GC_Del,
|
|
.tp_getset = ga_properties,
|
|
};
|
|
|
|
PyObject *
|
|
Py_GenericAlias(PyObject *origin, PyObject *args)
|
|
{
|
|
gaobject *alias = PyObject_GC_New(gaobject, &Py_GenericAliasType);
|
|
if (alias == NULL) {
|
|
return NULL;
|
|
}
|
|
if (!setup_ga(alias, origin, args)) {
|
|
PyObject_GC_Del((PyObject *)alias);
|
|
return NULL;
|
|
}
|
|
_PyObject_GC_TRACK(alias);
|
|
return (PyObject *)alias;
|
|
}
|