Refactor class declaration logic to the parser and runtime

src/parsing/parameter-initializer-rewriter.cc

 // Copyright 2015 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/parameter-initializer-rewriter.h"
 
 #include <algorithm>
 #include <utility>
 #include <vector>
 
@@ skipping 15 matching lines @@
         old_scope_(old_scope),
         new_scope_(new_scope),
         old_scope_closure_(old_scope->ClosureScope()),
         new_scope_closure_(new_scope->ClosureScope()) {}
   ~Rewriter();
 
  private:
   void VisitExpression(Expression* expr) override {}
 
   void VisitFunctionLiteral(FunctionLiteral* expr) override;
-  void VisitClassLiteral(ClassLiteral* expr) override;
   void VisitVariableProxy(VariableProxy* expr) override;
 
   void VisitBlock(Block* stmt) override;
   void VisitTryCatchStatement(TryCatchStatement* stmt) override;
   void VisitWithStatement(WithStatement* stmt) override;
 
   Scope* old_scope_;
   Scope* new_scope_;
   Scope* old_scope_closure_;
   Scope* new_scope_closure_;
@@ skipping 12 matching lines @@
     // Ensure that we add temporaries in the order they appeared in old_scope_.
     std::sort(temps_.begin(), temps_.end(), LessThanSecond());
     for (auto var_and_index : temps_) {
       var_and_index.first->set_scope(new_scope_closure_);
       new_scope_closure_->AddTemporary(var_and_index.first);
     }
   }
 }
 
 void Rewriter::VisitFunctionLiteral(FunctionLiteral* function_literal) {
-  function_literal->scope()->ReplaceOuterScope(new_scope_);
-}
-
-
-void Rewriter::VisitClassLiteral(ClassLiteral* class_literal) {
-  class_literal->scope()->ReplaceOuterScope(new_scope_);
-  if (class_literal->extends() != nullptr) {
-    Visit(class_literal->extends());
-  }
-  // No need to visit the constructor since it will have the class
-  // scope on its scope chain.
-  ZoneList<ObjectLiteralProperty*>* props = class_literal->properties();
-  for (int i = 0; i < props->length(); ++i) {
-    ObjectLiteralProperty* prop = props->at(i);
-    if (!prop->key()->IsLiteral()) {
-      Visit(prop->key());
-    }
-    // No need to visit the values, since all values are functions with
-    // the class scope on their scope chain.
-    DCHECK(prop->value()->IsFunctionLiteral());
+  if (function_literal->scope()->outer_scope() == old_scope_) {
+    function_literal->scope()->ReplaceOuterScope(new_scope_);
   }
 }
 
 
 void Rewriter::VisitVariableProxy(VariableProxy* proxy) {
   if (proxy->is_resolved()) {
     Variable* var = proxy->var();
     if (var->mode() != TEMPORARY) return;
     // Temporaries are only placed in ClosureScopes.
     DCHECK_EQ(var->scope(), var->scope()->ClosureScope());
     // If the temporary is already where it should be, return quickly.
     if (var->scope() == new_scope_closure_) return;
     int index = old_scope_closure_->RemoveTemporary(var);
     if (index >= 0) {
       temps_.push_back(std::make_pair(var, index));
     }
   } else if (old_scope_->RemoveUnresolved(proxy)) {
     new_scope_->AddUnresolved(proxy);
   }
 }
 
 
 void Rewriter::VisitBlock(Block* stmt) {
-  if (stmt->scope() != nullptr)
+  if (stmt->scope() != nullptr && stmt->scope()->outer_scope() == old_scope_) {
     stmt->scope()->ReplaceOuterScope(new_scope_);
-  else

[adamk, 2016/07/14 22:00:47]

Why does this else go away?

[bakkot, 2016/07/14 22:46:01]

It prevents recursing into statements in DoExpressions. Those statements can
contain temporaries (and did, in previous versions of this code), but this
'else' prevents the Rewriter from being able to see and re-scope them. This
caused crashes. (As far as I can tell, this code path could only have been hit
by DoExpressions anyway, since this Rewriter is called on an Expression and does
not recurse into function bodies.)

-    VisitStatements(stmt->statements());
+  }
+  VisitStatements(stmt->statements());
 }
 
 
 void Rewriter::VisitTryCatchStatement(TryCatchStatement* stmt) {
   Visit(stmt->try_block());
-  stmt->scope()->ReplaceOuterScope(new_scope_);
+  if (stmt->scope()->outer_scope() == old_scope_) {
+    stmt->scope()->ReplaceOuterScope(new_scope_);
+  }
 }
 
 
 void Rewriter::VisitWithStatement(WithStatement* stmt) {
   Visit(stmt->expression());
-  stmt->scope()->ReplaceOuterScope(new_scope_);
+  if (stmt->scope()->outer_scope() == old_scope_) {
+    stmt->scope()->ReplaceOuterScope(new_scope_);
+  }
 }
 
 
 }  // anonymous namespace
 
 
 void RewriteParameterInitializerScope(uintptr_t stack_limit,
                                       Expression* initializer, Scope* old_scope,
                                       Scope* new_scope) {
   Rewriter rewriter(stack_limit, initializer, old_scope, new_scope);
   rewriter.Run();
 }
 
 
 }  // namespace internal
 }  // namespace v8