[strong] checking of this & super in constructors

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 199 matching lines @@
     int materialized_literal_count() {
       return next_materialized_literal_index_;
     }
 
     int NextHandlerIndex() { return next_handler_index_++; }
     int handler_count() { return next_handler_index_; }
 
     void AddProperty() { expected_property_count_++; }
     int expected_property_count() { return expected_property_count_; }
 
+    Scanner::Location this_location() const { return this_location_; }
+    Scanner::Location super_location() const { return super_location_; }
     Scanner::Location return_location() const { return return_location_; }
-    Scanner::Location super_call_location() const {
-      return super_call_location_;
+    void set_this_location(Scanner::Location location) {
+      this_location_ = location;
+    }
+    void set_super_location(Scanner::Location location) {
+      super_location_ = location;
     }
     void set_return_location(Scanner::Location location) {
       return_location_ = location;
     }
-    void set_super_call_location(Scanner::Location location) {
-      super_call_location_ = location;
-    }
 
     bool is_generator() const { return IsGeneratorFunction(kind_); }
 
     FunctionKind kind() const { return kind_; }
     FunctionState* outer() const { return outer_function_state_; }
 
     void set_generator_object_variable(
         typename Traits::Type::GeneratorVariable* variable) {
       DCHECK(variable != NULL);
       DCHECK(is_generator());
@@ skipping 11 matching lines @@
     // the function.  Includes regexp literals, and boilerplate for object and
     // array literals.
     int next_materialized_literal_index_;
 
     // Used to assign a per-function index to try and catch handlers.
     int next_handler_index_;
 
     // Properties count estimation.
     int expected_property_count_;
 
+    // Location of most recent use of 'this' (invalid if none).
+    Scanner::Location this_location_;
+
     // Location of most recent 'return' statement (invalid if none).
     Scanner::Location return_location_;
 
     // Location of call to the "super" constructor (invalid if none).
-    Scanner::Location super_call_location_;
+    Scanner::Location super_location_;
 
     FunctionKind kind_;
     // For generators, this variable may hold the generator object. It variable
     // is used by yield expressions and return statements. It is not necessary
     // for generator functions to have this variable set.
     Variable* generator_object_variable_;
 
     FunctionState** function_state_stack_;
     FunctionState* outer_function_state_;
     Scope** scope_stack_;
@@ skipping 321 matching lines @@
   ExpressionT ParseLeftHandSideExpression(bool* ok);
   ExpressionT ParseMemberWithNewPrefixesExpression(bool* ok);
   ExpressionT ParseMemberExpression(bool* ok);
   ExpressionT ParseMemberExpressionContinuation(ExpressionT expression,
                                                 bool* ok);
   ExpressionT ParseArrowFunctionLiteral(int start_pos, ExpressionT params_ast,
                                         bool* ok);
   ExpressionT ParseTemplateLiteral(ExpressionT tag, int start, bool* ok);
   void AddTemplateExpression(ExpressionT);
   ExpressionT ParseSuperExpression(bool is_new, bool* ok);
+  ExpressionT ParseStrongInitializationExpression(bool* ok);
+  ExpressionT ParseStrongSuperCallExpression(bool* ok);
 
   // Checks if the expression is a valid reference expression (e.g., on the
   // left-hand side of assignments). Although ruled out by ECMA as early errors,
   // we allow calls for web compatibility and rewrite them to a runtime throw.
   ExpressionT CheckAndRewriteReferenceExpression(
       ExpressionT expression,
       Scanner::Location location, const char* message, bool* ok);
 
   // Used to validate property names in object literals and class literals
   enum PropertyKind {
@@ skipping 1050 matching lines @@
 }
 
 
 template <class Traits>
 ParserBase<Traits>::FunctionState::FunctionState(
     FunctionState** function_state_stack, Scope** scope_stack, Scope* scope,
     FunctionKind kind, typename Traits::Type::Factory* factory)
     : next_materialized_literal_index_(0),
       next_handler_index_(0),
       expected_property_count_(0),
+      this_location_(Scanner::Location::invalid()),
       return_location_(Scanner::Location::invalid()),
-      super_call_location_(Scanner::Location::invalid()),
+      super_location_(Scanner::Location::invalid()),
       kind_(kind),
       generator_object_variable_(NULL),
       function_state_stack_(function_state_stack),
       outer_function_state_(*function_state_stack),
       scope_stack_(scope_stack),
       outer_scope_(*scope_stack),
       factory_(factory) {
   *scope_stack_ = scope;
   *function_state_stack = this;
 }
@@ skipping 192 matching lines @@
   //   '(' Expression ')'
   //   TemplateLiteral
 
   int beg_pos = scanner()->peek_location().beg_pos;
   int end_pos = scanner()->peek_location().end_pos;
   ExpressionT result = this->EmptyExpression();
   Token::Value token = peek();
   switch (token) {
     case Token::THIS: {
       Consume(Token::THIS);
+      if (is_strong(language_mode())) {
+        // Constructors' usages of 'this' in strong mode are parsed separately.
+        // TODO(rossberg): this does not work with arrow functions yet.
+        if (i::IsConstructor(function_state_->kind())) {
+          ReportMessage("strong_constructor_this");
+          *ok = false;
+          break;
+        }
+      }
       scope_->RecordThisUsage();
       result = this->ThisExpression(scope_, factory(), beg_pos);
       break;
     }
 
     case Token::NULL_LITERAL:
     case Token::TRUE_LITERAL:
     case Token::FALSE_LITERAL:
     case Token::SMI:
     case Token::NUMBER:
@@ skipping 50 matching lines @@
         parenthesized_function_ = (peek() == Token::FUNCTION);
         result = this->ParseExpression(true, CHECK_OK);
         result->increase_parenthesization_level();
         Expect(Token::RPAREN, CHECK_OK);
       }
       break;
 
     case Token::CLASS: {
       Consume(Token::CLASS);
       if (!allow_harmony_sloppy() && is_sloppy(language_mode())) {
-        ReportMessage("sloppy_lexical", NULL);
+        ReportMessage("sloppy_lexical");
         *ok = false;
         break;
       }
       int class_token_position = position();
       IdentifierT name = this->EmptyIdentifier();
       bool is_strict_reserved_name = false;
       Scanner::Location class_name_location = Scanner::Location::invalid();
       if (peek_any_identifier()) {
         name = ParseIdentifierOrStrictReservedWord(&is_strict_reserved_name,
                                                    CHECK_OK);
@@ skipping 806 matching lines @@
     result = ParsePrimaryExpression(CHECK_OK);
   }
 
   result = ParseMemberExpressionContinuation(result, CHECK_OK);
   return result;
 }
 
 
 template <class Traits>
 typename ParserBase<Traits>::ExpressionT
+ParserBase<Traits>::ParseStrongInitializationExpression(bool* ok) {
+  // InitializationExpression ::  (strong mode)
+  //  'this' '.' IdentifierName '=' AssignmentExpression
+  //  'this' '[' Expression ']' '=' AssignmentExpression
+
+  Consume(Token::THIS);
+  int pos = position();
+  function_state_->set_this_location(scanner()->location());
+  scope_->RecordThisUsage();
+  ExpressionT this_expr = this->ThisExpression(scope_, factory(), pos);
+
+  ExpressionT left = this->EmptyExpression();
+  switch (peek()) {
+    case Token::LBRACK: {
+      Consume(Token::LBRACK);
+      int pos = position();
+      ExpressionT index = this->ParseExpression(true, CHECK_OK);
+      left = factory()->NewProperty(this_expr, index, pos);
+      if (fni_ != NULL) {
+        this->PushPropertyName(fni_, index);
+      }
+      Expect(Token::RBRACK, CHECK_OK);
+      break;
+    }
+    case Token::PERIOD: {
+      Consume(Token::PERIOD);
+      int pos = position();
+      IdentifierT name = ParseIdentifierName(CHECK_OK);
+      left = factory()->NewProperty(
+          this_expr, factory()->NewStringLiteral(name, pos), pos);
+      if (fni_ != NULL) {
+        this->PushLiteralName(fni_, name);
+      }
+      break;
+    }
+    default:
+      ReportMessage("strong_constructor_this");
+      *ok = false;
+      return this->EmptyExpression();
+  }
+
+  if (peek() != Token::ASSIGN) {
+    ReportMessageAt(function_state_->this_location(),
+                    "strong_constructor_this");
+    *ok = false;
+    return this->EmptyExpression();
+  }
+  Consume(Token::ASSIGN);
+  left = this->MarkExpressionAsAssigned(left);
+
+  ExpressionT right = this->ParseAssignmentExpression(true, CHECK_OK);
+  this->CheckAssigningFunctionLiteralToProperty(left, right);
+  function_state_->AddProperty();
+  if (fni_ != NULL) {
+    // Check if the right hand side is a call to avoid inferring a
+    // name if we're dealing with "this.a = function(){...}();"-like
+    // expression.
+    if (!right->IsCall() && !right->IsCallNew()) {
+      fni_->Infer();
+    } else {
+      fni_->RemoveLastFunction();
+    }
+    fni_->Leave();
+  }
+
+  if (function_state_->return_location().IsValid()) {
+    ReportMessageAt(function_state_->return_location(),
+                    "strong_constructor_return_misplaced");
+    *ok = false;
+    return this->EmptyExpression();
+  }
+
+  return factory()->NewAssignment(Token::ASSIGN, left, right, pos);
+}
+
+
+template <class Traits>
+typename ParserBase<Traits>::ExpressionT
+ParserBase<Traits>::ParseStrongSuperCallExpression(bool* ok) {
+  // SuperCallExpression ::  (strong mode)
+  //  'super' '(' ExpressionList ')'
+
+  Consume(Token::SUPER);
+  int pos = position();
+  Scanner::Location super_loc = scanner()->location();
+  ExpressionT expr = this->SuperReference(scope_, factory());
+
+  if (peek() != Token::LPAREN) {
+    ReportMessage("strong_constructor_super");
+    *ok = false;
+    return this->EmptyExpression();
+  }
+
+  typename Traits::Type::ExpressionList args = ParseArguments(CHECK_OK);
+
+  // TODO(rossberg): This doesn't work with arrow functions yet.
+  if (!IsSubclassConstructor(function_state_->kind())) {
+    ReportMessage("unexpected_super");
+    *ok = false;
+    return this->EmptyExpression();
+  } else if (function_state_->super_location().IsValid()) {
+    ReportMessageAt(scanner()->location(), "strong_super_call_duplicate");
+    *ok = false;
+    return this->EmptyExpression();
+  } else if (function_state_->this_location().IsValid()) {
+    ReportMessageAt(scanner()->location(), "strong_super_call_misplaced");
+    *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();
+  }
+
+  function_state_->set_super_location(super_loc);
+  return factory()->NewCall(expr, args, pos);
+}
+
+
+template <class Traits>
+typename ParserBase<Traits>::ExpressionT
 ParserBase<Traits>::ParseSuperExpression(bool is_new, bool* ok) {
   Expect(Token::SUPER, CHECK_OK);
 
+  // TODO(aperez): Does this actually work with lazily compiled arrows?
   FunctionState* function_state = function_state_;
   while (IsArrowFunction(function_state->kind())) {
     function_state = function_state->outer();
   }
   // TODO(arv): Handle eval scopes similarly.
 
   FunctionKind kind = function_state->kind();
   if (IsConciseMethod(kind) || IsAccessorFunction(kind) ||
       i::IsConstructor(kind)) {
     if (peek() == Token::PERIOD || peek() == Token::LBRACK) {
       scope_->RecordSuperPropertyUsage();
       return this->SuperReference(scope_, factory());
     }
     // new super() is never allowed.
     // super() is only allowed in derived constructor
     if (!is_new && peek() == Token::LPAREN && IsSubclassConstructor(kind)) {
       if (is_strong(language_mode())) {
-        if (function_state->super_call_location().IsValid()) {
-          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();
-        }
+        // Super calls in strong mode are parsed separately.
+        ReportMessageAt(scanner()->location(), "strong_constructor_super");
+        *ok = false;
+        return this->EmptyExpression();
       }
-      function_state->set_super_call_location(scanner()->location());
+      function_state->set_super_location(scanner()->location());
       return this->SuperReference(scope_, factory());
     }
   }
 
   ReportMessageAt(scanner()->location(), "unexpected_super");
   *ok = false;
   return this->EmptyExpression();
 }
 
 
@@ skipping 121 matching lines @@
       // Single-expression body
       int pos = position();
       parenthesized_function_ = false;
       ExpressionT expression = ParseAssignmentExpression(true, CHECK_OK);
       body = this->NewStatementList(1, zone());
       body->Add(factory()->NewReturnStatement(expression, pos), zone());
       materialized_literal_count = function_state.materialized_literal_count();
       expected_property_count = function_state.expected_property_count();
       handler_count = function_state.handler_count();
     }
-    super_loc = function_state.super_call_location();
+    super_loc = function_state.super_location();
 
     scope->set_start_position(start_pos);
     scope->set_end_position(scanner()->location().end_pos);
 
     // Arrow function *parameter lists* are always checked as in strict mode.
     // TODO(arv): eval_args_error_loc and reserved_loc needs to be set by
     // DeclareArrowParametersFromExpression.
     Scanner::Location eval_args_error_loc = Scanner::Location::invalid();
     Scanner::Location reserved_loc = Scanner::Location::invalid();
     const bool use_strict_params = true;
@@ skipping 10 matching lines @@
 
   FunctionLiteralT function_literal = factory()->NewFunctionLiteral(
       this->EmptyIdentifierString(), ast_value_factory(), scope, body,
       materialized_literal_count, expected_property_count, handler_count,
       num_parameters, FunctionLiteral::kNoDuplicateParameters,
       FunctionLiteral::ANONYMOUS_EXPRESSION, FunctionLiteral::kIsFunction,
       FunctionLiteral::kNotParenthesized, FunctionKind::kArrowFunction,
       start_pos);
 
   function_literal->set_function_token_position(start_pos);
-  if (super_loc.IsValid()) function_state_->set_super_call_location(super_loc);
+  if (super_loc.IsValid()) function_state_->set_super_location(super_loc);
 
   if (fni_ != NULL) this->InferFunctionName(fni_, function_literal);
 
   return function_literal;
 }
 
 
 template <typename Traits>
 typename ParserBase<Traits>::ExpressionT
 ParserBase<Traits>::ParseTemplateLiteral(ExpressionT tag, int start, bool* ok) {
@@ skipping 164 matching lines @@
       *ok = false;
       return;
     }
     has_seen_constructor_ = true;
     return;
   }
 }
 } }  // v8::internal
 
 #endif  // V8_PREPARSER_H