Improving error messages when adding properties to non JSObject receiver in

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 "src/objects.h"
 
 #include <cmath>
 #include <iomanip>
 #include <sstream>
 
@@ skipping 364 matching lines @@
 
 
 // static
 Handle<String> Object::TypeOf(Isolate* isolate, Handle<Object> object) {
   if (object->IsNumber()) return isolate->factory()->number_string();
   if (object->IsUndefined() || object->IsUndetectableObject()) {
     return isolate->factory()->undefined_string();
   }
   if (object->IsBoolean()) return isolate->factory()->boolean_string();
   if (object->IsSymbol()) return isolate->factory()->symbol_string();
+  if (object->IsString()) return isolate->factory()->string_string();
 #define SIMD128_TYPE(TYPE, Type, type, lane_count, lane_type) \
   if (object->Is##Type()) return isolate->factory()->type##_string();
   SIMD128_TYPES(SIMD128_TYPE)
 #undef SIMD128_TYPE
   if (object->IsCallable()) return isolate->factory()->function_string();
   return isolate->factory()->object_string();
 }
 
 
 // static
@@ skipping 3286 matching lines @@
 MaybeHandle<Object> Object::SetSuperProperty(LookupIterator* it,
                                              Handle<Object> value,
                                              LanguageMode language_mode,
                                              StoreFromKeyed store_mode) {
   bool found = false;
   MaybeHandle<Object> result =
       SetPropertyInternal(it, value, language_mode, store_mode, &found);
   if (found) return result;
 
   if (!it->GetReceiver()->IsJSReceiver()) {
-    return WriteToReadOnlyProperty(it->isolate(), it->GetReceiver(),
-                                   it->GetName(), value, language_mode);
+    return WriteToReadOnlyProperty(it, value, language_mode);
   }
 
   LookupIterator::Configuration c = LookupIterator::OWN;
   LookupIterator own_lookup =
       it->IsElement()
           ? LookupIterator(it->isolate(), it->GetReceiver(), it->index(), c)
           : LookupIterator(it->GetReceiver(), it->name(), c);
 
   for (; own_lookup.IsFound(); own_lookup.Next()) {
     switch (own_lookup.state()) {
@@ skipping 65 matching lines @@
   if (is_strong(language_mode)) {
     THROW_NEW_ERROR(
         isolate,
         NewTypeError(MessageTemplate::kStrongPropertyAccess, name, receiver),
         Object);
   }
   return isolate->factory()->undefined_value();
 }
 
 
+MaybeHandle<Object> Object::CannotCreateProperty(LookupIterator* it,
+                                                 Handle<Object> value,
+                                                 LanguageMode language_mode) {
+  return CannotCreateProperty(it->isolate(), it->GetReceiver(), it->GetName(),
+                              value, language_mode);
+}
+
+
+MaybeHandle<Object> Object::CannotCreateProperty(Isolate* isolate,
+                                                 Handle<Object> receiver,
+                                                 Handle<Object> name,
+                                                 Handle<Object> value,
+                                                 LanguageMode language_mode) {
+  if (is_sloppy(language_mode)) return value;
+  Handle<String> typeof_string = Object::TypeOf(isolate, receiver);
+  THROW_NEW_ERROR(isolate,
+                  NewTypeError(MessageTemplate::kStrictCannotCreateProperty,
+                               name, typeof_string, receiver),
+                  Object);
+}
+
+
 MaybeHandle<Object> Object::WriteToReadOnlyProperty(
     LookupIterator* it, Handle<Object> value, LanguageMode language_mode) {
   return WriteToReadOnlyProperty(it->isolate(), it->GetReceiver(),
                                  it->GetName(), value, language_mode);
 }
 
 
 MaybeHandle<Object> Object::WriteToReadOnlyProperty(
     Isolate* isolate, Handle<Object> receiver, Handle<Object> name,
     Handle<Object> value, LanguageMode language_mode) {
   if (is_sloppy(language_mode)) return value;
-  THROW_NEW_ERROR(
-      isolate,
-      NewTypeError(MessageTemplate::kStrictReadOnlyProperty, name, receiver),
-      Object);
+  Handle<String> typeof_string = Object::TypeOf(isolate, receiver);
+  THROW_NEW_ERROR(isolate,
+                  NewTypeError(MessageTemplate::kStrictReadOnlyProperty, name,
+                               typeof_string, receiver),
+                  Object);
 }
 
 
 MaybeHandle<Object> Object::RedefineNonconfigurableProperty(
     Isolate* isolate, Handle<Object> name, Handle<Object> value,
     LanguageMode language_mode) {
   if (is_sloppy(language_mode)) return value;
   THROW_NEW_ERROR(isolate,
                   NewTypeError(MessageTemplate::kRedefineDisallowed, name),
                   Object);
@@ skipping 104 matching lines @@
 }
 
 
 MaybeHandle<Object> Object::AddDataProperty(LookupIterator* it,
                                             Handle<Object> value,
                                             PropertyAttributes attributes,
                                             LanguageMode language_mode,
                                             StoreFromKeyed store_mode) {
   DCHECK(!it->GetReceiver()->IsJSProxy());
   if (!it->GetReceiver()->IsJSObject()) {
-    // TODO(verwaest): Throw a TypeError with a more specific message.
-    return WriteToReadOnlyProperty(it, value, language_mode);
+    if (!it->IsFound()) {
+      return CannotCreateProperty(it, value, language_mode);
+    } else {
+      return WriteToReadOnlyProperty(it, value, language_mode);

[Toon Verwaest, 2015/10/07 14:21:37]

This case shouldn't happen I think.

[Camillo Bruni, 2015/10/07 14:30:41]

removed.

+    }
   }
 
   DCHECK_NE(LookupIterator::INTEGER_INDEXED_EXOTIC, it->state());
 
   Handle<JSObject> receiver = it->GetStoreTarget();
 
   // If the receiver is a JSGlobalProxy, store on the prototype (JSGlobalObject)
   // instead. If the prototype is Null, the proxy is detached.
   if (receiver->IsJSGlobalProxy()) return value;
 
@@ skipping 9564 matching lines @@
   uint32_t length = 0;
   CHECK(array->length()->ToArrayLength(&length));
   if (length <= index) return HasReadOnlyLength(array);
   return false;
 }
 
 
 MaybeHandle<Object> JSArray::ReadOnlyLengthError(Handle<JSArray> array) {
   Isolate* isolate = array->GetIsolate();
   Handle<Name> length = isolate->factory()->length_string();
-  THROW_NEW_ERROR(
-      isolate,
-      NewTypeError(MessageTemplate::kStrictReadOnlyProperty, length, array),
-      Object);
+  Handle<String> typeof_string = Object::TypeOf(isolate, array);
+  THROW_NEW_ERROR(isolate,
+                  NewTypeError(MessageTemplate::kStrictReadOnlyProperty, length,
+                               typeof_string, array),
+                  Object);
 }
 
 
 template <typename BackingStore>
 static int FastHoleyElementsUsage(JSObject* object, BackingStore* store) {
   int limit = object->IsJSArray()
                   ? Smi::cast(JSArray::cast(object)->length())->value()
                   : store->length();
   int used = 0;
   for (int i = 0; i < limit; ++i) {
@@ skipping 3352 matching lines @@
   if (cell->value() != *new_value) {
     cell->set_value(*new_value);
     Isolate* isolate = cell->GetIsolate();
     cell->dependent_code()->DeoptimizeDependentCodeGroup(
         isolate, DependentCode::kPropertyCellChangedGroup);
   }
 }
 
 }  // namespace internal
 }  // namespace v8