| Index: src/runtime.cc | 
| diff --git a/src/runtime.cc b/src/runtime.cc | 
| index 2787cd2edb30813538f2d2d5da3acc66622b8fb9..540ba157453e4bb01a9156aadb856372e8bd987c 100644 | 
| --- a/src/runtime.cc | 
| +++ b/src/runtime.cc | 
| @@ -153,25 +153,13 @@ namespace internal { | 
| PropertyDetails name = PropertyDetails(Smi::cast(args[index])); | 
|  | 
|  | 
| -// Assert that the given argument has a valid value for a StrictModeFlag | 
| -// and store it in a StrictModeFlag variable with the given name. | 
| +// Assert that the given argument has a valid value for a StrictMode | 
| +// and store it in a StrictMode variable with the given name. | 
| #define CONVERT_STRICT_MODE_ARG_CHECKED(name, index)                 \ | 
| RUNTIME_ASSERT(args[index]->IsSmi());                              \ | 
| -  RUNTIME_ASSERT(args.smi_at(index) == kStrictMode ||                \ | 
| -                 args.smi_at(index) == kSloppyMode);                 \ | 
| -  StrictModeFlag name =                                              \ | 
| -      static_cast<StrictModeFlag>(args.smi_at(index)); | 
| - | 
| - | 
| -// Assert that the given argument has a valid value for a LanguageMode | 
| -// and store it in a LanguageMode variable with the given name. | 
| -#define CONVERT_LANGUAGE_MODE_ARG(name, index)                       \ | 
| -  ASSERT(args[index]->IsSmi());                                      \ | 
| -  ASSERT(args.smi_at(index) == SLOPPY_MODE ||                        \ | 
| -         args.smi_at(index) == STRICT_MODE ||                        \ | 
| -         args.smi_at(index) == EXTENDED_MODE);                       \ | 
| -  LanguageMode name =                                                \ | 
| -      static_cast<LanguageMode>(args.smi_at(index)); | 
| +  RUNTIME_ASSERT(args.smi_at(index) == STRICT ||                     \ | 
| +                 args.smi_at(index) == SLOPPY);                      \ | 
| +  StrictMode name = static_cast<StrictMode>(args.smi_at(index)); | 
|  | 
|  | 
| static Handle<Map> ComputeObjectLiteralMap( | 
| @@ -298,7 +286,7 @@ static Handle<Object> CreateObjectLiteralBoilerplate( | 
| if (Handle<String>::cast(key)->AsArrayIndex(&element_index)) { | 
| // Array index as string (uint32). | 
| result = JSObject::SetOwnElement( | 
| -            boilerplate, element_index, value, kSloppyMode); | 
| +            boilerplate, element_index, value, SLOPPY); | 
| } else { | 
| Handle<String> name(String::cast(*key)); | 
| ASSERT(!name->AsArrayIndex(&element_index)); | 
| @@ -309,7 +297,7 @@ static Handle<Object> CreateObjectLiteralBoilerplate( | 
| } else if (key->ToArrayIndex(&element_index)) { | 
| // Array index (uint32). | 
| result = JSObject::SetOwnElement( | 
| -          boilerplate, element_index, value, kSloppyMode); | 
| +          boilerplate, element_index, value, SLOPPY); | 
| } else { | 
| // Non-uint32 number. | 
| ASSERT(key->IsNumber()); | 
| @@ -2098,7 +2086,7 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_DeclareGlobals) { | 
| attr |= READ_ONLY; | 
| } | 
|  | 
| -    LanguageMode language_mode = DeclareGlobalsLanguageMode::decode(flags); | 
| +    StrictMode strict_mode = DeclareGlobalsStrictMode::decode(flags); | 
|  | 
| if (!lookup.IsFound() || is_function) { | 
| // If the local property exists, check that we can reconfigure it | 
| @@ -2120,7 +2108,7 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_DeclareGlobals) { | 
| RETURN_IF_EMPTY_HANDLE(isolate, | 
| JSObject::SetProperty( | 
| global, name, value, static_cast<PropertyAttributes>(attr), | 
| -              language_mode == SLOPPY_MODE ? kSloppyMode : kStrictMode)); | 
| +              strict_mode)); | 
| } | 
| } | 
|  | 
| @@ -2176,8 +2164,7 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_DeclareContextSlot) { | 
| Handle<JSObject> object = Handle<JSObject>::cast(holder); | 
| RETURN_IF_EMPTY_HANDLE( | 
| isolate, | 
| -            JSReceiver::SetProperty(object, name, initial_value, mode, | 
| -                                    kSloppyMode)); | 
| +            JSReceiver::SetProperty(object, name, initial_value, mode, SLOPPY)); | 
| } | 
| } | 
|  | 
| @@ -2223,7 +2210,7 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_DeclareContextSlot) { | 
| JSObject::SetLocalPropertyIgnoreAttributes(object, name, value, mode)); | 
| } else { | 
| RETURN_IF_EMPTY_HANDLE(isolate, | 
| -         JSReceiver::SetProperty(object, name, value, mode, kSloppyMode)); | 
| +         JSReceiver::SetProperty(object, name, value, mode, SLOPPY)); | 
| } | 
| } | 
|  | 
| @@ -2244,9 +2231,7 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_InitializeVarGlobal) { | 
|  | 
| CONVERT_ARG_HANDLE_CHECKED(String, name, 0); | 
| RUNTIME_ASSERT(args[1]->IsSmi()); | 
| -  CONVERT_LANGUAGE_MODE_ARG(language_mode, 1); | 
| -  StrictModeFlag strict_mode_flag = (language_mode == SLOPPY_MODE) | 
| -      ? kSloppyMode : kStrictMode; | 
| +  CONVERT_STRICT_MODE_ARG_CHECKED(strict_mode, 1); | 
|  | 
| // According to ECMA-262, section 12.2, page 62, the property must | 
| // not be deletable. | 
| @@ -2270,7 +2255,7 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_InitializeVarGlobal) { | 
| CONVERT_ARG_HANDLE_CHECKED(Object, value, 2); | 
| Handle<Object> result = JSObject::SetPropertyForResult( | 
| handle(lookup.holder()), &lookup, name, value, attributes, | 
| -            strict_mode_flag); | 
| +            strict_mode); | 
| RETURN_IF_EMPTY_HANDLE(isolate, result); | 
| return *result; | 
| } else { | 
| @@ -2283,7 +2268,7 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_InitializeVarGlobal) { | 
| CONVERT_ARG_HANDLE_CHECKED(Object, value, 2); | 
| Handle<GlobalObject> global(isolate->context()->global_object()); | 
| Handle<Object> result = JSReceiver::SetProperty( | 
| -        global, name, value, attributes, strict_mode_flag); | 
| +        global, name, value, attributes, strict_mode); | 
| RETURN_IF_EMPTY_HANDLE(isolate, result); | 
| return *result; | 
| } | 
| @@ -2337,7 +2322,7 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_InitializeConstGlobal) { | 
| // Passing sloppy mode because the property is writable. | 
| RETURN_IF_EMPTY_HANDLE( | 
| isolate, | 
| -        JSReceiver::SetProperty(global, name, value, attributes, kSloppyMode)); | 
| +        JSReceiver::SetProperty(global, name, value, attributes, SLOPPY)); | 
| return *value; | 
| } | 
|  | 
| @@ -2407,7 +2392,7 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_InitializeConstContextSlot) { | 
| // Strict mode not needed (const disallowed in strict mode). | 
| RETURN_IF_EMPTY_HANDLE( | 
| isolate, | 
| -        JSReceiver::SetProperty(global, name, value, NONE, kSloppyMode)); | 
| +        JSReceiver::SetProperty(global, name, value, NONE, SLOPPY)); | 
| return *value; | 
| } | 
|  | 
| @@ -2458,8 +2443,7 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_InitializeConstContextSlot) { | 
| // Strict mode not needed (const disallowed in strict mode). | 
| RETURN_IF_EMPTY_HANDLE( | 
| isolate, | 
| -          JSReceiver::SetProperty(object, name, value, attributes, | 
| -                                  kSloppyMode)); | 
| +          JSReceiver::SetProperty(object, name, value, attributes, SLOPPY)); | 
| } | 
| } | 
|  | 
| @@ -2620,7 +2604,7 @@ static Handle<JSFunction> InstallBuiltin(Isolate* isolate, | 
| code, | 
| false); | 
| optimized->shared()->DontAdaptArguments(); | 
| -  JSReceiver::SetProperty(holder, key, optimized, NONE, kStrictMode); | 
| +  JSReceiver::SetProperty(holder, key, optimized, NONE, STRICT); | 
| return optimized; | 
| } | 
|  | 
| @@ -2656,7 +2640,7 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_IsSloppyModeFunction) { | 
| } | 
| JSFunction* function = JSFunction::cast(callable); | 
| SharedFunctionInfo* shared = function->shared(); | 
| -  return isolate->heap()->ToBoolean(shared->is_sloppy_mode()); | 
| +  return isolate->heap()->ToBoolean(shared->strict_mode() == SLOPPY); | 
| } | 
|  | 
|  | 
| @@ -2676,7 +2660,7 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_GetDefaultReceiver) { | 
| JSFunction* function = JSFunction::cast(callable); | 
|  | 
| SharedFunctionInfo* shared = function->shared(); | 
| -  if (shared->native() || !shared->is_sloppy_mode()) { | 
| +  if (shared->native() || shared->strict_mode() == STRICT) { | 
| return isolate->heap()->undefined_value(); | 
| } | 
| // Returns undefined for strict or native functions, or | 
| @@ -5081,7 +5065,7 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_DefineOrRedefineDataProperty) { | 
| name, | 
| obj_value, | 
| handle(lookup.holder()), | 
| -                                            kStrictMode); | 
| +                                            STRICT); | 
| RETURN_IF_EMPTY_HANDLE(isolate, result_object); | 
| return *result_object; | 
| } | 
| @@ -5154,7 +5138,7 @@ Handle<Object> Runtime::SetObjectProperty(Isolate* isolate, | 
| Handle<Object> key, | 
| Handle<Object> value, | 
| PropertyAttributes attr, | 
| -                                          StrictModeFlag strict_mode) { | 
| +                                          StrictMode strict_mode) { | 
| SetPropertyMode set_mode = attr == NONE ? SET_PROPERTY : DEFINE_PROPERTY; | 
|  | 
| if (object->IsUndefined() || object->IsNull()) { | 
| @@ -5272,7 +5256,7 @@ Handle<Object> Runtime::ForceSetObjectProperty(Isolate* isolate, | 
| return value; | 
| } | 
|  | 
| -    return JSObject::SetElement(js_object, index, value, attr, kSloppyMode, | 
| +    return JSObject::SetElement(js_object, index, value, attr, SLOPPY, | 
| false, | 
| DEFINE_PROPERTY); | 
| } | 
| @@ -5280,7 +5264,7 @@ Handle<Object> Runtime::ForceSetObjectProperty(Isolate* isolate, | 
| if (key->IsName()) { | 
| Handle<Name> name = Handle<Name>::cast(key); | 
| if (name->AsArrayIndex(&index)) { | 
| -      return JSObject::SetElement(js_object, index, value, attr, kSloppyMode, | 
| +      return JSObject::SetElement(js_object, index, value, attr, SLOPPY, | 
| false, | 
| DEFINE_PROPERTY); | 
| } else { | 
| @@ -5298,7 +5282,7 @@ Handle<Object> Runtime::ForceSetObjectProperty(Isolate* isolate, | 
| Handle<String> name = Handle<String>::cast(converted); | 
|  | 
| if (name->AsArrayIndex(&index)) { | 
| -    return JSObject::SetElement(js_object, index, value, attr, kSloppyMode, | 
| +    return JSObject::SetElement(js_object, index, value, attr, SLOPPY, | 
| false, | 
| DEFINE_PROPERTY); | 
| } else { | 
| @@ -5365,10 +5349,10 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_SetProperty) { | 
| PropertyAttributes attributes = | 
| static_cast<PropertyAttributes>(unchecked_attributes); | 
|  | 
| -  StrictModeFlag strict_mode = kSloppyMode; | 
| +  StrictMode strict_mode = SLOPPY; | 
| if (args.length() == 5) { | 
| -    CONVERT_STRICT_MODE_ARG_CHECKED(strict_mode_flag, 4); | 
| -    strict_mode = strict_mode_flag; | 
| +    CONVERT_STRICT_MODE_ARG_CHECKED(strict_mode_arg, 4); | 
| +    strict_mode = strict_mode_arg; | 
| } | 
|  | 
| Handle<Object> result = Runtime::SetObjectProperty(isolate, object, key, | 
| @@ -5547,7 +5531,7 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_DeleteProperty) { | 
| CONVERT_ARG_HANDLE_CHECKED(JSReceiver, object, 0); | 
| CONVERT_ARG_HANDLE_CHECKED(Name, key, 1); | 
| CONVERT_STRICT_MODE_ARG_CHECKED(strict_mode, 2); | 
| -  JSReceiver::DeleteMode delete_mode = (strict_mode == kStrictMode) | 
| +  JSReceiver::DeleteMode delete_mode = strict_mode == STRICT | 
| ? JSReceiver::STRICT_DELETION : JSReceiver::NORMAL_DELETION; | 
| Handle<Object> result = JSReceiver::DeleteProperty(object, key, delete_mode); | 
| RETURN_IF_EMPTY_HANDLE(isolate, result); | 
| @@ -5989,7 +5973,7 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_GetArgumentsProperty) { | 
| if (key->Equals(isolate->heap()->length_string())) return Smi::FromInt(n); | 
| if (key->Equals(isolate->heap()->callee_string())) { | 
| JSFunction* function = frame->function(); | 
| -    if (!function->shared()->is_sloppy_mode()) { | 
| +    if (function->shared()->strict_mode() == STRICT) { | 
| return isolate->Throw(*isolate->factory()->NewTypeError( | 
| "strict_arguments_callee", HandleVector<Object>(NULL, 0))); | 
| } | 
| @@ -9110,7 +9094,7 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_DeclareModules) { | 
| case VAR: | 
| case LET: | 
| case CONST: | 
| -        case CONST_HARMONY: { | 
| +        case CONST_LEGACY: { | 
| PropertyAttributes attr = | 
| IsImmutableVariableMode(mode) ? FROZEN : SEALED; | 
| Handle<AccessorInfo> info = | 
| @@ -9123,7 +9107,7 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_DeclareModules) { | 
| case MODULE: { | 
| Object* referenced_context = Context::cast(host_context)->get(index); | 
| Handle<JSModule> value(Context::cast(referenced_context)->module()); | 
| -          JSReceiver::SetProperty(module, name, value, FROZEN, kStrictMode); | 
| +          JSReceiver::SetProperty(module, name, value, FROZEN, STRICT); | 
| break; | 
| } | 
| case INTERNAL: | 
| @@ -9346,9 +9330,7 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_StoreContextSlot) { | 
| Handle<Object> value(args[0], isolate); | 
| CONVERT_ARG_HANDLE_CHECKED(Context, context, 1); | 
| CONVERT_ARG_HANDLE_CHECKED(String, name, 2); | 
| -  CONVERT_LANGUAGE_MODE_ARG(language_mode, 3); | 
| -  StrictModeFlag strict_mode = (language_mode == SLOPPY_MODE) | 
| -      ? kSloppyMode : kStrictMode; | 
| +  CONVERT_STRICT_MODE_ARG_CHECKED(strict_mode, 3); | 
|  | 
| int index; | 
| PropertyAttributes attributes; | 
| @@ -9375,7 +9357,7 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_StoreContextSlot) { | 
| if ((attributes & READ_ONLY) == 0) { | 
| // Context is a fixed array and set cannot fail. | 
| context->set(index, *value); | 
| -    } else if (strict_mode == kStrictMode) { | 
| +    } else if (strict_mode == STRICT) { | 
| // Setting read only property in strict mode. | 
| Handle<Object> error = | 
| isolate->factory()->NewTypeError("strict_cannot_assign", | 
| @@ -9397,7 +9379,7 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_StoreContextSlot) { | 
| // The property was not found. | 
| ASSERT(attributes == ABSENT); | 
|  | 
| -    if (strict_mode == kStrictMode) { | 
| +    if (strict_mode == STRICT) { | 
| // Throw in strict mode (assignment to undefined variable). | 
| Handle<Object> error = | 
| isolate->factory()->NewReferenceError( | 
| @@ -9415,7 +9397,7 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_StoreContextSlot) { | 
| RETURN_IF_EMPTY_HANDLE( | 
| isolate, | 
| JSReceiver::SetProperty(object, name, value, NONE, strict_mode)); | 
| -  } else if (strict_mode == kStrictMode && (attributes & READ_ONLY) != 0) { | 
| +  } else if (strict_mode == STRICT && (attributes & READ_ONLY) != 0) { | 
| // Setting read only property in strict mode. | 
| Handle<Object> error = | 
| isolate->factory()->NewTypeError( | 
| @@ -9754,7 +9736,7 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_CompileString) { | 
| ParseRestriction restriction = function_literal_only | 
| ? ONLY_SINGLE_FUNCTION_LITERAL : NO_PARSE_RESTRICTION; | 
| Handle<JSFunction> fun = Compiler::GetFunctionFromEval( | 
| -      source, context, SLOPPY_MODE, restriction, RelocInfo::kNoPosition); | 
| +      source, context, SLOPPY, restriction, RelocInfo::kNoPosition); | 
| RETURN_IF_EMPTY_HANDLE(isolate, fun); | 
| return *fun; | 
| } | 
| @@ -9763,7 +9745,7 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_CompileString) { | 
| static ObjectPair CompileGlobalEval(Isolate* isolate, | 
| Handle<String> source, | 
| Handle<Object> receiver, | 
| -                                    LanguageMode language_mode, | 
| +                                    StrictMode strict_mode, | 
| int scope_position) { | 
| Handle<Context> context = Handle<Context>(isolate->context()); | 
| Handle<Context> native_context = Handle<Context>(context->native_context()); | 
| @@ -9783,7 +9765,7 @@ static ObjectPair CompileGlobalEval(Isolate* isolate, | 
| // and return the compiled function bound in the local context. | 
| static const ParseRestriction restriction = NO_PARSE_RESTRICTION; | 
| Handle<JSFunction> compiled = Compiler::GetFunctionFromEval( | 
| -      source, context, language_mode, restriction, scope_position); | 
| +      source, context, strict_mode, restriction, scope_position); | 
| RETURN_IF_EMPTY_HANDLE_VALUE(isolate, compiled, | 
| MakePair(Failure::Exception(), NULL)); | 
| return MakePair(*compiled, *receiver); | 
| @@ -9806,12 +9788,14 @@ RUNTIME_FUNCTION(ObjectPair, Runtime_ResolvePossiblyDirectEval) { | 
| return MakePair(*callee, isolate->heap()->undefined_value()); | 
| } | 
|  | 
| -  CONVERT_LANGUAGE_MODE_ARG(language_mode, 3); | 
| +  ASSERT(args[3]->IsSmi()); | 
| +  ASSERT(args.smi_at(3) == SLOPPY || args.smi_at(3) == STRICT); | 
| +  StrictMode strict_mode = static_cast<StrictMode>(args.smi_at(3)); | 
| ASSERT(args[4]->IsSmi()); | 
| return CompileGlobalEval(isolate, | 
| args.at<String>(1), | 
| args.at<Object>(2), | 
| -                           language_mode, | 
| +                           strict_mode, | 
| args.smi_at(4)); | 
| } | 
|  | 
| @@ -9876,7 +9860,7 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_PushIfAbsent) { | 
| // Strict not needed. Used for cycle detection in Array join implementation. | 
| RETURN_IF_EMPTY_HANDLE(isolate, JSObject::SetFastElement(array, length, | 
| element, | 
| -                                                           kSloppyMode, | 
| +                                                           SLOPPY, | 
| true)); | 
| return isolate->heap()->true_value(); | 
| } | 
| @@ -11348,7 +11332,7 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_GetFrameDetails) { | 
| // THE FRAME ITERATOR TO WRAP THE RECEIVER. | 
| Handle<Object> receiver(it.frame()->receiver(), isolate); | 
| if (!receiver->IsJSObject() && | 
| -      shared->is_sloppy_mode() && | 
| +      shared->strict_mode() == SLOPPY && | 
| !function->IsBuiltin()) { | 
| // If the receiver is not a JSObject and the function is not a | 
| // builtin or strict-mode we have hit an optimization where a | 
| @@ -11400,8 +11384,7 @@ static Handle<JSObject> MaterializeStackLocalsWithFrameInspector( | 
|  | 
| RETURN_IF_EMPTY_HANDLE_VALUE( | 
| isolate, | 
| -        Runtime::SetObjectProperty( | 
| -            isolate, target, name, value, NONE, kSloppyMode), | 
| +        Runtime::SetObjectProperty(isolate, target, name, value, NONE, SLOPPY), | 
| Handle<JSObject>()); | 
| } | 
|  | 
| @@ -11413,8 +11396,7 @@ static Handle<JSObject> MaterializeStackLocalsWithFrameInspector( | 
|  | 
| RETURN_IF_EMPTY_HANDLE_VALUE( | 
| isolate, | 
| -        Runtime::SetObjectProperty( | 
| -            isolate, target, name, value, NONE, kSloppyMode), | 
| +        Runtime::SetObjectProperty(isolate, target, name, value, NONE, SLOPPY), | 
| Handle<JSObject>()); | 
| } | 
|  | 
| @@ -11497,7 +11479,7 @@ static Handle<JSObject> MaterializeLocalContext(Isolate* isolate, | 
| key, | 
| GetProperty(isolate, ext, key), | 
| NONE, | 
| -                                       kSloppyMode), | 
| +                                       SLOPPY), | 
| Handle<JSObject>()); | 
| } | 
| } | 
| @@ -11598,8 +11580,7 @@ static bool SetLocalVariableValue(Isolate* isolate, | 
| // We don't expect this to do anything except replacing | 
| // property value. | 
| Runtime::SetObjectProperty(isolate, ext, variable_name, new_value, | 
| -                                     NONE, | 
| -                                     kSloppyMode); | 
| +                                     NONE, SLOPPY); | 
| return true; | 
| } | 
| } | 
| @@ -11647,8 +11628,7 @@ static Handle<JSObject> MaterializeClosure(Isolate* isolate, | 
| isolate, | 
| Runtime::SetObjectProperty(isolate, closure_scope, key, | 
| GetProperty(isolate, ext, key), | 
| -                                     NONE, | 
| -                                     kSloppyMode), | 
| +                                     NONE, SLOPPY), | 
| Handle<JSObject>()); | 
| } | 
| } | 
| @@ -11680,8 +11660,7 @@ static bool SetClosureVariableValue(Isolate* isolate, | 
| if (JSReceiver::HasProperty(ext, variable_name)) { | 
| // We don't expect this to do anything except replacing property value. | 
| Runtime::SetObjectProperty(isolate, ext, variable_name, new_value, | 
| -                                 NONE, | 
| -                                 kSloppyMode); | 
| +                                 NONE, SLOPPY); | 
| return true; | 
| } | 
| } | 
| @@ -11703,8 +11682,7 @@ static Handle<JSObject> MaterializeCatchScope(Isolate* isolate, | 
| RETURN_IF_EMPTY_HANDLE_VALUE( | 
| isolate, | 
| Runtime::SetObjectProperty(isolate, catch_scope, name, thrown_object, | 
| -                                 NONE, | 
| -                                 kSloppyMode), | 
| +                                 NONE, SLOPPY), | 
| Handle<JSObject>()); | 
| return catch_scope; | 
| } | 
| @@ -12217,7 +12195,7 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_GetStepInPositions) { | 
| Smi* position_value = Smi::FromInt(break_location_iterator.position()); | 
| JSObject::SetElement(array, len, | 
| Handle<Object>(position_value, isolate), | 
| -            NONE, kSloppyMode); | 
| +            NONE, SLOPPY); | 
| len++; | 
| } | 
| } | 
| @@ -12726,7 +12704,7 @@ static Handle<JSObject> MaterializeArgumentsObject( | 
| isolate->factory()->arguments_string(), | 
| arguments, | 
| ::NONE, | 
| -                             kSloppyMode); | 
| +                             SLOPPY); | 
| return target; | 
| } | 
|  | 
| @@ -12746,7 +12724,7 @@ static MaybeObject* DebugEvaluate(Isolate* isolate, | 
| Handle<JSFunction> eval_fun = | 
| Compiler::GetFunctionFromEval(source, | 
| context, | 
| -                                    SLOPPY_MODE, | 
| +                                    SLOPPY, | 
| NO_PARSE_RESTRICTION, | 
| RelocInfo::kNoPosition); | 
| RETURN_IF_EMPTY_HANDLE(isolate, eval_fun); | 
| @@ -13004,7 +12982,7 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_DebugReferencedBy) { | 
|  | 
| // Get the constructor function for context extension and arguments array. | 
| JSObject* arguments_boilerplate = | 
| -      isolate->context()->native_context()->arguments_boilerplate(); | 
| +      isolate->context()->native_context()->sloppy_arguments_boilerplate(); | 
| JSFunction* arguments_function = | 
| JSFunction::cast(arguments_boilerplate->map()->constructor()); | 
|  | 
|  |