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

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/object.h"
 #include "vm/snapshot_ids.h"
 
@@ skipping 84 matching lines @@
   V(ContextScope, "ContextScope")                                              \
   V(ICData, "ICData")                                                          \
   V(MegamorphicCache, "MegamorphicCache")                                      \
   V(SubtypeTestCache, "SubtypeTestCache")                                      \
   V(ApiError, "ApiError")                                                      \
   V(LanguageError, "LanguageError")                                            \
   V(UnhandledException, "UnhandledException")                                  \
   V(UnwindError, "UnwindError")                                                \
   V(IntegerImplementation, "_IntegerImplementation")                           \
   V(Number, "num")                                                             \
-  V(Smi, "_Smi")                                                               \
-  V(Mint, "_Mint")                                                             \
-  V(Bigint, "_Bigint")                                                         \
-  V(Double, "_Double")                                                         \
+  V(_Smi, "_Smi")                                                              \
+  V(_Mint, "_Mint")                                                            \
+  V(_Bigint, "_Bigint")                                                        \
+  V(_Double, "_Double")                                                        \
   V(Bool, "bool")                                                              \
   V(ObjectArray, "_ObjectArray")                                               \
   V(GrowableObjectArray, "_GrowableObjectArray")                               \
   V(ImmutableArray, "_ImmutableArray")                                         \
   V(OneByteString, "_OneByteString")                                           \
   V(TwoByteString, "_TwoByteString")                                           \
   V(ExternalOneByteString, "_ExternalOneByteString")                           \
   V(ExternalTwoByteString, "_ExternalTwoByteString")                           \
   V(Stacktrace, "Stacktrace")                                                  \
   V(JSSyntaxRegExp, "_JSSyntaxRegExp")                                         \

[Florian Schneider, 2013/01/03 14:39:51]

Maybe also rename the other accessors for private names:

V(_JSSyntaxRegExp, "_JSSyntaxRegExp") 

I don't have a strong preference, but I'd consistently insert or leave out the
"_" on the name of the accessors for private name symbols.

[siva, 2013/01/03 17:54:35]

Good point.

I will rename these to be consistent with the _ names.

On 2013/01/03 14:39:51, Florian Schneider wrote:

   V(Object, "Object")                                                          \
+  V(Int, "int")                                                                \
+  V(Double, "double")                                                          \
+  V(Int8List, "Int8List")                                                      \
+  V(Uint8List, "Uint8List")                                                    \
+  V(Uint8ClampedList, "Uint8ClampedList")                                      \
+  V(Int16List, "Int16List")                                                    \
+  V(Uint16List, "Uint16List")                                                  \
+  V(Int32List, "Int32List")                                                    \
+  V(Uint32List, "Uint32List")                                                  \
+  V(Int64List, "Int64List")                                                    \
+  V(Uint64List, "Uint64List")                                                  \
+  V(Float32List, "Float32List")                                                \
+  V(Float64List, "Float64List")                                                \
   V(_Int8Array, "_Int8Array")                                                  \
   V(_Uint8Array, "_Uint8Array")                                                \
   V(_Uint8ClampedArray, "_Uint8ClampedArray")                                  \
   V(_Int16Array, "_Int16Array")                                                \
   V(_Uint16Array, "_Uint16Array")                                              \
   V(_Int32Array, "_Int32Array")                                                \
   V(_Uint32Array, "_Uint32Array")                                              \
   V(_Int64Array, "_Int64Array")                                                \
   V(_Uint64Array, "_Uint64Array")                                              \
   V(_Float32Array, "_Float32Array")                                            \
   V(_Float64Array, "_Float64Array")                                            \
   V(_ExternalInt8Array, "_ExternalInt8Array")                                  \
   V(_ExternalUint8Array, "_ExternalUint8Array")                                \
   V(_ExternalUint8ClampedArray, "_ExternalUint8ClampedArray")                  \
   V(_ExternalInt16Array, "_ExternalInt16Array")                                \
   V(_ExternalUint16Array, "_ExternalUint16Array")                              \
   V(_ExternalInt32Array, "_ExternalInt32Array")                                \
   V(_ExternalUint32Array, "_ExternalUint32Array")                              \
   V(_ExternalInt64Array, "_ExternalInt64Array")                                \
   V(_ExternalUint64Array, "_ExternalUint64Array")                              \
   V(_ExternalFloat32Array, "_ExternalFloat32Array")                            \
   V(_ExternalFloat64Array, "_ExternalFloat64Array")                            \
   V(_WeakProperty, "_WeakProperty")                                            \
   V(InvocationMirror, "_InvocationMirror")                                     \
   V(AllocateInvocationMirror, "_allocateInvocationMirror")                     \
-
-#define PREDEFINED_SYMBOL_HANDLES_LIST(V)                                      \
-  V(Dot)                                                                       \
-  V(EqualOperator)                                                             \
-  V(IndexToken)                                                                \
-  V(AssignIndexToken)                                                          \
-  V(This)                                                                      \
+  V(toString, "toString")                                                      \
+  V(_ReceivePortImpl, "_ReceivePortImpl")                                      \
+  V(_lookupReceivePort, "_lookupReceivePort")                                  \
+  V(_handleMessage, "_handleMessage")                                          \
+  V(_SendPortImpl, "_SendPortImpl")                                            \
+  V(_create, "_create")                                                        \
+  V(_id, "_id")                                                                \
+  V(_get_or_create, "_get_or_create")                                          \
+  V(RangeError, "RangeError")                                                  \
+  V(ArgumentError, "ArgumentError")                                            \
+  V(FormatException, "FormatException")                                        \
+  V(StackOverflowError, "StackOverflowError")                                  \
+  V(OutOfMemoryError, "OutOfMemoryError")                                      \
+  V(InternalError, "InternalError")                                            \
+  V(NullThrownError, "NullThrownError")                                        \
+  V(IllegalJSRegExpException, "IllegalJSRegExpException")                      \
+  V(IsolateSpawnException, "IsolateSpawnException")                            \
+  V(IsolateUnhandledException, "IsolateUnhandledException")                    \
+  V(BooleanExpression, "boolean expression")                                   \
+  V(Malformed, "malformed")                                                    \
+  V(InstanceOf, "InstanceOf")                                                  \
+  V(MegamorphicMiss, "megamorphic_miss")                                       \
+  V(CommaSpace, ", ")                                                          \
+  V(ColonSpace, ": ")                                                          \
+  V(RParenArrow, ") => ")                                                      \
+  V(SpaceExtendsSpace, " extends ")                                            \
+  V(PatchSpace, "patch ")                                                      \
+  V(AliasOwner, ":alias_owner")                                                \
+  V(SwitchExpr, ":switch_expr")                                                \
+  V(TwoNewlines, "\n\n")                                                       \
+  V(TwoSpaces, "  ")                                                           \
 
 // Contains a list of frequently used strings in a canonicalized form. This
 // list is kept in the vm_isolate in order to share the copy across isolates
 // without having to maintain copies in each isolate.
 class Symbols : public AllStatic {
  public:
   enum { kMaxOneCharCodeSymbol = 0xFF };
 
   // List of strings that are pre created in the vm isolate.
   enum SymbolId {
     kIllegal = 0,
 
 #define DEFINE_SYMBOL_INDEX(symbol, literal)                                   \
-    k##symbol,
+    k##symbol##Id,
 PREDEFINED_SYMBOLS_LIST(DEFINE_SYMBOL_INDEX)
 #undef DEFINE_SYMBOL_INDEX
-    kMaxPredefinedId,
-    kNullCharId = kMaxPredefinedId,
-    kMaxId = kNullCharId + kMaxOneCharCodeSymbol + 1,
+
+    kNullCharId,  // One char code symbol starts here and takes up 256 entries.
+    kMaxPredefinedId = kNullCharId + kMaxOneCharCodeSymbol + 1,
   };
 
-  // Access methods for symbols stored in the vm isolate.
-#define DEFINE_SYMBOL_ACCESSOR(symbol, literal)                                \
-  static RawString* symbol() { return predefined_[k##symbol]; }
-PREDEFINED_SYMBOLS_LIST(DEFINE_SYMBOL_ACCESSOR)
-#undef DEFINE_SYMBOL_ACCESSOR
-  static RawString* Dot() { return predefined_[kNullCharId + '.']; }
-  static RawString* Equals() { return predefined_[kNullCharId + '=']; }
+  // 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.
+  static const int kNullCharCodeSymbolOffset = 0;
+
+  // Access methods for one byte character symbols stored in the vm isolate.
+  static const String& Dot() {
+    return *(symbol_handles_[kNullCharId + '.']);
+  }
+  static const String& Equals() {
+    return *(symbol_handles_[kNullCharId + '=']);
+  }
+  static const String& LAngleBracket() {
+    return *(symbol_handles_[kNullCharId + '<']);
+  }
+  static const String& RAngleBracket() {
+    return *(symbol_handles_[kNullCharId + '>']);
+  }
+  static const String& LParen() {
+    return *(symbol_handles_[kNullCharId + '(']);
+  }
+  static const String& RParen() {
+    return *(symbol_handles_[kNullCharId + ')']);
+  }
+  static const String& LBracket() {
+    return *(symbol_handles_[kNullCharId + '[']);
+  }
+  static const String& RBracket() {
+    return *(symbol_handles_[kNullCharId + ']']);
+  }
+  static const String& LBrace() {
+    return *(symbol_handles_[kNullCharId + '{']);
+  }
+  static const String& RBrace() {
+    return *(symbol_handles_[kNullCharId + '}']);
+  }
+  static const String& Blank() {
+    return *(symbol_handles_[kNullCharId + ' ']);
+  }
+  static const String& Dollar() {
+    return *(symbol_handles_[kNullCharId + '$']);
+  }
+  static const String& NewLine() {
+    return *(symbol_handles_[kNullCharId + '\n']);
+  }
+  static const String& DoubleQuotes() {
+    return *(symbol_handles_[kNullCharId + '"']);
+  }
+  static const String& LowercaseR() {
+    return *(symbol_handles_[kNullCharId + 'r']);
+  }
+  static const String& Dash() {
+    return *(symbol_handles_[kNullCharId + '-']);
+  }
 
   // Access methods for symbol handles stored in the vm isolate.
-#define DEFINE_SYMBOL_HANDLE_ACCESSOR(symbol)                                  \
-  static const String& symbol##Handle() { return *symbol##_handle_; }
-PREDEFINED_SYMBOL_HANDLES_LIST(DEFINE_SYMBOL_HANDLE_ACCESSOR)
+#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
 
   // Initialize frequently used symbols in the vm isolate.
   static void InitOnce(Isolate* isolate);
 
   // Initialize and setup a symbol table for the isolate.
   static void SetupSymbolTable(Isolate* isolate);
 
   // Get number of symbols in an isolate's symbol table.
   static intptr_t Size(Isolate* isolate);
@@ skipping 63 matching lines @@
                             intptr_t hash);
   static intptr_t FindIndex(const Array& symbol_table,
                             const String& str,
                             intptr_t begin_index,
                             intptr_t len,
                             intptr_t hash);
   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 + kMaxId));
+            object_id < (kMaxPredefinedObjectIds + kMaxPredefinedId));
   }
 
-  // List of symbols that are stored in the vm isolate for easy access.
-  static RawString* predefined_[kMaxId];
+  // 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];
 
   // Statistics used to measure the efficiency of the symbol table.
   static const intptr_t kMaxCollisionBuckets = 10;
   static intptr_t num_of_grows_;
   static intptr_t collision_count_[kMaxCollisionBuckets];
 
-#define DECLARE_SYMBOL_HANDLE(symbol)                                          \
-  static String* symbol##_handle_;
-PREDEFINED_SYMBOL_HANDLES_LIST(DECLARE_SYMBOL_HANDLE)
-#undef DECLARE_SYMBOL_HANDLE
-
   friend class String;
   friend class SnapshotReader;
   friend class SnapshotWriter;
   friend class ApiMessageReader;
 
   DISALLOW_COPY_AND_ASSIGN(Symbols);
 };
 
 }  // namespace dart
 
 #endif  // VM_SYMBOLS_H_