Abstract Syntax Research Articles

"A Multi-Pass Compiler with Code Optimized Abstract Syntax Tree"

"A Multi-Pass Compiler with Code Optimized Abstract Syntax Tree"

Storage State Analysis and Extraction of Ethereum Blockchain Smart Contracts

In migrating and upgrading an Ethereum smart contract, it is necessary to transfer both the code as well as the stored data. Various methods attempt to migrate or upgrade a smart contract, but they are mostly manual, error-prone, and applicable only before deployment. Further, they have challenges in extracting the storage state of complex mapping data structures along with their keys. In this work, we present Smartmuv as an automatic source-code-based static analysis tool to analyze and extract the state from the storage-trie of smart contracts. Based on the abstract syntax tree and the control flow graphs of the Solidity source code, the tool analyzes each state variable including mapping types along the inheritance hierarchy. It also provides the upgrade algorithm that initializes the extracted state in the constructor of new smart contract. Smartmuv safely approximates the origin of the keys used in the mapping to extract values and has been able to extract the mapping state of 23,673 smart contracts with 95.7% overall precision. Moreover, we also validate the Smartmuv’s extracted state with the third-party tool Etherscan.

Towards Learning Generalizable Code Embeddings Using Task-agnostic Graph Convolutional Networks

Code embeddings have seen increasing applications in software engineering (SE) research and practice recently. Despite the advances in embedding techniques applied in SE research, one of the main challenges is their generalizability. A recent study finds that code embeddings may not be readily leveraged for the downstream tasks that the embeddings are not particularly trained for. Therefore, in this article, we propose GraphCodeVec , which represents the source code as graphs and leverages the Graph Convolutional Networks to learn more generalizable code embeddings in a task-agnostic manner. The edges in the graph representation are automatically constructed from the paths in the abstract syntax trees, and the nodes from the tokens in the source code. To evaluate the effectiveness of GraphCodeVec , we consider three downstream benchmark tasks (i.e., code comment generation, code authorship identification, and code clones detection) that are used in a prior benchmarking of code embeddings and add three new downstream tasks (i.e., source code classification, logging statements prediction, and software defect prediction), resulting in a total of six downstream tasks that are considered in our evaluation. For each downstream task, we apply the embeddings learned by GraphCodeVec and the embeddings learned from four baseline approaches and compare their respective performance. We find that GraphCodeVec outperforms all the baselines in five out of the six downstream tasks, and its performance is relatively stable across different tasks and datasets. In addition, we perform ablation experiments to understand the impacts of the training context (i.e., the graph context extracted from the abstract syntax trees) and the training model (i.e., the Graph Convolutional Networks) on the effectiveness of the generated embeddings. The results show that both the graph context and the Graph Convolutional Networks can benefit GraphCodeVec in producing high-quality embeddings for the downstream tasks, while the improvement by Graph Convolutional Networks is more robust across different downstream tasks and datasets. Our findings suggest that future research and practice may consider using graph-based deep learning methods to capture the structural information of the source code for SE tasks.

A Heterogeneous Graph to Abstract Syntax Tree Framework for Text-to-SQL.

Text-to-SQL is the task of converting a natural language utterance plus the corresponding database schema into a SQL program. The inputs naturally form a heterogeneous graph while the output SQL can be transduced into an abstract syntax tree (AST). Traditional encoder-decoder models ignore higher-order semantics in heterogeneous graph encoding and introduce permutation biases during AST construction, thus incapable of exploiting the refined structure knowledge precisely. In this work, we propose a generic heterogeneous graph to abstract syntax tree (HG2AST) framework to integrate dedicated structure knowledge into statistics-based models. On the encoder side, we leverage a line graph enhanced encoder (LGESQL) to iteratively update both node and edge features through dual graph message passing and aggregation. On the decoder side, a grammar-based decoder first constructs the equivalent SQL AST and then transforms it into the desired SQL via post-processing. To avoid over-fitting permutation biases, we propose a golden tree-oriented learning (GTL) algorithm to adaptively control the expanding order of AST nodes. The graph encoder and tree decoder are combined into a unified framework through two auxiliary modules. Extensive experiments on various text-to-SQL datasets, including single/multi-table, single/cross-domain, and multilingual settings, demonstrate the superiority and broad applicability.

