Create frequently used symbols in the vm isolate

lib/isolate.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 "platform/assert.h"
 #include "vm/bootstrap_natives.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_entry.h"
 #include "vm/exceptions.h"
 #include "vm/longjump.h"
 #include "vm/message_handler.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/port.h"
 #include "vm/resolver.h"
 #include "vm/snapshot.h"
+#include "vm/symbols.h"
 #include "vm/thread.h"
 
 namespace dart {
 
 class IsolateStartData {
  public:
   IsolateStartData(char* library_url,
                    char* class_name,
                    intptr_t port_id)
       : library_url_(library_url),
@@ skipping 29 matching lines @@
 }
 
 
 static void ThrowErrorException(Exceptions::ExceptionType type,
                                 const char* error_msg,
                                 const char* library_url,
                                 const char* class_name) {
   String& str = String::Handle();
   String& name = String::Handle();
   str ^= String::New(error_msg);
-  name ^= String::NewSymbol(library_url);
+  name ^= Symbols::New(library_url);
   str ^= String::Concat(str, name);
   name ^= String::New(":");
   str ^= String::Concat(str, name);
-  name ^= String::NewSymbol(class_name);
+  name ^= Symbols::New(class_name);
   str ^= String::Concat(str, name);
   GrowableArray<const Object*> arguments(1);
   arguments.Add(&str);
   Exceptions::ThrowByType(type, arguments);
 }
 
 
 // TODO(turnidge): Move to DartLibraryCalls.
 RawObject* ReceivePortCreate(intptr_t port_id) {
   Library& isolate_lib = Library::Handle(Library::IsolateLibrary());
   ASSERT(!isolate_lib.IsNull());
   const String& public_class_name =
-      String::Handle(String::NewSymbol("_ReceivePortImpl"));
+      String::Handle(Symbols::New("_ReceivePortImpl"));
   const String& class_name =
       String::Handle(isolate_lib.PrivateName(public_class_name));
   const String& function_name =
-      String::Handle(String::NewSymbol("_get_or_create"));
+      String::Handle(Symbols::New("_get_or_create"));
   const int kNumArguments = 1;
   const Array& kNoArgumentNames = Array::Handle();
   const Function& function = Function::Handle(
       Resolver::ResolveStatic(isolate_lib,
                               class_name,
                               function_name,
                               kNumArguments,
                               kNoArgumentNames,
                               Resolver::kIsQualified));
   GrowableArray<const Object*> arguments(kNumArguments);
@@ skipping 17 matching lines @@
   intptr_t port_id = data->port_id_;
   delete data;
 
   {
     StartIsolateScope start_scope(isolate);
     Zone zone(isolate);
     HandleScope handle_scope(isolate);
     ASSERT(ClassFinalizer::AllClassesFinalized());
     // Lookup the target class by name, create an instance and call the run
     // method.
-    const String& lib_name = String::Handle(String::NewSymbol(library_url));
+    const String& lib_name = String::Handle(Symbols::New(library_url));
     free(library_url);
     const Library& lib = Library::Handle(Library::LookupLibrary(lib_name));
     ASSERT(!lib.IsNull());
-    const String& cls_name = String::Handle(String::NewSymbol(class_name));
+    const String& cls_name = String::Handle(Symbols::New(class_name));
     free(class_name);
     const Class& target_class = Class::Handle(lib.LookupClass(cls_name));
     // TODO(iposva): Deserialize or call the constructor after allocating.
     // For now, we only support a non-parameterized or raw target class.
     const Instance& target = Instance::Handle(Instance::New(target_class));
     Object& result = Object::Handle();
 
     // Invoke the default constructor.
     const String& period = String::Handle(String::New("."));
     String& constructor_name = String::Handle(String::Concat(cls_name, period));
     const Function& default_constructor =
         Function::Handle(target_class.LookupConstructor(constructor_name));
     if (!default_constructor.IsNull()) {
       GrowableArray<const Object*> arguments(1);
       arguments.Add(&target);
       arguments.Add(&Smi::Handle(Smi::New(Function::kCtorPhaseAll)));
       const Array& kNoArgumentNames = Array::Handle();
       result = DartEntry::InvokeStatic(default_constructor,
                                        arguments,
                                        kNoArgumentNames);
       if (result.IsError()) {
         StoreError(isolate, result);
         return false;
       }
       ASSERT(result.IsNull());
     }
 
     // Invoke the "_run" method.
     const Function& target_function = Function::Handle(Resolver::ResolveDynamic(
-        target, String::Handle(String::NewSymbol("_run")), 2, 0));
+        target, String::Handle(Symbols::New("_run")), 2, 0));
     // TODO(iposva): Proper error checking here.
     ASSERT(!target_function.IsNull());
     // TODO(iposva): Allocate the proper port number here.
     const Object& local_port = Object::Handle(ReceivePortCreate(port_id));
     if (local_port.IsError()) {
       StoreError(isolate, local_port);
       return false;
     }
     GrowableArray<const Object*> arguments(1);
     arguments.Add(&local_port);
@@ skipping 38 matching lines @@
 static bool CheckArguments(const char* library_url, const char* class_name) {
   Isolate* isolate = Isolate::Current();
   Zone zone(isolate);
   HandleScope handle_scope(isolate);
   String& name = String::Handle();
   if (!ClassFinalizer::FinalizePendingClasses()) {
     return false;
   }
   // Lookup the target class by name, create an instance and call the run
   // method.
-  name ^= String::NewSymbol(library_url);
+  name ^= Symbols::New(library_url);
   const Library& lib = Library::Handle(Library::LookupLibrary(name));
   if (lib.IsNull()) {
     const String& error_str = String::Handle(
         String::New("Error starting Isolate, library not loaded : "));
     const Error& error = Error::Handle(LanguageError::New(error_str));
     Isolate::Current()->object_store()->set_sticky_error(error);
     return false;
   }
-  name ^= String::NewSymbol(class_name);
+  name ^= Symbols::New(class_name);
   const Class& target_class = Class::Handle(lib.LookupClass(name));
   if (target_class.IsNull()) {
     const String& error_str = String::Handle(
         String::New("Error starting Isolate, class not loaded : "));
     const Error& error = Error::Handle(LanguageError::New(error_str));
     Isolate::Current()->object_store()->set_sticky_error(error);
     return false;
   }
   return true;  // No errors.
 }
@@ skipping 407 matching lines @@
 
 DEFINE_NATIVE_ENTRY(isolate_getPortInternal, 0) {
   const Object& port = Object::Handle(ReceivePortCreate(isolate->main_port()));
   if (port.IsError()) {
     Exceptions::PropagateError(Error::Cast(port));
   }
   arguments->SetReturn(port);
 }
 
 }  // namespace dart