[strong] Implement static restrictions on binding/assignment to 'undefined' identifier.

src/parser.cc

 // 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.
 
 #include "src/v8.h"
 
 #include "src/api.h"
 #include "src/ast.h"
 #include "src/bailout-reason.h"
 #include "src/base/platform/platform.h"
@@ skipping 447 matching lines @@
 
 bool ParserTraits::IsArguments(const AstRawString* identifier) const {
   return identifier == parser_->ast_value_factory()->arguments_string();
 }
 
 
 bool ParserTraits::IsEvalOrArguments(const AstRawString* identifier) const {
   return IsEval(identifier) || IsArguments(identifier);
 }
 
+bool ParserTraits::IsUndefined(const AstRawString* identifier) const {
+  return identifier == parser_->ast_value_factory()->undefined_string();
+}
 
 bool ParserTraits::IsPrototype(const AstRawString* identifier) const {
   return identifier == parser_->ast_value_factory()->prototype_string();
 }
 
 
 bool ParserTraits::IsConstructor(const AstRawString* identifier) const {
   return identifier == parser_->ast_value_factory()->constructor_string();
 }
 
@@ skipping 990 matching lines @@
       local_name = ParseIdentifierName(CHECK_OK);
     }
     if (!Token::IsIdentifier(scanner()->current_token(), STRICT, false)) {
       *ok = false;
       ReportMessage("unexpected_reserved");
       return NULL;
     } else if (IsEvalOrArguments(local_name)) {
       *ok = false;
       ReportMessage("strict_eval_arguments");
       return NULL;
+    } else if (is_strong(language_mode()) && IsUndefined(local_name)) {
+      *ok = false;
+      ReportMessage("strong_undefined");
+      return NULL;
     }
     VariableProxy* proxy = NewUnresolved(local_name, IMPORT);
     ImportDeclaration* declaration =
         factory()->NewImportDeclaration(proxy, import_name, NULL, scope_, pos);
     Declare(declaration, true, CHECK_OK);
     result->Add(declaration, zone());
     if (peek() == Token::RBRACE) break;
     Expect(Token::COMMA, CHECK_OK);
   }
 
