VM: Re-format to use at most one newline between functions

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"
@@ skipping 106 matching lines @@
 
  private:
   void PrintIndent() {
     for (intptr_t i = 0; i < *indent_; i++) {
       OS::Print(". ");
     }
   }
   intptr_t* indent_;
 };
 
-
 #define TRACE_PARSER(s)                                                        \
   TraceParser __p__(this->TokenPos(), this->script_, &this->trace_indent_, s)
 
 #else  // not DEBUG
 #define TRACE_PARSER(s)
 #endif  // DEBUG
 
-
 class BoolScope : public ValueObject {
  public:
   BoolScope(bool* addr, bool new_value) : _addr(addr), _saved_value(*addr) {
     *_addr = new_value;
   }
   ~BoolScope() { *_addr = _saved_value; }
 
  private:
   bool* _addr;
   bool _saved_value;
 };
 
-
 // Helper class to save and restore token position.
 class Parser::TokenPosScope : public ValueObject {
  public:
   explicit TokenPosScope(Parser* p) : p_(p) { saved_pos_ = p_->TokenPos(); }
   TokenPosScope(Parser* p, TokenPosition pos) : p_(p), saved_pos_(pos) {}
   ~TokenPosScope() { p_->SetPosition(saved_pos_); }
 
  private:
   Parser* p_;
   TokenPosition saved_pos_;
   DISALLOW_COPY_AND_ASSIGN(TokenPosScope);
 };
 
-
 class RecursionChecker : public ValueObject {
  public:
   explicit RecursionChecker(Parser* p) : parser_(p) {
     parser_->recursion_counter_++;
     // No need to check the stack unless the parser is in an unusually deep
     // recurive state. Thus, we omit the more expensive stack checks in
     // the common case.
     const int kMaxUncheckedDepth = 100;  // Somewhat arbitrary.
     if (parser_->recursion_counter_ > kMaxUncheckedDepth) {
       parser_->CheckStack();
     }
   }
   ~RecursionChecker() { parser_->recursion_counter_--; }
 
  private:
   Parser* parser_;
 };
 
-
 static RawTypeArguments* NewTypeArguments(
     const GrowableArray<AbstractType*>& objs) {
   const TypeArguments& a =
       TypeArguments::Handle(TypeArguments::New(objs.length()));
   for (int i = 0; i < objs.length(); i++) {
     a.SetTypeAt(i, *objs.At(i));
   }
   // Cannot canonicalize TypeArgument yet as its types may not have been
   // finalized yet.
   return a.raw();
 }
 
-
 void ParsedFunction::AddToGuardedFields(const Field* field) const {
   if ((field->guarded_cid() == kDynamicCid) ||
       (field->guarded_cid() == kIllegalCid)) {
     return;
   }
 
   for (intptr_t j = 0; j < guarded_fields_->length(); j++) {
     const Field* other = (*guarded_fields_)[j];
     if (field->Original() == other->Original()) {
       // Abort background compilation early if the guarded state of this field
@@ skipping 11 matching lines @@
   }
 
   // Note: the list of guarded fields must contain copies during background
   // compilation because we will look at their guarded_cid when copying
   // the array of guarded fields from callee into the caller during
   // inlining.
   ASSERT(!field->IsOriginal() || Thread::Current()->IsMutatorThread());
   guarded_fields_->Add(&Field::ZoneHandle(Z, field->raw()));
 }
 
-
 void ParsedFunction::Bailout(const char* origin, const char* reason) const {
   Report::MessageF(Report::kBailout, Script::Handle(function_.script()),
                    function_.token_pos(), Report::AtLocation,
                    "%s Bailout in %s: %s", origin,
                    String::Handle(function_.name()).ToCString(), reason);
   UNREACHABLE();
 }
 
-
 kernel::ScopeBuildingResult* ParsedFunction::EnsureKernelScopes() {
   if (kernel_scopes_ == NULL) {
     intptr_t kernel_offset = function().kernel_offset();
     Script& script = Script::Handle(Z, function().script());
     kernel::StreamingScopeBuilder builder(
         this, kernel_offset, script.kernel_data(), script.kernel_data_size());
     kernel_scopes_ = builder.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());
     ASSERT(temp != NULL);
     set_expression_temp_var(temp);
   }
   ASSERT(has_expression_temp_var());
   return expression_temp_var();
 }
 
-
 void ParsedFunction::EnsureFinallyReturnTemp(bool is_async) {
   if (!has_finally_return_temp_var()) {
     LocalVariable* temp =
         new (Z) LocalVariable(function_.token_pos(), function_.token_pos(),
                               Symbols::FinallyRetVal(), Object::dynamic_type());
     ASSERT(temp != NULL);
     temp->set_is_final();
     if (is_async) {
       temp->set_is_captured();
     }
     set_finally_return_temp_var(temp);
   }
   ASSERT(has_finally_return_temp_var());
 }
 
-
 void ParsedFunction::SetNodeSequence(SequenceNode* node_sequence) {
   ASSERT(node_sequence_ == NULL);
   ASSERT(node_sequence != NULL);
   node_sequence_ = node_sequence;
 }
 
-
 void ParsedFunction::SetRegExpCompileData(
     RegExpCompileData* regexp_compile_data) {
   ASSERT(regexp_compile_data_ == NULL);
   ASSERT(regexp_compile_data != NULL);
   regexp_compile_data_ = regexp_compile_data;
 }
 
-
 void ParsedFunction::AddDeferredPrefix(const LibraryPrefix& prefix) {
   // 'deferred_prefixes_' are used to invalidate code, but no invalidation is
   // needed if --load_deferred_eagerly.
   ASSERT(!FLAG_load_deferred_eagerly);
   ASSERT(prefix.is_deferred_load());
   ASSERT(!prefix.is_loaded());
   for (intptr_t i = 0; i < deferred_prefixes_->length(); i++) {
     if ((*deferred_prefixes_)[i]->raw() == prefix.raw()) {
       return;
     }
   }
   deferred_prefixes_->Add(&LibraryPrefix::ZoneHandle(Z, prefix.raw()));
 }
 
-
 void ParsedFunction::AllocateVariables() {
   ASSERT(!function().IsIrregexpFunction());
   LocalScope* scope = node_sequence()->scope();
   const intptr_t num_fixed_params = function().num_fixed_parameters();
   const intptr_t num_opt_params = function().NumOptionalParameters();
   const intptr_t num_params = num_fixed_params + num_opt_params;
   // Compute start indices to parameters and locals, and the number of
   // parameters to copy.
   if (num_opt_params == 0) {
     // Parameter i will be at fp[kParamEndSlotFromFp + num_params - i] and
@@ skipping 14 matching lines @@
   bool found_captured_variables = false;
   int next_free_frame_index = scope->AllocateVariables(
       first_parameter_index_, num_params, first_stack_local_index_, NULL,
       &found_captured_variables);
 
   // Frame indices are relative to the frame pointer and are decreasing.
   ASSERT(next_free_frame_index <= first_stack_local_index_);
   num_stack_locals_ = first_stack_local_index_ - next_free_frame_index;
 }
 
-
 struct CatchParamDesc {
   CatchParamDesc()
       : token_pos(TokenPosition::kNoSource),
         type(NULL),
         name(NULL),
         var(NULL) {}
   TokenPosition token_pos;
   const AbstractType* type;
   const String* name;
   LocalVariable* var;
 };
 
-
 void ParsedFunction::AllocateIrregexpVariables(intptr_t num_stack_locals) {
   ASSERT(function().IsIrregexpFunction());
   ASSERT(function().NumOptionalParameters() == 0);
   const intptr_t num_params = function().num_fixed_parameters();
   ASSERT(num_params == RegExpMacroAssembler::kParamCount);
   // Compute start indices to parameters and locals, and the number of
   // parameters to copy.
   // Parameter i will be at fp[kParamEndSlotFromFp + num_params - i] and
   // local variable j will be at fp[kFirstLocalSlotFromFp - j].
   first_parameter_index_ = kParamEndSlotFromFp + num_params;
   first_stack_local_index_ = kFirstLocalSlotFromFp;
   num_copied_params_ = 0;
 
   // Frame indices are relative to the frame pointer and are decreasing.
   num_stack_locals_ = num_stack_locals;
 }
 
-
 struct Parser::Block : public ZoneAllocated {
   Block(Block* outer_block, LocalScope* local_scope, SequenceNode* seq)
       : parent(outer_block), scope(local_scope), statements(seq) {
     ASSERT(scope != NULL);
     ASSERT(statements != NULL);
   }
   Block* parent;  // Enclosing block, or NULL if outermost.
   LocalScope* scope;
   SequenceNode* statements;
 };
 
-
 // Class which describes an inlined finally block which is used to generate
 // inlined code for the finally blocks when there is an exit from a try
 // block using 'return', 'break' or 'continue'.
 class Parser::TryStack : public ZoneAllocated {
  public:
   TryStack(Block* try_block, TryStack* outer_try, intptr_t try_index)
       : try_block_(try_block),
         inlined_finally_nodes_(),
         outer_try_(outer_try),
         try_index_(try_index),
@@ skipping 23 matching lines @@
   GrowableArray<AstNode*> inlined_finally_nodes_;
   TryStack* outer_try_;
   const intptr_t try_index_;
   bool inside_catch_;    // True when parsing a catch clause of this try.
   bool inside_finally_;  // True when parsing a finally clause of an inner try
                          // of this try.
 
   DISALLOW_COPY_AND_ASSIGN(TryStack);
 };
 
-
 void Parser::TryStack::AddNodeForFinallyInlining(AstNode* node) {
   inlined_finally_nodes_.Add(node);
 }
 
-
 void Parser::TryStack::RemoveJumpToLabel(SourceLabel* label) {
   int i = 0;
   while (i < inlined_finally_nodes_.length()) {
     if (inlined_finally_nodes_[i]->IsJumpNode()) {
       JumpNode* jump = inlined_finally_nodes_[i]->AsJumpNode();
       if (jump->label() == label) {
         // Shift remaining entries left and delete last entry.
         for (int j = i + 1; j < inlined_finally_nodes_.length(); j++) {
           inlined_finally_nodes_[j - 1] = inlined_finally_nodes_[j];
         }
         inlined_finally_nodes_.RemoveLast();
         continue;
       }
     }
     i++;
   }
 }
 
-
 // For parsing a compilation unit.
 Parser::Parser(const Script& script,
                const Library& library,
                TokenPosition token_pos)
     : thread_(Thread::Current()),
       isolate_(thread()->isolate()),
       allocation_space_(thread_->IsMutatorThread() ? Heap::kNew : Heap::kOld),
       script_(Script::Handle(zone(), script.raw())),
       tokens_iterator_(zone(),
                        TokenStream::Handle(zone(), script.tokens()),
@@ skipping 12 matching lines @@
       try_stack_(NULL),
       last_used_try_index_(0),
       unregister_pending_function_(false),
       async_temp_scope_(NULL),
       trace_indent_(0),
       recursion_counter_(0) {
   ASSERT(tokens_iterator_.IsValid());
   ASSERT(!library.IsNull());
 }
 
-
 // For parsing a function.
 Parser::Parser(const Script& script,
                ParsedFunction* parsed_function,
                TokenPosition token_pos)
     : thread_(Thread::Current()),
       isolate_(thread()->isolate()),
       allocation_space_(thread_->IsMutatorThread() ? Heap::kNew : Heap::kOld),
       script_(Script::Handle(zone(), script.raw())),
       tokens_iterator_(zone(),
                        TokenStream::Handle(zone(), script.tokens()),
@@ skipping 18 matching lines @@
       last_used_try_index_(0),
       unregister_pending_function_(false),
       async_temp_scope_(NULL),
       trace_indent_(0),
       recursion_counter_(0) {
   ASSERT(tokens_iterator_.IsValid());
   ASSERT(!current_function().IsNull());
   EnsureExpressionTemp();
 }
 
-
 Parser::~Parser() {
   if (unregister_pending_function_) {
     const GrowableObjectArray& pending_functions =
         GrowableObjectArray::Handle(T->pending_functions());
     ASSERT(!pending_functions.IsNull());
     ASSERT(pending_functions.Length() > 0);
     ASSERT(pending_functions.At(pending_functions.Length() - 1) ==
            current_function().raw());
     pending_functions.RemoveLast();
   }
 }
 
-
 // Each try in this function gets its own try index.
 // See definition of RawPcDescriptors::PcDescriptor.
 int16_t Parser::AllocateTryIndex() {
   if (!Utils::IsInt(16, last_used_try_index_ - 1)) {
     ReportError("too many nested try statements");
   }
   return last_used_try_index_++;
 }
 
-
 void Parser::SetScript(const Script& script, TokenPosition token_pos) {
   script_ = script.raw();
   tokens_iterator_.SetStream(TokenStream::Handle(Z, script.tokens()),
                              token_pos);
   token_kind_ = Token::kILLEGAL;
 }
 
-
 bool Parser::SetAllowFunctionLiterals(bool value) {
   bool current_value = allow_function_literals_;
   allow_function_literals_ = value;
   return current_value;
 }
 
-
 const Function& Parser::current_function() const {
   ASSERT(parsed_function() != NULL);
   return parsed_function()->function();
 }
 
-
 const Function& Parser::innermost_function() const {
   return innermost_function_;
 }
 
-
 int Parser::FunctionLevel() const {
   if (current_block_ != NULL) {
     return current_block_->scope->function_level();
   }
   return 0;
 }
 
-
 const Class& Parser::current_class() const {
   return current_class_;
 }
 
-
 void Parser::set_current_class(const Class& value) {
   current_class_ = value.raw();
 }
 
-
 void Parser::SetPosition(TokenPosition position) {
   tokens_iterator_.SetCurrentPosition(position);
   token_kind_ = Token::kILLEGAL;
   prev_token_pos_ = position;
 }
 
-
 // Set state and increments generational count so that thge background compiler
 // can detect if loading/top-level-parsing occured during compilation.
 class TopLevelParsingScope : public StackResource {
  public:
   explicit TopLevelParsingScope(Thread* thread) : StackResource(thread) {
     isolate()->IncrTopLevelParsingCount();
   }
   ~TopLevelParsingScope() {
     isolate()->DecrTopLevelParsingCount();
     isolate()->IncrLoadingInvalidationGen();
   }
 };
 
-
 void Parser::ParseCompilationUnit(const Library& library,
                                   const Script& script) {
   Thread* thread = Thread::Current();
   ASSERT(thread->long_jump_base()->IsSafeToJump());
   CSTAT_TIMER_SCOPE(thread, parser_timer);
 #ifndef PRODUCT
   VMTagScope tagScope(thread, VMTag::kCompileTopLevelTagId);
   TimelineDurationScope tds(thread, Timeline::GetCompilerStream(),
                             "CompileTopLevel");
   if (tds.enabled()) {
     tds.SetNumArguments(1);
     tds.CopyArgument(0, "script", String::Handle(script.url()).ToCString());
   }
 #endif
 
   TopLevelParsingScope scope(thread);
   Parser parser(script, library, TokenPosition::kMinSource);
   parser.ParseTopLevel();
 }
 
-
 void Parser::ComputeCurrentToken() {
   ASSERT(token_kind_ == Token::kILLEGAL);
   token_kind_ = tokens_iterator_.CurrentTokenKind();
   if (token_kind_ == Token::kERROR) {
     ReportError(TokenPos(), "%s", CurrentLiteral()->ToCString());
   }
 }
 
-
 Token::Kind Parser::LookaheadToken(int num_tokens) {
   return tokens_iterator_.LookaheadTokenKind(num_tokens);
 }
 
-
 String* Parser::CurrentLiteral() const {
   String& result = String::ZoneHandle(Z, tokens_iterator_.CurrentLiteral());
   return &result;
 }
 
-
 RawDouble* Parser::CurrentDoubleLiteral() const {
   literal_token_ ^= tokens_iterator_.CurrentToken();
   ASSERT(literal_token_.kind() == Token::kDOUBLE);
   return Double::RawCast(literal_token_.value());
 }
 
-
 RawInteger* Parser::CurrentIntegerLiteral() const {
   literal_token_ ^= tokens_iterator_.CurrentToken();
   ASSERT(literal_token_.kind() == Token::kINTEGER);
   RawInteger* ri = Integer::RawCast(literal_token_.value());
   return ri;
 }
 
-
 struct ParamDesc {
   ParamDesc()
       : type(NULL),
         name_pos(TokenPosition::kNoSource),
         name(NULL),
         default_value(NULL),
         metadata(NULL),
         var(NULL),
         is_final(false),
         is_field_initializer(false),
         has_explicit_type(false),
         is_covariant(false) {}
   const AbstractType* type;
   TokenPosition name_pos;
   const String* name;
   const Instance* default_value;  // NULL if not an optional parameter.
   const Object* metadata;  // NULL if no metadata or metadata not evaluated.
   LocalVariable* var;      // Scope variable allocated for this parameter.
   bool is_final;
   bool is_field_initializer;
   bool has_explicit_type;
   bool is_covariant;
 };
 
-
 struct ParamList {
   ParamList() { Clear(); }
 
   void Clear() {
     num_fixed_parameters = 0;
     num_optional_parameters = 0;
     has_optional_positional_parameters = false;
     has_optional_named_parameters = false;
     has_explicit_default_values = false;
     has_field_initializer = false;
@@ skipping 58 matching lines @@
   bool has_optional_positional_parameters;
   bool has_optional_named_parameters;
   bool has_explicit_default_values;
   bool has_field_initializer;
   bool has_covariant;
   bool implicitly_final;
   bool skipped;
   ZoneGrowableArray<ParamDesc>* parameters;
 };
 
-
 struct MemberDesc {
   MemberDesc() { Clear(); }
 
   void Clear() {
     has_abstract = false;
     has_external = false;
     has_covariant = false;
     has_final = false;
     has_const = false;
     has_static = false;
@@ skipping 62 matching lines @@
   // For constructors: NULL for unnamed constructor,
   // identifier after classname for named constructors.
   // For getters and setters: unmangled name.
   String* dict_name;
   ParamList params;
   RawFunction::Kind kind;
   // NULL for functions, field object for static or instance fields.
   Field* field_;
 };
 
-
 class ClassDesc : public ValueObject {
  public:
   ClassDesc(Zone* zone,
             const Class& cls,
             const String& cls_name,
             bool is_interface,
             TokenPosition token_pos)
       : zone_(zone),
         clazz_(cls),
         class_name_(cls_name),
@@ skipping 54 matching lines @@
  private:
   Zone* zone_;
   const Class& clazz_;
   const String& class_name_;
   TokenPosition token_pos_;  // Token index of "class" keyword.
   GrowableArray<const Function*> functions_;
   GrowableArray<const Field*> fields_;
   GrowableArray<MemberDesc> members_;
 };
 
-
 class TopLevel : public ValueObject {
  public:
   explicit TopLevel(Zone* zone)
       : zone_(zone), fields_(zone, 4), functions_(zone, 4) {}
 
   void AddField(const Field& field) {
     fields_.Add(&Field::ZoneHandle(zone_, field.raw()));
   }
 
   void AddFunction(const Function& function) {
     functions_.Add(&Function::ZoneHandle(zone_, function.raw()));
   }
 
   const GrowableArray<const Field*>& fields() const { return fields_; }
 
   const GrowableArray<const Function*>& functions() const { return functions_; }
 
  private:
   Zone* zone_;
   GrowableArray<const Field*> fields_;
   GrowableArray<const Function*> functions_;
 };
 
-
 void Parser::ParseClass(const Class& cls) {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   const int64_t num_tokes_before = STAT_VALUE(thread, num_tokens_consumed);
 #ifndef PRODUCT
   TimelineDurationScope tds(thread, Timeline::GetCompilerStream(),
                             "ParseClass");
   if (tds.enabled()) {
     tds.SetNumArguments(1);
     tds.CopyArgument(0, "class", String::Handle(cls.Name()).ToCString());
@@ skipping 11 matching lines @@
     CSTAT_TIMER_SCOPE(thread, parser_timer);
     const Script& script = Script::Handle(zone, cls.script());
     const Library& lib = Library::Handle(zone, cls.library());
     Parser parser(script, lib, cls.token_pos());
     parser.ParseEnumDefinition(cls);
   }
   const int64_t num_tokes_after = STAT_VALUE(thread, num_tokens_consumed);
   INC_STAT(thread, num_class_tokens, num_tokes_after - num_tokes_before);
 }
 
-
 bool Parser::FieldHasFunctionLiteralInitializer(const Field& field,
                                                 TokenPosition* start,
                                                 TokenPosition* end) {
   if (!field.has_initializer()) {
     return false;
   }
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   const Class& cls = Class::Handle(zone, field.Owner());
   const Script& script = Script::Handle(zone, cls.script());
@@ skipping 16 matching lines @@
   *start = TokenPos();
   if (IsFunctionLiteral()) {
     SkipExpr();
     *end = PrevTokenPos();
     return true;
   }
 
   return false;
 }
 
-
 RawObject* Parser::ParseFunctionParameters(const Function& func) {
   ASSERT(!func.IsNull());
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     Thread* thread = Thread::Current();
     StackZone stack_zone(thread);
     Zone* zone = stack_zone.GetZone();
     const Script& script = Script::Handle(zone, func.script());
     const Class& owner = Class::Handle(zone, func.Owner());
     ASSERT(!owner.IsNull());
@@ skipping 34 matching lines @@
     Thread* thread = Thread::Current();
     Error& error = Error::Handle();
     error = thread->sticky_error();
     thread->clear_sticky_error();
     return error.raw();
   }
   UNREACHABLE();
   return Object::null();
 }
 
-
 bool Parser::ParseFormalParameters(const Function& func, ParamList* params) {
   ASSERT(!func.IsNull());
   // This is currently only used for constructors. To handle all kinds
   // of functions, special cases for getters and possibly other kinds
   // need to be added.
   ASSERT(func.kind() == RawFunction::kConstructor);
   ASSERT(!func.IsRedirectingFactory());
   // Implicit constructors have no source, no user-defined formal parameters.
   if (func.IsImplicitConstructor()) {
     return true;
@@ skipping 16 matching lines @@
     return true;
   } else {
     Thread::Current()->clear_sticky_error();
     params->Clear();
     return false;
   }
   UNREACHABLE();
   return false;
 }
 
-
 void Parser::ParseFunction(ParsedFunction* parsed_function) {
   Thread* thread = parsed_function->thread();
   ASSERT(thread == Thread::Current());
   Zone* zone = thread->zone();
   CSTAT_TIMER_SCOPE(thread, parser_timer);
   INC_STAT(thread, num_functions_parsed, 1);
 #ifndef PRODUCT
   VMTagScope tagScope(thread, VMTag::kCompileParseFunctionTagId,
                       FLAG_profile_vm);
   TimelineDurationScope tds(thread, Timeline::GetCompilerStream(),
@@ skipping 88 matching lines @@
         ((instantiator != NULL) && instantiator->is_captured())) {
       parsed_function->set_instantiator(instantiator);
     }
   }
   // ParseFunc has recorded the generic function type arguments variable.
   ASSERT(!FLAG_reify_generic_functions ||
          !parser.current_function().IsGeneric() ||
          (parsed_function->function_type_arguments() != NULL));
 }
 
-
 RawObject* Parser::ParseMetadata(const Field& meta_data) {
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     Thread* thread = Thread::Current();
     StackZone stack_zone(thread);
     Zone* zone = stack_zone.GetZone();
     const Class& owner_class = Class::Handle(zone, meta_data.Owner());
     const Script& script = Script::Handle(zone, meta_data.Script());
     const TokenPosition token_pos = meta_data.token_pos();
     // Parsing metadata can involve following paths in the parser that are
@@ skipping 23 matching lines @@
     Zone* zone = stack_zone.GetZone();
     Error& error = Error::Handle(zone);
     error = thread->sticky_error();
     thread->clear_sticky_error();
     return error.raw();
   }
   UNREACHABLE();
   return Object::null();
 }
 
-
 RawArray* Parser::EvaluateMetadata() {
   CheckToken(Token::kAT, "Metadata character '@' expected");
   GrowableObjectArray& meta_values =
       GrowableObjectArray::Handle(Z, GrowableObjectArray::New(Heap::kOld));
   while (CurrentToken() == Token::kAT) {
     ConsumeToken();
     TokenPosition expr_pos = TokenPos();
     if (!IsIdentifier()) {
       ExpectIdentifier("identifier expected");
     }
@@ skipping 53 matching lines @@
     }
     if (expr->EvalConstExpr() == NULL) {
       ReportError(expr_pos, "expression must be a compile-time constant");
     }
     const Instance& val = EvaluateConstExpr(expr_pos, expr);
     meta_values.Add(val, Heap::kOld);
   }
   return Array::MakeFixedLength(meta_values);
 }
 
-
 SequenceNode* Parser::ParseStaticInitializer() {
   ExpectIdentifier("field name expected");
   CheckToken(Token::kASSIGN, "field initialier expected");
   ConsumeToken();
   OpenFunctionBlock(parsed_function()->function());
   TokenPosition expr_pos = TokenPos();
   AstNode* expr = ParseExpr(kAllowConst, kConsumeCascades);
   ReturnNode* ret = new (Z) ReturnNode(expr_pos, expr);
   current_block_->statements->Add(ret);
   return CloseBlock();
 }
 
-
 ParsedFunction* Parser::ParseStaticFieldInitializer(const Field& field) {
   ASSERT(field.is_static());
   Thread* thread = Thread::Current();
   // TODO(koda): Should there be a StackZone here?
   Zone* zone = thread->zone();
 #ifndef PRODUCT
   VMTagScope tagScope(thread, VMTag::kCompileParseFunctionTagId,
                       FLAG_profile_vm);
   TimelineDurationScope tds(thread, Timeline::GetCompilerStream(),
                             "ParseStaticFieldInitializer");
@@ skipping 36 matching lines @@
   body->scope()->AddVariable(parsed_function->current_context_var());
   if (parsed_function->has_finally_return_temp_var()) {
     body->scope()->AddVariable(parsed_function->finally_return_temp_var());
   }
   // The instantiator is not required in a static expression.
   ASSERT(!parser.IsInstantiatorRequired());
 
   return parsed_function;
 }
 
-
 SequenceNode* Parser::ParseStaticFinalGetter(const Function& func) {
   TRACE_PARSER("ParseStaticFinalGetter");
   ASSERT(func.num_fixed_parameters() == 0);  // static.
   ASSERT(!func.HasOptionalParameters());
   ASSERT(AbstractType::Handle(Z, func.result_type()).IsResolved());
   OpenFunctionBlock(func);
   TokenPosition ident_pos = TokenPos();
   const String& field_name = *ExpectIdentifier("field name expected");
   const Class& field_class = Class::Handle(Z, func.Owner());
   const Field& field =
@@ skipping 24 matching lines @@
     // and handle errors while evaluating the expression.
     current_block_->statements->Add(new (Z)
                                         InitStaticFieldNode(ident_pos, field));
     ReturnNode* return_node =
         new ReturnNode(ident_pos, new LoadStaticFieldNode(ident_pos, field));
     current_block_->statements->Add(return_node);
   }
   return CloseBlock();
 }
 
-
 // Create AstNodes for an implicit instance getter method:
 //   LoadLocalNode 0 ('this');
 //   LoadInstanceFieldNode (field_name);
 //   ReturnNode (field's value);
 SequenceNode* Parser::ParseInstanceGetter(const Function& func) {
   TRACE_PARSER("ParseInstanceGetter");
   ParamList params;
   // func.token_pos() points to the name of the field.
   const TokenPosition ident_pos = func.token_pos();
   ASSERT(current_class().raw() == func.Owner());
@@ skipping 18 matching lines @@
   ASSERT(!field.IsNull());
 
   LoadInstanceFieldNode* load_field =
       new LoadInstanceFieldNode(ident_pos, load_receiver, field);
 
   ReturnNode* return_node = new ReturnNode(ST(ident_pos), load_field);
   current_block_->statements->Add(return_node);
   return CloseBlock();
 }
 
-
 // Create AstNodes for an implicit instance setter method:
 //   LoadLocalNode 0 ('this')
 //   LoadLocalNode 1 ('value')
 //   SetInstanceField (field_name);
 //   ReturnNode (void);
 SequenceNode* Parser::ParseInstanceSetter(const Function& func) {
   TRACE_PARSER("ParseInstanceSetter");
   // func.token_pos() points to the name of the field.
   const TokenPosition ident_pos = func.token_pos();
   const String& field_name = *CurrentLiteral();
@@ skipping 21 matching lines @@
 
   EnsureExpressionTemp();
   StoreInstanceFieldNode* store_field =
       new StoreInstanceFieldNode(ident_pos, receiver, field, value,
                                  /* is_initializer = */ false);
   current_block_->statements->Add(store_field);
   current_block_->statements->Add(new ReturnNode(ST(ident_pos)));
   return CloseBlock();
 }
 
-
 SequenceNode* Parser::ParseConstructorClosure(const Function& func) {
   TRACE_PARSER("ParseConstructorClosure");
   const TokenPosition token_pos = func.token_pos();
 
   Function& constructor = Function::ZoneHandle(Z);
   TypeArguments& type_args = TypeArguments::ZoneHandle(Z);
   ParseConstructorClosurization(&constructor, &type_args);
   ASSERT(!constructor.IsNull());
 
   ParamList params;
@@ skipping 32 matching lines @@
     ctor_args->set_names(arg_names);
   }
 
   AstNode* new_object =
       CreateConstructorCallNode(token_pos, type_args, constructor, ctor_args);
   ReturnNode* return_node = new ReturnNode(token_pos, new_object);
   current_block_->statements->Add(return_node);
   return CloseBlock();
 }
 
-
 SequenceNode* Parser::ParseImplicitClosure(const Function& func) {
   TRACE_PARSER("ParseImplicitClosure");
   TokenPosition token_pos = func.token_pos();
 
   OpenFunctionBlock(func);
 
   const Function& parent = Function::Handle(func.parent_function());
   intptr_t type_args_len = 0;  // Length of type args vector passed to parent.
   LocalVariable* type_args_var = NULL;
   if (FLAG_reify_generic_functions) {
@@ skipping 126 matching lines @@
                                   InvocationMirror::kStatic, im_type,
                                   NULL);  // No existing function.
   }
 
   ASSERT(call != NULL);
   ReturnNode* return_node = new ReturnNode(token_pos, call);
   current_block_->statements->Add(return_node);
   return CloseBlock();
 }
 
-
 SequenceNode* Parser::ParseMethodExtractor(const Function& func) {
   TRACE_PARSER("ParseMethodExtractor");
 
   ParamList params;
 
   const TokenPosition ident_pos = func.token_pos();
   ASSERT(func.token_pos() == TokenPosition::kMethodExtractor);
   ASSERT(current_class().raw() == func.Owner());
   params.AddReceiver(ReceiverType(current_class()), ident_pos);
   ASSERT(func.num_fixed_parameters() == 1);  // Receiver.
   ASSERT(!func.HasOptionalParameters());
 
   // Build local scope for function and populate with the formal parameters.
   OpenFunctionBlock(func);
   AddFormalParamsToScope(&params, current_block_->scope);
 
   // Receiver is local 0.
   LocalVariable* receiver = current_block_->scope->VariableAt(0);
   LoadLocalNode* load_receiver = new LoadLocalNode(ident_pos, receiver);
 
   ClosureNode* closure = new ClosureNode(
       ident_pos, Function::ZoneHandle(Z, func.extracted_method_closure()),
       load_receiver, NULL);
 
   ReturnNode* return_node = new ReturnNode(ident_pos, closure);
   current_block_->statements->Add(return_node);
   return CloseBlock();
 }
 
-
 void Parser::BuildDispatcherScope(const Function& func,
                                   const ArgumentsDescriptor& desc) {
   ParamList params;
   // Receiver first.
   TokenPosition token_pos = func.token_pos();
   params.AddReceiver(ReceiverType(current_class()), token_pos);
   // Remaining positional parameters.
   intptr_t i = 1;
   for (; i < desc.PositionalCount(); ++i) {
     ParamDesc p;
@@ skipping 30 matching lines @@
     // Insert function type arguments variable to scope.
     LocalVariable* type_args_var = new (Z) LocalVariable(
         TokenPosition::kNoSource, TokenPosition::kNoSource,
         Symbols::FunctionTypeArgumentsVar(), Object::dynamic_type());
     current_block_->scope->AddVariable(type_args_var);
     ASSERT(FunctionLevel() == 0);
     parsed_function_->set_function_type_arguments(type_args_var);
   }
 }
 
-
 SequenceNode* Parser::ParseNoSuchMethodDispatcher(const Function& func) {
   TRACE_PARSER("ParseNoSuchMethodDispatcher");
   ASSERT(FLAG_lazy_dispatchers);
   ASSERT(func.IsNoSuchMethodDispatcher());
   TokenPosition token_pos = func.token_pos();
   ASSERT(func.token_pos() == TokenPosition::kMinSource);
   ASSERT(current_class().raw() == func.Owner());
 
   ArgumentsDescriptor desc(Array::Handle(Z, func.saved_args_desc()));
   ASSERT(desc.Count() > 0);
@@ skipping 37 matching lines @@
         Symbols::NoSuchMethod(), args_desc);
   }
   StaticCallNode* call =
       new StaticCallNode(token_pos, no_such_method, arguments);
 
   ReturnNode* return_node = new ReturnNode(token_pos, call);
   current_block_->statements->Add(return_node);
   return CloseBlock();
 }
 
-
 SequenceNode* Parser::ParseInvokeFieldDispatcher(const Function& func) {
   TRACE_PARSER("ParseInvokeFieldDispatcher");
   ASSERT(func.IsInvokeFieldDispatcher());
   TokenPosition token_pos = func.token_pos();
   ASSERT(func.token_pos() == TokenPosition::kMinSource);
   ASSERT(current_class().raw() == func.Owner());
 
   const Array& args_desc = Array::Handle(Z, func.saved_args_desc());
   ArgumentsDescriptor desc(args_desc);
   ASSERT(desc.Count() > 0);
@@ skipping 47 matching lines @@
     result = new ClosureCallNode(token_pos, function_object, args);
   } else {
     result = BuildClosureCall(token_pos, function_object, args);
   }
 
   ReturnNode* return_node = new ReturnNode(token_pos, result);
   current_block_->statements->Add(return_node);
   return CloseBlock();
 }
 
-
 AstNode* Parser::BuildClosureCall(TokenPosition token_pos,
                                   AstNode* closure,
                                   ArgumentListNode* arguments) {
   return new InstanceCallNode(token_pos, closure, Symbols::Call(), arguments);
 }
 
-
 void Parser::SkipToMatching() {
   Token::Kind opening_token = CurrentToken();
   ASSERT((opening_token == Token::kLBRACE) ||
          (opening_token == Token::kLPAREN));
   GrowableArray<Token::Kind> token_stack(8);
   GrowableArray<TokenPosition> token_pos_stack(8);
   // Adding the first opening brace here, because it will be consumed
   // in the loop right away.
   token_stack.Add(opening_token);
   const TokenPosition start_pos = TokenPos();
@@ skipping 44 matching lines @@
         Error::Handle(), script_, opening_pos, Report::AtLocation,
         Report::kWarning, allocation_space_, "unbalanced '%s' opens here",
         Token::Str(opening_token)));
     ReportErrors(error, script_, token_pos, "unbalanced '%s'",
                  Token::Str(token));
   } else if (unexpected_token_found) {
     ReportError(start_pos, "unterminated '%s'", Token::Str(opening_token));
   }
 }
 
-
 void Parser::SkipBlock() {
   ASSERT(CurrentToken() == Token::kLBRACE);
   SkipToMatching();
 }
 
-
 // Skips tokens up to and including matching closing parenthesis.
 void Parser::SkipToMatchingParenthesis() {
   ASSERT(CurrentToken() == Token::kLPAREN);
   SkipToMatching();
   ASSERT(CurrentToken() == Token::kRPAREN);
   ConsumeToken();
 }
 
-
 // Parses a parameter type as defined by the 'parameterTypeList' production.
 void Parser::ParseParameterType(ParamList* params) {
   TRACE_PARSER("ParseParameterType");
   ParamDesc parameter;
 
   parameter.has_explicit_type = true;  // The type is required by the syntax.
   // It is too early to resolve the type here, since it can be a result type
   // referring to a not yet declared function type parameter.
   parameter.type = &AbstractType::ZoneHandle(
       Z, ParseTypeOrFunctionType(false, ClassFinalizer::kDoNotResolve));
@@ skipping 50 matching lines @@
   }
   if (params->implicitly_final) {
     parameter.is_final = true;
   }
   params->parameters->Add(parameter);
   if (parameter.is_covariant) {
     params->has_covariant = true;
   }
 }
 
-
 // Parses a formal parameter as defined by the 'formalParameterList' production.
 void Parser::ParseFormalParameter(bool allow_explicit_default_value,
                                   bool evaluate_metadata,
                                   ParamList* params) {
   TRACE_PARSER("ParseFormalParameter");
   ParamDesc parameter;
   bool var_seen = false;
   bool final_seen = false;
   bool this_seen = false;
 
@@ skipping 210 matching lines @@
   }
   if (params->implicitly_final) {
     parameter.is_final = true;
   }
   params->parameters->Add(parameter);
   if (parameter.is_covariant) {
     params->has_covariant = true;
   }
 }
 
-
 // Parses a sequence of normal or optional formal parameters.
 void Parser::ParseFormalParameters(bool use_function_type_syntax,
                                    bool allow_explicit_default_values,
                                    bool evaluate_metadata,
                                    ParamList* params) {
   TRACE_PARSER("ParseFormalParameters");
   // Optional parameter lists cannot be empty.
   // The completely empty parameter list is handled before getting here.
   bool has_seen_parameter = false;
   do {
@@ skipping 25 matching lines @@
       ASSERT(!allow_explicit_default_values && !evaluate_metadata);
       ParseParameterType(params);
     } else {
       ParseFormalParameter(allow_explicit_default_values, evaluate_metadata,
                            params);
     }
     has_seen_parameter = true;
   } while (CurrentToken() == Token::kCOMMA);
 }
 
-
 void Parser::ParseFormalParameterList(bool use_function_type_syntax,
                                       bool allow_explicit_default_values,
                                       bool evaluate_metadata,
                                       ParamList* params) {
   TRACE_PARSER("ParseFormalParameterList");
   ASSERT(CurrentToken() == Token::kLPAREN);
 
   if (LookaheadToken(1) != Token::kRPAREN) {
     // Parse fixed parameters.
     ParseFormalParameters(use_function_type_syntax,
@@ skipping 16 matching lines @@
         !params->has_optional_positional_parameters &&
         !params->has_optional_named_parameters) {
       ReportError("',' or ')' expected");
     }
   } else {
     ConsumeToken();
   }
   ExpectToken(Token::kRPAREN);
 }
 
-
 String& Parser::ParseNativeDeclaration() {
   TRACE_PARSER("ParseNativeDeclaration");
   ASSERT(IsSymbol(Symbols::Native()));
   ConsumeToken();
   CheckToken(Token::kSTRING, "string literal expected");
   String& native_name = *CurrentLiteral();
   ConsumeToken();
   return native_name;
 }
 
-
 // Resolve and return the dynamic function of the given name in the superclass.
 // If it is not found, and resolve_getter is true, try to resolve a getter of
 // the same name. If it is still not found, return noSuchMethod and
 // set is_no_such_method to true..
 RawFunction* Parser::GetSuperFunction(TokenPosition token_pos,
                                       const String& name,
                                       ArgumentListNode* arguments,
                                       bool resolve_getter,
                                       bool* is_no_such_method) {
   const Class& super_class = Class::Handle(Z, current_class().SuperClass());
@@ skipping 21 matching lines @@
     super_func = Resolver::ResolveDynamicAnyArgs(Z, super_class,
                                                  Symbols::NoSuchMethod());
     ASSERT(!super_func.IsNull());
     *is_no_such_method = true;
   } else {
     *is_no_such_method = false;
   }
   return super_func.raw();
 }
 
-
 StaticCallNode* Parser::BuildInvocationMirrorAllocation(
     TokenPosition call_pos,
     const String& function_name,
     const ArgumentListNode& function_args,
     const LocalVariable* temp_for_last_arg,
     bool is_super_invocation) {
   const TokenPosition args_pos = function_args.token_pos();
   // Build arguments to the call to the static
   // InvocationMirror._allocateInvocationMirror method.
   ArgumentListNode* arguments = new ArgumentListNode(args_pos);
@@ skipping 33 matching lines @@
   const Class& mirror_class =
       Class::Handle(Library::LookupCoreClass(Symbols::InvocationMirror()));
   ASSERT(!mirror_class.IsNull());
   const Function& allocation_function =
       Function::ZoneHandle(mirror_class.LookupStaticFunction(
           Library::PrivateCoreLibName(Symbols::AllocateInvocationMirror())));
   ASSERT(!allocation_function.IsNull());
   return new StaticCallNode(call_pos, allocation_function, arguments);
 }
 
-
 ArgumentListNode* Parser::BuildNoSuchMethodArguments(
     TokenPosition call_pos,
     const String& function_name,
     const ArgumentListNode& function_args,
     const LocalVariable* temp_for_last_arg,
     bool is_super_invocation) {
   ASSERT(function_args.length() >= 1);  // The receiver is the first argument.
   const TokenPosition args_pos = function_args.token_pos();
   ArgumentListNode* arguments = new ArgumentListNode(args_pos);
   arguments->Add(function_args.NodeAt(0));
   // The second argument is the invocation mirror.
   arguments->Add(
       BuildInvocationMirrorAllocation(call_pos, function_name, function_args,
                                       temp_for_last_arg, is_super_invocation));
   return arguments;
 }
 
-
 AstNode* Parser::ParseSuperCall(const String& function_name,
                                 const TypeArguments& func_type_args) {
   TRACE_PARSER("ParseSuperCall");
   ASSERT(CurrentToken() == Token::kLPAREN);
   const TokenPosition supercall_pos = TokenPos();
 
   // 'this' parameter is the first argument to super call (after the type args).
   ArgumentListNode* arguments =
       new ArgumentListNode(supercall_pos, func_type_args);
   AstNode* receiver = LoadReceiver(supercall_pos);
@@ skipping 19 matching lines @@
     }
     return BuildClosureCall(supercall_pos, closure, closure_arguments);
   }
   if (is_no_such_method) {
     arguments = BuildNoSuchMethodArguments(supercall_pos, function_name,
                                            *arguments, NULL, true);
   }
   return new StaticCallNode(supercall_pos, super_function, arguments);
 }
 
-
 // Simple test if a node is side effect free.
 static bool IsSimpleLocalOrLiteralNode(AstNode* node) {
   return node->IsLiteralNode() || node->IsLoadLocalNode();
 }
 
-
 AstNode* Parser::BuildUnarySuperOperator(Token::Kind op, PrimaryNode* super) {
   ASSERT(super->IsSuper());
   AstNode* super_op = NULL;
   const TokenPosition super_pos = super->token_pos();
   if ((op == Token::kNEGATE) || (op == Token::kBIT_NOT)) {
     // Resolve the operator function in the superclass.
     const String& operator_function_name = Symbols::Token(op);
     ArgumentListNode* op_arguments = new ArgumentListNode(super_pos);
     AstNode* receiver = LoadReceiver(super_pos);
     op_arguments->Add(receiver);
     const bool kResolveGetter = false;
     bool is_no_such_method = false;
     const Function& super_operator = Function::ZoneHandle(
         Z, GetSuperFunction(super_pos, operator_function_name, op_arguments,
                             kResolveGetter, &is_no_such_method));
     if (is_no_such_method) {
       op_arguments = BuildNoSuchMethodArguments(
           super_pos, operator_function_name, *op_arguments, NULL, true);
     }
     super_op = new StaticCallNode(super_pos, super_operator, op_arguments);
   } else {
     ReportError(super_pos, "illegal super operator call");
   }
   return super_op;
 }
 
-
 AstNode* Parser::ParseSuperOperator() {
   TRACE_PARSER("ParseSuperOperator");
   AstNode* super_op = NULL;
   const TokenPosition operator_pos = TokenPos();
 
   if (CurrentToken() == Token::kLBRACK) {
     ConsumeToken();
     AstNode* index_expr = ParseExpr(kAllowConst, kConsumeCascades);
     ExpectToken(Token::kRBRACK);
     AstNode* receiver = LoadReceiver(operator_pos);
@@ skipping 34 matching lines @@
           operator_pos, operator_function_name, *op_arguments, NULL, true);
     }
     super_op = new StaticCallNode(operator_pos, super_operator, op_arguments);
     if (negate_result) {
       super_op = new UnaryOpNode(operator_pos, Token::kNOT, super_op);
     }
   }
   return super_op;
 }
 
-
 ClosureNode* Parser::CreateImplicitClosureNode(const Function& func,
                                                TokenPosition token_pos,
                                                AstNode* receiver) {
   Function& implicit_closure_function =
       Function::ZoneHandle(Z, func.ImplicitClosureFunction());
   return new ClosureNode(token_pos, implicit_closure_function, receiver, NULL);
 }
 
-
 AstNode* Parser::ParseSuperFieldAccess(const String& field_name,
                                        TokenPosition field_pos) {
   TRACE_PARSER("ParseSuperFieldAccess");
   const Class& super_class = Class::ZoneHandle(Z, current_class().SuperClass());
   if (super_class.IsNull()) {
     ReportError("class '%s' does not have a superclass",
                 String::Handle(Z, current_class().Name()).ToCString());
   }
   AstNode* implicit_argument = LoadReceiver(field_pos);
 
@@ skipping 25 matching lines @@
                                          implicit_argument);
       }
       // No function or field exists of the specified field_name.
       // Emit a StaticGetterNode anyway, so that noSuchMethod gets called.
     }
   }
   return new (Z)
       StaticGetterNode(field_pos, implicit_argument, super_class, field_name);
 }
 
-
 StaticCallNode* Parser::GenerateSuperConstructorCall(
     const Class& cls,
     TokenPosition supercall_pos,
     LocalVariable* receiver,
     ArgumentListNode* forwarding_args) {
   const Class& super_class = Class::Handle(Z, cls.SuperClass());
   // Omit the implicit super() if there is no super class (i.e.
   // we're not compiling class Object), or if the super class is an
   // artificially generated "wrapper class" that has no constructor.
   if (super_class.IsNull() ||
@@ skipping 49 matching lines @@
                                     arguments->length(), arguments->names(),
                                     &error_message)) {
     ReportError(supercall_pos,
                 "invalid arguments passed to super constructor '%s()': %s",
                 String::Handle(Z, super_class.Name()).ToCString(),
                 error_message.ToCString());
   }
   return new StaticCallNode(supercall_pos, super_ctor, arguments);
 }
 
-
 StaticCallNode* Parser::ParseSuperInitializer(const Class& cls,
                                               LocalVariable* receiver) {
   TRACE_PARSER("ParseSuperInitializer");
   ASSERT(CurrentToken() == Token::kSUPER);
   const TokenPosition supercall_pos = TokenPos();
   ConsumeToken();
   const Class& super_class = Class::Handle(Z, cls.SuperClass());
   ASSERT(!super_class.IsNull());
   String& ctor_name = String::Handle(Z, super_class.Name());
   ctor_name = Symbols::FromConcat(T, ctor_name, Symbols::Dot());
@@ skipping 34 matching lines @@
   if (!super_ctor.AreValidArguments(arguments->type_args_len(),
                                     arguments->length(), arguments->names(),
                                     &error_message)) {
     ReportError(supercall_pos,
                 "invalid arguments passed to super class constructor '%s': %s",
                 ctor_name.ToCString(), error_message.ToCString());
   }
   return new StaticCallNode(supercall_pos, super_ctor, arguments);
 }
 
-
 AstNode* Parser::ParseInitializer(const Class& cls,
                                   LocalVariable* receiver,
                                   GrowableArray<Field*>* initialized_fields) {
   TRACE_PARSER("ParseInitializer");
   const TokenPosition field_pos = TokenPos();
   if (FLAG_assert_initializer && CurrentToken() == Token::kASSERT) {
     return ParseAssertStatement(current_function().is_const());
   }
   if (CurrentToken() == Token::kTHIS) {
     ConsumeToken();
@@ skipping 33 matching lines @@
   AstNode* initializer = CheckDuplicateFieldInit(field_pos, initialized_fields,
                                                  instance, &field, init_expr);
   if (initializer == NULL) {
     initializer =
         new (Z) StoreInstanceFieldNode(field_pos, instance, field, init_expr,
                                        /* is_initializer = */ true);
   }
   return initializer;
 }
 
-
 void Parser::CheckFieldsInitialized(const Class& cls) {
   const Array& fields = Array::Handle(Z, cls.fields());
   Field& field = Field::Handle(Z);
   SequenceNode* initializers = current_block_->statements;
   for (int field_num = 0; field_num < fields.Length(); field_num++) {
     field ^= fields.At(field_num);
     if (field.is_static()) {
       continue;
     }
 
@@ skipping 10 matching lines @@
         }
       }
     }
 
     if (found) continue;
 
     field.RecordStore(Object::null_object());
   }
 }
 
-
 AstNode* Parser::ParseExternalInitializedField(const Field& field) {
   // Only use this function if the initialized field originates
   // from a different class. We need to save and restore the
   // library and token stream (script).
   // The current_class remains unchanged, so that type arguments
   // are resolved in the correct scope class.
   ASSERT(current_class().raw() != field.Origin());
   const Library& saved_library = Library::Handle(Z, library().raw());
   const Script& saved_script = Script::Handle(Z, script().raw());
   const TokenPosition saved_token_pos = TokenPos();
@@ skipping 13 matching lines @@
     init_expr = ParseExpr(kAllowConst, kConsumeCascades);
     if (init_expr->EvalConstExpr() != NULL) {
       init_expr = FoldConstExpr(expr_pos, init_expr);
     }
   }
   set_library(saved_library);
   SetScript(saved_script, saved_token_pos);
   return init_expr;
 }
 
-
 void Parser::ParseInitializedInstanceFields(
     const Class& cls,
     LocalVariable* receiver,
     GrowableArray<Field*>* initialized_fields) {
   TRACE_PARSER("ParseInitializedInstanceFields");
   const Array& fields = Array::Handle(Z, cls.fields());
   Field& f = Field::Handle(Z);
   const TokenPosition saved_pos = TokenPos();
   for (int i = 0; i < fields.Length(); i++) {
     f ^= fields.At(i);
@@ skipping 32 matching lines @@
       AstNode* field_init = new StoreInstanceFieldNode(
           field.token_pos(), instance, field, init_expr,
           /* is_initializer = */ true);
       current_block_->statements->Add(field_init);
     }
   }
   initialized_fields->Add(NULL);  // End of inline initializers.
   SetPosition(saved_pos);
 }
 
-
 AstNode* Parser::CheckDuplicateFieldInit(
     TokenPosition init_pos,
     GrowableArray<Field*>* initialized_fields,
     AstNode* instance,
     Field* field,
     AstNode* init_value) {
   ASSERT(!field->is_static());
   AstNode* result = NULL;
   const String& field_name = String::Handle(field->name());
   String& initialized_name = String::Handle(Z);
@@ skipping 82 matching lines @@
     initializer_idx++;
     if (initialized_field->raw() == field->raw()) {
       ReportError(init_pos, "duplicate initializer for field %s",
                   String::Handle(Z, field->name()).ToCString());
     }
   }
   initialized_fields->Add(field);
   return result;
 }
 
-
 void Parser::ParseInitializers(const Class& cls,
                                LocalVariable* receiver,
                                GrowableArray<Field*>* initialized_fields) {
   TRACE_PARSER("ParseInitializers");
   bool super_init_is_last = false;
   intptr_t super_init_index = -1;
   StaticCallNode* super_init_call = NULL;
   if (CurrentToken() == Token::kCOLON) {
     do {
       ConsumeToken();  // Colon or comma.
@@ skipping 51 matching lines @@
       AstNode* save_temp = new (Z) StoreLocalNode(arg->token_pos(), temp, arg);
       saved_args->AddNode(save_temp);
       ctor_args->SetNodeAt(i, new (Z) LoadLocalNode(arg->token_pos(), temp));
     }
     current_block_->statements->ReplaceNodeAt(super_init_index, saved_args);
     current_block_->statements->Add(super_init_call);
   }
   CheckFieldsInitialized(cls);
 }
 
-
 void Parser::ParseConstructorRedirection(const Class& cls,
                                          LocalVariable* receiver) {
   TRACE_PARSER("ParseConstructorRedirection");
   ExpectToken(Token::kCOLON);
   ASSERT(CurrentToken() == Token::kTHIS);
   const TokenPosition call_pos = TokenPos();
   ConsumeToken();
   String& ctor_name = String::Handle(Z, cls.Name());
   GrowableHandlePtrArray<const String> pieces(Z, 3);
   pieces.Add(ctor_name);
@@ skipping 34 matching lines @@
                                        arguments->length(), arguments->names(),
                                        &error_message)) {
     ReportError(call_pos, "invalid arguments passed to constructor '%s': %s",
                 String::Handle(Z, redirect_ctor.UserVisibleName()).ToCString(),
                 error_message.ToCString());
   }
   current_block_->statements->Add(
       new StaticCallNode(call_pos, redirect_ctor, arguments));
 }
 
-
 SequenceNode* Parser::MakeImplicitConstructor(const Function& func) {
   ASSERT(func.IsGenerativeConstructor());
   ASSERT(func.Owner() == current_class().raw());
   const TokenPosition ctor_pos = TokenPos();
   OpenFunctionBlock(func);
 
   LocalVariable* receiver =
       new LocalVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
                         Symbols::This(), *ReceiverType(current_class()));
   current_block_->scope->InsertParameterAt(0, receiver);
@@ skipping 55 matching lines @@
     current_block_->statements->Add(super_call);
   }
   CheckFieldsInitialized(current_class());
 
   // Empty constructor body.
   current_block_->statements->Add(new ReturnNode(ST(ctor_pos)));
   SequenceNode* statements = CloseBlock();
   return statements;
 }
 
-
 // Returns a zone allocated string.
 static char* DumpPendingFunctions(
     Zone* zone,
     const GrowableObjectArray& pending_functions) {
   ASSERT(zone != NULL);
   char* result = OS::SCreate(zone, "Pending Functions:\n");
   for (intptr_t i = 0; i < pending_functions.Length(); i++) {
     const Function& func =
         Function::Handle(zone, Function::RawCast(pending_functions.At(i)));
     const String& fname = String::Handle(zone, func.UserVisibleName());
     result = OS::SCreate(zone, "%s%" Pd ": %s\n", result, i, fname.ToCString());
   }
   return result;
 }
 
