[parser] unify metaproperty parsing and require unescaped property name

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/hashmap.h"
@@ skipping 436 matching lines @@
       return true;
     }
     return false;
   }
 
   bool PeekContextualKeyword(Vector<const char> keyword) {
     return peek() == Token::IDENTIFIER &&
            scanner()->is_next_contextual_keyword(keyword);
   }
 
+  int ExpectMetaProperty(Vector<const char> keyword, const char* full,

[adamk, 2016/02/16 20:52:09]

Some nits on argument names: this should be "property", not "keyword". Also, how
about "full_name" instead of "full"?

[caitp (gmail), 2016/02/16 22:13:55]

Done.

+                         bool* ok);
+
   void ExpectContextualKeyword(Vector<const char> keyword, bool* ok) {
     Expect(Token::IDENTIFIER, ok);
     if (!*ok) return;
     if (!scanner()->is_literal_contextual_keyword(keyword)) {
       ReportUnexpectedToken(scanner()->current_token());
       *ok = false;
     }
   }
 
   bool CheckInOrOf(ForEachStatement::VisitMode* visit_mode, bool* ok) {
@@ skipping 2066 matching lines @@
 
   // Parse the initial primary or function expression.
   ExpressionT result = this->EmptyExpression();
   if (peek() == Token::FUNCTION) {
     BindingPatternUnexpectedToken(classifier);
     ArrowFormalParametersUnexpectedToken(classifier);
 
     Consume(Token::FUNCTION);
     int function_token_position = position();
 
-    if (FLAG_harmony_function_sent && Check(Token::PERIOD)) {
+    if (FLAG_harmony_function_sent && peek() == Token::PERIOD) {
       // function.sent
-
-      int pos = position();
-      ExpectContextualKeyword(CStrVector("sent"), CHECK_OK);
+      int pos =
+          ExpectMetaProperty(CStrVector("sent"), "function.sent", CHECK_OK);
 
       if (!is_generator()) {
         // TODO(neis): allow escaping into closures?
         ReportMessageAt(scanner()->location(),
                         MessageTemplate::kUnexpectedFunctionSent);
         *ok = false;
         return this->EmptyExpression();
       }
 
       return this->FunctionSentExpression(scope_, factory(), pos);
@@ skipping 204 matching lines @@
       function_state_->set_super_location(scanner()->location());
       return this->SuperCallReference(scope_, factory(), pos);
     }
   }
 
   ReportMessageAt(scanner()->location(), MessageTemplate::kUnexpectedSuper);
   *ok = false;
   return this->EmptyExpression();
 }
 
+template <class Traits>
+int ParserBase<Traits>::ExpectMetaProperty(Vector<const char> keyword,

[adamk, 2016/02/16 20:52:09]

Returning a position isn't something we do elsewhere in the parser, I don't see
a win in introducing a new convention here. Would prefer this be a void function
and keep the position() call outside. You could pass in the position if you want
to avoid redundant position() calls.

[caitp (gmail), 2016/02/16 22:13:55]

Done.

+                                           const char* full, bool* ok) {
+  int pos = position();
+  if (*ok) {

[adamk, 2016/02/16 20:52:09]

I don't think should ever be false, so this if statement isn't needed.

[caitp (gmail), 2016/02/16 22:13:55]

Done.

+    Consume(Token::PERIOD);
+    ExpectContextualKeyword(keyword, ok);
+    if (!*ok) return pos;
+    if (scanner()->literal_contains_escapes()) {
+      Traits::ReportMessageAt(
+          Scanner::Location(pos, scanner()->location().end_pos),
+          MessageTemplate::kInvalidEscapedMetaProperty, full, kSyntaxError);

[adamk, 2016/02/16 20:52:09]

kSyntaxError is the default

[caitp (gmail), 2016/02/16 22:13:55]

Done.

+      *ok = false;
+    }
+  }
+  return pos;
+}
 
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT
 ParserBase<Traits>::ParseNewTargetExpression(bool* ok) {
-  int pos = position();
-  Consume(Token::PERIOD);
-  ExpectContextualKeyword(CStrVector("target"), CHECK_OK);
+  int pos = ExpectMetaProperty(CStrVector("target"), "new.target", CHECK_OK);
 
   if (!scope_->ReceiverScope()->is_function_scope()) {
     ReportMessageAt(scanner()->location(),
                     MessageTemplate::kUnexpectedNewTarget);
     *ok = false;
     return this->EmptyExpression();
   }
 
   return this->NewTargetExpression(scope_, factory(), pos);
 }
@@ skipping 556 matching lines @@
       return;
     }
     has_seen_constructor_ = true;
     return;
   }
 }
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PARSER_BASE_H