- Refactor Symbol allocation to expect a thread parameter.

runtime/vm/symbols.h

 // 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.
 
 #ifndef VM_SYMBOLS_H_
 #define VM_SYMBOLS_H_
 
 #include "vm/growable_array.h"
 #include "vm/object.h"
 #include "vm/snapshot_ids.h"
@@ skipping 15 matching lines @@
   V(UnaryMinus, "unary-")                                                      \
   V(Identical, "identical")                                                    \
   V(Length, "length")                                                          \
   V(_setLength, "_setLength")                                                  \
   V(IndexToken, "[]")                                                          \
   V(AssignIndexToken, "[]=")                                                   \
   V(TopLevel, "::")                                                            \
   V(DefaultLabel, ":L")                                                        \
   V(Other, "other")                                                            \
   V(Call, "call")                                                              \
+  V(GetCall, "get:call")                                                       \
   V(Current, "current")                                                        \
   V(_current, "_current")                                                      \
   V(MoveNext, "moveNext")                                                      \
   V(IsYieldEach, "isYieldEach")                                                \
   V(Value, "value")                                                            \
   V(_EnumHelper, "_EnumHelper")                                                \
   V(_SyncIterable, "_SyncIterable")                                            \
   V(_SyncIterableConstructor, "_SyncIterable.")                                \
   V(_SyncIterator, "_SyncIterator")                                            \
   V(IteratorParameter, ":iterator")                                            \
   V(_AsyncStarStreamController, "_AsyncStarStreamController")                  \
   V(_AsyncStarStreamControllerConstructor, "_AsyncStarStreamController.")      \
   V(Controller, ":controller")                                                 \
   V(Stream, "stream")                                                          \
   V(isPaused, "isPaused")                                                      \
   V(AddError, "addError")                                                      \
   V(AddStream, "addStream")                                                    \
   V(Cancel, "cancel")                                                          \
   V(Close, "close")                                                            \
   V(Values, "values")                                                          \
   V(_EnumNames, "_enum_names")                                                 \
   V(ExprTemp, ":expr_temp")                                                    \
+  V(FinallyRetVal, ":finally_ret_val")                                         \
   V(AnonymousClosure, "<anonymous closure>")                                   \
   V(AnonymousSignature, "<anonymous signature>")                               \
   V(ImplicitClosure, "<implicit closure>")                                     \
   V(ClosureParameter, ":closure")                                              \
   V(TypeArgumentsParameter, ":type_arguments")                                 \
   V(AssertionError, "_AssertionError")                                         \
   V(CastError, "_CastError")                                                   \
   V(TypeError, "_TypeError")                                                   \
   V(FallThroughError, "FallThroughError")                                      \
   V(AbstractClassInstantiationError, "AbstractClassInstantiationError")        \
@@ skipping 331 matching lines @@
 
   // List of strings that are pre created in the vm isolate.
   enum SymbolId {
     kIllegal = 0,
 
 #define DEFINE_SYMBOL_INDEX(symbol, literal)                                   \
     k##symbol##Id,
     PREDEFINED_SYMBOLS_LIST(DEFINE_SYMBOL_INDEX)
 #undef DEFINE_SYMBOL_INDEX
 
-    kKwTableStart,  // First keyword at kKwTableStart + 1.
+    kTokenTableStart,  // First token at kTokenTableStart + 1.
 
-#define DEFINE_KEYWORD_SYMBOL_INDEX(t, s, p, a)                                \
+#define DEFINE_TOKEN_SYMBOL_INDEX(t, s, p, a)                                  \
     t##Id,
-    DART_KEYWORD_LIST(DEFINE_KEYWORD_SYMBOL_INDEX)
-#undef DEFINE_KEYWORD_SYMBOL_INDEX
+    DART_TOKEN_LIST(DEFINE_TOKEN_SYMBOL_INDEX)
+    DART_KEYWORD_LIST(DEFINE_TOKEN_SYMBOL_INDEX)
+#undef DEFINE_TOKEN_SYMBOL_INDEX
 
     kNullCharId,  // One char code symbol starts here and takes up 256 entries.
     kMaxPredefinedId = kNullCharId + kMaxOneCharCodeSymbol + 1,
   };
 
   // Number of one character symbols being predefined in the predefined_ array.
   static const int kNumberOfOneCharCodeSymbols =
       (kMaxPredefinedId - kNullCharId);
 
   // Offset of Null character which is the predefined character symbol.
