Erlang refactoring with relational database Anik Vg and

Erlang refactoring with relational database Anikó Víg and Tamás Nagy Supervisors: Zoltán Horváth and Simon Thompson Project members: László Lövei, Tamás Kozsik Supported by ELTE IKKK, Ericsson Hungary, in cooperation with University of Kent

Refactor n Refactoring is restructuring program code without altering its external behaviour n Aims: restructuring of code, code quality improvement, coding conventions, optimization, migrating to new API n In general not available for functional languages, only: Ha. Re (AST) and Clean refactoring (relational database)

Erlang n Functional programming language and runtime n n n environment developed by Ericsson Designed to build distributed, reliable, soft realtime concurrent systems (telecommunication) Highly dynamic nature Lightweight processes and message passing Messages can be sent to a process ID or registered name, which are bound to function code at runtime. Possibility of running dynamically created code (eval, hot code replacement).

Erlang n Function id-s are atoms, atoms may be constructed n n n runtime (and passed as arguments to apply, spawn). The syntactical category of an atom may be a function or ”string”, etc. Side effects are restricted to message passing and built-in functions Modules with explicit interface definitions and static export and import lists No static type system Variables are assigned a value only once in their life Variables are not typed statically, they can have a value of any data type.

The refactor tool Distel ODBC (? ) Emacs Source code In Emacs Erlang node My. SQL AST of the source Source in the database

Code , AST

Storing the code in database n Every node in a tree has a unique identifier. n Every module has a unique module identifier. n Almost every syntax-tree node type has an own database table n The records in the tables contain the identifiers of the current nodes and their children’s ones. n We store the positions, node types and names in separate tables.

Semantic informations n We store the semantic informations in separate tables: identical variables, function definitions and their calling expressions, scope of the nodes, hierarhy of scopes n AST + semantic informations = graph, not tree. + Searching and using a graph is more efficient with relational database as traversing the tree. - The storing-recovering of the code and communication with the database is more expensive

Our own tables: visibility of variables

Our own tables: function calls

Our own tables: visibility of scopes

Problems during the building up n The Erlang prepocessor substitutes the macro definitions using epp_dodger instead of epp n Every node has only the line number of position informations using erl_scan 1 (modified by Huiqing) instead of erl_scan: it can give back the column information too

Problems during the building up n In Erlanguage there are many types of comments: we have not only comments, but pre- and postcomments too, which can be list of comment nodes. n The erl_comment_scan: file collects the comments from the file, and we have to put them too with the correct position information into the database. n There is the same problem with the column infomation so we use erl_recomment 1 instead of erl_recomment.

The algorithms n We use postorder traverse on the syntax tree to give identifiers and put the nodes into the correct table. n We use preorder traverse on the syntax tree to get the visibility information. n The other information come from the database (collected by separate processes), for example the information of the function callings.

Analysis for Refactoring Steps n Syntax analysis (AST) n Static semantics (Annotated AST or relational database): scope, visibility, binding structure, type information. n Side-condition analysis n Compensations n Dynamic function calls (apply, spawn, etc. ) n Syntactical, semantical and library coverage

Rename variable n Definition: Find every occurrence of the variable (i. e. the variables with the same name in the visibility range of the variable) and replace every occurrence with the new name. n Precondition: The new variable name is not visible at any occurrence of the variable n Limited to one module (no global variables)

Rename function n Definition: The refactoring rely on finding the definition and every place of call for a given function and substitute it with a new name. n Preconditions: No name clash in the current module (existing functions, import list) n No name clash in other modules, if the function is exported n

Reorder arguments n Definition: Change the order of arguments in the same way at the definition and every place of call for a given function. n Preconditions: n No side effect of the parameters (just planned) n Tricky implicit function calls delete, create subtree (the same problem will be at the tuple arguments refactor step too)

Implicit function example

Tuple arguments n Definition: Change the way of using some arguments at the definition and at every place of call for a given function by grouping some arguments into one tuple argument. n Preconditions: n n The given position must be within a formal argument of a function definition The function must be a declared function, not a funexpression The given number must not be too large No name clash if the arity is changing (not only in the current module if the function is exported)

Eliminate variable n Definition: All instances of a variable are replaced with its bound value in that region where the variable is visible. The variable can be left out where its value is not used. n Preconditions: n n n It has exactly one binding occurrence on the left hand side of a pattern matching expression, and not a part of a compound pattern. The expression bound to the variable has no side effects. Every variable of the expression is visible (that is, not shadowed) at every occurrence of the variable to be eliminated.

Eliminate variable cont. n Decide if an occurrence is needed (remove or replace). Remove if: n n Not at the end of block expression Not at the end of clause body Not at the end of the recieve expression action Not at the end of try expression body, after branch and handler n Replicate subtree, because we need unique id-s in the new subtrees. The subtree can contain every node type, we had to implement the most of the syntax tool module for database representation.

Planned refactor steps (short term) n Merge subexpression duplicates: All instances of the same subexpressions are stored in a variable that the user gives, then all instances of the original subexpression are changed to the variable. n Extract function: An alternative of a function definition might contain a sequence of expressions which can be considered as a logical unit, hence a function definition can be created from it. The extracted function is lifted to the module level, and it is parameterised with the variables that the expressions depend on. The sequence of expressions is replaced with a function call expression.

Planned refactor steps (middle term) n Tuple to record n Specialisation of functions n Generalisation of functions n Fusion of functions n Modification of data structures

Future work n Testing in big projects n Compare the two approaches n Making a common release version