1// Copyright 2010 the V8 project authors. All rights reserved. 2// Redistribution and use in source and binary forms, with or without 3// modification, are permitted provided that the following conditions are 4// met: 5// 6// * Redistributions of source code must retain the above copyright 7// notice, this list of conditions and the following disclaimer. 8// * Redistributions in binary form must reproduce the above 9// copyright notice, this list of conditions and the following 10// disclaimer in the documentation and/or other materials provided 11// with the distribution. 12// * Neither the name of Google Inc. nor the names of its 13// contributors may be used to endorse or promote products derived 14// from this software without specific prior written permission. 15// 16// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 17// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 18// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 19// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 20// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 21// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 22// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 23// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 24// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 25// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 26// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 28// LiveEdit feature implementation. The script should be executed after 29// debug-debugger.js. 30 31// A LiveEdit namespace. It contains functions that modifies JavaScript code 32// according to changes of script source (if possible). 33// 34// When new script source is put in, the difference is calculated textually, 35// in form of list of delete/add/change chunks. The functions that include 36// change chunk(s) get recompiled, or their enclosing functions are 37// recompiled instead. 38// If the function may not be recompiled (e.g. it was completely erased in new 39// version of the script) it remains unchanged, but the code that could 40// create a new instance of this function goes away. An old version of script 41// is created to back up this obsolete function. 42// All unchanged functions have their positions updated accordingly. 43// 44// LiveEdit namespace is declared inside a single function constructor. 45Debug.LiveEdit = new function() { 46 47 // Forward declaration for minifier. 48 var FunctionStatus; 49 50 // Applies the change to the script. 51 // The change is in form of list of chunks encoded in a single array as 52 // a series of triplets (pos1_start, pos1_end, pos2_end) 53 function ApplyPatchMultiChunk(script, diff_array, new_source, preview_only, 54 change_log) { 55 56 var old_source = script.source; 57 58 // Gather compile information about old version of script. 59 var old_compile_info = GatherCompileInfo(old_source, script); 60 61 // Build tree structures for old and new versions of the script. 62 var root_old_node = BuildCodeInfoTree(old_compile_info); 63 64 var pos_translator = new PosTranslator(diff_array); 65 66 // Analyze changes. 67 MarkChangedFunctions(root_old_node, pos_translator.GetChunks()); 68 69 // Find all SharedFunctionInfo's that were compiled from this script. 70 FindLiveSharedInfos(root_old_node, script); 71 72 // Gather compile information about new version of script. 73 var new_compile_info; 74 try { 75 new_compile_info = GatherCompileInfo(new_source, script); 76 } catch (e) { 77 throw new Failure("Failed to compile new version of script: " + e); 78 } 79 var root_new_node = BuildCodeInfoTree(new_compile_info); 80 81 // Link recompiled script data with other data. 82 FindCorrespondingFunctions(root_old_node, root_new_node); 83 84 // Prepare to-do lists. 85 var replace_code_list = new Array(); 86 var link_to_old_script_list = new Array(); 87 var link_to_original_script_list = new Array(); 88 var update_positions_list = new Array(); 89 90 function HarvestTodo(old_node) { 91 function CollectDamaged(node) { 92 link_to_old_script_list.push(node); 93 for (var i = 0; i < node.children.length; i++) { 94 CollectDamaged(node.children[i]); 95 } 96 } 97 98 // Recursively collects all newly compiled functions that are going into 99 // business and should have link to the actual script updated. 100 function CollectNew(node_list) { 101 for (var i = 0; i < node_list.length; i++) { 102 link_to_original_script_list.push(node_list[i]); 103 CollectNew(node_list[i].children); 104 } 105 } 106 107 if (old_node.status == FunctionStatus.DAMAGED) { 108 CollectDamaged(old_node); 109 return; 110 } 111 if (old_node.status == FunctionStatus.UNCHANGED) { 112 update_positions_list.push(old_node); 113 } else if (old_node.status == FunctionStatus.SOURCE_CHANGED) { 114 update_positions_list.push(old_node); 115 } else if (old_node.status == FunctionStatus.CHANGED) { 116 replace_code_list.push(old_node); 117 CollectNew(old_node.unmatched_new_nodes); 118 } 119 for (var i = 0; i < old_node.children.length; i++) { 120 HarvestTodo(old_node.children[i]); 121 } 122 } 123 124 var preview_description = { 125 change_tree: DescribeChangeTree(root_old_node), 126 textual_diff: { 127 old_len: old_source.length, 128 new_len: new_source.length, 129 chunks: diff_array 130 }, 131 updated: false 132 }; 133 134 if (preview_only) { 135 return preview_description; 136 } 137 138 HarvestTodo(root_old_node); 139 140 // Collect shared infos for functions whose code need to be patched. 141 var replaced_function_infos = new Array(); 142 for (var i = 0; i < replace_code_list.length; i++) { 143 var live_shared_function_infos = 144 replace_code_list[i].live_shared_function_infos; 145 146 if (live_shared_function_infos) { 147 for (var j = 0; j < live_shared_function_infos.length; j++) { 148 replaced_function_infos.push(live_shared_function_infos[j]); 149 } 150 } 151 } 152 153 // We haven't changed anything before this line yet. 154 // Committing all changes. 155 156 // Check that function being patched is not currently on stack or drop them. 157 var dropped_functions_number = 158 CheckStackActivations(replaced_function_infos, change_log); 159 160 preview_description.stack_modified = dropped_functions_number != 0; 161 162 // Start with breakpoints. Convert their line/column positions and 163 // temporary remove. 164 var break_points_restorer = TemporaryRemoveBreakPoints(script, change_log); 165 166 var old_script; 167 168 // Create an old script only if there are function that should be linked 169 // to old version. 170 if (link_to_old_script_list.length == 0) { 171 %LiveEditReplaceScript(script, new_source, null); 172 old_script = void 0; 173 } else { 174 var old_script_name = CreateNameForOldScript(script); 175 176 // Update the script text and create a new script representing an old 177 // version of the script. 178 old_script = %LiveEditReplaceScript(script, new_source, 179 old_script_name); 180 181 var link_to_old_script_report = new Array(); 182 change_log.push( { linked_to_old_script: link_to_old_script_report } ); 183 184 // We need to link to old script all former nested functions. 185 for (var i = 0; i < link_to_old_script_list.length; i++) { 186 LinkToOldScript(link_to_old_script_list[i], old_script, 187 link_to_old_script_report); 188 } 189 190 preview_description.created_script_name = old_script_name; 191 } 192 193 // Link to an actual script all the functions that we are going to use. 194 for (var i = 0; i < link_to_original_script_list.length; i++) { 195 %LiveEditFunctionSetScript( 196 link_to_original_script_list[i].info.shared_function_info, script); 197 } 198 199 for (var i = 0; i < replace_code_list.length; i++) { 200 PatchFunctionCode(replace_code_list[i], change_log); 201 } 202 203 var position_patch_report = new Array(); 204 change_log.push( {position_patched: position_patch_report} ); 205 206 for (var i = 0; i < update_positions_list.length; i++) { 207 // TODO(LiveEdit): take into account wether it's source_changed or 208 // unchanged and whether positions changed at all. 209 PatchPositions(update_positions_list[i], diff_array, 210 position_patch_report); 211 212 if (update_positions_list[i].live_shared_function_infos) { 213 update_positions_list[i].live_shared_function_infos. 214 forEach(function (info) { 215 %LiveEditFunctionSourceUpdated(info.raw_array); 216 }); 217 } 218 } 219 220 break_points_restorer(pos_translator, old_script); 221 222 preview_description.updated = true; 223 return preview_description; 224 } 225 // Function is public. 226 this.ApplyPatchMultiChunk = ApplyPatchMultiChunk; 227 228 229 // Fully compiles source string as a script. Returns Array of 230 // FunctionCompileInfo -- a descriptions of all functions of the script. 231 // Elements of array are ordered by start positions of functions (from top 232 // to bottom) in the source. Fields outer_index and next_sibling_index help 233 // to navigate the nesting structure of functions. 234 // 235 // All functions get compiled linked to script provided as parameter script. 236 // TODO(LiveEdit): consider not using actual scripts as script, because 237 // we have to manually erase all links right after compile. 238 function GatherCompileInfo(source, script) { 239 // Get function info, elements are partially sorted (it is a tree of 240 // nested functions serialized as parent followed by serialized children. 241 var raw_compile_info = %LiveEditGatherCompileInfo(script, source); 242 243 // Sort function infos by start position field. 244 var compile_info = new Array(); 245 var old_index_map = new Array(); 246 for (var i = 0; i < raw_compile_info.length; i++) { 247 var info = new FunctionCompileInfo(raw_compile_info[i]); 248 // Remove all links to the actual script. Breakpoints system and 249 // LiveEdit itself believe that any function in heap that points to a 250 // particular script is a regular function. 251 // For some functions we will restore this link later. 252 %LiveEditFunctionSetScript(info.shared_function_info, void 0); 253 compile_info.push(info); 254 old_index_map.push(i); 255 } 256 257 for (var i = 0; i < compile_info.length; i++) { 258 var k = i; 259 for (var j = i + 1; j < compile_info.length; j++) { 260 if (compile_info[k].start_position > compile_info[j].start_position) { 261 k = j; 262 } 263 } 264 if (k != i) { 265 var temp_info = compile_info[k]; 266 var temp_index = old_index_map[k]; 267 compile_info[k] = compile_info[i]; 268 old_index_map[k] = old_index_map[i]; 269 compile_info[i] = temp_info; 270 old_index_map[i] = temp_index; 271 } 272 } 273 274 // After sorting update outer_inder field using old_index_map. Also 275 // set next_sibling_index field. 276 var current_index = 0; 277 278 // The recursive function, that goes over all children of a particular 279 // node (i.e. function info). 280 function ResetIndexes(new_parent_index, old_parent_index) { 281 var previous_sibling = -1; 282 while (current_index < compile_info.length && 283 compile_info[current_index].outer_index == old_parent_index) { 284 var saved_index = current_index; 285 compile_info[saved_index].outer_index = new_parent_index; 286 if (previous_sibling != -1) { 287 compile_info[previous_sibling].next_sibling_index = saved_index; 288 } 289 previous_sibling = saved_index; 290 current_index++; 291 ResetIndexes(saved_index, old_index_map[saved_index]); 292 } 293 if (previous_sibling != -1) { 294 compile_info[previous_sibling].next_sibling_index = -1; 295 } 296 } 297 298 ResetIndexes(-1, -1); 299 Assert(current_index == compile_info.length); 300 301 return compile_info; 302 } 303 304 305 // Replaces function's Code. 306 function PatchFunctionCode(old_node, change_log) { 307 var new_info = old_node.corresponding_node.info; 308 if (old_node.live_shared_function_infos) { 309 old_node.live_shared_function_infos.forEach(function (old_info) { 310 %LiveEditReplaceFunctionCode(new_info.raw_array, 311 old_info.raw_array); 312 313 // The function got a new code. However, this new code brings all new 314 // instances of SharedFunctionInfo for nested functions. However, 315 // we want the original instances to be used wherever possible. 316 // (This is because old instances and new instances will be both 317 // linked to a script and breakpoints subsystem does not really 318 // expects this; neither does LiveEdit subsystem on next call). 319 for (var i = 0; i < old_node.children.length; i++) { 320 if (old_node.children[i].corresponding_node) { 321 var corresponding_child_info = 322 old_node.children[i].corresponding_node.info. 323 shared_function_info; 324 325 if (old_node.children[i].live_shared_function_infos) { 326 old_node.children[i].live_shared_function_infos. 327 forEach(function (old_child_info) { 328 %LiveEditReplaceRefToNestedFunction( 329 old_info.info, 330 corresponding_child_info, 331 old_child_info.info); 332 }); 333 } 334 } 335 } 336 }); 337 338 change_log.push( {function_patched: new_info.function_name} ); 339 } else { 340 change_log.push( {function_patched: new_info.function_name, 341 function_info_not_found: true} ); 342 } 343 } 344 345 346 // Makes a function associated with another instance of a script (the 347 // one representing its old version). This way the function still 348 // may access its own text. 349 function LinkToOldScript(old_info_node, old_script, report_array) { 350 if (old_info_node.live_shared_function_infos) { 351 old_info_node.live_shared_function_infos. 352 forEach(function (info) { 353 %LiveEditFunctionSetScript(info.info, old_script); 354 }); 355 356 report_array.push( { name: old_info_node.info.function_name } ); 357 } else { 358 report_array.push( 359 { name: old_info_node.info.function_name, not_found: true } ); 360 } 361 } 362 363 364 // Returns function that restores breakpoints. 365 function TemporaryRemoveBreakPoints(original_script, change_log) { 366 var script_break_points = GetScriptBreakPoints(original_script); 367 368 var break_points_update_report = []; 369 change_log.push( { break_points_update: break_points_update_report } ); 370 371 var break_point_old_positions = []; 372 for (var i = 0; i < script_break_points.length; i++) { 373 var break_point = script_break_points[i]; 374 375 break_point.clear(); 376 377 // TODO(LiveEdit): be careful with resource offset here. 378 var break_point_position = Debug.findScriptSourcePosition(original_script, 379 break_point.line(), break_point.column()); 380 381 var old_position_description = { 382 position: break_point_position, 383 line: break_point.line(), 384 column: break_point.column() 385 }; 386 break_point_old_positions.push(old_position_description); 387 } 388 389 390 // Restores breakpoints and creates their copies in the "old" copy of 391 // the script. 392 return function (pos_translator, old_script_copy_opt) { 393 // Update breakpoints (change positions and restore them in old version 394 // of script. 395 for (var i = 0; i < script_break_points.length; i++) { 396 var break_point = script_break_points[i]; 397 if (old_script_copy_opt) { 398 var clone = break_point.cloneForOtherScript(old_script_copy_opt); 399 clone.set(old_script_copy_opt); 400 401 break_points_update_report.push( { 402 type: "copied_to_old", 403 id: break_point.number(), 404 new_id: clone.number(), 405 positions: break_point_old_positions[i] 406 } ); 407 } 408 409 var updated_position = pos_translator.Translate( 410 break_point_old_positions[i].position, 411 PosTranslator.ShiftWithTopInsideChunkHandler); 412 413 var new_location = 414 original_script.locationFromPosition(updated_position, false); 415 416 break_point.update_positions(new_location.line, new_location.column); 417 418 var new_position_description = { 419 position: updated_position, 420 line: new_location.line, 421 column: new_location.column 422 }; 423 424 break_point.set(original_script); 425 426 break_points_update_report.push( { type: "position_changed", 427 id: break_point.number(), 428 old_positions: break_point_old_positions[i], 429 new_positions: new_position_description 430 } ); 431 } 432 }; 433 } 434 435 436 function Assert(condition, message) { 437 if (!condition) { 438 if (message) { 439 throw "Assert " + message; 440 } else { 441 throw "Assert"; 442 } 443 } 444 } 445 446 function DiffChunk(pos1, pos2, len1, len2) { 447 this.pos1 = pos1; 448 this.pos2 = pos2; 449 this.len1 = len1; 450 this.len2 = len2; 451 } 452 453 function PosTranslator(diff_array) { 454 var chunks = new Array(); 455 var current_diff = 0; 456 for (var i = 0; i < diff_array.length; i += 3) { 457 var pos1_begin = diff_array[i]; 458 var pos2_begin = pos1_begin + current_diff; 459 var pos1_end = diff_array[i + 1]; 460 var pos2_end = diff_array[i + 2]; 461 chunks.push(new DiffChunk(pos1_begin, pos2_begin, pos1_end - pos1_begin, 462 pos2_end - pos2_begin)); 463 current_diff = pos2_end - pos1_end; 464 } 465 this.chunks = chunks; 466 } 467 PosTranslator.prototype.GetChunks = function() { 468 return this.chunks; 469 }; 470 471 PosTranslator.prototype.Translate = function(pos, inside_chunk_handler) { 472 var array = this.chunks; 473 if (array.length == 0 || pos < array[0].pos1) { 474 return pos; 475 } 476 var chunk_index1 = 0; 477 var chunk_index2 = array.length - 1; 478 479 while (chunk_index1 < chunk_index2) { 480 var middle_index = Math.floor((chunk_index1 + chunk_index2) / 2); 481 if (pos < array[middle_index + 1].pos1) { 482 chunk_index2 = middle_index; 483 } else { 484 chunk_index1 = middle_index + 1; 485 } 486 } 487 var chunk = array[chunk_index1]; 488 if (pos >= chunk.pos1 + chunk.len1) { 489 return pos + chunk.pos2 + chunk.len2 - chunk.pos1 - chunk.len1; 490 } 491 492 if (!inside_chunk_handler) { 493 inside_chunk_handler = PosTranslator.DefaultInsideChunkHandler; 494 } 495 return inside_chunk_handler(pos, chunk); 496 }; 497 498 PosTranslator.DefaultInsideChunkHandler = function(pos, diff_chunk) { 499 Assert(false, "Cannot translate position in changed area"); 500 }; 501 502 PosTranslator.ShiftWithTopInsideChunkHandler = 503 function(pos, diff_chunk) { 504 // We carelessly do not check whether we stay inside the chunk after 505 // translation. 506 return pos - diff_chunk.pos1 + diff_chunk.pos2; 507 }; 508 509 var FunctionStatus = { 510 // No change to function or its inner functions; however its positions 511 // in script may have been shifted. 512 UNCHANGED: "unchanged", 513 // The code of a function remains unchanged, but something happened inside 514 // some inner functions. 515 SOURCE_CHANGED: "source changed", 516 // The code of a function is changed or some nested function cannot be 517 // properly patched so this function must be recompiled. 518 CHANGED: "changed", 519 // Function is changed but cannot be patched. 520 DAMAGED: "damaged" 521 }; 522 523 function CodeInfoTreeNode(code_info, children, array_index) { 524 this.info = code_info; 525 this.children = children; 526 // an index in array of compile_info 527 this.array_index = array_index; 528 this.parent = void 0; 529 530 this.status = FunctionStatus.UNCHANGED; 531 // Status explanation is used for debugging purposes and will be shown 532 // in user UI if some explanations are needed. 533 this.status_explanation = void 0; 534 this.new_start_pos = void 0; 535 this.new_end_pos = void 0; 536 this.corresponding_node = void 0; 537 this.unmatched_new_nodes = void 0; 538 539 // 'Textual' correspondence/matching is weaker than 'pure' 540 // correspondence/matching. We need 'textual' level for visual presentation 541 // in UI, we use 'pure' level for actual code manipulation. 542 // Sometimes only function body is changed (functions in old and new script 543 // textually correspond), but we cannot patch the code, so we see them 544 // as an old function deleted and new function created. 545 this.textual_corresponding_node = void 0; 546 this.textually_unmatched_new_nodes = void 0; 547 548 this.live_shared_function_infos = void 0; 549 } 550 551 // From array of function infos that is implicitly a tree creates 552 // an actual tree of functions in script. 553 function BuildCodeInfoTree(code_info_array) { 554 // Throughtout all function we iterate over input array. 555 var index = 0; 556 557 // Recursive function that builds a branch of tree. 558 function BuildNode() { 559 var my_index = index; 560 index++; 561 var child_array = new Array(); 562 while (index < code_info_array.length && 563 code_info_array[index].outer_index == my_index) { 564 child_array.push(BuildNode()); 565 } 566 var node = new CodeInfoTreeNode(code_info_array[my_index], child_array, 567 my_index); 568 for (var i = 0; i < child_array.length; i++) { 569 child_array[i].parent = node; 570 } 571 return node; 572 } 573 574 var root = BuildNode(); 575 Assert(index == code_info_array.length); 576 return root; 577 } 578 579 // Applies a list of the textual diff chunks onto the tree of functions. 580 // Determines status of each function (from unchanged to damaged). However 581 // children of unchanged functions are ignored. 582 function MarkChangedFunctions(code_info_tree, chunks) { 583 584 // A convenient iterator over diff chunks that also translates 585 // positions from old to new in a current non-changed part of script. 586 var chunk_it = new function() { 587 var chunk_index = 0; 588 var pos_diff = 0; 589 this.current = function() { return chunks[chunk_index]; }; 590 this.next = function() { 591 var chunk = chunks[chunk_index]; 592 pos_diff = chunk.pos2 + chunk.len2 - (chunk.pos1 + chunk.len1); 593 chunk_index++; 594 }; 595 this.done = function() { return chunk_index >= chunks.length; }; 596 this.TranslatePos = function(pos) { return pos + pos_diff; }; 597 }; 598 599 // A recursive function that processes internals of a function and all its 600 // inner functions. Iterator chunk_it initially points to a chunk that is 601 // below function start. 602 function ProcessInternals(info_node) { 603 info_node.new_start_pos = chunk_it.TranslatePos( 604 info_node.info.start_position); 605 var child_index = 0; 606 var code_changed = false; 607 var source_changed = false; 608 // Simultaneously iterates over child functions and over chunks. 609 while (!chunk_it.done() && 610 chunk_it.current().pos1 < info_node.info.end_position) { 611 if (child_index < info_node.children.length) { 612 var child = info_node.children[child_index]; 613 614 if (child.info.end_position <= chunk_it.current().pos1) { 615 ProcessUnchangedChild(child); 616 child_index++; 617 continue; 618 } else if (child.info.start_position >= 619 chunk_it.current().pos1 + chunk_it.current().len1) { 620 code_changed = true; 621 chunk_it.next(); 622 continue; 623 } else if (child.info.start_position <= chunk_it.current().pos1 && 624 child.info.end_position >= chunk_it.current().pos1 + 625 chunk_it.current().len1) { 626 ProcessInternals(child); 627 source_changed = source_changed || 628 ( child.status != FunctionStatus.UNCHANGED ); 629 code_changed = code_changed || 630 ( child.status == FunctionStatus.DAMAGED ); 631 child_index++; 632 continue; 633 } else { 634 code_changed = true; 635 child.status = FunctionStatus.DAMAGED; 636 child.status_explanation = 637 "Text diff overlaps with function boundary"; 638 child_index++; 639 continue; 640 } 641 } else { 642 if (chunk_it.current().pos1 + chunk_it.current().len1 <= 643 info_node.info.end_position) { 644 info_node.status = FunctionStatus.CHANGED; 645 chunk_it.next(); 646 continue; 647 } else { 648 info_node.status = FunctionStatus.DAMAGED; 649 info_node.status_explanation = 650 "Text diff overlaps with function boundary"; 651 return; 652 } 653 } 654 Assert("Unreachable", false); 655 } 656 while (child_index < info_node.children.length) { 657 var child = info_node.children[child_index]; 658 ProcessUnchangedChild(child); 659 child_index++; 660 } 661 if (code_changed) { 662 info_node.status = FunctionStatus.CHANGED; 663 } else if (source_changed) { 664 info_node.status = FunctionStatus.SOURCE_CHANGED; 665 } 666 info_node.new_end_pos = 667 chunk_it.TranslatePos(info_node.info.end_position); 668 } 669 670 function ProcessUnchangedChild(node) { 671 node.new_start_pos = chunk_it.TranslatePos(node.info.start_position); 672 node.new_end_pos = chunk_it.TranslatePos(node.info.end_position); 673 } 674 675 ProcessInternals(code_info_tree); 676 } 677 678 // For ecah old function (if it is not damaged) tries to find a corresponding 679 // function in new script. Typically it should succeed (non-damaged functions 680 // by definition may only have changes inside their bodies). However there are 681 // reasons for corresponence not to be found; function with unmodified text 682 // in new script may become enclosed into other function; the innocent change 683 // inside function body may in fact be something like "} function B() {" that 684 // splits a function into 2 functions. 685 function FindCorrespondingFunctions(old_code_tree, new_code_tree) { 686 687 // A recursive function that tries to find a correspondence for all 688 // child functions and for their inner functions. 689 function ProcessChildren(old_node, new_node) { 690 var old_children = old_node.children; 691 var new_children = new_node.children; 692 693 var unmatched_new_nodes_list = []; 694 var textually_unmatched_new_nodes_list = []; 695 696 var old_index = 0; 697 var new_index = 0; 698 while (old_index < old_children.length) { 699 if (old_children[old_index].status == FunctionStatus.DAMAGED) { 700 old_index++; 701 } else if (new_index < new_children.length) { 702 if (new_children[new_index].info.start_position < 703 old_children[old_index].new_start_pos) { 704 unmatched_new_nodes_list.push(new_children[new_index]); 705 textually_unmatched_new_nodes_list.push(new_children[new_index]); 706 new_index++; 707 } else if (new_children[new_index].info.start_position == 708 old_children[old_index].new_start_pos) { 709 if (new_children[new_index].info.end_position == 710 old_children[old_index].new_end_pos) { 711 old_children[old_index].corresponding_node = 712 new_children[new_index]; 713 old_children[old_index].textual_corresponding_node = 714 new_children[new_index]; 715 if (old_children[old_index].status != FunctionStatus.UNCHANGED) { 716 ProcessChildren(old_children[old_index], 717 new_children[new_index]); 718 if (old_children[old_index].status == FunctionStatus.DAMAGED) { 719 unmatched_new_nodes_list.push( 720 old_children[old_index].corresponding_node); 721 old_children[old_index].corresponding_node = void 0; 722 old_node.status = FunctionStatus.CHANGED; 723 } 724 } 725 } else { 726 old_children[old_index].status = FunctionStatus.DAMAGED; 727 old_children[old_index].status_explanation = 728 "No corresponding function in new script found"; 729 old_node.status = FunctionStatus.CHANGED; 730 unmatched_new_nodes_list.push(new_children[new_index]); 731 textually_unmatched_new_nodes_list.push(new_children[new_index]); 732 } 733 new_index++; 734 old_index++; 735 } else { 736 old_children[old_index].status = FunctionStatus.DAMAGED; 737 old_children[old_index].status_explanation = 738 "No corresponding function in new script found"; 739 old_node.status = FunctionStatus.CHANGED; 740 old_index++; 741 } 742 } else { 743 old_children[old_index].status = FunctionStatus.DAMAGED; 744 old_children[old_index].status_explanation = 745 "No corresponding function in new script found"; 746 old_node.status = FunctionStatus.CHANGED; 747 old_index++; 748 } 749 } 750 751 while (new_index < new_children.length) { 752 unmatched_new_nodes_list.push(new_children[new_index]); 753 textually_unmatched_new_nodes_list.push(new_children[new_index]); 754 new_index++; 755 } 756 757 if (old_node.status == FunctionStatus.CHANGED) { 758 var why_wrong_expectations = 759 WhyFunctionExpectationsDiffer(old_node.info, new_node.info); 760 if (why_wrong_expectations) { 761 old_node.status = FunctionStatus.DAMAGED; 762 old_node.status_explanation = why_wrong_expectations; 763 } 764 } 765 old_node.unmatched_new_nodes = unmatched_new_nodes_list; 766 old_node.textually_unmatched_new_nodes = 767 textually_unmatched_new_nodes_list; 768 } 769 770 ProcessChildren(old_code_tree, new_code_tree); 771 772 old_code_tree.corresponding_node = new_code_tree; 773 old_code_tree.textual_corresponding_node = new_code_tree; 774 775 Assert(old_code_tree.status != FunctionStatus.DAMAGED, 776 "Script became damaged"); 777 } 778 779 function FindLiveSharedInfos(old_code_tree, script) { 780 var shared_raw_list = %LiveEditFindSharedFunctionInfosForScript(script); 781 782 var shared_infos = new Array(); 783 784 for (var i = 0; i < shared_raw_list.length; i++) { 785 shared_infos.push(new SharedInfoWrapper(shared_raw_list[i])); 786 } 787 788 // Finds all SharedFunctionInfos that corresponds to compile info 789 // in old version of the script. 790 function FindFunctionInfos(compile_info) { 791 var wrappers = []; 792 793 for (var i = 0; i < shared_infos.length; i++) { 794 var wrapper = shared_infos[i]; 795 if (wrapper.start_position == compile_info.start_position && 796 wrapper.end_position == compile_info.end_position) { 797 wrappers.push(wrapper); 798 } 799 } 800 801 if (wrappers.length > 0) { 802 return wrappers; 803 } 804 } 805 806 function TraverseTree(node) { 807 node.live_shared_function_infos = FindFunctionInfos(node.info); 808 809 for (var i = 0; i < node.children.length; i++) { 810 TraverseTree(node.children[i]); 811 } 812 } 813 814 TraverseTree(old_code_tree); 815 } 816 817 818 // An object describing function compilation details. Its index fields 819 // apply to indexes inside array that stores these objects. 820 function FunctionCompileInfo(raw_array) { 821 this.function_name = raw_array[0]; 822 this.start_position = raw_array[1]; 823 this.end_position = raw_array[2]; 824 this.param_num = raw_array[3]; 825 this.code = raw_array[4]; 826 this.code_scope_info = raw_array[5]; 827 this.scope_info = raw_array[6]; 828 this.outer_index = raw_array[7]; 829 this.shared_function_info = raw_array[8]; 830 this.next_sibling_index = null; 831 this.raw_array = raw_array; 832 } 833 834 function SharedInfoWrapper(raw_array) { 835 this.function_name = raw_array[0]; 836 this.start_position = raw_array[1]; 837 this.end_position = raw_array[2]; 838 this.info = raw_array[3]; 839 this.raw_array = raw_array; 840 } 841 842 // Changes positions (including all statments) in function. 843 function PatchPositions(old_info_node, diff_array, report_array) { 844 if (old_info_node.live_shared_function_infos) { 845 old_info_node.live_shared_function_infos.forEach(function (info) { 846 %LiveEditPatchFunctionPositions(info.raw_array, 847 diff_array); 848 }); 849 850 report_array.push( { name: old_info_node.info.function_name } ); 851 } else { 852 // TODO(LiveEdit): function is not compiled yet or is already collected. 853 report_array.push( 854 { name: old_info_node.info.function_name, info_not_found: true } ); 855 } 856 } 857 858 // Adds a suffix to script name to mark that it is old version. 859 function CreateNameForOldScript(script) { 860 // TODO(635): try better than this; support several changes. 861 return script.name + " (old)"; 862 } 863 864 // Compares a function interface old and new version, whether it 865 // changed or not. Returns explanation if they differ. 866 function WhyFunctionExpectationsDiffer(function_info1, function_info2) { 867 // Check that function has the same number of parameters (there may exist 868 // an adapter, that won't survive function parameter number change). 869 if (function_info1.param_num != function_info2.param_num) { 870 return "Changed parameter number: " + function_info1.param_num + 871 " and " + function_info2.param_num; 872 } 873 var scope_info1 = function_info1.scope_info; 874 var scope_info2 = function_info2.scope_info; 875 876 var scope_info1_text; 877 var scope_info2_text; 878 879 if (scope_info1) { 880 scope_info1_text = scope_info1.toString(); 881 } else { 882 scope_info1_text = ""; 883 } 884 if (scope_info2) { 885 scope_info2_text = scope_info2.toString(); 886 } else { 887 scope_info2_text = ""; 888 } 889 890 if (scope_info1_text != scope_info2_text) { 891 return "Incompatible variable maps: [" + scope_info1_text + 892 "] and [" + scope_info2_text + "]"; 893 } 894 // No differences. Return undefined. 895 return; 896 } 897 898 // Minifier forward declaration. 899 var FunctionPatchabilityStatus; 900 901 // For array of wrapped shared function infos checks that none of them 902 // have activations on stack (of any thread). Throws a Failure exception 903 // if this proves to be false. 904 function CheckStackActivations(shared_wrapper_list, change_log) { 905 var shared_list = new Array(); 906 for (var i = 0; i < shared_wrapper_list.length; i++) { 907 shared_list[i] = shared_wrapper_list[i].info; 908 } 909 var result = %LiveEditCheckAndDropActivations(shared_list, true); 910 if (result[shared_list.length]) { 911 // Extra array element may contain error message. 912 throw new Failure(result[shared_list.length]); 913 } 914 915 var problems = new Array(); 916 var dropped = new Array(); 917 for (var i = 0; i < shared_list.length; i++) { 918 var shared = shared_wrapper_list[i]; 919 if (result[i] == FunctionPatchabilityStatus.REPLACED_ON_ACTIVE_STACK) { 920 dropped.push({ name: shared.function_name } ); 921 } else if (result[i] != FunctionPatchabilityStatus.AVAILABLE_FOR_PATCH) { 922 var description = { 923 name: shared.function_name, 924 start_pos: shared.start_position, 925 end_pos: shared.end_position, 926 replace_problem: 927 FunctionPatchabilityStatus.SymbolName(result[i]) 928 }; 929 problems.push(description); 930 } 931 } 932 if (dropped.length > 0) { 933 change_log.push({ dropped_from_stack: dropped }); 934 } 935 if (problems.length > 0) { 936 change_log.push( { functions_on_stack: problems } ); 937 throw new Failure("Blocked by functions on stack"); 938 } 939 940 return dropped.length; 941 } 942 943 // A copy of the FunctionPatchabilityStatus enum from liveedit.h 944 var FunctionPatchabilityStatus = { 945 AVAILABLE_FOR_PATCH: 1, 946 BLOCKED_ON_ACTIVE_STACK: 2, 947 BLOCKED_ON_OTHER_STACK: 3, 948 BLOCKED_UNDER_NATIVE_CODE: 4, 949 REPLACED_ON_ACTIVE_STACK: 5 950 }; 951 952 FunctionPatchabilityStatus.SymbolName = function(code) { 953 var enumeration = FunctionPatchabilityStatus; 954 for (name in enumeration) { 955 if (enumeration[name] == code) { 956 return name; 957 } 958 } 959 }; 960 961 962 // A logical failure in liveedit process. This means that change_log 963 // is valid and consistent description of what happened. 964 function Failure(message) { 965 this.message = message; 966 } 967 // Function (constructor) is public. 968 this.Failure = Failure; 969 970 Failure.prototype.toString = function() { 971 return "LiveEdit Failure: " + this.message; 972 }; 973 974 // A testing entry. 975 function GetPcFromSourcePos(func, source_pos) { 976 return %GetFunctionCodePositionFromSource(func, source_pos); 977 } 978 // Function is public. 979 this.GetPcFromSourcePos = GetPcFromSourcePos; 980 981 // LiveEdit main entry point: changes a script text to a new string. 982 function SetScriptSource(script, new_source, preview_only, change_log) { 983 var old_source = script.source; 984 var diff = CompareStrings(old_source, new_source); 985 return ApplyPatchMultiChunk(script, diff, new_source, preview_only, 986 change_log); 987 } 988 // Function is public. 989 this.SetScriptSource = SetScriptSource; 990 991 function CompareStrings(s1, s2) { 992 return %LiveEditCompareStrings(s1, s2); 993 } 994 995 // Applies the change to the script. 996 // The change is always a substring (change_pos, change_pos + change_len) 997 // being replaced with a completely different string new_str. 998 // This API is a legacy and is obsolete. 999 // 1000 // @param {Script} script that is being changed 1001 // @param {Array} change_log a list that collects engineer-readable 1002 // description of what happened. 1003 function ApplySingleChunkPatch(script, change_pos, change_len, new_str, 1004 change_log) { 1005 var old_source = script.source; 1006 1007 // Prepare new source string. 1008 var new_source = old_source.substring(0, change_pos) + 1009 new_str + old_source.substring(change_pos + change_len); 1010 1011 return ApplyPatchMultiChunk(script, 1012 [ change_pos, change_pos + change_len, change_pos + new_str.length], 1013 new_source, false, change_log); 1014 } 1015 1016 // Creates JSON description for a change tree. 1017 function DescribeChangeTree(old_code_tree) { 1018 1019 function ProcessOldNode(node) { 1020 var child_infos = []; 1021 for (var i = 0; i < node.children.length; i++) { 1022 var child = node.children[i]; 1023 if (child.status != FunctionStatus.UNCHANGED) { 1024 child_infos.push(ProcessOldNode(child)); 1025 } 1026 } 1027 var new_child_infos = []; 1028 if (node.textually_unmatched_new_nodes) { 1029 for (var i = 0; i < node.textually_unmatched_new_nodes.length; i++) { 1030 var child = node.textually_unmatched_new_nodes[i]; 1031 new_child_infos.push(ProcessNewNode(child)); 1032 } 1033 } 1034 var res = { 1035 name: node.info.function_name, 1036 positions: DescribePositions(node), 1037 status: node.status, 1038 children: child_infos, 1039 new_children: new_child_infos 1040 }; 1041 if (node.status_explanation) { 1042 res.status_explanation = node.status_explanation; 1043 } 1044 if (node.textual_corresponding_node) { 1045 res.new_positions = DescribePositions(node.textual_corresponding_node); 1046 } 1047 return res; 1048 } 1049 1050 function ProcessNewNode(node) { 1051 var child_infos = []; 1052 // Do not list ancestors. 1053 if (false) { 1054 for (var i = 0; i < node.children.length; i++) { 1055 child_infos.push(ProcessNewNode(node.children[i])); 1056 } 1057 } 1058 var res = { 1059 name: node.info.function_name, 1060 positions: DescribePositions(node), 1061 children: child_infos, 1062 }; 1063 return res; 1064 } 1065 1066 function DescribePositions(node) { 1067 return { 1068 start_position: node.info.start_position, 1069 end_position: node.info.end_position 1070 }; 1071 } 1072 1073 return ProcessOldNode(old_code_tree); 1074 } 1075 1076 1077 // Functions are public for tests. 1078 this.TestApi = { 1079 PosTranslator: PosTranslator, 1080 CompareStrings: CompareStrings, 1081 ApplySingleChunkPatch: ApplySingleChunkPatch 1082 }; 1083}; 1084