Abstract: While a runtime specializer may always be able to generate an automated specialized version of a generic class, in some cases an alternate form of user control over specialization may allow the use of automated specialization while also adding (or overriding) specialization-specific method implementations. In general, the set of members of a generic class may not change when the class is specialized. In other words, the same members may exist in the auto-specialized version as in the generic version. However, manual refinement of specialized classes may allow a developer to hand specialize a particular (possibly a better) representation and/or implementation of one or more methods of the specialized class.

Abstract: The disclosed embodiments provide a system that facilitates the compilation and execution of a software program. During operation, the system obtains a closure from source code for the software program. Next, the system characterizes a type of the closure based on a mutability of one or more variables captured by the closure. Finally, the system encodes the type into a compiled form of the closure to facilitate subsequent execution of the closure in a multithreaded environment.

Abstract: The disclosed embodiments provide a system that facilitates the development and maintenance of a software program. This system includes a software development kit (SDK) and a runtime system for the software program. During operation, the system obtains a role associated with a dependency of a consumer in the software program on an interface. Next, the system obtains a compatibility policy for the interface. Finally, the system uses the role and the compatibility policy to manage use of the interface by the consumer in the software program.

Abstract: The disclosed embodiments provide a system that facilitates the development and maintenance of a software program. This system includes a software development kit (SDK) and a runtime system for the software program. During operation, the system associates classes of the software program with module declarations for a set of modules and uses the module declarations to manage dependencies in the software program throughout the life cycle of the software program.

Abstract: The disclosed embodiments provide a system that facilitates the development and execution of a software program. During operation, the system obtains, from the software program, a method call associated with one or more interfaces containing a virtual extension method. Next, the system resolves the method call by obtaining a method implementation corresponding to the method call from at least one of an inheritance hierarchy associated with the method call and the virtual extension method.

Abstract: Generic classes may have more than one specializable type parameter and it may be desirable to specialize one or more of the type variables while not specializing others. The result of partial specialization may be one or more additional generic classes that are further specializable on the remaining type parameters. A runtime specializer may partially specialize a generic class to produce a partially specialized class and may subsequently further specialize the partially specialized class to generate a fully specialized class. Thus, rather than performing the specialization of a generic class all at once, such as by specializing Map<K, V> into Map<int, int> or Map<long, int>, one type parameter may be partially specialized, such as resulting in Map<K, int>, and then at some later time the remaining type parameter(s) may be specialized, such as to generate Map<int, int> or Map<long, int>.

Abstract: The loading or operation of a specialized class may trigger the specialization of other classes. A compiler may be configured to recognize dependency relationships between generic classes and to describe the classes in terms of the type variables of the triggering types (e.g., the types and/or type parameterizations) that trigger the specialization of classes based on the specialization of a first class. A compiler may include information, such as structural references, indicating dependency relationships between classes when generating class files. Thus, the class file may include information indicating that a class extends a class resulting from applying a specialization code generator to an argument. Loading a first class may trigger the loading of a second class described by a structural description such that a specializer (and/or class loader) may apply the structural description to generate and load the second class for the particular parameterization.

Abstract: Metadata-driven dynamic specialization may include applying a type erasure operation to a set of instruction in a generic class or to a method declaration that includes typed variables using an encoded form of an instruction or an argument to an instruction. The instruction may operate on values of the reference types and the argument may be a signature that indicates the reference types. The encoded form may be annotated to include metadata indicating which type variables have been erased and which reference types are the erasures of type variables. Additionally, the metadata may indicate that the instruction operates on values of, and that the argument indicates reference types that are erasures of, the type variables of the class (or method) declaration. Moreover, the encoded form of the instruction or argument may be used directly without specialization or transformation.

Abstract: While a runtime specializer may always be able to generate an automated specialized version of a generic class, in some cases an alternate form of user control over specialization may allow the use of automated specialization while also adding (or overriding) specialization-specific method implementations. In general, the set of members of a generic class may not change when the class is specialized. In other words, the same members may exist in the auto-specialized version as in the generic version. However, manual refinement of specialized classes may allow a developer to hand specialize a particular (possibly a better) representation and/or implementation of one or more methods of the specialized class.

Abstract: Some embodiments provide a system that facilitates the development, maintenance, and execution of a software program. During operation, the system obtains a module declaration for a module to be used in the software program. Next, the system resolves one or more dependencies of the module using the module declaration and a list of available modules for the software program. Finally, the system uses the resolved dependencies to manage the software program throughout the life cycle of the software program.

