Store pointer instead of reference to LocalVariable in ast and flow graph.

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/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 691 matching lines @@
     const bool kTestOnly = true;
     if (parser.current_function().IsInFactoryScope()) {
       instantiator = parser.LookupTypeArgumentsParameter(node_sequence->scope(),
                                                          kTestOnly);
     } else {
       instantiator = parser.LookupReceiver(node_sequence->scope(), kTestOnly);
     }
     if (!parser.current_function().IsLocalFunction() ||
         ((instantiator != NULL) && instantiator->is_captured())) {
       parsed_function->set_instantiator(
-          new LoadLocalNode(node_sequence->token_pos(), *instantiator));
+          new LoadLocalNode(node_sequence->token_pos(), instantiator));
     }
   }
 
   parsed_function->set_default_parameter_values(default_parameter_values);
 }
 
 
 // TODO(regis): Implement support for non-const final static fields (currently
 // supported "final" fields are actually const fields).
 // TODO(regis): Since a const variable is implicitly final,
@@ skipping 121 matching lines @@
   ASSERT(func.num_fixed_parameters() == 1);  // receiver.
   ASSERT(func.num_optional_parameters() == 0);
   ASSERT(AbstractType::Handle(func.result_type()).IsResolved());
 
   // 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(TokenPos(), *receiver);
+  LoadLocalNode* load_receiver = new LoadLocalNode(TokenPos(), receiver);
   // TokenPos() returns the function's token position which points to the
   // name of the field;
   ASSERT(IsIdentifier());
   const String& field_name = *CurrentLiteral();
   const Class& field_class = Class::Handle(func.owner());
   const Field& field =
       Field::ZoneHandle(field_class.LookupInstanceField(field_name));
 
   LoadInstanceFieldNode* load_field =
       new LoadInstanceFieldNode(TokenPos(), load_receiver, field);
@@ skipping 27 matching lines @@
                            &field_type);
   ASSERT(func.num_fixed_parameters() == 2);  // receiver, value.
   ASSERT(func.num_optional_parameters() == 0);
   ASSERT(AbstractType::Handle(func.result_type()).IsVoidType());
 
   // Build local scope for function and populate with the formal parameters.
   OpenFunctionBlock(func);
   AddFormalParamsToScope(&params, current_block_->scope);
 
   LoadLocalNode* receiver =
-      new LoadLocalNode(TokenPos(), *current_block_->scope->VariableAt(0));
+      new LoadLocalNode(TokenPos(), current_block_->scope->VariableAt(0));
   LoadLocalNode* value =
-      new LoadLocalNode(TokenPos(), *current_block_->scope->VariableAt(1));
+      new LoadLocalNode(TokenPos(), current_block_->scope->VariableAt(1));
 
   StoreInstanceFieldNode* store_field =
       new StoreInstanceFieldNode(TokenPos(), receiver, field, value);
 
   current_block_->statements->Add(store_field);
   current_block_->statements->Add(new ReturnNode(TokenPos()));
   return CloseBlock();
 }
 
 
