FINE-GRAIN TRANSFORMATIONS FOR REFACTORING EMMAD I. M. SAADEH THESIS

Transcription

1 FINE-GRAIN TRANSFORMATIONS FOR REFACTORING By EMMAD I. M. SAADEH THESIS Submitted in partial fulfillment of the requirements for the degree of Philosophiae Doctor (Computer Science) in the Faculty of Engineering, Built Environment and Information Technology of the University of Pretoria, 2009 Pretoria, South Africa University of Pretoria

2 FINE-GRAIN TRANSFORMATIONS FOR REFACTORING By: Emmad I. M. Saadeh Supervisor: Prof. Derrick Kourie Department: Computer Science Degree: PhD (Computer Science) ABSTRACT This thesis proposes a new approach to formalize refactorings, principally at the UML class diagram design level (but incorporating a limited amount of code-level information basic access-related information). A set of abstract and atomic fine-grain transformations (FGTs) is defined as prototypical building blocks for constructing refactorings. The semantics of each FGT is specified in terms of its pre- and postcondition conjuncts. Various logical relationships between FGT pre- and postcondition conjuncts are fully catalogued. These include uni- and bidirectional sequential dependency relationships; absorbing and cancelling reduction relationships; and uni- and bi-directional conflict relationships. The principle container for FGTs is an FGT-list in which the ordering of FGTs respects the sequential relationships between them. Such a list is characterised by the set of FGT precondition conjuncts (which a system should satisfy if the FGTs are to be sequentially applied to the system) as well as the resulting postcondition conjuncts (that describe the effect of applying the list). In the thesis, twenty-nine commonly used primitive refactorings are specified as such FGT-lists, together with their associated FGT-enabling precondition conjuncts. Refactoring-level pre- and postconditions are also identified for each primitive refactoring FGT-list. These are, of course, required to guarantee behaviour preservation. An alternative container for FGTs is defined, called an FGT-DAG. It is a directed acyclic graph with FGTs as nodes, and with arcs that reflect the sequential dependency relationships between constituent FGTs. An algorithm is provided to convert a list of FGTs into a corresponding set of FGT-DAGs. Thus design level refactorings specified as FGT-lists can be also be converted to corresponding sets of FGT-DAGs. The precondition for applying such a refactoring to a given system is specified at two levels: the FGT-enabling precondition conjuncts that apply to each FGT-DAG, and the refactoring-level precondition conjuncts. The thesis provides various algorithms that operate on FGT-DAGs. These include an algorithm to remove redundancies from an FGT-DAG. It also includes algorithms that operate on the i

3 elements of a set of FGT-DAGs: to detect sequential dependencies between these elements, to detect whether they are in deadlock, and to detect and possibly remove or modify FGTs causing conflicts between them. In addition, an algorithm is provided to build composite refactorings from primitive refactorings. It indicates how composite-level and FGT-enabling precondition conjuncts can be derived and utilised to avoid the rollback problem. A Prolog prototype FGT-based refactoring tool has been implemented. The tool stores all of the above-mentioned catalogued information as Prolog rules and facts. This includes the twenty-nine commonly used primitive refactorings (stored as Prolog FGT-lists) and their associated refactoring-level pre- and postcondition conjuncts. The tool also implements all the previously mentioned algorithms as Prolog procedures. The thesis thus establishes the foundations for a tool in which end users can create (and apply without rollback) not only composite refactorings, but also completely new refactorings whose semantics is constrained only by the fine-grained semantics of FGTs, rather than by the more course-grained semantics of primitive refactorings. Furthermore, using FGTs as refactoring building blocks (i.e. instead of primitive refactorings) means that redundancies and conflicts can be more accurately pin-pointed and removed; and opportunities for parallel execution are exposed at a more fine-grained level. These advantages come at the cost of having to carry out more computations because analysis has to take place at the FGT-level rather than at the refactoring-level. ii

4 To my father, mother & my wife for their encouragement and support. iii

