Semmle Limited

Microsoft Technology Licensing, LLC

Max Schaefer

Oege De Moor

Pavel Avgustinov

Julian Tibble

Anders Starcke Henriksen

Arthur Baars

Albert Ziegler

Alexander Eyers-Taylor

Balabhadra Graveley

Mathieu Verbaere

Rahul Pandita

Johan Sebastian Heesemann Rosenkilde

Damien Sereni

Oegerikus De Moor

Edward Emil Aftandilian

Sarah Ezzeldin Mostafa Nadi

Adriana Sejfia

A large language model, trained on source code and natural language text generates a unit test for a change to a file in a pull request of a code repository. An ordered sequence of prompts is created and each is applied serially to the large language model to perform an individual task that leads to the generation of the unit test. The unit test may be added to an existing file or generated as a newly-created file. Each prompt includes the data from a previously-issued prompt of the ordered sequence in order for the model to retain contextual knowledge learned previously. The model generates the unit test as update commands when the unit test is added to an existing file.

Conversational unit test generation using large language model

Techniques for intelligently prompting an LLM to fix code are disclosed. A corpus of release notes for a set of libraries is accessed. The release notes include information describing deprecated or removed APIs associated with the libraries. The corpus is stored in a vector database. A code snippet is accessed. This snippet is identified as potentially using a deprecated API. The code snippet is used to identify a set of release notes from the vector database. These release notes are determined to satisfy a threshold level of similarity with the code snippet. An LLM prompt is built and is fed to the LLM. The LLM prompt instructs the LLM to update the code snippet based on the identified set of release notes. Output of the LLM is displayed. This output includes a proposed rewritten version of the code snippet.

Fixing usages of deprecated APIs using large language models

An elidable text is constructed that prioritizes the content included in a prompt to a large language model having a fixed-size context window. The elidable text is generated from developer-generated instructions or automatically for source code within a source code editor. A source code editor may include a feature that selects certain lines of code as important or focused which are assigned a high-priority value. A changed line, a line of source code at a current cursor position, lines of source code at the beginning of a file and those that output data are considered focused lines. Non-focused lines are assigned a priority based on a distance from a focused line. The elidable text constrains the data included in a prompt to the context window size by replacing the lowest-valued lines of text and source code with a replacement string.

Elidable text for prompt crafting

Classifying packages based on generic feature extraction. A computer system identifies a set of training packages, including a first subset known to be malicious, and a second subset known to be benign. The computer system extracts a set of training feature vectors from the set of training packages by inputting each training package to a feature extraction model, which generates a training feature vector for each training package. The computer system trains a classification model using the set of training feature vectors. After training the classification model using the set of training feature vectors, a subject package is classified as malicious or benign based on extracting a feature vector for the subject package by inputting the subject package to the feature extraction model, and inputting the feature vector to the classification model.

Generic feature extraction for identifying malicious packages

A computer system identifies a code synthesis model and a set of software repositories, each comprising corresponding source code and corresponding tests for testing the corresponding source code. The computer system tests a plurality of generated source code predictions using the set of software repositories. The testing includes, for each software repository in the set of software repositories, identifying a portion of the corresponding source code of the software repository that is covered by the corresponding tests of the software repository, using the code synthesis model to generate a source code prediction for the portion of the corresponding source code, and using the corresponding tests of the software repository to test the source code prediction that was generated using the code synthesis model. Based on testing the plurality of generated source code predictions using the set of software repositories, the computer system generates an evaluation of the code synthesis model.

Code synthesis model evaluation harnessing real-world code repositories

Detecting a malicious package associated with a software repository. A method identifies a subject package in a software repository, and extracts a feature set from the subject package. The feature set includes single-version features, including whether the subject package accesses personally identifying information, accesses specified system resource(s), uses specified application programming interface(s), includes installation script(s), and/or includes a binary, minified, or obfuscated file. The feature set also includes change features, including an amount of time since publication of a prior version of the subject package, a semantic update type, and/or how single-version feature(s) have changed since the prior version. The method provides the feature set as input to a set of classifiers, each being configured to use the feature set to generate a prediction of whether the subject package is malicious or benign. Based at least on the prediction, the method classifiers the subject package as being malicious or benign.

Automated detection of malicious packages in a software repository

What is disclosed are a novel system and method for inferring types of database queries. In one embodiment a program and associated database schema that includes a type hierarchy is accessed. The program includes query operations to a database that contains relations described by a database schema. Types are inferred from definitions in the program by replacing each database relationship in the program by the types in the database schema. A new program is generated with the types that have been inferred with the new program only accessing unary relations in the database. In another embodiment, testing of each of the types that have been inferred is performed for type emptiness. In response to type emptiness being found for a type that have been inferred, a variety of different operations are performing including removing the type, providing a notification regarding the emptiness found for the type, and more.

Type inference for datalog with complex type hierarchies

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.

Source code element signatures

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.

Algebraic data types for database query languages

Methods, systems, and apparatus, including computer programs encoded on computer storage media, for generating identifiers for tuples of recursively defined relations. One of the methods includes selecting one or more of the recursively defined relations to evaluate. Respective keys are computed for each tuple of any new tuples computed during recursive evaluation. For each key that occurs in a cache of keys, obtaining a tuple for the key from the cache and adding the obtained tuple to a new relation. For each key that does not occur in the cache of keys, generating a new identifier for the key, and adding, to a new relation for each key of each tuple of any keys that do not occur in the cache of keys for a relation, a new tuple comprising (1) elements of the tuple and (2) the new identifier for the key.

Generating identifiers for tuples of recursively defined relations

Methods, systems, and apparatus, including computer programs encoded on computer storage media, for matching and attributing code violations. One of the methods includes receiving a snapshot S of a code base of source code and a different snapshot T of the code base. Data representing first violations in the snapshot S and second violations in the snapshot T is received. Pairs of matching violations are determined using performing two or more matching processes, including performing a first matching process, the first matching process determining first pairs of matching violations according to a first matching algorithm and performing a second matching process, the second matching process determining second pairs of matching violations according to a second matching algorithm from violations not matched by the first matching process. The first pairs of matching violations and the second pairs of matching violations are included in the determined pairs of matching violations.

Growing community of inventors

Oxford, United Kingdom

Max Schaefer