Create frequently used symbols in the vm isolate

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"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_entry.h"
 #include "vm/flags.h"
 #include "vm/growable_array.h"
 #include "vm/longjump.h"
 #include "vm/native_entry.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/resolver.h"
 #include "vm/scopes.h"
+#include "vm/symbols.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, enable_asserts, false, "Enable assert statements.");
 DEFINE_FLAG(bool, enable_type_checks, false, "Enable type checks.");
 DEFINE_FLAG(bool, trace_parser, false, "Trace parser operations.");
 DEFINE_FLAG(bool, warning_as_error, false, "Treat warnings as errors.");
 DEFINE_FLAG(bool, silent_warnings, false, "Silence warnings.");
 
 static void CheckedModeHandler(bool value) {
@@ skipping 84 matching lines @@
     stack_trace ^= Object::Clone(stack_trace, Heap::kOld);
   }
   return new ThrowNode(token_pos,
                        new LiteralNode(token_pos, exception),
                        new LiteralNode(token_pos, stack_trace));
 }
 
 
 LocalVariable* ParsedFunction::CreateExpressionTempVar(intptr_t token_pos) {
   return new LocalVariable(token_pos,
-                           String::ZoneHandle(String::NewSymbol(":expr_temp")),
+                           String::ZoneHandle(Symbols::New(":expr_temp")),
                            Type::ZoneHandle(Type::DynamicType()));
 }
 
 
 void ParsedFunction::SetNodeSequence(SequenceNode* node_sequence) {
   ASSERT(node_sequence_ == NULL);
   ASSERT(node_sequence != NULL);
   node_sequence_ = node_sequence;
   const int num_fixed_params = function().num_fixed_parameters();
   const int num_opt_params = function().num_optional_parameters();
@@ skipping 45 matching lines @@
                                parameter_count,
                                first_stack_local_index_,
                                scope,
                                &context_owner);
 
   // If this function is not a closure function and if it contains captured
   // variables, the context needs to be saved on entry and restored on exit.
   // Add and allocate a local variable to this purpose.
   if ((context_owner != NULL) && !function().IsClosureFunction()) {
     const String& context_var_name = String::ZoneHandle(
-        String::NewSymbol(LocalVariable::kSavedContextVarName));
+        Symbols::New(LocalVariable::kSavedContextVarName));
     LocalVariable* context_var =
         new LocalVariable(function().token_pos(),
                           context_var_name,
                           Type::ZoneHandle(Type::DynamicType()));
     context_var->set_index(next_free_frame_index--);
     scope->AddVariable(context_var);
     set_saved_context_var(context_var);
   }
 
   // Frame indices are relative to the frame pointer and are decreasing.
@@ skipping 228 matching lines @@
     implicitly_final = false;
     this->parameters = new ZoneGrowableArray<ParamDesc>();
   }
 
   void AddFinalParameter(intptr_t name_pos,
                          const char* name,
                          const AbstractType* type) {
     this->num_fixed_parameters++;
     ParamDesc param;
     param.name_pos = name_pos;
-    param.name = &String::ZoneHandle(String::NewSymbol(name));
+    param.name = &String::ZoneHandle(Symbols::New(name));
     param.is_final = true;
     param.type = type;
     this->parameters->Add(param);
   }
 
   void AddReceiver(intptr_t name_pos) {
     ASSERT(this->parameters->is_empty());
     // The receiver does not need to be type checked.
     AddFinalParameter(name_pos,
                       kThisName,
@@ skipping 360 matching lines @@
     // accesses to the field do not throw again, since initializers should only
     // be executed once.
     SequenceNode* report_circular = new SequenceNode(TokenPos(), NULL);
     report_circular->Add(
         new StoreStaticFieldNode(
             TokenPos(),
             field,
             new LiteralNode(TokenPos(), Instance::ZoneHandle())));
     // TODO(regis): Exception to throw is not specified by spec.
     const String& circular_error = String::ZoneHandle(
-        String::NewSymbol("circular dependency in field initialization"));
+        Symbols::New("circular dependency in field initialization"));
     report_circular->Add(
         new ThrowNode(TokenPos(),
                       new LiteralNode(TokenPos(), circular_error),
                       NULL));
     AstNode* circular_check =
         new IfNode(TokenPos(), compare_circular, report_circular, NULL);
     current_block_->statements->Add(circular_check);
 
     // Generate code checking for uninitialized field.
     AstNode* compare_uninitialized = new ComparisonNode(
@@ skipping 403 matching lines @@
   const Class& super_class = Class::Handle(current_class().SuperClass());
   if (super_class.IsNull()) {
     ErrorMsg(token_pos, "class '%s' does not have a superclass",
              String::Handle(current_class().Name()).ToCString());
   }
 
   Function& super_func =
       Function::Handle(ResolveDynamicFunction(super_class, name));
   if (super_func.IsNull()) {
     const String& no_such_method_name =
-        String::ZoneHandle(String::NewSymbol(kNoSuchMethodName));
+        String::ZoneHandle(Symbols::New(kNoSuchMethodName));
     super_func = ResolveDynamicFunction(super_class, no_such_method_name);
     ASSERT(!super_func.IsNull());
     *is_no_such_method = true;
   } else {
     *is_no_such_method = false;
   }
   CheckFunctionIsCallable(token_pos, super_func);
   return super_func.raw();
 }
 
 
 // Lookup class in the corelib implementation which contains various VM
 // helper methods and classes.
 static RawClass* LookupImplClass(const String& class_name) {
   return Library::Handle(Library::CoreImplLibrary()).LookupClass(class_name);
 }
 
 
 // Lookup class in the corelib which also contains various VM
 // helper methods and classes. Allow look up of private classes.
 static RawClass* LookupCoreClass(const String& class_name) {
   const Library& core_lib = Library::Handle(Library::CoreLibrary());
   String& name = String::Handle(class_name.raw());
   if (class_name.CharAt(0) == Scanner::kPrivateIdentifierStart) {
     // Private identifiers are mangled on a per script basis.
     name = String::Concat(name, String::Handle(core_lib.private_key()));
-    name = String::NewSymbol(name);
+    name = Symbols::New(name);
   }
   return core_lib.LookupClass(name);
 }
 
 
 ArgumentListNode* Parser::BuildNoSuchMethodArguments(
     const String& function_name,
     const ArgumentListNode& function_args) {
   ASSERT(function_args.length() >= 1);  // The receiver is the first argument.
   const intptr_t args_pos = function_args.token_pos();
@@ skipping 65 matching lines @@
             CreateTempConstVariable(operator_pos, index_expr->id(), "lix");
         AstNode* save =
             new StoreLocalNode(operator_pos, *temp, index_expr);
         current_block_->statements->Add(save);
         index_expr = new LoadLocalNode(operator_pos, *temp);
       }
     }
 
     // Resolve the [] operator function in the superclass.
     const String& index_operator_name =
