Internalize AstRawStrings by walking the string_table_ instead of adding them to a list

src/ast/ast-value-factory.h

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 26 matching lines @@
 // independent of the V8 heap and internalizing them later. During parsing,
 // AstStrings and AstValues are created and stored outside the heap, in
 // AstValueFactory. After parsing, the strings and values are internalized
 // (moved into the V8 heap).
 namespace v8 {
 namespace internal {
 
 class AstString : public ZoneObject {
  public:
   explicit AstString(bool is_raw)
-      : next_(nullptr), bit_field_(IsRawStringBits::encode(is_raw)) {}
+      : bit_field_(IsRawStringBits::encode(is_raw)) {}
 
   int length() const;
   bool IsEmpty() const { return length() == 0; }
 
   // Puts the string into the V8 heap.
   void Internalize(Isolate* isolate);
 
   // This function can be called after internalizing.
   V8_INLINE Handle<String> string() const {
     DCHECK(!string_.is_null());
     return string_;
   }
 
-  AstString** next_location() { return &next_; }
-  AstString* next() const { return next_; }
-
  protected:
   // Handle<String>::null() until internalized.
   Handle<String> string_;
-  AstString* next_;
   // Poor-man's virtual dispatch to AstRawString / AstConsString. Takes less
   // memory.
   class IsRawStringBits : public BitField<bool, 0, 1> {};
   int bit_field_;
 };
 
 
 class AstRawString final : public AstString {
  public:
   int length() const {
@@ skipping 48 matching lines @@
   Vector<const byte> literal_bytes_;
 };
 
 
 class AstConsString final : public AstString {
  public:
   AstConsString(const AstString* left, const AstString* right)
       : AstString(false),
         length_(left->length() + right->length()),
         left_(left),
-        right_(right) {}
+        right_(right),
+        next_(nullptr) {}
 
   int length() const { return length_; }
 
   void Internalize(Isolate* isolate);
 
+  AstConsString* next() { return next_; }
+  AstConsString** next_location() { return &next_; }
+
  private:
   const int length_;
   const AstString* left_;
   const AstString* right_;
+  AstConsString* next_;
 };
 
 
 // AstValue is either a string, a number, a string array, a boolean, or a
 // special value (null, undefined, the hole).
 class AstValue : public ZoneObject {
  public:
   bool IsString() const {
     return type_ == STRING;
   }
@@ skipping 101 matching lines @@
   }
 
   Type type_;
 
   // Uninternalized value.
   union {
     const AstRawString* string_;
     double number_;
     int smi_;
     bool bool_;
-    const AstRawString* strings_;
     const char* symbol_name_;
   };
 
   // Handle<String>::null() until internalized.
   Handle<Object> value_;
   AstValue* next_;
 };
 
 
 // For generating constants.
@@ skipping 40 matching lines @@
   F(false_value)           \
   F(null_value)            \
   F(undefined_value)       \
   F(the_hole_value)
 
 class AstValueFactory {
  public:
   AstValueFactory(Zone* zone, uint32_t hash_seed)
       : string_table_(AstRawStringCompare),
         values_(nullptr),
-        strings_end_(&strings_),
+        cons_strings_(nullptr),
+        cons_strings_end_(&cons_strings_),
         zone_(zone),
         hash_seed_(hash_seed) {
-    ResetStrings();
 #define F(name, str) name##_string_ = NULL;
     STRING_CONSTANTS(F)
 #undef F
 #define F(name) name##_ = NULL;
     OTHER_CONSTANTS(F)
 #undef F
   }
 
   Zone* zone() const { return zone_; }
 
@@ skipping 38 matching lines @@
   const AstValue* NewNull();
   const AstValue* NewUndefined();
   const AstValue* NewTheHole();
 
  private:
   AstValue* AddValue(AstValue* value) {
     value->set_next(values_);
     values_ = value;
     return value;
   }
-  AstString* AddString(AstString* string) {
-    *strings_end_ = string;
-    strings_end_ = string->next_location();
+  AstConsString* AddConsString(AstConsString* string) {
+    *cons_strings_end_ = string;
+    cons_strings_end_ = string->next_location();
     return string;
   }
-  void ResetStrings() {
-    strings_ = nullptr;
-    strings_end_ = &strings_;
+  void ResetConsStrings() {
+    cons_strings_ = nullptr;
+    cons_strings_end_ = &cons_strings_;
   }
   V8_EXPORT_PRIVATE AstRawString* GetOneByteStringInternal(
       Vector<const uint8_t> literal);
   AstRawString* GetTwoByteStringInternal(Vector<const uint16_t> literal);
   AstRawString* GetString(uint32_t hash, bool is_one_byte,
                           Vector<const byte> literal_bytes);
 
   static bool AstRawStringCompare(void* a, void* b);
 
   // All strings are copied here, one after another (no NULLs inbetween).
   base::CustomMatcherHashMap string_table_;
   // For keeping track of all AstValues and AstRawStrings we've created (so that
   // they can be internalized later).
   AstValue* values_;
-  // We need to keep track of strings_ in order, since cons strings require
-  // their members to be internalized first.
-  AstString* strings_;
-  AstString** strings_end_;
+  // We need to keep track of cons_strings_ in order since they require their
+  // members to be internalized first.
+  AstConsString* cons_strings_;
+  AstConsString** cons_strings_end_;
   Zone* zone_;
 
   uint32_t hash_seed_;
 
 #define F(name, str) const AstRawString* name##_string_;
   STRING_CONSTANTS(F)
 #undef F
 
 #define F(name) AstValue* name##_;
   OTHER_CONSTANTS(F)
 #undef F
 };
 }  // namespace internal
 }  // namespace v8
 
 #undef STRING_CONSTANTS
 #undef OTHER_CONSTANTS
 
 #endif  // V8_AST_AST_VALUE_FACTORY_H_