Separate Scope into DeclarationScope and Scope

src/parsing/parser.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_H_
 #define V8_PARSING_PARSER_H_
 
 #include "src/allocation.h"
 #include "src/ast/ast.h"
 #include "src/ast/scopes.h"
@@ skipping 86 matching lines @@
   void set_extension(v8::Extension* extension) { extension_ = extension; }
 
   ScriptData** cached_data() { return cached_data_; }
   void set_cached_data(ScriptData** cached_data) { cached_data_ = cached_data; }
 
   ScriptCompiler::CompileOptions compile_options() { return compile_options_; }
   void set_compile_options(ScriptCompiler::CompileOptions compile_options) {
     compile_options_ = compile_options;
   }
 
-  Scope* script_scope() { return script_scope_; }
-  void set_script_scope(Scope* script_scope) { script_scope_ = script_scope; }
+  DeclarationScope* script_scope() { return script_scope_; }
+  void set_script_scope(DeclarationScope* script_scope) {
+    script_scope_ = script_scope;
+  }
 
   AstValueFactory* ast_value_factory() { return ast_value_factory_; }
   void set_ast_value_factory(AstValueFactory* ast_value_factory) {
     ast_value_factory_ = ast_value_factory;
   }
 
   FunctionLiteral* literal() { return literal_; }
   void set_literal(FunctionLiteral* literal) { literal_ = literal; }
 
-  Scope* scope() { return scope_; }
-  void set_scope(Scope* scope) { scope_ = scope; }
+  DeclarationScope* scope() { return scope_; }
+  void set_scope(DeclarationScope* scope) { scope_ = scope; }
 
   UnicodeCache* unicode_cache() { return unicode_cache_; }
   void set_unicode_cache(UnicodeCache* unicode_cache) {
     unicode_cache_ = unicode_cache;
   }
 
   uintptr_t stack_limit() { return stack_limit_; }
   void set_stack_limit(uintptr_t stack_limit) { stack_limit_ = stack_limit; }
 
   uint32_t hash_seed() { return hash_seed_; }
@@ skipping 71 matching lines @@
   };
 
   //------------- Inputs to parsing and scope analysis -----------------------
   Zone* zone_;
   unsigned flags_;
   ScriptCompiler::ExternalSourceStream* source_stream_;
   ScriptCompiler::StreamedSource::Encoding source_stream_encoding_;
   Utf16CharacterStream* character_stream_;
   v8::Extension* extension_;
   ScriptCompiler::CompileOptions compile_options_;
-  Scope* script_scope_;
+  DeclarationScope* script_scope_;
   UnicodeCache* unicode_cache_;
   uintptr_t stack_limit_;
   uint32_t hash_seed_;
   int compiler_hints_;
   int start_position_;
   int end_position_;
 
   // TODO(titzer): Move handles and isolate out of ParseInfo.
   Isolate* isolate_;
   Handle<SharedFunctionInfo> shared_;
   Handle<Script> script_;
   Handle<Context> context_;
 
   //----------- Inputs+Outputs of parsing and scope analysis -----------------
   ScriptData** cached_data_;  // used if available, populated if requested.
   AstValueFactory* ast_value_factory_;  // used if available, otherwise new.
 
   //----------- Outputs of parsing and scope analysis ------------------------
   FunctionLiteral* literal_;  // produced by full parser.
-  Scope* scope_;              // produced by scope analysis.
+  DeclarationScope* scope_;   // produced by scope analysis.
 
   void SetFlag(Flag f) { flags_ |= f; }
   void SetFlag(Flag f, bool v) { flags_ = v ? flags_ | f : flags_ & ~f; }
   bool GetFlag(Flag f) const { return (flags_ & f) != 0; }
 };
 
 class FunctionEntry BASE_EMBEDDED {
  public:
   enum {
     kStartPositionIndex,
@@ skipping 92 matching lines @@
     const AstRawString* name;
     Expression* pattern;
     Expression* initializer;
     int initializer_end_position;
     bool is_rest;
     bool is_simple() const {
       return pattern->IsVariableProxy() && initializer == nullptr && !is_rest;
     }
   };
 
-  explicit ParserFormalParameters(Scope* scope)
+  explicit ParserFormalParameters(DeclarationScope* scope)
       : FormalParametersBase(scope), params(4, scope->zone()) {}
   ZoneList<Parameter> params;
 
   int Arity() const { return params.length(); }
   const Parameter& at(int i) const { return params[i]; }
 };
 
 
 class ParserTraits {
  public:
@@ skipping 215 matching lines @@
 
   V8_INLINE void AddParameterInitializationBlock(
       const ParserFormalParameters& parameters,
       ZoneList<v8::internal::Statement*>* body, bool is_async, bool* ok);
 
   void ParseAsyncArrowSingleExpressionBody(
       ZoneList<Statement*>* body, bool accept_IN,
       Type::ExpressionClassifier* classifier, int pos, bool* ok);
 
   V8_INLINE Scope* NewScope(ScopeType scope_type);
-  V8_INLINE Scope* NewFunctionScope(FunctionKind kind);
+  V8_INLINE DeclarationScope* NewFunctionScope(FunctionKind kind);
   V8_INLINE Scope* NewScopeWithParent(Scope* parent, ScopeType scope_type);
 
   V8_INLINE void AddFormalParameter(ParserFormalParameters* parameters,
                                     Expression* pattern,
                                     Expression* initializer,
                                     int initializer_end_position, bool is_rest);
   V8_INLINE void DeclareFormalParameter(
-      Scope* scope, const ParserFormalParameters::Parameter& parameter,
+      DeclarationScope* scope,
+      const ParserFormalParameters::Parameter& parameter,
       Type::ExpressionClassifier* classifier);
   void ParseArrowFunctionFormalParameters(ParserFormalParameters* parameters,
                                           Expression* params, int end_pos,
                                           bool* ok);
   void ParseArrowFunctionFormalParameterList(
       ParserFormalParameters* parameters, Expression* params,
       const Scanner::Location& params_loc, Scanner::Location* duplicate_loc,
       const Scope::Snapshot& scope_snapshot, bool* ok);
 
   V8_INLINE Expression* ParseAsyncFunctionExpression(bool* ok);
@@ skipping 459 matching lines @@
   // The var declarations are hoisted to the function scope, but originate from
   // a scope where the name has also been let bound or the var declaration is
   // hoisted over such a scope.
   void CheckConflictingVarDeclarations(Scope* scope, bool* ok);
 
   // Insert initializer statements for var-bindings shadowing parameter bindings
   // from a non-simple parameter list.
   void InsertShadowingVarBindingInitializers(Block* block);
 
   // Implement sloppy block-scoped functions, ES2015 Annex B 3.3
-  void InsertSloppyBlockFunctionVarBindings(Scope* scope,
+  void InsertSloppyBlockFunctionVarBindings(DeclarationScope* scope,
                                             Scope* complex_params_scope,
                                             bool* ok);
 
   // Parser support
   VariableProxy* NewUnresolved(const AstRawString* name, VariableMode mode);
   Variable* Declare(Declaration* declaration,
                     DeclarationDescriptor::Kind declaration_kind, bool resolve,
                     bool* ok, Scope* declaration_scope = nullptr);
   void DeclareImport(const AstRawString* local_name, int pos, bool* ok);
 
@@ skipping 101 matching lines @@
 }
 
 Scope* ParserTraits::NewScopeWithParent(Scope* parent, ScopeType scope_type) {
   return parser_->NewScopeWithParent(parent, scope_type);
 }
 
 Scope* ParserTraits::NewScope(ScopeType scope_type) {
   return parser_->NewScope(scope_type);
 }
 
-Scope* ParserTraits::NewFunctionScope(FunctionKind kind) {
+DeclarationScope* ParserTraits::NewFunctionScope(FunctionKind kind) {
   return parser_->NewFunctionScope(kind);
 }
 
 const AstRawString* ParserTraits::EmptyIdentifierString() {
   return parser_->ast_value_factory()->empty_string();
 }
 
 
 void ParserTraits::SkipLazyFunctionBody(int* materialized_literal_count,
                                         int* expected_property_count, bool* ok,
@@ skipping 95 matching lines @@
   bool is_simple = pattern->IsVariableProxy() && initializer == nullptr;
   const AstRawString* name = is_simple
                                  ? pattern->AsVariableProxy()->raw_name()
                                  : parser_->ast_value_factory()->empty_string();
   parameters->params.Add(
       ParserFormalParameters::Parameter(name, pattern, initializer,
                                         initializer_end_position, is_rest),
       parameters->scope->zone());
 }
 
-
 void ParserTraits::DeclareFormalParameter(
-    Scope* scope, const ParserFormalParameters::Parameter& parameter,
+    DeclarationScope* scope, const ParserFormalParameters::Parameter& parameter,
     Type::ExpressionClassifier* classifier) {
   bool is_duplicate = false;
   bool is_simple = classifier->is_simple_parameter_list();
   auto name = is_simple || parameter.is_rest
                   ? parameter.name
                   : parser_->ast_value_factory()->empty_string();
   auto mode = is_simple || parameter.is_rest ? VAR : TEMPORARY;
   if (!is_simple) scope->SetHasNonSimpleParameters();
   bool is_optional = parameter.initializer != nullptr;
   Variable* var =
@@ skipping 35 matching lines @@
 
 DoExpression* ParserTraits::ParseDoExpression(bool* ok) {
   return parser_->ParseDoExpression(ok);
 }
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PARSER_H_