-        String::ZoneHandle(String::NewSymbol(Token::Str(Token::kINDEX)));
+        String::ZoneHandle(Symbols::New(Token::Str(Token::kINDEX)));
     bool is_no_such_method = false;
     const Function& index_operator = Function::ZoneHandle(
         GetSuperFunction(operator_pos,
                          index_operator_name,
                          &is_no_such_method));
 
     ArgumentListNode* index_op_arguments = new ArgumentListNode(operator_pos);
     AstNode* receiver = LoadReceiver(operator_pos);
     index_op_arguments->Add(receiver);
     index_op_arguments->Add(index_expr);
 
     if (is_no_such_method) {
       index_op_arguments = BuildNoSuchMethodArguments(index_operator_name,
                                                       *index_op_arguments);
     }
     super_op = new StaticCallNode(
         operator_pos, index_operator, index_op_arguments);
 
     if (Token::IsAssignmentOperator(CurrentToken())) {
       Token::Kind assignment_op = CurrentToken();
       ConsumeToken();
       AstNode* value = ParseExpr(kAllowConst);
 
       value = ExpandAssignableOp(operator_pos, assignment_op, super_op, value);
 
       // Resolve the []= operator function in the superclass.
       const String& assign_index_operator_name = String::ZoneHandle(
-          String::NewSymbol(Token::Str(Token::kASSIGN_INDEX)));
+          Symbols::New(Token::Str(Token::kASSIGN_INDEX)));
       bool is_no_such_method = false;
       const Function& assign_index_operator = Function::ZoneHandle(
           GetSuperFunction(operator_pos,
                            assign_index_operator_name,
                            &is_no_such_method));
 
       ArgumentListNode* operator_args = new ArgumentListNode(operator_pos);
       operator_args->Add(LoadReceiver(operator_pos));
       operator_args->Add(index_expr);
       operator_args->Add(value);
 
       if (is_no_such_method) {
         operator_args = BuildNoSuchMethodArguments(assign_index_operator_name,
                                                    *operator_args);
       }
       super_op = new StaticCallNode(
           operator_pos, assign_index_operator, operator_args);
     }
   } else if (Token::CanBeOverloaded(CurrentToken())) {
     Token::Kind op = CurrentToken();
     ConsumeToken();
 
     // Resolve the operator function in the superclass.
     const String& operator_function_name =
-        String::Handle(String::NewSymbol(Token::Str(op)));
+        String::Handle(Symbols::New(Token::Str(op)));
     bool is_no_such_method = false;
     const Function& super_operator = Function::ZoneHandle(
         GetSuperFunction(operator_pos,
                          operator_function_name,
                          &is_no_such_method));
 
     ASSERT(Token::Precedence(op) >= Token::Precedence(Token::kBIT_OR));
     AstNode* other_operand = ParseBinaryExpr(Token::Precedence(op) + 1);
 
     ArgumentListNode* op_arguments = new ArgumentListNode(operator_pos);
@@ skipping 99 matching lines @@
                                           LocalVariable* receiver) {
   const intptr_t supercall_pos = TokenPos();
   const Class& super_class = Class::Handle(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() || (super_class.num_native_fields() > 0)) {
     return;
   }
   String& ctor_name = String::Handle(super_class.Name());
-  String& ctor_suffix = String::Handle(String::NewSymbol("."));
+  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);
   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);
