ptolemy.backtrack.eclipse.ast.transform

Class AssignmentTransformer

java.lang.Object

ptolemy.backtrack.eclipse.ast.transform.AbstractTransformer

ptolemy.backtrack.eclipse.ast.transform.AssignmentTransformer

All Implemented Interfaces:

AliasHandler, AssignmentHandler, ClassHandler, CrossAnalysisHandler, FieldDeclarationHandler, MethodDeclarationHandler

public class AssignmentTransformer
extends AbstractTransformer
implements AliasHandler, AssignmentHandler, ClassHandler, CrossAnalysisHandler, FieldDeclarationHandler, MethodDeclarationHandler

The assignment transformer to transform Java source programs into new programs that support backtracking.

In this approach, each assignment to a state variable is refactored to become a method call, which, before actually assigning the new value, back up the old value of the field in a record (see FieldRecord).

This transformer implements several handlers. It does the refactoring as the type analyzer (TypeAnalyzer) analyzes the original source code. The analyzer calls back methods defined in the handlers after assigning appropriate types to AST nodes. Those callback methods (implemented in this class) refactors the given nodes on-the-fly as the type analysis goes on.

This class must be used at the same time as ConstructorTransformer to get the correct refactoring result.

Since:

Ptolemy II 5.1

Version:

$Id$

Author:

Thomas Feng

Pt.AcceptedRating:

Red (tfeng)

Pt.ProposedRating:

Red (tfeng)

Field Summary

Fields

Modifier and Type	Field and Description
static java.lang.String	COMMIT_NAME The name of commit methods.
static boolean	HANDLE_STATIC_FIELDS Whether to refactor private static fields.
static boolean	OPTIMIZE_CALL Whether to optimize method calls.
static java.lang.String	PROXY_NAME The name of the proxy class created in each anonymous class.
static java.lang.String	RECORD_PREFIX The prefix of records (new fields to be added to a class).
static java.lang.String	RECORDS_NAME The name of the record array.
static java.lang.String	RESTORE_NAME The name of restore methods.

Fields inherited from class ptolemy.backtrack.eclipse.ast.transform.AbstractTransformer

ASSIGN_PREFIX, BACKUP_PREFIX, CHECKPOINT_NAME, CHECKPOINT_RECORD_NAME, GET_CHECKPOINT_NAME, SET_CHECKPOINT_NAME

Constructor Summary

Constructors

Constructor and Description
AssignmentTransformer()

Method Summary

Modifier and Type	Method and Description
void	enter(org.eclipse.jdt.core.dom.AnonymousClassDeclaration node, TypeAnalyzerState state) Enter an anonymous class declaration.
void	enter(org.eclipse.jdt.core.dom.FieldDeclaration node, TypeAnalyzerState state) Enter a field declaration.
void	enter(org.eclipse.jdt.core.dom.MethodDeclaration node, TypeAnalyzerState state) Enter a method declaration.
void	enter(org.eclipse.jdt.core.dom.TypeDeclaration node, TypeAnalyzerState state) Enter an class declaration.
void	exit(org.eclipse.jdt.core.dom.AnonymousClassDeclaration node, TypeAnalyzerState state) Exit an anonymous class declaration, and add extra methods and fields to it.
void	exit(org.eclipse.jdt.core.dom.FieldDeclaration node, TypeAnalyzerState state) Exit a field declaration.
void	exit(org.eclipse.jdt.core.dom.MethodDeclaration node, TypeAnalyzerState state) Exit a method declaration.
void	exit(org.eclipse.jdt.core.dom.TypeDeclaration node, TypeAnalyzerState state) Exit a class declaration, and add extra methods and fields to it.
void	handle(org.eclipse.jdt.core.dom.Assignment node, TypeAnalyzerState state) Handle an assignment, and refactor it to be a special method call if the left-hand side of the assignment is a state variable.
void	handle(org.eclipse.jdt.core.dom.ClassInstanceCreation node, TypeAnalyzerState state) Handle a class instance creation.
void	handle(org.eclipse.jdt.core.dom.MethodInvocation node, TypeAnalyzerState state) Handle a method invocation.
void	handle(org.eclipse.jdt.core.dom.PostfixExpression node, TypeAnalyzerState state) Handle a postfix expression, and refactor it to be a special method call if its subexpression evaluates to be a state variable.
void	handle(org.eclipse.jdt.core.dom.PrefixExpression node, TypeAnalyzerState state) Handle a prefix expression, and refactor it to be a special method call if its subexpression evaluates to be a state variable.
void	handle(org.eclipse.jdt.core.dom.ReturnStatement node, TypeAnalyzerState state) Handle a return statement.
void	handle(TypeAnalyzerState state) Fix the refactoring result when the set of cross-analyzed types changes.
void	handle(org.eclipse.jdt.core.dom.VariableDeclarationFragment node, TypeAnalyzerState state) Handle a variable declaration fragment.

Methods inherited from class ptolemy.backtrack.eclipse.ast.transform.AbstractTransformer

_getAssignMethodName, _getBackupMethodName, addToLists, createName, createType, getClassName, getClassName, hasMethod, hasMethod, indexOf, isFieldDuplicated, lastIndexOf, removeNode, replaceNode

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

COMMIT_NAME

public static final java.lang.String COMMIT_NAME

The name of commit methods.

See Also:

Constant Field Values

HANDLE_STATIC_FIELDS

public static final boolean HANDLE_STATIC_FIELDS

Whether to refactor private static fields.

See Also:

Constant Field Values

OPTIMIZE_CALL

public static final boolean OPTIMIZE_CALL

Whether to optimize method calls. (Not implemented yet.)

See Also:

Constant Field Values

PROXY_NAME

public static final java.lang.String PROXY_NAME

The name of the proxy class created in each anonymous class.

See Also:

Constant Field Values

RECORDS_NAME

public static final java.lang.String RECORDS_NAME

The name of the record array.

See Also:

Constant Field Values

RECORD_PREFIX

public static final java.lang.String RECORD_PREFIX

The prefix of records (new fields to be added to a class).

See Also:

Constant Field Values

RESTORE_NAME

public static final java.lang.String RESTORE_NAME

The name of restore methods.

See Also:

Constant Field Values

Constructor Detail

AssignmentTransformer

public AssignmentTransformer()

Method Detail

enter

public void enter(org.eclipse.jdt.core.dom.AnonymousClassDeclaration node,
                  TypeAnalyzerState state)

Enter an anonymous class declaration. Nothing is done in this method.

Specified by:

enter in interface ClassHandler

Parameters:

node - The AST node of the anonymous class declaration.

state - The current state of the type analyzer.

enter

public void enter(org.eclipse.jdt.core.dom.FieldDeclaration node,
                  TypeAnalyzerState state)

Enter a field declaration. If the field is static, a flag is set so that handling of other nodes (such as assignment) may be different from those in non-static fields.

Specified by:

enter in interface FieldDeclarationHandler

Parameters:

node - The AST node of the field declaration.

state - The current state of the type analyzer.

enter

public void enter(org.eclipse.jdt.core.dom.MethodDeclaration node,
                  TypeAnalyzerState state)

Enter a method declaration. If the method is static, a flag is set so that handling of other nodes (such as assignment) may be different from those in non-static methods.

Specified by:

enter in interface MethodDeclarationHandler

Parameters:

node - The AST node of the method declaration.

state - The current state of the type analyzer.

enter

public void enter(org.eclipse.jdt.core.dom.TypeDeclaration node,
                  TypeAnalyzerState state)

Enter an class declaration. Nothing is done in this method.

Specified by:

enter in interface ClassHandler

Parameters:

node - The AST node of the anonymous class declaration.

state - The current state of the type analyzer.

exit

public void exit(org.eclipse.jdt.core.dom.AnonymousClassDeclaration node,
                 TypeAnalyzerState state)

Exit an anonymous class declaration, and add extra methods and fields to it.

This function is called after all the existing methods and fields in the same class has been visited, and all the field assignments in it are handled with handle(Assignment, TypeAnalyzerState).

Specified by:

exit in interface ClassHandler

Parameters:

node - The AST node of the anonymous class declaration.

state - The current state of the type analyzer.

exit

public void exit(org.eclipse.jdt.core.dom.FieldDeclaration node,
                 TypeAnalyzerState state)

Exit a field declaration. The flag of static field is set back to its old value before the field was entered.

Specified by:

exit in interface FieldDeclarationHandler

Parameters:

node - The AST node of the field declaration.

state - The current state of the type analyzer.

exit

public void exit(org.eclipse.jdt.core.dom.MethodDeclaration node,
                 TypeAnalyzerState state)

Exit a method declaration. The flag of static method is set back to its old value before the method was entered.

Specified by:

exit in interface MethodDeclarationHandler

Parameters:

node - The AST node of the method declaration.

state - The current state of the type analyzer.

exit

public void exit(org.eclipse.jdt.core.dom.TypeDeclaration node,
                 TypeAnalyzerState state)

Exit a class declaration, and add extra methods and fields to it.

This function is called after all the existing methods and fields in the same class has been visited, and all the field assignments in it are handled with handle(Assignment, TypeAnalyzerState).

Specified by:

exit in interface ClassHandler

Parameters:

node - The AST node of the anonymous class declaration.

state - The current state of the type analyzer.

handle

public void handle(org.eclipse.jdt.core.dom.Assignment node,
                   TypeAnalyzerState state)

Handle an assignment, and refactor it to be a special method call if the left-hand side of the assignment is a state variable. The accessed field is also recorded in a list so that extra private methods used to back up fields are only created for those used fields. If the field on the left-hand side is a multi-dimensional array, access with different numbers of indices is recorded with multiple entries. For each of those entries, an extra method is created.

An assignment may also be an alias point, in which case an array field is aliased with a local variable. For example: Suppose field is an array field recognized as a state variable. Expression buffer = field aliases the field with a local variable buffer. After that, the method may modify the field array (with the name buffer) without letting field's owner class know. So, this is an alias point. This function refactors this alias point and replaces field with a function call.

Specified by:

handle in interface AliasHandler

Specified by:

handle in interface AssignmentHandler

Parameters:

node - The assignment to be refactored.

state - The current state of the type analyzer.

handle

public void handle(org.eclipse.jdt.core.dom.ClassInstanceCreation node,
                   TypeAnalyzerState state)

Handle a class instance creation. If there are arguments that are aliased array fields, complete backup arrays are created for them and stored in memory.

For example: Suppose field is an array field recognized as a state variable. Expression new MyClass(field) instantiates an object of class MyClass with argument field. The constructor of MyClass may modify the field array without letting field's owner class know. So, this is an alias point. This function refactors this alias point and replaces field with a function call.

Specified by:

handle in interface AliasHandler

Parameters:

node - The class instance creation to be refactored.

state - The current state of the type analyzer.

handle

public void handle(org.eclipse.jdt.core.dom.MethodInvocation node,
                   TypeAnalyzerState state)

Handle a method invocation. If there are arguments that are aliased array fields, complete backup arrays are created for them and stored in memory.

For example: Suppose field is an array field recognized as a state variable. Expression func(field) invokes method func an with argument field. func may modify the field array in its body without letting field's owner class know. So, this is an alias point. This function refactors this alias point and replaces field with a function call.

Specified by:

handle in interface AliasHandler

Parameters:

node - The method invocation to be refactored.

state - The current state of the type analyzer.

handle

public void handle(org.eclipse.jdt.core.dom.PostfixExpression node,
                   TypeAnalyzerState state)

Handle a postfix expression, and refactor it to be a special method call if its subexpression evaluates to be a state variable. The accessed field is also recorded in a list so that extra private methods used to back up fields are only created for those used fields. If the field in the subexpression is a multi-dimensional array, access with different numbers of indices is recorded with multiple entries. For each of those entries, an extra method is created.

Specified by:

handle in interface AssignmentHandler

Parameters:

node - The postfix expression to be refactored.

state - The current state of the type analyzer.

handle

public void handle(org.eclipse.jdt.core.dom.PrefixExpression node,
                   TypeAnalyzerState state)

Handle a prefix expression, and refactor it to be a special method call if its subexpression evaluates to be a state variable. The accessed field is also recorded in a list so that extra private methods used to back up fields are only created for those used fields. If the field in the subexpression is a multi-dimensional array, access with different numbers of indices is recorded with multiple entries. For each of those entries, an extra method is created.

Specified by:

handle in interface AssignmentHandler

Parameters:

node - The prefix expression to be refactored.

state - The current state of the type analyzer.

handle

public void handle(org.eclipse.jdt.core.dom.ReturnStatement node,
                   TypeAnalyzerState state)

Handle a return statement. If the expression to be returned is an aliased array field, a complete backup array is created for it and stored in memory.

For example: Suppose field is an array field recognized as a state variable. Statement return field; returns the field to the calling method. The calling method may modify the field array in its body without letting field's owner class know. So, this is an alias point. This function refactors this alias point and replaces field with a function call.

Specified by:

handle in interface AliasHandler

Parameters:

node - The return statement to be refactored.

state - The current state of the type analyzer.

handle

public void handle(TypeAnalyzerState state)

Fix the refactoring result when the set of cross-analyzed types changes.

The set of cross-analyzed types defines the growing set of types that are analyzed in a run. Special care is taken for cross-analyzed types because they are monitored by checkpoint objects, and checkpoint-related extra methods are added to them. Unfortunately, it is not possible to know all the cross-analyzed types at the beginning. It is then necessary to fix the refactoring result when more cross-analyzed types are discovered later.

Specified by:

handle in interface CrossAnalysisHandler

Parameters:

state - The current state of the type analyzer.

See Also:

TypeAnalyzerState.getCrossAnalyzedTypes()

handle

public void handle(org.eclipse.jdt.core.dom.VariableDeclarationFragment node,
                   TypeAnalyzerState state)

Handle a variable declaration fragment. If the frament has an initializer and the initializer evaluates to an aliased array field, a complete backup array is created for it and stored in memory.

For example: Suppose field is an array field recognized as a state variable. Variable declaration int[] buffer = field (with one fragment only) aliases the field to with name buffer. The declaring method may modify the field array (with name buffer) in its body without letting field's owner class know. So, this is an alias point. This function refactors this alias point and replaces field with a function call.

Specified by:

handle in interface AliasHandler

Parameters:

node - The variable declaration fragment to be refactored.

state - The current state of the type analyzer.