Remove unnecessary RewriteNonPatternArguments

src/parsing/parser.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/parser.h"
 
 #include "src/api.h"
 #include "src/ast/ast.h"
 #include "src/ast/ast-expression-rewriter.h"
 #include "src/ast/ast-expression-visitor.h"
@@ skipping 4877 matching lines @@
 
   int pos = peek_position();
   Expect(Token::MOD, CHECK_OK);
   // Allow "eval" or "arguments" for backward compatibility.
   const AstRawString* name = ParseIdentifier(kAllowRestrictedIdentifiers,
                                              CHECK_OK);
   Scanner::Location spread_pos;
   ExpressionClassifier classifier;
   ZoneList<Expression*>* args =
       ParseArguments(&spread_pos, &classifier, CHECK_OK);
-  args = RewriteNonPatternArguments(args, &classifier, CHECK_OK);
+  ValidateExpression(&classifier, CHECK_OK);

[rossberg, 2016/01/21 14:16:37]

Hm, isn't this redundant as well? If the thing has already been rewritten then
it should also have been validated already. What case would this check capture?

[nickie, 2016/01/21 14:29:25]

Honestly, I don't know.  This line was replaced with the call to
RewriteNonPatternArguments here:

https://codereview.chromium.org/1567603005/diff/120001/src/parsing/parser.cc#...

The ParseArguments function makes sure that each argument (if any exist) is
rewritten as a non-pattern.  This practically invokes ValidateExpression for
each argument, in order.  I'm not sure, however, if this is all you need here.

[rossberg, 2016/01/21 14:46:00]

Let's remove it then it see. Having a dangling Validate without Rewrite seems
fishy. If it's actually necessary, I'd think we have a bug elsewhere.

[nickie, 2016/01/21 15:02:53]

Acknowledged.

 
   DCHECK(!spread_pos.IsValid());
 
   if (extension_ != NULL) {
     // The extension structures are only accessible while parsing the
     // very first time not when reparsing because of lazy compilation.
     scope_->DeclarationScope()->ForceEagerCompilation();
   }
 
   const Runtime::Function* function = Runtime::FunctionForName(name->string());
@@ skipping 548 matching lines @@
   parser_->RewriteDestructuringAssignments();
 }
 
 
 Expression* ParserTraits::RewriteNonPattern(
     Expression* expr, const ExpressionClassifier* classifier, bool* ok) {
   return parser_->RewriteNonPattern(expr, classifier, ok);
 }
 
 
-ZoneList<Expression*>* ParserTraits::RewriteNonPatternArguments(
-    ZoneList<Expression*>* args, const ExpressionClassifier* classifier,
-    bool* ok) {
-  return parser_->RewriteNonPatternArguments(args, classifier, ok);
-}
-
-
 ObjectLiteralProperty* ParserTraits::RewriteNonPatternObjectLiteralProperty(
     ObjectLiteralProperty* property, const ExpressionClassifier* classifier,
     bool* ok) {
   return parser_->RewriteNonPatternObjectLiteralProperty(property, classifier,
                                                          ok);
 }
 
 
 class NonPatternRewriter : public AstExpressionRewriter {
  public:
@@ skipping 31 matching lines @@
                                       bool* ok) {
   ValidateExpression(classifier, ok);
   if (!*ok) return expr;
   NonPatternRewriter rewriter(stack_limit_, this);
   Expression* result = reinterpret_cast<Expression*>(rewriter.Rewrite(expr));
   DCHECK_NOT_NULL(result);
   return result;
 }
 
 
-ZoneList<Expression*>* Parser::RewriteNonPatternArguments(
-    ZoneList<Expression*>* args, const ExpressionClassifier* classifier,
-    bool* ok) {
-  ValidateExpression(classifier, ok);
-  if (!*ok) return args;
-  for (int i = 0; i < args->length(); i++) {
-    NonPatternRewriter rewriter(stack_limit_, this);
-    Expression* result =
-        reinterpret_cast<Expression*>(rewriter.Rewrite(args->at(i)));
-    DCHECK_NOT_NULL(result);
-    args->Set(i, result);
-  }
-  return args;
-}
-
-
 ObjectLiteralProperty* Parser::RewriteNonPatternObjectLiteralProperty(
     ObjectLiteralProperty* property, const ExpressionClassifier* classifier,
     bool* ok) {
   if (property != nullptr) {
     Expression* key = RewriteNonPattern(property->key(), classifier, ok);
     property->set_key(key);
     Expression* value = RewriteNonPattern(property->value(), classifier, ok);
     property->set_value(value);
   }
   return property;
@@ skipping 202 matching lines @@
     auto class_literal = value->AsClassLiteral();
     if (class_literal->raw_name() == nullptr) {
       class_literal->set_raw_name(name);
     }
   }
 }
 
 
 }  // namespace internal
 }  // namespace v8