Abstract: A tool, such as a compiler or an interpreter, receives program source code and determines that the code includes an operation for which type conversion is permitted on an operand. The tool determines a source type of the operand, and a target type to which the operand is to be converted. In response to determining that the source type is a reference type and the target type is a primitive type, the tool generates a set of instructions to (a) determine whether, at run time, in accordance with a class definition of the reference type, a value of the target primitive type can be obtained via one or more method invocations on the operand (b) if such a value can be obtained, obtain the value and assign the value to a result of the operation and (c) if such a value cannot be obtained, generate an error indication.

Abstract: One embodiment of the present invention provides a system that characterizes content in object code. During operation, the system receives the source code of a program. The system also receives one or more pieces of object code of the program, or creates one or more pieces of object code from the source code. Next, the system identifies a construct in the object code. The system then determines whether the construct is physically present in the source code. If the construct is not physically present, the system determines whether the construct is logically present in the source code, wherein a construct is logically present if it is required by the programming language. If so, the system sets a construct flag to indicate that the construct is “synthesized.” However, if not, the system sets the construct flag to indicate that the construct is “synthetic.” Finally, the construct flag is made available to a reflective API.

Abstract: A compiler receives source code for a program and determines that the code includes a declaration expression and an initialization expression in an assignment context. The declaration expression introduces a variable and specifies part of a parameterized type for the variable but not another part of the parameterized type. A parameterized type may include a ground type part and one or more type arguments; in a declaration expression, the specified part of the parameterized type may include a ground type and the unspecified part may include one or more of the type arguments. The initialization expression specifies an initial value for the variable, where the value has a parameterized type. The assignment context associates the declared variable with the initial value. The compiler infers the type for the variable based at least on the part specified in the declaration expression and on the type specified by the initialization expression.

Abstract: The disclosed embodiments provide a system that facilitates the development and execution of a software program. During operation, the system provides a mechanism for restricting a variable to a runtime context in the software program. Next, the system identifies the runtime context during execution of the software program. Finally, the system uses the mechanism to prevent incorrect execution of the software program by ensuring that a closure capturing the variable executes within the identified runtime context.

Abstract: The disclosed embodiments provide a system that facilitates the development and execution of a software program. During operation, the system provides a mechanism for restricting a variable to a runtime context in the software program. Next, the system identifies the runtime context during execution of the software program. Finally, the system uses the mechanism to prevent incorrect execution of the software program by ensuring that a closure capturing the variable executes within the identified runtime context.

Abstract: A tool, such as a compiler or an interpreter, receives program source code and determines that the code includes an operation for which type conversion is permitted on an operand. The tool determines a source type of the operand, and a target type to which the operand is to be converted. In response to determining that the source type is a reference type and the target type is a primitive type, the tool generates a set of instructions to (a) determine whether, at run time, in accordance with a class definition of the reference type, a value of the target primitive type can be obtained via one or more method invocations on the operand (b) if such a value can be obtained, obtain the value and assign the value to a result of the operation and (c) if such a value cannot be obtained, generate an error indication.

Abstract: The disclosed embodiments provide a system that provides access control for a software program. During operation, the system identifies a member of a module to be used in the software program. Next, the system infers the visibility of the member based on the accessibility of the member. Finally, the system uses the visibility and the accessibility to provide access control during the life cycle of the software program.

Abstract: The disclosed embodiments provide a system that facilitates the compilation of a software program. During operation, the system uses a directory hierarchy for the software program to infer a compilation unit to be used in the software program as a member of a module. Next, the system obtains a module declaration for the module using the directory hierarchy. Finally, the system enables compilation of the software program by dynamically identifying and locating one or more dependencies of the module using the module declaration and the directory hierarchy.

Abstract: The disclosed embodiments provide a system that facilitates the development and compilation of a software program. During operation, the system obtains a set of compilation units to be used in the software program and a version order associated with a programming language of the compilation units. Next, for each compilation unit from the set of compilation units, the system uses the version order to select a version of the programming language that is compatible with the compilation unit. The system then uses the version to compile the compilation unit.

Abstract: Various embodiments herein include one or more of systems, methods, software, and/or data structures to implement a multi-way branch statement in a computer programming language. The multi-way branch statement may include a plurality of case labels each having a non-primitive data type (e.g., strings) and being associated with a block of code to be executed dependent upon a control variable that also has a non-primitive data type. The implementation may include encoding the case labels for the multi-way branch statement as a binary decision diagram (BDD), such as a zero-suppressed binary decision diagram (ZDD), wherein the control variable for the multi-way branch statement may be compared with the case labels by stepping through the BDD. The BDD may include identifiers that provide information regarding which of the case labels is matched by the control variable, such that an appropriate code block may be executed.