-
 void Parser::CheckRecursiveInvocation() {
   const GrowableObjectArray& pending_functions =
       GrowableObjectArray::Handle(Z, T->pending_functions());
   ASSERT(!pending_functions.IsNull());
   for (int i = 0; i < pending_functions.Length(); i++) {
     if (pending_functions.At(i) == current_function().raw()) {
       const String& fname =
           String::Handle(Z, current_function().UserVisibleName());
       if (FLAG_trace_service) {
         const char* pending_function_dump =
             DumpPendingFunctions(Z, pending_functions);
         ASSERT(pending_function_dump != NULL);
         ReportError("circular dependency for function %s\n%s",
                     fname.ToCString(), pending_function_dump);
       } else {
         ReportError("circular dependency for function %s", fname.ToCString());
       }
     }
   }
   ASSERT(!unregister_pending_function_);
   pending_functions.Add(current_function(), Heap::kOld);
   unregister_pending_function_ = true;
 }
 
-
 // Parser is at the opening parenthesis of the formal parameter declaration
 // of function. Parse the formal parameters, initializers and code.
 SequenceNode* Parser::ParseConstructor(const Function& func) {
   TRACE_PARSER("ParseConstructor");
   ASSERT(func.IsGenerativeConstructor());
   ASSERT(!func.IsFactory());
   ASSERT(!func.is_static());
   ASSERT(!func.IsLocalFunction());
   const Class& cls = Class::Handle(Z, func.Owner());
   ASSERT(!cls.IsNull());
@@ skipping 154 matching lines @@
 
   SequenceNode* ctor_block = CloseBlock();
   if (ctor_block->length() > 0) {
     current_block_->statements->Add(ctor_block);
   }
   current_block_->statements->Add(new ReturnNode(func.end_token_pos()));
   SequenceNode* statements = CloseBlock();
   return statements;
 }
 
-
 // Parser is at the opening parenthesis of the formal parameter
 // declaration of the function or constructor.
 // Parse the formal parameters and code.
 SequenceNode* Parser::ParseFunc(const Function& func, bool check_semicolon) {
   TRACE_PARSER("ParseFunc");
   ASSERT(innermost_function().raw() == func.raw());
 
   // Save current try index. Try index starts at zero for each function.
   intptr_t saved_try_index = last_used_try_index_;
   last_used_try_index_ = 0;
@@ skipping 283 matching lines @@
   } else if (func.IsAsyncGenClosure()) {
     body = CloseAsyncGeneratorClosure(body);
   }
   EnsureHasReturnStatement(body, end_token_pos);
   current_block_->statements->Add(body);
   last_used_try_index_ = saved_try_index;
   async_temp_scope_ = saved_async_temp_scope;
   return CloseBlock();
 }
 
-
 void Parser::AddEqualityNullCheck() {
   AstNode* argument = new LoadLocalNode(
       TokenPosition::kNoSource, current_block_->scope->parent()->VariableAt(1));
   LiteralNode* null_operand =
       new LiteralNode(TokenPosition::kNoSource, Instance::ZoneHandle(Z));
   ComparisonNode* check_arg = new ComparisonNode(
       TokenPosition::kNoSource, Token::kEQ_STRICT, argument, null_operand);
   ComparisonNode* result =
       new ComparisonNode(TokenPosition::kNoSource, Token::kEQ_STRICT,
                          LoadReceiver(TokenPosition::kNoSource), null_operand);
   SequenceNode* arg_is_null =
       new SequenceNode(TokenPosition::kNoSource, current_block_->scope);
   arg_is_null->Add(new ReturnNode(TokenPosition::kNoSource, result));
   IfNode* if_arg_null =
       new IfNode(TokenPosition::kNoSource, check_arg, arg_is_null, NULL);
   current_block_->statements->Add(if_arg_null);
 }
 
-
 void Parser::SkipIf(Token::Kind token) {
   if (CurrentToken() == token) {
     ConsumeToken();
   }
 }
 
-
 void Parser::SkipInitializers() {
   ASSERT(CurrentToken() == Token::kCOLON);
   do {
     ConsumeToken();  // Colon or comma.
     if (CurrentToken() == Token::kSUPER) {
       ConsumeToken();
       if (CurrentToken() == Token::kPERIOD) {
         ConsumeToken();
         ExpectIdentifier("identifier expected");
       }
       CheckToken(Token::kLPAREN);
       SkipToMatchingParenthesis();
     } else if (FLAG_assert_initializer && (CurrentToken() == Token::kASSERT)) {
       ConsumeToken();
       CheckToken(Token::kLPAREN);
       SkipToMatchingParenthesis();
     } else {
       SkipIf(Token::kTHIS);
       SkipIf(Token::kPERIOD);
       ExpectIdentifier("identifier expected");
       ExpectToken(Token::kASSIGN);
       SetAllowFunctionLiterals(false);
       SkipExpr();
       SetAllowFunctionLiterals(true);
     }
   } while (CurrentToken() == Token::kCOMMA);
 }
 
-
 // If the current identifier is a library prefix followed by a period,
 // consume the identifier and period, and return the resolved library
 // prefix.
 RawLibraryPrefix* Parser::ParsePrefix() {
   ASSERT(IsIdentifier());
   // A library prefix can never stand by itself. It must be followed by
   // a period or a hash mark (for closurization).
   Token::Kind next_token = LookaheadToken(1);
   if ((next_token != Token::kPERIOD) && (next_token != Token::kHASH)) {
     return LibraryPrefix::null();
@@ skipping 26 matching lines @@
   if (current_class().LookupTypeParameter(ident) != TypeParameter::null()) {
     return LibraryPrefix::null();
   }
 
   // We have a name that is not shadowed, followed by a period or #.
   // Consume the identifier, let the caller consume the . or #.
   ConsumeToken();
   return prefix.raw();
 }
 
-
 void Parser::ParseMethodOrConstructor(ClassDesc* members, MemberDesc* method) {
   TRACE_PARSER("ParseMethodOrConstructor");
   // We are at the beginning of the formal parameters list.
   ASSERT(CurrentToken() == Token::kLPAREN || CurrentToken() == Token::kLT ||
          method->IsGetter());
   ASSERT(method->type != NULL);  // May still be unresolved.
   ASSERT(current_member_ == method);
 
   if (method->has_covariant) {
     ReportError(method->name_pos,
@@ skipping 341 matching lines @@
   }
 
   ASSERT(is_top_level_);
   AddFormalParamsToFunction(&method->params, func);
   ASSERT(innermost_function().raw() == func.raw());
   innermost_function_ = Function::null();
   ResolveSignature(func);
   members->AddFunction(func);
 }
 
-
 void Parser::ParseFieldDefinition(ClassDesc* members, MemberDesc* field) {
   TRACE_PARSER("ParseFieldDefinition");
   // The parser has read the first field name and is now at the token
   // after the field name.
   ASSERT(CurrentToken() == Token::kSEMICOLON ||
          CurrentToken() == Token::kCOMMA || CurrentToken() == Token::kASSIGN);
   ASSERT(field->type != NULL);
   ASSERT(field->name_pos.IsReal());
   ASSERT(current_member_ == field);
   // All const fields are also final.
@@ skipping 152 matching lines @@
     if (CurrentToken() != Token::kCOMMA) {
       break;
     }
     ConsumeToken();
     field->name_pos = this->TokenPos();
     field->name = ExpectIdentifier("field name expected");
   }
   ExpectSemicolon();
 }
 
-
 void Parser::CheckOperatorArity(const MemberDesc& member) {
   intptr_t expected_num_parameters;  // Includes receiver.
   Token::Kind op = member.operator_token;
   if (op == Token::kASSIGN_INDEX) {
     expected_num_parameters = 3;
   } else if ((op == Token::kBIT_NOT) || (op == Token::kNEGATE)) {
     expected_num_parameters = 1;
   } else {
     expected_num_parameters = 2;
   }
   if ((member.params.num_optional_parameters > 0) ||
       member.params.has_optional_positional_parameters ||
       member.params.has_optional_named_parameters ||
       (member.params.num_fixed_parameters != expected_num_parameters)) {
     // Subtract receiver when reporting number of expected arguments.
     ReportError(member.name_pos, "operator %s expects %" Pd " argument(s)",
                 member.name->ToCString(), (expected_num_parameters - 1));
   }
 }
 
-
 void Parser::CheckMemberNameConflict(ClassDesc* members, MemberDesc* member) {
   const String& name = *member->DictName();
   if (name.Equals(members->class_name())) {
     ReportError(member->name_pos, "%s '%s' conflicts with class name",
                 member->ToCString(), name.ToCString());
   }
   if (members->clazz().LookupTypeParameter(name) != TypeParameter::null()) {
     ReportError(member->name_pos, "%s '%s' conflicts with type parameter",
                 member->ToCString(), name.ToCString());
   }
   for (int i = 0; i < members->members().length(); i++) {
     MemberDesc* existing_member = &members->members()[i];
     if (name.Equals(*existing_member->DictName())) {
       ReportError(
           member->name_pos, "%s '%s' conflicts with previously declared %s",
           member->ToCString(), name.ToCString(), existing_member->ToCString());
     }
   }
 }
 
-
 void Parser::ParseClassMemberDefinition(ClassDesc* members,
                                         TokenPosition metadata_pos) {
   TRACE_PARSER("ParseClassMemberDefinition");
   MemberDesc member;
   current_member_ = &member;
   member.metadata_pos = metadata_pos;
   member.decl_begin_pos = TokenPos();
   if ((CurrentToken() == Token::kEXTERNAL) &&
       (LookaheadToken(1) != Token::kLPAREN)) {
     ConsumeToken();
@@ skipping 195 matching lines @@
     }
     ParseFieldDefinition(members, &member);
   } else {
     UnexpectedToken();
   }
   current_member_ = NULL;
   CheckMemberNameConflict(members, &member);
   members->AddMember(member);
 }
 
-
 void Parser::ParseEnumDeclaration(const GrowableObjectArray& pending_classes,
                                   const Object& tl_owner,
                                   TokenPosition metadata_pos) {
   TRACE_PARSER("ParseEnumDeclaration");
   const TokenPosition declaration_pos =
       (metadata_pos.IsReal()) ? metadata_pos : TokenPos();
   ConsumeToken();
   const TokenPosition name_pos = TokenPos();
   String* enum_name =
       ExpectUserDefinedTypeIdentifier("enum type name expected");
@@ skipping 28 matching lines @@
   library_.AddClass(cls);
   cls.set_is_synthesized_class();
   cls.set_is_enum_class();
   if (FLAG_enable_mirrors && (metadata_pos.IsReal())) {
     library_.AddClassMetadata(cls, tl_owner, metadata_pos);
   }
   cls.set_super_type(Type::Handle(Z, Type::ObjectType()));
   pending_classes.Add(cls, Heap::kOld);
 }
 
-
 void Parser::ParseClassDeclaration(const GrowableObjectArray& pending_classes,
                                    const Object& tl_owner,
                                    TokenPosition metadata_pos) {
   TRACE_PARSER("ParseClassDeclaration");
   bool is_patch = false;
   bool is_abstract = false;
   TokenPosition declaration_pos =
       metadata_pos.IsReal() ? metadata_pos : TokenPos();
   if (is_patch_source() && IsPatchAnnotation(metadata_pos)) {
     is_patch = true;
@@ skipping 165 matching lines @@
 
   if (is_mixin_declaration) {
     ExpectSemicolon();
   } else {
     CheckToken(Token::kLBRACE);
     SkipBlock();
     ExpectToken(Token::kRBRACE);
   }
 }
 
-
 void Parser::ParseClassDefinition(const Class& cls) {
   TRACE_PARSER("ParseClassDefinition");
   INC_STAT(thread(), num_classes_parsed, 1);
   set_current_class(cls);
   is_top_level_ = true;
   String& class_name = String::Handle(Z, cls.Name());
   SkipMetadata();
   if (CurrentToken() == Token::kABSTRACT) {
     ConsumeToken();
   }
@@ skipping 47 matching lines @@
         Report::LongJumpF(error, script_, class_pos,
                           "patch validation failed, not applying patch.\n");
       }
     }
     if (!orig_class.ApplyPatch(cls, &error)) {
       Report::LongJumpF(error, script_, class_pos, "applying patch failed");
     }
   }
 }
 
-
 void Parser::ParseEnumDefinition(const Class& cls) {
   TRACE_PARSER("ParseEnumDefinition");
   INC_STAT(thread(), num_classes_parsed, 1);
   set_current_class(cls);
   const Class& helper_class =
       Class::Handle(Z, Library::LookupCoreClass(Symbols::_EnumHelper()));
   ASSERT(!helper_class.IsNull());
 
   SkipMetadata();
   ExpectToken(Token::kENUM);
@@ skipping 170 matching lines @@
       Z, helper_class.LookupDynamicFunctionAllowPrivate(Symbols::hashCode()));
   ASSERT(!hash_code_func.IsNull());
   hash_code_func = hash_code_func.Clone(cls);
   enum_members.AddFunction(hash_code_func);
 
   cls.AddFields(enum_members.fields());
   const Array& functions = Array::Handle(Z, enum_members.MakeFunctionsArray());
   cls.SetFunctions(functions);
 }
 
-
 // Add an implicit constructor to the given class.
 void Parser::AddImplicitConstructor(const Class& cls) {
   // The implicit constructor is unnamed, has no explicit parameter.
   String& ctor_name = String::ZoneHandle(Z, cls.Name());
   ctor_name = Symbols::FromDot(T, ctor_name);
   // To indicate that this is an implicit constructor, we set the
   // token position and end token position of the function
   // to the token position of the class.
   Function& ctor = Function::Handle(
       Z, Function::New(ctor_name, RawFunction::kConstructor,
@@ skipping 15 matching lines @@
 
   AddFormalParamsToFunction(&params, ctor);
   ctor.set_result_type(Object::dynamic_type());
   ResolveSignature(ctor);
   // The body of the constructor cannot modify the type of the constructed
   // instance, which is passed in as the receiver.
   ctor.set_result_type(*receiver_type);
   cls.AddFunction(ctor);
 }
 
-
 void Parser::CheckFinalInitializationConflicts(const ClassDesc* class_desc,
                                                const MemberDesc* member) {
   const ParamList* params = &member->params;
   if (!params->has_field_initializer) {
     return;
   }
 
   const ZoneGrowableArray<ParamDesc>& parameters = *params->parameters;
   const GrowableArray<const Field*>& fields = class_desc->fields();
   String& field_name = String::Handle(Z);
@@ skipping 14 matching lines @@
       field_name ^= current_field->name();
       if (param_name.Equals(field_name)) {
         ReportError(current_param.name_pos,
                     "final field '%s' is already initialized.",
                     param_name.ToCString());
       }
     }
   }
 }
 
-
 // Check for cycles in constructor redirection.
 void Parser::CheckConstructors(ClassDesc* class_desc) {
   // Check for cycles in constructor redirection.
   const GrowableArray<MemberDesc>& members = class_desc->members();
   for (int i = 0; i < members.length(); i++) {
     MemberDesc* member = &members[i];
     if (member->IsConstructor()) {
       // Check that our constructors don't try and reinitialize an initialized
       // final variable.
       CheckFinalInitializationConflicts(class_desc, member);
@@ skipping 15 matching lines @@
       // the next redirection. If we can't find the constructor to
       // which the current one redirects, we ignore the unresolved
       // reference. We'll catch it later when the constructor gets
       // compiled.
       ctors.Add(member);
       member = class_desc->LookupMember(*member->redirect_name);
     }
   }
 }
 
-
 void Parser::ParseMixinAppAlias(const GrowableObjectArray& pending_classes,
                                 const Object& tl_owner,
                                 TokenPosition metadata_pos) {
   TRACE_PARSER("ParseMixinAppAlias");
   const TokenPosition classname_pos = TokenPos();
   String& class_name = *ExpectUserDefinedTypeIdentifier("class name expected");
   if (FLAG_trace_parser) {
     OS::Print("toplevel parsing mixin application alias class '%s'\n",
               class_name.ToCString());
   }
@@ skipping 37 matching lines @@
   if (CurrentToken() == Token::kIMPLEMENTS) {
     ParseInterfaceList(mixin_application);
   }
   ExpectSemicolon();
   pending_classes.Add(mixin_application, Heap::kOld);
   if (FLAG_enable_mirrors && metadata_pos.IsReal()) {
     library_.AddClassMetadata(mixin_application, tl_owner, metadata_pos);
   }
 }
 
-
 // Look ahead to detect if we are seeing ident [ TypeParameters ] ("(" | "=").
 // We need this lookahead to distinguish between the optional return type
 // and the alias name of a function type alias.
 // Token position remains unchanged.
 bool Parser::IsFunctionTypeAliasName(bool* use_function_type_syntax) {
   if (IsIdentifier()) {
     const Token::Kind ahead = LookaheadToken(1);
     if ((ahead == Token::kLPAREN) || (ahead == Token::kASSIGN)) {
       *use_function_type_syntax = (ahead == Token::kASSIGN);
       return true;
     }
   }
   const TokenPosScope saved_pos(this);
   if (IsIdentifier() && (LookaheadToken(1) == Token::kLT)) {
     ConsumeToken();
     if (TryParseTypeParameters()) {
       const Token::Kind current = CurrentToken();
       if ((current == Token::kLPAREN) || (current == Token::kASSIGN)) {
         *use_function_type_syntax = (current == Token::kASSIGN);
         return true;
       }
     }
   }
   *use_function_type_syntax = false;
   return false;
 }
 
-
 void Parser::ParseTypedef(const GrowableObjectArray& pending_classes,
                           const Object& tl_owner,
                           TokenPosition metadata_pos) {
   TRACE_PARSER("ParseTypedef");
   TokenPosition declaration_pos =
       metadata_pos.IsReal() ? metadata_pos : TokenPos();
   ExpectToken(Token::kTYPEDEF);
 
   // Distinguish between two possible typedef forms:
   // 1) returnType? identifier typeParameters? formalParameterList ’;’
@@ skipping 98 matching lines @@
   }
   // The alias should not be marked as finalized yet, since it needs to be
   // checked in the class finalizer for illegal self references.
   ASSERT(!function_type_alias.is_finalized());
   pending_classes.Add(function_type_alias, Heap::kOld);
   if (FLAG_enable_mirrors && metadata_pos.IsReal()) {
     library_.AddClassMetadata(function_type_alias, tl_owner, metadata_pos);
   }
 }
 
-
 // Consumes exactly one right angle bracket. If the current token is
 // a single bracket token, it is consumed normally. However, if it is
 // a double bracket, it is replaced by a single bracket token without
 // incrementing the token index.
 void Parser::ConsumeRightAngleBracket() {
   if (token_kind_ == Token::kGT) {
     ConsumeToken();
   } else if (token_kind_ == Token::kSHR) {
     token_kind_ = Token::kGT;
   } else {
     UNREACHABLE();
   }
 }
 
-
 bool Parser::IsPatchAnnotation(TokenPosition pos) {
   if (pos == TokenPosition::kNoSource) {
     return false;
   }
   TokenPosScope saved_pos(this);
   SetPosition(pos);
   ExpectToken(Token::kAT);
   return IsSymbol(Symbols::Patch());
 }
 
-
 TokenPosition Parser::SkipMetadata() {
   if (CurrentToken() != Token::kAT) {
     return TokenPosition::kNoSource;
   }
   TokenPosition metadata_pos = TokenPos();
   while (CurrentToken() == Token::kAT) {
     ConsumeToken();
     ExpectIdentifier("identifier expected");
     if (CurrentToken() == Token::kPERIOD) {
       ConsumeToken();
       ExpectIdentifier("identifier expected");
       if (CurrentToken() == Token::kPERIOD) {
         ConsumeToken();
         ExpectIdentifier("identifier expected");
       }
     }
     if (CurrentToken() == Token::kLPAREN) {
       SkipToMatchingParenthesis();
     }
   }
   return metadata_pos;
 }
 
-
 void Parser::SkipTypeArguments() {
   if (CurrentToken() == Token::kLT) {
     do {
       ConsumeToken();
       SkipTypeOrFunctionType(true);
     } while (CurrentToken() == Token::kCOMMA);
     Token::Kind token = CurrentToken();
     if ((token == Token::kGT) || (token == Token::kSHR)) {
       ConsumeRightAngleBracket();
     } else {
       ReportError("right angle bracket expected");
     }
   }
 }
 
-
 void Parser::SkipTypeParameters() {
   // Function already parsed, no need to check FLAG_generic_method_syntax.
   if (IsTypeParameters()) {
     const bool skipped = TryParseTypeParameters();
     ASSERT(skipped);
   }
 }
 
-
 void Parser::SkipType(bool allow_void) {
   if (CurrentToken() == Token::kVOID) {
     if (!allow_void) {
       ReportError("'void' not allowed here");
     }
     ConsumeToken();
   } else {
     ExpectIdentifier("type name expected");
     if (CurrentToken() == Token::kPERIOD) {
       ConsumeToken();
       ExpectIdentifier("name expected");
     }
     SkipTypeArguments();
   }
 }
 
-
 void Parser::SkipTypeOrFunctionType(bool allow_void) {
   if (CurrentToken() == Token::kVOID) {
     TokenPosition void_pos = TokenPos();
     ConsumeToken();
     // 'void' is always allowed as result type of a function type.
     if (!allow_void && !IsFunctionTypeSymbol()) {
       ReportError(void_pos, "'void' not allowed here");
     }
   } else if (!IsFunctionTypeSymbol()) {
     // Including 'Function' not followed by '(' or '<'.
     SkipType(false);
   }
   while (IsFunctionTypeSymbol()) {
     ConsumeToken();
     SkipTypeArguments();
     if (CurrentToken() == Token::kLPAREN) {
       SkipToMatchingParenthesis();
     } else {
       ReportError("'(' expected");
     }
   }
 }
 
-
 void Parser::ParseTypeParameters(bool parameterizing_class) {
   TRACE_PARSER("ParseTypeParameters");
   if (CurrentToken() == Token::kLT) {
     GrowableArray<AbstractType*> type_parameters_array(Z, 2);
     intptr_t index = 0;
     TypeParameter& type_parameter = TypeParameter::Handle(Z);
     TypeParameter& existing_type_parameter = TypeParameter::Handle(Z);
     String& existing_type_parameter_name = String::Handle(Z);
     AbstractType& type_parameter_bound = Type::Handle(Z);
     do {
@@ skipping 64 matching lines @@
     const intptr_t num_types = type_parameters.Length();
     for (intptr_t i = 0; i < num_types; i++) {
       type_parameter ^= type_parameters.TypeAt(i);
       type_parameter_bound = type_parameter.bound();
       ResolveType(&type_parameter_bound);
       type_parameter.set_bound(type_parameter_bound);
     }
   }
 }
 
-
 RawTypeArguments* Parser::ParseTypeArguments(
     ClassFinalizer::FinalizationKind finalization) {
   TRACE_PARSER("ParseTypeArguments");
   if (CurrentToken() == Token::kLT) {
     GrowableArray<AbstractType*> types;
     AbstractType& type = AbstractType::Handle(Z);
     do {
       ConsumeToken();
       type = ParseTypeOrFunctionType(true, finalization);
       // Map a malformed type argument to dynamic.
@@ skipping 12 matching lines @@
       TypeArguments& type_args = TypeArguments::Handle(NewTypeArguments(types));
       if (finalization == ClassFinalizer::kCanonicalize) {
         type_args = type_args.Canonicalize();
       }
       return type_args.raw();
     }
   }
   return TypeArguments::null();
 }
 
-
 // Parse interface list and add to class cls.
 void Parser::ParseInterfaceList(const Class& cls) {
   TRACE_PARSER("ParseInterfaceList");
   ASSERT(CurrentToken() == Token::kIMPLEMENTS);
   const GrowableObjectArray& all_interfaces =
       GrowableObjectArray::Handle(Z, GrowableObjectArray::New(Heap::kOld));
   AbstractType& interface = AbstractType::Handle(Z);
   // First get all the interfaces already implemented by class.
   Array& cls_interfaces = Array::Handle(Z, cls.interfaces());
   for (intptr_t i = 0; i < cls_interfaces.Length(); i++) {
     interface ^= cls_interfaces.At(i);
     all_interfaces.Add(interface, Heap::kOld);
   }
   // Now parse and add the new interfaces.
   do {
     ConsumeToken();
     TokenPosition interface_pos = TokenPos();
     interface = ParseType(ClassFinalizer::kResolveTypeParameters);
     if (interface.IsTypeParameter()) {
       ReportError(interface_pos,
                   "type parameter '%s' may not be used in interface list",
                   String::Handle(Z, interface.UserVisibleName()).ToCString());
     }
     all_interfaces.Add(interface, Heap::kOld);
   } while (CurrentToken() == Token::kCOMMA);
   cls_interfaces = Array::MakeFixedLength(all_interfaces);
   cls.set_interfaces(cls_interfaces);
 }
 
-
 RawAbstractType* Parser::ParseMixins(const AbstractType& super_type) {
   TRACE_PARSER("ParseMixins");
   ASSERT(CurrentToken() == Token::kWITH);
   const GrowableObjectArray& mixin_types =
       GrowableObjectArray::Handle(Z, GrowableObjectArray::New(Heap::kOld));
   AbstractType& mixin_type = AbstractType::Handle(Z);
   do {
     ConsumeToken();
     mixin_type = ParseType(ClassFinalizer::kResolveTypeParameters);
     if (mixin_type.IsDynamicType()) {
       // The string 'dynamic' is not resolved yet at this point, but a malformed
       // type mapped to dynamic can be encountered here.
       ReportError(mixin_type.token_pos(), "illegal mixin of a malformed type");
     }
     if (mixin_type.IsTypeParameter()) {
       ReportError(mixin_type.token_pos(),
                   "mixin type '%s' may not be a type parameter",
                   String::Handle(Z, mixin_type.UserVisibleName()).ToCString());
     }
     mixin_types.Add(mixin_type, Heap::kOld);
   } while (CurrentToken() == Token::kCOMMA);
   return MixinAppType::New(
       super_type, Array::Handle(Z, Array::MakeFixedLength(mixin_types)));
 }
 
-
 void Parser::ParseTopLevelVariable(TopLevel* top_level,
                                    const Object& owner,
                                    TokenPosition metadata_pos) {
   TRACE_PARSER("ParseTopLevelVariable");
   const bool is_const = (CurrentToken() == Token::kCONST);
   // Const fields are implicitly final.
   const bool is_final = is_const || (CurrentToken() == Token::kFINAL);
   const bool is_static = true;
   const AbstractType& type = AbstractType::ZoneHandle(
       Z, ParseConstFinalVarOrType(ClassFinalizer::kResolveTypeParameters));
@@ skipping 70 matching lines @@
       ConsumeToken();
     } else if (CurrentToken() == Token::kSEMICOLON) {
       ConsumeToken();
       break;
     } else {
       ExpectSemicolon();  // Reports error.
     }
   }
 }
 
-
 RawFunction::AsyncModifier Parser::ParseFunctionModifier() {
   if (IsSymbol(Symbols::Async())) {
     ConsumeToken();
     if (CurrentToken() == Token::kMUL) {
       const bool enableAsyncStar = true;
       if (!enableAsyncStar) {
         ReportError("async* generator functions are not yet supported");
       }
       ConsumeToken();
       return RawFunction::kAsyncGen;
     } else {
       return RawFunction::kAsync;
     }
   } else if (IsSymbol(Symbols::Sync()) && (LookaheadToken(1) == Token::kMUL)) {
     const bool enableSyncStar = true;
     if (!enableSyncStar) {
       ReportError("sync* generator functions are not yet supported");
     }
     ConsumeToken();
     ConsumeToken();
     return RawFunction::kSyncGen;
   }
   return RawFunction::kNoModifier;
 }
 
