[parser] Allow duplicate __proto__ keys in patterns

src/parsing/parser-base.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_PARSER_BASE_H
 #define V8_PARSING_PARSER_BASE_H
 
 #include "src/ast/scopes.h"
 #include "src/bailout-reason.h"
 #include "src/base/hashmap.h"
@@ skipping 1164 matching lines @@
     kAccessorProperty,
     kValueProperty,
     kMethodProperty
   };
 
   class ObjectLiteralCheckerBase {
    public:
     explicit ObjectLiteralCheckerBase(ParserBase* parser) : parser_(parser) {}
 
     virtual void CheckProperty(Token::Value property, PropertyKind type,
-                               MethodKind method_type, bool* ok) = 0;
+                               MethodKind method_type,
+                               ExpressionClassifier* classifier, bool* ok) = 0;
 
     virtual ~ObjectLiteralCheckerBase() {}
 
    protected:
     ParserBase* parser() const { return parser_; }
     Scanner* scanner() const { return parser_->scanner(); }
 
    private:
     ParserBase* parser_;
   };
 
   // Validation per ES6 object literals.
   class ObjectLiteralChecker : public ObjectLiteralCheckerBase {
    public:
     explicit ObjectLiteralChecker(ParserBase* parser)
         : ObjectLiteralCheckerBase(parser), has_seen_proto_(false) {}
 
     void CheckProperty(Token::Value property, PropertyKind type,
-                       MethodKind method_type, bool* ok) override;
+                       MethodKind method_type, ExpressionClassifier* classifier,
+                       bool* ok) override;
 
    private:
     bool IsProto() { return this->scanner()->LiteralMatches("__proto__", 9); }
 
     bool has_seen_proto_;
   };
 
   // Validation per ES6 class literals.
   class ClassLiteralChecker : public ObjectLiteralCheckerBase {
    public:
     explicit ClassLiteralChecker(ParserBase* parser)
         : ObjectLiteralCheckerBase(parser), has_seen_constructor_(false) {}
 
     void CheckProperty(Token::Value property, PropertyKind type,
-                       MethodKind method_type, bool* ok) override;
+                       MethodKind method_type, ExpressionClassifier* classifier,
+                       bool* ok) override;
 
    private:
     bool IsConstructor() {
       return this->scanner()->LiteralMatches("constructor", 11);
     }
     bool IsPrototype() {
       return this->scanner()->LiteralMatches("prototype", 9);
     }
 
     bool has_seen_constructor_;
