Remember deopt-id -> context-level mappings in var descriptors.

runtime/vm/scopes.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/scopes.h"
 
 #include "vm/object.h"
 #include "vm/stack_frame.h"
 #include "vm/symbols.h"
 
@@ skipping 266 matching lines @@
     return false;
   }
   if (str.raw() == Symbols::AsyncStackTraceVar().raw()) {
     // Keep :async_stack_trace for asynchronous debugging.
     return false;
   }
   return str.CharAt(0) == ':';
 }
 
 
-RawLocalVarDescriptors* LocalScope::GetVarDescriptors(const Function& func) {
+RawLocalVarDescriptors* LocalScope::GetVarDescriptors(
+    const Function& func,
+    ZoneGrowableArray<intptr_t>* context_level_array) {
   GrowableArray<VarDesc> vars(8);
+
+  // Record deopt-id -> context-level mappings, using ranges of deopt-ids with
+  // the same context-level.
+  for (intptr_t start = 0; start < context_level_array->length();) {

[Vyacheslav Egorov (Google), 2017/05/31 14:29:51]

Maybe context_level_array tuples need to be sorted by deopt_id before processing
it here to prevent dependence on IR was generated (e.g. that AST order induces
deopt_order)? 

[rmacnak, 2017/05/31 18:03:17]

We don't depend on the order the AST is processed or the order the IR is
generated. We do depend on the flow graph builders to have the correct context
level at the time a deopt id is allocated. The range encoding depends on the
pairs having sorted deopt ids, which happens because we allocate deopt ids
sequentially and record them as they are allocated. We assert in L303 that deopt
ids are ascending. Added a comment explicitly noting this.

[Vyacheslav Egorov (Google), 2017/06/01 12:32:41]

Yeah, I am not sure what I was thinking. GetNextDeoptId obviously returns deopt
ids in the ascending order. 

+    intptr_t start_deopt_id = (*context_level_array)[start];
+    intptr_t start_context_level = (*context_level_array)[start + 1];
+    intptr_t end = start;
+    intptr_t end_deopt_id = start_deopt_id;
+    for (intptr_t peek = start + 2; peek < context_level_array->length();
+         peek += 2) {
+      intptr_t peek_deopt_id = (*context_level_array)[peek];
+      intptr_t peek_context_level = (*context_level_array)[peek + 1];
+      ASSERT(peek_deopt_id > end_deopt_id);
+      if (peek_context_level != start_context_level) break;
+      end = peek;
+      end_deopt_id = peek_deopt_id;
+    }
+
+    VarDesc desc;
+    desc.name = &Symbols::Empty();  // No name.
+    desc.info.set_kind(RawLocalVarDescriptors::kContextLevel);
+    desc.info.scope_id = 0;
+    desc.info.begin_pos = TokenPosition(start_deopt_id);
+    desc.info.end_pos = TokenPosition(end_deopt_id);
+    desc.info.set_index(start_context_level);
+    vars.Add(desc);
+
+    start = end + 2;
+  }
+
   // First enter all variables from scopes of outer functions.
   const ContextScope& context_scope =
       ContextScope::Handle(func.context_scope());
   if (!context_scope.IsNull()) {
     ASSERT(func.IsLocalFunction());
     for (int i = 0; i < context_scope.num_variables(); i++) {
       String& name = String::Handle(context_scope.NameAt(i));
       RawLocalVarDescriptors::VarInfoKind kind;
       if (!IsFilteredIdentifier(name)) {
         kind = RawLocalVarDescriptors::kContextVar;
@@ skipping 27 matching lines @@
   }
   return var_desc.raw();
 }
 
 
 // Add visible variables that are declared in this scope to vars, then
 // collect visible variables of children, followed by siblings.
 void LocalScope::CollectLocalVariables(GrowableArray<VarDesc>* vars,
                                        int16_t* scope_id) {
   (*scope_id)++;
-  if (num_context_variables() > 0) {
-    VarDesc desc;
-    desc.name = &Symbols::Empty();  // No name.
-    desc.info.set_kind(RawLocalVarDescriptors::kContextLevel);
-    desc.info.scope_id = *scope_id;
-    desc.info.begin_pos = begin_token_pos();
-    desc.info.end_pos = end_token_pos();
-    desc.info.set_index(context_level());
-    vars->Add(desc);
-  }
   for (int i = 0; i < this->variables_.length(); i++) {
     LocalVariable* var = variables_[i];
     if ((var->owner() == this) && !var->is_invisible()) {
       if (var->name().raw() == Symbols::CurrentContextVar().raw()) {
         // This is the local variable in which the function saves its
         // own context before calling a closure function.
         VarDesc desc;
         desc.name = &var->name();
         desc.info.set_kind(RawLocalVarDescriptors::kSavedCurrentContext);
         desc.info.scope_id = 0;
@@ skipping 346 matching lines @@
     return fixed_parameter_count - (index() - kParamEndSlotFromFp);
   } else {
     // Shift negative indexes so that the lowest one is 0 (they are still
     // non-positive).
     return fixed_parameter_count - (index() - kFirstLocalSlotFromFp);
   }
 }
 
 
 }  // namespace dart