-
 void Parser::ParseTopLevelFunction(TopLevel* top_level,
                                    const Object& owner,
                                    TokenPosition metadata_pos) {
   TRACE_PARSER("ParseTopLevelFunction");
   const TokenPosition decl_begin_pos = TokenPos();
   AbstractType& result_type = Type::Handle(Z, Type::DynamicType());
   bool is_external = false;
   bool is_patch = false;
   if (is_patch_source() && IsPatchAnnotation(metadata_pos)) {
     is_patch = true;
@@ skipping 112 matching lines @@
         Function::Handle(Z, toplevel_cls.LookupStaticFunction(func_name));
     ASSERT(!replaced_func.IsNull());
     toplevel_cls.RemoveFunction(replaced_func);
     library_.ReplaceObject(func, func_name);
   }
   if (FLAG_enable_mirrors && metadata_pos.IsReal()) {
     library_.AddFunctionMetadata(func, metadata_pos);
   }
 }
 
-
 void Parser::ParseTopLevelAccessor(TopLevel* top_level,
                                    const Object& owner,
                                    TokenPosition metadata_pos) {
   TRACE_PARSER("ParseTopLevelAccessor");
   const TokenPosition decl_begin_pos = TokenPos();
   const bool is_static = true;
   bool is_external = false;
   bool is_patch = false;
   AbstractType& result_type = AbstractType::Handle(Z);
   if (is_patch_source() && IsPatchAnnotation(metadata_pos)) {
@@ skipping 99 matching lines @@
     ExpectSemicolon();
   } else if (IsSymbol(Symbols::Native())) {
     native_name = &ParseNativeDeclaration();
     accessor_end_pos = TokenPos();
     ExpectSemicolon();
     is_native = true;
   } else {
     ReportError("function block expected");
   }
   Function& func = Function::Handle(
-      Z, Function::New(accessor_name, is_getter ? RawFunction::kGetterFunction
-                                                : RawFunction::kSetterFunction,
+      Z, Function::New(accessor_name,
+                       is_getter ? RawFunction::kGetterFunction
+                                 : RawFunction::kSetterFunction,
                        is_static,
                        /* is_const = */ false,
                        /* is_abstract = */ false, is_external, is_native, owner,
                        decl_begin_pos));
   func.set_result_type(result_type);
   func.set_end_token_pos(accessor_end_pos);
   func.set_modifier(func_modifier);
   if (is_native) {
     func.set_is_debuggable(false);
     func.set_native_name(*native_name);
@@ skipping 15 matching lines @@
         Function::Handle(Z, toplevel_cls.LookupFunction(accessor_name));
     ASSERT(!replaced_func.IsNull());
     toplevel_cls.RemoveFunction(replaced_func);
     library_.ReplaceObject(func, accessor_name);
   }
   if (FLAG_enable_mirrors && metadata_pos.IsReal()) {
     library_.AddFunctionMetadata(func, metadata_pos);
   }
 }
 
-
 RawObject* Parser::CallLibraryTagHandler(Dart_LibraryTag tag,
                                          TokenPosition token_pos,
                                          const String& url) {
   Dart_LibraryTagHandler handler = I->library_tag_handler();
   if (handler == NULL) {
     if (url.StartsWith(Symbols::DartScheme())) {
       if (tag == Dart_kCanonicalizeUrl) {
         return url.raw();
       }
       return Object::null();
@@ skipping 19 matching lines @@
     Report::LongJumpF(prev_error, script_, token_pos, "library handler failed");
   }
   if (tag == Dart_kCanonicalizeUrl) {
     if (!result.IsString()) {
       ReportError(token_pos, "library handler failed URI canonicalization");
     }
   }
   return result.raw();
 }
 
-
 void Parser::ParseLibraryName() {
   ASSERT(CurrentToken() == Token::kLIBRARY);
   ConsumeToken();
   String& lib_name = *ExpectIdentifier("library name expected");
   if (CurrentToken() == Token::kPERIOD) {
     GrowableHandlePtrArray<const String> pieces(Z, 3);
     pieces.Add(lib_name);
     while (CurrentToken() == Token::kPERIOD) {
       ConsumeToken();
       pieces.Add(Symbols::Dot());
       pieces.Add(*ExpectIdentifier("malformed library name"));
     }
     lib_name = Symbols::FromConcatAll(T, pieces);
   }
   library_.SetName(lib_name);
   ExpectSemicolon();
 }
 
-
 void Parser::ParseIdentList(GrowableObjectArray* names) {
   if (!IsIdentifier()) {
     ReportError("identifier expected");
   }
   while (IsIdentifier()) {
     names->Add(*CurrentLiteral(), allocation_space_);
     ConsumeToken();  // Identifier.
     if (CurrentToken() != Token::kCOMMA) {
       return;
     }
     ConsumeToken();  // Comma.
   }
 }
 
-
 void Parser::ParseLibraryImportExport(const Object& tl_owner,
                                       TokenPosition metadata_pos) {
   ASSERT(Thread::Current()->IsMutatorThread());
   bool is_import = (CurrentToken() == Token::kIMPORT);
   bool is_export = (CurrentToken() == Token::kEXPORT);
   ASSERT(is_import || is_export);
   const TokenPosition import_pos = TokenPos();
   ConsumeToken();
   CheckToken(Token::kSTRING, "library url expected");
   AstNode* url_literal = ParseStringLiteral(false);
@@ skipping 161 matching lines @@
             LibraryPrefix::New(prefix, ns, is_deferred_import, library_);
         library_.AddObject(library_prefix, prefix);
       }
     }
   } else {
     ASSERT(is_export);
     library_.AddExport(ns);
   }
 }
 
-
 void Parser::ParseLibraryPart() {
   const TokenPosition source_pos = TokenPos();
   ConsumeToken();  // Consume "part".
   if (IsSymbol(Symbols::Of())) {
     ReportError("part of declarations are not allowed in script files");
   }
   CheckToken(Token::kSTRING, "url expected");
   AstNode* url_literal = ParseStringLiteral(false);
   ASSERT(url_literal->IsLiteralNode());
   ASSERT(url_literal->AsLiteralNode()->literal().IsString());
   const String& url = String::Cast(url_literal->AsLiteralNode()->literal());
   ExpectSemicolon();
   const String& canon_url = String::CheckedHandle(
       CallLibraryTagHandler(Dart_kCanonicalizeUrl, source_pos, url));
   CallLibraryTagHandler(Dart_kSourceTag, source_pos, canon_url);
 }
 
-
 void Parser::ParseLibraryDefinition(const Object& tl_owner) {
   TRACE_PARSER("ParseLibraryDefinition");
 
   // Handle the script tag.
   if (CurrentToken() == Token::kSCRIPTTAG) {
     // Nothing to do for script tags except to skip them.
     ConsumeToken();
   }
 
   ASSERT(script_.kind() != RawScript::kSourceTag);
@@ skipping 32 matching lines @@
     library_.AddImport(core_ns);
   }
   while (CurrentToken() == Token::kPART) {
     ParseLibraryPart();
     rewind_pos = TokenPos();
     metadata_pos = SkipMetadata();
   }
   SetPosition(rewind_pos);
 }
 
-
 void Parser::ParsePartHeader() {
   SkipMetadata();
   CheckToken(Token::kPART, "'part of' expected");
   ConsumeToken();
   if (!IsSymbol(Symbols::Of())) {
     ReportError("'part of' expected");
   }
   ConsumeToken();
   // The VM is not required to check that the library name or URI matches the
   // name or URI of the current library, so we ignore them.
   if (CurrentToken() == Token::kSTRING) {
     ParseStringLiteral(false);
   } else {
     ExpectIdentifier("library name expected");
     while (CurrentToken() == Token::kPERIOD) {
       ConsumeToken();
       ExpectIdentifier("malformed library name");
     }
   }
   ExpectSemicolon();
 }
 
-
 void Parser::ParseTopLevel() {
   TRACE_PARSER("ParseTopLevel");
   // Collect the classes found at the top level in this growable array.
   // They need to be registered with class finalization after parsing
   // has been completed.
   ObjectStore* object_store = I->object_store();
   const GrowableObjectArray& pending_classes =
       GrowableObjectArray::Handle(Z, object_store->pending_classes());
   SetPosition(TokenPosition::kMinSource);
   is_top_level_ = true;
@@ skipping 54 matching lines @@
   }
   for (intptr_t i = 0; i < top_level.functions().length(); i++) {
     toplevel_class.AddFunction(*top_level.functions()[i]);
   }
   if (toplevel_class.is_finalized()) {
     toplevel_class.ResetFinalization();
   }
   pending_classes.Add(toplevel_class, Heap::kOld);
 }
 
-
 void Parser::CheckStack() {
   volatile uword c_stack_pos = Thread::GetCurrentStackPointer();
   volatile uword c_stack_base = OSThread::Current()->stack_base();
   volatile uword c_stack_limit =
       c_stack_base - OSThread::GetSpecifiedStackSize();
   // Note: during early initialization the stack_base() can return 0.
   if ((c_stack_base > 0) && (c_stack_pos < c_stack_limit)) {
     ReportError("stack overflow while parsing");
   }
 }
 
-
 void Parser::ChainNewBlock(LocalScope* outer_scope) {
   Block* block = new (Z) Block(current_block_, outer_scope,
                                new (Z) SequenceNode(TokenPos(), outer_scope));
   current_block_ = block;
 }
 
-
 void Parser::OpenBlock() {
   ASSERT(current_block_ != NULL);
   LocalScope* outer_scope = current_block_->scope;
   ChainNewBlock(new (Z) LocalScope(outer_scope, outer_scope->function_level(),
                                    outer_scope->loop_level()));
 }
 
-
 void Parser::OpenLoopBlock() {
   ASSERT(current_block_ != NULL);
   LocalScope* outer_scope = current_block_->scope;
   ChainNewBlock(new (Z) LocalScope(outer_scope, outer_scope->function_level(),
                                    outer_scope->loop_level() + 1));
 }
 
-
 void Parser::OpenFunctionBlock(const Function& func) {
   LocalScope* outer_scope;
   if (current_block_ == NULL) {
     if (!func.IsLocalFunction()) {
       // We are compiling a non-nested function.
       outer_scope = new (Z) LocalScope(NULL, 0, 0);
     } else {
       // We are compiling the function of an invoked closure.
       // Restore the outer scope containing all captured variables.
       const ContextScope& context_scope =
           ContextScope::Handle(Z, func.context_scope());
       ASSERT(!context_scope.IsNull());
       outer_scope = new (Z)
           LocalScope(LocalScope::RestoreOuterScope(context_scope), 0, 0);
     }
   } else {
     // We are parsing a nested function while compiling the enclosing function.
     outer_scope = new (Z) LocalScope(
         current_block_->scope, current_block_->scope->function_level() + 1, 0);
   }
   ChainNewBlock(outer_scope);
 }
 
-
 void Parser::OpenAsyncClosure() {
   TRACE_PARSER("OpenAsyncClosure");
   async_temp_scope_ = current_block_->scope;
   OpenAsyncTryBlock();
 }
 
-
 SequenceNode* Parser::CloseAsyncGeneratorTryBlock(SequenceNode* body) {
   TRACE_PARSER("CloseAsyncGeneratorTryBlock");
   // The generated try-catch-finally that wraps the async generator function
   // body is the outermost try statement.
   ASSERT(try_stack_ != NULL);
   ASSERT(try_stack_->outer_try() == NULL);
   // We only get here when parsing an async generator body.
   ASSERT(innermost_function().IsAsyncGenClosure());
 
   const TokenPosition try_end_pos = innermost_function().end_token_pos();
@@ skipping 135 matching lines @@
 
   const intptr_t try_index = try_statement->try_index();
 
   AstNode* try_catch_node = new (Z)
       TryCatchNode(TokenPosition::kNoSource, body, context_var, catch_clause,
                    finally_clause, try_index, finally_clause);
   current_block_->statements->Add(try_catch_node);
   return CloseBlock();
 }
 
-
 SequenceNode* Parser::CloseAsyncTryBlock(SequenceNode* try_block,
                                          TokenPosition func_end_pos) {
   // This is the outermost try-catch of the function.
   ASSERT(try_stack_ != NULL);
   ASSERT(try_stack_->outer_try() == NULL);
   ASSERT(innermost_function().IsAsyncClosure());
   LocalScope* try_scope = current_block_->scope;
 
   try_stack_->enter_catch();
 
@@ skipping 80 matching lines @@
       saved_stack_trace_var, CatchClauseNode::kInvalidTryIndex, true);
   AstNode* try_catch_node = new (Z) TryCatchNode(
       TokenPosition::kNoSource, try_block, context_var, catch_clause,
       NULL,  // No finally clause.
       try_index,
       NULL);  // No rethrow-finally clause.
   current_block_->statements->Add(try_catch_node);
   return CloseBlock();
 }
 
-
 // Wrap the body of the async or async* closure in a try/catch block.
 void Parser::OpenAsyncTryBlock() {
   ASSERT(innermost_function().IsAsyncClosure() ||
          innermost_function().IsAsyncGenClosure());
   LocalVariable* context_var = NULL;
   LocalVariable* exception_var = NULL;
   LocalVariable* stack_trace_var = NULL;
   LocalVariable* saved_exception_var = NULL;
   LocalVariable* saved_stack_trace_var = NULL;
   SetupExceptionVariables(current_block_->scope, true, &context_var,
                           &exception_var, &stack_trace_var,
                           &saved_exception_var, &saved_stack_trace_var);
 
   // Open the try block.
   OpenBlock();
   // This is the outermost try-catch in the function.
   ASSERT(try_stack_ == NULL);
   PushTry(current_block_);
   // Validate that we always get try index of 0.
   ASSERT(try_stack_->try_index() == CatchClauseNode::kImplicitAsyncTryIndex);
 
   SetupSavedTryContext(context_var);
 }
 
-
 void Parser::AddSyncGenClosureParameters(ParamList* params) {
   // Create the parameter list for the body closure of a sync generator:
   // 1) Implicit closure parameter;
   // 2) Iterator
   // Add implicit closure parameter if not already present.
   if (params->parameters->length() == 0) {
     params->AddFinalParameter(TokenPosition::kMinSource,
                               &Symbols::ClosureParameter(),
                               &Object::dynamic_type());
   }
   ParamDesc iterator_param;
   iterator_param.name = &Symbols::IteratorParameter();
   iterator_param.type = &Object::dynamic_type();
   params->parameters->Add(iterator_param);
   params->num_fixed_parameters++;
 }
 
-
 void Parser::AddAsyncGenClosureParameters(ParamList* params) {
   // Create the parameter list for the body closure of an async generator.
   // The closure has the same parameters as an asynchronous non-generator.
   AddAsyncClosureParameters(params);
 }
 
-
 RawFunction* Parser::OpenSyncGeneratorFunction(TokenPosition func_pos) {
   Function& body = Function::Handle(Z);
   String& body_closure_name = String::Handle(Z);
   bool is_new_closure = false;
 
   AddContinuationVariables();
 
   // Check whether a function for the body of this generator
   // function has already been created by a previous
   // compilation.
@@ skipping 75 matching lines @@
   arguments->Add(closure_obj);
   ConstructorCallNode* new_iterable = new (Z) ConstructorCallNode(
       TokenPosition::kNoSource, TypeArguments::ZoneHandle(Z),
       iterable_constructor, arguments);
   ReturnNode* return_node =
       new (Z) ReturnNode(TokenPosition::kNoSource, new_iterable);
   current_block_->statements->Add(return_node);
   return CloseBlock();
 }
 
-
 void Parser::AddAsyncClosureParameters(ParamList* params) {
   // Async closures have three optional parameters:
   // * A continuation result.
   // * A continuation error.
   // * A continuation stack trace.
   ASSERT(params->parameters->length() <= 1);
   // Add implicit closure parameter if not yet present.
   if (params->parameters->length() == 0) {
     params->AddFinalParameter(TokenPosition::kMinSource,
                               &Symbols::ClosureParameter(),
@@ skipping 11 matching lines @@
   params->parameters->Add(error_param);
   ParamDesc stack_trace_param;
   stack_trace_param.name = &Symbols::AsyncOperationStackTraceParam();
   stack_trace_param.default_value = &Object::null_instance();
   stack_trace_param.type = &Object::dynamic_type();
   params->parameters->Add(stack_trace_param);
   params->has_optional_positional_parameters = true;
   params->num_optional_parameters += 3;
 }
 
-
 RawFunction* Parser::OpenAsyncFunction(TokenPosition async_func_pos) {
   TRACE_PARSER("OpenAsyncFunction");
   AddContinuationVariables();
   AddAsyncClosureVariables();
   Function& closure = Function::Handle(Z);
   bool is_new_closure = false;
 
   // Check whether a function for the asynchronous function body of
   // this async function has already been created by a previous
   // compilation of this function.
@@ skipping 30 matching lines @@
     closure.SetSignatureType(signature_type);
     ASSERT(AbstractType::Handle(Z, closure.result_type()).IsResolved());
     ASSERT(closure.NumParameters() == closure_params.parameters->length());
   }
   OpenFunctionBlock(closure);
   AddFormalParamsToScope(&closure_params, current_block_->scope);
   async_temp_scope_ = current_block_->scope;
   return closure.raw();
 }
 
-
 void Parser::AddContinuationVariables() {
   // Add to current block's scope:
   //   var :await_jump_var;
   //   var :await_ctx_var;
   LocalVariable* await_jump_var =
       new (Z) LocalVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
                             Symbols::AwaitJumpVar(), Object::dynamic_type());
   current_block_->scope->AddVariable(await_jump_var);
   LocalVariable* await_ctx_var =
       new (Z) LocalVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
                             Symbols::AwaitContextVar(), Object::dynamic_type());
   current_block_->scope->AddVariable(await_ctx_var);
 }
 
-
 void Parser::AddAsyncClosureVariables() {
   // Add to current block's scope:
   //   var :async_op;
   //   var :async_then_callback;
   //   var :async_catch_error_callback;
   //   var :async_completer;
   //   var :async_stack_trace;
   LocalVariable* async_op_var =
       new (Z) LocalVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
                             Symbols::AsyncOperation(), Object::dynamic_type());
   current_block_->scope->AddVariable(async_op_var);
   LocalVariable* async_then_callback_var = new (Z)
       LocalVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
                     Symbols::AsyncThenCallback(), Object::dynamic_type());
   current_block_->scope->AddVariable(async_then_callback_var);
   LocalVariable* async_catch_error_callback_var = new (Z)
       LocalVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
                     Symbols::AsyncCatchErrorCallback(), Object::dynamic_type());
   current_block_->scope->AddVariable(async_catch_error_callback_var);
   LocalVariable* async_completer =
       new (Z) LocalVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
                             Symbols::AsyncCompleter(), Object::dynamic_type());
   current_block_->scope->AddVariable(async_completer);
   LocalVariable* async_stack_trace = new (Z)
       LocalVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
                     Symbols::AsyncStackTraceVar(), Object::dynamic_type());
   current_block_->scope->AddVariable(async_stack_trace);
 }
 
-
 void Parser::AddAsyncGeneratorVariables() {
   // Add to current block's scope:
   //   var :controller;
   // The :controller variable is used by the async generator closure to
   // store the StreamController object to which the yielded expressions
   // are added.
   //   var :async_op;
   //   var :async_then_callback;
   //   var :async_catch_error_callback;
   //   var :async_stack_trace;
@@ skipping 19 matching lines @@
   LocalVariable* async_stack_trace = new (Z)
       LocalVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
                     Symbols::AsyncStackTraceVar(), Object::dynamic_type());
   current_block_->scope->AddVariable(async_stack_trace);
   LocalVariable* controller_stream = new (Z)
       LocalVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
                     Symbols::ControllerStream(), Object::dynamic_type());
   current_block_->scope->AddVariable(controller_stream);
 }
 
-
 RawFunction* Parser::OpenAsyncGeneratorFunction(TokenPosition async_func_pos) {
   TRACE_PARSER("OpenAsyncGeneratorFunction");
   AddContinuationVariables();
   AddAsyncGeneratorVariables();
 
   Function& closure = Function::Handle(Z);
   bool is_new_closure = false;
 
   // Check whether a function for the asynchronous function body of
   // this async generator has already been created by a previous
@@ skipping 33 matching lines @@
     ASSERT(AbstractType::Handle(Z, closure.result_type()).IsResolved());
     ASSERT(closure.NumParameters() == closure_params.parameters->length());
   }
 
   OpenFunctionBlock(closure);
   AddFormalParamsToScope(&closure_params, current_block_->scope);
   async_temp_scope_ = current_block_->scope;
   return closure.raw();
 }
 
-
 // Generate the Ast nodes for the implicit code of the async* function.
 //
 // f(...) async* {
 //   var :controller;
 //   var :await_jump_var = -1;
 //   var :await_context_var;
 //   f_async_body() {
 //     ... source code of f ...
 //   }
 //   var :async_op = f_async_body;
@@ skipping 49 matching lines @@
   // :await_jump_var = -1;
   LocalVariable* jump_var =
       current_block_->scope->LookupVariable(Symbols::AwaitJumpVar(), false);
   LiteralNode* init_value = new (Z)
       LiteralNode(TokenPosition::kNoSource, Smi::ZoneHandle(Smi::New(-1)));
   current_block_->statements->Add(
       new (Z) StoreLocalNode(TokenPosition::kNoSource, jump_var, init_value));
 
   TokenPosition token_pos = TokenPosition::kNoSource;
 
-
   // Add to AST:
   //   :async_op = <closure>;  (containing the original body)
   LocalVariable* async_op_var =
       current_block_->scope->LookupVariable(Symbols::AsyncOperation(), false);
   ClosureNode* closure_obj = new (Z) ClosureNode(
       TokenPosition::kNoSource, closure_func, NULL, closure_body->scope());
   StoreLocalNode* store_async_op = new (Z)
       StoreLocalNode(TokenPosition::kNoSource, async_op_var, closure_obj);
 
   current_block_->statements->Add(store_async_op);
@@ skipping 94 matching lines @@
   current_block_->statements->Add(store_controller_stream);
 
   // return :controller.stream;
   ReturnNode* return_node = new (Z) ReturnNode(
       TokenPosition::kNoSource,
       new (Z) LoadLocalNode(TokenPosition::kNoSource, controller_stream_var));
   current_block_->statements->Add(return_node);
   return CloseBlock();
 }
 
-
 void Parser::OpenAsyncGeneratorClosure() {
   async_temp_scope_ = current_block_->scope;
   OpenAsyncTryBlock();
 }
 
-
 SequenceNode* Parser::CloseAsyncGeneratorClosure(SequenceNode* body) {
   // We need a temporary expression to store intermediate return values.
   parsed_function()->EnsureExpressionTemp();
 
   SequenceNode* new_body = CloseAsyncGeneratorTryBlock(body);
   ASSERT(new_body != NULL);
   ASSERT(new_body->scope() != NULL);
   return new_body;
 }
 
-
 // Add a return node to the sequence if necessary.
 void Parser::EnsureHasReturnStatement(SequenceNode* seq,
                                       TokenPosition return_pos) {
   if ((seq->length() == 0) || !seq->NodeAt(seq->length() - 1)->IsReturnNode()) {
     const Function& func = innermost_function();
     // The implicit return value of synchronous generator closures is false,
     // to indicate that there are no more elements in the iterable.
     // In other cases the implicit return value is null.
     AstNode* return_value =
         func.IsSyncGenClosure()
             ? new LiteralNode(return_pos, Bool::False())
             : new LiteralNode(return_pos, Instance::ZoneHandle());
     seq->Add(new ReturnNode(return_pos, return_value));
   }
 }
 
-
 SequenceNode* Parser::CloseBlock() {
   SequenceNode* statements = current_block_->statements;
   if (current_block_->scope != NULL) {
     // Record the begin and end token index of the scope.
     ASSERT(statements != NULL);
     current_block_->scope->set_begin_token_pos(statements->token_pos());
     current_block_->scope->set_end_token_pos(TokenPos());
   }
   current_block_ = current_block_->parent;
   return statements;
 }
 
-
 SequenceNode* Parser::CloseAsyncFunction(const Function& closure,
                                          SequenceNode* closure_body) {
   TRACE_PARSER("CloseAsyncFunction");
   ASSERT(!closure.IsNull());
   ASSERT(closure_body != NULL);
 
   // Explicitly reference variables of the async function from the
   // closure body in order to mark them as captured.
   LocalVariable* existing_var =
       closure_body->scope()->LookupVariable(Symbols::AwaitJumpVar(), false);
@@ skipping 132 matching lines @@
   //   return :async_completer.future;
   ReturnNode* return_node = new (Z) ReturnNode(
       token_pos,
       new (Z) InstanceGetterNode(
           token_pos, new (Z) LoadLocalNode(token_pos, async_completer),
           Symbols::CompleterFuture()));
   current_block_->statements->Add(return_node);
   return CloseBlock();
 }
 
-
 SequenceNode* Parser::CloseAsyncClosure(SequenceNode* body,
                                         TokenPosition func_end_pos) {
   // We need a temporary expression to store intermediate return values.
   parsed_function()->EnsureExpressionTemp();
 
   SequenceNode* new_body = CloseAsyncTryBlock(body, func_end_pos);
   ASSERT(new_body != NULL);
   ASSERT(new_body->scope() != NULL);
   return new_body;
 }
 
-
 // Set up default values for all optional parameters to the function.
 void Parser::SetupDefaultsForOptionalParams(const ParamList& params) {
   if ((current_function().raw() == innermost_function().raw()) &&
       (params.num_optional_parameters > 0)) {
     ZoneGrowableArray<const Instance*>* default_values =
         new ZoneGrowableArray<const Instance*>(zone(),
                                                params.num_optional_parameters);
     // Build array of default parameter values.
     const ZoneGrowableArray<ParamDesc>& parameters = *params.parameters;
     const int first_opt_param_offset = params.num_fixed_parameters;
     for (int i = 0; i < params.num_optional_parameters; i++) {
       const Instance* default_value =
           parameters[i + first_opt_param_offset].default_value;
       default_values->Add(default_value);
     }
     parsed_function()->set_default_parameter_values(default_values);
   }
 }
 
-
 void Parser::FinalizeFormalParameterTypes(const ParamList* params) {
   ASSERT((params != NULL) && (params->parameters != NULL));
   const int num_parameters = params->parameters->length();
   AbstractType& type = AbstractType::Handle(Z);
   for (int i = 0; i < num_parameters; i++) {
     ParamDesc& param_desc = (*params->parameters)[i];
     type = param_desc.type->raw();
     ResolveType(&type);
     type = CanonicalizeType(type);
     if (type.raw() != param_desc.type->raw()) {
       param_desc.type = &AbstractType::ZoneHandle(Z, type.raw());
     }
   }
 }
 
-
 // Populate the parameter type array and parameter name array of the function
 // with the formal parameter types and names.
 void Parser::AddFormalParamsToFunction(const ParamList* params,
                                        const Function& func) {
   ASSERT((params != NULL) && (params->parameters != NULL));
   ASSERT((params->num_optional_parameters > 0) ==
          (params->has_optional_positional_parameters ||
           params->has_optional_named_parameters));
   if (!Utils::IsInt(16, params->num_fixed_parameters) ||
       !Utils::IsInt(16, params->num_optional_parameters)) {
@@ skipping 25 matching lines @@
     if (param_desc.is_covariant) {
       if (!func.IsDynamicFunction(true)) {
         ReportError(param_desc.name_pos,
                     "only instance functions may have "
                     "covariant parameters");
       }
     }
   }
 }
 