@@ skipping 21 matching lines @@
 
 AstNode* Parser::ParseSuperInitializer(const Class& cls,
                                        LocalVariable* receiver) {
   TRACE_PARSER("ParseSuperInitializer");
   ASSERT(CurrentToken() == Token::kSUPER);
   const intptr_t supercall_pos = TokenPos();
   ConsumeToken();
   const Class& super_class = Class::Handle(cls.SuperClass());
   ASSERT(!super_class.IsNull());
   String& ctor_name = String::Handle(super_class.Name());
-  String& ctor_suffix = String::Handle(String::NewSymbol("."));
+  String& ctor_suffix = String::Handle(Symbols::Dot());
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();
     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");
   }
 
@@ skipping 165 matching lines @@
 }
 
 
 void Parser::ParseConstructorRedirection(const Class& cls,
                                          LocalVariable* receiver) {
   TRACE_PARSER("ParseConstructorRedirection");
   ASSERT(CurrentToken() == Token::kTHIS);
   const intptr_t call_pos = TokenPos();
   ConsumeToken();
   String& ctor_name = String::Handle(cls.Name());
-  String& ctor_suffix = String::Handle(String::NewSymbol("."));
+  String& ctor_suffix = String::Handle(Symbols::Dot());
 
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();
     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");
   }
@@ skipping 38 matching lines @@
   OpenFunctionBlock(func);
 
   // Parse expressions of instance fields that have an explicit
   // initializers.
   GrowableArray<FieldInitExpression> initializers;
   Class& cls = Class::Handle(func.owner());
   ParseInitializedInstanceFields(cls, &initializers);
 
   LocalVariable* receiver = new LocalVariable(
       ctor_pos,
-      String::ZoneHandle(String::NewSymbol(kThisName)),
+      String::ZoneHandle(Symbols::New(kThisName)),
       Type::ZoneHandle(Type::DynamicType()));
   current_block_->scope->AddVariable(receiver);
 
   LocalVariable* phase_parameter = new LocalVariable(
        ctor_pos,
-       String::ZoneHandle(String::NewSymbol(kPhaseParameterName)),
+       String::ZoneHandle(Symbols::New(kPhaseParameterName)),
        Type::ZoneHandle(Type::DynamicType()));
   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* field_init =
         new StoreInstanceFieldNode(field->token_pos(),
@@ skipping 533 matching lines @@
       if (method->params.has_field_initializer) {
         // Constructors that redirect to another constructor must not
         // initialize any fields using field initializer parameters.
         ErrorMsg(formal_param_pos, "Redirecting constructor "
                  "may not use field initializer parameters");
       }
       ConsumeToken();  // Colon.
       ExpectToken(Token::kTHIS);
       String& redir_name = String::ZoneHandle(
           String::Concat(members->class_name(),
-                         String::Handle(String::NewSymbol("."))));
+                         String::Handle(Symbols::Dot())));
       if (CurrentToken() == Token::kPERIOD) {
         ConsumeToken();
         redir_name = String::Concat(redir_name,
             *ExpectIdentifier("constructor name expected"));
       }
       method->redirect_name = &redir_name;
       if (CurrentToken() != Token::kLPAREN) {
         ErrorMsg("'(' expected");
       }
       SkipToMatchingParenthesis();
@@ skipping 315 matching lines @@
       member.type = &Type::ZoneHandle(Type::New(result_type_class,
                                                 TypeArguments::Handle(),
                                                 factory_name.ident_pos));
     } else {
       member.name_pos = TokenPos();
       member.name = CurrentLiteral();
       ConsumeToken();
     }
     // We must be dealing with a constructor or named constructor.
     member.kind = RawFunction::kConstructor;
-    String& ctor_suffix = String::ZoneHandle(String::NewSymbol("."));
+    String& ctor_suffix = String::ZoneHandle(Symbols::Dot());
     if (CurrentToken() == Token::kPERIOD) {
       // Named constructor.
       ConsumeToken();
       const String* name = ExpectIdentifier("identifier expected");
       ctor_suffix = String::Concat(ctor_suffix, *name);
     }
     *member.name = String::Concat(*member.name, ctor_suffix);
     // Ensure that names are symbols.
