/*

* This file implements the compiler's code generation stage, which

* produces a sequence of pseudo-instructions from an AST.

*

* The primary entry point is _PyCodegen_Body() for modules, and

* _PyCodegen_Expression() for expressions.

*

* CAUTION: The VISIT_* macros abort the current function when they

* encounter a problem. So don't invoke them when there is memory

* which needs to be released. Code blocks are OK, as the compiler

* structure takes care of releasing those. Use the arena to manage

* objects.

*/

#include <stdbool.h>

#include "Python.h"

#include "opcode.h"

#include "pycore_ast.h" // _PyAST_GetDocString()

#define NEED_OPCODE_TABLES

#include "pycore_opcode_utils.h"

#undef NEED_OPCODE_TABLES

#include "pycore_compile.h"

#include "pycore_instruction_sequence.h" // _PyInstructionSequence_NewLabel()

#include "pycore_intrinsics.h"

#include "pycore_long.h" // _PyLong_GetZero()

#include "pycore_pystate.h" // _Py_GetConfig()

#include "pycore_symtable.h" // PySTEntryObject

#define NEED_OPCODE_METADATA

#include "pycore_opcode_metadata.h" // _PyOpcode_opcode_metadata, _PyOpcode_num_popped/pushed

#undef NEED_OPCODE_METADATA

#define COMP_GENEXP 0

#define COMP_LISTCOMP 1

#define COMP_SETCOMP 2

#define COMP_DICTCOMP 3

/* A soft limit for stack use, to avoid excessive

* memory use for large constants, etc.

*

* The value 30 is plucked out of thin air.

* Code that could use more stack than this is

* rare, so the exact value is unimportant.

*/

#define STACK_USE_GUIDELINE 30

#undef SUCCESS

#undef ERROR

#define SUCCESS 0

#define ERROR -1

#define RETURN_IF_ERROR(X) \

if ((X) == -1) { \

return ERROR; \

}

#define RETURN_IF_ERROR_IN_SCOPE(C, CALL) { \

if ((CALL) < 0) { \

_PyCompile_ExitScope((C)); \

return ERROR; \

} \

}

struct _PyCompiler;

typedef struct _PyCompiler compiler;

#define INSTR_SEQUENCE(C) _PyCompile_InstrSequence(C)

#define FUTURE_FEATURES(C) _PyCompile_FutureFeatures(C)

#define SYMTABLE(C) _PyCompile_Symtable(C)

#define SYMTABLE_ENTRY(C) _PyCompile_SymtableEntry(C)

#define OPTIMIZATION_LEVEL(C) _PyCompile_OptimizationLevel(C)

#define IS_INTERACTIVE_TOP_LEVEL(C) _PyCompile_IsInteractiveTopLevel(C)

#define SCOPE_TYPE(C) _PyCompile_ScopeType(C)

#define QUALNAME(C) _PyCompile_Qualname(C)

#define METADATA(C) _PyCompile_Metadata(C)

typedef _PyInstruction instruction;

typedef _PyInstructionSequence instr_sequence;

typedef _Py_SourceLocation location;

typedef _PyJumpTargetLabel jump_target_label;

typedef _PyCompile_FBlockInfo fblockinfo;

#define LOCATION(LNO, END_LNO, COL, END_COL) \

((const _Py_SourceLocation){(LNO), (END_LNO), (COL), (END_COL)})

#define LOC(x) SRC_LOCATION_FROM_AST(x)

#define NEW_JUMP_TARGET_LABEL(C, NAME) \

jump_target_label NAME = _PyInstructionSequence_NewLabel(INSTR_SEQUENCE(C)); \

if (!IS_JUMP_TARGET_LABEL(NAME)) { \

return ERROR; \

}

#define USE_LABEL(C, LBL) \

RETURN_IF_ERROR(_PyInstructionSequence_UseLabel(INSTR_SEQUENCE(C), (LBL).id))

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.

*

* idx: the index we want to access

* arr: pointer to the array

* alloc: pointer to the capacity of the array

* default_alloc: initial number of items

* item_size: size of each item

*

*/

int

_PyCompile_EnsureArrayLargeEnough(int idx, void **array, int *alloc,

int default_alloc, size_t item_size)

