// TypeVar, TypeVarTuple, ParamSpec, and TypeAlias

#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"

/*[clinic input]

class typevar "typevarobject *" "&_PyTypeVar_Type"

class paramspec "paramspecobject *" "&_PyParamSpec_Type"

class paramspecargs "paramspecattrobject *" "&_PyParamSpecArgs_Type"

class paramspeckwargs "paramspecattrobject *" "&_PyParamSpecKwargs_Type"

class typevartuple "typevartupleobject *" "&_PyTypeVarTuple_Type"

class typealias "typealiasobject *" "&_PyTypeAlias_Type"

class Generic "PyObject *" "&PyGeneric_Type"

[clinic start generated code]*/

/*[clinic end generated code: output=da39a3ee5e6b4b0d input=aa86741931a0f55c]*/

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"

/* NoDefault is a marker object to indicate that a parameter has no default. */

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

* we accidentally decref NoDefault out of existence. Instead,

* since NoDefault is an immortal object, re-set the reference count.

*/

_Py_SetImmortal(nodefault);

}

PyDoc_STRVAR(nodefault_doc,

"NoDefaultType()\n"

"--\n\n"

"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,

"_ConstEvaluator()\n"

"--\n\n"

"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,

};

int

_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;

}

/*

* Return a typing.Union. This is used as the nb_or (|) operator for

* TypeVar and ParamSpec. We use this rather than _Py_union_type_or

* (which would produce a types.Union) because historically TypeVar

* supported unions with string forward references, and we want to

* preserve that behavior. _Py_union_type_or only allows a small set

* of types.

*/

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 *constraints, PyObject *evaluate_constraints,

PyObject *default_value,

bool covariant, bool contravariant, bool infer_variance,

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;

}

/*[clinic input]

@classmethod

typevar.__new__ as typevar_new

name: object(subclass_of="&PyUnicode_Type")

*constraints: tuple

bound: object = None

default as default_value: object(c_default="&_Py_NoDefaultStruct") = typing.NoDefault

covariant: bool = False

contravariant: bool = False

infer_variance: bool = False

Create a TypeVar.

[clinic start generated code]*/

static PyObject *

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

PyObject *bound, PyObject *default_value, int covariant,

int contravariant, int infer_variance)

/*[clinic end generated code: output=d2b248ff074eaab6 input=1b5b62e40c92c167]*/

{

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;

}

/*[clinic input]

typevar.__typing_subst__ as typevar_typing_subst

arg: object

/

[clinic start generated code]*/

static PyObject *

typevar_typing_subst_impl(typevarobject *self, PyObject *arg)

/*[clinic end generated code: output=c76ced134ed8f4e1 input=9e87b57f0fc59b92]*/

{

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

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

return result;

}

/*[clinic input]

typevar.__typing_prepare_subst__ as typevar_typing_prepare_subst

alias: object

args: object

/

[clinic start generated code]*/

static PyObject *

typevar_typing_prepare_subst_impl(typevarobject *self, PyObject *alias,

PyObject *args)

/*[clinic end generated code: output=82c3f4691e0ded22 input=201a750415d14ffb]*/

{

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;

}

/*[clinic input]

typevar.__reduce__ as typevar_reduce

[clinic start generated code]*/

static PyObject *

typevar_reduce_impl(typevarobject *self)

/*[clinic end generated code: output=02e5c55d7cf8a08f input=de76bc95f04fb9ff]*/

{

return Py_NewRef(self->name);

}

/*[clinic input]

typevar.has_default as typevar_has_default

[clinic start generated code]*/

static PyObject *

typevar_has_default_impl(typevarobject *self)

/*[clinic end generated code: output=76bf0b8dc98b97dd input=31024aa030761cf6]*/

{

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,

"Type variable.\n\

\n\

The preferred way to construct a type variable is via the dedicated\n\

syntax for generic functions, classes, and type aliases::\n\

\n\

class Sequence[T]: # T is a TypeVar\n\

...\n\

\n\

This syntax can also be used to create bound and constrained type\n\

variables::\n\

\n\

# S is a TypeVar bound to str\n\

class StrSequence[S: str]:\n\

...\n\

\n\

# A is a TypeVar constrained to str or bytes\n\

class StrOrBytesSequence[A: (str, bytes)]:\n\

...\n\

\n\

Type variables can also have defaults:\n\

\n\

class IntDefault[T = int]:\n\

...\n\

\n\

However, if desired, reusable type variables can also be constructed\n\

manually, like so::\n\

\n\

T = TypeVar('T') # Can be anything\n\

S = TypeVar('S', bound=str) # Can be any subtype of str\n\

A = TypeVar('A', str, bytes) # Must be exactly str or bytes\n\

D = TypeVar('D', default=int) # Defaults to int\n\

\n\

Type variables exist primarily for the benefit of static type\n\

checkers. They serve as the parameters for generic types as well\n\

as for generic function and type alias definitions.\n\

\n\

The variance of type variables is inferred by type checkers when they\n\

are created through the type parameter syntax and when\n\

``infer_variance=True`` is passed. Manually created type variables may\n\

be explicitly marked covariant or contravariant by passing\n\

``covariant=True`` or ``contravariant=True``. By default, manually\n\

created type variables are invariant. See PEP 484 and PEP 695 for more\n\

details.\n\

");

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;