Graph-based specification and verification for aspect-oriented languages

摘要

Aspect-oriented software development aims at improving separation of concerns at all levels in the software development life-cycle, from architecture to code implementation. In this thesis we strive to develop verification methods specifically for aspect-oriented programming languages. For this purpose, we model the behaviour of these languages through an operational semantics. We use graph transformations to specify these semantics. Graph transformation has mathematical foundation, and provides an intuitive way to describe component-based systems, such as software systems. In addition, graph transformations have an executable nature, and can be used to generate the execution state space of programs. We use these state spaces for the verification of programs with aspects. We start by defining an improvement of specification using rule-based systems. Pure rule-based systems typically consist of a single, unstructured set of rules. We propose so-called control automata, which can be added on top of pure rule-based systems. Then, we specify the runtime semantics of a number of aspect-oriented languages, namely of (1) Composition Filters, (2)Featherweight Java with assignments with an aspectual extension, and (3) a subset of multithreaded Java extended with a subset of AspectJ. We show that such semantics can be used to simulate a (partial) program and we expose the steps involved in the execution of such a program and that the resulting labelled transition systems can be used for existing verification methods. Then, we propose two novel approaches that address complications caused by the use of aspect-oriented programming. The approaches are based on the given semantics. The first approach allows the detection of aspect interference on shared join points by performing a confluence analysis on the resulting state space. The second approach allows the verification of run-time properties that require tracking of individual objects over time. This is achieved by extending the semantics with special rules for adding tracking information to the graphs. We show that the approach can be used for both object-oriented and aspect-oriented implementations.