Compositional embeddings of domain-specific languages

A common approach to defining domain-specific languages (DSLs) is via a direct embedding into a host language. There are several well-known techniques to do such embeddings, including shallow and deep embeddings. However, such embeddings come with various trade-offs in existing programming languages. Owing to such trade-offs, many embedded DSLs end up using a mix of approaches in practice, requiring a substantial amount of code, as well as some advanced coding techniques. In this paper, we show that the recently proposed Compositional Programming paradigm and the CP language provide improved support for embedded DSLs. In CP we obtain a new form of embedding, which we call a compositional embedding, that has most of the advantages of both shallow and deep embeddings. On the one hand, compositional embeddings enable various forms of linguistic reuse that are characteristic of shallow embeddings, including the ability to reuse host-language optimizations in the DSL and add new DSL constructs easily. On the other hand, similarly to deep embeddings, compositional embeddings support definitions by pattern matching or dynamic dispatching (including dependent interpretations, transformations, and optimizations) over the abstract syntax of the DSL and have the ability to add new interpretations. We illustrate an instance of compositional embeddings with a DSL for document authoring called ExT. The DSL is highly flexible and extensible, allowing users to create various non-trivial extensions easily. For instance, ExT supports various extensions that enable the production of wiki-like documents, LaTeX documents, vector graphics or charts. The viability of compositional embeddings for ExT is evaluated with three applications.

A Category Theoretic View of Contextual Types: From Simple Types to Dependent Types

We describe the categorical semantics for a simply typed variant and a simplified dependently typed variant of Cocon , a contextual modal type theory where the box modality mediates between the weak function space that is used to represent higher-order abstract syntax (HOAS) trees and the strong function space that describes (recursive) computations about them. What makes Cocon different from standard type theories is the presence of first-class contexts and contextual objects to describe syntax trees that are closed with respect to a given context of assumptions. Following M. Hofmann’s work, we use a presheaf model to characterise HOAS trees. Surprisingly, this model already provides the necessary structure to also model Cocon . In particular, we can capture the contextual objects of Cocon using a comonad ♭ that restricts presheaves to their closed elements. This gives a simple semantic characterisation of the invariants of contextual types (e.g. substitution invariance) and identifies Cocon as a type-theoretic syntax of presheaf models. We further extend this characterisation to dependent types using categories with families and show that we can model a fragment of Cocon without recursor in the Fitch-style dependent modal type theory presented by Birkedal et al.

AI-assisted programming question generation: Constructing semantic networks of programming knowledge by local knowledge graph and abstract syntax tree

Creating practice questions for programming learning is not an easy job. It requires the instructor to diligently organize heterogeneous learning resources. Although educational technologies have been adopted across levels of programming learning, programming question generation (PQG) is still predominantly performed by instructors without advanced technological support. This study proposes a knowledge-based PQG model that aims to help the instructor generate new programming questions and expand the assessment items by the Local Knowledge Graph and Syntax Tree. A group of experienced instructors was recruited to evaluate the PQG model and expressed significantly positive feedback on the generated questions.

XCode : Towards Cross-Language Code Representation with Large-Scale Pre-Training

Source code representation learning is the basis of applying artificial intelligence to many software engineering tasks such as code clone detection, algorithm classification, and code summarization. Recently, many works have tried to improve the performance of source code representation from various perspectives, e.g., introducing the structural information of programs into latent representation. However, when dealing with rapidly expanded unlabeled cross-language source code datasets from the Internet, there are still two issues. Firstly, deep learning models for many code-specific tasks still suffer from the lack of high-quality labels. Secondly, the structural differences among programming languages make it more difficult to process multiple languages in a single neural architecture. To address these issues, in this article, we propose a novel Cross -language Code representation with a large-scale pre-training ( XCode ) method. Concretely, we propose to use several abstract syntax trees and ELMo-enhanced variational autoencoders to obtain multiple pre-trained source code language models trained on about 1.5 million code snippets. To fully utilize the knowledge across programming languages, we further propose a Shared Encoder-Decoder (SED) architecture which uses the multi-teacher single-student method to transfer knowledge from the aforementioned pre-trained models to the distilled SED. The pre-trained models and SED will cooperate to better represent the source code. For evaluation, we examine our approach on three typical downstream cross-language tasks, i.e., source code translation, code clone detection, and code-to-code search, on a real-world dataset composed of programming exercises with multiple solutions. Experimental results demonstrate the effectiveness of our proposed approach on cross-language code representations. Meanwhile, our approach performs significantly better than several code representation baselines on different downstream tasks in terms of multiple automatic evaluation metrics.