{

void *arr = *array;

if (arr == NULL) {

int new_alloc = default_alloc;

if (idx >= new_alloc) {

new_alloc = idx + default_alloc;

}

arr = PyMem_Calloc(new_alloc, item_size);

if (arr == NULL) {

PyErr_NoMemory();

return ERROR;

}

*alloc = new_alloc;

}

else if (idx >= *alloc) {

size_t oldsize = *alloc * item_size;

int new_alloc = *alloc << 1;

if (idx >= new_alloc) {

new_alloc = idx + default_alloc;

}

size_t newsize = new_alloc * item_size;

if (oldsize > (SIZE_MAX >> 1)) {

PyErr_NoMemory();

return ERROR;

}

assert(newsize > 0);

void *tmp = PyMem_Realloc(arr, newsize);

if (tmp == NULL) {

PyErr_NoMemory();

return ERROR;

}

*alloc = new_alloc;

arr = tmp;

memset((char *)arr + oldsize, 0, newsize - oldsize);

}

*array = arr;

return SUCCESS;

}

typedef struct {

// A list of strings corresponding to name captures. It is used to track:

// - Repeated name assignments in the same pattern.

// - Different name assignments in alternatives.

// - The order of name assignments in alternatives.

PyObject *stores;

// If 0, any name captures against our subject will raise.

int allow_irrefutable;

// An array of blocks to jump to on failure. Jumping to fail_pop[i] will pop

// i items off of the stack. The end result looks like this (with each block

// falling through to the next):

// fail_pop[4]: POP_TOP

// fail_pop[3]: POP_TOP

// fail_pop[2]: POP_TOP

// fail_pop[1]: POP_TOP

// fail_pop[0]: NOP

jump_target_label *fail_pop;

// The current length of fail_pop.

Py_ssize_t fail_pop_size;

// The number of items on top of the stack that need to *stay* on top of the

// stack. Variable captures go beneath these. All of them will be popped on

// failure.

Py_ssize_t on_top;

} pattern_context;

static int codegen_nameop(compiler *, location, identifier, expr_context_ty);

static int codegen_visit_stmt(compiler *, stmt_ty);

static int codegen_visit_keyword(compiler *, keyword_ty);

static int codegen_visit_expr(compiler *, expr_ty);

static int codegen_augassign(compiler *, stmt_ty);

static int codegen_annassign(compiler *, stmt_ty);

static int codegen_subscript(compiler *, expr_ty);

static int codegen_slice(compiler *, expr_ty);

static bool are_all_items_const(asdl_expr_seq *, Py_ssize_t, Py_ssize_t);

static int codegen_with(compiler *, stmt_ty, int);

static int codegen_async_with(compiler *, stmt_ty, int);

static int codegen_async_for(compiler *, stmt_ty);

static int codegen_call_simple_kw_helper(compiler *c,

location loc,

asdl_keyword_seq *keywords,

Py_ssize_t nkwelts);

static int codegen_call_helper_impl(compiler *c, location loc,

int n, /* Args already pushed */

asdl_expr_seq *args,

PyObject *injected_arg,

asdl_keyword_seq *keywords);

static int codegen_call_helper(compiler *c, location loc,

int n, asdl_expr_seq *args,

asdl_keyword_seq *keywords);

static int codegen_try_except(compiler *, stmt_ty);

static int codegen_try_star_except(compiler *, stmt_ty);

static int codegen_sync_comprehension_generator(

compiler *c, location loc,

asdl_comprehension_seq *generators, int gen_index,

int depth,

expr_ty elt, expr_ty val, int type,

int iter_on_stack);

static int codegen_async_comprehension_generator(

compiler *c, location loc,

asdl_comprehension_seq *generators, int gen_index,

int depth,

expr_ty elt, expr_ty val, int type,

int iter_on_stack);

static int codegen_pattern(compiler *, pattern_ty, pattern_context *);

static int codegen_match(compiler *, stmt_ty);

static int codegen_pattern_subpattern(compiler *,

pattern_ty, pattern_context *);

static int codegen_make_closure(compiler *c, location loc,

PyCodeObject *co, Py_ssize_t flags);

/* Add an opcode with an integer argument */

static int

codegen_addop_i(instr_sequence *seq, int opcode, Py_ssize_t oparg, location loc)

{

/* oparg value is unsigned, but a signed C int is usually used to store

it in the C code (like Python/ceval.c).

Limit to 32-bit signed C int (rather than INT_MAX) for portability.

The argument of a concrete bytecode instruction is limited to 8-bit.

EXTENDED_ARG is used for 16, 24, and 32-bit arguments. */

int oparg_ = Py_SAFE_DOWNCAST(oparg, Py_ssize_t, int);

assert(!IS_ASSEMBLER_OPCODE(opcode));

return _PyInstructionSequence_Addop(seq, opcode, oparg_, loc);

}

#define ADDOP_I(C, LOC, OP, O) \

RETURN_IF_ERROR(codegen_addop_i(INSTR_SEQUENCE(C), (OP), (O), (LOC)))

#define ADDOP_I_IN_SCOPE(C, LOC, OP, O) \

RETURN_IF_ERROR_IN_SCOPE(C, codegen_addop_i(INSTR_SEQUENCE(C), (OP), (O), (LOC)));

static int

codegen_addop_noarg(instr_sequence *seq, int opcode, location loc)

{

assert(!OPCODE_HAS_ARG(opcode));

assert(!IS_ASSEMBLER_OPCODE(opcode));

return _PyInstructionSequence_Addop(seq, opcode, 0, loc);

}

#define ADDOP(C, LOC, OP) \

RETURN_IF_ERROR(codegen_addop_noarg(INSTR_SEQUENCE(C), (OP), (LOC)))

#define ADDOP_IN_SCOPE(C, LOC, OP) \

RETURN_IF_ERROR_IN_SCOPE((C), codegen_addop_noarg(INSTR_SEQUENCE(C), (OP), (LOC)))

static int

codegen_addop_load_const(compiler *c, location loc, PyObject *o)

{

Py_ssize_t arg = _PyCompile_AddConst(c, o);

if (arg < 0) {

return ERROR;

}

ADDOP_I(c, loc, LOAD_CONST, arg);

return SUCCESS;

}

#define ADDOP_LOAD_CONST(C, LOC, O) \

RETURN_IF_ERROR(codegen_addop_load_const((C), (LOC), (O)))

#define ADDOP_LOAD_CONST_IN_SCOPE(C, LOC, O) \

RETURN_IF_ERROR_IN_SCOPE((C), codegen_addop_load_const((C), (LOC), (O)))

/* Same as ADDOP_LOAD_CONST, but steals a reference. */

#define ADDOP_LOAD_CONST_NEW(C, LOC, O) { \

PyObject *__new_const = (O); \

if (__new_const == NULL) { \

return ERROR; \

} \

if (codegen_addop_load_const((C), (LOC), __new_const) < 0) { \

Py_DECREF(__new_const); \

return ERROR; \

} \

Py_DECREF(__new_const); \

}

static int

codegen_addop_o(compiler *c, location loc,

int opcode, PyObject *dict, PyObject *o)

{

Py_ssize_t arg = _PyCompile_DictAddObj(dict, o);

RETURN_IF_ERROR(arg);

ADDOP_I(c, loc, opcode, arg);

return SUCCESS;

}

#define ADDOP_N(C, LOC, OP, O, TYPE) { \

assert(!OPCODE_HAS_CONST(OP)); /* use ADDOP_LOAD_CONST_NEW */ \

int ret = codegen_addop_o((C), (LOC), (OP), METADATA(C)->u_ ## TYPE, (O)); \

Py_DECREF((O)); \

RETURN_IF_ERROR(ret); \

}

#define ADDOP_N_IN_SCOPE(C, LOC, OP, O, TYPE) { \

assert(!OPCODE_HAS_CONST(OP)); /* use ADDOP_LOAD_CONST_NEW */ \

int ret = codegen_addop_o((C), (LOC), (OP), METADATA(C)->u_ ## TYPE, (O)); \

Py_DECREF((O)); \

RETURN_IF_ERROR_IN_SCOPE((C), ret); \

}

#define LOAD_METHOD -1

#define LOAD_SUPER_METHOD -2

#define LOAD_ZERO_SUPER_ATTR -3

#define LOAD_ZERO_SUPER_METHOD -4

static int

codegen_addop_name(compiler *c, location loc,

int opcode, PyObject *dict, PyObject *o)

