[style] Rename some enum values with 'k' prefix

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/scopes.h"
 #include "src/bailout-reason.h"
 #include "src/base/hashmap.h"
@@ skipping 12 matching lines @@
   kFunctionNameIsStrictReserved,
   kSkipFunctionNameCheck,
   kFunctionNameValidityUnknown
 };
 
 enum AllowLabelledFunctionStatement {
   kAllowLabelledFunctionStatement,
   kDisallowLabelledFunctionStatement,
 };
 
-enum class FunctionBody { Normal, SingleExpression };
-
 enum class ParseFunctionFlags {
   kIsNormal = 0,
   kIsGenerator = 1,
   kIsAsync = 2,
   kIsDefault = 4
 };
 
 static inline ParseFunctionFlags operator|(ParseFunctionFlags lhs,
                                            ParseFunctionFlags rhs) {
   typedef unsigned char T;
   return static_cast<ParseFunctionFlags>(static_cast<T>(lhs) |
                                          static_cast<T>(rhs));
 }
 
 static inline ParseFunctionFlags& operator|=(ParseFunctionFlags& lhs,
                                              const ParseFunctionFlags& rhs) {
   lhs = lhs | rhs;
   return lhs;
 }
 
 static inline bool operator&(ParseFunctionFlags bitfield,
                              ParseFunctionFlags mask) {
   typedef unsigned char T;
   return static_cast<T>(bitfield) & static_cast<T>(mask);
 }
 
 enum class MethodKind {
-  Normal = 0,
-  Static = 1 << 0,
-  Generator = 1 << 1,
-  StaticGenerator = Static | Generator,
-  Async = 1 << 2,
-  StaticAsync = Static | Async,
+  kNormal = 0,
+  kStatic = 1 << 0,
+  kGenerator = 1 << 1,
+  kStaticGenerator = kStatic | kGenerator,
+  kAsync = 1 << 2,
+  kStaticAsync = kStatic | kAsync,
 
   /* Any non-ordinary method kinds */
-  SpecialMask = Generator | Async
+  kSpecialMask = kGenerator | kAsync
 };
 
 inline bool IsValidMethodKind(MethodKind kind) {
-  return kind == MethodKind::Normal || kind == MethodKind::Static ||
-         kind == MethodKind::Generator || kind == MethodKind::StaticGenerator ||
-         kind == MethodKind::Async || kind == MethodKind::StaticAsync;
+  return kind == MethodKind::kNormal || kind == MethodKind::kStatic ||
+         kind == MethodKind::kGenerator ||
+         kind == MethodKind::kStaticGenerator || kind == MethodKind::kAsync ||
+         kind == MethodKind::kStaticAsync;
 }
 
 static inline MethodKind operator|(MethodKind lhs, MethodKind rhs) {
   typedef unsigned char T;
   return static_cast<MethodKind>(static_cast<T>(lhs) | static_cast<T>(rhs));
 }
 
 static inline MethodKind& operator|=(MethodKind& lhs, const MethodKind& rhs) {
   lhs = lhs | rhs;
   DCHECK(IsValidMethodKind(lhs));
   return lhs;
 }
 
 static inline bool operator&(MethodKind bitfield, MethodKind mask) {
   typedef unsigned char T;
   return static_cast<T>(bitfield) & static_cast<T>(mask);
 }
 
 inline bool IsNormalMethod(MethodKind kind) {
-  return kind == MethodKind::Normal;
+  return kind == MethodKind::kNormal;
 }
 
 inline bool IsSpecialMethod(MethodKind kind) {
-  return kind & MethodKind::SpecialMask;
+  return kind & MethodKind::kSpecialMask;
 }
 
 inline bool IsStaticMethod(MethodKind kind) {
-  return kind & MethodKind::Static;
+  return kind & MethodKind::kStatic;
 }
 
 inline bool IsGeneratorMethod(MethodKind kind) {
-  return kind & MethodKind::Generator;
+  return kind & MethodKind::kGenerator;
 }
 
-inline bool IsAsyncMethod(MethodKind kind) { return kind & MethodKind::Async; }
+inline bool IsAsyncMethod(MethodKind kind) { return kind & MethodKind::kAsync; }
 
 struct FormalParametersBase {
   explicit FormalParametersBase(DeclarationScope* scope) : scope(scope) {}
   DeclarationScope* scope;
   bool has_rest = false;
   bool is_simple = true;
   int materialized_literals_count = 0;
 };
 
 
