Add strong mode.

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 271 matching lines @@
                                             int pos, int end_pos) {
   int materialized_literal_count = -1;
   int expected_property_count = -1;
   int handler_count = 0;
   int parameter_count = 0;
   const AstRawString* name = ast_value_factory()->empty_string();
 
   Scope* function_scope =
       NewScope(scope, FUNCTION_SCOPE, FunctionKind::kDefaultConstructor);
   function_scope->SetLanguageMode(
-      static_cast<LanguageMode>(scope->language_mode() | STRICT));
+      static_cast<LanguageMode>(scope->language_mode() | STRICT_BIT));
   // Set start and end position to the same value
   function_scope->set_start_position(pos);
   function_scope->set_end_position(pos);
   ZoneList<Statement*>* body = NULL;
 
   {
     AstNodeFactory function_factory(ast_value_factory());
     FunctionState function_state(&function_state_, &scope_, function_scope,
                                  &function_factory);
 
@@ skipping 835 matching lines @@
     }
 
     if (directive_prologue) {
       // 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->raw_value()->IsString()) {
-        // Check "use strict" directive (ES5 14.1) and "use asm" directive. Only
-        // one can be present.
-        if (is_sloppy(language_mode()) &&
+        // Check "use strict" directive (ES5 14.1), "use asm" directive, and
+        // "use sanity" directive (experimental). Only one can be present.
+        bool use_strict_found =
+            is_sloppy(language_mode()) &&
             literal->raw_value()->AsString() ==
                 ast_value_factory()->use_strict_string() &&
             token_loc.end_pos - token_loc.beg_pos ==
-                ast_value_factory()->use_strict_string()->length() + 2) {
+                ast_value_factory()->use_strict_string()->length() + 2;
+        bool use_sanity_found =

[arv (Not doing code reviews), 2015/02/04 16:17:11]

Don't we want a flag for this work?

[rossberg, 2015/02/04 16:19:57]

Ah, excellent point! Yes, we need a flag. I suggest --sane-mode.

[marja, 2015/02/05 12:11:37]

Done.

+            !use_strict_found && !is_sane(language_mode()) &&

[rossberg, 2015/02/04 16:18:09]

If I read this correctly then

  "use sanity"; "use strict";

will turn on sane mode, while

  "use strict"; "use sanity";

will leave you in strict mode. That would be weird. I think it should be fine to
redundantly have both directives in either order.

[marja, 2015/02/05 12:11:37]

Done. (Oops, preparser was already following that logic.)

+            literal->raw_value()->AsString() ==
+                ast_value_factory()->use_sanity_string() &&
+            token_loc.end_pos - token_loc.beg_pos ==
+                ast_value_factory()->use_sanity_string()->length() + 2;
+        if (use_strict_found || use_sanity_found) {
+          // Sane mode implies strict mode.
+
           // TODO(mstarzinger): Global strict eval calls, need their own scope
           // as specified in ES5 10.4.2(3). The correct fix would be to always
           // add this scope in DoParseProgram(), but that requires adaptations
           // all over the code base, so we go with a quick-fix for now.
           // In the same manner, we have to patch the parsing mode.
           if (is_eval && !scope_->is_eval_scope()) {
             DCHECK(scope_->is_script_scope());
             Scope* scope = NewScope(scope_, EVAL_SCOPE);
             scope->set_start_position(scope_->start_position());
             scope->set_end_position(scope_->end_position());
             scope_ = scope;
             if (eval_scope != NULL) {
               // Caller will correct the positions of the ad hoc eval scope.
               *eval_scope = scope;
             }
             mode_ = PARSE_EAGERLY;
           }
           scope_->SetLanguageMode(
-              static_cast<LanguageMode>(scope_->language_mode() | STRICT));
-          // "use strict" is the only directive for now.
+              static_cast<LanguageMode>(scope_->language_mode() | STRICT_BIT));
+
+          if (use_sanity_found) {
+            scope_->SetLanguageMode(
+                static_cast<LanguageMode>(scope_->language_mode() | SANE_BIT));
+          }
+
+          // Don't allow additional directives.
           directive_prologue = false;
         } else if (literal->raw_value()->AsString() ==
                        ast_value_factory()->use_asm_string() &&
                    token_loc.end_pos - token_loc.beg_pos ==
                        ast_value_factory()->use_asm_string()->length() + 2) {
           // Store the usage count; The actual use counter on the isolate is
           // incremented after parsing is done.
           ++use_counts_[v8::Isolate::kUseAsm];
           scope_->SetAsmModule();
+          // Don't allow additional directives.
+          directive_prologue = false;
         }
       } else {
         // End of the directive prologue.
         directive_prologue = false;
       }
     }
 
     body->Add(stat, zone());
   }
 
@@ skipping 56 matching lines @@
   int pos = peek_position();
   // Construct block expecting 16 statements.
   Block* body = factory()->NewBlock(NULL, 16, false, RelocInfo::kNoPosition);
 #ifdef DEBUG
   if (FLAG_print_interface_details) PrintF("# Literal ");
 #endif
   Scope* scope = NewScope(scope_, MODULE_SCOPE);
 
   scope->set_start_position(scanner()->location().beg_pos);
   scope->SetLanguageMode(
-      static_cast<LanguageMode>(scope->language_mode() | STRICT));
+      static_cast<LanguageMode>(scope->language_mode() | STRICT_BIT));
 
   {
     BlockState block_state(&scope_, scope);
     Target target(&this->target_stack_, body);
 
     while (peek() != Token::EOS) {
       Statement* stat = ParseModuleItem(CHECK_OK);
       if (stat && !stat->IsEmpty()) {
         body->AddStatement(stat, zone());
       }
@@ skipping 2758 matching lines @@
   }
   if (IsEvalOrArguments(name)) {
     ReportMessageAt(class_name_location, "strict_eval_arguments");
     *ok = false;
     return NULL;
   }
 
   Scope* block_scope = NewScope(scope_, BLOCK_SCOPE);
   BlockState block_state(&scope_, block_scope);
   scope_->SetLanguageMode(
-      static_cast<LanguageMode>(scope_->language_mode() | STRICT));
+      static_cast<LanguageMode>(scope_->language_mode() | STRICT_BIT));
   scope_->SetScopeName(name);
 
   VariableProxy* proxy = NULL;
   if (name != NULL) {
     proxy = NewUnresolved(name, CONST, Interface::NewConst());
     Declaration* declaration =
         factory()->NewVariableDeclaration(proxy, CONST, block_scope, pos);
     Declare(declaration, true, CHECK_OK);
   }
 
@@ skipping 1362 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