Don't track function-kind through FunctionState, always read from underlying scope

src/parsing/parser.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/parsing/parser.h"
 
 #include <memory>
 
 #include "src/api.h"
 #include "src/ast/ast-expression-rewriter.h"
@@ skipping 214 matching lines @@
   DeclarationScope* function_scope = NewFunctionScope(kind);
   SetLanguageMode(function_scope,
                   static_cast<LanguageMode>(language_mode | STRICT));
   // Set start and end position to the same value
   function_scope->set_start_position(pos);
   function_scope->set_end_position(pos);
   ZoneList<Statement*>* body = NULL;
 
   {
     FunctionState function_state(&function_state_, &scope_state_,
-                                 function_scope, kind);
+                                 function_scope);
 
     body = new (zone()) ZoneList<Statement*>(call_super ? 2 : 1, zone());
     if (call_super) {
       // $super_constructor = %_GetSuperConstructor(<this-function>)
       // %reflect_construct(
       //     $super_constructor, InternalArray(...args), new.target)
       auto constructor_args_name = ast_value_factory()->empty_string();
       bool is_duplicate;
       bool is_rest = true;
       bool is_optional = false;
@@ skipping 533 matching lines @@
       // declared at the module level but not MODULE-allocated.
       parsing_mode = PARSE_EAGERLY;
     }
 
     DeclarationScope* scope = outer->AsDeclarationScope();
 
     scope->set_start_position(0);
 
     // Enter 'scope' with the given parsing mode.
     ParsingModeScope parsing_mode_scope(this, parsing_mode);
-    FunctionState function_state(&function_state_, &scope_state_, scope,
-                                 kNormalFunction);
+    FunctionState function_state(&function_state_, &scope_state_, scope);
 
     ZoneList<Statement*>* body = new(zone()) ZoneList<Statement*>(16, zone());
     bool ok = true;
     int beg_pos = scanner()->location().beg_pos;
     parsing_module_ = info->is_module();
     if (parsing_module_) {
       // Declare the special module parameter.
       auto name = ast_value_factory()->empty_string();
       bool is_duplicate;
       bool is_rest = false;
@@ skipping 128 matching lines @@
 
   // Place holder for the result.
   FunctionLiteral* result = nullptr;
 
   {
     // Parse the function literal.
     Scope* outer = original_scope_;
     DeclarationScope* outer_function = outer->GetClosureScope();
     DCHECK(outer);
     FunctionState function_state(&function_state_, &scope_state_,
-                                 outer_function,
-                                 outer_function->function_kind());
+                                 outer_function);
     BlockState block_state(&scope_state_, outer);
     DCHECK(is_sloppy(outer->language_mode()) ||
            is_strict(info->language_mode()));
     FunctionLiteral::FunctionType function_type = ComputeFunctionType(info);
     bool ok = true;
 
     if (info->is_arrow()) {
       bool is_async = allow_harmony_async_await() && info->is_async();
       if (is_async) {
         DCHECK(!scanner()->HasAnyLineTerminatorAfterNext());
         if (!Check(Token::ASYNC)) {
           CHECK(stack_overflow());
           return nullptr;
         }
         if (!(peek_any_identifier() || peek() == Token::LPAREN)) {
           CHECK(stack_overflow());
           return nullptr;
         }
       }
 
       // TODO(adamk): We should construct this scope from the ScopeInfo.
-      DeclarationScope* scope = NewFunctionScope(FunctionKind::kArrowFunction);
+      FunctionKind arrow_kind = is_async ? kAsyncArrowFunction : kArrowFunction;
+      DeclarationScope* scope = NewFunctionScope(arrow_kind);
 
       // These two bits only need to be explicitly set because we're
       // not passing the ScopeInfo to the Scope constructor.
       // TODO(adamk): Remove these calls once the above NewScope call
       // passes the ScopeInfo.
       if (info->calls_eval()) {
         scope->RecordEvalCall();
       }
       SetLanguageMode(scope, info->language_mode());
 
@@ skipping 14 matching lines @@
           // BindingIdentifier
           ParseFormalParameter(&formals, &ok);
           if (ok) DeclareFormalParameter(formals.scope, formals.at(0));
         }
       }
 
       if (ok) {
         checkpoint.Restore(&formals.materialized_literals_count);
         // Pass `accept_IN=true` to ParseArrowFunctionLiteral --- This should
         // not be observable, or else the preparser would have failed.
-        Expression* expression =
-            ParseArrowFunctionLiteral(true, formals, is_async, &ok);
+        Expression* expression = ParseArrowFunctionLiteral(true, formals, &ok);
         if (ok) {
           // Scanning must end at the same position that was recorded
           // previously. If not, parsing has been interrupted due to a stack
           // overflow, at which point the partially parsed arrow function
           // concise body happens to be a valid expression. This is a problem
           // only for arrow functions with single expression bodies, since there
           // is no end token such as "}" for normal functions.
           if (scanner()->location().end_pos == info->end_position()) {
             // The pre-parser saw an arrow function here, so the full parser
             // must produce a FunctionLiteral.
@@ skipping 1767 matching lines @@
     DiscardableZoneScope zone_scope(this, &temp_zone, use_temp_zone);
 
     DeclarationScope* scope = NewFunctionScope(kind);
     SetLanguageMode(scope, language_mode);
     if (!use_temp_zone) {
       main_scope = scope;
     } else {
       DCHECK(main_scope->zone() != scope->zone());
     }
 
-    FunctionState function_state(&function_state_, &scope_state_, scope, kind);
+    FunctionState function_state(&function_state_, &scope_state_, scope);
 #ifdef DEBUG
     scope->SetScopeName(function_name);
 #endif
     ExpressionClassifier formals_classifier(this, &duplicate_finder);
 
     if (is_generator) {
       // For generators, allocating variables in contexts is currently a win
       // because it minimizes the work needed to suspend and resume an
       // activation.  The machine code produced for generators (by full-codegen)
       // relies on this forced context allocation, but not in an essential way.
@@ skipping 748 matching lines @@
   // .class-field-0-func(),
   //   DONT_ENUM, false)
 
   RaiseLanguageMode(STRICT);
   FunctionKind kind = FunctionKind::kConciseMethod;
   DeclarationScope* initializer_scope = NewFunctionScope(kind);
   SetLanguageMode(initializer_scope, language_mode());
   initializer_scope->set_start_position(scanner()->location().end_pos);
   initializer_scope->set_end_position(scanner()->location().end_pos);
   FunctionState initializer_state(&function_state_, &scope_state_,
-                                  initializer_scope, kind);
+                                  initializer_scope);
   ZoneList<Statement*>* body = new (zone()) ZoneList<Statement*>(count, zone());
   for (int i = 0; i < count; ++i) {
     const AstRawString* name =
         ClassFieldVariableName(true, ast_value_factory(), i);
     VariableProxy* name_proxy = scope()->NewUnresolved(factory(), name);
     const AstRawString* function_name =
         ClassFieldVariableName(false, ast_value_factory(), i);
     VariableProxy* function_proxy =
         scope()->NewUnresolved(factory(), function_name);
     ZoneList<Expression*>* args = new (zone()) ZoneList<Expression*>(2, zone());
@@ skipping 2039 matching lines @@
 
   return final_loop;
 }
 
 #undef CHECK_OK
 #undef CHECK_OK_VOID
 #undef CHECK_FAILED
 
 }  // namespace internal
 }  // namespace v8