_PyStaticObject_CheckRefcnt((PyObject *)&_Py_STR(dot));
_PyStaticObject_CheckRefcnt((PyObject *)&_Py_STR(dot_locals));
_PyStaticObject_CheckRefcnt((PyObject *)&_Py_STR(empty));
+ _PyStaticObject_CheckRefcnt((PyObject *)&_Py_STR(format));
_PyStaticObject_CheckRefcnt((PyObject *)&_Py_STR(generic_base));
_PyStaticObject_CheckRefcnt((PyObject *)&_Py_STR(json_decoder));
_PyStaticObject_CheckRefcnt((PyObject *)&_Py_STR(kwdefaults));
_PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_abstract_));
_PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_active));
_PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_align_));
- _PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_annotation));
_PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_anonymous_));
_PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_argtypes_));
_PyStaticObject_CheckRefcnt((PyObject *)&_Py_ID(_as_parameter_));
STRUCT_FOR_STR(dot, ".")
STRUCT_FOR_STR(dot_locals, ".<locals>")
STRUCT_FOR_STR(empty, "")
+ STRUCT_FOR_STR(format, ".format")
STRUCT_FOR_STR(generic_base, ".generic_base")
STRUCT_FOR_STR(json_decoder, "json.decoder")
STRUCT_FOR_STR(kwdefaults, ".kwdefaults")
STRUCT_FOR_ID(_abstract_)
STRUCT_FOR_ID(_active)
STRUCT_FOR_ID(_align_)
- STRUCT_FOR_ID(_annotation)
STRUCT_FOR_ID(_anonymous_)
STRUCT_FOR_ID(_argtypes_)
STRUCT_FOR_ID(_as_parameter_)
#define MAKE_FUNCTION_KWDEFAULTS 0x02
#define MAKE_FUNCTION_ANNOTATIONS 0x04
#define MAKE_FUNCTION_CLOSURE 0x08
+#define MAKE_FUNCTION_ANNOTATE 0x10
/* Values used as the oparg for LOAD_COMMON_CONSTANT */
#define CONSTANT_ASSERTIONERROR 0
INIT_STR(dot, "."), \
INIT_STR(dot_locals, ".<locals>"), \
INIT_STR(empty, ""), \
+ INIT_STR(format, ".format"), \
INIT_STR(generic_base, ".generic_base"), \
INIT_STR(json_decoder, "json.decoder"), \
INIT_STR(kwdefaults, ".kwdefaults"), \
INIT_ID(_abstract_), \
INIT_ID(_active), \
INIT_ID(_align_), \
- INIT_ID(_annotation), \
INIT_ID(_anonymous_), \
INIT_ID(_argtypes_), \
INIT_ID(_as_parameter_), \
typedef enum _block_type {
FunctionBlock, ClassBlock, ModuleBlock,
- // Used for annotations if 'from __future__ import annotations' is active.
- // Annotation blocks cannot bind names and are not evaluated.
+ // Used for annotations. If 'from __future__ import annotations' is active,
+ // annotation blocks cannot bind names and are not evaluated. Otherwise, they
+ // are lazily evaluated (see PEP 649).
AnnotationBlock,
// Used for generics and type aliases. These work mostly like functions
// (see PEP 695 for details). The three different blocks function identically;
including free refs to globals */
unsigned ste_generator : 1; /* true if namespace is a generator */
unsigned ste_coroutine : 1; /* true if namespace is a coroutine */
+ unsigned ste_annotations_used : 1; /* true if there are any annotations in this scope */
_Py_comprehension_ty ste_comprehension; /* Kind of comprehension (if any) */
unsigned ste_varargs : 1; /* true if block has varargs */
unsigned ste_varkeywords : 1; /* true if block has varkeywords */
int ste_end_col_offset; /* end offset of first line of block */
int ste_opt_lineno; /* lineno of last exec or import * */
int ste_opt_col_offset; /* offset of last exec or import * */
+ struct _symtable_entry *ste_annotation_block; /* symbol table entry for this entry's annotations */
struct symtable *ste_table;
} PySTEntryObject;
PyObject *filename,
_PyFutureFeatures *future);
extern PySTEntryObject* _PySymtable_Lookup(struct symtable *, void *);
+extern int _PySymtable_LookupOptional(struct symtable *, void *, PySTEntryObject **);
extern void _PySymtable_Free(struct symtable *);
string = &_Py_ID(_align_);
assert(_PyUnicode_CheckConsistency(string, 1));
_PyUnicode_InternInPlace(interp, &string);
- string = &_Py_ID(_annotation);
- assert(_PyUnicode_CheckConsistency(string, 1));
- _PyUnicode_InternInPlace(interp, &string);
string = &_Py_ID(_anonymous_);
assert(_PyUnicode_CheckConsistency(string, 1));
_PyUnicode_InternInPlace(interp, &string);
"""
if isinstance(obj, type):
# class
- obj_dict = getattr(obj, '__dict__', None)
- if obj_dict and hasattr(obj_dict, 'get'):
- ann = obj_dict.get('__annotations__', None)
- if isinstance(ann, types.GetSetDescriptorType):
- ann = None
- else:
- ann = None
+ ann = obj.__annotations__
obj_globals = None
module_name = getattr(obj, '__module__', None)
if self.__methods is None:
d = {}
for st in self._table.children:
+ if st.type == _symtable.TYPE_ANNOTATION:
+ continue
d[st.name] = 1
self.__methods = tuple(d)
return self.__methods
dis_annot_stmt_str = """\
0 RESUME 0
- 2 SETUP_ANNOTATIONS
- LOAD_CONST 0 (1)
+ 2 LOAD_CONST 0 (1)
STORE_NAME 0 (x)
- LOAD_NAME 1 (int)
- LOAD_NAME 2 (__annotations__)
- LOAD_CONST 1 ('x')
- STORE_SUBSCR
-
- 3 LOAD_NAME 3 (fun)
- PUSH_NULL
- LOAD_CONST 0 (1)
- CALL 1
- LOAD_NAME 2 (__annotations__)
- LOAD_CONST 2 ('y')
- STORE_SUBSCR
4 LOAD_CONST 0 (1)
- LOAD_NAME 4 (lst)
- LOAD_NAME 3 (fun)
+ LOAD_NAME 1 (lst)
+ LOAD_NAME 2 (fun)
PUSH_NULL
- LOAD_CONST 3 (0)
+ LOAD_CONST 1 (0)
CALL 1
STORE_SUBSCR
- LOAD_NAME 1 (int)
- POP_TOP
- RETURN_CONST 4 (None)
+
+ 2 LOAD_CONST 2 (<code object __annotate__ at 0x..., file "<dis>", line 2>)
+ MAKE_FUNCTION
+ STORE_NAME 3 (__annotate__)
+ RETURN_CONST 3 (None)
"""
compound_stmt_str = """\
var_annot_global: int # a global annotated is necessary for test_var_annot
-# custom namespace for testing __annotations__
-
-class CNS:
- def __init__(self):
- self._dct = {}
- def __setitem__(self, item, value):
- self._dct[item.lower()] = value
- def __getitem__(self, item):
- return self._dct[item]
-
class GrammarTests(unittest.TestCase):
self.assertEqual(E.__annotations__, {})
self.assertEqual(F.__annotations__, {})
-
- def test_var_annot_metaclass_semantics(self):
- class CMeta(type):
- @classmethod
- def __prepare__(metacls, name, bases, **kwds):
- return {'__annotations__': CNS()}
- class CC(metaclass=CMeta):
- XX: 'ANNOT'
- self.assertEqual(CC.__annotations__['xx'], 'ANNOT')
-
def test_var_annot_module_semantics(self):
self.assertEqual(test.__annotations__, {})
self.assertEqual(ann_module.__annotations__,
- {1: 2, 'x': int, 'y': str, 'f': typing.Tuple[int, int], 'u': int | float})
+ {'x': int, 'y': str, 'f': typing.Tuple[int, int], 'u': int | float})
self.assertEqual(ann_module.M.__annotations__,
- {'123': 123, 'o': type})
+ {'o': type})
self.assertEqual(ann_module2.__annotations__, {})
def test_var_annot_in_module(self):
ann_module3.D_bad_ann(5)
def test_var_annot_simple_exec(self):
- gns = {}; lns= {}
+ gns = {}; lns = {}
exec("'docstring'\n"
- "__annotations__[1] = 2\n"
"x: int = 5\n", gns, lns)
- self.assertEqual(lns["__annotations__"], {1: 2, 'x': int})
- with self.assertRaises(KeyError):
- gns['__annotations__']
-
- def test_var_annot_custom_maps(self):
- # tests with custom locals() and __annotations__
- ns = {'__annotations__': CNS()}
- exec('X: int; Z: str = "Z"; (w): complex = 1j', ns)
- self.assertEqual(ns['__annotations__']['x'], int)
- self.assertEqual(ns['__annotations__']['z'], str)
+ self.assertEqual(lns["__annotate__"](1), {'x': int})
with self.assertRaises(KeyError):
- ns['__annotations__']['w']
- nonloc_ns = {}
- class CNS2:
- def __init__(self):
- self._dct = {}
- def __setitem__(self, item, value):
- nonlocal nonloc_ns
- self._dct[item] = value
- nonloc_ns[item] = value
- def __getitem__(self, item):
- return self._dct[item]
- exec('x: int = 1', {}, CNS2())
- self.assertEqual(nonloc_ns['__annotations__']['x'], int)
-
- def test_var_annot_refleak(self):
- # complex case: custom locals plus custom __annotations__
- # this was causing refleak
- cns = CNS()
- nonloc_ns = {'__annotations__': cns}
- class CNS2:
- def __init__(self):
- self._dct = {'__annotations__': cns}
- def __setitem__(self, item, value):
- nonlocal nonloc_ns
- self._dct[item] = value
- nonloc_ns[item] = value
- def __getitem__(self, item):
- return self._dct[item]
- exec('X: str', {}, CNS2())
- self.assertEqual(nonloc_ns['__annotations__']['x'], str)
+ gns['__annotate__']
def test_var_annot_rhs(self):
ns = {}
ann_module4 = import_helper.import_fresh_module(
'test.typinganndata.ann_module4',
)
+ self.assertFalse("__annotations__" in ann_module4.__dict__)
+ self.assertEqual(ann_module4.__annotations__, {"a": int, "b": str})
self.assertTrue("__annotations__" in ann_module4.__dict__)
del ann_module4.__annotations__
self.assertFalse("__annotations__" in ann_module4.__dict__)
def test_use_existing_annotations(self):
ns = {'__annotations__': {1: 2}}
exec('x: int', ns)
- self.assertEqual(ns['__annotations__'], {'x': int, 1: 2})
+ self.assertEqual(ns['__annotations__'], {1: 2})
def test_do_not_recreate_annotations(self):
# Don't rely on the existence of the '__annotations__' global.
with support.swap_item(globals(), '__annotations__', {}):
- del globals()['__annotations__']
+ globals().pop('__annotations__', None)
class C:
- del __annotations__
- with self.assertRaises(NameError):
- x: int
+ try:
+ del __annotations__
+ except NameError:
+ pass
+ x: int
+ self.assertEqual(C.__annotations__, {"x": int})
def test_raise_class_exceptions(self):
import dis
import pickle
+import types
import unittest
from test.support import check_syntax_error
# without constant folding we end up with
# COMPARE_OP(is), IS_OP (0)
# with constant folding we should expect a IS_OP (1)
- codes = [(i.opname, i.argval) for i in dis.get_instructions(g)]
+ code_obj = next(const for const in g.__code__.co_consts
+ if isinstance(const, types.CodeType) and const.co_name == "__annotate__")
+ codes = [(i.opname, i.argval) for i in dis.get_instructions(code_obj)]
self.assertNotIn(('UNARY_NOT', None), codes)
self.assertIn(('IS_OP', 1), codes)
actualMethods = []
for m in py_item.__dict__.keys():
+ if m == "__annotate__":
+ continue
if ismethod(py_item, getattr(py_item, m), m):
actualMethods.append(m)
foundMethods = []
| __weakref__%s
class B(builtins.object)
+ | Methods defined here:
+ |
+ | __annotate__(...)
+ |
+ | ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__%s
| Data and other attributes defined here:
|
| NO_MEANING = 'eggs'
- |
- | __annotations__ = {'NO_MEANING': <class 'str'>}
class C(builtins.object)
| Methods defined here:
list of weak references to the object
class B(builtins.object)
+ Methods defined here:
+ __annotate__(...)
+ ----------------------------------------------------------------------
Data descriptors defined here:
__dict__
dictionary for instance variables
----------------------------------------------------------------------
Data and other attributes defined here:
NO_MEANING = 'eggs'
- __annotations__ = {'NO_MEANING': <class 'str'>}
class C(builtins.object)
def test_no_active_future(self):
console = InteractiveColoredConsole()
- source = "x: int = 1; print(__annotations__)"
+ source = "x: int = 1; print(__annotate__(1))"
f = io.StringIO()
with contextlib.redirect_stdout(f):
result = console.runsource(source)
def test_annotated(self):
st1 = symtable.symtable('def f():\n x: int\n', 'test', 'exec')
- st2 = st1.get_children()[0]
+ st2 = st1.get_children()[1]
+ self.assertEqual(st2.get_type(), "function")
self.assertTrue(st2.lookup('x').is_local())
self.assertTrue(st2.lookup('x').is_annotated())
self.assertFalse(st2.lookup('x').is_global())
st3 = symtable.symtable('def f():\n x = 1\n', 'test', 'exec')
- st4 = st3.get_children()[0]
+ st4 = st3.get_children()[1]
+ self.assertEqual(st4.get_type(), "function")
self.assertTrue(st4.lookup('x').is_local())
self.assertFalse(st4.lookup('x').is_annotated())
def f_with_type():
def foo(a: THIS_DOES_NOT_EXIST ) -> int:
return 0
+ foo.__annotations__
lineno_f = f_with_type.__code__.co_firstlineno
expected_f = (
f' File "{__file__}", line {self.callable_line}, in get_exception\n'
' callable()\n'
' ~~~~~~~~^^\n'
- f' File "{__file__}", line {lineno_f+1}, in f_with_type\n'
+ f' File "{__file__}", line {lineno_f+3}, in f_with_type\n'
+ ' foo.__annotations__\n'
+ f' File "{__file__}", line {lineno_f+1}, in __annotate__\n'
' def foo(a: THIS_DOES_NOT_EXIST ) -> int:\n'
' ^^^^^^^^^^^^^^^^^^^\n'
)
import textwrap
import types
import unittest
-from test.support import run_code
+from test.support import run_code, check_syntax_error
+
+VALUE = 1
+FORWARDREF = 2
+SOURCE = 3
+
class TypeAnnotationTests(unittest.TestCase):
class C:
a:int=3
b:str=4
+ self.assertEqual(C.__annotations__, {"a": int, "b": str})
self.assertTrue("__annotations__" in C.__dict__)
del C.__annotations__
self.assertFalse("__annotations__" in C.__dict__)
self.assertEqual(D.__annotations__, {})
+def build_module(code: str, name: str = "top") -> types.ModuleType:
+ ns = run_code(code)
+ mod = types.ModuleType(name)
+ mod.__dict__.update(ns)
+ return mod
+
+
class TestSetupAnnotations(unittest.TestCase):
def check(self, code: str):
code = textwrap.dedent(code)
with self.subTest(scope=scope):
if scope == "class":
code = f"class C:\n{textwrap.indent(code, ' ')}"
- ns = run_code(code)
- if scope == "class":
+ ns = run_code(code)
annotations = ns["C"].__annotations__
else:
- annotations = ns["__annotations__"]
+ annotations = build_module(code).__annotations__
self.assertEqual(annotations, {"x": int})
def test_top_level(self):
# Setting f.__annotations__ also clears __annotate__
f.__annotations__ = {"z": 43}
self.assertIs(f.__annotate__, None)
+
+
+class DeferredEvaluationTests(unittest.TestCase):
+ def test_function(self):
+ def func(x: undefined, /, y: undefined, *args: undefined, z: undefined, **kwargs: undefined) -> undefined:
+ pass
+
+ with self.assertRaises(NameError):
+ func.__annotations__
+
+ undefined = 1
+ self.assertEqual(func.__annotations__, {
+ "x": 1,
+ "y": 1,
+ "args": 1,
+ "z": 1,
+ "kwargs": 1,
+ "return": 1,
+ })
+
+ def test_async_function(self):
+ async def func(x: undefined, /, y: undefined, *args: undefined, z: undefined, **kwargs: undefined) -> undefined:
+ pass
+
+ with self.assertRaises(NameError):
+ func.__annotations__
+
+ undefined = 1
+ self.assertEqual(func.__annotations__, {
+ "x": 1,
+ "y": 1,
+ "args": 1,
+ "z": 1,
+ "kwargs": 1,
+ "return": 1,
+ })
+
+ def test_class(self):
+ class X:
+ a: undefined
+
+ with self.assertRaises(NameError):
+ X.__annotations__
+
+ undefined = 1
+ self.assertEqual(X.__annotations__, {"a": 1})
+
+ def test_module(self):
+ ns = run_code("x: undefined = 1")
+ anno = ns["__annotate__"]
+ with self.assertRaises(NotImplementedError):
+ anno(2)
+
+ with self.assertRaises(NameError):
+ anno(1)
+
+ ns["undefined"] = 1
+ self.assertEqual(anno(1), {"x": 1})
+
+ def test_class_scoping(self):
+ class Outer:
+ def meth(self, x: Nested): ...
+ x: Nested
+ class Nested: ...
+
+ self.assertEqual(Outer.meth.__annotations__, {"x": Outer.Nested})
+ self.assertEqual(Outer.__annotations__, {"x": Outer.Nested})
+
+ def test_no_exotic_expressions(self):
+ check_syntax_error(self, "def func(x: (yield)): ...", "yield expression cannot be used within an annotation")
+ check_syntax_error(self, "def func(x: (yield from x)): ...", "yield expression cannot be used within an annotation")
+ check_syntax_error(self, "def func(x: (y := 3)): ...", "named expression cannot be used within an annotation")
+ check_syntax_error(self, "def func(x: (await 42)): ...", "await expression cannot be used within an annotation")
+
+ def test_no_exotic_expressions_in_unevaluated_annotations(self):
+ preludes = [
+ "",
+ "class X: ",
+ "def f(): ",
+ "async def f(): ",
+ ]
+ for prelude in preludes:
+ with self.subTest(prelude=prelude):
+ check_syntax_error(self, prelude + "(x): (yield)", "yield expression cannot be used within an annotation")
+ check_syntax_error(self, prelude + "(x): (yield from x)", "yield expression cannot be used within an annotation")
+ check_syntax_error(self, prelude + "(x): (y := 3)", "named expression cannot be used within an annotation")
+ check_syntax_error(self, prelude + "(x): (await 42)", "await expression cannot be used within an annotation")
+
+ def test_ignore_non_simple_annotations(self):
+ ns = run_code("class X: (y): int")
+ self.assertEqual(ns["X"].__annotations__, {})
+ ns = run_code("class X: int.b: int")
+ self.assertEqual(ns["X"].__annotations__, {})
+ ns = run_code("class X: int[str]: int")
+ self.assertEqual(ns["X"].__annotations__, {})
+
+ def test_generated_annotate(self):
+ def func(x: int):
+ pass
+ class X:
+ x: int
+ mod = build_module("x: int")
+ for obj in (func, X, mod):
+ with self.subTest(obj=obj):
+ annotate = obj.__annotate__
+ self.assertIsInstance(annotate, types.FunctionType)
+ self.assertEqual(annotate.__name__, "__annotate__")
+ with self.assertRaises(NotImplementedError):
+ annotate(FORWARDREF)
+ with self.assertRaises(NotImplementedError):
+ annotate(SOURCE)
+ with self.assertRaises(NotImplementedError):
+ annotate(None)
+ self.assertEqual(annotate(VALUE), {"x": int})
+
+ def test_comprehension_in_annotation(self):
+ # This crashed in an earlier version of the code
+ ns = run_code("x: [y for y in range(10)]")
+ self.assertEqual(ns["__annotate__"](1), {"x": list(range(10))})
+
+ def test_future_annotations(self):
+ code = """
+ from __future__ import annotations
+
+ def f(x: int) -> int: pass
+ """
+ ns = run_code(code)
+ f = ns["f"]
+ self.assertIsInstance(f.__annotate__, types.FunctionType)
+ annos = {"x": "int", "return": "int"}
+ self.assertEqual(f.__annotate__(VALUE), annos)
+ self.assertEqual(f.__annotations__, annos)
+
+ def test_name_clash_with_format(self):
+ # this test would fail if __annotate__'s parameter was called "format"
+ code = """
+ class format: pass
+
+ def f(x: format): pass
+ """
+ ns = run_code(code)
+ f = ns["f"]
+ self.assertEqual(f.__annotations__, {"x": ns["format"]})
gth(None)
def test_get_type_hints_modules(self):
- ann_module_type_hints = {1: 2, 'f': Tuple[int, int], 'x': int, 'y': str, 'u': int | float}
+ ann_module_type_hints = {'f': Tuple[int, int], 'x': int, 'y': str, 'u': int | float}
self.assertEqual(gth(ann_module), ann_module_type_hints)
self.assertEqual(gth(ann_module2), {})
self.assertEqual(gth(ann_module3), {})
self.assertEqual(gth(ann_module.C), # gth will find the right globalns
{'y': Optional[ann_module.C]})
self.assertIsInstance(gth(ann_module.j_class), dict)
- self.assertEqual(gth(ann_module.M), {'123': 123, 'o': type})
+ self.assertEqual(gth(ann_module.M), {'o': type})
self.assertEqual(gth(ann_module.D),
{'j': str, 'k': str, 'y': Optional[ann_module.C]})
self.assertEqual(gth(ann_module.Y), {'z': int})
from typing import Optional
from functools import wraps
-__annotations__[1] = 2
-
class C:
x = 5; y: Optional['C'] = None
x: int = 5; y: str = x; f: Tuple[int, int]
class M(type):
-
- __annotations__['123'] = 123
o: type = object
(pars): bool = True
base_globals = getattr(sys.modules.get(base.__module__, None), '__dict__', {})
else:
base_globals = globalns
- ann = base.__dict__.get('__annotations__', {})
+ ann = getattr(base, '__annotations__', {})
if isinstance(ann, types.GetSetDescriptorType):
ann = {}
base_locals = dict(vars(base)) if localns is None else localns
raise TypeError(
'can only inherit from a NamedTuple type and Generic')
bases = tuple(tuple if base is _NamedTuple else base for base in bases)
- types = ns.get('__annotations__', {})
+ if "__annotations__" in ns:
+ types = ns["__annotations__"]
+ elif "__annotate__" in ns:
+ types = ns["__annotate__"](1) # VALUE
+ else:
+ types = {}
default_names = []
for field_name in types:
if field_name in ns:
tp_dict.__orig_bases__ = bases
annotations = {}
- own_annotations = ns.get('__annotations__', {})
+ if "__annotations__" in ns:
+ own_annotations = ns["__annotations__"]
+ elif "__annotate__" in ns:
+ own_annotations = ns["__annotate__"](1) # VALUE
+ else:
+ own_annotations = {}
msg = "TypedDict('Name', {f0: t0, f1: t1, ...}); each t must be a type"
own_annotations = {
n: _type_check(tp, msg, module=tp_dict.__module__)
mutable_keys = set()
for base in bases:
- annotations.update(base.__dict__.get('__annotations__', {}))
+ # TODO: Avoid eagerly evaluating annotations in VALUE format.
+ # Instead, evaluate in FORWARDREF format to figure out which
+ # keys have Required/NotRequired/ReadOnly qualifiers, and create
+ # a new __annotate__ function for the resulting TypedDict that
+ # combines the annotations from this class and its parents.
+ annotations.update(base.__annotations__)
base_required = base.__dict__.get('__required_keys__', set())
required_keys |= base_required
--- /dev/null
+Evaluation of annotations is now deferred. See :pep:`649` for details.
assert(func_obj->func_defaults == NULL);
func_obj->func_defaults = attr;
break;
+ case MAKE_FUNCTION_ANNOTATE:
+ assert(PyCallable_Check(attr));
+ assert(func_obj->func_annotate == NULL);
+ func_obj->func_annotate = attr;
+ break;
default:
Py_UNREACHABLE();
}
COMPILER_SCOPE_ASYNC_FUNCTION,
COMPILER_SCOPE_LAMBDA,
COMPILER_SCOPE_COMPREHENSION,
- COMPILER_SCOPE_TYPEPARAMS,
+ COMPILER_SCOPE_ANNOTATIONS,
};
#define INITIAL_INSTR_SEQUENCE_SIZE 100
#define INITIAL_INSTR_SEQUENCE_LABELS_MAP_SIZE 10
+static const int compare_masks[] = {
+ [Py_LT] = COMPARISON_LESS_THAN,
+ [Py_LE] = COMPARISON_LESS_THAN | COMPARISON_EQUALS,
+ [Py_EQ] = COMPARISON_EQUALS,
+ [Py_NE] = COMPARISON_NOT_EQUALS,
+ [Py_GT] = COMPARISON_GREATER_THAN,
+ [Py_GE] = COMPARISON_GREATER_THAN | COMPARISON_EQUALS,
+};
+
/*
* Resize the array if index is out of range.
*
PyObject *u_private; /* for private name mangling */
PyObject *u_static_attributes; /* for class: attributes accessed via self.X */
+ PyObject *u_deferred_annotations; /* AnnAssign nodes deferred to the end of compilation */
instr_sequence *u_instr_sequence; /* codegen output */
static int compiler_match(struct compiler *, stmt_ty);
static int compiler_pattern_subpattern(struct compiler *,
pattern_ty, pattern_context *);
+static int compiler_make_closure(struct compiler *c, location loc,
+ PyCodeObject *co, Py_ssize_t flags);
static PyCodeObject *optimize_and_assemble(struct compiler *, int addNone);
Py_CLEAR(u->u_metadata.u_fasthidden);
Py_CLEAR(u->u_private);
Py_CLEAR(u->u_static_attributes);
+ Py_CLEAR(u->u_deferred_annotations);
PyMem_Free(u);
}
capsule = PyList_GET_ITEM(c->c_stack, stack_size - 1);
parent = (struct compiler_unit *)PyCapsule_GetPointer(capsule, CAPSULE_NAME);
assert(parent);
- if (parent->u_scope_type == COMPILER_SCOPE_TYPEPARAMS) {
- /* The parent is a type parameter scope, so we need to
+ if (parent->u_scope_type == COMPILER_SCOPE_ANNOTATIONS) {
+ /* The parent is an annotation scope, so we need to
look at the grandparent. */
if (stack_size == 2) {
// If we're immediately within the module, we can skip
}
u->u_private = NULL;
+ u->u_deferred_annotations = NULL;
if (scope_type == COMPILER_SCOPE_CLASS) {
u->u_static_attributes = PySet_New(0);
if (!u->u_static_attributes) {
PyErr_SetRaisedException(exc);
}
-/* Search if variable annotations are present statically in a block. */
-
-static bool
-find_ann(asdl_stmt_seq *stmts)
-{
- int i, j, res = 0;
- stmt_ty st;
-
- for (i = 0; i < asdl_seq_LEN(stmts); i++) {
- st = (stmt_ty)asdl_seq_GET(stmts, i);
- switch (st->kind) {
- case AnnAssign_kind:
- return true;
- case For_kind:
- res = find_ann(st->v.For.body) ||
- find_ann(st->v.For.orelse);
- break;
- case AsyncFor_kind:
- res = find_ann(st->v.AsyncFor.body) ||
- find_ann(st->v.AsyncFor.orelse);
- break;
- case While_kind:
- res = find_ann(st->v.While.body) ||
- find_ann(st->v.While.orelse);
- break;
- case If_kind:
- res = find_ann(st->v.If.body) ||
- find_ann(st->v.If.orelse);
- break;
- case With_kind:
- res = find_ann(st->v.With.body);
- break;
- case AsyncWith_kind:
- res = find_ann(st->v.AsyncWith.body);
- break;
- case Try_kind:
- for (j = 0; j < asdl_seq_LEN(st->v.Try.handlers); j++) {
- excepthandler_ty handler = (excepthandler_ty)asdl_seq_GET(
- st->v.Try.handlers, j);
- if (find_ann(handler->v.ExceptHandler.body)) {
- return true;
- }
- }
- res = find_ann(st->v.Try.body) ||
- find_ann(st->v.Try.finalbody) ||
- find_ann(st->v.Try.orelse);
- break;
- case TryStar_kind:
- for (j = 0; j < asdl_seq_LEN(st->v.TryStar.handlers); j++) {
- excepthandler_ty handler = (excepthandler_ty)asdl_seq_GET(
- st->v.TryStar.handlers, j);
- if (find_ann(handler->v.ExceptHandler.body)) {
- return true;
- }
- }
- res = find_ann(st->v.TryStar.body) ||
- find_ann(st->v.TryStar.finalbody) ||
- find_ann(st->v.TryStar.orelse);
- break;
- case Match_kind:
- for (j = 0; j < asdl_seq_LEN(st->v.Match.cases); j++) {
- match_case_ty match_case = (match_case_ty)asdl_seq_GET(
- st->v.Match.cases, j);
- if (find_ann(match_case->body)) {
- return true;
- }
- }
- break;
- default:
- res = false;
- break;
- }
- if (res) {
- break;
- }
- }
- return res;
-}
-
/*
* Frame block handling functions
*/
return SUCCESS;
}
+static int
+compiler_setup_annotations_scope(struct compiler *c, location loc,
+ void *key, PyObject *name)
+{
+ if (compiler_enter_scope(c, name, COMPILER_SCOPE_ANNOTATIONS,
+ key, loc.lineno) == -1) {
+ return ERROR;
+ }
+ c->u->u_metadata.u_posonlyargcount = 1;
+ // if .format != 1: raise NotImplementedError
+ _Py_DECLARE_STR(format, ".format");
+ ADDOP_I(c, loc, LOAD_FAST, 0);
+ ADDOP_LOAD_CONST(c, loc, _PyLong_GetOne());
+ ADDOP_I(c, loc, COMPARE_OP, (Py_NE << 5) | compare_masks[Py_NE]);
+ NEW_JUMP_TARGET_LABEL(c, body);
+ ADDOP_JUMP(c, loc, POP_JUMP_IF_FALSE, body);
+ ADDOP_I(c, loc, LOAD_COMMON_CONSTANT, CONSTANT_NOTIMPLEMENTEDERROR);
+ ADDOP_I(c, loc, RAISE_VARARGS, 1);
+ USE_LABEL(c, body);
+ return 0;
+}
+
+static int
+compiler_leave_annotations_scope(struct compiler *c, location loc,
+ Py_ssize_t annotations_len)
+{
+ ADDOP_I(c, loc, BUILD_MAP, annotations_len);
+ ADDOP_IN_SCOPE(c, loc, RETURN_VALUE);
+ PyCodeObject *co = optimize_and_assemble(c, 1);
+ compiler_exit_scope(c);
+ if (co == NULL) {
+ return ERROR;
+ }
+ if (compiler_make_closure(c, loc, co, 0) < 0) {
+ Py_DECREF(co);
+ return ERROR;
+ }
+ Py_DECREF(co);
+ return 0;
+}
+
/* Compile a sequence of statements, checking for a docstring
and for annotations. */
stmt_ty st = (stmt_ty)asdl_seq_GET(stmts, 0);
loc = LOC(st);
}
- /* Every annotated class and module should have __annotations__. */
- if (find_ann(stmts)) {
+ /* If from __future__ import annotations is active,
+ * every annotated class and module should have __annotations__.
+ * Else __annotate__ is created when necessary. */
+ if ((c->c_future.ff_features & CO_FUTURE_ANNOTATIONS) && c->u->u_ste->ste_annotations_used) {
ADDOP(c, loc, SETUP_ANNOTATIONS);
}
if (!asdl_seq_LEN(stmts)) {
return SUCCESS;
}
Py_ssize_t first_instr = 0;
- PyObject *docstring = _PyAST_GetDocString(stmts);
- if (docstring) {
- first_instr = 1;
- /* if not -OO mode, set docstring */
- if (c->c_optimize < 2) {
- PyObject *cleandoc = _PyCompile_CleanDoc(docstring);
- if (cleandoc == NULL) {
- return ERROR;
+ if (!c->c_interactive) {
+ PyObject *docstring = _PyAST_GetDocString(stmts);
+ if (docstring) {
+ first_instr = 1;
+ /* if not -OO mode, set docstring */
+ if (c->c_optimize < 2) {
+ PyObject *cleandoc = _PyCompile_CleanDoc(docstring);
+ if (cleandoc == NULL) {
+ return ERROR;
+ }
+ stmt_ty st = (stmt_ty)asdl_seq_GET(stmts, 0);
+ assert(st->kind == Expr_kind);
+ location loc = LOC(st->v.Expr.value);
+ ADDOP_LOAD_CONST(c, loc, cleandoc);
+ Py_DECREF(cleandoc);
+ RETURN_IF_ERROR(compiler_nameop(c, NO_LOCATION, &_Py_ID(__doc__), Store));
}
- stmt_ty st = (stmt_ty)asdl_seq_GET(stmts, 0);
- assert(st->kind == Expr_kind);
- location loc = LOC(st->v.Expr.value);
- ADDOP_LOAD_CONST(c, loc, cleandoc);
- Py_DECREF(cleandoc);
- RETURN_IF_ERROR(compiler_nameop(c, NO_LOCATION, &_Py_ID(__doc__), Store));
}
}
for (Py_ssize_t i = first_instr; i < asdl_seq_LEN(stmts); i++) {
VISIT(c, stmt, (stmt_ty)asdl_seq_GET(stmts, i));
}
+ // If there are annotations and the future import is not on, we
+ // collect the annotations in a separate pass and generate an
+ // __annotate__ function. See PEP 649.
+ if (!(c->c_future.ff_features & CO_FUTURE_ANNOTATIONS) &&
+ c->u->u_deferred_annotations != NULL) {
+
+ // It's possible that ste_annotations_block is set but
+ // u_deferred_annotations is not, because the former is still
+ // set if there are only non-simple annotations (i.e., annotations
+ // for attributes, subscripts, or parenthesized names). However, the
+ // reverse should not be possible.
+ assert(c->u->u_ste->ste_annotation_block != NULL);
+ PyObject *deferred_anno = Py_NewRef(c->u->u_deferred_annotations);
+ void *key = (void *)((uintptr_t)c->u->u_ste->ste_id + 1);
+ if (compiler_setup_annotations_scope(c, loc, key,
+ c->u->u_ste->ste_annotation_block->ste_name) == -1) {
+ Py_DECREF(deferred_anno);
+ return ERROR;
+ }
+ Py_ssize_t annotations_len = PyList_Size(deferred_anno);
+ for (Py_ssize_t i = 0; i < annotations_len; i++) {
+ PyObject *ptr = PyList_GET_ITEM(deferred_anno, i);
+ stmt_ty st = (stmt_ty)PyLong_AsVoidPtr(ptr);
+ if (st == NULL) {
+ compiler_exit_scope(c);
+ Py_DECREF(deferred_anno);
+ return ERROR;
+ }
+ PyObject *mangled = _Py_Mangle(c->u->u_private, st->v.AnnAssign.target->v.Name.id);
+ ADDOP_LOAD_CONST_NEW(c, LOC(st), mangled);
+ VISIT(c, expr, st->v.AnnAssign.annotation);
+ }
+ Py_DECREF(deferred_anno);
+
+ RETURN_IF_ERROR(
+ compiler_leave_annotations_scope(c, loc, annotations_len)
+ );
+ RETURN_IF_ERROR(
+ compiler_nameop(c, loc, &_Py_ID(__annotate__), Store)
+ );
+ }
return SUCCESS;
}
}
break;
case Interactive_kind:
- if (find_ann(mod->v.Interactive.body)) {
- ADDOP(c, loc, SETUP_ANNOTATIONS);
- }
c->c_interactive = 1;
- VISIT_SEQ(c, stmt, mod->v.Interactive.body);
+ if (compiler_body(c, loc, mod->v.Interactive.body) < 0) {
+ return ERROR;
+ }
break;
case Expression_kind:
VISIT(c, expr, mod->v.Expression.body);
if (flags & MAKE_FUNCTION_ANNOTATIONS) {
ADDOP_I(c, loc, SET_FUNCTION_ATTRIBUTE, MAKE_FUNCTION_ANNOTATIONS);
}
+ if (flags & MAKE_FUNCTION_ANNOTATE) {
+ ADDOP_I(c, loc, SET_FUNCTION_ATTRIBUTE, MAKE_FUNCTION_ANNOTATE);
+ }
if (flags & MAKE_FUNCTION_KWDEFAULTS) {
ADDOP_I(c, loc, SET_FUNCTION_ATTRIBUTE, MAKE_FUNCTION_KWDEFAULTS);
}
VISIT(c, expr, annotation);
}
}
- *annotations_len += 2;
+ *annotations_len += 1;
return SUCCESS;
}
}
static int
-compiler_visit_annotations(struct compiler *c, location loc,
- arguments_ty args, expr_ty returns)
+compiler_visit_annotations_in_scope(struct compiler *c, location loc,
+ arguments_ty args, expr_ty returns,
+ Py_ssize_t *annotations_len)
{
- /* Push arg annotation names and values.
- The expressions are evaluated out-of-order wrt the source code.
-
- Return -1 on error, 0 if no annotations pushed, 1 if a annotations is pushed.
- */
- Py_ssize_t annotations_len = 0;
-
RETURN_IF_ERROR(
- compiler_visit_argannotations(c, args->args, &annotations_len, loc));
+ compiler_visit_argannotations(c, args->args, annotations_len, loc));
RETURN_IF_ERROR(
- compiler_visit_argannotations(c, args->posonlyargs, &annotations_len, loc));
+ compiler_visit_argannotations(c, args->posonlyargs, annotations_len, loc));
if (args->vararg && args->vararg->annotation) {
RETURN_IF_ERROR(
compiler_visit_argannotation(c, args->vararg->arg,
- args->vararg->annotation, &annotations_len, loc));
+ args->vararg->annotation, annotations_len, loc));
}
RETURN_IF_ERROR(
- compiler_visit_argannotations(c, args->kwonlyargs, &annotations_len, loc));
+ compiler_visit_argannotations(c, args->kwonlyargs, annotations_len, loc));
if (args->kwarg && args->kwarg->annotation) {
RETURN_IF_ERROR(
compiler_visit_argannotation(c, args->kwarg->arg,
- args->kwarg->annotation, &annotations_len, loc));
+ args->kwarg->annotation, annotations_len, loc));
}
RETURN_IF_ERROR(
- compiler_visit_argannotation(c, &_Py_ID(return), returns, &annotations_len, loc));
+ compiler_visit_argannotation(c, &_Py_ID(return), returns, annotations_len, loc));
- if (annotations_len) {
- ADDOP_I(c, loc, BUILD_TUPLE, annotations_len);
- return 1;
+ return 0;
+}
+
+static int
+compiler_visit_annotations(struct compiler *c, location loc,
+ arguments_ty args, expr_ty returns)
+{
+ /* Push arg annotation names and values.
+ The expressions are evaluated separately from the rest of the source code.
+
+ Return -1 on error, or a combination of flags to add to the function.
+ */
+ Py_ssize_t annotations_len = 0;
+
+ PySTEntryObject *ste;
+ if (_PySymtable_LookupOptional(c->c_st, args, &ste) < 0) {
+ return ERROR;
+ }
+ assert(ste != NULL);
+ bool annotations_used = ste->ste_annotations_used;
+
+ if (annotations_used) {
+ if (compiler_setup_annotations_scope(c, loc, (void *)args,
+ ste->ste_name) < 0) {
+ Py_DECREF(ste);
+ return ERROR;
+ }
+ }
+ Py_DECREF(ste);
+
+ if (compiler_visit_annotations_in_scope(c, loc, args, returns, &annotations_len) < 0) {
+ if (annotations_used) {
+ compiler_exit_scope(c);
+ }
+ return ERROR;
+ }
+
+ if (annotations_used) {
+ RETURN_IF_ERROR(
+ compiler_leave_annotations_scope(c, loc, annotations_len)
+ );
+ return MAKE_FUNCTION_ANNOTATE;
}
return 0;
identifier name, void *key,
bool allow_starred)
{
- if (compiler_enter_scope(c, name, COMPILER_SCOPE_TYPEPARAMS,
+ if (compiler_enter_scope(c, name, COMPILER_SCOPE_ANNOTATIONS,
key, e->lineno) == -1) {
return ERROR;
}
asdl_expr_seq *decos;
asdl_type_param_seq *type_params;
Py_ssize_t funcflags;
- int annotations;
int firstlineno;
if (is_async) {
if (!type_params_name) {
return ERROR;
}
- if (compiler_enter_scope(c, type_params_name, COMPILER_SCOPE_TYPEPARAMS,
+ if (compiler_enter_scope(c, type_params_name, COMPILER_SCOPE_ANNOTATIONS,
(void *)type_params, firstlineno) == -1) {
Py_DECREF(type_params_name);
return ERROR;
}
}
- annotations = compiler_visit_annotations(c, loc, args, returns);
- if (annotations < 0) {
+ int annotations_flag = compiler_visit_annotations(c, loc, args, returns);
+ if (annotations_flag < 0) {
if (is_generic) {
compiler_exit_scope(c);
}
return ERROR;
}
- if (annotations > 0) {
- funcflags |= MAKE_FUNCTION_ANNOTATIONS;
- }
+ funcflags |= annotations_flag;
if (compiler_function_body(c, s, is_async, funcflags, firstlineno) < 0) {
if (is_generic) {
if (!type_params_name) {
return ERROR;
}
- if (compiler_enter_scope(c, type_params_name, COMPILER_SCOPE_TYPEPARAMS,
+ if (compiler_enter_scope(c, type_params_name, COMPILER_SCOPE_ANNOTATIONS,
(void *)type_params, firstlineno) == -1) {
Py_DECREF(type_params_name);
return ERROR;
if (!type_params_name) {
return ERROR;
}
- if (compiler_enter_scope(c, type_params_name, COMPILER_SCOPE_TYPEPARAMS,
+ if (compiler_enter_scope(c, type_params_name, COMPILER_SCOPE_ANNOTATIONS,
(void *)type_params, loc.lineno) == -1) {
Py_DECREF(type_params_name);
return ERROR;
return SUCCESS;
}
-static const int compare_masks[] = {
- [Py_LT] = COMPARISON_LESS_THAN,
- [Py_LE] = COMPARISON_LESS_THAN | COMPARISON_EQUALS,
- [Py_EQ] = COMPARISON_EQUALS,
- [Py_NE] = COMPARISON_NOT_EQUALS,
- [Py_GT] = COMPARISON_GREATER_THAN,
- [Py_GE] = COMPARISON_GREATER_THAN | COMPARISON_EQUALS,
-};
-
static int compiler_addcompare(struct compiler *c, location loc,
cmpop_ty op)
{
{
location loc = LOC(s);
expr_ty targ = s->v.AnnAssign.target;
- PyObject* mangled;
+ bool future_annotations = c->c_future.ff_features & CO_FUTURE_ANNOTATIONS;
+ PyObject *mangled;
assert(s->kind == AnnAssign_kind);
if (s->v.AnnAssign.simple &&
(c->u->u_scope_type == COMPILER_SCOPE_MODULE ||
c->u->u_scope_type == COMPILER_SCOPE_CLASS)) {
- if (c->c_future.ff_features & CO_FUTURE_ANNOTATIONS) {
- VISIT(c, annexpr, s->v.AnnAssign.annotation)
+ if (future_annotations) {
+ VISIT(c, annexpr, s->v.AnnAssign.annotation);
+ ADDOP_NAME(c, loc, LOAD_NAME, &_Py_ID(__annotations__), names);
+ mangled = _Py_MaybeMangle(c->u->u_private, c->u->u_ste, targ->v.Name.id);
+ ADDOP_LOAD_CONST_NEW(c, loc, mangled);
+ ADDOP(c, loc, STORE_SUBSCR);
}
else {
- VISIT(c, expr, s->v.AnnAssign.annotation);
+ if (c->u->u_deferred_annotations == NULL) {
+ c->u->u_deferred_annotations = PyList_New(0);
+ if (c->u->u_deferred_annotations == NULL) {
+ return ERROR;
+ }
+ }
+ PyObject *ptr = PyLong_FromVoidPtr((void *)s);
+ if (ptr == NULL) {
+ return ERROR;
+ }
+ if (PyList_Append(c->u->u_deferred_annotations, ptr) < 0) {
+ Py_DECREF(ptr);
+ return ERROR;
+ }
+ Py_DECREF(ptr);
}
- ADDOP_NAME(c, loc, LOAD_NAME, &_Py_ID(__annotations__), names);
- mangled = _Py_MaybeMangle(c->u->u_private, c->u->u_ste, targ->v.Name.id);
- ADDOP_LOAD_CONST_NEW(c, loc, mangled);
- ADDOP(c, loc, STORE_SUBSCR);
}
break;
case Attribute_kind:
return ERROR;
}
/* Annotation is evaluated last. */
- if (!s->v.AnnAssign.simple && check_annotation(c, s) < 0) {
+ if (future_annotations && !s->v.AnnAssign.simple && check_annotation(c, s) < 0) {
return ERROR;
}
return SUCCESS;
assert(func_obj->func_defaults == NULL);
func_obj->func_defaults = attr;
break;
+ case MAKE_FUNCTION_ANNOTATE:
+ assert(PyCallable_Check(attr));
+ assert(func_obj->func_annotate == NULL);
+ func_obj->func_annotate = attr;
+ break;
default:
Py_UNREACHABLE();
}
assert(func_obj->func_defaults == NULL);
func_obj->func_defaults = attr;
break;
+ case MAKE_FUNCTION_ANNOTATE:
+ assert(PyCallable_Check(attr));
+ assert(func_obj->func_annotate == NULL);
+ func_obj->func_annotate = attr;
+ break;
default:
Py_UNREACHABLE();
}
ste->ste_varkeywords = 0;
ste->ste_opt_lineno = 0;
ste->ste_opt_col_offset = 0;
+ ste->ste_annotations_used = 0;
ste->ste_lineno = lineno;
ste->ste_col_offset = col_offset;
ste->ste_end_lineno = end_lineno;
ste->ste_can_see_class_scope = 0;
ste->ste_comp_iter_expr = 0;
ste->ste_needs_classdict = 0;
+ ste->ste_annotation_block = NULL;
ste->ste_symbols = PyDict_New();
ste->ste_varnames = PyList_New(0);
Py_XDECREF(ste->ste_varnames);
Py_XDECREF(ste->ste_children);
Py_XDECREF(ste->ste_directives);
+ Py_XDECREF(ste->ste_annotation_block);
Py_XDECREF(ste->ste_mangled_names);
PyObject_Free(ste);
}
static int symtable_visit_comprehension(struct symtable *st, comprehension_ty);
static int symtable_visit_keyword(struct symtable *st, keyword_ty);
static int symtable_visit_params(struct symtable *st, asdl_arg_seq *args);
-static int symtable_visit_annotation(struct symtable *st, expr_ty annotation);
+static int symtable_visit_annotation(struct symtable *st, expr_ty annotation, void *key);
static int symtable_visit_argannotations(struct symtable *st, asdl_arg_seq *args);
static int symtable_implicit_arg(struct symtable *st, int pos);
-static int symtable_visit_annotations(struct symtable *st, stmt_ty, arguments_ty, expr_ty);
+static int symtable_visit_annotations(struct symtable *st, stmt_ty, arguments_ty, expr_ty,
+ struct _symtable_entry *parent_ste);
static int symtable_visit_withitem(struct symtable *st, withitem_ty item);
static int symtable_visit_match_case(struct symtable *st, match_case_ty m);
static int symtable_visit_pattern(struct symtable *st, pattern_ty s);
return (PySTEntryObject *)v;
}
+int
+_PySymtable_LookupOptional(struct symtable *st, void *key,
+ PySTEntryObject **out)
+{
+ PyObject *k = PyLong_FromVoidPtr(key);
+ if (k == NULL) {
+ *out = NULL;
+ return -1;
+ }
+ int result = PyDict_GetItemRef(st->st_blocks, k, (PyObject **)out);
+ Py_DECREF(k);
+ assert(*out == NULL || PySTEntry_Check(*out));
+ return result;
+}
+
long
_PyST_GetSymbol(PySTEntryObject *ste, PyObject *name)
{
_PyST_IsFunctionLike(PySTEntryObject *ste)
{
return ste->ste_type == FunctionBlock
+ || ste->ste_type == AnnotationBlock
|| ste->ste_type == TypeVarBoundBlock
|| ste->ste_type == TypeAliasBlock
|| ste->ste_type == TypeParamBlock;
}
static int
-symtable_enter_block(struct symtable *st, identifier name, _Py_block_ty block,
- void *ast, int lineno, int col_offset,
- int end_lineno, int end_col_offset)
+symtable_enter_existing_block(struct symtable *st, PySTEntryObject* ste)
{
- PySTEntryObject *prev = NULL, *ste;
-
- ste = ste_new(st, name, block, ast, lineno, col_offset, end_lineno, end_col_offset);
- if (ste == NULL)
- return 0;
if (PyList_Append(st->st_stack, (PyObject *)ste) < 0) {
- Py_DECREF(ste);
return 0;
}
- prev = st->st_cur;
+ PySTEntryObject *prev = st->st_cur;
/* bpo-37757: For now, disallow *all* assignment expressions in the
* outermost iterator expression of a comprehension, even those inside
* a nested comprehension or a lambda expression.
}
/* No need to inherit ste_mangled_names in classes, where all names
* are mangled. */
- if (prev && prev->ste_mangled_names != NULL && block != ClassBlock) {
+ if (prev && prev->ste_mangled_names != NULL && ste->ste_type != ClassBlock) {
ste->ste_mangled_names = Py_NewRef(prev->ste_mangled_names);
}
/* The entry is owned by the stack. Borrow it for st_cur. */
- Py_DECREF(ste);
st->st_cur = ste;
- /* Annotation blocks shouldn't have any affect on the symbol table since in
- * the compilation stage, they will all be transformed to strings. They are
- * only created if future 'annotations' feature is activated. */
- if (block == AnnotationBlock) {
+ /* If "from __future__ import annotations" is active,
+ * annotation blocks shouldn't have any affect on the symbol table since in
+ * the compilation stage, they will all be transformed to strings. */
+ if (st->st_future->ff_features & CO_FUTURE_ANNOTATIONS && ste->ste_type == AnnotationBlock) {
return 1;
}
- if (block == ModuleBlock)
+ if (ste->ste_type == ModuleBlock)
st->st_global = st->st_cur->ste_symbols;
if (prev) {
return 1;
}
+static int
+symtable_enter_block(struct symtable *st, identifier name, _Py_block_ty block,
+ void *ast, int lineno, int col_offset,
+ int end_lineno, int end_col_offset)
+{
+ PySTEntryObject *ste = ste_new(st, name, block, ast,
+ lineno, col_offset, end_lineno, end_col_offset);
+ if (ste == NULL)
+ return 0;
+ int result = symtable_enter_existing_block(st, ste);
+ Py_DECREF(ste);
+ return result;
+}
+
static long
symtable_lookup_entry(struct symtable *st, PySTEntryObject *ste, PyObject *name)
{
VISIT_QUIT(st, 0);
}
switch (s->kind) {
- case FunctionDef_kind:
+ case FunctionDef_kind: {
if (!symtable_add_def(st, s->v.FunctionDef.name, DEF_LOCAL, LOCATION(s)))
VISIT_QUIT(st, 0);
if (s->v.FunctionDef.args->defaults)
}
VISIT_SEQ(st, type_param, s->v.FunctionDef.type_params);
}
+ PySTEntryObject *new_ste = ste_new(st, s->v.FunctionDef.name, FunctionBlock, (void *)s,
+ LOCATION(s));
+ if (!new_ste) {
+ VISIT_QUIT(st, 0);
+ }
+
if (!symtable_visit_annotations(st, s, s->v.FunctionDef.args,
- s->v.FunctionDef.returns))
+ s->v.FunctionDef.returns, new_ste)) {
+ Py_DECREF(new_ste);
VISIT_QUIT(st, 0);
- if (!symtable_enter_block(st, s->v.FunctionDef.name,
- FunctionBlock, (void *)s,
- LOCATION(s)))
+ }
+ if (!symtable_enter_existing_block(st, new_ste)) {
+ Py_DECREF(new_ste);
VISIT_QUIT(st, 0);
+ }
+ Py_DECREF(new_ste);
VISIT(st, arguments, s->v.FunctionDef.args);
VISIT_SEQ(st, stmt, s->v.FunctionDef.body);
if (!symtable_exit_block(st))
VISIT_QUIT(st, 0);
}
break;
+ }
case ClassDef_kind: {
PyObject *tmp;
if (!symtable_add_def(st, s->v.ClassDef.name, DEF_LOCAL, LOCATION(s)))
VISIT(st, expr, s->v.Assign.value);
break;
case AnnAssign_kind:
+ st->st_cur->ste_annotations_used = 1;
if (s->v.AnnAssign.target->kind == Name_kind) {
expr_ty e_name = s->v.AnnAssign.target;
long cur = symtable_lookup(st, e_name->v.Name.id);
else {
VISIT(st, expr, s->v.AnnAssign.target);
}
- if (!symtable_visit_annotation(st, s->v.AnnAssign.annotation)) {
+ if (!symtable_visit_annotation(st, s->v.AnnAssign.annotation,
+ (void *)((uintptr_t)st->st_cur->ste_id + 1))) {
VISIT_QUIT(st, 0);
}
VISIT_SEQ(st, withitem, s->v.With.items);
VISIT_SEQ(st, stmt, s->v.With.body);
break;
- case AsyncFunctionDef_kind:
+ case AsyncFunctionDef_kind: {
if (!symtable_add_def(st, s->v.AsyncFunctionDef.name, DEF_LOCAL, LOCATION(s)))
VISIT_QUIT(st, 0);
if (s->v.AsyncFunctionDef.args->defaults)
}
VISIT_SEQ(st, type_param, s->v.AsyncFunctionDef.type_params);
}
+ PySTEntryObject *new_ste = ste_new(st, s->v.FunctionDef.name, FunctionBlock, (void *)s,
+ LOCATION(s));
+ if (!new_ste) {
+ VISIT_QUIT(st, 0);
+ }
+
if (!symtable_visit_annotations(st, s, s->v.AsyncFunctionDef.args,
- s->v.AsyncFunctionDef.returns))
+ s->v.AsyncFunctionDef.returns, new_ste))
VISIT_QUIT(st, 0);
- if (!symtable_enter_block(st, s->v.AsyncFunctionDef.name,
- FunctionBlock, (void *)s,
- s->lineno, s->col_offset,
- s->end_lineno, s->end_col_offset))
+ if (!symtable_enter_existing_block(st, new_ste)) {
+ Py_DECREF(new_ste);
VISIT_QUIT(st, 0);
+ }
+ Py_DECREF(new_ste);
+
st->st_cur->ste_coroutine = 1;
VISIT(st, arguments, s->v.AsyncFunctionDef.args);
VISIT_SEQ(st, stmt, s->v.AsyncFunctionDef.body);
VISIT_QUIT(st, 0);
}
break;
+ }
case AsyncWith_kind:
VISIT_SEQ(st, withitem, s->v.AsyncWith.items);
VISIT_SEQ(st, stmt, s->v.AsyncWith.body);
}
static int
-symtable_visit_annotation(struct symtable *st, expr_ty annotation)
+symtable_visit_annotation(struct symtable *st, expr_ty annotation, void *key)
{
- int future_annotations = st->st_future->ff_features & CO_FUTURE_ANNOTATIONS;
- if (future_annotations &&
- !symtable_enter_block(st, &_Py_ID(_annotation), AnnotationBlock,
- (void *)annotation, annotation->lineno,
- annotation->col_offset, annotation->end_lineno,
- annotation->end_col_offset)) {
- VISIT_QUIT(st, 0);
+ struct _symtable_entry *parent_ste = st->st_cur;
+ if (parent_ste->ste_annotation_block == NULL) {
+ _Py_block_ty current_type = parent_ste->ste_type;
+ if (!symtable_enter_block(st, &_Py_ID(__annotate__), AnnotationBlock,
+ key, LOCATION(annotation))) {
+ VISIT_QUIT(st, 0);
+ }
+ parent_ste->ste_annotation_block =
+ (struct _symtable_entry *)Py_NewRef(st->st_cur);
+ int future_annotations = st->st_future->ff_features & CO_FUTURE_ANNOTATIONS;
+ if (current_type == ClassBlock && !future_annotations) {
+ st->st_cur->ste_can_see_class_scope = 1;
+ if (!symtable_add_def(st, &_Py_ID(__classdict__), USE, LOCATION(annotation))) {
+ return 0;
+ }
+ }
+
+ _Py_DECLARE_STR(format, ".format");
+ // The generated __annotate__ function takes a single parameter with the
+ // internal name ".format".
+ if (!symtable_add_def(st, &_Py_STR(format), DEF_PARAM,
+ LOCATION(annotation))) {
+ return 0;
+ }
+ if (!symtable_add_def(st, &_Py_STR(format), USE,
+ LOCATION(annotation))) {
+ return 0;
+ }
+ }
+ else {
+ if (!symtable_enter_existing_block(st, parent_ste->ste_annotation_block)) {
+ VISIT_QUIT(st, 0);
+ }
}
VISIT(st, expr, annotation);
- if (future_annotations && !symtable_exit_block(st)) {
+ if (!symtable_exit_block(st)) {
VISIT_QUIT(st, 0);
}
return 1;
for (i = 0; i < asdl_seq_LEN(args); i++) {
arg_ty arg = (arg_ty)asdl_seq_GET(args, i);
- if (arg->annotation)
+ if (arg->annotation) {
+ st->st_cur->ste_annotations_used = 1;
VISIT(st, expr, arg->annotation);
+ }
}
return 1;
}
static int
-symtable_visit_annotations(struct symtable *st, stmt_ty o, arguments_ty a, expr_ty returns)
+symtable_visit_annotations(struct symtable *st, stmt_ty o, arguments_ty a, expr_ty returns,
+ struct _symtable_entry *function_ste)
{
- int future_annotations = st->st_future->ff_features & CO_FUTURE_ANNOTATIONS;
- if (future_annotations &&
- !symtable_enter_block(st, &_Py_ID(_annotation), AnnotationBlock,
- (void *)o, o->lineno, o->col_offset, o->end_lineno,
- o->end_col_offset)) {
+ int is_in_class = st->st_cur->ste_can_see_class_scope;
+ _Py_block_ty current_type = st->st_cur->ste_type;
+ if (!symtable_enter_block(st, &_Py_ID(__annotate__), AnnotationBlock,
+ (void *)a, LOCATION(o))) {
VISIT_QUIT(st, 0);
}
+ if (is_in_class || current_type == ClassBlock) {
+ st->st_cur->ste_can_see_class_scope = 1;
+ if (!symtable_add_def(st, &_Py_ID(__classdict__), USE, LOCATION(o))) {
+ return 0;
+ }
+ }
+ _Py_DECLARE_STR(format, ".format");
+ // We need to insert code that reads this "parameter" to the function.
+ if (!symtable_add_def(st, &_Py_STR(format), DEF_PARAM, LOCATION(o))) {
+ return 0;
+ }
+ if (!symtable_add_def(st, &_Py_STR(format), USE, LOCATION(o))) {
+ return 0;
+ }
if (a->posonlyargs && !symtable_visit_argannotations(st, a->posonlyargs))
return 0;
if (a->args && !symtable_visit_argannotations(st, a->args))
return 0;
- if (a->vararg && a->vararg->annotation)
+ if (a->vararg && a->vararg->annotation) {
+ st->st_cur->ste_annotations_used = 1;
VISIT(st, expr, a->vararg->annotation);
- if (a->kwarg && a->kwarg->annotation)
+ }
+ if (a->kwarg && a->kwarg->annotation) {
+ st->st_cur->ste_annotations_used = 1;
VISIT(st, expr, a->kwarg->annotation);
+ }
if (a->kwonlyargs && !symtable_visit_argannotations(st, a->kwonlyargs))
return 0;
- if (future_annotations && !symtable_exit_block(st)) {
- VISIT_QUIT(st, 0);
+ if (returns) {
+ st->st_cur->ste_annotations_used = 1;
+ VISIT(st, expr, returns);
}
- if (returns && !symtable_visit_annotation(st, returns)) {
+ if (!symtable_exit_block(st)) {
VISIT_QUIT(st, 0);
}
return 1;
static int
symtable_raise_if_annotation_block(struct symtable *st, const char *name, expr_ty e)
{
- enum _block_type type = st->st_cur->ste_type;
+ _Py_block_ty type = st->st_cur->ste_type;
if (type == AnnotationBlock)
PyErr_Format(PyExc_SyntaxError, ANNOTATION_NOT_ALLOWED, name);
else if (type == TypeVarBoundBlock)
projects / thirdparty / Python / cpython.git / commitdiff
