Describe LiveEdit changes and support preview mode

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 33 matching lines @@
 // LiveEdit namespace is declared inside a single function constructor.
 Debug.LiveEdit = new function() {
 
   // 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, change_log) {
+  function ApplyPatchMultiChunk(script, diff_array, new_source, preview_only, change_log) {

[mnaganov (inactive), 2010/07/02 16:23:36]

nit: >80 chars

[Peter Rybin, 2013/06/26 19:39:57]

Done.

 
     var old_source = script.source;
 
     // Gather compile information about old version of script.
     var old_compile_info = GatherCompileInfo(old_source, script);
   
     // Build tree structures for old and new versions of the script.
     var root_old_node = BuildCodeInfoTree(old_compile_info);
 
     var pos_translator = new PosTranslator(diff_array);
@@ skipping 24 matching lines @@
 
     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
-      // business and should be have link to the actual script updated.
+      // business and should have link to the actual script updated.
       function CollectNew(node_list) {
         for (var i = 0; i < node_list.length; i++) {
           link_to_original_script_list.push(node_list[i]);
           CollectNew(node_list[i].children);
         }
       }
       
       if (old_node.status == FunctionStatus.DAMAGED) {
         CollectDamaged(old_node);
         return;
       }
       if (old_node.status == FunctionStatus.UNCHANGED) {
         update_positions_list.push(old_node);
       } else if (old_node.status == FunctionStatus.SOURCE_CHANGED) {
         update_positions_list.push(old_node);
       } else if (old_node.status == FunctionStatus.CHANGED) {
         replace_code_list.push(old_node);
         CollectNew(old_node.unmatched_new_nodes);
       }
       for (var i = 0; i < old_node.children.length; i++) {
         HarvestTodo(old_node.children[i]);
       }
     }
 
+    var preview_description = {
+        change_tree: DescribeChangeTree(root_old_node),
+        textual_diff: {
+          old_len: old_source.length,
+          new_len: new_source.length,
+          chunks: diff_array
+        },
+        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();
     for (var i = 0; i < replace_code_list.length; i++) {
       var info_wrapper = replace_code_list[i].live_shared_info_wrapper; 
       if (info_wrapper) {
         replaced_function_infos.push(info_wrapper);
       }
     }
 
-    // Check that function being patched is not currently on stack.
-    CheckStackActivations(replaced_function_infos, change_log);
-  
-  
     // We haven't changed anything before this line yet.
     // Committing all changes.
     
+    // Check that function being patched is not currently on stack or drop them.
+    var dropped_functions_number =
+        CheckStackActivations(replaced_function_infos, change_log);
+    
+    preview_description.stack_modified = dropped_functions_number != 0; 
+  
     // Start with breakpoints. Convert their line/column positions and 
     // temporary remove.
     var break_points_restorer = TemporaryRemoveBreakPoints(script, change_log);
 
     var old_script;
 
     // Create an old script only if there are function that should be linked
     // to old version.
     if (link_to_old_script_list.length == 0) {
       %LiveEditReplaceScript(script, new_source, null);
       old_script = void 0;
     } 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();
       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();
     change_log.push( {position_patched: position_patch_report} );
     
     for (var i = 0; i < update_positions_list.length; i++) {
       // TODO(LiveEdit): take into account wether it's source_changed or
       // unchanged and whether positions changed at all.
       PatchPositions(update_positions_list[i], diff_array,
           position_patch_report);
     }
     
     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.
@@ skipping 285 matching lines @@
     this.parent = void 0;
     
     this.status = FunctionStatus.UNCHANGED;
     // Status explanation is used for debugging purposes and will be shown
     // in user UI if some explanations are needed.
     this.status_explanation = void 0;
     this.new_start_pos = void 0;
     this.new_end_pos = void 0;
     this.corresponding_node = void 0;
     this.unmatched_new_nodes = void 0;
+    
+    // 'Textual' correspondence/matching is weaker than 'pure'
+    // correspondence/matching. We need 'textual' level for visual presentation
+    // in UI, we use 'pure' level for actual code manipulation.
+    // Sometimes only function body is changed (functions in old and new script
+    // textually correspond), but we cannot patch the code, so we see them
+    // as an old function deleted and new function created.  
+    this.textual_corresponding_node = void 0;
+    this.textually_unmatched_new_nodes = void 0;
+    
     this.live_shared_info_wrapper = void 0;
   }
   
   // 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. 
@@ skipping 126 matching lines @@
   // 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 ProcessChildren(old_node, new_node) {
       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;
       while (old_index < old_children.length) {
         if (old_children[old_index].status == FunctionStatus.DAMAGED) {
           old_index++;
         } else if (new_index < new_children.length) {
           if (new_children[new_index].info.start_position <
               old_children[old_index].new_start_pos) {
             unmatched_new_nodes_list.push(new_children[new_index]);
+            textually_unmatched_new_nodes_list.push(new_children[new_index]);
             new_index++;
           } else if (new_children[new_index].info.start_position ==
               old_children[old_index].new_start_pos) {
             if (new_children[new_index].info.end_position ==
                 old_children[old_index].new_end_pos) {
               old_children[old_index].corresponding_node =
                   new_children[new_index];
+              old_children[old_index].textual_corresponding_node =
+                  new_children[new_index];
               if (old_children[old_index].status != FunctionStatus.UNCHANGED) {
                 ProcessChildren(old_children[old_index],
                     new_children[new_index]);
                 if (old_children[old_index].status == FunctionStatus.DAMAGED) {
                   unmatched_new_nodes_list.push(
                       old_children[old_index].corresponding_node);
                   old_children[old_index].corresponding_node = void 0;
                   old_node.status = FunctionStatus.CHANGED;
                 }
               }
             } else {
               old_children[old_index].status = FunctionStatus.DAMAGED;
               old_children[old_index].status_explanation =
                   "No corresponding function in new script found";
               old_node.status = FunctionStatus.CHANGED;
               unmatched_new_nodes_list.push(new_children[new_index]);
+              textually_unmatched_new_nodes_list.push(new_children[new_index]);
             }
             new_index++;
             old_index++;
           } else {
             old_children[old_index].status = FunctionStatus.DAMAGED;
             old_children[old_index].status_explanation =
                 "No corresponding function in new script found";
             old_node.status = FunctionStatus.CHANGED;
             old_index++;
           }
         } else {
           old_children[old_index].status = FunctionStatus.DAMAGED;
           old_children[old_index].status_explanation =
               "No corresponding function in new script found";
           old_node.status = FunctionStatus.CHANGED;
           old_index++;
         }
       }
       
       while (new_index < new_children.length) {
         unmatched_new_nodes_list.push(new_children[new_index]);
+        textually_unmatched_new_nodes_list.push(new_children[new_index]);
         new_index++;
       }
       
       if (old_node.status == FunctionStatus.CHANGED) {
-        if (!CompareFunctionExpectations(old_node.info, new_node.info)) {
+        var why_wrong_expectations =
+            WhyFunctionExpectationsDiffer(old_node.info, new_node.info);
+        if (why_wrong_expectations) {
           old_node.status = FunctionStatus.DAMAGED;
-          old_node.status_explanation = "Changed code expectations";
+          old_node.status_explanation = why_wrong_expectations;
         }
       }
       old_node.unmatched_new_nodes = unmatched_new_nodes_list;
+      old_node.textually_unmatched_new_nodes =
+          textually_unmatched_new_nodes_list;
     }
 
     ProcessChildren(old_code_tree, new_code_tree);
     
     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();
   
     for (var i = 0; i < shared_raw_list.length; i++) {
@@ skipping 63 matching lines @@
     report_array.push( { name: old_info_node.info.function_name } );
   }
 
   // Adds a suffix to script name to mark that it is old version.
   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.
-  function CompareFunctionExpectations(function_info1, function_info2) {
+  // changed or not. Returns explanation if they differ.
+  function WhyFunctionExpectationsDiffer(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;
+      return "Changed parameter number: " + function_info1.param_num + 
+          " and " + function_info2.param_num;
     }
     var scope_info1 = function_info1.scope_info;
     var scope_info2 = function_info2.scope_info;
-  
-    if (!scope_info1) {
-      return !scope_info2;
+
+    var scope_info1_text; 
+    var scope_info2_text; 
+    
+    if (scope_info1) {
+      scope_info1_text = scope_info1.toString(); 
+    } else {
+      scope_info1_text = "";
     }
-  
-    if (scope_info1.length != scope_info2.length) {
-      return false;
+    if (scope_info2) {
+      scope_info2_text = scope_info2.toString(); 
+    } else {
+      scope_info2_text = "";
     }
-  
-    // 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();
+    
+    if (scope_info1_text != scope_info2_text) {
+      return "Incompatible variable maps: [" + scope_info1_text +
+          "] and [" + scope_info2_text + "]";  
+    }
+    return;

[mnaganov (inactive), 2010/07/02 16:23:36]

I would expect a comment here.

[Peter Rybin, 2013/06/26 19:39:57]

Done.

   }
   
   // 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();
@@ skipping 23 matching lines @@
         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 Failure("Blocked by functions on stack");
     }
+    
+    return dropped.length;
   }
   
   // A copy of the FunctionPatchabilityStatus enum from liveedit.h
   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
   }
@@ skipping 21 matching lines @@
   }
   
   // 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, change_log) {
+  function SetScriptSource(script, new_source, preview_only, change_log) {
     var old_source = script.source;
     var diff = CompareStringsLinewise(old_source, new_source);
-    if (diff.length == 0) {
-      change_log.push( { empty_diff: true } );
-      return;
-    }
-    ApplyPatchMultiChunk(script, diff, new_source, change_log);
+    return ApplyPatchMultiChunk(script, diff, new_source, preview_only,
+        change_log);
   }
   // Function is public.
   this.SetScriptSource = SetScriptSource;
   
   function CompareStringsLinewise(s1, s2) {
     return %LiveEditCompareStringsLinewise(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.
   //
   // @param {Script} script that is being changed
   // @param {Array} change_log a list that collects engineer-readable
   //     description of what happened.
   function ApplySingleChunkPatch(script, change_pos, change_len, new_str,
       change_log) {
     var old_source = script.source;
   
     // Prepare new source string.
     var new_source = old_source.substring(0, change_pos) +
         new_str + old_source.substring(change_pos + change_len);
     
     return ApplyPatchMultiChunk(script,
         [ change_pos, change_pos + change_len, change_pos + new_str.length],
-        new_source, change_log);
+        new_source, false, change_log);
+  }
+  
+  // Creates JSON description for a change tree.
+  function DescribeChangeTree(old_code_tree) {
+    
+    function ProcessOldNode(node) {
+      var child_infos = [];
+      for (var i = 0; i < node.children.length; i++) {
+        var child = node.children[i];
+        if (child.status != FunctionStatus.UNCHANGED) {
+          child_infos.push(ProcessOldNode(child));
+        }
+      }
+      var new_child_infos = [];
+      if (node.textually_unmatched_new_nodes) {
+        for (var i = 0; i < node.textually_unmatched_new_nodes.length; i++) {
+          var child = node.textually_unmatched_new_nodes[i];
+          new_child_infos.push(ProcessNewNode(child));
+        }
+      }
+      var res = {
+        name: node.info.function_name,
+        positions: DescribePositions(node),
+        status: node.status,
+        children: child_infos,
+        new_children: new_child_infos  
+      };
+      if (node.status_explanation) {
+        res.status_explanation = node.status_explanation;
+      }
+      if (node.textual_corresponding_node) {
+        res.new_positions = DescribePositions(node.textual_corresponding_node);
+      }
+      return res;
+    }
+    
+    function ProcessNewNode(node) {
+      var child_infos = [];
+      // Do not list ancestors.
+      if (false) {
+        for (var i = 0; i < node.children.length; i++) {
+          child_infos.push(ProcessNewNode(node.children[i]));
+        }
+      }
+      var res = {
+        name: node.info.function_name,
+        positions: DescribePositions(node),
+        children: child_infos,
+      };
+      return res;
+    }
+    
+    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 = {
     PosTranslator: PosTranslator,
     CompareStringsLinewise: CompareStringsLinewise,
     ApplySingleChunkPatch: ApplySingleChunkPatch
   }
 }