[async functions] Disallow 'await' in arrow params inside async functions

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 915 matching lines @@
   void ValidateFormalParameterInitializer(
       const ExpressionClassifier* classifier, bool* ok) {
     if (!classifier->is_valid_formal_parameter_initializer()) {
       ReportClassifierError(classifier->formal_parameter_initializer_error());
       *ok = false;
     }
   }
 
   void ValidateBindingPattern(const ExpressionClassifier* classifier,
                               bool* ok) {
-    if (!classifier->is_valid_binding_pattern() ||

[caitp, 2016/08/19 23:04:34]

If this passes tests, it looks great. At some point, this was definitely needed
to make `var { ... await ... }` / var [ ... await ... ]` throw within async
functions. Maybe that's not true anymore.

I guess there's no reason the normal BindingPattern handler can't do this.

[adamk, 2016/08/19 23:07:42]

Yeah, that was exactly my thinking (and it seems to be true; I still need the
call to RecordBindingPatternError, it just doesn't have to be separate from
other binding pattern errors).

The same may actually be true of ExpressionError vs CoverInitializedNameError,
see discussion in gsathya's https://codereview.chromium.org/2255353002/.

Some day I'll understand all the uses of ExpressionClassifier :)

-        !classifier->is_valid_async_binding_pattern()) {
-      const Scanner::Location& a = classifier->binding_pattern_error().location;
-      const Scanner::Location& b =
-          classifier->async_binding_pattern_error().location;
-      if (a.beg_pos < 0 || (b.beg_pos >= 0 && a.beg_pos > b.beg_pos)) {
-        ReportClassifierError(classifier->async_binding_pattern_error());
-      } else {
-        ReportClassifierError(classifier->binding_pattern_error());
-      }
+    if (!classifier->is_valid_binding_pattern()) {
+      ReportClassifierError(classifier->binding_pattern_error());
       *ok = false;
     }
   }
 
   void ValidateAssignmentPattern(const ExpressionClassifier* classifier,
                                  bool* ok) {
     if (!classifier->is_valid_assignment_pattern()) {
       ReportClassifierError(classifier->assignment_pattern_error());
       *ok = false;
     }
@@ skipping 1825 matching lines @@
     int beg_pos = peek_position();
     switch (PeekAhead()) {
       case Token::RPAREN:
       case Token::RBRACK:
       case Token::RBRACE:
       case Token::ASSIGN:
       case Token::COMMA: {
         Next();
         IdentifierT name = this->GetSymbol(scanner());
 
-        // Possibly async arrow formals --- record ExpressionError just in case.
-        ExpressionUnexpectedToken(classifier);
-        classifier->RecordAsyncBindingPatternError(
+        classifier->RecordBindingPatternError(
             Scanner::Location(beg_pos, scanner()->location().end_pos),
             MessageTemplate::kAwaitBindingIdentifier);
-        classifier->RecordAsyncArrowFormalParametersError(
+        classifier->RecordArrowFormalParametersError(

[caitp, 2016/08/19 23:04:34]

good find!

             Scanner::Location(beg_pos, scanner()->location().end_pos),
             MessageTemplate::kAwaitBindingIdentifier);
 
         return this->ExpressionFromIdentifier(name, beg_pos,
                                               scanner()->location().end_pos);
       }
       default:
         break;
     }
 
@@ skipping 946 matching lines @@
     has_seen_constructor_ = true;
     return;
   }
 }
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PARSER_BASE_H