#include "Python.h"

#include "pycore_interpframe.h" // _PyInterpreterFrame

#include "pycore_object.h" // _PyObject_GC_TRACK/UNTRACK, PyAnnotateFormat

#include "pycore_typevarobject.h"

#include "pycore_unicodeobject.h" // _PyUnicode_EqualToASCIIString()

#include "pycore_unionobject.h" // _Py_union_type_or, _Py_union_from_tuple

#include "structmember.h"

typedef struct {

PyObject_HEAD

PyObject *name;

PyObject *bound;

PyObject *evaluate_bound;

PyObject *constraints;

PyObject *evaluate_constraints;

PyObject *default_value;

PyObject *evaluate_default;

bool covariant;

bool contravariant;

bool infer_variance;

} typevarobject;

typedef struct {

PyObject_HEAD

PyObject *name;

PyObject *default_value;

PyObject *evaluate_default;

} typevartupleobject;

typedef struct {

PyObject_HEAD

PyObject *name;

PyObject *bound;

PyObject *default_value;

PyObject *evaluate_default;

bool covariant;

bool contravariant;

bool infer_variance;

} paramspecobject;

typedef struct {

PyObject_HEAD

PyObject *name;

PyObject *type_params;

PyObject *compute_value;

PyObject *value;

PyObject *module;

} typealiasobject;

#define typevarobject_CAST(op) ((typevarobject *)(op))

#define typevartupleobject_CAST(op) ((typevartupleobject *)(op))

#define paramspecobject_CAST(op) ((paramspecobject *)(op))

#define typealiasobject_CAST(op) ((typealiasobject *)(op))

#include "clinic/typevarobject.c.h"

static PyObject *

NoDefault_repr(PyObject *op)

{

return PyUnicode_FromString("typing.NoDefault");

}

static PyObject *

NoDefault_reduce(PyObject *op, PyObject *Py_UNUSED(ignored))

{

return PyUnicode_FromString("NoDefault");

}

static PyMethodDef nodefault_methods[] = {

{"__reduce__", NoDefault_reduce, METH_NOARGS, NULL},

{NULL, NULL}

};

static PyObject *

nodefault_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)

{

if (PyTuple_GET_SIZE(args) || (kwargs && PyDict_GET_SIZE(kwargs))) {

PyErr_SetString(PyExc_TypeError, "NoDefaultType takes no arguments");

return NULL;

}

return &_Py_NoDefaultStruct;

}

static void

nodefault_dealloc(PyObject *nodefault)

