Abstract: Methods, systems, and apparatus, including computer programs encoded on computer storage media, for linearizing the commit history of a code base. One of the methods includes receiving a request to attribute source code contributions to a particular snapshot in a project having a revision graph with multiple branches. Source code contributions occurring in each non-merge commit on a single path through the revision graph are attributed to a responsible developer entity of the non-merge commit. Each merge commit is processed on the single path including identifying contributions introduced by the merge commit, identifying one or more respective responsible developer entities for the contributions occurring in the one or more feature branch snapshots from one or more feature branches, and attributing source code contributions occurring in the one or more feature branch snapshots from the one or more feature branches to the identified one or more respective responsible developer entities.

Abstract: Methods, systems, and apparatus, including computer programs encoded on computer storage media, for attributing violation introductions and removals. One of the methods includes receiving a request to compute a number of violation introductions attributable to a particular developer entity in a plurality of ancestor snapshots of an original snapshot in a revision graph of a code base. A respective match set for each of a plurality of violations occurring in the plurality of ancestor snapshots of the original snapshot are computed, wherein each match set for a particular violation in a particular snapshot includes any transitively matching violations in the ancestor snapshots of the particular snapshot that transitively match the particular violation. A count of unique match sets having at least one violation that was introduced by the particular developer entity is computed. The number of unique match sets is provided in response to the request.

Abstract: Methods, systems, and apparatus, including computer programs encoded on computer storage media, for computing weights for source code alerts. One of the methods includes generating a respective sample of alerts for each feature of a plurality of features. One or more feature values are computed for alerts having a same respective attribute value for each feature of a plurality of features. An importance distribution that maps each feature value to a respective measure of importance for an alert having the feature value is used to compute a respective feature score for the feature using one or more feature values computed the alert. A respective weight is computed for each alert by combining the plurality of feature scores computed for the alert.

Abstract: Methods, systems, and apparatus, including computer programs encoded on computer storage media, for generating signatures for source code elements. One of the methods includes generating a respective signature for each source code element of the plurality of source code elements, including obtaining a name of the source code element, obtaining one or more of a location of a compilation unit containing the source code element and contents of the compilation unit containing the source code element, and generating the signature including combining a first representation of the name of the source code element and one or more of a second representation of the location of the compilation unit and a third representation of the contents of the compilation unit containing the source code element, wherein at least two of the plurality of source code elements have a same name and different respective signatures.

Abstract: Methods, systems, and apparatus, including computer programs encoded on computer storage media, for comparing software projects having been analyzed using different criteria. One of the methods includes receiving, for each of a plurality of software projects, source code evaluation criteria that had been used to analyze source code of the respective software project. An overlapping set of source code evaluation criteria is determined. For each of the software projects, source code analysis results which resulted from the overlapping set of source code evaluation criteria are determined, and a respective value of a characteristic metric for the source code analysis results is computed. The respective values of the characteristic metric for each of the software projects are compared, and for at least one of the software projects, an assessment of the software project is output.

Abstract: Methods, systems, and apparatus, including computer programs encoded on computer storage media, for computing coding velocity. One of the methods includes receiving a definition of one or more individual source code developers belonging to a target developer entity. Coding-velocity samples for each individual source code developer belonging to the target developer entity are generated, wherein each coding-velocity sample represents a measure of coding activity by the individual source code developer over a respective time duration. The coding-velocity samples are aggregated according to the definition of the target developer entity. A coding-velocity model for the target developer entity is generated from the aggregated coding-velocity samples of the target developer entity. A value of a particular coding-velocity attribute for the target developer entity is computed using the coding-velocity model.

Abstract: Methods, systems, and apparatus, including computer programs encoded on computer storage media, for generating a commit graph for a software project maintained in a version control system having a directory-based branching structure. One of the methods includes receiving data representing a commit history of a software project maintained in a version control system having a directory-based branching system in which each branch of the commit history has a respective branch directory and each revision is identified by a branch path and a revision number. The commit history is traced backward in time from a starting commit of a branch to identify an initial commit in which a branch directory for the branch was created. The commit history is then processed forward in time from the initial commit to generate a tree-structured commit graph.

Abstract: Methods, systems, and apparatus, including computer programs encoded on computer storage media, for evaluating recursive predicates and exiversal predicates. One of the methods includes receiving an expression having an exiversal quantifier that specifies a condition x and a condition y. The expression is transformed into a second expression having multiple recursive calls, the second expression having a first non-negated term with a first recursive call in the condition y, and a second negated term with a second recursive call in the condition y. The second expression is evaluated using evaluation predicates that include a single delta predicate that replaces only the recursive call in the first non-negated term to identify data elements in the relation having at least one attribute satisfying the condition x and the condition y, and, for each attribute of the data element satisfying the condition x, the attribute also satisfies the condition y.

Abstract: Methods, systems, and apparatus, including computer programs encoded on computer storage media, for aggregating source code metric values. One of the methods includes obtaining data representing a directed graph, wherein one or more nodes of the graph are associated with a respective set of one or more metric instances, wherein each set of metric instances for each node includes all metric instances occurring in sets of any node descendant from the node in the graph, wherein each metric instance identifies a location in a source code base, and wherein each metric instance has a respective metric value, a respective identifier, and a respective attribute type. An attribute value is computed for a first node in the graph from the respective metric value of each metric instance in a first set of metric instances associated with the first node.