Complete algebraic semantics for second-order rewriting systems based on abstract syntax with variable binding

AbstractBy using algebraic structures in a presheaf category over finite sets, following Fiore, Plotkin and Turi, we develop sound and complete models of second-order rewriting systems called second-order computation systems (CSs). Restricting the algebraic structures to those equipped with well-founded relations, we obtain a complete characterisation of terminating CSs. We also extend the characterisation to rewriting on meta-terms using the notion of $\Sigma$ -monoid.

Simplified abstract syntax tree based semantic features learning for software change prediction

AbstractSoftware change prediction aims to identify the change‐prone parts of source code, which can help software practitioners allocate resources more efficiently, increase the quality of software products, and reduce maintenance costs. In recent years, researchers have built many change prediction models based on product and process metrics using traditional classification algorithms. However, source code contains rich semantic structural information, which traditional features cannot usually capture. Therefore, extracting the semantic features of code can help improve the performance of existing models. To bridge the gap between semantic features and change prediction, we introduce a novel change prediction approach based on a simplified abstract syntax tree (AST). Specifically, we first extract semantic features from partial AST nodes that pay attention to the syntax and semantic of code instead of all AST nodes. Then, a bidirectional recurrent neural network is utilized to model the deep semantic information of the code for change prediction. We also propose a new dataset that to some extent alleviates the data‐imbalance problem, which has become an active research topic. We conducted extensive experiments on the proposed dataset. The results show the effectiveness of semantic features for change prediction. Further, our model outperformed a state‐of‐the‐art code representation method.

Robust algorithmic binding to arbitrary fragment of program code

When solving a task, a programmer actively interacts with a finite set of code fragments. The information about their locations is important for quick navigation, for other developers, and as a kind of documentation. Integrated development environments (IDEs) provide tools for marking code fragments with labels, displaying lists of labels, and using these labels for quick navigation. However, they often lose the correspondence between the label and the marked place when the code is edited, in particular when changes are made outside the IDE. In previous works, the authors propose a tool to be integrated into various IDEs for “binding” to large syntactic entities of a program and building a markup that is robust to code editing. The description of the marked element is built on the basis of the abstract syntax tree (AST) of the program. Later it is used to algorithmically search for the element in an edited code. The search has a success rate from 99 to 100%. This article aims at robust algorithmic binding to an arbitrary section of the code. For binding to a single-line code fragment, we propose an extension of the model describing the marked fragment, and an additional search algorithm. We also propose an algorithm for embedding nodes corresponding to multi-line fragments in an AST. We show that the correctness of the AST is not violated by these embeddings. Bindings to randomly selected lines were made in the code of three large C# projects. Manual check of these lines search results in the edited code has confirmed that the bindings are robust to code editing.

New multi-agent approach for generating feedbacks base on Multiple Choice Questions

Most intelligent tutorial systems promote the learning and resolution of exercises based on feedback in the form of advice, remarks, explanation…To always remain in self-assessment, our approach offers a new type of feedback in the form of multiple-choice questions applied in the field of algorithms (language c, java ...) dedicated for beginners in programming. The approach is based on the multi-agent model to have interaction between learners without the help of the teacher. There are three types of agents in our work, there is the learner agent who represents the learner, there is also the feedback agent who sends the MCQs to the learners who made mistakes and finally, the controller agent feeds the base of multiple-choice questions based on feedback from learners. The controlling agent compares the instructions of the learners with the instructions of the correct model based on the AST abstract syntax tree and detects errors which will be proposed as erroneous items (distractors) for the learners. We can say that this type of feedback is not direct like other work (advice, comments, explanation ...) but we always remain in the evaluation: MCQ, exercise ... As perspectives, we will focus mainly on the classification of LO learning objects in the form of an ontology to facilitate the use of data and the generation of multiple-choice questions at different levels. And also, we aim to develop a suitable platform which allows to define the agents and the messages to be exchanged between them to set up our system.

