Mirror
/
cpython
mirror of https://github.com/python/cpython
4
1
Fork 0
Code Issues Releases Wiki Activity

gh-104656: Rename typeparams AST node to type_params (#104657)

This commit is contained in:
Jelle Zijlstra 2023-05-21 21:25:09 -07:00 committed by GitHub
parent ef5d00a592
commit a5f244d627
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
14 changed files with 290 additions and 287 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
Doc/library/ast.rst
View File

@ -1724,7 +1724,7 @@ Function and class definitions
body=[ body=[
FunctionDef( FunctionDef(
name='f', name='f',
typeparams=[], type_params=[],
args=arguments( args=arguments(
posonlyargs=[], posonlyargs=[],
args=[ args=[
@ -1848,7 +1848,7 @@ Function and class definitions
body=[ body=[
ClassDef( ClassDef(
name='Foo', name='Foo',
typeparams=[], type_params=[],
bases=[ bases=[
Name(id='base1', ctx=Load()), Name(id='base1', ctx=Load()),
Name(id='base2', ctx=Load())], Name(id='base2', ctx=Load())],
@ -1887,7 +1887,7 @@ Async and await
body=[ body=[
AsyncFunctionDef( AsyncFunctionDef(
name='f', name='f',
typeparams=[], type_params=[],
args=arguments( args=arguments(
posonlyargs=[], posonlyargs=[],
args=[], args=[],

8
Grammar/python.gram
View File

@ -640,12 +640,12 @@ type_alias[stmt_ty]:
# Type parameter declaration # Type parameter declaration
# -------------------------- # --------------------------
type_params[asdl_typeparam_seq*]: '[' t=type_param_seq ']' { type_params[asdl_type_param_seq*]: '[' t=type_param_seq ']' {
CHECK_VERSION(asdl_typeparam_seq *, 12, "Type parameter lists are", t) } CHECK_VERSION(asdl_type_param_seq *, 12, "Type parameter lists are", t) }
type_param_seq[asdl_typeparam_seq*]: a[asdl_typeparam_seq*]=','.type_param+ [','] { a } type_param_seq[asdl_type_param_seq*]: a[asdl_type_param_seq*]=','.type_param+ [','] { a }
type_param[typeparam_ty] (memo): type_param[type_param_ty] (memo):
| a=NAME b=[type_param_bound] { _PyAST_TypeVar(a->v.Name.id, b, EXTRA) } | a=NAME b=[type_param_bound] { _PyAST_TypeVar(a->v.Name.id, b, EXTRA) }
| '*' a=NAME colon=":" e=expression { | '*' a=NAME colon=":" e=expression {
RAISE_SYNTAX_ERROR_STARTING_FROM(colon, e->kind == Tuple_kind RAISE_SYNTAX_ERROR_STARTING_FROM(colon, e->kind == Tuple_kind

43
Include/internal/pycore_ast.h generated
View File

@ -51,7 +51,7 @@ typedef struct _pattern *pattern_ty;
typedef struct _type_ignore *type_ignore_ty; typedef struct _type_ignore *type_ignore_ty;
typedef struct _typeparam *typeparam_ty; typedef struct _type_param *type_param_ty;
typedef struct { typedef struct {
@ -151,10 +151,11 @@ asdl_type_ignore_seq *_Py_asdl_type_ignore_seq_new(Py_ssize_t size, PyArena
typedef struct { typedef struct {
_ASDL_SEQ_HEAD _ASDL_SEQ_HEAD
typeparam_ty typed_elements[1]; type_param_ty typed_elements[1];
} asdl_typeparam_seq; } asdl_type_param_seq;
asdl_typeparam_seq *_Py_asdl_typeparam_seq_new(Py_ssize_t size, PyArena *arena); asdl_type_param_seq *_Py_asdl_type_param_seq_new(Py_ssize_t size, PyArena
*arena);
enum _mod_kind {Module_kind=1, Interactive_kind=2, Expression_kind=3, enum _mod_kind {Module_kind=1, Interactive_kind=2, Expression_kind=3,
@ -197,7 +198,7 @@ struct _stmt {
union { union {
struct { struct {
identifier name; identifier name;
asdl_typeparam_seq *typeparams; asdl_type_param_seq *type_params;
arguments_ty args; arguments_ty args;
asdl_stmt_seq *body; asdl_stmt_seq *body;
asdl_expr_seq *decorator_list; asdl_expr_seq *decorator_list;
@ -207,7 +208,7 @@ struct _stmt {
struct { struct {
identifier name; identifier name;
asdl_typeparam_seq *typeparams; asdl_type_param_seq *type_params;
arguments_ty args; arguments_ty args;
asdl_stmt_seq *body; asdl_stmt_seq *body;
asdl_expr_seq *decorator_list; asdl_expr_seq *decorator_list;
@ -217,7 +218,7 @@ struct _stmt {
struct { struct {
identifier name; identifier name;
asdl_typeparam_seq *typeparams; asdl_type_param_seq *type_params;
asdl_expr_seq *bases; asdl_expr_seq *bases;
asdl_keyword_seq *keywords; asdl_keyword_seq *keywords;
asdl_stmt_seq *body; asdl_stmt_seq *body;
@ -240,7 +241,7 @@ struct _stmt {
struct { struct {
expr_ty name; expr_ty name;
asdl_typeparam_seq *typeparams; asdl_type_param_seq *type_params;
expr_ty value; expr_ty value;
} TypeAlias; } TypeAlias;
@ -649,9 +650,9 @@ struct _type_ignore {
} v; } v;
}; };
enum _typeparam_kind {TypeVar_kind=1, ParamSpec_kind=2, TypeVarTuple_kind=3}; enum _type_param_kind {TypeVar_kind=1, ParamSpec_kind=2, TypeVarTuple_kind=3};
struct _typeparam { struct _type_param {
enum _typeparam_kind kind; enum _type_param_kind kind;
union { union {
struct { struct {
identifier name; identifier name;
@ -681,18 +682,18 @@ mod_ty _PyAST_Interactive(asdl_stmt_seq * body, PyArena *arena);
mod_ty _PyAST_Expression(expr_ty body, PyArena *arena); mod_ty _PyAST_Expression(expr_ty body, PyArena *arena);
mod_ty _PyAST_FunctionType(asdl_expr_seq * argtypes, expr_ty returns, PyArena mod_ty _PyAST_FunctionType(asdl_expr_seq * argtypes, expr_ty returns, PyArena
*arena); *arena);
stmt_ty _PyAST_FunctionDef(identifier name, asdl_typeparam_seq * typeparams, stmt_ty _PyAST_FunctionDef(identifier name, asdl_type_param_seq * type_params,
arguments_ty args, asdl_stmt_seq * body, arguments_ty args, asdl_stmt_seq * body,
asdl_expr_seq * decorator_list, expr_ty returns, asdl_expr_seq * decorator_list, expr_ty returns,
string type_comment, int lineno, int col_offset, int string type_comment, int lineno, int col_offset, int
end_lineno, int end_col_offset, PyArena *arena); end_lineno, int end_col_offset, PyArena *arena);
stmt_ty _PyAST_AsyncFunctionDef(identifier name, asdl_typeparam_seq * stmt_ty _PyAST_AsyncFunctionDef(identifier name, asdl_type_param_seq *
typeparams, arguments_ty args, asdl_stmt_seq * type_params, arguments_ty args, asdl_stmt_seq *
body, asdl_expr_seq * decorator_list, expr_ty body, asdl_expr_seq * decorator_list, expr_ty
returns, string type_comment, int lineno, int returns, string type_comment, int lineno, int
col_offset, int end_lineno, int end_col_offset, col_offset, int end_lineno, int end_col_offset,
PyArena *arena); PyArena *arena);
stmt_ty _PyAST_ClassDef(identifier name, asdl_typeparam_seq * typeparams, stmt_ty _PyAST_ClassDef(identifier name, asdl_type_param_seq * type_params,
asdl_expr_seq * bases, asdl_keyword_seq * keywords, asdl_expr_seq * bases, asdl_keyword_seq * keywords,
asdl_stmt_seq * body, asdl_expr_seq * decorator_list, asdl_stmt_seq * body, asdl_expr_seq * decorator_list,
int lineno, int col_offset, int end_lineno, int int lineno, int col_offset, int end_lineno, int
@ -704,9 +705,9 @@ stmt_ty _PyAST_Delete(asdl_expr_seq * targets, int lineno, int col_offset, int
stmt_ty _PyAST_Assign(asdl_expr_seq * targets, expr_ty value, string stmt_ty _PyAST_Assign(asdl_expr_seq * targets, expr_ty value, string
type_comment, int lineno, int col_offset, int end_lineno, type_comment, int lineno, int col_offset, int end_lineno,
int end_col_offset, PyArena *arena); int end_col_offset, PyArena *arena);
stmt_ty _PyAST_TypeAlias(expr_ty name, asdl_typeparam_seq * typeparams, expr_ty stmt_ty _PyAST_TypeAlias(expr_ty name, asdl_type_param_seq * type_params,
value, int lineno, int col_offset, int end_lineno, int expr_ty value, int lineno, int col_offset, int
end_col_offset, PyArena *arena); end_lineno, int end_col_offset, PyArena *arena);
stmt_ty _PyAST_AugAssign(expr_ty target, operator_ty op, expr_ty value, int stmt_ty _PyAST_AugAssign(expr_ty target, operator_ty op, expr_ty value, int
lineno, int col_offset, int end_lineno, int lineno, int col_offset, int end_lineno, int
end_col_offset, PyArena *arena); end_col_offset, PyArena *arena);
@ -891,12 +892,12 @@ pattern_ty _PyAST_MatchOr(asdl_pattern_seq * patterns, int lineno, int
col_offset, int end_lineno, int end_col_offset, col_offset, int end_lineno, int end_col_offset,
PyArena *arena); PyArena *arena);
type_ignore_ty _PyAST_TypeIgnore(int lineno, string tag, PyArena *arena); type_ignore_ty _PyAST_TypeIgnore(int lineno, string tag, PyArena *arena);
typeparam_ty _PyAST_TypeVar(identifier name, expr_ty bound, int lineno, int type_param_ty _PyAST_TypeVar(identifier name, expr_ty bound, int lineno, int
col_offset, int end_lineno, int end_col_offset, col_offset, int end_lineno, int end_col_offset,
PyArena *arena); PyArena *arena);
typeparam_ty _PyAST_ParamSpec(identifier name, int lineno, int col_offset, int type_param_ty _PyAST_ParamSpec(identifier name, int lineno, int col_offset, int
end_lineno, int end_col_offset, PyArena *arena); end_lineno, int end_col_offset, PyArena *arena);
typeparam_ty _PyAST_TypeVarTuple(identifier name, int lineno, int col_offset, type_param_ty _PyAST_TypeVarTuple(identifier name, int lineno, int col_offset,
int end_lineno, int end_col_offset, PyArena int end_lineno, int end_col_offset, PyArena
*arena); *arena);

4
Include/internal/pycore_ast_state.h generated
View File

@ -248,8 +248,8 @@ struct ast_state {
PyObject *type_comment; PyObject *type_comment;
PyObject *type_ignore_type; PyObject *type_ignore_type;
PyObject *type_ignores; PyObject *type_ignores;
PyObject *typeparam_type; PyObject *type_param_type;
PyObject *typeparams; PyObject *type_params;
PyObject *unaryop_type; PyObject *unaryop_type;
PyObject *upper; PyObject *upper;
PyObject *value; PyObject *value;

12
Lib/ast.py
View File

@ -1051,7 +1051,7 @@ class _Unparser(NodeVisitor):
self.fill("@") self.fill("@")
self.traverse(deco) self.traverse(deco)
self.fill("class " + node.name) self.fill("class " + node.name)
self._typeparams_helper(node.typeparams) self._type_params_helper(node.type_params)
with self.delimit_if("(", ")", condition = node.bases or node.keywords): with self.delimit_if("(", ")", condition = node.bases or node.keywords):
comma = False comma = False
for e in node.bases: for e in node.bases:
@ -1083,7 +1083,7 @@ class _Unparser(NodeVisitor):
self.traverse(deco) self.traverse(deco)
def_str = fill_suffix + " " + node.name def_str = fill_suffix + " " + node.name
self.fill(def_str) self.fill(def_str)
self._typeparams_helper(node.typeparams) self._type_params_helper(node.type_params)
with self.delimit("(", ")"): with self.delimit("(", ")"):
self.traverse(node.args) self.traverse(node.args)
if node.returns: if node.returns:
@ -1092,10 +1092,10 @@ class _Unparser(NodeVisitor):
with self.block(extra=self.get_type_comment(node)): with self.block(extra=self.get_type_comment(node)):
self._write_docstring_and_traverse_body(node) self._write_docstring_and_traverse_body(node)
def _typeparams_helper(self, typeparams): def _type_params_helper(self, type_params):
if typeparams is not None and len(typeparams) > 0: if type_params is not None and len(type_params) > 0:
with self.delimit("[", "]"): with self.delimit("[", "]"):
self.interleave(lambda: self.write(", "), self.traverse, typeparams) self.interleave(lambda: self.write(", "), self.traverse, type_params)
def visit_TypeVar(self, node): def visit_TypeVar(self, node):
self.write(node.name) self.write(node.name)
@ -1112,7 +1112,7 @@ class _Unparser(NodeVisitor):
def visit_TypeAlias(self, node): def visit_TypeAlias(self, node):
self.fill("type ") self.fill("type ")
self.traverse(node.name) self.traverse(node.name)
self._typeparams_helper(node.typeparams) self._type_params_helper(node.type_params)
self.write(" = ") self.write(" = ")
self.traverse(node.value) self.traverse(node.value)

2
Misc/NEWS.d/next/Core and Builtins/2023-04-25-08-43-11.gh-issue-103763.ZLBZk1.rst
View File

@ -8,7 +8,7 @@ attribute. This is implemented as a new AST node ``ast.TypeAlias``.
New syntax (``class X[T]: ...``, ``def func[T](): ...``) is added for defining New syntax (``class X[T]: ...``, ``def func[T](): ...``) is added for defining
generic functions and classes. This is implemented as a new generic functions and classes. This is implemented as a new
``typeparams`` attribute on the AST nodes for classes and functions. ``type_params`` attribute on the AST nodes for classes and functions.
This node holds instances of the new AST classes ``ast.TypeVar``, This node holds instances of the new AST classes ``ast.TypeVar``,
``ast.ParamSpec``, and ``ast.TypeVarTuple``. ``ast.ParamSpec``, and ``ast.TypeVarTuple``.

10
Parser/Python.asdl
View File

@ -8,15 +8,15 @@ module Python
| Expression(expr body) | Expression(expr body)
| FunctionType(expr* argtypes, expr returns) | FunctionType(expr* argtypes, expr returns)
stmt = FunctionDef(identifier name, typeparam* typeparams, arguments args, stmt = FunctionDef(identifier name, type_param* type_params, arguments args,
stmt* body, expr* decorator_list, expr? returns, stmt* body, expr* decorator_list, expr? returns,
string? type_comment) string? type_comment)
| AsyncFunctionDef(identifier name, typeparam* typeparams, arguments args, | AsyncFunctionDef(identifier name, type_param* type_params, arguments args,
stmt* body, expr* decorator_list, expr? returns, stmt* body, expr* decorator_list, expr? returns,
string? type_comment) string? type_comment)
| ClassDef(identifier name, | ClassDef(identifier name,
typeparam* typeparams, type_param* type_params,
expr* bases, expr* bases,
keyword* keywords, keyword* keywords,
stmt* body, stmt* body,
@ -25,7 +25,7 @@ module Python
| Delete(expr* targets) | Delete(expr* targets)
| Assign(expr* targets, expr value, string? type_comment) | Assign(expr* targets, expr value, string? type_comment)
| TypeAlias(expr name, typeparam* typeparams, expr value) | TypeAlias(expr name, type_param* type_params, expr value)
| AugAssign(expr target, operator op, expr value) | AugAssign(expr target, operator op, expr value)
-- 'simple' indicates that we annotate simple name without parens -- 'simple' indicates that we annotate simple name without parens
| AnnAssign(expr target, expr annotation, expr? value, int simple) | AnnAssign(expr target, expr annotation, expr? value, int simple)
@ -145,7 +145,7 @@ module Python
type_ignore = TypeIgnore(int lineno, string tag) type_ignore = TypeIgnore(int lineno, string tag)
typeparam = TypeVar(identifier name, expr? bound) type_param = TypeVar(identifier name, expr? bound)
| ParamSpec(identifier name) | ParamSpec(identifier name)
| TypeVarTuple(identifier name) | TypeVarTuple(identifier name)
attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset) attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)

6
Parser/action_helpers.c
View File

@ -752,7 +752,7 @@ _PyPegen_function_def_decorators(Parser *p, asdl_expr_seq *decorators, stmt_ty f
assert(function_def != NULL); assert(function_def != NULL);
if (function_def->kind == AsyncFunctionDef_kind) { if (function_def->kind == AsyncFunctionDef_kind) {
return _PyAST_AsyncFunctionDef( return _PyAST_AsyncFunctionDef(
function_def->v.FunctionDef.name, function_def->v.FunctionDef.typeparams, function_def->v.FunctionDef.name, function_def->v.FunctionDef.type_params,
function_def->v.FunctionDef.args, function_def->v.FunctionDef.args,
function_def->v.FunctionDef.body, decorators, function_def->v.FunctionDef.returns, function_def->v.FunctionDef.body, decorators, function_def->v.FunctionDef.returns,
function_def->v.FunctionDef.type_comment, function_def->lineno, function_def->v.FunctionDef.type_comment, function_def->lineno,
@ -761,7 +761,7 @@ _PyPegen_function_def_decorators(Parser *p, asdl_expr_seq *decorators, stmt_ty f
} }
return _PyAST_FunctionDef( return _PyAST_FunctionDef(
function_def->v.FunctionDef.name, function_def->v.FunctionDef.typeparams, function_def->v.FunctionDef.name, function_def->v.FunctionDef.type_params,
function_def->v.FunctionDef.args, function_def->v.FunctionDef.args,
function_def->v.FunctionDef.body, decorators, function_def->v.FunctionDef.body, decorators,
function_def->v.FunctionDef.returns, function_def->v.FunctionDef.returns,
@ -776,7 +776,7 @@ _PyPegen_class_def_decorators(Parser *p, asdl_expr_seq *decorators, stmt_ty clas
{ {
assert(class_def != NULL); assert(class_def != NULL);
return _PyAST_ClassDef( return _PyAST_ClassDef(
class_def->v.ClassDef.name, class_def->v.ClassDef.typeparams, class_def->v.ClassDef.name, class_def->v.ClassDef.type_params,
class_def->v.ClassDef.bases, class_def->v.ClassDef.keywords, class_def->v.ClassDef.bases, class_def->v.ClassDef.keywords,
class_def->v.ClassDef.body, decorators, class_def->v.ClassDef.body, decorators,
class_def->lineno, class_def->col_offset, class_def->end_lineno, class_def->lineno, class_def->col_offset, class_def->end_lineno,

30
Parser/parser.c generated
View File

@ -696,9 +696,9 @@ static asdl_pattern_seq* positional_patterns_rule(Parser *p);
static asdl_seq* keyword_patterns_rule(Parser *p); static asdl_seq* keyword_patterns_rule(Parser *p);
static KeyPatternPair* keyword_pattern_rule(Parser *p); static KeyPatternPair* keyword_pattern_rule(Parser *p);
static stmt_ty type_alias_rule(Parser *p); static stmt_ty type_alias_rule(Parser *p);
static asdl_typeparam_seq* type_params_rule(Parser *p); static asdl_type_param_seq* type_params_rule(Parser *p);
static asdl_typeparam_seq* type_param_seq_rule(Parser *p); static asdl_type_param_seq* type_param_seq_rule(Parser *p);
static typeparam_ty type_param_rule(Parser *p); static type_param_ty type_param_rule(Parser *p);
static expr_ty type_param_bound_rule(Parser *p); static expr_ty type_param_bound_rule(Parser *p);
static expr_ty expressions_rule(Parser *p); static expr_ty expressions_rule(Parser *p);
static expr_ty expression_rule(Parser *p); static expr_ty expression_rule(Parser *p);
@ -10653,7 +10653,7 @@ type_alias_rule(Parser *p)
} }
// type_params: '[' type_param_seq ']' // type_params: '[' type_param_seq ']'
static asdl_typeparam_seq* static asdl_type_param_seq*
type_params_rule(Parser *p) type_params_rule(Parser *p)
{ {
if (p->level++ == MAXSTACK) { if (p->level++ == MAXSTACK) {
@ -10664,7 +10664,7 @@ type_params_rule(Parser *p)
p->level--; p->level--;
return NULL; return NULL;
} }
asdl_typeparam_seq* _res = NULL; asdl_type_param_seq* _res = NULL;
int _mark = p->mark; int _mark = p->mark;
{ // '[' type_param_seq ']' { // '[' type_param_seq ']'
if (p->error_indicator) { if (p->error_indicator) {
@ -10674,7 +10674,7 @@ type_params_rule(Parser *p)
D(fprintf(stderr, "%*c> type_params[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'[' type_param_seq ']'")); D(fprintf(stderr, "%*c> type_params[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "'[' type_param_seq ']'"));
Token * _literal; Token * _literal;
Token * _literal_1; Token * _literal_1;
asdl_typeparam_seq* t; asdl_type_param_seq* t;
if ( if (
(_literal = _PyPegen_expect_token(p, 9)) // token='[' (_literal = _PyPegen_expect_token(p, 9)) // token='['
&& &&
@ -10684,7 +10684,7 @@ type_params_rule(Parser *p)
) )
{ {
D(fprintf(stderr, "%*c+ type_params[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'[' type_param_seq ']'")); D(fprintf(stderr, "%*c+ type_params[%d-%d]: %s succeeded!\n", p->level, ' ', _mark, p->mark, "'[' type_param_seq ']'"));
_res = CHECK_VERSION ( asdl_typeparam_seq* , 12 , "Type parameter lists are" , t ); _res = CHECK_VERSION ( asdl_type_param_seq* , 12 , "Type parameter lists are" , t );
if (_res == NULL && PyErr_Occurred()) { if (_res == NULL && PyErr_Occurred()) {
p->error_indicator = 1; p->error_indicator = 1;
p->level--; p->level--;
@ -10703,7 +10703,7 @@ type_params_rule(Parser *p)
} }
// type_param_seq: ','.type_param+ ','? // type_param_seq: ','.type_param+ ','?
static asdl_typeparam_seq* static asdl_type_param_seq*
type_param_seq_rule(Parser *p) type_param_seq_rule(Parser *p)
{ {
if (p->level++ == MAXSTACK) { if (p->level++ == MAXSTACK) {
@ -10714,7 +10714,7 @@ type_param_seq_rule(Parser *p)
p->level--; p->level--;
return NULL; return NULL;
} }
asdl_typeparam_seq* _res = NULL; asdl_type_param_seq* _res = NULL;
int _mark = p->mark; int _mark = p->mark;
{ // ','.type_param+ ','? { // ','.type_param+ ','?
if (p->error_indicator) { if (p->error_indicator) {
@ -10724,9 +10724,9 @@ type_param_seq_rule(Parser *p)
D(fprintf(stderr, "%*c> type_param_seq[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.type_param+ ','?")); D(fprintf(stderr, "%*c> type_param_seq[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "','.type_param+ ','?"));
void *_opt_var; void *_opt_var;
UNUSED(_opt_var); // Silence compiler warnings UNUSED(_opt_var); // Silence compiler warnings
asdl_typeparam_seq* a; asdl_type_param_seq* a;
if ( if (
(a = (asdl_typeparam_seq*)_gather_81_rule(p)) // ','.type_param+ (a = (asdl_type_param_seq*)_gather_81_rule(p)) // ','.type_param+
&& &&
(_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','? (_opt_var = _PyPegen_expect_token(p, 12), !p->error_indicator) // ','?
) )
@ -10756,7 +10756,7 @@ type_param_seq_rule(Parser *p)
// | '*' NAME // | '*' NAME
// | '**' NAME ":" expression // | '**' NAME ":" expression
// | '**' NAME // | '**' NAME
static typeparam_ty static type_param_ty
type_param_rule(Parser *p) type_param_rule(Parser *p)
{ {
if (p->level++ == MAXSTACK) { if (p->level++ == MAXSTACK) {
@ -10767,7 +10767,7 @@ type_param_rule(Parser *p)
p->level--; p->level--;
return NULL; return NULL;
} }
typeparam_ty _res = NULL; type_param_ty _res = NULL;
if (_PyPegen_is_memoized(p, type_param_type, &_res)) { if (_PyPegen_is_memoized(p, type_param_type, &_res)) {
p->level--; p->level--;
return _res; return _res;
@ -30199,7 +30199,7 @@ _loop0_82_rule(Parser *p)
} }
D(fprintf(stderr, "%*c> _loop0_82[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' type_param")); D(fprintf(stderr, "%*c> _loop0_82[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "',' type_param"));
Token * _literal; Token * _literal;
typeparam_ty elem; type_param_ty elem;
while ( while (
(_literal = _PyPegen_expect_token(p, 12)) // token=',' (_literal = _PyPegen_expect_token(p, 12)) // token=','
&& &&
@ -30266,7 +30266,7 @@ _gather_81_rule(Parser *p)
return NULL; return NULL;
} }
D(fprintf(stderr, "%*c> _gather_81[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "type_param _loop0_82")); D(fprintf(stderr, "%*c> _gather_81[%d-%d]: %s\n", p->level, ' ', _mark, p->mark, "type_param _loop0_82"));
typeparam_ty elem; type_param_ty elem;
asdl_seq * seq; asdl_seq * seq;
if ( if (
(elem = type_param_rule(p)) // type_param (elem = type_param_rule(p)) // type_param

244
Python/Python-ast.c generated
View File

@ -261,8 +261,8 @@ void _PyAST_Fini(PyInterpreterState *interp)
Py_CLEAR(state->type_comment); Py_CLEAR(state->type_comment);
Py_CLEAR(state->type_ignore_type); Py_CLEAR(state->type_ignore_type);
Py_CLEAR(state->type_ignores); Py_CLEAR(state->type_ignores);
Py_CLEAR(state->typeparam_type); Py_CLEAR(state->type_param_type);
Py_CLEAR(state->typeparams); Py_CLEAR(state->type_params);
Py_CLEAR(state->unaryop_type); Py_CLEAR(state->unaryop_type);
Py_CLEAR(state->upper); Py_CLEAR(state->upper);
Py_CLEAR(state->value); Py_CLEAR(state->value);
@ -362,7 +362,7 @@ static int init_identifiers(struct ast_state *state)
if ((state->type = PyUnicode_InternFromString("type")) == NULL) return 0; if ((state->type = PyUnicode_InternFromString("type")) == NULL) return 0;
if ((state->type_comment = PyUnicode_InternFromString("type_comment")) == NULL) return 0; if ((state->type_comment = PyUnicode_InternFromString("type_comment")) == NULL) return 0;
if ((state->type_ignores = PyUnicode_InternFromString("type_ignores")) == NULL) return 0; if ((state->type_ignores = PyUnicode_InternFromString("type_ignores")) == NULL) return 0;
if ((state->typeparams = PyUnicode_InternFromString("typeparams")) == NULL) return 0; if ((state->type_params = PyUnicode_InternFromString("type_params")) == NULL) return 0;
if ((state->upper = PyUnicode_InternFromString("upper")) == NULL) return 0; if ((state->upper = PyUnicode_InternFromString("upper")) == NULL) return 0;
if ((state->value = PyUnicode_InternFromString("value")) == NULL) return 0; if ((state->value = PyUnicode_InternFromString("value")) == NULL) return 0;
if ((state->values = PyUnicode_InternFromString("values")) == NULL) return 0; if ((state->values = PyUnicode_InternFromString("values")) == NULL) return 0;
@ -383,7 +383,7 @@ GENERATE_ASDL_SEQ_CONSTRUCTOR(withitem, withitem_ty)
GENERATE_ASDL_SEQ_CONSTRUCTOR(match_case, match_case_ty) GENERATE_ASDL_SEQ_CONSTRUCTOR(match_case, match_case_ty)
GENERATE_ASDL_SEQ_CONSTRUCTOR(pattern, pattern_ty) GENERATE_ASDL_SEQ_CONSTRUCTOR(pattern, pattern_ty)
GENERATE_ASDL_SEQ_CONSTRUCTOR(type_ignore, type_ignore_ty) GENERATE_ASDL_SEQ_CONSTRUCTOR(type_ignore, type_ignore_ty)
GENERATE_ASDL_SEQ_CONSTRUCTOR(typeparam, typeparam_ty) GENERATE_ASDL_SEQ_CONSTRUCTOR(type_param, type_param_ty)
static PyObject* ast2obj_mod(struct ast_state *state, void*); static PyObject* ast2obj_mod(struct ast_state *state, void*);
static const char * const Module_fields[]={ static const char * const Module_fields[]={
@ -409,7 +409,7 @@ static const char * const stmt_attributes[] = {
static PyObject* ast2obj_stmt(struct ast_state *state, void*); static PyObject* ast2obj_stmt(struct ast_state *state, void*);
static const char * const FunctionDef_fields[]={ static const char * const FunctionDef_fields[]={
"name", "name",
"typeparams", "type_params",
"args", "args",
"body", "body",
"decorator_list", "decorator_list",
@ -418,7 +418,7 @@ static const char * const FunctionDef_fields[]={
}; };
static const char * const AsyncFunctionDef_fields[]={ static const char * const AsyncFunctionDef_fields[]={
"name", "name",
"typeparams", "type_params",
"args", "args",
"body", "body",
"decorator_list", "decorator_list",
@ -427,7 +427,7 @@ static const char * const AsyncFunctionDef_fields[]={
}; };
static const char * const ClassDef_fields[]={ static const char * const ClassDef_fields[]={
"name", "name",
"typeparams", "type_params",
"bases", "bases",
"keywords", "keywords",
"body", "body",
@ -446,7 +446,7 @@ static const char * const Assign_fields[]={
}; };
static const char * const TypeAlias_fields[]={ static const char * const TypeAlias_fields[]={
"name", "name",
"typeparams", "type_params",
"value", "value",
}; };
static const char * const AugAssign_fields[]={ static const char * const AugAssign_fields[]={
@ -775,13 +775,13 @@ static const char * const TypeIgnore_fields[]={
"lineno", "lineno",
"tag", "tag",
}; };
static const char * const typeparam_attributes[] = { static const char * const type_param_attributes[] = {
"lineno", "lineno",
"col_offset", "col_offset",
"end_lineno", "end_lineno",
"end_col_offset", "end_col_offset",
}; };
static PyObject* ast2obj_typeparam(struct ast_state *state, void*); static PyObject* ast2obj_type_param(struct ast_state *state, void*);
static const char * const TypeVar_fields[]={ static const char * const TypeVar_fields[]={
"name", "name",
"bound", "bound",
@ -1169,13 +1169,13 @@ init_types(struct ast_state *state)
"FunctionType(expr* argtypes, expr returns)"); "FunctionType(expr* argtypes, expr returns)");
if (!state->FunctionType_type) return 0; if (!state->FunctionType_type) return 0;
state->stmt_type = make_type(state, "stmt", state->AST_type, NULL, 0, state->stmt_type = make_type(state, "stmt", state->AST_type, NULL, 0,
"stmt = FunctionDef(identifier name, typeparam* typeparams, arguments args, stmt* body, expr* decorator_list, expr? returns, string? type_comment)\n" "stmt = FunctionDef(identifier name, type_param* type_params, arguments args, stmt* body, expr* decorator_list, expr? returns, string? type_comment)\n"
" | AsyncFunctionDef(identifier name, typeparam* typeparams, arguments args, stmt* body, expr* decorator_list, expr? returns, string? type_comment)\n" " | AsyncFunctionDef(identifier name, type_param* type_params, arguments args, stmt* body, expr* decorator_list, expr? returns, string? type_comment)\n"
" | ClassDef(identifier name, typeparam* typeparams, expr* bases, keyword* keywords, stmt* body, expr* decorator_list)\n" " | ClassDef(identifier name, type_param* type_params, expr* bases, keyword* keywords, stmt* body, expr* decorator_list)\n"
" | Return(expr? value)\n" " | Return(expr? value)\n"
" | Delete(expr* targets)\n" " | Delete(expr* targets)\n"
" | Assign(expr* targets, expr value, string? type_comment)\n" " | Assign(expr* targets, expr value, string? type_comment)\n"
" | TypeAlias(expr name, typeparam* typeparams, expr value)\n" " | TypeAlias(expr name, type_param* type_params, expr value)\n"
" | AugAssign(expr target, operator op, expr value)\n" " | AugAssign(expr target, operator op, expr value)\n"
" | AnnAssign(expr target, expr annotation, expr? value, int simple)\n" " | AnnAssign(expr target, expr annotation, expr? value, int simple)\n"
" | For(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)\n" " | For(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)\n"
@ -1206,7 +1206,7 @@ init_types(struct ast_state *state)
return 0; return 0;
state->FunctionDef_type = make_type(state, "FunctionDef", state->stmt_type, state->FunctionDef_type = make_type(state, "FunctionDef", state->stmt_type,
FunctionDef_fields, 7, FunctionDef_fields, 7,
"FunctionDef(identifier name, typeparam* typeparams, arguments args, stmt* body, expr* decorator_list, expr? returns, string? type_comment)"); "FunctionDef(identifier name, type_param* type_params, arguments args, stmt* body, expr* decorator_list, expr? returns, string? type_comment)");
if (!state->FunctionDef_type) return 0; if (!state->FunctionDef_type) return 0;
if (PyObject_SetAttr(state->FunctionDef_type, state->returns, Py_None) == if (PyObject_SetAttr(state->FunctionDef_type, state->returns, Py_None) ==
-1) -1)
@ -1217,7 +1217,7 @@ init_types(struct ast_state *state)
state->AsyncFunctionDef_type = make_type(state, "AsyncFunctionDef", state->AsyncFunctionDef_type = make_type(state, "AsyncFunctionDef",
state->stmt_type, state->stmt_type,
AsyncFunctionDef_fields, 7, AsyncFunctionDef_fields, 7,
"AsyncFunctionDef(identifier name, typeparam* typeparams, arguments args, stmt* body, expr* decorator_list, expr? returns, string? type_comment)"); "AsyncFunctionDef(identifier name, type_param* type_params, arguments args, stmt* body, expr* decorator_list, expr? returns, string? type_comment)");
if (!state->AsyncFunctionDef_type) return 0; if (!state->AsyncFunctionDef_type) return 0;
if (PyObject_SetAttr(state->AsyncFunctionDef_type, state->returns, Py_None) if (PyObject_SetAttr(state->AsyncFunctionDef_type, state->returns, Py_None)
== -1) == -1)
@ -1227,7 +1227,7 @@ init_types(struct ast_state *state)
return 0; return 0;
state->ClassDef_type = make_type(state, "ClassDef", state->stmt_type, state->ClassDef_type = make_type(state, "ClassDef", state->stmt_type,
ClassDef_fields, 6, ClassDef_fields, 6,
"ClassDef(identifier name, typeparam* typeparams, expr* bases, keyword* keywords, stmt* body, expr* decorator_list)"); "ClassDef(identifier name, type_param* type_params, expr* bases, keyword* keywords, stmt* body, expr* decorator_list)");
if (!state->ClassDef_type) return 0; if (!state->ClassDef_type) return 0;
state->Return_type = make_type(state, "Return", state->stmt_type, state->Return_type = make_type(state, "Return", state->stmt_type,
Return_fields, 1, Return_fields, 1,
@ -1248,7 +1248,7 @@ init_types(struct ast_state *state)
return 0; return 0;
state->TypeAlias_type = make_type(state, "TypeAlias", state->stmt_type, state->TypeAlias_type = make_type(state, "TypeAlias", state->stmt_type,
TypeAlias_fields, 3, TypeAlias_fields, 3,
"TypeAlias(expr name, typeparam* typeparams, expr value)"); "TypeAlias(expr name, type_param* type_params, expr value)");
if (!state->TypeAlias_type) return 0; if (!state->TypeAlias_type) return 0;
state->AugAssign_type = make_type(state, "AugAssign", state->stmt_type, state->AugAssign_type = make_type(state, "AugAssign", state->stmt_type,
AugAssign_fields, 3, AugAssign_fields, 3,
@ -1894,33 +1894,33 @@ init_types(struct ast_state *state)
TypeIgnore_fields, 2, TypeIgnore_fields, 2,
"TypeIgnore(int lineno, string tag)"); "TypeIgnore(int lineno, string tag)");
if (!state->TypeIgnore_type) return 0; if (!state->TypeIgnore_type) return 0;
state->typeparam_type = make_type(state, "typeparam", state->AST_type, state->type_param_type = make_type(state, "type_param", state->AST_type,
NULL, 0, NULL, 0,
"typeparam = TypeVar(identifier name, expr? bound)\n" "type_param = TypeVar(identifier name, expr? bound)\n"
" | ParamSpec(identifier name)\n" " | ParamSpec(identifier name)\n"
" | TypeVarTuple(identifier name)"); " | TypeVarTuple(identifier name)");
if (!state->typeparam_type) return 0; if (!state->type_param_type) return 0;
if (!add_attributes(state, state->typeparam_type, typeparam_attributes, 4)) if (!add_attributes(state, state->type_param_type, type_param_attributes,
return 0; 4)) return 0;
if (PyObject_SetAttr(state->typeparam_type, state->end_lineno, Py_None) == if (PyObject_SetAttr(state->type_param_type, state->end_lineno, Py_None) ==
-1) -1)
return 0; return 0;
if (PyObject_SetAttr(state->typeparam_type, state->end_col_offset, Py_None) if (PyObject_SetAttr(state->type_param_type, state->end_col_offset,
== -1) Py_None) == -1)
return 0; return 0;
state->TypeVar_type = make_type(state, "TypeVar", state->typeparam_type, state->TypeVar_type = make_type(state, "TypeVar", state->type_param_type,
TypeVar_fields, 2, TypeVar_fields, 2,
"TypeVar(identifier name, expr? bound)"); "TypeVar(identifier name, expr? bound)");
if (!state->TypeVar_type) return 0; if (!state->TypeVar_type) return 0;
if (PyObject_SetAttr(state->TypeVar_type, state->bound, Py_None) == -1) if (PyObject_SetAttr(state->TypeVar_type, state->bound, Py_None) == -1)
return 0; return 0;
state->ParamSpec_type = make_type(state, "ParamSpec", state->ParamSpec_type = make_type(state, "ParamSpec",
state->typeparam_type, ParamSpec_fields, state->type_param_type, ParamSpec_fields,
1, 1,
"ParamSpec(identifier name)"); "ParamSpec(identifier name)");
if (!state->ParamSpec_type) return 0; if (!state->ParamSpec_type) return 0;
state->TypeVarTuple_type = make_type(state, "TypeVarTuple", state->TypeVarTuple_type = make_type(state, "TypeVarTuple",
state->typeparam_type, state->type_param_type,
TypeVarTuple_fields, 1, TypeVarTuple_fields, 1,
"TypeVarTuple(identifier name)"); "TypeVarTuple(identifier name)");
if (!state->TypeVarTuple_type) return 0; if (!state->TypeVarTuple_type) return 0;
@ -1967,8 +1967,8 @@ static int obj2ast_pattern(struct ast_state *state, PyObject* obj, pattern_ty*
out, PyArena* arena); out, PyArena* arena);
static int obj2ast_type_ignore(struct ast_state *state, PyObject* obj, static int obj2ast_type_ignore(struct ast_state *state, PyObject* obj,
type_ignore_ty* out, PyArena* arena); type_ignore_ty* out, PyArena* arena);
static int obj2ast_typeparam(struct ast_state *state, PyObject* obj, static int obj2ast_type_param(struct ast_state *state, PyObject* obj,
typeparam_ty* out, PyArena* arena); type_param_ty* out, PyArena* arena);
mod_ty mod_ty
_PyAST_Module(asdl_stmt_seq * body, asdl_type_ignore_seq * type_ignores, _PyAST_Module(asdl_stmt_seq * body, asdl_type_ignore_seq * type_ignores,
@ -2032,7 +2032,7 @@ _PyAST_FunctionType(asdl_expr_seq * argtypes, expr_ty returns, PyArena *arena)
} }
stmt_ty stmt_ty
_PyAST_FunctionDef(identifier name, asdl_typeparam_seq * typeparams, _PyAST_FunctionDef(identifier name, asdl_type_param_seq * type_params,
arguments_ty args, asdl_stmt_seq * body, asdl_expr_seq * arguments_ty args, asdl_stmt_seq * body, asdl_expr_seq *
decorator_list, expr_ty returns, string type_comment, int decorator_list, expr_ty returns, string type_comment, int
lineno, int col_offset, int end_lineno, int end_col_offset, lineno, int col_offset, int end_lineno, int end_col_offset,
@ -2054,7 +2054,7 @@ _PyAST_FunctionDef(identifier name, asdl_typeparam_seq * typeparams,
return NULL; return NULL;
p->kind = FunctionDef_kind; p->kind = FunctionDef_kind;
p->v.FunctionDef.name = name; p->v.FunctionDef.name = name;
p->v.FunctionDef.typeparams = typeparams; p->v.FunctionDef.type_params = type_params;
p->v.FunctionDef.args = args; p->v.FunctionDef.args = args;
p->v.FunctionDef.body = body; p->v.FunctionDef.body = body;
p->v.FunctionDef.decorator_list = decorator_list; p->v.FunctionDef.decorator_list = decorator_list;
@ -2068,7 +2068,7 @@ _PyAST_FunctionDef(identifier name, asdl_typeparam_seq * typeparams,
} }
stmt_ty stmt_ty
_PyAST_AsyncFunctionDef(identifier name, asdl_typeparam_seq * typeparams, _PyAST_AsyncFunctionDef(identifier name, asdl_type_param_seq * type_params,
arguments_ty args, asdl_stmt_seq * body, asdl_expr_seq arguments_ty args, asdl_stmt_seq * body, asdl_expr_seq
* decorator_list, expr_ty returns, string type_comment, * decorator_list, expr_ty returns, string type_comment,
int lineno, int col_offset, int end_lineno, int int lineno, int col_offset, int end_lineno, int
@ -2090,7 +2090,7 @@ _PyAST_AsyncFunctionDef(identifier name, asdl_typeparam_seq * typeparams,
return NULL; return NULL;
p->kind = AsyncFunctionDef_kind; p->kind = AsyncFunctionDef_kind;
p->v.AsyncFunctionDef.name = name; p->v.AsyncFunctionDef.name = name;
p->v.AsyncFunctionDef.typeparams = typeparams; p->v.AsyncFunctionDef.type_params = type_params;
p->v.AsyncFunctionDef.args = args; p->v.AsyncFunctionDef.args = args;
p->v.AsyncFunctionDef.body = body; p->v.AsyncFunctionDef.body = body;
p->v.AsyncFunctionDef.decorator_list = decorator_list; p->v.AsyncFunctionDef.decorator_list = decorator_list;
@ -2104,10 +2104,11 @@ _PyAST_AsyncFunctionDef(identifier name, asdl_typeparam_seq * typeparams,
} }
stmt_ty stmt_ty
_PyAST_ClassDef(identifier name, asdl_typeparam_seq * typeparams, asdl_expr_seq _PyAST_ClassDef(identifier name, asdl_type_param_seq * type_params,
* bases, asdl_keyword_seq * keywords, asdl_stmt_seq * body, asdl_expr_seq * bases, asdl_keyword_seq * keywords,
asdl_expr_seq * decorator_list, int lineno, int col_offset, int asdl_stmt_seq * body, asdl_expr_seq * decorator_list, int
end_lineno, int end_col_offset, PyArena *arena) lineno, int col_offset, int end_lineno, int end_col_offset,
PyArena *arena)
{ {
stmt_ty p; stmt_ty p;
if (!name) { if (!name) {
@ -2120,7 +2121,7 @@ _PyAST_ClassDef(identifier name, asdl_typeparam_seq * typeparams, asdl_expr_seq
return NULL; return NULL;
p->kind = ClassDef_kind; p->kind = ClassDef_kind;
p->v.ClassDef.name = name; p->v.ClassDef.name = name;
p->v.ClassDef.typeparams = typeparams; p->v.ClassDef.type_params = type_params;
p->v.ClassDef.bases = bases; p->v.ClassDef.bases = bases;
p->v.ClassDef.keywords = keywords; p->v.ClassDef.keywords = keywords;
p->v.ClassDef.body = body; p->v.ClassDef.body = body;
@ -2192,8 +2193,8 @@ _PyAST_Assign(asdl_expr_seq * targets, expr_ty value, string type_comment, int
} }
stmt_ty stmt_ty
_PyAST_TypeAlias(expr_ty name, asdl_typeparam_seq * typeparams, expr_ty value, _PyAST_TypeAlias(expr_ty name, asdl_type_param_seq * type_params, expr_ty
int lineno, int col_offset, int end_lineno, int value, int lineno, int col_offset, int end_lineno, int
end_col_offset, PyArena *arena) end_col_offset, PyArena *arena)
{ {
stmt_ty p; stmt_ty p;
@ -2212,7 +2213,7 @@ _PyAST_TypeAlias(expr_ty name, asdl_typeparam_seq * typeparams, expr_ty value,
return NULL; return NULL;
p->kind = TypeAlias_kind; p->kind = TypeAlias_kind;
p->v.TypeAlias.name = name; p->v.TypeAlias.name = name;
p->v.TypeAlias.typeparams = typeparams; p->v.TypeAlias.type_params = type_params;
p->v.TypeAlias.value = value; p->v.TypeAlias.value = value;
p->lineno = lineno; p->lineno = lineno;
p->col_offset = col_offset; p->col_offset = col_offset;
@ -3713,17 +3714,17 @@ _PyAST_TypeIgnore(int lineno, string tag, PyArena *arena)
return p; return p;
} }
typeparam_ty type_param_ty
_PyAST_TypeVar(identifier name, expr_ty bound, int lineno, int col_offset, int _PyAST_TypeVar(identifier name, expr_ty bound, int lineno, int col_offset, int
end_lineno, int end_col_offset, PyArena *arena) end_lineno, int end_col_offset, PyArena *arena)
{ {
typeparam_ty p; type_param_ty p;
if (!name) { if (!name) {
PyErr_SetString(PyExc_ValueError, PyErr_SetString(PyExc_ValueError,
"field 'name' is required for TypeVar"); "field 'name' is required for TypeVar");
return NULL; return NULL;
} }
p = (typeparam_ty)_PyArena_Malloc(arena, sizeof(*p)); p = (type_param_ty)_PyArena_Malloc(arena, sizeof(*p));
if (!p) if (!p)
return NULL; return NULL;
p->kind = TypeVar_kind; p->kind = TypeVar_kind;
@ -3736,17 +3737,17 @@ _PyAST_TypeVar(identifier name, expr_ty bound, int lineno, int col_offset, int
return p; return p;
} }
typeparam_ty type_param_ty
_PyAST_ParamSpec(identifier name, int lineno, int col_offset, int end_lineno, _PyAST_ParamSpec(identifier name, int lineno, int col_offset, int end_lineno,
int end_col_offset, PyArena *arena) int end_col_offset, PyArena *arena)
{ {
typeparam_ty p; type_param_ty p;
if (!name) { if (!name) {
PyErr_SetString(PyExc_ValueError, PyErr_SetString(PyExc_ValueError,
"field 'name' is required for ParamSpec"); "field 'name' is required for ParamSpec");
return NULL; return NULL;
} }
p = (typeparam_ty)_PyArena_Malloc(arena, sizeof(*p)); p = (type_param_ty)_PyArena_Malloc(arena, sizeof(*p));
if (!p) if (!p)
return NULL; return NULL;
p->kind = ParamSpec_kind; p->kind = ParamSpec_kind;
@ -3758,17 +3759,17 @@ _PyAST_ParamSpec(identifier name, int lineno, int col_offset, int end_lineno,
return p; return p;
} }
typeparam_ty type_param_ty
_PyAST_TypeVarTuple(identifier name, int lineno, int col_offset, int _PyAST_TypeVarTuple(identifier name, int lineno, int col_offset, int
end_lineno, int end_col_offset, PyArena *arena) end_lineno, int end_col_offset, PyArena *arena)
{ {
typeparam_ty p; type_param_ty p;
if (!name) { if (!name) {
PyErr_SetString(PyExc_ValueError, PyErr_SetString(PyExc_ValueError,
"field 'name' is required for TypeVarTuple"); "field 'name' is required for TypeVarTuple");
return NULL; return NULL;
} }
p = (typeparam_ty)_PyArena_Malloc(arena, sizeof(*p)); p = (type_param_ty)_PyArena_Malloc(arena, sizeof(*p));
if (!p) if (!p)
return NULL; return NULL;
p->kind = TypeVarTuple_kind; p->kind = TypeVarTuple_kind;
@ -3882,10 +3883,10 @@ ast2obj_stmt(struct ast_state *state, void* _o)
if (PyObject_SetAttr(result, state->name, value) == -1) if (PyObject_SetAttr(result, state->name, value) == -1)
goto failed; goto failed;
Py_DECREF(value); Py_DECREF(value);
value = ast2obj_list(state, (asdl_seq*)o->v.FunctionDef.typeparams, value = ast2obj_list(state, (asdl_seq*)o->v.FunctionDef.type_params,
ast2obj_typeparam); ast2obj_type_param);
if (!value) goto failed; if (!value) goto failed;
if (PyObject_SetAttr(result, state->typeparams, value) == -1) if (PyObject_SetAttr(result, state->type_params, value) == -1)
goto failed; goto failed;
Py_DECREF(value); Py_DECREF(value);
value = ast2obj_arguments(state, o->v.FunctionDef.args); value = ast2obj_arguments(state, o->v.FunctionDef.args);
@ -3926,10 +3927,10 @@ ast2obj_stmt(struct ast_state *state, void* _o)
goto failed; goto failed;
Py_DECREF(value); Py_DECREF(value);
value = ast2obj_list(state, value = ast2obj_list(state,
(asdl_seq*)o->v.AsyncFunctionDef.typeparams, (asdl_seq*)o->v.AsyncFunctionDef.type_params,
ast2obj_typeparam); ast2obj_type_param);
if (!value) goto failed; if (!value) goto failed;
if (PyObject_SetAttr(result, state->typeparams, value) == -1) if (PyObject_SetAttr(result, state->type_params, value) == -1)
goto failed; goto failed;
Py_DECREF(value); Py_DECREF(value);
value = ast2obj_arguments(state, o->v.AsyncFunctionDef.args); value = ast2obj_arguments(state, o->v.AsyncFunctionDef.args);
@ -3970,10 +3971,10 @@ ast2obj_stmt(struct ast_state *state, void* _o)
if (PyObject_SetAttr(result, state->name, value) == -1) if (PyObject_SetAttr(result, state->name, value) == -1)
goto failed; goto failed;
Py_DECREF(value); Py_DECREF(value);
value = ast2obj_list(state, (asdl_seq*)o->v.ClassDef.typeparams, value = ast2obj_list(state, (asdl_seq*)o->v.ClassDef.type_params,
ast2obj_typeparam); ast2obj_type_param);
if (!value) goto failed; if (!value) goto failed;
if (PyObject_SetAttr(result, state->typeparams, value) == -1) if (PyObject_SetAttr(result, state->type_params, value) == -1)
goto failed; goto failed;
Py_DECREF(value); Py_DECREF(value);
value = ast2obj_list(state, (asdl_seq*)o->v.ClassDef.bases, value = ast2obj_list(state, (asdl_seq*)o->v.ClassDef.bases,
@ -4052,10 +4053,10 @@ ast2obj_stmt(struct ast_state *state, void* _o)
if (PyObject_SetAttr(result, state->name, value) == -1) if (PyObject_SetAttr(result, state->name, value) == -1)
goto failed; goto failed;
Py_DECREF(value); Py_DECREF(value);
value = ast2obj_list(state, (asdl_seq*)o->v.TypeAlias.typeparams, value = ast2obj_list(state, (asdl_seq*)o->v.TypeAlias.type_params,
ast2obj_typeparam); ast2obj_type_param);
if (!value) goto failed; if (!value) goto failed;
if (PyObject_SetAttr(result, state->typeparams, value) == -1) if (PyObject_SetAttr(result, state->type_params, value) == -1)
goto failed; goto failed;
Py_DECREF(value); Py_DECREF(value);
value = ast2obj_expr(state, o->v.TypeAlias.value); value = ast2obj_expr(state, o->v.TypeAlias.value);
@ -5656,9 +5657,9 @@ failed:
} }
PyObject* PyObject*
ast2obj_typeparam(struct ast_state *state, void* _o) ast2obj_type_param(struct ast_state *state, void* _o)
{ {
typeparam_ty o = (typeparam_ty)_o; type_param_ty o = (type_param_ty)_o;
PyObject *result = NULL, *value = NULL; PyObject *result = NULL, *value = NULL;
PyTypeObject *tp; PyTypeObject *tp;
if (!o) { if (!o) {
@ -6074,7 +6075,7 @@ obj2ast_stmt(struct ast_state *state, PyObject* obj, stmt_ty* out, PyArena*
} }
if (isinstance) { if (isinstance) {
identifier name; identifier name;
asdl_typeparam_seq* typeparams; asdl_type_param_seq* type_params;
arguments_ty args; arguments_ty args;
asdl_stmt_seq* body; asdl_stmt_seq* body;
asdl_expr_seq* decorator_list; asdl_expr_seq* decorator_list;
@ -6098,11 +6099,11 @@ obj2ast_stmt(struct ast_state *state, PyObject* obj, stmt_ty* out, PyArena*
if (res != 0) goto failed; if (res != 0) goto failed;
Py_CLEAR(tmp); Py_CLEAR(tmp);
} }
if (_PyObject_LookupAttr(obj, state->typeparams, &tmp) < 0) { if (_PyObject_LookupAttr(obj, state->type_params, &tmp) < 0) {
return 1; return 1;
} }
if (tmp == NULL) { if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"typeparams\" missing from FunctionDef"); PyErr_SetString(PyExc_TypeError, "required field \"type_params\" missing from FunctionDef");
return 1; return 1;
} }
else { else {
@ -6110,27 +6111,27 @@ obj2ast_stmt(struct ast_state *state, PyObject* obj, stmt_ty* out, PyArena*
Py_ssize_t len; Py_ssize_t len;
Py_ssize_t i; Py_ssize_t i;
if (!PyList_Check(tmp)) { if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "FunctionDef field \"typeparams\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); PyErr_Format(PyExc_TypeError, "FunctionDef field \"type_params\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed; goto failed;
} }
len = PyList_GET_SIZE(tmp); len = PyList_GET_SIZE(tmp);
typeparams = _Py_asdl_typeparam_seq_new(len, arena); type_params = _Py_asdl_type_param_seq_new(len, arena);
if (typeparams == NULL) goto failed; if (type_params == NULL) goto failed;
for (i = 0; i < len; i++) { for (i = 0; i < len; i++) {
typeparam_ty val; type_param_ty val;
PyObject *tmp2 = Py_NewRef(PyList_GET_ITEM(tmp, i)); PyObject *tmp2 = Py_NewRef(PyList_GET_ITEM(tmp, i));
if (_Py_EnterRecursiveCall(" while traversing 'FunctionDef' node")) { if (_Py_EnterRecursiveCall(" while traversing 'FunctionDef' node")) {
goto failed; goto failed;
} }
res = obj2ast_typeparam(state, tmp2, &val, arena); res = obj2ast_type_param(state, tmp2, &val, arena);
_Py_LeaveRecursiveCall(); _Py_LeaveRecursiveCall();
Py_DECREF(tmp2); Py_DECREF(tmp2);
if (res != 0) goto failed; if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) { if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "FunctionDef field \"typeparams\" changed size during iteration"); PyErr_SetString(PyExc_RuntimeError, "FunctionDef field \"type_params\" changed size during iteration");
goto failed; goto failed;
} }
asdl_seq_SET(typeparams, i, val); asdl_seq_SET(type_params, i, val);
} }
Py_CLEAR(tmp); Py_CLEAR(tmp);
} }
@ -6257,9 +6258,10 @@ obj2ast_stmt(struct ast_state *state, PyObject* obj, stmt_ty* out, PyArena*
if (res != 0) goto failed; if (res != 0) goto failed;
Py_CLEAR(tmp); Py_CLEAR(tmp);
} }
*out = _PyAST_FunctionDef(name, typeparams, args, body, decorator_list, *out = _PyAST_FunctionDef(name, type_params, args, body,
returns, type_comment, lineno, col_offset, decorator_list, returns, type_comment,
end_lineno, end_col_offset, arena); lineno, col_offset, end_lineno,
end_col_offset, arena);
if (*out == NULL) goto failed; if (*out == NULL) goto failed;
return 0; return 0;
} }
@ -6270,7 +6272,7 @@ obj2ast_stmt(struct ast_state *state, PyObject* obj, stmt_ty* out, PyArena*
} }
if (isinstance) { if (isinstance) {
identifier name; identifier name;
asdl_typeparam_seq* typeparams; asdl_type_param_seq* type_params;
arguments_ty args; arguments_ty args;
asdl_stmt_seq* body; asdl_stmt_seq* body;
asdl_expr_seq* decorator_list; asdl_expr_seq* decorator_list;
@ -6294,11 +6296,11 @@ obj2ast_stmt(struct ast_state *state, PyObject* obj, stmt_ty* out, PyArena*
if (res != 0) goto failed; if (res != 0) goto failed;
Py_CLEAR(tmp); Py_CLEAR(tmp);
} }
if (_PyObject_LookupAttr(obj, state->typeparams, &tmp) < 0) { if (_PyObject_LookupAttr(obj, state->type_params, &tmp) < 0) {
return 1; return 1;
} }
if (tmp == NULL) { if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"typeparams\" missing from AsyncFunctionDef"); PyErr_SetString(PyExc_TypeError, "required field \"type_params\" missing from AsyncFunctionDef");
return 1; return 1;
} }
else { else {
@ -6306,27 +6308,27 @@ obj2ast_stmt(struct ast_state *state, PyObject* obj, stmt_ty* out, PyArena*
Py_ssize_t len; Py_ssize_t len;
Py_ssize_t i; Py_ssize_t i;
if (!PyList_Check(tmp)) { if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "AsyncFunctionDef field \"typeparams\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); PyErr_Format(PyExc_TypeError, "AsyncFunctionDef field \"type_params\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed; goto failed;
} }
len = PyList_GET_SIZE(tmp); len = PyList_GET_SIZE(tmp);
typeparams = _Py_asdl_typeparam_seq_new(len, arena); type_params = _Py_asdl_type_param_seq_new(len, arena);
if (typeparams == NULL) goto failed; if (type_params == NULL) goto failed;
for (i = 0; i < len; i++) { for (i = 0; i < len; i++) {
typeparam_ty val; type_param_ty val;
PyObject *tmp2 = Py_NewRef(PyList_GET_ITEM(tmp, i)); PyObject *tmp2 = Py_NewRef(PyList_GET_ITEM(tmp, i));
if (_Py_EnterRecursiveCall(" while traversing 'AsyncFunctionDef' node")) { if (_Py_EnterRecursiveCall(" while traversing 'AsyncFunctionDef' node")) {
goto failed; goto failed;
} }
res = obj2ast_typeparam(state, tmp2, &val, arena); res = obj2ast_type_param(state, tmp2, &val, arena);
_Py_LeaveRecursiveCall(); _Py_LeaveRecursiveCall();
Py_DECREF(tmp2); Py_DECREF(tmp2);
if (res != 0) goto failed; if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) { if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "AsyncFunctionDef field \"typeparams\" changed size during iteration"); PyErr_SetString(PyExc_RuntimeError, "AsyncFunctionDef field \"type_params\" changed size during iteration");
goto failed; goto failed;
} }
asdl_seq_SET(typeparams, i, val); asdl_seq_SET(type_params, i, val);
} }
Py_CLEAR(tmp); Py_CLEAR(tmp);
} }
@ -6453,7 +6455,7 @@ obj2ast_stmt(struct ast_state *state, PyObject* obj, stmt_ty* out, PyArena*
if (res != 0) goto failed; if (res != 0) goto failed;
Py_CLEAR(tmp); Py_CLEAR(tmp);
} }
*out = _PyAST_AsyncFunctionDef(name, typeparams, args, body, *out = _PyAST_AsyncFunctionDef(name, type_params, args, body,
decorator_list, returns, type_comment, decorator_list, returns, type_comment,
lineno, col_offset, end_lineno, lineno, col_offset, end_lineno,
end_col_offset, arena); end_col_offset, arena);
@ -6467,7 +6469,7 @@ obj2ast_stmt(struct ast_state *state, PyObject* obj, stmt_ty* out, PyArena*
} }
if (isinstance) { if (isinstance) {
identifier name; identifier name;
asdl_typeparam_seq* typeparams; asdl_type_param_seq* type_params;
asdl_expr_seq* bases; asdl_expr_seq* bases;
asdl_keyword_seq* keywords; asdl_keyword_seq* keywords;
asdl_stmt_seq* body; asdl_stmt_seq* body;
@ -6490,11 +6492,11 @@ obj2ast_stmt(struct ast_state *state, PyObject* obj, stmt_ty* out, PyArena*
if (res != 0) goto failed; if (res != 0) goto failed;
Py_CLEAR(tmp); Py_CLEAR(tmp);
} }
if (_PyObject_LookupAttr(obj, state->typeparams, &tmp) < 0) { if (_PyObject_LookupAttr(obj, state->type_params, &tmp) < 0) {
return 1; return 1;
} }
if (tmp == NULL) { if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"typeparams\" missing from ClassDef"); PyErr_SetString(PyExc_TypeError, "required field \"type_params\" missing from ClassDef");
return 1; return 1;
} }
else { else {
@ -6502,27 +6504,27 @@ obj2ast_stmt(struct ast_state *state, PyObject* obj, stmt_ty* out, PyArena*
Py_ssize_t len; Py_ssize_t len;
Py_ssize_t i; Py_ssize_t i;
if (!PyList_Check(tmp)) { if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "ClassDef field \"typeparams\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); PyErr_Format(PyExc_TypeError, "ClassDef field \"type_params\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed; goto failed;
} }
len = PyList_GET_SIZE(tmp); len = PyList_GET_SIZE(tmp);
typeparams = _Py_asdl_typeparam_seq_new(len, arena); type_params = _Py_asdl_type_param_seq_new(len, arena);
if (typeparams == NULL) goto failed; if (type_params == NULL) goto failed;
for (i = 0; i < len; i++) { for (i = 0; i < len; i++) {
typeparam_ty val; type_param_ty val;
PyObject *tmp2 = Py_NewRef(PyList_GET_ITEM(tmp, i)); PyObject *tmp2 = Py_NewRef(PyList_GET_ITEM(tmp, i));
if (_Py_EnterRecursiveCall(" while traversing 'ClassDef' node")) { if (_Py_EnterRecursiveCall(" while traversing 'ClassDef' node")) {
goto failed; goto failed;
} }
res = obj2ast_typeparam(state, tmp2, &val, arena); res = obj2ast_type_param(state, tmp2, &val, arena);
_Py_LeaveRecursiveCall(); _Py_LeaveRecursiveCall();
Py_DECREF(tmp2); Py_DECREF(tmp2);
if (res != 0) goto failed; if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) { if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "ClassDef field \"typeparams\" changed size during iteration"); PyErr_SetString(PyExc_RuntimeError, "ClassDef field \"type_params\" changed size during iteration");
goto failed; goto failed;
} }
asdl_seq_SET(typeparams, i, val); asdl_seq_SET(type_params, i, val);
} }
Py_CLEAR(tmp); Py_CLEAR(tmp);
} }
@ -6670,7 +6672,7 @@ obj2ast_stmt(struct ast_state *state, PyObject* obj, stmt_ty* out, PyArena*
} }
Py_CLEAR(tmp); Py_CLEAR(tmp);
} }
*out = _PyAST_ClassDef(name, typeparams, bases, keywords, body, *out = _PyAST_ClassDef(name, type_params, bases, keywords, body,
decorator_list, lineno, col_offset, end_lineno, decorator_list, lineno, col_offset, end_lineno,
end_col_offset, arena); end_col_offset, arena);
if (*out == NULL) goto failed; if (*out == NULL) goto failed;
@ -6847,7 +6849,7 @@ obj2ast_stmt(struct ast_state *state, PyObject* obj, stmt_ty* out, PyArena*
} }
if (isinstance) { if (isinstance) {
expr_ty name; expr_ty name;
asdl_typeparam_seq* typeparams; asdl_type_param_seq* type_params;
expr_ty value; expr_ty value;
if (_PyObject_LookupAttr(obj, state->name, &tmp) < 0) { if (_PyObject_LookupAttr(obj, state->name, &tmp) < 0) {
@ -6867,11 +6869,11 @@ obj2ast_stmt(struct ast_state *state, PyObject* obj, stmt_ty* out, PyArena*
if (res != 0) goto failed; if (res != 0) goto failed;
Py_CLEAR(tmp); Py_CLEAR(tmp);
} }
if (_PyObject_LookupAttr(obj, state->typeparams, &tmp) < 0) { if (_PyObject_LookupAttr(obj, state->type_params, &tmp) < 0) {
return 1; return 1;
} }
if (tmp == NULL) { if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"typeparams\" missing from TypeAlias"); PyErr_SetString(PyExc_TypeError, "required field \"type_params\" missing from TypeAlias");
return 1; return 1;
} }
else { else {
@ -6879,27 +6881,27 @@ obj2ast_stmt(struct ast_state *state, PyObject* obj, stmt_ty* out, PyArena*
Py_ssize_t len; Py_ssize_t len;
Py_ssize_t i; Py_ssize_t i;
if (!PyList_Check(tmp)) { if (!PyList_Check(tmp)) {
PyErr_Format(PyExc_TypeError, "TypeAlias field \"typeparams\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp))); PyErr_Format(PyExc_TypeError, "TypeAlias field \"type_params\" must be a list, not a %.200s", _PyType_Name(Py_TYPE(tmp)));
goto failed; goto failed;
} }
len = PyList_GET_SIZE(tmp); len = PyList_GET_SIZE(tmp);
typeparams = _Py_asdl_typeparam_seq_new(len, arena); type_params = _Py_asdl_type_param_seq_new(len, arena);
if (typeparams == NULL) goto failed; if (type_params == NULL) goto failed;
for (i = 0; i < len; i++) { for (i = 0; i < len; i++) {
typeparam_ty val; type_param_ty val;
PyObject *tmp2 = Py_NewRef(PyList_GET_ITEM(tmp, i)); PyObject *tmp2 = Py_NewRef(PyList_GET_ITEM(tmp, i));
if (_Py_EnterRecursiveCall(" while traversing 'TypeAlias' node")) { if (_Py_EnterRecursiveCall(" while traversing 'TypeAlias' node")) {
goto failed; goto failed;
} }
res = obj2ast_typeparam(state, tmp2, &val, arena); res = obj2ast_type_param(state, tmp2, &val, arena);
_Py_LeaveRecursiveCall(); _Py_LeaveRecursiveCall();
Py_DECREF(tmp2); Py_DECREF(tmp2);
if (res != 0) goto failed; if (res != 0) goto failed;
if (len != PyList_GET_SIZE(tmp)) { if (len != PyList_GET_SIZE(tmp)) {
PyErr_SetString(PyExc_RuntimeError, "TypeAlias field \"typeparams\" changed size during iteration"); PyErr_SetString(PyExc_RuntimeError, "TypeAlias field \"type_params\" changed size during iteration");
goto failed; goto failed;
} }
asdl_seq_SET(typeparams, i, val); asdl_seq_SET(type_params, i, val);
} }
Py_CLEAR(tmp); Py_CLEAR(tmp);
} }
@ -6920,7 +6922,7 @@ obj2ast_stmt(struct ast_state *state, PyObject* obj, stmt_ty* out, PyArena*
if (res != 0) goto failed; if (res != 0) goto failed;
Py_CLEAR(tmp); Py_CLEAR(tmp);
} }
*out = _PyAST_TypeAlias(name, typeparams, value, lineno, col_offset, *out = _PyAST_TypeAlias(name, type_params, value, lineno, col_offset,
end_lineno, end_col_offset, arena); end_lineno, end_col_offset, arena);
if (*out == NULL) goto failed; if (*out == NULL) goto failed;
return 0; return 0;
@ -12293,7 +12295,7 @@ obj2ast_type_ignore(struct ast_state *state, PyObject* obj, type_ignore_ty*
} }
int int
obj2ast_typeparam(struct ast_state *state, PyObject* obj, typeparam_ty* out, obj2ast_type_param(struct ast_state *state, PyObject* obj, type_param_ty* out,
PyArena* arena) PyArena* arena)
{ {
int isinstance; int isinstance;
@ -12313,12 +12315,12 @@ obj2ast_typeparam(struct ast_state *state, PyObject* obj, typeparam_ty* out,
return 1; return 1;
} }
if (tmp == NULL) { if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"lineno\" missing from typeparam"); PyErr_SetString(PyExc_TypeError, "required field \"lineno\" missing from type_param");
return 1; return 1;
} }
else { else {
int res; int res;
if (_Py_EnterRecursiveCall(" while traversing 'typeparam' node")) { if (_Py_EnterRecursiveCall(" while traversing 'type_param' node")) {
goto failed; goto failed;
} }
res = obj2ast_int(state, tmp, &lineno, arena); res = obj2ast_int(state, tmp, &lineno, arena);
@ -12330,12 +12332,12 @@ obj2ast_typeparam(struct ast_state *state, PyObject* obj, typeparam_ty* out,
return 1; return 1;
} }
if (tmp == NULL) { if (tmp == NULL) {
PyErr_SetString(PyExc_TypeError, "required field \"col_offset\" missing from typeparam"); PyErr_SetString(PyExc_TypeError, "required field \"col_offset\" missing from type_param");
return 1; return 1;
} }
else { else {
int res; int res;
if (_Py_EnterRecursiveCall(" while traversing 'typeparam' node")) { if (_Py_EnterRecursiveCall(" while traversing 'type_param' node")) {
goto failed; goto failed;
} }
res = obj2ast_int(state, tmp, &col_offset, arena); res = obj2ast_int(state, tmp, &col_offset, arena);
@ -12352,7 +12354,7 @@ obj2ast_typeparam(struct ast_state *state, PyObject* obj, typeparam_ty* out,
} }
else { else {
int res; int res;
if (_Py_EnterRecursiveCall(" while traversing 'typeparam' node")) { if (_Py_EnterRecursiveCall(" while traversing 'type_param' node")) {
goto failed; goto failed;
} }
res = obj2ast_int(state, tmp, &end_lineno, arena); res = obj2ast_int(state, tmp, &end_lineno, arena);
@ -12369,7 +12371,7 @@ obj2ast_typeparam(struct ast_state *state, PyObject* obj, typeparam_ty* out,
} }
else { else {
int res; int res;
if (_Py_EnterRecursiveCall(" while traversing 'typeparam' node")) { if (_Py_EnterRecursiveCall(" while traversing 'type_param' node")) {
goto failed; goto failed;
} }
res = obj2ast_int(state, tmp, &end_col_offset, arena); res = obj2ast_int(state, tmp, &end_col_offset, arena);
@ -12486,7 +12488,7 @@ obj2ast_typeparam(struct ast_state *state, PyObject* obj, typeparam_ty* out,
return 0; return 0;
} }
PyErr_Format(PyExc_TypeError, "expected some sort of typeparam, but got %R", obj); PyErr_Format(PyExc_TypeError, "expected some sort of type_param, but got %R", obj);
failed: failed:
Py_XDECREF(tmp); Py_XDECREF(tmp);
return 1; return 1;
@ -12880,7 +12882,7 @@ astmodule_exec(PyObject *m)
if (PyModule_AddObjectRef(m, "TypeIgnore", state->TypeIgnore_type) < 0) { if (PyModule_AddObjectRef(m, "TypeIgnore", state->TypeIgnore_type) < 0) {
return -1; return -1;
} }
if (PyModule_AddObjectRef(m, "typeparam", state->typeparam_type) < 0) { if (PyModule_AddObjectRef(m, "type_param", state->type_param_type) < 0) {
return -1; return -1;
} }
if (PyModule_AddObjectRef(m, "TypeVar", state->TypeVar_type) < 0) { if (PyModule_AddObjectRef(m, "TypeVar", state->TypeVar_type) < 0) {

18
Python/ast.c
View File

@ -17,12 +17,12 @@ struct validator {
static int validate_stmts(struct validator *, asdl_stmt_seq *); static int validate_stmts(struct validator *, asdl_stmt_seq *);
static int validate_exprs(struct validator *, asdl_expr_seq *, expr_context_ty, int); static int validate_exprs(struct validator *, asdl_expr_seq *, expr_context_ty, int);
static int validate_patterns(struct validator *, asdl_pattern_seq *, int); static int validate_patterns(struct validator *, asdl_pattern_seq *, int);
static int validate_typeparams(struct validator *, asdl_typeparam_seq *); static int validate_type_params(struct validator *, asdl_type_param_seq *);
static int _validate_nonempty_seq(asdl_seq *, const char *, const char *); static int _validate_nonempty_seq(asdl_seq *, const char *, const char *);
static int validate_stmt(struct validator *, stmt_ty); static int validate_stmt(struct validator *, stmt_ty);
static int validate_expr(struct validator *, expr_ty, expr_context_ty); static int validate_expr(struct validator *, expr_ty, expr_context_ty);
static int validate_pattern(struct validator *, pattern_ty, int); static int validate_pattern(struct validator *, pattern_ty, int);
static int validate_typeparam(struct validator *, typeparam_ty); static int validate_typeparam(struct validator *, type_param_ty);
#define VALIDATE_POSITIONS(node) \ #define VALIDATE_POSITIONS(node) \
if (node->lineno > node->end_lineno) { \ if (node->lineno > node->end_lineno) { \
@ -728,7 +728,7 @@ validate_stmt(struct validator *state, stmt_ty stmt)
switch (stmt->kind) { switch (stmt->kind) {
case FunctionDef_kind: case FunctionDef_kind:
ret = validate_body(state, stmt->v.FunctionDef.body, "FunctionDef") && ret = validate_body(state, stmt->v.FunctionDef.body, "FunctionDef") &&
validate_typeparams(state, stmt->v.FunctionDef.typeparams) && validate_type_params(state, stmt->v.FunctionDef.type_params) &&
validate_arguments(state, stmt->v.FunctionDef.args) && validate_arguments(state, stmt->v.FunctionDef.args) &&
validate_exprs(state, stmt->v.FunctionDef.decorator_list, Load, 0) && validate_exprs(state, stmt->v.FunctionDef.decorator_list, Load, 0) &&
(!stmt->v.FunctionDef.returns || (!stmt->v.FunctionDef.returns ||
@ -736,7 +736,7 @@ validate_stmt(struct validator *state, stmt_ty stmt)
break; break;
case ClassDef_kind: case ClassDef_kind:
ret = validate_body(state, stmt->v.ClassDef.body, "ClassDef") && ret = validate_body(state, stmt->v.ClassDef.body, "ClassDef") &&
validate_typeparams(state, stmt->v.ClassDef.typeparams) && validate_type_params(state, stmt->v.ClassDef.type_params) &&
validate_exprs(state, stmt->v.ClassDef.bases, Load, 0) && validate_exprs(state, stmt->v.ClassDef.bases, Load, 0) &&
validate_keywords(state, stmt->v.ClassDef.keywords) && validate_keywords(state, stmt->v.ClassDef.keywords) &&
validate_exprs(state, stmt->v.ClassDef.decorator_list, Load, 0); validate_exprs(state, stmt->v.ClassDef.decorator_list, Load, 0);
@ -769,7 +769,7 @@ validate_stmt(struct validator *state, stmt_ty stmt)
break; break;
case TypeAlias_kind: case TypeAlias_kind:
ret = validate_expr(state, stmt->v.TypeAlias.name, Store) && ret = validate_expr(state, stmt->v.TypeAlias.name, Store) &&
validate_typeparams(state, stmt->v.TypeAlias.typeparams) && validate_type_params(state, stmt->v.TypeAlias.type_params) &&
validate_expr(state, stmt->v.TypeAlias.value, Load); validate_expr(state, stmt->v.TypeAlias.value, Load);
break; break;
case For_kind: case For_kind:
@ -919,7 +919,7 @@ validate_stmt(struct validator *state, stmt_ty stmt)
break; break;
case AsyncFunctionDef_kind: case AsyncFunctionDef_kind:
ret = validate_body(state, stmt->v.AsyncFunctionDef.body, "AsyncFunctionDef") && ret = validate_body(state, stmt->v.AsyncFunctionDef.body, "AsyncFunctionDef") &&
validate_typeparams(state, stmt->v.AsyncFunctionDef.typeparams) && validate_type_params(state, stmt->v.AsyncFunctionDef.type_params) &&
validate_arguments(state, stmt->v.AsyncFunctionDef.args) && validate_arguments(state, stmt->v.AsyncFunctionDef.args) &&
validate_exprs(state, stmt->v.AsyncFunctionDef.decorator_list, Load, 0) && validate_exprs(state, stmt->v.AsyncFunctionDef.decorator_list, Load, 0) &&
(!stmt->v.AsyncFunctionDef.returns || (!stmt->v.AsyncFunctionDef.returns ||
@ -993,7 +993,7 @@ validate_patterns(struct validator *state, asdl_pattern_seq *patterns, int star_
} }
static int static int
validate_typeparam(struct validator *state, typeparam_ty tp) validate_typeparam(struct validator *state, type_param_ty tp)
{ {
VALIDATE_POSITIONS(tp); VALIDATE_POSITIONS(tp);
int ret = -1; int ret = -1;
@ -1014,11 +1014,11 @@ validate_typeparam(struct validator *state, typeparam_ty tp)
} }
static int static int
validate_typeparams(struct validator *state, asdl_typeparam_seq *tps) validate_type_params(struct validator *state, asdl_type_param_seq *tps)
{ {
Py_ssize_t i; Py_ssize_t i;
for (i = 0; i < asdl_seq_LEN(tps); i++) { for (i = 0; i < asdl_seq_LEN(tps); i++) {
typeparam_ty tp = asdl_seq_GET(tps, i); type_param_ty tp = asdl_seq_GET(tps, i);
if (tp) { if (tp) {
if (!validate_typeparam(state, tp)) if (!validate_typeparam(state, tp))
return 0; return 0;

12
Python/ast_opt.c
View File

@ -642,7 +642,7 @@ static int astfold_withitem(withitem_ty node_, PyArena *ctx_, _PyASTOptimizeStat
static int astfold_excepthandler(excepthandler_ty node_, PyArena *ctx_, _PyASTOptimizeState *state); static int astfold_excepthandler(excepthandler_ty node_, PyArena *ctx_, _PyASTOptimizeState *state);
static int astfold_match_case(match_case_ty node_, PyArena *ctx_, _PyASTOptimizeState *state); static int astfold_match_case(match_case_ty node_, PyArena *ctx_, _PyASTOptimizeState *state);
static int astfold_pattern(pattern_ty node_, PyArena *ctx_, _PyASTOptimizeState *state); static int astfold_pattern(pattern_ty node_, PyArena *ctx_, _PyASTOptimizeState *state);
static int astfold_typeparam(typeparam_ty node_, PyArena *ctx_, _PyASTOptimizeState *state); static int astfold_type_param(type_param_ty node_, PyArena *ctx_, _PyASTOptimizeState *state);
#define CALL(FUNC, TYPE, ARG) \ #define CALL(FUNC, TYPE, ARG) \
if (!FUNC((ARG), ctx_, state)) \ if (!FUNC((ARG), ctx_, state)) \
@ -881,7 +881,7 @@ astfold_stmt(stmt_ty node_, PyArena *ctx_, _PyASTOptimizeState *state)
} }
switch (node_->kind) { switch (node_->kind) {
case FunctionDef_kind: case FunctionDef_kind:
CALL_SEQ(astfold_typeparam, typeparam, node_->v.FunctionDef.typeparams); CALL_SEQ(astfold_type_param, type_param, node_->v.FunctionDef.type_params);
CALL(astfold_arguments, arguments_ty, node_->v.FunctionDef.args); CALL(astfold_arguments, arguments_ty, node_->v.FunctionDef.args);
CALL(astfold_body, asdl_seq, node_->v.FunctionDef.body); CALL(astfold_body, asdl_seq, node_->v.FunctionDef.body);
CALL_SEQ(astfold_expr, expr, node_->v.FunctionDef.decorator_list); CALL_SEQ(astfold_expr, expr, node_->v.FunctionDef.decorator_list);
@ -890,7 +890,7 @@ astfold_stmt(stmt_ty node_, PyArena *ctx_, _PyASTOptimizeState *state)
} }
break; break;
case AsyncFunctionDef_kind: case AsyncFunctionDef_kind:
CALL_SEQ(astfold_typeparam, typeparam, node_->v.AsyncFunctionDef.typeparams); CALL_SEQ(astfold_type_param, type_param, node_->v.AsyncFunctionDef.type_params);
CALL(astfold_arguments, arguments_ty, node_->v.AsyncFunctionDef.args); CALL(astfold_arguments, arguments_ty, node_->v.AsyncFunctionDef.args);
CALL(astfold_body, asdl_seq, node_->v.AsyncFunctionDef.body); CALL(astfold_body, asdl_seq, node_->v.AsyncFunctionDef.body);
CALL_SEQ(astfold_expr, expr, node_->v.AsyncFunctionDef.decorator_list); CALL_SEQ(astfold_expr, expr, node_->v.AsyncFunctionDef.decorator_list);
@ -899,7 +899,7 @@ astfold_stmt(stmt_ty node_, PyArena *ctx_, _PyASTOptimizeState *state)
} }
break; break;
case ClassDef_kind: case ClassDef_kind:
CALL_SEQ(astfold_typeparam, typeparam, node_->v.ClassDef.typeparams); CALL_SEQ(astfold_type_param, type_param, node_->v.ClassDef.type_params);
CALL_SEQ(astfold_expr, expr, node_->v.ClassDef.bases); CALL_SEQ(astfold_expr, expr, node_->v.ClassDef.bases);
CALL_SEQ(astfold_keyword, keyword, node_->v.ClassDef.keywords); CALL_SEQ(astfold_keyword, keyword, node_->v.ClassDef.keywords);
CALL(astfold_body, asdl_seq, node_->v.ClassDef.body); CALL(astfold_body, asdl_seq, node_->v.ClassDef.body);
@ -928,7 +928,7 @@ astfold_stmt(stmt_ty node_, PyArena *ctx_, _PyASTOptimizeState *state)
break; break;
case TypeAlias_kind: case TypeAlias_kind:
CALL(astfold_expr, expr_ty, node_->v.TypeAlias.name); CALL(astfold_expr, expr_ty, node_->v.TypeAlias.name);
CALL_SEQ(astfold_typeparam, typeparam, node_->v.TypeAlias.typeparams); CALL_SEQ(astfold_type_param, type_param, node_->v.TypeAlias.type_params);
CALL(astfold_expr, expr_ty, node_->v.TypeAlias.value); CALL(astfold_expr, expr_ty, node_->v.TypeAlias.value);
break; break;
case For_kind: case For_kind:
@ -1084,7 +1084,7 @@ astfold_match_case(match_case_ty node_, PyArena *ctx_, _PyASTOptimizeState *stat
} }
static int static int
astfold_typeparam(typeparam_ty node_, PyArena *ctx_, _PyASTOptimizeState *state) astfold_type_param(type_param_ty node_, PyArena *ctx_, _PyASTOptimizeState *state)
{ {
switch (node_->kind) { switch (node_->kind) {
case TypeVar_kind: case TypeVar_kind:

72
Python/compile.c
View File

@ -2113,15 +2113,15 @@ wrap_in_stopiteration_handler(struct compiler *c)
} }
static int static int
compiler_type_params(struct compiler *c, asdl_typeparam_seq *typeparams) compiler_type_params(struct compiler *c, asdl_type_param_seq *type_params)
{ {
if (!typeparams) { if (!type_params) {
return SUCCESS; return SUCCESS;
} }
Py_ssize_t n = asdl_seq_LEN(typeparams); Py_ssize_t n = asdl_seq_LEN(type_params);
for (Py_ssize_t i = 0; i < n; i++) { for (Py_ssize_t i = 0; i < n; i++) {
typeparam_ty typeparam = asdl_seq_GET(typeparams, i); type_param_ty typeparam = asdl_seq_GET(type_params, i);
location loc = LOC(typeparam); location loc = LOC(typeparam);
switch(typeparam->kind) { switch(typeparam->kind) {
case TypeVar_kind: case TypeVar_kind:
@ -2170,7 +2170,7 @@ compiler_type_params(struct compiler *c, asdl_typeparam_seq *typeparams)
break; break;
} }
} }
ADDOP_I(c, LOC(asdl_seq_GET(typeparams, 0)), BUILD_TUPLE, n); ADDOP_I(c, LOC(asdl_seq_GET(type_params, 0)), BUILD_TUPLE, n);
return SUCCESS; return SUCCESS;
} }
@ -2248,7 +2248,7 @@ compiler_function(struct compiler *c, stmt_ty s, int is_async)
expr_ty returns; expr_ty returns;
identifier name; identifier name;
asdl_expr_seq *decos; asdl_expr_seq *decos;
asdl_typeparam_seq *typeparams; asdl_type_param_seq *type_params;
Py_ssize_t funcflags; Py_ssize_t funcflags;
int annotations; int annotations;
int firstlineno; int firstlineno;
@ -2260,7 +2260,7 @@ compiler_function(struct compiler *c, stmt_ty s, int is_async)
returns = s->v.AsyncFunctionDef.returns; returns = s->v.AsyncFunctionDef.returns;
decos = s->v.AsyncFunctionDef.decorator_list; decos = s->v.AsyncFunctionDef.decorator_list;
name = s->v.AsyncFunctionDef.name; name = s->v.AsyncFunctionDef.name;
typeparams = s->v.AsyncFunctionDef.typeparams; type_params = s->v.AsyncFunctionDef.type_params;
} else { } else {
assert(s->kind == FunctionDef_kind); assert(s->kind == FunctionDef_kind);
@ -2268,7 +2268,7 @@ compiler_function(struct compiler *c, stmt_ty s, int is_async)
returns = s->v.FunctionDef.returns; returns = s->v.FunctionDef.returns;
decos = s->v.FunctionDef.decorator_list; decos = s->v.FunctionDef.decorator_list;
name = s->v.FunctionDef.name; name = s->v.FunctionDef.name;
typeparams = s->v.FunctionDef.typeparams; type_params = s->v.FunctionDef.type_params;
} }
RETURN_IF_ERROR(compiler_check_debug_args(c, args)); RETURN_IF_ERROR(compiler_check_debug_args(c, args));
@ -2281,7 +2281,7 @@ compiler_function(struct compiler *c, stmt_ty s, int is_async)
location loc = LOC(s); location loc = LOC(s);
int is_generic = asdl_seq_LEN(typeparams) > 0; int is_generic = asdl_seq_LEN(type_params) > 0;
if (is_generic) { if (is_generic) {
// Used by the CALL to the type parameters function. // Used by the CALL to the type parameters function.
@ -2305,17 +2305,17 @@ compiler_function(struct compiler *c, stmt_ty s, int is_async)
if (num_typeparam_args == 2) { if (num_typeparam_args == 2) {
ADDOP_I(c, loc, SWAP, 2); ADDOP_I(c, loc, SWAP, 2);
} }
PyObject *typeparams_name = PyUnicode_FromFormat("<generic parameters of %U>", name); PyObject *type_params_name = PyUnicode_FromFormat("<generic parameters of %U>", name);
if (!typeparams_name) { if (!type_params_name) {
return ERROR; return ERROR;
} }
if (compiler_enter_scope(c, typeparams_name, COMPILER_SCOPE_TYPEPARAMS, if (compiler_enter_scope(c, type_params_name, COMPILER_SCOPE_TYPEPARAMS,
(void *)typeparams, firstlineno) == -1) { (void *)type_params, firstlineno) == -1) {
Py_DECREF(typeparams_name); Py_DECREF(type_params_name);
return ERROR; return ERROR;
} }
Py_DECREF(typeparams_name); Py_DECREF(type_params_name);
RETURN_IF_ERROR_IN_SCOPE(c, compiler_type_params(c, typeparams)); RETURN_IF_ERROR_IN_SCOPE(c, compiler_type_params(c, type_params));
if ((funcflags & 0x01) || (funcflags & 0x02)) { if ((funcflags & 0x01) || (funcflags & 0x02)) {
RETURN_IF_ERROR_IN_SCOPE(c, codegen_addop_i(INSTR_SEQUENCE(c), LOAD_FAST, 0, loc)); RETURN_IF_ERROR_IN_SCOPE(c, codegen_addop_i(INSTR_SEQUENCE(c), LOAD_FAST, 0, loc));
} }
@ -2416,8 +2416,8 @@ compiler_class_body(struct compiler *c, stmt_ty s, int firstlineno)
compiler_exit_scope(c); compiler_exit_scope(c);
return ERROR; return ERROR;
} }
asdl_typeparam_seq *typeparams = s->v.ClassDef.typeparams; asdl_type_param_seq *type_params = s->v.ClassDef.type_params;
if (asdl_seq_LEN(typeparams) > 0) { if (asdl_seq_LEN(type_params) > 0) {
if (!compiler_set_type_params_in_class(c, loc)) { if (!compiler_set_type_params_in_class(c, loc)) {
compiler_exit_scope(c); compiler_exit_scope(c);
return ERROR; return ERROR;
@ -2519,23 +2519,23 @@ compiler_class(struct compiler *c, stmt_ty s)
} }
location loc = LOC(s); location loc = LOC(s);
asdl_typeparam_seq *typeparams = s->v.ClassDef.typeparams; asdl_type_param_seq *type_params = s->v.ClassDef.type_params;
int is_generic = asdl_seq_LEN(typeparams) > 0; int is_generic = asdl_seq_LEN(type_params) > 0;
if (is_generic) { if (is_generic) {
Py_XSETREF(c->u->u_private, Py_NewRef(s->v.ClassDef.name)); Py_XSETREF(c->u->u_private, Py_NewRef(s->v.ClassDef.name));
ADDOP(c, loc, PUSH_NULL); ADDOP(c, loc, PUSH_NULL);
PyObject *typeparams_name = PyUnicode_FromFormat("<generic parameters of %U>", PyObject *type_params_name = PyUnicode_FromFormat("<generic parameters of %U>",
s->v.ClassDef.name); s->v.ClassDef.name);
if (!typeparams_name) { if (!type_params_name) {
return ERROR; return ERROR;
} }
if (compiler_enter_scope(c, typeparams_name, COMPILER_SCOPE_TYPEPARAMS, if (compiler_enter_scope(c, type_params_name, COMPILER_SCOPE_TYPEPARAMS,
(void *)typeparams, firstlineno) == -1) { (void *)type_params, firstlineno) == -1) {
Py_DECREF(typeparams_name); Py_DECREF(type_params_name);
return ERROR; return ERROR;
} }
Py_DECREF(typeparams_name); Py_DECREF(type_params_name);
RETURN_IF_ERROR_IN_SCOPE(c, compiler_type_params(c, typeparams)); RETURN_IF_ERROR_IN_SCOPE(c, compiler_type_params(c, type_params));
_Py_DECLARE_STR(type_params, ".type_params"); _Py_DECLARE_STR(type_params, ".type_params");
RETURN_IF_ERROR_IN_SCOPE(c, compiler_nameop(c, loc, &_Py_STR(type_params), Store)); RETURN_IF_ERROR_IN_SCOPE(c, compiler_nameop(c, loc, &_Py_STR(type_params), Store));
} }
@ -2637,26 +2637,26 @@ static int
compiler_typealias(struct compiler *c, stmt_ty s) compiler_typealias(struct compiler *c, stmt_ty s)
{ {
location loc = LOC(s); location loc = LOC(s);
asdl_typeparam_seq *typeparams = s->v.TypeAlias.typeparams; asdl_type_param_seq *type_params = s->v.TypeAlias.type_params;
int is_generic = asdl_seq_LEN(typeparams) > 0; int is_generic = asdl_seq_LEN(type_params) > 0;
PyObject *name = s->v.TypeAlias.name->v.Name.id; PyObject *name = s->v.TypeAlias.name->v.Name.id;
if (is_generic) { if (is_generic) {
ADDOP(c, loc, PUSH_NULL); ADDOP(c, loc, PUSH_NULL);
PyObject *typeparams_name = PyUnicode_FromFormat("<generic parameters of %U>", PyObject *type_params_name = PyUnicode_FromFormat("<generic parameters of %U>",
name); name);
if (!typeparams_name) { if (!type_params_name) {
return ERROR; return ERROR;
} }
if (compiler_enter_scope(c, typeparams_name, COMPILER_SCOPE_TYPEPARAMS, if (compiler_enter_scope(c, type_params_name, COMPILER_SCOPE_TYPEPARAMS,
(void *)typeparams, loc.lineno) == -1) { (void *)type_params, loc.lineno) == -1) {
Py_DECREF(typeparams_name); Py_DECREF(type_params_name);
return ERROR; return ERROR;
} }
Py_DECREF(typeparams_name); Py_DECREF(type_params_name);
RETURN_IF_ERROR_IN_SCOPE( RETURN_IF_ERROR_IN_SCOPE(
c, compiler_addop_load_const(c->c_const_cache, c->u, loc, name) c, compiler_addop_load_const(c->c_const_cache, c->u, loc, name)
); );
RETURN_IF_ERROR_IN_SCOPE(c, compiler_type_params(c, typeparams)); RETURN_IF_ERROR_IN_SCOPE(c, compiler_type_params(c, type_params));
} }
else { else {
ADDOP_LOAD_CONST(c, loc, name); ADDOP_LOAD_CONST(c, loc, name);

86
Python/symtable.c
View File

@ -231,7 +231,7 @@ static int symtable_enter_block(struct symtable *st, identifier name,
static int symtable_exit_block(struct symtable *st); static int symtable_exit_block(struct symtable *st);
static int symtable_visit_stmt(struct symtable *st, stmt_ty s); static int symtable_visit_stmt(struct symtable *st, stmt_ty s);
static int symtable_visit_expr(struct symtable *st, expr_ty s); static int symtable_visit_expr(struct symtable *st, expr_ty s);
static int symtable_visit_typeparam(struct symtable *st, typeparam_ty s); static int symtable_visit_type_param(struct symtable *st, type_param_ty s);
static int symtable_visit_genexp(struct symtable *st, expr_ty s); static int symtable_visit_genexp(struct symtable *st, expr_ty s);
static int symtable_visit_listcomp(struct symtable *st, expr_ty s); static int symtable_visit_listcomp(struct symtable *st, expr_ty s);
static int symtable_visit_setcomp(struct symtable *st, expr_ty s); static int symtable_visit_setcomp(struct symtable *st, expr_ty s);
@ -528,7 +528,7 @@ error_at_directive(PySTEntryObject *ste, PyObject *name)
static int static int
analyze_name(PySTEntryObject *ste, PyObject *scopes, PyObject *name, long flags, analyze_name(PySTEntryObject *ste, PyObject *scopes, PyObject *name, long flags,
PyObject *bound, PyObject *local, PyObject *free, PyObject *bound, PyObject *local, PyObject *free,
PyObject *global, PyObject *typeparams, PySTEntryObject *class_entry) PyObject *global, PyObject *type_params, PySTEntryObject *class_entry)
{ {
if (flags & DEF_GLOBAL) { if (flags & DEF_GLOBAL) {
if (flags & DEF_NONLOCAL) { if (flags & DEF_NONLOCAL) {
@ -557,7 +557,7 @@ analyze_name(PySTEntryObject *ste, PyObject *scopes, PyObject *name, long flags,
return error_at_directive(ste, name); return error_at_directive(ste, name);
} }
if (PySet_Contains(typeparams, name)) { if (PySet_Contains(type_params, name)) {
PyErr_Format(PyExc_SyntaxError, PyErr_Format(PyExc_SyntaxError,
"nonlocal binding not allowed for type parameter '%U'", "nonlocal binding not allowed for type parameter '%U'",
name); name);
@ -574,11 +574,11 @@ analyze_name(PySTEntryObject *ste, PyObject *scopes, PyObject *name, long flags,
if (PySet_Discard(global, name) < 0) if (PySet_Discard(global, name) < 0)
return 0; return 0;
if (flags & DEF_TYPE_PARAM) { if (flags & DEF_TYPE_PARAM) {
if (PySet_Add(typeparams, name) < 0) if (PySet_Add(type_params, name) < 0)
return 0; return 0;
} }
else { else {
if (PySet_Discard(typeparams, name) < 0) if (PySet_Discard(type_params, name) < 0)
return 0; return 0;
} }
return 1; return 1;
@ -871,12 +871,12 @@ error:
static int static int
analyze_child_block(PySTEntryObject *entry, PyObject *bound, PyObject *free, analyze_child_block(PySTEntryObject *entry, PyObject *bound, PyObject *free,
PyObject *global, PyObject *typeparams, PyObject *global, PyObject *type_params,
PySTEntryObject *class_entry, PyObject **child_free); PySTEntryObject *class_entry, PyObject **child_free);
static int static int
analyze_block(PySTEntryObject *ste, PyObject *bound, PyObject *free, analyze_block(PySTEntryObject *ste, PyObject *bound, PyObject *free,
PyObject *global, PyObject *typeparams, PyObject *global, PyObject *type_params,
PySTEntryObject *class_entry) PySTEntryObject *class_entry)
{ {
PyObject *name, *v, *local = NULL, *scopes = NULL, *newbound = NULL; PyObject *name, *v, *local = NULL, *scopes = NULL, *newbound = NULL;
@ -939,7 +939,7 @@ analyze_block(PySTEntryObject *ste, PyObject *bound, PyObject *free,
while (PyDict_Next(ste->ste_symbols, &pos, &name, &v)) { while (PyDict_Next(ste->ste_symbols, &pos, &name, &v)) {
long flags = PyLong_AS_LONG(v); long flags = PyLong_AS_LONG(v);
if (!analyze_name(ste, scopes, name, flags, if (!analyze_name(ste, scopes, name, flags,
bound, local, free, global, typeparams, class_entry)) bound, local, free, global, type_params, class_entry))
goto error; goto error;
} }
@ -1002,7 +1002,7 @@ analyze_block(PySTEntryObject *ste, PyObject *bound, PyObject *free,
!entry->ste_generator; !entry->ste_generator;
if (!analyze_child_block(entry, newbound, newfree, newglobal, if (!analyze_child_block(entry, newbound, newfree, newglobal,
typeparams, new_class_entry, &child_free)) type_params, new_class_entry, &child_free))
{ {
goto error; goto error;
} }
@ -1066,11 +1066,11 @@ analyze_block(PySTEntryObject *ste, PyObject *bound, PyObject *free,
static int static int
analyze_child_block(PySTEntryObject *entry, PyObject *bound, PyObject *free, analyze_child_block(PySTEntryObject *entry, PyObject *bound, PyObject *free,
PyObject *global, PyObject *typeparams, PyObject *global, PyObject *type_params,
PySTEntryObject *class_entry, PyObject** child_free) PySTEntryObject *class_entry, PyObject** child_free)
{ {
PyObject *temp_bound = NULL, *temp_global = NULL, *temp_free = NULL; PyObject *temp_bound = NULL, *temp_global = NULL, *temp_free = NULL;
PyObject *temp_typeparams = NULL; PyObject *temp_type_params = NULL;
/* Copy the bound/global/free sets. /* Copy the bound/global/free sets.
@ -1088,30 +1088,30 @@ analyze_child_block(PySTEntryObject *entry, PyObject *bound, PyObject *free,
temp_global = PySet_New(global); temp_global = PySet_New(global);
if (!temp_global) if (!temp_global)
goto error; goto error;
temp_typeparams = PySet_New(typeparams); temp_type_params = PySet_New(type_params);
if (!temp_typeparams) if (!temp_type_params)
goto error; goto error;
if (!analyze_block(entry, temp_bound, temp_free, temp_global, if (!analyze_block(entry, temp_bound, temp_free, temp_global,
temp_typeparams, class_entry)) temp_type_params, class_entry))
goto error; goto error;
*child_free = temp_free; *child_free = temp_free;
Py_DECREF(temp_bound); Py_DECREF(temp_bound);
Py_DECREF(temp_global); Py_DECREF(temp_global);
Py_DECREF(temp_typeparams); Py_DECREF(temp_type_params);
return 1; return 1;
error: error:
Py_XDECREF(temp_bound); Py_XDECREF(temp_bound);
Py_XDECREF(temp_free); Py_XDECREF(temp_free);
Py_XDECREF(temp_global); Py_XDECREF(temp_global);
Py_XDECREF(temp_typeparams); Py_XDECREF(temp_type_params);
return 0; return 0;
} }
static int static int
symtable_analyze(struct symtable *st) symtable_analyze(struct symtable *st)
{ {
PyObject *free, *global, *typeparams; PyObject *free, *global, *type_params;
int r; int r;
free = PySet_New(NULL); free = PySet_New(NULL);
@ -1122,16 +1122,16 @@ symtable_analyze(struct symtable *st)
Py_DECREF(free); Py_DECREF(free);
return 0; return 0;
} }
typeparams = PySet_New(NULL); type_params = PySet_New(NULL);
if (!typeparams) { if (!type_params) {
Py_DECREF(free); Py_DECREF(free);
Py_DECREF(global); Py_DECREF(global);
return 0; return 0;
} }
r = analyze_block(st->st_top, NULL, free, global, typeparams, NULL); r = analyze_block(st->st_top, NULL, free, global, type_params, NULL);
Py_DECREF(free); Py_DECREF(free);
Py_DECREF(global); Py_DECREF(global);
Py_DECREF(typeparams); Py_DECREF(type_params);
return r; return r;
} }
@ -1313,7 +1313,7 @@ symtable_add_def(struct symtable *st, PyObject *name, int flag,
} }
static int static int
symtable_enter_typeparam_block(struct symtable *st, identifier name, symtable_enter_type_param_block(struct symtable *st, identifier name,
void *ast, int has_defaults, int has_kwdefaults, void *ast, int has_defaults, int has_kwdefaults,
enum _stmt_kind kind, enum _stmt_kind kind,
int lineno, int col_offset, int lineno, int col_offset,
@ -1472,10 +1472,10 @@ symtable_visit_stmt(struct symtable *st, stmt_ty s)
VISIT_SEQ_WITH_NULL(st, expr, s->v.FunctionDef.args->kw_defaults); VISIT_SEQ_WITH_NULL(st, expr, s->v.FunctionDef.args->kw_defaults);
if (s->v.FunctionDef.decorator_list) if (s->v.FunctionDef.decorator_list)
VISIT_SEQ(st, expr, s->v.FunctionDef.decorator_list); VISIT_SEQ(st, expr, s->v.FunctionDef.decorator_list);
if (asdl_seq_LEN(s->v.FunctionDef.typeparams) > 0) { if (asdl_seq_LEN(s->v.FunctionDef.type_params) > 0) {
if (!symtable_enter_typeparam_block( if (!symtable_enter_type_param_block(
st, s->v.FunctionDef.name, st, s->v.FunctionDef.name,
(void *)s->v.FunctionDef.typeparams, (void *)s->v.FunctionDef.type_params,
s->v.FunctionDef.args->defaults != NULL, s->v.FunctionDef.args->defaults != NULL,
has_kwonlydefaults(s->v.FunctionDef.args->kwonlyargs, has_kwonlydefaults(s->v.FunctionDef.args->kwonlyargs,
s->v.FunctionDef.args->kw_defaults), s->v.FunctionDef.args->kw_defaults),
@ -1483,7 +1483,7 @@ symtable_visit_stmt(struct symtable *st, stmt_ty s)
LOCATION(s))) { LOCATION(s))) {
VISIT_QUIT(st, 0); VISIT_QUIT(st, 0);
} }
VISIT_SEQ(st, typeparam, s->v.FunctionDef.typeparams); VISIT_SEQ(st, type_param, s->v.FunctionDef.type_params);
} }
if (!symtable_visit_annotations(st, s, s->v.FunctionDef.args, if (!symtable_visit_annotations(st, s, s->v.FunctionDef.args,
s->v.FunctionDef.returns)) s->v.FunctionDef.returns))
@ -1496,7 +1496,7 @@ symtable_visit_stmt(struct symtable *st, stmt_ty s)
VISIT_SEQ(st, stmt, s->v.FunctionDef.body); VISIT_SEQ(st, stmt, s->v.FunctionDef.body);
if (!symtable_exit_block(st)) if (!symtable_exit_block(st))
VISIT_QUIT(st, 0); VISIT_QUIT(st, 0);
if (asdl_seq_LEN(s->v.FunctionDef.typeparams) > 0) { if (asdl_seq_LEN(s->v.FunctionDef.type_params) > 0) {
if (!symtable_exit_block(st)) if (!symtable_exit_block(st))
VISIT_QUIT(st, 0); VISIT_QUIT(st, 0);
} }
@ -1507,14 +1507,14 @@ symtable_visit_stmt(struct symtable *st, stmt_ty s)
VISIT_QUIT(st, 0); VISIT_QUIT(st, 0);
if (s->v.ClassDef.decorator_list) if (s->v.ClassDef.decorator_list)
VISIT_SEQ(st, expr, s->v.ClassDef.decorator_list); VISIT_SEQ(st, expr, s->v.ClassDef.decorator_list);
if (asdl_seq_LEN(s->v.ClassDef.typeparams) > 0) { if (asdl_seq_LEN(s->v.ClassDef.type_params) > 0) {
if (!symtable_enter_typeparam_block(st, s->v.ClassDef.name, if (!symtable_enter_type_param_block(st, s->v.ClassDef.name,
(void *)s->v.ClassDef.typeparams, (void *)s->v.ClassDef.type_params,
false, false, s->kind, false, false, s->kind,
LOCATION(s))) { LOCATION(s))) {
VISIT_QUIT(st, 0); VISIT_QUIT(st, 0);
} }
VISIT_SEQ(st, typeparam, s->v.ClassDef.typeparams); VISIT_SEQ(st, type_param, s->v.ClassDef.type_params);
} }
VISIT_SEQ(st, expr, s->v.ClassDef.bases); VISIT_SEQ(st, expr, s->v.ClassDef.bases);
VISIT_SEQ(st, keyword, s->v.ClassDef.keywords); VISIT_SEQ(st, keyword, s->v.ClassDef.keywords);
@ -1524,7 +1524,7 @@ symtable_visit_stmt(struct symtable *st, stmt_ty s)
VISIT_QUIT(st, 0); VISIT_QUIT(st, 0);
tmp = st->st_private; tmp = st->st_private;
st->st_private = s->v.ClassDef.name; st->st_private = s->v.ClassDef.name;
if (asdl_seq_LEN(s->v.ClassDef.typeparams) > 0) { if (asdl_seq_LEN(s->v.ClassDef.type_params) > 0) {
if (!symtable_add_def(st, &_Py_ID(__type_params__), if (!symtable_add_def(st, &_Py_ID(__type_params__),
DEF_LOCAL, LOCATION(s))) { DEF_LOCAL, LOCATION(s))) {
VISIT_QUIT(st, 0); VISIT_QUIT(st, 0);
@ -1539,7 +1539,7 @@ symtable_visit_stmt(struct symtable *st, stmt_ty s)
st->st_private = tmp; st->st_private = tmp;
if (!symtable_exit_block(st)) if (!symtable_exit_block(st))
VISIT_QUIT(st, 0); VISIT_QUIT(st, 0);
if (asdl_seq_LEN(s->v.ClassDef.typeparams) > 0) { if (asdl_seq_LEN(s->v.ClassDef.type_params) > 0) {
if (!symtable_exit_block(st)) if (!symtable_exit_block(st))
VISIT_QUIT(st, 0); VISIT_QUIT(st, 0);
} }
@ -1550,16 +1550,16 @@ symtable_visit_stmt(struct symtable *st, stmt_ty s)
assert(s->v.TypeAlias.name->kind == Name_kind); assert(s->v.TypeAlias.name->kind == Name_kind);
PyObject *name = s->v.TypeAlias.name->v.Name.id; PyObject *name = s->v.TypeAlias.name->v.Name.id;
int is_in_class = st->st_cur->ste_type == ClassBlock; int is_in_class = st->st_cur->ste_type == ClassBlock;
int is_generic = asdl_seq_LEN(s->v.TypeAlias.typeparams) > 0; int is_generic = asdl_seq_LEN(s->v.TypeAlias.type_params) > 0;
if (is_generic) { if (is_generic) {
if (!symtable_enter_typeparam_block( if (!symtable_enter_type_param_block(
st, name, st, name,
(void *)s->v.TypeAlias.typeparams, (void *)s->v.TypeAlias.type_params,
false, false, s->kind, false, false, s->kind,
LOCATION(s))) { LOCATION(s))) {
VISIT_QUIT(st, 0); VISIT_QUIT(st, 0);
} }
VISIT_SEQ(st, typeparam, s->v.TypeAlias.typeparams); VISIT_SEQ(st, type_param, s->v.TypeAlias.type_params);
} }
if (!symtable_enter_block(st, name, TypeAliasBlock, if (!symtable_enter_block(st, name, TypeAliasBlock,
(void *)s, LOCATION(s))) (void *)s, LOCATION(s)))
@ -1785,10 +1785,10 @@ symtable_visit_stmt(struct symtable *st, stmt_ty s)
s->v.AsyncFunctionDef.args->kw_defaults); s->v.AsyncFunctionDef.args->kw_defaults);
if (s->v.AsyncFunctionDef.decorator_list) if (s->v.AsyncFunctionDef.decorator_list)
VISIT_SEQ(st, expr, s->v.AsyncFunctionDef.decorator_list); VISIT_SEQ(st, expr, s->v.AsyncFunctionDef.decorator_list);
if (asdl_seq_LEN(s->v.AsyncFunctionDef.typeparams) > 0) { if (asdl_seq_LEN(s->v.AsyncFunctionDef.type_params) > 0) {
if (!symtable_enter_typeparam_block( if (!symtable_enter_type_param_block(
st, s->v.AsyncFunctionDef.name, st, s->v.AsyncFunctionDef.name,
(void *)s->v.AsyncFunctionDef.typeparams, (void *)s->v.AsyncFunctionDef.type_params,
s->v.AsyncFunctionDef.args->defaults != NULL, s->v.AsyncFunctionDef.args->defaults != NULL,
has_kwonlydefaults(s->v.AsyncFunctionDef.args->kwonlyargs, has_kwonlydefaults(s->v.AsyncFunctionDef.args->kwonlyargs,
s->v.AsyncFunctionDef.args->kw_defaults), s->v.AsyncFunctionDef.args->kw_defaults),
@ -1796,7 +1796,7 @@ symtable_visit_stmt(struct symtable *st, stmt_ty s)
LOCATION(s))) { LOCATION(s))) {
VISIT_QUIT(st, 0); VISIT_QUIT(st, 0);
} }
VISIT_SEQ(st, typeparam, s->v.AsyncFunctionDef.typeparams); VISIT_SEQ(st, type_param, s->v.AsyncFunctionDef.type_params);
} }
if (!symtable_visit_annotations(st, s, s->v.AsyncFunctionDef.args, if (!symtable_visit_annotations(st, s, s->v.AsyncFunctionDef.args,
s->v.AsyncFunctionDef.returns)) s->v.AsyncFunctionDef.returns))
@ -1811,7 +1811,7 @@ symtable_visit_stmt(struct symtable *st, stmt_ty s)
VISIT_SEQ(st, stmt, s->v.AsyncFunctionDef.body); VISIT_SEQ(st, stmt, s->v.AsyncFunctionDef.body);
if (!symtable_exit_block(st)) if (!symtable_exit_block(st))
VISIT_QUIT(st, 0); VISIT_QUIT(st, 0);
if (asdl_seq_LEN(s->v.AsyncFunctionDef.typeparams) > 0) { if (asdl_seq_LEN(s->v.AsyncFunctionDef.type_params) > 0) {
if (!symtable_exit_block(st)) if (!symtable_exit_block(st))
VISIT_QUIT(st, 0); VISIT_QUIT(st, 0);
} }
@ -2110,7 +2110,7 @@ symtable_visit_expr(struct symtable *st, expr_ty e)
} }
static int static int
symtable_visit_typeparam(struct symtable *st, typeparam_ty tp) symtable_visit_type_param(struct symtable *st, type_param_ty tp)
{ {
if (++st->recursion_depth > st->recursion_limit) { if (++st->recursion_depth > st->recursion_limit) {
PyErr_SetString(PyExc_RecursionError, PyErr_SetString(PyExc_RecursionError,