WIP: new.target

src/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_PREPARSER_H
 #define V8_PREPARSER_H
 
 #include "src/v8.h"
 
 #include "src/bailout-reason.h"
@@ skipping 96 matching lines @@
         zone_(zone),
         scanner_(scanner),
         stack_overflow_(false),
         allow_lazy_(false),
         allow_natives_(false),
         allow_harmony_arrow_functions_(false),
         allow_harmony_object_literals_(false),
         allow_harmony_sloppy_(false),
         allow_harmony_computed_property_names_(false),
         allow_harmony_rest_params_(false),
+        allow_harmony_new_target_(false),
         allow_harmony_spreadcalls_(false),
         allow_strong_mode_(false) {}
 
   // Getters that indicate whether certain syntactical constructs are
   // allowed to be parsed by this instance of the parser.
   bool allow_lazy() const { return allow_lazy_; }
   bool allow_natives() const { return allow_natives_; }
   bool allow_harmony_arrow_functions() const {
     return allow_harmony_arrow_functions_;
   }
   bool allow_harmony_modules() const { return scanner()->HarmonyModules(); }
   bool allow_harmony_classes() const { return scanner()->HarmonyClasses(); }
   bool allow_harmony_object_literals() const {
     return allow_harmony_object_literals_;
   }
   bool allow_harmony_sloppy() const { return allow_harmony_sloppy_; }
   bool allow_harmony_unicode() const { return scanner()->HarmonyUnicode(); }
   bool allow_harmony_computed_property_names() const {
     return allow_harmony_computed_property_names_;
   }
   bool allow_harmony_rest_params() const {
     return allow_harmony_rest_params_;
   }
+  bool allow_harmony_new_target() const { return allow_harmony_new_target_; }
   bool allow_harmony_spreadcalls() const { return allow_harmony_spreadcalls_; }
 
   bool allow_strong_mode() const { return allow_strong_mode_; }
 
   // Setters that determine whether certain syntactical constructs are
   // allowed to be parsed by this instance of the parser.
   void set_allow_lazy(bool allow) { allow_lazy_ = allow; }
   void set_allow_natives(bool allow) { allow_natives_ = allow; }
   void set_allow_harmony_arrow_functions(bool allow) {
     allow_harmony_arrow_functions_ = allow;
@@ skipping 12 matching lines @@
   }
   void set_allow_harmony_unicode(bool allow) {
     scanner()->SetHarmonyUnicode(allow);
   }
   void set_allow_harmony_computed_property_names(bool allow) {
     allow_harmony_computed_property_names_ = allow;
   }
   void set_allow_harmony_rest_params(bool allow) {
     allow_harmony_rest_params_ = allow;
   }
+  void set_allow_harmony_new_target(bool allow) {
+    allow_harmony_new_target_ = allow;
+  }
   void set_allow_harmony_spreadcalls(bool allow) {
     allow_harmony_spreadcalls_ = allow;
   }
   void set_allow_strong_mode(bool allow) { allow_strong_mode_ = allow; }
 
  protected:
   enum AllowRestrictedIdentifiers {
     kAllowRestrictedIdentifiers,
     kDontAllowRestrictedIdentifiers
   };
@@ skipping 438 matching lines @@
   ExpressionT ParseMemberWithNewPrefixesExpression(bool* ok);
   ExpressionT ParseMemberExpression(bool* ok);
   ExpressionT ParseMemberExpressionContinuation(ExpressionT expression,
                                                 bool* ok);
   ExpressionT ParseArrowFunctionLiteral(
       Scope* function_scope, const FormalParameterErrorLocations& error_locs,
       bool has_rest, bool* ok);
   ExpressionT ParseTemplateLiteral(ExpressionT tag, int start, bool* ok);
   void AddTemplateExpression(ExpressionT);
   ExpressionT ParseSuperExpression(bool is_new, bool* ok);
+  ExpressionT ParseNewTargetExpression(bool* ok);
 
   void ParseFormalParameter(FormalParameterScopeT* scope,
                             FormalParameterErrorLocations* locs, bool is_rest,
                             bool* ok);
   int ParseFormalParameterList(FormalParameterScopeT* scope,
                                FormalParameterErrorLocations* locs,
                                bool* has_rest, bool* ok);
   void CheckArityRestrictions(
       int param_count, FunctionLiteral::ArityRestriction arity_restriction,
       int formals_start_pos, int formals_end_pos, bool* ok);
@@ skipping 85 matching lines @@
   Scanner* scanner_;
   bool stack_overflow_;
 
   bool allow_lazy_;
   bool allow_natives_;
   bool allow_harmony_arrow_functions_;
   bool allow_harmony_object_literals_;
   bool allow_harmony_sloppy_;
   bool allow_harmony_computed_property_names_;
   bool allow_harmony_rest_params_;