What You See is What it Means! Semantic Representation Learning of Code based on Visualization and Transfer Learning

Recent successes in training word embeddings for Natural Language Processing ( NLP ) tasks have encouraged a wave of research on representation learning for source code, which builds on similar NLP methods. The overall objective is then to produce code embeddings that capture the maximum of program semantics. State-of-the-art approaches invariably rely on a syntactic representation (i.e., raw lexical tokens, abstract syntax trees, or intermediate representation tokens) to generate embeddings, which are criticized in the literature as non-robust or non-generalizable. In this work, we investigate a novel embedding approach based on the intuition that source code has visual patterns of semantics. We further use these patterns to address the outstanding challenge of identifying semantic code clones. We propose the WySiWiM ( ‘ ‘What You See Is What It Means ” ) approach where visual representations of source code are fed into powerful pre-trained image classification neural networks from the field of computer vision to benefit from the practical advantages of transfer learning. We evaluate the proposed embedding approach on the task of vulnerable code prediction in source code and on two variations of the task of semantic code clone identification: code clone detection (a binary classification problem), and code classification (a multi-classification problem). We show with experiments on the BigCloneBench (Java), Open Judge (C) that although simple, our WySiWiM approach performs as effectively as state-of-the-art approaches such as ASTNN or TBCNN. We also showed with data from NVD and SARD that WySiWiM representation can be used to learn a vulnerable code detector with reasonable performance (accuracy ∼90%). We further explore the influence of different steps in our approach, such as the choice of visual representations or the classification algorithm, to eventually discuss the promises and limitations of this research direction.

Supervised Authorship Segmentation of Open Source Code Projects

Abstract Source code authorship attribution can be used for many types of intelligence on binaries and executables, including forensics, but introduces a threat to the privacy of anonymous programmers. Previous work has shown how to attribute individually authored code files and code segments. In this work, we examine authorship segmentation, in which we determine authorship of arbitrary parts of a program. While previous work has performed segmentation at the textual level, we attempt to attribute subtrees of the abstract syntax tree (AST). We focus on two primary problems: identifying the primary author of an arbitrary AST subtree and identifying on which edges of the AST primary authorship changes. We demonstrate that the former is a difficult problem but the later is much easier. We also demonstrate methods by which we can leverage the easier problem to improve accuracy for the harder problem. We show that while identifying the author of subtrees is difficult overall, this is primarily due to the abundance of small subtrees: in the validation set we can attribute subtrees of at least 25 nodes with accuracy over 80% and at least 33 nodes with accuracy over 90%, while in the test set we can attribute subtrees of at least 33 nodes with accuracy of 70%. While our baseline accuracy for single AST nodes is 20.21% for the validation set and 35.66% for the test set, we present techniques by which we can increase this accuracy to 42.01% and 49.21% respectively. We further present observations about collaborative code found on GitHub that may drive further research.

Code Completion by Modeling Flattened Abstract Syntax Trees as Graphs

Code completion has become an essential component of integrated development environments. Contemporary code completion methods rely on the abstract syntax tree (AST) to generate syntactically correct code. However, they cannot fully capture the sequential and repetitive patterns of writing code and the structural information of the AST. To alleviate these problems, we propose a new code completion approach named CCAG, which models the flattened sequence of a partial AST as an AST graph. CCAG uses our proposed AST Graph Attention Block to capture different dependencies in the AST graph for representation learning in code completion. The sub-tasks of code completion are optimized via multi-task learning in CCAG, and the task balance is automatically achieved using uncertainty without the need to tune task weights. The experimental results show that CCAG has superior performance than state-of-the-art approaches and it is able to provide intelligent code completion.

