[runtime] split up loops with HandleScopes

src/debug/liveedit.cc

 // Copyright 2012 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/debug/liveedit.h"
 
 #include "src/ast/scopeinfo.h"
 #include "src/ast/scopes.h"
 #include "src/code-stubs.h"
 #include "src/compilation-cache.h"
@@ skipping 1162 matching lines @@
 // Each group describes a change in text; groups are sorted by change_begin.
 // Only position in text beyond any changes may be successfully translated.
 // If a positions is inside some region that changed, result is currently
 // undefined.
 static int TranslatePosition(int original_position,
                              Handle<JSArray> position_change_array) {
   int position_diff = 0;
   int array_len = GetArrayLength(position_change_array);
   Isolate* isolate = position_change_array->GetIsolate();
   // TODO(635): binary search may be used here
-  for (int i = 0; i < array_len; i += 3) {
-    HandleScope scope(isolate);
+  FOR_WITH_HANDLE_SCOPE(isolate, int, i = 0, i, i < array_len, i += 3, {
     Handle<Object> element =
         JSReceiver::GetElement(isolate, position_change_array, i)
             .ToHandleChecked();
     CHECK(element->IsSmi());
     int chunk_start = Handle<Smi>::cast(element)->value();
     if (original_position < chunk_start) {
-      break;
+      return original_position + position_diff;
     }
     element = JSReceiver::GetElement(isolate, position_change_array, i + 1)
                   .ToHandleChecked();
     CHECK(element->IsSmi());
     int chunk_end = Handle<Smi>::cast(element)->value();
     // Position mustn't be inside a chunk.
     DCHECK(original_position >= chunk_end);
     element = JSReceiver::GetElement(isolate, position_change_array, i + 2)
                   .ToHandleChecked();
     CHECK(element->IsSmi());
     int chunk_changed_end = Handle<Smi>::cast(element)->value();
     position_diff = chunk_changed_end - chunk_end;
-  }
+  });
 
   return original_position + position_diff;
 }
 
 
 // Auto-growing buffer for writing relocation info code section. This buffer
 // is a simplified version of buffer from Assembler. Unlike Assembler, this
 // class is platform-independent and it works without dealing with instructions.
 // As specified by RelocInfo format, the buffer is filled in reversed order:
 // from upper to lower addresses.
@@ skipping 221 matching lines @@
 static bool CheckActivation(Handle<JSArray> shared_info_array,
                             Handle<JSArray> result,
                             StackFrame* frame,
                             LiveEdit::FunctionPatchabilityStatus status) {
   if (!frame->is_java_script()) return false;
 
   Handle<JSFunction> function(JavaScriptFrame::cast(frame)->function());
 
   Isolate* isolate = shared_info_array->GetIsolate();
   int len = GetArrayLength(shared_info_array);
-  for (int i = 0; i < len; i++) {
-    HandleScope scope(isolate);
+  FOR_WITH_HANDLE_SCOPE(isolate, int, i = 0, i, i < len, i++, {
     Handle<Object> element =
         JSReceiver::GetElement(isolate, shared_info_array, i).ToHandleChecked();
     Handle<JSValue> jsvalue = Handle<JSValue>::cast(element);
     Handle<SharedFunctionInfo> shared =
         UnwrapSharedFunctionInfoFromJSValue(jsvalue);
 
     if (function->Inlines(*shared)) {
       SetElementSloppy(result, i, Handle<Smi>(Smi::FromInt(status), isolate));
       return true;
     }
-  }
+  });
   return false;
 }
 
 
 // Iterates over handler chain and removes all elements that are inside
 // frames being dropped.
 static bool FixTryCatchHandler(StackFrame* top_frame,
                                StackFrame* bottom_frame) {
   Address* pointer_address =
       &Memory::Address_at(top_frame->isolate()->get_address_from_id(
@@ skipping 180 matching lines @@
     return NULL;
   }
   bool FrameUsesNewTarget(StackFrame* frame) {
     if (!frame->is_java_script()) return false;
     JavaScriptFrame* jsframe = JavaScriptFrame::cast(frame);
     Handle<SharedFunctionInfo> old_shared(jsframe->function()->shared());
     Isolate* isolate = old_shared->GetIsolate();
     int len = GetArrayLength(old_shared_array_);
     // Find corresponding new shared function info and return whether it
     // references new.target.
-    for (int i = 0; i < len; i++) {
-      HandleScope scope(isolate);
+    FOR_WITH_HANDLE_SCOPE(isolate, int, i = 0, i, i < len, i++, {
       Handle<Object> old_element =
           JSReceiver::GetElement(isolate, old_shared_array_, i)
               .ToHandleChecked();
       if (!old_shared.is_identical_to(UnwrapSharedFunctionInfoFromJSValue(
               Handle<JSValue>::cast(old_element)))) {
         continue;
       }
 
       Handle<Object> new_element =
           JSReceiver::GetElement(isolate, new_shared_array_, i)
               .ToHandleChecked();
       if (new_element->IsUndefined()) return false;
       Handle<SharedFunctionInfo> new_shared =
           UnwrapSharedFunctionInfoFromJSValue(
               Handle<JSValue>::cast(new_element));
       if (new_shared->scope_info()->HasNewTarget()) {
         SetElementSloppy(
             result_, i,
             Handle<Smi>(
                 Smi::FromInt(
                     LiveEdit::FUNCTION_BLOCKED_NO_NEW_TARGET_ON_RESTART),
                 isolate));
         return true;
       }
       return false;
-    }
+    });
     return false;
   }
 
  private:
   Handle<JSArray> old_shared_array_;
   Handle<JSArray> new_shared_array_;
   Handle<JSArray> result_;
 };
 
 
@@ skipping 338 matching lines @@
   isolate_->active_function_info_listener()->FunctionCode(code);
 }
 
 
 bool LiveEditFunctionTracker::IsActive(Isolate* isolate) {
   return isolate->active_function_info_listener() != NULL;
 }
 
 }  // namespace internal
 }  // namespace v8