Make a namespace for LiveEdit

src/liveedit-debugger.js

 // 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 10 matching lines @@
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // LiveEdit feature implementation. The script should be executed after
 // debug-debugger.js.
 
+// A LiveEdit namespace is declared inside a single function constructor.
+Debug.LiveEdit = new function() {
+
+// TODO(LiveEdit): restore indentation below
 
 // Changes script text and recompiles all relevant functions if possible.
 // The change is always a substring (change_pos, change_pos + change_len)
 // being replaced with a completely different string new_str.
 //
 // Only one function will have its Code changed in result of this function.
 // All nested functions (should they have any instances at the moment) are left
 // unchanged and re-linked to a newly created script instance representing old
 // version of the source. (Generally speaking,
 // during the change all nested functions are erased and completely different
 // set of nested functions are introduced.) All other functions just have
 // their positions updated.
 //
 // @param {Script} script that is being changed
 // @param {Array} change_log a list that collects engineer-readable description
 //     of what happened.
-Debug.LiveEditChangeScript = function(script, change_pos, change_len, new_str,
+function ApplyPatch(script, change_pos, change_len, new_str,
     change_log) {
 
-  // So far the function works as namespace.
-  var liveedit = Debug.LiveEditChangeScript;
-  var Assert = liveedit.Assert;
-
   // 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.
   //
   // The script is used for compilation, because it produces code that
   // needs to be linked with some particular script (for nested functions).
   function DebugGatherCompileInfo(source) {
     // 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();
     for (var i = 0; i < raw_compile_info.length; i++) {
-        compile_info.push(new liveedit.FunctionCompileInfo(raw_compile_info[i]));
+        compile_info.push(new FunctionCompileInfo(raw_compile_info[i]));
         old_index_map.push(i);
     }
 
     for (var i = 0; i < compile_info.length; i++) {
       var k = i;
       for (var j = i + 1; j < compile_info.length; j++) {
         if (compile_info[k].start_position > compile_info[j].start_position) {
           k = j;
         }
       }
@@ skipping 133 matching lines @@
   // Prepare new source string.
   var new_source = old_source.substring(0, change_pos) +
       new_str + old_source.substring(change_pos + change_len);
 
   // Find all SharedFunctionInfo's that are compiled from this script.
   var shared_raw_list = %LiveEditFindSharedFunctionInfosForScript(script);
 
   var shared_infos = new Array();
 
   for (var i = 0; i < shared_raw_list.length; i++) {
-    shared_infos.push(new liveedit.SharedInfoWrapper(shared_raw_list[i]));
+    shared_infos.push(new SharedInfoWrapper(shared_raw_list[i]));
   }
 
   // Gather compile information about old version of script.
   var old_compile_info = DebugGatherCompileInfo(old_source);
 
   // Gather compile information about new version of script.
   var new_compile_info;
   try {
     new_compile_info = DebugGatherCompileInfo(new_source);
   } catch (e) {
-    throw new liveedit.Failure("Failed to compile new version of script: " + e);
+    throw new Failure("Failed to compile new version of script: " + e);
   }
 
   // An index of a single function, that is going to have its code replaced.
   var function_being_patched =
       FindChangedFunction(old_compile_info, change_pos, change_len_old);
 
   // In old and new script versions function with a change should have the
   // same indexes.
   var function_being_patched2 =
       FindChangedFunction(new_compile_info, change_pos, change_len_new);
   Assert(function_being_patched == function_being_patched2,
          "inconsistent old/new compile info");
 
   // Check that function being patched has the same expectations in a new
   // version. Otherwise we cannot safely patch its behavior and should
   // choose the outer function instead.
-  while (!liveedit.CompareFunctionExpectations(
+  while (!CompareFunctionExpectations(
       old_compile_info[function_being_patched],
       new_compile_info[function_being_patched])) {
 
     Assert(old_compile_info[function_being_patched].outer_index ==
         new_compile_info[function_being_patched].outer_index);
     function_being_patched =
         old_compile_info[function_being_patched].outer_index;
     Assert(function_being_patched != -1);
   }
 
   // Check that function being patched is not currently on stack.
-  liveedit.CheckStackActivations(
+  CheckStackActivations(
       [ FindFunctionInfo(function_being_patched) ], change_log );
 
 
   // Committing all changes.
-  var old_script_name = liveedit.CreateNameForOldScript(script);
+  var old_script_name = CreateNameForOldScript(script);
 
   // Update the script text and create a new script representing an old
   // version of the script.
   var old_script = %LiveEditReplaceScript(script, new_source, old_script_name);
 
   PatchCode(new_compile_info[function_being_patched],
       FindFunctionInfo(function_being_patched));
 
   var position_patch_report = new Array();
   change_log.push( {position_patched: position_patch_report} );
@@ skipping 32 matching lines @@
   }
 
   var link_to_old_script_report = new Array();
   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 = function_being_patched + 1; i < old_next_sibling; i++) {
     LinkToOldScript(FindFunctionInfo(i), old_script);
   }
 }
+// Function is public.
+this.ApplyPatch = ApplyPatch;
 
-Debug.LiveEditChangeScript.Assert = function(condition, message) {
+function Assert(condition, message) {
   if (!condition) {
     if (message) {
       throw "Assert " + message;
     } else {
       throw "Assert";
     }
   }
 }
 
 // An object describing function compilation details. Its index fields
 // apply to indexes inside array that stores these objects.
-Debug.LiveEditChangeScript.FunctionCompileInfo = function(raw_array) {
+function FunctionCompileInfo(raw_array) {
   this.function_name = raw_array[0];
   this.start_position = raw_array[1];
   this.end_position = raw_array[2];
   this.param_num = raw_array[3];
   this.code = raw_array[4];
   this.scope_info = raw_array[5];
   this.outer_index = raw_array[6];
   this.next_sibling_index = null;
   this.raw_array = raw_array;
 }
 
-// A structure describing SharedFunctionInfo.
-Debug.LiveEditChangeScript.SharedInfoWrapper = function(raw_array) {
+function SharedInfoWrapper(raw_array) {
   this.function_name = raw_array[0];
   this.start_position = raw_array[1];
   this.end_position = raw_array[2];
   this.info = raw_array[3];
   this.raw_array = raw_array;
 }
 
 // Adds a suffix to script name to mark that it is old version.
-Debug.LiveEditChangeScript.CreateNameForOldScript = function(script) {
+function CreateNameForOldScript(script) {
   // TODO(635): try better than this; support several changes.
   return script.name + " (old)";
 }
 
 // Compares a function interface old and new version, whether it
 // changed or not.
-Debug.LiveEditChangeScript.CompareFunctionExpectations =
-    function(function_info1, function_info2) {
+function CompareFunctionExpectations(function_info1, function_info2) {
   // Check that function has the same number of parameters (there may exist
   // an adapter, that won't survive function parameter number change).
   if (function_info1.param_num != function_info2.param_num) {
     return false;
   }
   var scope_info1 = function_info1.scope_info;
   var scope_info2 = function_info2.scope_info;
 
   if (!scope_info1) {
     return !scope_info2;
   }
 
   if (scope_info1.length != scope_info2.length) {
     return false;
   }
 
   // Check that outer scope structure is not changed. Otherwise the function
   // will not properly work with existing scopes.
   return scope_info1.toString() == scope_info2.toString();
 }
 
+// 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.
-Debug.LiveEditChangeScript.CheckStackActivations = function(shared_wrapper_list,
-                                                            change_log) {
-  var liveedit = Debug.LiveEditChangeScript;
-
+function CheckStackActivations(shared_wrapper_list, change_log) {
   var shared_list = new Array();
   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 liveedit.Failure(result[shared_list.length]);
+    throw new Failure(result[shared_list.length]);
   }
-  
+
   var problems = new Array();
   var dropped = new Array();
   for (var i = 0; i < shared_list.length; i++) {
     var shared = shared_wrapper_list[i];
-    if (result[i] == liveedit.FunctionPatchabilityStatus.REPLACED_ON_ACTIVE_STACK) {
+    if (result[i] == FunctionPatchabilityStatus.REPLACED_ON_ACTIVE_STACK) {
       dropped.push({ name: shared.function_name } );
-    } else if (result[i] != liveedit.FunctionPatchabilityStatus.AVAILABLE_FOR_PATCH) {
+    } 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:
-              liveedit.FunctionPatchabilityStatus.SymbolName(result[i])
+              FunctionPatchabilityStatus.SymbolName(result[i])
       };
       problems.push(description);
     }
   }
   if (dropped.length > 0) {
     change_log.push({ dropped_from_stack: dropped });
   }
   if (problems.length > 0) {
     change_log.push( { functions_on_stack: problems } );
-    throw new liveedit.Failure("Blocked by functions on stack");
+    throw new Failure("Blocked by functions on stack");
   }
 }
 
 // A copy of the FunctionPatchabilityStatus enum from liveedit.h
-Debug.LiveEditChangeScript.FunctionPatchabilityStatus = {
+var FunctionPatchabilityStatus = {
     AVAILABLE_FOR_PATCH: 1,
     BLOCKED_ON_ACTIVE_STACK: 2,
     BLOCKED_ON_OTHER_STACK: 3,
     BLOCKED_UNDER_NATIVE_CODE: 4,
     REPLACED_ON_ACTIVE_STACK: 5
 }
 
-Debug.LiveEditChangeScript.FunctionPatchabilityStatus.SymbolName =
-    function(code) {
-  var enum = Debug.LiveEditChangeScript.FunctionPatchabilityStatus;
+FunctionPatchabilityStatus.SymbolName = function(code) {
+  var enum = FunctionPatchabilityStatus;
   for (name in enum) {
     if (enum[name] == code) {
       return name;
     }
   }      
 }
 
 
 // A logical failure in liveedit process. This means that change_log
 // is valid and consistent description of what happened.
-Debug.LiveEditChangeScript.Failure = function(message) {
+function Failure(message) {
   this.message = message;
 }
+// Function (constructor) is public.
+this.Failure = Failure;
 
-Debug.LiveEditChangeScript.Failure.prototype.toString = function() {
+Failure.prototype.toString = function() {
   return "LiveEdit Failure: " + this.message;
 }
 
 // A testing entry.
-Debug.LiveEditChangeScript.GetPcFromSourcePos = function(func, source_pos) {
+function GetPcFromSourcePos(func, source_pos) {
   return %GetFunctionCodePositionFromSource(func, source_pos);
 }
+// Function is public.
+this.GetPcFromSourcePos = GetPcFromSourcePos;
 
-// A LiveEdit namespace is declared inside a single function constructor.
-Debug.LiveEdit = new function() {
-  var LiveEdit = this;
-
+// TODO(LiveEdit): restore indentation above
   
   // LiveEdit main entry point: changes a script text to a new string.
-  LiveEdit.SetScriptSource = function(script, new_source, change_log) {
+  function SetScriptSource(script, new_source, change_log) {
     var old_source = script.source;
     var diff = FindSimpleDiff(old_source, new_source);
     if (!diff) {
       return;
     }
-    Debug.LiveEditChangeScript(script, diff.change_pos, diff.old_len,
+    ApplyPatch(script, diff.change_pos, diff.old_len,
         new_source.substring(diff.change_pos, diff.change_pos + diff.new_len),
         change_log);
   }
+  // Function is public.
+  this.SetScriptSource = SetScriptSource;
 
   
   // Finds a difference between 2 strings in form of a single chunk.
   // This is a temporary solution. We should calculate a read diff instead.
   function FindSimpleDiff(old_source, new_source) {
     var change_pos;
     var old_len;
     var new_len;
     
     // A find range block. Whenever control leaves it, it should set 3 local
@@ skipping 46 matching lines @@
     }
 
     if (old_len == 0 && new_len == 0) {
       // no change
       return;
     }
     
     return { "change_pos": change_pos, "old_len": old_len, "new_len": new_len };
   }
 }