@@ skipping 404 matching lines @@
     ExpectToken(Token::kRBRACK);
 
     if (Token::IsAssignmentOperator(CurrentToken()) &&
         (CurrentToken() != Token::kASSIGN)) {
       // Compound assignment. Ensure side effects in index expression
       // only execute once. If the index is not a local variable or an
       // literal, evaluate and save in a temporary local.
       if (!IsSimpleLocalOrLiteralNode(index_expr)) {
         LocalVariable* temp =
             CreateTempConstVariable(operator_pos, "lix");
-        AstNode* save =
-            new StoreLocalNode(operator_pos, *temp, index_expr);
+        AstNode* save = new StoreLocalNode(operator_pos, temp, index_expr);
         current_block_->statements->Add(save);
-        index_expr = new LoadLocalNode(operator_pos, *temp);
+        index_expr = new LoadLocalNode(operator_pos, temp);
       }
     }
 
     // Resolve the [] operator function in the superclass.
     const String& index_operator_name =
         String::ZoneHandle(Symbols::IndexToken());
     bool is_no_such_method = false;
     const Function& index_operator = Function::ZoneHandle(
         GetSuperFunction(operator_pos,
                          index_operator_name,
@@ skipping 162 matching lines @@
   // 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() || (super_class.num_native_fields() > 0)) {
     return;
   }
   String& ctor_name = String::Handle(super_class.Name());
   String& ctor_suffix = String::Handle(Symbols::Dot());
   ctor_name = String::Concat(ctor_name, ctor_suffix);
   ArgumentListNode* arguments = new ArgumentListNode(supercall_pos);
   // Implicit 'this' parameter is the first argument.
-  AstNode* implicit_argument = new LoadLocalNode(supercall_pos, *receiver);
+  AstNode* implicit_argument = new LoadLocalNode(supercall_pos, receiver);
   arguments->Add(implicit_argument);
   // Implicit construction phase parameter is second argument.
   AstNode* phase_parameter =
       new LiteralNode(supercall_pos,
                       Smi::ZoneHandle(Smi::New(Function::kCtorPhaseAll)));
   arguments->Add(phase_parameter);
   const Function& super_ctor = Function::ZoneHandle(
       super_class.LookupConstructor(ctor_name));
   if (super_ctor.IsNull()) {
       ErrorMsg(supercall_pos,
@@ skipping 30 matching lines @@
     ctor_suffix = String::Concat(
         ctor_suffix, *ExpectIdentifier("constructor name expected"));
   }
   ctor_name = String::Concat(ctor_name, ctor_suffix);
   if (CurrentToken() != Token::kLPAREN) {
     ErrorMsg("parameter list expected");
   }
 
   ArgumentListNode* arguments = new ArgumentListNode(supercall_pos);
   // 'this' parameter is the first argument to super class constructor.
-  AstNode* implicit_argument = new LoadLocalNode(supercall_pos, *receiver);
+  AstNode* implicit_argument = new LoadLocalNode(supercall_pos, receiver);
   arguments->Add(implicit_argument);
   // Second implicit parameter is the construction phase. We optimistically
   // assume that we can execute both the super initializer and the super
   // constructor body. We may later change this to only execute the
   // super initializer.
   AstNode* phase_parameter =
       new LiteralNode(supercall_pos,
                       Smi::ZoneHandle(Smi::New(Function::kCtorPhaseAll)));
   arguments->Add(phase_parameter);
   // 'this' parameter must not be accessible to the other super call arguments.
@@ skipping 40 matching lines @@
   receiver->set_invisible(true);
   AstNode* init_expr = ParseConditionalExpr();
   receiver->set_invisible(false);
   SetAllowFunctionLiterals(saved_mode);
   Field& field = Field::ZoneHandle(cls.LookupInstanceField(field_name));
   if (field.IsNull()) {
     ErrorMsg(field_pos, "unresolved reference to instance field '%s'",
              field_name.ToCString());
   }
   CheckDuplicateFieldInit(field_pos, initialized_fields, &field);
-  AstNode* instance = new LoadLocalNode(field_pos, *receiver);
+  AstNode* instance = new LoadLocalNode(field_pos, receiver);
   return new StoreInstanceFieldNode(field_pos, instance, field, init_expr);
 }
 
 
 void Parser::CheckConstFieldsInitialized(const Class& cls) {
   const Array& fields = Array::Handle(cls.fields());
   Field& field = Field::Handle();
   SequenceNode* initializers = current_block_->statements;
   for (int field_num = 0; field_num < fields.Length(); field_num++) {
     field ^= fields.At(field_num);
@@ skipping 134 matching lines @@
     ctor_suffix = String::Concat(
         ctor_suffix, *ExpectIdentifier("constructor name expected"));
   }
   ctor_name = String::Concat(ctor_name, ctor_suffix);
   if (CurrentToken() != Token::kLPAREN) {
     ErrorMsg("parameter list expected");
   }
 
   ArgumentListNode* arguments = new ArgumentListNode(call_pos);
   // 'this' parameter is the first argument to constructor.
-  AstNode* implicit_argument = new LoadLocalNode(call_pos, *receiver);
+  AstNode* implicit_argument = new LoadLocalNode(call_pos, receiver);
   arguments->Add(implicit_argument);
   // Construction phase parameter is second argument.
   LocalVariable* phase_param = LookupPhaseParameter();
   ASSERT(phase_param != NULL);
-  AstNode* phase_argument = new LoadLocalNode(call_pos, *phase_param);
+  AstNode* phase_argument = new LoadLocalNode(call_pos, phase_param);
   arguments->Add(phase_argument);
   ParseActualParameters(arguments, kAllowConst);
 
   // Resolve the constructor.
   const Function& redirect_ctor = Function::ZoneHandle(
       cls.LookupConstructor(ctor_name));
   if (redirect_ctor.IsNull()) {
     ErrorMsg(call_pos, "constructor '%s' not found", ctor_name.ToCString());
   }
   String& error_message = String::Handle();
@@ skipping 34 matching lines @@
   LocalVariable* phase_parameter = new LocalVariable(
        ctor_pos,
        String::ZoneHandle(Symbols::PhaseParameter()),
        Type::ZoneHandle(Type::IntInterface()));
   current_block_->scope->AddVariable(phase_parameter);
 
   // Now that the "this" parameter is in scope, we can generate the code
   // to strore the initializer expressions in the respective instance fields.
   for (int i = 0; i < initializers.length(); i++) {
     const Field* field = initializers[i].inst_field;
-    AstNode* instance = new LoadLocalNode(field->token_pos(), *receiver);
+    AstNode* instance = new LoadLocalNode(field->token_pos(), receiver);
     AstNode* field_init =
         new StoreInstanceFieldNode(field->token_pos(),
                                    instance,
                                    *field,
                                    initializers[i].expr);
     current_block_->statements->Add(field_init);
   }
 
   GenerateSuperConstructorCall(cls, receiver);
   CheckConstFieldsInitialized(cls);
@@ skipping 67 matching lines @@
   AddFormalParamsToScope(&params, current_block_->scope);
   LocalVariable* receiver = current_block_->scope->VariableAt(0);
 
   // Now that the "this" parameter is in scope, we can generate the code
   // to store the initializer expressions in the respective instance fields.
   // We do this before the field parameters and the initializers from the
   // constructor's initializer list get compiled.
   OpenBlock();
   for (int i = 0; i < initializers.length(); i++) {
     const Field* field = initializers[i].inst_field;
-    AstNode* instance = new LoadLocalNode(field->token_pos(), *receiver);
+    AstNode* instance = new LoadLocalNode(field->token_pos(), receiver);
     AstNode* field_init =
         new StoreInstanceFieldNode(field->token_pos(),
                                    instance,
                                    *field,
                                    initializers[i].expr);
     current_block_->statements->Add(field_init);
   }
 
   // Turn formal field parameters into field initializers or report error
   // if the function is not a constructor.
   if (params.has_field_initializer) {
     for (int i = 0; i < params.parameters->length(); i++) {
       ParamDesc& param = (*params.parameters)[i];
       if (param.is_field_initializer) {
         const String& field_name = *param.name;
         Field& field = Field::ZoneHandle(cls.LookupInstanceField(field_name));
         if (field.IsNull()) {
           ErrorMsg(param.name_pos,
                    "unresolved reference to instance field '%s'",
                    field_name.ToCString());
         }
         CheckDuplicateFieldInit(param.name_pos, &initialized_fields, &field);
-        AstNode* instance = new LoadLocalNode(param.name_pos, *receiver);
+        AstNode* instance = new LoadLocalNode(param.name_pos, receiver);
         LocalVariable* p =
             current_block_->scope->LookupVariable(*param.name, false);
         ASSERT(p != NULL);
         // Initializing formals cannot be used in the explicit initializer
         // list, nor can they be used in the constructor body.
         // Thus, make the parameter invisible.
         p->set_invisible(true);
-        AstNode* value = new LoadLocalNode(param.name_pos, *p);
+        AstNode* value = new LoadLocalNode(param.name_pos, p);
         AstNode* initializer = new StoreInstanceFieldNode(
             param.name_pos, instance, field, value);
         current_block_->statements->Add(initializer);
       }
     }
   }
 
   // Now parse the explicit initializer list or constructor redirection.
   ParseInitializers(cls, receiver, &initialized_fields);
 
   SequenceNode* init_statements = CloseBlock();
   if (init_statements->length() > 0) {
     // Generate guard around the initializer code.
     LocalVariable* phase_param = LookupPhaseParameter();
-    AstNode* phase_value = new LoadLocalNode(TokenPos(), *phase_param);
+    AstNode* phase_value = new LoadLocalNode(TokenPos(), phase_param);
     AstNode* phase_check = new BinaryOpNode(
         TokenPos(), Token::kBIT_AND, phase_value,
         new LiteralNode(TokenPos(),
                         Smi::ZoneHandle(Smi::New(Function::kCtorPhaseInit))));
     AstNode* comparison =
         new ComparisonNode(TokenPos(), Token::kNE_STRICT,
                            phase_check,
                            new LiteralNode(TokenPos(),
                                            Smi::ZoneHandle(Smi::New(0))));
     AstNode* guarded_init_statements =
@@ skipping 29 matching lines @@
     // expressions are not evaluated twice.
     ArgumentListNode* ctor_args = super_call->arguments();
     // The super initializer call has at least 2 arguments: the
     // implicit receiver, and the hidden construction phase.
     ASSERT(ctor_args->length() >= 2);
     for (int i = 2; i < ctor_args->length(); i++) {
       AstNode* arg = ctor_args->NodeAt(i);
       if (!IsSimpleLocalOrLiteralNode(arg)) {
         LocalVariable* temp =
             CreateTempConstVariable(arg->token_pos(), "sca");
-        AstNode* save_temp =
-            new StoreLocalNode(arg->token_pos(), *temp, arg);
+        AstNode* save_temp = new StoreLocalNode(arg->token_pos(), temp, arg);
         ctor_args->SetNodeAt(i, save_temp);
       }
     }
   }
   OpenBlock();  // Block to collect constructor body nodes.
 
   // Insert the implicit super call to the super constructor body.
   if (super_call != NULL) {
     ArgumentListNode* initializer_args = super_call->arguments();
     const Function& super_ctor = super_call->function();
     // Patch the initializer call so it only executes the super initializer.
     initializer_args->SetNodeAt(1,
                         new LiteralNode(TokenPos(),
                         Smi::ZoneHandle(Smi::New(Function::kCtorPhaseInit))));
 
     ArgumentListNode* super_call_args = new ArgumentListNode(TokenPos());
     // First argument is the receiver.
-    super_call_args->Add(new LoadLocalNode(TokenPos(), *receiver));
+    super_call_args->Add(new LoadLocalNode(TokenPos(), receiver));
     // Second argument is the construction phase argument.
     AstNode* phase_parameter =
         new LiteralNode(TokenPos(),
                         Smi::ZoneHandle(Smi::New(Function::kCtorPhaseBody)));
     super_call_args->Add(phase_parameter);
     super_call_args->set_names(initializer_args->names());
     for (int i = 2; i < initializer_args->length(); i++) {
       AstNode* arg = initializer_args->NodeAt(i);
       if (arg->IsLiteralNode()) {
         LiteralNode* lit = arg->AsLiteralNode();
         super_call_args->Add(new LiteralNode(TokenPos(), lit->literal()));
       } else {
         ASSERT(arg->IsLoadLocalNode() || arg->IsStoreLocalNode());
         if (arg->IsLoadLocalNode()) {
           const LocalVariable& temp = arg->AsLoadLocalNode()->local();
-          super_call_args->Add(new LoadLocalNode(TokenPos(), temp));
+          super_call_args->Add(new LoadLocalNode(TokenPos(), &temp));
         } else if (arg->IsStoreLocalNode()) {
           const LocalVariable& temp = arg->AsStoreLocalNode()->local();
-          super_call_args->Add(new LoadLocalNode(TokenPos(), temp));
+          super_call_args->Add(new LoadLocalNode(TokenPos(), &temp));
         }
       }
     }
     ASSERT(super_ctor.AreValidArguments(super_call_args->length(),
                                         super_call_args->names(),
                                         NULL));
     current_block_->statements->Add(
         new StaticCallNode(TokenPos(), super_ctor, super_call_args));
   }
 
   if (CurrentToken() == Token::kLBRACE) {
     ConsumeToken();
     ParseStatementSequence();
     ExpectToken(Token::kRBRACE);
   } else if (CurrentToken() == Token::kARROW) {
     ErrorMsg("constructors may not return a value");
   } else if (IsLiteral("native")) {
     ErrorMsg("native constructors not supported");
   } else if (CurrentToken() == Token::kSEMICOLON) {
     // Some constructors have no function body.
     ConsumeToken();
   } else {
     UnexpectedToken();
   }
 
   SequenceNode* ctor_block = CloseBlock();
   if (ctor_block->length() > 0) {
     // Generate guard around the constructor body code.
     LocalVariable* phase_param = LookupPhaseParameter();
-    AstNode* phase_value = new LoadLocalNode(TokenPos(), *phase_param);
+    AstNode* phase_value = new LoadLocalNode(TokenPos(), phase_param);
     AstNode* phase_check =
         new BinaryOpNode(TokenPos(), Token::kBIT_AND,
             phase_value,
             new LiteralNode(TokenPos(),
                 Smi::ZoneHandle(Smi::New(Function::kCtorPhaseBody))));
     AstNode* comparison =
        new ComparisonNode(TokenPos(), Token::kNE_STRICT,
                          phase_check,
                          new LiteralNode(TokenPos(),
                                          Smi::ZoneHandle(Smi::New(0))));
@@ skipping 2099 matching lines @@
 
 
 AstNode* Parser::LoadReceiver(intptr_t 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) {
     ErrorMsg(token_pos, "illegal implicit access to receiver 'this'");
   }
-  return new LoadLocalNode(TokenPos(), *receiver);
+  return new LoadLocalNode(TokenPos(), receiver);
 }
 
 
 AstNode* Parser::LoadTypeArgumentsParameter(intptr_t token_pos) {
   // A nested function may access ':type_arguments' to use as instantiator,
   // referring to the implicit first parameter of the outermost enclosing
   // factory function.
   const bool kTestOnly = false;
   LocalVariable* param = LookupTypeArgumentsParameter(current_block_->scope,
                                                       kTestOnly);
   ASSERT(param != NULL);
-  return new LoadLocalNode(TokenPos(), *param);
+  return new LoadLocalNode(TokenPos(), param);
 }
 
 
 AstNode* Parser::CallGetter(intptr_t token_pos,
                             AstNode* object,
                             const String& name) {
   return new InstanceGetterNode(TokenPos(), object, name);
 }
 
 
 // Returns ast nodes of the variable initialization.
 AstNode* Parser::ParseVariableDeclaration(const AbstractType& type,
                                           bool is_final,
                                           bool is_const) {
   TRACE_PARSER("ParseVariableDeclaration");
   ASSERT(IsIdentifier());
   const intptr_t ident_pos = TokenPos();
   LocalVariable* variable =
       new LocalVariable(ident_pos, *CurrentLiteral(), type);
   ASSERT(current_block_ != NULL);
   ASSERT(current_block_->scope != NULL);
   ConsumeToken();  // Variable identifier.
   AstNode* initialization = NULL;
   if (CurrentToken() == Token::kASSIGN) {
     // Variable initialization.
     const intptr_t assign_pos = TokenPos();
     ConsumeToken();
     AstNode* expr = ParseExpr(is_const, kConsumeCascades);
-    initialization = new StoreLocalNode(assign_pos, *variable, expr);
+    initialization = new StoreLocalNode(assign_pos, variable, expr);
   } else if (is_final || is_const) {
     ErrorMsg(ident_pos,
     "missing initialization of 'final' or 'const' variable");
   } else {
     // Initialize variable with null.
     AstNode* null_expr = new LiteralNode(ident_pos, Instance::ZoneHandle());
-    initialization = new StoreLocalNode(ident_pos, *variable, null_expr);
+    initialization = new StoreLocalNode(ident_pos, variable, null_expr);
   }
   // Add variable to scope after parsing the initalizer expression.
   // The expression must not be able to refer to the variable.
   if (!current_block_->scope->AddVariable(variable)) {
     ErrorMsg(ident_pos, "identifier '%s' already defined",
              variable->name().ToCString());
   }
   if (is_final || is_const) {
     variable->set_is_final();
   }
@@ skipping 255 matching lines @@
   // This pruning is done by omitting to hook the local scope in its parent
   // scope in the constructor of LocalScope.
   AstNode* closure =
       new ClosureNode(ident_pos, function, NULL, statements->scope());
 
   if (function_variable == NULL) {
     ASSERT(is_literal);
     return closure;
   } else {
     AstNode* initialization =
-        new StoreLocalNode(ident_pos, *function_variable, closure);
+        new StoreLocalNode(ident_pos, function_variable, closure);
     return initialization;
   }
 }
 
 
 // Returns true if the current and next tokens can be parsed as type
 // parameters. Current token position is not saved and restored.
 bool Parser::TryParseTypeParameter() {
   if (CurrentToken() == Token::kLT) {
     // We are possibly looking at type parameters. Find closing ">".
@@ skipping 362 matching lines @@
   SequenceNode* case_expressions = new SequenceNode(case_pos, NULL);
   while (CurrentToken() == Token::kCASE || CurrentToken() == Token::kDEFAULT) {
     if (CurrentToken() == Token::kCASE) {
       if (default_seen) {
         ErrorMsg("default clause must be last case");
       }
       ConsumeToken();  // Keyword case.
       const intptr_t expr_pos = TokenPos();
       AstNode* expr = ParseExpr(kAllowConst, kConsumeCascades);
       AstNode* switch_expr_load = new LoadLocalNode(case_pos,
-                                                    *switch_expr_value);
+                                                    switch_expr_value);
       AstNode* case_comparison = new ComparisonNode(expr_pos,
                                                     Token::kEQ,
                                                     expr,
                                                     switch_expr_load);
       case_expressions->Add(case_comparison);
     } else {
       if (default_seen) {
         ErrorMsg("only one default clause is allowed");
       }
       ConsumeToken();  // Keyword default.
@@ skipping 70 matching lines @@
   OpenBlock();
   current_block_->scope->AddLabel(label);
 
   // Store switch expression in temporary local variable.
   LocalVariable* temp_variable =
       new LocalVariable(expr_pos,
                         String::ZoneHandle(Symbols::New(":switch_expr")),
                         Type::ZoneHandle(Type::DynamicType()));
   current_block_->scope->AddVariable(temp_variable);
   AstNode* save_switch_expr =
-      new StoreLocalNode(expr_pos, *temp_variable, switch_expr);
+      new StoreLocalNode(expr_pos, temp_variable, switch_expr);
   current_block_->statements->Add(save_switch_expr);
 
   // Parse case clauses
   bool default_seen = false;
   while (true) {
     // Check for statement label
     SourceLabel* case_label = NULL;
     if (IsIdentifier() && LookaheadToken(1) == Token::kCOLON) {
       // Case statements start with a label.
       String* label_name = CurrentLiteral();
@@ skipping 124 matching lines @@
       new LocalVariable(collection_pos, iterator_name, iterator_type);
   current_block_->scope->AddVariable(iterator_var);
 
   // Generate initialization of iterator variable.
   const String& iterator_method_name =
       String::ZoneHandle(Symbols::GetIterator());
   ArgumentListNode* no_args = new ArgumentListNode(collection_pos);
   AstNode* get_iterator = new InstanceCallNode(
       collection_pos, collection_expr, iterator_method_name, no_args);
   AstNode* iterator_init =
-      new StoreLocalNode(collection_pos, *iterator_var, get_iterator);
+      new StoreLocalNode(collection_pos, iterator_var, get_iterator);
   current_block_->statements->Add(iterator_init);
 
   // Generate while loop condition.
   AstNode* iterator_has_next = new InstanceCallNode(
       collection_pos,
-      new LoadLocalNode(collection_pos, *iterator_var),
+      new LoadLocalNode(collection_pos, iterator_var),
       String::ZoneHandle(Symbols::HasNext()),
       no_args);
 
   // 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();
   current_block_->scope->AddLabel(label);
 
   AstNode* iterator_next = new InstanceCallNode(
       collection_pos,
-      new LoadLocalNode(collection_pos, *iterator_var),
+      new LoadLocalNode(collection_pos, iterator_var),
       String::ZoneHandle(Symbols::Next()),
       no_args);
 
   // Generate assignment of next iterator value to loop variable.
   AstNode* loop_var_assignment = NULL;
   if (loop_var != NULL) {
     // The for loop declares a new variable. Add it to the loop body scope.
     current_block_->scope->AddVariable(loop_var);
     loop_var_assignment =
-        new StoreLocalNode(loop_var_pos, *loop_var, iterator_next);
+        new StoreLocalNode(loop_var_pos, loop_var, iterator_next);
   } else {
     AstNode* loop_var_primary =
         ResolveIdent(loop_var_pos, *loop_var_name, false);
     ASSERT(!loop_var_primary->IsPrimaryNode());
     loop_var_assignment =
         CreateAssignmentNode(loop_var_primary, iterator_next);
     if (loop_var_assignment == NULL) {
       ErrorMsg(loop_var_pos, "variable or field '%s' is not assignable",
                loop_var_name->ToCString());
     }
@@ skipping 390 matching lines @@
     OpenBlock();
 
     // Generate code to load the exception object (:exception_var) into
     // the exception variable specified in this block.
     ASSERT(exception_param.var != NULL);
     LocalVariable* var = LookupLocalScope(*exception_param.var);
     ASSERT(var != NULL);
     ASSERT(catch_excp_var != NULL);
     current_block_->statements->Add(
         new StoreLocalNode(catch_pos,
-                           *var,
-                           new LoadLocalNode(catch_pos, *catch_excp_var)));
+                           var,
+                           new LoadLocalNode(catch_pos, catch_excp_var)));
     if (stack_trace_param.var != NULL) {
       // A stack trace variable is specified in this block, so generate code
       // to load the stack trace object (:stacktrace_var) into the stack trace
       // variable specified in this block.
       LocalVariable* trace = LookupLocalScope(*stack_trace_param.var);
       ASSERT(catch_trace_var != NULL);
       current_block_->statements->Add(
           new StoreLocalNode(catch_pos,
-                             *trace,
-                             new LoadLocalNode(catch_pos, *catch_trace_var)));
+                             trace,
+                             new LoadLocalNode(catch_pos, catch_trace_var)));
     }
 
     ParseStatementSequence();  // Parse the catch handler code.
     current_block_->statements->Add(
         new JumpNode(catch_pos, Token::kCONTINUE, end_catch_label));
     SequenceNode* catch_handler = CloseBlock();
     ExpectToken(Token::kRBRACE);
 
     if (!exception_param.type->IsDynamicType()) {  // Has a type specification.
       // Now form an 'if type check' as an exception type exists in
       // the catch specifier.
       if (!exception_param.type->IsInstantiated() &&
           (current_block_->scope->function_level() > 0)) {
         // Make sure that the instantiator is captured.
         CaptureInstantiator();
       }
       TypeNode* exception_type = new TypeNode(catch_pos, *exception_param.type);
-      AstNode* exception_var = new LoadLocalNode(catch_pos, *catch_excp_var);
+      AstNode* exception_var = new LoadLocalNode(catch_pos, catch_excp_var);
       if (!exception_type->type().IsInstantiated()) {
         EnsureExpressionTemp();
       }
       AstNode* type_cond_expr = new ComparisonNode(
           catch_pos, Token::kIS, exception_var, exception_type);
       current_block_->statements->Add(
           new IfNode(catch_pos, type_cond_expr, catch_handler, NULL));
     } else {
       // No exception type exists in the catch specifier so execute the
       // catch handler code unconditionally.
@@ skipping 15 matching lines @@
     ConsumeToken();  // Consume the 'finally'.
     const intptr_t finally_pos = TokenPos();
     // Add the finally block to the exit points recorded so far.
     intptr_t node_index = 0;
     AstNode* node_to_inline =
         inner_try_block->GetNodeToInlineFinally(node_index);
     while (node_to_inline != NULL) {
       finally_block = ParseFinallyBlock();
       InlinedFinallyNode* node = new InlinedFinallyNode(finally_pos,
                                                         finally_block,
-                                                        *context_var);
+                                                        context_var);
       AddFinallyBlockToNode(node_to_inline, node);
       node_index += 1;
       node_to_inline = inner_try_block->GetNodeToInlineFinally(node_index);
       tokens_iterator_.SetCurrentPosition(finally_pos);
     }
     if (!generic_catch_seen) {
       // No generic catch handler exists so execute this finally block
       // before rethrowing the exception.
       finally_block = ParseFinallyBlock();
       catch_handler_list->Add(finally_block);
       tokens_iterator_.SetCurrentPosition(finally_pos);
     }
     finally_block = ParseFinallyBlock();
   } else {
     if (!catch_seen) {
       ErrorMsg("'catch' or 'finally' expected");
     }
   }
 
   if (!generic_catch_seen) {
     // No generic catch handler exists so rethrow the exception so that
     // the next catch handler can deal with it.
     catch_handler_list->Add(
         new ThrowNode(handler_pos,
-                      new LoadLocalNode(handler_pos, *catch_excp_var),
-                      new LoadLocalNode(handler_pos, *catch_trace_var)));
+                      new LoadLocalNode(handler_pos, catch_excp_var),
+                      new LoadLocalNode(handler_pos, catch_trace_var)));
   }
   CatchClauseNode* catch_block = new CatchClauseNode(handler_pos,
                                                      catch_handler_list,
-                                                     *context_var,
-                                                     *catch_excp_var,
-                                                     *catch_trace_var);
+                                                     context_var,
+                                                     catch_excp_var,
+                                                     catch_trace_var);
 
   // Now create the try/catch ast node and return it. If there is a label
   // on the try/catch, close the block that's embedding the try statement
   // and attach the label to it.
   AstNode* try_catch_node =
       new TryCatchNode(try_pos, try_block, end_catch_label,
-                       *context_var, catch_block, finally_block);
+                       context_var, catch_block, finally_block);
 
   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;
 }
 