+  bool allow_harmony_new_target_;
   bool allow_harmony_spreadcalls_;
   bool allow_strong_mode_;
 };
 
 
 class PreParserIdentifier {
  public:
   PreParserIdentifier() : type_(kUnknownIdentifier) {}
   static PreParserIdentifier Default() {
     return PreParserIdentifier(kUnknownIdentifier);
@@ skipping 753 matching lines @@
   static PreParserIdentifier GetNextSymbol(Scanner* scanner) {
     return PreParserIdentifier::Default();
   }
 
   static PreParserExpression ThisExpression(Scope* scope,
                                             PreParserFactory* factory,
                                             int pos) {
     return PreParserExpression::This();
   }
 
+  static PreParserExpression NewTargetExpression(Scope* scope,
+                                                 PreParserFactory* factory,
+                                                 int start_position,
+                                                 int end_position) {
+    return PreParserExpression::Default();
+  }
+
   static PreParserExpression SuperReference(Scope* scope,
                                             PreParserFactory* factory) {
     return PreParserExpression::Default();
   }
 
   static PreParserExpression DefaultConstructor(bool call_super, Scope* scope,
                                                 int pos, int end_pos) {
     return PreParserExpression::Default();
   }
 
@@ skipping 1383 matching lines @@
   }
 }
 
 
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT
 ParserBase<Traits>::ParseMemberWithNewPrefixesExpression(bool* ok) {
   // NewExpression ::
   //   ('new')+ MemberExpression
 
+  // NewTarget ::
+  //   'new' '.' 'target'
+
   // The grammar for new expressions is pretty warped. We can have several 'new'
   // keywords following each other, and then a MemberExpression. When we see '('
   // after the MemberExpression, it's associated with the rightmost unassociated
   // 'new' to create a NewExpression with arguments. However, a NewExpression
   // can also occur without arguments.
 
   // Examples of new expression:
   // new foo.bar().baz means (new (foo.bar)()).baz
   // new foo()() means (new foo())()
   // new new foo()() means (new (new foo())())
   // new new foo means new (new foo)
   // new new foo() means new (new foo())
   // new new foo().bar().baz means (new (new foo()).bar()).baz
 
   if (peek() == Token::NEW) {
     Consume(Token::NEW);
     int new_pos = position();
     ExpressionT result = this->EmptyExpression();
     if (peek() == Token::SUPER) {
       const bool is_new = true;
       result = ParseSuperExpression(is_new, CHECK_OK);
+    } else if (allow_harmony_new_target() && peek() == Token::PERIOD) {
+      return ParseNewTargetExpression(CHECK_OK);
     } else {
       result = this->ParseMemberWithNewPrefixesExpression(CHECK_OK);
     }
     if (peek() == Token::LPAREN) {
       // NewExpression with arguments.
       Scanner::Location spread_pos;
       typename Traits::Type::ExpressionList args =
           this->ParseArguments(&spread_pos, CHECK_OK);
 
       if (spread_pos.IsValid()) {
@@ skipping 87 matching lines @@
           ReportMessageAt(scanner()->location(), "strong_super_call_duplicate");
           *ok = false;
           return this->EmptyExpression();
         } else if (function_state->return_location().IsValid()) {
           ReportMessageAt(function_state->return_location(),
                           "strong_constructor_return_misplaced");
           *ok = false;
           return this->EmptyExpression();
         }
       }
+      scope_->RecordNewTargetUsage();
       function_state->set_super_call_location(scanner()->location());
       return this->SuperReference(scope_, factory());
     }
   }
 
   ReportMessageAt(scanner()->location(), "unexpected_super");
   *ok = false;
   return this->EmptyExpression();
 }
 
 
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT
+ParserBase<Traits>::ParseNewTargetExpression(bool* ok) {
+  int pos = position();
+  Consume(Token::PERIOD);
+  ExpectContextualKeyword(CStrVector("target"), CHECK_OK);
+
+  Scope* scope = scope_->DeclarationScope();
+  while (scope->is_eval_scope() || scope->is_arrow_scope()) {
+    scope = scope->outer_scope();
+    DCHECK_NOT_NULL(scope);
+    scope = scope->DeclarationScope();
+  }
+
+  if (scope->is_script_scope() || scope->is_module_scope()) {
+    ReportMessageAt(scanner()->location(), "unexpected_new_target");
+    *ok = false;
+    return this->EmptyExpression();
+  }
+
+  scope_->RecordNewTargetUsage();
+
+  // ExpressionT is_construct_call = factory()->NewCallRuntime(
+  //     ast_value_factory()->is_construct_call_string(),
+  //     Runtime::FunctionForId(Runtime::kInlineIsConstructCall),
+  //     this->NewExpressionList(0, zone_), RelocInfo::kNoPosition);
+
+  // ExpressionT void_zero = factory()->NewUnaryOperation(
+  //     Token::VOID, factory()->NewNumberLiteral(0, RelocInfo::kNoPosition),
+  //     RelocInfo::kNoPosition);
+
+  // %_IsConstructCall() ? new.target : void 0
+  // return factory()->NewConditional(
+  //     is_construct_call,
+  //     this->NewTargetExpression(scope_, factory(), pos, position()),
+  //     void_zero,
+  //     RelocInfo::kNoPosition);
+
+  return this->NewTargetExpression(scope_, factory(), pos, position());
+}
+
+
+template <class Traits>
+typename ParserBase<Traits>::ExpressionT
 ParserBase<Traits>::ParseMemberExpressionContinuation(ExpressionT expression,
                                                       bool* ok) {
   // Parses this part of MemberExpression:
   // ('[' Expression ']' | '.' Identifier | TemplateLiteral)*
   while (true) {
     switch (peek()) {
       case Token::LBRACK: {
         Consume(Token::LBRACK);
         int pos = position();
         ExpressionT index = this->ParseExpression(true, CHECK_OK);
@@ skipping 410 matching lines @@
       *ok = false;
       return;
     }
     has_seen_constructor_ = true;
     return;
   }
 }
 } }  // v8::internal
 
 #endif  // V8_PREPARSER_H