{

/* This should never get called, but we also don't want to SEGV if

_Py_SetImmortal(nodefault);

}

PyDoc_STRVAR(nodefault_doc,

"The type of the NoDefault singleton.");

PyTypeObject _PyNoDefault_Type = {

PyVarObject_HEAD_INIT(&PyType_Type, 0)

"NoDefaultType",

.tp_dealloc = nodefault_dealloc,

.tp_repr = NoDefault_repr,

.tp_flags = Py_TPFLAGS_DEFAULT,

.tp_doc = nodefault_doc,

.tp_methods = nodefault_methods,

.tp_new = nodefault_new,

};

PyObject _Py_NoDefaultStruct = _PyObject_HEAD_INIT(&_PyNoDefault_Type);

typedef struct {

PyObject_HEAD

PyObject *value;

} constevaluatorobject;

#define constevaluatorobject_CAST(op) ((constevaluatorobject *)(op))

static void

constevaluator_dealloc(PyObject *self)

{

PyTypeObject *tp = Py_TYPE(self);

constevaluatorobject *ce = constevaluatorobject_CAST(self);

_PyObject_GC_UNTRACK(self);

Py_XDECREF(ce->value);

Py_TYPE(self)->tp_free(self);

Py_DECREF(tp);

}

static int

constevaluator_traverse(PyObject *self, visitproc visit, void *arg)

{

constevaluatorobject *ce = constevaluatorobject_CAST(self);

Py_VISIT(ce->value);

return 0;

}

static int

constevaluator_clear(PyObject *self)

{

constevaluatorobject *ce = constevaluatorobject_CAST(self);

Py_CLEAR(ce->value);

return 0;

}

static PyObject *

constevaluator_repr(PyObject *self)

{

constevaluatorobject *ce = constevaluatorobject_CAST(self);

return PyUnicode_FromFormat("<constevaluator %R>", ce->value);

}

static PyObject *

constevaluator_call(PyObject *self, PyObject *args, PyObject *kwargs)

{

constevaluatorobject *ce = constevaluatorobject_CAST(self);

if (!_PyArg_NoKeywords("constevaluator.__call__", kwargs)) {

return NULL;

}

int format;

if (!PyArg_ParseTuple(args, "i:constevaluator.__call__", &format)) {

return NULL;

}

PyObject *value = ce->value;

if (format == _Py_ANNOTATE_FORMAT_STRING) {

PyUnicodeWriter *writer = PyUnicodeWriter_Create(5); // cannot be <5

if (writer == NULL) {

return NULL;

}

if (PyTuple_Check(value)) {

if (PyUnicodeWriter_WriteChar(writer, '(') < 0) {

PyUnicodeWriter_Discard(writer);

return NULL;

}

for (Py_ssize_t i = 0; i < PyTuple_GET_SIZE(value); i++) {

PyObject *item = PyTuple_GET_ITEM(value, i);

if (i > 0) {

if (PyUnicodeWriter_WriteASCII(writer, ", ", 2) < 0) {

PyUnicodeWriter_Discard(writer);

return NULL;

}

}

if (_Py_typing_type_repr(writer, item) < 0) {

PyUnicodeWriter_Discard(writer);

return NULL;

}

}

if (PyUnicodeWriter_WriteChar(writer, ')') < 0) {

PyUnicodeWriter_Discard(writer);

return NULL;

}

}

else {

if (_Py_typing_type_repr(writer, value) < 0) {

PyUnicodeWriter_Discard(writer);

return NULL;

}

}

return PyUnicodeWriter_Finish(writer);

}

return Py_NewRef(value);

}

static PyObject *

constevaluator_alloc(PyObject *value)

{

PyTypeObject *tp = _PyInterpreterState_GET()->cached_objects.constevaluator_type;

assert(tp != NULL);

constevaluatorobject *ce = PyObject_GC_New(constevaluatorobject, tp);

if (ce == NULL) {

return NULL;

}

ce->value = Py_NewRef(value);

_PyObject_GC_TRACK(ce);

return (PyObject *)ce;

}

PyDoc_STRVAR(constevaluator_doc,

"Internal type for implementing evaluation functions.");

static PyType_Slot constevaluator_slots[] = {

{Py_tp_doc, (void *)constevaluator_doc},

{Py_tp_dealloc, constevaluator_dealloc},

{Py_tp_traverse, constevaluator_traverse},

{Py_tp_clear, constevaluator_clear},

{Py_tp_repr, constevaluator_repr},

{Py_tp_call, constevaluator_call},

{Py_tp_alloc, PyType_GenericAlloc},

{Py_tp_free, PyObject_GC_Del},

{0, NULL},

};

PyType_Spec constevaluator_spec = {

.name = "_typing._ConstEvaluator",

.basicsize = sizeof(constevaluatorobject),

.flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_IMMUTABLETYPE

| Py_TPFLAGS_DISALLOW_INSTANTIATION,

.slots = constevaluator_slots,

};

_Py_typing_type_repr(PyUnicodeWriter *writer, PyObject *p)

{

PyObject *qualname = NULL;

PyObject *module = NULL;

PyObject *r = NULL;

int rc;

if (p == Py_Ellipsis) {

// The Ellipsis object

r = PyUnicode_FromString("...");

goto exit;

}

if (p == (PyObject *)&_PyNone_Type) {

return PyUnicodeWriter_WriteASCII(writer, "None", 4);

}

if ((rc = PyObject_HasAttrWithError(p, &_Py_ID(__origin__))) > 0 &&

(rc = PyObject_HasAttrWithError(p, &_Py_ID(__args__))) > 0)

{

// It looks like a GenericAlias

goto use_repr;

}

if (rc < 0) {

goto exit;

}

if (PyObject_GetOptionalAttr(p, &_Py_ID(__qualname__), &qualname) < 0) {

goto exit;

}

if (qualname == NULL) {

goto use_repr;

}

if (PyObject_GetOptionalAttr(p, &_Py_ID(__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;

}

rc = PyUnicodeWriter_WriteStr(writer, r);

Py_DECREF(r);

return rc;

}

static PyObject *

call_typing_func_object(const char *name, PyObject **args, size_t nargs)

{

PyObject *typing = PyImport_ImportModule("typing");

if (typing == NULL) {

return NULL;

}

PyObject *func = PyObject_GetAttrString(typing, name);

if (func == NULL) {

Py_DECREF(typing);

return NULL;

}

PyObject *result = PyObject_Vectorcall(func, args, nargs, NULL);

Py_DECREF(func);

Py_DECREF(typing);

return result;

}

static PyObject *

type_check(PyObject *arg, const char *msg)

{

// Calling typing.py here leads to bootstrapping problems

if (Py_IsNone(arg)) {

return Py_NewRef(Py_TYPE(arg));

}

PyObject *message_str = PyUnicode_FromString(msg);

if (message_str == NULL) {

return NULL;

}

PyObject *args[2] = {arg, message_str};

PyObject *result = call_typing_func_object("_type_check", args, 2);

Py_DECREF(message_str);

return result;

}

static PyObject *

make_union(PyObject *self, PyObject *other)

{

PyObject *args = PyTuple_Pack(2, self, other);

if (args == NULL) {

return NULL;

}

PyObject *u = _Py_union_from_tuple(args);

Py_DECREF(args);

return u;

}

static PyObject *

caller(void)

{

_PyInterpreterFrame *f = _PyThreadState_GET()->current_frame;

if (f == NULL) {

Py_RETURN_NONE;

}

if (f == NULL || PyStackRef_IsNull(f->f_funcobj)) {

Py_RETURN_NONE;

}

PyObject *r = PyFunction_GetModule(PyStackRef_AsPyObjectBorrow(f->f_funcobj));

if (!r) {

PyErr_Clear();

Py_RETURN_NONE;

}

return Py_NewRef(r);

}

static PyObject *

unpack(PyObject *self)

{

PyObject *typing = PyImport_ImportModule("typing");

if (typing == NULL) {

return NULL;

}

PyObject *unpack = PyObject_GetAttrString(typing, "Unpack");

if (unpack == NULL) {

Py_DECREF(typing);

return NULL;

}

PyObject *unpacked = PyObject_GetItem(unpack, self);

Py_DECREF(typing);

Py_DECREF(unpack);

return unpacked;

}

static int

contains_typevartuple(PyTupleObject *params)

{

Py_ssize_t n = PyTuple_GET_SIZE(params);

PyTypeObject *tp = _PyInterpreterState_GET()->cached_objects.typevartuple_type;

for (Py_ssize_t i = 0; i < n; i++) {

PyObject *param = PyTuple_GET_ITEM(params, i);

if (Py_IS_TYPE(param, tp)) {

return 1;

}

}

return 0;

}

static PyObject *

unpack_typevartuples(PyObject *params)

{

assert(PyTuple_Check(params));

// TypeVarTuple must be unpacked when passed to Generic, so we do that here.

if (contains_typevartuple((PyTupleObject *)params)) {

Py_ssize_t n = PyTuple_GET_SIZE(params);

PyObject *new_params = PyTuple_New(n);

if (new_params == NULL) {

return NULL;

}

PyTypeObject *tp = _PyInterpreterState_GET()->cached_objects.typevartuple_type;

for (Py_ssize_t i = 0; i < n; i++) {

PyObject *param = PyTuple_GET_ITEM(params, i);

if (Py_IS_TYPE(param, tp)) {

PyObject *unpacked = unpack(param);

if (unpacked == NULL) {

Py_DECREF(new_params);

return NULL;

}

PyTuple_SET_ITEM(new_params, i, unpacked);

}

else {

PyTuple_SET_ITEM(new_params, i, Py_NewRef(param));

}

}

return new_params;

}

else {

return Py_NewRef(params);

}

}

static void

typevar_dealloc(PyObject *self)

{

PyTypeObject *tp = Py_TYPE(self);

typevarobject *tv = typevarobject_CAST(self);

_PyObject_GC_UNTRACK(self);

Py_XDECREF(tv->name);

Py_XDECREF(tv->bound);

Py_XDECREF(tv->evaluate_bound);

Py_XDECREF(tv->constraints);

Py_XDECREF(tv->evaluate_constraints);

Py_XDECREF(tv->default_value);

Py_XDECREF(tv->evaluate_default);

PyObject_ClearManagedDict(self);

PyObject_ClearWeakRefs(self);

Py_TYPE(self)->tp_free(self);

Py_DECREF(tp);

}

static int

typevar_traverse(PyObject *self, visitproc visit, void *arg)

{

Py_VISIT(Py_TYPE(self));

typevarobject *tv = typevarobject_CAST(self);

Py_VISIT(tv->name);

Py_VISIT(tv->bound);

Py_VISIT(tv->evaluate_bound);

Py_VISIT(tv->constraints);

Py_VISIT(tv->evaluate_constraints);

Py_VISIT(tv->default_value);

Py_VISIT(tv->evaluate_default);

return PyObject_VisitManagedDict(self, visit, arg);

}

static int

typevar_clear(PyObject *op)

{

typevarobject *self = typevarobject_CAST(op);

Py_CLEAR(self->name);

Py_CLEAR(self->bound);

Py_CLEAR(self->evaluate_bound);

Py_CLEAR(self->constraints);

Py_CLEAR(self->evaluate_constraints);

Py_CLEAR(self->default_value);

Py_CLEAR(self->evaluate_default);

PyObject_ClearManagedDict(op);

return 0;

}

static PyObject *

typevar_repr(PyObject *self)

{

typevarobject *tv = typevarobject_CAST(self);

if (tv->infer_variance) {

return Py_NewRef(tv->name);

}

char variance = tv->covariant ? '+' : tv->contravariant ? '-' : '~';

return PyUnicode_FromFormat("%c%U", variance, tv->name);

}

static PyMemberDef typevar_members[] = {

{"__name__", _Py_T_OBJECT, offsetof(typevarobject, name), Py_READONLY},

{"__covariant__", Py_T_BOOL, offsetof(typevarobject, covariant), Py_READONLY},

{"__contravariant__", Py_T_BOOL, offsetof(typevarobject, contravariant), Py_READONLY},

{"__infer_variance__", Py_T_BOOL, offsetof(typevarobject, infer_variance), Py_READONLY},

{0}

};

static PyObject *

typevar_bound(PyObject *op, void *Py_UNUSED(closure))

{

typevarobject *self = typevarobject_CAST(op);

if (self->bound != NULL) {

return Py_NewRef(self->bound);

}

if (self->evaluate_bound == NULL) {

Py_RETURN_NONE;

}

PyObject *bound = PyObject_CallNoArgs(self->evaluate_bound);

self->bound = Py_XNewRef(bound);

return bound;

}

static PyObject *

typevar_default(PyObject *op, void *Py_UNUSED(closure))

{

typevarobject *self = typevarobject_CAST(op);

if (self->default_value != NULL) {

return Py_NewRef(self->default_value);

}

if (self->evaluate_default == NULL) {

return &_Py_NoDefaultStruct;

}

PyObject *default_value = PyObject_CallNoArgs(self->evaluate_default);

self->default_value = Py_XNewRef(default_value);

return default_value;

}

static PyObject *

typevar_constraints(PyObject *op, void *Py_UNUSED(closure))

{

typevarobject *self = typevarobject_CAST(op);

if (self->constraints != NULL) {

return Py_NewRef(self->constraints);

}

if (self->evaluate_constraints == NULL) {

return PyTuple_New(0);

}

PyObject *constraints = PyObject_CallNoArgs(self->evaluate_constraints);

self->constraints = Py_XNewRef(constraints);

return constraints;

}

static PyObject *

typevar_evaluate_bound(PyObject *op, void *Py_UNUSED(closure))

{

typevarobject *self = typevarobject_CAST(op);

if (self->evaluate_bound != NULL) {

return Py_NewRef(self->evaluate_bound);

}

if (self->bound != NULL) {

return constevaluator_alloc(self->bound);

}

Py_RETURN_NONE;

}

static PyObject *

typevar_evaluate_constraints(PyObject *op, void *Py_UNUSED(closure))

{

typevarobject *self = typevarobject_CAST(op);

if (self->evaluate_constraints != NULL) {

return Py_NewRef(self->evaluate_constraints);

}

if (self->constraints != NULL) {

return constevaluator_alloc(self->constraints);

}

Py_RETURN_NONE;

}

static PyObject *

typevar_evaluate_default(PyObject *op, void *Py_UNUSED(closure))

{

typevarobject *self = typevarobject_CAST(op);

if (self->evaluate_default != NULL) {

return Py_NewRef(self->evaluate_default);

}

if (self->default_value != NULL) {

return constevaluator_alloc(self->default_value);

}

Py_RETURN_NONE;

}

static PyGetSetDef typevar_getset[] = {

{"__bound__", typevar_bound, NULL, NULL, NULL},

{"__constraints__", typevar_constraints, NULL, NULL, NULL},

{"__default__", typevar_default, NULL, NULL, NULL},

{"evaluate_bound", typevar_evaluate_bound, NULL, NULL, NULL},

{"evaluate_constraints", typevar_evaluate_constraints, NULL, NULL, NULL},

{"evaluate_default", typevar_evaluate_default, NULL, NULL, NULL},

{0}

};

static typevarobject *

typevar_alloc(PyObject *name, PyObject *bound, PyObject *evaluate_bound,

PyObject *module)

{

PyTypeObject *tp = _PyInterpreterState_GET()->cached_objects.typevar_type;

assert(tp != NULL);

typevarobject *tv = PyObject_GC_New(typevarobject, tp);

if (tv == NULL) {

return NULL;

}

tv->name = Py_NewRef(name);

tv->bound = Py_XNewRef(bound);

tv->evaluate_bound = Py_XNewRef(evaluate_bound);

tv->constraints = Py_XNewRef(constraints);

tv->evaluate_constraints = Py_XNewRef(evaluate_constraints);

tv->default_value = Py_XNewRef(default_value);

tv->evaluate_default = NULL;

tv->covariant = covariant;

tv->contravariant = contravariant;

tv->infer_variance = infer_variance;

_PyObject_GC_TRACK(tv);

if (module != NULL) {

if (PyObject_SetAttrString((PyObject *)tv, "__module__", module) < 0) {

Py_DECREF(tv);

return NULL;

}

}

return tv;

}

static PyObject *

typevar_new_impl(PyTypeObject *type, PyObject *name, PyObject *constraints,

PyObject *bound, PyObject *default_value, int covariant,

int contravariant, int infer_variance)

{

if (covariant && contravariant) {

PyErr_SetString(PyExc_ValueError,

"Bivariant types are not supported.");

return NULL;

}

if (infer_variance && (covariant || contravariant)) {

PyErr_SetString(PyExc_ValueError,

"Variance cannot be specified with infer_variance.");

return NULL;

}

if (Py_IsNone(bound)) {

bound = NULL;

}

if (bound != NULL) {

bound = type_check(bound, "Bound must be a type.");

if (bound == NULL) {

return NULL;

}

}

assert(PyTuple_CheckExact(constraints));

Py_ssize_t n_constraints = PyTuple_GET_SIZE(constraints);

if (n_constraints == 1) {

PyErr_SetString(PyExc_TypeError,

"A single constraint is not allowed");

Py_XDECREF(bound);

return NULL;

} else if (n_constraints == 0) {

constraints = NULL;

} else if (bound != NULL) {

PyErr_SetString(PyExc_TypeError,

"Constraints cannot be combined with bound=...");

Py_XDECREF(bound);

return NULL;

}

PyObject *module = caller();

if (module == NULL) {

Py_XDECREF(bound);

return NULL;

}

PyObject *tv = (PyObject *)typevar_alloc(name, bound, NULL,

constraints, NULL,

default_value,

covariant, contravariant,

infer_variance, module);

Py_XDECREF(bound);

Py_XDECREF(module);

return tv;

}

static PyObject *

typevar_typing_subst_impl(typevarobject *self, PyObject *arg)

{

PyObject *args[2] = {(PyObject *)self, arg};

PyObject *result = call_typing_func_object("_typevar_subst", args, 2);

return result;

}

static PyObject *

typevar_typing_prepare_subst_impl(typevarobject *self, PyObject *alias,

PyObject *args)

{

PyObject *params = PyObject_GetAttrString(alias, "__parameters__");

if (params == NULL) {

return NULL;

}

Py_ssize_t i = PySequence_Index(params, (PyObject *)self);

if (i == -1) {

Py_DECREF(params);

return NULL;

}

Py_ssize_t args_len = PySequence_Length(args);

if (args_len == -1) {

Py_DECREF(params);

return NULL;

}

if (i < args_len) {

// We already have a value for our TypeVar

Py_DECREF(params);

return Py_NewRef(args);

}

else if (i == args_len) {

// If the TypeVar has a default, use it.

PyObject *dflt = typevar_default((PyObject *)self, NULL);

if (dflt == NULL) {

Py_DECREF(params);

return NULL;

}

if (dflt != &_Py_NoDefaultStruct) {

PyObject *new_args = PyTuple_Pack(1, dflt);

Py_DECREF(dflt);

if (new_args == NULL) {

Py_DECREF(params);

return NULL;

}

PyObject *result = PySequence_Concat(args, new_args);

Py_DECREF(params);

Py_DECREF(new_args);

return result;

}

}

Py_DECREF(params);

PyErr_Format(PyExc_TypeError,

"Too few arguments for %S; actual %zd, expected at least %zd",

alias, args_len, i + 1);

return NULL;

}

static PyObject *

typevar_reduce_impl(typevarobject *self)

{

return Py_NewRef(self->name);

}

static PyObject *

typevar_has_default_impl(typevarobject *self)

{

if (self->evaluate_default != NULL ||

(self->default_value != &_Py_NoDefaultStruct && self->default_value != NULL)) {

Py_RETURN_TRUE;

}

Py_RETURN_FALSE;

}

static PyObject *

typevar_mro_entries(PyObject *self, PyObject *args)

{

PyErr_SetString(PyExc_TypeError,

"Cannot subclass an instance of TypeVar");

return NULL;

}

static PyMethodDef typevar_methods[] = {

TYPEVAR_TYPING_SUBST_METHODDEF

TYPEVAR_TYPING_PREPARE_SUBST_METHODDEF

TYPEVAR_REDUCE_METHODDEF

TYPEVAR_HAS_DEFAULT_METHODDEF

{"__mro_entries__", typevar_mro_entries, METH_O},

{0}

};

PyDoc_STRVAR(typevar_doc,

");

static PyType_Slot typevar_slots[] = {

{Py_tp_doc, (void *)typevar_doc},

{Py_tp_methods, typevar_methods},

{Py_nb_or, make_union},

{Py_tp_new, typevar_new},

{Py_tp_dealloc, typevar_dealloc},

{Py_tp_alloc, PyType_GenericAlloc},

{Py_tp_free, PyObject_GC_Del},

{Py_tp_traverse, typevar_traverse},

{Py_tp_clear, typevar_clear},

{Py_tp_repr, typevar_repr},

{Py_tp_members, typevar_members},

{Py_tp_getset, typevar_getset},

{0, NULL},

};

PyType_Spec typevar_spec = {

.name = "typing.TypeVar",

.basicsize = sizeof(typevarobject),

.flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_IMMUTABLETYPE

| Py_TPFLAGS_MANAGED_DICT | Py_TPFLAGS_MANAGED_WEAKREF,

.slots = typevar_slots,

};

typedef struct {

PyObject_HEAD

PyObject *__origin__;

} paramspecattrobject;

#define paramspecattrobject_CAST(op) ((paramspecattrobject *)(op))

static void

paramspecattr_dealloc(PyObject *self)

{

PyTypeObject *tp = Py_TYPE(self);

paramspecattrobject *psa = paramspecattrobject_CAST(self);

_PyObject_GC_UNTRACK(self);

Py_XDECREF(psa->__origin__);

Py_TYPE(self)->tp_free(self);

Py_DECREF(tp);

}

static int

paramspecattr_traverse(PyObject *self, visitproc visit, void *arg)

{

paramspecattrobject *psa = paramspecattrobject_CAST(self);

Py_VISIT(psa->__origin__);

return 0;

}

static int

paramspecattr_clear(PyObject *op)

{

paramspecattrobject *self = paramspecattrobject_CAST(op);

Py_CLEAR(self->__origin__);

return 0;

}

static PyObject *

paramspecattr_richcompare(PyObject *a, PyObject *b, int op)

{

if (!Py_IS_TYPE(a, Py_TYPE(b))) {

Py_RETURN_NOTIMPLEMENTED;

}

if (op != Py_EQ && op != Py_NE) {

Py_RETURN_NOTIMPLEMENTED;

}

paramspecattrobject *lhs = paramspecattrobject_CAST(a); // may be unsafe

paramspecattrobject *rhs = (paramspecattrobject *)b; // safe fast cast

return PyObject_RichCompare(lhs->__origin__, rhs->__origin__, op);

}

static PyMemberDef paramspecattr_members[] = {

{"__origin__", _Py_T_OBJECT, offsetof(paramspecattrobject, __origin__), Py_READONLY},

{0}

};

static paramspecattrobject *

paramspecattr_new(PyTypeObject *tp, PyObject *origin)

{

paramspecattrobject *psa = PyObject_GC_New(paramspecattrobject, tp);

if (psa == NULL) {

return NULL;