Methods and systems for analyzing annotated programming code

1. A computer-implemented method comprising:

storing, in a profiles data store included in a memory of a computer, a profile including annotations for code and associated code types for each of the annotations;

receiving, by the computer, annotated code; and

prior to executing the annotated code:

parsing, by the computer, the annotated code to identify a plurality of functions, each function of the plurality of functions in the annotated code having an associated function label and an associated annotation;

identifying, by the computer, a calling function included in the plurality of functions, the calling function having an associated first function label and an associated first annotation;

determining, by the computer, that the calling function calls a first sub-function, the first sub-function having an associated second function label and an associated second annotation;

querying, by the computer, a function call log included in the memory of the computer, the query using the first function label associated with the calling function;

determining, by the computer, if an annotation summary for the calling function is stored in the function call log based on a result of the query;

based on the result of the query indicating that an annotation summary is not stored in the function call log for the calling function, analyzing, by the computer, the calling function comprising:

accessing the profile, the accessing comprising:

associating a first code type with the calling function based on the first code type being associated with the first annotation; and

associating a second code type with the first sub-function based on the second code type being associated with the second annotation; and

identifying an issue with execution of the annotated code, the issue based on rules governing the calling function of the first code type calling the first sub-function of the second code type;

generating, by the computer, an annotation summary for the calling function, the annotation summary including an error message based on the identified issue; and

storing, by the computer, the annotation summary in the function call log for the calling function.

2. The computer-implemented method of claim 1 , further comprising, based on the result of the query indicating that an annotation summary is stored in the function call log for the calling function, retrieving the stored annotation summary for the calling function.

3. The computer-implemented method of claim 1 , further comprising:

determining that the calling function is called as a sub-function by a second function; and

generating a second annotation summary for the second function, the second annotation summary including the stored annotation summary for the calling function called as the sub-function by the second function.

4. The computer-implemented method of claim 1 , wherein the function call log stores a plurality of annotation summaries for the plurality of functions in the annotated code.

5. The computer-implemented method of claim 1 ,

wherein the annotated code is received from a computing device; and

wherein execution, by the computing device, of the annotated code including the calling function negatively impacts performance of the computing device due to the identified issue.

6. The computer-implemented method of claim 1 , further comprising converting the annotated code from a first language format to an intermediate language format prior to parsing the annotated code.

7. The computer-implemented method of claim 1 ,

wherein the method further comprises determining, by the computer, that the calling function calls a second sub-function as an intermediate function call between the calling function and the first sub-function, the second sub-function having an associated third function label and an associated third annotation;

wherein accessing the profile further comprises associating a third code type with the second sub-function based on the third code type being associated with the third annotation;

wherein analyzing the calling function further comprises not identifying a potential issue when the annotated code is executed based on rules governing the calling function of the first code type calling the second sub-function of the third code type and based on rules governing the second sub-function of the third code type calling the first sub-function of the second code type; and

wherein the annotation summary for the calling function does not include an error message.

8. The computer-implemented method of claim 1 , wherein generating the annotation summary for the calling function further comprises:

generating a mapping from the calling function to the first sub-function; and

storing the mapping in the annotation summary.

9. The computer-implemented method of claim 1 , further comprising:

determining that a first instance of the calling function in a class has a mismatching annotation from a second instance of the calling function in a subclass of the class; and

generating a mismatch error message for the calling function in the annotation summary for the calling function in response to determining that the first instance of the calling function in the class has the mismatching annotation from the second instance of the calling function in the subclass of the class.

10. The computer-implemented method of claim 1 ,

wherein when the first code type indicates the calling function is performance critical,

wherein when the second code type indicates the first sub-function is expensive, and

wherein the error message included in the annotation summary for the calling function indicates that a performance critical function is calling an expensive function that requires an allocation of memory above a threshold.

11. The computer-implemented method of claim 1 , wherein a static program analysis system included in the computer parses the annotated code and generates the annotation summary.

12. The computer-implemented method of claim 1 ,

wherein when the first code type indicates the calling function is non-allocating, a non-allocating function prohibiting allocation of memory,

wherein the second code type indicates the first sub-function is memory-allocating, and

wherein the error message indicates that the non-allocating function is calling a memory-allocating function that requires an allocation of memory.

13. A non-transitory computer-readable medium storing instructions which, when executed by one or more processors in a processing device, cause the processing device to perform a method comprising:

storing, in a profiles data store included in a memory, a profile including annotations for code and associated code types for each of the annotations;

receiving, by the processing device, annotated code; and

prior to executing the annotated code:

parsing the annotated code to identify a plurality of functions, each function of the plurality of functions in the annotated code having an associated function label and an associated annotation;

identifying a calling function included in the plurality of functions, the calling function having an associated first function label and an associated first annotation;

determining that the calling function calls a first sub-function, the first sub-function having an associated second function label and an associated second annotation;

querying a function call log included in the memory, the query using the first function label associated with the calling function;

determining if an annotation summary for the calling function is stored in the function call log based on a result of the query;

based on the result of the query indicating that an annotation summary is not stored in the function call log for the calling function, analyzing the calling function comprising:

accessing the profile, the accessing comprising:

associating a first code type with the calling function based on the first code type being associated with the first annotation; and

associating a second code type with the first sub-function based on the second code type being associated with the second annotation; and

identifying an issue with execution of the annotated code, the issue based on rules governing the calling function of the first code type calling the first sub-function of the second code type;

generating an annotation summary for the calling function, the annotation summary including an error message based on the identified issue; and

storing the annotation summary in the function call log for the calling function.

14. The non-transitory computer-readable medium of claim 13 , further comprising, based on the result of the query indicating that an annotation summary is stored in the function call log for the calling function, retrieving the stored annotation summary for the calling function.

15. The non-transitory computer-readable medium of claim 14 , further comprising:

determining that the calling function is called as a sub-function by a second function; and

generating a second annotation summary for the second function, the second annotation summary including the stored annotation summary for the calling function called as the sub-function by the second function.

16. The non-transitory computer-readable medium of claim 13 ,

wherein the method further comprises determining that the calling function calls a second sub-function as an intermediate function call between the calling function and the first sub-function, the second sub-function having an associated third function label and an associated third annotation;

wherein accessing the profile further comprises associating a third code type with the second sub-function based on the third code type being associated with the third annotation;

wherein analyzing the calling function further comprises not identifying a potential issue when the annotated code is executed based on rules governing the calling function of the first code type calling the second sub-function of the third code type and based on rules governing the second sub-function of the third code type calling the first sub-function of the second code type; and

wherein the annotation summary for the calling function does not include an error message.

17. The non-transitory computer-readable medium of claim 13 , further comprising:

determining that a first instance of the calling function in a class has a mismatching annotation from a second instance of the calling function in a subclass of the class;

determining that the first instance of the calling function has a mismatching annotation from the second instance of the calling function; and

generating a mismatch error message for the calling function in the annotation summary for the calling function in response to determining that the first instance of the calling function has the mismatching annotation from the second instance of the calling function.

18. The non-transitory computer-readable medium of claim 13 ,

wherein when the first code type indicates the calling function is performance critical,

wherein when the second code type indicates the first sub-function is expensive, and

wherein the error message included in the annotation summary for the calling function indicates that a performance critical function is calling an expensive function that requires an allocation of memory above a threshold.

19. The non-transitory computer-readable medium of claim 13 ,

wherein when the first code type indicates the calling function is non-allocating, a non-allocating function prohibiting allocation of memory,

wherein the second code type indicates the first sub-function is memory-allocating, and

wherein the error message indicates that the non-allocating function is calling a memory-allocating function that requires an allocation of memory.

20. An apparatus comprising:

a processing device; and

a memory coupled to the processing device, the memory storing instructions which, when executed by the processing device, cause the apparatus to:

store, in a profiles data store included in the memory, a profile including annotations for code and associated code types for each of the annotations;

receive, by the processing device, annotated code; and

prior to executing the annotated code:

parse the annotated code to identify a plurality of functions each function of the plurality of functions in the annotated code having an associated function label and an associated annotation;

identify a calling function included in the plurality of functions, the calling function having an associated first function label and an associated first annotation;

determine that the calling function calls a first sub-function the first sub-function having an associated second function label and an associated second annotation;

query a function call log included in the memory, the query using the first function label associated with the calling function;

determine if an annotation summary for the calling function is stored in the function call log based on a result of the query;

based on the result of the query indicating that an annotation summary is not stored in the function call log for the calling function, analyze the calling function comprising:

accessing the profile, the accessing comprising:

 associating a first code type with the calling function based on the first code type being associated with the first annotation; and

 associating a second code type with the first sub-function based on the second code type being associated with the second annotation; and

identifying an issue with execution of the annotated code, the issue based on rules governing the calling function of the first code type calling the first sub-function of the second code type;

generate an annotation summary for the calling function, the annotation summary including an error message based on the identified issue; and

store the annotation summary in the function call log for the calling function.