bpo-32892: Use ast.Constant instead of specific constant AST types. (GH-9445)
diff --git a/Python/ast.c b/Python/ast.c
index b2fcb21..587f838 100644
--- a/Python/ast.c
+++ b/Python/ast.c
@@ -295,23 +295,6 @@
return 0;
}
return 1;
- case Num_kind: {
- PyObject *n = exp->v.Num.n;
- if (!PyLong_CheckExact(n) && !PyFloat_CheckExact(n) &&
- !PyComplex_CheckExact(n)) {
- PyErr_SetString(PyExc_TypeError, "non-numeric type in Num");
- return 0;
- }
- return 1;
- }
- case Str_kind: {
- PyObject *s = exp->v.Str.s;
- if (!PyUnicode_CheckExact(s)) {
- PyErr_SetString(PyExc_TypeError, "non-string type in Str");
- return 0;
- }
- return 1;
- }
case JoinedStr_kind:
return validate_exprs(exp->v.JoinedStr.values, Load, 0);
case FormattedValue_kind:
@@ -320,14 +303,6 @@
if (exp->v.FormattedValue.format_spec)
return validate_expr(exp->v.FormattedValue.format_spec, Load);
return 1;
- case Bytes_kind: {
- PyObject *b = exp->v.Bytes.s;
- if (!PyBytes_CheckExact(b)) {
- PyErr_SetString(PyExc_TypeError, "non-bytes type in Bytes");
- return 0;
- }
- return 1;
- }
case Attribute_kind:
return validate_expr(exp->v.Attribute.value, Load);
case Subscript_kind:
@@ -339,10 +314,8 @@
return validate_exprs(exp->v.List.elts, ctx, 0);
case Tuple_kind:
return validate_exprs(exp->v.Tuple.elts, ctx, 0);
- /* These last cases don't have any checking. */
+ /* This last case doesn't have any checking. */
case Name_kind:
- case NameConstant_kind:
- case Ellipsis_kind:
return 1;
default:
PyErr_SetString(PyExc_SystemError, "unexpected expression");
@@ -1040,19 +1013,23 @@
break;
case Dict_kind:
case Set_kind:
- case Num_kind:
- case Str_kind:
- case Bytes_kind:
case JoinedStr_kind:
case FormattedValue_kind:
expr_name = "literal";
break;
- case NameConstant_kind:
- expr_name = "keyword";
+ case Constant_kind: {
+ PyObject *value = e->v.Constant.value;
+ if (value == Py_None || value == Py_False || value == Py_True) {
+ expr_name = "keyword";
+ }
+ else if (value == Py_Ellipsis) {
+ expr_name = "Ellipsis";
+ }
+ else {
+ expr_name = "literal";
+ }
break;
- case Ellipsis_kind:
- expr_name = "Ellipsis";
- break;
+ }
case Compare_kind:
expr_name = "comparison";
break;
@@ -2091,11 +2068,11 @@
size_t len = strlen(s);
if (len >= 4 && len <= 5) {
if (!strcmp(s, "None"))
- return NameConstant(Py_None, LINENO(n), n->n_col_offset, c->c_arena);
+ return Constant(Py_None, LINENO(n), n->n_col_offset, c->c_arena);
if (!strcmp(s, "True"))
- return NameConstant(Py_True, LINENO(n), n->n_col_offset, c->c_arena);
+ return Constant(Py_True, LINENO(n), n->n_col_offset, c->c_arena);
if (!strcmp(s, "False"))
- return NameConstant(Py_False, LINENO(n), n->n_col_offset, c->c_arena);
+ return Constant(Py_False, LINENO(n), n->n_col_offset, c->c_arena);
}
name = new_identifier(s, c);
if (!name)
@@ -2144,10 +2121,10 @@
Py_DECREF(pynum);
return NULL;
}
- return Num(pynum, LINENO(n), n->n_col_offset, c->c_arena);
+ return Constant(pynum, LINENO(n), n->n_col_offset, c->c_arena);
}
case ELLIPSIS: /* Ellipsis */
- return Ellipsis(LINENO(n), n->n_col_offset, c->c_arena);
+ return Constant(Py_Ellipsis, LINENO(n), n->n_col_offset, c->c_arena);
case LPAR: /* some parenthesized expressions */
ch = CHILD(n, 1);
@@ -4751,7 +4728,7 @@
expr_ty's, and then after that start dynamically allocating,
doubling the number allocated each time. Note that the f-string
f'{0}a{1}' contains 3 expr_ty's: 2 FormattedValue's, and one
- Str for the literal 'a'. So you add expr_ty's about twice as
+ Constant for the literal 'a'. So you add expr_ty's about twice as
fast as you add exressions in an f-string. */
Py_ssize_t allocated; /* Number we've allocated. */
@@ -4903,7 +4880,7 @@
ExprList_Dealloc(&state->expr_list);
}
-/* Make a Str node, but decref the PyUnicode object being added. */
+/* Make a Constant node, but decref the PyUnicode object being added. */
static expr_ty
make_str_node_and_del(PyObject **str, struct compiling *c, const node* n)
{
@@ -4914,7 +4891,7 @@
Py_DECREF(s);
return NULL;
}
- return Str(s, LINENO(n), n->n_col_offset, c->c_arena);
+ return Constant(s, LINENO(n), n->n_col_offset, c->c_arena);
}
/* Add a non-f-string (that is, a regular literal string). str is
@@ -5002,11 +4979,11 @@
break;
/* We know we have an expression. Convert any existing string
- to a Str node. */
+ to a Constant node. */
if (!state->last_str) {
/* Do nothing. No previous literal. */
} else {
- /* Convert the existing last_str literal to a Str node. */
+ /* Convert the existing last_str literal to a Constant node. */
expr_ty str = make_str_node_and_del(&state->last_str, c, n);
if (!str || ExprList_Append(&state->expr_list, str) < 0)
return -1;
@@ -5033,7 +5010,7 @@
}
/* Convert the partial state reflected in last_str and expr_list to an
- expr_ty. The expr_ty can be a Str, or a JoinedStr. */
+ expr_ty. The expr_ty can be a Constant, or a JoinedStr. */
static expr_ty
FstringParser_Finish(FstringParser *state, struct compiling *c,
const node *n)
@@ -5055,7 +5032,7 @@
return make_str_node_and_del(&state->last_str, c, n);
}
- /* Create a Str node out of last_str, if needed. It will be the
+ /* Create a Constant node out of last_str, if needed. It will be the
last node in our expression list. */
if (state->last_str) {
expr_ty str = make_str_node_and_del(&state->last_str, c, n);
@@ -5206,9 +5183,9 @@
/* Accepts a STRING+ atom, and produces an expr_ty node. Run through
each STRING atom, and process it as needed. For bytes, just
- concatenate them together, and the result will be a Bytes node. For
+ concatenate them together, and the result will be a Constant node. For
normal strings and f-strings, concatenate them together. The result
- will be a Str node if there were no f-strings; a FormattedValue
+ will be a Constant node if there were no f-strings; a FormattedValue
node if there's just an f-string (with no leading or trailing
literals), or a JoinedStr node if there are multiple f-strings or
any literals involved. */
@@ -5279,7 +5256,7 @@
/* Just return the bytes object and we're done. */
if (PyArena_AddPyObject(c->c_arena, bytes_str) < 0)
goto error;
- return Bytes(bytes_str, LINENO(n), n->n_col_offset, c->c_arena);
+ return Constant(bytes_str, LINENO(n), n->n_col_offset, c->c_arena);
}
/* We're not a bytes string, bytes_str should never have been set. */
@@ -5304,9 +5281,6 @@
return NULL;
}
expr_ty e = st->v.Expr.value;
- if (e->kind == Str_kind) {
- return e->v.Str.s;
- }
if (e->kind == Constant_kind && PyUnicode_CheckExact(e->v.Constant.value)) {
return e->v.Constant.value;
}