[parser/ast] Reduce memory consumption for AstConsString.

src/ast/ast-value-factory.cc

 // 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 138 matching lines @@
                                   length) == 0;
     } else {
       return CompareCharsUnsigned(reinterpret_cast<const uint16_t*>(l),
                                   reinterpret_cast<const uint16_t*>(r),
                                   length) == 0;
     }
   }
 }
 
 void AstConsString::Internalize(Isolate* isolate) {
-  Handle<String> tmp(isolate->factory()->empty_string());
-  for (const AstRawString* current : strings_) {
-    // AstRawStrings are internalized before AstConsStrings, so *current is
-    // already internalized.
+  if (IsEmpty()) {
+    set_string(isolate->factory()->empty_string());
+    return;
+  }
+  // AstRawStrings are internalized before AstConsStrings, so
+  // AstRawString::string() will just work.
+  Handle<String> tmp(segment_.string->string());
+  for (AstConsString::Segment* current = segment_.next; current != nullptr;
+       current = current->next) {
     tmp = isolate->factory()
-              ->NewConsString(tmp, current->string())
+              ->NewConsString(current->string->string(), tmp)
               .ToHandleChecked();
   }
   set_string(tmp);
 }
 
 bool AstValue::IsPropertyName() const {
   if (type_ == STRING) {
     uint32_t index;
     return !string_->AsArrayIndex(&index);
   }
@@ skipping 103 matching lines @@
   if (content.IsOneByte()) {
     result = GetOneByteStringInternal(content.ToOneByteVector());
   } else {
     DCHECK(content.IsTwoByte());
     result = GetTwoByteStringInternal(content.ToUC16Vector());
   }
   return result;
 }
 
 AstConsString* AstValueFactory::NewConsString() {
-  AstConsString* new_string = new (zone_) AstConsString(zone_);
+  AstConsString* new_string = new (zone_) AstConsString;
   DCHECK_NOT_NULL(new_string);
   AddConsString(new_string);
   return new_string;
 }
 
 AstConsString* AstValueFactory::NewConsString(const AstRawString* str) {
-  return NewConsString()->AddString(str);
+  return NewConsString()->AddString(zone_, str);
 }
 
 AstConsString* AstValueFactory::NewConsString(const AstRawString* str1,
                                               const AstRawString* str2) {
-  return NewConsString()->AddString(str1)->AddString(str2);
+  return NewConsString()->AddString(zone_, str1)->AddString(zone_, str2);
 }
 
 void AstValueFactory::Internalize(Isolate* isolate) {
   // Strings need to be internalized before values, because values refer to
   // strings.
   for (AstRawString* current = strings_; current != nullptr;) {
     AstRawString* next = current->next();
     current->Internalize(isolate);
     current = next;
   }
@@ skipping 91 matching lines @@
     CHECK_NOT_NULL(new_string);
     AddString(new_string);
     entry->key = new_string;
     entry->value = reinterpret_cast<void*>(1);
   }
   return reinterpret_cast<AstRawString*>(entry->key);
 }
 
 }  // namespace internal
 }  // namespace v8