Ensure the result is used for the remaining calls to SetElement...

src/liveedit.cc

 // Copyright 2010 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 268 matching lines @@
 class CompareOutputArrayWriter {
  public:
   CompareOutputArrayWriter()
       : array_(Factory::NewJSArray(10)), current_size_(0) {}
 
   Handle<JSArray> GetResult() {
     return array_;
   }
 
   void WriteChunk(int char_pos1, int char_pos2, int char_len1, int char_len2) {
-    SetElement(array_,
-               current_size_,
-               Handle<Object>(Smi::FromInt(char_pos1)),
-               kNonStrictMode);
-    SetElement(array_,
-               current_size_ + 1,
-               Handle<Object>(Smi::FromInt(char_pos1 + char_len1)),
-               kNonStrictMode);
-    SetElement(array_,
-               current_size_ + 2,
-               Handle<Object>(Smi::FromInt(char_pos2 + char_len2)),
-               kNonStrictMode);
+    Handle<Object> no_failure;
+    no_failure = SetElement(array_,

[Lasse Reichstein, 2011/03/08 09:26:08]

Add a comment saying that we never set element accessors in the debug context.

+                            current_size_,
+                            Handle<Object>(Smi::FromInt(char_pos1)),
+                            kNonStrictMode);
+    ASSERT(!no_failure.is_null());
+    no_failure = SetElement(array_,
+                            current_size_ + 1,
+                            Handle<Object>(Smi::FromInt(char_pos1 + char_len1)),
+                            kNonStrictMode);
+    ASSERT(!no_failure.is_null());
+    no_failure = SetElement(array_,
+                            current_size_ + 2,
+                            Handle<Object>(Smi::FromInt(char_pos2 + char_len2)),
+                            kNonStrictMode);

[Lasse Reichstein, 2011/03/08 09:26:08]

Are we sure we don't get any warnings from this assignment in release mode? On
any platform? The assigned value is unused.

+    ASSERT(!no_failure.is_null());
     current_size_ += 3;
   }
 
  private:
   Handle<JSArray> array_;
   int current_size_;
 };
 
 
 // Represents 2 strings as 2 arrays of tokens.
@@ skipping 234 matching lines @@
     return S(array_handle);
   }
   explicit JSArrayBasedStruct(Handle<JSArray> array) : array_(array) {
   }
   Handle<JSArray> GetJSArray() {
     return array_;
   }
 
  protected:
   void SetField(int field_position, Handle<Object> value) {
-    SetElement(array_, field_position, value, kNonStrictMode);
+    Handle<Object> no_failure =
+        SetElement(array_, field_position, value, kNonStrictMode);
+    ASSERT(!no_failure.is_null());
   }
   void SetSmiValueField(int field_position, int value) {
-    SetElement(array_,
-               field_position,
-               Handle<Smi>(Smi::FromInt(value)),
-               kNonStrictMode);
+    Handle<Object> no_failure = SetElement(array_,
+                                           field_position,
+                                           Handle<Smi>(Smi::FromInt(value)),
+                                           kNonStrictMode);
+    ASSERT(!no_failure.is_null());
   }
   Object* GetField(int field_position) {
     return array_->GetElementNoExceptionThrown(field_position);
   }
   int GetSmiValueField(int field_position) {
     Object* res = GetField(field_position);
     return Smi::cast(res)->value();
   }
 
  private:
@@ skipping 118 matching lines @@
     result_ = Factory::NewJSArray(10);
   }
 
   void FunctionStarted(FunctionLiteral* fun) {
     HandleScope scope;
     FunctionInfoWrapper info = FunctionInfoWrapper::Create();
     info.SetInitialProperties(fun->name(), fun->start_position(),
                               fun->end_position(), fun->num_parameters(),
                               current_parent_index_);
     current_parent_index_ = len_;
-    SetElement(result_, len_, info.GetJSArray(), kNonStrictMode);
+    Handle<Object> no_failure =
+        SetElement(result_, len_, info.GetJSArray(), kNonStrictMode);
+    ASSERT(!no_failure.is_null());
     len_++;
   }
 
   void FunctionDone() {
     HandleScope scope;
     FunctionInfoWrapper info =
         FunctionInfoWrapper::cast(
             result_->GetElementNoExceptionThrown(current_parent_index_));
     current_parent_index_ = info.GetParentIndex();
   }
@@ skipping 58 matching lines @@
       // Sort it.
       for (int k = 1; k < j; k++) {
         int l = k;
         for (int m = k + 1; m < j; m++) {
           if (list[l]->AsSlot()->index() > list[m]->AsSlot()->index()) {
             l = m;
           }
         }
         list[k] = list[l];
       }
+      Handle<Object> no_failure;
       for (int i = 0; i < j; i++) {
-        SetElement(scope_info_list, scope_info_length,
-                   list[i]->name(), kNonStrictMode);
+        no_failure = SetElement(scope_info_list, scope_info_length,
+                                list[i]->name(), kNonStrictMode);
+        ASSERT(!no_failure.is_null());
         scope_info_length++;
-        SetElement(scope_info_list, scope_info_length,
-                   Handle<Smi>(Smi::FromInt(list[i]->AsSlot()->index())),
-                   kNonStrictMode);
+        no_failure = SetElement(
+            scope_info_list,
+            scope_info_length,
+            Handle<Smi>(Smi::FromInt(list[i]->AsSlot()->index())),
+            kNonStrictMode);
+        ASSERT(!no_failure.is_null());
         scope_info_length++;
       }
-      SetElement(scope_info_list, scope_info_length,
-                 Handle<Object>(Heap::null_value()), kNonStrictMode);
+      no_failure = SetElement(scope_info_list,
+                              scope_info_length,
+                              Handle<Object>(Heap::null_value()),
+                              kNonStrictMode);
+      ASSERT(!no_failure.is_null());
       scope_info_length++;
 
       outer_scope = outer_scope->outer_scope();
     } while (outer_scope != NULL);
 
     return *scope_info_list;
   }
 
   Handle<JSArray> result_;
   int len_;
@@ skipping 22 matching lines @@
 void LiveEdit::WrapSharedFunctionInfos(Handle<JSArray> array) {
   HandleScope scope;
   int len = Smi::cast(array->length())->value();
   for (int i = 0; i < len; i++) {
     Handle<SharedFunctionInfo> info(
         SharedFunctionInfo::cast(array->GetElementNoExceptionThrown(i)));
     SharedInfoWrapper info_wrapper = SharedInfoWrapper::Create();
     Handle<String> name_handle(String::cast(info->name()));
     info_wrapper.SetProperties(name_handle, info->start_position(),
                                info->end_position(), info);
-    SetElement(array, i, info_wrapper.GetJSArray(), kNonStrictMode);
+    Handle<Object> no_failure =
+        SetElement(array, i, info_wrapper.GetJSArray(), kNonStrictMode);
+    ASSERT(!no_failure.is_null());
   }
 }
 
 
 // Visitor that collects all references to a particular code object,
 // including "CODE_TARGET" references in other code objects.
 // It works in context of ZoneScope.
 class ReferenceCollectorVisitor : public ObjectVisitor {
  public:
   explicit ReferenceCollectorVisitor(Code* original)
@@ skipping 477 matching lines @@
       JSFunction::cast(JavaScriptFrame::cast(frame)->function()));
 
   int len = Smi::cast(shared_info_array->length())->value();
   for (int i = 0; i < len; i++) {
     JSValue* wrapper =
         JSValue::cast(shared_info_array->GetElementNoExceptionThrown(i));
     Handle<SharedFunctionInfo> shared(
         SharedFunctionInfo::cast(wrapper->value()));
 
     if (function->shared() == *shared || IsInlined(*function, *shared)) {
-      SetElement(result, i, Handle<Smi>(Smi::FromInt(status)), kNonStrictMode);
+      Handle<Object> no_failure =
+          SetElement(result,
+                     i,
+                     Handle<Smi>(Smi::FromInt(status)),
+                     kNonStrictMode);
+      ASSERT(!no_failure.is_null());
       return true;
     }
   }
   return false;
 }
 
 
 // Iterates over handler chain and removes all elements that are inside
 // frames being dropped.
 static bool FixTryCatchHandler(StackFrame* top_frame,
@@ skipping 184 matching lines @@
   }
   Debug::FramesHaveBeenDropped(new_id, drop_mode,
                                restarter_frame_function_pointer);
 
   // Replace "blocked on active" with "replaced on active" status.
   for (int i = 0; i < array_len; i++) {
     if (result->GetElement(i) ==
         Smi::FromInt(LiveEdit::FUNCTION_BLOCKED_ON_ACTIVE_STACK)) {
       Handle<Object> replaced(
           Smi::FromInt(LiveEdit::FUNCTION_REPLACED_ON_ACTIVE_STACK));
-      SetElement(result, i, replaced, kNonStrictMode);
+      Handle<Object> no_failure =
+          SetElement(result, i, replaced, kNonStrictMode);
+      ASSERT(!no_failure.is_null());
     }
   }
   return NULL;
 }
 
 
 class InactiveThreadActivationsChecker : public ThreadVisitor {
  public:
   InactiveThreadActivationsChecker(Handle<JSArray> shared_info_array,
                                    Handle<JSArray> result)
@@ skipping 19 matching lines @@
 
 
 Handle<JSArray> LiveEdit::CheckAndDropActivations(
     Handle<JSArray> shared_info_array, bool do_drop) {
   int len = Smi::cast(shared_info_array->length())->value();
 
   Handle<JSArray> result = Factory::NewJSArray(len);
 
   // Fill the default values.
   for (int i = 0; i < len; i++) {
-    SetElement(result, i,
-               Handle<Smi>(Smi::FromInt(FUNCTION_AVAILABLE_FOR_PATCH)),
-               kNonStrictMode);
+    Handle<Object> no_failure =
+        SetElement(result, i,
+                   Handle<Smi>(Smi::FromInt(FUNCTION_AVAILABLE_FOR_PATCH)),
+                   kNonStrictMode);
+    ASSERT(!no_failure.is_null());
   }
 
 
   // First check inactive threads. Fail if some functions are blocked there.
   InactiveThreadActivationsChecker inactive_threads_checker(shared_info_array,
                                                             result);
   ThreadManager::IterateArchivedThreads(&inactive_threads_checker);
   if (inactive_threads_checker.HasBlockedFunctions()) {
     return result;
   }
 
   // Try to drop activations from the current stack.
   const char* error_message =
       DropActivationsInActiveThread(shared_info_array, result, do_drop);
   if (error_message != NULL) {
     // Add error message as an array extra element.
     Vector<const char> vector_message(error_message, StrLength(error_message));
     Handle<String> str = Factory::NewStringFromAscii(vector_message);
-    SetElement(result, len, str, kNonStrictMode);
+    Handle<Object> no_failure = SetElement(result, len, str, kNonStrictMode);
+    ASSERT(!no_failure.is_null());
   }
   return result;
 }
 
 
 LiveEditFunctionTracker::LiveEditFunctionTracker(FunctionLiteral* fun) {
   if (active_function_info_listener != NULL) {
     active_function_info_listener->FunctionStarted(fun);
   }
 }
@@ skipping 47 matching lines @@
 
 bool LiveEditFunctionTracker::IsActive() {
   return false;
 }
 
 #endif  // ENABLE_DEBUGGER_SUPPORT
 
 
 
 } }  // namespace v8::internal