Microsoft Technology Licensing, LLC

Aleksey V Tsingauz

Henricus Johannes Maria Meijer

Amanda K Silver

Avner Y Aharoni

David N Schach

Matthew J Warren

Mads Torgersen

Paul Allen Vick, Jr

John Lawrence Hamby

Jared Porter Parsons

Peter H Golde

Neal M Gafter

Manish Kumar Jayaswal

Karen Liu

Paul A Vick, Jr

Kevin Wagner Halverson

Renaud Paquay

Eugueni Zabokritski

Raja Krishnaswamy

Samuel Ng

Michael Shneerson

Tomas Matousek

Timothy Yat Tim Ng

Evgueni Zabokritski

Kevin Pilch-Bisson

Timothy Ng

Ghanashyam Chandrasekhar Namboodiripad

Andrew Casey

Gen Lu

Scott Daniel Wisniewski

Tanner Evan Gooding

Kevin Andrew Pilch

Edward T Maurer

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.

Efficient immutable syntax representation with incremental change

Instrumentation is extensible because the language construct to be instrumented and the particular instrumentation desired for the language construct can be provided to the compiler for each individual compilation using input provided during compilation of a program using a dynamic analyzer. The dynamic analyzer can identify the programming language construct to be instrumented and the instrumentation to be inserted into the code. The dynamic analyzer can analyze the data that is collected.

Extensible instrumentation

A compiler can instrument a program during the front end of compilation to collect data about runtime behavior when the program is executed. Instrumentation can occur during source language processing rather than later in the compilation chain. The instrumentation can occur in between semantic analysis and code generation. The instrumentation can occur in an instrumenting rewriting phase. The instrumentation can occur in a first lowering phase in which high level constructs in a programming language are rewritten as lower level constructs in intermediate representation (IR). The compiler can inject the instrumentation code at particular points in the source code based on specified language constructs in the source program. The types of instrumentation injected can be extended by providing additional information to the compiler at compilation time, without the need to reprogram the compiler.

Instrumenting program code

A batch compiler is employed to enable compilation of code provided at runtime. A managed application receives code during execution and invokes the compiler to transform the code to enable it to execute within the context of the receiving application. Among other things, employment of a batch compiler preserves investments made to such compilers while also opening up new scenarios in application scripting and/or hosting that are otherwise unavailable.

Compiler in a managed application context

User assemblies can be created by a compiler that can handle more than one type definition during execution. Local copies are created for respective authoritative types in a code library, and the local copies are marked with a local type identifier. An authoritative type identifier (e.g., a globally unique identifier (GUID)) is copied from the authoritative type to the local type, and functions and properties associated with the local type are also copied from the authoritative type. Authoritative types are resolved for requested types when a local assembly references a local type from a compiled user assembly. The local type can be identified by a local type identifier, and an authoritative type can be retrieved from the code library that has a same authoritative type identifier as the requested type. A local copy of the retrieved authoritative type can be copied to the local assembly under compilation. The compiler can then emit user assemblies that comprise merely local types.

Handling multiple definition of types

The claimed subject matter relates to an architecture that can facilitate query comprehension that are constructed in a compositional manner. In accordance therewith, the query comprehensions can be assembled together in virtually in order without common requirements that force query operators of a query expression to follow ordering/syntactic rules. In addition, the architecture can provide for query expressions that arbitrarily composable and which can be terminated at any point. If the query expression terminates without a Select or Return clause at the end, the architecture can facilitate generation of an implicit Select or Return, and output results.

Compositional query comprehensions

The claimed subject matter relates to a formalization of operator patterns that can facilitate type flow of element types between an operator in a first clause of an expression to an operator in a next clause of the expression. The type that flows to, and the operator extant in, the next clause can be combined to infer the element type of the next clause. As such, type-checking, autocompletion and other advantageous features can be accomplished incrementally without the need for a prior full translation of the expression.

Query pattern to enable type flow of element types

A query language system is provided that includes a query component that specifies operations for one or more items in a data set. An aggregator component identifies one or more keys associated with the data set, the keys are supplied to one or more aggregators that perform direct computations from the keys in order to determine at least one aggregated value for the data set.

Efficient execution of aggregation queries

Growing community of inventors

Seattle, WA, United States of America

Aleksey V Tsingauz