Abstract: A single asynchronous enumerable object is generated that contains the data and methods needed to iterate through an enumerable asynchronously. The asynchronous enumerable object contains the code for traversing the enumerable one step at a time and the operations needed to suspend an iteration to await completion of an asynchronous operation and to resume the iteration upon completion of the asynchronous operation. The allocation of a single object to perform all of these tasks reduces the memory consumption needed to execute an asynchronous enumeration.

Abstract: Utilizing role types that extend underlying types. Within a program definition, a computer system identifies a statement assigning an object of an underlying type to a role type that extends the underlying type. The underlying type implements a first interface, and the role type implements a second interface. Based on the role type extending the underlying type, the computer system assigns the object of the underlying type to the role type. Based on assigning the object of the underlying type to the role type, the role type is usable to interact with the object of the underlying type using both the first interface and the second interface.

Abstract: Efficient immutable syntax representation with parent pointers under incremental change is enabled by creating a data structure comprising at least one tree structure that allows both upward and downward references in the tree and a tree structure that is immutable (read-only), and allows parts of itself to be re-used in other data structures. The data structure described enables tools to search and target particular sub trees. The fragment of the tree representing the targeted sub tree is produced as it is used. The rest of the tree is not produced. The read-only tree retains relative information, allowing it to be reassembled and shared.

Abstract: A single asynchronous enumerable object is generated that contains the data and methods needed to iterate through an enumerable asynchronously. The asynchronous enumerable object contains the code for traversing the enumerable one step at a time and the operations needed to suspend an iteration to await completion of an asynchronous operation and to resume the iteration upon completion of the asynchronous operation. The allocation of a single object to perform all of these tasks reduces the memory consumption needed to execute an asynchronous enumeration.

Abstract: Efficient immutable syntax representation with parent pointers under incremental change is enabled by creating a data structure comprising at least one tree structure that allows both upward and downward references in the tree and a tree structure that is immutable (read-only), and allows parts of itself to be re-used in other data structures. The data structure described enables tools to search and target particular sub trees. The fragment of the tree representing the targeted sub tree is produced as it is used. The rest of the tree is not produced. The read-only tree retains relative information, allowing it to be reassembled and shared.

Abstract: Efficient immutable syntax representation with parent pointers under incremental change is enabled by creating a data structure comprising at least one tree structure that allows both upward and downward references in the tree and a tree structure that is immutable (read-only), and allows parts of itself to be re-used in other data structures. The data structure described enables tools to search and target particular sub trees. The fragment of the tree representing the targeted sub tree is produced as it is used. The rest of the tree is not produced. The read-only tree retains relative information, allowing it to be reassembled and shared.

Abstract: An asynchronous method is implemented in a manner that reduces the amount of runtime overhead needed to execute the asynchronous method. The data elements needed to suspend an asynchronous method to await completion of an asynchronous operation, to resume the asynchronous method at a resumption point, and to provide a completion status of the caller of the asynchronous method are consolidated into one or two reusable objects. An asynchronous method may be associated with a distinct object pool of reusable objects. The size of a pool and the total size of all pools can be configured statically or dynamically based on runtime conditions.

Abstract: Static type checking can be performed on types and values defined in modules in a system that dynamically composes programs from modules. The types and values do not share a global namespace. Each module defines its own module universe, disjoint from other modules. A language mechanism can establish a local name binding to one module within the content of another module. When type checking at compile time an environment can be established that corresponds to a runtime instance of the program. The static type system can be arranged to align with the runtime values, such that the names used to refer to objects at runtime are the same as the names used to refer to the types of those objects in the static type system. Aliases of a particular type are resolved to a known compile time description of the type.

Abstract: Type inference is used to provide the benefits of static type checking without explicitly declaring type in the source code. Type inference that proceeds in a bottom up direction is augmented by contextual typing that proceeds in a top down direction. Contextual typing types enclosed expressions by associating the type of a directly enclosing expression with the enclosed expression. Object literals, function literals and array literals enclosed in assignment and call expressions, can be contextually typed.

Abstract: Statically extensible types allow a static type system to model the behavior of dynamic object model extension in dynamic runtime systems. Static types that model dynamically extended types can be extended using additional declarations in the same compilation. Declarations for a particular type can come from multiple independent sources which can have been defined at multiple points in time. Extension declarations can use the same syntax as the initial type declaration. Hence presence of one or more declarations for the same type in a compilation can indicate that the type has been extended. These features allow static type checking of dynamic plug-ins to be supported using statically extensible types. Declarations and extension declarations for a type can be merged together to create an extended type that enables different processing paths and dependencies.

Abstract: A static type, called “dynamic”, is introduced into a statically bound programming language. An expression or subexpression that is defined as a static type called “dynamic” in the source code of a program written in the statically bound programming language, is bound based on its runtime type instead of on its compile time type. Binding can be performed based on a mixture of compile time and runtime types that are based on the specification of types of expressions in source code. This type of binding is called hybrid binding. Operations are bound using the runtime type of constituent expressions (i.e., the runtime type of a receiver, an argument, or an operand) typed as dynamic and the compile time type of static constituents. If any constituent expression of an operation is dynamic, binding occurs at runtime instead of at compile time.

Abstract: Unsuspended co-routines are handled by the machine call stack mechanism in which the stack grows and shrinks as recursive calls are made and returned from. When a co-routine is suspended, however, additional call stack processing is performed. A suspension message is issued, and the entire resume-able part of the call stack is removed, and is copied to the heap. A frame that returns control to a driver method (a resumer) is copied to the call stack so that resumption of the co-routine does not recursively reactivate the whole call stack. Instead the resumer reactivates only the topmost or most current frame called the leaf frame. When a co-routine is suspended, it does not return to its caller, but instead returns to the resumer that has reactivated it.

Abstract: The present invention extends to methods, systems, and computer program products for transforming source code to await execution of asynchronous operations. Embodiments of the invention simplify authoring and use of asynchronous methods, by generating statements that use well-defined awaitable objects to await completion of asynchronous operations. For example, a computer system can transform a statement that requests to await the completion of an asynchronous operation into a plurality of statements that use a predefined pattern of members of an awaitable object corresponding the asynchronous operation. The pattern can include one or more members configured to return a completion status of the asynchronous operation, one or more members configured to resume execution of the asynchronous method at a resumption point when the asynchronous operation completes, and one or more members configured to retrieve completion results.

Abstract: A function in a type system can be overloaded using specified constants. The constant can be can be the result of evaluating an expression to: a string, a number, a Boolean, a pattern or any type of constant. The return type of the function can depend on the specified constant that is passed into the function. The return type of the function can depend on the type of the specified constant that is passed into the function. The type of the parameter that is passed into the function can depend on the value of the constant. The function overloads can be validated to ensure that the constant-based overload is a subtype of a more general overload. A constant can be an expression used at compile time during type checking.

Abstract: Statically extensible types allow a static type system to model the behavior of dynamic object model extension in dynamic runtime systems. Static types that model dynamically extended types can be extended using additional declarations in the same compilation. Declarations for a particular type can come from multiple independent sources which can have been defined at multiple points in time. Extension declarations can use the same syntax as the initial type declaration. Hence presence of one or more declarations for the same type in a compilation can indicate that the type has been extended. These features allow static type checking of dynamic plug-ins to be supported using statically extensible types. Declarations and extension declarations for a type can be merged together to create an extended type that enables different processing paths and dependencies.

Abstract: Static type checking can be performed on types and values defined in modules in a system that dynamically composes programs from modules. The types and values do not share a global namespace. Each module defines its own module universe, disjoint from other modules. A language mechanism can establish a local name binding to one module within the content of another module. When type checking at compile time an environment can be established that corresponds to a runtime instance of the program. The static type system can be arranged to align with the runtime values, such that the names used to refer to objects at runtime are the same as the names used to refer to the types of those objects in the static type system. Aliases of a particular type are resolved to a known compile time description of the type.

Abstract: Type inference is used to provide the benefits of static type checking without explicitly declaring type in the source code. Type inference that proceeds in a bottom up direction is augmented by contextual typing that proceeds in a top down direction. Contextual typing types enclosed expressions by associating the type of a directly enclosing expression with the enclosed expression. Object literals, function literals and array literals enclosed in assignment and call expressions, can be contextually typed.

Abstract: Queries targeting various data sources are processed in a query processing pipeline that parses the query into a set of operations (e.g., an expression tree or a translated SQL query) using a set of query operators, each handling a particular type of operation. The query operators are often designed in an unspecialized manner, such that each query operator handles one query operation in an atomic, generic manner (e.g., sorting generic data items for an ORDER BY clause.) More efficient queries may be devised by including specialized queries that operate in common but special cases, such as a sorting of a particular data type (e.g., a floating-point number sort) or a sequence of two or more operations that are often performed together (e.g., a WHERE test of an attribute followed by a SELECT of the same attribute.) The use of specialized operators may result in the formulation of more efficient queries.

Abstract: A design time debugging tool provides debugging information available from the compiler during design time, as if a user were debugging code that provided the debugging information, by exposing information available from the compiler without initiation of a debugging session and without executing the program being debugged.

Abstract: The present invention extends to methods, systems, and computer program products for representing various programming elements with compiler-generated tasks. Embodiments of the invention enable access to the future state of a method through a handle to a single and composable task object. For example, an asynchronous method is rewritten to generate and return a handle to an instance of a builder object, which represents one or more future states of the asynchronous method. Information about operation of the asynchronous method is then passed through the handle. Accordingly, state of the asynchronous method is trackable prior to and after completing.