@Override
public boolean visit(VariableDeclarationFragment node) {
for (Map.Entry<String, Object> entry : replaceVariablesMap.entrySet()) {
String key = entry.getKey();
if (variablesMap.containsKey(key) && variablesMap.get(key) == getLine(node)) {
AST ast = rewrite.getAST();
VariableDeclarationFragment fragment = ast.newVariableDeclarationFragment();
fragment.setName(ast.newSimpleName(key));
fragment.setInitializer(createNewObject(replaceVariablesMap.get(key)));
rewrite.replace(node, fragment, null);
}
}
return true;
}
private ASTRewrite doAddField(CompilationUnit astRoot) {
SimpleName node = fOriginalNode;
boolean isInDifferentCU = false;
ASTNode newTypeDecl = astRoot.findDeclaringNode(fSenderBinding);
if (newTypeDecl == null) {
astRoot = ASTResolving.createQuickFixAST(getCompilationUnit(), null);
newTypeDecl = astRoot.findDeclaringNode(fSenderBinding.getKey());
isInDifferentCU = true;
}
ImportRewrite imports = createImportRewrite(astRoot);
ImportRewriteContext importRewriteContext =
new ContextSensitiveImportRewriteContext(
ASTResolving.findParentBodyDeclaration(node), imports);
if (newTypeDecl != null) {
AST ast = newTypeDecl.getAST();
ASTRewrite rewrite = ASTRewrite.create(ast);
VariableDeclarationFragment fragment = ast.newVariableDeclarationFragment();
fragment.setName(ast.newSimpleName(node.getIdentifier()));
Type type = evaluateVariableType(ast, imports, importRewriteContext, fSenderBinding);
FieldDeclaration newDecl = ast.newFieldDeclaration(fragment);
newDecl.setType(type);
newDecl
.modifiers()
.addAll(ASTNodeFactory.newModifiers(ast, evaluateFieldModifiers(newTypeDecl)));
if (fSenderBinding.isInterface() || fVariableKind == CONST_FIELD) {
fragment.setInitializer(ASTNodeFactory.newDefaultExpression(ast, type, 0));
}
ChildListPropertyDescriptor property = ASTNodes.getBodyDeclarationsProperty(newTypeDecl);
List<BodyDeclaration> decls =
ASTNodes.<BodyDeclaration>getChildListProperty(newTypeDecl, property);
int maxOffset = isInDifferentCU ? -1 : node.getStartPosition();
int insertIndex = findFieldInsertIndex(decls, newDecl, maxOffset);
ListRewrite listRewriter = rewrite.getListRewrite(newTypeDecl, property);
listRewriter.insertAt(newDecl, insertIndex, null);
ModifierCorrectionSubProcessor.installLinkedVisibilityProposals(
getLinkedProposalModel(), rewrite, newDecl.modifiers(), fSenderBinding.isInterface());
addLinkedPosition(rewrite.track(newDecl.getType()), false, KEY_TYPE);
if (!isInDifferentCU) {
addLinkedPosition(rewrite.track(node), true, KEY_NAME);
}
addLinkedPosition(rewrite.track(fragment.getName()), false, KEY_NAME);
if (fragment.getInitializer() != null) {
addLinkedPosition(rewrite.track(fragment.getInitializer()), false, KEY_INITIALIZER);
}
return rewrite;
}
return null;
}
private ASTRewrite doAddLocal(CompilationUnit cu) {
AST ast = cu.getAST();
Block body;
BodyDeclaration decl = ASTResolving.findParentBodyDeclaration(fOriginalNode);
IBinding targetContext = null;
if (decl instanceof MethodDeclaration) {
body = (((MethodDeclaration) decl).getBody());
targetContext = ((MethodDeclaration) decl).resolveBinding();
} else if (decl instanceof Initializer) {
body = (((Initializer) decl).getBody());
targetContext = Bindings.getBindingOfParentType(decl);
} else {
return null;
}
ASTRewrite rewrite = ASTRewrite.create(ast);
ImportRewrite imports = createImportRewrite((CompilationUnit) decl.getRoot());
ImportRewriteContext importRewriteContext =
new ContextSensitiveImportRewriteContext(decl, imports);
SimpleName[] names = getAllReferences(body);
ASTNode dominant = getDominantNode(names);
Statement dominantStatement = ASTResolving.findParentStatement(dominant);
if (ASTNodes.isControlStatementBody(dominantStatement.getLocationInParent())) {
dominantStatement = (Statement) dominantStatement.getParent();
}
SimpleName node = names[0];
if (isAssigned(dominantStatement, node)) {
// x = 1; -> int x = 1;
Assignment assignment = (Assignment) node.getParent();
// trick to avoid comment removal around the statement: keep the expression statement
// and replace the assignment with an VariableDeclarationExpression
VariableDeclarationFragment newDeclFrag = ast.newVariableDeclarationFragment();
VariableDeclarationExpression newDecl = ast.newVariableDeclarationExpression(newDeclFrag);
newDecl.setType(evaluateVariableType(ast, imports, importRewriteContext, targetContext));
Expression placeholder = (Expression) rewrite.createCopyTarget(assignment.getRightHandSide());
newDeclFrag.setInitializer(placeholder);
newDeclFrag.setName(ast.newSimpleName(node.getIdentifier()));
rewrite.replace(assignment, newDecl, null);
addLinkedPosition(rewrite.track(newDecl.getType()), false, KEY_TYPE);
addLinkedPosition(rewrite.track(newDeclFrag.getName()), true, KEY_NAME);
setEndPosition(rewrite.track(assignment.getParent()));
return rewrite;
} else if ((dominant != dominantStatement) && isForStatementInit(dominantStatement, node)) {
// for (x = 1;;) ->for (int x = 1;;)
Assignment assignment = (Assignment) node.getParent();
VariableDeclarationFragment frag = ast.newVariableDeclarationFragment();
VariableDeclarationExpression expression = ast.newVariableDeclarationExpression(frag);
frag.setName(ast.newSimpleName(node.getIdentifier()));
Expression placeholder = (Expression) rewrite.createCopyTarget(assignment.getRightHandSide());
frag.setInitializer(placeholder);
expression.setType(evaluateVariableType(ast, imports, importRewriteContext, targetContext));
rewrite.replace(assignment, expression, null);
addLinkedPosition(rewrite.track(expression.getType()), false, KEY_TYPE);
addLinkedPosition(rewrite.track(frag.getName()), true, KEY_NAME);
setEndPosition(rewrite.track(expression));
return rewrite;
} else if ((dominant != dominantStatement)
&& isEnhancedForStatementVariable(dominantStatement, node)) {
// for (x: collectionOfT) -> for (T x: collectionOfT)
EnhancedForStatement enhancedForStatement = (EnhancedForStatement) dominantStatement;
SingleVariableDeclaration parameter = enhancedForStatement.getParameter();
Expression expression = enhancedForStatement.getExpression();
SimpleName newName = (SimpleName) rewrite.createMoveTarget(node);
rewrite.set(parameter, SingleVariableDeclaration.NAME_PROPERTY, newName, null);
ITypeBinding elementBinding = null;
ITypeBinding typeBinding = expression.resolveTypeBinding();
if (typeBinding != null) {
if (typeBinding.isArray()) {
elementBinding = typeBinding.getElementType();
} else {
ITypeBinding iterable =
Bindings.findTypeInHierarchy(typeBinding, "java.lang.Iterable"); // $NON-NLS-1$
if (iterable != null) {
ITypeBinding[] typeArguments = iterable.getTypeArguments();
if (typeArguments.length == 1) {
elementBinding = typeArguments[0];
elementBinding = Bindings.normalizeForDeclarationUse(elementBinding, ast);
}
}
}
}
Type type;
if (elementBinding != null) {
type = imports.addImport(elementBinding, ast, importRewriteContext);
} else {
type = ast.newSimpleType(ast.newSimpleName("Object")); // $NON-NLS-1$
}
rewrite.set(parameter, SingleVariableDeclaration.TYPE_PROPERTY, type, null);
addLinkedPosition(rewrite.track(type), false, KEY_TYPE);
addLinkedPosition(rewrite.track(newName), true, KEY_NAME);
setEndPosition(rewrite.track(expression));
return rewrite;
}
// foo(x) -> int x; foo(x)
VariableDeclarationFragment newDeclFrag = ast.newVariableDeclarationFragment();
VariableDeclarationStatement newDecl = ast.newVariableDeclarationStatement(newDeclFrag);
newDeclFrag.setName(ast.newSimpleName(node.getIdentifier()));
newDecl.setType(evaluateVariableType(ast, imports, importRewriteContext, targetContext));
// newDeclFrag.setInitializer(ASTNodeFactory.newDefaultExpression(ast, newDecl.getType(), 0));
addLinkedPosition(rewrite.track(newDecl.getType()), false, KEY_TYPE);
addLinkedPosition(rewrite.track(node), true, KEY_NAME);
addLinkedPosition(rewrite.track(newDeclFrag.getName()), false, KEY_NAME);
Statement statement = dominantStatement;
List<? extends ASTNode> list = ASTNodes.getContainingList(statement);
while (list == null
&& statement.getParent() instanceof Statement) { // parent must be if, for or while
statement = (Statement) statement.getParent();
list = ASTNodes.getContainingList(statement);
}
if (list != null) {
ASTNode parent = statement.getParent();
StructuralPropertyDescriptor childProperty = statement.getLocationInParent();
if (childProperty.isChildListProperty()) {
rewrite
.getListRewrite(parent, (ChildListPropertyDescriptor) childProperty)
.insertBefore(newDecl, statement, null);
return rewrite;
} else {
return null;
}
}
return rewrite;
}
private Example makeExample(
MethodDeclaration node,
Set<? extends Expression> envolvedInvocations,
List<ApiMethod> envolvedApiMethods) {
// Visitor responsável por realizar o slicing de programas
SlicingStatementVisitor visitor =
new SlicingStatementVisitor(node, new HashSet<ASTNode>(envolvedInvocations));
node.accept(visitor);
Collection<Statement> relatedStatements = visitor.getSlicedStatements();
ASTNode newAST =
ASTUtil.copyStatements(node.getBody(), relatedStatements, AST.newAST(AST.JLS3));
if (!relatedStatements.isEmpty()) {
LOGGER.error("Some statements were not included!");
}
if (newAST == null) {
LOGGER.error("Slicing process failed for node ");
// TODO Se AST retornada for nula é porque faltou incluir statement(s)
return null;
} else if (((Block) newAST).statements().isEmpty()) {
LOGGER.error("Slicing process failed for node ");
// TODO Se o Block retornado for vazio é porque faltou incluir statement(s)
return null;
}
ASTUtil.removeEmptyBlocks((Block) newAST);
// Adiciona declarações de variáveis que não foram encontradas no escopo do método
// Para facilitar, tipos iguais são declarados no mesmo Statement
Set<String> additionalDeclarationLines = new HashSet<String>();
Map<ITypeBinding, List<IVariableBinding>> typesMap =
new HashMap<ITypeBinding, List<IVariableBinding>>();
for (IVariableBinding ivb : visitor.getUndiscoveredDeclarations()) {
if (!typesMap.containsKey(ivb.getType())) {
typesMap.put(ivb.getType(), new ArrayList<IVariableBinding>(2));
}
typesMap.get(ivb.getType()).add(ivb);
}
for (ITypeBinding typeBinding : typesMap.keySet()) {
List<IVariableBinding> variableBindings = typesMap.get(typeBinding);
Stack<VariableDeclarationFragment> fragments = new Stack<VariableDeclarationFragment>();
for (IVariableBinding ivb : variableBindings) {
VariableDeclarationFragment declarationFragment =
newAST.getAST().newVariableDeclarationFragment();
declarationFragment.setName(newAST.getAST().newSimpleName(ivb.getName()));
fragments.add(declarationFragment);
}
VariableDeclarationStatement statement =
newAST.getAST().newVariableDeclarationStatement(fragments.pop());
while (!fragments.isEmpty()) {
statement.fragments().add(fragments.pop());
}
statement.setType(this.getType(typeBinding, newAST.getAST()));
additionalDeclarationLines.add(statement.toString());
((Block) newAST).statements().add(0, statement);
}
Example example = new Example();
example.setAttachment(this.attachmentMap.get(node.getRoot()));
example.setApiMethods(new HashSet<ApiElement>(envolvedApiMethods));
example.setImports(visitor.getImports());
for (Expression seed : envolvedInvocations) {
example.getSeeds().add(seed.toString());
}
example.setSourceMethod(node.toString());
example.setAddedAt(new Date(System.currentTimeMillis()));
try {
IMethodBinding nodeBinding = node.resolveBinding();
if (!this.methodMap.containsKey(nodeBinding)) {
ApiClass newApiClass = new ApiClass(nodeBinding.getDeclaringClass().getQualifiedName());
methodDeclarationHandler(node, newApiClass);
}
example.setSourceMethodCall(this.methodMap.get(nodeBinding).getFullName());
} catch (Exception e) {
LOGGER.error(e);
if (example.getSourceMethodCall() == null) {
example.setSourceMethodCall("?");
}
}
String codeExample = newAST.toString();
for (String line : additionalDeclarationLines) {
codeExample =
codeExample.replace(
line,
line.replace("\n", "").concat(" ").concat("//initialized previously").concat("\n"));
}
// FIXME
codeExample = codeExample.replaceAll("(\\{\n)(\\s+)(\\})", "$1 //do something \n$3");
try {
example.setCodeExample(codeExample);
example.setFormattedCodeExample(ASTUtil.codeFormatter(codeExample));
} catch (Exception e) {
LOGGER.error(e);
if (example.getFormattedCodeExample() == null) {
example.setFormattedCodeExample(codeExample);
}
}
// TODO Obter métricas do exemplo
example
.getMetrics()
.put(ExampleMetric.LOC.name(), example.getFormattedCodeExample().split("\n").length - 1);
example.getMetrics().put(ExampleMetric.ARGUMENTS.name(), visitor.getNumberOfArguments());
example
.getMetrics()
.put(ExampleMetric.DECISION_STATEMENTS.name(), visitor.getNumberOfDecisionStatements());
example.getMetrics().put(ExampleMetric.INVOCATIONS.name(), visitor.getNumberOfInvocations());
example
.getMetrics()
.put(ExampleMetric.NULL_ARGUMENTS.name(), visitor.getNumberOfNullArguments());
example
.getMetrics()
.put(ExampleMetric.PRIMITIVE_ARGUMENTS.name(), visitor.getNumberOfPrimitiveArguments());
example
.getMetrics()
.put(ExampleMetric.FIELD_ARGUMENTS.name(), visitor.getNumberOfFieldArguments());
example
.getMetrics()
.put(
ExampleMetric.UNDISCOVERED_DECLARATIONS.name(),
visitor.getNumberOfUndiscoveredDeclarations());
example
.getMetrics()
.put(ExampleMetric.UNHANDLED_EXCEPTIONS.name(), visitor.getNumberOfUnhandledExceptions());
return example;
}
private void createConstantDeclaration() throws CoreException {
Type type = getConstantType();
IExpressionFragment fragment = getSelectedExpression();
Expression initializer =
getSelectedExpression().createCopyTarget(fCuRewrite.getASTRewrite(), true);
AST ast = fCuRewrite.getAST();
VariableDeclarationFragment variableDeclarationFragment = ast.newVariableDeclarationFragment();
variableDeclarationFragment.setName(ast.newSimpleName(fConstantName));
variableDeclarationFragment.setInitializer(initializer);
FieldDeclaration fieldDeclaration = ast.newFieldDeclaration(variableDeclarationFragment);
fieldDeclaration.setType(type);
Modifier.ModifierKeyword accessModifier = Modifier.ModifierKeyword.toKeyword(fVisibility);
if (accessModifier != null) fieldDeclaration.modifiers().add(ast.newModifier(accessModifier));
fieldDeclaration.modifiers().add(ast.newModifier(Modifier.ModifierKeyword.STATIC_KEYWORD));
fieldDeclaration.modifiers().add(ast.newModifier(Modifier.ModifierKeyword.FINAL_KEYWORD));
boolean createComments =
JavaPreferencesSettings.getCodeGenerationSettings(fCu.getJavaProject()).createComments;
if (createComments) {
String comment =
CodeGeneration.getFieldComment(
fCu, getConstantTypeName(), fConstantName, StubUtility.getLineDelimiterUsed(fCu));
if (comment != null && comment.length() > 0) {
Javadoc doc =
(Javadoc) fCuRewrite.getASTRewrite().createStringPlaceholder(comment, ASTNode.JAVADOC);
fieldDeclaration.setJavadoc(doc);
}
}
AbstractTypeDeclaration parent = getContainingTypeDeclarationNode();
ListRewrite listRewrite =
fCuRewrite.getASTRewrite().getListRewrite(parent, parent.getBodyDeclarationsProperty());
TextEditGroup msg =
fCuRewrite.createGroupDescription(
RefactoringCoreMessages.ExtractConstantRefactoring_declare_constant);
if (insertFirst()) {
listRewrite.insertFirst(fieldDeclaration, msg);
} else {
listRewrite.insertAfter(fieldDeclaration, getNodeToInsertConstantDeclarationAfter(), msg);
}
if (fLinkedProposalModel != null) {
ASTRewrite rewrite = fCuRewrite.getASTRewrite();
LinkedProposalPositionGroup nameGroup = fLinkedProposalModel.getPositionGroup(KEY_NAME, true);
nameGroup.addPosition(rewrite.track(variableDeclarationFragment.getName()), true);
String[] nameSuggestions = guessConstantNames();
if (nameSuggestions.length > 0 && !nameSuggestions[0].equals(fConstantName)) {
nameGroup.addProposal(fConstantName, null, nameSuggestions.length + 1);
}
for (int i = 0; i < nameSuggestions.length; i++) {
nameGroup.addProposal(nameSuggestions[i], null, nameSuggestions.length - i);
}
LinkedProposalPositionGroup typeGroup = fLinkedProposalModel.getPositionGroup(KEY_TYPE, true);
typeGroup.addPosition(rewrite.track(type), true);
ITypeBinding typeBinding = guessBindingForReference(fragment.getAssociatedExpression());
if (typeBinding != null) {
ITypeBinding[] relaxingTypes = ASTResolving.getNarrowingTypes(ast, typeBinding);
for (int i = 0; i < relaxingTypes.length; i++) {
typeGroup.addProposal(relaxingTypes[i], fCuRewrite.getCu(), relaxingTypes.length - i);
}
}
boolean isInterface =
parent.resolveBinding() != null && parent.resolveBinding().isInterface();
ModifierCorrectionSubProcessor.installLinkedVisibilityProposals(
fLinkedProposalModel, rewrite, fieldDeclaration.modifiers(), isInterface);
}
}
// generate a variable declaration with an initializer specified by the given expression
// e.g. given x.f(a,b) ==> int y = x.f(a,b);
public static List<Statement> genVarDeclStatement(Expression exp) {
List<Statement> result = new ArrayList<Statement>();
VariableDeclarationFragment fragment = AST.newAST(AST.JLS8).newVariableDeclarationFragment();
ExpressionStatement assignmentStmt = genAssignmentStatement(exp);
// The type of the generated variable
Type varType = AST.newAST(AST.JLS8).newWildcardType();
if (exp.resolveTypeBinding() != null) {
if (exp.resolveTypeBinding().isPrimitive()) {
switch (exp.resolveTypeBinding().getName()) {
case "void":
varType = AST.newAST(AST.JLS8).newPrimitiveType(PrimitiveType.VOID);
break;
case "int":
varType = AST.newAST(AST.JLS8).newPrimitiveType(PrimitiveType.INT);
break;
case "char":
varType = AST.newAST(AST.JLS8).newPrimitiveType(PrimitiveType.CHAR);
break;
case "long":
varType = AST.newAST(AST.JLS8).newPrimitiveType(PrimitiveType.LONG);
break;
case "boolean":
varType = AST.newAST(AST.JLS8).newPrimitiveType(PrimitiveType.BOOLEAN);
break;
case "float":
varType = AST.newAST(AST.JLS8).newPrimitiveType(PrimitiveType.FLOAT);
break;
case "short":
varType = AST.newAST(AST.JLS8).newPrimitiveType(PrimitiveType.SHORT);
break;
case "byte":
varType = AST.newAST(AST.JLS8).newPrimitiveType(PrimitiveType.BYTE);
break;
case "double":
varType = AST.newAST(AST.JLS8).newPrimitiveType(PrimitiveType.DOUBLE);
break;
}
} else {
// Option 1: only use the simplename
/*
SimpleName typeName = AST.newAST(AST.JLS8).newSimpleName(exp.resolveTypeBinding().getName());
AST tempAST = AST.newAST(AST.JLS8);
varType = tempAST.newSimpleType((Name) ASTNode.copySubtree(tempAST, typeName));
*/
varType = resolveQualifiedType(exp.resolveTypeBinding().getQualifiedName());
}
}
// Declaration Fragment
fragment.setName(
(SimpleName)
ASTNode.copySubtree(
fragment.getAST(),
((SimpleName) ((Assignment) assignmentStmt.getExpression()).getLeftHandSide())));
// fragment.setInitializer((Expression) ASTNode.copySubtree(fragment.getAST(), exp));
AST varDeclFragAST = AST.newAST(AST.JLS8);
VariableDeclarationStatement decl =
varDeclFragAST.newVariableDeclarationStatement(
(VariableDeclarationFragment) ASTNode.copySubtree(varDeclFragAST, fragment));
decl.setType((Type) ASTNode.copySubtree(decl.getAST(), varType));
result.add(decl);
// initializer is defined here as a separate statement
Assignment assign = varDeclFragAST.newAssignment();
assign.setLeftHandSide((Expression) ASTNode.copySubtree(varDeclFragAST, fragment.getName()));
assign.setRightHandSide((Expression) ASTNode.copySubtree(varDeclFragAST, exp));
ExpressionStatement assignStmt = varDeclFragAST.newExpressionStatement(assign);
result.add(assignStmt);
return result;
}
@SuppressWarnings("unchecked")
@Before
public void setUp() {
manager = ModelManager.getInstance();
manager.clearModel();
AST ast2 = AST.newAST(AST.JLS3);
CompilationUnit cu2 = ast2.newCompilationUnit();
PackageDeclaration pack2 = ast2.newPackageDeclaration();
pack2.setName(ast2.newName("be.ac.ua.test.otherpack"));
cu2.setPackage(pack2);
TypeDeclaration type2 = ast2.newTypeDeclaration();
type2.setName(ast2.newSimpleName("Foo"));
cu2.types().add(type2); // created mock compilationunit containing package and class
PackageRecorder prec2 = new PackageRecorder(pack2);
prec2.storeChange(new Add()); // store the package addition
ClassRecorder crec2 = new ClassRecorder(type2);
declaredclassadd = new Add();
crec2.storeChange(declaredclassadd);
AST ast = AST.newAST(AST.JLS3);
CompilationUnit cu = ast.newCompilationUnit();
PackageDeclaration pack = ast.newPackageDeclaration();
pack.setName(ast.newName(packname));
cu.setPackage(pack);
TypeDeclaration type = ast.newTypeDeclaration();
type.setName(ast.newSimpleName(classname));
cu.types().add(type);
PackageRecorder prec = new PackageRecorder(pack);
prec.storeChange(new Add()); // store the package addition
ClassRecorder crec = new ClassRecorder(type);
classadd = new Add();
crec.storeChange(classadd);
// Class and package created and changes logged, now create the Field.
VariableDeclarationFragment frag1 = ast.newVariableDeclarationFragment();
frag1.setName(ast.newSimpleName(intfieldname));
FieldDeclaration field = ast.newFieldDeclaration(frag1);
field.setType(ast.newPrimitiveType(PrimitiveType.INT)); // field has type int
type.bodyDeclarations().add(field);
VariableDeclarationFragment frag2 = ast.newVariableDeclarationFragment();
frag2.setName(ast.newSimpleName(fieldname));
FieldDeclaration field2 = ast.newFieldDeclaration(frag2);
field2.setType(ast.newSimpleType(ast.newName(declaredTypeName))); // field has type Foo
type.bodyDeclarations().add(field2);
VariableDeclarationFragment frag3 = ast.newVariableDeclarationFragment();
frag3.setName(ast.newSimpleName(field3Name));
FieldDeclaration field3 = ast.newFieldDeclaration(frag3);
field3.setType(ast.newSimpleType(ast.newName("Foo"))); // field has type Foo
type.bodyDeclarations().add(field3);
ImportDeclaration imp = ast.newImportDeclaration();
imp.setName(ast.newName(declaredTypeName));
cu.imports().add(imp);
// created mock compilationunit containing package and class
recorder1 = new FieldRecorder(field);
recorder2 = new FieldRecorder(field2);
recorder3 = new FieldRecorder(field3);
}
