Address comments from Matthias on previous CL

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 6591 matching lines @@
   LocalVariable* saved_stack_trace_var =
       try_scope->LocalLookupVariable(Symbols::SavedStackTraceVar());
   SaveExceptionAndStackTrace(current_block_->statements, exception_var,
                              stack_trace_var, saved_exception_var,
                              saved_stack_trace_var);
 
   // Catch block: add the error to the stream.
   // :controller.AddError(:exception, :stack_trace);
   // return;  // The finally block will close the stream.
   LocalVariable* controller =
-      current_block_->scope->LookupVariable(Symbols::Controller(), false);
+      current_block_->scope->LookupVariable(Symbols::ColonController(), false);
   ASSERT(controller != NULL);
   ArgumentListNode* args = new (Z) ArgumentListNode(TokenPosition::kNoSource);
   args->Add(new (Z)
                 LoadLocalNode(TokenPosition::kNoSource, exception_param.var));
   args->Add(new (Z)
                 LoadLocalNode(TokenPosition::kNoSource, stack_trace_param.var));
   current_block_->statements->Add(new (Z) InstanceCallNode(
       try_end_pos, new (Z) LoadLocalNode(TokenPosition::kNoSource, controller),
       Symbols::AddError(), args));
   ReturnNode* return_node = new (Z) ReturnNode(TokenPosition::kNoSource);
@@ skipping 463 matching lines @@
   // are added.
   //   var :async_op;
   //   var :async_then_callback;
   //   var :async_catch_error_callback;
   //   var :async_stack_trace;
   //   var :controller_stream;
   // These variables are used to store the async generator closure containing
   // the body of the async* function. They are used by the await operator.
   LocalVariable* controller_var =
       new (Z) LocalVariable(TokenPosition::kNoSource, TokenPosition::kNoSource,
-                            Symbols::Controller(), Object::dynamic_type());
+                            Symbols::ColonController(), Object::dynamic_type());
   current_block_->scope->AddVariable(controller_var);
   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)
@@ skipping 88 matching lines @@
 
   // Explicitly reference variables of the async genenerator function from the
   // closure body in order to mark them as captured.
   LocalVariable* existing_var =
       closure_body->scope()->LookupVariable(Symbols::AwaitJumpVar(), false);
   ASSERT((existing_var != NULL) && existing_var->is_captured());
   existing_var =
       closure_body->scope()->LookupVariable(Symbols::AwaitContextVar(), false);
   ASSERT((existing_var != NULL) && existing_var->is_captured());
   existing_var =
-      closure_body->scope()->LookupVariable(Symbols::Controller(), false);
+      closure_body->scope()->LookupVariable(Symbols::ColonController(), false);
   ASSERT((existing_var != NULL) && existing_var->is_captured());
   existing_var =
       closure_body->scope()->LookupVariable(Symbols::AsyncOperation(), false);
   ASSERT((existing_var != NULL) && existing_var->is_captured());
   existing_var = closure_body->scope()->LookupVariable(
       Symbols::AsyncThenCallback(), false);
   ASSERT((existing_var != NULL) && existing_var->is_captured());
   existing_var = closure_body->scope()->LookupVariable(
       Symbols::AsyncCatchErrorCallback(), false);
   ASSERT((existing_var != NULL) && existing_var->is_captured());
@@ skipping 99 matching lines @@
 
   // :controller = new _AsyncStarStreamController(body_closure);
   ArgumentListNode* arguments =
       new (Z) ArgumentListNode(TokenPosition::kNoSource);
   arguments->Add(new (Z) LoadLocalNode(TokenPosition::kNoSource, async_op_var));
   ConstructorCallNode* controller_constructor_call =
       new (Z) ConstructorCallNode(TokenPosition::kNoSource,
                                   TypeArguments::ZoneHandle(Z),
                                   controller_constructor, arguments);
   LocalVariable* controller_var =
-      current_block_->scope->LookupVariable(Symbols::Controller(), false);
+      current_block_->scope->LookupVariable(Symbols::ColonController(), false);
   StoreLocalNode* store_controller = new (Z) StoreLocalNode(
       TokenPosition::kNoSource, controller_var, controller_constructor_call);
   current_block_->statements->Add(store_controller);
 
   // Grab :controller.stream
   InstanceGetterNode* controller_stream = new (Z) InstanceGetterNode(
       TokenPosition::kNoSource,
       new (Z) LoadLocalNode(TokenPosition::kNoSource, controller_var),
       Symbols::Stream());
 
@@ skipping 3062 matching lines @@
                                   outer_async_saved_try_ctx)));
       }
     } else {
       ASSERT(outer_saved_try_ctx == NULL);
     }
   } else {
     // yield statement in async* function.
     ASSERT(innermost_function().IsAsyncGenerator() ||
            innermost_function().IsAsyncGenClosure());
 
-    LocalVariable* controller_var = LookupLocalScope(Symbols::Controller());
+    LocalVariable* controller_var =
+        LookupLocalScope(Symbols::ColonController());
     ASSERT(controller_var != NULL);
     // :controller.add[Stream](expr);
     ArgumentListNode* add_args = new (Z) ArgumentListNode(yield_pos);
     add_args->Add(expr);
     AstNode* add_call = new (Z) InstanceCallNode(
         yield_pos,
         new (Z) LoadLocalNode(TokenPosition::kNoSource, controller_var),
         is_yield_each ? Symbols::AddStream() : Symbols::add(), add_args);
 
     // if (:controller.add[Stream](expr)) {
@@ skipping 4713 matching lines @@
     const ArgumentListNode& function_args,
     const LocalVariable* temp_for_last_arg,
     bool is_super_invocation) {
   UNREACHABLE();
   return NULL;
 }
 
 }  // namespace dart
 
 #endif  // DART_PRECOMPILED_RUNTIME