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

vm/object.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/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
@@ skipping 169 matching lines @@
   intptr_t suffix_len = at_pos - dot_pos;
   if (suffix_len > 1) {
     // This is a named constructor.  Add the name back to the string.
     const String& suffix =
         String::Handle(String::SubString(name, dot_pos, suffix_len));
     return String::Concat(result, suffix);
   }
 
   if (is_setter) {
     // Setters need to end with '='.
-    const String& suffix = String::Handle(Symbols::Equals());
-    return String::Concat(result, suffix);
+    return String::Concat(result, Symbols::Equals());
   }
 
   return result.raw();
 }
 
 
 template<typename type>
 static bool IsSpecialCharacter(type value) {
   return ((value == '"') ||
           (value == '\n') ||
@@ skipping 222 matching lines @@
     uword address = heap->Allocate(Array::InstanceSize(0), Heap::kOld);
     *empty_array_ = reinterpret_cast<RawArray*>(address + kHeapObjectTag);
     InitializeObject(address, kArrayCid, Array::InstanceSize(0));
     empty_array_->raw()->ptr()->length_ = Smi::New(0);
   }
 }
 
 
 #define SET_CLASS_NAME(class_name, name)                                       \
   cls = class_name##_class();                                                  \
-  str = Symbols::name();                                                       \
-  cls.set_name(str);                                                           \
+  cls.set_name(Symbols::name());                                               \
 
 void Object::RegisterSingletonClassNames() {
   Class& cls = Class::Handle();
-  String& str = String::Handle();
 
   // Set up names for all VM singleton classes.
   SET_CLASS_NAME(class, Class);
   SET_CLASS_NAME(null, Null);
   SET_CLASS_NAME(dynamic, Dynamic);
   SET_CLASS_NAME(void, Void);
   SET_CLASS_NAME(unresolved_class, UnresolvedClass);
   SET_CLASS_NAME(type_arguments, TypeArguments);
   SET_CLASS_NAME(instantiated_type_arguments, InstantiatedTypeArguments);
   SET_CLASS_NAME(patch_class, PatchClass);
@@ skipping 20 matching lines @@
   SET_CLASS_NAME(megamorphic_cache, MegamorphicCache);
   SET_CLASS_NAME(subtypetestcache, SubtypeTestCache);
   SET_CLASS_NAME(api_error, ApiError);
   SET_CLASS_NAME(language_error, LanguageError);
   SET_CLASS_NAME(unhandled_exception, UnhandledException);
   SET_CLASS_NAME(unwind_error, UnwindError);
 
   // Set up names for object array and one byte string class which are
   // pre-allocated in the vm isolate also.
   cls = Dart::vm_isolate()->object_store()->array_class();
-  str = Symbols::ObjectArray();
-  cls.set_name(str);
+  cls.set_name(Symbols::ObjectArray());
   cls = Dart::vm_isolate()->object_store()->one_byte_string_class();
-  str = Symbols::OneByteString();
-  cls.set_name(str);
+  cls.set_name(Symbols::OneByteString());
 }
 
 
 // Make unused space in an object whose type has been transformed safe
 // for traversing during GC.
 // The unused part of the transformed object is marked as an Array
 // object or a regular Object so that it can be traversed during garbage
 // collection.
 void Object::MakeUnusedSpaceTraversable(const Object& obj,
                                         intptr_t original_size,
@@ skipping 121 matching lines @@
 
   Context& context = Context::Handle(Context::New(0, Heap::kOld));
   object_store->set_empty_context(context);
 
   // Now that the symbol table is initialized and that the core dictionary as
   // well as the core implementation dictionary have been setup, preallocate
   // remaining classes and register them by name in the dictionaries.
   String& name = String::Handle();
   cls = Class::New<Bool>();
   object_store->set_bool_class(cls);
-  name = Symbols::Bool();
-  RegisterClass(cls, name, core_lib);
+  RegisterClass(cls, Symbols::Bool(), core_lib);
   pending_classes.Add(cls, Heap::kOld);
 
   cls = object_store->array_class();  // Was allocated above.
-  name = Symbols::ObjectArray();
-  RegisterPrivateClass(cls, name, core_lib);
+  RegisterPrivateClass(cls, Symbols::ObjectArray(), core_lib);
   pending_classes.Add(cls, Heap::kOld);
   // We cannot use NewNonParameterizedType(cls), because Array is parameterized.
   type ^= Type::New(Object::Handle(cls.raw()),
                     TypeArguments::Handle(),
                     Scanner::kDummyTokenIndex);
   type.set_is_finalized_instantiated();
   type ^= type.Canonicalize();
   object_store->set_array_type(type);
 
   cls = object_store->growable_object_array_class();  // Was allocated above.
-  name = Symbols::GrowableObjectArray();
-  RegisterPrivateClass(cls, name, core_lib);
+  RegisterPrivateClass(cls, Symbols::GrowableObjectArray(), core_lib);
   pending_classes.Add(cls, Heap::kOld);
 
   cls = Class::New<ImmutableArray>();
   object_store->set_immutable_array_class(cls);
   cls.set_type_arguments_field_offset(Array::type_arguments_offset());
   ASSERT(object_store->immutable_array_class() != object_store->array_class());
-  name = Symbols::ImmutableArray();
-  RegisterPrivateClass(cls, name, core_lib);
+  RegisterPrivateClass(cls, Symbols::ImmutableArray(), core_lib);
   pending_classes.Add(cls, Heap::kOld);
 
   cls = object_store->one_byte_string_class();  // Was allocated above.
-  name = Symbols::OneByteString();
-  RegisterPrivateClass(cls, name, core_lib);
+  RegisterPrivateClass(cls, Symbols::OneByteString(), core_lib);
   pending_classes.Add(cls, Heap::kOld);
 
   cls = object_store->two_byte_string_class();  // Was allocated above.
-  name = Symbols::TwoByteString();
-  RegisterPrivateClass(cls, name, core_lib);
+  RegisterPrivateClass(cls, Symbols::TwoByteString(), core_lib);
   pending_classes.Add(cls, Heap::kOld);
 
   cls = Class::NewStringClass(kExternalOneByteStringCid);
   object_store->set_external_one_byte_string_class(cls);
-  name = Symbols::ExternalOneByteString();
-  RegisterPrivateClass(cls, name, core_lib);
+  RegisterPrivateClass(cls, Symbols::ExternalOneByteString(), core_lib);
   pending_classes.Add(cls, Heap::kOld);
 
   cls = Class::NewStringClass(kExternalTwoByteStringCid);
   object_store->set_external_two_byte_string_class(cls);
-  name = Symbols::ExternalTwoByteString();
-  RegisterPrivateClass(cls, name, core_lib);
+  RegisterPrivateClass(cls, Symbols::ExternalTwoByteString(), core_lib);
   pending_classes.Add(cls, Heap::kOld);
 
   cls = Class::New<Stacktrace>();
   object_store->set_stacktrace_class(cls);
-  name = Symbols::Stacktrace();
-  RegisterClass(cls, name, core_lib);
+  RegisterClass(cls, Symbols::Stacktrace(), core_lib);
   pending_classes.Add(cls, Heap::kOld);
   // Super type set below, after Object is allocated.
 
   cls = Class::New<JSRegExp>();
   object_store->set_jsregexp_class(cls);
-  name = Symbols::JSSyntaxRegExp();
-  RegisterPrivateClass(cls, name, core_lib);
+  RegisterPrivateClass(cls, Symbols::JSSyntaxRegExp(), core_lib);
   pending_classes.Add(cls, Heap::kOld);
 
   // Initialize the base interfaces used by the core VM classes.
   const Script& script = Script::Handle(Bootstrap::LoadCoreScript(false));
 
   // Allocate and initialize the pre-allocated classes in the core library.
   cls = Class::New<Instance>(kInstanceCid);
   object_store->set_object_class(cls);
-  name = Symbols::Object();
-  cls.set_name(name);
+  cls.set_name(Symbols::Object());
   cls.set_script(script);
   cls.set_is_prefinalized();
   core_lib.AddClass(cls);
   pending_classes.Add(cls, Heap::kOld);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_object_type(type);
 
   cls = object_store->type_class();
-  name = Symbols::Type();
-  RegisterPrivateClass(cls, name, core_lib);
+  RegisterPrivateClass(cls, Symbols::Type(), core_lib);
   pending_classes.Add(cls, Heap::kOld);
 
   cls = object_store->type_parameter_class();
-  name = Symbols::TypeParameter();
-  RegisterPrivateClass(cls, name, core_lib);
+  RegisterPrivateClass(cls, Symbols::TypeParameter(), core_lib);
   pending_classes.Add(cls, Heap::kOld);
 
   cls = Class::New<Integer>();
   object_store->set_integer_implementation_class(cls);
-  name = Symbols::IntegerImplementation();
-  RegisterPrivateClass(cls, name, core_lib);
+  RegisterPrivateClass(cls, Symbols::IntegerImplementation(), core_lib);
   pending_classes.Add(cls, Heap::kOld);
 
   cls = Class::New<Smi>();
   object_store->set_smi_class(cls);
-  name = Symbols::Smi();
-  RegisterPrivateClass(cls, name, core_lib);
+  RegisterPrivateClass(cls, Symbols::_Smi(), core_lib);
   pending_classes.Add(cls, Heap::kOld);
 
   cls = Class::New<Mint>();
   object_store->set_mint_class(cls);
-  name = Symbols::Mint();
-  RegisterPrivateClass(cls, name, core_lib);
+  RegisterPrivateClass(cls, Symbols::_Mint(), core_lib);
   pending_classes.Add(cls, Heap::kOld);
 
   cls = Class::New<Bigint>();
   object_store->set_bigint_class(cls);
-  name = Symbols::Bigint();
-  RegisterPrivateClass(cls, name, core_lib);
+  RegisterPrivateClass(cls, Symbols::_Bigint(), core_lib);
   pending_classes.Add(cls, Heap::kOld);
 
   cls = Class::New<Double>();
   object_store->set_double_class(cls);
-  name = Symbols::Double();
-  RegisterPrivateClass(cls, name, core_lib);
+  RegisterPrivateClass(cls, Symbols::_Double(), core_lib);
   pending_classes.Add(cls, Heap::kOld);
 
   cls = Class::New<WeakProperty>();
   object_store->set_weak_property_class(cls);
-  name = Symbols::_WeakProperty();
-  RegisterPrivateClass(cls, name, core_lib);
+  RegisterPrivateClass(cls, Symbols::_WeakProperty(), core_lib);
 
   Library::InitScalarlistLibrary(isolate);
   Library& scalarlist_lib = Library::Handle(Library::ScalarlistLibrary());
 
   cls = Class::New<Int8Array>();
   object_store->set_int8_array_class(cls);
-  name = Symbols::_Int8Array();
-  RegisterPrivateClass(cls, name, scalarlist_lib);
+  RegisterPrivateClass(cls, Symbols::_Int8Array(), scalarlist_lib);
 
   cls = Class::New<Uint8Array>();
   object_store->set_uint8_array_class(cls);
-  name = Symbols::_Uint8Array();
-  RegisterPrivateClass(cls, name, scalarlist_lib);
+  RegisterPrivateClass(cls, Symbols::_Uint8Array(), scalarlist_lib);
 
   cls = Class::New<Uint8ClampedArray>();
   object_store->set_uint8_clamped_array_class(cls);
-  name = Symbols::_Uint8ClampedArray();
-  RegisterPrivateClass(cls, name, scalarlist_lib);
+  RegisterPrivateClass(cls, Symbols::_Uint8ClampedArray(), scalarlist_lib);
 
   cls = Class::New<Int16Array>();
   object_store->set_int16_array_class(cls);
-  name = Symbols::_Int16Array();
-  RegisterPrivateClass(cls, name, scalarlist_lib);
+  RegisterPrivateClass(cls, Symbols::_Int16Array(), scalarlist_lib);
 
   cls = Class::New<Uint16Array>();
   object_store->set_uint16_array_class(cls);
-  name = Symbols::_Uint16Array();
-  RegisterPrivateClass(cls, name, scalarlist_lib);
+  RegisterPrivateClass(cls, Symbols::_Uint16Array(), scalarlist_lib);
 
   cls = Class::New<Int32Array>();
   object_store->set_int32_array_class(cls);
-  name = Symbols::_Int32Array();
-  RegisterPrivateClass(cls, name, scalarlist_lib);
+  RegisterPrivateClass(cls, Symbols::_Int32Array(), scalarlist_lib);
 
   cls = Class::New<Uint32Array>();
   object_store->set_uint32_array_class(cls);
-  name = Symbols::_Uint32Array();
-  RegisterPrivateClass(cls, name, scalarlist_lib);
+  RegisterPrivateClass(cls, Symbols::_Uint32Array(), scalarlist_lib);
 
   cls = Class::New<Int64Array>();
   object_store->set_int64_array_class(cls);
-  name = Symbols::_Int64Array();
-  RegisterPrivateClass(cls, name, scalarlist_lib);
+  RegisterPrivateClass(cls, Symbols::_Int64Array(), scalarlist_lib);
 
   cls = Class::New<Uint64Array>();
   object_store->set_uint64_array_class(cls);
-  name = Symbols::_Uint64Array();
-  RegisterPrivateClass(cls, name, scalarlist_lib);
+  RegisterPrivateClass(cls, Symbols::_Uint64Array(), scalarlist_lib);
 
   cls = Class::New<Float32Array>();
   object_store->set_float32_array_class(cls);
-  name = Symbols::_Float32Array();
-  RegisterPrivateClass(cls, name, scalarlist_lib);
+  RegisterPrivateClass(cls, Symbols::_Float32Array(), scalarlist_lib);
 
   cls = Class::New<Float64Array>();
   object_store->set_float64_array_class(cls);
-  name = Symbols::_Float64Array();
-  RegisterPrivateClass(cls, name, scalarlist_lib);
+  RegisterPrivateClass(cls, Symbols::_Float64Array(), scalarlist_lib);
 
   cls = Class::New<ExternalInt8Array>();
   object_store->set_external_int8_array_class(cls);
-  name = Symbols::_ExternalInt8Array();
-  RegisterPrivateClass(cls, name, scalarlist_lib);
+  RegisterPrivateClass(cls, Symbols::_ExternalInt8Array(), scalarlist_lib);
 
   cls = Class::New<ExternalUint8Array>();
   object_store->set_external_uint8_array_class(cls);
-  name = Symbols::_ExternalUint8Array();
-  RegisterPrivateClass(cls, name, scalarlist_lib);
+  RegisterPrivateClass(cls, Symbols::_ExternalUint8Array(), scalarlist_lib);
 
   cls = Class::New<ExternalUint8ClampedArray>();
   object_store->set_external_uint8_clamped_array_class(cls);
-  name = Symbols::_ExternalUint8ClampedArray();
-  RegisterPrivateClass(cls, name, scalarlist_lib);
+  RegisterPrivateClass(cls,
+                       Symbols::_ExternalUint8ClampedArray(),
+                       scalarlist_lib);
 
   cls = Class::New<ExternalInt16Array>();
   object_store->set_external_int16_array_class(cls);
-  name = Symbols::_ExternalInt16Array();
-  RegisterPrivateClass(cls, name, scalarlist_lib);
+  RegisterPrivateClass(cls, Symbols::_ExternalInt16Array(), scalarlist_lib);
 
   cls = Class::New<ExternalUint16Array>();
   object_store->set_external_uint16_array_class(cls);
-  name = Symbols::_ExternalUint16Array();
-  RegisterPrivateClass(cls, name, scalarlist_lib);
+  RegisterPrivateClass(cls, Symbols::_ExternalUint16Array(), scalarlist_lib);
 
   cls = Class::New<ExternalInt32Array>();
   object_store->set_external_int32_array_class(cls);
-  name = Symbols::_ExternalInt32Array();
-  RegisterPrivateClass(cls, name, scalarlist_lib);
+  RegisterPrivateClass(cls, Symbols::_ExternalInt32Array(), scalarlist_lib);
 
   cls = Class::New<ExternalUint32Array>();
   object_store->set_external_uint32_array_class(cls);
-  name = Symbols::_ExternalUint32Array();
-  RegisterPrivateClass(cls, name, scalarlist_lib);
+  RegisterPrivateClass(cls, Symbols::_ExternalUint32Array(), scalarlist_lib);
 
   cls = Class::New<ExternalInt64Array>();
   object_store->set_external_int64_array_class(cls);
-  name = Symbols::_ExternalInt64Array();
-  RegisterPrivateClass(cls, name, scalarlist_lib);
+  RegisterPrivateClass(cls, Symbols::_ExternalInt64Array(), scalarlist_lib);
 
   cls = Class::New<ExternalUint64Array>();
   object_store->set_external_uint64_array_class(cls);
-  name = Symbols::_ExternalUint64Array();
-  RegisterPrivateClass(cls, name, scalarlist_lib);
+  RegisterPrivateClass(cls, Symbols::_ExternalUint64Array(), scalarlist_lib);
 
   cls = Class::New<ExternalFloat32Array>();
   object_store->set_external_float32_array_class(cls);
-  name = Symbols::_ExternalFloat32Array();
-  RegisterPrivateClass(cls, name, scalarlist_lib);
+  RegisterPrivateClass(cls, Symbols::_ExternalFloat32Array(), scalarlist_lib);
 
   cls = Class::New<ExternalFloat64Array>();
   object_store->set_external_float64_array_class(cls);
-  name = Symbols::_ExternalFloat64Array();
-  RegisterPrivateClass(cls, name, scalarlist_lib);
+  RegisterPrivateClass(cls, Symbols::_ExternalFloat64Array(), scalarlist_lib);
 
   // Set the super type of class Stacktrace to Object type so that the
   // 'toString' method is implemented.
   cls = object_store->stacktrace_class();
   cls.set_super_type(type);
 
   // Note: The abstract class Function is represented by VM class
   // DartFunction, not VM class Function.
-  name = Symbols::Function();
   cls = Class::New<DartFunction>();
-  RegisterClass(cls, name, core_lib);
+  RegisterClass(cls, Symbols::Function(), core_lib);
   pending_classes.Add(cls, Heap::kOld);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_function_type(type);
 
   cls = Class::New<Number>();
-  name = Symbols::Number();
-  RegisterClass(cls, name, core_lib);
+  RegisterClass(cls, Symbols::Number(), core_lib);
   pending_classes.Add(cls, Heap::kOld);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_number_type(type);
 
-  name = Symbols::New("int");
-  cls = Class::New<Instance>(name, script, Scanner::kDummyTokenIndex);
-  RegisterClass(cls, name, core_lib);
+  cls = Class::New<Instance>(Symbols::Int(), script, Scanner::kDummyTokenIndex);
+  RegisterClass(cls, Symbols::Int(), core_lib);
   pending_classes.Add(cls, Heap::kOld);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_int_type(type);
 
-  name = Symbols::New("double");
-  cls = Class::New<Instance>(name, script, Scanner::kDummyTokenIndex);
-  RegisterClass(cls, name, core_lib);
+  cls = Class::New<Instance>(Symbols::Double(),
+                             script,
+                             Scanner::kDummyTokenIndex);
+  RegisterClass(cls, Symbols::Double(), core_lib);
   pending_classes.Add(cls, Heap::kOld);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_double_type(type);
 
   name = Symbols::New("String");
   cls = Class::New<Instance>(name, script, Scanner::kDummyTokenIndex);
   RegisterClass(cls, name, core_lib);
   pending_classes.Add(cls, Heap::kOld);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_string_type(type);
 
-  name = Symbols::New("List");
-  cls = Class::New<Instance>(name, script, Scanner::kDummyTokenIndex);
-  RegisterClass(cls, name, core_lib);
+  cls = Class::New<Instance>(Symbols::List(),
+                             script,
+                             Scanner::kDummyTokenIndex);
+  RegisterClass(cls, Symbols::List(), core_lib);
   pending_classes.Add(cls, Heap::kOld);
   object_store->set_list_class(cls);
 
   cls = object_store->bool_class();
   type = Type::NewNonParameterizedType(cls);
   object_store->set_bool_type(type);
 
   cls = object_store->smi_class();
   type = Type::NewNonParameterizedType(cls);
   object_store->set_smi_type(type);
@@ skipping 370 matching lines @@
 
 RawString* Class::UserVisibleName() const {
   if (FLAG_show_internal_names) {
     return Name();
   }
   switch (id()) {
     case kIntegerCid:
     case kSmiCid:
     case kMintCid:
     case kBigintCid:
-      return Symbols::New("int");
+      return Symbols::Int().raw();
     case kDoubleCid:
-      return Symbols::New("double");
+      return Symbols::Double().raw();
     case kOneByteStringCid:
     case kTwoByteStringCid:
     case kExternalOneByteStringCid:
     case kExternalTwoByteStringCid:
       return Symbols::New("String");
     case kArrayCid:
     case kImmutableArrayCid:
     case kGrowableObjectArrayCid:
-      return Symbols::New("List");
+      return Symbols::List().raw();
     case kInt8ArrayCid:
     case kExternalInt8ArrayCid:
-      return Symbols::New("Int8List");
+      return Symbols::Int8List().raw();
     case kUint8ArrayCid:
     case kExternalUint8ArrayCid:
-      return Symbols::New("Uint8List");
+      return Symbols::Uint8List().raw();
     case kUint8ClampedArrayCid:
     case kExternalUint8ClampedArrayCid:
-      return Symbols::New("Uint8ClampedList");
+      return Symbols::Uint8ClampedList().raw();
     case kInt16ArrayCid:
     case kExternalInt16ArrayCid:
-      return Symbols::New("Int16List");
+      return Symbols::Int16List().raw();
     case kUint16ArrayCid:
     case kExternalUint16ArrayCid:
-      return Symbols::New("Uint16List");
+      return Symbols::Uint16List().raw();
     case kInt32ArrayCid:
     case kExternalInt32ArrayCid:
-      return Symbols::New("Int32List");
+      return Symbols::Int32List().raw();
     case kUint32ArrayCid:
     case kExternalUint32ArrayCid:
-      return Symbols::New("Uint32List");
+      return Symbols::Uint32List().raw();
     case kInt64ArrayCid:
     case kExternalInt64ArrayCid:
-      return Symbols::New("Int64List");
+      return Symbols::Int64List().raw();
     case kUint64ArrayCid:
     case kExternalUint64ArrayCid:
-      return Symbols::New("Uint64List");
+      return Symbols::Uint64List().raw();
     case kFloat32ArrayCid:
     case kExternalFloat32ArrayCid:
-      return Symbols::New("Float32List");
+      return Symbols::Float32List().raw();
     case kFloat64ArrayCid:
     case kExternalFloat64ArrayCid:
-      return Symbols::New("Float64List");
+      return Symbols::Float64List().raw();
     default:
       if (!IsSignatureClass()) {
         const String& name = String::Handle(Name());
         return IdentifierPrettyName(name);
       } else {
         return Name();
       }
   }
   UNREACHABLE();
 }
@@ skipping 766 matching lines @@
       }
       // Check for two function types.
       const Function& fun = Function::Handle(signature_function());
       return fun.TypeTest(test_kind,
                           type_arguments,
                           other_fun,
                           other_type_arguments,
                           malformed_error);
     }
     // Check if type S has a call() method of function type T.
