Introduce LanguageMode, drop StrictMode.

src/parser.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_PARSER_H_
 #define V8_PARSER_H_
 
 #include "src/allocation.h"
 #include "src/ast.h"
 #include "src/compiler.h"  // For CachedDataMode
@@ skipping 13 matching lines @@
 class Target;
 
 
 class FunctionEntry BASE_EMBEDDED {
  public:
   enum {
     kStartPositionIndex,
     kEndPositionIndex,
     kLiteralCountIndex,
     kPropertyCountIndex,
-    kStrictModeIndex,
+    kLanguageModeIndex,
     kSize
   };
 
   explicit FunctionEntry(Vector<unsigned> backing)
     : backing_(backing) { }
 
   FunctionEntry() : backing_() { }
 
   int start_pos() { return backing_[kStartPositionIndex]; }
   int end_pos() { return backing_[kEndPositionIndex]; }
   int literal_count() { return backing_[kLiteralCountIndex]; }
   int property_count() { return backing_[kPropertyCountIndex]; }
-  StrictMode strict_mode() {
-    DCHECK(backing_[kStrictModeIndex] == SLOPPY ||
-           backing_[kStrictModeIndex] == STRICT);
-    return static_cast<StrictMode>(backing_[kStrictModeIndex]);
+  LanguageMode language_mode() {
+    STATIC_ASSERT(LANGUAGE_END == 2);
+    DCHECK(backing_[kLanguageModeIndex] == SLOPPY ||

[rossberg, 2015/02/03 12:26:20]

Same here, could use is_valid_l_m

[marja, 2015/02/03 14:45:02]

Done.

+           backing_[kLanguageModeIndex] == STRICT);
+    return static_cast<LanguageMode>(backing_[kLanguageModeIndex]);
   }
 
   bool is_valid() { return !backing_.is_empty(); }
 
  private:
   Vector<unsigned> backing_;
 };
 
 
 // Wrapper around ScriptData to provide parser-specific functionality.
@@ skipping 602 matching lines @@
   // function literal.  Returns false (and deallocates any allocated AST
   // nodes) if parsing failed.
   static bool Parse(CompilationInfo* info,
                     bool allow_lazy = false) {
     ParseInfo parse_info = {info->isolate()->stack_guard()->real_climit(),
                             info->isolate()->heap()->HashSeed(),
                             info->isolate()->unicode_cache()};
     Parser parser(info, &parse_info);
     parser.set_allow_lazy(allow_lazy);
     if (parser.Parse()) {
-      info->SetStrictMode(info->function()->strict_mode());
+      info->SetLanguageMode(info->function()->language_mode());
       return true;
     }
     return false;
   }
   bool Parse();
   void ParseOnBackground();
 
   // Handle errors detected during parsing, move statistics to Isolate,
   // internalize strings (move them to the heap).
   void Internalize();
@@ skipping 311 matching lines @@
 }
 
 
 Expression* ParserTraits::CloseTemplateLiteral(TemplateLiteralState* state,
                                                int start, Expression* tag) {
   return parser_->CloseTemplateLiteral(state, start, tag);
 }
 } }  // namespace v8::internal
 
 #endif  // V8_PARSER_H_