@@ skipping 29 matching lines @@
     ExpectSemicolon(CHECK_OK);
     // TODO(ES6): Add module to the requested modules of scope_->module().
     USE(module_specifier);
     return factory()->NewEmptyStatement(pos);
   }
 
   // Parse ImportedDefaultBinding if present.
   ImportDeclaration* import_default_declaration = NULL;
   if (tok != Token::MUL && tok != Token::LBRACE) {
     const AstRawString* local_name =
-        ParseIdentifier(kDontAllowEvalOrArguments, CHECK_OK);
+        ParseIdentifier(kDontAllowRestrictedIdentifiers, CHECK_OK);
     VariableProxy* proxy = NewUnresolved(local_name, IMPORT);
     import_default_declaration = factory()->NewImportDeclaration(
         proxy, ast_value_factory()->default_string(), NULL, scope_, pos);
     Declare(import_default_declaration, true, CHECK_OK);
   }
 
   const AstRawString* module_instance_binding = NULL;
   ZoneList<ImportDeclaration*>* named_declarations = NULL;
   if (import_default_declaration == NULL || Check(Token::COMMA)) {
     switch (peek()) {
       case Token::MUL: {
         Consume(Token::MUL);
         ExpectContextualKeyword(CStrVector("as"), CHECK_OK);
         module_instance_binding =
-            ParseIdentifier(kDontAllowEvalOrArguments, CHECK_OK);
+            ParseIdentifier(kDontAllowRestrictedIdentifiers, CHECK_OK);
         // TODO(ES6): Add an appropriate declaration.
         break;
       }
 
       case Token::LBRACE:
         named_declarations = ParseNamedImports(pos, CHECK_OK);
         break;
 
       default:
         *ok = false;
@@ skipping 468 matching lines @@
 
 
 // Language extension which is only enabled for source files loaded
 // through the API's extension mechanism.  A native function
 // declaration is resolved by looking up the function through a
 // callback provided by the extension.
 Statement* Parser::ParseNativeDeclaration(bool* ok) {
   int pos = peek_position();
   Expect(Token::FUNCTION, CHECK_OK);
   // Allow "eval" or "arguments" for backward compatibility.
-  const AstRawString* name = ParseIdentifier(kAllowEvalOrArguments, CHECK_OK);
+  const AstRawString* name =
+      ParseIdentifier(kAllowRestrictedIdentifiers, CHECK_OK);
   Expect(Token::LPAREN, CHECK_OK);
   bool done = (peek() == Token::RPAREN);
   while (!done) {
-    ParseIdentifier(kAllowEvalOrArguments, CHECK_OK);
+    ParseIdentifier(kAllowRestrictedIdentifiers, CHECK_OK);
     done = (peek() == Token::RPAREN);
     if (!done) {
       Expect(Token::COMMA, CHECK_OK);
     }
   }
   Expect(Token::RPAREN, CHECK_OK);
   Expect(Token::SEMICOLON, CHECK_OK);
 
   // Make sure that the function containing the native declaration
   // isn't lazily compiled. The extension structures are only
@@ skipping 258 matching lines @@
   // Create new block with one expected declaration.
   Block* block = factory()->NewBlock(NULL, 1, true, pos);
   int nvars = 0;  // the number of variables declared
   const AstRawString* name = NULL;
   bool is_for_iteration_variable;
   do {
     if (fni_ != NULL) fni_->Enter();
 
     // Parse variable name.
     if (nvars > 0) Consume(Token::COMMA);
-    name = ParseIdentifier(kDontAllowEvalOrArguments, CHECK_OK);
+    name = ParseIdentifier(kDontAllowRestrictedIdentifiers, CHECK_OK);
     Scanner::Location variable_loc = scanner()->location();
     if (fni_ != NULL) fni_->PushVariableName(name);
 
     // Declare variable.
     // Note that we *always* must treat the initial value via a separate init
     // assignment for variables and constants because the value must be assigned
     // when the variable is encountered in the source. But the variable/constant
     // is declared (and set to 'undefined') upon entering the function within
     // which the variable or constant is declared. Only function variables have
     // an initial value in the declaration (because they are initialized upon
@@ skipping 328 matching lines @@
   // ContinueStatement ::
   //   'continue' Identifier? ';'
 
   int pos = peek_position();
   Expect(Token::CONTINUE, CHECK_OK);
   const AstRawString* label = NULL;
   Token::Value tok = peek();
   if (!scanner()->HasAnyLineTerminatorBeforeNext() &&
       tok != Token::SEMICOLON && tok != Token::RBRACE && tok != Token::EOS) {
     // ECMA allows "eval" or "arguments" as labels even in strict mode.
-    label = ParseIdentifier(kAllowEvalOrArguments, CHECK_OK);
+    label = ParseIdentifier(kAllowRestrictedIdentifiers, CHECK_OK);
   }
   IterationStatement* target = LookupContinueTarget(label, CHECK_OK);
   if (target == NULL) {
     // Illegal continue statement.
     const char* message = "illegal_continue";
     if (label != NULL) {
       message = "unknown_label";
     }
     ParserTraits::ReportMessage(message, label);
     *ok = false;
     return NULL;
   }
   ExpectSemicolon(CHECK_OK);
   return factory()->NewContinueStatement(target, pos);
 }
 
 
 Statement* Parser::ParseBreakStatement(ZoneList<const AstRawString*>* labels,
                                        bool* ok) {
   // BreakStatement ::
   //   'break' Identifier? ';'
 
   int pos = peek_position();
   Expect(Token::BREAK, CHECK_OK);
   const AstRawString* label = NULL;
   Token::Value tok = peek();
   if (!scanner()->HasAnyLineTerminatorBeforeNext() &&
       tok != Token::SEMICOLON && tok != Token::RBRACE && tok != Token::EOS) {
     // ECMA allows "eval" or "arguments" as labels even in strict mode.
-    label = ParseIdentifier(kAllowEvalOrArguments, CHECK_OK);
+    label = ParseIdentifier(kAllowRestrictedIdentifiers, CHECK_OK);
   }
   // Parse labeled break statements that target themselves into
   // empty statements, e.g. 'l1: l2: l3: break l2;'
   if (label != NULL && ContainsLabel(labels, label)) {
     ExpectSemicolon(CHECK_OK);
     return factory()->NewEmptyStatement(pos);
   }
   BreakableStatement* target = NULL;
   target = LookupBreakTarget(label, CHECK_OK);
   if (target == NULL) {
@@ skipping 204 matching lines @@
   Scope* catch_scope = NULL;
   Variable* catch_variable = NULL;
   Block* catch_block = NULL;
   const AstRawString* name = NULL;
   if (tok == Token::CATCH) {
     Consume(Token::CATCH);
 
     Expect(Token::LPAREN, CHECK_OK);
     catch_scope = NewScope(scope_, CATCH_SCOPE);
     catch_scope->set_start_position(scanner()->location().beg_pos);
-    name = ParseIdentifier(kDontAllowEvalOrArguments, CHECK_OK);
+    name = ParseIdentifier(kDontAllowRestrictedIdentifiers, CHECK_OK);
 
     Expect(Token::RPAREN, CHECK_OK);
 
     catch_variable = catch_scope->DeclareLocal(name, VAR, kCreatedInitialized,
                                                Variable::NORMAL);
     BlockState block_state(&scope_, catch_scope);
     catch_block = ParseBlock(NULL, CHECK_OK);
 
     catch_scope->set_end_position(scanner()->location().end_pos);
     tok = peek();
@@ skipping 904 matching lines @@
     Expect(Token::LPAREN, CHECK_OK);
     scope->set_start_position(scanner()->location().beg_pos);
 
     // We don't yet know if the function will be strict, so we cannot yet
     // produce errors for parameter names or duplicates. However, we remember
     // the locations of these errors if they occur and produce the errors later.
     Scanner::Location eval_args_error_loc = Scanner::Location::invalid();
     Scanner::Location dupe_error_loc = Scanner::Location::invalid();
     Scanner::Location reserved_error_loc = Scanner::Location::invalid();
 
+    // Similarly for strong mode.
+    Scanner::Location undefined_error_loc = Scanner::Location::invalid();
+
     bool is_rest = false;
     bool done = arity_restriction == FunctionLiteral::GETTER_ARITY ||
         (peek() == Token::RPAREN &&
          arity_restriction != FunctionLiteral::SETTER_ARITY);
     while (!done) {
       bool is_strict_reserved = false;
       is_rest = peek() == Token::ELLIPSIS && allow_harmony_rest_params();
       if (is_rest) {
         Consume(Token::ELLIPSIS);
       }
 
       const AstRawString* param_name =
           ParseIdentifierOrStrictReservedWord(&is_strict_reserved, CHECK_OK);
 
       // Store locations for possible future error reports.
       if (!eval_args_error_loc.IsValid() && IsEvalOrArguments(param_name)) {
         eval_args_error_loc = scanner()->location();
       }
+      if (!undefined_error_loc.IsValid() && IsUndefined(param_name)) {
+        undefined_error_loc = scanner()->location();
+      }
       if (!reserved_error_loc.IsValid() && is_strict_reserved) {
         reserved_error_loc = scanner()->location();
       }
       if (!dupe_error_loc.IsValid() &&
           scope_->IsDeclaredParameter(param_name)) {
         duplicate_parameters = FunctionLiteral::kHasDuplicateParameters;
         dupe_error_loc = scanner()->location();
       }
 
       Variable* var = scope_->DeclareParameter(param_name, VAR, is_rest);
@@ skipping 98 matching lines @@
       handler_count = function_state.handler_count();
     }
 
     // Validate name and parameter names. We can do this only after parsing the
     // function, since the function can declare itself strict.
     CheckFunctionName(language_mode(), kind, function_name,
                       name_is_strict_reserved, function_name_location,
                       CHECK_OK);
     const bool use_strict_params = is_rest || IsConciseMethod(kind);
     CheckFunctionParameterNames(language_mode(), use_strict_params,
-                                eval_args_error_loc, dupe_error_loc,
-                                reserved_error_loc, CHECK_OK);
+                                eval_args_error_loc, undefined_error_loc,
+                                dupe_error_loc, reserved_error_loc, CHECK_OK);
 
     if (is_strict(language_mode())) {
       CheckStrictOctalLiteral(scope->start_position(), scope->end_position(),
                               CHECK_OK);
     }
     if (is_strict(language_mode())) {
       CheckConflictingVarDeclarations(scope, CHECK_OK);
     }
     if (is_strong(language_mode()) && IsSubclassConstructor(kind)) {
       if (!function_state.super_call_location().IsValid()) {
@@ skipping 231 matching lines @@
   if (name_is_strict_reserved) {
     ReportMessageAt(class_name_location, "unexpected_strict_reserved");
     *ok = false;
     return NULL;
   }
   if (IsEvalOrArguments(name)) {
     ReportMessageAt(class_name_location, "strict_eval_arguments");
     *ok = false;
     return NULL;
   }
+  if (is_strong(language_mode()) && IsUndefined(name)) {
+    ReportMessageAt(class_name_location, "strong_undefined");
+    *ok = false;
+    return NULL;
+  }
 
   // Create a block scope which is additionally tagged as class scope; this is
   // important for resolving variable references to the class name in the strong
   // mode.
   Scope* block_scope = NewScope(scope_, BLOCK_SCOPE);
   block_scope->tag_as_class_scope();
   BlockState block_state(&scope_, block_scope);
   scope_->SetLanguageMode(
       static_cast<LanguageMode>(scope_->language_mode() | STRICT_BIT));
   scope_->SetScopeName(name);
@@ skipping 71 matching lines @@
 }
 
 
 Expression* Parser::ParseV8Intrinsic(bool* ok) {
   // CallRuntime ::
   //   '%' Identifier Arguments
 
   int pos = peek_position();
   Expect(Token::MOD, CHECK_OK);
   // Allow "eval" or "arguments" for backward compatibility.
-  const AstRawString* name = ParseIdentifier(kAllowEvalOrArguments, CHECK_OK);
+  const AstRawString* name =
+      ParseIdentifier(kAllowRestrictedIdentifiers, CHECK_OK);
   ZoneList<Expression*>* args = ParseArguments(CHECK_OK);
 
   if (extension_ != NULL) {
     // The extension structures are only accessible while parsing the
     // very first time not when reparsing because of lazy compilation.
     scope_->DeclarationScope()->ForceEagerCompilation();
   }
 
   const Runtime::Function* function = Runtime::FunctionForName(name->string());
 
@@ skipping 1246 matching lines @@
     } else {
       const uc16* data = reinterpret_cast<const uc16*>(raw_string->raw_data());
       running_hash = StringHasher::ComputeRunningHash(running_hash, data,
                                                       raw_string->length());
     }
   }
 
   return running_hash;
 }
 } }  // namespace v8::internal