Create frequently used symbols in the vm isolate

vm/dart_api_impl.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 "include/dart_api.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/dart.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_api_message.h"
 #include "vm/dart_api_state.h"
 #include "vm/dart_entry.h"
 #include "vm/debuginfo.h"
 #include "vm/exceptions.h"
 #include "vm/flags.h"
 #include "vm/growable_array.h"
 #include "vm/message.h"
 #include "vm/native_entry.h"
 #include "vm/native_message_handler.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/port.h"
 #include "vm/resolver.h"
 #include "vm/stack_frame.h"
+#include "vm/symbols.h"
 #include "vm/timer.h"
 #include "vm/unicode.h"
 #include "vm/verifier.h"
 
 namespace dart {
 
 DECLARE_FLAG(bool, print_class_table);
 
 ThreadLocalKey Api::api_native_key_ = Thread::kUnsetThreadLocalKey;
 
@@ skipping 1077 matching lines @@
 DART_EXPORT Dart_Handle Dart_GetReceivePort(Dart_Port port_id) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   Library& isolate_lib = Library::Handle(isolate, Library::IsolateLibrary());
   ASSERT(!isolate_lib.IsNull());
   const String& public_class_name =
       String::Handle(isolate, String::New("_ReceivePortImpl"));
   const String& class_name =
       String::Handle(isolate, isolate_lib.PrivateName(public_class_name));
   const String& function_name =
-      String::Handle(isolate, String::NewSymbol("_get_or_create"));
+      String::Handle(isolate, Symbols::New("_get_or_create"));
   const int kNumArguments = 1;
   const Array& kNoArgumentNames = Array::Handle(isolate);
   const Function& function = Function::Handle(
       isolate,
       Resolver::ResolveStatic(isolate_lib,
                               class_name,
                               function_name,
                               kNumArguments,
                               kNoArgumentNames,
                               Resolver::kIsQualified));
@@ skipping 1440 matching lines @@
 // --- Function and Variable Reflection ---
 
 
 // Outside of the vm, we expose setter names with a trailing '='.
 static bool HasExternalSetterSuffix(const String& name) {
   return name.CharAt(name.Length() - 1) == '=';
 }
 
 
 static RawString* AddExternalSetterSuffix(const String& name) {
-  const String& equals = String::Handle(String::NewSymbol("="));
+  const String& equals = String::Handle(Symbols::New("="));
   return String::Concat(name, equals);
 }
 
 
 static RawString* RemoveExternalSetterSuffix(const String& name) {
   ASSERT(HasExternalSetterSuffix(name));
   return String::SubString(name, 0, name.Length() - 1);
 }
 
 
@@ skipping 94 matching lines @@
 
     // Case 3.  Lookup the funciton with the getter prefix prepended.
     if (func.IsNull()) {
       tmp_name = Field::GetterName(func_name);
       func = cls.LookupFunction(tmp_name);
     }
 
     // Case 4.  Lookup the function with a . appended to find the
     // unnamed constructor.
     if (func.IsNull()) {
-      const String& dot = String::Handle(String::NewSymbol("."));
+      const String& dot = String::Handle(Symbols::Dot());
       tmp_name = String::Concat(func_name, dot);
       func = cls.LookupFunction(tmp_name);
     }
   } else if (obj.IsLibrary()) {
     const Library& lib = Library::Cast(obj);
 
     // Case 1.  Lookup the unmodified function name.
     func = lib.LookupFunctionAllowPrivate(func_name);
 
     // Case 2.  Lookup the function without the external setter suffix
@@ skipping 373 matching lines @@
     RETURN_TYPE_ERROR(isolate, clazz, Class);
   }
   String& base_constructor_name = String::Handle();
   base_constructor_name = cls.Name();
 
   // And get the name of the constructor to invoke.
   String& dot_name = String::Handle(isolate);
   const Object& name_obj =
       Object::Handle(isolate, Api::UnwrapHandle(constructor_name));
   if (name_obj.IsNull()) {
-    dot_name = String::NewSymbol(".");
+    dot_name = Symbols::Dot();
   } else if (name_obj.IsString()) {
-    const String& dot = String::Handle(isolate, String::NewSymbol("."));
+    const String& dot = String::Handle(isolate, Symbols::Dot());
     dot_name = String::Concat(dot, String::Cast(name_obj));
   } else {
     return Api::NewError(
         "%s expects argument 'constructor_name' to be of type String.",
         CURRENT_FUNC);
   }
 
   const char* msg = CheckIsolateState(isolate);
   if (msg != NULL) {
     return Api::NewError(msg);
@@ skipping 496 matching lines @@
                                                       int field_count) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& param = Object::Handle(isolate, Api::UnwrapHandle(name));
   if (param.IsNull() || !param.IsString() || field_count <= 0) {
     return Api::NewError(
         "Invalid arguments passed to Dart_CreateNativeWrapperClass");
   }
   String& cls_name = String::Handle(isolate);
   cls_name ^= param.raw();
-  cls_name = String::NewSymbol(cls_name);
+  cls_name = Symbols::New(cls_name);
   Library& lib = Library::Handle(isolate);
   lib ^= Api::UnwrapHandle(library);
   if (lib.IsNull()) {
     return Api::NewError(
         "Invalid arguments passed to Dart_CreateNativeWrapperClass");
   }
   const Class& cls = Class::Handle(
       isolate, Class::NewNativeWrapper(&lib, cls_name, field_count));
   if (cls.IsNull()) {
     return Api::NewError(
@@ skipping 525 matching lines @@
     *buffer_size = 0;
   }
 }
 
 
 DART_EXPORT void Dart_InitFlowGraphPrinting(FileWriterFunction function) {
   Dart::set_flow_graph_writer(function);
 }
 
 }  // namespace dart