5 Acknowledgments First, I am thankful to God for having granted me the skills, power, patience, and opportunities that made this possible in spite of all the other commitments and responsibilities that I had. I would like to thank my supervisor, Prof. Derrick Kourie, for his support, guidance and patience along these years, and for providing constant direction. He has been a source of encouragement and inspiration. I learned a lot from the feedback he gave me. I was amazed by both his insights and his stamina. He invested his most valuable resource on my behalf: his time. I owe thanks to my colleagues in the Espresso Research Group and in the Computer Science Department in University of Pretoria for all the encouragements during the different stages of this work. I thank my parents, brothers and sisters for their support. I especially appreciated my father's words of encouragement. I thank my children Ibraheem, Marah, and Adam for many encouraging times together. I owe them all the time I spent to accomplish this work. I am especially thankful to my wife Hadeel for her love, support, and patient throughout this entire process. I really thank her for all the responsibilities she took on behalf of me to give me a chance to do my research. Without her, I never would have made it through the program. As a wife and mother, she picked up the slack and encouraged me in an extraordinary way. She deserves an award at least as valuable as my PhD. iv

6 TABLE OF CONTENTS Page ABSTRACT ACKNOWLEDGEMENTS TABLE OF CONTENTS LIST OF FIGURES LIST OF TABLES LIST OF ALGORITHMS i iv v x xii xiii I Prologue CHAPTER 1. INTRODUCTION The Problem The Proposed Formalism Thesis Overview REFACTORING STATE OF THE ART Software Evolution Refactoring Codes Level Non-Object-Oriented Programming Languages Object-Oriented Programming Languages Design Level Models Database Schemas Level Software Architectural Level Software Requirements Level Formalisms Graph Transformations Pre- and Postcondition Program Slicing Formal Concept Analysis II The Approach 3. LOGIC-BASED REPRESENTATION Introduction Object Element Logic-Terms Relation Element Logic-Terms Example Reflection on this Chapter v

7 4. FGT-BASED APPROACH Introduction Fine-Grain Transformations (FGTs) Object Element FGTs addobject FGT renameobject FGT changeoamode FGT changeodeftype FGT deleteobject FGT Relational Element FGTs addrelation FGT renamerelation FGT deleterelation FGT FGT Sequential Dependency Definition Uni-Directional Sequential Dependencies Bi-Directional Sequential Dependency Mapping Feasible FGT-Lists to FGT-DAGs FGTs for Primitive and Composite Refactorings Definitions FGT-Enabling Preconditions in an FGT-DAG FGTs and Primitive Refactorings Preconditions Applying Refactorings Reflection on this Chapter PRIMITIVE REFACTORINGS AS FGT COLLECTIONS Introduction Add Element Refactorings addclass addmethod addattribute addparameter addgetter addsetter Change Element Refactorings Changing Characteristics renameclass renamemethod renameattribute renameparameter changeclassaccess changemethodaccess changeattributeaccess changemethodreturntype changeattributedeftype changeparameterdeftype Change Structure (Restructuring) vi

8 changesuper movemethod moveattribute attributereadstomethodcall attributewritestomethodcall pullupmethod pushdownmethod pullupattribute pushdownattribute Delete Element Refactorings deleteclass deletemethod deleteattribute deleteparameter Reflection on this Chapter MOTIVATED EXAMPLE LAN Simulation Logic-Based Representation encapsulateattribute Refactoring createclass Refactoring pullupmethod Refactoring LAN after Refactorings III Features Of The Approach 7. REDUNDANCY REMOVAL Introduction Absorbing Reduction Cancelling Reduction Advantages of Reduction Process Reduction Algorithm Example Efficiency Considerations DETECTING AND RESOLVING CONFLICTS Introduction Conflicts in FGT-Based Approach FGT's Conflicts-Pairs Bi-Directional Conflict Uni-Directional Conflict Conflict Algorithm LAN Motivated Example Reflections on Conflicts SEQUENTIAL DEPENDENCY BETWEEN REFACTORINGS Introduction Sequential Dependency in Previous Approaches vii