-
 // Populate local scope with the formal parameters.
 void Parser::AddFormalParamsToScope(const ParamList* params,
                                     LocalScope* scope) {
   ASSERT((params != NULL) && (params->parameters != NULL));
   ASSERT(scope != NULL);
   const int num_parameters = params->parameters->length();
   for (int i = 0; i < num_parameters; i++) {
     ParamDesc& param_desc = (*params->parameters)[i];
     const String* name = param_desc.name;
     LocalVariable* parameter = new (Z) LocalVariable(
         param_desc.name_pos, param_desc.name_pos, *name, *param_desc.type);
     if (!scope->InsertParameterAt(i, parameter)) {
       ReportError(param_desc.name_pos, "name '%s' already exists in scope",
                   param_desc.name->ToCString());
     }
     param_desc.var = parameter;
     if (param_desc.is_final) {
       parameter->set_is_final();
     }
     if (FLAG_initializing_formal_access) {
       // Field initializer parameters are implicitly final.
       ASSERT(!param_desc.is_field_initializer || param_desc.is_final);
     } else if (param_desc.is_field_initializer) {
       parameter->set_invisible(true);
     }
   }
 }
 
-
 // Builds ReturnNode/NativeBodyNode for a native function.
 void Parser::ParseNativeFunctionBlock(const ParamList* params,
                                       const Function& func) {
   ASSERT(func.is_native());
   ASSERT(func.NumParameters() == params->parameters->length());
   TRACE_PARSER("ParseNativeFunctionBlock");
 
   // Parse the function name out.
   const String& native_name = ParseNativeDeclaration();
 
   // Now add the NativeBodyNode and return statement.
   current_block_->statements->Add(new (Z) ReturnNode(
       TokenPos(),
       new (Z) NativeBodyNode(TokenPos(), Function::ZoneHandle(Z, func.raw()),
                              native_name, current_block_->scope,
                              FLAG_link_natives_lazily)));
 }
 
-
 LocalVariable* Parser::LookupReceiver(LocalScope* from_scope, bool test_only) {
   ASSERT(!current_function().is_static());
   return from_scope->LookupVariable(Symbols::This(), test_only);
 }
 
-
 LocalVariable* Parser::LookupTypeArgumentsParameter(LocalScope* from_scope,
                                                     bool test_only) {
   ASSERT(current_function().IsInFactoryScope());
   return from_scope->LookupVariable(Symbols::TypeArgumentsParameter(),
                                     test_only);
 }
 
-
 void Parser::CaptureInstantiator() {
   ASSERT(FunctionLevel() > 0);
   const String* variable_name = current_function().IsInFactoryScope()
                                     ? &Symbols::TypeArgumentsParameter()
                                     : &Symbols::This();
   current_block_->scope->CaptureVariable(
       current_block_->scope->LookupVariable(*variable_name, true));
 }
 
-
 void Parser::CaptureFunctionTypeArguments() {
   ASSERT(InGenericFunctionScope());
   ASSERT(FunctionLevel() > 0);
   if (!FLAG_reify_generic_functions) {
     return;
   }
   const String* variable_name = &Symbols::FunctionTypeArgumentsVar();
   current_block_->scope->CaptureVariable(
       current_block_->scope->LookupVariable(*variable_name, true));
 }
 
-
 void Parser::CaptureAllInstantiators() {
   if (IsInstantiatorRequired()) {
     CaptureInstantiator();
   }
   if (innermost_function().HasGenericParent()) {
     CaptureFunctionTypeArguments();
   }
 }
 
-
 AstNode* Parser::LoadReceiver(TokenPosition token_pos) {
   // A nested function may access 'this', referring to the receiver of the
   // outermost enclosing function.
   const bool kTestOnly = false;
   LocalVariable* receiver = LookupReceiver(current_block_->scope, kTestOnly);
   if (receiver == NULL) {
     ReportError(token_pos, "illegal implicit access to receiver 'this'");
   }
   return new (Z) LoadLocalNode(TokenPos(), receiver);
 }
 
-
 InstanceGetterNode* Parser::CallGetter(TokenPosition token_pos,
                                        AstNode* object,
                                        const String& name) {
   return new (Z) InstanceGetterNode(token_pos, object, name);
 }
 
-
 // Returns ast nodes of the variable initialization.
 AstNode* Parser::ParseVariableDeclaration(const AbstractType& type,
                                           bool is_final,
                                           bool is_const,
                                           SequenceNode** await_preamble) {
   TRACE_PARSER("ParseVariableDeclaration");
   ASSERT(IsIdentifier());
   const TokenPosition ident_pos = TokenPos();
   const String& ident = *CurrentLiteral();
   ConsumeToken();  // Variable identifier.
@@ skipping 50 matching lines @@
     ASSERT(existing_var->owner() == current_block_->scope);
     ReportError(ident_pos, "identifier '%s' already defined",
                 variable->name().ToCString());
   }
   if (is_final || is_const) {
     variable->set_is_final();
   }
   return initialization;
 }
 
-
 // Parses ('var' | 'final' [type] | 'const' [type] | type).
 // The presence of 'final' or 'const' must be detected and remembered
 // before the call. If a type is parsed, it may be resolved and finalized
 // according to the given type finalization mode.
 RawAbstractType* Parser::ParseConstFinalVarOrType(
     ClassFinalizer::FinalizationKind finalization) {
   TRACE_PARSER("ParseConstFinalVarOrType");
   if (CurrentToken() == Token::kVAR) {
     ConsumeToken();
     return Type::DynamicType();
@@ skipping 20 matching lines @@
     if ((follower != Token::kLT) &&        // Parameterized type.
         (follower != Token::kPERIOD) &&    // Qualified class name of type.
         !Token::IsIdentifier(follower) &&  // Variable name following a type.
         (follower != Token::kTHIS)) {      // Field parameter following a type.
       return Type::DynamicType();
     }
   }
   return ParseTypeOrFunctionType(false, finalization);
 }
 
-
 // Returns ast nodes of the variable initialization. Variables without an
 // explicit initializer are initialized to null. If several variables are
 // declared, the individual initializers are collected in a sequence node.
 AstNode* Parser::ParseVariableDeclarationList() {
   TRACE_PARSER("ParseVariableDeclarationList");
   SkipMetadata();
   bool is_final = (CurrentToken() == Token::kFINAL);
   bool is_const = (CurrentToken() == Token::kCONST);
   const AbstractType& type = AbstractType::ZoneHandle(
       Z,
@@ skipping 25 matching lines @@
         ParseVariableDeclaration(type, is_final, is_const, &preamble);
     if (preamble != NULL) {
       sequence->Add(preamble);
     }
     sequence->Add(declaration);
     initializers = sequence;
   }
   return initializers;
 }
 
-
 AstNode* Parser::ParseFunctionStatement(bool is_literal) {
   TRACE_PARSER("ParseFunctionStatement");
   AbstractType& result_type = AbstractType::Handle(Z, Type::DynamicType());
   const String* function_name = NULL;
   const TokenPosition function_pos = TokenPos();
   TokenPosition function_name_pos = TokenPosition::kNoSource;
   TokenPosition metadata_pos = TokenPosition::kNoSource;
   if (is_literal) {
     ASSERT(CurrentToken() == Token::kLPAREN || CurrentToken() == Token::kLT);
     function_name = &Symbols::AnonymousClosure();
@@ skipping 186 matching lines @@
   // The local scope of the parsed function can be pruned, since contained
   // variables are not relevant for the compilation of the enclosing function.
   // This pruning is done by omitting to hook the local scope in its parent
   // scope in the constructor of LocalScope.
   AstNode* closure =
       new (Z) ClosureNode(function_pos, function, NULL,
                           statements != NULL ? statements->scope() : NULL);
 
   ASSERT(innermost_function_.raw() == function.raw());
   innermost_function_ = function.parent_function();
-  return is_literal ? closure : new (Z) StoreLocalNode(
-                                    function_pos, function_variable, closure);
+  return is_literal
+             ? closure
+             : new (Z) StoreLocalNode(function_pos, function_variable, closure);
 }
 
-
 // Returns true if the current and next tokens can be parsed as type
 // parameters. Current token position is not saved and restored.
 bool Parser::TryParseTypeParameters() {
   ASSERT(CurrentToken() == Token::kLT);
   int nesting_level = 0;
   do {
     Token::Kind ct = CurrentToken();
     if (ct == Token::kLT) {
       nesting_level++;
     } else if (ct == Token::kGT) {
@@ skipping 12 matching lines @@
       return false;
     }
     ConsumeToken();
   } while (nesting_level > 0);
   if (nesting_level < 0) {
     return false;
   }
   return true;
 }
 
-
 // Returns true if the next tokens can be parsed as type parameters.
 bool Parser::IsTypeParameters() {
   if (CurrentToken() == Token::kLT) {
     TokenPosScope param_pos(this);
     if (!TryParseTypeParameters()) {
       return false;
     }
     return true;
   }
   return false;
 }
 
-
 // Returns true if the next tokens are [ typeParameters ] '('.
 bool Parser::IsParameterPart() {
   if (CurrentToken() == Token::kLPAREN) {
     return true;
   }
   if (CurrentToken() == Token::kLT) {
     TokenPosScope type_arg_pos(this);
     if (!TryParseTypeParameters()) {
       return false;
     }
     return CurrentToken() == Token::kLPAREN;
   }
   return false;
 }
 
-
 // Returns true if the current and next tokens can be parsed as type
 // arguments. Current token position is not saved and restored.
 bool Parser::TryParseTypeArguments() {
   ASSERT(CurrentToken() == Token::kLT);
   int nesting_level = 0;
   do {
     Token::Kind ct = CurrentToken();
     if (ct == Token::kLT) {
       nesting_level++;
     } else if (ct == Token::kGT) {
@@ skipping 17 matching lines @@
       return false;
     }
     ConsumeToken();
   } while (nesting_level > 0);
   if (nesting_level < 0) {
     return false;
   }
   return true;
 }
 
-
 // Returns true if the next tokens are [ typeArguments ] '('.
 bool Parser::IsArgumentPart() {
   if (CurrentToken() == Token::kLPAREN) {
     return true;
   }
   if (CurrentToken() == Token::kLT) {
     TokenPosScope type_arg_pos(this);
     if (!TryParseTypeArguments()) {
       return false;
     }
     return CurrentToken() == Token::kLPAREN;
   }
   return false;
 }
 
-
 bool Parser::IsSimpleLiteral(const AbstractType& type, Instance* value) {
   // Assigning null never causes a type error.
   if (CurrentToken() == Token::kNULL) {
     *value = Instance::null();
     return true;
   }
   // If the type of the const field is guaranteed to be instantiated once
   // resolved at class finalization time, and if the type of the literal is one
   // of int, double, String, or bool, then preset the field with the value and
   // perform the type check (in checked mode only) at finalization time.
@@ skipping 19 matching lines @@
   } else if (CurrentToken() == Token::kTRUE) {
     *value = Bool::True().raw();
     return true;
   } else if (CurrentToken() == Token::kFALSE) {
     *value = Bool::False().raw();
     return true;
   }
   return false;
 }
 
-
 // Returns true if the current token is kIDENT or a pseudo-keyword.
 bool Parser::IsIdentifier() {
   return Token::IsIdentifier(CurrentToken()) &&
          !(await_is_keyword_ &&
            ((CurrentLiteral()->raw() == Symbols::Await().raw()) ||
             (CurrentLiteral()->raw() == Symbols::Async().raw()) ||
             (CurrentLiteral()->raw() == Symbols::YieldKw().raw())));
 }
 
-
 bool Parser::IsSymbol(const String& symbol) {
   return (CurrentLiteral()->raw() == symbol.raw()) &&
          (CurrentToken() == Token::kIDENT);
 }
 
-
 // Returns true if the current token is 'Function' followed by '<' or '('.
 // 'Function' not followed by '<' or '(' denotes the Function class.
 bool Parser::IsFunctionTypeSymbol() {
   return IsSymbol(Symbols::Function()) &&
          ((LookaheadToken(1) == Token::kLPAREN) ||
           (LookaheadToken(1) == Token::kLT));
 }
 
-
 // Returns true if the next tokens can be parsed as a an optionally
 // qualified identifier: [ident '.'] ident.
 // Current token position is not restored.
 bool Parser::TryParseQualIdent() {
   if (CurrentToken() != Token::kIDENT) {
     return false;
   }
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();
     if (CurrentToken() != Token::kIDENT) {
       return false;
     }
     ConsumeToken();
   }
   return true;
 }
 
-
 // Returns true if the next tokens can be parsed as a type with optional
 // type parameters. Current token position is not restored.
 // Allow 'void' as type if 'allow_void' is true.
 // Note that 'void Function()' is always allowed, since it is a function type
 // and not the void type.
 bool Parser::TryParseType(bool allow_void) {
   bool found = false;
   if (CurrentToken() == Token::kVOID) {
     ConsumeToken();
     if (allow_void) {
@@ skipping 19 matching lines @@
     if (CurrentToken() == Token::kLPAREN) {
       SkipToMatchingParenthesis();
     } else {
       return false;
     }
     found = true;
   }
   return found;
 }
 
-
 // Look ahead to detect whether the next tokens should be parsed as
 // a variable declaration. Ignores optional metadata.
 // Returns true if we detect the token pattern:
 //     'var'
 //   | 'final'
 //   | const [type] ident (';' | '=' | ',')
 //   | type ident (';' | '=' | ',')
 // Token position remains unchanged.
 bool Parser::IsVariableDeclaration() {
   if ((CurrentToken() == Token::kVAR) || (CurrentToken() == Token::kFINAL)) {
@@ skipping 43 matching lines @@
     if ((CurrentToken() == Token::kSEMICOLON) ||
         (CurrentToken() == Token::kCOMMA) ||
         (CurrentToken() == Token::kASSIGN)) {
       is_var_decl = true;
     }
   }
   SetPosition(saved_pos);
   return is_var_decl;
 }
 
-
 // Look ahead to see if the following tokens are a return type followed
 // by an identifier.
 bool Parser::IsFunctionReturnType() {
   TokenPosScope decl_pos(this);
   if (TryParseType(true)) {
     if (IsIdentifier()) {
       // Return type followed by function name.
       return true;
     }
   }
   return false;
 }
 
-
 // Look ahead to detect whether the next tokens should be parsed as
 // a function declaration. Token position remains unchanged.
 bool Parser::IsFunctionDeclaration() {
   bool is_external = false;
   TokenPosScope decl_pos(this);
   SkipMetadata();
   if ((is_top_level_) && (CurrentToken() == Token::kEXTERNAL)) {
     // Skip over 'external' for top-level function declarations.
     is_external = true;
     ConsumeToken();
@@ skipping 23 matching lines @@
   // Check parameter list and the following token.
   SkipToMatchingParenthesis();
   if ((CurrentToken() == Token::kLBRACE) || (CurrentToken() == Token::kARROW) ||
       (is_top_level_ && IsSymbol(Symbols::Native())) || is_external ||
       IsSymbol(Symbols::Async()) || IsSymbol(Symbols::Sync())) {
     return true;
   }
   return false;
 }
 
-
 bool Parser::IsTopLevelAccessor() {
   const TokenPosScope saved_pos(this);
   if (CurrentToken() == Token::kEXTERNAL) {
     ConsumeToken();
   }
   if ((CurrentToken() == Token::kGET) || (CurrentToken() == Token::kSET)) {
     return true;
   }
   if (TryParseType(true)) {
     if ((CurrentToken() == Token::kGET) || (CurrentToken() == Token::kSET)) {
       if (Token::IsIdentifier(LookaheadToken(1))) {  // Accessor name.
         return true;
       }
     }
   }
   return false;
 }
 
-
 bool Parser::IsFunctionLiteral() {
   if (!allow_function_literals_) {
     return false;
   }
   if ((CurrentToken() == Token::kLPAREN) || (CurrentToken() == Token::kLT)) {
     TokenPosScope saved_pos(this);
     if ((CurrentToken() == Token::kLT) && !TryParseTypeParameters()) {
       return false;
     }
     if (CurrentToken() != Token::kLPAREN) {
       return false;
     }
     SkipToMatchingParenthesis();
     ParseFunctionModifier();
     if ((CurrentToken() == Token::kLBRACE) ||
         (CurrentToken() == Token::kARROW)) {
       return true;
     }
   }
   return false;
 }
 
-
 // Current token position is the token after the opening ( of the for
 // statement. Returns true if we recognize a for ( .. in expr)
 // statement.
 bool Parser::IsForInStatement() {
   const TokenPosScope saved_pos(this);
   // Allow const modifier as well when recognizing a for-in statement
   // pattern. We will get an error later if the loop variable is
   // declared with const.
   if (CurrentToken() == Token::kVAR || CurrentToken() == Token::kFINAL ||
       CurrentToken() == Token::kCONST) {
     ConsumeToken();
   }
   if (IsIdentifier()) {
     if (LookaheadToken(1) == Token::kIN) {
       return true;
     } else if (TryParseType(false)) {
       if (IsIdentifier()) {
         ConsumeToken();
       }
       return CurrentToken() == Token::kIN;
     }
   }
   return false;
 }
 
-
 static bool ContainsAbruptCompletingStatement(SequenceNode* seq);
 
 static bool IsAbruptCompleting(AstNode* statement) {
   return statement->IsReturnNode() || statement->IsJumpNode() ||
          statement->IsThrowNode() ||
          (statement->IsSequenceNode() &&
           ContainsAbruptCompletingStatement(statement->AsSequenceNode()));
 }
 
-
 static bool ContainsAbruptCompletingStatement(SequenceNode* seq) {
   for (int i = 0; i < seq->length(); i++) {
     if (IsAbruptCompleting(seq->NodeAt(i))) {
       return true;
     }
   }
   return false;
 }
 
-
 void Parser::ParseStatementSequence() {
   TRACE_PARSER("ParseStatementSequence");
   const bool dead_code_allowed = true;
   bool abrupt_completing_seen = false;
   RecursionChecker rc(this);
   while (CurrentToken() != Token::kRBRACE) {
     const TokenPosition statement_pos = TokenPos();
     AstNode* statement = ParseStatement();
     // Do not add statements with no effect (e.g., LoadLocalNode).
     if ((statement != NULL) && statement->IsLoadLocalNode()) {
       // Skip load local.
       continue;
     }
     if (statement != NULL) {
       if (!dead_code_allowed && abrupt_completing_seen) {
         ReportError(statement_pos,
                     "dead code after abrupt completing statement");
       }
       current_block_->statements->Add(statement);
       abrupt_completing_seen |= IsAbruptCompleting(statement);
     }
   }
 }
 
-
 // Parse nested statement of if, while, for, etc. We automatically generate
 // a sequence of one statement if there are no curly braces.
 // The argument 'parsing_loop_body' indicates the parsing of a loop statement.
 SequenceNode* Parser::ParseNestedStatement(bool parsing_loop_body,
                                            SourceLabel* label) {
   TRACE_PARSER("ParseNestedStatement");
   if (parsing_loop_body) {
     OpenLoopBlock();
   } else {
     OpenBlock();
   }
   if (label != NULL) {
     current_block_->scope->AddLabel(label);
   }
   if (CurrentToken() == Token::kLBRACE) {
     ConsumeToken();
     ParseStatementSequence();
     ExpectToken(Token::kRBRACE);
   } else {
     RecursionChecker rc(this);
     AstNode* statement = ParseStatement();
     if (statement != NULL) {
       current_block_->statements->Add(statement);
     }
   }
   SequenceNode* sequence = CloseBlock();
   return sequence;
 }
 
-
 AstNode* Parser::ParseIfStatement(String* label_name) {
   TRACE_PARSER("ParseIfStatement");
   ASSERT(CurrentToken() == Token::kIF);
   const TokenPosition if_pos = TokenPos();
   SourceLabel* label = NULL;
   if (label_name != NULL) {
     label = SourceLabel::New(if_pos, label_name, SourceLabel::kStatement);
     OpenBlock();
     current_block_->scope->AddLabel(label);
   }
@@ skipping 12 matching lines @@
       new (Z) IfNode(if_pos, cond_expr, true_branch, false_branch);
   if (label != NULL) {
     current_block_->statements->Add(if_node);
     SequenceNode* sequence = CloseBlock();
     sequence->set_label(label);
     if_node = sequence;
   }
   return if_node;
 }
 
-
 // Return true if the type class of the given value implements the
 // == operator.
 static bool ImplementsEqualOperator(Zone* zone, const Instance& value) {
   Class& cls = Class::Handle(value.clazz());
   const Function& equal_op = Function::Handle(
       zone,
       Resolver::ResolveDynamicAnyArgs(zone, cls, Symbols::EqualOperator()));
   ASSERT(!equal_op.IsNull());
   cls = equal_op.Owner();
   return !cls.IsObjectClass();
 }
 
-
 // Check that all case expressions are of the same type, either int, String,
 // or any other class that does not override the == operator.
 // The expressions are compile-time constants and are thus in the form
 // of a LiteralNode.
 RawClass* Parser::CheckCaseExpressions(
     const GrowableArray<LiteralNode*>& values) {
   const intptr_t num_expressions = values.length();
   if (num_expressions == 0) {
     return Object::dynamic_class();
   }
@@ skipping 35 matching lines @@
     }
   }
   if (first_value.IsInteger()) {
     return Type::Handle(Z, Type::IntType()).type_class();
   } else if (first_value.IsString()) {
     return Type::Handle(Z, Type::StringType()).type_class();
   }
   return first_value.clazz();
 }
 
-
 CaseNode* Parser::ParseCaseClause(LocalVariable* switch_expr_value,
                                   GrowableArray<LiteralNode*>* case_expr_values,
                                   SourceLabel* case_label) {
   TRACE_PARSER("ParseCaseClause");
   bool default_seen = false;
   const TokenPosition case_pos = TokenPos();
   // The case expressions node sequence does not own the enclosing scope.
   SequenceNode* case_expressions = new (Z) SequenceNode(case_pos, NULL);
   while (CurrentToken() == Token::kCASE || CurrentToken() == Token::kDEFAULT) {
     if (CurrentToken() == Token::kCASE) {
@@ skipping 57 matching lines @@
     if (statement != NULL) {
       current_block_->statements->Add(statement);
       abrupt_completing_seen |= IsAbruptCompleting(statement);
     }
   }
   SequenceNode* statements = CloseBlock();
   return new (Z) CaseNode(case_pos, case_label, case_expressions, default_seen,
                           switch_expr_value, statements);
 }
 
-
 AstNode* Parser::ParseSwitchStatement(String* label_name) {
   TRACE_PARSER("ParseSwitchStatement");
   ASSERT(CurrentToken() == Token::kSWITCH);
   const TokenPosition switch_pos = TokenPos();
   SourceLabel* label =
       SourceLabel::New(switch_pos, label_name, SourceLabel::kSwitch);
   ConsumeToken();
   ExpectToken(Token::kLPAREN);
   const TokenPosition expr_pos = TokenPos();
   AstNode* switch_expr =
@@ skipping 78 matching lines @@
   if (unresolved_label != NULL) {
     ReportError("unresolved reference to label '%s'",
                 unresolved_label->name().ToCString());
   }
 
   SequenceNode* switch_body = CloseBlock();
   ExpectToken(Token::kRBRACE);
   return new (Z) SwitchNode(switch_pos, label, switch_body);
 }
 
-
 AstNode* Parser::ParseWhileStatement(String* label_name) {
   TRACE_PARSER("ParseWhileStatement");
   const TokenPosition while_pos = TokenPos();
   SourceLabel* label =
       SourceLabel::New(while_pos, label_name, SourceLabel::kWhile);
   ConsumeToken();
   ExpectToken(Token::kLPAREN);
   SequenceNode* await_preamble = NULL;
   AstNode* cond_expr =
       ParseAwaitableExpr(kAllowConst, kConsumeCascades, &await_preamble);
   ExpectToken(Token::kRPAREN);
   const bool parsing_loop_body = true;
   SequenceNode* while_body = ParseNestedStatement(parsing_loop_body, label);
   WhileNode* while_node = new (Z)
       WhileNode(while_pos, label, cond_expr, await_preamble, while_body);
   return while_node;
 }
 
-
 AstNode* Parser::ParseDoWhileStatement(String* label_name) {
   TRACE_PARSER("ParseDoWhileStatement");
   const TokenPosition do_pos = TokenPos();
   SourceLabel* label =
       SourceLabel::New(do_pos, label_name, SourceLabel::kDoWhile);
   ConsumeToken();
   const bool parsing_loop_body = true;
   SequenceNode* dowhile_body = ParseNestedStatement(parsing_loop_body, label);
   ExpectToken(Token::kWHILE);
   ExpectToken(Token::kLPAREN);
   SequenceNode* await_preamble = NULL;
   TokenPosition expr_pos = TokenPos();
   AstNode* cond_expr =
       ParseAwaitableExpr(kAllowConst, kConsumeCascades, &await_preamble);
   if (await_preamble != NULL) {
     // Prepend the preamble to the condition.
     LetNode* await_cond = new (Z) LetNode(expr_pos);
     await_cond->AddNode(await_preamble);
     await_cond->AddNode(cond_expr);
     cond_expr = await_cond;
   }
   ExpectToken(Token::kRPAREN);
   ExpectSemicolon();
   return new (Z) DoWhileNode(do_pos, label, cond_expr, dowhile_body);
 }
 
-
 static LocalVariable* LookupSavedTryContextVar(LocalScope* scope) {
   LocalVariable* var =
       scope->LocalLookupVariable(Symbols::SavedTryContextVar());
   ASSERT((var != NULL) && !var->is_captured());
   return var;
 }
 
-
 static LocalVariable* LookupAsyncSavedTryContextVar(Thread* thread,
                                                     LocalScope* scope,
                                                     uint16_t try_index) {
   Zone* zone = thread->zone();
   const String& async_saved_try_ctx_name = String::ZoneHandle(
       zone, Symbols::NewFormatted(
                 thread, "%s%d",
                 Symbols::AsyncSavedTryCtxVarPrefix().ToCString(), try_index));
   LocalVariable* var = scope->LocalLookupVariable(async_saved_try_ctx_name);
   ASSERT(var != NULL);
   return var;
 }
 
-
 // If the await or yield being parsed is in a try block, the continuation code
 // needs to restore the corresponding stack-based variable :saved_try_ctx_var,
 // and the stack-based variable :saved_try_ctx_var of the outer try block.
 // The inner :saved_try_ctx_var is used by a finally clause handling an
 // exception thrown by the continuation code in a try block or catch block.
 // If no finally clause exists, the catch or finally clause of the outer try
 // block, if any, uses the outer :saved_try_ctx_var to handle the exception.
 //
 // * Try blocks and catch blocks:
 //     Set the context variable for this try block and for the outer try block.
@@ skipping 35 matching lines @@
   }
   // An async or async* has an implicitly created try-catch around the
   // function body, so the await or yield inside the async closure should always
   // be created with a try scope.
   ASSERT((*saved_try_ctx != NULL) || innermost_function().IsAsyncFunction() ||
          innermost_function().IsAsyncGenerator() ||
          innermost_function().IsSyncGenClosure() ||
          innermost_function().IsSyncGenerator());
 }
 
-
 // Build an AST node for static call to Dart function print(str).
 // Used during debugging to insert print in generated dart code.
 AstNode* Parser::DartPrint(const char* str) {
   const Library& lib = Library::Handle(Library::CoreLibrary());
   const Function& print_fn =
       Function::ZoneHandle(Z, lib.LookupFunctionAllowPrivate(Symbols::print()));
   ASSERT(!print_fn.IsNull());
   ArgumentListNode* one_arg =
       new (Z) ArgumentListNode(TokenPosition::kNoSource);
   String& msg = String::ZoneHandle(Symbols::NewFormatted(T, "%s", str));
   one_arg->Add(new (Z) LiteralNode(TokenPosition::kNoSource, msg));
   AstNode* print_call =
       new (Z) StaticCallNode(TokenPosition::kNoSource, print_fn, one_arg);
   return print_call;
 }
 
-
 AstNode* Parser::ParseAwaitForStatement(String* label_name) {
   TRACE_PARSER("ParseAwaitForStatement");
   ASSERT(IsAwaitKeyword());
   const TokenPosition await_for_pos = TokenPos();
   ConsumeToken();  // await.
   ASSERT(CurrentToken() == Token::kFOR);
   ConsumeToken();  // for.
   ExpectToken(Token::kLPAREN);
 
   if (!innermost_function().IsAsyncFunction() &&
@@ skipping 297 matching lines @@
   AstNode* try_catch_node =
       new (Z) TryCatchNode(await_for_pos, try_block, context_var, catch_clause,
                            finally_clause, try_index, finally_clause);
 
   ASSERT(current_block_ == await_for_block);
   await_for_block->statements->Add(try_catch_node);
 
   return CloseBlock();  // Implicit block around while loop.
 }
 
-
 AstNode* Parser::ParseForInStatement(TokenPosition forin_pos,
                                      SourceLabel* label) {
   TRACE_PARSER("ParseForInStatement");
   bool loop_var_is_final = (CurrentToken() == Token::kFINAL);
   if (CurrentToken() == Token::kCONST) {
     ReportError("Loop variable cannot be 'const'");
   }
   const String* loop_var_name = NULL;
   TokenPosition loop_var_pos = TokenPosition::kNoSource;
   bool new_loop_var = false;
@@ skipping 100 matching lines @@
 
   SequenceNode* for_loop_statement = CloseBlock();
 
   AstNode* while_statement = new (Z)
       WhileNode(forin_pos, label, iterator_moveNext, NULL, for_loop_statement);
   current_block_->statements->Add(while_statement);
 
   return CloseBlock();  // Implicit block around while loop.
 }
 
-
 AstNode* Parser::ParseForStatement(String* label_name) {
   TRACE_PARSER("ParseForStatement");
   const TokenPosition for_pos = TokenPos();
   ConsumeToken();
   ExpectToken(Token::kLPAREN);
   SourceLabel* label = SourceLabel::New(for_pos, label_name, SourceLabel::kFor);
   if (IsForInStatement()) {
     return ParseForInStatement(for_pos, label);
   }
   // Open a block that contains the loop variable. Make it a loop block so
@@ skipping 43 matching lines @@
     }
   }
   AstNode* for_node = new (Z)
       ForNode(for_pos, label, NodeAsSequenceNode(init_pos, initializer, NULL),
               condition, condition_preamble,
               NodeAsSequenceNode(incr_pos, increment, NULL), body);
   current_block_->statements->Add(for_node);
   return CloseBlock();
 }
 
-
 // Calling VM-internal helpers, uses implementation core library.
 AstNode* Parser::MakeStaticCall(const String& cls_name,
                                 const String& func_name,
                                 ArgumentListNode* arguments) {
   const Class& cls = Class::Handle(Z, Library::LookupCoreClass(cls_name));
   ASSERT(!cls.IsNull());
   const intptr_t kTypeArgsLen = 0;  // Not passing type args to generic func.
   const Function& func = Function::ZoneHandle(
       Z, Resolver::ResolveStatic(cls, func_name, kTypeArgsLen,
                                  arguments->length(), arguments->names()));
   ASSERT(!func.IsNull());
   return new (Z) StaticCallNode(arguments->token_pos(), func, arguments);
 }
 
-
 AstNode* Parser::ParseAssertStatement(bool is_const) {
   TRACE_PARSER("ParseAssertStatement");
   ConsumeToken();  // Consume assert keyword.
   ExpectToken(Token::kLPAREN);
   const TokenPosition condition_pos = TokenPos();
   if (!I->asserts()) {
     SkipExpr();
     if (CurrentToken() == Token::kCOMMA) {
       ConsumeToken();
       if (CurrentToken() != Token::kRPAREN) {
@@ skipping 86 matching lines @@
     assertion_check = preamble;
   } else {
     // Build if (!condition) _AsertionError._throwNew(...)
     assertion_check = new (Z)
         IfNode(condition_pos, not_condition,
                NodeAsSequenceNode(condition_pos, assert_throw, NULL), NULL);
   }
   return assertion_check;
 }
 
-
 // Populate local scope of the catch block with the catch parameters.
 void Parser::AddCatchParamsToScope(CatchParamDesc* exception_param,
                                    CatchParamDesc* stack_trace_param,
                                    LocalScope* scope) {
   if (exception_param->name != NULL) {
     LocalVariable* var = new (Z)
         LocalVariable(exception_param->token_pos, exception_param->token_pos,
                       *exception_param->name, *exception_param->type);
     var->set_is_final();
     bool added_to_scope = scope->AddVariable(var);
     ASSERT(added_to_scope);
     exception_param->var = var;
   }
   if (stack_trace_param->name != NULL) {
     LocalVariable* var = new (Z) LocalVariable(
         stack_trace_param->token_pos, stack_trace_param->token_pos,
         *stack_trace_param->name, *stack_trace_param->type);
     var->set_is_final();
     bool added_to_scope = scope->AddVariable(var);
     if (!added_to_scope) {
       // The name of the exception param is reused for the stack trace param.
       ReportError(stack_trace_param->token_pos,
                   "name '%s' already exists in scope",
                   stack_trace_param->name->ToCString());
     }
     stack_trace_param->var = var;
   }
 }
 
-
 // Generate code to load the exception object (:exception_var) into
 // the saved exception variable (:saved_exception_var) used to rethrow.
 // Generate code to load the stack trace object (:stack_trace_var) into
 // the saved stacktrace variable (:saved_stack_trace_var) used to rethrow.
 void Parser::SaveExceptionAndStackTrace(SequenceNode* statements,
                                         LocalVariable* exception_var,
                                         LocalVariable* stack_trace_var,
                                         LocalVariable* saved_exception_var,
                                         LocalVariable* saved_stack_trace_var) {
   ASSERT(innermost_function().IsAsyncClosure() ||
          innermost_function().IsAsyncFunction() ||
          innermost_function().IsSyncGenClosure() ||
          innermost_function().IsSyncGenerator() ||
          innermost_function().IsAsyncGenClosure() ||
          innermost_function().IsAsyncGenerator());
 
   ASSERT(saved_exception_var != NULL);
   ASSERT(exception_var != NULL);
   statements->Add(new (Z) StoreLocalNode(
       TokenPosition::kNoSource, saved_exception_var,
       new (Z) LoadLocalNode(TokenPosition::kNoSource, exception_var)));
 
   ASSERT(saved_stack_trace_var != NULL);
   ASSERT(stack_trace_var != NULL);
   statements->Add(new (Z) StoreLocalNode(
       TokenPosition::kNoSource, saved_stack_trace_var,
       new (Z) LoadLocalNode(TokenPosition::kNoSource, stack_trace_var)));
 }
 
-
 SequenceNode* Parser::EnsureFinallyClause(
     bool parse,
     bool is_async,
     LocalVariable* exception_var,
     LocalVariable* stack_trace_var,
     LocalVariable* rethrow_exception_var,
     LocalVariable* rethrow_stack_trace_var) {
   TRACE_PARSER("EnsureFinallyClause");
   ASSERT(parse || (is_async && (try_stack_ != NULL)));
   // Increasing the loop level prevents the reuse of a parent context and forces
@@ skipping 43 matching lines @@
     ParseStatementSequence();
     ExpectToken(Token::kRBRACE);
   }
   SequenceNode* finally_clause = CloseBlock();
   if (try_stack_ != NULL) {
     try_stack_->exit_finally();
   }
   return finally_clause;
 }
 
-
 void Parser::PushTry(Block* try_block) {
   intptr_t try_index = AllocateTryIndex();
   try_stack_ = new (Z) TryStack(try_block, try_stack_, try_index);
 }
 
-
 Parser::TryStack* Parser::PopTry() {
   TryStack* innermost_try = try_stack_;
   try_stack_ = try_stack_->outer_try();
   return innermost_try;
 }
 
-
 void Parser::AddNodeForFinallyInlining(AstNode* node) {
   if (node == NULL) {
     return;
   }
   ASSERT(node->IsReturnNode() || node->IsJumpNode());
   const intptr_t func_level = FunctionLevel();
   TryStack* iterator = try_stack_;
   while ((iterator != NULL) &&
          (iterator->try_block()->scope->function_level() == func_level)) {
     // For continue and break node check if the target label is in scope.
@@ skipping 13 matching lines @@
       // RemoveNodesForFinallyInlining below.)
       if (!label->IsUnresolved() && label->owner()->IsNestedWithin(try_scope)) {
         break;
       }
     }
     iterator->AddNodeForFinallyInlining(node);
     iterator = iterator->outer_try();
   }
 }
 
-
 void Parser::RemoveNodesForFinallyInlining(SourceLabel* label) {
   TryStack* iterator = try_stack_;
   const intptr_t func_level = FunctionLevel();
   while ((iterator != NULL) &&
          (iterator->try_block()->scope->function_level() == func_level)) {
     iterator->RemoveJumpToLabel(label);
     iterator = iterator->outer_try();
   }
 }
 
-
 // Add the inlined finally clause to the specified node.
 void Parser::AddFinallyClauseToNode(bool is_async,
                                     AstNode* node,
                                     InlinedFinallyNode* finally_clause) {
   ReturnNode* return_node = node->AsReturnNode();
   if (return_node != NULL) {
     if (FunctionLevel() == 0) {
       parsed_function()->EnsureFinallyReturnTemp(is_async);
     }
     return_node->AddInlinedFinallyNode(finally_clause);
     return;
   }
   JumpNode* jump_node = node->AsJumpNode();
   ASSERT(jump_node != NULL);
   jump_node->AddInlinedFinallyNode(finally_clause);
 }
 
-
 SequenceNode* Parser::ParseCatchClauses(
     TokenPosition handler_pos,
     bool is_async,
     LocalVariable* exception_var,
     LocalVariable* stack_trace_var,
     LocalVariable* rethrow_exception_var,
     LocalVariable* rethrow_stack_trace_var,
     const GrowableObjectArray& handler_types,
     bool* needs_stack_trace) {
   // All catch blocks are merged into an if-then-else sequence of the
@@ skipping 181 matching lines @@
     // an outer try block is present) and code to save the exception and
     // stack trace variables.
     // This async code is inserted before the current node sequence containing
     // the chain of if/then/else handling all catch clauses.
     async_code->Add(current);
     current = async_code;
   }
   return current;
 }
 
-
 void Parser::SetupSavedTryContext(LocalVariable* saved_try_context) {
   const String& async_saved_try_ctx_name = String::ZoneHandle(
       Z, Symbols::NewFormatted(T, "%s%d",
                                Symbols::AsyncSavedTryCtxVarPrefix().ToCString(),
                                last_used_try_index_ - 1));
   LocalVariable* async_saved_try_ctx =
       new (Z) LocalVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
                             async_saved_try_ctx_name, Object::dynamic_type());
   ASSERT(async_temp_scope_ != NULL);
   async_temp_scope_->AddVariable(async_saved_try_ctx);
   ASSERT(saved_try_context != NULL);
   current_block_->statements->Add(new (Z) StoreLocalNode(
       TokenPosition::kNoSource, async_saved_try_ctx,
       new (Z) LoadLocalNode(TokenPosition::kNoSource, saved_try_context)));
 }
 
-
 // We create three variables for exceptions:
 // ':saved_try_context_var' - Used to save the context before the start of
 //                            the try block. The context register is
 //                            restored from this variable before
 //                            processing the catch block handler.
 // ':exception_var' - Used to save the current exception object that was
 //                    thrown.
 // ':stack_trace_var' - Used to save the current stack trace object which
 //                      the stack trace was copied into when an exception
 //                      was thrown.
@@ skipping 46 matching lines @@
         try_scope->LocalLookupVariable(Symbols::SavedStackTraceVar());
     if (*saved_stack_trace_var == NULL) {
       *saved_stack_trace_var = new (Z)
           LocalVariable(TokenPos(), TokenPos(), Symbols::SavedStackTraceVar(),
                         Object::dynamic_type());
       try_scope->AddVariable(*saved_stack_trace_var);
     }
   }
 }
 
-
 AstNode* Parser::ParseTryStatement(String* label_name) {
   TRACE_PARSER("ParseTryStatement");
 
   const TokenPosition try_pos = TokenPos();
   SourceLabel* try_label = NULL;
   if (label_name != NULL) {
     try_label = SourceLabel::New(try_pos, label_name, SourceLabel::kStatement);
     OpenBlock();
     current_block_->scope->AddLabel(try_label);
   }
@@ skipping 117 matching lines @@
   if (try_label != NULL) {
     current_block_->statements->Add(try_catch_node);
     SequenceNode* sequence = CloseBlock();
     sequence->set_label(try_label);
     try_catch_node = sequence;
   }
 
   return try_catch_node;
 }
 
-
 AstNode* Parser::ParseJump(String* label_name) {
   TRACE_PARSER("ParseJump");
   ASSERT(CurrentToken() == Token::kBREAK || CurrentToken() == Token::kCONTINUE);
   Token::Kind jump_kind = CurrentToken();
   const TokenPosition jump_pos = TokenPos();
   SourceLabel* target = NULL;
   ConsumeToken();
   if (IsIdentifier()) {
     // Explicit label after break/continue.
     const String& target_name = *CurrentLiteral();
@@ skipping 46 matching lines @@
   if (jump_kind == Token::kBREAK && target->kind() == SourceLabel::kCase) {
     ReportError(jump_pos, "'break' to case clause label is illegal");
   }
   if (target->FunctionLevel() != FunctionLevel()) {
     ReportError(jump_pos, "'%s' target must be in same function context",
                 Token::Str(jump_kind));
   }
   return new (Z) JumpNode(jump_pos, jump_kind, target);
 }
 
-
 AstNode* Parser::ParseYieldStatement() {
   bool is_yield_each = false;
   const TokenPosition yield_pos = TokenPos();
   ConsumeToken();  // yield reserved word.
   if (CurrentToken() == Token::kMUL) {
     is_yield_each = true;
     ConsumeToken();
   }
   if (!innermost_function().IsGenerator() &&
       !innermost_function().IsGeneratorClosure()) {
@@ skipping 118 matching lines @@
             new (Z) LoadLocalNode(TokenPosition::kNoSource,
                                   outer_async_saved_try_ctx)));
       }
     } else {
       ASSERT(outer_saved_try_ctx == NULL);
     }
   }
   return yield;
 }
 
-
 AstNode* Parser::ParseStatement() {
   TRACE_PARSER("ParseStatement");
   AstNode* statement = NULL;
   TokenPosition label_pos = TokenPosition::kNoSource;
   String* label_name = NULL;
   if (IsIdentifier()) {
     if (LookaheadToken(1) == Token::kCOLON) {
       // Statement starts with a label.
       label_name = CurrentLiteral();
       label_pos = TokenPos();
@@ skipping 167 matching lines @@
     statement = new (Z)
         ThrowNode(statement_pos, new (Z) LoadLocalNode(statement_pos, excp_var),
                   new (Z) LoadLocalNode(statement_pos, trace_var));
   } else {
     statement = ParseAwaitableExpr(kAllowConst, kConsumeCascades, NULL);
     ExpectSemicolon();
   }
   return statement;
 }
 
-
 void Parser::ReportError(const Error& error) {
   Report::LongJump(error);
   UNREACHABLE();
 }
 
-
 void Parser::ReportErrors(const Error& prev_error,
                           const Script& script,
                           TokenPosition token_pos,
                           const char* format,
                           ...) {
   va_list args;
   va_start(args, format);
   Report::LongJumpV(prev_error, script, token_pos, format, args);
   va_end(args);
   UNREACHABLE();
 }
 
-
 void Parser::ReportError(TokenPosition token_pos,
                          const char* format,
                          ...) const {
   va_list args;
   va_start(args, format);
   Report::MessageV(Report::kError, script_, token_pos, Report::AtLocation,
                    format, args);
   va_end(args);
   UNREACHABLE();
 }
 
-
 void Parser::ReportErrorBefore(const char* format, ...) {
   va_list args;
   va_start(args, format);
   Report::MessageV(Report::kError, script_, PrevTokenPos(),
                    Report::AfterLocation, format, args);
   va_end(args);
   UNREACHABLE();
 }
 
-
 void Parser::ReportError(const char* format, ...) const {
   va_list args;
   va_start(args, format);
   Report::MessageV(Report::kError, script_, TokenPos(), Report::AtLocation,
                    format, args);
   va_end(args);
   UNREACHABLE();
 }
 
-
 void Parser::ReportWarning(TokenPosition token_pos,
                            const char* format,
                            ...) const {
   va_list args;
   va_start(args, format);
   Report::MessageV(Report::kWarning, script_, token_pos, Report::AtLocation,
                    format, args);
   va_end(args);
 }
 
-
 void Parser::ReportWarning(const char* format, ...) const {
   va_list args;
   va_start(args, format);
   Report::MessageV(Report::kWarning, script_, TokenPos(), Report::AtLocation,
                    format, args);
   va_end(args);
 }
 
-
 void Parser::CheckToken(Token::Kind token_expected, const char* msg) {
   if (CurrentToken() != token_expected) {
     if (msg != NULL) {
       ReportError("%s", msg);
     } else {
       ReportError("'%s' expected", Token::Str(token_expected));
     }
   }
 }
 
-
 void Parser::ExpectToken(Token::Kind token_expected) {
   if (CurrentToken() != token_expected) {
     ReportError("'%s' expected", Token::Str(token_expected));
   }
   ConsumeToken();
 }
 
-
 void Parser::ExpectSemicolon() {
   if (CurrentToken() != Token::kSEMICOLON) {
     ReportErrorBefore("semicolon expected");
   }
   ConsumeToken();
 }
 
-
 void Parser::UnexpectedToken() {
   ReportError("unexpected token '%s'", CurrentToken() == Token::kIDENT
                                            ? CurrentLiteral()->ToCString()
                                            : Token::Str(CurrentToken()));
 }
 
-
 String* Parser::ExpectUserDefinedTypeIdentifier(const char* msg) {
   if (CurrentToken() != Token::kIDENT) {
     ReportError("%s", msg);
   }
   String* ident = CurrentLiteral();
   if (ident->Equals("dynamic")) {
     ReportError("%s", msg);
   }
   ConsumeToken();
   return ident;
 }
 
-
 // Check whether current token is an identifier or a built-in identifier.
 String* Parser::ExpectIdentifier(const char* msg) {
   if (!IsIdentifier()) {
     ReportError("%s", msg);
   }
   String* ident = CurrentLiteral();
   ConsumeToken();
   return ident;
 }
 
-
 bool Parser::IsAwaitKeyword() {
   return (FLAG_await_is_keyword || await_is_keyword_) &&
          IsSymbol(Symbols::Await());
 }
 
-
 bool Parser::IsYieldKeyword() {
   return (FLAG_await_is_keyword || await_is_keyword_) &&
          IsSymbol(Symbols::YieldKw());
 }
 
-
 static bool IsIncrementOperator(Token::Kind token) {
   return token == Token::kINCR || token == Token::kDECR;
 }
 
-
 static bool IsPrefixOperator(Token::Kind token) {
   return (token == Token::kSUB) || (token == Token::kNOT) ||
          (token == Token::kBIT_NOT);
 }
 
-
 SequenceNode* Parser::NodeAsSequenceNode(TokenPosition sequence_pos,
                                          AstNode* node,
                                          LocalScope* scope) {
   if ((node == NULL) || !node->IsSequenceNode()) {
     SequenceNode* sequence = new SequenceNode(sequence_pos, scope);
     if (node != NULL) {
       sequence->Add(node);
     }
     return sequence;
   }
   return node->AsSequenceNode();
 }
 
-
 // Call _throwNewIfNotLoaded if prefix is not NULL, otherwise call _throwNew.
 AstNode* Parser::ThrowTypeError(TokenPosition type_pos,
                                 const AbstractType& type,
                                 LibraryPrefix* prefix) {
   ArgumentListNode* arguments = new (Z) ArgumentListNode(type_pos);
 
   String& method_name = String::Handle(Z);
   if (prefix == NULL) {
     method_name = Library::PrivateCoreLibName(Symbols::ThrowNew()).raw();
   } else {
     arguments->Add(new (Z) LiteralNode(type_pos, *prefix));
     method_name =
         Library::PrivateCoreLibName(Symbols::ThrowNewIfNotLoaded()).raw();
   }
   // Location argument.
   arguments->Add(new (Z) LiteralNode(
       type_pos,
       Integer::ZoneHandle(Z, Integer::New(type_pos.value(), Heap::kOld))));
   // Src value argument.
   arguments->Add(new (Z) LiteralNode(type_pos, Object::null_instance()));
   // Dst type argument.
   arguments->Add(new (Z) LiteralNode(type_pos, type));
   // Dst name argument.
   arguments->Add(new (Z) LiteralNode(type_pos, Symbols::Empty()));
   // Bound error msg argument.
   arguments->Add(new (Z) LiteralNode(type_pos, Object::null_instance()));
   return MakeStaticCall(Symbols::TypeError(), method_name, arguments);
 }
 
-
 // Call _throwNewIfNotLoaded if prefix is not NULL, otherwise call _throwNew.
 AstNode* Parser::ThrowNoSuchMethodError(TokenPosition call_pos,
                                         const Class& cls,
                                         const String& function_name,
                                         ArgumentListNode* function_arguments,
                                         InvocationMirror::Call im_call,
                                         InvocationMirror::Type im_type,
                                         const Function* func,
                                         const LibraryPrefix* prefix) {
   ArgumentListNode* arguments = new (Z) ArgumentListNode(call_pos);
@@ skipping 73 matching lines @@
     // between dart2js and VM. Update the constructor to accept a string
     // describing the formal parameters of an incompatible call target.
     array = Array::New(1, Heap::kOld);
     array.SetAt(0, String::Handle(Z, function.UserVisibleFormalParameters()));
   }
   arguments->Add(new (Z) LiteralNode(call_pos, array));
 
   return MakeStaticCall(Symbols::NoSuchMethodError(), method_name, arguments);
 }
 
-
 AstNode* Parser::ParseBinaryExpr(int min_preced) {
   TRACE_PARSER("ParseBinaryExpr");
   ASSERT(min_preced >= Token::Precedence(Token::kIFNULL));
   AstNode* left_operand = ParseUnaryExpr();
   if (left_operand->IsPrimaryNode() &&
       (left_operand->AsPrimaryNode()->IsSuper())) {
     ReportError(left_operand->token_pos(), "illegal use of 'super'");
   }
   int current_preced = Token::Precedence(CurrentToken());
   while (current_preced >= min_preced) {
@@ skipping 42 matching lines @@
       } else {
         left_operand =
             OptimizeBinaryOpNode(op_pos, op_kind, left_operand, right_operand);
       }
     }
     current_preced--;
   }
   return left_operand;
 }
 
-
 AstNode* Parser::ParseAwaitableExprList() {
   TRACE_PARSER("ParseAwaitableExprList");
   SequenceNode* preamble = NULL;
   AstNode* expressions =
       ParseAwaitableExpr(kAllowConst, kConsumeCascades, &preamble);
   if (preamble != NULL) {
     preamble->Add(expressions);
     expressions = preamble;
   }
   if (CurrentToken() == Token::kCOMMA) {
     // Collect comma-separated expressions in a non scope owning sequence node.
     SequenceNode* list = new (Z) SequenceNode(TokenPos(), NULL);
     list->Add(expressions);
     while (CurrentToken() == Token::kCOMMA) {
       ConsumeToken();
       preamble = NULL;
       AstNode* expr =
           ParseAwaitableExpr(kAllowConst, kConsumeCascades, &preamble);
       if (preamble != NULL) {
         list->Add(preamble);
       }
       list->Add(expr);
     }
     expressions = list;
   }
   return expressions;
 }
 
-
 void Parser::EnsureExpressionTemp() {
   // Temporary used later by the flow_graph_builder.
   parsed_function()->EnsureExpressionTemp();
 }
 
-
 LocalVariable* Parser::CreateTempConstVariable(TokenPosition token_pos,
                                                const char* s) {
   char name[64];
   OS::SNPrint(name, 64, ":%s%" Pd "", s, token_pos.value());
   LocalVariable* temp = new (Z) LocalVariable(
       token_pos, token_pos, String::ZoneHandle(Z, Symbols::New(T, name)),
       Object::dynamic_type());
   temp->set_is_final();
   current_block_->scope->AddVariable(temp);
   return temp;
 }
 
