super.property store

src/objects.cc

 // Copyright 2013 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 <sstream>
 
 #include "src/v8.h"
 
 #include "src/accessors.h"
 #include "src/allocation-site-scopes.h"
@@ skipping 3125 matching lines @@
   // If the receiver is the JSGlobalObject, the store was contextual. In case
   // the property did not exist yet on the global object itself, we have to
   // throw a reference error in strict mode.
   if (it->GetReceiver()->IsJSGlobalObject() && is_strict(language_mode)) {
     Handle<Object> args[1] = {it->name()};
     THROW_NEW_ERROR(it->isolate(),
                     NewReferenceError("not_defined", HandleVector(args, 1)),
                     Object);
   }
 
+  // super.property = value
+  // No property was found starting from the prototype of [[HomeObject]].
   if (data_store_mode == SUPER_PROPERTY) {

[arv (Not doing code reviews), 2015/02/17 20:41:22]

To me it looks like this if can be skipped since this code path is not specific
to super properties, it is just very hard to get here without super (you would
have to use a proxy).

     LookupIterator own_lookup(it->GetReceiver(), it->name(),
                               LookupIterator::OWN);
+    if (!own_lookup.IsFound()) {

[arv (Not doing code reviews), 2015/02/17 20:41:22]

Is there an existing function that can be used here? I feel dirty doing all this
logic here.

+      return AddDataProperty(&own_lookup, value, NONE, language_mode,
+                             store_mode);
+    }
 
-    return JSObject::SetProperty(&own_lookup, value, language_mode, store_mode,
-                                 NORMAL_PROPERTY);
+    PropertyDetails details = own_lookup.property_details();
+
+    // Otherwise reconfigure property with descriptor {value: value}.
+    if (details.IsConfigurable()) {
+      return JSObject::SetOwnPropertyIgnoreAttributes(
+          Handle<JSObject>::cast(it->GetReceiver()), it->name(), value,
+          details.attributes());
+    }
+
+    if (details.IsReadOnly()) {
+      return WriteToReadOnlyProperty(&own_lookup, value, language_mode);
+    }
+
+    // Not configurable but writable.
+    if (details.kind() == kData) {
+      return SetDataProperty(&own_lookup, value);
+    }
+
+    Handle<Object> args[] = {it->name()};
+    THROW_NEW_ERROR(it->isolate(),
+                    NewTypeError("redefine_disallowed",
+                                 HandleVector(args, arraysize(args))),
+                    Object);
   }
 
   return AddDataProperty(it, value, NONE, language_mode, store_mode);
 }
 
 
 MaybeHandle<Object> Object::WriteToReadOnlyProperty(
     LookupIterator* it, Handle<Object> value, LanguageMode language_mode) {
   if (is_sloppy(language_mode)) return value;
 
@@ skipping 14050 matching lines @@
                                                CompilationInfo* info) {
   Handle<DependentCode> codes = DependentCode::InsertCompilationInfo(
       handle(cell->dependent_code(), info->isolate()),
       DependentCode::kPropertyCellChangedGroup, info->object_wrapper());
   if (*codes != cell->dependent_code()) cell->set_dependent_code(*codes);
   info->dependencies(DependentCode::kPropertyCellChangedGroup)->Add(
       cell, info->zone());
 }
 
 } }  // namespace v8::internal