-    *member.name = String::NewSymbol(*member.name);
+    *member.name = Symbols::New(*member.name);
     if (member.type == NULL) {
       ASSERT(!member.has_factory);
       // The body of the constructor cannot modify the type arguments of the
       // constructed instance, which is passed in as a hidden parameter.
       // Therefore, there is no need to set the result type to be checked.
       member.type = &Type::ZoneHandle(Type::DynamicType());
     } else {
       // The type can only be already set in the factory case.
       if (!member.has_factory) {
         ErrorMsg(member.name_pos, "constructor must not specify return type");
@@ skipping 41 matching lines @@
     if (!Token::CanBeOverloaded(CurrentToken())) {
       ErrorMsg("invalid operator overloading");
     }
     if (member.has_static) {
       ErrorMsg("operator overloading functions cannot be static");
     }
     operator_token = CurrentToken();
     member.kind = RawFunction::kRegularFunction;
     member.name_pos = this->TokenPos();
     member.name =
-        &String::ZoneHandle(String::NewSymbol(Token::Str(operator_token)));
+        &String::ZoneHandle(Symbols::New(Token::Str(operator_token)));
     ConsumeToken();
   } else if (IsIdentifier()) {
     member.name = CurrentLiteral();
     member.name_pos = TokenPos();
     ConsumeToken();
   } else {
     ErrorMsg("identifier expected");
   }
 
   ASSERT(member.name != NULL);
@@ skipping 124 matching lines @@
 
 // 1. Add an implicit constructor if no explicit constructor is present.
 // 2. Check for cycles in constructor redirection.
 void Parser::CheckConstructors(ClassDesc* class_desc) {
   // Add an implicit constructor if no explicit constructor is present.
   if (!class_desc->has_constructor()) {
     // The implicit constructor is unnamed, has no explicit parameter,
     // and contains a supercall in the initializer list.
     String& ctor_name = String::ZoneHandle(
         String::Concat(class_desc->class_name(),
-                       String::Handle(String::NewSymbol("."))));
-    ctor_name = String::NewSymbol(ctor_name);
+                       String::Handle(Symbols::Dot())));
+    ctor_name = Symbols::New(ctor_name);
     // The token position for the implicit constructor is the 'class'
     // keyword of the constructor's class.
     Function& ctor = Function::Handle(
         Function::New(ctor_name,
                       RawFunction::kConstructor,
                       /* is_static = */ false,
                       /* is_const = */ false,
                       class_desc->token_pos()));
     ParamList params;
     // Add implicit 'this' parameter.
@@ skipping 61 matching lines @@
 
 
 void Parser::ParseFunctionTypeAlias(
     const GrowableObjectArray& pending_classes) {
   TRACE_PARSER("ParseFunctionTypeAlias");
   ExpectToken(Token::kTYPEDEF);
 
   // Allocate an interface to hold the type parameters and their bounds.
   // Make it the owner of the function type descriptor.
   const Class& alias_owner = Class::Handle(
-      Class::New(String::Handle(String::NewSymbol(":alias_owner")),
+      Class::New(String::Handle(Symbols::New(":alias_owner")),
                  Script::Handle(),
                  TokenPos()));
   alias_owner.set_is_interface();
   alias_owner.set_library(library_);
   set_current_class(alias_owner);
 
   // Parse the result type of the function type.
   AbstractType& result_type = Type::Handle(Type::DynamicType());
   if (CurrentToken() == Token::kVOID) {
     ConsumeToken();
@@ skipping 132 matching lines @@
     ParseQualIdent(&factory_name);
     LibraryPrefix& lib_prefix = LibraryPrefix::Handle();
     if (factory_name.lib_prefix != NULL) {
       lib_prefix = factory_name.lib_prefix->raw();
     }
     const UnresolvedClass& unresolved_factory_class = UnresolvedClass::Handle(
         UnresolvedClass::New(lib_prefix,
                              *factory_name.ident,
                              factory_name.ident_pos));
     const Class& factory_class = Class::Handle(
-        Class::New(String::Handle(String::NewSymbol(":factory_signature")),
+        Class::New(String::Handle(Symbols::New(":factory_signature")),
                    script_,
                    factory_name.ident_pos));
     factory_class.set_library(library_);
     factory_class.set_is_finalized();
     ParseTypeParameters(factory_class);
     unresolved_factory_class.set_factory_signature_class(factory_class);
     interface.set_factory_class(unresolved_factory_class);
     // If a type parameter list is included in the default factory clause (it
     // can be omitted), verify that it matches the list of type parameters of
     // the interface in number and names, but not necessarily in bounds.
@@ skipping 635 matching lines @@
   // They need to be registered with class finalization after parsing
   // has been completed.
   Isolate* isolate = Isolate::Current();
   ObjectStore* object_store = isolate->object_store();
   const GrowableObjectArray& pending_classes =
       GrowableObjectArray::Handle(isolate, object_store->pending_classes());
   SetPosition(0);
   is_top_level_ = true;
   TopLevel top_level;
   Class& toplevel_class = Class::Handle(
-      Class::New(String::ZoneHandle(String::NewSymbol("::")),
+      Class::New(String::ZoneHandle(Symbols::New("::")),
                  script_,
                  TokenPos()));
   toplevel_class.set_library(library_);
 
   if (is_library_source()) {
     ParseLibraryDefinition();
   }
 
   while (true) {
     set_current_class(Class::Handle());  // No current class.
@@ skipping 197 matching lines @@
       new ReturnNode(TokenPos(), new NativeBodyNode(TokenPos(),
                                                     native_name,
                                                     native_function,
                                                     num_parameters,
                                                     has_opt_params,
                                                     is_instance_closure)));
 }
 
 
 LocalVariable* Parser::LookupReceiver(LocalScope* from_scope, bool test_only) {
-  const String& this_name = String::Handle(String::NewSymbol(kThisName));
+  const String& this_name = String::Handle(Symbols::New(kThisName));
   return from_scope->LookupVariable(this_name, test_only);
 }
 
 
 LocalVariable* Parser::LookupPhaseParameter() {
   const String& phase_name =
-      String::Handle(String::NewSymbol(kPhaseParameterName));
+      String::Handle(Symbols::New(kPhaseParameterName));
   const bool kTestOnly = false;
   return current_block_->scope->LookupVariable(phase_name, kTestOnly);
 }
 
 
 void Parser::CaptureReceiver() {
   ASSERT(current_block_->scope->function_level() > 0);
   const bool kTestOnly = false;
   // Side effect of lookup captures the receiver variable.
   LocalVariable* receiver = LookupReceiver(current_block_->scope, kTestOnly);
@@ skipping 148 matching lines @@
   const intptr_t ident_pos = TokenPos();
   if (IsIdentifier()) {
     variable_name = CurrentLiteral();
     function_name = variable_name;
     ConsumeToken();
   } else {
     if (!is_literal) {
       ErrorMsg("function name expected");
     }
     const String& anonymous_function_name =
-        String::ZoneHandle(String::NewSymbol("function"));
+        String::ZoneHandle(Symbols::New("function"));
     function_name = &anonymous_function_name;
   }
   ASSERT(ident_pos >= 0);
 
   if (CurrentToken() != Token::kLPAREN) {
     ErrorMsg("'(' expected");
   }
   intptr_t function_pos = TokenPos();
 
   // Check whether we have parsed this closure function before, in a previous
@@ skipping 558 matching lines @@
   if (paren_found) {
     ExpectToken(Token::kRPAREN);
   }
   ExpectToken(Token::kLBRACE);
   OpenBlock();
   current_block_->scope->AddLabel(label);
 
   // Store switch expression in temporary local variable.
   LocalVariable* temp_variable =
       new LocalVariable(expr_pos,
-                        String::ZoneHandle(String::NewSymbol(":switch_expr")),
+                        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);
   current_block_->statements->Add(save_switch_expr);
 
   // Parse case clauses
   bool default_seen = false;
   while (true) {
     // Check for statement label
@@ skipping 107 matching lines @@
   }
   ExpectToken(Token::kIN);
   const intptr_t collection_pos = TokenPos();
   AstNode* collection_expr = ParseExpr(kAllowConst);
   ExpectToken(Token::kRPAREN);
 
   OpenBlock();  // Implicit block around while loop.
 
   // Generate implicit iterator variable and add to scope.
   const String& iterator_name =
-      String::ZoneHandle(String::NewSymbol(":for-in-iter"));
+      String::ZoneHandle(Symbols::New(":for-in-iter"));
   // We could set the type of the implicit iterator variable to Iterator<T>
   // where T is the type of the for loop variable. However, the type error
   // would refer to the compiler generated iterator and could confuse the user.
   // It is better to leave the iterator untyped and postpone the type error
   // until the loop variable is assigned to.
   const AbstractType& iterator_type = Type::ZoneHandle(Type::DynamicType());
   LocalVariable* iterator_var =
       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(String::NewSymbol(kGetIteratorName));
+      String::ZoneHandle(Symbols::New(kGetIteratorName));
   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);
   current_block_->statements->Add(iterator_init);
 
   // Generate while loop condition.
   AstNode* iterator_has_next = new InstanceCallNode(
       collection_pos,
       new LoadLocalNode(collection_pos, *iterator_var),
-      String::ZoneHandle(String::NewSymbol("hasNext")),
+      String::ZoneHandle(Symbols::New("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),
-      String::ZoneHandle(String::NewSymbol("next")),
+      String::ZoneHandle(Symbols::New("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);
   } else {
@@ skipping 94 matching lines @@
                      NodeAsSequenceNode(incr_pos, increment, incr_scope),
                      body);
 }
 
 
 // Calling VM-internal helpers, uses implementation core library.
 AstNode* Parser::MakeStaticCall(const char* class_name,
                                 const char* function_name,
                                 ArgumentListNode* arguments) {
   const String& cls_name =
-      String::Handle(String::NewSymbol(class_name));
+      String::Handle(Symbols::New(class_name));
   const Class& cls = Class::Handle(LookupImplClass(cls_name));
   ASSERT(!cls.IsNull());
   const String& func_name =
-      String::ZoneHandle(String::NewSymbol(function_name));
+      String::ZoneHandle(Symbols::New(function_name));
   const Function& func = Function::ZoneHandle(
       Resolver::ResolveStatic(cls,
                               func_name,
                               arguments->length(),
                               arguments->names(),
                               Resolver::kIsQualified));
   ASSERT(!func.IsNull());
   CheckFunctionIsCallable(arguments->token_pos(), func);
   return new StaticCallNode(arguments->token_pos(), func, arguments);
 }
@@ skipping 175 matching lines @@
   //                        slot before processing the catch block handler.
   // ':exception_var' - Used to save the current exception object that was
   //                    thrown.
   // ':stacktrace_var' - Used to save the current stack trace object into which
   //                     the stack trace was copied into when an exception was
   //                     thrown.
   // :exception_var and :stacktrace_var get set with the exception object
   // and the stacktrace object when an exception is thrown.
   // These three implicit variables can never be captured variables.
   const String& context_var_name =
-      String::ZoneHandle(String::NewSymbol(":saved_context_var"));
+      String::ZoneHandle(Symbols::New(":saved_context_var"));
   LocalVariable* context_var =
       current_block_->scope->LocalLookupVariable(context_var_name);
   if (context_var == NULL) {
     context_var = new LocalVariable(TokenPos(),
                                     context_var_name,
                                     Type::ZoneHandle(Type::DynamicType()));
     current_block_->scope->AddVariable(context_var);
   }
   const String& catch_excp_var_name =
-      String::ZoneHandle(String::NewSymbol(":exception_var"));
+      String::ZoneHandle(Symbols::New(":exception_var"));
   LocalVariable* catch_excp_var =
       current_block_->scope->LocalLookupVariable(catch_excp_var_name);
   if (catch_excp_var == NULL) {
     catch_excp_var = new LocalVariable(TokenPos(),
                                        catch_excp_var_name,
                                        Type::ZoneHandle(Type::DynamicType()));
     current_block_->scope->AddVariable(catch_excp_var);
   }
   const String& catch_trace_var_name =
-      String::ZoneHandle(String::NewSymbol(":stacktrace_var"));
+      String::ZoneHandle(Symbols::New(":stacktrace_var"));
   LocalVariable* catch_trace_var =
       current_block_->scope->LocalLookupVariable(catch_trace_var_name);
   if (catch_trace_var == NULL) {
     catch_trace_var = new LocalVariable(TokenPos(),
                                         catch_trace_var_name,
                                         Type::ZoneHandle(Type::DynamicType()));
     current_block_->scope->AddVariable(catch_trace_var);
   }
 
   const intptr_t try_pos = TokenPos();
@@ skipping 348 matching lines @@
       // Check if it is ok to do a rethrow.
       SourceLabel* label = current_block_->scope->LookupInnermostCatchLabel();
       if (label == NULL ||
           label->FunctionLevel() != current_block_->scope->function_level()) {
         ErrorMsg("rethrow of an exception is not valid here");
       }
       ASSERT(label->owner() != NULL);
       LocalScope* scope = label->owner()->parent();
       ASSERT(scope != NULL);
       LocalVariable* excp_var = scope->LocalLookupVariable(
-          String::ZoneHandle(String::NewSymbol(":exception_var")));
+          String::ZoneHandle(Symbols::New(":exception_var")));
       ASSERT(excp_var != NULL);
       LocalVariable* trace_var = scope->LocalLookupVariable(
-          String::ZoneHandle(String::NewSymbol(":stacktrace_var")));
+          String::ZoneHandle(Symbols::New(":stacktrace_var")));
       ASSERT(trace_var != NULL);
       statement = new ThrowNode(statement_pos,
                                 new LoadLocalNode(statement_pos, *excp_var),
                                 new LoadLocalNode(statement_pos, *trace_var));
     }
   } else {
     statement = ParseExpr(kAllowConst);
     ExpectSemicolon();
   }
   return statement;
@@ skipping 268 matching lines @@
 AstNode* Parser::ThrowTypeError(intptr_t type_pos, const AbstractType& type) {
   ASSERT(type.IsMalformed());
   ArgumentListNode* arguments = new ArgumentListNode(type_pos);
   // Location argument.
   arguments->Add(new LiteralNode(
       type_pos, Integer::ZoneHandle(Integer::New(type_pos))));
   // Src value argument.
   arguments->Add(new LiteralNode(type_pos, Instance::ZoneHandle()));
   // Dst type name argument.
   arguments->Add(new LiteralNode(type_pos, String::ZoneHandle(
-      String::NewSymbol("malformed"))));
+      Symbols::New("malformed"))));
   // Dst name argument.
   arguments->Add(new LiteralNode(type_pos, String::ZoneHandle(
-    String::NewSymbol(""))));
+    Symbols::New(""))));
   // Malformed type error.
   const Error& error = Error::Handle(type.malformed_error());
   arguments->Add(new LiteralNode(type_pos, String::ZoneHandle(
-      String::NewSymbol(error.ToErrorCString()))));
+      Symbols::New(error.ToErrorCString()))));
   return MakeStaticCall(kTypeErrorName, kThrowNewName, arguments);
 }
 
 
 AstNode* Parser::ParseBinaryExpr(int min_preced) {
   TRACE_PARSER("ParseBinaryExpr");
   ASSERT(min_preced >= 4);
   AstNode* left_operand = ParseUnaryExpr();
   if (IsLiteral("as")) {  // Not a reserved word.
     token_kind_ = Token::kAS;
@@ skipping 99 matching lines @@
 }
 
 
 LocalVariable* Parser::CreateTempConstVariable(intptr_t token_pos,
                                                intptr_t token_id,
                                                const char* s) {
   char name[64];
   OS::SNPrint(name, 64, ":%s%d", s, token_id);
   LocalVariable* temp =
       new LocalVariable(token_pos,
-                        String::ZoneHandle(String::NewSymbol(name)),
+                        String::ZoneHandle(Symbols::New(name)),
                         Type::ZoneHandle(Type::DynamicType()));
   temp->set_is_final();
   current_block_->scope->AddVariable(temp);
   return temp;
 }
 
 
 // TODO(srdjan): Implement other optimizations.
 AstNode* Parser::OptimizeBinaryOpNode(intptr_t op_pos,
                                       Token::Kind binary_op,
@@ skipping 1418 matching lines @@
     }
   }
   ASSERT(type_arguments.IsNull() || (type_arguments.Length() == 1));
 
   // Parse the list elements. Note: there may be an optional extra
   // comma after the last element.
   ArrayNode* list = new ArrayNode(TokenPos(), type_arguments);
   if (!is_empty_literal) {
     const bool saved_mode = SetAllowFunctionLiterals(true);
     const String& dst_name = String::ZoneHandle(
-        String::NewSymbol("list literal element"));
+        Symbols::New("list literal element"));
     while (CurrentToken() != Token::kRBRACK) {
       const intptr_t element_pos = TokenPos();
       AstNode* element = ParseExpr(is_const);
       if (FLAG_enable_type_checks &&
           !is_const &&
           !element_type.IsDynamicType()) {
         element = new AssignableNode(element_pos,
                                      element,
                                      element_type,
                                      dst_name);
@@ skipping 37 matching lines @@
         }
       }
       const_list.SetAt(i, elem->AsLiteralNode()->literal());
     }
     const_list ^= const_list.Canonicalize();
     const_list.MakeImmutable();
     return new LiteralNode(literal_pos, const_list);
   } else {
     // Factory call at runtime.
     String& list_literal_factory_class_name = String::Handle(
-        String::NewSymbol(kListLiteralFactoryClassName));
+        Symbols::New(kListLiteralFactoryClassName));
     const Class& list_literal_factory_class =
         Class::Handle(LookupCoreClass(list_literal_factory_class_name));
     ASSERT(!list_literal_factory_class.IsNull());
     const String& list_literal_factory_name =
-        String::Handle(String::NewSymbol(kListLiteralFactoryName));
+        String::Handle(Symbols::New(kListLiteralFactoryName));
     const Function& list_literal_factory = Function::ZoneHandle(
         list_literal_factory_class.LookupFactory(list_literal_factory_name));
     ASSERT(!list_literal_factory.IsNull());
     if (!type_arguments.IsNull() &&
         !type_arguments.IsInstantiated() &&
         (current_block_->scope->function_level() > 0)) {
       // Make sure that the instantiator is captured.
       CaptureReceiver();
     }
     ArgumentListNode* factory_param = new ArgumentListNode(literal_pos);
@@ skipping 100 matching lines @@
   ASSERT(map_type_arguments.IsNull() || (map_type_arguments.Length() == 2));
   map_type_arguments ^= map_type_arguments.Canonicalize();
 
   // Parse the map entries. Note: there may be an optional extra
   // comma after the last entry.
   // The kv_pair array is temporary and of element type Dynamic. It is passed
   // to the factory to initialize a properly typed map.
   ArrayNode* kv_pairs =
       new ArrayNode(TokenPos(), TypeArguments::ZoneHandle());
   const String& dst_name = String::ZoneHandle(
-      String::NewSymbol("list literal element"));
+      Symbols::New("list literal element"));
   while (CurrentToken() != Token::kRBRACE) {
     AstNode* key = NULL;
     if (CurrentToken() == Token::kSTRING) {
       key = ParseStringLiteral();
     }
     if (key == NULL) {
       ErrorMsg("map entry key must be string literal");
     } else if (is_const && !key->IsLiteralNode()) {
       ErrorMsg("map entry key must be compile time constant string");
     }
@@ skipping 51 matching lines @@
                    String::Handle(value_type.UserVisibleName()).ToCString());
         }
       }
       key_value_array.SetAt(i, arg->AsLiteralNode()->literal());
     }
     key_value_array ^= key_value_array.Canonicalize();
     key_value_array.MakeImmutable();
 
     // Construct the map object.
     const String& immutable_map_class_name =
-        String::Handle(String::NewSymbol(kImmutableMapName));
+        String::Handle(Symbols::New(kImmutableMapName));
     const Class& immutable_map_class =
         Class::Handle(LookupImplClass(immutable_map_class_name));
     ASSERT(!immutable_map_class.IsNull());
     ArgumentListNode* constr_args = new ArgumentListNode(TokenPos());
     constr_args->Add(new LiteralNode(literal_pos, key_value_array));
     const String& constr_name =
-        String::Handle(String::NewSymbol(kImmutableMapConstructorName));
+        String::Handle(Symbols::New(kImmutableMapConstructorName));
     const Function& map_constr = Function::ZoneHandle(
         immutable_map_class.LookupConstructor(constr_name));
     ASSERT(!map_constr.IsNull());
     const Object& constructor_result = Object::Handle(
         EvaluateConstConstructorCall(immutable_map_class,
                                      map_type_arguments,
                                      map_constr,
                                      constr_args));
     if (constructor_result.IsUnhandledException()) {
       return GenerateRethrow(literal_pos, constructor_result);
     } else {
       const Instance& const_instance = Instance::Cast(constructor_result);
       return new LiteralNode(literal_pos,
                              Instance::ZoneHandle(const_instance.raw()));
     }
   } else {
     // Factory call at runtime.
     String& map_literal_factory_class_name = String::Handle(
-        String::NewSymbol(kMapLiteralFactoryClassName));
+        Symbols::New(kMapLiteralFactoryClassName));
     const Class& map_literal_factory_class =
         Class::Handle(LookupCoreClass(map_literal_factory_class_name));
     ASSERT(!map_literal_factory_class.IsNull());
     const String& map_literal_factory_name =