-
 AstNode* Parser::OptimizeBinaryOpNode(TokenPosition op_pos,
                                       Token::Kind binary_op,
                                       AstNode* lhs,
                                       AstNode* rhs) {
   LiteralNode* lhs_literal = lhs->AsLiteralNode();
   LiteralNode* rhs_literal = rhs->AsLiteralNode();
   if ((lhs_literal != NULL) && (rhs_literal != NULL)) {
     if (lhs_literal->literal().IsDouble() &&
         rhs_literal->literal().IsDouble()) {
       double left_double = Double::Cast(lhs_literal->literal()).value();
@@ skipping 34 matching lines @@
     LoadLocalNode* load_left_temp = new (Z) LoadLocalNode(no_pos, left_temp);
     ComparisonNode* null_compare = new (Z)
         ComparisonNode(no_pos, Token::kNE_STRICT, load_left_temp, null_operand);
     result->AddNode(
         new (Z) ConditionalExprNode(op_pos, null_compare, load_left_temp, rhs));
     return result;
   }
   return new (Z) BinaryOpNode(op_pos, binary_op, lhs, rhs);
 }
 
-
 AstNode* Parser::ExpandAssignableOp(TokenPosition op_pos,
                                     Token::Kind assignment_op,
                                     AstNode* lhs,
                                     AstNode* rhs) {
   TRACE_PARSER("ExpandAssignableOp");
   switch (assignment_op) {
     case Token::kASSIGN:
       return rhs;
     case Token::kASSIGN_ADD:
       return new (Z) BinaryOpNode(op_pos, Token::kADD, lhs, rhs);
@@ skipping 21 matching lines @@
       return new (Z) BinaryOpNode(op_pos, Token::kIFNULL, lhs, rhs);
     default:
       ReportError(op_pos,
                   "internal error: ExpandAssignableOp '%s' unimplemented",
                   Token::Name(assignment_op));
       UNIMPLEMENTED();
       return NULL;
   }
 }
 
-
 // Evaluates the value of the compile time constant expression
 // and returns a literal node for the value.
 LiteralNode* Parser::FoldConstExpr(TokenPosition expr_pos, AstNode* expr) {
   if (expr->IsLiteralNode()) {
     return expr->AsLiteralNode();
   }
   if (expr->EvalConstExpr() == NULL) {
     ReportError(expr_pos, "expression is not a valid compile-time constant");
   }
   return new (Z) LiteralNode(expr_pos, EvaluateConstExpr(expr_pos, expr));
 }
 
-
 LetNode* Parser::PrepareCompoundAssignmentNodes(AstNode** expr) {
   AstNode* node = *expr;
   TokenPosition token_pos = node->token_pos();
   LetNode* result = new (Z) LetNode(token_pos);
   if (node->IsLoadIndexedNode()) {
     LoadIndexedNode* load_indexed = node->AsLoadIndexedNode();
     AstNode* array = load_indexed->array();
     AstNode* index = load_indexed->index_expr();
     if (!IsSimpleLocalOrLiteralNode(load_indexed->array())) {
       LocalVariable* t0 = result->AddInitializer(load_indexed->array());
@@ skipping 14 matching lines @@
       LocalVariable* t0 = result->AddInitializer(getter->receiver());
       receiver = new (Z) LoadLocalNode(token_pos, t0);
     }
     *expr = new (Z) InstanceGetterNode(
         token_pos, receiver, getter->field_name(), getter->is_conditional());
     return result;
   }
   return result;
 }
 
-
 // Check whether the syntax of expression expr is a grammatically legal
 // assignable expression. This check is used to detect situations where
 // the expression itself is assignable, but the source is grammatically
 // wrong. The AST representation of an expression cannot distinguish
 // between x = 0 and (x) = 0. The latter is illegal.
 // A syntactically legal assignable expression always ends with an
 // identifier token or a ] token. We rewind the token iterator and
 // check whether the token before end_pos is an identifier or ].
 bool Parser::IsLegalAssignableSyntax(AstNode* expr, TokenPosition end_pos) {
   ASSERT(expr->token_pos().IsReal());
   ASSERT(expr->token_pos() < end_pos);
   SetPosition(expr->token_pos());
   Token::Kind token = Token::kILLEGAL;
   while (TokenPos() < end_pos) {
     token = CurrentToken();
     ConsumeToken();
   }
   ASSERT(TokenPos() == end_pos);
   return Token::IsIdentifier(token) || (token == Token::kRBRACK);
 }
 
-
 AstNode* Parser::CreateAssignmentNode(AstNode* original,
                                       AstNode* rhs,
                                       const String* left_ident,
                                       TokenPosition left_pos,
                                       bool is_compound /* = false */) {
   AstNode* result = original->MakeAssignmentNode(rhs);
   if (result == NULL) {
     String& name = String::ZoneHandle(Z);
     const Class* target_cls = &current_class();
     if (original->IsTypeNode()) {
@@ skipping 30 matching lines @@
       (rhs->AsBinaryOpNode()->kind() == Token::kIFNULL)) {
     BinaryOpNode* ifnull = rhs->AsBinaryOpNode();
     AstNode* modified_assign =
         CreateAssignmentNode(original, ifnull->right(), left_ident, left_pos);
     result = OptimizeBinaryOpNode(ifnull->token_pos(), ifnull->kind(),
                                   ifnull->left(), modified_assign);
   }
   return result;
 }
 
-
 AstNode* Parser::ParseCascades(AstNode* expr) {
   TokenPosition cascade_pos = TokenPos();
   LetNode* cascade = new (Z) LetNode(cascade_pos);
   LocalVariable* cascade_receiver_var = cascade->AddInitializer(expr);
   while (CurrentToken() == Token::kCASCADE) {
     cascade_pos = TokenPos();
     LoadLocalNode* load_cascade_receiver =
         new (Z) LoadLocalNode(cascade_pos, cascade_receiver_var);
     if (Token::IsIdentifier(LookaheadToken(1))) {
       // Replace .. with . for ParseSelectors().
@@ skipping 36 matching lines @@
       }
     }
     cascade->AddNode(expr);
   }
   // The result is an expression with the (side effects of the) cascade
   // sequence followed by the (value of the) receiver temp variable load.
   cascade->AddNode(new (Z) LoadLocalNode(cascade_pos, cascade_receiver_var));
   return cascade;
 }
 
-
 // Convert loading of a static const field into a literal node.
 static AstNode* LiteralIfStaticConst(Zone* zone, AstNode* expr) {
   if (expr->IsLoadStaticFieldNode()) {
     const Field& field = expr->AsLoadStaticFieldNode()->field();
     if (field.is_const() &&
         !expr->AsLoadStaticFieldNode()->is_deferred_reference()) {
       ASSERT(field.StaticValue() != Object::sentinel().raw());
       ASSERT(field.StaticValue() != Object::transition_sentinel().raw());
       return new (zone) LiteralNode(
           expr->token_pos(), Instance::ZoneHandle(zone, field.StaticValue()));
     }
   }
   return expr;
 }
 
-
 AstNode* Parser::ParseAwaitableExpr(bool require_compiletime_const,
                                     bool consume_cascades,
                                     SequenceNode** await_preamble) {
   TRACE_PARSER("ParseAwaitableExpr");
   BoolScope saved_seen_await(&parsed_function()->have_seen_await_expr_, false);
   AstNode* expr = ParseExpr(require_compiletime_const, consume_cascades);
   if (parsed_function()->have_seen_await()) {
     // Make sure we do not reuse the scope to avoid creating contexts that we
     // are unaware of, i.e, creating contexts that have already been covered.
     // See FlowGraphBuilder::VisitSequenceNode() for details on when contexts
     // are created.
     OpenBlock();
     AwaitTransformer at(current_block_->statements, async_temp_scope_);
     AstNode* result = at.Transform(expr);
     SequenceNode* preamble = CloseBlock();
     if (await_preamble == NULL) {
       current_block_->statements->Add(preamble);
     } else {
       *await_preamble = preamble;
     }
     return result;
   }
   return expr;
 }
 
-
 AstNode* Parser::ParseExpr(bool require_compiletime_const,
                            bool consume_cascades) {
   TRACE_PARSER("ParseExpr");
   String* expr_ident =
       Token::IsIdentifier(CurrentToken()) ? CurrentLiteral() : NULL;
   const TokenPosition expr_pos = TokenPos();
 
   RecursionChecker rc(this);
 
   if (CurrentToken() == Token::kTHROW) {
@@ skipping 54 matching lines @@
     return let_expr;
   } else {
     AstNode* assigned_value = LiteralIfStaticConst(Z, right_expr);
     AstNode* assign_expr =
         CreateAssignmentNode(expr, assigned_value, expr_ident, expr_pos);
     ASSERT(assign_expr != NULL);
     return assign_expr;
   }
 }
 
-
 LiteralNode* Parser::ParseConstExpr() {
   TRACE_PARSER("ParseConstExpr");
   TokenPosition expr_pos = TokenPos();
   AstNode* expr = ParseExpr(kRequireConst, kNoCascades);
   if (!expr->IsLiteralNode()) {
     ReportError(expr_pos, "expression must be a compile-time constant");
   }
   return expr->AsLiteralNode();
 }
 
-
 AstNode* Parser::ParseConditionalExpr() {
   TRACE_PARSER("ParseConditionalExpr");
   const TokenPosition expr_pos = TokenPos();
   AstNode* expr = ParseBinaryExpr(Token::Precedence(Token::kIFNULL));
   if (CurrentToken() == Token::kCONDITIONAL) {
     EnsureExpressionTemp();
     ConsumeToken();
     AstNode* expr1 = ParseExpr(kAllowConst, kNoCascades);
     ExpectToken(Token::kCOLON);
     AstNode* expr2 = ParseExpr(kAllowConst, kNoCascades);
     expr = new (Z) ConditionalExprNode(expr_pos, expr, expr1, expr2);
   }
   return expr;
 }
 
-
 AstNode* Parser::ParseUnaryExpr() {
   TRACE_PARSER("ParseUnaryExpr");
   AstNode* expr = NULL;
   const TokenPosition op_pos = TokenPos();
   if (IsAwaitKeyword()) {
     TRACE_PARSER("ParseAwaitExpr");
     if (!innermost_function().IsAsyncFunction() &&
         !innermost_function().IsAsyncClosure() &&
         !innermost_function().IsAsyncGenerator() &&
         !innermost_function().IsAsyncGenClosure()) {
@@ skipping 44 matching lines @@
         CreateAssignmentNode(expr, add, expr_ident, expr_pos, true);
     ASSERT(store != NULL);
     let_expr->AddNode(store);
     expr = let_expr;
   } else {
     expr = ParsePostfixExpr();
   }
   return expr;
 }
 
-
 ArgumentListNode* Parser::ParseActualParameters(
     ArgumentListNode* implicit_arguments,
     const TypeArguments& func_type_args,
     bool require_const) {
   TRACE_PARSER("ParseActualParameters");
   ASSERT(CurrentToken() == Token::kLPAREN);
   const bool saved_mode = SetAllowFunctionLiterals(true);
   ArgumentListNode* arguments;
   if (implicit_arguments == NULL) {
     // TODO(regis): When require_const is true, do we need to check that
@@ skipping 41 matching lines @@
     ConsumeToken();
   }
   ExpectToken(Token::kRPAREN);
   SetAllowFunctionLiterals(saved_mode);
   if (named_argument_seen) {
     arguments->set_names(Array::Handle(Z, Array::MakeFixedLength(names)));
   }
   return arguments;
 }
 
-
 AstNode* Parser::ParseStaticCall(const Class& cls,
                                  const String& func_name,
                                  TokenPosition ident_pos,
                                  const TypeArguments& func_type_args,
                                  const LibraryPrefix* prefix) {
   TRACE_PARSER("ParseStaticCall");
   const TokenPosition call_pos = TokenPos();
   ASSERT(CurrentToken() == Token::kLPAREN);
   ArgumentListNode* arguments =
       ParseActualParameters(NULL, func_type_args, kAllowConst);
@@ skipping 58 matching lines @@
             1, new (Z) LiteralNode(arg1->token_pos(),
                                    EvaluateConstExpr(arg1->token_pos(), arg1)));
       }
     }
     return new (Z) ComparisonNode(ident_pos, Token::kEQ_STRICT,
                                   arguments->NodeAt(0), arguments->NodeAt(1));
   }
   return new (Z) StaticCallNode(ident_pos, func, arguments);
 }
 
-
 AstNode* Parser::ParseInstanceCall(AstNode* receiver,
                                    const String& func_name,
                                    TokenPosition ident_pos,
                                    const TypeArguments& func_type_args,
                                    bool is_conditional) {
   TRACE_PARSER("ParseInstanceCall");
   CheckToken(Token::kLPAREN);
   ArgumentListNode* arguments =
       ParseActualParameters(NULL, func_type_args, kAllowConst);
   return new (Z) InstanceCallNode(ident_pos, receiver, func_name, arguments,
                                   is_conditional);
 }
 
-
 AstNode* Parser::ParseClosureCall(AstNode* closure,
                                   const TypeArguments& func_type_args) {
   TRACE_PARSER("ParseClosureCall");
   const TokenPosition call_pos = TokenPos();
   ASSERT(CurrentToken() == Token::kLPAREN);
   ArgumentListNode* arguments =
       ParseActualParameters(NULL, func_type_args, kAllowConst);
   return BuildClosureCall(call_pos, closure, arguments);
 }
 
-
 AstNode* Parser::GenerateStaticFieldLookup(const Field& field,
                                            TokenPosition ident_pos) {
   // If the static field has an initializer, initialize the field at compile
   // time, which is only possible if the field is const.
   AstNode* initializing_getter = RunStaticFieldInitializer(field, ident_pos);
   if (initializing_getter != NULL) {
     // The field is not yet initialized and could not be initialized at compile
     // time. The getter will initialize the field.
     return initializing_getter;
   }
@@ skipping 10 matching lines @@
     return new (Z)
         LoadStaticFieldNode(ident_pos, Field::ZoneHandle(Z, field.raw()));
   } else {
     ASSERT(getter.kind() == RawFunction::kImplicitStaticFinalGetter);
     return new (Z) StaticGetterNode(ident_pos,
                                     NULL,  // Receiver.
                                     field_owner, field_name);
   }
 }
 
-
 // Reference to 'field_name' with explicit class as primary.
 AstNode* Parser::GenerateStaticFieldAccess(const Class& cls,
                                            const String& field_name,
                                            TokenPosition ident_pos) {
   AstNode* access = NULL;
   const Field& field = Field::ZoneHandle(Z, cls.LookupStaticField(field_name));
   Function& func = Function::ZoneHandle(Z);
   if (field.IsNull()) {
     // No field, check if we have an explicit getter function.
     func = cls.LookupGetterFunction(field_name);
@@ skipping 16 matching lines @@
       ASSERT(func.kind() != RawFunction::kImplicitStaticFinalGetter);
       access = new (Z) StaticGetterNode(
           ident_pos, NULL, Class::ZoneHandle(Z, cls.raw()), field_name);
     }
   } else {
     access = GenerateStaticFieldLookup(field, ident_pos);
   }
   return access;
 }
 
-
 AstNode* Parser::LoadFieldIfUnresolved(AstNode* node) {
   if (!node->IsPrimaryNode()) {
     return node;
   }
   PrimaryNode* primary = node->AsPrimaryNode();
   if (primary->primary().IsString()) {
     if (primary->IsSuper()) {
       return primary;
     }
     // In a static method, evaluation of an unresolved identifier causes a
@@ skipping 18 matching lines @@
       getter->set_is_deferred(primary->is_deferred_reference());
       return getter;
     } else {
       AstNode* receiver = LoadReceiver(primary->token_pos());
       return CallGetter(node->token_pos(), receiver, name);
     }
   }
   return primary;
 }
 
-
 AstNode* Parser::LoadClosure(PrimaryNode* primary) {
   ASSERT(primary->primary().IsFunction());
   const Function& func =
       Function::Cast(Object::ZoneHandle(primary->primary().raw()));
   const String& funcname = String::ZoneHandle(Z, func.name());
   if (func.is_static()) {
     // Static function access.
     ClosureNode* closure =
         CreateImplicitClosureNode(func, primary->token_pos(), NULL);
     closure->set_is_deferred(primary->is_deferred_reference());
     return closure;
   } else {
     // Instance function access.
     if (current_function().is_static() ||
         current_function().IsInFactoryScope()) {
       ReportError(primary->token_pos(),
                   "cannot access instance method '%s' from static method",
                   funcname.ToCString());
     }
     AstNode* receiver = LoadReceiver(primary->token_pos());
     return CallGetter(primary->token_pos(), receiver, funcname);
   }
   UNREACHABLE();
   return NULL;
 }
 
-
 AstNode* Parser::LoadTypeParameter(PrimaryNode* primary) {
   const TokenPosition primary_pos = primary->token_pos();
   TypeParameter& type_parameter = TypeParameter::ZoneHandle(Z);
   type_parameter = TypeParameter::Cast(primary->primary()).raw();
   if (type_parameter.IsClassTypeParameter()) {
     if (ParsingStaticMember()) {
       const String& name = String::Handle(Z, type_parameter.name());
       ReportError(primary_pos,
                   "cannot access type parameter '%s' "
                   "from static function",
@@ skipping 13 matching lines @@
     if (FunctionLevel() > 0) {
       // Make sure that the parent function type arguments are captured.
       CaptureFunctionTypeArguments();
     }
   }
   ASSERT(type_parameter.IsFinalized());
   ASSERT(!type_parameter.IsMalformed());
   return new (Z) TypeNode(primary_pos, type_parameter);
 }
 
-
 AstNode* Parser::ParseSelectors(AstNode* primary, bool is_cascade) {
   AstNode* left = primary;
   while (true) {
     AstNode* selector = NULL;
     if ((CurrentToken() == Token::kPERIOD) ||
         (CurrentToken() == Token::kQM_PERIOD)) {
       // Unconditional or conditional property extraction or method call.
       bool is_conditional = CurrentToken() == Token::kQM_PERIOD;
       ConsumeToken();
       if (left->IsPrimaryNode()) {
@@ skipping 227 matching lines @@
         }
       }
       // Done parsing selectors.
       return left;
     }
     ASSERT(selector != NULL);
     left = selector;
   }
 }
 
-
 // Closurization e#m of getter, setter, method or operator.
 AstNode* Parser::ParseClosurization(AstNode* primary) {
   if (!FLAG_support_deprecated_tearoff_syntax) {
     ReportError("tear-off using the x#id syntax is a deprecated feature");
     return NULL;
   }
   ExpectToken(Token::kHASH);
   TokenPosition property_pos = TokenPos();
   bool is_setter_name = false;
 
@@ skipping 135 matching lines @@
   GrowableHandlePtrArray<const String> pieces(Z, 3);
   pieces.Add(Symbols::HashMark());
   if (is_setter_name) {
     pieces.Add(Symbols::SetterPrefix());
   }
   pieces.Add(extractor_name);
   extractor_name = Symbols::FromConcatAll(T, pieces);
   return new (Z) InstanceGetterNode(property_pos, primary, extractor_name);
 }
 
-
 AstNode* Parser::ParsePostfixExpr() {
   TRACE_PARSER("ParsePostfixExpr");
   String* expr_ident =
       Token::IsIdentifier(CurrentToken()) ? CurrentLiteral() : NULL;
   const TokenPosition expr_pos = TokenPos();
   AstNode* expr = ParsePrimary();
   if (CurrentToken() == Token::kHASH) {
     expr = LoadFieldIfUnresolved(expr);
     expr = ParseClosurization(expr);
   } else {
@@ skipping 20 matching lines @@
     ASSERT(store != NULL);
     // The result is a pair of the (side effects of the) store followed by
     // the (value of the) initial value temp variable load.
     let_expr->AddNode(store);
     let_expr->AddNode(new (Z) LoadLocalNode(op_pos, temp));
     return let_expr;
   }
   return expr;
 }
 
-
 // Resolve the type parameters that may appear in the given signature from the
 // signature function and current class.
 // Unresolved type classes get resolved later by the class finalizer.
 void Parser::ResolveSignature(const Function& signature) {
   const Function& saved_innermost_function =
       Function::Handle(Z, innermost_function().raw());
   innermost_function_ = signature.raw();
   AbstractType& type = AbstractType::Handle();
   // Resolve upper bounds of function type parameters.
   const intptr_t num_type_params = signature.NumTypeParameters();
@@ skipping 15 matching lines @@
   // Resolve formal parameter types.
   const intptr_t num_parameters = signature.NumParameters();
   for (intptr_t i = 0; i < num_parameters; i++) {
     type = signature.ParameterTypeAt(i);
     ResolveType(&type);
     signature.SetParameterTypeAt(i, type);
   }
   innermost_function_ = saved_innermost_function.raw();
 }
 
-
 // Resolve the type parameters that may appear in the given type and in its type
 // arguments from the current function and current class.
 // Unresolved type classes get resolved later by the class finalizer.
 void Parser::ResolveType(AbstractType* type) {
   ASSERT(type != NULL);
   if (type->IsResolved()) {
     // Some types are resolved by definition, such as a TypeParameter.
     return;
   }
   // Resolve type class.
@@ skipping 79 matching lines @@
         Function::Handle(Z, Type::Cast(*type).signature());
     Type& signature_type = Type::Handle(Z, signature.SignatureType());
     if (signature_type.raw() != type->raw()) {
       ResolveType(&signature_type);
     } else {
       ResolveSignature(signature);
     }
   }
 }
 
-
 RawAbstractType* Parser::CanonicalizeType(const AbstractType& type) {
   // If the current class is the result of a mixin application, we must
   // use the class scope of the class from which the function originates.
   if (current_class().IsMixinApplication()) {
     return ClassFinalizer::FinalizeType(
         Class::Handle(Z, parsed_function()->function().origin()), type);
   }
   return ClassFinalizer::FinalizeType(current_class(), type);
 }
 
-
 LocalVariable* Parser::LookupLocalScope(const String& ident) {
   if (current_block_ == NULL) {
     return NULL;
   }
   // A found name is treated as accessed and possibly marked as captured.
   const bool kTestOnly = false;
   return current_block_->scope->LookupVariable(ident, kTestOnly);
 }
 
-
 void Parser::CheckInstanceFieldAccess(TokenPosition field_pos,
                                       const String& field_name) {
   // Fields are not accessible from a static function, except from a
   // constructor, which is considered as non-static by the compiler.
   if (current_function().is_static()) {
     ReportError(field_pos,
                 "cannot access instance field '%s' from a static function",
                 field_name.ToCString());
   }
 }
 
-
 bool Parser::ParsingStaticMember() const {
   if (is_top_level_) {
     return (current_member_ != NULL) && current_member_->has_static &&
            !current_member_->has_factory;
   }
   ASSERT(!current_function().IsNull());
   return current_function().is_static() &&
          !current_function().IsInFactoryScope();
 }
 
-
 const AbstractType* Parser::ReceiverType(const Class& cls) {
   ASSERT(!cls.IsNull());
   ASSERT(!cls.IsTypedefClass());
   // Note that if cls is _Closure, the returned type will be _Closure,
   // and not the signature type.
   Type& type = Type::ZoneHandle(Z, cls.CanonicalType());
   if (!type.IsNull()) {
     return &type;
   }
   type = Type::New(cls, TypeArguments::Handle(Z, cls.type_parameters()),
                    cls.token_pos(), Heap::kOld);
   if (cls.is_type_finalized()) {
     type ^= ClassFinalizer::FinalizeType(cls, type);
     // Note that the receiver type may now be a malbounded type.
     cls.SetCanonicalType(type);
   }
   return &type;
 }
 
-
 bool Parser::IsInstantiatorRequired() const {
   ASSERT(!current_function().IsNull());
   if (current_function().is_static() &&
       !current_function().IsInFactoryScope()) {
     return false;
   }
   return current_class().IsGeneric();
 }
 
-
 bool Parser::InGenericFunctionScope() const {
   if (!innermost_function().IsNull()) {
     // With one more free tag bit in Function, we could cache this information.
     if (innermost_function().IsGeneric() ||
         innermost_function().HasGenericParent()) {
       return true;
     }
   }
   return false;
 }
 
-
 void Parser::InsertCachedConstantValue(const Script& script,
                                        TokenPosition token_pos,
                                        const Instance& value) {
   ASSERT(Thread::Current()->IsMutatorThread());
   const intptr_t kInitialConstMapSize = 16;
   ASSERT(!script.InVMHeap());
   if (script.compile_time_constants() == Array::null()) {
     const Array& array = Array::Handle(
         HashTables::New<ConstantsMap>(kInitialConstMapSize, Heap::kOld));
     script.set_compile_time_constants(array);
   }
   ConstantsMap constants(script.compile_time_constants());
   constants.InsertNewOrGetValue(token_pos, value);
   script.set_compile_time_constants(constants.Release());
 }
 
-
 void Parser::CacheConstantValue(TokenPosition token_pos,
                                 const Instance& value) {
   if (current_function().kind() == RawFunction::kImplicitStaticFinalGetter) {
     // Don't cache constants in initializer expressions. They get
     // evaluated only once.
     return;
   }
   InsertCachedConstantValue(script_, token_pos, value);
   INC_STAT(thread_, num_cached_consts, 1);
 }
 
-
 bool Parser::GetCachedConstant(TokenPosition token_pos, Instance* value) {
   bool is_present = false;
   ASSERT(!script_.InVMHeap());
   if (script_.compile_time_constants() == Array::null()) {
     return false;
   }
   ConstantsMap constants(script_.compile_time_constants());
   *value ^= constants.GetOrNull(token_pos, &is_present);
   // Mutator compiler thread may add constants while background compiler
   // is running, and thus change the value of 'compile_time_constants';
   // do not assert that 'compile_time_constants' has not changed.
   constants.Release();
   if (FLAG_compiler_stats && is_present) {
     thread_->compiler_stats()->num_const_cache_hits++;
   }
   return is_present;
 }
 
-
 RawInstance* Parser::TryCanonicalize(const Instance& instance,
                                      TokenPosition token_pos) {
   if (instance.IsNull()) {
     return instance.raw();
   }
   const char* error_str = NULL;
   Instance& result =
       Instance::Handle(Z, instance.CheckAndCanonicalize(thread(), &error_str));
   if (result.IsNull()) {
     ReportError(token_pos, "Invalid const object %s", error_str);
   }
   return result.raw();
 }
 
-
 // If the field is already initialized, return no ast (NULL).
 // Otherwise, if the field is constant, initialize the field and return no ast.
 // If the field is not initialized and not const, return the ast for the getter.
 StaticGetterNode* Parser::RunStaticFieldInitializer(
     const Field& field,
     TokenPosition field_ref_pos) {
   ASSERT(field.is_static());
   const Class& field_owner = Class::ZoneHandle(Z, field.Owner());
   const String& field_name = String::ZoneHandle(Z, field.name());
   const String& getter_name =
@@ skipping 58 matching lines @@
     }
   }
   if (getter.IsNull() ||
       (getter.kind() == RawFunction::kImplicitStaticFinalGetter)) {
     return NULL;
   }
   ASSERT(getter.kind() == RawFunction::kImplicitGetter);
   return new (Z) StaticGetterNode(field_ref_pos, NULL, field_owner, field_name);
 }
 
-
 RawObject* Parser::EvaluateConstConstructorCall(
     const Class& type_class,
     const TypeArguments& type_arguments,
     const Function& constructor,
     ArgumentListNode* arguments) {
   NoReloadScope no_reload_scope(isolate(), thread());
   NoOOBMessageScope no_msg_scope(thread());
   // Factories and constructors are not generic functions.
   const int kTypeArgsLen = 0;
   // Factories have one extra argument: the type arguments.
@@ skipping 43 matching lines @@
     }
   } else {
     if (constructor.IsFactory()) {
       // The factory method returns the allocated object.
       instance ^= result.raw();
     }
     return TryCanonicalize(instance, TokenPos());
   }
 }
 
-
 // Do a lookup for the identifier in the block scope and the class scope
 // return true if the identifier is found, false otherwise.
 // If node is non NULL return an AST node corresponding to the identifier.
 bool Parser::ResolveIdentInLocalScope(TokenPosition ident_pos,
                                       const String& ident,
                                       AstNode** node,
                                       intptr_t* function_level) {
   TRACE_PARSER("ResolveIdentInLocalScope");
   // First try to find the identifier in the nested local scopes.
   LocalVariable* local = LookupLocalScope(ident);
@@ skipping 87 matching lines @@
     }
   }
 
   // Nothing found in scope of current class.
   if (node != NULL) {
     *node = NULL;
   }
   return false;
 }
 
-
 // Resolve an identifier by checking the global scope of the current
 // library. If not found in the current library, then look in the scopes
 // of all libraries that are imported without a library prefix.
 AstNode* Parser::ResolveIdentInCurrentLibraryScope(TokenPosition ident_pos,
                                                    const String& ident) {
   TRACE_PARSER("ResolveIdentInCurrentLibraryScope");
   HANDLESCOPE(thread());
   const Object& obj = Object::Handle(Z, library_.ResolveName(ident));
   if (obj.IsClass()) {
     const Class& cls = Class::Cast(obj);
@@ skipping 23 matching lines @@
     const LibraryPrefix& prefix = LibraryPrefix::Cast(obj);
     ReportError(ident_pos, "illegal use of library prefix '%s'",
                 String::Handle(prefix.name()).ToCString());
   } else {
     ASSERT(obj.IsNull());
   }
   // Lexically unresolved primary identifiers are referenced by their name.
   return new (Z) PrimaryNode(ident_pos, ident);
 }
 
-
 // Do a lookup for the identifier in the scope of the specified
 // library prefix. This means trying to resolve it locally in all of the
 // libraries present in the library prefix.
 AstNode* Parser::ResolveIdentInPrefixScope(TokenPosition ident_pos,
                                            const LibraryPrefix& prefix,
                                            const String& ident) {
   TRACE_PARSER("ResolveIdentInPrefixScope");
   HANDLESCOPE(thread());
   if (ident.CharAt(0) == Library::kPrivateIdentifierStart) {
     // Private names are not exported by libraries. The name mangling
@@ skipping 58 matching lines @@
         primary->set_prefix(&prefix);
       }
       return primary;
     }
   }
   // All possible object types are handled above.
   UNREACHABLE();
   return NULL;
 }
 
-
 // Resolve identifier. Issue an error message if
 // the ident refers to a method and allow_closure_names is false.
 // If the name cannot be resolved, turn it into an instance field access
 // if we're compiling an instance method, or generate
 // throw NoSuchMethodError if we're compiling a static method.
 AstNode* Parser::ResolveIdent(TokenPosition ident_pos,
                               const String& ident,
                               bool allow_closure_names) {
   TRACE_PARSER("ResolveIdent");
   // First try to find the variable in the local scope (block scope or
@@ skipping 70 matching lines @@
       type ^= CanonicalizeType(type);
       // Type may be malbounded, but not malformed.
       ASSERT(!type.IsMalformed());
       resolved =
           new (Z) TypeNode(primary_pos, type, primary->is_deferred_reference());
     }
   }
   return resolved;
 }
 
-
 RawAbstractType* Parser::ParseType(
     ClassFinalizer::FinalizationKind finalization,
     bool allow_deferred_type,
     bool consume_unresolved_prefix) {
   LibraryPrefix& prefix = LibraryPrefix::Handle(Z);
   return ParseType(finalization, allow_deferred_type, consume_unresolved_prefix,
                    &prefix);
 }
 
-
 // Parses and returns a type or a function type.
 RawAbstractType* Parser::ParseTypeOrFunctionType(
     bool allow_void,
     ClassFinalizer::FinalizationKind finalization) {
   TRACE_PARSER("ParseTypeOrFunctionType");
   AbstractType& type = AbstractType::Handle(Z);
   if (CurrentToken() == Token::kVOID) {
     TokenPosition void_pos = TokenPos();
     type = Type::VoidType();
     ConsumeToken();
@@ skipping 20 matching lines @@
   }
   if (finalization >= ClassFinalizer::kResolveTypeParameters) {
     ResolveType(&type);
     if (finalization >= ClassFinalizer::kCanonicalize) {
       type ^= CanonicalizeType(type);
     }
   }
   return type.raw();
 }
 
-
 // Parses and returns a function type.
 // If 'result_type' is not null, parsing of the result type is skipped.
 RawType* Parser::ParseFunctionType(
     const AbstractType& result_type,
     ClassFinalizer::FinalizationKind finalization) {
   TRACE_PARSER("ParseFunctionType");
   AbstractType& type = AbstractType::Handle(Z, result_type.raw());
   if (type.IsNull()) {
     if (CurrentToken() == Token::kVOID) {
       ConsumeToken();
@@ skipping 56 matching lines @@
   }
   if (finalization >= ClassFinalizer::kResolveTypeParameters) {
     ResolveType(&type);
     if (finalization >= ClassFinalizer::kCanonicalize) {
       type ^= CanonicalizeType(type);
     }
   }
   return Type::RawCast(type.raw());
 }
 
-
 // Parses type = [ident "."] ident ["<" type { "," type } ">"], then resolve and
 // finalize it according to the given type finalization mode.
 // Returns type and sets prefix.
 RawAbstractType* Parser::ParseType(
     ClassFinalizer::FinalizationKind finalization,
     bool allow_deferred_type,
     bool consume_unresolved_prefix,
     LibraryPrefix* prefix) {
   TRACE_PARSER("ParseType");
   CheckToken(Token::kIDENT, "type name expected");
@@ skipping 66 matching lines @@
       }
       // If the deferred prefixes are not allowed, or if the prefix is not yet
       // loaded when finalization is requested, return a malformed type.
       // Otherwise, handle resolution below, as needed.
       if (!allow_deferred_type ||
           (!prefix->is_loaded() &&
            (finalization > ClassFinalizer::kResolveTypeParameters))) {
         ParseTypeArguments(ClassFinalizer::kIgnore);
         return ClassFinalizer::NewFinalizedMalformedType(
             Error::Handle(Z),  // No previous error.
-            script_, ident_pos, !prefix->is_loaded() && allow_deferred_type
-                                    ? "deferred type '%s.%s' is not yet loaded"
-                                    : "using deferred type '%s.%s' is invalid",
+            script_, ident_pos,
+            !prefix->is_loaded() && allow_deferred_type
+                ? "deferred type '%s.%s' is not yet loaded"
+                : "using deferred type '%s.%s' is invalid",
             String::Handle(Z, prefix->name()).ToCString(),
             type_name.ToCString());
       }
     }
   }
   Object& type_class = Object::Handle(Z);
   // Leave type_class as null if type finalization mode is kIgnore.
   if (finalization != ClassFinalizer::kIgnore) {
     type_class = UnresolvedClass::New(*prefix, type_name, ident_pos);
   }
   TypeArguments& type_arguments =
       TypeArguments::Handle(Z, ParseTypeArguments(finalization));
   if (finalization == ClassFinalizer::kIgnore) {
     return Type::DynamicType();
   }
   AbstractType& type = AbstractType::Handle(
       Z, Type::New(type_class, type_arguments, ident_pos, Heap::kOld));
   if (finalization >= ClassFinalizer::kResolveTypeParameters) {
     ResolveType(&type);
     if (finalization >= ClassFinalizer::kCanonicalize) {
       type ^= CanonicalizeType(type);
     }
   }
   return type.raw();
 }
 
-
 void Parser::CheckConstructorCallTypeArguments(
     TokenPosition pos,
     const Function& constructor,
     const TypeArguments& type_arguments) {
   if (!type_arguments.IsNull()) {
     const Class& constructor_class = Class::Handle(Z, constructor.Owner());
     ASSERT(!constructor_class.IsNull());
     ASSERT(constructor_class.is_finalized());
     ASSERT(type_arguments.IsCanonical());
     // Do not report the expected vs. actual number of type arguments, because
     // the type argument vector is flattened and raw types are allowed.
     if (type_arguments.Length() != constructor_class.NumTypeArguments()) {
       ReportError(pos, "wrong number of type arguments passed to constructor");
     }
   }
 }
 
-
 // Parse "[" [ expr { "," expr } ["," ] "]".
 // Note: if the list literal is empty and the brackets have no whitespace
 // between them, the scanner recognizes the opening and closing bracket
 // as one token of type Token::kINDEX.
 AstNode* Parser::ParseListLiteral(TokenPosition type_pos,
                                   bool is_const,
                                   const TypeArguments& type_arguments) {
   TRACE_PARSER("ParseListLiteral");
   ASSERT(type_pos.IsReal());
   ASSERT(CurrentToken() == Token::kLBRACK || CurrentToken() == Token::kINDEX);
@@ skipping 142 matching lines @@
       factory_param->Add(empty_array_literal);
     } else {
       ArrayNode* list = new (Z) ArrayNode(TokenPos(), type, element_list);
       factory_param->Add(list);
     }
     return CreateConstructorCallNode(literal_pos, factory_type_args,
                                      factory_method, factory_param);
   }
 }
 
-
 ConstructorCallNode* Parser::CreateConstructorCallNode(
     TokenPosition token_pos,
     const TypeArguments& type_arguments,
     const Function& constructor,
     ArgumentListNode* arguments) {
   if (!type_arguments.IsNull() && !type_arguments.IsInstantiated()) {
     EnsureExpressionTemp();
   }
   return new (Z)
       ConstructorCallNode(token_pos, type_arguments, constructor, arguments);
 }
 
-
 static void AddKeyValuePair(GrowableArray<AstNode*>* pairs,
                             bool is_const,
                             AstNode* key,
                             AstNode* value) {
   if (is_const) {
     ASSERT(key->IsLiteralNode());
     const Instance& new_key = key->AsLiteralNode()->literal();
     for (int i = 0; i < pairs->length(); i += 2) {
       const Instance& key_i = (*pairs)[i]->AsLiteralNode()->literal();
       // The keys of a compile time constant map are compile time
       // constants, i.e. canonicalized values. Thus, we can compare
       // raw pointers to check for equality.
       if (new_key.raw() == key_i.raw()) {
         // Duplicate key found. The new value replaces the previously
         // defined value.
         (*pairs)[i + 1] = value;
         return;
       }
     }
   }
   pairs->Add(key);
   pairs->Add(value);
 }
 
-
 AstNode* Parser::ParseMapLiteral(TokenPosition type_pos,
                                  bool is_const,
                                  const TypeArguments& type_arguments) {
   TRACE_PARSER("ParseMapLiteral");
   ASSERT(type_pos.IsReal());
   ASSERT(CurrentToken() == Token::kLBRACE);
   const TokenPosition literal_pos = TokenPos();
 
   if (is_const) {
     Instance& existing_const = Instance::ZoneHandle(Z);
@@ skipping 199 matching lines @@
       factory_param->Add(kv_pairs);
     }
 
     return CreateConstructorCallNode(literal_pos, factory_type_args,
                                      factory_method, factory_param);
   }
   UNREACHABLE();
   return NULL;
 }
 
-
 AstNode* Parser::ParseCompoundLiteral() {
   TRACE_PARSER("ParseCompoundLiteral");
   bool is_const = false;
   if (CurrentToken() == Token::kCONST) {
     is_const = true;
     ConsumeToken();
   }
   const TokenPosition type_pos = TokenPos();
   TypeArguments& type_arguments = TypeArguments::Handle(
       Z, ParseTypeArguments(ClassFinalizer::kCanonicalize));
   // Malformed type arguments are mapped to dynamic, so we will not encounter
   // them here.
   // Map and List interfaces do not declare bounds on their type parameters, so
   // we will not see malbounded type arguments here.
   AstNode* primary = NULL;
   if ((CurrentToken() == Token::kLBRACK) || (CurrentToken() == Token::kINDEX)) {
     primary = ParseListLiteral(type_pos, is_const, type_arguments);
   } else if (CurrentToken() == Token::kLBRACE) {
     primary = ParseMapLiteral(type_pos, is_const, type_arguments);
   } else {
     UnexpectedToken();
   }
   return primary;
 }
 
-
 AstNode* Parser::ParseSymbolLiteral() {
   ASSERT(CurrentToken() == Token::kHASH);
   ConsumeToken();
   TokenPosition symbol_pos = TokenPos();
   String& symbol = String::ZoneHandle(Z);
   if (IsIdentifier()) {
     symbol = CurrentLiteral()->raw();
     ConsumeToken();
     GrowableHandlePtrArray<const String> pieces(Z, 3);
     pieces.Add(symbol);
@@ skipping 29 matching lines @@
                                       constr, constr_args));
   if (result.IsUnhandledException()) {
     ReportErrors(Error::Cast(result), script_, symbol_pos,
                  "error executing const Symbol constructor");
   }
   symbol_instance ^= result.raw();
   CacheConstantValue(symbol_pos, symbol_instance);
   return new (Z) LiteralNode(symbol_pos, symbol_instance);
 }
 
-
 RawFunction* Parser::BuildConstructorClosureFunction(const Function& ctr,
                                                      TokenPosition token_pos) {
   ASSERT(ctr.kind() == RawFunction::kConstructor);
   Function& closure = Function::Handle(Z);
   closure = I->LookupClosureFunction(innermost_function(), token_pos);
   if (!closure.IsNull()) {
     ASSERT(closure.IsConstructorClosureFunction());
     return closure.raw();
   }
 
@@ skipping 22 matching lines @@
 
   // Finalize function type.
   Type& signature_type = Type::Handle(Z, closure.SignatureType());
   signature_type ^= CanonicalizeType(signature_type);
   closure.SetSignatureType(signature_type);
   // Finalization would be premature when top-level parsing.
   ASSERT(!is_top_level_);
   return closure.raw();
 }
 
-
 static String& BuildConstructorName(Thread* thread,
                                     const String& type_class_name,
                                     const String* named_constructor) {
   // By convention, the static function implementing a named constructor 'C'
   // for class 'A' is labeled 'A.C', and the static function implementing the
   // unnamed constructor for class 'A' is labeled 'A.'.
   // This convention prevents users from explicitly calling constructors.
   Zone* zone = thread->zone();
   String& constructor_name =
       String::Handle(zone, Symbols::FromDot(thread, type_class_name));
   if (named_constructor != NULL) {
     constructor_name =
         Symbols::FromConcat(thread, constructor_name, *named_constructor);
   }
   return constructor_name;
 }
 
-
 // Parse a primary expression of the form new T# or new T#m.
 // Current token position is after the keyword new. Extracts the
 // anonymous or named constructor and type arguments.
 // Note that type type T has already been parsed before
 // (by ParseNewOperator()) and is guaranteed to be well-formed,
 // and the constructor is known to exist.
 void Parser::ParseConstructorClosurization(Function* constructor,
                                            TypeArguments* type_arguments) {
   *constructor = Function::null();
   *type_arguments = TypeArguments::null();
@@ skipping 42 matching lines @@
                                      NULL,  // bound_trail
                                      Heap::kOld);
         ASSERT(error.IsNull());
       }
       *type_arguments = type.arguments();
       *constructor = constructor->RedirectionTarget();
     }
   }
 }
 
-
 AstNode* Parser::ParseNewOperator(Token::Kind op_kind) {
   TRACE_PARSER("ParseNewOperator");
   const TokenPosition new_pos = TokenPos();
   ASSERT((op_kind == Token::kNEW) || (op_kind == Token::kCONST));
   bool is_const = (op_kind == Token::kCONST);
   if (!IsIdentifier()) {
     ReportError("type name expected");
   }
   TokenPosition type_pos = TokenPos();
   // Can't allocate const objects of a deferred type.
@@ skipping 333 matching lines @@
     new_object = CreateConstructorCallNode(new_pos, type_arguments, constructor,
                                            arguments);
   }
   if (!type_bound.IsNull()) {
     new_object = new (Z) AssignableNode(new_pos, new_object, type_bound,
                                         Symbols::FactoryResult());
   }
   return new_object;
 }
 
-
 String& Parser::Interpolate(const GrowableArray<AstNode*>& values) {
   NoReloadScope no_reload_scope(isolate(), thread());
   NoOOBMessageScope no_msg_scope(thread());
   const Class& cls =
       Class::Handle(Z, Library::LookupCoreClass(Symbols::StringBase()));
   ASSERT(!cls.IsNull());
   const Function& func = Function::Handle(
       Z, cls.LookupStaticFunction(
              Library::PrivateCoreLibName(Symbols::Interpolate())));
   ASSERT(!func.IsNull());
@@ skipping 15 matching lines @@
   result = DartEntry::InvokeFunction(func, interpolate_arg);
   if (result.IsUnhandledException()) {
     ReportError("%s", Error::Cast(result).ToErrorCString());
   }
   String& concatenated = String::ZoneHandle(Z);
   concatenated ^= result.raw();
   concatenated = Symbols::New(T, concatenated);
   return concatenated;
 }
 
-
 // A string literal consists of the concatenation of the next n tokens
 // that satisfy the EBNF grammar:
 // literal = kSTRING {{ interpol } kSTRING }
 // interpol = kINTERPOL_VAR | (kINTERPOL_START expression kINTERPOL_END)
 // In other words, the scanner breaks down interpolated strings so that
 // a string literal always begins and ends with a kSTRING token.
 AstNode* Parser::ParseStringLiteral(bool allow_interpolation) {
   TRACE_PARSER("ParseStringLiteral");
   AstNode* primary = NULL;
   const TokenPosition literal_start = TokenPos();
@@ skipping 84 matching lines @@
       // find the value next time.
     }
   } else {
     ArrayNode* values = new (Z) ArrayNode(
         TokenPos(), Type::ZoneHandle(Z, Type::ArrayType()), values_list);
     primary = new (Z) StringInterpolateNode(TokenPos(), values);
   }
   return primary;
 }
 
-
 AstNode* Parser::ParsePrimary() {
   TRACE_PARSER("ParsePrimary");
   ASSERT(!is_top_level_);
   AstNode* primary = NULL;
   const Token::Kind token = CurrentToken();
   if (IsFunctionLiteral()) {
     primary = ParseFunctionStatement(true);
   } else if (IsIdentifier()) {
     TokenPosition qual_ident_pos = TokenPos();
     const LibraryPrefix& prefix = LibraryPrefix::ZoneHandle(Z, ParsePrefix());
@@ skipping 192 matching lines @@
       ReportError("super call or super getter may not use ?.");
     } else {
       primary = new (Z) PrimaryNode(super_pos, Symbols::Super());
     }
   } else {
     UnexpectedToken();
   }
   return primary;
 }
 
-
 // Evaluate expression in expr and return the value. The expression must
 // be a compile time constant.
 const Instance& Parser::EvaluateConstExpr(TokenPosition expr_pos,
                                           AstNode* expr) {
   NoReloadScope no_reload_scope(isolate(), thread());
   NoOOBMessageScope no_msg_scope(thread());
   if (expr->IsLiteralNode()) {
     return expr->AsLiteralNode()->literal();
   } else if (expr->IsLoadLocalNode() &&
              expr->AsLoadLocalNode()->local().IsConst()) {
@@ skipping 37 matching lines @@
                    "error evaluating constant expression");
     }
     ASSERT(result.IsInstance() || result.IsNull());
     value ^= result.raw();
     value = TryCanonicalize(value, expr_pos);
     CacheConstantValue(expr_pos, value);
     return value;
   }
 }
 
-
 void Parser::SkipFunctionLiteral() {
   if (IsIdentifier()) {
     if (LookaheadToken(1) != Token::kLPAREN) {
       SkipTypeOrFunctionType(true);
     }
     ExpectIdentifier("function name expected");
   }
   if (CurrentToken() == Token::kLPAREN) {
     SkipToMatchingParenthesis();
   }
   RawFunction::AsyncModifier async_modifier = ParseFunctionModifier();
   BoolScope allow_await(&this->await_is_keyword_,
                         async_modifier != RawFunction::kNoModifier);
   if (CurrentToken() == Token::kLBRACE) {
     SkipBlock();
     ExpectToken(Token::kRBRACE);
   } else if (CurrentToken() == Token::kARROW) {
     ConsumeToken();
     SkipExpr();
   }
 }
 
-
 // Skips function/method/constructor/getter/setter preambles until the formal
 // parameter list. It is enough to skip the tokens, since we have already
 // previously parsed the function.
 void Parser::SkipFunctionPreamble() {
   while (true) {
     if (IsFunctionTypeSymbol()) {
       ConsumeToken();
       SkipTypeParameters();
       SkipToMatchingParenthesis();
       continue;
@@ skipping 16 matching lines @@
       }
       // Case: Getter.
       ConsumeToken();  // Parse away 'get'.
       ConsumeToken();  // Parse away the getter name.
       return;
     }
     ConsumeToken();  // Can be static, factory, operator, void, ident, etc...
   }
 }
 
-
 void Parser::SkipListLiteral() {
   if (CurrentToken() == Token::kINDEX) {
     // Empty list literal.
     ConsumeToken();
     return;
   }
   ExpectToken(Token::kLBRACK);
   while (CurrentToken() != Token::kRBRACK) {
     SkipNestedExpr();
     if (CurrentToken() == Token::kCOMMA) {
       ConsumeToken();
     } else {
       break;
     }
   }
   ExpectToken(Token::kRBRACK);
 }
 
-
 void Parser::SkipMapLiteral() {
   ExpectToken(Token::kLBRACE);
   while (CurrentToken() != Token::kRBRACE) {
     SkipNestedExpr();
     ExpectToken(Token::kCOLON);
     SkipNestedExpr();
     if (CurrentToken() == Token::kCOMMA) {
       ConsumeToken();
     } else {
       break;
     }
   }
   ExpectToken(Token::kRBRACE);
 }
 
-
 void Parser::SkipActualParameters() {
   if (CurrentToken() == Token::kLT) {
     SkipTypeArguments();
   }
   ExpectToken(Token::kLPAREN);
   while (CurrentToken() != Token::kRPAREN) {
     if (IsIdentifier() && (LookaheadToken(1) == Token::kCOLON)) {
       // Named actual parameter.
       ConsumeToken();
       ConsumeToken();
     }
     SkipNestedExpr();
     if (CurrentToken() == Token::kCOMMA) {
       ConsumeToken();
     }
   }
   ExpectToken(Token::kRPAREN);
 }
 
-
 void Parser::SkipCompoundLiteral() {
   if (CurrentToken() == Token::kLT) {
     SkipTypeArguments();
   }
   if ((CurrentToken() == Token::kLBRACK) || (CurrentToken() == Token::kINDEX)) {
     SkipListLiteral();
   } else if (CurrentToken() == Token::kLBRACE) {
     SkipMapLiteral();
   }
 }
 
-
 void Parser::SkipSymbolLiteral() {
   ConsumeToken();  // Hash sign.
   if (IsIdentifier()) {
     ConsumeToken();
     while (CurrentToken() == Token::kPERIOD) {
       ConsumeToken();
       ExpectIdentifier("identifier expected");
     }
   } else if (Token::CanBeOverloaded(CurrentToken())) {
     ConsumeToken();
   } else {
     UnexpectedToken();
   }
 }
 
-
 void Parser::SkipNewOperator() {
   ConsumeToken();  // Skip new or const keyword.
   if (IsIdentifier()) {
     SkipType(false);
     if (CurrentToken() == Token::kPERIOD) {
       ConsumeToken();
       ExpectIdentifier("identifier expected");
     } else if (CurrentToken() == Token::kHASH) {
       ConsumeToken();
       if (IsIdentifier()) {
         ConsumeToken();
       }
       return;
     }
     if (CurrentToken() == Token::kLPAREN) {
       SkipActualParameters();
       return;
     }
   }
 }
 
-
 void Parser::SkipStringLiteral() {
   ASSERT(CurrentToken() == Token::kSTRING);
   while (CurrentToken() == Token::kSTRING) {
     ConsumeToken();
     while (true) {
       if (CurrentToken() == Token::kINTERPOL_VAR) {
         ConsumeToken();
       } else if (CurrentToken() == Token::kINTERPOL_START) {
         ConsumeToken();
         const bool saved_mode = SetAllowFunctionLiterals(true);
         SkipExpr();
         SetAllowFunctionLiterals(saved_mode);
         ExpectToken(Token::kINTERPOL_END);
       } else {
         break;
       }
     }
   }
 }
 
-
 void Parser::SkipPrimary() {
   if (IsFunctionLiteral()) {
     SkipFunctionLiteral();
     return;
   }
   switch (CurrentToken()) {
     case Token::kTHIS:
     case Token::kSUPER:
     case Token::kNULL:
     case Token::kTRUE:
@@ skipping 40 matching lines @@
       if (IsIdentifier()) {
         ConsumeToken();  // Handle pseudo-keyword identifiers.
       } else {
         UnexpectedToken();
         UNREACHABLE();
       }
       break;
   }
 }
 
-
 void Parser::SkipSelectors() {
   while (true) {
     const Token::Kind current_token = CurrentToken();
     if (current_token == Token::kCASCADE) {
       ConsumeToken();
       if (CurrentToken() == Token::kLBRACK) {
         continue;  // Consume [ in next loop iteration.
       } else {
         ExpectIdentifier("identifier or [ expected after ..");
       }
@@ skipping 25 matching lines @@
     } else {
       ReportError("identifier or operator expected");
     }
   }
   SkipSelectors();
   if (IsIncrementOperator(CurrentToken())) {
     ConsumeToken();
   }
 }
 
-
 void Parser::SkipUnaryExpr() {
   if (IsPrefixOperator(CurrentToken()) || IsIncrementOperator(CurrentToken()) ||
       IsAwaitKeyword()) {
     ConsumeToken();
     SkipUnaryExpr();
   } else {
     SkipPostfixExpr();
   }
 }
 
-
 void Parser::SkipBinaryExpr() {
   SkipUnaryExpr();
   const int min_prec = Token::Precedence(Token::kIFNULL);
   const int max_prec = Token::Precedence(Token::kMUL);
   while (((min_prec <= Token::Precedence(CurrentToken())) &&
           (Token::Precedence(CurrentToken()) <= max_prec))) {
     if (CurrentToken() == Token::kIS) {
       ConsumeToken();
       if (CurrentToken() == Token::kNOT) {
         ConsumeToken();
       }
       SkipTypeOrFunctionType(false);
     } else if (CurrentToken() == Token::kAS) {
       ConsumeToken();
       SkipTypeOrFunctionType(false);
     } else {
       ConsumeToken();
       SkipUnaryExpr();
     }
   }
 }
 
-
 void Parser::SkipConditionalExpr() {
   SkipBinaryExpr();
   if (CurrentToken() == Token::kCONDITIONAL) {
     ConsumeToken();
     SkipExpr();
     ExpectToken(Token::kCOLON);
     SkipExpr();
   }
 }
 
-
 void Parser::SkipExpr() {
   while (CurrentToken() == Token::kTHROW) {
     ConsumeToken();
   }
   SkipConditionalExpr();
   if (CurrentToken() == Token::kCASCADE) {
     SkipSelectors();
   }
   if (Token::IsAssignmentOperator(CurrentToken())) {
     ConsumeToken();
     SkipExpr();
   }
 }
 
-
 void Parser::SkipNestedExpr() {
   const bool saved_mode = SetAllowFunctionLiterals(true);
   SkipExpr();
   SetAllowFunctionLiterals(saved_mode);
 }
 
-
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart
 
-
 #else  // DART_PRECOMPILED_RUNTIME
 
-
 namespace dart {
 
 void ParsedFunction::AddToGuardedFields(const Field* field) const {
   UNREACHABLE();
 }
 
-
 kernel::ScopeBuildingResult* ParsedFunction::EnsureKernelScopes() {
   UNREACHABLE();
   return NULL;
 }
 
-
 LocalVariable* ParsedFunction::EnsureExpressionTemp() {
   UNREACHABLE();
   return NULL;
 }
 
-
 void ParsedFunction::SetNodeSequence(SequenceNode* node_sequence) {
   UNREACHABLE();
 }
 
-
 void ParsedFunction::SetRegExpCompileData(
     RegExpCompileData* regexp_compile_data) {
   UNREACHABLE();
 }
 
-
 void ParsedFunction::AllocateVariables() {
   UNREACHABLE();
 }
 
-
 void ParsedFunction::AllocateIrregexpVariables(intptr_t num_stack_locals) {
   UNREACHABLE();
 }
 
-
 void ParsedFunction::Bailout(const char* origin, const char* reason) const {
   UNREACHABLE();
 }
 
-
 void Parser::ParseCompilationUnit(const Library& library,
                                   const Script& script) {
   UNREACHABLE();
 }
 
-
 void Parser::ParseClass(const Class& cls) {
   UNREACHABLE();
 }
 
-
 RawObject* Parser::ParseFunctionParameters(const Function& func) {
   UNREACHABLE();
   return Object::null();
 }
 
-
 void Parser::ParseFunction(ParsedFunction* parsed_function) {
   UNREACHABLE();
 }
 
-
 RawObject* Parser::ParseMetadata(const Field& meta_data) {
   UNREACHABLE();
   return Object::null();
 }
 
-
 ParsedFunction* Parser::ParseStaticFieldInitializer(const Field& field) {
   UNREACHABLE();
   return NULL;
 }
 
-
 void Parser::InsertCachedConstantValue(const Script& script,
                                        TokenPosition token_pos,
                                        const Instance& value) {
   UNREACHABLE();
 }
 
-
 ArgumentListNode* Parser::BuildNoSuchMethodArguments(
     TokenPosition call_pos,
     const String& function_name,
     const ArgumentListNode& function_args,
     const LocalVariable* temp_for_last_arg,
     bool is_super_invocation) {
   UNREACHABLE();
   return NULL;
 }
 
 bool Parser::FieldHasFunctionLiteralInitializer(const Field& field,
                                                 TokenPosition* start,
                                                 TokenPosition* end) {
   UNREACHABLE();
   return false;
 }
 
-
 }  // namespace dart
 
 #endif  // DART_PRECOMPILED_RUNTIME