@@ skipping 166 matching lines @@
       ASSERT(label->owner() != NULL);
       LocalScope* scope = label->owner()->parent();
       ASSERT(scope != NULL);
       LocalVariable* excp_var = scope->LocalLookupVariable(
           String::ZoneHandle(Symbols::ExceptionVar()));
       ASSERT(excp_var != NULL);
       LocalVariable* trace_var = scope->LocalLookupVariable(
           String::ZoneHandle(Symbols::StacktraceVar()));
       ASSERT(trace_var != NULL);
       statement = new ThrowNode(statement_pos,
-                                new LoadLocalNode(statement_pos, *excp_var),
-                                new LoadLocalNode(statement_pos, *trace_var));
+                                new LoadLocalNode(statement_pos, excp_var),
+                                new LoadLocalNode(statement_pos, trace_var));
     }
   } else {
     statement = ParseExpr(kAllowConst, kConsumeCascades);
     ExpectSemicolon();
   }
   return statement;
 }
 
 
 RawError* Parser::FormatErrorWithAppend(const Error& prev_error,
@@ skipping 371 matching lines @@
       ConsumeToken();
       AstNode* expr = ParseExpr(kAllowConst, kConsumeCascades);
       list->Add(expr);
     }
     expressions = list;
   }
   return expressions;
 }
 
 
