Separate Scope into DeclarationScope and Scope

src/parsing/rewriter.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/rewriter.h"
 
 #include "src/ast/ast.h"
 #include "src/ast/scopes.h"
 #include "src/parsing/parser.h"
 
 namespace v8 {
 namespace internal {
 
 class Processor final : public AstVisitor<Processor> {
  public:
-  Processor(Isolate* isolate, Scope* closure_scope, Variable* result,
+  Processor(Isolate* isolate, DeclarationScope* closure_scope, Variable* result,
             AstValueFactory* ast_value_factory)
       : result_(result),
         result_assigned_(false),
         replacement_(nullptr),
         is_set_(false),
         zone_(ast_value_factory->zone()),
         closure_scope_(closure_scope),
         factory_(ast_value_factory) {
-    DCHECK_EQ(closure_scope, closure_scope->ClosureScope());
+    DCHECK_EQ(closure_scope, closure_scope->GetClosureScope());
     InitializeAstVisitor(isolate);
   }
 
-  Processor(Parser* parser, Scope* closure_scope, Variable* result,
+  Processor(Parser* parser, DeclarationScope* closure_scope, Variable* result,
             AstValueFactory* ast_value_factory)
       : result_(result),
         result_assigned_(false),
         replacement_(nullptr),
         is_set_(false),
         zone_(ast_value_factory->zone()),
         closure_scope_(closure_scope),
         factory_(ast_value_factory) {
-    DCHECK_EQ(closure_scope, closure_scope->ClosureScope());
+    DCHECK_EQ(closure_scope, closure_scope->GetClosureScope());
     InitializeAstVisitor(parser->stack_limit());
   }
 
   void Process(ZoneList<Statement*>* statements);
   bool result_assigned() const { return result_assigned_; }
 
   Zone* zone() { return zone_; }
-  Scope* closure_scope() { return closure_scope_; }
+  DeclarationScope* closure_scope() { return closure_scope_; }
   AstNodeFactory* factory() { return &factory_; }
 
   // Returns ".result = value"
   Expression* SetResult(Expression* value) {
     result_assigned_ = true;
     VariableProxy* result_proxy = factory()->NewVariableProxy(result_);
     return factory()->NewAssignment(Token::ASSIGN, result_proxy, value,
                                     kNoSourcePosition);
   }
 
@@ skipping 13 matching lines @@
   // [replacement_].  In many cases this will just be the original node.
   Statement* replacement_;
 
   // To avoid storing to .result all the time, we eliminate some of
   // the stores by keeping track of whether or not we're sure .result
   // will be overwritten anyway. This is a bit more tricky than what I
   // was hoping for.
   bool is_set_;
 
   Zone* zone_;
-  Scope* closure_scope_;
+  DeclarationScope* closure_scope_;
   AstNodeFactory factory_;
 
   // Node visitors.
 #define DEF_VISIT(type) void Visit##type(type* node);
   AST_NODE_LIST(DEF_VISIT)
 #undef DEF_VISIT
 
   void VisitIterationStatement(IterationStatement* stmt);
 
   DEFINE_AST_VISITOR_SUBCLASS_MEMBERS();
@@ skipping 241 matching lines @@
 
 
 // Assumes code has been parsed.  Mutates the AST, so the AST should not
 // continue to be used in the case of failure.
 bool Rewriter::Rewrite(ParseInfo* info) {
   FunctionLiteral* function = info->literal();
   DCHECK_NOT_NULL(function);
   Scope* scope = function->scope();
   DCHECK_NOT_NULL(scope);
   if (!scope->is_script_scope() && !scope->is_eval_scope()) return true;
-  Scope* closure_scope = scope->ClosureScope();
+  DeclarationScope* closure_scope = scope->GetClosureScope();
 
   ZoneList<Statement*>* body = function->body();
   if (!body->is_empty()) {
     Variable* result = closure_scope->NewTemporary(
         info->ast_value_factory()->dot_result_string());
     // The name string must be internalized at this point.
     DCHECK(!result->name().is_null());
     Processor processor(info->isolate(), closure_scope, result,
                         info->ast_value_factory());
     processor.Process(body);
     if (processor.HasStackOverflow()) return false;
 
     if (processor.result_assigned()) {
       int pos = kNoSourcePosition;
       VariableProxy* result_proxy =
           processor.factory()->NewVariableProxy(result, pos);
       Statement* result_statement =
           processor.factory()->NewReturnStatement(result_proxy, pos);
       body->Add(result_statement, info->zone());
     }
   }
 
   return true;
 }
 
-bool Rewriter::Rewrite(Parser* parser, Scope* closure_scope, DoExpression* expr,
-                       AstValueFactory* factory) {
+bool Rewriter::Rewrite(Parser* parser, DeclarationScope* closure_scope,
+                       DoExpression* expr, AstValueFactory* factory) {
   Block* block = expr->block();
-  DCHECK_EQ(closure_scope, closure_scope->ClosureScope());
+  DCHECK_EQ(closure_scope, closure_scope->GetClosureScope());
   DCHECK(block->scope() == nullptr ||
-         block->scope()->ClosureScope() == closure_scope);
+         block->scope()->GetClosureScope() == closure_scope);
   ZoneList<Statement*>* body = block->statements();
   VariableProxy* result = expr->result();
   Variable* result_var = result->var();
 
   if (!body->is_empty()) {
     Processor processor(parser, closure_scope, result_var, factory);
     processor.Process(body);
     if (processor.HasStackOverflow()) return false;
 
     if (!processor.result_assigned()) {
       AstNodeFactory* node_factory = processor.factory();
       Expression* undef = node_factory->NewUndefinedLiteral(kNoSourcePosition);
       Statement* completion = node_factory->NewExpressionStatement(
           processor.SetResult(undef), expr->position());
       body->Add(completion, factory->zone());
     }
   }
   return true;
 }
 
 
 }  // namespace internal
 }  // namespace v8