Separate Scope into DeclarationScope and Scope

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 93 matching lines @@
   return kind & MethodKind::Static;
 }
 
 inline bool IsGeneratorMethod(MethodKind kind) {
   return kind & MethodKind::Generator;
 }
 
 inline bool IsAsyncMethod(MethodKind kind) { return kind & MethodKind::Async; }
 
 struct FormalParametersBase {
-  explicit FormalParametersBase(Scope* scope) : scope(scope) {}
-  Scope* scope;
+  explicit FormalParametersBase(DeclarationScope* scope) : scope(scope) {}
+  DeclarationScope* scope;
   bool has_rest = false;
   bool is_simple = true;
   int materialized_literals_count = 0;
 };
 
 
 // ----------------------------------------------------------------------------
 // The CHECK_OK macro is a convenient macro to enforce error
 // handling for functions that may fail (by returning !*ok).
 //
@@ skipping 192 matching lines @@
       return this->scope()->FinalizeBlockScope();
     }
     LanguageMode language_mode() const {
       return this->scope()->language_mode();
     }
 
    private:
     Scope* NewScope(ScopeState* outer_state) {
       Scope* parent = outer_state->scope();
       Zone* zone = outer_state->zone();
-      return new (zone) Scope(zone, parent, BLOCK_SCOPE, kNormalFunction);
+      return new (zone) Scope(zone, parent, BLOCK_SCOPE);
     }
   };
 
   struct DestructuringAssignment {
    public:
     DestructuringAssignment(ExpressionT expression, Scope* scope)
         : assignment(expression), scope(scope) {}
 
     ExpressionT assignment;
     Scope* scope;
@@ skipping 273 matching lines @@
     }
     ~ParsingModeScope() {
       parser_->mode_ = old_mode_;
     }
 
    private:
     ParserBase* parser_;
     Mode old_mode_;
   };
 
-  Scope* NewScriptScope() {
-    return new (zone()) Scope(zone(), nullptr, SCRIPT_SCOPE, kNormalFunction);
+  DeclarationScope* NewScriptScope() {
+    return new (zone()) DeclarationScope(zone(), nullptr, SCRIPT_SCOPE);
+  }
+
+  DeclarationScope* NewVarblockScope() {
+    return new (zone()) DeclarationScope(zone(), scope(), BLOCK_SCOPE);
+  }
+
+  DeclarationScope* NewModuleScope(Scope* parent) {
+    DeclarationScope* result =
+        new (zone()) DeclarationScope(zone(), parent, MODULE_SCOPE);
+    // TODO(verwaest): Move into the DeclarationScope constructor.
+    result->DeclareThis(ast_value_factory());
+    return result;
+  }
+
+  DeclarationScope* NewEvalScope(Scope* parent) {
+    return new (zone()) DeclarationScope(zone(), parent, EVAL_SCOPE);
   }
 
   Scope* NewScope(ScopeType scope_type) {
     return NewScopeWithParent(scope(), scope_type);
   }
 
   // This constructor should only be used when absolutely necessary. Most scopes
   // should automatically use scope() as parent, and be fine with
   // NewScope(ScopeType) above.
   Scope* NewScopeWithParent(Scope* parent, ScopeType scope_type) {
     // Must always use the specific constructors for the blacklisted scope
     // types.
     DCHECK_NE(FUNCTION_SCOPE, scope_type);
     DCHECK_NE(SCRIPT_SCOPE, scope_type);
+    DCHECK_NE(MODULE_SCOPE, scope_type);
     DCHECK_NOT_NULL(parent);
-    Scope* result =
-        new (zone()) Scope(zone(), parent, scope_type, kNormalFunction);
-    if (scope_type == MODULE_SCOPE) result->DeclareThis(ast_value_factory());
-    return result;
+    return new (zone()) Scope(zone(), parent, scope_type);
   }
 
-  Scope* NewFunctionScope(FunctionKind kind) {
+  DeclarationScope* NewFunctionScope(FunctionKind kind) {
     DCHECK(ast_value_factory());
-    Scope* result = new (zone()) Scope(zone(), scope(), FUNCTION_SCOPE, kind);
+    DeclarationScope* result =
+        new (zone()) DeclarationScope(zone(), scope(), FUNCTION_SCOPE, kind);
+    // TODO(verwaest): Move into the DeclarationScope constructor.
     if (!IsArrowFunction(kind)) {
       result->DeclareThis(ast_value_factory());
       result->DeclareDefaultFunctionVariables(ast_value_factory());
     }
     return result;
   }
 
   Scanner* scanner() const { return scanner_; }
   AstValueFactory* ast_value_factory() const { return ast_value_factory_; }
   int position() { return scanner_->location().beg_pos; }
@@ skipping 490 matching lines @@
   // Keep track of eval() calls since they disable all local variable
   // optimizations. This checks if expression is an eval call, and if yes,
   // forwards the information to scope.
   void CheckPossibleEvalCall(ExpressionT expression, Scope* scope) {
     if (Traits::IsIdentifier(expression) &&
         Traits::IsEval(Traits::AsIdentifier(expression))) {
       scope->RecordEvalCall();
       if (is_sloppy(scope->language_mode())) {
         // For sloppy scopes we also have to record the call at function level,
         // in case it includes declarations that will be hoisted.
-        scope->DeclarationScope()->RecordEvalCall();
+        scope->GetDeclarationScope()->RecordEvalCall();
       }
     }
   }
 
   // Used to validate property names in object literals and class literals
   enum PropertyKind {
     kAccessorProperty,
     kValueProperty,
     kMethodProperty
   };
@@ skipping 43 matching lines @@
     bool IsConstructor() {
       return this->scanner()->LiteralMatches("constructor", 11);
     }
     bool IsPrototype() {
       return this->scanner()->LiteralMatches("prototype", 9);
     }
 
     bool has_seen_constructor_;
   };
 
-  ModuleDescriptor* module() const { return scope()->module(); }
+  ModuleDescriptor* module() const {
+    return scope()->AsDeclarationScope()->module();
+  }
   Scope* scope() const { return scope_state_->scope(); }
 
   ScopeState* scope_state_;        // Scope stack.
   FunctionState* function_state_;  // Function state stack.
   v8::Extension* extension_;
   FuncNameInferrer* fni_;
   AstValueFactory* ast_value_factory_;  // Not owned.
   typename Traits::Type::Factory ast_node_factory_;
   ParserRecorder* log_;
   Mode mode_;
@@ skipping 1081 matching lines @@
                                   parenthesized_formals, is_async, CHECK_OK);
     // This reads strangely, but is correct: it checks whether any
     // sub-expression of the parameter list failed to be a valid formal
     // parameter initializer. Since YieldExpressions are banned anywhere
     // in an arrow parameter list, this is correct.
     // TODO(adamk): Rename "FormalParameterInitializerError" to refer to
     // "YieldExpression", which is its only use.
     ValidateFormalParameterInitializer(&arrow_formals_classifier, ok);
 
     Scanner::Location loc(lhs_beg_pos, scanner()->location().end_pos);
-    Scope* scope =
+    DeclarationScope* scope =
         this->NewFunctionScope(is_async ? FunctionKind::kAsyncArrowFunction
                                         : FunctionKind::kArrowFunction);
     // Because the arrow's parameters were parsed in the outer scope, any
     // usage flags that might have been triggered there need to be copied
     // to the arrow scope.
     this->scope()->PropagateUsageFlagsToScope(scope);
     FormalParametersT parameters(scope);
     if (!arrow_formals_classifier.is_simple_parameter_list()) {
       scope->SetHasNonSimpleParameters();
       parameters.is_simple = false;
@@ skipping 744 matching lines @@
       ParseMemberExpressionContinuation(result, is_async, classifier, CHECK_OK);
   return result;
 }
 
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT
 ParserBase<Traits>::ParseSuperExpression(bool is_new, bool* ok) {
   Expect(Token::SUPER, CHECK_OK);
   int pos = position();
 
-  Scope* scope = this->scope()->ReceiverScope();
+  DeclarationScope* scope = this->scope()->GetReceiverScope();
   FunctionKind kind = scope->function_kind();
   if (IsConciseMethod(kind) || IsAccessorFunction(kind) ||
       IsClassConstructor(kind)) {
     if (peek() == Token::PERIOD || peek() == Token::LBRACK) {
       scope->RecordSuperPropertyUsage();
       return this->NewSuperPropertyReference(this->scope(), factory(), pos);
     }
     // new super() is never allowed.
     // super() is only allowed in derived constructor
     if (!is_new && peek() == Token::LPAREN && IsSubclassConstructor(kind)) {
@@ skipping 21 matching lines @@
     *ok = false;
   }
 }
 
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT
 ParserBase<Traits>::ParseNewTargetExpression(bool* ok) {
   int pos = position();
   ExpectMetaProperty(CStrVector("target"), "new.target", pos, CHECK_OK);
 
-  if (!scope()->ReceiverScope()->is_function_scope()) {
+  if (!scope()->GetReceiverScope()->is_function_scope()) {
     ReportMessageAt(scanner()->location(),
                     MessageTemplate::kUnexpectedNewTarget);
     *ok = false;
     return this->EmptyExpression();
   }
 
   return this->NewTargetExpression(scope(), factory(), pos);
 }
 
 template <class Traits>
@@ skipping 541 matching lines @@
     has_seen_constructor_ = true;
     return;
   }
 }
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PARSER_BASE_H