-    const String& function_name = String::Handle(Symbols::Call());
-    Function& function = Function::Handle(LookupDynamicFunction(function_name));
+    Function& function =
+        Function::Handle(LookupDynamicFunction(Symbols::Call()));
     if (function.IsNull()) {
       // Walk up the super_class chain.
       Class& cls = Class::Handle(SuperClass());
       while (!cls.IsNull() && function.IsNull()) {
-        function = cls.LookupDynamicFunction(function_name);
+        function = cls.LookupDynamicFunction(Symbols::Call());
         cls = cls.SuperClass();
       }
     }
     if (!function.IsNull()) {
       if (other_is_function_class ||
           function.TypeTest(test_kind,
                             type_arguments,
                             other_fun,
                             other_type_arguments,
                             malformed_error)) {
@@ skipping 327 matching lines @@
 void UnresolvedClass::set_library_prefix(
     const LibraryPrefix& library_prefix) const {
   StorePointer(&raw_ptr()->library_prefix_, library_prefix.raw());
 }
 
 
 RawString* UnresolvedClass::Name() const {
   if (library_prefix() != LibraryPrefix::null()) {
     const LibraryPrefix& lib_prefix = LibraryPrefix::Handle(library_prefix());
     String& name = String::Handle();
-    String& str = String::Handle();
     name = lib_prefix.name();  // Qualifier.
-    str = Symbols::Dot();
-    name = String::Concat(name, str);
-    str = ident();
+    name = String::Concat(name, Symbols::Dot());
+    const String& str = String::Handle(ident());
     name = String::Concat(name, str);
     return name.raw();
   } else {
     return ident();
   }
 }
 
 
 const char* UnresolvedClass::ToCString() const {
   const char* format = "unresolved class '%s'";
@@ skipping 72 matching lines @@
 
 RawString* AbstractTypeArguments::SubvectorName(
     intptr_t from_index,
     intptr_t len,
     NameVisibility name_visibility) const {
   ASSERT(from_index + len <= Length());
   String& name = String::Handle();
   const intptr_t num_strings = 2*len + 1;  // "<""T"", ""T"">".
   const Array& strings = Array::Handle(Array::New(num_strings));
   intptr_t s = 0;
-  strings.SetAt(s++, String::Handle(Symbols::New("<")));
-  const String& kCommaSpace = String::Handle(Symbols::New(", "));
+  strings.SetAt(s++, Symbols::LAngleBracket());
   AbstractType& type = AbstractType::Handle();
   for (intptr_t i = 0; i < len; i++) {
     type = TypeAt(from_index + i);
     name = type.BuildName(name_visibility);
     strings.SetAt(s++, name);
     if (i < len - 1) {
-      strings.SetAt(s++, kCommaSpace);
+      strings.SetAt(s++, Symbols::CommaSpace());
     }
   }
-  strings.SetAt(s++, String::Handle(Symbols::New(">")));
+  strings.SetAt(s++, Symbols::RAngleBracket());
   ASSERT(s == num_strings);
   name = String::ConcatAll(strings);
   return Symbols::New(name);
 }
 
 
 bool AbstractTypeArguments::Equals(const AbstractTypeArguments& other) const {
   ASSERT(!IsNull());  // Use AbstractTypeArguments::AreEqual().
   if (this->raw() == other.raw()) {
     return true;
@@ skipping 928 matching lines @@
 
 void Function::set_is_inlinable(bool value) const {
   set_kind_tag(InlinableBit::update(value, raw_ptr()->kind_tag_));
 }
 
 
 bool Function::IsInlineable() const {
   // '==' call is handled specially.
   return InlinableBit::decode(raw_ptr()->kind_tag_) &&
          HasCode() &&
-         name() != Symbols::EqualOperator();
+         name() != Symbols::EqualOperator().raw();
 }
 
 
 intptr_t Function::NumParameters() const {
   return num_fixed_parameters() + NumOptionalParameters();
 }
 
 
 intptr_t Function::NumImplicitParameters() const {
   if (kind() == RawFunction::kConstructor) {
@@ skipping 480 matching lines @@
   closure_function.SetNumOptionalParameters(num_opt_params, has_opt_pos_params);
   closure_function.set_parameter_types(Array::Handle(Array::New(num_params,
                                                                 Heap::kOld)));
   closure_function.set_parameter_names(Array::Handle(Array::New(num_params,
                                                                 Heap::kOld)));
   AbstractType& param_type = AbstractType::Handle();
   String& param_name = String::Handle();
   // Add implicit closure object parameter.
   param_type = Type::DynamicType();
   closure_function.SetParameterTypeAt(0, param_type);
-  param_name = Symbols::ClosureParameter();
-  closure_function.SetParameterNameAt(0, param_name);
+  closure_function.SetParameterNameAt(0, Symbols::ClosureParameter());
   for (int i = kClosure; i < num_params; i++) {
     param_type = ParameterTypeAt(has_receiver - kClosure + i);
     closure_function.SetParameterTypeAt(i, param_type);
     param_name = ParameterNameAt(has_receiver - kClosure + i);
     closure_function.SetParameterNameAt(i, param_name);
   }
 
   // Lookup or create a new signature class for the closure function in the
   // library of the owner class.
   const Class& owner_class = Class::Handle(Owner());
@@ skipping 23 matching lines @@
   return closure_function.raw();
 }
 
 
 RawString* Function::BuildSignature(
     bool instantiate,
     NameVisibility name_visibility,
     const AbstractTypeArguments& instantiator) const {
   const GrowableObjectArray& pieces =
       GrowableObjectArray::Handle(GrowableObjectArray::New());
-  const String& kCommaSpace = String::Handle(Symbols::New(", "));
-  const String& kColonSpace = String::Handle(Symbols::New(": "));
-  const String& kLParen = String::Handle(Symbols::New("("));
-  const String& kRParenArrow = String::Handle(Symbols::New(") => "));
-  const String& kLBracket = String::Handle(Symbols::New("["));
-  const String& kRBracket = String::Handle(Symbols::New("]"));
-  const String& kLBrace = String::Handle(Symbols::New("{"));
-  const String& kRBrace = String::Handle(Symbols::New("}"));
   String& name = String::Handle();
   if (!instantiate && !is_static() && (name_visibility == kInternalName)) {
     // Prefix the signature with its class and type parameters, if any (e.g.
     // "Map<K, V>(K) => bool").
     // The signature of static functions cannot be type parameterized.
-    const String& kSpaceExtendsSpace =
-        String::Handle(Symbols::New(" extends "));
-    const String& kLAngleBracket = String::Handle(Symbols::New("<"));
-    const String& kRAngleBracket = String::Handle(Symbols::New(">"));
     const Class& function_class = Class::Handle(Owner());
     ASSERT(!function_class.IsNull());
     const TypeArguments& type_parameters = TypeArguments::Handle(
         function_class.type_parameters());
     if (!type_parameters.IsNull()) {
       const String& function_class_name = String::Handle(function_class.Name());
       pieces.Add(function_class_name);
       intptr_t num_type_parameters = type_parameters.Length();
-      pieces.Add(kLAngleBracket);
+      pieces.Add(Symbols::LAngleBracket());
       TypeParameter& type_parameter = TypeParameter::Handle();
       AbstractType& bound = AbstractType::Handle();
       for (intptr_t i = 0; i < num_type_parameters; i++) {
         type_parameter ^= type_parameters.TypeAt(i);
         name = type_parameter.name();
         pieces.Add(name);
         bound = type_parameter.bound();
         if (!bound.IsNull() && !bound.IsObjectType()) {
-          pieces.Add(kSpaceExtendsSpace);
+          pieces.Add(Symbols::SpaceExtendsSpace());
           name = bound.BuildName(name_visibility);
           pieces.Add(name);
         }
         if (i < num_type_parameters - 1) {
-          pieces.Add(kCommaSpace);
+          pieces.Add(Symbols::CommaSpace());
         }
       }
-      pieces.Add(kRAngleBracket);
+      pieces.Add(Symbols::RAngleBracket());
     }
   }
   AbstractType& param_type = AbstractType::Handle();
   const intptr_t num_params = NumParameters();
   const intptr_t num_fixed_params = num_fixed_parameters();
   const intptr_t num_opt_pos_params = NumOptionalPositionalParameters();
   const intptr_t num_opt_named_params = NumOptionalNamedParameters();
   const intptr_t num_opt_params = num_opt_pos_params + num_opt_named_params;
   ASSERT((num_fixed_params + num_opt_params) == num_params);
-  pieces.Add(kLParen);
+  pieces.Add(Symbols::LParen());
   intptr_t i = 0;
   if (name_visibility == kUserVisibleName) {
     // Hide implicit parameters.
     i = NumImplicitParameters();
   }
   while (i < num_fixed_params) {
     param_type = ParameterTypeAt(i);
     ASSERT(!param_type.IsNull());
     if (instantiate && !param_type.IsInstantiated()) {
       param_type = param_type.InstantiateFrom(instantiator);
     }
     name = param_type.BuildName(name_visibility);
     pieces.Add(name);
     if (i != (num_params - 1)) {
-      pieces.Add(kCommaSpace);
+      pieces.Add(Symbols::CommaSpace());
     }
     i++;
   }
   if (num_opt_params > 0) {
     if (num_opt_pos_params > 0) {
-      pieces.Add(kLBracket);
+      pieces.Add(Symbols::LBracket());
     } else {
-      pieces.Add(kLBrace);
+      pieces.Add(Symbols::LBrace());
     }
     for (intptr_t i = num_fixed_params; i < num_params; i++) {
       // The parameter name of an optional positional parameter does not need
       // to be part of the signature, since it is not used.
       if (num_opt_named_params > 0) {
         name = ParameterNameAt(i);
         pieces.Add(name);
-        pieces.Add(kColonSpace);
+        pieces.Add(Symbols::ColonSpace());
       }
       param_type = ParameterTypeAt(i);
       if (instantiate && !param_type.IsInstantiated()) {
         param_type = param_type.InstantiateFrom(instantiator);
       }
       ASSERT(!param_type.IsNull());
       name = param_type.BuildName(name_visibility);
       pieces.Add(name);
       if (i != (num_params - 1)) {
-        pieces.Add(kCommaSpace);
+        pieces.Add(Symbols::CommaSpace());
       }
     }
     if (num_opt_pos_params > 0) {
-      pieces.Add(kRBracket);
+      pieces.Add(Symbols::RBracket());
     } else {
-      pieces.Add(kRBrace);
+      pieces.Add(Symbols::RBrace());
     }
   }
-  pieces.Add(kRParenArrow);
+  pieces.Add(Symbols::RParenArrow());
   AbstractType& res_type = AbstractType::Handle(result_type());
   if (instantiate && !res_type.IsInstantiated()) {
     res_type = res_type.InstantiateFrom(instantiator);
   }
   name = res_type.BuildName(name_visibility);
   pieces.Add(name);
   const Array& strings = Array::Handle(Array::MakeArray(pieces));
   return Symbols::New(String::Handle(String::ConcatAll(strings)));
 }
 
@@ skipping 40 matching lines @@
 
 
 RawString* Function::UserVisibleName() const {
   const String& str = String::Handle(name());
   return IdentifierPrettyName(str);
 }
 
 
 RawString* Function::QualifiedUserVisibleName() const {
   String& tmp = String::Handle();
-  String& suffix = String::Handle();
   const Class& cls = Class::Handle(Owner());
 
   if (IsClosureFunction()) {
     if (IsLocalFunction()) {
       const Function& parent = Function::Handle(parent_function());
       tmp = parent.QualifiedUserVisibleName();
     } else {
       return UserVisibleName();
     }
   } else {
     if (cls.IsTopLevel()) {
       return UserVisibleName();
     } else {
       tmp = cls.UserVisibleName();
     }
   }
-  suffix = Symbols::Dot();
-  tmp = String::Concat(tmp, suffix);
-  suffix = UserVisibleName();
+  tmp = String::Concat(tmp, Symbols::Dot());
+  const String& suffix = String::Handle(UserVisibleName());
   return String::Concat(tmp, suffix);
 }
 
 
 // Construct fingerprint from token stream. The token stream contains also
 // arguments.
 int32_t Function::SourceFingerprint() const {
   uint32_t result = String::Handle(Signature()).Hash();
   TokenStream::Iterator tokens_iterator(TokenStream::Handle(
       Script::Handle(script()).tokens()), token_pos());
@@ skipping 146 matching lines @@
 
 RawString* Field::GetterName(const String& field_name) {
   String& str = String::Handle();
   str = String::New(kGetterPrefix);
   str = String::Concat(str, field_name);
   return str.raw();
 }
 
 
 RawString* Field::GetterSymbol(const String& field_name) {
-  String& str = String::Handle();
-  str = Field::GetterName(field_name);
+  const String& str = String::Handle(Field::GetterName(field_name));
   return Symbols::New(str);
 }
 
 
 RawString* Field::SetterName(const String& field_name) {
   String& str = String::Handle();
   str = String::New(kSetterPrefix);
   str = String::Concat(str, field_name);
   return str.raw();
 }
 
 
 RawString* Field::SetterSymbol(const String& field_name) {
-  String& str = String::Handle();
-  str = Field::SetterName(field_name);
+  const String& str = String::Handle(Field::SetterName(field_name));
   return Symbols::New(str);
 }
 
 
 RawString* Field::NameFromGetter(const String& getter_name) {
   String& str = String::Handle();
   str = String::SubString(getter_name, strlen(kGetterPrefix));
   return str.raw();
 }
 
@@ skipping 176 matching lines @@
 
 
 RawString* TokenStream::GenerateSource() const {
   Iterator iterator(*this, 0);
   const ExternalUint8Array& data = ExternalUint8Array::Handle(GetStream());
   const GrowableObjectArray& literals =
       GrowableObjectArray::Handle(GrowableObjectArray::New(data.Length()));
   const String& private_key = String::Handle(PrivateKey());
   intptr_t private_len = private_key.Length();
 
-  String& blank = String::Handle(String::New(" "));
-  String& newline = String::Handle(String::New("\n"));
-  String& two_newlines = String::Handle(String::New("\n\n"));
-  String& double_quotes = String::Handle(String::New("\""));
-  String& dollar = String::Handle(String::New("$"));
-  String& two_spaces = String::Handle(String::New("  "));
-  String& raw_string = String::Handle(String::New("r"));
-
   Token::Kind curr = iterator.CurrentTokenKind();
   Token::Kind prev = Token::kILLEGAL;
   // Handles used in the loop.
   Object& obj = Object::Handle();
   String& literal = String::Handle();
   // Current indentation level.
   int indent = 0;
 
   while (curr != Token::kEOS) {
     // Remember current values for this token.
@@ skipping 20 matching lines @@
               (prev != Token::kINTERPOL_VAR) &&
               (prev != Token::kINTERPOL_END)) {
             is_raw_string = true;
           } else {
             escape_characters = true;
           }
         }
       }
       if ((prev != Token::kINTERPOL_VAR) && (prev != Token::kINTERPOL_END)) {
         if (is_raw_string) {
-          literals.Add(raw_string);
+          literals.Add(Symbols::LowercaseR());
         }
-        literals.Add(double_quotes);
+        literals.Add(Symbols::DoubleQuotes());
       }
       if (escape_characters) {
         literal = String::EscapeSpecialCharacters(literal, is_raw_string);
         literals.Add(literal);
       } else {
         literals.Add(literal);
       }
       if ((next != Token::kINTERPOL_VAR) && (next != Token::kINTERPOL_START)) {
-        literals.Add(double_quotes);
+        literals.Add(Symbols::DoubleQuotes());
       }
     } else if (curr == Token::kINTERPOL_VAR) {
-      literals.Add(dollar);
+      literals.Add(Symbols::Dollar());
       if (literal.CharAt(0) == Scanner::kPrivateIdentifierStart) {
         literal = String::SubString(literal, 0, literal.Length() - private_len);
       }
       literals.Add(literal);
     } else if (curr == Token::kIDENT) {
       if (literal.CharAt(0) == Scanner::kPrivateIdentifierStart) {
         literal = String::SubString(literal, 0, literal.Length() - private_len);
       }
       literals.Add(literal);
     } else {
       literals.Add(literal);
     }
     // Determine the separation text based on this current token.
     const String* separator = NULL;
     switch (curr) {
       case Token::kLBRACE:
         indent++;
-        separator = &newline;
+        separator = &Symbols::NewLine();
         break;
       case Token::kRBRACE:
         if (indent == 0) {
-          separator = &two_newlines;
+          separator = &Symbols::TwoNewlines();
         } else {
-          separator = &newline;
+          separator = &Symbols::NewLine();
         }
         break;
       case Token::kSEMICOLON:
-        separator = &newline;
+        separator = &Symbols::NewLine();
         break;
       case Token::kPERIOD:
       case Token::kLPAREN:
       case Token::kLBRACK:
       case Token::kTIGHTADD:
       case Token::kINTERPOL_VAR:
       case Token::kINTERPOL_START:
       case Token::kINTERPOL_END:
         break;
       default:
-        separator = &blank;
+        separator = &Symbols::Blank();
         break;
     }
     // Determine whether the separation text needs to be updated based on the
     // next token.
     switch (next) {
       case Token::kRBRACE:
         indent--;
         break;
       case Token::kSEMICOLON:
       case Token::kPERIOD:
       case Token::kCOMMA:
       case Token::kLPAREN:
       case Token::kRPAREN:
       case Token::kLBRACK:
       case Token::kRBRACK:
       case Token::kINTERPOL_VAR:
       case Token::kINTERPOL_START:
       case Token::kINTERPOL_END:
         separator = NULL;
         break;
       case Token::kELSE:
-        separator = &blank;
+        separator = &Symbols::Blank();
       default:
         // Do nothing.
         break;
     }
     // Update the few cases where both tokens need to be taken into account.
     if (((curr == Token::kIF) || (curr == Token::kFOR)) &&
         (next == Token::kLPAREN)) {
-      separator = &blank;
+      separator = &Symbols::Blank();
     } else if ((curr == Token::kASSIGN) && (next == Token::kLPAREN)) {
-      separator = & blank;
+      separator = &Symbols::Blank();
     } else if ((curr == Token::kLBRACE) && (next == Token::kRBRACE)) {
       separator = NULL;
     }
     if (separator != NULL) {
       literals.Add(*separator);
-      if (separator == &newline) {
+      if (separator == &Symbols::NewLine()) {
         for (int i = 0; i < indent; i++) {
-          literals.Add(two_spaces);
+          literals.Add(Symbols::TwoSpaces());
         }
       }
     }
     // Setup for next iteration.
     prev = curr;
     curr = next;
   }
   const Array& source = Array::Handle(Array::MakeArray(literals));
   return String::ConcatAll(source);
 }
@@ skipping 412 matching lines @@
   if (FLAG_compiler_stats) {
     CompilerStats::src_length += src.Length();
   }
 }
 
 
 void Script::GetTokenLocation(intptr_t token_pos,
                               intptr_t* line,
                               intptr_t* column) const {
   const String& src = String::Handle(Source());
-  const String& dummy_key = String::Handle(Symbols::Empty());
   const TokenStream& tkns = TokenStream::Handle(tokens());
   intptr_t src_pos = tkns.ComputeSourcePosition(token_pos);
-  Scanner scanner(src, dummy_key);
+  Scanner scanner(src, Symbols::Empty());
   scanner.ScanTo(src_pos);
   *line = scanner.CurrentPosition().line;
   *column = scanner.CurrentPosition().column;
 }
 
 
 void Script::TokenRangeAtLine(intptr_t line_number,
                               intptr_t* first_token_index,
                               intptr_t* last_token_index) const {
   const String& src = String::Handle(Source());
-  const String& dummy_key = String::Handle(Symbols::Empty());
   const TokenStream& tkns = TokenStream::Handle(tokens());
-  Scanner scanner(src, dummy_key);
+  Scanner scanner(src, Symbols::Empty());
   scanner.TokenRangeAtLine(line_number, first_token_index, last_token_index);
   if (*first_token_index >= 0) {
     *first_token_index = tkns.ComputeTokenPosition(*first_token_index);
   }
   if (*last_token_index >= 0) {
     *last_token_index = tkns.ComputeTokenPosition(*last_token_index);
   }
 }
 
 
@@ skipping 12 matching lines @@
       current_line++;
     } else if (src.CharAt(ix) == '\r') {
       if ((ix + 1 != src.Length()) && (src.CharAt(ix + 1) != '\n')) {
         current_line++;
       }
     } else {
       last_char = ix;
     }
   }
   // Guarantee that returned string is never NULL.
-  String& line = String::Handle(Symbols::Empty());
   if (line_start >= 0) {
-    line = String::SubString(src, line_start, last_char - line_start + 1);
+    const String& line = String::Handle(
+        String::SubString(src, line_start, last_char - line_start + 1));
+    return line.raw();
+  } else {
+    return Symbols::Empty().raw();
   }
-  return line.raw();
 }
 
 
 RawString* Script::GetSnippet(intptr_t from_line,
                               intptr_t from_column,
                               intptr_t to_line,
                               intptr_t to_column) const {
   const String& src = String::Handle(Source());
   intptr_t length = src.Length();
   intptr_t line = 1;
@@ skipping 3249 matching lines @@
   if (cls.IsSignatureClass()) {
     if (function != NULL) {
       *function = Closure::function(*this);
     }
     if (context != NULL) {
       *context = Closure::context(*this);
     }
     return true;
   }
   // Try to resolve a "call" method.
-  const String& call_symbol = String::Handle(Symbols::Call());
   Function& call_function = Function::Handle();
   do {
-    call_function = cls.LookupDynamicFunction(call_symbol);
+    call_function = cls.LookupDynamicFunction(Symbols::Call());
     if (!call_function.IsNull()) {
       if (function != NULL) {
         *function = call_function.raw();
       }
       if (context != NULL) {
         *context = Isolate::Current()->object_store()->empty_context();
       }
       return true;
     }
     cls = cls.SuperClass();
@@ skipping 2124 matching lines @@
 
 
 RawString* String::SubString(const String& str,
                              intptr_t begin_index,
                              intptr_t length,
                              Heap::Space space) {
   ASSERT(!str.IsNull());
   ASSERT(begin_index >= 0);
   ASSERT(length >= 0);
   if (begin_index <= str.Length() && length == 0) {
-    return Symbols::Empty();
+    return Symbols::Empty().raw();
   }
   if (begin_index > str.Length()) {
     return String::null();
   }
   String& result = String::Handle();
   bool is_one_byte_string = true;
   intptr_t char_size = str.CharSize();
   if (char_size == kTwoByteChar) {
     for (intptr_t i = begin_index; i < begin_index + length; ++i) {
       if (!Utf::IsLatin1(str.CharAt(i))) {
@@ skipping 392 matching lines @@
 
 
 RawOneByteString* OneByteString::SubStringUnchecked(const String& str,
                                                     intptr_t begin_index,
                                                     intptr_t length,
                                                     Heap::Space space) {
   ASSERT(!str.IsNull() && str.IsOneByteString());
   ASSERT(begin_index >= 0);
   ASSERT(length >= 0);
   if (begin_index <= str.Length() && length == 0) {
-    return OneByteString::raw(String::Handle(Symbols::Empty()));
+    return OneByteString::raw(Symbols::Empty());
   }
   ASSERT(begin_index < str.Length());
   RawOneByteString* result = OneByteString::New(length, space);
   NoGCScope no_gc;
   if (length > 0) {
     uint8_t* dest = &result->ptr()->data_[0];
     uint8_t* src =  &raw_ptr(str)->data_[begin_index];
     memmove(dest, src, length);
   }
   return result;
@@ skipping 1386 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart