[esnext] Fix various callsites to use is_resumable, not is_generator

src/debug/debug.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/debug/debug.h"
 
 #include "src/api.h"
 #include "src/arguments.h"
 #include "src/bootstrapper.h"
 #include "src/code-stubs.h"
@@ skipping 1313 matching lines @@
                                       "prepare for break points");
 
   bool is_interpreted = shared->HasBytecodeArray();
 
   {
     // TODO(yangguo): with bytecode, we still walk the heap to find all
     // optimized code for the function to deoptimize. We can probably be
     // smarter here and avoid the heap walk.
     HeapIterator iterator(isolate_->heap());
     HeapObject* obj;
-    bool include_generators = !is_interpreted && shared->is_generator();
+    bool include_generators = !is_interpreted && shared->is_resumable();

[caitp (gmail), 2016/05/20 13:35:56]

I imagine this fixes what could have been broken debugger tests, had they been
written. No generator-specific tests were added in
35c28ce0a742e58346d2dea009428cacd442040d, though. Yang might be able to point
out failures corrected by this?

[Dan Ehrenberg, 2016/05/20 14:59:19]

Seems like this will come up if you add a breakpoint to an async function after
an await while the function is actually still awaiting the result. Let's write a
test for this (but maybe it can come in a follow-on patch?)

 
     while ((obj = iterator.next())) {
       if (obj->IsJSFunction()) {
         JSFunction* function = JSFunction::cast(obj);
         if (!function->Inlines(*shared)) continue;
         if (function->code()->kind() == Code::OPTIMIZED_FUNCTION) {
           Deoptimizer::DeoptimizeFunction(function);
         }
         if (is_interpreted) continue;
         if (function->shared() == *shared) functions.Add(handle(function));
       } else if (include_generators && obj->IsJSGeneratorObject()) {
+        // This case handles async functions as well, as they use generator
+        // objects for in-progress async function execution.
         JSGeneratorObject* generator_obj = JSGeneratorObject::cast(obj);
         if (!generator_obj->is_suspended()) continue;
         JSFunction* function = generator_obj->function();
         if (!function->Inlines(*shared)) continue;
         int pc_offset = generator_obj->continuation();
         int index =
             ComputeContinuationIndexFromPcOffset(function->code(), pc_offset);
         generator_obj->set_continuation(index);
         suspended_generators.Add(handle(generator_obj));
       }
@@ skipping 1230 matching lines @@
 }
 
 
 void LockingCommandMessageQueue::Clear() {
   base::LockGuard<base::Mutex> lock_guard(&mutex_);
   queue_.Clear();
 }
 
 }  // namespace internal
 }  // namespace v8