Revert of Non-pattern rewriting revisited

src/parsing/pattern-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/ast/ast.h"
 #include "src/messages.h"
 #include "src/parsing/parameter-initializer-rewriter.h"
 #include "src/parsing/parser.h"
 
 namespace v8 {
@@ skipping 15 matching lines @@
   rewriter.descriptor_ = declaration_descriptor;
   rewriter.names_ = names;
   rewriter.ok_ = ok;
   rewriter.recursion_level_ = 0;
 
   rewriter.RecurseIntoSubpattern(rewriter.pattern_, declaration->initializer);
 }
 
 
 void Parser::PatternRewriter::RewriteDestructuringAssignment(
-    Parser* parser, RewritableExpression* to_rewrite, Scope* scope) {
+    Parser* parser, RewritableAssignmentExpression* to_rewrite, Scope* scope) {
   PatternRewriter rewriter;
 
   DCHECK(!to_rewrite->is_rewritten());
 
   bool ok = true;
   rewriter.scope_ = scope;
   rewriter.parser_ = parser;
   rewriter.context_ = ASSIGNMENT;
   rewriter.pattern_ = to_rewrite;
   rewriter.block_ = nullptr;
   rewriter.descriptor_ = nullptr;
   rewriter.names_ = nullptr;
   rewriter.ok_ = &ok;
   rewriter.recursion_level_ = 0;
 
   rewriter.RecurseIntoSubpattern(rewriter.pattern_, nullptr);
   DCHECK(ok);
 }
 
 
 Expression* Parser::PatternRewriter::RewriteDestructuringAssignment(
     Parser* parser, Assignment* assignment, Scope* scope) {
   DCHECK_NOT_NULL(assignment);
   DCHECK_EQ(Token::ASSIGN, assignment->op());
-  auto to_rewrite = parser->factory()->NewRewritableExpression(assignment);
+  auto to_rewrite =
+      parser->factory()->NewRewritableAssignmentExpression(assignment);
   RewriteDestructuringAssignment(parser, to_rewrite, scope);
   return to_rewrite->expression();
 }
 
 
 bool Parser::PatternRewriter::IsAssignmentContext(PatternContext c) const {
   return c == ASSIGNMENT || c == ASSIGNMENT_INITIALIZER;
 }
 
 
@@ skipping 11 matching lines @@
   return old_context;
 }
 
 
 Parser::PatternRewriter::PatternContext
 Parser::PatternRewriter::SetInitializerContextIfNeeded(Expression* node) {
   // Set appropriate initializer context for BindingElement and
   // AssignmentElement nodes
   PatternContext old_context = context();
   bool is_destructuring_assignment =
-      node->IsRewritableExpression() &&
-      !node->AsRewritableExpression()->is_rewritten();
+      node->IsRewritableAssignmentExpression() &&
+      !node->AsRewritableAssignmentExpression()->is_rewritten();
   bool is_assignment =
       node->IsAssignment() && node->AsAssignment()->op() == Token::ASSIGN;
   if (is_destructuring_assignment || is_assignment) {
     switch (old_context) {
       case BINDING:
         set_context(INITIALIZER);
         break;
       case ASSIGNMENT:
         set_context(ASSIGNMENT_INITIALIZER);
         break;
@@ skipping 211 matching lines @@
         RelocInfo::kNoPosition);
 
     block_->statements()->Add(
         factory()->NewExpressionStatement(assignment, RelocInfo::kNoPosition),
         zone());
   }
   return temp;
 }
 
 
-void Parser::PatternRewriter::VisitRewritableExpression(
-    RewritableExpression* node) {
-  // If this is not a destructuring assignment...
-  if (!IsAssignmentContext() || !node->expression()->IsAssignment()) {
-    // Mark the node as rewritten to prevent redundant rewriting, and
+void Parser::PatternRewriter::VisitRewritableAssignmentExpression(
+    RewritableAssignmentExpression* node) {
+  if (!IsAssignmentContext()) {
+    // Mark the assignment as rewritten to prevent redundant rewriting, and
     // perform BindingPattern rewriting
     DCHECK(!node->is_rewritten());
     node->Rewrite(node->expression());
     return node->expression()->Accept(this);
   }
 
   if (node->is_rewritten()) return;
   DCHECK(IsAssignmentContext());
   Assignment* assign = node->expression()->AsAssignment();
   DCHECK_NOT_NULL(assign);
@@ skipping 278 matching lines @@
 NOT_A_PATTERN(TryFinallyStatement)
 NOT_A_PATTERN(UnaryOperation)
 NOT_A_PATTERN(VariableDeclaration)
 NOT_A_PATTERN(WhileStatement)
 NOT_A_PATTERN(WithStatement)
 NOT_A_PATTERN(Yield)
 
 #undef NOT_A_PATTERN
 }  // namespace internal
 }  // namespace v8