Remove getters that duplicate FunctionKind in SharedFunctionInfo and ParseInfo

src/parsing/parser-base.h

 // 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.
 
 #ifndef V8_PARSING_PARSER_BASE_H
 #define V8_PARSING_PARSER_BASE_H
 
 #include "src/ast/ast.h"
 #include "src/ast/scopes.h"
 #include "src/bailout-reason.h"
@@ skipping 389 matching lines @@
       return next_materialized_literal_index_;
     }
 
     void SkipMaterializedLiterals(int count) {
       next_materialized_literal_index_ += count;
     }
 
     void AddProperty() { expected_property_count_++; }
     int expected_property_count() { return expected_property_count_; }
 
-    bool is_generator() const { return IsGeneratorFunction(kind()); }
-    bool is_async_function() const { return IsAsyncFunction(kind()); }
-    bool is_resumable() const { return is_generator() || is_async_function(); }
-
     FunctionKind kind() const { return scope()->function_kind(); }
     FunctionState* outer() const { return outer_function_state_; }
 
     void set_generator_object_variable(typename Types::Variable* variable) {
       DCHECK(variable != NULL);
-      DCHECK(is_resumable());
+      DCHECK(IsResumableFunction(kind()));
       generator_object_variable_ = variable;
     }
     typename Types::Variable* generator_object_variable() const {
       return generator_object_variable_;
     }
 
     void set_promise_variable(typename Types::Variable* variable) {
       DCHECK(variable != NULL);
-      DCHECK(is_async_function());
+      DCHECK(IsAsyncFunction(kind()));
       promise_variable_ = variable;
     }
     typename Types::Variable* promise_variable() const {
       return promise_variable_;
     }
 
     const ZoneList<DestructuringAssignment>&
         destructuring_assignments_to_rewrite() const {
       return destructuring_assignments_to_rewrite_;
     }
@@ skipping 494 matching lines @@
   typename Types::Factory* factory() { return &ast_node_factory_; }
 
   DeclarationScope* GetReceiverScope() const {
     return scope()->GetReceiverScope();
   }
   LanguageMode language_mode() { return scope()->language_mode(); }
   void RaiseLanguageMode(LanguageMode mode) {
     LanguageMode old = scope()->language_mode();
     impl()->SetLanguageMode(scope(), old > mode ? old : mode);
   }
-  bool is_generator() const { return function_state_->is_generator(); }
+  bool is_generator() const {
+    return IsGeneratorFunction(function_state_->kind());
+  }
   bool is_async_function() const {
-    return function_state_->is_async_function();
+    return IsAsyncFunction(function_state_->kind());
   }
-  bool is_resumable() const { return function_state_->is_resumable(); }
+  bool is_resumable() const {
+    return IsResumableFunction(function_state_->kind());
+  }
 
   // Report syntax errors.
   void ReportMessage(MessageTemplate::Template message) {
     Scanner::Location source_location = scanner()->location();
     impl()->ReportMessageAt(source_location, message,
                             static_cast<const char*>(nullptr), kSyntaxError);
   }
 
   template <typename T>
   void ReportMessage(MessageTemplate::Template message, T arg,
@@ skipping 4455 matching lines @@
     has_seen_constructor_ = true;
     return;
   }
 }
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PARSER_BASE_H