Mirrors
/
cpython
mirror of https://github.com/python/cpython
3
0
Fork 0
Code Releases Activity
Browse Source

bpo-40408: Fix support of nested type variables in GenericAlias. (GH-19836)

pull/19898/head
Serhiy Storchaka 6 years ago
committed by GitHub
parent
603d354626
commit
41a64587a0
No known key found for this signature in database GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 140 additions and 26 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 41
      Lib/test/test_genericalias.py
  2. 2
      Misc/NEWS.d/next/Core and Builtins/2020-05-01-15-36-14.bpo-40408.XzQI59.rst
  3. 123
      Objects/genericaliasobject.c

41
Lib/test/test_genericalias.py
View File

@ -41,6 +41,8 @@ import typing
from typing import TypeVar
T = TypeVar('T')
K = TypeVar('K')
V = TypeVar('V')
class BaseTest(unittest.TestCase):
"""Test basics."""
@ -170,10 +172,7 @@ class BaseTest(unittest.TestCase):
self.assertEqual(a.__parameters__, ())
def test_parameters(self):
from typing import TypeVar
T = TypeVar('T')
K = TypeVar('K')
V = TypeVar('V')
from typing import List, Dict, Callable
D0 = dict[str, int]
self.assertEqual(D0.__args__, (str, int))
self.assertEqual(D0.__parameters__, ())
@ -195,14 +194,43 @@ class BaseTest(unittest.TestCase):
L1 = list[T]
self.assertEqual(L1.__args__, (T,))
self.assertEqual(L1.__parameters__, (T,))
L2 = list[list[T]]
self.assertEqual(L2.__args__, (list[T],))
self.assertEqual(L2.__parameters__, (T,))
L3 = list[List[T]]
self.assertEqual(L3.__args__, (List[T],))
self.assertEqual(L3.__parameters__, (T,))
L4a = list[Dict[K, V]]
self.assertEqual(L4a.__args__, (Dict[K, V],))
self.assertEqual(L4a.__parameters__, (K, V))
L4b = list[Dict[T, int]]
self.assertEqual(L4b.__args__, (Dict[T, int],))
self.assertEqual(L4b.__parameters__, (T,))
L5 = list[Callable[[K, V], K]]
self.assertEqual(L5.__args__, (Callable[[K, V], K],))
self.assertEqual(L5.__parameters__, (K, V))
def test_parameter_chaining(self):
from typing import TypeVar
T = TypeVar('T')
from typing import List, Dict, Union, Callable
self.assertEqual(list[T][int], list[int])
self.assertEqual(dict[str, T][int], dict[str, int])
self.assertEqual(dict[T, int][str], dict[str, int])
self.assertEqual(dict[K, V][str, int], dict[str, int])
self.assertEqual(dict[T, T][int], dict[int, int])
self.assertEqual(list[list[T]][int], list[list[int]])
self.assertEqual(list[dict[T, int]][str], list[dict[str, int]])
self.assertEqual(list[dict[str, T]][int], list[dict[str, int]])
self.assertEqual(list[dict[K, V]][str, int], list[dict[str, int]])
self.assertEqual(dict[T, list[int]][str], dict[str, list[int]])
self.assertEqual(list[List[T]][int], list[List[int]])
self.assertEqual(list[Dict[K, V]][str, int], list[Dict[str, int]])
self.assertEqual(list[Union[K, V]][str, int], list[Union[str, int]])
self.assertEqual(list[Callable[[K, V], K]][str, int],
list[Callable[[str, int], str]])
self.assertEqual(dict[T, List[int]][str], dict[str, List[int]])
with self.assertRaises(TypeError):
list[int][int]
dict[T, int][str, int]
@ -255,7 +283,6 @@ class BaseTest(unittest.TestCase):
self.assertEqual(a.__parameters__, ())
def test_union_generic(self):
T = typing.TypeVar('T')
a = typing.Union[list[T], tuple[T, ...]]
self.assertEqual(a.__args__, (list[T], tuple[T, ...]))
self.assertEqual(a.__parameters__, (T,))

2
Misc/NEWS.d/next/Core and Builtins/2020-05-01-15-36-14.bpo-40408.XzQI59.rst
View File

@ -0,0 +1,2 @@
Fixed support of nested type variables in GenericAlias (e.g.
``list[list[T]]``).

123
Objects/genericaliasobject.c
View File

@ -182,28 +182,60 @@ tuple_index(PyObject *self, Py_ssize_t len, PyObject *item)
return -1;
}
// tuple(t for t in args if isinstance(t, TypeVar))
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 len = PyTuple_GET_SIZE(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 < len; iarg++) {
for (Py_ssize_t iarg = 0; iarg < nargs; iarg++) {
PyObject *t = PyTuple_GET_ITEM(args, iarg);
int typevar = is_typevar(t);
if (typevar < 0) {
Py_XDECREF(parameters);
Py_DECREF(parameters);
return NULL;
}
if (typevar) {
if (tuple_index(parameters, iparam, t) < 0) {
Py_INCREF(t);
PyTuple_SET_ITEM(parameters, iparam, t);
iparam++;
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(&parameters, 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) {
@ -215,6 +247,48 @@ make_parameters(PyObject *args)
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];
}
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)
{
@ -233,17 +307,25 @@ ga_getitem(PyObject *self, PyObject *item)
self);
}
int is_tuple = PyTuple_Check(item);
Py_ssize_t nitem = is_tuple ? PyTuple_GET_SIZE(item) : 1;
if (nitem != nparams) {
Py_ssize_t nitems = is_tuple ? PyTuple_GET_SIZE(item) : 1;
PyObject **argitems = is_tuple ? &PyTuple_GET_ITEM(item, 0) : &item;
if (nitems != nparams) {
return PyErr_Format(PyExc_TypeError,
"Too %s arguments for %R",
nitem > nparams ? "many" : "few",
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)
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_typevar(arg);
@ -254,18 +336,21 @@ ga_getitem(PyObject *self, PyObject *item)
if (typevar) {
Py_ssize_t iparam = tuple_index(alias->parameters, nparams, arg);
assert(iparam >= 0);
if (is_tuple) {
arg = PyTuple_GET_ITEM(item, iparam);
}
else {
assert(iparam == 0);
arg = item;
arg = argitems[iparam];
Py_INCREF(arg);
}
else {
arg = subs_tvars(arg, alias->parameters, argitems);
if (arg == NULL) {
Py_DECREF(newargs);
return NULL;
}
}
Py_INCREF(arg);
PyTuple_SET_ITEM(newargs, iarg, arg);
}
PyObject *res = Py_GenericAlias(alias->origin, newargs);
Py_DECREF(newargs);
return res;
}

Write Preview
Loading…
Cancel
Save