(early draft) Strict mode - throw exception on assignment to read only property.

src/stub-cache.cc

 // Copyright 2006-2009 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 580 matching lines @@
       UNREACHABLE();
       return static_cast<ExternalArrayType>(0);
   }
 }
 
 }  // anonymous namespace
 
 
 MaybeObject* StubCache::ComputeKeyedLoadOrStoreExternalArray(
     JSObject* receiver,
-    bool is_store) {
+    bool is_store,
+    Code::ExtraICState extra_ic_state) {
+    ASSERT(extra_ic_state == kNonStrictMode || extra_ic_state == kStrictMode);
   Code::Flags flags =
       Code::ComputeMonomorphicFlags(
           is_store ? Code::KEYED_STORE_IC : Code::KEYED_LOAD_IC,
-          NORMAL);
+          NORMAL,
+          extra_ic_state);
   ExternalArrayType array_type =
       ElementsKindToExternalArrayType(receiver->GetElementsKind());
   String* name =
       is_store ? Heap::KeyedStoreExternalArray_symbol()
           : Heap::KeyedLoadExternalArray_symbol();
   // Use the global maps for the particular external array types,
   // rather than the receiver's map, when looking up the cached code,
   // so that we actually canonicalize these stubs.
   Map* map = Heap::MapForExternalArrayType(array_type);
   Object* code = map->FindInCodeCache(name, flags);
   if (code->IsUndefined()) {
     ExternalArrayStubCompiler compiler;
-    { MaybeObject* maybe_code =
-          is_store ? compiler.CompileKeyedStoreStub(array_type, flags) :
-          compiler.CompileKeyedLoadStub(array_type, flags);
+    { MaybeObject* maybe_code = is_store
+          ? compiler.CompileKeyedStoreStub(array_type, flags)
+          : compiler.CompileKeyedLoadStub(array_type, flags);
       if (!maybe_code->ToObject(&code)) return maybe_code;
     }
     if (is_store) {
       PROFILE(
           CodeCreateEvent(Logger::KEYED_STORE_IC_TAG, Code::cast(code), 0));
     } else {
       PROFILE(
           CodeCreateEvent(Logger::KEYED_LOAD_IC_TAG, Code::cast(code), 0));
     }
     Object* result;
     { MaybeObject* maybe_result =
           map->UpdateCodeCache(name, Code::cast(code));
       if (!maybe_result->ToObject(&result)) return maybe_result;
     }
   }
   return code;
 }
 
 
 MaybeObject* StubCache::ComputeStoreNormal(Code::ExtraICState extra_ic_state) {
-  return Builtins::builtin(extra_ic_state == StoreIC::kStoreICStrict
+  return Builtins::builtin(extra_ic_state == kStrictMode
                             ? Builtins::StoreIC_Normal_Strict
                             : Builtins::StoreIC_Normal);
 }
 
 
 MaybeObject* StubCache::ComputeStoreGlobal(String* name,
                                            GlobalObject* receiver,
                                            JSGlobalPropertyCell* cell,
                                            Code::ExtraICState extra_ic_state) {
   Code::Flags flags = Code::ComputeMonomorphicFlags(
@@ skipping 763 matching lines @@
   return result;
 }
 
 
 MaybeObject* StoreInterceptorProperty(Arguments args) {
   JSObject* recv = JSObject::cast(args[0]);
   String* name = String::cast(args[1]);
   Object* value = args[2];
   ASSERT(recv->HasNamedInterceptor());
   PropertyAttributes attr = NONE;
-  MaybeObject* result = recv->SetPropertyWithInterceptor(name, value, attr);
+  MaybeObject* result = recv->SetPropertyWithInterceptor(

[Martin Maly, 2011/02/24 06:33:34]

This needs to be figured out whether we need to pass strict mode flag here.
Probably yes.

[Lasse Reichstein, 2011/02/24 12:37:54]

I'm guessing "yes" too.

+      name, value, attr, kNonStrictMode);   // TODL(mmaly): Is this OK?
   return result;
 }
 
 
 MaybeObject* KeyedLoadPropertyWithInterceptor(Arguments args) {
   JSObject* receiver = JSObject::cast(args[0]);
   ASSERT(Smi::cast(args[1])->value() >= 0);
   uint32_t index = Smi::cast(args[1])->value();
   return receiver->GetElementWithInterceptor(receiver, index);
 }
@@ skipping 419 matching lines @@
     if (!maybe_result->ToObject(&result)) return maybe_result;
   }
   Code* code = Code::cast(result);
   USE(code);
   PROFILE(CodeCreateEvent(Logger::STUB_TAG, code, "ExternalArrayStub"));
   return result;
 }
 
 
 } }  // namespace v8::internal