"fastlocal" -> "localsplus"

python · ericsnowcurrently · Jun 3, 2021 · May 20, 2021 · May 26, 2021 · May 21, 2021
commit 235e4aa3f9a9dd0978edbea1eb1ce61f3b59a266
diff --git a/Include/cpython/code.h b/Include/cpython/code.h
@@ -18,8 +18,8 @@ typedef struct _PyOpcache _PyOpcache;
 
 
 // These are duplicated from pycore_code.h.
-typedef unsigned char _PyFastLocalKind;
-typedef _PyFastLocalKind *_PyFastLocalKinds;
+typedef unsigned char _PyLocalsPlusKind;
+typedef _PyLocalsPlusKind *_PyLocalsPlusKinds;
 
 /* Bytecode object */
 struct PyCodeObject {
@@ -60,8 +60,8 @@ struct PyCodeObject {
     int co_kwonlyargcount;      /* #keyword only arguments */
     int co_stacksize;           /* #entries needed for evaluation stack */
     int co_firstlineno;         /* first source line number */
-    PyObject *co_fastlocalnames;  /* tuple mapping fastlocalsplus to names */
-    _PyFastLocalKinds co_fastlocalkinds; /* array mapping to local kinds */
+    PyObject *co_localsplusnames;  /* tuple mapping offsets to names */
+    _PyLocalsPlusKinds co_localspluskinds; /* array mapping to local kinds */
     PyObject *co_filename;      /* unicode (where it was loaded from) */
     PyObject *co_name;          /* unicode (name, for reference) */
     PyObject *co_linetable;     /* string (encoding addr<->lineno mapping) See
@@ -71,7 +71,7 @@ struct PyCodeObject {
     /* These fields are set with computed values on new code objects. */
 
     int *co_cell2arg;           /* Maps cell vars which are arguments. */
-    // redundant values (derived from co_fastlocalnames and co_fastlocalkinds)
+    // redundant values (derived from co_localsplusnames and co_localspluskinds)
     int co_nlocalsplus;         /* number of local + cell + free variables */
     int co_nlocals;             /* number of local variables */
     int co_ncellvars;           /* number of cell variables */

diff --git a/Include/internal/pycore_code.h b/Include/internal/pycore_code.h
@@ -27,24 +27,24 @@ struct _PyOpcache {
 
 
 // We would use an enum if C let us specify the storage type.
-typedef unsigned char _PyFastLocalKind;
-/* Note that these all fit within _PyFastLocalKind, as do combinations. */
+typedef unsigned char _PyLocalsPlusKind;
+/* Note that these all fit within _PyLocalsPlusKind, as do combinations. */
 // Later, we will use the smaller numbers to differentiate the different
 // kinds of locals (e.g. pos-only arg, varkwargs, local-only).
 #define CO_FAST_LOCAL   0x20
 #define CO_FAST_CELL    0x40
 #define CO_FAST_FREE    0x80
 
-typedef _PyFastLocalKind *_PyFastLocalKinds;
+typedef _PyLocalsPlusKind *_PyLocalsPlusKinds;
 
 static inline int
-_PyCode_InitFastLocalKinds(int num, _PyFastLocalKinds *pkinds)
+_PyCode_InitLocalsPlusKinds(int num, _PyLocalsPlusKinds *pkinds)
 {
     if (num == 0) {
         *pkinds = NULL;
         return 0;
     }
-    _PyFastLocalKinds kinds = PyMem_NEW(_PyFastLocalKind, num);
+    _PyLocalsPlusKinds kinds = PyMem_NEW(_PyLocalsPlusKind, num);
     if (kinds == NULL) {
         PyErr_NoMemory();
         return -1;
@@ -54,7 +54,7 @@ _PyCode_InitFastLocalKinds(int num, _PyFastLocalKinds *pkinds)
 }
 
 static inline void
-_PyCode_ClearFastLocalKinds(_PyFastLocalKinds kinds)
+_PyCode_ClearLocalsPlusKinds(_PyLocalsPlusKinds kinds)
 {
     if (kinds != NULL) {
         PyMem_Free(kinds);
@@ -77,8 +77,8 @@ struct _PyCodeConstructor {
     PyObject *names;
 
     /* mapping frame offsets to information */
-    PyObject *fastlocalnames;
-    _PyFastLocalKinds fastlocalkinds;
+    PyObject *localsplusnames;
+    _PyLocalsPlusKinds localspluskinds;
 
     /* args (within varnames) */
     int argcount;

diff --git a/Lib/dis.py b/Lib/dis.py
@@ -279,7 +279,7 @@ def get_instructions(x, *, first_line=None):
     else:
         line_offset = 0
     return _get_instructions_bytes(co.co_code,
-                                   co._get_fastlocalnames(), co.co_nlocals,
+                                   co._get_localsplusnames(), co.co_nlocals,
                                    co.co_names, co.co_consts,
                                    linestarts, line_offset)
 
@@ -336,7 +336,7 @@ def parse_exception_table(code):
     except StopIteration:
         return entries
 
-def _get_instructions_bytes(code, fastlocalnames=None, nlocals=0,
+def _get_instructions_bytes(code, localsplusnames=None, nlocals=0,
                             names=None, constants=None,
                             linestarts=None, line_offset=0,
                             exception_entries=()):
@@ -378,12 +378,12 @@ def _get_instructions_bytes(code, fastlocalnames=None, nlocals=0,
                 argval = offset + 2 + arg*2
                 argrepr = "to " + repr(argval)
             elif op in haslocal:
-                argval, argrepr = _get_name_info(arg, fastlocalnames)
+                argval, argrepr = _get_name_info(arg, localsplusnames)
             elif op in hascompare:
                 argval = cmp_op[arg]
                 argrepr = argval
             elif op in hasfree:
-                argval, argrepr = _get_name_info(arg + nlocals, fastlocalnames)
+                argval, argrepr = _get_name_info(arg + nlocals, localsplusnames)
             elif op == FORMAT_VALUE:
                 argval, argrepr = FORMAT_VALUE_CONVERTERS[arg & 0x3]
                 argval = (argval, bool(arg & 0x4))
@@ -403,7 +403,7 @@ def disassemble(co, lasti=-1, *, file=None):
     linestarts = dict(findlinestarts(co))
     exception_entries = parse_exception_table(co)
     _disassemble_bytes(co.co_code, lasti,
-                       co._get_fastlocalnames(), co.co_nlocals,
+                       co._get_localsplusnames(), co.co_nlocals,
                        co.co_names, co.co_consts, linestarts, file=file,
                        exception_entries=exception_entries)
 
@@ -418,7 +418,7 @@ def _disassemble_recursive(co, *, file=None, depth=None):
                 print("Disassembly of %r:" % (x,), file=file)
                 _disassemble_recursive(x, file=file, depth=depth)
 
-def _disassemble_bytes(code, lasti=-1, fastlocalnames=None, nlocals=0,
+def _disassemble_bytes(code, lasti=-1, localsplusnames=None, nlocals=0,
                        names=None, constants=None, linestarts=None,
                        *, file=None, line_offset=0, exception_entries=()):
     # Omit the line number column entirely if we have no line number info
@@ -436,7 +436,7 @@ def _disassemble_bytes(code, lasti=-1, fastlocalnames=None, nlocals=0,
         offset_width = len(str(maxoffset))
     else:
         offset_width = 4
-    for instr in _get_instructions_bytes(code, fastlocalnames, nlocals, names,
+    for instr in _get_instructions_bytes(code, localsplusnames, nlocals, names,
                                          constants, linestarts,
                                          line_offset=line_offset, exception_entries=exception_entries):
         new_source_line = (show_lineno and
@@ -527,7 +527,7 @@ def __init__(self, x, *, first_line=None, current_offset=None):
     def __iter__(self):
         co = self.codeobj
         return _get_instructions_bytes(co.co_code,
-                                       co._get_fastlocalnames(), co.co_nlocals,
+                                       co._get_localsplusnames(), co.co_nlocals,
                                        co.co_names, co.co_consts,
                                        self._linestarts,
                                        line_offset=self._line_offset,
@@ -557,7 +557,7 @@ def dis(self):
             offset = -1
         with io.StringIO() as output:
             _disassemble_bytes(co.co_code,
-                               fastlocalnames=co._get_fastlocalnames(),
+                               localsplusnames=co._get_localsplusnames(),
                                nlocals=co.co_nlocals,
                                names=co.co_names, constants=co.co_consts,
                                linestarts=self._linestarts,

diff --git a/Objects/clinic/codeobject.c.h b/Objects/clinic/codeobject.c.h