[es6] strict eval/arguments and strong undefined in AssignmentPattern

src/parsing/preparser.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_PREPARSER_H
 #define V8_PARSING_PREPARSER_H
 
 #include "src/ast/scopes.h"
 #include "src/bailout-reason.h"
 #include "src/hashmap.h"
@@ skipping 107 matching lines @@
 
   static PreParserExpression BinaryOperation(PreParserExpression left,
                                              Token::Value op,
                                              PreParserExpression right) {
     return PreParserExpression(
         TypeField::encode(kBinaryOperationExpression) |
         HasRestField::encode(op == Token::COMMA &&
                              right->IsSpreadExpression()));
   }
 
-  static PreParserExpression AssignmentPattern() {
+  static PreParserExpression Assignment() {
     return PreParserExpression(TypeField::encode(kExpression) |
-                               ExpressionTypeField::encode(kAssignmentPattern));
+                               ExpressionTypeField::encode(kAssignment));
   }
 
   static PreParserExpression ObjectLiteral() {
     return PreParserExpression(TypeField::encode(kObjectLiteralExpression));
   }
 
   static PreParserExpression ArrayLiteral() {
     return PreParserExpression(TypeField::encode(kArrayLiteralExpression));
   }
 
@@ skipping 47 matching lines @@
 
   bool IsIdentifier() const {
     return TypeField::decode(code_) == kIdentifierExpression;
   }
 
   PreParserIdentifier AsIdentifier() const {
     DCHECK(IsIdentifier());
     return PreParserIdentifier(IdentifierTypeField::decode(code_));
   }
 
-  bool IsAssignmentPattern() const {
+  bool IsAssignment() const {
     return TypeField::decode(code_) == kExpression &&
-           ExpressionTypeField::decode(code_) == kAssignmentPattern;
+           ExpressionTypeField::decode(code_) == kAssignment;
   }
 
   bool IsObjectLiteral() const {
     return TypeField::decode(code_) == kObjectLiteralExpression;
   }
 
   bool IsArrayLiteral() const {
     return TypeField::decode(code_) == kArrayLiteralExpression;
   }
 
@@ skipping 90 matching lines @@
     kArrayLiteralExpression
   };
 
   enum ExpressionType {
     kThisExpression,
     kThisPropertyExpression,
     kPropertyExpression,
     kCallExpression,
     kSuperCallReference,
     kNoTemplateTagExpression,
-    kAssignmentPattern
+    kAssignment
   };
 
   explicit PreParserExpression(uint32_t expression_code)
       : code_(expression_code) {}
 
   // The first three bits are for the Type.
   typedef BitField<Type, 0, 3> TypeField;
 
   // The rest of the bits are interpreted depending on the value
   // of the Type field, so they can share the storage.
@@ skipping 169 matching lines @@
     return PreParserExpression::Default();
   }
   PreParserExpression NewRewritableAssignmentExpression(
       PreParserExpression expression) {
     return expression;
   }
   PreParserExpression NewAssignment(Token::Value op,
                                     PreParserExpression left,
                                     PreParserExpression right,
                                     int pos) {
-    return PreParserExpression::Default();
-  }
-  PreParserExpression NewAssignmentPattern(PreParserExpression pattern,
-                                           int pos) {
-    DCHECK(pattern->IsObjectLiteral() || pattern->IsArrayLiteral());
-    return PreParserExpression::AssignmentPattern();
+    return PreParserExpression::Assignment();
   }
   PreParserExpression NewYield(PreParserExpression generator_object,
                                PreParserExpression expression,
                                Yield::Kind yield_kind,
                                int pos) {
     return PreParserExpression::Default();
   }
   PreParserExpression NewConditional(PreParserExpression condition,
                                      PreParserExpression then_expression,
                                      PreParserExpression else_expression,
@@ skipping 629 matching lines @@
     const PreParserFormalParameters& parameters, FunctionKind kind,
     FunctionLiteral::FunctionType function_type, bool* ok) {
   return pre_parser_->ParseEagerFunctionBody(function_name, pos, parameters,
                                              kind, function_type, ok);
 }
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PREPARSER_H