@@ skipping 724 matching lines @@
   }
 
   if (!in_class && !is_generator) {
     DCHECK(!IsStaticMethod(method_kind));
 
     if (peek() == Token::COLON) {
       // PropertyDefinition
       //    PropertyName ':' AssignmentExpression
       if (!*is_computed_name) {
         checker->CheckProperty(name_token, kValueProperty, MethodKind::kNormal,
+                               classifier,
                                CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
       }
       Consume(Token::COLON);
       int beg_pos = peek_position();
       ExpressionT value = this->ParseAssignmentExpression(
           true, classifier, CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
       CheckDestructuringElement(value, classifier, beg_pos,
                                 scanner()->location().end_pos);
 
       return factory()->NewObjectLiteralProperty(name_expression, value,
@@ skipping 74 matching lines @@
         CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
     method_kind |= MethodKind::kAsync;
   }
 
   if (is_generator || peek() == Token::LPAREN) {
     // MethodDefinition
     //    PropertyName '(' StrictFormalParameters ')' '{' FunctionBody '}'
     //    '*' PropertyName '(' StrictFormalParameters ')' '{' FunctionBody '}'
     if (!*is_computed_name) {
       checker->CheckProperty(name_token, kMethodProperty, method_kind,
+                             classifier,
                              CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
     }
 
     FunctionKind kind = is_generator
                             ? FunctionKind::kConciseGeneratorMethod
                             : is_async ? FunctionKind::kAsyncConciseMethod
                                        : FunctionKind::kConciseMethod;
 
     if (in_class && !IsStaticMethod(method_kind) &&
         this->IsConstructor(*name)) {
@@ skipping 30 matching lines @@
     *name = this->EmptyIdentifier();
     bool dont_care = false;
     name_token = peek();
 
     name_expression = ParsePropertyName(
         name, &dont_care, &dont_care, &dont_care, is_computed_name, classifier,
         CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
 
     if (!*is_computed_name) {
       checker->CheckProperty(name_token, kAccessorProperty, method_kind,
+                             classifier,
                              CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
     }
 
     typename Traits::Type::FunctionLiteral value = this->ParseFunctionLiteral(
         *name, scanner()->location(), kSkipFunctionNameCheck,
         is_get ? FunctionKind::kGetterFunction : FunctionKind::kSetterFunction,
         kNoSourcePosition, FunctionLiteral::kAccessorOrMethod, language_mode(),
         CHECK_OK_CUSTOM(EmptyObjectLiteralProperty));
 
     // Make sure the name expression is a string since we need a Name for
@@ skipping 284 matching lines @@
     return expression;
   }
 
   // Now pending non-pattern expressions must be discarded.
   arrow_formals_classifier.Discard();
 
   CheckNoTailCallExpressions(classifier, CHECK_OK);
 
   if (IsValidPattern(expression) && peek() == Token::ASSIGN) {
     classifier->ForgiveCoverInitializedNameError();
+    classifier->ForgiveExpressionError();

[adamk, 2016/08/18 20:35:22]

Is this necessary? What fails if you don't "forgive"?

[gsathya, 2016/08/19 20:11:18]

As discussed offline -- leaving this here. 

     ValidateAssignmentPattern(classifier, CHECK_OK);
     is_destructuring_assignment = true;
   } else {
     expression = this->CheckAndRewriteReferenceExpression(
         expression, lhs_beg_pos, scanner()->location().end_pos,
         MessageTemplate::kInvalidLhsInAssignment, CHECK_OK);
   }
 
   expression = this->MarkExpressionAsAssigned(expression);
 
@@ skipping 10 matching lines @@
   ExpressionT right =
       this->ParseAssignmentExpression(accept_IN, &rhs_classifier, CHECK_OK);
   CheckNoTailCallExpressions(&rhs_classifier, CHECK_OK);
   Traits::RewriteNonPattern(&rhs_classifier, CHECK_OK);
   classifier->Accumulate(
       &rhs_classifier,
       ExpressionClassifier::ExpressionProductions |
           ExpressionClassifier::CoverInitializedNameProduction |
           ExpressionClassifier::AsyncArrowFormalParametersProduction);
 
+  if (!classifier->is_valid_expression())

[adamk, 2016/08/18 20:35:22]

Was this necessary? I wouldn't think you'd need to add this.

[gsathya, 2016/08/19 20:11:18]

Removed.

+    ReportClassifierError(classifier->expression_error());
+
   // TODO(1231235): We try to estimate the set of properties set by
   // constructors. We define a new property whenever there is an
   // assignment to a property of 'this'. We should probably only add
   // properties if we haven't seen them before. Otherwise we'll
   // probably overestimate the number of properties.
   if (op == Token::ASSIGN && this->IsThisProperty(expression)) {
     function_state_->AddProperty();
   }
 
   this->CheckAssigningFunctionLiteralToProperty(expression, right);
@@ skipping 1218 matching lines @@
   }
 }
 
 
 #undef CHECK_OK
 #undef CHECK_OK_CUSTOM
 
 template <typename Traits>
 void ParserBase<Traits>::ObjectLiteralChecker::CheckProperty(
     Token::Value property, PropertyKind type, MethodKind method_type,
-    bool* ok) {
+    ExpressionClassifier* classifier, bool* ok) {

[adamk, 2016/08/18 20:35:22]

Hmm, it's a little strange that this takes "ok" now that it can never fail, but
I guess that's needed because of the class case?

[gsathya, 2016/08/19 20:11:18]

Yeah :/ It's the same with classifier being added to
ClassLiteralChecker::CheckProperty.

   DCHECK(!IsStaticMethod(method_type));
   DCHECK(!IsSpecialMethod(method_type) || type == kMethodProperty);
 
   if (property == Token::SMI || property == Token::NUMBER) return;
 
   if (type == kValueProperty && IsProto()) {
     if (has_seen_proto_) {
-      this->parser()->ReportMessage(MessageTemplate::kDuplicateProto);
-      *ok = false;
+      classifier->RecordExpressionError(this->scanner()->location(),
+                                        MessageTemplate::kDuplicateProto,
+                                        kSyntaxError);
       return;
     }
     has_seen_proto_ = true;
-    return;
   }
 }
 
 template <typename Traits>
 void ParserBase<Traits>::ClassLiteralChecker::CheckProperty(
     Token::Value property, PropertyKind type, MethodKind method_type,
-    bool* ok) {
+    ExpressionClassifier* classifier, bool* ok) {
   DCHECK(type == kMethodProperty || type == kAccessorProperty);
 
   if (property == Token::SMI || property == Token::NUMBER) return;
 
   if (IsStaticMethod(method_type)) {
     if (IsPrototype()) {
       this->parser()->ReportMessage(MessageTemplate::kStaticPrototype);
       *ok = false;
       return;
     }
@@ skipping 17 matching lines @@
     has_seen_constructor_ = true;
     return;
   }
 }
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PARSER_BASE_H