# Test various flavors of legal and illegal future statements
+from functools import partial
import unittest
from test import support
+from textwrap import dedent
import os
import re
exec("from __future__ import unicode_literals; x = ''", {}, scope)
self.assertIsInstance(scope["x"], str)
+class AnnotationsFutureTestCase(unittest.TestCase):
+ template = dedent(
+ """
+ from __future__ import annotations
+ def f() -> {ann}:
+ ...
+ def g(arg: {ann}) -> None:
+ ...
+ var: {ann}
+ var2: {ann} = None
+ """
+ )
+
+ def getActual(self, annotation):
+ scope = {}
+ exec(self.template.format(ann=annotation), {}, scope)
+ func_ret_ann = scope['f'].__annotations__['return']
+ func_arg_ann = scope['g'].__annotations__['arg']
+ var_ann1 = scope['__annotations__']['var']
+ var_ann2 = scope['__annotations__']['var2']
+ self.assertEqual(func_ret_ann, func_arg_ann)
+ self.assertEqual(func_ret_ann, var_ann1)
+ self.assertEqual(func_ret_ann, var_ann2)
+ return func_ret_ann
+
+ def assertAnnotationEqual(
+ self, annotation, expected=None, drop_parens=False, is_tuple=False,
+ ):
+ actual = self.getActual(annotation)
+ if expected is None:
+ expected = annotation if not is_tuple else annotation[1:-1]
+ if drop_parens:
+ self.assertNotEqual(actual, expected)
+ actual = actual.replace("(", "").replace(")", "")
+
+ self.assertEqual(actual, expected)
+
+ def test_annotations(self):
+ eq = self.assertAnnotationEqual
+ eq('...')
+ eq("'some_string'")
+ eq("b'\\xa3'")
+ eq('Name')
+ eq('None')
+ eq('True')
+ eq('False')
+ eq('1')
+ eq('1.0')
+ eq('1j')
+ eq('True or False')
+ eq('True or False or None')
+ eq('True and False')
+ eq('True and False and None')
+ eq('(Name1 and Name2) or Name3')
+ eq('Name1 or (Name2 and Name3)')
+ eq('(Name1 and Name2) or (Name3 and Name4)')
+ eq('Name1 or (Name2 and Name3) or Name4')
+ eq('v1 << 2')
+ eq('1 >> v2')
+ eq(r'1 % finished')
+ eq('((1 + v2) - (v3 * 4)) ^ (((5 ** v6) / 7) // 8)')
+ eq('not great')
+ eq('~great')
+ eq('+value')
+ eq('-1')
+ eq('(~int) and (not ((v1 ^ (123 + v2)) | True))')
+ eq('lambda arg: None')
+ eq('lambda a=True: a')
+ eq('lambda a, b, c=True: a')
+ eq("lambda a, b, c=True, *, d=(1 << v2), e='str': a")
+ eq("lambda a, b, c=True, *vararg, d=(v1 << 2), e='str', **kwargs: a + b")
+ eq('1 if True else 2')
+ eq('(str or None) if True else (str or bytes or None)')
+ eq('(str or None) if (1 if True else 2) else (str or bytes or None)')
+ eq("{'2.7': dead, '3.7': (long_live or die_hard)}")
+ eq("{'2.7': dead, '3.7': (long_live or die_hard), **{'3.6': verygood}}")
+ eq("{**a, **b, **c}")
+ eq("{'2.7', '3.6', '3.7', '3.8', '3.9', ('4.0' if gilectomy else '3.10')}")
+ eq("({'a': 'b'}, (True or False), (+value), 'string', b'bytes') or None")
+ eq("()")
+ eq("(1,)")
+ eq("(1, 2)")
+ eq("(1, 2, 3)")
+ eq("[]")
+ eq("[1, 2, 3, 4, 5, 6, 7, 8, 9, (10 or A), (11 or B), (12 or C)]")
+ eq("{i for i in (1, 2, 3)}")
+ eq("{(i ** 2) for i in (1, 2, 3)}")
+ eq("{(i ** 2) for i, _ in ((1, 'a'), (2, 'b'), (3, 'c'))}")
+ eq("{((i ** 2) + j) for i in (1, 2, 3) for j in (1, 2, 3)}")
+ eq("[i for i in (1, 2, 3)]")
+ eq("[(i ** 2) for i in (1, 2, 3)]")
+ eq("[(i ** 2) for i, _ in ((1, 'a'), (2, 'b'), (3, 'c'))]")
+ eq("[((i ** 2) + j) for i in (1, 2, 3) for j in (1, 2, 3)]")
+ eq(r"{i: 0 for i in (1, 2, 3)}")
+ eq("{i: j for i, j in ((1, 'a'), (2, 'b'), (3, 'c'))}")
+ eq("Python3 > Python2 > COBOL")
+ eq("Life is Life")
+ eq("call()")
+ eq("call(arg)")
+ eq("call(kwarg='hey')")
+ eq("call(arg, kwarg='hey')")
+ eq("call(arg, another, kwarg='hey', **kwargs)")
+ eq("lukasz.langa.pl")
+ eq("call.me(maybe)")
+ eq("1 .real")
+ eq("1.0 .real")
+ eq("....__class__")
+ eq("list[str]")
+ eq("dict[str, int]")
+ eq("tuple[str, ...]")
+ eq("tuple[str, int, float, dict[str, int]]")
+ eq("slice[0]")
+ eq("slice[0:1]")
+ eq("slice[0:1:2]")
+ eq("slice[:]")
+ eq("slice[:-1]")
+ eq("slice[1:]")
+ eq("slice[::-1]")
+ eq('(str or None) if (sys.version_info[0] > (3,)) else (str or bytes or None)')
+ eq("f'f-string without formatted values is just a string'")
+ eq("f'{{NOT a formatted value}}'")
+ eq("f'some f-string with {a} {few():.2f} {formatted.values!r}'")
+ eq('''f"{f'{nested} inner'} outer"''')
+ eq("f'space between opening braces: { {a for a in (1, 2, 3)}}'")
+
+ def test_annotations_inexact(self):
+ """Source formatting is not always preserved
+
+ This is due to reconstruction from AST. We *need to* put the parens
+ in nested expressions because we don't know if the source code
+ had them in the first place or not.
+ """
+ eq = partial(self.assertAnnotationEqual, drop_parens=True)
+ eq('Name1 and Name2 or Name3')
+ eq('Name1 or Name2 and Name3')
+ eq('Name1 and Name2 or Name3 and Name4')
+ eq('Name1 or Name2 and Name3 or Name4')
+ eq('1 + v2 - v3 * 4 ^ v5 ** 6 / 7 // 8')
+ eq('~int and not v1 ^ 123 + v2 | True')
+ eq('str or None if True else str or bytes or None')
+ eq("{'2.7': dead, '3.7': long_live or die_hard}")
+ eq("{'2.7', '3.6', '3.7', '3.8', '3.9', '4.0' if gilectomy else '3.10'}")
+ eq("[1, 2, 3, 4, 5, 6, 7, 8, 9, 10 or A, 11 or B, 12 or C]")
+ # Consequently, we always drop unnecessary parens if they were given in
+ # the outer scope:
+ some_name = self.getActual("(SomeName)")
+ self.assertEqual(some_name, 'SomeName')
+ # Interestingly, in the case of tuples (and generator expressions) the
+ # parens are *required* by the Python syntax in the annotation context.
+ # But there's no point storing that detail in __annotations__ so we're
+ # fine with the parens-less form.
+ eq = partial(self.assertAnnotationEqual, is_tuple=True)
+ eq("(Good, Bad, Ugly)")
+ eq("(i for i in (1, 2, 3))")
+ eq("((i ** 2) for i in (1, 2, 3))")
+ eq("((i ** 2) for i, _ in ((1, 'a'), (2, 'b'), (3, 'c')))")
+ eq("(((i ** 2) + j) for i in (1, 2, 3) for j in (1, 2, 3))")
+ eq("(*starred)")
+ eq('(yield from outside_of_generator)')
+ eq('(yield)')
+ eq('(await some.complicated[0].call(with_args=(True or (1 is not 1))))')
if __name__ == "__main__":
--- /dev/null
+#include <stdbool.h>
+#include "Python.h"
+#include "Python-ast.h"
+
+static PyObject *_str_open_br;
+static PyObject *_str_dbl_open_br;
+static PyObject *_str_close_br;
+static PyObject *_str_dbl_close_br;
+
+/* Forward declarations for recursion via helper functions. */
+static PyObject *
+expr_as_unicode(expr_ty e, bool omit_parens);
+static int
+append_ast_expr(_PyUnicodeWriter *writer, expr_ty e, bool omit_parens);
+static int
+append_joinedstr(_PyUnicodeWriter *writer, expr_ty e, bool is_format_spec);
+static int
+append_formattedvalue(_PyUnicodeWriter *writer, expr_ty e, bool is_format_spec);
+
+static int
+append_charp(_PyUnicodeWriter *writer, const char *charp)
+{
+ return _PyUnicodeWriter_WriteASCIIString(writer, charp, -1);
+}
+
+static int
+append_repr(_PyUnicodeWriter *writer, PyObject *obj)
+{
+ int ret;
+ PyObject *repr;
+ repr = PyObject_Repr(obj);
+ if (!repr) {
+ return -1;
+ }
+ ret = _PyUnicodeWriter_WriteStr(writer, repr);
+ Py_DECREF(repr);
+ return ret;
+}
+
+static int
+append_ast_boolop(_PyUnicodeWriter *writer, expr_ty e, bool omit_parens)
+{
+ Py_ssize_t i, value_count;
+ asdl_seq *values;
+
+ if (!omit_parens && -1 == append_charp(writer, "(")) {
+ return -1;
+ }
+
+ values = e->v.BoolOp.values;
+ value_count = asdl_seq_LEN(values) - 1;
+ assert(value_count >= 0);
+
+ if (-1 == append_ast_expr(writer,
+ (expr_ty)asdl_seq_GET(values, 0),
+ false)) {
+ return -1;
+ }
+
+ const char *op = (e->v.BoolOp.op == And) ? " and " : " or ";
+ for (i = 1; i <= value_count; ++i) {
+ if (-1 == append_charp(writer, op)) {
+ return -1;
+ }
+
+ if (-1 == append_ast_expr(writer,
+ (expr_ty)asdl_seq_GET(values, i),
+ false)) {
+ return -1;
+ }
+ }
+
+ return omit_parens ? 0 : append_charp(writer, ")");
+}
+
+static int
+append_ast_binop(_PyUnicodeWriter *writer, expr_ty e, bool omit_parens)
+{
+ const char *op;
+
+ if (!omit_parens && -1 == append_charp(writer, "(")) {
+ return -1;
+ }
+
+ if (-1 == append_ast_expr(writer, e->v.BinOp.left, false)) {
+ return -1;
+ }
+
+ switch(e->v.BinOp.op) {
+ case Add: op = " + "; break;
+ case Sub: op = " - "; break;
+ case Mult: op = " * "; break;
+ case MatMult: op = " @ "; break;
+ case Div: op = " / "; break;
+ case Mod: op = " % "; break;
+ case LShift: op = " << "; break;
+ case RShift: op = " >> "; break;
+ case BitOr: op = " | "; break;
+ case BitXor: op = " ^ "; break;
+ case BitAnd: op = " & "; break;
+ case FloorDiv: op = " // "; break;
+ case Pow: op = " ** "; break;
+ }
+
+ if (-1 == append_charp(writer, op)) {
+ return -1;
+ }
+
+ if (-1 == append_ast_expr(writer, e->v.BinOp.right, false)) {
+ return -1;
+ }
+
+ return omit_parens ? 0 : append_charp(writer, ")");
+}
+
+static int
+append_ast_unaryop(_PyUnicodeWriter *writer, expr_ty e, bool omit_parens)
+{
+ const char *op;
+
+ if (!omit_parens && -1 == append_charp(writer, "(")) {
+ return -1;
+ }
+
+ switch(e->v.UnaryOp.op) {
+ case Invert: op = "~"; break;
+ case Not: op = "not "; break;
+ case UAdd: op = "+"; break;
+ case USub: op = "-"; break;
+ }
+
+ if (-1 == append_charp(writer, op)) {
+ return -1;
+ }
+
+ if (-1 == append_ast_expr(writer, e->v.UnaryOp.operand, false)) {
+ return -1;
+ }
+
+ return omit_parens ? 0 : append_charp(writer, ")");
+}
+
+static int
+append_ast_arg(_PyUnicodeWriter *writer, arg_ty arg)
+{
+ if (-1 == _PyUnicodeWriter_WriteStr(writer, arg->arg)) {
+ return -1;
+ }
+ if (arg->annotation) {
+ if (-1 == append_charp(writer, ": ")) {
+ return -1;
+ }
+ if (-1 == append_ast_expr(writer, arg->annotation, true)) {
+ return -1;
+ }
+ }
+ return 0;
+}
+
+static int
+append_ast_args(_PyUnicodeWriter *writer, arguments_ty args)
+{
+ bool first;
+ Py_ssize_t i, di, arg_count, default_count;
+ arg_ty arg;
+ expr_ty default_;
+
+ first = true;
+
+ /* positional arguments with defaults */
+ arg_count = asdl_seq_LEN(args->args);
+ default_count = asdl_seq_LEN(args->defaults);
+ for (i = 0; i < arg_count; i++) {
+ if (first) {
+ first = false;
+ }
+ else if (-1 == append_charp(writer, ", ")) {
+ return -1;
+ }
+
+ arg = (arg_ty)asdl_seq_GET(args->args, i);
+ if (-1 == append_ast_arg(writer, arg)) {
+ return -1;
+ }
+
+ di = i - arg_count + default_count;
+ if (di >= 0) {
+ if (-1 == append_charp(writer, "=")) {
+ return -1;
+ }
+ default_ = (expr_ty)asdl_seq_GET(args->defaults, di);
+ if (-1 == append_ast_expr(writer, default_, false)) {
+ return -1;
+ }
+ }
+ }
+
+ /* vararg, or bare '*' if no varargs but keyword-only arguments present */
+ if (args->vararg || args->kwonlyargs) {
+ if (first) {
+ first = false;
+ }
+ else if (-1 == append_charp(writer, ", ")) {
+ return -1;
+ }
+
+ if (-1 == append_charp(writer, "*")) {
+ return -1;
+ }
+
+ if (args->vararg) {
+ if (-1 == append_ast_arg(writer, args->vararg)) {
+ return -1;
+ }
+ }
+ }
+
+ /* keyword-only arguments */
+ arg_count = asdl_seq_LEN(args->kwonlyargs);
+ default_count = asdl_seq_LEN(args->kw_defaults);
+ for (i = 0; i < arg_count; i++) {
+ if (first) {
+ first = false;
+ }
+ else if (-1 == append_charp(writer, ", ")) {
+ return -1;
+ }
+
+ arg = (arg_ty)asdl_seq_GET(args->kwonlyargs, i);
+ if (-1 == append_ast_arg(writer, arg)) {
+ return -1;
+ }
+
+ di = i - arg_count + default_count;
+ if (di >= 0) {
+ if (-1 == append_charp(writer, "=")) {
+ return -1;
+ }
+ default_ = (expr_ty)asdl_seq_GET(args->kw_defaults, di);
+ if (-1 == append_ast_expr(writer, default_, false)) {
+ return -1;
+ }
+ }
+ }
+
+ /* **kwargs */
+ if (args->kwarg) {
+ if (first) {
+ first = false;
+ }
+ else if (-1 == append_charp(writer, ", ")) {
+ return -1;
+ }
+
+ if (-1 == append_charp(writer, "**")) {
+ return -1;
+ }
+
+ if (-1 == append_ast_arg(writer, args->kwarg)) {
+ return -1;
+ }
+ }
+
+ return 0;
+}
+
+static int
+append_ast_lambda(_PyUnicodeWriter *writer, expr_ty e, bool omit_parens)
+{
+ if (!omit_parens && -1 == append_charp(writer, "(")) {
+ return -1;
+ }
+
+ if (-1 == append_charp(writer, "lambda ")) {
+ return -1;
+ }
+
+ if (-1 == append_ast_args(writer, e->v.Lambda.args)) {
+ return -1;
+ }
+
+ if (-1 == append_charp(writer, ": ")) {
+ return -1;
+ }
+
+ if (-1 == append_ast_expr(writer, e->v.Lambda.body, true)) {
+ return -1;
+ }
+
+ return omit_parens ? 0 : append_charp(writer, ")");
+}
+
+static int
+append_ast_ifexp(_PyUnicodeWriter *writer, expr_ty e, bool omit_parens)
+{
+ if (!omit_parens && -1 == append_charp(writer, "(")) {
+ return -1;
+ }
+
+ if (-1 == append_ast_expr(writer, e->v.IfExp.body, false)) {
+ return -1;
+ }
+
+ if (-1 == append_charp(writer, " if ")) {
+ return -1;
+ }
+
+ if (-1 == append_ast_expr(writer, e->v.IfExp.test, false)) {
+ return -1;
+ }
+
+ if (-1 == append_charp(writer, " else ")) {
+ return -1;
+ }
+
+ if (-1 == append_ast_expr(writer, e->v.IfExp.orelse, false)) {
+ return -1;
+ }
+
+ return omit_parens ? 0 : append_charp(writer, ")");
+}
+
+static int
+append_ast_dict(_PyUnicodeWriter *writer, expr_ty e)
+{
+ Py_ssize_t i, value_count;
+ expr_ty key_node, value_node;
+
+ if (-1 == append_charp(writer, "{")) {
+ return -1;
+ }
+
+ value_count = asdl_seq_LEN(e->v.Dict.values);
+
+ for (i = 0; i < value_count; i++) {
+ if (i > 0 && -1 == append_charp(writer, ", ")) {
+ return -1;
+ }
+ key_node = (expr_ty)asdl_seq_GET(e->v.Dict.keys, i);
+ if (key_node != NULL) {
+ if (-1 == append_ast_expr(writer, key_node, false)) {
+ return -1;
+ }
+
+ if (-1 == append_charp(writer, ": ")) {
+ return -1;
+ }
+ }
+ else if (-1 == append_charp(writer, "**")) {
+ return -1;
+ }
+
+ value_node = (expr_ty)asdl_seq_GET(e->v.Dict.values, i);
+ if (-1 == append_ast_expr(writer, value_node, false)) {
+ return -1;
+ }
+ }
+
+ return append_charp(writer, "}");
+}
+
+static int
+append_ast_set(_PyUnicodeWriter *writer, expr_ty e)
+{
+ Py_ssize_t i, elem_count;
+ expr_ty elem_node;
+
+ if (-1 == append_charp(writer, "{")) {
+ return -1;
+ }
+
+ elem_count = asdl_seq_LEN(e->v.Set.elts);
+ for (i = 0; i < elem_count; i++) {
+ if (i > 0 && -1 == append_charp(writer, ", ")) {
+ return -1;
+ }
+
+ elem_node = (expr_ty)asdl_seq_GET(e->v.Set.elts, i);
+ if (-1 == append_ast_expr(writer, elem_node, false)) {
+ return -1;
+ }
+ }
+
+ return append_charp(writer, "}");
+}
+
+static int
+append_ast_list(_PyUnicodeWriter *writer, expr_ty e)
+{
+ Py_ssize_t i, elem_count;
+ expr_ty elem_node;
+
+ if (-1 == append_charp(writer, "[")) {
+ return -1;
+ }
+
+ elem_count = asdl_seq_LEN(e->v.List.elts);
+ for (i = 0; i < elem_count; i++) {
+ if (i > 0 && -1 == append_charp(writer, ", ")) {
+ return -1;
+ }
+ elem_node = (expr_ty)asdl_seq_GET(e->v.List.elts, i);
+ if (-1 == append_ast_expr(writer, elem_node, false)) {
+ return -1;
+ }
+ }
+
+ return append_charp(writer, "]");
+}
+
+static int
+append_ast_tuple(_PyUnicodeWriter *writer, expr_ty e, bool omit_parens)
+{
+ Py_ssize_t i, elem_count;
+ expr_ty elem_node;
+
+ elem_count = asdl_seq_LEN(e->v.Tuple.elts);
+
+ if (!omit_parens || elem_count < 2) {
+ if (-1 == append_charp(writer, "(")) {
+ return -1;
+ }
+ }
+
+ for (i = 0; i < elem_count; i++) {
+ if ((i > 0 || elem_count == 1) && -1 == append_charp(writer, ", ")) {
+ return -1;
+ }
+ elem_node = (expr_ty)asdl_seq_GET(e->v.Tuple.elts, i);
+ if (-1 == append_ast_expr(writer, elem_node, false)) {
+ return -1;
+ }
+ }
+
+ if (!omit_parens || elem_count < 2) {
+ return append_charp(writer, ")");
+ }
+
+ return 0;
+}
+
+static int
+append_ast_comprehension(_PyUnicodeWriter *writer, comprehension_ty gen)
+{
+ Py_ssize_t i, if_count;
+
+ if (-1 == append_charp(writer, gen->is_async ? " async for " : " for ")) {
+ return -1;
+ }
+
+ if (-1 == append_ast_expr(writer, gen->target, true)) {
+ return -1;
+ }
+
+ if (-1 == append_charp(writer, " in ")) {
+ return -1;
+ }
+
+ if (-1 == append_ast_expr(writer, gen->iter, false)) {
+ return -1;
+ }
+
+ if_count = asdl_seq_LEN(gen->ifs);
+ for (i = 0; i < if_count; i++) {
+ if (-1 == append_charp(writer, " if ")) {
+ return -1;
+ }
+
+ if (-1 == append_ast_expr(writer,
+ (expr_ty)asdl_seq_GET(gen->ifs, i),
+ false)) {
+ return -1;
+ }
+ }
+ return 0;
+}
+
+static int
+append_ast_comprehensions(_PyUnicodeWriter *writer, asdl_seq *comprehensions)
+{
+ Py_ssize_t i, gen_count;
+ comprehension_ty comp_node;
+ gen_count = asdl_seq_LEN(comprehensions);
+
+ for (i = 0; i < gen_count; i++) {
+ comp_node = (comprehension_ty)asdl_seq_GET(comprehensions, i);
+ if (-1 == append_ast_comprehension(writer, comp_node)) {
+ return -1;
+ }
+ }
+
+ return 0;
+}
+
+static int
+append_ast_genexp(_PyUnicodeWriter *writer, expr_ty e, bool omit_parens)
+{
+ if (!omit_parens && -1 == append_charp(writer, "(")) {
+ return -1;
+ }
+
+ if (-1 == append_ast_expr(writer, e->v.GeneratorExp.elt, false)) {
+ return -1;
+ }
+
+ if (-1 == append_ast_comprehensions(writer, e->v.GeneratorExp.generators)) {
+ return -1;
+ }
+
+ return omit_parens ? 0 : append_charp(writer, ")");
+}
+
+static int
+append_ast_listcomp(_PyUnicodeWriter *writer, expr_ty e)
+{
+ if (-1 == append_charp(writer, "[")) {
+ return -1;
+ }
+
+ if (-1 == append_ast_expr(writer, e->v.ListComp.elt, false)) {
+ return -1;
+ }
+
+ if (-1 == append_ast_comprehensions(writer, e->v.ListComp.generators)) {
+ return -1;
+ }
+
+ return append_charp(writer, "]");
+}
+
+static int
+append_ast_setcomp(_PyUnicodeWriter *writer, expr_ty e)
+{
+ if (-1 == append_charp(writer, "{")) {
+ return -1;
+ }
+
+ if (-1 == append_ast_expr(writer, e->v.SetComp.elt, false)) {
+ return -1;
+ }
+
+ if (-1 == append_ast_comprehensions(writer, e->v.SetComp.generators)) {
+ return -1;
+ }
+
+ return append_charp(writer, "}");
+}
+
+static int
+append_ast_dictcomp(_PyUnicodeWriter *writer, expr_ty e)
+{
+ if (-1 == append_charp(writer, "{")) {
+ return -1;
+ }
+
+ if (-1 == append_ast_expr(writer, e->v.DictComp.key, false)) {
+ return -1;
+ }
+
+ if (-1 == append_charp(writer, ": ")) {
+ return -1;
+ }
+
+ if (-1 == append_ast_expr(writer, e->v.DictComp.value, false)) {
+ return -1;
+ }
+
+ if (-1 == append_ast_comprehensions(writer, e->v.DictComp.generators)) {
+ return -1;
+ }
+
+ return append_charp(writer, "}");
+}
+
+static int
+append_ast_compare(_PyUnicodeWriter *writer, expr_ty e, bool omit_parens)
+{
+ const char *op;
+ Py_ssize_t i, comparator_count;
+ asdl_seq *comparators;
+ asdl_int_seq *ops;
+
+ if (!omit_parens && -1 == append_charp(writer, "(")) {
+ return -1;
+ }
+
+ comparators = e->v.Compare.comparators;
+ ops = e->v.Compare.ops;
+ comparator_count = asdl_seq_LEN(comparators);
+ assert(comparator_count > 0);
+ assert(comparator_count == asdl_seq_LEN(ops));
+
+ if (-1 == append_ast_expr(writer, e->v.Compare.left, false)) {
+ return -1;
+ }
+
+ for (i = 0; i < comparator_count; i++) {
+ switch ((cmpop_ty)asdl_seq_GET(ops, i)) {
+ case Eq:
+ op = " == ";
+ break;
+ case NotEq:
+ op = " != ";
+ break;
+ case Lt:
+ op = " < ";
+ break;
+ case LtE:
+ op = " <= ";
+ break;
+ case Gt:
+ op = " > ";
+ break;
+ case GtE:
+ op = " >= ";
+ break;
+ case Is:
+ op = " is ";
+ break;
+ case IsNot:
+ op = " is not ";
+ break;
+ case In:
+ op = " in ";
+ break;
+ case NotIn:
+ op = " not in ";
+ break;
+ default:
+ PyErr_SetString(PyExc_SystemError,
+ "unexpected comparison kind");
+ return -1;
+ }
+
+ if (-1 == append_charp(writer, op)) {
+ return -1;
+ }
+
+ if (-1 == append_ast_expr(writer,
+ (expr_ty)asdl_seq_GET(comparators, i),
+ false)) {
+ return -1;
+ }
+ }
+
+ return omit_parens ? 0 : append_charp(writer, ")");
+}
+
+static int
+append_ast_keyword(_PyUnicodeWriter *writer, keyword_ty kw)
+{
+ if (kw->arg == NULL) {
+ if (-1 == append_charp(writer, "**")) {
+ return -1;
+ }
+ }
+ else {
+ if (-1 == _PyUnicodeWriter_WriteStr(writer, kw->arg)) {
+ return -1;
+ }
+
+ if (-1 == append_charp(writer, "=")) {
+ return -1;
+ }
+ }
+
+ return append_ast_expr(writer, kw->value, false);
+}
+
+static int
+append_ast_call(_PyUnicodeWriter *writer, expr_ty e)
+{
+ bool first;
+ Py_ssize_t i, arg_count, kw_count;
+ expr_ty expr;
+ keyword_ty kw;
+
+ if (-1 == append_ast_expr(writer, e->v.Call.func, false)) {
+ return -1;
+ }
+
+ if (-1 == append_charp(writer, "(")) {
+ return -1;
+ }
+
+ first = true;
+ arg_count = asdl_seq_LEN(e->v.Call.args);
+ for (i = 0; i < arg_count; i++) {
+ if (first) {
+ first = false;
+ }
+ else if (-1 == append_charp(writer, ", ")) {
+ return -1;
+ }
+
+ expr = (expr_ty)asdl_seq_GET(e->v.Call.args, i);
+ if (-1 == append_ast_expr(writer, expr, false)) {
+ return -1;
+ }
+ }
+
+ kw_count = asdl_seq_LEN(e->v.Call.keywords);
+ for (i = 0; i < kw_count; i++) {
+ if (first) {
+ first = false;
+ }
+ else if (-1 == append_charp(writer, ", ")) {
+ return -1;
+ }
+
+ kw = (keyword_ty)asdl_seq_GET(e->v.Call.keywords, i);
+ if (-1 == append_ast_keyword(writer, kw)) {
+ return -1;
+ }
+ }
+
+ return append_charp(writer, ")");
+}
+
+static PyObject *
+escape_braces(PyObject *orig)
+{
+ PyObject *temp;
+ PyObject *result;
+ temp = PyUnicode_Replace(orig, _str_open_br, _str_dbl_open_br, -1);
+ if (!temp) {
+ return NULL;
+ }
+ result = PyUnicode_Replace(temp, _str_close_br, _str_dbl_close_br, -1);
+ Py_DECREF(temp);
+ return result;
+}
+
+static int
+append_fstring_unicode(_PyUnicodeWriter *writer, PyObject *unicode)
+{
+ PyObject *escaped;
+ int result = -1;
+ escaped = escape_braces(unicode);
+ if (escaped) {
+ result = _PyUnicodeWriter_WriteStr(writer, escaped);
+ Py_DECREF(escaped);
+ }
+ return result;
+}
+
+static int
+append_fstring_element(_PyUnicodeWriter *writer, expr_ty e, bool is_format_spec)
+{
+ switch (e->kind) {
+ case Constant_kind:
+ return append_fstring_unicode(writer, e->v.Constant.value);
+ case Str_kind:
+ return append_fstring_unicode(writer, e->v.Str.s);
+ case JoinedStr_kind:
+ return append_joinedstr(writer, e, is_format_spec);
+ case FormattedValue_kind:
+ return append_formattedvalue(writer, e, is_format_spec);
+ default:
+ PyErr_SetString(PyExc_SystemError,
+ "unknown expression kind inside f-string");
+ return -1;
+ }
+}
+
+/* Build body separately to enable wrapping the entire stream of Strs,
+ Constants and FormattedValues in one opening and one closing quote. */
+static PyObject *
+build_fstring_body(asdl_seq *values, bool is_format_spec)
+{
+ Py_ssize_t i, value_count;
+ _PyUnicodeWriter body_writer;
+ _PyUnicodeWriter_Init(&body_writer);
+ body_writer.min_length = 256;
+ body_writer.overallocate = 1;
+
+ value_count = asdl_seq_LEN(values) - 1;
+ assert(value_count >= 0);
+ for (i = 0; i <= value_count; ++i) {
+ if (-1 == append_fstring_element(&body_writer,
+ (expr_ty)asdl_seq_GET(values, i),
+ is_format_spec
+ )) {
+ _PyUnicodeWriter_Dealloc(&body_writer);
+ return NULL;
+ }
+ }
+
+ return _PyUnicodeWriter_Finish(&body_writer);
+}
+
+static int
+append_joinedstr(_PyUnicodeWriter *writer, expr_ty e, bool is_format_spec)
+{
+ int result = -1;
+ PyObject *body = build_fstring_body(e->v.JoinedStr.values, is_format_spec);
+ if (!body) {
+ return -1;
+ }
+
+ if (!is_format_spec) {
+ if (-1 != append_charp(writer, "f") &&
+ -1 != append_repr(writer, body))
+ {
+ result = 0;
+ }
+ }
+ else {
+ result = _PyUnicodeWriter_WriteStr(writer, body);
+ }
+ Py_DECREF(body);
+ return result;
+}
+
+static int
+append_formattedvalue(_PyUnicodeWriter *writer, expr_ty e, bool is_format_spec)
+{
+ char *conversion;
+ char *outer_brace = "{";
+ PyObject *temp_fv_str = expr_as_unicode(e->v.FormattedValue.value, true);
+ if (!temp_fv_str) {
+ return -1;
+ }
+ if (PyUnicode_Find(temp_fv_str, _str_open_br, 0, 1, 1) == 0) {
+ /* Expression starts with a brace, split it with a space from the outer
+ one. */
+ outer_brace = "{ ";
+ }
+ if (-1 == append_charp(writer, outer_brace)) {
+ Py_DECREF(temp_fv_str);
+ return -1;
+ }
+ if (-1 == _PyUnicodeWriter_WriteStr(writer, temp_fv_str)) {
+ Py_DECREF(temp_fv_str);
+ return -1;
+ }
+ Py_DECREF(temp_fv_str);
+
+ if (e->v.FormattedValue.conversion > 0) {
+ switch (e->v.FormattedValue.conversion) {
+ case 97:
+ conversion = "!a";
+ break;
+ case 114:
+ conversion = "!r";
+ break;
+ case 115:
+ conversion = "!s";
+ break;
+ default:
+ PyErr_SetString(PyExc_SystemError,
+ "unknown f-value conversion kind");
+ return -1;
+ }
+ if (-1 == append_charp(writer, conversion)) {
+ return -1;
+ }
+ }
+ if (e->v.FormattedValue.format_spec > 0) {
+ if (-1 == _PyUnicodeWriter_WriteASCIIString(writer, ":", 1) ||
+ -1 == append_fstring_element(writer,
+ e->v.FormattedValue.format_spec,
+ true
+ ))
+ {
+ return -1;
+ }
+ }
+ return append_charp(writer, "}");
+}
+
+static int
+append_ast_attribute(_PyUnicodeWriter *writer, expr_ty e)
+{
+ const char *period;
+ if (-1 == append_ast_expr(writer, e->v.Attribute.value, false)) {
+ return -1;
+ }
+
+ /* Special case: integers require a space for attribute access to be
+ unambiguous. Floats and complex numbers don't but work with it, too. */
+ if (e->v.Attribute.value->kind == Num_kind ||
+ e->v.Attribute.value->kind == Constant_kind)
+ {
+ period = " .";
+ }
+ else {
+ period = ".";
+ }
+ if (-1 == append_charp(writer, period)) {
+ return -1;
+ }
+
+ return _PyUnicodeWriter_WriteStr(writer, e->v.Attribute.attr);
+}
+
+static int
+append_ast_simple_slice(_PyUnicodeWriter *writer, slice_ty slice)
+{
+ if (slice->v.Slice.lower) {
+ if (-1 == append_ast_expr(writer, slice->v.Slice.lower, false)) {
+ return -1;
+ }
+ }
+
+ if (-1 == append_charp(writer, ":")) {
+ return -1;
+ }
+
+ if (slice->v.Slice.upper) {
+ if (-1 == append_ast_expr(writer, slice->v.Slice.upper, false)) {
+ return -1;
+ }
+ }
+
+ if (slice->v.Slice.step) {
+ if (-1 == append_charp(writer, ":")) {
+ return -1;
+ }
+ if (-1 == append_ast_expr(writer, slice->v.Slice.step, false)) {
+ return -1;
+ }
+ }
+ return 0;
+}
+
+static int
+append_ast_ext_slice(_PyUnicodeWriter *writer, slice_ty slice)
+{
+ Py_ssize_t i, dims_count;
+ dims_count = asdl_seq_LEN(slice->v.ExtSlice.dims);
+ for (i = 0; i < dims_count; i++) {
+ if (i > 0 && -1 == append_charp(writer, ", ")) {
+ return -1;
+ }
+ if (-1 == append_ast_expr(writer,
+ (expr_ty)asdl_seq_GET(slice->v.ExtSlice.dims, i),
+ false)) {
+ return -1;
+ }
+ }
+ return 0;
+}
+
+static int
+append_ast_slice(_PyUnicodeWriter *writer, slice_ty slice, bool omit_parens)
+{
+ switch(slice->kind) {
+ case Slice_kind:
+ return append_ast_simple_slice(writer, slice);
+ case ExtSlice_kind:
+ return append_ast_ext_slice(writer, slice);
+ case Index_kind:
+ return append_ast_expr(writer, slice->v.Index.value, omit_parens);
+ default:
+ PyErr_SetString(PyExc_SystemError,
+ "unexpected slice kind");
+ return -1;
+ }
+}
+
+static int
+append_ast_subscript(_PyUnicodeWriter *writer, expr_ty e)
+{
+ if (-1 == append_ast_expr(writer, e->v.Subscript.value, false)) {
+ return -1;
+ }
+
+ if (-1 == append_charp(writer, "[")) {
+ return -1;
+ }
+
+ if (-1 == append_ast_slice(writer, e->v.Subscript.slice, true)) {
+ return -1;
+ }
+
+ return append_charp(writer, "]");
+}
+
+static int
+append_ast_starred(_PyUnicodeWriter *writer, expr_ty e)
+{
+ if (-1 == append_charp(writer, "*")) {
+ return -1;
+ }
+
+ return append_ast_expr(writer, e->v.Starred.value, false);
+}
+
+static int
+append_ast_yield(_PyUnicodeWriter *writer, expr_ty e, bool omit_parens)
+{
+ if (!omit_parens && -1 == append_charp(writer, "(")) {
+ return -1;
+ }
+
+ if (-1 == append_charp(writer, e->v.Yield.value ? "yield " : "yield")) {
+ return -1;
+ }
+
+ if (e->v.Yield.value) {
+ if (-1 == append_ast_expr(writer, e->v.Yield.value, false)) {
+ return -1;
+ }
+ }
+ return omit_parens ? 0 : append_charp(writer, ")");
+}
+
+static int
+append_ast_yield_from(_PyUnicodeWriter *writer, expr_ty e, bool omit_parens)
+{
+ if (!omit_parens && -1 == append_charp(writer, "(")) {
+ return -1;
+ }
+
+ if (-1 == append_charp(writer,
+ e->v.YieldFrom.value ? "yield from " : "yield from")) {
+ return -1;
+ }
+
+ if (e->v.YieldFrom.value) {
+ if (-1 == append_ast_expr(writer, e->v.YieldFrom.value, false)) {
+ return -1;
+ }
+ }
+ return omit_parens ? 0 : append_charp(writer, ")");
+}
+
+static int
+append_ast_await(_PyUnicodeWriter *writer, expr_ty e, bool omit_parens)
+{
+ if (!omit_parens && -1 == append_charp(writer, "(")) {
+ return -1;
+ }
+
+ if (-1 == append_charp(writer, e->v.Await.value ? "await " : "await")) {
+ return -1;
+ }
+
+ if (e->v.Await.value) {
+ if (-1 == append_ast_expr(writer, e->v.Await.value, false)) {
+ return -1;
+ }
+ }
+ return omit_parens ? 0 : append_charp(writer, ")");
+}
+
+static int
+append_ast_expr(_PyUnicodeWriter *writer, expr_ty e, bool omit_parens)
+{
+ switch (e->kind) {
+ case BoolOp_kind:
+ return append_ast_boolop(writer, e, omit_parens);
+ case BinOp_kind:
+ return append_ast_binop(writer, e, omit_parens);
+ case UnaryOp_kind:
+ return append_ast_unaryop(writer, e, omit_parens);
+ case Lambda_kind:
+ return append_ast_lambda(writer, e, omit_parens);
+ case IfExp_kind:
+ return append_ast_ifexp(writer, e, omit_parens);
+ case Dict_kind:
+ return append_ast_dict(writer, e);
+ case Set_kind:
+ return append_ast_set(writer, e);
+ case GeneratorExp_kind:
+ return append_ast_genexp(writer, e, omit_parens);
+ case ListComp_kind:
+ return append_ast_listcomp(writer, e);
+ case SetComp_kind:
+ return append_ast_setcomp(writer, e);
+ case DictComp_kind:
+ return append_ast_dictcomp(writer, e);
+ case Yield_kind:
+ return append_ast_yield(writer, e, omit_parens);
+ case YieldFrom_kind:
+ return append_ast_yield_from(writer, e, omit_parens);
+ case Await_kind:
+ return append_ast_await(writer, e, omit_parens);
+ case Compare_kind:
+ return append_ast_compare(writer, e, omit_parens);
+ case Call_kind:
+ return append_ast_call(writer, e);
+ case Constant_kind:
+ return append_repr(writer, e->v.Constant.value);
+ case Num_kind:
+ return append_repr(writer, e->v.Num.n);
+ case Str_kind:
+ return append_repr(writer, e->v.Str.s);
+ case JoinedStr_kind:
+ return append_joinedstr(writer, e, false);
+ case FormattedValue_kind:
+ return append_formattedvalue(writer, e, false);
+ case Bytes_kind:
+ return append_repr(writer, e->v.Bytes.s);
+ case Ellipsis_kind:
+ return append_charp(writer, "...");
+ case NameConstant_kind:
+ return append_repr(writer, e->v.NameConstant.value);
+ /* The following exprs can be assignment targets. */
+ case Attribute_kind:
+ return append_ast_attribute(writer, e);
+ case Subscript_kind:
+ return append_ast_subscript(writer, e);
+ case Starred_kind:
+ return append_ast_starred(writer, e);
+ case Name_kind:
+ return _PyUnicodeWriter_WriteStr(writer, e->v.Name.id);
+ /* child nodes of List and Tuple will have expr_context set */
+ case List_kind:
+ return append_ast_list(writer, e);
+ case Tuple_kind:
+ return append_ast_tuple(writer, e, omit_parens);
+ default:
+ PyErr_SetString(PyExc_SystemError,
+ "unknown expression kind");
+ return -1;
+ }
+}
+
+static int
+maybe_init_static_strings()
+{
+ if (!_str_open_br &&
+ !(_str_open_br = PyUnicode_InternFromString("{"))) {
+ return -1;
+ }
+ if (!_str_dbl_open_br &&
+ !(_str_dbl_open_br = PyUnicode_InternFromString("{{"))) {
+ return -1;
+ }
+ if (!_str_close_br &&
+ !(_str_close_br = PyUnicode_InternFromString("}"))) {
+ return -1;
+ }
+ if (!_str_dbl_close_br &&
+ !(_str_dbl_close_br = PyUnicode_InternFromString("}}"))) {
+ return -1;
+ }
+ return 0;
+}
+
+static PyObject *
+expr_as_unicode(expr_ty e, bool omit_parens)
+{
+ _PyUnicodeWriter writer;
+ _PyUnicodeWriter_Init(&writer);
+ writer.min_length = 256;
+ writer.overallocate = 1;
+ if (-1 == maybe_init_static_strings() ||
+ -1 == append_ast_expr(&writer, e, omit_parens))
+ {
+ _PyUnicodeWriter_Dealloc(&writer);
+ return NULL;
+ }
+ return _PyUnicodeWriter_Finish(&writer);
+}
+
+PyObject *
+_PyAST_ExprAsUnicode(expr_ty e, bool omit_parens)
+{
+ return expr_as_unicode(e, omit_parens);
+}
projects / python / commitdiff