Address comments from Matthias on previous CL

runtime/vm/debugger.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/debugger.h"
 
 #include "include/dart_api.h"
 
 #include "platform/address_sanitizer.h"
 
@@ skipping 692 matching lines @@
           innermost_begin_pos = var_info.begin_pos;
           context_level_ = var_info.index();
         }
       }
     }
     ASSERT(context_level_ >= 0);
   }
   return context_level_;
 }
 
-RawObject* ActivationFrame::GetAsyncCompleter() {
+
+RawObject* ActivationFrame::GetAsyncContextVariable(const String& name) {
   if (!function_.IsAsyncClosure()) {
     return Object::null();
   }
   GetVarDescriptors();
   intptr_t var_desc_len = var_descriptors_.Length();
-  if (!live_frame_) {
-    // Not actually on the stack. Pull it out of the closure's context.
-    intptr_t var_desc_len = var_descriptors_.Length();
-    for (intptr_t i = 0; i < var_desc_len; i++) {
-      RawLocalVarDescriptors::VarInfo var_info;
-      var_descriptors_.GetInfo(i, &var_info);
+  for (intptr_t i = 0; i < var_desc_len; i++) {
+    RawLocalVarDescriptors::VarInfo var_info;
+    var_descriptors_.GetInfo(i, &var_info);
+    if (var_descriptors_.GetName(i) == name.raw()) {
       const int8_t kind = var_info.kind();
-      if (var_descriptors_.GetName(i) == Symbols::AsyncCompleter().raw()) {
+      if (!live_frame_) {
         ASSERT(kind == RawLocalVarDescriptors::kContextVar);
-        ASSERT(!ctx_.IsNull());
-        return ctx_.At(var_info.index());
       }
-    }
-  } else {
-    ASSERT(fp() != 0);
-    // On the stack.
-    for (intptr_t i = 0; i < var_desc_len; i++) {
-      RawLocalVarDescriptors::VarInfo var_info;
-      var_descriptors_.GetInfo(i, &var_info);
-      if (var_descriptors_.GetName(i) == Symbols::AsyncCompleter().raw()) {
-        const int8_t kind = var_info.kind();
-        if (kind == RawLocalVarDescriptors::kStackVar) {
-          return GetStackVar(var_info.index());
-        } else {
-          ASSERT(kind == RawLocalVarDescriptors::kContextVar);
-          return GetContextVar(var_info.scope_id, var_info.index());
+      if (kind == RawLocalVarDescriptors::kStackVar) {
+        return GetStackVar(var_info.index());
+      } else {
+        ASSERT(kind == RawLocalVarDescriptors::kContextVar);
+        if (!live_frame_) {
+          ASSERT(!ctx_.IsNull());
+          return ctx_.At(var_info.index());
         }
+        return GetContextVar(var_info.scope_id, var_info.index());
       }
     }
   }
   return Object::null();
 }
 
 
+RawObject* ActivationFrame::GetAsyncCompleter() {
+  return GetAsyncContextVariable(Symbols::AsyncCompleter());
+}
+
+
 RawObject* ActivationFrame::GetAsyncCompleterAwaiter(const Object& completer) {
   const Class& sync_completer_cls = Class::Handle(completer.clazz());
   ASSERT(!sync_completer_cls.IsNull());
   const Class& completer_cls = Class::Handle(sync_completer_cls.SuperClass());
   const Field& future_field =
       Field::Handle(completer_cls.LookupInstanceFieldAllowPrivate(
           Symbols::CompleterFuture()));
   ASSERT(!future_field.IsNull());
   Instance& future = Instance::Handle();
   future ^= Instance::Cast(completer).GetField(future_field);
   ASSERT(!future.IsNull());
   const Class& future_cls = Class::Handle(future.clazz());
   ASSERT(!future_cls.IsNull());
   const Field& awaiter_field = Field::Handle(
       future_cls.LookupInstanceFieldAllowPrivate(Symbols::_Awaiter()));
   ASSERT(!awaiter_field.IsNull());
   return future.GetField(awaiter_field);
 }
 
 
 RawObject* ActivationFrame::GetAsyncStreamControllerStream() {
-  if (!function_.IsAsyncGenClosure()) {
-    return Object::null();
-  }
-  GetVarDescriptors();
-  intptr_t var_desc_len = var_descriptors_.Length();
-  if (!live_frame_) {
-    // Not actually on the stack. Pull it out of the closure's context.
-    intptr_t var_desc_len = var_descriptors_.Length();
-    for (intptr_t i = 0; i < var_desc_len; i++) {
-      RawLocalVarDescriptors::VarInfo var_info;
-      var_descriptors_.GetInfo(i, &var_info);
-      const int8_t kind = var_info.kind();
-      if (var_descriptors_.GetName(i) == Symbols::ControllerStream().raw()) {
-        ASSERT(kind == RawLocalVarDescriptors::kContextVar);
-        ASSERT(!ctx_.IsNull());
-        return ctx_.At(var_info.index());
-      }
-    }
-  } else {
-    ASSERT(fp() != 0);
-    // On the stack.
-    for (intptr_t i = 0; i < var_desc_len; i++) {
-      RawLocalVarDescriptors::VarInfo var_info;
-      var_descriptors_.GetInfo(i, &var_info);
-      if (var_descriptors_.GetName(i) == Symbols::ControllerStream().raw()) {
-        const int8_t kind = var_info.kind();
-        if (kind == RawLocalVarDescriptors::kStackVar) {
-          return GetStackVar(var_info.index());
-        } else {
-          ASSERT(kind == RawLocalVarDescriptors::kContextVar);
-          return GetContextVar(var_info.scope_id, var_info.index());
-        }
-      }
-    }
-  }
-  return Object::null();
+  return GetAsyncContextVariable(Symbols::ControllerStream());
 }
 
 
 RawObject* ActivationFrame::GetAsyncStreamControllerStreamAwaiter(
     const Object& stream) {
   const Class& stream_cls = Class::Handle(stream.clazz());
   ASSERT(!stream_cls.IsNull());
   const Class& stream_impl_cls = Class::Handle(stream_cls.SuperClass());
   const Field& awaiter_field = Field::Handle(
       stream_impl_cls.LookupInstanceFieldAllowPrivate(Symbols::_Awaiter()));
@@ skipping 19 matching lines @@
 
 bool ActivationFrame::HandlesException(const Instance& exc_obj) {
   intptr_t try_index = TryIndex();
   if (try_index < 0) {
     return false;
   }
   ExceptionHandlers& handlers = ExceptionHandlers::Handle();
   Array& handled_types = Array::Handle();
   AbstractType& type = Type::Handle();
   const TypeArguments& no_instantiator = TypeArguments::Handle();
-  const intptr_t try_index_threshold = CatchClauseNode::kImplicitAsyncTryIndex;
   const bool is_async =
       function().IsAsyncClosure() || function().IsAsyncGenClosure();
   handlers = code().exception_handlers();
   ASSERT(!handlers.IsNull());
   intptr_t num_handlers_checked = 0;
-  while (try_index >= try_index_threshold) {
+  while (try_index != CatchClauseNode::kInvalidTryIndex) {
     // Detect circles in the exception handler data.
     num_handlers_checked++;
     ASSERT(num_handlers_checked <= handlers.num_entries());
     // Only consider user written handlers for async methods.
     if (!is_async || !handlers.IsGenerated(try_index)) {
       handled_types = handlers.GetHandledTypes(try_index);
       const intptr_t num_types = handled_types.Length();
       for (intptr_t k = 0; k < num_types; k++) {
         type ^= handled_types.At(k);
         ASSERT(!type.IsNull());
@@ skipping 3289 matching lines @@
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart