Line data    Source code

       1             : // Copyright 2011 the V8 project authors. All rights reserved.
       2             : // Use of this source code is governed by a BSD-style license that can be
       3             : // found in the LICENSE file.
       4             : 
       5             : #include "src/parsing/func-name-inferrer.h"
       6             : 
       7             : #include "src/ast/ast-value-factory.h"
       8             : #include "src/ast/ast.h"
       9             : #include "src/objects-inl.h"
      10             : 
      11             : namespace v8 {
      12             : namespace internal {
      13             : 
      14     2441034 : FuncNameInferrer::FuncNameInferrer(AstValueFactory* ast_value_factory)
      15     4882068 :     : ast_value_factory_(ast_value_factory) {}
      16             : 
      17     1643500 : void FuncNameInferrer::PushEnclosingName(const AstRawString* name) {
      18             :   // Enclosing name is a name of a constructor function. To check
      19             :   // that it is really a constructor, we check that it is not empty
      20             :   // and starts with a capital letter.
      21     1643500 :   if (!name->IsEmpty() && unibrow::Uppercase::Is(name->FirstCharacter())) {
      22      258352 :     names_stack_.push_back(Name(name, kEnclosingConstructorName));
      23             :   }
      24     1643433 : }
      25             : 
      26             : 
      27    10860100 : void FuncNameInferrer::PushLiteralName(const AstRawString* name) {
      28    21720261 :   if (IsOpen() && name != ast_value_factory_->prototype_string()) {
      29    20682155 :     names_stack_.push_back(Name(name, kLiteralName));
      30             :   }
      31    10860177 : }
      32             : 
      33             : 
      34    32832437 : void FuncNameInferrer::PushVariableName(const AstRawString* name) {
      35    65664969 :   if (IsOpen() && name != ast_value_factory_->dot_result_string()) {
      36    65665358 :     names_stack_.push_back(Name(name, kVariableName));
      37             :   }
      38    32832379 : }
      39             : 
      40        6329 : void FuncNameInferrer::RemoveAsyncKeywordFromEnd() {
      41        6329 :   if (IsOpen()) {
      42       12658 :     CHECK_GT(names_stack_.size(), 0);
      43        6329 :     CHECK(names_stack_.back().name()->IsOneByteEqualTo("async"));
      44             :     names_stack_.pop_back();
      45             :   }
      46        6328 : }
      47             : 
      48      470353 : const AstConsString* FuncNameInferrer::MakeNameFromStack() {
      49      940706 :   if (names_stack_.size() == 0) {
      50      817631 :     return ast_value_factory_->empty_cons_string();
      51             :   }
      52     1094821 :   AstConsString* result = ast_value_factory_->NewConsString();
      53             :   auto it = names_stack_.begin();
      54     1560038 :   while (it != names_stack_.end()) {
      55             :     // Advance the iterator to be able to peek the next value.
      56             :     auto current = it++;
      57             :     // Skip consecutive variable declarations.
      58      969332 :     if (it != names_stack_.end() && current->type() == kVariableName &&
      59             :         it->type() == kVariableName) {
      60             :       continue;
      61             :     }
      62             :     // Add name. Separate names with ".".
      63      634243 :     Zone* zone = ast_value_factory_->zone();
      64      634243 :     if (!result->IsEmpty()) {
      65      173613 :       result->AddString(zone, ast_value_factory_->dot_string());
      66             :     }
      67      634227 :     result->AddString(zone, current->name());
      68             :   }
      69             :   return result;
      70             : }
      71             : 
      72      470352 : void FuncNameInferrer::InferFunctionsNames() {
      73      470352 :   const AstConsString* func_name = MakeNameFromStack();
      74     1416033 :   for (FunctionLiteral* func : funcs_to_infer_) {
      75      475138 :     func->set_raw_inferred_name(func_name);
      76             :   }
      77      470442 :   funcs_to_infer_.resize(0);
      78      470374 : }
      79             : 
      80             : 
      81             : }  // namespace internal
      82      183867 : }  // namespace v8