Include only stuff you need, part 9: variables.h

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 1390 matching lines @@
   for (int i = 0; i < names.length(); ++i) {
     // TODO(neis): Provide better location.
     descriptor->AddExport(names[i], names[i], scanner()->location(), zone());
   }
 
   DCHECK_NOT_NULL(result);
   return result;
 }
 
 VariableProxy* Parser::NewUnresolved(const AstRawString* name, int begin_pos,
-                                     int end_pos, Variable::Kind kind) {
+                                     int end_pos, VariableKind kind) {
   return scope()->NewUnresolved(factory(), name, begin_pos, end_pos, kind);
 }
 
 VariableProxy* Parser::NewUnresolved(const AstRawString* name) {
   return scope()->NewUnresolved(factory(), name, scanner()->location().beg_pos,
                                 scanner()->location().end_pos);
 }
 
 Declaration* Parser::DeclareVariable(const AstRawString* name,
                                      VariableMode mode, int pos, bool* ok) {
@@ skipping 718 matching lines @@
         const AstRawString* name = ast_value_factory()->dot_catch_string();
         Expression* pattern = nullptr;
         if (peek_any_identifier()) {
           name = ParseIdentifier(kDontAllowRestrictedIdentifiers, CHECK_OK);
         } else {
           ExpressionClassifier pattern_classifier(this);
           pattern = ParsePrimaryExpression(CHECK_OK);
           ValidateBindingPattern(CHECK_OK);
         }
         catch_variable = catch_scope->DeclareLocal(
-            name, VAR, kCreatedInitialized, Variable::NORMAL);
+            name, VAR, kCreatedInitialized, NORMAL_VARIABLE);
 
         Expect(Token::RPAREN, CHECK_OK);
 
         ZoneList<const AstRawString*> bound_names(1, zone());
         if (pattern != nullptr) {
           DeclarationDescriptor descriptor;
           descriptor.declaration_kind = DeclarationDescriptor::NORMAL;
           descriptor.scope = scope();
           descriptor.hoist_scope = nullptr;
           descriptor.mode = LET;
@@ skipping 1648 matching lines @@
         BuildDotDebugIsActive(), debug_push_promise,
         factory()->NewEmptyStatement(kNoSourcePosition), kNoSourcePosition);
   }
   result->statements()->Add(conditionally_debug_push_promise, zone());
 
   // catch (.catch) { return %RejectPromise(.promise, .catch), .promise }
   Scope* catch_scope = NewScope(CATCH_SCOPE);
   catch_scope->set_is_hidden();
   Variable* catch_variable =
       catch_scope->DeclareLocal(ast_value_factory()->dot_catch_string(), VAR,
-                                kCreatedInitialized, Variable::NORMAL);
+                                kCreatedInitialized, NORMAL_VARIABLE);
   Block* catch_block = factory()->NewBlock(nullptr, 1, true, kNoSourcePosition);
 
   Expression* promise_reject = BuildRejectPromise(
       factory()->NewVariableProxy(catch_variable), kNoSourcePosition);
   ReturnStatement* return_promise_reject =
       factory()->NewReturnStatement(promise_reject, kNoSourcePosition);
   catch_block->statements()->Add(return_promise_reject, zone());
 
   TryStatement* try_catch_statement = factory()->NewTryCatchStatement(
       inner_block, catch_scope, catch_variable, catch_block, kNoSourcePosition);
@@ skipping 1596 matching lines @@
     Block* try_block = factory()->NewBlock(nullptr, 2, false, nopos);
     try_block->statements()->Add(yield_output, zone());
     try_block->statements()->Add(set_mode_next, zone());
 
     Block* catch_block = factory()->NewBlock(nullptr, 1, false, nopos);
     catch_block->statements()->Add(set_mode_throw, zone());
 
     Scope* catch_scope = NewScope(CATCH_SCOPE);
     catch_scope->set_is_hidden();
     const AstRawString* name = ast_value_factory()->dot_catch_string();
-    Variable* catch_variable =
-        catch_scope->DeclareLocal(name, VAR, kCreatedInitialized,
-                                               Variable::NORMAL);
+    Variable* catch_variable = catch_scope->DeclareLocal(
+        name, VAR, kCreatedInitialized, NORMAL_VARIABLE);
 
     try_catch = factory()->NewTryCatchStatementForDesugaring(
         try_block, catch_scope, catch_variable, catch_block, nopos);
   }
 
   // try { ... } finally { ... }
   Statement* try_finally;
   {
     Block* try_block = factory()->NewBlock(nullptr, 1, false, nopos);
     try_block->statements()->Add(try_catch, zone());
@@ skipping 266 matching lines @@
   // try { #try_block }
   // catch(e) {
   //   #set_completion_throw;
   //   %ReThrow(e);
   // }
   Statement* try_catch;
   {
     Scope* catch_scope = NewScopeWithParent(scope(), CATCH_SCOPE);
     Variable* catch_variable =
         catch_scope->DeclareLocal(ast_value_factory()->dot_catch_string(), VAR,
-                                  kCreatedInitialized, Variable::NORMAL);
+                                  kCreatedInitialized, NORMAL_VARIABLE);
     catch_scope->set_is_hidden();
 
     Statement* rethrow;
     // We use %ReThrow rather than the ordinary throw because we want to
     // preserve the original exception message.  This is also why we create a
     // TryCatchStatementForReThrow below (which does not clear the pending
     // message), rather than a TryCatchStatement.
     {
       auto args = new (zone()) ZoneList<Expression*>(1, zone());
       args->Add(factory()->NewVariableProxy(catch_variable), zone());
@@ skipping 85 matching lines @@
 
     Block* try_block = factory()->NewBlock(nullptr, 1, false, nopos);
     try_block->statements()->Add(factory()->NewExpressionStatement(call, nopos),
                                  zone());
 
     Block* catch_block = factory()->NewBlock(nullptr, 0, false, nopos);
 
     Scope* catch_scope = NewScope(CATCH_SCOPE);
     Variable* catch_variable =
         catch_scope->DeclareLocal(ast_value_factory()->dot_catch_string(), VAR,
-                                  kCreatedInitialized, Variable::NORMAL);
+                                  kCreatedInitialized, NORMAL_VARIABLE);
     catch_scope->set_is_hidden();
 
     try_call_return = factory()->NewTryCatchStatement(
         try_block, catch_scope, catch_variable, catch_block, nopos);
   }
 
   // let output = %_Call(iteratorReturn, iterator);
   // if (!IS_RECEIVER(output)) {
   //   %ThrowIteratorResultNotAnObject(output);
   // }
@@ skipping 133 matching lines @@
   node->Print(Isolate::Current());
 }
 #endif  // DEBUG
 
 #undef CHECK_OK
 #undef CHECK_OK_VOID
 #undef CHECK_FAILED
 
 }  // namespace internal
 }  // namespace v8