-const LocalVariable& Parser::GetIncrementTempLocal() {
+const LocalVariable* Parser::GetIncrementTempLocal() {
   if (expression_temp_ == NULL) {
     expression_temp_ = ParsedFunction::CreateExpressionTempVar(
         current_function().token_pos());
+    ASSERT(expression_temp_ != NULL);
   }
-  return *expression_temp_;
+  return expression_temp_;
 }
 
 
 void Parser::EnsureExpressionTemp() {
   // Temporary used later by the flow_graph_builder.
   GetIncrementTempLocal();
 }
 
 
 LocalVariable* Parser::CreateTempConstVariable(intptr_t token_pos,
@@ skipping 98 matching lines @@
   AstNode* node = *expr;
   if (node->IsLoadIndexedNode()) {
     LoadIndexedNode* left_node = node->AsLoadIndexedNode();
     LoadIndexedNode* right_node = left_node;
     intptr_t token_pos = node->token_pos();
     node = NULL;  // Do not use it.
     if (!IsSimpleLocalOrLiteralNode(left_node->array())) {
       LocalVariable* temp =
           CreateTempConstVariable(token_pos, "lia");
       StoreLocalNode* save =
-          new StoreLocalNode(token_pos, *temp, left_node->array());
+          new StoreLocalNode(token_pos, temp, left_node->array());
       left_node =
           new LoadIndexedNode(token_pos, save, left_node->index_expr());
       right_node = new LoadIndexedNode(token_pos,
-                                       new LoadLocalNode(token_pos, *temp),
+                                       new LoadLocalNode(token_pos, temp),
                                        right_node->index_expr());
     }
     if (!IsSimpleLocalOrLiteralNode(left_node->index_expr())) {
       LocalVariable* temp =
           CreateTempConstVariable(token_pos, "lix");
       StoreLocalNode* save =
-          new StoreLocalNode(token_pos, *temp, left_node->index_expr());
+          new StoreLocalNode(token_pos, temp, left_node->index_expr());
       left_node = new LoadIndexedNode(token_pos,
                                       left_node->array(),
                                       save);
       right_node = new LoadIndexedNode(token_pos,
                                        right_node->array(),
-                                       new LoadLocalNode(token_pos, *temp));
+                                       new LoadLocalNode(token_pos, temp));
     }
     *expr = right_node;
     return left_node;
   }
   if (node->IsInstanceGetterNode()) {
     InstanceGetterNode* left_node = node->AsInstanceGetterNode();
     InstanceGetterNode* right_node = left_node;
     intptr_t token_pos = node->token_pos();
     node = NULL;  // Do not use it.
     if (!IsSimpleLocalOrLiteralNode(left_node->receiver())) {
       LocalVariable* temp =
           CreateTempConstVariable(token_pos, "igr");
       StoreLocalNode* save =
-          new StoreLocalNode(token_pos, *temp, left_node->receiver());
+          new StoreLocalNode(token_pos, temp, left_node->receiver());
       left_node = new InstanceGetterNode(token_pos,
                                          save,
                                          left_node->field_name());
       right_node = new InstanceGetterNode(token_pos,
-                                          new LoadLocalNode(token_pos, *temp),
+                                          new LoadLocalNode(token_pos, temp),
                                           right_node->field_name());
     }
     *expr = right_node;
     return left_node;
   }
   return *expr;
 }
 
 
 // Ensure that the expression temp is allocated for nodes that may need it.
 AstNode* Parser::CreateAssignmentNode(AstNode* original, AstNode* rhs) {
   AstNode* result = original->MakeAssignmentNode(rhs);
   if ((result != NULL) &&
       (result->IsStoreIndexedNode() ||
        result->IsInstanceSetterNode() ||
        result->IsStaticSetterNode())) {
     EnsureExpressionTemp();
   }
   return result;
 }
 
 
 AstNode* Parser::ParseCascades(AstNode* expr) {
   intptr_t cascade_pos = TokenPos();
   LocalVariable* cascade_receiver_var =
       CreateTempConstVariable(cascade_pos, "casc");
   StoreLocalNode* save_cascade =
-      new StoreLocalNode(cascade_pos, *cascade_receiver_var, expr);
+      new StoreLocalNode(cascade_pos, cascade_receiver_var, expr);
   current_block_->statements->Add(save_cascade);
   while (CurrentToken() == Token::kCASCADE) {
     cascade_pos = TokenPos();
     LoadLocalNode* load_cascade_receiver =
-        new LoadLocalNode(cascade_pos, *cascade_receiver_var);
+        new LoadLocalNode(cascade_pos, cascade_receiver_var);
     if (Token::IsIdentifier(LookaheadToken(1))) {
       // Replace .. with . for ParseSelectors().
       token_kind_ = Token::kPERIOD;
     } else if (LookaheadToken(1) == Token::kLBRACK) {
       ConsumeToken();
     } else {
       ErrorMsg("identifier or [ expected after ..");
     }
     expr = ParseSelectors(load_cascade_receiver, true);
 
@@ skipping 16 matching lines @@
       if (assign_expr == NULL) {
         ErrorMsg(assignment_pos,
                  "left hand side of '%s' is not assignable",
                  Token::Str(assignment_op));
       }
       expr = assign_expr;
     }
     current_block_->statements->Add(expr);
   }
   // Result of the cascade is the receiver.
