Strict mode arguments do not share binding with formal parameters.

src/parser.cc

 // Copyright 2010 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 265 matching lines @@
   Handle<FixedArray> this_property_assignments() {
     return this_property_assignments_;
   }
 
   void AddProperty() { expected_property_count_++; }
   int expected_property_count() { return expected_property_count_; }
 
   void AddLoop() { loop_count_++; }
   bool ContainsLoops() const { return loop_count_ > 0; }
 
-  bool StrictMode() { return strict_mode_; }
-  void EnableStrictMode() {
-    strict_mode_ = FLAG_strict_mode;
-  }
-
  private:
   // Captures the number of literals that need materialization in the
   // function.  Includes regexp literals, and boilerplate for object
   // and array literals.
   int materialized_literal_count_;
 
   // Properties count estimation.
   int expected_property_count_;
 
   // Keeps track of assignments to properties of this. Used for
   // optimizing constructors.
   bool only_simple_this_property_assignments_;
   Handle<FixedArray> this_property_assignments_;
 
   // Captures the number of loops inside the scope.
   int loop_count_;
 
-  // Parsing strict mode code.
-  bool strict_mode_;
-
   // Bookkeeping
   TemporaryScope** variable_;
   TemporaryScope* parent_;
 };
 
 
 TemporaryScope::TemporaryScope(TemporaryScope** variable)
   : materialized_literal_count_(0),
     expected_property_count_(0),
     only_simple_this_property_assignments_(false),
     this_property_assignments_(Factory::empty_fixed_array()),
     loop_count_(0),
     variable_(variable),
     parent_(*variable) {
-  // Inherit the strict mode from the parent scope.
-  strict_mode_ = (parent_ != NULL) && parent_->strict_mode_;
   *variable = this;
 }
 
 
 TemporaryScope::~TemporaryScope() {
   *variable_ = parent_;
 }
 
 
 Handle<String> Parser::LookupSymbol(int symbol_id) {
@@ skipping 319 matching lines @@
   Scope::Type type =
     in_global_context
       ? Scope::GLOBAL_SCOPE
       : Scope::EVAL_SCOPE;
   Handle<String> no_name = Factory::empty_symbol();
 
   FunctionLiteral* result = NULL;
   { Scope* scope = NewScope(top_scope_, type, inside_with());
     LexicalScope lexical_scope(&this->top_scope_, &this->with_nesting_level_,
                                scope);
     TemporaryScope temp_scope(&this->temp_scope_);

[Kevin Millikin (Chromium), 2011/03/07 11:46:48]

Hmmm.  TemporaryScope seems like a bad name---it's not really a "scope" at all. 
It seems like a bundle of function-specific bits (literals and a loop flag).  We
already have a stack-allocated "LexicalScope" everywhere we have a
TemporaryScope, so we should probably just combine them.

Maybe roll it into the next change you make to the parser.

[Martin Maly, 2011/03/07 19:09:40]

Putting it on my list of opportunistic changes to make.

     if (strict_mode == kStrictMode) {
-      temp_scope.EnableStrictMode();
+      top_scope_->EnableStrictMode();
     }
     ZoneList<Statement*>* body = new ZoneList<Statement*>(16);
     bool ok = true;
     int beg_loc = scanner().location().beg_pos;
     ParseSourceElements(body, Token::EOS, &ok);
-    if (ok && temp_scope_->StrictMode()) {
+    if (ok && top_scope_->is_strict_mode()) {
       CheckOctalLiteral(beg_loc, scanner().location().end_pos, &ok);
     }
     if (ok) {
       result = new FunctionLiteral(
           no_name,
           top_scope_,
           body,
           temp_scope.materialized_literal_count(),
           temp_scope.expected_property_count(),
           temp_scope.only_simple_this_property_assignments(),
           temp_scope.this_property_assignments(),
           0,
           0,
           source->length(),
           false,
-          temp_scope.ContainsLoops(),
-          temp_scope.StrictMode());
+          temp_scope.ContainsLoops());
     } else if (stack_overflow_) {
       Top::StackOverflow();
     }
   }
 
   // Make sure the target stack is empty.
   ASSERT(target_stack_ == NULL);
 
   // If there was a syntax error we have to get rid of the AST
   // and it is not safe to do so before the scope has been deleted.
@@ skipping 44 matching lines @@
   {
     // Parse the function literal.
     Handle<String> no_name = Factory::empty_symbol();
     Scope* scope =
         NewScope(top_scope_, Scope::GLOBAL_SCOPE, inside_with());
     LexicalScope lexical_scope(&this->top_scope_, &this->with_nesting_level_,
                                scope);
     TemporaryScope temp_scope(&this->temp_scope_);
 
     if (info->strict_mode()) {
-      temp_scope.EnableStrictMode();
+      top_scope_->EnableStrictMode();
     }
 
     FunctionLiteralType type =
         info->is_expression() ? EXPRESSION : DECLARATION;
     bool ok = true;
     result = ParseFunctionLiteral(name,
                                   false,    // Strict mode name already checked.
                                   RelocInfo::kNoPosition, type, &ok);
     // Make sure the results agree.
     ASSERT(ok == (result != NULL));
@@ skipping 366 matching lines @@
       // A shot at a directive.
       ExpressionStatement *e_stat;
       Literal *literal;
       // Still processing directive prologue?
       if ((e_stat = stat->AsExpressionStatement()) != NULL &&
           (literal = e_stat->expression()->AsLiteral()) != NULL &&
           literal->handle()->IsString()) {
         Handle<String> directive = Handle<String>::cast(literal->handle());
 
         // Check "use strict" directive (ES5 14.1).
-        if (!temp_scope_->StrictMode() &&
+        if (!top_scope_->is_strict_mode() &&
             directive->Equals(Heap::use_strict()) &&
             token_loc.end_pos - token_loc.beg_pos ==
               Heap::use_strict()->length() + 2) {
-          temp_scope_->EnableStrictMode();
+          top_scope_->EnableStrictMode();
           // "use strict" is the only directive for now.
           directive_prologue = false;
         }
       } else {
         // End of the directive prologue.
         directive_prologue = false;
       }
     }
 
     // We find and mark the initialization blocks on top level code only.
@@ skipping 117 matching lines @@
       if (statement) {
         statement->set_statement_pos(statement_pos);
       }
       if (result) result->AddStatement(statement);
       return result;
     }
 
     case Token::FUNCTION: {
       // In strict mode, FunctionDeclaration is only allowed in the context
       // of SourceElements.
-      if (temp_scope_->StrictMode()) {
+      if (top_scope_->is_strict_mode()) {
         ReportMessageAt(scanner().peek_location(), "strict_function",
                         Vector<const char*>::empty());
         *ok = false;
         return NULL;
       }
       return ParseFunctionDeclaration(ok);
     }
 
     case Token::NATIVE:
       return ParseNativeDeclaration(ok);
@@ skipping 237 matching lines @@
                                          bool* ok) {
   // VariableDeclarations ::
   //   ('var' | 'const') (Identifier ('=' AssignmentExpression)?)+[',']
 
   Variable::Mode mode = Variable::VAR;
   bool is_const = false;
   if (peek() == Token::VAR) {
     Consume(Token::VAR);
   } else if (peek() == Token::CONST) {
     Consume(Token::CONST);
-    if (temp_scope_->StrictMode()) {
+    if (top_scope_->is_strict_mode()) {
       ReportMessage("strict_const", Vector<const char*>::empty());
       *ok = false;
       return NULL;
     }
     mode = Variable::CONST;
     is_const = true;
   } else {
     UNREACHABLE();  // by current callers
   }
 
@@ skipping 15 matching lines @@
   int nvars = 0;  // the number of variables declared
   do {
     if (fni_ != NULL) fni_->Enter();
 
     // Parse variable name.
     if (nvars > 0) Consume(Token::COMMA);
     Handle<String> name = ParseIdentifier(CHECK_OK);
     if (fni_ != NULL) fni_->PushVariableName(name);
 
     // Strict mode variables may not be named eval or arguments
-    if (temp_scope_->StrictMode() && IsEvalOrArguments(name)) {
+    if (top_scope_->is_strict_mode() && IsEvalOrArguments(name)) {
       ReportMessage("strict_var_name", Vector<const char*>::empty());
       *ok = false;
       return NULL;
     }
 
     // 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
@@ skipping 88 matching lines @@
         // the number of arguments (1 or 2).
         initialize =
             new CallRuntime(
               Factory::InitializeConstGlobal_symbol(),
               Runtime::FunctionForId(Runtime::kInitializeConstGlobal),
               arguments);
       } else {
         // Add strict mode.
         // We may want to pass singleton to avoid Literal allocations.
         arguments->Add(NewNumberLiteral(
-            temp_scope_->StrictMode() ? kStrictMode : kNonStrictMode));
+            top_scope_->is_strict_mode() ? kStrictMode : kNonStrictMode));
 
         // Be careful not to assign a value to the global variable if
         // we're in a with. The initialization value should not
         // necessarily be stored in the global object in that case,
         // which is why we need to generate a separate assignment node.
         if (value != NULL && !inside_with()) {
           arguments->Add(value);
           value = NULL;  // zap the value to avoid the unnecessary assignment
         }
 
@@ skipping 252 matching lines @@
   return result;
 }
 
 
 Statement* Parser::ParseWithStatement(ZoneStringList* labels, bool* ok) {
   // WithStatement ::
   //   'with' '(' Expression ')' Statement
 
   Expect(Token::WITH, CHECK_OK);
 
-  if (temp_scope_->StrictMode()) {
+  if (top_scope_->is_strict_mode()) {
     ReportMessage("strict_mode_with", Vector<const char*>::empty());
     *ok = false;
     return NULL;
   }
 
   Expect(Token::LPAREN, CHECK_OK);
   Expression* expr = ParseExpression(true, CHECK_OK);
   Expect(Token::RPAREN, CHECK_OK);
 
   return WithHelper(expr, labels, false, CHECK_OK);
@@ skipping 118 matching lines @@
   ZoneList<BreakTarget*>* catch_target_list = new ZoneList<BreakTarget*>(0);
   TargetCollector catch_collector(catch_target_list);
   bool has_catch = false;
   if (tok == Token::CATCH) {
     has_catch = true;
     Consume(Token::CATCH);
 
     Expect(Token::LPAREN, CHECK_OK);
     Handle<String> name = ParseIdentifier(CHECK_OK);
 
-    if (temp_scope_->StrictMode() && IsEvalOrArguments(name)) {
+    if (top_scope_->is_strict_mode() && IsEvalOrArguments(name)) {
       ReportMessage("strict_catch_variable", Vector<const char*>::empty());
       *ok = false;
       return NULL;
     }
 
     Expect(Token::RPAREN, CHECK_OK);
 
     if (peek() == Token::LBRACE) {
       // Allocate a temporary for holding the finally state while
       // executing the finally block.
@@ skipping 230 matching lines @@
 
   // Signal a reference error if the expression is an invalid left-hand
   // side expression.  We could report this as a syntax error here but
   // for compatibility with JSC we choose to report the error at
   // runtime.
   if (expression == NULL || !expression->IsValidLeftHandSide()) {
     Handle<String> type = Factory::invalid_lhs_in_assignment_symbol();
     expression = NewThrowReferenceError(type);
   }
 
-  if (temp_scope_->StrictMode()) {
+  if (top_scope_->is_strict_mode()) {
     // Assignment to eval or arguments is disallowed in strict mode.
     CheckStrictModeLValue(expression, "strict_lhs_assignment", CHECK_OK);
   }
 
   Token::Value op = Next();  // Get assignment operator.
   int pos = scanner().location().beg_pos;
   Expression* right = ParseAssignmentExpression(accept_IN, CHECK_OK);
 
   // TODO(1231235): We try to estimate the set of properties set by
   // constructors. We define a new property whenever there is an
@@ skipping 198 matching lines @@
           return expression;
         case Token::SUB:
           return NewNumberLiteral(-value);
         case Token::BIT_NOT:
           return NewNumberLiteral(~DoubleToInt32(value));
         default: break;
       }
     }
 
     // "delete identifier" is a syntax error in strict mode.
-    if (op == Token::DELETE && temp_scope_->StrictMode()) {
+    if (op == Token::DELETE && top_scope_->is_strict_mode()) {
       VariableProxy* operand = expression->AsVariableProxy();
       if (operand != NULL && !operand->is_this()) {
         ReportMessage("strict_delete", Vector<const char*>::empty());
         *ok = false;
         return NULL;
       }
     }
 
     return new UnaryOperation(op, expression);
 
   } else if (Token::IsCountOp(op)) {
     op = Next();
     Expression* expression = ParseUnaryExpression(CHECK_OK);
     // Signal a reference error if the expression is an invalid
     // left-hand side expression.  We could report this as a syntax
     // error here but for compatibility with JSC we choose to report the
     // error at runtime.
     if (expression == NULL || !expression->IsValidLeftHandSide()) {
       Handle<String> type = Factory::invalid_lhs_in_prefix_op_symbol();
       expression = NewThrowReferenceError(type);
     }
 
-    if (temp_scope_->StrictMode()) {
+    if (top_scope_->is_strict_mode()) {
       // Prefix expression operand in strict mode may not be eval or arguments.
       CheckStrictModeLValue(expression, "strict_lhs_prefix", CHECK_OK);
     }
 
     int position = scanner().location().beg_pos;
     IncrementOperation* increment = new IncrementOperation(op, expression);
     return new CountOperation(true /* prefix */, increment, position);
 
   } else {
     return ParsePostfixExpression(ok);
@@ skipping 10 matching lines @@
       Token::IsCountOp(peek())) {
     // Signal a reference error if the expression is an invalid
     // left-hand side expression.  We could report this as a syntax
     // error here but for compatibility with JSC we choose to report the
     // error at runtime.
     if (expression == NULL || !expression->IsValidLeftHandSide()) {
       Handle<String> type = Factory::invalid_lhs_in_postfix_op_symbol();
       expression = NewThrowReferenceError(type);
     }
 
-    if (temp_scope_->StrictMode()) {
+    if (top_scope_->is_strict_mode()) {
       // Postfix expression operand in strict mode may not be eval or arguments.
       CheckStrictModeLValue(expression, "strict_lhs_prefix", CHECK_OK);
     }
 
     Token::Value next = Next();
     int position = scanner().location().beg_pos;
     IncrementOperation* increment = new IncrementOperation(next, expression);
     expression = new CountOperation(false /* postfix */, increment, position);
   }
   return expression;
@@ skipping 187 matching lines @@
     case Token::NUMBER:
       return ReportMessage("unexpected_token_number",
                            Vector<const char*>::empty());
     case Token::STRING:
       return ReportMessage("unexpected_token_string",
                            Vector<const char*>::empty());
     case Token::IDENTIFIER:
       return ReportMessage("unexpected_token_identifier",
                            Vector<const char*>::empty());
     case Token::FUTURE_RESERVED_WORD:
-      return ReportMessage(temp_scope_->StrictMode() ?
+      return ReportMessage(top_scope_->is_strict_mode() ?
                                "unexpected_strict_reserved" :
                                "unexpected_token_identifier",
                            Vector<const char*>::empty());
     default:
       const char* name = Token::String(token);
       ASSERT(name != NULL);
       ReportMessage("unexpected_token", Vector<const char*>(&name, 1));
   }
 }
 
@@ skipping 484 matching lines @@
   // ObjectLiteral ::
   //   '{' (
   //       ((IdentifierName | String | Number) ':' AssignmentExpression)
   //     | (('get' | 'set') (IdentifierName | String | Number) FunctionLiteral)
   //    )*[','] '}'
 
   ZoneList<ObjectLiteral::Property*>* properties =
       new ZoneList<ObjectLiteral::Property*>(4);
   int number_of_boilerplate_properties = 0;
 
-  ObjectLiteralPropertyChecker checker(this, temp_scope_->StrictMode());
+  ObjectLiteralPropertyChecker checker(this, top_scope_->is_strict_mode());
 
   Expect(Token::LBRACE, CHECK_OK);
   Scanner::Location loc = scanner().location();
 
   while (peek() != Token::RBRACE) {
     if (fni_ != NULL) fni_->Enter();
 
     Literal* key = NULL;
     Token::Value next = peek();
 
@@ skipping 276 matching lines @@
       expected_property_count = temp_scope.expected_property_count();
       only_simple_this_property_assignments =
           temp_scope.only_simple_this_property_assignments();
       this_property_assignments = temp_scope.this_property_assignments();
 
       Expect(Token::RBRACE, CHECK_OK);
       end_pos = scanner().location().end_pos;
     }
 
     // Validate strict mode.
-    if (temp_scope_->StrictMode()) {
+    if (top_scope_->is_strict_mode()) {
       if (IsEvalOrArguments(name)) {
         int position = function_token_position != RelocInfo::kNoPosition
             ? function_token_position
             : (start_pos > 0 ? start_pos - 1 : start_pos);
         Scanner::Location location = Scanner::Location(position, start_pos);
         ReportMessageAt(location,
                         "strict_function_name", Vector<const char*>::empty());
         *ok = false;
         return NULL;
       }
@@ skipping 33 matching lines @@
                             top_scope_,
                             body,
                             materialized_literal_count,
                             expected_property_count,
                             only_simple_this_property_assignments,
                             this_property_assignments,
                             num_parameters,
                             start_pos,
                             end_pos,
                             function_name->length() > 0,
-                            temp_scope.ContainsLoops(),
-                            temp_scope.StrictMode());
+                            temp_scope.ContainsLoops());
     function_literal->set_function_token_position(function_token_position);
 
     if (fni_ != NULL && !is_named) fni_->AddFunction(function_literal);
     return function_literal;
   }
 }
 
 
 Expression* Parser::ParseV8Intrinsic(bool* ok) {
   // CallRuntime ::
@@ skipping 108 matching lines @@
 
 Handle<String> Parser::ParseIdentifier(bool* ok) {
   bool is_reserved;
   return ParseIdentifierOrReservedWord(&is_reserved, ok);
 }
 
 
 Handle<String> Parser::ParseIdentifierOrReservedWord(bool* is_reserved,
                                                      bool* ok) {
   *is_reserved = false;
-  if (temp_scope_->StrictMode()) {
+  if (top_scope_->is_strict_mode()) {
     Expect(Token::IDENTIFIER, ok);
   } else {
     if (!Check(Token::IDENTIFIER)) {
       Expect(Token::FUTURE_RESERVED_WORD, ok);
       *is_reserved = true;
     }
   }
   if (!*ok) return Handle<String>();
   return GetSymbol(ok);
 }
@@ skipping 10 matching lines @@
   }
   return GetSymbol(ok);
 }
 
 
 // Checks LHS expression for assignment and prefix/postfix increment/decrement
 // in strict mode.
 void Parser::CheckStrictModeLValue(Expression* expression,
                                    const char* error,
                                    bool* ok) {
-  ASSERT(temp_scope_->StrictMode());
+  ASSERT(top_scope_->is_strict_mode());
   VariableProxy* lhs = expression != NULL
       ? expression->AsVariableProxy()
       : NULL;
 
   if (lhs != NULL && !lhs->is_this() && IsEvalOrArguments(lhs->name())) {
     ReportMessage(error, Vector<const char*>::empty());
     *ok = false;
   }
 }
 
@@ skipping 1301 matching lines @@
                                    info->is_global(),
                                    info->StrictMode());
     }
   }
 
   info->SetFunction(result);
   return (result != NULL);
 }
 
 } }  // namespace v8::internal