Cleanup: use const reference for ParsedFunction where possible.

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 "lib/invocation_mirror.h"
 #include "platform/utils.h"
 #include "vm/ast_transformer.h"
 #include "vm/bootstrap.h"
@@ skipping 343 matching lines @@
                                    parsed_function->function().Owner())),
       library_(Library::Handle(zone(), Class::Handle(
           zone(),
           parsed_function->function().origin()).library())),
       try_blocks_list_(NULL),
       last_used_try_index_(0),
       unregister_pending_function_(false),
       async_temp_scope_(NULL) {
   ASSERT(tokens_iterator_.IsValid());
   ASSERT(!current_function().IsNull());
-  if (FLAG_enable_type_checks) {
-    EnsureExpressionTemp();
-  }
+  EnsureExpressionTemp();
 }
 
 
 Parser::~Parser() {
   if (unregister_pending_function_) {
     const GrowableObjectArray& pending_functions =
         GrowableObjectArray::Handle(I->object_store()->pending_functions());
     ASSERT(pending_functions.Length() > 0);
     ASSERT(pending_functions.At(pending_functions.Length()-1) ==
         current_function().raw());
@@ skipping 7209 matching lines @@
   // while (await :for-in-iter.moveNext())
   ArgumentListNode* no_args = new(Z) ArgumentListNode(stream_pos);
   AstNode* iterator_moveNext = new(Z) InstanceCallNode(
       stream_pos,
       new(Z) LoadLocalNode(stream_pos, iterator_var),
                            Symbols::MoveNext(),
                            no_args);
   AstNode* await_moveNext = new (Z) AwaitNode(stream_pos, iterator_moveNext);
   OpenBlock();
   AwaitTransformer at(current_block_->statements,
-                      parsed_function(),
+                      *parsed_function(),
                       async_temp_scope_);
   AstNode* transformed_await = at.Transform(await_moveNext);
   SequenceNode* await_preamble = CloseBlock();
 
   // Parse the for loop body. Ideally, we would use ParseNestedStatement()
   // here, but that does not work well because we have to insert an implicit
   // variable assignment and potentially a variable declaration in the
   // loop body.
   OpenLoopBlock();
   SourceLabel* label =
@@ skipping 1673 matching lines @@
   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,
-                        parsed_function(),
+                        *parsed_function(),
                         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;
   }
@@ skipping 2925 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart