Introduce ModuleScope subclass of DeclarationScope

src/ast/scopes.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_AST_SCOPES_H_
 #define V8_AST_SCOPES_H_
 
 #include "src/ast/ast.h"
 #include "src/base/hashmap.h"
 #include "src/globals.h"
@@ skipping 51 matching lines @@
 
 // Global invariants after AST construction: Each reference (i.e. identifier)
 // to a JavaScript variable (including global properties) is represented by a
 // VariableProxy node. Immediately after AST construction and before variable
 // allocation, most VariableProxy nodes are "unresolved", i.e. not bound to a
 // corresponding variable (though some are bound during parse time). Variable
 // allocation binds each unresolved VariableProxy to one Variable and assigns
 // a location. Note that many VariableProxy nodes may refer to the same Java-
 // Script variable.
 
-class DeclarationScope;
-
-// JS environments are represented in the parser using two scope classes, Scope
-// and its subclass DeclarationScope. DeclarationScope is used for any scope
-// that hosts 'var' declarations. This includes script, module, eval, varblock,
-// and function scope. All fields required by such scopes are only available on
-// DeclarationScope.
+// JS environments are represented in the parser using Scope, DeclarationScope
+// and ModuleScope. DeclarationScope is used for any scope that hosts 'var'
+// declarations. This includes script, module, eval, varblock, and function
+// scope. ModuleScope further specializes DeclarationScope.
 class Scope: public ZoneObject {
  public:
   // ---------------------------------------------------------------------------
   // Construction
 
   Scope(Zone* zone, Scope* outer_scope, ScopeType scope_type);
 
 #ifdef DEBUG
   // The scope name is only used for printing/debugging.
   void SetScopeName(const AstRawString* scope_name) {
     scope_name_ = scope_name;
   }
 #endif
 
   // TODO(verwaest): Is this needed on Scope?
   int num_parameters() const;
 
   DeclarationScope* AsDeclarationScope();
   const DeclarationScope* AsDeclarationScope() const;
+  ModuleScope* AsModuleScope();
+  const ModuleScope* AsModuleScope() const;
 
   class Snapshot final BASE_EMBEDDED {
    public:
     explicit Snapshot(Scope* scope);
 
     void Reparent(DeclarationScope* new_parent) const;
 
    private:
     Scope* outer_scope_;
     Scope* top_inner_scope_;
@@ skipping 329 matching lines @@
   void CheckScopePositions();
 
   // Check that all Scopes in the scope tree use the same Zone.
   void CheckZones();
 #endif
 
   // Retrieve `IsSimpleParameterList` of current or outer function.
   bool HasSimpleParameters();
   void set_is_debug_evaluate_scope() { is_debug_evaluate_scope_ = true; }
 
+ protected:
+  void set_language_mode(LanguageMode language_mode) {
+    language_mode_ = language_mode;
+  }
+
  private:
   Zone* zone_;
 
   // Scope tree.
   Scope* outer_scope_;  // the immediately enclosing outer scope, or NULL
   Scope* inner_scope_;  // an inner scope of this scope
   Scope* sibling_;  // a sibling inner scope of the outer scope of this scope.
 
   // The variables declared in this scope:
   //
@@ skipping 209 matching lines @@
   }
 
   bool NeedsHomeObject() const {
     return scope_uses_super_property_ ||
            ((scope_calls_eval_ || inner_scope_calls_eval_) &&
             (IsConciseMethod(function_kind()) ||
              IsAccessorFunction(function_kind()) ||
              IsClassConstructor(function_kind())));
   }
 
-  // The ModuleDescriptor for this scope; only for module scopes.
-  // TODO(verwaest): Move to ModuleScope?
-  ModuleDescriptor* module() const {
-    DCHECK(is_module_scope());
-    DCHECK_NOT_NULL(module_descriptor_);
-    return module_descriptor_;
-  }
-
   void DeclareThis(AstValueFactory* ast_value_factory);
   void DeclareDefaultFunctionVariables(AstValueFactory* ast_value_factory);
 
   // This lookup corresponds to a lookup in the "intermediate" scope sitting
   // between this scope and the outer scope. (ECMA-262, 3rd., requires that
   // the name of named function literal is kept in an intermediate scope
   // in between this scope and the next outer scope.)
   Variable* LookupFunctionVar(const AstRawString* name);
 
   // Declare the function variable for a function literal. This variable
@@ skipping 146 matching lines @@
   Handle<StringSet> CollectNonLocals(ParseInfo* info,
                                      Handle<StringSet> non_locals);
 
 #ifdef DEBUG
   void PrintParameters();
 #endif
 
   void AllocateLocals();
   void AllocateParameterLocals();
   void AllocateReceiver();
-  // Set MODULE as VariableLocation for all variables that will live in some
-  // module's export table.
-  void AllocateModuleVariables();
 
  private:
   void AllocateParameter(Variable* var, int index);
 
   void SetDefaults();
 
   // If the scope is a function scope, this is the function kind.
   const FunctionKind function_kind_;
 
   bool has_simple_parameters_ : 1;
@@ skipping 11 matching lines @@
   // Convenience variable.
   Variable* receiver_;
   // Function variable, if any; function scopes only.
   Variable* function_;
   // new.target variable, function scopes only.
   Variable* new_target_;
   // Convenience variable; function scopes only.
   Variable* arguments_;
   // Convenience variable; Subclass constructor only
   Variable* this_function_;
-  // Module descriptor; module scopes only.
+};
+
+class ModuleScope final : public DeclarationScope {
+ public:
+  ModuleScope(Zone* zone, DeclarationScope* script_scope,
+              AstValueFactory* ast_value_factory);
+
+  ModuleDescriptor* module() const {
+    DCHECK_NOT_NULL(module_descriptor_);
+    return module_descriptor_;
+  }
+
+  // Set MODULE as VariableLocation for all variables that will live in some
+  // module's export table.
+  void AllocateModuleVariables();
+
+ private:
   ModuleDescriptor* module_descriptor_;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_SCOPES_H_