Abstract: Methods, systems, and apparatus, including computer programs encoded on computer storage media, for performing automatic builds of snapshots using software packages with highly similar contents. One of the methods includes computing, by a source code analysis system, a respective similarity score between contents of a particular snapshot and contents of each software package of a plurality of software packages in one or more package repositories. A highest-scoring software package for the snapshot is determined using the computed similarity scores. An automatic build of the snapshot using the highest-scoring software package is performed, including identifying one or more dependencies and one or more build commands from the highest-scoring software package, installing the one or more dependencies in a build environment of the snapshot, and executing the one or more build commands in the build environment of the snapshot.

Abstract: Methods, systems, and apparatus, including computer programs encoded on computer storage media, for performing differential recursive evaluation. One of the methods includes receiving an original recursive expression that defines tuples belonging to an output relation. A final delta expression is generated including repeatedly applying one or more delta rules to the initial delta expression, wherein the final delta expression has at least one call to a delta relation that represents tuples generated by the final delta expression on a previous iteration. Until the final delta expression generates no new tuples, the final delta expression is evaluated using the tuples computed by the final delta expression on the previous iteration wherever the call to the delta relation occurs and the output relation is updated including adding to the output relation any tuples newly generated by evaluating the final delta expression.

Abstract: Methods, systems, and apparatus, including computer programs encoded on computer storage media, for identifying source code used to build executable. One of the methods includes determining that a first newly created process is a compiler, the compiler being invoked to compile a source code file; after the compiler exits, generating a first hash value of an object file generated by the compiler; generating an object artifact that identifies the source code file and includes the first hash value of contents of the object file generated by the compiler; determining that the second newly created process is a linker, the linker being invoked to generate an executable file from one or more object files; generating a link artifact that includes respective hash values of each of the one or more object files used to generate the executable file; and providing the link artifact and object artifact to a static analysis system.

Abstract: Methods, systems, and apparatus, including computer programs encoded on computer storage media, for implementing algebraic data types in database query languages. One of the methods includes receiving an expression in a database query language, the expression having a programming language construct representing an algebraic data type, wherein the expression specifies two or more alternative subtypes. Respective domain relations are generated using definitions of each of the alternative subtypes within the expression. Unique domain identifiers are assigned among domain tuples belonging to each alternative subtype. A union relation is generated for the algebraic data type. Unique union identifiers are assigned for union tuples belonging to the union relation. Respective injector relations are generated for each of the alternative subtypes.

Abstract: Methods, systems, and apparatus, including computer programs encoded on computer storage media, for performing differential recursive evaluation of recursive aggregates. One of the methods includes receiving an original recursive expression that defines tuples belonging to an output relation, wherein the original recursive expression has a recursive aggregation construct, the recursive aggregation construct having a range and a recursive term. An aggregates delta rule is applied to the initial delta expression to generate a final delta expression having an existential term and a gamma term. The existential term is evaluated to generate tuples related by the range and tuples in the delta relation, and the aggregation construct is evaluated using tuples generated by the existential term as the range of the aggregation construct. The output relation is updated including adding to the output relation any tuples newly generated by evaluating the final delta expression.

Abstract: Methods for reducing storage and performing static analysis on violations across code base revisions are disclosed. An example method begins with receiving a child snapshot representing a code base at a specific revision. A parent snapshot is identified. Then, canonical representations for violations representing coding defects in the parent and child snapshots are computed. An example method determines matching violations between the snapshots, unmatched parent violations, and unmatched child violations. For matching violations that have different canonical representations, a mapping between the parent snapshot violation and the child snapshot violation is stored using their respective canonical representations. For unmatched parent violations, each violation's canonical representation is stored with an indication that the violation has been eliminated from the child snapshot.

Abstract: Methods, systems, and apparatus, including computer programs encoded on computer storage media, for expressing inequality expressions as a bounded number of equality expressions. One of the methods includes receiving an original query having an inequality expression for an original attribute. A new query that replaces the inequality expression with a bounded number of equality expressions is generated, wherein each equality expression references a respective auxiliary attribute, each auxiliary attribute representing intervals of values for the original attribute. The new query having the bounded number of equality expressions is provided to a database system instead of the original query. Query results that satisfy the inequality expression for the original attribute are received from the database system.

Abstract: Methods, systems, and apparatus, including computer programs encoded on computer storage media, for extracting source code. One of the methods includes receiving, by a newly created process, a request to execute code of an executable file in the newly created process, wherein the request specifies a parameter. The newly created process loads a process interception library. Library initialization code of the process interception library determines whether the parameter should be intercepted. In response to determining that the parameter should be intercepted, the parameter is provided to another process.

Abstract: Methods, systems, and apparatus, including computer programs encoded on computer storage media, for automatically determining configuration properties of a compiler. One of the methods includes determining that an executable of the newly created process is a compiler called by the build system to compile source code of a source code file. In response to the determining, a plurality of configuration properties of the compiler called by the build system are determined, the configuration properties including first properties of a plurality of built-in functions of the compiler, second properties of a plurality of built-in types of the compiler, or both. A compiler emulator is configured to emulate the behavior of the compiler called by the build system using the determined configuration properties. Access to the source code is provided to the compiler emulator configured using the determined configuration properties.