INFERRING MISSING TYPE INFORMATION FOR REFLECTION

• US 20100242017A1
• Filed: 03/20/2009
• Published: 09/23/2010
• Est. Priority Date: 03/20/2009
• Status: Active Grant

• Current Assignee: Microsoft Technology Licensing LLC (Microsoft Corporation)
• Original Assignee: Microsoft Corporation
• Inventors: Stenberg, Per Johan, Bordoloi, Bijoy
• Granted Patent: US 8,407,667 B2
• Time in Patent Office: Days
• US Class Current: 717/111
• CPC Class Codes: G06F 8/30 Creation or generation of source code
• CPC Class Codes: G06F 8/36 Software reuse
• CPC Class Codes: G06F 8/74 Reverse engineering; Extracting design information from source code

Abstract

A stripped-down version of a library is generated from server source code extracted from a server project. The transitive closure of program entities extracted from the server source code and referenced by the extracted program entities can be computed. A placeholder entity can be inferred for an entity defined by the transitive closure computation if a definition of the entity cannot be found in the server source code. The stripped-down library generated from the extracted server source code is received by a reflection-based component that uses reflection to generate documentation and disclosure information helpful in the development of the client source code. A placeholder entity can be marked or decorated to signal to the reflection-based component that client source code is not to be generated for the decorated entities.

Claims

1. A system comprising:

a processor and a memory including a library generating module configured to cause the processor to;

receive metadata extracted from server source code in a server project of an application comprising at least the server project and at least one client project, wherein the extracted metadata comprises a set of program entities comprising a computed transitive closure of an extracted program entity and program entities referenced by the extracted program entity;

determine program entities within the set of program entities for which a definition is missing in the server source code;

replace each of the program entities within the set of program entities for which the definition is missing with a placeholder entity;

mark each placeholder entity;

generate a library from the extracted metadata without compilation of the server project, wherein the library comprises metadata associated with the set of program entities, wherein each program entity in the set of program entities is an entity that is exposed to the at least one client project and wherein the library does not comprise metadata associated with program entities not exposed to the at least one client project; and

provide the generated library to a reflection-based component that provides documentation and disambiguation information for an unmarked program entity in the set of program entities to a client source code editor, and not provide documentation and disambiguation information for a marked program entity in the set of program entities to the client source code editor, wherein the documentation and disambiguation information is provided to the client source code editor dynamically during development of client source code of the at least one client project.

2. The system of claim 1, wherein the processor generates source code for the at least one client project for unmarked program entities of the set of program entities and does not generate source code for the client project for marked program entities of the set of program entities.

3. The system of claim 1, wherein the metadata extracted from the server source code is associated with a type and a type definition referenced in the server source code.

4. The system of claim 1, wherein constraints on the program entities of the set of program entities are determined.

5. The system of claim 4, wherein the constraints comprise an interface implementation for a type, a set of implementations of abstract methods for the type or base classes for the type, wherein the type is used as a type argument in a generic type definition.

6. The system of claim 3, wherein a placeholder type is inferred for the type, wherein a type definition for the type is missing from the server source code.

7. The system of claim 6, further comprising the reflection-based component, wherein the reflection-based component generates the documentation and disambiguation information for types that are defined in the server source code, wherein the documentation and disambiguation information is displayed dynamically in the client source code editor during client source code development, and does not provide the documentation and disambiguation information for inferred types and wherein the reflection-based component generates a proxy class from the library comprising at least one proxy class and the at least one proxy class is displayed in the client source code editor during the development of the client source code.

8. A method comprising:

extracting metadata from server-side source code of a server project of an application under development on a software development computer, the application comprising server-side software generated from the server-side source code and client-side software generated from client-side source code, wherein the extracted metadata comprises metadata associated with a set of program entities comprising a transitive closure of program entities referenced in the extracted metadata, wherein the program entities are entities exposed by the server-side software to the client-side software and wherein the extracted metadata does not comprise a program entity that is not exposed to the client-side software by the server-side software;

determining program entities within the set of program entities for which a definition is missing in the server-side source code;

replacing each of the program entities within the set of program entities for which the definition is missing with a placeholder entity;

marking each placeholder entity;

generating a library from the extracted metadata without compilation of the server project, wherein the library comprises metadata associated with a program entity of the set of program entities and does not comprise an executable;

receiving the generated library and generating client-side source code and documentation and disambiguation information associated with the program entity of the set of program entities from the generated library by reflection; and

displaying the documentation and disambiguation information in a client source code editor dynamically during client-side software development on the software development computer.

9. The method of claim 8, wherein development of the client-side software and development of the server-side software proceed incrementally.

10. The method of claim 8, wherein the documentation and disambiguation information is displayed without compilation of the server project and comprises at least one API exposed to the client-side software and does not comprise APIs associated with inferred types.

11. The method of claim 8, wherein constraints are determined for the program entity of the set of program entities, wherein the program entity of the set of program entities comprises a type and wherein the constraints comprise an interface implementation for the type, an implementation of an abstract method for the type or a base class for the type, wherein the type is used as a type argument in a generic type definition.

12. The method of claim 8, further comprising:

providing the generated library to a reflection-based component comprising a code generator, wherein the reflection-based component generates client source code for at least one client project of the application from the generated library and wherein the reflection-based component does not generate client source code for placeholder entities.

13. The method of claim 8, further comprising:

extracting source code from the server project, the extracted source code comprising an undefined class that exposes an API to the client-side software, wherein a proxy class for the undefined class is not generated.

14. The method of claim 8, further comprising:

extracting source code from the server project, the extracted source code comprising an undefined class that exposes an API to the client-side software, wherein documentation and disambiguation information for the undefined class is not dynamically displayed in the client source code editor during the client-side software development.

15. A computer-readable storage medium comprising computer-executable instructions which when executed cause at least one processor to:

extract metadata from server-side source code of a server project of an application, wherein the extracted metadata comprises at least one server-side program entity exposed to a client-side project by the server project and wherein the extracted metadata does not comprise a program entity that is not exposed to the client-side project;

extract additional metadata from the server-side source code, wherein the additional extracted metadata comprises at least one additional server-side program entity referenced by the at least one server-side program entity;

replace a program entity in the extracted metadata or in the additional extracted metadata that is not defined in the server-side source code with a marked inferred program entity;

convert the extracted metadata and the additional extracted metadata to libraries comprising metadata, without compiling the server-side source code; and

display documentation and disambiguation information associated with the at least one server-side program entity derived from the libraries in a source code editor during development of client-side source code for the application and not display documentation and disambiguation information associated with the library derived from the marked inferred program entity.

16. The computer-readable storage medium of claim 15, comprising further computer-executable instructions, which when executed cause the at least one processor to:

determine a constraint for the at least one server-side program entity, wherein the at least one server-side program entity comprises a type and wherein the constraint comprises an interface implementation for the type, an implementation of an abstract method for the type or a base class for the type, wherein the type is used as a type argument in a generic type definition.

17. The computer-readable storage medium of claim 15, comprising further computer-executable instructions, which when executed cause the at least one processor to:

receive the libraries and not generate client-side source code documentation and disambiguation information from the libraries generated from program entities that are marked.

18. The computer-readable storage medium of claim 15, comprising further computer-executable instructions, which when executed cause the at least one processor to:

not generate client-side source code for a client project of the application for the marked inferred program entity.

19. The computer-readable storage medium of claim 15, comprising further computer-executable instructions, which when executed cause the at least one processor to:

provide the documentation and disambiguation information to a source code editor in which the client-side source code is being developed before the server-side source code is successfully compiled.

20. The computer-readable storage medium of claim 19, comprising further computer-executable instructions, which when executed cause the at least one processor to:

provide the documentation and disambiguation information by reflection on the libraries generated from the metadata extracted from the server-side source code, wherein the libraries are generated without compilation of the server-side source code from which the metadata was extracted.