deps: update V8 to 7.0.276.20

PR-URL: https://github.com/nodejs/node/pull/22754
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Refael Ackermann <refack@gmail.com>
Reviewed-By: Ali Ijaz Sheikh <ofrobots@google.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>

1 files changed, 23 insertions, 21 deletions

diff --git a/deps/v8/src/parsing/func-name-inferrer.cc b/deps/v8/src/parsing/func-name-inferrer.cc
index 4920877610..7d476f1e64 100644
--- a/deps/v8/src/parsing/func-name-inferrer.cc
+++ b/deps/v8/src/parsing/func-name-inferrer.cc
@@ -14,72 +14,74 @@ namespace internal {
 FuncNameInferrer::FuncNameInferrer(AstValueFactory* ast_value_factory,
                                    Zone* zone)
     : ast_value_factory_(ast_value_factory),
-      entries_stack_(10, zone),
-      names_stack_(5, zone),
-      funcs_to_infer_(4, zone),
-      zone_(zone) {
-}
-
+      entries_stack_(zone),
+      names_stack_(zone),
+      funcs_to_infer_(zone),
+      zone_(zone) {}
 
 void FuncNameInferrer::PushEnclosingName(const AstRawString* name) {
   // Enclosing name is a name of a constructor function. To check
   // that it is really a constructor, we check that it is not empty
   // and starts with a capital letter.
   if (!name->IsEmpty() && unibrow::Uppercase::Is(name->FirstCharacter())) {
-    names_stack_.Add(Name(name, kEnclosingConstructorName), zone());
+    names_stack_.push_back(Name(name, kEnclosingConstructorName));
   }
 }
 
 
 void FuncNameInferrer::PushLiteralName(const AstRawString* name) {
   if (IsOpen() && name != ast_value_factory_->prototype_string()) {
-    names_stack_.Add(Name(name, kLiteralName), zone());
+    names_stack_.push_back(Name(name, kLiteralName));
   }
 }
 
 
 void FuncNameInferrer::PushVariableName(const AstRawString* name) {
   if (IsOpen() && name != ast_value_factory_->dot_result_string()) {
-    names_stack_.Add(Name(name, kVariableName), zone());
+    names_stack_.push_back(Name(name, kVariableName));
   }
 }
 
 void FuncNameInferrer::RemoveAsyncKeywordFromEnd() {
   if (IsOpen()) {
-    CHECK_GT(names_stack_.length(), 0);
-    CHECK(names_stack_.last().name->IsOneByteEqualTo("async"));
-    names_stack_.RemoveLast();
+    CHECK_GT(names_stack_.size(), 0);
+    CHECK(names_stack_.back().name->IsOneByteEqualTo("async"));
+    names_stack_.pop_back();
   }
 }
 
 void FuncNameInferrer::Leave() {
   DCHECK(IsOpen());
-  names_stack_.Rewind(entries_stack_.RemoveLast());
-  if (entries_stack_.is_empty()) funcs_to_infer_.Clear();
+  size_t last_entry = entries_stack_.back();
+  entries_stack_.pop_back();
+  names_stack_.Rewind(last_entry);
+  if (entries_stack_.is_empty()) funcs_to_infer_.Rewind();
 }
 
 const AstConsString* FuncNameInferrer::MakeNameFromStack() {
   AstConsString* result = ast_value_factory_->NewConsString();
-  for (int pos = 0; pos < names_stack_.length(); pos++) {
+  auto it = names_stack_.begin();
+  while (it != names_stack_.end()) {
+    // Advance the iterator to be able to peek the next value.
+    auto current = it++;
     // Skip consecutive variable declarations.
-    if (pos + 1 < names_stack_.length() &&
-        names_stack_.at(pos).type == kVariableName &&
-        names_stack_.at(pos + 1).type == kVariableName) {
+    if (it != names_stack_.end() && current->type == kVariableName &&
+        it->type == kVariableName) {
       continue;
     }
     // Add name. Separate names with ".".
     if (!result->IsEmpty()) {
       result->AddString(zone(), ast_value_factory_->dot_string());
     }
-    result->AddString(zone(), names_stack_.at(pos).name);
+    result->AddString(zone(), current->name);
   }
   return result;
 }
 
 void FuncNameInferrer::InferFunctionsNames() {
   const AstConsString* func_name = MakeNameFromStack();
-  for (int i = 0; i < funcs_to_infer_.length(); ++i) {
-    funcs_to_infer_[i]->set_raw_inferred_name(func_name);
+  for (FunctionLiteral* func : funcs_to_infer_) {
+    func->set_raw_inferred_name(func_name);
   }
   funcs_to_infer_.Rewind(0);
 }