Avoid redundant allocation of accessor names.

runtime/vm/symbols.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/symbols.h"
 
 #include "vm/handles.h"
 #include "vm/handles_impl.h"
 #include "vm/hash_table.h"
 #include "vm/isolate.h"
@@ skipping 152 matching lines @@
   } else {
     String& result = String::Handle(
         String::SubString(str_, begin_index_, len_, Heap::kOld));
     result.SetCanonical();
     result.SetHash(hash_);
     return result.raw();
   }
 }
 
 
+class ConcatString {
+ public:
+  ConcatString(const String& str1, const String& str2)
+      : str1_(str1), str2_(str2), hash_(String::HashConcat(str1, str2)) {}
+  RawString* ToSymbol() const;
+  bool Equals(const String& other) const {
+    return other.EqualsConcat(str1_, str2_);
+  }
+  intptr_t Hash() const { return hash_; }
+ private:
+  const String& str1_;
+  const String& str2_;
+  intptr_t hash_;
+};
+
+
+RawString* ConcatString::ToSymbol() const {
+  String& result = String::Handle(String::Concat(str1_, str2_, Heap::kOld));
+  result.SetCanonical();
+  result.SetHash(hash_);
+  return result.raw();
+}
+
+
 class SymbolTraits {
  public:
   static bool IsMatch(const Object& a, const Object& b) {
     return String::Cast(a).Equals(String::Cast(b));
   }
   template<typename CharType>
   static bool IsMatch(const CharArray<CharType>& array, const Object& obj) {
     return array.Equals(String::Cast(obj));
   }
   static bool IsMatch(const StringSlice& slice, const Object& obj) {
     return slice.Equals(String::Cast(obj));
   }
+  static bool IsMatch(const ConcatString& concat, const Object& obj) {
+    return concat.Equals(String::Cast(obj));
+  }
   static uword Hash(const Object& key) {
     return String::Cast(key).Hash();
   }
   template<typename CharType>
   static uword Hash(const CharArray<CharType>& array) {
     return array.Hash();
   }
   static uword Hash(const StringSlice& slice) {
     return slice.Hash();
   }
+  static uword Hash(const ConcatString& concat) {
+    return concat.Hash();
+  }
   template<typename CharType>
   static RawObject* NewKey(const CharArray<CharType>& array) {
     return array.ToSymbol();
   }
   static RawObject* NewKey(const StringSlice& slice) {
     return slice.ToSymbol();
   }
+  static RawObject* NewKey(const ConcatString& concat) {
+    return concat.ToSymbol();
+  }
 };
 typedef UnorderedHashSet<SymbolTraits> SymbolTable;
 
 
 void Symbols::SetupSymbolTable(Isolate* isolate) {
   ASSERT(isolate != NULL);
 
   // Setup the symbol table used within the String class.
   const intptr_t initial_size = (isolate == Dart::vm_isolate()) ?
       kInitialVMIsolateSymtabSize : kInitialSymtabSize;
@@ skipping 59 matching lines @@
 RawString* Symbols::FromUTF16(const uint16_t* utf16_array, intptr_t len) {
   return NewSymbol(UTF16Array(utf16_array, len));
 }
 
 
 RawString* Symbols::FromUTF32(const int32_t* utf32_array, intptr_t len) {
   return NewSymbol(UTF32Array(utf32_array, len));
 }
 
 
-// StringType can be StringSlice, Latin1Array, UTF16Array or UTF32Array.
+RawString* Symbols::FromConcat(const String& str1, const String& str2) {
+  return NewSymbol(ConcatString(str1, str2));
+}
+
+
+// StringType can be StringSlice, ConcatString, or {Latin1,UTF16,UTF32}Array.
 template<typename StringType>
 RawString* Symbols::NewSymbol(const StringType& str) {
   Isolate* isolate = Isolate::Current();
   String& symbol = String::Handle(isolate);
   {
     Isolate* vm_isolate = Dart::vm_isolate();
     SymbolTable table(isolate, vm_isolate->object_store()->symbol_table());
     symbol ^= table.GetOrNull(str);
     table.Release();
   }
@@ skipping 59 matching lines @@
 RawObject* Symbols::GetVMSymbol(intptr_t object_id) {
   ASSERT(IsVMSymbolId(object_id));
   intptr_t i = (object_id - kMaxPredefinedObjectIds);
   if ((i > kIllegal) && (i < Symbols::kMaxPredefinedId)) {
     return symbol_handles_[i]->raw();
   }
   return Object::null();
 }
 
 }  // namespace dart