Convert all symbols accessor to return read only handles so that it is not necessary to create a ne…

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"
@@ skipping 1084 matching lines @@
   DARTSCOPE(isolate);
   return Api::NewHandle(isolate, DartLibraryCalls::NewSendPort(port_id));
 }
 
 
 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, Symbols::New("_get_or_create"));
+  const String& class_name = String::Handle(
+      isolate, isolate_lib.PrivateName(Symbols::_ReceivePortImpl()));
   const int kNumArguments = 1;
-  const Array& kNoArgNames = Array::Handle(isolate);
   const Function& function = Function::Handle(
       isolate,
       Resolver::ResolveStatic(isolate_lib,
                               class_name,
-                              function_name,
+                              Symbols::_get_or_create(),
                               kNumArguments,
-                              kNoArgNames,
+                              Object::empty_array(),
                               Resolver::kIsQualified));
   const Array& args = Array::Handle(isolate, Array::New(kNumArguments));
   args.SetAt(0, Integer::Handle(isolate, Integer::New(port_id)));
   return Api::NewHandle(isolate, DartEntry::InvokeStatic(function, args));
 }
 
 
 DART_EXPORT Dart_Port Dart_GetMainPortId() {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
@@ skipping 751 matching lines @@
   }
   if (obj.IsGrowableObjectArray()) {
     GET_LIST_LENGTH(isolate, GrowableObjectArray, obj, len);
   }
   // Now check and handle a dart object that implements the List interface.
   const Instance& instance =
       Instance::Handle(isolate, GetListInstance(isolate, obj));
   if (instance.IsNull()) {
     return Api::NewError("Object does not implement the List interface");
   }
-  String& name = String::Handle(isolate, Symbols::Length());
-  name = Field::GetterName(name);
+  const String& name = String::Handle(Field::GetterName(Symbols::Length()));
   const Function& function =
       Function::Handle(isolate, Resolver::ResolveDynamic(instance, name, 1, 0));
   if (function.IsNull()) {
     return Api::NewError("List object does not have a 'length' field.");
   }
 
   const int kNumArgs = 1;
   const Array& args = Array::Handle(isolate, Array::New(kNumArgs));
   args.SetAt(0, instance);  // Set up the receiver as the first argument.
   const Object& retval =
@@ skipping 46 matching lines @@
     GET_LIST_ELEMENT(isolate, GrowableObjectArray, obj, index);
   } else if (obj.IsError()) {
     return list;
   } else {
     // Check and handle a dart object that implements the List interface.
     const Instance& instance =
         Instance::Handle(isolate, GetListInstance(isolate, obj));
     if (!instance.IsNull()) {
       const Function& function = Function::Handle(
           isolate,
-          Resolver::ResolveDynamic(instance,
-                                   Symbols::IndexTokenHandle(),
-                                   2,
-                                   0));
+          Resolver::ResolveDynamic(instance, Symbols::IndexToken(), 2, 0));
       if (!function.IsNull()) {
         const int kNumArgs = 2;
         const Array& args = Array::Handle(isolate, Array::New(kNumArgs));
         const Integer& indexobj = Integer::Handle(isolate, Integer::New(index));
         args.SetAt(0, instance);
         args.SetAt(1, indexobj);
         return Api::NewHandle(isolate, DartEntry::InvokeDynamic(function,
                                                                 args));
       }
     }
@@ skipping 31 matching lines @@
   } else if (obj.IsError()) {
     return list;
   } else {
     // Check and handle a dart object that implements the List interface.
     const Instance& instance =
         Instance::Handle(isolate, GetListInstance(isolate, obj));
     if (!instance.IsNull()) {
       const Function& function = Function::Handle(
           isolate,
           Resolver::ResolveDynamic(instance,
-                                   Symbols::AssignIndexTokenHandle(),
+                                   Symbols::AssignIndexToken(),
                                    3,
                                    0));
       if (!function.IsNull()) {
         const Integer& index_obj =
             Integer::Handle(isolate, Integer::New(index));
         const Object& value_obj =
             Object::Handle(isolate, Api::UnwrapHandle(value));
         if (!value_obj.IsNull() && !value_obj.IsInstance()) {
           RETURN_TYPE_ERROR(isolate, value, Instance);
         }
@@ skipping 64 matching lines @@
                               length);
   } else if (obj.IsError()) {
     return list;
   } else {
     // Check and handle a dart object that implements the List interface.
     const Instance& instance =
         Instance::Handle(isolate, GetListInstance(isolate, obj));
     if (!instance.IsNull()) {
       const Function& function = Function::Handle(
           isolate,
-          Resolver::ResolveDynamic(instance,
-                                   Symbols::IndexTokenHandle(),
-                                   2,
-                                   0));
+          Resolver::ResolveDynamic(instance, Symbols::IndexToken(), 2, 0));
       if (!function.IsNull()) {
         Object& result = Object::Handle(isolate);
         Integer& intobj = Integer::Handle(isolate);
         const int kNumArgs = 2;
         const Array& args = Array::Handle(isolate, Array::New(kNumArgs));
         args.SetAt(0, instance);  // Set up the receiver as the first argument.
         for (int i = 0; i < length; i++) {
           intobj = Integer::New(offset + i);
           args.SetAt(1, intobj);
           result = DartEntry::InvokeDynamic(function, args);
@@ skipping 68 matching lines @@
   } else if (obj.IsError()) {
     return list;
   } else {
   // Check and handle a dart object that implements the List interface.
     const Instance& instance =
         Instance::Handle(isolate, GetListInstance(isolate, obj));
     if (!instance.IsNull()) {
       const Function& function = Function::Handle(
           isolate,
           Resolver::ResolveDynamic(instance,
-                                   Symbols::AssignIndexTokenHandle(),
+                                   Symbols::AssignIndexToken(),
                                    3,
                                    0));
       if (!function.IsNull()) {
         Integer& indexobj = Integer::Handle(isolate);
         Integer& valueobj = Integer::Handle(isolate);
         const int kNumArgs = 3;
         const Array& args = Array::Handle(isolate, Array::New(kNumArgs));
         args.SetAt(0, instance);  // Set up the receiver as the first argument.
         for (int i = 0; i < length; i++) {
           indexobj = Integer::New(offset + i);
@@ skipping 590 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()) {
-      tmp_name = String::Concat(func_name, Symbols::DotHandle());
+      tmp_name = String::Concat(func_name, Symbols::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
     // '='.  Make sure to do this check after the regular lookup, so
@@ skipping 544 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 = Symbols::Dot();
+    dot_name = Symbols::Dot().raw();
   } else if (name_obj.IsString()) {
-    dot_name = String::Concat(Symbols::DotHandle(), String::Cast(name_obj));
+    dot_name = String::Concat(Symbols::Dot(), String::Cast(name_obj));
   } else {
     RETURN_TYPE_ERROR(isolate, constructor_name, String);
   }
   const char* msg = CheckIsolateState(isolate);
   if (msg != NULL) {
     return Api::NewError("%s", msg);
   }
 
   // Resolve the constructor.
   result = ResolveConstructor(
@@ skipping 123 matching lines @@
     if (msg != NULL) {
       return Api::NewError("%s", msg);
     }
 
     const Class& cls = Class::Cast(obj);
     const Function& function = Function::Handle(
         isolate,
         Resolver::ResolveStatic(cls,
                                 function_name,
                                 number_of_arguments,
-                                Array::Handle(isolate),
+                                Object::empty_array(),
                                 Resolver::kIsQualified));
     if (function.IsNull()) {
       const String& cls_name = String::Handle(isolate, cls.Name());
       return Api::NewError("%s: did not find static method '%s.%s'.",
                            CURRENT_FUNC,
                            cls_name.ToCString(),
                            function_name.ToCString());
     }
     return Api::NewHandle(isolate, DartEntry::InvokeStatic(function, args));
 
@@ skipping 809 matching lines @@
   if (library_vm.IsNull()) {
     RETURN_TYPE_ERROR(isolate, library, Library);
   }
   const Library& import_vm = Api::UnwrapLibraryHandle(isolate, import);
   if (import_vm.IsNull()) {
     RETURN_TYPE_ERROR(isolate, import, Library);
   }
   const Object& prefix_object =
       Object::Handle(isolate, Api::UnwrapHandle(prefix));
   const String& prefix_vm = prefix_object.IsNull()
-      ? String::Handle(isolate, Symbols::New(""))
+      ? Symbols::Empty()
       : String::Cast(prefix_object);
   if (prefix_vm.IsNull()) {
     RETURN_TYPE_ERROR(isolate, prefix, String);
   }
   const String& prefix_symbol =
       String::Handle(isolate, Symbols::New(prefix_vm));
   const Namespace& import_ns = Namespace::Handle(
       Namespace::New(import_vm, Array::Handle(), Array::Handle()));
   if (prefix_vm.Length() == 0) {
     library_vm.AddImport(import_ns);
@@ skipping 123 matching lines @@
   }
   {
     NoGCScope no_gc;
     RawObject* raw_obj = obj.raw();
     isolate->heap()->SetPeer(raw_obj, peer);
   }
   return Api::Success(isolate);
 }
 
 }  // namespace dart