python · iritkatriel · Sep 10, 2021 · Sep 15, 2021 · Sep 30, 2021 · Oct 27, 2021
diff --git a/Doc/library/dis.rst b/Doc/library/dis.rst
@@ -859,6 +859,11 @@ All of the following opcodes use their arguments.
 
    Pushes ``co_consts[consti]`` onto the stack.
 
+.. opcode:: LOAD_NONE
+
+   Pushes ``None`` onto the stack.
+
+   .. versionadded:: 3.11
 
 .. opcode:: LOAD_NAME (namei)
 

diff --git a/Include/opcode.h b/Include/opcode.h
diff --git a/Lib/dis.py b/Lib/dis.py
@@ -27,6 +27,7 @@
 MAKE_FUNCTION_FLAGS = ('defaults', 'kwdefaults', 'annotations', 'closure')
 
 LOAD_CONST = opmap['LOAD_CONST']
+LOAD_NONE = opmap['LOAD_NONE']
 
 def _try_compile(source, name):
     """Attempts to compile the given source, first as an expression and
@@ -331,6 +332,8 @@ def _get_const_value(op, arg, co_consts):
     if op == LOAD_CONST:
         if co_consts is not None:
             argval = co_consts[arg]
+    elif op == LOAD_NONE:
+        argval = None
     return argval
 
 def _get_const_info(op, arg, co_consts):
@@ -574,7 +577,7 @@ def _find_imports(co):
         if op == IMPORT_NAME and i >= 2:
             from_op = opargs[i-1]
             level_op = opargs[i-2]
-            if (from_op[0] in hasconst and level_op[0] in hasconst):
+            if from_op[0] in hasconst and level_op[0] in hasconst:
                 level = _get_const_value(level_op[0], level_op[1], consts)
                 fromlist = _get_const_value(from_op[0], from_op[1], consts)
                 yield (names[oparg], level, fromlist)

diff --git a/Lib/opcode.py b/Lib/opcode.py
@@ -122,6 +122,8 @@ def jabs_op(name, op):
 def_op('INPLACE_AND', 77)
 def_op('INPLACE_XOR', 78)
 def_op('INPLACE_OR', 79)
+def_op('LOAD_NONE', 80)
+hasconst.append(80)
 
 def_op('LIST_TO_TUPLE', 82)
 def_op('RETURN_VALUE', 83)

diff --git a/Lib/test/test_ast.py b/Lib/test/test_ast.py
@@ -1723,20 +1723,19 @@ def test_get_docstring(self):
         tree = ast.parse("'docstring'\nx = 1")
         self.assertEqual(ast.get_docstring(tree), 'docstring')
 
-    def get_load_const(self, tree):
-        # Compile to bytecode, disassemble and get parameter of LOAD_CONST
+    def get_values_for_opname(self, tree, opname):
+        # Compile to bytecode, disassemble and get parameter of opname
         # instructions
         co = compile(tree, '<string>', 'exec')
         consts = []
         for instr in dis.get_instructions(co):
-            if instr.opname == 'LOAD_CONST':
+            if instr.opname == opname:
                 consts.append(instr.argval)
         return consts
 
     @support.cpython_only
     def test_load_const(self):
-        consts = [None,
-                  True, False,
+        consts = [True, False,
                   124,
                   2.0,
                   3j,
@@ -1746,11 +1745,15 @@ def test_load_const(self):
 
         code = '\n'.join(['x={!r}'.format(const) for const in consts])
         code += '\nx = ...'
-        consts.extend((Ellipsis, None))
+        consts.append(Ellipsis)
+
+        code += '\nx = None'  # LOAD_NONE, so not added to consts
 
         tree = ast.parse(code)
-        self.assertEqual(self.get_load_const(tree),
+        self.assertEqual(self.get_values_for_opname(tree, 'LOAD_CONST'),
                          consts)
+        self.assertEqual(self.get_values_for_opname(tree, 'LOAD_NONE'),
+                         [None, None])  # One None from return at the end
 
         # Replace expression nodes with constants
         for assign, const in zip(tree.body, consts):
@@ -1759,8 +1762,11 @@ def test_load_const(self):
             ast.copy_location(new_node, assign.value)
             assign.value = new_node
 
-        self.assertEqual(self.get_load_const(tree),
+        self.assertEqual(self.get_values_for_opname(tree, 'LOAD_CONST'),
                          consts)
+        self.assertEqual(self.get_values_for_opname(tree, 'LOAD_NONE'),
+                         [None, None])  # One None from return at the end
+
 
     def test_literal_eval(self):
         tree = ast.parse("1 + 2")

diff --git a/Lib/test/test_code.py b/Lib/test/test_code.py
@@ -87,7 +87,7 @@
 freevars: ()
 nlocals: 0
 flags: 3
-consts: ("'doc string'", 'None')
+consts: ("'doc string'",)
 
 >>> def keywordonly_args(a,b,*,k1):
 ...     return a,b,k1
@@ -377,7 +377,7 @@ def test_co_positions_artificial_instructions(self):
             ],
             [
                 ("PUSH_EXC_INFO", None),
-                ("LOAD_CONST", None), # artificial 'None'
+                ("LOAD_NONE", None),  # artificial 'None'
                 ("STORE_NAME", "e"),  # XX: we know the location for this
                 ("DELETE_NAME", "e"),
                 ("RERAISE", 1),

diff --git a/Lib/test/test_compile.py b/Lib/test/test_compile.py
@@ -758,7 +758,7 @@ def unused_block_while_else():
         for func in funcs:
             opcodes = list(dis.get_instructions(func))
             self.assertLessEqual(len(opcodes), 3)
-            self.assertEqual('LOAD_CONST', opcodes[-2].opname)
+            self.assertEqual('LOAD_NONE', opcodes[-2].opname)
             self.assertEqual(None, opcodes[-2].argval)
             self.assertEqual('RETURN_VALUE', opcodes[-1].opname)
 
@@ -777,7 +777,7 @@ def continue_in_while():
         for func in funcs:
             opcodes = list(dis.get_instructions(func))
             self.assertEqual(2, len(opcodes))
-            self.assertEqual('LOAD_CONST', opcodes[0].opname)
+            self.assertEqual('LOAD_NONE', opcodes[0].opname)
             self.assertEqual(None, opcodes[0].argval)
             self.assertEqual('RETURN_VALUE', opcodes[1].opname)