Introduce LanguageMode, drop StrictMode.

src/objects-inl.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.
 //
 // Review notes:
 //
 // - The use of macros in these inline functions may seem superfluous
 // but it is absolutely needed to make sure gcc generates optimal
 // code. gcc is not happy when attempting to inline too deep.
 //
@@ skipping 1179 matching lines @@
                                                    uint32_t index) {
   return GetPropertyWithHandler(
       proxy, receiver, proxy->GetIsolate()->factory()->Uint32ToString(index));
 }
 
 
 MaybeHandle<Object> JSProxy::SetElementWithHandler(Handle<JSProxy> proxy,
                                                    Handle<JSReceiver> receiver,
                                                    uint32_t index,
                                                    Handle<Object> value,
-                                                   StrictMode strict_mode) {
+                                                   LanguageMode language_mode) {
   Isolate* isolate = proxy->GetIsolate();
   Handle<String> name = isolate->factory()->Uint32ToString(index);
-  return SetPropertyWithHandler(proxy, receiver, name, value, strict_mode);
+  return SetPropertyWithHandler(proxy, receiver, name, value, language_mode);
 }
 
 
 Maybe<bool> JSProxy::HasElementWithHandler(Handle<JSProxy> proxy,
                                            uint32_t index) {
   Isolate* isolate = proxy->GetIsolate();
   Handle<String> name = isolate->factory()->Uint32ToString(index);
   return HasPropertyWithHandler(proxy, name);
 }
 
@@ skipping 4583 matching lines @@
                                      kOptimizationDisabled,
                                      disable));
   // If disabling optimizations we reflect that in the code object so
   // it will not be counted as optimizable code.
   if ((code()->kind() == Code::FUNCTION) && disable) {
     code()->set_optimizable(false);
   }
 }
 
 
-StrictMode SharedFunctionInfo::strict_mode() {
+LanguageMode SharedFunctionInfo::language_mode() {
+  STATIC_ASSERT(LANGUAGE_END == 2);
   return BooleanBit::get(compiler_hints(), kStrictModeFunction)
       ? STRICT : SLOPPY;
 }
 
 
-void SharedFunctionInfo::set_strict_mode(StrictMode strict_mode) {
-  // We only allow mode transitions from sloppy to strict.
-  DCHECK(this->strict_mode() == SLOPPY || this->strict_mode() == strict_mode);
+void SharedFunctionInfo::set_language_mode(LanguageMode language_mode) {
+  STATIC_ASSERT(LANGUAGE_END == 2);
+  // We only allow language mode transitions that set the same language mode
+  // again or go up in the chain:
+  DCHECK(!is_strict(this->language_mode()) || is_strict(language_mode));

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

Maybe abstract that into an is_stricter_than predicate.

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

That seems overkill; this is now easier to read after adding is_sloppy:

is_sloppy(this->language_mode()) || is_strict(language_mode)

(And this occurs in... 2 places, I think)

[rossberg, 2015/02/03 15:14:29]

The reason I thought this would be useful is that the condition might get more
complicated once we add more modes, and should hence be next to the mode
definition itself. There might also arise additional places where it comes up.

But I'm fine with deferring this.

   int hints = compiler_hints();
-  hints = BooleanBit::set(hints, kStrictModeFunction, strict_mode == STRICT);
+  hints = BooleanBit::set(hints, kStrictModeFunction, is_strict(language_mode));
   set_compiler_hints(hints);
 }
 
 
 FunctionKind SharedFunctionInfo::kind() {
   return FunctionKindBits::decode(compiler_hints());
 }
 
 
 void SharedFunctionInfo::set_kind(FunctionKind kind) {
@@ skipping 1773 matching lines @@
 #undef READ_SHORT_FIELD
 #undef WRITE_SHORT_FIELD
 #undef READ_BYTE_FIELD
 #undef WRITE_BYTE_FIELD
 #undef NOBARRIER_READ_BYTE_FIELD
 #undef NOBARRIER_WRITE_BYTE_FIELD
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_INL_H_