@@ skipping 92 matching lines @@
   static const String& Percent() {
     return *(symbol_handles_[kNullCharId + '%']);
   }
   static const String& Caret() {
     return *(symbol_handles_[kNullCharId + '^']);
   }
   static const String& Tilde() {
     return *(symbol_handles_[kNullCharId + '~']);
   }
 
-  static const String& Empty() { return *(symbol_handles_[kKwTableStart]); }
+  static const String& Empty() { return *(symbol_handles_[kTokenTableStart]); }
   static const String& False() { return *(symbol_handles_[kFALSEId]); }
   static const String& Library() { return *(symbol_handles_[kLIBRARYId]); }
   static const String& Super() { return *(symbol_handles_[kSUPERId]); }
   static const String& This() { return *(symbol_handles_[kTHISId]); }
   static const String& True() { return *(symbol_handles_[kTRUEId]); }
   static const String& Void() { return *(symbol_handles_[kVOIDId]); }
 
   // Access methods for symbol handles stored in the vm isolate for predefined
   // symbols.
 #define DEFINE_SYMBOL_HANDLE_ACCESSOR(symbol, literal)                         \
   static const String& symbol() { return *(symbol_handles_[k##symbol##Id]); }
   PREDEFINED_SYMBOLS_LIST(DEFINE_SYMBOL_HANDLE_ACCESSOR)
 #undef DEFINE_SYMBOL_HANDLE_ACCESSOR
 
   // Access methods for symbol handles stored in the vm isolate for keywords.
 #define DEFINE_SYMBOL_HANDLE_ACCESSOR(t, s, p, a)                              \
   static const String& t() { return *(symbol_handles_[t##Id]); }
+  DART_TOKEN_LIST(DEFINE_SYMBOL_HANDLE_ACCESSOR)
   DART_KEYWORD_LIST(DEFINE_SYMBOL_HANDLE_ACCESSOR)
 #undef DEFINE_SYMBOL_HANDLE_ACCESSOR
 
-  // Get symbol for scanner keyword.
-  static const String& Keyword(Token::Kind keyword);
+  // Get symbol for scanner token.
+  static const String& Token(Token::Kind token);
 
   // Initialize frequently used symbols in the vm isolate.
   static void InitOnce(Isolate* isolate);
   static void InitOnceFromSnapshot(Isolate* isolate);
 
   // Add all the symbols that were cached in the VM isolate to this isolate,
   // we do this when an Isolate is not created from the snapshot so that
   // we get a unified symbol table that can be be dumped into the VM isolate
   // snapshot.
   static void AddPredefinedSymbolsToIsolate();
 
   // Initialize and setup a symbol table for the isolate.
   static void SetupSymbolTable(Isolate* isolate);
 
   // Treat the symbol table as weak and collect garbage. Answer the number of
   // symbols deleted from the symbol table because they where not referenced
   // from anywhere else.
   static intptr_t Compact(Isolate* isolate);
 
   // Creates a Symbol given a C string that is assumed to contain
   // UTF-8 encoded characters and '\0' is considered a termination character.
   // TODO(7123) - Rename this to FromCString(....).
-  static RawString* New(const char* cstr) {
-    return New(cstr, strlen(cstr));
+  static RawString* New(Thread* thread, const char* cstr) {
+    return New(thread, cstr, strlen(cstr));
   }
-  static RawString* New(const char* cstr, intptr_t length);
+  static RawString* New(Thread* thread, const char* cstr, intptr_t length);
 
   // Creates a new Symbol from an array of UTF-8 encoded characters.
-  static RawString* FromUTF8(const uint8_t* utf8_array, intptr_t len);
+  static RawString* FromUTF8(Thread* thread,
+                             const uint8_t* utf8_array,
+                             intptr_t len);
 
   // Creates a new Symbol from an array of Latin-1 encoded characters.
-  static RawString* FromLatin1(const uint8_t* latin1_array, intptr_t len);
+  static RawString* FromLatin1(Thread* thread,
+                               const uint8_t* latin1_array,
+                               intptr_t len);
 
   // Creates a new Symbol from an array of UTF-16 encoded characters.
-  static RawString* FromUTF16(const uint16_t* utf16_array, intptr_t len);
+  static RawString* FromUTF16(Thread* thread,
+                              const uint16_t* utf16_array,
+                              intptr_t len);
 
   // Creates a new Symbol from an array of UTF-32 encoded characters.
-  static RawString* FromUTF32(const int32_t* utf32_array, intptr_t len);
+  static RawString* FromUTF32(Thread* thread,
+                              const int32_t* utf32_array,
+                              intptr_t len);
 
-  static RawString* New(const String& str);
-  static RawString* New(const String& str,
+  static RawString* New(Thread* thread, const String& str);
+  static RawString* New(Thread* thread,
+                        const String& str,
                         intptr_t begin_index,
                         intptr_t length);
 
-  static RawString* NewFormatted(const char* format, ...)
-      PRINTF_ATTRIBUTE(1, 2);
-  static RawString* NewFormattedV(const char* format, va_list args);
+  static RawString* NewFormatted(Thread* thread, const char* format, ...)
+      PRINTF_ATTRIBUTE(2, 3);
+  static RawString* NewFormattedV(Thread* thread,
+                                  const char* format,
+                                  va_list args);
 
-  static RawString* FromConcat(const String& str1, const String& str2);
+  static RawString* FromConcat(Thread* thread,
+                               const String& str1,
+                               const String& str2);
 
-  static RawString* FromConcatAll(
+  static RawString* FromConcatAll(Thread* thread,
       const GrowableHandlePtrArray<const String>& strs);
 
+  static RawString* FromGet(Thread* thread, const String& str);
+  static RawString* FromSet(Thread* thread, const String& str);
+  static RawString* FromDot(Thread* thread, const String& str);
+
   // Returns char* of predefined symbol.
   static const char* Name(SymbolId symbol);
 
-  static RawString* FromCharCode(int32_t char_code);
+  static RawString* FromCharCode(Thread* thread, int32_t char_code);
 
   static RawString** PredefinedAddress() {
     return reinterpret_cast<RawString**>(&predefined_);
   }
 
   static void DumpStats();
 
   // Returns Symbol::Null if no symbol is found.
   template<typename StringType>
-  static RawString* Lookup(const StringType& str);
+  static RawString* Lookup(Thread* thread, const StringType& str);
 
   // Returns Symbol::Null if no symbol is found.
-  static RawString* LookupFromConcat(const String& str1, const String& str2);
+  static RawString* LookupFromConcat(Thread* thread,
+                                     const String& str1,
+                                     const String& str2);
+
+  static RawString* LookupFromGet(Thread* thread, const String& str);
+  static RawString* LookupFromSet(Thread* thread, const String& str);
+  static RawString* LookupFromDot(Thread* thread, const String& str);
 
  private:
   enum {
     kInitialVMIsolateSymtabSize = 1024,
     kInitialSymtabSize = 2048
   };
 
   static void GetStats(Isolate* isolate,
                        intptr_t* size,
                        intptr_t* capacity);
 
   template<typename StringType>
-  static RawString* NewSymbol(const StringType& str);
+  static RawString* NewSymbol(Thread* thread, const StringType& str);
 
   static intptr_t LookupVMSymbol(RawObject* obj);
   static RawObject* GetVMSymbol(intptr_t object_id);
   static bool IsVMSymbolId(intptr_t object_id) {
     return (object_id >= kMaxPredefinedObjectIds &&
             object_id < (kMaxPredefinedObjectIds + kMaxPredefinedId));
   }
 
   // List of Latin1 characters stored in the vm isolate as symbols
   // in order to make Symbols::FromCharCode fast. This structure is
   // used in generated dart code for direct access to these objects.
   static RawString* predefined_[kNumberOfOneCharCodeSymbols];
 
   // List of handles for predefined symbols.
   static String* symbol_handles_[kMaxPredefinedId];
 
   friend class Dart;
   friend class String;
   friend class SnapshotReader;
   friend class SnapshotWriter;
   friend class ApiMessageReader;
 
   DISALLOW_COPY_AND_ASSIGN(Symbols);
 };
 
 }  // namespace dart
 
 #endif  // VM_SYMBOLS_H_