#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_code.h" // _PyCode_New()

#include "pycore_compile.h"

#include "pycore_flowgraph.h"

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

#include "pycore_intrinsics.h"

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

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

#include "pycore_setobject.h" // _PySet_NextEntry()

#include "pycore_symtable.h" // PySTEntryObject, _PyFuture_FromAST()

#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

#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 IS_TOP_LEVEL_AWAIT(C) ( \

((C)->c_flags.cf_flags & PyCF_ALLOW_TOP_LEVEL_AWAIT) \

&& ((C)->u->u_ste->ste_type == ModuleBlock))

typedef _Py_SourceLocation location;

typedef struct _PyCfgBuilder cfg_builder;

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

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

static inline bool

location_is_after(location loc1, location loc2) {

return (loc1.lineno > loc2.end_lineno) ||

((loc1.lineno == loc2.end_lineno) &&

(loc1.col_offset > loc2.end_col_offset));

}

#define LOC(x) SRC_LOCATION_FROM_AST(x)

typedef _PyJumpTargetLabel jump_target_label;

static jump_target_label NO_LABEL = {-1};

#define SAME_LABEL(L1, L2) ((L1).id == (L2).id)

#define IS_LABEL(L) (!SAME_LABEL((L), (NO_LABEL)))

#define NEW_JUMP_TARGET_LABEL(C, NAME) \

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

if (!IS_LABEL(NAME)) { \

return ERROR; \

}

#define USE_LABEL(C, LBL) \

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

enum fblocktype { WHILE_LOOP, FOR_LOOP, TRY_EXCEPT, FINALLY_TRY, FINALLY_END,

WITH, ASYNC_WITH, HANDLER_CLEANUP, POP_VALUE, EXCEPTION_HANDLER,

EXCEPTION_GROUP_HANDLER, ASYNC_COMPREHENSION_GENERATOR,

STOP_ITERATION };

struct fblockinfo {

};

enum {

COMPILER_SCOPE_MODULE,

COMPILER_SCOPE_CLASS,

COMPILER_SCOPE_FUNCTION,

COMPILER_SCOPE_ASYNC_FUNCTION,

COMPILER_SCOPE_LAMBDA,

COMPILER_SCOPE_COMPREHENSION,

COMPILER_SCOPE_TYPEPARAMS,

};

typedef _PyInstruction instruction;

typedef _PyInstructionSequence instr_sequence;

#define INITIAL_INSTR_SEQUENCE_SIZE 100

#define INITIAL_INSTR_SEQUENCE_LABELS_MAP_SIZE 10

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

}

static cfg_builder*

instr_sequence_to_cfg(instr_sequence *seq) {

if (_PyInstructionSequence_ApplyLabelMap(seq) < 0) {

return NULL;

}

cfg_builder *g = _PyCfgBuilder_New();

if (g == NULL) {

return NULL;

}

for (int i = 0; i < seq->s_used; i++) {

seq->s_instrs[i].i_target = 0;

}

for (int i = 0; i < seq->s_used; i++) {

instruction *instr = &seq->s_instrs[i];

if (HAS_TARGET(instr->i_opcode)) {

assert(instr->i_oparg >= 0 && instr->i_oparg < seq->s_used);

seq->s_instrs[instr->i_oparg].i_target = 1;

}

}

for (int i = 0; i < seq->s_used; i++) {

instruction *instr = &seq->s_instrs[i];

if (instr->i_target) {

jump_target_label lbl_ = {i};

if (_PyCfgBuilder_UseLabel(g, lbl_) < 0) {

goto error;

}

}

int opcode = instr->i_opcode;

int oparg = instr->i_oparg;

if (_PyCfgBuilder_Addop(g, opcode, oparg, instr->i_loc) < 0) {

goto error;

}

}

if (_PyCfgBuilder_CheckSize(g) < 0) {

goto error;

}

return g;

error:

_PyCfgBuilder_Free(g);

return NULL;

}

struct compiler_unit {

};

struct compiler {

};

#define INSTR_SEQUENCE(C) ((C)->u->u_instr_sequence)

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_addop_i(instr_sequence *seq, int opcode, Py_ssize_t oparg, location loc);

static void compiler_free(struct compiler *);

static int compiler_error(struct compiler *, location loc, const char *, ...);

static int compiler_warn(struct compiler *, location loc, const char *, ...);

static int compiler_nameop(struct compiler *, location, identifier, expr_context_ty);

static PyCodeObject *compiler_mod(struct compiler *, mod_ty);

static int compiler_visit_stmt(struct compiler *, stmt_ty);

static int compiler_visit_keyword(struct compiler *, keyword_ty);

static int compiler_visit_expr(struct compiler *, expr_ty);

static int compiler_augassign(struct compiler *, stmt_ty);

static int compiler_annassign(struct compiler *, stmt_ty);

static int compiler_subscript(struct compiler *, expr_ty);

static int compiler_slice(struct compiler *, expr_ty);

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

static int compiler_with(struct compiler *, stmt_ty, int);

static int compiler_async_with(struct compiler *, stmt_ty, int);

static int compiler_async_for(struct compiler *, stmt_ty);

static int compiler_call_simple_kw_helper(struct compiler *c,

location loc,

asdl_keyword_seq *keywords,

Py_ssize_t nkwelts);

static int compiler_call_helper(struct compiler *c, location loc,

int n, asdl_expr_seq *args,

asdl_keyword_seq *keywords);

static int compiler_try_except(struct compiler *, stmt_ty);

static int compiler_try_star_except(struct compiler *, stmt_ty);

static int compiler_set_qualname(struct compiler *);

static int compiler_sync_comprehension_generator(

int iter_on_stack);

static int compiler_async_comprehension_generator(

int iter_on_stack);

static int compiler_pattern(struct compiler *, pattern_ty, pattern_context *);

static int compiler_match(struct compiler *, stmt_ty);

static int compiler_pattern_subpattern(struct compiler *,

pattern_ty, pattern_context *);

static PyCodeObject *optimize_and_assemble(struct compiler *, int addNone);

#define CAPSULE_NAME "compile.c compiler unit"

static int

compiler_setup(struct compiler *c, mod_ty mod, PyObject *filename,

PyCompilerFlags *flags, int optimize, PyArena *arena)

{

PyCompilerFlags local_flags = _PyCompilerFlags_INIT;

c->c_const_cache = PyDict_New();

if (!c->c_const_cache) {

return ERROR;

}

c->c_stack = PyList_New(0);

if (!c->c_stack) {

return ERROR;

}

c->c_filename = Py_NewRef(filename);

c->c_arena = arena;

if (!_PyFuture_FromAST(mod, filename, &c->c_future)) {

return ERROR;

}

if (!flags) {

flags = &local_flags;

}

int merged = c->c_future.ff_features | flags->cf_flags;

c->c_future.ff_features = merged;

flags->cf_flags = merged;

c->c_flags = *flags;

c->c_optimize = (optimize == -1) ? _Py_GetConfig()->optimization_level : optimize;

c->c_nestlevel = 0;

c->c_save_nested_seqs = false;

if (!_PyAST_Optimize(mod, arena, c->c_optimize, merged)) {

return ERROR;

}

c->c_st = _PySymtable_Build(mod, filename, &c->c_future);

if (c->c_st == NULL) {

if (!PyErr_Occurred()) {

PyErr_SetString(PyExc_SystemError, "no symtable");

}

return ERROR;

}

return SUCCESS;

}

static struct compiler*

new_compiler(mod_ty mod, PyObject *filename, PyCompilerFlags *pflags,

int optimize, PyArena *arena)

{

struct compiler *c = PyMem_Calloc(1, sizeof(struct compiler));

if (c == NULL) {

return NULL;

}

if (compiler_setup(c, mod, filename, pflags, optimize, arena) < 0) {

compiler_free(c);

return NULL;

}

return c;

}

PyCodeObject *

_PyAST_Compile(mod_ty mod, PyObject *filename, PyCompilerFlags *pflags,

int optimize, PyArena *arena)

{

assert(!PyErr_Occurred());

struct compiler *c = new_compiler(mod, filename, pflags, optimize, arena);

if (c == NULL) {

return NULL;

}

PyCodeObject *co = compiler_mod(c, mod);

compiler_free(c);

assert(co || PyErr_Occurred());

return co;

}

_PyCompile_AstOptimize(mod_ty mod, PyObject *filename, PyCompilerFlags *cf,

int optimize, PyArena *arena)

{

_PyFutureFeatures future;

if (!_PyFuture_FromAST(mod, filename, &future)) {

return -1;

}

int flags = future.ff_features | cf->cf_flags;

if (optimize == -1) {

optimize = _Py_GetConfig()->optimization_level;

}

if (!_PyAST_Optimize(mod, arena, optimize, flags)) {

return -1;

}

return 0;

}

static void

compiler_free(struct compiler *c)

{

if (c->c_st)

_PySymtable_Free(c->c_st);

Py_XDECREF(c->c_filename);

Py_XDECREF(c->c_const_cache);

Py_XDECREF(c->c_stack);

PyMem_Free(c);

}

static PyObject *

list2dict(PyObject *list)

{

Py_ssize_t i, n;

PyObject *v, *k;

PyObject *dict = PyDict_New();

if (!dict) return NULL;

n = PyList_Size(list);

for (i = 0; i < n; i++) {

v = PyLong_FromSsize_t(i);

if (!v) {

Py_DECREF(dict);

return NULL;

}

k = PyList_GET_ITEM(list, i);

if (PyDict_SetItem(dict, k, v) < 0) {

Py_DECREF(v);

Py_DECREF(dict);

return NULL;

}

Py_DECREF(v);

}

return dict;

}

static PyObject *

dictbytype(PyObject *src, int scope_type, int flag, Py_ssize_t offset)

{

Py_ssize_t i = offset, scope, num_keys, key_i;

PyObject *k, *v, *dest = PyDict_New();

PyObject *sorted_keys;

assert(offset >= 0);

if (dest == NULL)

return NULL;

/* Sort the keys so that we have a deterministic order on the indexes

sorted_keys = PyDict_Keys(src);

if (sorted_keys == NULL)

return NULL;

if (PyList_Sort(sorted_keys) != 0) {

Py_DECREF(sorted_keys);

return NULL;

}

num_keys = PyList_GET_SIZE(sorted_keys);

for (key_i = 0; key_i < num_keys; key_i++) {

/* XXX this should probably be a macro in symtable.h */

long vi;

k = PyList_GET_ITEM(sorted_keys, key_i);

v = PyDict_GetItemWithError(src, k);

assert(v && PyLong_Check(v));

vi = PyLong_AS_LONG(v);

scope = (vi >> SCOPE_OFFSET) & SCOPE_MASK;

if (scope == scope_type || vi & flag) {

PyObject *item = PyLong_FromSsize_t(i);

if (item == NULL) {

Py_DECREF(sorted_keys);

Py_DECREF(dest);

return NULL;

}

i++;

if (PyDict_SetItem(dest, k, item) < 0) {

Py_DECREF(sorted_keys);

Py_DECREF(item);

Py_DECREF(dest);

return NULL;

}

Py_DECREF(item);

}

}

Py_DECREF(sorted_keys);

return dest;

}

static void

compiler_unit_free(struct compiler_unit *u)

{

Py_CLEAR(u->u_instr_sequence);

Py_CLEAR(u->u_ste);

Py_CLEAR(u->u_metadata.u_name);

Py_CLEAR(u->u_metadata.u_qualname);

Py_CLEAR(u->u_metadata.u_consts);

Py_CLEAR(u->u_metadata.u_names);

Py_CLEAR(u->u_metadata.u_varnames);

Py_CLEAR(u->u_metadata.u_freevars);

Py_CLEAR(u->u_metadata.u_cellvars);

Py_CLEAR(u->u_metadata.u_fasthidden);

Py_CLEAR(u->u_private);

Py_CLEAR(u->u_static_attributes);

PyMem_Free(u);

}

static int

compiler_maybe_add_static_attribute_to_class(struct compiler *c, expr_ty e)

{

assert(e->kind == Attribute_kind);

expr_ty attr_value = e->v.Attribute.value;

if (attr_value->kind != Name_kind ||

e->v.Attribute.ctx != Store ||

!_PyUnicode_EqualToASCIIString(attr_value->v.Name.id, "self"))

{

return SUCCESS;

}

Py_ssize_t stack_size = PyList_GET_SIZE(c->c_stack);

for (Py_ssize_t i = stack_size - 1; i >= 0; i--) {

PyObject *capsule = PyList_GET_ITEM(c->c_stack, i);

struct compiler_unit *u = (struct compiler_unit *)PyCapsule_GetPointer(

capsule, CAPSULE_NAME);

assert(u);

if (u->u_scope_type == COMPILER_SCOPE_CLASS) {

assert(u->u_static_attributes);

RETURN_IF_ERROR(PySet_Add(u->u_static_attributes, e->v.Attribute.attr));

break;

}

}

return SUCCESS;

}

static int

compiler_set_qualname(struct compiler *c)

{

Py_ssize_t stack_size;

struct compiler_unit *u = c->u;

PyObject *name, *base;

base = NULL;

stack_size = PyList_GET_SIZE(c->c_stack);

assert(stack_size >= 1);

if (stack_size > 1) {

int scope, force_global = 0;

struct compiler_unit *parent;

PyObject *mangled, *capsule;

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 (stack_size == 2) {

// If we're immediately within the module, we can skip

// the rest and just set the qualname to be the same as name.

u->u_metadata.u_qualname = Py_NewRef(u->u_metadata.u_name);

return SUCCESS;

}

capsule = PyList_GET_ITEM(c->c_stack, stack_size - 2);

parent = (struct compiler_unit *)PyCapsule_GetPointer(capsule, CAPSULE_NAME);

assert(parent);

}

if (u->u_scope_type == COMPILER_SCOPE_FUNCTION

|| u->u_scope_type == COMPILER_SCOPE_ASYNC_FUNCTION

|| u->u_scope_type == COMPILER_SCOPE_CLASS) {

assert(u->u_metadata.u_name);

mangled = _Py_Mangle(parent->u_private, u->u_metadata.u_name);

if (!mangled) {

return ERROR;

}

scope = _PyST_GetScope(parent->u_ste, mangled);

Py_DECREF(mangled);

assert(scope != GLOBAL_IMPLICIT);

if (scope == GLOBAL_EXPLICIT)

force_global = 1;

}

if (!force_global) {

if (parent->u_scope_type == COMPILER_SCOPE_FUNCTION

|| parent->u_scope_type == COMPILER_SCOPE_ASYNC_FUNCTION

|| parent->u_scope_type == COMPILER_SCOPE_LAMBDA)

{

_Py_DECLARE_STR(dot_locals, ".<locals>");

base = PyUnicode_Concat(parent->u_metadata.u_qualname,

&_Py_STR(dot_locals));

if (base == NULL) {

return ERROR;

}

}

else {

base = Py_NewRef(parent->u_metadata.u_qualname);

}

}

}

if (base != NULL) {

name = PyUnicode_Concat(base, _Py_LATIN1_CHR('.'));

Py_DECREF(base);

if (name == NULL) {

return ERROR;

}

PyUnicode_Append(&name, u->u_metadata.u_name);

if (name == NULL) {

return ERROR;

}

}

else {

name = Py_NewRef(u->u_metadata.u_name);

}

u->u_metadata.u_qualname = name;

return SUCCESS;

}

static int

stack_effect(int opcode, int oparg, int jump)

{

if (0 <= opcode && opcode <= MAX_REAL_OPCODE) {

if (_PyOpcode_Deopt[opcode] != opcode) {

// Specialized instructions are not supported.

return PY_INVALID_STACK_EFFECT;

}

int popped = _PyOpcode_num_popped(opcode, oparg);

int pushed = _PyOpcode_num_pushed(opcode, oparg);

if (popped < 0 || pushed < 0) {

return PY_INVALID_STACK_EFFECT;

}

return pushed - popped;

}

// Pseudo ops

switch (opcode) {

case POP_BLOCK:

case JUMP:

case JUMP_NO_INTERRUPT:

return 0;

case EXIT_INIT_CHECK:

return -1;

/* Exception handling pseudo-instructions */

case SETUP_FINALLY:

/* 0 in the normal flow.

return jump ? 1 : 0;

case SETUP_CLEANUP:

/* As SETUP_FINALLY, but pushes lasti as well */

return jump ? 2 : 0;

case SETUP_WITH:

/* 0 in the normal flow.

return jump ? 1 : 0;

case STORE_FAST_MAYBE_NULL:

return -1;

case LOAD_CLOSURE:

return 1;

case LOAD_METHOD:

return 1;

case LOAD_SUPER_METHOD:

case LOAD_ZERO_SUPER_METHOD:

case LOAD_ZERO_SUPER_ATTR:

return -1;

default:

return PY_INVALID_STACK_EFFECT;

}

return PY_INVALID_STACK_EFFECT; /* not reachable */

}

PyCompile_OpcodeStackEffectWithJump(int opcode, int oparg, int jump)

{

return stack_effect(opcode, oparg, jump);

}

PyCompile_OpcodeStackEffect(int opcode, int oparg)

{

return stack_effect(opcode, oparg, -1);

}

_PyCompile_OpcodeIsValid(int opcode)

{

return IS_VALID_OPCODE(opcode);

}

_PyCompile_OpcodeHasArg(int opcode)

{

return OPCODE_HAS_ARG(opcode);

}

_PyCompile_OpcodeHasConst(int opcode)

{

return OPCODE_HAS_CONST(opcode);

}

_PyCompile_OpcodeHasName(int opcode)

{

return OPCODE_HAS_NAME(opcode);

}

_PyCompile_OpcodeHasJump(int opcode)

{

return OPCODE_HAS_JUMP(opcode);

}

_PyCompile_OpcodeHasFree(int opcode)

{

return OPCODE_HAS_FREE(opcode);

}

_PyCompile_OpcodeHasLocal(int opcode)

{

return OPCODE_HAS_LOCAL(opcode);

}

_PyCompile_OpcodeHasExc(int opcode)

{

return IS_BLOCK_PUSH_OPCODE(opcode);

}

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

}

static Py_ssize_t

dict_add_o(PyObject *dict, PyObject *o)

{

PyObject *v;

Py_ssize_t arg;

if (PyDict_GetItemRef(dict, o, &v) < 0) {

return ERROR;

}

if (!v) {

arg = PyDict_GET_SIZE(dict);

v = PyLong_FromSsize_t(arg);

if (!v) {

return ERROR;

}

if (PyDict_SetItem(dict, o, v) < 0) {

Py_DECREF(v);

return ERROR;

}

}

else

arg = PyLong_AsLong(v);

Py_DECREF(v);

return arg;

}

static PyObject*

merge_consts_recursive(PyObject *const_cache, PyObject *o)

{

assert(PyDict_CheckExact(const_cache));

// None and Ellipsis are immortal objects, and key is the singleton.

// No need to merge object and key.

if (o == Py_None || o == Py_Ellipsis) {

return o;

}

PyObject *key = _PyCode_ConstantKey(o);

if (key == NULL) {

return NULL;

}

PyObject *t;

int res = PyDict_SetDefaultRef(const_cache, key, key, &t);

if (res != 0) {

// o was not inserted into const_cache. t is either the existing value

// or NULL (on error).

Py_DECREF(key);

return t;

}

Py_DECREF(t);

// We registered o in const_cache.

// When o is a tuple or frozenset, we want to merge its

// items too.

if (PyTuple_CheckExact(o)) {

Py_ssize_t len = PyTuple_GET_SIZE(o);

for (Py_ssize_t i = 0; i < len; i++) {

PyObject *item = PyTuple_GET_ITEM(o, i);

PyObject *u = merge_consts_recursive(const_cache, item);

if (u == NULL) {

Py_DECREF(key);

return NULL;

}

// See _PyCode_ConstantKey()

PyObject *v; // borrowed

if (PyTuple_CheckExact(u)) {

v = PyTuple_GET_ITEM(u, 1);

}

else {

v = u;

}

if (v != item) {

PyTuple_SET_ITEM(o, i, Py_NewRef(v));

Py_DECREF(item);

}

Py_DECREF(u);

}

}

else if (PyFrozenSet_CheckExact(o)) {

// *key* is tuple. And its first item is frozenset of

// constant keys.

// See _PyCode_ConstantKey() for detail.

assert(PyTuple_CheckExact(key));

assert(PyTuple_GET_SIZE(key) == 2);

Py_ssize_t len = PySet_GET_SIZE(o);

if (len == 0) { // empty frozenset should not be re-created.

return key;

}

PyObject *tuple = PyTuple_New(len);

if (tuple == NULL) {

Py_DECREF(key);

return NULL;

}

Py_ssize_t i = 0, pos = 0;

PyObject *item;

Py_hash_t hash;

while (_PySet_NextEntry(o, &pos, &item, &hash)) {

PyObject *k = merge_consts_recursive(const_cache, item);

if (k == NULL) {

Py_DECREF(tuple);

Py_DECREF(key);

return NULL;

}

PyObject *u;

if (PyTuple_CheckExact(k)) {

u = Py_NewRef(PyTuple_GET_ITEM(k, 1));

Py_DECREF(k);

}

else {

u = k;

}

PyTuple_SET_ITEM(tuple, i, u); // Steals reference of u.

i++;

}

// Instead of rewriting o, we create new frozenset and embed in the

// key tuple. Caller should get merged frozenset from the key tuple.

PyObject *new = PyFrozenSet_New(tuple);

Py_DECREF(tuple);

if (new == NULL) {

Py_DECREF(key);

return NULL;

}

assert(PyTuple_GET_ITEM(key, 1) == o);

Py_DECREF(o);

PyTuple_SET_ITEM(key, 1, new);

}

return key;

}

static Py_ssize_t

compiler_add_const(PyObject *const_cache, struct compiler_unit *u, PyObject *o)

{

assert(PyDict_CheckExact(const_cache));

PyObject *key = merge_consts_recursive(const_cache, o);

if (key == NULL) {

return ERROR;

}

Py_ssize_t arg = dict_add_o(u->u_metadata.u_consts, key);

Py_DECREF(key);

return arg;

}

static int

compiler_addop_load_const(PyObject *const_cache, struct compiler_unit *u, location loc, PyObject *o)

{

Py_ssize_t arg = compiler_add_const(const_cache, u, o);

if (arg < 0) {

return ERROR;

}

return codegen_addop_i(u->u_instr_sequence, LOAD_CONST, arg, loc);

}

static int

compiler_addop_o(struct compiler_unit *u, location loc,

int opcode, PyObject *dict, PyObject *o)