9 9.3 Sequential Dependency between FGT-Based Refactorings Sequential Dependency Algorithm Deadlock Problem LAN Motivated Example COMPOSITE REFACTORINGS Introduction FGT-based Composite Refactoring Examples encapsulateattribute Composite Refactoring enh-pullupattribute Composite Refactoring Reflection on this Chapter PARALLELIZING OPPORTUNITIES Introduction Parallelizing Opportunities Reflection on Parallelization NEW REFACTORINGS Introduction Example New Refactorings in the FGT-Based Approach Reflection on this Chapter IV Epilogue 13. CONCLUSIONS Summary Conclusions Future Work V Appendix A. FGT SEQUENTIAL DEPENDENCY A.1 Uni-Directional Sequential Dependencies A.2 Bi-Directional FGTs Sequential Dependencies B. PRIMITIVE REFACTORINGS AS FGT SEQUENCES B.1 Add Element Refactorings B.1.1 addclass B.1.2 addmethod B.1.3 addattribute B.1.4 addparameter B.2 Rename Element Refactorings B.2.1 renameclass B.2.2 renamemethod B.2.3 renameattribute B.2.4 renameparameter B.3 Change Characteristics Refactorings viii

10 B.3.1 changeclassaccess B.3.2 changemethodaccess B.3.3 changeattributeaccess B.3.4 changemethodreturntype B.3.5 changeattributedeftype B.3.6 changeparameterdeftype B.4 Delete Element Refactorings B.4.1 deletemethod B.4.2 deleteattribute B.4.3 deleteparameter BIBLIOGRAPHY ix

11 LIST OF FIGURES Page 1.1 pullupmethod Refactoring: (a) before refactoring, (b) after refactoring Refactorings as black box Refactorings as hard coded sequence of statements Refactoring as a set of FGT-DAGs Simplified UML meta-model A simple UML class diagram of the SimpleSys A code-level implementation of the SimpleSys Underlying logic representations of the SimpleSys Potential sequential dependencies between FGTs FGT-DAGs of refactoring X Primitive, composite refactorings and FGTs Primitive refactoring different considerations Class A before and after addgetter(a.x) Class A before and after addsetter(a.x) Class A & B before and after movemethod(b.m, A, [int]) Class A & B before and after moveattribute(a.x, B) A UML class diagram of the LAN simulation before refactoring A code-level implementation of the LAN simulation before refactoring Underlying logic representations of the LAN simulation before refactoring Packet & Workstation classes before and after encapsulateattribute refactoring Underlying logic representations of the LAN simulation after refactorings A UML class diagram of the LAN simulation after refactoring A code-level implementation of the LAN simulation example after refactoring Part of the reduction facts as implemented in Prolog Reduction inside refactoring Refactoring X after reduction Conflict between refactorings R i & Rj Conflicts detection in FGT-based approach Possible conflicts between FGTs A Selection of fgtconflict facts as implemented in Prolog A simplified UML class diagram of a college system Conflict detection & resolving algorithm Conflicts between refactorings movemethod & pullupmethod Sequential dependency between refactorings R i & R j Ambiguous sequential dependency Sequential dependency in FGT-based approach Refactoring Directed Acyclic Graphs (REF-DAGs) Deadlock problem Sequential dependency between refactorings createclass & pullupmethod Straightforward approach Composite refactoring in composite preconditions approaches x

12 10.3 Composite refactoring in FGT approach A simplified UML class diagram of a college system encapsulateattribute composite refactoring encapsulateattribute composite refactoring in FGT approach A simplified UML class diagram. (a) before and (b) after refactoring enh-pullupattribute composite refactoring Part of the LAN system's class diagram Part of the LAN system's class diagram after enh-pullupmethod xi

13 LIST Of TABLES Page 4.1 Primitive refactorings encapsulateattribute refactoring createclass refactoring pullupmethod refactoring Absorbing reduction Cancelling reduction Bi-directional FGT conflict-pairs Uni-directional FGT conflict-pairs encapsulateattribute refactoring enh-pullupattribute refactoring A comparison between FGTs-based and alternative formalisms xii

14 LIST OF ALGORITHMS Page 4.1 Building FGT-DAGs algorithm Reduction algorithm Conflict detection & resolving algorithm Sequential dependency algorithm Deadlock detection algorithm xiii

15 Part I Prologue 1

16 CHAPTER 1 INTRODUCTION 1.1 The Problem Software that is used in a real-world environment inevitably changes or becomes progressively less useful in that environment. As evolving software changes, its structure tends to become more complex [46]. Because of this, the major part of the total software development cost is devoted to software maintenance [9, 29, and 47]. Better software development methods and tools do not THE THESIS Prologue I The Approach II Features Of The Approach III Epilogue IV Appendix V INTRODUCTION REFACTORING _ STATE OF THE ART2 solve this problem, because their increased capacity is used to implement more new requirements within the same time frame [25], making the software more complex again. To cope with this spiral of complexity, there is an urgent need for techniques that reduce software complexity by incrementally improving the internal software quality. The research domain that addresses this problem is referred to as restructuring [1, 28] or, in the specific case of objectoriented software development, refactoring [22, 65]. [59] Refactoring is the process of improving the internal structure of the software while preserving its external behaviour [22, 65 and 70]. By improving the internal structure it is meant that refactoring will restructure the software in order to improve its quality by making it easier to understand, to extend, to find bugs, and to program faster [2, 60]. Preserving the external behaviour means, before and after applying the refactoring, the software will require the same preconditions and result in the same postconditions. The refactoring community assumes a set of precondition conjuncts for each refactoring that needs to be satisfied as a condition for applying that refactoring. To give an idea about refactoring before going into the details of the thesis, Figure 1.1(a) shows a simple example of a UML class diagram with four classes: HR, Employee as a superclass, Salesman and Engineer as subclasses of Employee. The HR class has two association relations, one with each of the Salesman and Engineer classes. The Salesman and Engineer subclasses have the same method getname which is called by the method report in the HR class. 1 LOGIC-BASED REDUNDANCY FGT SEQUENTIAL REPRESENTATION3 REMOVAL 7 CONCLUSIONS 13 DEPENDENCY A DETECTING AND FGT-BASED PRIMITIVE RESOLVING APPROACH 4 8 REFACTORINGS B CONFLICTS AS FGT SEQUENCES SEQUENTIAL PRIMITIVE DEPENDENCY REFACTORINGS AS 5 BETWEEN 9 FGT COLLECTIONS REFACTORINGS COMPOSITE MOTIVATED REFACTORINGS 10 EXAMPLE 6 PARALLELIZING OPPORTUNITEIS 11 NEW REFACTORINGS 12 2

17 Figure 1.1: pullupmethod Refactoring: (a) before refactoring, (b) after refactoring Note that the duplication of the getname method in the two subclasses as shown in Figure 1.1(a) causes the following design problems: 1. More efforts and spaces are needed at the design and code levels. 2. There is an increased chance of inconsistency between the two copies. This can arise if the developer changes one of the two copies and forgets to change the other. 3. The design is complicated, because the same method appears two times in the design. This also causes two association relations to be created between HR class and each one of the two subclasses. To solve these problems, it is preferred to change the design by deleting the getname method from the two subclasses and move it to their superclass, as shown in Figure 1.1(b). As a result, one copy of the getname method will appear in the design and also the two association relations between the HR class and the two subclasses will be replaced by one association relation between the HR class and the Employee class. Doing this restructuring will increase the quality of the internal design of the class diagram without changing the external behaviour of the system (The system will make the same services as before restructuring). This is because the getname method will be inherited to the two subclasses. The associated association relation also will be inherited. The restructuring done in the previous example is an example of refactoring. In this case, it is a pullupmethod refactoring. The precondition for the pullupmethod refactoring that should be satisfied in order to apply the refactoring to the system, as a condition to preserve the behaviour of the system is: 3

18 1. The getname method should not be declared in the superclass (Employee) or any of its ancestors. 2. The access mode of the getname method in the subclasses is not private. 3. All the references made by the getname method must be visible from the superclass. 4. The signature of the method in all the subclasses should be the same. A current research trend is to investigate refactorings at levels of abstraction above the codelevel [23, 68, and 81]. This is because many people are visually oriented and prefer to visualize the relationships between classes rather than apprehend them textually. Furthermore, being able to directly manipulate code at a higher level of granularity (i.e. methods, variables, and classes rather than characters) can make refactoring more efficient [2]. Therefore, this thesis also focusses on refactorings at the design level. Several approaches have been used to formalize such refactorings, as discussed in section 2.4. For example, the graph transformations approach [11, 18 and 19] represents software as a graph, and refactorings are formalized as graph-production rules [7, 34, 51-56, and 63]. As another approach, the logic-based conditional transformation approach [38, 39] represents software as logic-terms and refactorings are formalized as conditional transformations with pre- and postconditions. In general, reasoning takes place at the level of refactorings themselves, and attention is not paid to the detailed transformational steps that must be applied to the model to achieve the refactoring. Such reasoning is with respect to a set of preconditions that must be satisfied in order to apply that refactoring, resulting in a set of postconditions. In this sense, a refactoring is treated as an abstraction, or as a black box as illustrated in Figure 1.2. Figure 1.2: Refactorings as black box Of course, to be of practical value, these conceptual ideas have to be implemented in refactoring tools. Such a tool would have to access some representation of an underlying system that is to be refactored. The refactorings themselves are implemented as hard coded parameterise procedures i.e. as a sequence of code statements. To apply a particular 4

19 refactoring to the underlying system, the tool requires an interface that allows the user to select and invoke procedures which then execute the actual refactoring, thus changing the underlying system representation accordingly. Figure 1.3: Refactorings as hard coded sequence of statements Treating refactoring as a black box can be notionally conceived of as shown in Figure 1.3. Whenever a refactoring is applied, the hard coded sequence of statements is executed atomically. The inter-relationship between the different code statements both within and between refactorings cannot be determined. This has the following implications: 1. Where redundancy inside or between refactoring may exist, there is no possibility to remove it. As shown in the figure on the right, there could be a redundancy between statement 3 and 20 in the code. For example, if statement 3 adds an attribute to a specific class in the system and subsequently statement 20 deletes or changes the name or definition type of that attribute, the redundancy cannot be removed. This kind of scenario could arise, for example, when composing two or more refactorings into a single one. 2. Where conflict occurs between two refactorings, it is not possible to determine which part of the two refactorings caused the conflict. The figure on the right side illustrates this by showing a conflict between statement 3 in Refactoring X Refactoring X S ta te m e n t 1. S ta te m e n t 2. S ta te m e n t S ta te m e n t S ta te m e n t n -1. S ta te m e n t n. refactoring X and statement 20 in refactoring Y. For example, statement 3 might add an attribute to a specific class in the system, based on a precondition of refactoring X that the class exists but does not have that attribute. On the other hand, statement 20 might delete that class from the system, based on the precondition that the class exists and has no attributes. Redundacy Statement 1. Statement 2. Statement Statement n-1. Statement n. Conflict Refactoring Y Statement 1. Statement 2. Statement Statement Statement n-1. Statement n. 5

20 This would constitute a conflict between the two refactorings if they were to be applied as separate threads to the system. 3. Where there is a sequential dependency between two refactorings, there is no possibility to know at what specific point on it one of the two refactorings is sequentially dependent on the other. As shown in the figure on the right side if there is a sequential dependency between statement 3 in refactoring X and statement 20 in refactoring Y. Where statement 3, for example, adds a class to the system and statement 20 adds an attribute to that class. In this case refactoring Y is considered to be sequentially dependent on refactoring X and having to be applied to the system after refactoring X. Again, because the two refactorings are considered as code sequences, there is no possibility to know at what specific point in the code one of the two refactorings becomes sequentially dependent on the other. 4. Because refactorings are considered as code sequences, two or more refactorings can only be run in parallel if they are shown to be sequentially independent of each other. Because there is no metainformation about the nature of sequential dependency between their constituent code statements, it is not possible to determine whether parts of the refactorings could be run in parallel. Refactoring X 5. A new composite refactoring can be assembled by using previously-defined refactorings as building blocks. Its constituent elements can only be analysed for redundancy, conflicts, sequential dependency and possible parallelization with reference to the pre- and postconditions of these elements i.e. with reference to the properties of the original refactorings. Nevertheless, as will be discussed later, such an analysis can suggest an ordering of the constituent refactorings which will avoid the so-called rollback problem. 6. If a tool allows a user to build new refactorings, the semantics of any new refactoring is necessarily constrained by the selection of refactorings that have been implemented in the tool. Any refactoring whose semantics goes beyond that will have to be hard coded as a task to be undertaken by the tool developer, rather than the tool user. Statement 1. Statement 2. Statement Statement n-1. Statement n. Sequential Dependecy Seq. Execution Refactoring Y Statement 1. Statement 2. Statement Statement Statement n-1. Statement n. Refactoring X Statem ent 1. Statem ent 2. Statem ent Statem ent n-1. Statem ent n. 6