[kernel] Streaming ScopeBuilder

runtime/vm/parser.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/parser.h"
 #include "vm/flags.h"
 
 #ifndef DART_PRECOMPILED_RUNTIME
 
 #include "lib/invocation_mirror.h"
 #include "platform/utils.h"
 #include "vm/ast_transformer.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_entry.h"
-#include "vm/kernel_to_il.h"
 #include "vm/growable_array.h"
 #include "vm/handles.h"
 #include "vm/hash_table.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
+#include "vm/kernel_binary_flowgraph.h"
 #include "vm/longjump.h"
 #include "vm/native_arguments.h"
 #include "vm/native_entry.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/os.h"
 #include "vm/regexp_assembler.h"
 #include "vm/resolver.h"
 #include "vm/safepoint.h"
 #include "vm/scanner.h"
@@ skipping 197 matching lines @@
   UNREACHABLE();
 }
 
 
 kernel::ScopeBuildingResult* ParsedFunction::EnsureKernelScopes() {
   if (kernel_scopes_ == NULL) {
     kernel::TreeNode* node = NULL;
     if (function().kernel_function() != NULL) {
       node = static_cast<kernel::TreeNode*>(function().kernel_function());
     }
-    kernel::ScopeBuilder builder(this, node);
-    kernel_scopes_ = builder.BuildScopes();
+
+    intptr_t kernel_offset = -1;
+    const uint8_t* kernel_data = NULL;
+    intptr_t kernel_data_size = 0;
+    if (node != NULL) {
+      kernel::TreeNode* library_node = node;
+      if (node != NULL) {

[Kevin Millikin (Google), 2017/06/12 08:25:14]

We know node != NULL.  We can also move all this code into `if
(function().kernel_function() != NULL)` above.

+        const Function* parent = &function();
+        while (true) {

[Kevin Millikin (Google), 2017/06/12 08:25:14]

The nested loops make this seem complicated.  Isn't it just (1) loop up
parent_function until we come to a function without a parent_function, then (2)
get either the Kernel parent or parent's parent?

+          library_node =
+              static_cast<kernel::TreeNode*>(parent->kernel_function());
+          while (library_node != NULL && !library_node->IsLibrary()) {
+            if (library_node->IsMember()) {
+              library_node = kernel::Member::Cast(library_node)->parent();
+            } else if (library_node->IsClass()) {
+              library_node = kernel::Class::Cast(library_node)->parent();
+              break;
+            } else {
+              library_node = NULL;
+              break;
+            }
+          }
+          if (library_node != NULL) break;
+          parent = &Function::Handle(parent->parent_function());
+        }
+      }
+      if (library_node != NULL && library_node->IsLibrary()) {
+        kernel::Library* library = kernel::Library::Cast(library_node);
+        kernel_offset = node->kernel_offset();
+        kernel_data = library->kernel_data();
+        kernel_data_size = library->kernel_data_size();
+      }
+    }
+
+    kernel::StreamingScopeBuilder builder2(this, kernel_offset, kernel_data,
+                                           kernel_data_size);
+    kernel_scopes_ = builder2.BuildScopes();
   }
   return kernel_scopes_;
 }
 
 
 LocalVariable* ParsedFunction::EnsureExpressionTemp() {
   if (!has_expression_temp_var()) {
     LocalVariable* temp =
         new (Z) LocalVariable(function_.token_pos(), function_.token_pos(),
                               Symbols::ExprTemp(), Object::dynamic_type());
@@ skipping 14943 matching lines @@
     const ArgumentListNode& function_args,
     const LocalVariable* temp_for_last_arg,
     bool is_super_invocation) {
   UNREACHABLE();
   return NULL;
 }
 
 }  // namespace dart
 
 #endif  // DART_PRECOMPILED_RUNTIME