Remove unused code.

Author: markshannon

Lib/test/test_asyncio/test_tasks.py

@@ -322,7 +322,6 @@ async def runner():
         self.loop.run_until_complete(runner())
 
     def test_task_repr(self):
-        self.maxDiff = None
         self.loop.set_debug(False)
 
         async def notmuch():

Objects/genobject.c

@@ -1335,9 +1335,6 @@ compute_cr_origin(int origin_depth, InterpreterFrame *current_frame)
         return NULL;
     }
     frame = current_frame;
-    if (frame) {
-
-    }
     for (int i = 0; i < frame_count; ++i) {
         PyCodeObject *code = frame->f_code;
         PyObject *frameinfo = Py_BuildValue("OiO",

Python/ceval.c

@@ -1757,49 +1757,8 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, InterpreterFrame *frame, int thr
 #endif
 
     DISPATCH();
-check_eval_breaker:
-    {
-        assert(STACK_LEVEL() >= 0); /* else underflow */
-        assert(STACK_LEVEL() <= frame->f_code->co_stacksize);  /* else overflow */
-        assert(!_PyErr_Occurred(tstate));
-
-        /* Do periodic things.  Doing this every time through
-           the loop would add too much overhead, so we do it
-           only every Nth instruction.  We also do it if
-           ``pending.calls_to_do'' is set, i.e. when an asynchronous
-           event needs attention (e.g. a signal handler or
-           async I/O handler); see Py_AddPendingCall() and
-           Py_MakePendingCalls() above. */
-
-        if (_Py_atomic_load_relaxed(eval_breaker)) {
-            opcode = _Py_OPCODE(*next_instr);
-            if (opcode != BEFORE_ASYNC_WITH &&
-                opcode != SEND &&
-                _Py_OPCODE(next_instr[-1]) != SEND) {
-                /* Few cases where we skip running signal handlers and other
-                   pending calls:
-                   - If we're about to enter the 'with:'. It will prevent
-                     emitting a resource warning in the common idiom
-                     'with open(path) as file:'.
-                   - If we're about to enter the 'async with:'.
-                   - If we're about to enter the 'try:' of a try/finally (not
-                     *very* useful, but might help in some cases and it's
-                     traditional)
-                   - If we're resuming a chain of nested 'yield from' or
-                     'await' calls, then each frame is parked with YIELD_FROM
-                     as its next opcode. If the user hit control-C we want to
-                     wait until we've reached the innermost frame before
-                     running the signal handler and raising KeyboardInterrupt
-                     (see bpo-30039).
-                */
-                if (eval_frame_handle_pending(tstate) != 0) {
-                    goto error;
-                }
-             }
-        }
-
-    DISPATCH();
 
+    {
     /* Start instructions */
 #if USE_COMPUTED_GOTOS
     {

Python/frame.c

@@ -22,23 +22,9 @@ _PyFrame_Traverse(InterpreterFrame *frame, visitproc visit, void *arg)
     return 0;
 }
 
-static int
-frame_is_initialized(InterpreterFrame *frame)
-{
-    if (frame->f_lasti < 0) {
-        return 0;
-    }
-    int opcode = _Py_OPCODE(frame->f_code->co_firstinstr[frame->f_lasti]);
-    if (opcode == MAKE_CELL || opcode == COPY_FREE_VARS) {
-        return 0;
-    }
-    return 1;
-}
-
 PyFrameObject *
 _PyFrame_MakeAndSetFrameObject(InterpreterFrame *frame)
 {
-    assert(frame_is_initialized(frame));
     assert(frame->frame_obj == NULL);
     PyObject *error_type, *error_value, *error_traceback;
     PyErr_Fetch(&error_type, &error_value, &error_traceback);