[kernel] Delete most of the AST

runtime/vm/kernel_binary_flowgraph.cc

 // Copyright (c) 2016, 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/kernel_binary_flowgraph.h"
 
 #include "vm/compiler.h"
 #include "vm/longjump.h"
 #include "vm/object_store.h"
 
@@ skipping 800 matching lines @@
       // TODO(jensj): From kernel_binary.cc
       // forinstmt->variable_->set_end_position(forinstmt->position_);
       ExitScope(position, builder_->reader_->max_position());
       --depth_.loop_;
       --depth_.for_in_;
       return;
     }
     case kSwitchStatement: {
       AddSwitchVariable();
       VisitExpression();                           // read condition.
-      int num_cases = builder_->ReadListLength();  // read number of cases.
-      for (intptr_t i = 0; i < num_cases; ++i) {
-        int num_expressions =
+      int case_count = builder_->ReadListLength();  // read number of cases.
+      for (intptr_t i = 0; i < case_count; ++i) {
+        int expression_count =
             builder_->ReadListLength();  // read number of expressions.
-        for (intptr_t j = 0; j < num_expressions; ++j) {
+        for (intptr_t j = 0; j < expression_count; ++j) {
           builder_->ReadPosition();  // read jth position.
           VisitExpression();         // read jth expression.
         }
         builder_->ReadBool();  // read is_default.
         VisitStatement();      // read body.
       }
       return;
     }
     case kContinueSwitchStatement:
       builder_->ReadUInt();  // read target_index.
@@ skipping 24 matching lines @@
     case kTryCatch: {
       ++depth_.try_;
       AddTryVariables();
       VisitStatement();  // read body.
       --depth_.try_;
 
       ++depth_.catch_;
       AddCatchVariables();
 
       builder_->ReadBool();  // read any_catch_needs_stack_trace.
-      intptr_t num_catches =
+      intptr_t catch_count =
           builder_->ReadListLength();  // read number of catches.
-      for (intptr_t i = 0; i < num_catches; ++i) {
+      for (intptr_t i = 0; i < catch_count; ++i) {
         PositionScope scope(builder_->reader_);
         intptr_t offset = builder_->ReaderOffset();  // Catch has no tag.
 
         EnterScope(offset);
 
         VisitDartType();            // Read the guard.
         tag = builder_->ReadTag();  // read first part of exception.
         if (tag == kSomething) {
           VisitVariableDeclaration();  // read exception.
         }
@@ skipping 54 matching lines @@
       VisitVariableDeclaration();        // read variable declaration.
       HandleLocalFunction(offset);       // read function node.
       return;
     }
     default:
       UNREACHABLE();
   }
 }
 
 void StreamingScopeBuilder::VisitArguments() {
-  builder_->ReadUInt();  // read num_arguments.
+  builder_->ReadUInt();  // read argument_count.
 
   // Types
   intptr_t list_length = builder_->ReadListLength();  // read list length.
   for (intptr_t i = 0; i < list_length; ++i) {
     VisitDartType();  // read ith type.
   }
 
   // Positional.
   list_length = builder_->ReadListLength();  // read list length.
   for (intptr_t i = 0; i < list_length; ++i) {
@@ skipping 1388 matching lines @@
 RawObject* StreamingConstantEvaluator::EvaluateConstConstructorCall(
     const dart::Class& type_class,
     const TypeArguments& type_arguments,
     const Function& constructor,
     const Object& argument) {
   // Factories have one extra argument: the type arguments.
   // Constructors have 1 extra arguments: receiver.
   const int kTypeArgsLen = 0;
   const int kNumArgs = 1;
   const int kNumExtraArgs = 1;
-  const int num_arguments = kNumArgs + kNumExtraArgs;
+  const int argument_count = kNumArgs + kNumExtraArgs;
   const Array& arg_values =
-      Array::Handle(Z, Array::New(num_arguments, Heap::kOld));
+      Array::Handle(Z, Array::New(argument_count, Heap::kOld));
   Instance& instance = Instance::Handle(Z);
   if (!constructor.IsFactory()) {
     instance = Instance::New(type_class, Heap::kOld);
     if (!type_arguments.IsNull()) {
       ASSERT(type_arguments.IsInstantiated());
       instance.SetTypeArguments(
           TypeArguments::Handle(Z, type_arguments.Canonicalize()));
     }
     arg_values.SetAt(0, instance);
   } else {
     // Prepend type_arguments to list of arguments to factory.
     ASSERT(type_arguments.IsZoneHandle());
     arg_values.SetAt(0, type_arguments);
   }
   arg_values.SetAt((0 + kNumExtraArgs), argument);
   const Array& args_descriptor =
-      Array::Handle(Z, ArgumentsDescriptor::New(kTypeArgsLen, num_arguments,
+      Array::Handle(Z, ArgumentsDescriptor::New(kTypeArgsLen, argument_count,
                                                 Object::empty_array()));
   const Object& result = Object::Handle(
       Z, DartEntry::InvokeFunction(constructor, arg_values, args_descriptor));
   ASSERT(!result.IsError());
   if (constructor.IsFactory()) {
     // The factory method returns the allocated object.
     instance ^= result.raw();
   }
   return H.Canonicalize(instance);
 }
@@ skipping 285 matching lines @@
     body += LoadStaticField();
   }
   body += Return(TokenPosition::kNoSource);
 
   return new (Z)
       FlowGraph(*parsed_function(), flow_graph_builder_->graph_entry_,
                 flow_graph_builder_->next_block_id_ - 1);
 }
 
 void StreamingFlowGraphBuilder::SetupDefaultParameterValues() {
-  intptr_t num_optional_parameters =
+  intptr_t optional_parameter_count =
       parsed_function()->function().NumOptionalParameters();
-  if (num_optional_parameters > 0) {
+  if (optional_parameter_count > 0) {
     ZoneGrowableArray<const Instance*>* default_values =
-        new ZoneGrowableArray<const Instance*>(Z, num_optional_parameters);
+        new ZoneGrowableArray<const Instance*>(Z, optional_parameter_count);
 
     AlternativeReadingScope alt(reader_);
     FunctionNodeHelper function_node_helper(this);
     function_node_helper.ReadUntilExcluding(
         FunctionNodeHelper::kPositionalParameters);
 
     if (parsed_function()->function().HasOptionalNamedParameters()) {
       // List of positional.
       intptr_t list_length = ReadListLength();  // read list length.
       for (intptr_t i = 0; i < list_length; ++i) {
         SkipVariableDeclaration();  // read ith variable declaration.
       }
 
       // List of named.
       list_length = ReadListLength();  // read list length.
-      ASSERT(num_optional_parameters == list_length);
+      ASSERT(optional_parameter_count == list_length);
       ASSERT(!parsed_function()->function().HasOptionalPositionalParameters());
       for (intptr_t i = 0; i < list_length; ++i) {
         Instance* default_value;
 
         // Read ith variable declaration
         VariableDeclarationHelper helper(this);
         helper.ReadUntilExcluding(VariableDeclarationHelper::kInitializer);
         Tag tag = ReadTag();  // read (first part of) initializer.
         if (tag == kSomething) {
           // this will (potentially) read the initializer,
           // but reset the position.
           default_value =
               &constant_evaluator_.EvaluateExpression(ReaderOffset());
           SkipExpression();  // read (actual) initializer.
         } else {
           default_value = &Instance::ZoneHandle(Z, Instance::null());
         }
         default_values->Add(default_value);
       }
     } else {
       // List of positional.
       intptr_t list_length = ReadListLength();  // read list length.
       ASSERT(list_length == function_node_helper.required_parameter_count_ +
-                                num_optional_parameters);
+                                optional_parameter_count);
       ASSERT(parsed_function()->function().HasOptionalPositionalParameters());
       for (intptr_t i = 0; i < function_node_helper.required_parameter_count_;
            ++i) {
         SkipVariableDeclaration();  // read ith variable declaration.
       }
-      for (intptr_t i = 0; i < num_optional_parameters; ++i) {
+      for (intptr_t i = 0; i < optional_parameter_count; ++i) {
         Instance* default_value;
 
         // Read ith variable declaration
         VariableDeclarationHelper helper(this);
         helper.ReadUntilExcluding(VariableDeclarationHelper::kInitializer);
         Tag tag = ReadTag();  // read (first part of) initializer.
         if (tag == kSomething) {
           // this will (potentially) read the initializer,
           // but reset the position.
           default_value =
@@ skipping 245 matching lines @@
                      argument_names);
 
   // Return the result.
   body += Return(function_node_helper.end_position_);
 
   return new (Z)
       FlowGraph(*parsed_function(), flow_graph_builder_->graph_entry_,
                 flow_graph_builder_->next_block_id_ - 1);
 }
 
-static bool IsGetMainClosure(const String& name) {
-  if (name.Length() < 16) return false;
-  const char* cstr = "_getMainClosure@";
-  for (intptr_t i = 0; i < 16; ++i) {
-    if (name.CharAt(i) != cstr[i]) return false;
-  }
-  return true;
-}
-
 FlowGraph* StreamingFlowGraphBuilder::BuildGraphOfFunction(
-    bool is_in_builtin_library_toplevel,
     intptr_t constructor_class_parent_offset) {
   const Function& dart_function = parsed_function()->function();
   TargetEntryInstr* normal_entry = flow_graph_builder_->BuildTargetEntry();
   flow_graph_builder_->graph_entry_ = new (Z) GraphEntryInstr(
       *parsed_function(), normal_entry, flow_graph_builder_->osr_id_);
 
   SetupDefaultParameterValues();
 
   Fragment body;
   if (!dart_function.is_native())
@@ skipping 141 matching lines @@
     body += StoreLocal(TokenPosition::kNoSource, async_stack_trace_var);
     body += Drop();
   }
 
   bool has_body = ReadTag() == kSomething;  // read first part of body.
 
   if (dart_function.is_native()) {
     body += flow_graph_builder_->NativeFunctionBody(first_parameter_offset,
                                                     dart_function);
   } else if (has_body) {
-    if (is_in_builtin_library_toplevel &&
-        IsGetMainClosure(dart::String::Handle(Z, dart_function.name()))) {
-      body += BuildGetMainClosure();
-    } else {
-      body += BuildStatement();  // read body.
-    }
+    body += BuildStatement();  // read body.
   }
   if (body.is_open()) {
     body += NullConstant();
     body += Return(dart_function.end_token_pos());
   }
 
   // If functions body contains any yield points build switch statement that
   // selects a continuation point based on the value of :await_jump_var.
   if (!yield_continuations().is_empty()) {
     // The code we are building will be executed right after we enter
@@ skipping 101 matching lines @@
   if (NeedsDebugStepCheck(dart_function, function_node_helper.position_)) {
     const intptr_t current_context_depth = flow_graph_builder_->context_depth_;
     flow_graph_builder_->context_depth_ = 0;
     // If a switch was added above: Start the switch by injecting a debuggable
     // safepoint so stepping over an await works.
     // If not, still start the body with a debuggable safepoint to ensure
     // breaking on a method always happens, even if there are no
     // assignments/calls/runtimecalls in the first basic block.
     // Place this check at the last parameter to ensure parameters
     // are in scope in the debugger at method entry.
-    const int num_params = dart_function.NumParameters();
+    const int parameter_count = dart_function.NumParameters();
     TokenPosition check_pos = TokenPosition::kNoSource;
-    if (num_params > 0) {
+    if (parameter_count > 0) {
       LocalScope* scope = parsed_function()->node_sequence()->scope();
-      const LocalVariable& parameter = *scope->VariableAt(num_params - 1);
+      const LocalVariable& parameter = *scope->VariableAt(parameter_count - 1);
       check_pos = parameter.token_pos();
     }
     if (!check_pos.IsDebugPause()) {
       // No parameters or synthetic parameters.
       check_pos = function_node_helper.position_;
       ASSERT(check_pos.IsDebugPause());
     }
 
     // TODO(29737): This sequence should be generated in order.
     body = DebugStepCheck(check_pos) + body;
     flow_graph_builder_->context_depth_ = current_context_depth;
   }
 
   normal_entry->LinkTo(body.entry);
 
   GraphEntryInstr* graph_entry = flow_graph_builder_->graph_entry_;
   // When compiling for OSR, use a depth first search to find the OSR
   // entry and make graph entry jump to it instead of normal entry.
   // Catch entries are always considered reachable, even if they
   // become unreachable after OSR.
   if (flow_graph_builder_->osr_id_ != Compiler::kNoOSRDeoptId) {
     graph_entry->RelinkToOsrEntry(Z, flow_graph_builder_->next_block_id_);
   }
   return new (Z) FlowGraph(*parsed_function(), graph_entry,
                            flow_graph_builder_->next_block_id_ - 1);
 }
 
-Fragment StreamingFlowGraphBuilder::BuildGetMainClosure() {
-  // _getMainClosure in dart:_builtin. Compile that one specially here.
-  const dart::Library& builtin =
-      dart::Library::Handle(Z, I->object_store()->builtin_library());
-  const Object& main =
-      Object::Handle(Z, builtin.LookupObjectAllowPrivate(dart::String::Handle(
-                            Z, dart::String::New("main"))));
-  if (main.IsField()) {
-    UNIMPLEMENTED();
-  } else if (main.IsFunction()) {
-    const Function& function = Function::Cast(main);
-    if (function.kind() == RawFunction::kRegularFunction) {
-      const Function& closure_function =
-          Function::Handle(Z, function.ImplicitClosureFunction());
-      const Instance& closure =
-          Instance::ZoneHandle(Z, closure_function.ImplicitStaticClosure());
-      Fragment instructions = Constant(closure);
-      instructions += Return(TokenPosition::kNoSource);
-      return instructions;
-    } else {
-      UNIMPLEMENTED();
-    }
-  } else {
-    UNIMPLEMENTED();
-  }
-  return Fragment();
-}
-
 FlowGraph* StreamingFlowGraphBuilder::BuildGraph(intptr_t kernel_offset) {
   const Function& function = parsed_function()->function();
 
   // Setup a [ActiveClassScope] and a [ActiveMemberScope] which will be used
   // e.g. for type translation.
   const dart::Class& klass =
       dart::Class::Handle(zone_, parsed_function()->function().Owner());
-  bool is_in_builtin_library_toplevel =
-      klass.library() == I->object_store()->builtin_library() &&
-      klass.IsTopLevel();
 
   Function& outermost_function = Function::Handle(Z);
   intptr_t outermost_kernel_offset = -1;
   intptr_t parent_class_offset = -1;
   DiscoverEnclosingElements(Z, function, &outermost_function,
                             &outermost_kernel_offset, &parent_class_offset);
   // Use [klass]/[kernel_class] as active class.  Type parameters will get
   // resolved via [kernel_class] unless we are nested inside a static factory
   // in which case we will use [member].
   intptr_t class_type_parameters = 0;
@@ skipping 29 matching lines @@
   SetOffset(kernel_offset);
 
   switch (function.kind()) {
     case RawFunction::kClosureFunction:
     case RawFunction::kRegularFunction:
     case RawFunction::kGetterFunction:
     case RawFunction::kSetterFunction: {
       ReadUntilFunctionNode();  // read until function node.
       return function.IsImplicitClosureFunction()
                  ? BuildGraphOfImplicitClosureFunction(function)
-                 : BuildGraphOfFunction(is_in_builtin_library_toplevel);
+                 : BuildGraphOfFunction();
     }
     case RawFunction::kConstructor: {
       bool is_factory = function.IsFactory();
       if (is_factory) {
         ReadUntilFunctionNode();  // read until function node.
-        return BuildGraphOfFunction(is_in_builtin_library_toplevel);
+        return BuildGraphOfFunction();
       } else {
         // Constructor: Pass offset to parent class.
         return BuildGraphOfFunction(
-            is_in_builtin_library_toplevel,
             ReadUntilFunctionNode());  // read until function node.
       }
     }
     case RawFunction::kImplicitGetter:
     case RawFunction::kImplicitStaticFinalGetter:
     case RawFunction::kImplicitSetter: {
       return IsStaticInitializer(function, Z)
                  ? BuildGraphOfStaticFieldInitializer()
                  : BuildGraphOfFieldAccessor(scopes()->setter_value);
     }
@@ skipping 603 matching lines @@
     }
     case kForInStatement:
     case kAsyncForInStatement:
       ReadPosition();             // read position.
       SkipVariableDeclaration();  // read variable.
       SkipExpression();           // read iterable.
       SkipStatement();            // read body.
       return;
     case kSwitchStatement: {
       SkipExpression();                  // read condition.
-      int num_cases = ReadListLength();  // read number of cases.
-      for (intptr_t i = 0; i < num_cases; ++i) {
-        int num_expressions = ReadListLength();  // read number of expressions.
-        for (intptr_t j = 0; j < num_expressions; ++j) {
+      int case_count = ReadListLength();  // read number of cases.
+      for (intptr_t i = 0; i < case_count; ++i) {
+        int expression_count = ReadListLength();  // read number of expressions.
+        for (intptr_t j = 0; j < expression_count; ++j) {
           ReadPosition();    // read jth position.
           SkipExpression();  // read jth expression.
         }
         ReadBool();       // read is_default.
         SkipStatement();  // read body.
       }
       return;
     }
     case kContinueSwitchStatement:
       ReadUInt();  // read target_index.
       return;
     case kIfStatement:
       SkipExpression();  // read condition.
       SkipStatement();   // read then.
       SkipStatement();   // read otherwise.
       return;
     case kReturnStatement: {
       ReadPosition();       // read position
       Tag tag = ReadTag();  // read (first part of) expression.
       if (tag == kSomething) {
         SkipExpression();  // read (rest of) expression.
       }
       return;
     }
     case kTryCatch: {
       SkipStatement();  // read body.
       ReadBool();       // read any_catch_needs_stack_trace.
-      intptr_t num_catches = ReadListLength();  // read number of catches.
-      for (intptr_t i = 0; i < num_catches; ++i) {
+      intptr_t catch_count = ReadListLength();  // read number of catches.
+      for (intptr_t i = 0; i < catch_count; ++i) {
         SkipDartType();   // read guard.
         tag = ReadTag();  // read first part of exception.
         if (tag == kSomething) {
           SkipVariableDeclaration();  // read exception.
         }
         tag = ReadTag();  // read first part of stack trace.
         if (tag == kSomething) {
           SkipVariableDeclaration();  // read stack trace.
         }
         SkipStatement();  // read body.
       }
       return;
     }
     case kTryFinally:
       SkipStatement();  // read body.
       SkipStatement();  // read finalizer.
       return;
-    case kYieldStatement:
-      ReadPosition();    // read position.
+    case kYieldStatement: {
+      TokenPosition position = ReadPosition();  // read position.
+      record_yield_position(position);
       ReadByte();        // read flags.
       SkipExpression();  // read expression.
       return;
+    }
     case kVariableDeclaration:
       SkipVariableDeclaration();  // read variable declaration.
       return;
     case kFunctionDeclaration:
       ReadPosition();             // read position.
       SkipVariableDeclaration();  // read variable.
       SkipFunctionNode();         // read function node.
       return;
     default:
       UNREACHABLE();
@@ skipping 24 matching lines @@
     SkipStringReference();  // read ith name index.
     SkipExpression();       // read ith expression.
   }
 }
 
 void StreamingFlowGraphBuilder::SkipVariableDeclaration() {
   VariableDeclarationHelper helper(this);
   helper.ReadUntilExcluding(VariableDeclarationHelper::kEnd);
 }
 
+void StreamingFlowGraphBuilder::SkipLibraryCombinator() {
+  ReadBool();                        // read is_show.
+  intptr_t name_count = ReadUInt();  // read list length.
+  for (intptr_t j = 0; j < name_count; ++j) {
+    ReadUInt();  // read ith entry of name_indices.
+  }
+}
+
+void StreamingFlowGraphBuilder::SkipLibraryDependency() {
+  ReadFlags();                                   // read flags.
+  SkipListOfExpressions();                       // Read annotations.
+  ReadCanonicalNameReference();                  // read target_reference.
+  ReadStringReference();                         // read name_index.
+  intptr_t combinator_count = ReadListLength();  // read list length.
+  for (intptr_t i = 0; i < combinator_count; ++i) {
+    SkipLibraryCombinator();
+  }
+}
+
+void StreamingFlowGraphBuilder::SkipLibraryTypedef() {
+  SkipCanonicalNameReference();  // read canonical name.
+  ReadPosition();                // read position.
+  SkipStringReference();         // read name index.
+  ReadUInt();                    // read source_uri_index.
+  SkipListOfDartTypes();         // read type parameters.
+  SkipDartType();                // read type.
+}
+
 TokenPosition StreamingFlowGraphBuilder::ReadPosition(bool record) {
-  return reader_->ReadPosition(record);
+  TokenPosition position = reader_->ReadPosition();
+  if (record) {
+    record_token_position(position);
+  }
+  return position;
+}
+
+void StreamingFlowGraphBuilder::record_token_position(TokenPosition position) {
+  if (record_for_script_id_ == current_script_id_ &&
+      record_token_positions_into_ != NULL) {
+    record_token_positions_into_->Add(position.value());
+  }
+}
+
+void StreamingFlowGraphBuilder::record_yield_position(TokenPosition position) {
+  if (record_for_script_id_ == current_script_id_ &&
+      record_yield_positions_into_ != NULL) {
+    record_yield_positions_into_->Add(position.value());
+  }
 }
 
 Tag StreamingFlowGraphBuilder::ReadTag(uint8_t* payload) {
   return reader_->ReadTag(payload);
 }
 
 Tag StreamingFlowGraphBuilder::PeekTag(uint8_t* payload) {
   return reader_->PeekTag(payload);
 }
 
@@ skipping 220 matching lines @@
 }
 
 Fragment StreamingFlowGraphBuilder::StaticCall(TokenPosition position,
                                                const Function& target,
                                                intptr_t argument_count,
                                                const Array& argument_names) {
   return flow_graph_builder_->StaticCall(position, target, argument_count,
                                          argument_names);
 }
 
-Fragment StreamingFlowGraphBuilder::InstanceCall(TokenPosition position,
-                                                 const dart::String& name,
-                                                 Token::Kind kind,
-                                                 intptr_t argument_count,
-                                                 intptr_t num_args_checked) {
+Fragment StreamingFlowGraphBuilder::InstanceCall(
+    TokenPosition position,
+    const dart::String& name,
+    Token::Kind kind,
+    intptr_t argument_count,
+    intptr_t checked_argument_count) {
   return flow_graph_builder_->InstanceCall(position, name, kind, argument_count,
-                                           num_args_checked);
+                                           checked_argument_count);
 }
 
 Fragment StreamingFlowGraphBuilder::ThrowException(TokenPosition position) {
   return flow_graph_builder_->ThrowException(position);
 }
 
 Fragment StreamingFlowGraphBuilder::BooleanNegate() {
   return flow_graph_builder_->BooleanNegate();
 }
 
 Fragment StreamingFlowGraphBuilder::TranslateInstantiatedTypeArguments(
     const TypeArguments& type_arguments) {
   return flow_graph_builder_->TranslateInstantiatedTypeArguments(
       type_arguments);
 }
 
 Fragment StreamingFlowGraphBuilder::StrictCompare(Token::Kind kind,
                                                   bool number_check) {
   return flow_graph_builder_->StrictCompare(kind, number_check);
 }
 
 Fragment StreamingFlowGraphBuilder::AllocateObject(TokenPosition position,
                                                    const dart::Class& klass,
                                                    intptr_t argument_count) {
   return flow_graph_builder_->AllocateObject(position, klass, argument_count);
 }
 
-Fragment StreamingFlowGraphBuilder::InstanceCall(TokenPosition position,
-                                                 const dart::String& name,
-                                                 Token::Kind kind,
-                                                 intptr_t argument_count,
-                                                 const Array& argument_names,
-                                                 intptr_t num_args_checked) {
+Fragment StreamingFlowGraphBuilder::InstanceCall(
+    TokenPosition position,
+    const dart::String& name,
+    Token::Kind kind,
+    intptr_t argument_count,
+    const Array& argument_names,
+    intptr_t checked_argument_count) {
   return flow_graph_builder_->InstanceCall(position, name, kind, argument_count,
-                                           argument_names, num_args_checked);
+                                           argument_names,
+                                           checked_argument_count);
 }
 
 Fragment StreamingFlowGraphBuilder::StoreLocal(TokenPosition position,
                                                LocalVariable* variable) {
   return flow_graph_builder_->StoreLocal(position, variable);
 }
 
 Fragment StreamingFlowGraphBuilder::StoreStaticField(TokenPosition position,
                                                      const dart::Field& field) {
   return flow_graph_builder_->StoreStaticField(position, field);
@@ skipping 509 matching lines @@
 
   instructions += PushArgument();  // push receiver as argument.
 
   // TODO(28109) Support generic methods in the VM or reify them away.
   Array& argument_names = Array::ZoneHandle(Z);
   intptr_t argument_count;
   instructions +=
       BuildArguments(&argument_names, &argument_count);  // read arguments.
   ++argument_count;
 
-  intptr_t num_args_checked = 1;
+  intptr_t checked_argument_count = 1;
   // If we have a special operation (e.g. +/-/==) we mark both arguments as
   // to be checked.
   if (token_kind != Token::kILLEGAL) {
     ASSERT(argument_count <= 2);
-    num_args_checked = argument_count;
+    checked_argument_count = argument_count;
   }
 
   instructions += InstanceCall(position, name, token_kind, argument_count,
-                               argument_names, num_args_checked);
+                               argument_names, checked_argument_count);
   // Later optimization passes assume that result of a x.[]=(...) call is not
   // used. We must guarantee this invariant because violation will lead to an
   // illegal IL once we replace x.[]=(...) with a sequence that does not
   // actually produce any value. See http://dartbug.com/29135 for more details.
   if (name.raw() == Symbols::AssignIndexToken().raw()) {
     instructions += Drop();
     instructions += NullConstant();
   }
 
   SkipCanonicalNameReference();  // read unused "interface_target_reference".
@@ skipping 1025 matching lines @@
 
   loop_depth_dec();
   for_in_depth_dec();
   return Fragment(instructions.entry, loop_exit);
 }
 
 Fragment StreamingFlowGraphBuilder::BuildSwitchStatement() {
   // We need the number of cases. So start by getting that, then go back.
   intptr_t offset = ReaderOffset();
   SkipExpression();                  // temporarily skip condition
-  int num_cases = ReadListLength();  // read number of cases.
+  int case_count = ReadListLength();  // read number of cases.
   SetOffset(offset);
 
-  SwitchBlock block(flow_graph_builder_, num_cases);
+  SwitchBlock block(flow_graph_builder_, case_count);
 
   // Instead of using a variable we should reuse the expression on the stack,
   // since it won't be assigned again, we don't need phi nodes.
   Fragment head_instructions = BuildExpression();  // read condition.
   head_instructions +=
       StoreLocal(TokenPosition::kNoSource, scopes()->switch_variable);
   head_instructions += Drop();
 
-  num_cases = ReadListLength();  // read number of cases.
+  case_count = ReadListLength();  // read number of cases.
 
   // Phase 1: Generate bodies and try to find out whether a body will be target
   // of a jump due to:
   //   * `continue case_label`
   //   * `case e1: case e2: body`
-  Fragment* body_fragments = new Fragment[num_cases];
-  intptr_t* case_expression_offsets = new intptr_t[num_cases];
+  Fragment* body_fragments = new Fragment[case_count];
+  intptr_t* case_expression_offsets = new intptr_t[case_count];
   int default_case = -1;
 
-  for (intptr_t i = 0; i < num_cases; ++i) {
+  for (intptr_t i = 0; i < case_count; ++i) {
     case_expression_offsets[i] = ReaderOffset();
-    int num_expressions = ReadListLength();  // read number of expressions.
-    for (intptr_t j = 0; j < num_expressions; ++j) {
+    int expression_count = ReadListLength();  // read number of expressions.
+    for (intptr_t j = 0; j < expression_count; ++j) {
       ReadPosition();    // read jth position.
       SkipExpression();  // read jth expression.
     }
     bool is_default = ReadBool();  // read is_default.
     if (is_default) default_case = i;
     Fragment& body_fragment = body_fragments[i] =
         BuildStatement();  // read body.
 
     if (body_fragment.entry == NULL) {
       // Make a NOP in order to ensure linking works properly.
       body_fragment = NullConstant();
       body_fragment += Drop();
     }
 
     // The Dart language specification mandates fall-throughs in [SwitchCase]es
     // to be runtime errors.
-    if (!is_default && body_fragment.is_open() && (i < (num_cases - 1))) {
+    if (!is_default && body_fragment.is_open() && (i < (case_count - 1))) {
       const dart::Class& klass = dart::Class::ZoneHandle(
           Z, dart::Library::LookupCoreClass(Symbols::FallThroughError()));
       ASSERT(!klass.IsNull());
       const dart::Function& constructor = dart::Function::ZoneHandle(
           Z, klass.LookupConstructorAllowPrivate(
                  H.DartSymbol("FallThroughError._create")));
       ASSERT(!constructor.IsNull());
       const dart::String& url = H.DartString(
           parsed_function()->function().ToLibNamePrefixedQualifiedCString(),
           Heap::kOld);
@@ skipping 26 matching lines @@
     //
     //    switch(expr) {
     //      case a:
     //      case b:
     //        <stmt-body>
     //    }
     //
     // This means that the <stmt-body> will have more than 1 incoming edge (one
     // from `a == expr` and one from `a != expr && b == expr`). The
     // `block.Destination()` records the additional jump.
-    if (num_expressions > 1) {
+    if (expression_count > 1) {
       block.DestinationDirect(i);
     }
   }
 
   intptr_t end_offset = ReaderOffset();
 
   // Phase 2: Generate everything except the real bodies:
   //   * jump directly to a body (if there is no jumper)
   //   * jump to a wrapper block which jumps to the body (if there is a jumper)
   Fragment current_instructions = head_instructions;
-  for (intptr_t i = 0; i < num_cases; ++i) {
+  for (intptr_t i = 0; i < case_count; ++i) {
     SetOffset(case_expression_offsets[i]);
-    int num_expressions = ReadListLength();  // read length of expressions.
+    int expression_count = ReadListLength();  // read length of expressions.
 
     if (i == default_case) {
-      ASSERT(i == (num_cases - 1));
+      ASSERT(i == (case_count - 1));
 
       // Evaluate the conditions for the default [SwitchCase] just for the
       // purpose of potentially triggering a compile-time error.
 
-      for (intptr_t j = 0; j < num_expressions; ++j) {
+      for (intptr_t j = 0; j < expression_count; ++j) {
         ReadPosition();  // read jth position.
         // this reads the expression, but doesn't skip past it.
         constant_evaluator_.EvaluateExpression(ReaderOffset());
         SkipExpression();  // read jth expression.
       }
 
       if (block.HadJumper(i)) {
         // There are several branches to the body, so we will make a goto to
         // the join block (and prepend a join instruction to the real body).
         JoinEntryInstr* join = block.DestinationDirect(i);
         current_instructions += Goto(join);
 
         current_instructions = Fragment(current_instructions.entry, join);
         current_instructions += body_fragments[i];
       } else {
         current_instructions += body_fragments[i];
       }
     } else {
       JoinEntryInstr* body_join = NULL;
       if (block.HadJumper(i)) {
         body_join = block.DestinationDirect(i);
         body_fragments[i] = Fragment(body_join) + body_fragments[i];
       }
 
-      for (intptr_t j = 0; j < num_expressions; ++j) {
+      for (intptr_t j = 0; j < expression_count; ++j) {
         TargetEntryInstr* then;
         TargetEntryInstr* otherwise;
 
         TokenPosition position = ReadPosition();  // read jth position.
         current_instructions +=
             Constant(constant_evaluator_.EvaluateExpression(ReaderOffset()));
         SkipExpression();  // read jth expression.
         current_instructions += PushArgument();
         current_instructions += LoadLocal(scopes()->switch_variable);
         current_instructions += PushArgument();
         current_instructions +=
             InstanceCall(position, Symbols::EqualOperator(), Token::kEQ,
                          /*argument_count=*/2,
-                         /*num_args_checked=*/2);
+                         /*checked_argument_count=*/2);
         current_instructions += BranchIfTrue(&then, &otherwise, false);
 
         Fragment then_fragment(then);
 
         if (body_join != NULL) {
           // There are several branches to the body, so we will make a goto to
           // the join block (the real body has already been prepended with a
           // join instruction).
           then_fragment += Goto(body_join);
         } else {
           // There is only a signle branch to the body, so we will just append
           // the body fragment.
           then_fragment += body_fragments[i];
         }
 
         current_instructions = Fragment(otherwise);
       }
     }
   }
 
-  if (num_cases > 0 && default_case < 0) {
+  if (case_count > 0 && default_case < 0) {
     // There is no default, which means we have an open [current_instructions]
     // (which is a [TargetEntryInstruction] for the last "otherwise" branch).
     //
     // Furthermore the last [SwitchCase] can be open as well.  If so, we need
     // to join these two.
-    Fragment& last_body = body_fragments[num_cases - 1];
+    Fragment& last_body = body_fragments[case_count - 1];
     if (last_body.is_open()) {
       ASSERT(current_instructions.is_open());
       ASSERT(current_instructions.current->IsTargetEntry());
 
       // Join the last "otherwise" branch and the last [SwitchCase] fragment.
       JoinEntryInstr* join = BuildJoinEntry();
       current_instructions += Goto(join);
       last_body += Goto(join);
 
       current_instructions = Fragment(join);
@@ skipping 103 matching lines @@
   {
     TryCatchBlock block(flow_graph_builder_, try_handler_index);
     try_body += BuildStatement();  // read body.
     try_body += Goto(after_try);
   }
   try_depth_dec();
 
   bool needs_stacktrace = ReadBool();  // read any_catch_needs_stack_trace
 
   catch_depth_inc();
-  intptr_t num_catches = ReadListLength();  // read number of catches.
+  intptr_t catch_count = ReadListLength();  // read number of catches.
   const Array& handler_types =
-      Array::ZoneHandle(Z, Array::New(num_catches, Heap::kOld));
+      Array::ZoneHandle(Z, Array::New(catch_count, Heap::kOld));
   Fragment catch_body =
       CatchBlockEntry(handler_types, try_handler_index, needs_stacktrace);
   // Fill in the body of the catch.
-  for (intptr_t i = 0; i < num_catches; ++i) {
+  for (intptr_t i = 0; i < catch_count; ++i) {
     intptr_t catch_offset = ReaderOffset();  // Catch has no tag.
     Tag tag = PeekTag();                     // peek guard type.
     AbstractType* type_guard = NULL;
     if (tag != kDynamicType) {
       type_guard = &T.BuildType();  // read guard.
       handler_types.SetAt(i, *type_guard);
     } else {
       SkipDartType();  // read guard.
       handler_types.SetAt(i, Object::dynamic_type());
     }
@@ skipping 452 matching lines @@
       total_parameter_count - positional_parameters_count;
 
   function.set_num_fixed_parameters(extra_parameters +
                                     required_parameter_count);
   if (named_parameters_count > 0) {
     function.SetNumOptionalParameters(named_parameters_count, false);
   } else {
     function.SetNumOptionalParameters(
         positional_parameters_count - required_parameter_count, true);
   }
-  intptr_t num_parameters = extra_parameters + total_parameter_count;
+  intptr_t parameter_count = extra_parameters + total_parameter_count;
   function.set_parameter_types(
-      Array::Handle(Z, Array::New(num_parameters, Heap::kOld)));
+      Array::Handle(Z, Array::New(parameter_count, Heap::kOld)));
   function.set_parameter_names(
-      Array::Handle(Z, Array::New(num_parameters, Heap::kOld)));
+      Array::Handle(Z, Array::New(parameter_count, Heap::kOld)));
   intptr_t pos = 0;
   if (is_method) {
     ASSERT(!klass.IsNull());
     function.SetParameterTypeAt(pos, H.GetCanonicalType(klass));
     function.SetParameterNameAt(pos, Symbols::This());
     pos++;
   } else if (is_closure) {
     function.SetParameterTypeAt(pos, AbstractType::dynamic_type());
     function.SetParameterNameAt(pos, Symbols::ClosureParameter());
     pos++;
@@ skipping 121 matching lines @@
   for (intptr_t i = 0; i < list_length; ++i) {
     // this will (potentially) read the expression, but reset the position.
     Instance& value = constant_evaluator_.EvaluateExpression(ReaderOffset());
     SkipExpression();  // read (actual) initializer.
     metadata_values.SetAt(i, value);
   }
 
   return metadata_values.raw();
 }
 
+void StreamingFlowGraphBuilder::CollectTokenPositionsFor(
+    intptr_t script_index,
+    GrowableArray<intptr_t>* record_token_positions_in,
+    GrowableArray<intptr_t>* record_yield_positions_in) {
+  record_token_positions_into_ = record_token_positions_in;
+  record_yield_positions_into_ = record_yield_positions_in;
+  record_for_script_id_ = script_index;
+
+  // Get offset for 1st library.
+  SetOffset(reader_->size() - 4);
+  intptr_t library_count = reader_->ReadUInt32();
+
+  SetOffset(reader_->size() - 4 - 4 * library_count);
+  intptr_t offset = reader_->ReadUInt32();
+
+  SetOffset(offset);
+  for (intptr_t i = 0; i < library_count; ++i) {
+    LibraryHelper library_helper(this);
+    library_helper.ReadUntilExcluding(LibraryHelper::kEnd);
+  }
+
+  record_token_positions_into_ = NULL;
+  record_yield_positions_into_ = NULL;
+  record_for_script_id_ = -1;
+}
+
+intptr_t StreamingFlowGraphBuilder::SourceTableSize() {
+  AlternativeReadingScope alt(reader_);
+  SetOffset(reader_->size() - 4);
+  intptr_t library_count = reader_->ReadUInt32();
+  SetOffset(reader_->size() - 4 - 4 * library_count - 3 * 4);
+  SetOffset(reader_->ReadUInt32());  // read source table offset.
+  return ReadUInt();                 // read source table size.
+}
+
+String& StreamingFlowGraphBuilder::SourceTableUriFor(intptr_t index) {
+  AlternativeReadingScope alt(reader_);
+  SetOffset(reader_->size() - 4);
+  intptr_t library_count = reader_->ReadUInt32();
+  SetOffset(reader_->size() - 4 - 4 * library_count - 3 * 4);
+  SetOffset(reader_->ReadUInt32());  // read source table offset.
+  intptr_t size = ReadUInt();        // read source table size.
+  intptr_t start = 0;
+  intptr_t end = -1;
+  for (intptr_t i = 0; i < size; ++i) {
+    intptr_t offset = ReadUInt();
+    if (i == index - 1) {
+      start = offset;
+    } else if (i == index) {
+      end = offset;
+    }
+  }
+  intptr_t end_offset = ReaderOffset();
+  return H.DartString(reader_->buffer() + end_offset + start, end - start,
+                      Heap::kOld);
+}
+
+String& StreamingFlowGraphBuilder::GetSourceFor(intptr_t index) {
+  AlternativeReadingScope alt(reader_);
+  SetOffset(reader_->size() - 4);
+  intptr_t library_count = reader_->ReadUInt32();
+  SetOffset(reader_->size() - 4 - 4 * library_count - 3 * 4);
+  SetOffset(reader_->ReadUInt32());  // read source table offset.
+  intptr_t size = ReadUInt();        // read source table size.
+  intptr_t uris_size = 0;
+  for (intptr_t i = 0; i < size; ++i) {
+    uris_size = ReadUInt();
+  }
+  SkipBytes(uris_size);
+
+  // Read the source code strings and line starts.
+  for (intptr_t i = 0; i < size; ++i) {
+    intptr_t length = ReadUInt();
+    if (index == i) {
+      return H.DartString(reader_->buffer() + ReaderOffset(), length,
+                          Heap::kOld);
+    }
+    SkipBytes(length);
+    intptr_t line_count = ReadUInt();
+    for (intptr_t j = 0; j < line_count; ++j) {
+      ReadUInt();
+    }
+  }
+
+  return String::Handle(String::null());
+}
+
+Array& StreamingFlowGraphBuilder::GetLineStartsFor(intptr_t index) {
+  AlternativeReadingScope alt(reader_);
+  SetOffset(reader_->size() - 4);
+  intptr_t library_count = reader_->ReadUInt32();
+  SetOffset(reader_->size() - 4 - 4 * library_count - 3 * 4);
+  SetOffset(reader_->ReadUInt32());  // read source table offset.
+  intptr_t size = ReadUInt();        // read source table size.
+  intptr_t uris_size = 0;
+  for (intptr_t i = 0; i < size; ++i) {
+    uris_size = ReadUInt();
+  }
+  SkipBytes(uris_size);
+
+  // Read the source code strings and line starts.
+  for (intptr_t i = 0; i < size; ++i) {
+    intptr_t length = ReadUInt();
+    SkipBytes(length);
+    intptr_t line_count = ReadUInt();
+    if (i == index) {
+      Array& array_object =
+          Array::Handle(Z, Array::New(line_count, Heap::kOld));
+      Smi& value = Smi::Handle(Z);
+      intptr_t previous_line_start = 0;
+      for (intptr_t j = 0; j < line_count; ++j) {
+        intptr_t line_start = ReadUInt() + previous_line_start;
+        value = Smi::New(line_start);
+        array_object.SetAt(j, value);
+        previous_line_start = line_start;
+      }
+      return array_object;
+    } else {
+      for (intptr_t j = 0; j < line_count; ++j) {
+        ReadUInt();
+      }
+    }
+  }
+
+  return Array::Handle(Array::null());
+}
+
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)