@@ skipping 1813 matching lines @@
   bool is_get = false;
   bool is_set = false;
   bool is_await = false;
   bool is_generator = Check(Token::MUL);
   bool is_async = false;
   const bool is_static = IsStaticMethod(method_kind);
 
   Token::Value name_token = peek();
 
   if (is_generator) {
-    method_kind |= MethodKind::Generator;
+    method_kind |= MethodKind::kGenerator;
   } else if (allow_harmony_async_await() && name_token == Token::ASYNC &&
              !scanner()->HasAnyLineTerminatorAfterNext() &&
              PeekAhead() != Token::LPAREN && PeekAhead()) {
     is_async = true;
   }
 
   int next_beg_pos = scanner()->peek_location().beg_pos;
   int next_end_pos = scanner()->peek_location().end_pos;
   ExpressionT name_expression = ParsePropertyName(
       name, &is_get, &is_set, &is_await, is_computed_name, classifier,
       CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
 
   if (fni_ != nullptr && !*is_computed_name) {
     this->PushLiteralName(fni_, *name);
   }
 
   if (!in_class && !is_generator) {
     DCHECK(!IsStaticMethod(method_kind));
 
     if (peek() == Token::COLON) {
       // PropertyDefinition
       //    PropertyName ':' AssignmentExpression
       if (!*is_computed_name) {
-        checker->CheckProperty(name_token, kValueProperty, MethodKind::Normal,
+        checker->CheckProperty(name_token, kValueProperty, MethodKind::kNormal,
                                CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
       }
       Consume(Token::COLON);
       int beg_pos = peek_position();
       ExpressionT value = this->ParseAssignmentExpression(
           true, classifier, CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
       CheckDestructuringElement(value, classifier, beg_pos,
                                 scanner()->location().end_pos);
 
       return factory()->NewObjectLiteralProperty(name_expression, value,
@@ skipping 65 matching lines @@
       Scanner::Location(next_beg_pos, scanner()->location().end_pos),
       MessageTemplate::kInvalidDestructuringTarget);
 
   if (is_async && !IsSpecialMethod(method_kind)) {
     DCHECK(!is_get);
     DCHECK(!is_set);
     bool dont_care;
     name_expression = ParsePropertyName(
         name, &dont_care, &dont_care, &dont_care, is_computed_name, classifier,
         CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
-    method_kind |= MethodKind::Async;
+    method_kind |= MethodKind::kAsync;
   }
 
   if (is_generator || peek() == Token::LPAREN) {
     // MethodDefinition
     //    PropertyName '(' StrictFormalParameters ')' '{' FunctionBody '}'
     //    '*' PropertyName '(' StrictFormalParameters ')' '{' FunctionBody '}'
     if (!*is_computed_name) {
       checker->CheckProperty(name_token, kMethodProperty, method_kind,
                              CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
     }
@@ skipping 18 matching lines @@
     return factory()->NewObjectLiteralProperty(name_expression, value,
                                                ObjectLiteralProperty::COMPUTED,
                                                is_static, *is_computed_name);
   }
 
   if (in_class && name_token == Token::STATIC && IsNormalMethod(method_kind)) {
     // ClassElement (static)
     //    'static' MethodDefinition
     *name = this->EmptyIdentifier();
     ObjectLiteralPropertyT property = ParsePropertyDefinition(
-        checker, true, has_extends, MethodKind::Static, is_computed_name,
+        checker, true, has_extends, MethodKind::kStatic, is_computed_name,
         nullptr, classifier, name, ok);
     Traits::RewriteNonPattern(classifier, ok);
     return property;
   }
 
   if (is_get || is_set) {
     // MethodDefinition (Accessors)
     //    get PropertyName '(' ')' '{' FunctionBody '}'
     //    set PropertyName '(' PropertySetParameterList ')' '{' FunctionBody '}'
     *name = this->EmptyIdentifier();
@@ skipping 52 matching lines @@
   Expect(Token::LBRACE, CHECK_OK);
 
   while (peek() != Token::RBRACE) {
     FuncNameInferrer::State fni_state(fni_);
 
     const bool in_class = false;
     const bool has_extends = false;
     bool is_computed_name = false;
     IdentifierT name = this->EmptyIdentifier();
     ObjectLiteralPropertyT property = this->ParsePropertyDefinition(
-        &checker, in_class, has_extends, MethodKind::Normal, &is_computed_name,
+        &checker, in_class, has_extends, MethodKind::kNormal, &is_computed_name,
         NULL, classifier, &name, CHECK_OK);
 
     if (is_computed_name) {
       has_computed_names = true;
     }
 
     // Count CONSTANT or COMPUTED properties to maintain the enumeration order.
     if (!has_computed_names && this->IsBoilerplateProperty(property)) {
       number_of_boilerplate_properties++;
     }
@@ skipping 145 matching lines @@
     expression = this->ParseConditionalExpression(
         accept_IN, &arrow_formals_classifier, CHECK_OK);
   }
 
   if (is_async && this->IsIdentifier(expression) && peek_any_identifier() &&
       PeekAhead() == Token::ARROW) {
     // async Identifier => AsyncConciseBody
     IdentifierT name =
         ParseAndClassifyIdentifier(&arrow_formals_classifier, CHECK_OK);
     expression = this->ExpressionFromIdentifier(
-        name, position(), scanner()->location().end_pos, InferName::No);
+        name, position(), scanner()->location().end_pos, InferName::kNo);
     if (fni_) {
       // Remove `async` keyword from inferred name stack.
       fni_->RemoveAsyncKeywordFromEnd();
     }
   }
 
   if (peek() == Token::ARROW) {
     Scanner::Location arrow_loc = scanner()->peek_location();
     ValidateArrowFormalParameters(&arrow_formals_classifier, expression,
                                   parenthesized_formals, is_async, CHECK_OK);
@@ skipping 1390 matching lines @@
     has_seen_constructor_ = true;
     return;
   }
 }
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PARSER_BASE_H