[strong] Implement static restrictions on binding 'undefined' in arrow functions

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 148 matching lines @@
   enum Mode {
     PARSE_LAZILY,
     PARSE_EAGERLY
   };
 
   enum VariableDeclarationContext {
     kStatementListItem,
     kStatement,
     kForStatement
   };
-
   class Checkpoint;
   class ObjectLiteralCheckerBase;
 
   // ---------------------------------------------------------------------------
   // FunctionState and BlockState together implement the parser's scope stack.
   // The parser's current scope is in scope_. BlockState and FunctionState
   // constructors push on the scope stack and the destructors pop. They are also
   // used to hold the parser's per-function and per-block state.
   class BlockState BASE_EMBEDDED {
    public:
@@ skipping 308 matching lines @@
       Traits::ReportMessageAt(function_name_loc, "strong_undefined");
       *ok = false;
       return;
     }
   }
 
   // Checking the parameter names of a function literal. This has to be done
   // after parsing the function, since the function can declare itself strict.
   void CheckFunctionParameterNames(LanguageMode language_mode,
                                    bool strict_params,
-                                   const Scanner::Location& eval_args_error_loc,
-                                   const Scanner::Location& undefined_error_loc,
-                                   const Scanner::Location& dupe_error_loc,
+                                   const Scanner::Location& eval_args_loc,
+                                   const Scanner::Location& undefined_loc,
+                                   const Scanner::Location& dupe_loc,
                                    const Scanner::Location& reserved_loc,
                                    bool* ok) {
     if (is_sloppy(language_mode) && !strict_params) return;
-
-    if (is_strict(language_mode) && eval_args_error_loc.IsValid()) {
-      Traits::ReportMessageAt(eval_args_error_loc, "strict_eval_arguments");
+    if (is_strict(language_mode) && eval_args_loc.IsValid()) {
+      Traits::ReportMessageAt(eval_args_loc, "strict_eval_arguments");
       *ok = false;
       return;
     }
-    if (is_strong(language_mode) && undefined_error_loc.IsValid()) {
-      Traits::ReportMessageAt(eval_args_error_loc, "strong_undefined");
+    if (is_strong(language_mode) && undefined_loc.IsValid()) {
+      Traits::ReportMessageAt(undefined_loc, "strong_undefined");
       *ok = false;
       return;
     }
     // TODO(arv): When we add support for destructuring in setters we also need
     // to check for duplicate names.
-    if (dupe_error_loc.IsValid()) {
-      Traits::ReportMessageAt(dupe_error_loc, "strict_param_dupe");
+    if (dupe_loc.IsValid()) {
+      Traits::ReportMessageAt(dupe_loc, "strict_param_dupe");
       *ok = false;
       return;
     }
     if (reserved_loc.IsValid()) {
       Traits::ReportMessageAt(reserved_loc, "unexpected_strict_reserved");
       *ok = false;
       return;
     }
   }
 
@@ skipping 221 matching lines @@
   bool IsStatic() const { return type_ == kStaticIdentifier; }
   bool IsYield() const { return type_ == kYieldIdentifier; }
   bool IsPrototype() const { return type_ == kPrototypeIdentifier; }
   bool IsConstructor() const { return type_ == kConstructorIdentifier; }
   bool IsFutureReserved() const { return type_ == kFutureReservedIdentifier; }
   bool IsFutureStrictReserved() const {
     return type_ == kFutureStrictReservedIdentifier ||
            type_ == kLetIdentifier || type_ == kStaticIdentifier ||
            type_ == kYieldIdentifier;
   }
-  V8_INLINE bool IsValidArrowParam() const {
-    // A valid identifier can be an arrow function parameter
-    // except for eval, arguments, yield, and reserved keywords.
-    return !(IsEval() || IsArguments() || IsFutureStrictReserved());
-  }
 
   // Allow identifier->name()[->length()] to work. The preparser
   // does not need the actual positions/lengths of the identifiers.
   const PreParserIdentifier* operator->() const { return this; }
   const PreParserIdentifier raw_name() const { return *this; }
 
   int position() const { return 0; }
   int length() const { return 0; }
 
  private:
   enum Type {
     kUnknownIdentifier,
     kFutureReservedIdentifier,
     kFutureStrictReservedIdentifier,
     kLetIdentifier,
     kStaticIdentifier,
     kYieldIdentifier,
     kEvalIdentifier,
     kArgumentsIdentifier,
     kUndefinedIdentifier,
     kPrototypeIdentifier,
     kConstructorIdentifier
   };
+
   explicit PreParserIdentifier(Type type) : type_(type) {}
   Type type_;
 
   friend class PreParserExpression;
 };
 
 
 class PreParserExpression {
  public:
   static PreParserExpression Default() {
     return PreParserExpression(TypeField::encode(kExpression));
   }
 
   static PreParserExpression Spread(PreParserExpression expression) {
     return PreParserExpression(TypeField::encode(kSpreadExpression));
   }
 
   static PreParserExpression FromIdentifier(PreParserIdentifier id) {
     return PreParserExpression(TypeField::encode(kIdentifierExpression) |
                                IdentifierTypeField::encode(id.type_));
   }
 
   static PreParserExpression BinaryOperation(PreParserExpression left,
                                              Token::Value op,
                                              PreParserExpression right) {
-    bool valid_arrow_param_list =
-        op == Token::COMMA && !left.is_parenthesized() &&
-        !right.is_parenthesized() && left.IsValidArrowParams() &&
-        right.IsValidArrowParams();
+    ValidArrowParam valid_arrow_param_list;
+    if (op == Token::COMMA && !left.is_parenthesized() &&
+       !right.is_parenthesized()) {
+      valid_arrow_param_list = std::min(left.IsValidArrowParams(),
+                                        right.IsValidArrowParams());
+    } else {
+      valid_arrow_param_list = kInvalidArrowParam;
+    }
     return PreParserExpression(
         TypeField::encode(kBinaryOperationExpression) |
         IsValidArrowParamListField::encode(valid_arrow_param_list));
   }
 
   static PreParserExpression EmptyArrowParamList() {
     // Any expression for which IsValidArrowParamList() returns true
     // will work here.
     return FromIdentifier(PreParserIdentifier::Default());
   }
@@ skipping 81 matching lines @@
 
   bool IsCall() const {
     return TypeField::decode(code_) == kExpression &&
            ExpressionTypeField::decode(code_) == kCallExpression;
   }
 
   bool IsValidReferenceExpression() const {
     return IsIdentifier() || IsProperty();
   }
 
-  bool IsValidArrowParamList() const {
-    return IsValidArrowParams() &&
-           ParenthesizationField::decode(code_) !=
-               kMultiParenthesizedExpression;
+  bool IsValidArrowParamList(Scope* scope, Scanner::Location* undefined_loc)
+  const {
+    ValidArrowParam valid = IsValidArrowParams();
+    if (ParenthesizationField::decode(code_) == kMultiParenthesizedExpression) {
+      return false;
+    }
+    if (valid == kValidArrowParam) {
+      return true;
+    } else if (valid == kInvalidStrongArrowParam) {
+      *undefined_loc = Scanner::Location();
+      return !is_strong(scope->language_mode());
+    } else {
+      return false;
+    }
   }
 
   // At the moment PreParser doesn't track these expression types.
   bool IsFunctionLiteral() const { return false; }
   bool IsCallNew() const { return false; }
 
   bool IsNoTemplateTag() const {
     return TypeField::decode(code_) == kExpression &&
            ExpressionTypeField::decode(code_) == kNoTemplateTagExpression;
   }
@@ skipping 45 matching lines @@
   };
 
   enum ExpressionType {
     kThisExpression,
     kThisPropertyExpression,
     kPropertyExpression,
     kCallExpression,
     kNoTemplateTagExpression
   };
 
+  enum ValidArrowParam {
+    kInvalidArrowParam,
+    kInvalidStrongArrowParam,
+    kValidArrowParam
+  };
+
   explicit PreParserExpression(uint32_t expression_code)
       : code_(expression_code) {}
 
-  V8_INLINE bool IsValidArrowParams() const {
-    return IsBinaryOperation()
-               ? IsValidArrowParamListField::decode(code_)
-               : (IsIdentifier() && AsIdentifier().IsValidArrowParam());
+  V8_INLINE ValidArrowParam IsValidArrowParams() const {
+    if (IsBinaryOperation()) {
+      return IsValidArrowParamListField::decode(code_);
+    }
+    if (!IsIdentifier()) {
+      return kInvalidArrowParam;
+    }
+    PreParserIdentifier ident = AsIdentifier();
+    // A valid identifier can be an arrow function parameter
+    // except for eval, arguments, yield, and reserved keywords.
+    if (ident.IsEval() || ident.IsArguments() ||
+        ident.IsFutureStrictReserved()) {
+      return kInvalidArrowParam;
+    }
+    // In strong mode, 'undefined' is similarly restricted.
+    if (ident.IsUndefined()) {
+      return kInvalidStrongArrowParam;
+    }
+    return kValidArrowParam;
   }
 
   // The first five bits are for the Type and Parenthesization.
   typedef BitField<Type, 0, 3> TypeField;
   typedef BitField<Parenthesization, TypeField::kNext, 2> ParenthesizationField;
 
   // The rest of the bits are interpreted depending on the value
   // of the Type field, so they can share the storage.
   typedef BitField<ExpressionType, ParenthesizationField::kNext, 3>
       ExpressionTypeField;
   typedef BitField<bool, ParenthesizationField::kNext, 1> IsUseStrictField;
   typedef BitField<bool, IsUseStrictField::kNext, 1> IsUseStrongField;
-  typedef BitField<bool, ParenthesizationField::kNext, 1>
+  typedef BitField<ValidArrowParam, ParenthesizationField::kNext, 2>
       IsValidArrowParamListField;
   typedef BitField<PreParserIdentifier::Type, ParenthesizationField::kNext, 10>
       IdentifierTypeField;
 
   uint32_t code_;
 };
 
 
 // PreParserExpressionList doesn't actually store the expressions because
 // PreParser doesn't need to.
@@ skipping 467 matching lines @@
   }
 
   V8_INLINE PreParserStatementList
   ParseEagerFunctionBody(PreParserIdentifier function_name, int pos,
                          Variable* fvar, Token::Value fvar_init_op,
                          FunctionKind kind, bool* ok);
 
   // Utility functions
   int DeclareArrowParametersFromExpression(PreParserExpression expression,
                                            Scope* scope,
+                                           Scanner::Location* undefined_loc,
                                            Scanner::Location* dupe_loc,
                                            bool* ok) {
     // TODO(aperez): Detect duplicated identifiers in paramlists.
-    *ok = expression.IsValidArrowParamList();
+    *ok = expression.IsValidArrowParamList(scope, undefined_loc);
     return 0;
   }
 
   struct TemplateLiteralState {};
 
   TemplateLiteralState OpenTemplateLiteral(int pos) {
     return TemplateLiteralState();
   }
   void AddTemplateSpan(TemplateLiteralState*, bool) {}
   void AddTemplateExpression(TemplateLiteralState*, PreParserExpression) {}
@@ skipping 1494 matching lines @@
                                               ExpressionT params_ast,
                                               bool* ok) {
   if (peek() == Token::ARROW && scanner_->HasAnyLineTerminatorBeforeNext()) {
     // ASI inserts `;` after arrow parameters if a line terminator is found.
     // `=> ...` is never a valid expression, so report as syntax error.
     // If next token is not `=>`, it's a syntax error anyways.
     ReportUnexpectedTokenAt(scanner_->peek_location(), Token::ARROW);
     *ok = false;
     return this->EmptyExpression();
   }
-
   Scope* scope = this->NewScope(scope_, ARROW_SCOPE);
   typename Traits::Type::StatementList body;
   int num_parameters = -1;
   int materialized_literal_count = -1;
   int expected_property_count = -1;
   int handler_count = 0;
   Scanner::Location super_loc;
 
   {
     typename Traits::Type::Factory function_factory(ast_value_factory());
     FunctionState function_state(&function_state_, &scope_, scope,
                                  kArrowFunction, &function_factory);
-    Scanner::Location dupe_error_loc = Scanner::Location::invalid();
-    // TODO(arv): Pass in eval_args_error_loc and reserved_loc here.
+    Scanner::Location undefined_loc = Scanner::Location::invalid();
+    Scanner::Location dupe_loc = Scanner::Location::invalid();
+    // TODO(arv): Pass in eval_args_loc and reserved_loc here.
     num_parameters = Traits::DeclareArrowParametersFromExpression(
-        params_ast, scope_, &dupe_error_loc, ok);
+        params_ast, scope_, &undefined_loc, &dupe_loc, ok);
     if (!*ok) {
       ReportMessageAt(
           Scanner::Location(start_pos, scanner()->location().beg_pos),
           "malformed_arrow_function_parameter_list");
       return this->EmptyExpression();
     }
 
+    if (undefined_loc.IsValid()) {
+      // Workaround for preparser not keeping track of positions.

[conradw, 2015/04/10 12:27:45]

Here's how the position of the error can be reported without the preparser
knowing where the identifier is...

+      undefined_loc = Scanner::Location(start_pos,
+                                        scanner()->location().end_pos);
+    }
     if (num_parameters > Code::kMaxArguments) {
       ReportMessageAt(Scanner::Location(params_ast->position(), position()),
                       "too_many_parameters");
       *ok = false;
       return this->EmptyExpression();
     }
 
     Expect(Token::ARROW, CHECK_OK);
 
     if (peek() == Token::LBRACE) {
-      // Multiple statemente body
+      // Multiple statement body
       Consume(Token::LBRACE);
       bool is_lazily_parsed =
           (mode() == PARSE_LAZILY && scope_->AllowsLazyCompilation());
       if (is_lazily_parsed) {
         body = this->NewStatementList(0, zone());
         this->SkipLazyFunctionBody(this->EmptyIdentifier(),
                                    &materialized_literal_count,
                                    &expected_property_count, CHECK_OK);
       } else {
         body = this->ParseEagerFunctionBody(
@@ skipping 14 matching lines @@
       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();
 
     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, undefined_error_loc, and reserved_loc
-    // needs to be set by DeclareArrowParametersFromExpression.
-    Scanner::Location eval_args_error_loc = Scanner::Location::invalid();
-    Scanner::Location undefined_error_loc = Scanner::Location::invalid();
+    // TODO(arv): eval_args_loc and reserved_loc needs to be set by
+    // DeclareArrowParametersFromExpression.
+    Scanner::Location eval_args_loc = Scanner::Location::invalid();
     Scanner::Location reserved_loc = Scanner::Location::invalid();
     const bool use_strict_params = true;
     this->CheckFunctionParameterNames(language_mode(), use_strict_params,
-                                      eval_args_error_loc, undefined_error_loc,
-                                      dupe_error_loc, reserved_loc, CHECK_OK);
+                                      eval_args_loc, undefined_loc, dupe_loc,
+                                      reserved_loc, CHECK_OK);
 
     // Validate strict mode.
     if (is_strict(language_mode())) {
       CheckStrictOctalLiteral(start_pos, scanner()->location().end_pos,
                               CHECK_OK);
       this->CheckConflictingVarDeclarations(scope, CHECK_OK);
     }
   }
 
   FunctionLiteralT function_literal = factory()->NewFunctionLiteral(
@@ skipping 192 matching lines @@
       *ok = false;
       return;
     }
     has_seen_constructor_ = true;
     return;
   }
 }
 } }  // v8::internal
 
 #endif  // V8_PREPARSER_H