Add read only handles for the following predefined symbols

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 417 matching lines @@
     num_fixed_parameters = 0;
     num_optional_parameters = 0;
     has_optional_positional_parameters = false;
     has_optional_named_parameters = false;
     has_field_initializer = false;
     implicitly_final = false;
     this->parameters = new ZoneGrowableArray<ParamDesc>();
   }
 
   void AddFinalParameter(intptr_t name_pos,
-                         String* name,
+                         const String* name,
                          const AbstractType* type) {
     this->num_fixed_parameters++;
     ParamDesc param;
     param.name_pos = name_pos;
     param.name = name;
     param.is_final = true;
     param.type = type;
     this->parameters->Add(param);
   }
 
   void AddReceiver(const Type* receiver_type) {
     ASSERT(this->parameters->is_empty());
     AddFinalParameter(receiver_type->token_pos(),
-                      &String::ZoneHandle(Symbols::This()),
+                      &Symbols::ThisHandle(),
                       receiver_type);
   }
 
   void SetImplicitlyFinal() {
     implicitly_final = true;
   }
 
   int num_fixed_parameters;
   int num_optional_parameters;
   bool has_optional_positional_parameters;
@@ skipping 1427 matching lines @@
 }
 
 
 SequenceNode* Parser::MakeImplicitConstructor(const Function& func) {
   ASSERT(func.IsConstructor());
   const intptr_t ctor_pos = TokenPos();
   OpenFunctionBlock(func);
   const Class& cls = Class::Handle(func.Owner());
   LocalVariable* receiver = new LocalVariable(
       ctor_pos,
-      String::ZoneHandle(Symbols::This()),
+      Symbols::ThisHandle(),
       Type::ZoneHandle(Type::DynamicType()));
   current_block_->scope->AddVariable(receiver);
 
   LocalVariable* phase_parameter = new LocalVariable(
        ctor_pos,
        String::ZoneHandle(Symbols::PhaseParameter()),
        Type::ZoneHandle(Type::SmiType()));
   current_block_->scope->AddVariable(phase_parameter);
 
   // Parse expressions of instance fields that have an explicit
@@ skipping 2614 matching lines @@
       new ReturnNode(TokenPos(),
                      new NativeBodyNode(TokenPos(),
                                         Function::ZoneHandle(func.raw()),
                                         native_name,
                                         native_function)));
 }
 
 
 LocalVariable* Parser::LookupReceiver(LocalScope* from_scope, bool test_only) {
   ASSERT(!current_function().is_static());
-  const String& this_name = String::Handle(Symbols::This());
-  return from_scope->LookupVariable(this_name, test_only);
+  return from_scope->LookupVariable(Symbols::ThisHandle(), test_only);
 }
 
 
 LocalVariable* Parser::LookupTypeArgumentsParameter(LocalScope* from_scope,
                                                     bool test_only) {
   ASSERT(current_function().IsInFactoryScope());
   const String& param_name = String::Handle(Symbols::TypeArgumentsParameter());
   return from_scope->LookupVariable(param_name, test_only);
 }
 LocalVariable* Parser::LookupPhaseParameter() {
@@ skipping 3137 matching lines @@
 // Returns true if ident resolves to a formal parameter of the current function
 // or of one of its enclosing functions.
 // Make sure not to capture the formal parameter, since it is not accessed.
 bool Parser::IsFormalParameter(const String& ident,
                                Function* owner_function,
                                LocalScope** owner_scope,
                                intptr_t* local_index) {
   if (current_block_ == NULL) {
     return false;
   }
-  if (ident.Equals(String::Handle(Symbols::This()))) {
+  if (ident.Equals(Symbols::ThisHandle())) {
     // 'this' is not a formal parameter.
     return false;
   }
   // Since an argument definition test does not use the value of the formal
   // parameter, there is no reason to capture it.
   const bool kTestOnly = true;  // No capturing.
   LocalVariable* local =
       current_block_->scope->LookupVariable(ident, kTestOnly);
   if (local == NULL) {
     if (!current_function().IsLocalFunction()) {
@@ skipping 1594 matching lines @@
     } else {
       // This is a qualified identifier with a library prefix so resolve
       // the identifier locally in that library (we do not include the
       // libraries imported by that library).
       primary = ResolveIdentInPrefixScope(qual_ident.ident_pos,
                                           *qual_ident.lib_prefix,
                                           *qual_ident.ident);
     }
     ASSERT(primary != NULL);
   } else if (CurrentToken() == Token::kTHIS) {
-    const String& this_name = String::Handle(Symbols::This());
-    LocalVariable* local = LookupLocalScope(this_name);
+    LocalVariable* local = LookupLocalScope(Symbols::ThisHandle());
     if (local == NULL) {
       ErrorMsg("receiver 'this' is not in scope");
     }
     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) {
@@ skipping 378 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart