| |
| |
| |
| |
| @@ -12,6 +12,7 @@ |
| import stat |
| import sys |
| import sysconfig |
| +import textwrap |
| import time |
| import types |
| import unittest |
| @@ -619,6 +620,14 @@ def sortdict(dict): |
| withcommas = ", ".join(reprpairs) |
| return "{%s}" % withcommas |
| |
| + |
| +def run_code(code: str) -> dict[str, object]: |
| + """Run a piece of code after dedenting it, and return its global namespace.""" |
| + ns = {} |
| + exec(textwrap.dedent(code), ns) |
| + return ns |
| + |
| + |
| def check_syntax_error(testcase, statement, errtext='', *, lineno=None, offset=None): |
| with testcase.assertRaisesRegex(SyntaxError, errtext) as cm: |
| compile(statement, '<test string>', 'exec') |
| |
| |
| |
| |
| @@ -181,7 +181,22 @@ def to_tuple(t): |
| "def f(a=1, /, b=2, *, c): pass", |
| "def f(a=1, /, b=2, *, c=4, **kwargs): pass", |
| "def f(a=1, /, b=2, *, c, **kwargs): pass", |
| - |
| + # Type aliases |
| + "type X = int", |
| + "type X[T] = int", |
| + "type X[T, *Ts, **P] = (T, Ts, P)", |
| + "type X[T: int, *Ts, **P] = (T, Ts, P)", |
| + "type X[T: (int, str), *Ts, **P] = (T, Ts, P)", |
| + # Generic classes |
| + "class X[T]: pass", |
| + "class X[T, *Ts, **P]: pass", |
| + "class X[T: int, *Ts, **P]: pass", |
| + "class X[T: (int, str), *Ts, **P]: pass", |
| + # Generic functions |
| + "def f[T](): pass", |
| + "def f[T, *Ts, **P](): pass", |
| + "def f[T: int, *Ts, **P](): pass", |
| + "def f[T: (int, str), *Ts, **P](): pass", |
| ] |
| |
| # These are compiled through "single" |
| @@ -262,7 +277,6 @@ def to_tuple(t): |
| "()", |
| # Combination |
| "a.b.c.d(a.b[1:2])", |
| - |
| ] |
| |
| # TODO: expr_context, slice, boolop, operator, unaryop, cmpop, comprehension |
| @@ -1013,6 +1027,18 @@ def test_exception_groups_feature_version(self): |
| with self.assertRaises(SyntaxError): |
| ast.parse(code, feature_version=(3, 10)) |
| |
| + def test_type_params_feature_version(self): |
| + samples = [ |
| + "type X = int", |
| + "class X[T]: pass", |
| + "def f[T](): pass", |
| + ] |
| + for sample in samples: |
| + with self.subTest(sample): |
| + ast.parse(sample) |
| + with self.assertRaises(SyntaxError): |
| + ast.parse(sample, feature_version=(3, 11)) |
| + |
| def test_invalid_major_feature_version(self): |
| with self.assertRaises(ValueError): |
| ast.parse('pass', feature_version=(2, 7)) |
| @@ -1557,16 +1583,16 @@ def arguments(args=None, posonlyargs=None, vararg=None, |
| |
| def test_funcdef(self): |
| a = ast.arguments([], [], None, [], [], None, []) |
| - f = ast.FunctionDef("x", a, [], [], None) |
| + f = ast.FunctionDef("x", [], a, [], [], None) |
| self.stmt(f, "empty body on FunctionDef") |
| - f = ast.FunctionDef("x", a, [ast.Pass()], [ast.Name("x", ast.Store())], |
| + f = ast.FunctionDef("x", [], a, [ast.Pass()], [ast.Name("x", ast.Store())], |
| None) |
| self.stmt(f, "must have Load context") |
| - f = ast.FunctionDef("x", a, [ast.Pass()], [], |
| + f = ast.FunctionDef("x", [], a, [ast.Pass()], [], |
| ast.Name("x", ast.Store())) |
| self.stmt(f, "must have Load context") |
| def fac(args): |
| - return ast.FunctionDef("x", args, [ast.Pass()], [], None) |
| + return ast.FunctionDef("x", [], args, [ast.Pass()], [], None) |
| self._check_arguments(fac, self.stmt) |
| |
| def test_classdef(self): |
| @@ -1579,7 +1605,7 @@ def cls(bases=None, keywords=None, body=None, decorator_list=None): |
| body = [ast.Pass()] |
| if decorator_list is None: |
| decorator_list = [] |
| - return ast.ClassDef("myclass", bases, keywords, |
| + return ast.ClassDef("myclass", [], bases, keywords, |
| body, decorator_list) |
| self.stmt(cls(bases=[ast.Name("x", ast.Store())]), |
| "must have Load context") |
| @@ -2869,23 +2895,23 @@ def main(): |
| exec_results = [ |
| ('Module', [('Expr', (1, 0, 1, 4), ('Constant', (1, 0, 1, 4), None, None))], []), |
| ('Module', [('Expr', (1, 0, 1, 18), ('Constant', (1, 0, 1, 18), 'module docstring', None))], []), |
| -('Module', [('FunctionDef', (1, 0, 1, 13), 'f', ('arguments', [], [], None, [], [], None, []), [('Pass', (1, 9, 1, 13))], [], None, None)], []), |
| -('Module', [('FunctionDef', (1, 0, 1, 29), 'f', ('arguments', [], [], None, [], [], None, []), [('Expr', (1, 9, 1, 29), ('Constant', (1, 9, 1, 29), 'function docstring', None))], [], None, None)], []), |
| -('Module', [('FunctionDef', (1, 0, 1, 14), 'f', ('arguments', [], [('arg', (1, 6, 1, 7), 'a', None, None)], None, [], [], None, []), [('Pass', (1, 10, 1, 14))], [], None, None)], []), |
| -('Module', [('FunctionDef', (1, 0, 1, 16), 'f', ('arguments', [], [('arg', (1, 6, 1, 7), 'a', None, None)], None, [], [], None, [('Constant', (1, 8, 1, 9), 0, None)]), [('Pass', (1, 12, 1, 16))], [], None, None)], []), |
| -('Module', [('FunctionDef', (1, 0, 1, 18), 'f', ('arguments', [], [], ('arg', (1, 7, 1, 11), 'args', None, None), [], [], None, []), [('Pass', (1, 14, 1, 18))], [], None, None)], []), |
| -('Module', [('FunctionDef', (1, 0, 1, 23), 'f', ('arguments', [], [], ('arg', (1, 7, 1, 16), 'args', ('Starred', (1, 13, 1, 16), ('Name', (1, 14, 1, 16), 'Ts', ('Load',)), ('Load',)), None), [], [], None, []), [('Pass', (1, 19, 1, 23))], [], None, None)], []), |
| -('Module', [('FunctionDef', (1, 0, 1, 36), 'f', ('arguments', [], [], ('arg', (1, 7, 1, 29), 'args', ('Starred', (1, 13, 1, 29), ('Subscript', (1, 14, 1, 29), ('Name', (1, 14, 1, 19), 'tuple', ('Load',)), ('Tuple', (1, 20, 1, 28), [('Name', (1, 20, 1, 23), 'int', ('Load',)), ('Constant', (1, 25, 1, 28), Ellipsis, None)], ('Load',)), ('Load',)), ('Load',)), None), [], [], None, []), [('Pass', (1, 32, 1, 36))], [], None, None)], []), |
| -('Module', [('FunctionDef', (1, 0, 1, 36), 'f', ('arguments', [], [], ('arg', (1, 7, 1, 29), 'args', ('Starred', (1, 13, 1, 29), ('Subscript', (1, 14, 1, 29), ('Name', (1, 14, 1, 19), 'tuple', ('Load',)), ('Tuple', (1, 20, 1, 28), [('Name', (1, 20, 1, 23), 'int', ('Load',)), ('Starred', (1, 25, 1, 28), ('Name', (1, 26, 1, 28), 'Ts', ('Load',)), ('Load',))], ('Load',)), ('Load',)), ('Load',)), None), [], [], None, []), [('Pass', (1, 32, 1, 36))], [], None, None)], []), |
| -('Module', [('FunctionDef', (1, 0, 1, 21), 'f', ('arguments', [], [], None, [], [], ('arg', (1, 8, 1, 14), 'kwargs', None, None), []), [('Pass', (1, 17, 1, 21))], [], None, None)], []), |
| -('Module', [('FunctionDef', (1, 0, 1, 71), 'f', ('arguments', [], [('arg', (1, 6, 1, 7), 'a', None, None), ('arg', (1, 9, 1, 10), 'b', None, None), ('arg', (1, 14, 1, 15), 'c', None, None), ('arg', (1, 22, 1, 23), 'd', None, None), ('arg', (1, 28, 1, 29), 'e', None, None)], ('arg', (1, 35, 1, 39), 'args', None, None), [('arg', (1, 41, 1, 42), 'f', None, None)], [('Constant', (1, 43, 1, 45), 42, None)], ('arg', (1, 49, 1, 55), 'kwargs', None, None), [('Constant', (1, 11, 1, 12), 1, None), ('Constant', (1, 16, 1, 20), None, None), ('List', (1, 24, 1, 26), [], ('Load',)), ('Dict', (1, 30, 1, 32), [], [])]), [('Expr', (1, 58, 1, 71), ('Constant', (1, 58, 1, 71), 'doc for f()', None))], [], None, None)], []), |
| -('Module', [('FunctionDef', (1, 0, 1, 27), 'f', ('arguments', [], [], None, [], [], None, []), [('Pass', (1, 23, 1, 27))], [], ('Subscript', (1, 11, 1, 21), ('Name', (1, 11, 1, 16), 'tuple', ('Load',)), ('Tuple', (1, 17, 1, 20), [('Starred', (1, 17, 1, 20), ('Name', (1, 18, 1, 20), 'Ts', ('Load',)), ('Load',))], ('Load',)), ('Load',)), None)], []), |
| -('Module', [('FunctionDef', (1, 0, 1, 32), 'f', ('arguments', [], [], None, [], [], None, []), [('Pass', (1, 28, 1, 32))], [], ('Subscript', (1, 11, 1, 26), ('Name', (1, 11, 1, 16), 'tuple', ('Load',)), ('Tuple', (1, 17, 1, 25), [('Name', (1, 17, 1, 20), 'int', ('Load',)), ('Starred', (1, 22, 1, 25), ('Name', (1, 23, 1, 25), 'Ts', ('Load',)), ('Load',))], ('Load',)), ('Load',)), None)], []), |
| -('Module', [('FunctionDef', (1, 0, 1, 45), 'f', ('arguments', [], [], None, [], [], None, []), [('Pass', (1, 41, 1, 45))], [], ('Subscript', (1, 11, 1, 39), ('Name', (1, 11, 1, 16), 'tuple', ('Load',)), ('Tuple', (1, 17, 1, 38), [('Name', (1, 17, 1, 20), 'int', ('Load',)), ('Starred', (1, 22, 1, 38), ('Subscript', (1, 23, 1, 38), ('Name', (1, 23, 1, 28), 'tuple', ('Load',)), ('Tuple', (1, 29, 1, 37), [('Name', (1, 29, 1, 32), 'int', ('Load',)), ('Constant', (1, 34, 1, 37), Ellipsis, None)], ('Load',)), ('Load',)), ('Load',))], ('Load',)), ('Load',)), None)], []), |
| -('Module', [('ClassDef', (1, 0, 1, 12), 'C', [], [], [('Pass', (1, 8, 1, 12))], [])], []), |
| -('Module', [('ClassDef', (1, 0, 1, 32), 'C', [], [], [('Expr', (1, 9, 1, 32), ('Constant', (1, 9, 1, 32), 'docstring for class C', None))], [])], []), |
| -('Module', [('ClassDef', (1, 0, 1, 21), 'C', [('Name', (1, 8, 1, 14), 'object', ('Load',))], [], [('Pass', (1, 17, 1, 21))], [])], []), |
| -('Module', [('FunctionDef', (1, 0, 1, 16), 'f', ('arguments', [], [], None, [], [], None, []), [('Return', (1, 8, 1, 16), ('Constant', (1, 15, 1, 16), 1, None))], [], None, None)], []), |
| +('Module', [('FunctionDef', (1, 0, 1, 13), 'f', [], ('arguments', [], [], None, [], [], None, []), [('Pass', (1, 9, 1, 13))], [], None, None)], []), |
| +('Module', [('FunctionDef', (1, 0, 1, 29), 'f', [], ('arguments', [], [], None, [], [], None, []), [('Expr', (1, 9, 1, 29), ('Constant', (1, 9, 1, 29), 'function docstring', None))], [], None, None)], []), |
| +('Module', [('FunctionDef', (1, 0, 1, 14), 'f', [], ('arguments', [], [('arg', (1, 6, 1, 7), 'a', None, None)], None, [], [], None, []), [('Pass', (1, 10, 1, 14))], [], None, None)], []), |
| +('Module', [('FunctionDef', (1, 0, 1, 16), 'f', [], ('arguments', [], [('arg', (1, 6, 1, 7), 'a', None, None)], None, [], [], None, [('Constant', (1, 8, 1, 9), 0, None)]), [('Pass', (1, 12, 1, 16))], [], None, None)], []), |
| +('Module', [('FunctionDef', (1, 0, 1, 18), 'f', [], ('arguments', [], [], ('arg', (1, 7, 1, 11), 'args', None, None), [], [], None, []), [('Pass', (1, 14, 1, 18))], [], None, None)], []), |
| +('Module', [('FunctionDef', (1, 0, 1, 23), 'f', [], ('arguments', [], [], ('arg', (1, 7, 1, 16), 'args', ('Starred', (1, 13, 1, 16), ('Name', (1, 14, 1, 16), 'Ts', ('Load',)), ('Load',)), None), [], [], None, []), [('Pass', (1, 19, 1, 23))], [], None, None)], []), |
| +('Module', [('FunctionDef', (1, 0, 1, 36), 'f', [], ('arguments', [], [], ('arg', (1, 7, 1, 29), 'args', ('Starred', (1, 13, 1, 29), ('Subscript', (1, 14, 1, 29), ('Name', (1, 14, 1, 19), 'tuple', ('Load',)), ('Tuple', (1, 20, 1, 28), [('Name', (1, 20, 1, 23), 'int', ('Load',)), ('Constant', (1, 25, 1, 28), Ellipsis, None)], ('Load',)), ('Load',)), ('Load',)), None), [], [], None, []), [('Pass', (1, 32, 1, 36))], [], None, None)], []), |
| +('Module', [('FunctionDef', (1, 0, 1, 36), 'f', [], ('arguments', [], [], ('arg', (1, 7, 1, 29), 'args', ('Starred', (1, 13, 1, 29), ('Subscript', (1, 14, 1, 29), ('Name', (1, 14, 1, 19), 'tuple', ('Load',)), ('Tuple', (1, 20, 1, 28), [('Name', (1, 20, 1, 23), 'int', ('Load',)), ('Starred', (1, 25, 1, 28), ('Name', (1, 26, 1, 28), 'Ts', ('Load',)), ('Load',))], ('Load',)), ('Load',)), ('Load',)), None), [], [], None, []), [('Pass', (1, 32, 1, 36))], [], None, None)], []), |
| +('Module', [('FunctionDef', (1, 0, 1, 21), 'f', [], ('arguments', [], [], None, [], [], ('arg', (1, 8, 1, 14), 'kwargs', None, None), []), [('Pass', (1, 17, 1, 21))], [], None, None)], []), |
| +('Module', [('FunctionDef', (1, 0, 1, 71), 'f', [], ('arguments', [], [('arg', (1, 6, 1, 7), 'a', None, None), ('arg', (1, 9, 1, 10), 'b', None, None), ('arg', (1, 14, 1, 15), 'c', None, None), ('arg', (1, 22, 1, 23), 'd', None, None), ('arg', (1, 28, 1, 29), 'e', None, None)], ('arg', (1, 35, 1, 39), 'args', None, None), [('arg', (1, 41, 1, 42), 'f', None, None)], [('Constant', (1, 43, 1, 45), 42, None)], ('arg', (1, 49, 1, 55), 'kwargs', None, None), [('Constant', (1, 11, 1, 12), 1, None), ('Constant', (1, 16, 1, 20), None, None), ('List', (1, 24, 1, 26), [], ('Load',)), ('Dict', (1, 30, 1, 32), [], [])]), [('Expr', (1, 58, 1, 71), ('Constant', (1, 58, 1, 71), 'doc for f()', None))], [], None, None)], []), |
| +('Module', [('FunctionDef', (1, 0, 1, 27), 'f', [], ('arguments', [], [], None, [], [], None, []), [('Pass', (1, 23, 1, 27))], [], ('Subscript', (1, 11, 1, 21), ('Name', (1, 11, 1, 16), 'tuple', ('Load',)), ('Tuple', (1, 17, 1, 20), [('Starred', (1, 17, 1, 20), ('Name', (1, 18, 1, 20), 'Ts', ('Load',)), ('Load',))], ('Load',)), ('Load',)), None)], []), |
| +('Module', [('FunctionDef', (1, 0, 1, 32), 'f', [], ('arguments', [], [], None, [], [], None, []), [('Pass', (1, 28, 1, 32))], [], ('Subscript', (1, 11, 1, 26), ('Name', (1, 11, 1, 16), 'tuple', ('Load',)), ('Tuple', (1, 17, 1, 25), [('Name', (1, 17, 1, 20), 'int', ('Load',)), ('Starred', (1, 22, 1, 25), ('Name', (1, 23, 1, 25), 'Ts', ('Load',)), ('Load',))], ('Load',)), ('Load',)), None)], []), |
| +('Module', [('FunctionDef', (1, 0, 1, 45), 'f', [], ('arguments', [], [], None, [], [], None, []), [('Pass', (1, 41, 1, 45))], [], ('Subscript', (1, 11, 1, 39), ('Name', (1, 11, 1, 16), 'tuple', ('Load',)), ('Tuple', (1, 17, 1, 38), [('Name', (1, 17, 1, 20), 'int', ('Load',)), ('Starred', (1, 22, 1, 38), ('Subscript', (1, 23, 1, 38), ('Name', (1, 23, 1, 28), 'tuple', ('Load',)), ('Tuple', (1, 29, 1, 37), [('Name', (1, 29, 1, 32), 'int', ('Load',)), ('Constant', (1, 34, 1, 37), Ellipsis, None)], ('Load',)), ('Load',)), ('Load',))], ('Load',)), ('Load',)), None)], []), |
| +('Module', [('ClassDef', (1, 0, 1, 12), 'C', [], [], [], [('Pass', (1, 8, 1, 12))], [])], []), |
| +('Module', [('ClassDef', (1, 0, 1, 32), 'C', [], [], [], [('Expr', (1, 9, 1, 32), ('Constant', (1, 9, 1, 32), 'docstring for class C', None))], [])], []), |
| +('Module', [('ClassDef', (1, 0, 1, 21), 'C', [], [('Name', (1, 8, 1, 14), 'object', ('Load',))], [], [('Pass', (1, 17, 1, 21))], [])], []), |
| +('Module', [('FunctionDef', (1, 0, 1, 16), 'f', [], ('arguments', [], [], None, [], [], None, []), [('Return', (1, 8, 1, 16), ('Constant', (1, 15, 1, 16), 1, None))], [], None, None)], []), |
| ('Module', [('Delete', (1, 0, 1, 5), [('Name', (1, 4, 1, 5), 'v', ('Del',))])], []), |
| ('Module', [('Assign', (1, 0, 1, 5), [('Name', (1, 0, 1, 1), 'v', ('Store',))], ('Constant', (1, 4, 1, 5), 1, None), None)], []), |
| ('Module', [('Assign', (1, 0, 1, 7), [('Tuple', (1, 0, 1, 3), [('Name', (1, 0, 1, 1), 'a', ('Store',)), ('Name', (1, 2, 1, 3), 'b', ('Store',))], ('Store',))], ('Name', (1, 6, 1, 7), 'c', ('Load',)), None)], []), |
| @@ -2922,28 +2948,41 @@ def main(): |
| ('Module', [('Expr', (1, 0, 1, 20), ('DictComp', (1, 0, 1, 20), ('Name', (1, 1, 1, 2), 'a', ('Load',)), ('Name', (1, 5, 1, 6), 'b', ('Load',)), [('comprehension', ('Tuple', (1, 11, 1, 14), [('Name', (1, 11, 1, 12), 'v', ('Store',)), ('Name', (1, 13, 1, 14), 'w', ('Store',))], ('Store',)), ('Name', (1, 18, 1, 19), 'x', ('Load',)), [], 0)]))], []), |
| ('Module', [('Expr', (1, 0, 1, 19), ('SetComp', (1, 0, 1, 19), ('Name', (1, 1, 1, 2), 'r', ('Load',)), [('comprehension', ('Name', (1, 7, 1, 8), 'l', ('Store',)), ('Name', (1, 12, 1, 13), 'x', ('Load',)), [('Name', (1, 17, 1, 18), 'g', ('Load',))], 0)]))], []), |
| ('Module', [('Expr', (1, 0, 1, 16), ('SetComp', (1, 0, 1, 16), ('Name', (1, 1, 1, 2), 'r', ('Load',)), [('comprehension', ('Tuple', (1, 7, 1, 10), [('Name', (1, 7, 1, 8), 'l', ('Store',)), ('Name', (1, 9, 1, 10), 'm', ('Store',))], ('Store',)), ('Name', (1, 14, 1, 15), 'x', ('Load',)), [], 0)]))], []), |
| -('Module', [('AsyncFunctionDef', (1, 0, 3, 18), 'f', ('arguments', [], [], None, [], [], None, []), [('Expr', (2, 1, 2, 17), ('Constant', (2, 1, 2, 17), 'async function', None)), ('Expr', (3, 1, 3, 18), ('Await', (3, 1, 3, 18), ('Call', (3, 7, 3, 18), ('Name', (3, 7, 3, 16), 'something', ('Load',)), [], [])))], [], None, None)], []), |
| -('Module', [('AsyncFunctionDef', (1, 0, 3, 8), 'f', ('arguments', [], [], None, [], [], None, []), [('AsyncFor', (2, 1, 3, 8), ('Name', (2, 11, 2, 12), 'e', ('Store',)), ('Name', (2, 16, 2, 17), 'i', ('Load',)), [('Expr', (2, 19, 2, 20), ('Constant', (2, 19, 2, 20), 1, None))], [('Expr', (3, 7, 3, 8), ('Constant', (3, 7, 3, 8), 2, None))], None)], [], None, None)], []), |
| -('Module', [('AsyncFunctionDef', (1, 0, 2, 21), 'f', ('arguments', [], [], None, [], [], None, []), [('AsyncWith', (2, 1, 2, 21), [('withitem', ('Name', (2, 12, 2, 13), 'a', ('Load',)), ('Name', (2, 17, 2, 18), 'b', ('Store',)))], [('Expr', (2, 20, 2, 21), ('Constant', (2, 20, 2, 21), 1, None))], None)], [], None, None)], []), |
| +('Module', [('AsyncFunctionDef', (1, 0, 3, 18), 'f', [], ('arguments', [], [], None, [], [], None, []), [('Expr', (2, 1, 2, 17), ('Constant', (2, 1, 2, 17), 'async function', None)), ('Expr', (3, 1, 3, 18), ('Await', (3, 1, 3, 18), ('Call', (3, 7, 3, 18), ('Name', (3, 7, 3, 16), 'something', ('Load',)), [], [])))], [], None, None)], []), |
| +('Module', [('AsyncFunctionDef', (1, 0, 3, 8), 'f', [], ('arguments', [], [], None, [], [], None, []), [('AsyncFor', (2, 1, 3, 8), ('Name', (2, 11, 2, 12), 'e', ('Store',)), ('Name', (2, 16, 2, 17), 'i', ('Load',)), [('Expr', (2, 19, 2, 20), ('Constant', (2, 19, 2, 20), 1, None))], [('Expr', (3, 7, 3, 8), ('Constant', (3, 7, 3, 8), 2, None))], None)], [], None, None)], []), |
| +('Module', [('AsyncFunctionDef', (1, 0, 2, 21), 'f', [], ('arguments', [], [], None, [], [], None, []), [('AsyncWith', (2, 1, 2, 21), [('withitem', ('Name', (2, 12, 2, 13), 'a', ('Load',)), ('Name', (2, 17, 2, 18), 'b', ('Store',)))], [('Expr', (2, 20, 2, 21), ('Constant', (2, 20, 2, 21), 1, None))], None)], [], None, None)], []), |
| ('Module', [('Expr', (1, 0, 1, 14), ('Dict', (1, 0, 1, 14), [None, ('Constant', (1, 10, 1, 11), 2, None)], [('Dict', (1, 3, 1, 8), [('Constant', (1, 4, 1, 5), 1, None)], [('Constant', (1, 6, 1, 7), 2, None)]), ('Constant', (1, 12, 1, 13), 3, None)]))], []), |
| ('Module', [('Expr', (1, 0, 1, 12), ('Set', (1, 0, 1, 12), [('Starred', (1, 1, 1, 8), ('Set', (1, 2, 1, 8), [('Constant', (1, 3, 1, 4), 1, None), ('Constant', (1, 6, 1, 7), 2, None)]), ('Load',)), ('Constant', (1, 10, 1, 11), 3, None)]))], []), |
| -('Module', [('AsyncFunctionDef', (1, 0, 2, 21), 'f', ('arguments', [], [], None, [], [], None, []), [('Expr', (2, 1, 2, 21), ('ListComp', (2, 1, 2, 21), ('Name', (2, 2, 2, 3), 'i', ('Load',)), [('comprehension', ('Name', (2, 14, 2, 15), 'b', ('Store',)), ('Name', (2, 19, 2, 20), 'c', ('Load',)), [], 1)]))], [], None, None)], []), |
| -('Module', [('FunctionDef', (4, 0, 4, 13), 'f', ('arguments', [], [], None, [], [], None, []), [('Pass', (4, 9, 4, 13))], [('Name', (1, 1, 1, 6), 'deco1', ('Load',)), ('Call', (2, 1, 2, 8), ('Name', (2, 1, 2, 6), 'deco2', ('Load',)), [], []), ('Call', (3, 1, 3, 9), ('Name', (3, 1, 3, 6), 'deco3', ('Load',)), [('Constant', (3, 7, 3, 8), 1, None)], [])], None, None)], []), |
| -('Module', [('AsyncFunctionDef', (4, 0, 4, 19), 'f', ('arguments', [], [], None, [], [], None, []), [('Pass', (4, 15, 4, 19))], [('Name', (1, 1, 1, 6), 'deco1', ('Load',)), ('Call', (2, 1, 2, 8), ('Name', (2, 1, 2, 6), 'deco2', ('Load',)), [], []), ('Call', (3, 1, 3, 9), ('Name', (3, 1, 3, 6), 'deco3', ('Load',)), [('Constant', (3, 7, 3, 8), 1, None)], [])], None, None)], []), |
| -('Module', [('ClassDef', (4, 0, 4, 13), 'C', [], [], [('Pass', (4, 9, 4, 13))], [('Name', (1, 1, 1, 6), 'deco1', ('Load',)), ('Call', (2, 1, 2, 8), ('Name', (2, 1, 2, 6), 'deco2', ('Load',)), [], []), ('Call', (3, 1, 3, 9), ('Name', (3, 1, 3, 6), 'deco3', ('Load',)), [('Constant', (3, 7, 3, 8), 1, None)], [])])], []), |
| -('Module', [('FunctionDef', (2, 0, 2, 13), 'f', ('arguments', [], [], None, [], [], None, []), [('Pass', (2, 9, 2, 13))], [('Call', (1, 1, 1, 19), ('Name', (1, 1, 1, 5), 'deco', ('Load',)), [('GeneratorExp', (1, 5, 1, 19), ('Name', (1, 6, 1, 7), 'a', ('Load',)), [('comprehension', ('Name', (1, 12, 1, 13), 'a', ('Store',)), ('Name', (1, 17, 1, 18), 'b', ('Load',)), [], 0)])], [])], None, None)], []), |
| -('Module', [('FunctionDef', (2, 0, 2, 13), 'f', ('arguments', [], [], None, [], [], None, []), [('Pass', (2, 9, 2, 13))], [('Attribute', (1, 1, 1, 6), ('Attribute', (1, 1, 1, 4), ('Name', (1, 1, 1, 2), 'a', ('Load',)), 'b', ('Load',)), 'c', ('Load',))], None, None)], []), |
| +('Module', [('AsyncFunctionDef', (1, 0, 2, 21), 'f', [], ('arguments', [], [], None, [], [], None, []), [('Expr', (2, 1, 2, 21), ('ListComp', (2, 1, 2, 21), ('Name', (2, 2, 2, 3), 'i', ('Load',)), [('comprehension', ('Name', (2, 14, 2, 15), 'b', ('Store',)), ('Name', (2, 19, 2, 20), 'c', ('Load',)), [], 1)]))], [], None, None)], []), |
| +('Module', [('FunctionDef', (4, 0, 4, 13), 'f', [], ('arguments', [], [], None, [], [], None, []), [('Pass', (4, 9, 4, 13))], [('Name', (1, 1, 1, 6), 'deco1', ('Load',)), ('Call', (2, 1, 2, 8), ('Name', (2, 1, 2, 6), 'deco2', ('Load',)), [], []), ('Call', (3, 1, 3, 9), ('Name', (3, 1, 3, 6), 'deco3', ('Load',)), [('Constant', (3, 7, 3, 8), 1, None)], [])], None, None)], []), |
| +('Module', [('AsyncFunctionDef', (4, 0, 4, 19), 'f', [], ('arguments', [], [], None, [], [], None, []), [('Pass', (4, 15, 4, 19))], [('Name', (1, 1, 1, 6), 'deco1', ('Load',)), ('Call', (2, 1, 2, 8), ('Name', (2, 1, 2, 6), 'deco2', ('Load',)), [], []), ('Call', (3, 1, 3, 9), ('Name', (3, 1, 3, 6), 'deco3', ('Load',)), [('Constant', (3, 7, 3, 8), 1, None)], [])], None, None)], []), |
| +('Module', [('ClassDef', (4, 0, 4, 13), 'C', [], [], [], [('Pass', (4, 9, 4, 13))], [('Name', (1, 1, 1, 6), 'deco1', ('Load',)), ('Call', (2, 1, 2, 8), ('Name', (2, 1, 2, 6), 'deco2', ('Load',)), [], []), ('Call', (3, 1, 3, 9), ('Name', (3, 1, 3, 6), 'deco3', ('Load',)), [('Constant', (3, 7, 3, 8), 1, None)], [])])], []), |
| +('Module', [('FunctionDef', (2, 0, 2, 13), 'f', [], ('arguments', [], [], None, [], [], None, []), [('Pass', (2, 9, 2, 13))], [('Call', (1, 1, 1, 19), ('Name', (1, 1, 1, 5), 'deco', ('Load',)), [('GeneratorExp', (1, 5, 1, 19), ('Name', (1, 6, 1, 7), 'a', ('Load',)), [('comprehension', ('Name', (1, 12, 1, 13), 'a', ('Store',)), ('Name', (1, 17, 1, 18), 'b', ('Load',)), [], 0)])], [])], None, None)], []), |
| +('Module', [('FunctionDef', (2, 0, 2, 13), 'f', [], ('arguments', [], [], None, [], [], None, []), [('Pass', (2, 9, 2, 13))], [('Attribute', (1, 1, 1, 6), ('Attribute', (1, 1, 1, 4), ('Name', (1, 1, 1, 2), 'a', ('Load',)), 'b', ('Load',)), 'c', ('Load',))], None, None)], []), |
| ('Module', [('Expr', (1, 0, 1, 8), ('NamedExpr', (1, 1, 1, 7), ('Name', (1, 1, 1, 2), 'a', ('Store',)), ('Constant', (1, 6, 1, 7), 1, None)))], []), |
| -('Module', [('FunctionDef', (1, 0, 1, 18), 'f', ('arguments', [('arg', (1, 6, 1, 7), 'a', None, None)], [], None, [], [], None, []), [('Pass', (1, 14, 1, 18))], [], None, None)], []), |
| -('Module', [('FunctionDef', (1, 0, 1, 26), 'f', ('arguments', [('arg', (1, 6, 1, 7), 'a', None, None)], [('arg', (1, 12, 1, 13), 'c', None, None), ('arg', (1, 15, 1, 16), 'd', None, None), ('arg', (1, 18, 1, 19), 'e', None, None)], None, [], [], None, []), [('Pass', (1, 22, 1, 26))], [], None, None)], []), |
| -('Module', [('FunctionDef', (1, 0, 1, 29), 'f', ('arguments', [('arg', (1, 6, 1, 7), 'a', None, None)], [('arg', (1, 12, 1, 13), 'c', None, None)], None, [('arg', (1, 18, 1, 19), 'd', None, None), ('arg', (1, 21, 1, 22), 'e', None, None)], [None, None], None, []), [('Pass', (1, 25, 1, 29))], [], None, None)], []), |
| -('Module', [('FunctionDef', (1, 0, 1, 39), 'f', ('arguments', [('arg', (1, 6, 1, 7), 'a', None, None)], [('arg', (1, 12, 1, 13), 'c', None, None)], None, [('arg', (1, 18, 1, 19), 'd', None, None), ('arg', (1, 21, 1, 22), 'e', None, None)], [None, None], ('arg', (1, 26, 1, 32), 'kwargs', None, None), []), [('Pass', (1, 35, 1, 39))], [], None, None)], []), |
| -('Module', [('FunctionDef', (1, 0, 1, 20), 'f', ('arguments', [('arg', (1, 6, 1, 7), 'a', None, None)], [], None, [], [], None, [('Constant', (1, 8, 1, 9), 1, None)]), [('Pass', (1, 16, 1, 20))], [], None, None)], []), |
| -('Module', [('FunctionDef', (1, 0, 1, 29), 'f', ('arguments', [('arg', (1, 6, 1, 7), 'a', None, None)], [('arg', (1, 14, 1, 15), 'b', None, None), ('arg', (1, 19, 1, 20), 'c', None, None)], None, [], [], None, [('Constant', (1, 8, 1, 9), 1, None), ('Constant', (1, 16, 1, 17), 2, None), ('Constant', (1, 21, 1, 22), 4, None)]), [('Pass', (1, 25, 1, 29))], [], None, None)], []), |
| -('Module', [('FunctionDef', (1, 0, 1, 32), 'f', ('arguments', [('arg', (1, 6, 1, 7), 'a', None, None)], [('arg', (1, 14, 1, 15), 'b', None, None)], None, [('arg', (1, 22, 1, 23), 'c', None, None)], [('Constant', (1, 24, 1, 25), 4, None)], None, [('Constant', (1, 8, 1, 9), 1, None), ('Constant', (1, 16, 1, 17), 2, None)]), [('Pass', (1, 28, 1, 32))], [], None, None)], []), |
| -('Module', [('FunctionDef', (1, 0, 1, 30), 'f', ('arguments', [('arg', (1, 6, 1, 7), 'a', None, None)], [('arg', (1, 14, 1, 15), 'b', None, None)], None, [('arg', (1, 22, 1, 23), 'c', None, None)], [None], None, [('Constant', (1, 8, 1, 9), 1, None), ('Constant', (1, 16, 1, 17), 2, None)]), [('Pass', (1, 26, 1, 30))], [], None, None)], []), |
| -('Module', [('FunctionDef', (1, 0, 1, 42), 'f', ('arguments', [('arg', (1, 6, 1, 7), 'a', None, None)], [('arg', (1, 14, 1, 15), 'b', None, None)], None, [('arg', (1, 22, 1, 23), 'c', None, None)], [('Constant', (1, 24, 1, 25), 4, None)], ('arg', (1, 29, 1, 35), 'kwargs', None, None), [('Constant', (1, 8, 1, 9), 1, None), ('Constant', (1, 16, 1, 17), 2, None)]), [('Pass', (1, 38, 1, 42))], [], None, None)], []), |
| -('Module', [('FunctionDef', (1, 0, 1, 40), 'f', ('arguments', [('arg', (1, 6, 1, 7), 'a', None, None)], [('arg', (1, 14, 1, 15), 'b', None, None)], None, [('arg', (1, 22, 1, 23), 'c', None, None)], [None], ('arg', (1, 27, 1, 33), 'kwargs', None, None), [('Constant', (1, 8, 1, 9), 1, None), ('Constant', (1, 16, 1, 17), 2, None)]), [('Pass', (1, 36, 1, 40))], [], None, None)], []), |
| +('Module', [('FunctionDef', (1, 0, 1, 18), 'f', [], ('arguments', [('arg', (1, 6, 1, 7), 'a', None, None)], [], None, [], [], None, []), [('Pass', (1, 14, 1, 18))], [], None, None)], []), |
| +('Module', [('FunctionDef', (1, 0, 1, 26), 'f', [], ('arguments', [('arg', (1, 6, 1, 7), 'a', None, None)], [('arg', (1, 12, 1, 13), 'c', None, None), ('arg', (1, 15, 1, 16), 'd', None, None), ('arg', (1, 18, 1, 19), 'e', None, None)], None, [], [], None, []), [('Pass', (1, 22, 1, 26))], [], None, None)], []), |
| +('Module', [('FunctionDef', (1, 0, 1, 29), 'f', [], ('arguments', [('arg', (1, 6, 1, 7), 'a', None, None)], [('arg', (1, 12, 1, 13), 'c', None, None)], None, [('arg', (1, 18, 1, 19), 'd', None, None), ('arg', (1, 21, 1, 22), 'e', None, None)], [None, None], None, []), [('Pass', (1, 25, 1, 29))], [], None, None)], []), |
| +('Module', [('FunctionDef', (1, 0, 1, 39), 'f', [], ('arguments', [('arg', (1, 6, 1, 7), 'a', None, None)], [('arg', (1, 12, 1, 13), 'c', None, None)], None, [('arg', (1, 18, 1, 19), 'd', None, None), ('arg', (1, 21, 1, 22), 'e', None, None)], [None, None], ('arg', (1, 26, 1, 32), 'kwargs', None, None), []), [('Pass', (1, 35, 1, 39))], [], None, None)], []), |
| +('Module', [('FunctionDef', (1, 0, 1, 20), 'f', [], ('arguments', [('arg', (1, 6, 1, 7), 'a', None, None)], [], None, [], [], None, [('Constant', (1, 8, 1, 9), 1, None)]), [('Pass', (1, 16, 1, 20))], [], None, None)], []), |
| +('Module', [('FunctionDef', (1, 0, 1, 29), 'f', [], ('arguments', [('arg', (1, 6, 1, 7), 'a', None, None)], [('arg', (1, 14, 1, 15), 'b', None, None), ('arg', (1, 19, 1, 20), 'c', None, None)], None, [], [], None, [('Constant', (1, 8, 1, 9), 1, None), ('Constant', (1, 16, 1, 17), 2, None), ('Constant', (1, 21, 1, 22), 4, None)]), [('Pass', (1, 25, 1, 29))], [], None, None)], []), |
| +('Module', [('FunctionDef', (1, 0, 1, 32), 'f', [], ('arguments', [('arg', (1, 6, 1, 7), 'a', None, None)], [('arg', (1, 14, 1, 15), 'b', None, None)], None, [('arg', (1, 22, 1, 23), 'c', None, None)], [('Constant', (1, 24, 1, 25), 4, None)], None, [('Constant', (1, 8, 1, 9), 1, None), ('Constant', (1, 16, 1, 17), 2, None)]), [('Pass', (1, 28, 1, 32))], [], None, None)], []), |
| +('Module', [('FunctionDef', (1, 0, 1, 30), 'f', [], ('arguments', [('arg', (1, 6, 1, 7), 'a', None, None)], [('arg', (1, 14, 1, 15), 'b', None, None)], None, [('arg', (1, 22, 1, 23), 'c', None, None)], [None], None, [('Constant', (1, 8, 1, 9), 1, None), ('Constant', (1, 16, 1, 17), 2, None)]), [('Pass', (1, 26, 1, 30))], [], None, None)], []), |
| +('Module', [('FunctionDef', (1, 0, 1, 42), 'f', [], ('arguments', [('arg', (1, 6, 1, 7), 'a', None, None)], [('arg', (1, 14, 1, 15), 'b', None, None)], None, [('arg', (1, 22, 1, 23), 'c', None, None)], [('Constant', (1, 24, 1, 25), 4, None)], ('arg', (1, 29, 1, 35), 'kwargs', None, None), [('Constant', (1, 8, 1, 9), 1, None), ('Constant', (1, 16, 1, 17), 2, None)]), [('Pass', (1, 38, 1, 42))], [], None, None)], []), |
| +('Module', [('FunctionDef', (1, 0, 1, 40), 'f', [], ('arguments', [('arg', (1, 6, 1, 7), 'a', None, None)], [('arg', (1, 14, 1, 15), 'b', None, None)], None, [('arg', (1, 22, 1, 23), 'c', None, None)], [None], ('arg', (1, 27, 1, 33), 'kwargs', None, None), [('Constant', (1, 8, 1, 9), 1, None), ('Constant', (1, 16, 1, 17), 2, None)]), [('Pass', (1, 36, 1, 40))], [], None, None)], []), |
| +('Module', [('TypeAlias', (1, 0, 1, 12), ('Name', (1, 5, 1, 6), 'X', ('Store',)), [], ('Name', (1, 9, 1, 12), 'int', ('Load',)))], []), |
| +('Module', [('TypeAlias', (1, 0, 1, 15), ('Name', (1, 5, 1, 6), 'X', ('Store',)), [('TypeVar', (1, 7, 1, 8), 'T', None)], ('Name', (1, 12, 1, 15), 'int', ('Load',)))], []), |
| +('Module', [('TypeAlias', (1, 0, 1, 32), ('Name', (1, 5, 1, 6), 'X', ('Store',)), [('TypeVar', (1, 7, 1, 8), 'T', None), ('TypeVarTuple', (1, 10, 1, 13), 'Ts'), ('ParamSpec', (1, 15, 1, 18), 'P')], ('Tuple', (1, 22, 1, 32), [('Name', (1, 23, 1, 24), 'T', ('Load',)), ('Name', (1, 26, 1, 28), 'Ts', ('Load',)), ('Name', (1, 30, 1, 31), 'P', ('Load',))], ('Load',)))], []), |
| +('Module', [('TypeAlias', (1, 0, 1, 37), ('Name', (1, 5, 1, 6), 'X', ('Store',)), [('TypeVar', (1, 7, 1, 13), 'T', ('Name', (1, 10, 1, 13), 'int', ('Load',))), ('TypeVarTuple', (1, 15, 1, 18), 'Ts'), ('ParamSpec', (1, 20, 1, 23), 'P')], ('Tuple', (1, 27, 1, 37), [('Name', (1, 28, 1, 29), 'T', ('Load',)), ('Name', (1, 31, 1, 33), 'Ts', ('Load',)), ('Name', (1, 35, 1, 36), 'P', ('Load',))], ('Load',)))], []), |
| +('Module', [('TypeAlias', (1, 0, 1, 44), ('Name', (1, 5, 1, 6), 'X', ('Store',)), [('TypeVar', (1, 7, 1, 20), 'T', ('Tuple', (1, 10, 1, 20), [('Name', (1, 11, 1, 14), 'int', ('Load',)), ('Name', (1, 16, 1, 19), 'str', ('Load',))], ('Load',))), ('TypeVarTuple', (1, 22, 1, 25), 'Ts'), ('ParamSpec', (1, 27, 1, 30), 'P')], ('Tuple', (1, 34, 1, 44), [('Name', (1, 35, 1, 36), 'T', ('Load',)), ('Name', (1, 38, 1, 40), 'Ts', ('Load',)), ('Name', (1, 42, 1, 43), 'P', ('Load',))], ('Load',)))], []), |
| +('Module', [('ClassDef', (1, 0, 1, 16), 'X', [('TypeVar', (1, 8, 1, 9), 'T', None)], [], [], [('Pass', (1, 12, 1, 16))], [])], []), |
| +('Module', [('ClassDef', (1, 0, 1, 26), 'X', [('TypeVar', (1, 8, 1, 9), 'T', None), ('TypeVarTuple', (1, 11, 1, 14), 'Ts'), ('ParamSpec', (1, 16, 1, 19), 'P')], [], [], [('Pass', (1, 22, 1, 26))], [])], []), |
| +('Module', [('ClassDef', (1, 0, 1, 31), 'X', [('TypeVar', (1, 8, 1, 14), 'T', ('Name', (1, 11, 1, 14), 'int', ('Load',))), ('TypeVarTuple', (1, 16, 1, 19), 'Ts'), ('ParamSpec', (1, 21, 1, 24), 'P')], [], [], [('Pass', (1, 27, 1, 31))], [])], []), |
| +('Module', [('ClassDef', (1, 0, 1, 38), 'X', [('TypeVar', (1, 8, 1, 21), 'T', ('Tuple', (1, 11, 1, 21), [('Name', (1, 12, 1, 15), 'int', ('Load',)), ('Name', (1, 17, 1, 20), 'str', ('Load',))], ('Load',))), ('TypeVarTuple', (1, 23, 1, 26), 'Ts'), ('ParamSpec', (1, 28, 1, 31), 'P')], [], [], [('Pass', (1, 34, 1, 38))], [])], []), |
| +('Module', [('FunctionDef', (1, 0, 1, 16), 'f', [('TypeVar', (1, 6, 1, 7), 'T', None)], ('arguments', [], [], None, [], [], None, []), [('Pass', (1, 12, 1, 16))], [], None, None)], []), |
| +('Module', [('FunctionDef', (1, 0, 1, 26), 'f', [('TypeVar', (1, 6, 1, 7), 'T', None), ('TypeVarTuple', (1, 9, 1, 12), 'Ts'), ('ParamSpec', (1, 14, 1, 17), 'P')], ('arguments', [], [], None, [], [], None, []), [('Pass', (1, 22, 1, 26))], [], None, None)], []), |
| +('Module', [('FunctionDef', (1, 0, 1, 31), 'f', [('TypeVar', (1, 6, 1, 12), 'T', ('Name', (1, 9, 1, 12), 'int', ('Load',))), ('TypeVarTuple', (1, 14, 1, 17), 'Ts'), ('ParamSpec', (1, 19, 1, 22), 'P')], ('arguments', [], [], None, [], [], None, []), [('Pass', (1, 27, 1, 31))], [], None, None)], []), |
| +('Module', [('FunctionDef', (1, 0, 1, 38), 'f', [('TypeVar', (1, 6, 1, 19), 'T', ('Tuple', (1, 9, 1, 19), [('Name', (1, 10, 1, 13), 'int', ('Load',)), ('Name', (1, 15, 1, 18), 'str', ('Load',))], ('Load',))), ('TypeVarTuple', (1, 21, 1, 24), 'Ts'), ('ParamSpec', (1, 26, 1, 29), 'P')], ('arguments', [], [], None, [], [], None, []), [('Pass', (1, 34, 1, 38))], [], None, None)], []), |
| ] |
| single_results = [ |
| ('Interactive', [('Expr', (1, 0, 1, 3), ('BinOp', (1, 0, 1, 3), ('Constant', (1, 0, 1, 1), 1, None), ('Add',), ('Constant', (1, 2, 1, 3), 2, None)))]), |
| |
| |
| |
| |
| @@ -39,7 +39,8 @@ def test_async_and_await_are_keywords(self): |
| self.assertIn("async", keyword.kwlist) |
| self.assertIn("await", keyword.kwlist) |
| |
| - def test_match_and_case_are_soft_keywords(self): |
| + def test_soft_keywords(self): |
| + self.assertIn("type", keyword.softkwlist) |
| self.assertIn("match", keyword.softkwlist) |
| self.assertIn("case", keyword.softkwlist) |
| self.assertIn("_", keyword.softkwlist) |
| |
| |
| |
| |
| @@ -1449,7 +1449,7 @@ def func(): |
| check(x, size('3Pi3c7P2ic??2P')) |
| # function |
| def func(): pass |
| - check(func, size('14Pi')) |
| + check(func, size('15Pi')) |
| class c(): |
| @staticmethod |
| def foo(): |
| |
| new file mode 100644 |
| |
| |
| |
| @@ -0,0 +1,204 @@ |
| +import types |
| +import unittest |
| +from test.support import check_syntax_error, run_code |
| + |
| +from typing import Callable, TypeAliasType, TypeVar, get_args |
| + |
| + |
| +class TypeParamsInvalidTest(unittest.TestCase): |
| + def test_name_collision_01(self): |
| + check_syntax_error(self, """type TA1[A, **A] = None""") |
| + |
| + def test_name_non_collision_02(self): |
| + ns = run_code("""type TA1[A] = lambda A: A""") |
| + self.assertIsInstance(ns["TA1"], TypeAliasType) |
| + self.assertTrue(callable(ns["TA1"].__value__)) |
| + self.assertEqual("arg", ns["TA1"].__value__("arg")) |
| + |
| + def test_name_non_collision_03(self): |
| + ns = run_code(""" |
| + class Outer[A]: |
| + type TA1[A] = None |
| + """ |
| + ) |
| + outer_A, = ns["Outer"].__type_params__ |
| + inner_A, = ns["Outer"].TA1.__type_params__ |
| + self.assertIsNot(outer_A, inner_A) |
| + |
| + |
| +class TypeParamsAccessTest(unittest.TestCase): |
| + def test_alias_access_01(self): |
| + ns = run_code("type TA1[A, B] = dict[A, B]") |
| + alias = ns["TA1"] |
| + self.assertIsInstance(alias, TypeAliasType) |
| + self.assertEqual(alias.__type_params__, get_args(alias.__value__)) |
| + |
| + def test_alias_access_02(self): |
| + ns = run_code(""" |
| + type TA1[A, B] = TA1[A, B] | int |
| + """ |
| + ) |
| + alias = ns["TA1"] |
| + self.assertIsInstance(alias, TypeAliasType) |
| + A, B = alias.__type_params__ |
| + self.assertEqual(alias.__value__, alias[A, B] | int) |
| + |
| + def test_alias_access_03(self): |
| + ns = run_code(""" |
| + class Outer[A]: |
| + def inner[B](self): |
| + type TA1[C] = TA1[A, B] | int |
| + return TA1 |
| + """ |
| + ) |
| + cls = ns["Outer"] |
| + A, = cls.__type_params__ |
| + B, = cls.inner.__type_params__ |
| + alias = cls.inner(None) |
| + self.assertIsInstance(alias, TypeAliasType) |
| + alias2 = cls.inner(None) |
| + self.assertIsNot(alias, alias2) |
| + self.assertEqual(len(alias.__type_params__), 1) |
| + |
| + self.assertEqual(alias.__value__, alias[A, B] | int) |
| + |
| + |
| +class TypeParamsAliasValueTest(unittest.TestCase): |
| + def test_alias_value_01(self): |
| + type TA1 = int |
| + |
| + self.assertIsInstance(TA1, TypeAliasType) |
| + self.assertEqual(TA1.__value__, int) |
| + self.assertEqual(TA1.__parameters__, ()) |
| + self.assertEqual(TA1.__type_params__, ()) |
| + |
| + type TA2 = TA1 | str |
| + |
| + self.assertIsInstance(TA2, TypeAliasType) |
| + a, b = TA2.__value__.__args__ |
| + self.assertEqual(a, TA1) |
| + self.assertEqual(b, str) |
| + self.assertEqual(TA2.__parameters__, ()) |
| + self.assertEqual(TA2.__type_params__, ()) |
| + |
| + def test_alias_value_02(self): |
| + class Parent[A]: |
| + type TA1[B] = dict[A, B] |
| + |
| + self.assertIsInstance(Parent.TA1, TypeAliasType) |
| + self.assertEqual(len(Parent.TA1.__parameters__), 1) |
| + self.assertEqual(len(Parent.__parameters__), 1) |
| + a, = Parent.__parameters__ |
| + b, = Parent.TA1.__parameters__ |
| + self.assertEqual(Parent.__type_params__, (a,)) |
| + self.assertEqual(Parent.TA1.__type_params__, (b,)) |
| + self.assertEqual(Parent.TA1.__value__, dict[a, b]) |
| + |
| + def test_alias_value_03(self): |
| + def outer[A](): |
| + type TA1[B] = dict[A, B] |
| + return TA1 |
| + |
| + o = outer() |
| + self.assertIsInstance(o, TypeAliasType) |
| + self.assertEqual(len(o.__parameters__), 1) |
| + self.assertEqual(len(outer.__type_params__), 1) |
| + b = o.__parameters__[0] |
| + self.assertEqual(o.__type_params__, (b,)) |
| + |
| + def test_alias_value_04(self): |
| + def more_generic[T, *Ts, **P](): |
| + type TA[T2, *Ts2, **P2] = tuple[Callable[P, tuple[T, *Ts]], Callable[P2, tuple[T2, *Ts2]]] |
| + return TA |
| + |
| + alias = more_generic() |
| + self.assertIsInstance(alias, TypeAliasType) |
| + T2, Ts2, P2 = alias.__type_params__ |
| + self.assertEqual(alias.__parameters__, (T2, *Ts2, P2)) |
| + T, Ts, P = more_generic.__type_params__ |
| + self.assertEqual(alias.__value__, tuple[Callable[P, tuple[T, *Ts]], Callable[P2, tuple[T2, *Ts2]]]) |
| + |
| + def test_subscripting(self): |
| + type NonGeneric = int |
| + type Generic[A] = dict[A, A] |
| + type VeryGeneric[T, *Ts, **P] = Callable[P, tuple[T, *Ts]] |
| + |
| + with self.assertRaises(TypeError): |
| + NonGeneric[int] |
| + |
| + specialized = Generic[int] |
| + self.assertIsInstance(specialized, types.GenericAlias) |
| + self.assertIs(specialized.__origin__, Generic) |
| + self.assertEqual(specialized.__args__, (int,)) |
| + |
| + specialized2 = VeryGeneric[int, str, float, [bool, range]] |
| + self.assertIsInstance(specialized2, types.GenericAlias) |
| + self.assertIs(specialized2.__origin__, VeryGeneric) |
| + self.assertEqual(specialized2.__args__, (int, str, float, [bool, range])) |
| + |
| + def test_repr(self): |
| + type Simple = int |
| + self.assertEqual(repr(Simple), "Simple") |
| + |
| + def test_recursive_repr(self): |
| + type Recursive = Recursive |
| + self.assertEqual(repr(Recursive), "Recursive") |
| + |
| + type X = list[Y] |
| + type Y = list[X] |
| + self.assertEqual(repr(X), "X") |
| + |
| + |
| +class TypeAliasConstructorTest(unittest.TestCase): |
| + def test_basic(self): |
| + TA = TypeAliasType("TA", int) |
| + self.assertEqual(TA.__name__, "TA") |
| + self.assertIs(TA.__value__, int) |
| + self.assertEqual(TA.__type_params__, ()) |
| + |
| + def test_generic(self): |
| + T = TypeVar("T") |
| + TA = TypeAliasType("TA", list[T], type_params=(T,)) |
| + self.assertEqual(TA.__name__, "TA") |
| + self.assertEqual(TA.__value__, list[T]) |
| + self.assertEqual(TA.__type_params__, (T,)) |
| + |
| + def test_keywords(self): |
| + TA = TypeAliasType(name="TA", value=int) |
| + self.assertEqual(TA.__name__, "TA") |
| + self.assertIs(TA.__value__, int) |
| + self.assertEqual(TA.__type_params__, ()) |
| + |
| + def test_errors(self): |
| + with self.assertRaises(TypeError): |
| + TypeAliasType() |
| + with self.assertRaises(TypeError): |
| + TypeAliasType("TA") |
| + with self.assertRaises(TypeError): |
| + TypeAliasType("TA", list, ()) |
| + with self.assertRaises(TypeError): |
| + TypeAliasType("TA", list, type_params=42) |
| + |
| + |
| +class TypeAliasTypeTest(unittest.TestCase): |
| + def test_immutable(self): |
| + with self.assertRaises(TypeError): |
| + TypeAliasType.whatever = "not allowed" |
| + |
| + def test_no_subclassing(self): |
| + with self.assertRaisesRegex(TypeError, "not an acceptable base type"): |
| + class MyAlias(TypeAliasType): |
| + pass |
| + |
| + def test_union(self): |
| + type Alias1 = int |
| + type Alias2 = str |
| + union = Alias1 | Alias2 |
| + self.assertIsInstance(union, types.UnionType) |
| + self.assertEqual(get_args(union), (Alias1, Alias2)) |
| + union2 = Alias1 | list[float] |
| + self.assertIsInstance(union2, types.UnionType) |
| + self.assertEqual(get_args(union2), (Alias1, list[float])) |
| + union3 = list[range] | Alias1 |
| + self.assertIsInstance(union3, types.UnionType) |
| + self.assertEqual(get_args(union3), (list[range], Alias1)) |
| |
| new file mode 100644 |
| |
| |
| |
| @@ -0,0 +1,847 @@ |
| +import asyncio |
| +import textwrap |
| +import types |
| +import unittest |
| +from test.support import requires_working_socket, check_syntax_error, run_code |
| + |
| +from typing import Generic, Sequence, TypeVar, TypeVarTuple, ParamSpec, get_args |
| + |
| + |
| +class TypeParamsInvalidTest(unittest.TestCase): |
| + def test_name_collision_01(self): |
| + check_syntax_error(self, """def func[**A, A](): ...""") |
| + |
| + def test_name_non_collision_02(self): |
| + ns = run_code("""def func[A](A): return A""") |
| + func = ns["func"] |
| + self.assertEqual(func(1), 1) |
| + A, = func.__type_params__ |
| + self.assertEqual(A.__name__, "A") |
| + |
| + def test_name_non_collision_03(self): |
| + ns = run_code("""def func[A](*A): return A""") |
| + func = ns["func"] |
| + self.assertEqual(func(1), (1,)) |
| + A, = func.__type_params__ |
| + self.assertEqual(A.__name__, "A") |
| + |
| + def test_name_non_collision_04(self): |
| + # Mangled names should not cause a conflict. |
| + ns = run_code(""" |
| + class ClassA: |
| + def func[__A](self, __A): return __A |
| + """ |
| + ) |
| + cls = ns["ClassA"] |
| + self.assertEqual(cls().func(1), 1) |
| + A, = cls.func.__type_params__ |
| + self.assertEqual(A.__name__, "__A") |
| + |
| + def test_name_non_collision_05(self): |
| + ns = run_code(""" |
| + class ClassA: |
| + def func[_ClassA__A](self, __A): return __A |
| + """ |
| + ) |
| + cls = ns["ClassA"] |
| + self.assertEqual(cls().func(1), 1) |
| + A, = cls.func.__type_params__ |
| + self.assertEqual(A.__name__, "_ClassA__A") |
| + |
| + def test_name_non_collision_06(self): |
| + ns = run_code(""" |
| + class ClassA[X]: |
| + def func(self, X): return X |
| + """ |
| + ) |
| + cls = ns["ClassA"] |
| + self.assertEqual(cls().func(1), 1) |
| + X, = cls.__type_params__ |
| + self.assertEqual(X.__name__, "X") |
| + |
| + def test_name_non_collision_07(self): |
| + ns = run_code(""" |
| + class ClassA[X]: |
| + def func(self): |
| + X = 1 |
| + return X |
| + """ |
| + ) |
| + cls = ns["ClassA"] |
| + self.assertEqual(cls().func(), 1) |
| + X, = cls.__type_params__ |
| + self.assertEqual(X.__name__, "X") |
| + |
| + def test_name_non_collision_08(self): |
| + ns = run_code(""" |
| + class ClassA[X]: |
| + def func(self): |
| + return [X for X in [1, 2]] |
| + """ |
| + ) |
| + cls = ns["ClassA"] |
| + self.assertEqual(cls().func(), [1, 2]) |
| + X, = cls.__type_params__ |
| + self.assertEqual(X.__name__, "X") |
| + |
| + def test_name_non_collision_9(self): |
| + ns = run_code(""" |
| + class ClassA[X]: |
| + def func[X](self): |
| + ... |
| + """ |
| + ) |
| + cls = ns["ClassA"] |
| + outer_X, = cls.__type_params__ |
| + inner_X, = cls.func.__type_params__ |
| + self.assertEqual(outer_X.__name__, "X") |
| + self.assertEqual(inner_X.__name__, "X") |
| + self.assertIsNot(outer_X, inner_X) |
| + |
| + def test_name_non_collision_10(self): |
| + ns = run_code(""" |
| + class ClassA[X]: |
| + X: int |
| + """ |
| + ) |
| + cls = ns["ClassA"] |
| + X, = cls.__type_params__ |
| + self.assertEqual(X.__name__, "X") |
| + self.assertIs(cls.__annotations__["X"], int) |
| + |
| + def test_name_non_collision_13(self): |
| + ns = run_code(""" |
| + X = 1 |
| + def outer(): |
| + def inner[X](): |
| + global X |
| + X = 2 |
| + return inner |
| + """ |
| + ) |
| + self.assertEqual(ns["X"], 1) |
| + outer = ns["outer"] |
| + outer()() |
| + self.assertEqual(ns["X"], 2) |
| + |
| + def test_disallowed_expressions(self): |
| + check_syntax_error(self, "type X = (yield)") |
| + check_syntax_error(self, "type X = (yield from x)") |
| + check_syntax_error(self, "type X = (await 42)") |
| + check_syntax_error(self, "async def f(): type X = (yield)") |
| + check_syntax_error(self, "type X = (y := 3)") |
| + check_syntax_error(self, "class X[T: (yield)]: pass") |
| + check_syntax_error(self, "class X[T: (yield from x)]: pass") |
| + check_syntax_error(self, "class X[T: (await 42)]: pass") |
| + check_syntax_error(self, "class X[T: (y := 3)]: pass") |
| + check_syntax_error(self, "class X[T](y := Sequence[T]): pass") |
| + check_syntax_error(self, "def f[T](y: (x := Sequence[T])): pass") |
| + |
| + |
| +class TypeParamsNonlocalTest(unittest.TestCase): |
| + def test_nonlocal_disallowed_01(self): |
| + code = """ |
| + def outer(): |
| + X = 1 |
| + def inner[X](): |
| + nonlocal X |
| + return X |
| + """ |
| + check_syntax_error(self, code) |
| + |
| + def test_nonlocal_disallowed_02(self): |
| + code = """ |
| + def outer2[T](): |
| + def inner1(): |
| + nonlocal T |
| + """ |
| + check_syntax_error(self, textwrap.dedent(code)) |
| + |
| + def test_nonlocal_disallowed_03(self): |
| + code = """ |
| + class Cls[T]: |
| + nonlocal T |
| + """ |
| + check_syntax_error(self, textwrap.dedent(code)) |
| + |
| + def test_nonlocal_allowed(self): |
| + code = """ |
| + def func[T](): |
| + T = "func" |
| + def inner(): |
| + nonlocal T |
| + T = "inner" |
| + inner() |
| + assert T == "inner" |
| + """ |
| + ns = run_code(code) |
| + func = ns["func"] |
| + T, = func.__type_params__ |
| + self.assertEqual(T.__name__, "T") |
| + |
| + |
| +class TypeParamsAccessTest(unittest.TestCase): |
| + def test_class_access_01(self): |
| + ns = run_code(""" |
| + class ClassA[A, B](dict[A, B]): |
| + ... |
| + """ |
| + ) |
| + cls = ns["ClassA"] |
| + A, B = cls.__type_params__ |
| + self.assertEqual(types.get_original_bases(cls), (dict[A, B], Generic[A, B])) |
| + |
| + def test_class_access_02(self): |
| + ns = run_code(""" |
| + class MyMeta[A, B](type): ... |
| + class ClassA[A, B](metaclass=MyMeta[A, B]): |
| + ... |
| + """ |
| + ) |
| + meta = ns["MyMeta"] |
| + cls = ns["ClassA"] |
| + A1, B1 = meta.__type_params__ |
| + A2, B2 = cls.__type_params__ |
| + self.assertIsNot(A1, A2) |
| + self.assertIsNot(B1, B2) |
| + self.assertIs(type(cls), meta) |
| + |
| + def test_class_access_03(self): |
| + code = """ |
| + def my_decorator(a): |
| + ... |
| + @my_decorator(A) |
| + class ClassA[A, B](): |
| + ... |
| + """ |
| + |
| + with self.assertRaisesRegex(NameError, "name 'A' is not defined"): |
| + run_code(code) |
| + |
| + def test_function_access_01(self): |
| + ns = run_code(""" |
| + def func[A, B](a: dict[A, B]): |
| + ... |
| + """ |
| + ) |
| + func = ns["func"] |
| + A, B = func.__type_params__ |
| + self.assertEqual(func.__annotations__["a"], dict[A, B]) |
| + |
| + def test_function_access_02(self): |
| + code = """ |
| + def func[A](a = list[A]()): |
| + ... |
| + """ |
| + |
| + with self.assertRaisesRegex(NameError, "name 'A' is not defined"): |
| + run_code(code) |
| + |
| + def test_function_access_03(self): |
| + code = """ |
| + def my_decorator(a): |
| + ... |
| + @my_decorator(A) |
| + def func[A](): |
| + ... |
| + """ |
| + |
| + with self.assertRaisesRegex(NameError, "name 'A' is not defined"): |
| + run_code(code) |
| + |
| + def test_method_access_01(self): |
| + ns = run_code(""" |
| + class ClassA: |
| + x = int |
| + def func[T](self, a: x, b: T): |
| + ... |
| + """ |
| + ) |
| + cls = ns["ClassA"] |
| + self.assertIs(cls.func.__annotations__["a"], int) |
| + T, = cls.func.__type_params__ |
| + self.assertIs(cls.func.__annotations__["b"], T) |
| + |
| + def test_nested_access_01(self): |
| + ns = run_code(""" |
| + class ClassA[A]: |
| + def funcB[B](self): |
| + class ClassC[C]: |
| + def funcD[D](self): |
| + return lambda: (A, B, C, D) |
| + return ClassC |
| + """ |
| + ) |
| + cls = ns["ClassA"] |
| + A, = cls.__type_params__ |
| + B, = cls.funcB.__type_params__ |
| + classC = cls().funcB() |
| + C, = classC.__type_params__ |
| + D, = classC.funcD.__type_params__ |
| + self.assertEqual(classC().funcD()(), (A, B, C, D)) |
| + |
| + def test_out_of_scope_01(self): |
| + code = """ |
| + class ClassA[T]: ... |
| + x = T |
| + """ |
| + |
| + with self.assertRaisesRegex(NameError, "name 'T' is not defined"): |
| + run_code(code) |
| + |
| + def test_out_of_scope_02(self): |
| + code = """ |
| + class ClassA[A]: |
| + def funcB[B](self): ... |
| + |
| + x = B |
| + """ |
| + |
| + with self.assertRaisesRegex(NameError, "name 'B' is not defined"): |
| + run_code(code) |
| + |
| + def test_class_scope_interaction_01(self): |
| + ns = run_code(""" |
| + class C: |
| + x = 1 |
| + def method[T](self, arg: x): pass |
| + """) |
| + cls = ns["C"] |
| + self.assertEqual(cls.method.__annotations__["arg"], 1) |
| + |
| + def test_class_scope_interaction_02(self): |
| + ns = run_code(""" |
| + class C: |
| + class Base: pass |
| + class Child[T](Base): pass |
| + """) |
| + cls = ns["C"] |
| + self.assertEqual(cls.Child.__bases__, (cls.Base, Generic)) |
| + T, = cls.Child.__type_params__ |
| + self.assertEqual(types.get_original_bases(cls.Child), (cls.Base, Generic[T])) |
| + |
| + def test_class_deref(self): |
| + ns = run_code(""" |
| + class C[T]: |
| + T = "class" |
| + type Alias = T |
| + """) |
| + cls = ns["C"] |
| + self.assertEqual(cls.Alias.__value__, "class") |
| + |
| + def test_shadowing_nonlocal(self): |
| + ns = run_code(""" |
| + def outer[T](): |
| + T = "outer" |
| + def inner(): |
| + nonlocal T |
| + T = "inner" |
| + return T |
| + return lambda: T, inner |
| + """) |
| + outer = ns["outer"] |
| + T, = outer.__type_params__ |
| + self.assertEqual(T.__name__, "T") |
| + getter, inner = outer() |
| + self.assertEqual(getter(), "outer") |
| + self.assertEqual(inner(), "inner") |
| + self.assertEqual(getter(), "inner") |
| + |
| + def test_reference_previous_typevar(self): |
| + def func[S, T: Sequence[S]](): |
| + pass |
| + |
| + S, T = func.__type_params__ |
| + self.assertEqual(T.__bound__, Sequence[S]) |
| + |
| + def test_super(self): |
| + class Base: |
| + def meth(self): |
| + return "base" |
| + |
| + class Child(Base): |
| + # Having int in the annotation ensures the class gets cells for both |
| + # __class__ and __classdict__ |
| + def meth[T](self, arg: int) -> T: |
| + return super().meth() + "child" |
| + |
| + c = Child() |
| + self.assertEqual(c.meth(1), "basechild") |
| + |
| + def test_type_alias_containing_lambda(self): |
| + type Alias[T] = lambda: T |
| + T, = Alias.__type_params__ |
| + self.assertIs(Alias.__value__(), T) |
| + |
| + def test_class_base_containing_lambda(self): |
| + # Test that scopes nested inside hidden functions work correctly |
| + outer_var = "outer" |
| + class Base[T]: ... |
| + class Child[T](Base[lambda: (int, outer_var, T)]): ... |
| + base, _ = types.get_original_bases(Child) |
| + func, = get_args(base) |
| + T, = Child.__type_params__ |
| + self.assertEqual(func(), (int, "outer", T)) |
| + |
| + def test_comprehension_01(self): |
| + type Alias[T: ([T for T in (T, [1])[1]], T)] = [T for T in T.__name__] |
| + self.assertEqual(Alias.__value__, ["T"]) |
| + T, = Alias.__type_params__ |
| + self.assertEqual(T.__constraints__, ([1], T)) |
| + |
| + def test_comprehension_02(self): |
| + type Alias[T: [lambda: T for T in (T, [1])[1]]] = [lambda: T for T in T.__name__] |
| + func, = Alias.__value__ |
| + self.assertEqual(func(), "T") |
| + T, = Alias.__type_params__ |
| + func, = T.__bound__ |
| + self.assertEqual(func(), 1) |
| + |
| + |
| +def global_generic_func[T](): |
| + pass |
| + |
| +class GlobalGenericClass[T]: |
| + pass |
| + |
| + |
| +class TypeParamsLazyEvaluationTest(unittest.TestCase): |
| + def test_qualname(self): |
| + class Foo[T]: |
| + pass |
| + |
| + def func[T](): |
| + pass |
| + |
| + self.assertEqual(Foo.__qualname__, "TypeParamsLazyEvaluationTest.test_qualname.<locals>.Foo") |
| + self.assertEqual(func.__qualname__, "TypeParamsLazyEvaluationTest.test_qualname.<locals>.func") |
| + self.assertEqual(global_generic_func.__qualname__, "global_generic_func") |
| + self.assertEqual(GlobalGenericClass.__qualname__, "GlobalGenericClass") |
| + |
| + def test_recursive_class(self): |
| + class Foo[T: Foo, U: (Foo, Foo)]: |
| + pass |
| + |
| + type_params = Foo.__type_params__ |
| + self.assertEqual(len(type_params), 2) |
| + self.assertEqual(type_params[0].__name__, "T") |
| + self.assertEqual(type_params[0].__bound__, Foo) |
| + self.assertEqual(type_params[0].__constraints__, None) |
| + |
| + self.assertEqual(type_params[1].__name__, "U") |
| + self.assertEqual(type_params[1].__bound__, None) |
| + self.assertEqual(type_params[1].__constraints__, (Foo, Foo)) |
| + |
| + def test_evaluation_error(self): |
| + class Foo[T: Undefined, U: (Undefined,)]: |
| + pass |
| + |
| + type_params = Foo.__type_params__ |
| + with self.assertRaises(NameError): |
| + type_params[0].__bound__ |
| + self.assertEqual(type_params[0].__constraints__, None) |
| + self.assertEqual(type_params[1].__bound__, None) |
| + with self.assertRaises(NameError): |
| + type_params[1].__constraints__ |
| + |
| + Undefined = "defined" |
| + self.assertEqual(type_params[0].__bound__, "defined") |
| + self.assertEqual(type_params[0].__constraints__, None) |
| + |
| + self.assertEqual(type_params[1].__bound__, None) |
| + self.assertEqual(type_params[1].__constraints__, ("defined",)) |
| + |
| + |
| +class TypeParamsClassScopeTest(unittest.TestCase): |
| + def test_alias(self): |
| + class X: |
| + T = int |
| + type U = T |
| + self.assertIs(X.U.__value__, int) |
| + |
| + ns = run_code(""" |
| + glb = "global" |
| + class X: |
| + cls = "class" |
| + type U = (glb, cls) |
| + """) |
| + cls = ns["X"] |
| + self.assertEqual(cls.U.__value__, ("global", "class")) |
| + |
| + def test_bound(self): |
| + class X: |
| + T = int |
| + def foo[U: T](self): ... |
| + self.assertIs(X.foo.__type_params__[0].__bound__, int) |
| + |
| + ns = run_code(""" |
| + glb = "global" |
| + class X: |
| + cls = "class" |
| + def foo[T: glb, U: cls](self): ... |
| + """) |
| + cls = ns["X"] |
| + T, U = cls.foo.__type_params__ |
| + self.assertEqual(T.__bound__, "global") |
| + self.assertEqual(U.__bound__, "class") |
| + |
| + def test_modified_later(self): |
| + class X: |
| + T = int |
| + def foo[U: T](self): ... |
| + type Alias = T |
| + X.T = float |
| + self.assertIs(X.foo.__type_params__[0].__bound__, float) |
| + self.assertIs(X.Alias.__value__, float) |
| + |
| + def test_binding_uses_global(self): |
| + ns = run_code(""" |
| + x = "global" |
| + def outer(): |
| + x = "nonlocal" |
| + class Cls: |
| + type Alias = x |
| + val = Alias.__value__ |
| + def meth[T: x](self, arg: x): ... |
| + bound = meth.__type_params__[0].__bound__ |
| + annotation = meth.__annotations__["arg"] |
| + x = "class" |
| + return Cls |
| + """) |
| + cls = ns["outer"]() |
| + self.assertEqual(cls.val, "global") |
| + self.assertEqual(cls.bound, "global") |
| + self.assertEqual(cls.annotation, "global") |
| + |
| + def test_no_binding_uses_nonlocal(self): |
| + ns = run_code(""" |
| + x = "global" |
| + def outer(): |
| + x = "nonlocal" |
| + class Cls: |
| + type Alias = x |
| + val = Alias.__value__ |
| + def meth[T: x](self, arg: x): ... |
| + bound = meth.__type_params__[0].__bound__ |
| + return Cls |
| + """) |
| + cls = ns["outer"]() |
| + self.assertEqual(cls.val, "nonlocal") |
| + self.assertEqual(cls.bound, "nonlocal") |
| + self.assertEqual(cls.meth.__annotations__["arg"], "nonlocal") |
| + |
| + def test_explicit_global(self): |
| + ns = run_code(""" |
| + x = "global" |
| + def outer(): |
| + x = "nonlocal" |
| + class Cls: |
| + global x |
| + type Alias = x |
| + Cls.x = "class" |
| + return Cls |
| + """) |
| + cls = ns["outer"]() |
| + self.assertEqual(cls.Alias.__value__, "global") |
| + |
| + def test_explicit_global_with_no_static_bound(self): |
| + ns = run_code(""" |
| + def outer(): |
| + class Cls: |
| + global x |
| + type Alias = x |
| + Cls.x = "class" |
| + return Cls |
| + """) |
| + ns["x"] = "global" |
| + cls = ns["outer"]() |
| + self.assertEqual(cls.Alias.__value__, "global") |
| + |
| + def test_explicit_global_with_assignment(self): |
| + ns = run_code(""" |
| + x = "global" |
| + def outer(): |
| + x = "nonlocal" |
| + class Cls: |
| + global x |
| + type Alias = x |
| + x = "global from class" |
| + Cls.x = "class" |
| + return Cls |
| + """) |
| + cls = ns["outer"]() |
| + self.assertEqual(cls.Alias.__value__, "global from class") |
| + |
| + def test_explicit_nonlocal(self): |
| + ns = run_code(""" |
| + x = "global" |
| + def outer(): |
| + x = "nonlocal" |
| + class Cls: |
| + nonlocal x |
| + type Alias = x |
| + x = "class" |
| + return Cls |
| + """) |
| + cls = ns["outer"]() |
| + self.assertEqual(cls.Alias.__value__, "class") |
| + |
| + |
| +class TypeParamsManglingTest(unittest.TestCase): |
| + def test_mangling(self): |
| + class Foo[__T]: |
| + param = __T |
| + def meth[__U](self, arg: __T, arg2: __U): |
| + return (__T, __U) |
| + type Alias[__V] = (__T, __V) |
| + |
| + T = Foo.__type_params__[0] |
| + self.assertEqual(T.__name__, "__T") |
| + U = Foo.meth.__type_params__[0] |
| + self.assertEqual(U.__name__, "__U") |
| + V = Foo.Alias.__type_params__[0] |
| + self.assertEqual(V.__name__, "__V") |
| + |
| + anno = Foo.meth.__annotations__ |
| + self.assertIs(anno["arg"], T) |
| + self.assertIs(anno["arg2"], U) |
| + self.assertEqual(Foo().meth(1, 2), (T, U)) |
| + |
| + self.assertEqual(Foo.Alias.__value__, (T, V)) |
| + |
| + |
| +class TypeParamsComplexCallsTest(unittest.TestCase): |
| + def test_defaults(self): |
| + # Generic functions with both defaults and kwdefaults trigger a specific code path |
| + # in the compiler. |
| + def func[T](a: T = "a", *, b: T = "b"): |
| + return (a, b) |
| + |
| + T, = func.__type_params__ |
| + self.assertIs(func.__annotations__["a"], T) |
| + self.assertIs(func.__annotations__["b"], T) |
| + self.assertEqual(func(), ("a", "b")) |
| + self.assertEqual(func(1), (1, "b")) |
| + self.assertEqual(func(b=2), ("a", 2)) |
| + |
| + def test_complex_base(self): |
| + class Base: |
| + def __init_subclass__(cls, **kwargs) -> None: |
| + cls.kwargs = kwargs |
| + |
| + kwargs = {"c": 3} |
| + # Base classes with **kwargs trigger a different code path in the compiler. |
| + class C[T](Base, a=1, b=2, **kwargs): |
| + pass |
| + |
| + T, = C.__type_params__ |
| + self.assertEqual(T.__name__, "T") |
| + self.assertEqual(C.kwargs, {"a": 1, "b": 2, "c": 3}) |
| + |
| + bases = (Base,) |
| + class C2[T](*bases, **kwargs): |
| + pass |
| + |
| + T, = C2.__type_params__ |
| + self.assertEqual(T.__name__, "T") |
| + self.assertEqual(C2.kwargs, {"c": 3}) |
| + |
| + |
| +class TypeParamsTraditionalTypeVarsTest(unittest.TestCase): |
| + def test_traditional_01(self): |
| + code = """ |
| + from typing import Generic |
| + class ClassA[T](Generic[T]): ... |
| + """ |
| + |
| + with self.assertRaisesRegex(TypeError, r"Cannot inherit from Generic\[...\] multiple times."): |
| + run_code(code) |
| + |
| + def test_traditional_02(self): |
| + from typing import TypeVar |
| + S = TypeVar("S") |
| + with self.assertRaises(TypeError): |
| + class ClassA[T](dict[T, S]): ... |
| + |
| + def test_traditional_03(self): |
| + # This does not generate a runtime error, but it should be |
| + # flagged as an error by type checkers. |
| + from typing import TypeVar |
| + S = TypeVar("S") |
| + def func[T](a: T, b: S) -> T | S: |
| + return a |
| + |
| + |
| +class TypeParamsTypeVarTest(unittest.TestCase): |
| + def test_typevar_01(self): |
| + def func1[A: str, B: str | int, C: (int, str)](): |
| + return (A, B, C) |
| + |
| + a, b, c = func1() |
| + |
| + self.assertIsInstance(a, TypeVar) |
| + self.assertEqual(a.__bound__, str) |
| + self.assertTrue(a.__infer_variance__) |
| + self.assertFalse(a.__covariant__) |
| + self.assertFalse(a.__contravariant__) |
| + |
| + self.assertIsInstance(b, TypeVar) |
| + self.assertEqual(b.__bound__, str | int) |
| + self.assertTrue(b.__infer_variance__) |
| + self.assertFalse(b.__covariant__) |
| + self.assertFalse(b.__contravariant__) |
| + |
| + self.assertIsInstance(c, TypeVar) |
| + self.assertEqual(c.__bound__, None) |
| + self.assertEqual(c.__constraints__, (int, str)) |
| + self.assertTrue(c.__infer_variance__) |
| + self.assertFalse(c.__covariant__) |
| + self.assertFalse(c.__contravariant__) |
| + |
| + def test_typevar_generator(self): |
| + def get_generator[A](): |
| + def generator1[C](): |
| + yield C |
| + |
| + def generator2[B](): |
| + yield A |
| + yield B |
| + yield from generator1() |
| + return generator2 |
| + |
| + gen = get_generator() |
| + |
| + a, b, c = [x for x in gen()] |
| + |
| + self.assertIsInstance(a, TypeVar) |
| + self.assertEqual(a.__name__, "A") |
| + self.assertIsInstance(b, TypeVar) |
| + self.assertEqual(b.__name__, "B") |
| + self.assertIsInstance(c, TypeVar) |
| + self.assertEqual(c.__name__, "C") |
| + |
| + @requires_working_socket() |
| + def test_typevar_coroutine(self): |
| + def get_coroutine[A](): |
| + async def coroutine[B](): |
| + return (A, B) |
| + return coroutine |
| + |
| + co = get_coroutine() |
| + |
| + self.addCleanup(asyncio.set_event_loop_policy, None) |
| + a, b = asyncio.run(co()) |
| + |
| + self.assertIsInstance(a, TypeVar) |
| + self.assertEqual(a.__name__, "A") |
| + self.assertIsInstance(b, TypeVar) |
| + self.assertEqual(b.__name__, "B") |
| + |
| + |
| +class TypeParamsTypeVarTupleTest(unittest.TestCase): |
| + def test_typevartuple_01(self): |
| + code = """def func1[*A: str](): pass""" |
| + check_syntax_error(self, code) |
| + code = """def func1[*A: (int, str)](): pass""" |
| + check_syntax_error(self, code) |
| + code = """class X[*A: str]: pass""" |
| + check_syntax_error(self, code) |
| + code = """class X[*A: (int, str)]: pass""" |
| + check_syntax_error(self, code) |
| + code = """type X[*A: str] = int""" |
| + check_syntax_error(self, code) |
| + code = """type X[*A: (int, str)] = int""" |
| + check_syntax_error(self, code) |
| + |
| + def test_typevartuple_02(self): |
| + def func1[*A](): |
| + return A |
| + |
| + a = func1() |
| + self.assertIsInstance(a, TypeVarTuple) |
| + |
| + |
| +class TypeParamsTypeVarParamSpecTest(unittest.TestCase): |
| + def test_paramspec_01(self): |
| + code = """def func1[**A: str](): pass""" |
| + check_syntax_error(self, code) |
| + code = """def func1[**A: (int, str)](): pass""" |
| + check_syntax_error(self, code) |
| + code = """class X[**A: str]: pass""" |
| + check_syntax_error(self, code) |
| + code = """class X[**A: (int, str)]: pass""" |
| + check_syntax_error(self, code) |
| + code = """type X[**A: str] = int""" |
| + check_syntax_error(self, code) |
| + code = """type X[**A: (int, str)] = int""" |
| + check_syntax_error(self, code) |
| + |
| + def test_paramspec_02(self): |
| + def func1[**A](): |
| + return A |
| + |
| + a = func1() |
| + self.assertIsInstance(a, ParamSpec) |
| + self.assertTrue(a.__infer_variance__) |
| + self.assertFalse(a.__covariant__) |
| + self.assertFalse(a.__contravariant__) |
| + |
| + |
| +class TypeParamsTypeParamsDunder(unittest.TestCase): |
| + def test_typeparams_dunder_class_01(self): |
| + class Outer[A, B]: |
| + class Inner[C, D]: |
| + @staticmethod |
| + def get_typeparams(): |
| + return A, B, C, D |
| + |
| + a, b, c, d = Outer.Inner.get_typeparams() |
| + self.assertEqual(Outer.__type_params__, (a, b)) |
| + self.assertEqual(Outer.Inner.__type_params__, (c, d)) |
| + |
| + self.assertEqual(Outer.__parameters__, (a, b)) |
| + self.assertEqual(Outer.Inner.__parameters__, (c, d)) |
| + |
| + def test_typeparams_dunder_class_02(self): |
| + class ClassA: |
| + pass |
| + |
| + self.assertEqual(ClassA.__type_params__, ()) |
| + |
| + def test_typeparams_dunder_class_03(self): |
| + code = """ |
| + class ClassA[A](): |
| + pass |
| + ClassA.__type_params__ = () |
| + """ |
| + |
| + with self.assertRaisesRegex(AttributeError, "attribute '__type_params__' of 'type' objects is not writable"): |
| + run_code(code) |
| + |
| + def test_typeparams_dunder_function_01(self): |
| + def outer[A, B](): |
| + def inner[C, D](): |
| + return A, B, C, D |
| + |
| + return inner |
| + |
| + inner = outer() |
| + a, b, c, d = inner() |
| + self.assertEqual(outer.__type_params__, (a, b)) |
| + self.assertEqual(inner.__type_params__, (c, d)) |
| + |
| + def test_typeparams_dunder_function_02(self): |
| + def func1(): |
| + pass |
| + |
| + self.assertEqual(func1.__type_params__, ()) |
| + |
| + def test_typeparams_dunder_function_03(self): |
| + code = """ |
| + def func[A](): |
| + pass |
| + func.__type_params__ = () |
| + """ |
| + |
| + with self.assertRaisesRegex(AttributeError, "attribute '__type_params__' of 'function' objects is not writable"): |
| + run_code(code) |
| |
| |
| |
| |
| @@ -48,11 +48,8 @@ |
| from test import _typed_dict_helper |
| |
| |
| -py_typing = import_helper.import_fresh_module('typing', blocked=['_typing']) |
| -c_typing = import_helper.import_fresh_module('typing', fresh=['_typing']) |
| - |
| - |
| CANNOT_SUBCLASS_TYPE = 'Cannot subclass special typing classes' |
| +NOT_A_BASE_TYPE = "type 'typing.%s' is not an acceptable base type" |
| CANNOT_SUBCLASS_INSTANCE = 'Cannot subclass an instance of %s' |
| |
| |
| @@ -430,7 +427,7 @@ def test_no_redefinition(self): |
| self.assertNotEqual(TypeVar('T', int, str), TypeVar('T', int, str)) |
| |
| def test_cannot_subclass(self): |
| - with self.assertRaisesRegex(TypeError, CANNOT_SUBCLASS_TYPE): |
| + with self.assertRaisesRegex(TypeError, NOT_A_BASE_TYPE % 'TypeVar'): |
| class V(TypeVar): pass |
| T = TypeVar("T") |
| with self.assertRaisesRegex(TypeError, |
| @@ -446,6 +443,9 @@ def test_bound_errors(self): |
| TypeVar('X', bound=Union) |
| with self.assertRaises(TypeError): |
| TypeVar('X', str, float, bound=Employee) |
| + with self.assertRaisesRegex(TypeError, |
| + r"Bound must be a type\. Got \(1, 2\)\."): |
| + TypeVar('X', bound=(1, 2)) |
| |
| def test_missing__name__(self): |
| # See bpo-39942 |
| @@ -1161,7 +1161,7 @@ class A(Generic[Unpack[Ts]]): pass |
| self.assertEndsWith(repr(K[float, str]), 'A[float, str, typing.Unpack[typing.Tuple[str, ...]]]') |
| |
| def test_cannot_subclass(self): |
| - with self.assertRaisesRegex(TypeError, CANNOT_SUBCLASS_TYPE): |
| + with self.assertRaisesRegex(TypeError, NOT_A_BASE_TYPE % 'TypeVarTuple'): |
| class C(TypeVarTuple): pass |
| Ts = TypeVarTuple('Ts') |
| with self.assertRaisesRegex(TypeError, |
| @@ -6444,34 +6444,27 @@ def foo(a: A) -> Optional[BaseException]: |
| class TestModules(TestCase): |
| func_names = ['_idfunc'] |
| |
| - def test_py_functions(self): |
| - for fname in self.func_names: |
| - self.assertEqual(getattr(py_typing, fname).__module__, 'typing') |
| - |
| - @skipUnless(c_typing, 'requires _typing') |
| def test_c_functions(self): |
| for fname in self.func_names: |
| - self.assertEqual(getattr(c_typing, fname).__module__, '_typing') |
| + self.assertEqual(getattr(typing, fname).__module__, '_typing') |
| |
| |
| -class NewTypeTests: |
| +class NewTypeTests(BaseTestCase): |
| def cleanup(self): |
| - for f in self.module._cleanups: |
| + for f in typing._cleanups: |
| f() |
| |
| @classmethod |
| def setUpClass(cls): |
| - sys.modules['typing'] = cls.module |
| global UserId |
| - UserId = cls.module.NewType('UserId', int) |
| - cls.UserName = cls.module.NewType(cls.__qualname__ + '.UserName', str) |
| + UserId = typing.NewType('UserId', int) |
| + cls.UserName = typing.NewType(cls.__qualname__ + '.UserName', str) |
| |
| @classmethod |
| def tearDownClass(cls): |
| global UserId |
| del UserId |
| del cls.UserName |
| - sys.modules['typing'] = typing |
| |
| def tearDown(self): |
| self.cleanup() |
| @@ -6491,11 +6484,11 @@ class D(UserId): |
| def test_or(self): |
| for cls in (int, self.UserName): |
| with self.subTest(cls=cls): |
| - self.assertEqual(UserId | cls, self.module.Union[UserId, cls]) |
| - self.assertEqual(cls | UserId, self.module.Union[cls, UserId]) |
| + self.assertEqual(UserId | cls, typing.Union[UserId, cls]) |
| + self.assertEqual(cls | UserId, typing.Union[cls, UserId]) |
| |
| - self.assertEqual(self.module.get_args(UserId | cls), (UserId, cls)) |
| - self.assertEqual(self.module.get_args(cls | UserId), (cls, UserId)) |
| + self.assertEqual(typing.get_args(UserId | cls), (UserId, cls)) |
| + self.assertEqual(typing.get_args(cls | UserId), (cls, UserId)) |
| |
| def test_special_attrs(self): |
| self.assertEqual(UserId.__name__, 'UserId') |
| @@ -6516,7 +6509,7 @@ def test_repr(self): |
| f'{__name__}.{self.__class__.__qualname__}.UserName') |
| |
| def test_pickle(self): |
| - UserAge = self.module.NewType('UserAge', float) |
| + UserAge = typing.NewType('UserAge', float) |
| for proto in range(pickle.HIGHEST_PROTOCOL + 1): |
| with self.subTest(proto=proto): |
| pickled = pickle.dumps(UserId, proto) |
| @@ -6548,15 +6541,6 @@ class ProUserId(UserId): |
| ... |
| |
| |
| -class NewTypePythonTests(NewTypeTests, BaseTestCase): |
| - module = py_typing |
| - |
| - |
| -@skipUnless(c_typing, 'requires _typing') |
| -class NewTypeCTests(NewTypeTests, BaseTestCase): |
| - module = c_typing |
| - |
| - |
| class NamedTupleTests(BaseTestCase): |
| class NestedEmployee(NamedTuple): |
| name: str |
| @@ -8170,11 +8154,11 @@ def test_paramspec_gets_copied(self): |
| self.assertEqual(C2[Concatenate[T, P2]].__parameters__, (T, P2)) |
| |
| def test_cannot_subclass(self): |
| - with self.assertRaisesRegex(TypeError, CANNOT_SUBCLASS_TYPE): |
| + with self.assertRaisesRegex(TypeError, NOT_A_BASE_TYPE % 'ParamSpec'): |
| class C(ParamSpec): pass |
| - with self.assertRaisesRegex(TypeError, CANNOT_SUBCLASS_TYPE): |
| + with self.assertRaisesRegex(TypeError, NOT_A_BASE_TYPE % 'ParamSpecArgs'): |
| class C(ParamSpecArgs): pass |
| - with self.assertRaisesRegex(TypeError, CANNOT_SUBCLASS_TYPE): |
| + with self.assertRaisesRegex(TypeError, NOT_A_BASE_TYPE % 'ParamSpecKwargs'): |
| class C(ParamSpecKwargs): pass |
| P = ParamSpec('P') |
| with self.assertRaisesRegex(TypeError, |
|
|