{

PyObject *mangled = _PyCompile_MaybeMangle(c, o);

if (!mangled) {

return ERROR;

}

Py_ssize_t arg = _PyCompile_DictAddObj(dict, mangled);

Py_DECREF(mangled);

if (arg < 0) {

return ERROR;

}

if (opcode == LOAD_ATTR) {

arg <<= 1;

}

if (opcode == LOAD_METHOD) {

opcode = LOAD_ATTR;

arg <<= 1;

arg |= 1;

}

if (opcode == LOAD_SUPER_ATTR) {

arg <<= 2;

arg |= 2;

}

if (opcode == LOAD_SUPER_METHOD) {

opcode = LOAD_SUPER_ATTR;

arg <<= 2;

arg |= 3;

}

if (opcode == LOAD_ZERO_SUPER_ATTR) {

opcode = LOAD_SUPER_ATTR;

arg <<= 2;

}

if (opcode == LOAD_ZERO_SUPER_METHOD) {

opcode = LOAD_SUPER_ATTR;

arg <<= 2;

arg |= 1;

}

ADDOP_I(c, loc, opcode, arg);

return SUCCESS;

}

#define ADDOP_NAME(C, LOC, OP, O, TYPE) \

RETURN_IF_ERROR(codegen_addop_name((C), (LOC), (OP), METADATA(C)->u_ ## TYPE, (O)))

static int

codegen_addop_j(instr_sequence *seq, location loc,

int opcode, jump_target_label target)

{

assert(IS_JUMP_TARGET_LABEL(target));

assert(OPCODE_HAS_JUMP(opcode) || IS_BLOCK_PUSH_OPCODE(opcode));

assert(!IS_ASSEMBLER_OPCODE(opcode));

return _PyInstructionSequence_Addop(seq, opcode, target.id, loc);

}

#define ADDOP_JUMP(C, LOC, OP, O) \

RETURN_IF_ERROR(codegen_addop_j(INSTR_SEQUENCE(C), (LOC), (OP), (O)))

#define ADDOP_COMPARE(C, LOC, CMP) \

RETURN_IF_ERROR(codegen_addcompare((C), (LOC), (cmpop_ty)(CMP)))

#define ADDOP_BINARY(C, LOC, BINOP) \

RETURN_IF_ERROR(addop_binary((C), (LOC), (BINOP), false))

#define ADDOP_INPLACE(C, LOC, BINOP) \

RETURN_IF_ERROR(addop_binary((C), (LOC), (BINOP), true))

#define ADD_YIELD_FROM(C, LOC, await) \

RETURN_IF_ERROR(codegen_add_yield_from((C), (LOC), (await)))

#define POP_EXCEPT_AND_RERAISE(C, LOC) \

RETURN_IF_ERROR(codegen_pop_except_and_reraise((C), (LOC)))

#define ADDOP_YIELD(C, LOC) \

RETURN_IF_ERROR(codegen_addop_yield((C), (LOC)))

/* VISIT and VISIT_SEQ takes an ASDL type as their second argument. They use

the ASDL name to synthesize the name of the C type and the visit function.

*/

#define VISIT(C, TYPE, V) \

RETURN_IF_ERROR(codegen_visit_ ## TYPE((C), (V)));

#define VISIT_IN_SCOPE(C, TYPE, V) \

RETURN_IF_ERROR_IN_SCOPE((C), codegen_visit_ ## TYPE((C), (V)))

#define VISIT_SEQ(C, TYPE, SEQ) { \

int _i; \

asdl_ ## TYPE ## _seq *seq = (SEQ); /* avoid variable capture */ \

for (_i = 0; _i < asdl_seq_LEN(seq); _i++) { \

TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, _i); \

RETURN_IF_ERROR(codegen_visit_ ## TYPE((C), elt)); \

} \

}

#define VISIT_SEQ_IN_SCOPE(C, TYPE, SEQ) { \

int _i; \

asdl_ ## TYPE ## _seq *seq = (SEQ); /* avoid variable capture */ \

for (_i = 0; _i < asdl_seq_LEN(seq); _i++) { \

TYPE ## _ty elt = (TYPE ## _ty)asdl_seq_GET(seq, _i); \

if (codegen_visit_ ## TYPE((C), elt) < 0) { \

_PyCompile_ExitScope(C); \

return ERROR; \

} \

} \

}

static int

codegen_call_exit_with_nones(compiler *c, location loc)

{

ADDOP_LOAD_CONST(c, loc, Py_None);

ADDOP_LOAD_CONST(c, loc, Py_None);

ADDOP_LOAD_CONST(c, loc, Py_None);

ADDOP_I(c, loc, CALL, 3);

return SUCCESS;

}

static int

codegen_add_yield_from(compiler *c, location loc, int await)

{

NEW_JUMP_TARGET_LABEL(c, send);

NEW_JUMP_TARGET_LABEL(c, fail);

NEW_JUMP_TARGET_LABEL(c, exit);

USE_LABEL(c, send);

ADDOP_JUMP(c, loc, SEND, exit);

// Set up a virtual try/except to handle when StopIteration is raised during

// a close or throw call. The only way YIELD_VALUE raises if they do!

ADDOP_JUMP(c, loc, SETUP_FINALLY, fail);

ADDOP_I(c, loc, YIELD_VALUE, 1);

ADDOP(c, NO_LOCATION, POP_BLOCK);

ADDOP_I(c, loc, RESUME, await ? RESUME_AFTER_AWAIT : RESUME_AFTER_YIELD_FROM);

ADDOP_JUMP(c, loc, JUMP_NO_INTERRUPT, send);

USE_LABEL(c, fail);

ADDOP(c, loc, CLEANUP_THROW);

USE_LABEL(c, exit);

ADDOP(c, loc, END_SEND);

return SUCCESS;

}

static int

codegen_pop_except_and_reraise(compiler *c, location loc)

{

/* Stack contents

* [exc_info, lasti, exc] COPY 3

* [exc_info, lasti, exc, exc_info] POP_EXCEPT

* [exc_info, lasti, exc] RERAISE 1

* (exception_unwind clears the stack)

*/

ADDOP_I(c, loc, COPY, 3);

ADDOP(c, loc, POP_EXCEPT);

ADDOP_I(c, loc, RERAISE, 1);

return SUCCESS;

}

/* Unwind a frame block. If preserve_tos is true, the TOS before

* popping the blocks will be restored afterwards, unless another

* return, break or continue is found. In which case, the TOS will

* be popped.

*/

static int

codegen_unwind_fblock(compiler *c, location *ploc,

fblockinfo *info, int preserve_tos)

{

switch (info->fb_type) {

case COMPILE_FBLOCK_WHILE_LOOP:

case COMPILE_FBLOCK_EXCEPTION_HANDLER:

case COMPILE_FBLOCK_EXCEPTION_GROUP_HANDLER:

case COMPILE_FBLOCK_ASYNC_COMPREHENSION_GENERATOR:

case COMPILE_FBLOCK_STOP_ITERATION:

return SUCCESS;

case COMPILE_FBLOCK_FOR_LOOP:

/* Pop the iterator */

if (preserve_tos) {

ADDOP_I(c, *ploc, SWAP, 2);

}

ADDOP(c, *ploc, POP_TOP);

return SUCCESS;

case COMPILE_FBLOCK_TRY_EXCEPT:

ADDOP(c, *ploc, POP_BLOCK);

return SUCCESS;

case COMPILE_FBLOCK_FINALLY_TRY:

/* This POP_BLOCK gets the line number of the unwinding statement */

ADDOP(c, *ploc, POP_BLOCK);

if (preserve_tos) {

RETURN_IF_ERROR(

_PyCompile_PushFBlock(c, *ploc, COMPILE_FBLOCK_POP_VALUE,

NO_LABEL, NO_LABEL, NULL));

}

/* Emit the finally block */

VISIT_SEQ(c, stmt, info->fb_datum);

if (preserve_tos) {

_PyCompile_PopFBlock(c, COMPILE_FBLOCK_POP_VALUE, NO_LABEL);

}

/* The finally block should appear to execute after the

* statement causing the unwinding, so make the unwinding

* instruction artificial */

*ploc = NO_LOCATION;

return SUCCESS;

case COMPILE_FBLOCK_FINALLY_END:

if (preserve_tos) {

ADDOP_I(c, *ploc, SWAP, 2);

}

ADDOP(c, *ploc, POP_TOP); /* exc_value */

if (preserve_tos) {

ADDOP_I(c, *ploc, SWAP, 2);

}

ADDOP(c, *ploc, POP_BLOCK);

ADDOP(c, *ploc, POP_EXCEPT);

return SUCCESS;

case COMPILE_FBLOCK_WITH:

case COMPILE_FBLOCK_ASYNC_WITH:

*ploc = info->fb_loc;

ADDOP(c, *ploc, POP_BLOCK);

if (preserve_tos) {

ADDOP_I(c, *ploc, SWAP, 3);

ADDOP_I(c, *ploc, SWAP, 2);

}

RETURN_IF_ERROR(codegen_call_exit_with_nones(c, *ploc));

if (info->fb_type == COMPILE_FBLOCK_ASYNC_WITH) {

ADDOP_I(c, *ploc, GET_AWAITABLE, 2);

ADDOP_LOAD_CONST(c, *ploc, Py_None);

ADD_YIELD_FROM(c, *ploc, 1);

}

ADDOP(c, *ploc, POP_TOP);

/* The exit block should appear to execute after the

* statement causing the unwinding, so make the unwinding

* instruction artificial */

*ploc = NO_LOCATION;

return SUCCESS;

case COMPILE_FBLOCK_HANDLER_CLEANUP: {

if (info->fb_datum) {

ADDOP(c, *ploc, POP_BLOCK);

}

if (preserve_tos) {

ADDOP_I(c, *ploc, SWAP, 2);

}

ADDOP(c, *ploc, POP_BLOCK);

ADDOP(c, *ploc, POP_EXCEPT);

if (info->fb_datum) {

ADDOP_LOAD_CONST(c, *ploc, Py_None);

RETURN_IF_ERROR(codegen_nameop(c, *ploc, info->fb_datum, Store));

RETURN_IF_ERROR(codegen_nameop(c, *ploc, info->fb_datum, Del));

}

return SUCCESS;

}

case COMPILE_FBLOCK_POP_VALUE: {

if (preserve_tos) {

ADDOP_I(c, *ploc, SWAP, 2);

}

ADDOP(c, *ploc, POP_TOP);

return SUCCESS;

}

}

Py_UNREACHABLE();

}

/** Unwind block stack. If loop is not NULL, then stop when the first loop is encountered. */

static int

codegen_unwind_fblock_stack(compiler *c, location *ploc,

int preserve_tos, fblockinfo **loop)

{

fblockinfo *top = _PyCompile_TopFBlock(c);

if (top == NULL) {

return SUCCESS;

}

if (top->fb_type == COMPILE_FBLOCK_EXCEPTION_GROUP_HANDLER) {

return _PyCompile_Error(

c, *ploc, "'break', 'continue' and 'return' cannot appear in an except* block");

}

if (loop != NULL && (top->fb_type == COMPILE_FBLOCK_WHILE_LOOP ||

top->fb_type == COMPILE_FBLOCK_FOR_LOOP)) {

*loop = top;

return SUCCESS;

}

fblockinfo copy = *top;

_PyCompile_PopFBlock(c, top->fb_type, top->fb_block);

RETURN_IF_ERROR(codegen_unwind_fblock(c, ploc, &copy, preserve_tos));

RETURN_IF_ERROR(codegen_unwind_fblock_stack(c, ploc, preserve_tos, loop));

_PyCompile_PushFBlock(c, copy.fb_loc, copy.fb_type, copy.fb_block,

copy.fb_exit, copy.fb_datum);

return SUCCESS;

}

static int

codegen_enter_scope(compiler *c, identifier name, int scope_type,

void *key, int lineno, PyObject *private,

_PyCompile_CodeUnitMetadata *umd)

{

RETURN_IF_ERROR(

_PyCompile_EnterScope(c, name, scope_type, key, lineno, private, umd));

location loc = LOCATION(lineno, lineno, 0, 0);

if (scope_type == COMPILE_SCOPE_MODULE) {

loc.lineno = 0;

}

ADDOP_I(c, loc, RESUME, RESUME_AT_FUNC_START);

return SUCCESS;

}

static int

codegen_setup_annotations_scope(compiler *c, location loc,

void *key, PyObject *name)

{

_PyCompile_CodeUnitMetadata umd = {

.u_posonlyargcount = 1,

};

RETURN_IF_ERROR(

codegen_enter_scope(c, name, COMPILE_SCOPE_ANNOTATIONS,

key, loc.lineno, NULL, &umd));

// 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 SUCCESS;

}

static int

codegen_leave_annotations_scope(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 = _PyCompile_OptimizeAndAssemble(c, 1);

_PyCompile_ExitScope(c);

if (co == NULL) {

return ERROR;

}

int ret = codegen_make_closure(c, loc, co, 0);

Py_DECREF(co);

RETURN_IF_ERROR(ret);

return SUCCESS;

}

static int

codegen_process_deferred_annotations(compiler *c, location loc)

{

PyObject *deferred_anno = _PyCompile_DeferredAnnotations(c);

if (deferred_anno == NULL) {

return SUCCESS;

}

Py_INCREF(deferred_anno);

// 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.

PySTEntryObject *ste = SYMTABLE_ENTRY(c);

assert(ste->ste_annotation_block != NULL);

void *key = (void *)((uintptr_t)ste->ste_id + 1);

if (codegen_setup_annotations_scope(c, loc, key,

ste->ste_annotation_block->ste_name) < 0) {

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) {

_PyCompile_ExitScope(c);

Py_DECREF(deferred_anno);

return ERROR;

}

PyObject *mangled = _PyCompile_Mangle(c, st->v.AnnAssign.target->v.Name.id);

if (!mangled) {

_PyCompile_ExitScope(c);

Py_DECREF(deferred_anno);

return ERROR;

}

ADDOP_LOAD_CONST_NEW(c, LOC(st), mangled);

VISIT(c, expr, st->v.AnnAssign.annotation);

}

Py_DECREF(deferred_anno);

RETURN_IF_ERROR(codegen_leave_annotations_scope(c, loc, annotations_len));

RETURN_IF_ERROR(codegen_nameop(c, loc, &_Py_ID(__annotate__), Store));

return SUCCESS;

}

/* Compile an expression */

int

_PyCodegen_Expression(compiler *c, expr_ty e)

{

VISIT(c, expr, e);

return SUCCESS;

}

/* Compile a sequence of statements, checking for a docstring

and for annotations. */

int

_PyCodegen_Body(compiler *c, location loc, asdl_stmt_seq *stmts, bool is_interactive)

{

/* If from __future__ import annotations is active,

* every annotated class and module should have __annotations__.

* Else __annotate__ is created when necessary. */

if ((FUTURE_FEATURES(c) & CO_FUTURE_ANNOTATIONS) && SYMTABLE_ENTRY(c)->ste_annotations_used) {

ADDOP(c, loc, SETUP_ANNOTATIONS);

}

if (!asdl_seq_LEN(stmts)) {

return SUCCESS;

}

Py_ssize_t first_instr = 0;

if (!is_interactive) { /* A string literal on REPL prompt is not a docstring */

PyObject *docstring = _PyAST_GetDocString(stmts);

if (docstring) {

first_instr = 1;

/* set docstring */

assert(OPTIMIZATION_LEVEL(c) < 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(codegen_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 (!(FUTURE_FEATURES(c) & CO_FUTURE_ANNOTATIONS)) {

RETURN_IF_ERROR(codegen_process_deferred_annotations(c, loc));

}

return SUCCESS;

}

int

_PyCodegen_EnterAnonymousScope(compiler* c, mod_ty mod)

{

_Py_DECLARE_STR(anon_module, "<module>");

RETURN_IF_ERROR(

codegen_enter_scope(c, &_Py_STR(anon_module), COMPILE_SCOPE_MODULE,

mod, 1, NULL, NULL));

return SUCCESS;

}

static int

codegen_make_closure(compiler *c, location loc,

PyCodeObject *co, Py_ssize_t flags)

{

if (co->co_nfreevars) {

int i = PyUnstable_Code_GetFirstFree(co);

for (; i < co->co_nlocalsplus; ++i) {

/* Bypass com_addop_varname because it will generate

LOAD_DEREF but LOAD_CLOSURE is needed.

*/

PyObject *name = PyTuple_GET_ITEM(co->co_localsplusnames, i);

int arg = _PyCompile_LookupArg(c, co, name);

RETURN_IF_ERROR(arg);

ADDOP_I(c, loc, LOAD_CLOSURE, arg);

}

flags |= MAKE_FUNCTION_CLOSURE;

ADDOP_I(c, loc, BUILD_TUPLE, co->co_nfreevars);

}

ADDOP_LOAD_CONST(c, loc, (PyObject*)co);

ADDOP(c, loc, MAKE_FUNCTION);

if (flags & MAKE_FUNCTION_CLOSURE) {

ADDOP_I(c, loc, SET_FUNCTION_ATTRIBUTE, MAKE_FUNCTION_CLOSURE);

}

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);

}

if (flags & MAKE_FUNCTION_DEFAULTS) {

ADDOP_I(c, loc, SET_FUNCTION_ATTRIBUTE, MAKE_FUNCTION_DEFAULTS);

}

return SUCCESS;

}

static int

codegen_decorators(compiler *c, asdl_expr_seq* decos)

{

if (!decos) {

return SUCCESS;

}

for (Py_ssize_t i = 0; i < asdl_seq_LEN(decos); i++) {

VISIT(c, expr, (expr_ty)asdl_seq_GET(decos, i));

}

return SUCCESS;

}

static int

codegen_apply_decorators(compiler *c, asdl_expr_seq* decos)

{

if (!decos) {

return SUCCESS;

}

for (Py_ssize_t i = asdl_seq_LEN(decos) - 1; i > -1; i--) {

location loc = LOC((expr_ty)asdl_seq_GET(decos, i));

ADDOP_I(c, loc, CALL, 0);

}

return SUCCESS;

}

static int

codegen_kwonlydefaults(compiler *c, location loc,

asdl_arg_seq *kwonlyargs, asdl_expr_seq *kw_defaults)

{

/* Push a dict of keyword-only default values.

Return -1 on error, 0 if no dict pushed, 1 if a dict is pushed.

*/

int default_count = 0;

for (int i = 0; i < asdl_seq_LEN(kwonlyargs); i++) {

arg_ty arg = asdl_seq_GET(kwonlyargs, i);

expr_ty default_ = asdl_seq_GET(kw_defaults, i);

if (default_) {

default_count++;

PyObject *mangled = _PyCompile_MaybeMangle(c, arg->arg);

if (!mangled) {

return ERROR;

}

ADDOP_LOAD_CONST_NEW(c, loc, mangled);

VISIT(c, expr, default_);

}

}

if (default_count) {

ADDOP_I(c, loc, BUILD_MAP, default_count);

return 1;

}

else {

return 0;

}

}

static int

codegen_visit_annexpr(compiler *c, expr_ty annotation)

{

location loc = LOC(annotation);

ADDOP_LOAD_CONST_NEW(c, loc, _PyAST_ExprAsUnicode(annotation));

return SUCCESS;

}

static int

codegen_argannotation(compiler *c, identifier id,

expr_ty annotation, Py_ssize_t *annotations_len, location loc)

{

if (!annotation) {

return SUCCESS;

}

PyObject *mangled = _PyCompile_MaybeMangle(c, id);

if (!mangled) {

return ERROR;

}

ADDOP_LOAD_CONST(c, loc, mangled);

Py_DECREF(mangled);

if (FUTURE_FEATURES(c) & CO_FUTURE_ANNOTATIONS) {

VISIT(c, annexpr, annotation);

}

else {

if (annotation->kind == Starred_kind) {

// *args: *Ts (where Ts is a TypeVarTuple).

// Do [annotation_value] = [*Ts].

// (Note that in theory we could end up here even for an argument

// other than *args, but in practice the grammar doesn't allow it.)

VISIT(c, expr, annotation->v.Starred.value);

ADDOP_I(c, loc, UNPACK_SEQUENCE, (Py_ssize_t) 1);

}

else {

VISIT(c, expr, annotation);

}

}

*annotations_len += 1;

return SUCCESS;

}

static int

codegen_argannotations(compiler *c, asdl_arg_seq* args,

Py_ssize_t *annotations_len, location loc)

{

int i;

for (i = 0; i < asdl_seq_LEN(args); i++) {

arg_ty arg = (arg_ty)asdl_seq_GET(args, i);

RETURN_IF_ERROR(

codegen_argannotation(

c,

arg->arg,

arg->annotation,

annotations_len,

loc));

}

return SUCCESS;

}

static int

codegen_annotations_in_scope(compiler *c, location loc,

arguments_ty args, expr_ty returns,

Py_ssize_t *annotations_len)

{

RETURN_IF_ERROR(

codegen_argannotations(c, args->args, annotations_len, loc));

RETURN_IF_ERROR(

codegen_argannotations(c, args->posonlyargs, annotations_len, loc));

if (args->vararg && args->vararg->annotation) {

RETURN_IF_ERROR(

codegen_argannotation(c, args->vararg->arg,

args->vararg->annotation, annotations_len, loc));

}

RETURN_IF_ERROR(

codegen_argannotations(c, args->kwonlyargs, annotations_len, loc));

if (args->kwarg && args->kwarg->annotation) {

RETURN_IF_ERROR(

codegen_argannotation(c, args->kwarg->arg,

args->kwarg->annotation, annotations_len, loc));

}

RETURN_IF_ERROR(

codegen_argannotation(c, &_Py_ID(return), returns, annotations_len, loc));

return 0;

}

static int

codegen_annotations(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;