Granted Patent B2

US 12,705,161 · App. 19/316,759 · Granted Aug 11, 2026

Inventors: Henrik Plate (Valbonne, FR); Dimitrios Styliadis (San Jose, CA); Georgios Gousios (Delft, NL); Joseph Hejderup (Palo Alto, CA); Philip Hamer (Palo Alto, CA)

Assignee: Endor Labs Inc

G06F11/3604G06F11/3636

Abstract

Claims (143)

1 . A method comprising:

determining, by one or more processors, that project code in a development system calls a component in a third-party library, wherein the component is in a compiled form;

determining, by the one or more processors, that the component has been updated to create an updated component in the third-party library, wherein the updated component is in the compiled form;

performing, by the one or more processors, a type hierarchy comparison of:

a first type hierarchy associated with the component; and

a second type hierarchy associated with the updated component;

performing, by the one or more processors, a call graph comparison of:

a first call graph associated with the component; and

a second call graph associated with the updated component;

performing, by the one or more processors, a function comparison of:

a first set of functions called by the component; and

a second set of functions called by the updated component,

wherein the first set of functions and the second set of functions include directly called functions and transitively called functions;

performing, by the one or more processors, a field comparison of:

a first set of fields accessed by the component; and

a second set of fields accessed by the updated component,

wherein the first set of fields and the second set of fields include directly accessed fields and transitively accessed fields; and

determining, by the one or more processors and based at least in part on:

the type hierarchy comparison,

the call graph comparison,

the function comparison, and

the field comparison,

a set of breaking changes associated with the updated component, each breaking change in the set of breaking changes identifying changes to the updated component, relative to the component, that are determined to cause an incompatibility when the project code calls the updated component;

wherein the project code is modified to create modified project code that does not include a breaking change from the set of breaking changes.

2 . The method of claim 1 , further comprising:

determining a source compatibility between the component and the updated component;

determining a binary compatibility between the component and the updated component;

determining a behavioral compatibility between the component and the updated component; or

any combination thereof.

3 . The method of claim 2 , further comprising:

determining the source compatibility using a compiler;

determining the binary compatibility using a virtual machine;

determining the behavioral compatibility at runtime by determining whether the updated component exhibits a behavior that is different from a previous behavior of a previous version of the updated component without causing compilation or linkage errors; or

any combination thereof.

4 . The method of claim 1 , wherein performing the type hierarchy comparison comprises:

traversing the first type hierarchy;

traversing the second type hierarchy; and

identifying, based on traversing the first type hierarchy and the second type hierarchy, one or more types that inherit or implement at least one type that changed from the component to the updated component.

5 . The method of claim 1 , wherein performing the call graph comparison comprises:

traversing the first call graph;

traversing the second call graph; and

identifying, based on traversing the first call graph and the second call graph, at least one function, included in the updated component, that changed from the component to the updated component.

6 . The method of claim 1 , wherein performing the call graph comparison comprises:

traversing the first call graph;

traversing the second call graph; and

identifying at least one function, called by the updated component, that changed from the component to the updated component.

7 . The method of claim 1 , wherein performing the call graph comparison comprises:

traversing the first call graph;

traversing the second call graph; and

identifying at least one field, accessed by the updated component, that changed from the component to the updated component.

8 . A server comprising:

one or more processors; and

one or more non-transitory computer readable media storing instructions executable by the one or more processors to perform operations comprising:

determining that project code in a development system calls a component in a third-party library, wherein the component is in a compiled form;

determining that the component has been updated to create an updated component in the third-party library, wherein the updated component is in the compiled form;

performing a type hierarchy comparison of:

a first type hierarchy associated with the component; and

a second type hierarchy associated with the updated component;

performing a call graph comparison of:

a first call graph associated with the component; and

a second call graph associated with the updated component;

performing a function comparison of:

a first set of functions called by the component; and

a second set of functions called by the updated component,

wherein the first set of functions and the second set of functions include directly called functions and transitively called functions;

performing a field comparison of:

a first set of fields accessed by the component; and

a second set of fields accessed by the updated component,

wherein the first set of fields and the second set of fields include directly accessed fields and transitively accessed fields; and

determining, based at least in part on:

the type hierarchy comparison,

the call graph comparison,

the function comparison, and

the field comparison,

a set of breaking changes associated with the updated component, each breaking change in the set of breaking changes identifying changes to the updated component, relative to the component, that are determined to cause an incompatibility when the project code calls the updated component;

wherein the project code is modified to create modified project code that does not include a breaking change from the set of breaking changes.

9 . The server of claim 8 , wherein performing the call graph comparison comprises:

comparing a package call graph of the component and the updated component;

comparing a global call graph of the component and the updated component; or

any combination thereof.

10 . The server of claim 8 , wherein the incompatibility comprises:

a source code incompatibility;

a binary incompatibility;

a behavioral incompatibility; or

any combination thereof.

11 . The server of claim 8 , wherein the project code comprises:

a plurality of types that are explicitly defined and implicitly inherited; and

a plurality of relationships that are explicitly defined and implicitly inherited.

12 . The server of claim 8 , wherein performing the field comparison comprises:

determining changes, between the component and the updated component, to particular fields accessible to the updated component; and

determining whether the changes to the fields are linked to particular fields in the project or in project dependencies.

13 . The server of claim 8 , further comprising:

determining a set of reachable types in the updated component;

performing a comparison of changes in the updated component relative to the component; and

determining, based on the comparison, whether new types or changed types in the set of reachable types are compatible with external types associated with the updated component.

14 . The server of claim 8 , the operations further comprising:

for each breaking change in the set of breaking changes:

determining one or more locations in the project code affected by the incompatibility; and

determining one or more actions to perform to address the incompatibility.

15 . One or more non-transitory computer readable media storing instructions executable by one or more processors to perform operations comprising:

determining that project code in a development system calls a component in a third-party library, wherein the component is in a compiled form;

determining that the component has been updated to create an updated component in the third-party library, wherein the updated component is in the compiled form;

performing a type hierarchy comparison of:

a first type hierarchy associated with the component; and

a second type hierarchy associated with the updated component;

performing a call graph comparison of:

a first call graph associated with the component; and

a second call graph associated with the updated component;

performing a function comparison of:

a first set of functions called by the component; and

a second set of functions called by the updated component,

wherein the first set of functions and the second set of functions include directly called functions and transitively called functions;

performing a field comparison of:

a first set of fields accessed by the component; and

a second set of fields accessed by the updated component,

wherein the first set of fields and the second set of fields include directly accessed fields and transitively accessed fields; and

determining, based at least in part on:

the type hierarchy comparison,

the call graph comparison,

the function comparison, and

the field comparison,

a set of breaking changes associated with the updated component, each breaking change in the set of breaking changes identifying changes to the updated component, relative to the component, that are determined to cause an incompatibility when the project code calls the updated component;

wherein the project code is modified to create modified project code that does not include a breaking change from the set of breaking changes.

16 . The one or more non-transitory computer readable media of claim 15 , wherein the incompatibility comprises:

an incoming incompatibility due to an incoming call;

an outgoing incompatibility due to an outgoing call; or

both.

17 . The one or more non-transitory computer readable media of claim 15 , wherein performing the type hierarchy comparison comprises:

traversing the first type hierarchy;

traversing the second type hierarchy; and

identifying, based on traversing the first type hierarchy and the second type hierarchy, one or more types that inherit or implement at least one type that changed from the component to the updated component.

18 . The one or more non-transitory computer readable media of claim 15 , wherein performing the call graph comparison comprises:

traversing the first call graph;

traversing the second call graph; and

identifying, based on traversing the first call graph and the second call graph, at least one function, included in the updated component, that changed from the component to the updated component.

19 . The one or more non-transitory computer readable media of claim 15 , further comprising:

determining a set of reachable types in the updated component;

performing a comparison of changes in the updated component relative to the component; and

determining, based on the comparison of the changes, whether new types or changed types in the set of reachable types are compatible with external types associated with the updated component.

20 . The one or more non-transitory computer readable media of claim 15 , the operations further comprising:

for each breaking change in the set of breaking changes:

determining one or more locations in the project code affected by the incompatibility; and

determining one or more actions to perform to address the incompatibility.

Assignments (1)

Continuity (9)

References Cited (66)