Debugger: load debugger builtins as normal native JS.

src/debug/liveedit.js

 // 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.
 
 // LiveEdit feature implementation. The script should be executed after
 // debug.js.
 
 // A LiveEdit namespace. It contains functions that modifies JavaScript code
 // according to changes of script source (if possible).
 //
 // When new script source is put in, the difference is calculated textually,
 // in form of list of delete/add/change chunks. The functions that include
 // change chunk(s) get recompiled, or their enclosing functions are
 // recompiled instead.
 // If the function may not be recompiled (e.g. it was completely erased in new
 // version of the script) it remains unchanged, but the code that could
 // create a new instance of this function goes away. An old version of script
 // is created to back up this obsolete function.
 // All unchanged functions have their positions updated accordingly.
 //
 // LiveEdit namespace is declared inside a single function constructor.
 
-"use strict";
+(function(global, utils) {
+  "use strict";
 
-Debug.LiveEdit = new function() {
+  // -------------------------------------------------------------------
+  // Imports
+
+  var FindScriptSourcePosition = global.Debug.findScriptSourcePosition;
+  var GetScriptBreakPoints;
+  var GlobalArray = global.Array;
+  var MathFloor = global.Math.floor;
+  var SyntaxError = global.SyntaxError;
+
+  utils.Import(function(from) {
+    GetScriptBreakPoints = from.GetScriptBreakPoints;
+  });
+
+  // -------------------------------------------------------------------
 
   // Forward declaration for minifier.
   var FunctionStatus;
 
   // Applies the change to the script.
   // The change is in form of list of chunks encoded in a single array as
   // a series of triplets (pos1_start, pos1_end, pos2_end)
   function ApplyPatchMultiChunk(script, diff_array, new_source, preview_only,
       change_log) {
 
@@ skipping 29 matching lines @@
         failure.details = details;
       }
       throw failure;
     }
     var root_new_node = BuildCodeInfoTree(new_compile_info);
 
     // Link recompiled script data with other data.
     FindCorrespondingFunctions(root_old_node, root_new_node);
 
     // Prepare to-do lists.
-    var replace_code_list = new Array();
-    var link_to_old_script_list = new Array();
-    var link_to_original_script_list = new Array();
-    var update_positions_list = new Array();
+    var replace_code_list = new GlobalArray();
+    var link_to_old_script_list = new GlobalArray();
+    var link_to_original_script_list = new GlobalArray();
+    var update_positions_list = new GlobalArray();
 
     function HarvestTodo(old_node) {
       function CollectDamaged(node) {
         link_to_old_script_list.push(node);
         for (var i = 0; i < node.children.length; i++) {
           CollectDamaged(node.children[i]);
         }
       }
 
       // Recursively collects all newly compiled functions that are going into
@@ skipping 32 matching lines @@
         updated: false
     };
 
     if (preview_only) {
       return preview_description;
     }
 
     HarvestTodo(root_old_node);
 
     // Collect shared infos for functions whose code need to be patched.
-    var replaced_function_infos = new Array();
+    var replaced_function_infos = new GlobalArray();
     for (var i = 0; i < replace_code_list.length; i++) {
       var live_shared_function_infos =
           replace_code_list[i].live_shared_function_infos;
 
       if (live_shared_function_infos) {
         for (var j = 0; j < live_shared_function_infos.length; j++) {
           replaced_function_infos.push(live_shared_function_infos[j]);
         }
       }
     }
@@ skipping 21 matching lines @@
       %LiveEditReplaceScript(script, new_source, null);
       old_script = UNDEFINED;
     } else {
       var old_script_name = CreateNameForOldScript(script);
 
       // Update the script text and create a new script representing an old
       // version of the script.
       old_script = %LiveEditReplaceScript(script, new_source,
           old_script_name);
 
-      var link_to_old_script_report = new Array();
+      var link_to_old_script_report = new GlobalArray();
       change_log.push( { linked_to_old_script: link_to_old_script_report } );
 
       // We need to link to old script all former nested functions.
       for (var i = 0; i < link_to_old_script_list.length; i++) {
         LinkToOldScript(link_to_old_script_list[i], old_script,
             link_to_old_script_report);
       }
 
       preview_description.created_script_name = old_script_name;
     }
 
     // Link to an actual script all the functions that we are going to use.
     for (var i = 0; i < link_to_original_script_list.length; i++) {
       %LiveEditFunctionSetScript(
           link_to_original_script_list[i].info.shared_function_info, script);
     }
 
     for (var i = 0; i < replace_code_list.length; i++) {
       PatchFunctionCode(replace_code_list[i], change_log);
     }
 
-    var position_patch_report = new Array();
+    var position_patch_report = new GlobalArray();
     change_log.push( {position_patched: position_patch_report} );
 
     for (var i = 0; i < update_positions_list.length; i++) {
       // TODO(LiveEdit): take into account whether it's source_changed or
       // unchanged and whether positions changed at all.
       PatchPositions(update_positions_list[i], diff_array,
           position_patch_report);
 
       if (update_positions_list[i].live_shared_function_infos) {
         update_positions_list[i].live_shared_function_infos.
             forEach(function (info) {
                 %LiveEditFunctionSourceUpdated(info.raw_array);
               });
       }
     }
 
     break_points_restorer(pos_translator, old_script);
 
     preview_description.updated = true;
     return preview_description;
   }
-  // Function is public.
-  this.ApplyPatchMultiChunk = ApplyPatchMultiChunk;
-
 
   // Fully compiles source string as a script. Returns Array of
   // FunctionCompileInfo -- a descriptions of all functions of the script.
   // Elements of array are ordered by start positions of functions (from top
   // to bottom) in the source. Fields outer_index and next_sibling_index help
   // to navigate the nesting structure of functions.
   //
   // All functions get compiled linked to script provided as parameter script.
   // TODO(LiveEdit): consider not using actual scripts as script, because
   // we have to manually erase all links right after compile.
   function GatherCompileInfo(source, script) {
     // Get function info, elements are partially sorted (it is a tree of
     // nested functions serialized as parent followed by serialized children.
     var raw_compile_info = %LiveEditGatherCompileInfo(script, source);
 
     // Sort function infos by start position field.
-    var compile_info = new Array();
-    var old_index_map = new Array();
+    var compile_info = new GlobalArray();
+    var old_index_map = new GlobalArray();
     for (var i = 0; i < raw_compile_info.length; i++) {
       var info = new FunctionCompileInfo(raw_compile_info[i]);
       // Remove all links to the actual script. Breakpoints system and
       // LiveEdit itself believe that any function in heap that points to a
       // particular script is a regular function.
       // For some functions we will restore this link later.
       %LiveEditFunctionSetScript(info.shared_function_info, UNDEFINED);
       compile_info.push(info);
       old_index_map.push(i);
     }
@@ skipping 112 matching lines @@
     var break_points_update_report = [];
     change_log.push( { break_points_update: break_points_update_report } );
 
     var break_point_old_positions = [];
     for (var i = 0; i < script_break_points.length; i++) {
       var break_point = script_break_points[i];
 
       break_point.clear();
 
       // TODO(LiveEdit): be careful with resource offset here.
-      var break_point_position = Debug.findScriptSourcePosition(original_script,
+      var break_point_position = FindScriptSourcePosition(original_script,
           break_point.line(), break_point.column());
 
       var old_position_description = {
           position: break_point_position,
           line: break_point.line(),
           column: break_point.column()
       };
       break_point_old_positions.push(old_position_description);
     }
 
@@ skipping 55 matching lines @@
   }
 
   function DiffChunk(pos1, pos2, len1, len2) {
     this.pos1 = pos1;
     this.pos2 = pos2;
     this.len1 = len1;
     this.len2 = len2;
   }
 
   function PosTranslator(diff_array) {
-    var chunks = new Array();
+    var chunks = new GlobalArray();
     var current_diff = 0;
     for (var i = 0; i < diff_array.length; i += 3) {
       var pos1_begin = diff_array[i];
       var pos2_begin = pos1_begin + current_diff;
       var pos1_end = diff_array[i + 1];
       var pos2_end = diff_array[i + 2];
       chunks.push(new DiffChunk(pos1_begin, pos2_begin, pos1_end - pos1_begin,
           pos2_end - pos2_begin));
       current_diff = pos2_end - pos1_end;
     }
     this.chunks = chunks;
   }
   PosTranslator.prototype.GetChunks = function() {
     return this.chunks;
   };
 
   PosTranslator.prototype.Translate = function(pos, inside_chunk_handler) {
     var array = this.chunks;
     if (array.length == 0 || pos < array[0].pos1) {
       return pos;
     }
     var chunk_index1 = 0;
     var chunk_index2 = array.length - 1;
 
     while (chunk_index1 < chunk_index2) {
-      var middle_index = Math.floor((chunk_index1 + chunk_index2) / 2);
+      var middle_index = MathFloor((chunk_index1 + chunk_index2) / 2);
       if (pos < array[middle_index + 1].pos1) {
         chunk_index2 = middle_index;
       } else {
         chunk_index1 = middle_index + 1;
       }
     }
     var chunk = array[chunk_index1];
     if (pos >= chunk.pos1 + chunk.len1) {
       return pos + chunk.pos2 + chunk.len2 - chunk.pos1 - chunk.len1;
     }
@@ skipping 60 matching lines @@
   // From array of function infos that is implicitly a tree creates
   // an actual tree of functions in script.
   function BuildCodeInfoTree(code_info_array) {
     // Throughtout all function we iterate over input array.
     var index = 0;
 
     // Recursive function that builds a branch of tree.
     function BuildNode() {
       var my_index = index;
       index++;
-      var child_array = new Array();
+      var child_array = new GlobalArray();
       while (index < code_info_array.length &&
           code_info_array[index].outer_index == my_index) {
         child_array.push(BuildNode());
       }
       var node = new CodeInfoTreeNode(code_info_array[my_index], child_array,
           my_index);
       for (var i = 0; i < child_array.length; i++) {
         child_array[i].parent = node;
       }
       return node;
@@ skipping 111 matching lines @@
   // inside function body may in fact be something like "} function B() {" that
   // splits a function into 2 functions.
   function FindCorrespondingFunctions(old_code_tree, new_code_tree) {
 
     // A recursive function that tries to find a correspondence for all
     // child functions and for their inner functions.
     function ProcessNode(old_node, new_node) {
       var scope_change_description =
           IsFunctionContextLocalsChanged(old_node.info, new_node.info);
       if (scope_change_description) {
-          old_node.status = FunctionStatus.CHANGED;
+        old_node.status = FunctionStatus.CHANGED;
       }
 
       var old_children = old_node.children;
       var new_children = new_node.children;
 
       var unmatched_new_nodes_list = [];
       var textually_unmatched_new_nodes_list = [];
 
       var old_index = 0;
       var new_index = 0;
@@ skipping 80 matching lines @@
     old_code_tree.corresponding_node = new_code_tree;
     old_code_tree.textual_corresponding_node = new_code_tree;
 
     Assert(old_code_tree.status != FunctionStatus.DAMAGED,
         "Script became damaged");
   }
 
   function FindLiveSharedInfos(old_code_tree, script) {
     var shared_raw_list = %LiveEditFindSharedFunctionInfosForScript(script);
 
-    var shared_infos = new Array();
+    var shared_infos = new GlobalArray();
 
     for (var i = 0; i < shared_raw_list.length; i++) {
       shared_infos.push(new SharedInfoWrapper(shared_raw_list[i]));
     }
 
     // Finds all SharedFunctionInfos that corresponds to compile info
     // in old version of the script.
     function FindFunctionInfos(compile_info) {
       var wrappers = [];
 
@@ skipping 96 matching lines @@
     return;
   }
 
   // Minifier forward declaration.
   var FunctionPatchabilityStatus;
 
   // For array of wrapped shared function infos checks that none of them
   // have activations on stack (of any thread). Throws a Failure exception
   // if this proves to be false.
   function CheckStackActivations(shared_wrapper_list, change_log) {
-    var shared_list = new Array();
+    var shared_list = new GlobalArray();
     for (var i = 0; i < shared_wrapper_list.length; i++) {
       shared_list[i] = shared_wrapper_list[i].info;
     }
     var result = %LiveEditCheckAndDropActivations(shared_list, true);
     if (result[shared_list.length]) {
       // Extra array element may contain error message.
       throw new Failure(result[shared_list.length]);
     }
 
-    var problems = new Array();
-    var dropped = new Array();
+    var problems = new GlobalArray();
+    var dropped = new GlobalArray();
     for (var i = 0; i < shared_list.length; i++) {
       var shared = shared_wrapper_list[i];
       if (result[i] == FunctionPatchabilityStatus.REPLACED_ON_ACTIVE_STACK) {
         dropped.push({ name: shared.function_name } );
       } else if (result[i] != FunctionPatchabilityStatus.AVAILABLE_FOR_PATCH) {
         var description = {
             name: shared.function_name,
             start_pos: shared.start_position,
             end_pos: shared.end_position,
             replace_problem:
@@ skipping 32 matching lines @@
       }
     }
   };
 
 
   // A logical failure in liveedit process. This means that change_log
   // is valid and consistent description of what happened.
   function Failure(message) {
     this.message = message;
   }
-  // Function (constructor) is public.
-  this.Failure = Failure;
 
   Failure.prototype.toString = function() {
     return "LiveEdit Failure: " + this.message;
   };
 
   function CopyErrorPositionToDetails(e, details) {
     function createPositionStruct(script, position) {
       if (position == -1) return;
       var location = script.locationFromPosition(position, true);
       if (location == null) return;
@@ skipping 14 matching lines @@
       start: createPositionStruct(script, e.startPosition),
       end: createPositionStruct(script, e.endPosition)
     };
     details.position = position_struct;
   }
 
   // A testing entry.
   function GetPcFromSourcePos(func, source_pos) {
     return %GetFunctionCodePositionFromSource(func, source_pos);
   }
-  // Function is public.
-  this.GetPcFromSourcePos = GetPcFromSourcePos;
 
   // LiveEdit main entry point: changes a script text to a new string.
   function SetScriptSource(script, new_source, preview_only, change_log) {
     var old_source = script.source;
     var diff = CompareStrings(old_source, new_source);
     return ApplyPatchMultiChunk(script, diff, new_source, preview_only,
         change_log);
   }
-  // Function is public.
-  this.SetScriptSource = SetScriptSource;
 
   function CompareStrings(s1, s2) {
     return %LiveEditCompareStrings(s1, s2);
   }
 
   // Applies the change to the script.
   // The change is always a substring (change_pos, change_pos + change_len)
   // being replaced with a completely different string new_str.
   // This API is a legacy and is obsolete.
   //
@@ skipping 66 matching lines @@
     function DescribePositions(node) {
       return {
         start_position: node.info.start_position,
         end_position: node.info.end_position
       };
     }
 
     return ProcessOldNode(old_code_tree);
   }
 
-  // Functions are public for tests.
-  this.TestApi = {
+  // -------------------------------------------------------------------
+  // Exports
+
+  var LiveEdit = {};
+  LiveEdit.SetScriptSource = SetScriptSource;
+  LiveEdit.ApplyPatchMultiChunk = ApplyPatchMultiChunk;
+  LiveEdit.Failure = Failure;
+  LiveEdit.GetPcFromSourcePos = GetPcFromSourcePos;
+
+  LiveEdit.TestApi = {
     PosTranslator: PosTranslator,
     CompareStrings: CompareStrings,
     ApplySingleChunkPatch: ApplySingleChunkPatch
   };
-};
+
+  global.Debug.LiveEdit = LiveEdit;
+
+})