-  return new LoadLocalNode(cascade_pos, *cascade_receiver_var);
+  return new LoadLocalNode(cascade_pos, cascade_receiver_var);
 }
 
 
 AstNode* Parser::ParseExpr(bool require_compiletime_const,
                            bool consume_cascades) {
   TRACE_PARSER("ParseExpr");
   const intptr_t expr_pos = TokenPos();
   AstNode* expr = ParseConditionalExpr();
   if (!Token::IsAssignmentOperator(CurrentToken())) {
     if ((CurrentToken() == Token::kCASCADE) && consume_cascades) {
@@ skipping 537 matching lines @@
   postfix_expr = ParseSelectors(postfix_expr, false);
   if (IsIncrementOperator(CurrentToken())) {
     TRACE_PARSER("IncrementOperator");
     Token::Kind incr_op = CurrentToken();
     if (!IsAssignableExpr(postfix_expr)) {
       ErrorMsg("expression is not assignable");
     }
     ConsumeToken();
     // Not prefix.
     AstNode* left_expr = PrepareCompoundAssignmentNodes(&postfix_expr);
-    const LocalVariable& temp = GetIncrementTempLocal();
+    const LocalVariable* temp = GetIncrementTempLocal();
     AstNode* save =
         new StoreLocalNode(postfix_expr_pos, temp, postfix_expr);
     Token::Kind binary_op =
         (incr_op == Token::kINCR) ? Token::kADD : Token::kSUB;
     BinaryOpNode* add = new BinaryOpNode(
         postfix_expr_pos,
         binary_op,
         save,
         new LiteralNode(postfix_expr_pos, Smi::ZoneHandle(Smi::New(1))));
     AstNode* store = CreateAssignmentNode(left_expr, add);
@@ skipping 293 matching lines @@
 // If node is non NULL return an AST node corresponding to the identifier.
 bool Parser::ResolveIdentInLocalScope(intptr_t ident_pos,
                                       const String &ident,
                                       AstNode** node) {
   TRACE_PARSER("ResolveIdentInLocalScope");
   Isolate* isolate = Isolate::Current();
   // First try to find the identifier in the nested local scopes.
   LocalVariable* local = LookupLocalScope(ident);
   if (local != NULL) {
     if (node != NULL) {
-      *node = new LoadLocalNode(ident_pos, *local);
+      *node = new LoadLocalNode(ident_pos, local);
     }
     return true;
   }
 
   // Try to find the identifier in the class scope of the current class.
   Class& cls = Class::Handle(isolate, current_class().raw());
   Function& func = Function::Handle(isolate, Function::null());
   Field& field = Field::Handle(isolate, Field::null());
 
   // First check if a field exists.
@@ skipping 483 matching lines @@
     ArgumentListNode* arguments) {
   if (!type_arguments.IsNull() && !type_arguments.IsInstantiated()) {
     EnsureExpressionTemp();
   }
   LocalVariable* allocated =
       CreateTempConstVariable(token_pos, "alloc");
   return new ConstructorCallNode(token_pos,
                                  type_arguments,
                                  constructor,
                                  arguments,
-                                 *allocated);
+                                 allocated);
 }
 
 
 static void AddKeyValuePair(ArrayNode* pairs,
                             bool is_const,
                             AstNode* key,
                             AstNode* value) {
   if (is_const) {
     ASSERT(key->IsLiteralNode());
     ASSERT(key->AsLiteralNode()->literal().IsString());
@@ skipping 679 matching lines @@
       primary = ResolveIdentInLibraryPrefixScope(*(qual_ident.lib_prefix),
                                                  qual_ident);
     }
     ASSERT(primary != NULL);
   } else if (CurrentToken() == Token::kTHIS) {
     const String& this_name = String::Handle(Symbols::This());
     LocalVariable* local = LookupLocalScope(this_name);
     if (local == NULL) {
       ErrorMsg("receiver 'this' is not in scope");
     }
-    primary = new LoadLocalNode(TokenPos(), *local);
+    primary = new LoadLocalNode(TokenPos(), local);
     ConsumeToken();
   } else if (CurrentToken() == Token::kINTEGER) {
     const Integer& literal = Integer::ZoneHandle(CurrentIntegerLiteral());
     primary = new LiteralNode(TokenPos(), literal);
     ConsumeToken();
   } else if (CurrentToken() == Token::kTRUE) {
     primary = new LiteralNode(TokenPos(), Bool::ZoneHandle(Bool::True()));
     ConsumeToken();
   } else if (CurrentToken() == Token::kFALSE) {
     primary = new LiteralNode(TokenPos(), Bool::ZoneHandle(Bool::False()));
@@ skipping 346 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart