[parser] Allow duplicate __proto__ keys in patterns

src/parsing/expression-classifier.h

 // 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.
 
 #ifndef V8_PARSING_EXPRESSION_CLASSIFIER_H
 #define V8_PARSING_EXPRESSION_CLASSIFIER_H
 
 #include "src/messages.h"
 #include "src/parsing/scanner.h"
 #include "src/parsing/token.h"
 
 namespace v8 {
 namespace internal {
 
 
 #define ERROR_CODES(T)                          \
   T(ExpressionProduction, 0)                    \
   T(FormalParameterInitializerProduction, 1)    \
   T(BindingPatternProduction, 2)                \
   T(AssignmentPatternProduction, 3)             \
   T(DistinctFormalParametersProduction, 4)      \
   T(StrictModeFormalParametersProduction, 5)    \
   T(ArrowFormalParametersProduction, 6)         \
   T(LetPatternProduction, 7)                    \
   T(CoverInitializedNameProduction, 8)          \
   T(TailCallExpressionProduction, 9)            \
   T(AsyncArrowFormalParametersProduction, 10)   \
-  T(AsyncBindingPatternProduction, 11)
+  T(AsyncBindingPatternProduction, 11)          \
+  T(AnnexBDuplicateProtoProduction, 12)

[adamk, 2016/08/19 20:17:07]

Let's just call this DuplicateProtoProduction.

[gsathya, 2016/08/19 23:22:57]

Changed to ObjectLiteralProduction as discussed offline

 
 
 template <typename Traits>
 class ExpressionClassifier {
  public:
   enum ErrorKind : unsigned {
 #define DEFINE_ERROR_KIND(NAME, CODE) k##NAME = CODE,
     ERROR_CODES(DEFINE_ERROR_KIND)
 #undef DEFINE_ERROR_KIND
     kUnusedError = 15  // Larger than error codes; should fit in 4 bits
@@ skipping 28 matching lines @@
         (ExpressionProduction | FormalParameterInitializerProduction |
          TailCallExpressionProduction),
     PatternProductions =
         (BindingPatternProduction | AssignmentPatternProduction |
          LetPatternProduction | AsyncBindingPatternProduction),
     FormalParametersProductions = (DistinctFormalParametersProduction |
                                    StrictModeFormalParametersProduction),
     AllProductions =
         (ExpressionProductions | PatternProductions |
          FormalParametersProductions | ArrowFormalParametersProduction |
-         CoverInitializedNameProduction | AsyncArrowFormalParametersProduction)
+         CoverInitializedNameProduction | AsyncArrowFormalParametersProduction |
+         AnnexBDuplicateProtoProduction)
   };
 
   enum FunctionProperties : unsigned {
     NonSimpleParameter = 1 << 0
   };
 
   explicit ExpressionClassifier(const Traits* t)
       : zone_(t->zone()),
         non_patterns_to_rewrite_(t->GetNonPatternList()),
         reported_errors_(t->GetReportedErrorList()),
@@ skipping 106 matching lines @@
   V8_INLINE const Error& cover_initialized_name_error() const {
     return reported_error(kCoverInitializedNameProduction);
   }
 
   V8_INLINE bool has_tail_call_expression() const {
     return !is_valid(TailCallExpressionProduction);
   }
   V8_INLINE const Error& tail_call_expression_error() const {
     return reported_error(kTailCallExpressionProduction);
   }
+
+  V8_INLINE bool has_annexb_duplicate_proto() const {
+    return !is_valid(AnnexBDuplicateProtoProduction);
+  }
+
+  V8_INLINE const Error& annexb_duplicate_proto_error() const {
+    return reported_error(kAnnexBDuplicateProtoProduction);
+  }
+
   V8_INLINE const Error& async_arrow_formal_parameters_error() const {
     return reported_error(kAsyncArrowFormalParametersProduction);
   }
 
   V8_INLINE const Error& async_binding_pattern_error() const {
     return reported_error(kAsyncBindingPatternProduction);
   }
 
   V8_INLINE bool is_simple_parameter_list() const {
     return !(function_properties_ & NonSimpleParameter);
@@ skipping 109 matching lines @@
   }
 
   void RecordTailCallExpressionError(const Scanner::Location& loc,
                                      MessageTemplate::Template message,
                                      const char* arg = nullptr) {
     if (has_tail_call_expression()) return;
     invalid_productions_ |= TailCallExpressionProduction;
     Add(Error(loc, message, kTailCallExpressionProduction, arg));
   }
 
+  void RecordAnnexBDuplicateProtoError(const Scanner::Location& loc,
+                                       MessageTemplate::Template message,
+                                       const char* arg = nullptr) {
+    if (has_annexb_duplicate_proto()) return;
+    invalid_productions_ |= AnnexBDuplicateProtoProduction;
+    Add(Error(loc, message, kAnnexBDuplicateProtoProduction, arg));
+  }
+
   void ForgiveCoverInitializedNameError() {
     if (!(invalid_productions_ & CoverInitializedNameProduction)) return;
     Error& e = reported_error(kCoverInitializedNameProduction);
     e.kind = kUnusedError;
     invalid_productions_ &= ~CoverInitializedNameProduction;
   }
 
   void ForgiveAssignmentPatternError() {
     if (!(invalid_productions_ & AssignmentPatternProduction)) return;
     Error& e = reported_error(kAssignmentPatternProduction);
     e.kind = kUnusedError;
     invalid_productions_ &= ~AssignmentPatternProduction;
   }
 
+  void ForgiveAnnexBDuplicateProtoError() {
+    if (!(invalid_productions_ & AnnexBDuplicateProtoProduction)) return;
+    Error& e = reported_error(kAnnexBDuplicateProtoProduction);
+    e.kind = kUnusedError;
+    invalid_productions_ &= ~AnnexBDuplicateProtoProduction;
+  }
+
   void Accumulate(ExpressionClassifier* inner, unsigned productions,
                   bool merge_non_patterns = true) {
     DCHECK_EQ(inner->reported_errors_, reported_errors_);
     DCHECK_EQ(inner->reported_errors_begin_, reported_errors_end_);
     DCHECK_EQ(inner->reported_errors_end_, reported_errors_->length());
     if (merge_non_patterns) MergeNonPatterns(inner);
     // Propagate errors from inner, but don't overwrite already recorded
     // errors.
     unsigned non_arrow_inner_invalid_productions =
         inner->invalid_productions_ & ~ArrowFormalParametersProduction;
@@ skipping 135 matching lines @@
 };
 
 
 #undef ERROR_CODES
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_EXPRESSION_CLASSIFIER_H