Syntactic Valence, Syntactic Relation

Syntax (ancient Greek σύν-ταξις “composition”, “coordination”, “order”) is a section of linguistics in which nominative and communicative linguistic units are studied: a sentence and a phrase. Literally translated syntax means not only composing, but also ordering, coordinating, combining words into a coherent text. The following article looks into the syntactic relations and valence in the English language.

Long short‐term memory on abstract syntax tree for SQL injection detection

SQL injection attack (SQLIA) is a code injection technique, used to attack data-driven applications by executing malicious SQL statements. Techniques like pattern matching, software testing and grammar analysis etc. are frequently used to prevent such attack. However, major bottlenecks still remain in detecting SQLIA with bypassing techniques, getting access to source code and requiring an additional manual operation to extract features. The authors propose a novel detection approach based on long short-term memory and abstract syntax tree, which could detect SQLIAs from the raw query strings and work under SQL detection bypassing scenario. Our deep learning technique explicitly uses both context and syntax information that previous methods failed to fully grasp. Experimental results clearly illustrate the superior performance of our method compared to other existing works when detecting with complete SQL raw queries.

Rečenična dopuna u formi zavisne rečenice i infinitivske konstrukcije

Syntax, as an important part of grammar, deals with the analysis of sentences and their elements. Many grammarians have paid great attention to sentence complements which, according to the dependent model of grammar, represent a very important part of a sentence. The structure or syntax of a sentence in German is probably the most complex topic in German grammar. One of the grammarians who devoted himself to this field of grammar was Ulrich Engel. Using the dependent model of grammar, Engel managed to bring the syntax of the German language closer to many Germanists in a simple way, and not only in the Germanspeaking area. Infinitive construction and dependent sentences are forms with the help of which certain sentence additions can be realized. Using the model of dependent grammar, this paper explains the process of realization of sentence addition, using examples from a specialized corpus, i.e., the first two chapters of the work Tin Drum (Die Blechtrommel) by Günther Grass, and the analysis of the content led to key answers.

A structural model for contextual code changes

We address the problem of predicting edit completions based on a learned model that was trained on past edits. Given a code snippet that is partially edited, our goal is to predict a completion of the edit for the rest of the snippet . We refer to this task as the EditCompletion task and present a novel approach for tackling it. The main idea is to directly represent structural edits. This allows us to model the likelihood of the edit itself, rather than learning the likelihood of the edited code. We represent an edit operation as a path in the program’s Abstract Syntax Tree (AST), originating from the source of the edit to the target of the edit. Using this representation, we present a powerful and lightweight neural model for the EditCompletion task. We conduct a thorough evaluation, comparing our approach to a variety of representation and modeling approaches that are driven by multiple strong models such as LSTMs, Transformers, and neural CRFs. Our experiments show that our model achieves a 28% relative gain over state-of-the-art sequential models and 2× higher accuracy than syntactic models that learn to generate the edited code , as opposed to modeling the edits directly. Our code, dataset, and trained models are publicly available at <a>https://github.com/tech-srl/c3po/</a> .

Defining Theoretical Foundations to Unified Metamodel For Model Reusability

Background: In model-driven development, model transformation transforms one model to another between different phases of software engineering. In model transformation, metamodel plays a vital role which defines the abstract syntax of models and the interrelationship between their elements. A unified metamodel defines an abstract syntax for both source and target models when they share core elements. Theoretical approaches define language and platform independent representation of models in software engineering. This paper investigates the theoretical foundation to this unified meta-modelling for their consistent transformation. Objective: This paper aims to define the formal foundations to the unified metamodel for generating implementation from design specifications and model reusability. Method: In this paper, the study considers transformation from design to implementation and vice versa using theoretical foundations to build a verified software system. Results: The related tools provide a formal representation of the design phase for verification purpose. Our approach provides a set-theoretical foundation to the unified metamodel for model transformation from USE (UML/OCL) to Spec#. In other words, our approach defines the formal foundation to define a model which consists of all the required properties for verification at the design and implementation phase. Conclusion: This paper introduced a new set of the theoretical framework which acts as an interface between the design and implementation to generate verified software systems.