-        String::Handle(String::NewSymbol(kMapLiteralFactoryName));
+        String::Handle(Symbols::New(kMapLiteralFactoryName));
     const Function& map_literal_factory = Function::ZoneHandle(
         map_literal_factory_class.LookupFactory(map_literal_factory_name));
     ASSERT(!map_literal_factory.IsNull());
     if (!map_type_arguments.IsNull() &&
         !map_type_arguments.IsInstantiated() &&
         (current_block_->scope->function_level() > 0)) {
       // Make sure that the instantiator is captured.
       CaptureReceiver();
     }
     ArgumentListNode* factory_param = new ArgumentListNode(literal_pos);
@@ skipping 35 matching lines @@
   return primary;
 }
 
 
 static const String& BuildConstructorName(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.
-  const String& period = String::Handle(String::NewSymbol("."));
+  const String& period = String::Handle(Symbols::Dot());
   String& constructor_name =
       String::Handle(String::Concat(type_class_name, period));
   if (named_constructor != NULL) {
     constructor_name = String::Concat(constructor_name, *named_constructor);
   }
   return constructor_name;
 }
 
 
 AstNode* Parser::ParseNewOperator() {
@@ skipping 224 matching lines @@
     // mode at runtime that it is within its declared bounds.
     new_object = CreateConstructorCallNode(
         new_pos, type_arguments, constructor, arguments);
   }
   return new_object;
 }
 
 
 String& Parser::Interpolate(ArrayNode* values) {
   const String& class_name =
-      String::Handle(String::NewSymbol(kStringClassName));
+      String::Handle(Symbols::New(kStringClassName));
   const Class& cls = Class::Handle(LookupImplClass(class_name));
   ASSERT(!cls.IsNull());
-  const String& func_name = String::Handle(String::NewSymbol(kInterpolateName));
+  const String& func_name = String::Handle(Symbols::New(kInterpolateName));
   const Function& func =
       Function::Handle(cls.LookupStaticFunction(func_name));
   ASSERT(!func.IsNull());
 
   // Build the array of literal values to interpolate.
   const Array& value_arr = Array::Handle(Array::New(values->length()));
   for (int i = 0; i < values->length(); i++) {
     ASSERT(values->ElementAt(i)->IsLiteralNode());
     value_arr.SetAt(i, values->ElementAt(i)->AsLiteralNode()->literal());
   }
 
   // Build argument array to pass to the interpolation function.
   GrowableArray<const Object*> interpolate_arg;
   interpolate_arg.Add(&value_arr);
   const Array& kNoArgumentNames = Array::Handle();
 
   // Call interpolation function.
   String& concatenated = String::ZoneHandle();
   concatenated ^= DartEntry::InvokeStatic(func,
                                           interpolate_arg,
                                           kNoArgumentNames);
   if (concatenated.IsUnhandledException()) {
     ErrorMsg("Exception thrown in Parser::Interpolate");
   }
-  concatenated = String::NewSymbol(concatenated);
+  concatenated = Symbols::New(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.
@@ skipping 155 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 = ResolveIdentInLibraryPrefixScope(*(qual_ident.lib_prefix),
                                                  qual_ident);
     }
     ASSERT(primary != NULL);
   } else if (CurrentToken() == Token::kTHIS) {
-    const String& this_name = String::Handle(String::NewSymbol(kThisName));
+    const String& this_name = String::Handle(Symbols::New(kThisName));
     LocalVariable* local = LookupLocalScope(this_name);
     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();
@@ skipping 340 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart