Automated identification of code dependency

Abstract

A first code update is received having a first code change. It is determined whether the first code change of the first code update can be implemented on a first reference code version on which at least one code change of a second code update has been undone.

What is claimed is: 
     
       1. One or more non-transitory computer-readable storage media storing computer-executable instructions for causing a computing system to perform processing to identify a code relationship between code versions, the processing comprising:
 receiving a first code update to a first code version, the first code update comprising at least a first code change, the at least a first code change being specified by (1) operations to locate a code segment to be changed; and one or more of (2) operations to modify the located code segment or code proximate the located code segment; (3) operations to remove code from the located code segment or code proximate the located code segment; or (4) operations to add code to the located code segment or code proximate the located code segment; 
 determining at least one software object changed by the first code update; 
 identifying a second code update of a plurality of code updates that modifies the at least one software object; 
 generating a second, code version, the second code version being a reference code version, by undoing at least the second code update, the second code update having been previously applied to the first code version, the second code update comprising at least a second code change:
 the at least a second code change being specified by (1) operations to locate a code segment to be changed; and one or more of (2) operations to modify the located code segment or code proximate the located code segment; (3) operations to remove code from the located code segment or code proximate the located code segment; or (4) operations to add code to the located code segment or code proximate the located code segment; 
 wherein undoing the at least a second code change comprises one or more of (1) adding previously deleted code; (2) removing previously added code; or (3) reversing a previous code modification; and 
 
 determining whether the first code update can be implemented on the second version, the determining comprising attempting to apply the first code update to the second code version, and wherein it is determined that the first code update cannot be implemented on the second code version if the code segment to be changed cannot be located in the second code version. 
 
     
     
       2. The one or more non-transitory computer-readable storage media of  claim 1 , the processing further comprising:
 determining whether the at least a first change of the first code update can be implemented on a third code version comprising the at least second code change of the second code update. 
 
     
     
       3. The one or more non-transitory computer-readable storage media of  claim 2 , the processing further comprising:
 applying the at least a first code change of the first code update to the second code version to provide a fourth code version; and 
 determining whether the at least a second code change of the second code update can be applied to the fourth code version. 
 
     
     
       4. The one or more non-transitory computer-readable storage media of  claim 3 , the processing further comprising:
 identifying the first and second code updates as independent if the at least a first code change of the first code update can be implemented on the third code version and the at least a second code change of the second code update can be applied to the fourth code version. 
 
     
     
       5. The one or more non-transitory computer-readable storage media of  claim 3 , the processing further comprising:
 identifying the first and second code updates as potentially interfering if the at least a first code change of the first code update can be implemented on the third code version and the at least a second code change of the second code update cannot be applied to the fourth code version. 
 
     
     
       6. The one or more non-transitory computer-readable storage media of  claim 2 , the processing further comprising:
 identifying the first and second code updates as potentially interfering if the at least a first code change of the first code update cannot be implemented on the third code version and the at least a second code change of the second code update can be applied to the fourth code version. 
 
     
     
       7. The one or more non-transitory computer-readable storage media of  claim 2 , the processing further comprising:
 identifying the at least a first code change of the first code update as dependent on the at least a second code change of the second code update if the at least a first code change of the first code update cannot be implemented on the second code version. 
 
     
     
       8. The one or more non-transitory computer-readable storage media of  claim 1 , the processing further comprising:
 identifying the at least a first code change of the first code update as potentially interfering with the at least a second code change of the second code update if the at least a first code change of the first code update cannot be implemented on the second code version. 
 
     
     
       9. The one or more non-transitory computer-readable storage media of  claim 1 , wherein determining whether the first code update can be implemented on the second code version comprises determining whether a chain of code updates that include the at least a first code change of the first code update can be implemented on the second code version. 
     
     
       10. The one or more non-transitory computer-readable storage media of  claim 9 , wherein the update chain includes at least a third code change made by a third code update. 
     
     
       11. The one or more non-transitory computer-readable storage media of  claim 1 , the processing further comprising:
 generating the second code version by undoing the at least a second code change of the second code update. 
 
     
     
       12. The one or more non-transitory computer-readable storage media of  claim 11 , wherein the generating comprises interchanging insert and delete operations of the second code update. 
     
     
       13. The one or more non-transitory computer readable storage media of  claim 12 , wherein the generating further comprises identifying a code portion to be changed in a third code version using a context block. 
     
     
       14. The one or more non-transitory computer-readable storage media of  claim 1 , the processing further comprising:
 displaying to a user a dependency status of the first code update relative to the second code update. 
 
     
     
       15. The one or more non-transitory computer-readable storage media of  claim 1 , wherein the dependency status can be dependent, independent, or potentially interfering. 
     
     
       16. The one or more non-transitory computer-readable storage media of  claim 1 , the processing further comprising:
 receiving user input determining whether the first code update should be applied to the second code version and user input determining whether the second code update should be applied to the second code version. 
 
     
     
       17. A computing system that implements a code analysis system, the computing system comprising:
 memory; 
 one or more processing units coupled to the memory; and 
 one or more non-transitory computer readable storage media storing instructions that, when loaded into the memory, cause the one or more processing units to perform operations for:
 receiving a first code update having at least a first code change, the at least a first code change comprising information useable to locate a code segment to be changed and information specifying one or more of code to be added, deleted, or modified in or proximate the code segment to be located; 
 determining at least one software object changed by the first code update; 
 identifying a second code update of a plurality of code updates that modifies the at least one software object; 
 determining whether the first code update can be implemented on a first reference code version on which at least a second code change of the second code update has been undone, the second code update having been previously applied to the first code version and the at least a second code change comprising information useable to locate a code segment to be changed and information specifying one or more of code to be added, deleted, or modified in or proximate the code segment to be located, the determining comprising:
 undoing the at least a second code change by one or more of (1) adding previously deleted code; (2) removing previously added code; or (3) reversing a previous code modification; and 
 attempting to locate the code segment to be changed in the first code update, and wherein it is determined that the first code update cannot be implemented on the first reference code version if the code segment to be changed cannot be located; 
 
 determining whether an update chain comprising the first code update and a third code update having at least a third code change can be implemented on the first reference code version; 
 determining whether the update chain can be implemented on a second reference code version comprising the at least a second code change of the second code update; and 
 determining whether the at least a second code change of the second code update can be implemented on a third reference code version comprising code changes of the update chain. 
 
 
     
     
       18. The computing system of  claim 17 , the operations further comprising:
 displaying to a user a dependency status of the first code update relative to the second code update. 
 
     
     
       19. In a computing system comprising a memory and one or more processors, a method of determining potential code dependencies, the method comprising:
 receiving a first code update to a first code version; 
 determining at least one software object changed by the first code update, the first code update comprising at last a first code change, the at least a first code change being specified by (1) operations to locate a code segment to be changed in the at least one software object; and one or more of (2) operations to modify the located code segment or code proximate the located code segment; (3) operations to remove code from the located code segment or code proximate the located code segment; or (4) operations to add code to the located code segment or code proximate the located code segment; 
 determining a plurality of second code updates modifying the at least one software object, a given code update of the plurality of second code updates comprising at least a second code change specified by (1) operations to locate a code segment to be changed; and one or more of (2) operations to modify the located code segment or code proximate the located code segment; (3) operations to remove code from the located code segment or code proximate the located code segment; or (4) operations to add code to the located code segment or code proximate the located code segment; and 
 for each of the plurality of second code updates, determining whether an update chain comprising the first code update and at least one second code update of the plurality of second code updates can be implemented on a reference code version on which the at least a second code change of another second code update of the plurality of second code updates has been undone, the determining comprising attempting to apply code updates of the update chain on the reference code version, and wherein it is determined that an update of the update chain cannot be implemented on the reference code version if a respective code segment to be changed cannot be located in the reference code version using location identification information included in a respective code update of the update chain, wherein undoing the at least a second code change comprises one or more of (1) adding previously deleted code; (2) removing previously added code; or (3) reversing a previous code modification. 
 
     
     
       20. The method of  claim 19 , further comprising:
 displaying to a user dependency statuses of the first code update relative to the plurality of second code updates.