private static ASTNode getRawReference(SimpleName name, CompilationUnit compilationUnit) {
SimpleName[] names = LinkedNodeFinder.findByNode(compilationUnit, name);
for (int j = 0; j < names.length; j++) {
if (names[j].getParent() instanceof VariableDeclarationFragment) {
VariableDeclarationFragment fragment = (VariableDeclarationFragment) names[j].getParent();
if (fragment.getParent() instanceof VariableDeclarationStatement) {
VariableDeclarationStatement statement =
(VariableDeclarationStatement) fragment.getParent();
ASTNode result =
(ASTNode) statement.getStructuralProperty(VariableDeclarationStatement.TYPE_PROPERTY);
if (isRawTypeReference(result)) return result;
} else if (fragment.getParent() instanceof FieldDeclaration) {
FieldDeclaration declaration = (FieldDeclaration) fragment.getParent();
ASTNode result =
(ASTNode) declaration.getStructuralProperty(FieldDeclaration.TYPE_PROPERTY);
if (isRawTypeReference(result)) return result;
}
} else if (names[j].getParent() instanceof SingleVariableDeclaration) {
SingleVariableDeclaration declaration = (SingleVariableDeclaration) names[j].getParent();
ASTNode result =
(ASTNode) declaration.getStructuralProperty(SingleVariableDeclaration.TYPE_PROPERTY);
if (isRawTypeReference(result)) return result;
} else if (names[j].getParent() instanceof MethodDeclaration) {
MethodDeclaration methodDecl = (MethodDeclaration) names[j].getParent();
ASTNode result =
(ASTNode) methodDecl.getStructuralProperty(MethodDeclaration.RETURN_TYPE2_PROPERTY);
if (isRawTypeReference(result)) return result;
}
}
return null;
}
/**
* Looks for local variable declarations. For every declaration of a variable, the parent {@link
* Block} denoting the variable's scope is stored in {variableScope} map.
*
* @param node the node to visit
*/
@Override
public boolean visit(final VariableDeclarationStatement node) {
for (final Object fragment : node.fragments()) {
final VariableDeclarationFragment frag = (VariableDeclarationFragment) fragment;
addBinding(node, frag.getName(), node.getType());
}
return true;
}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=388137
public void testbug388137() throws Exception {
this.workingCopies = new ICompilationUnit[1];
IJavaProject project =
createJavaProject("P1", new String[] {""}, new String[] {"CONVERTER_JCL15_LIB"}, "", "1.5");
try {
String contents =
"package p;\n"
+ "import java.util.List;\n"
+ "public class X {\n"
+ " public X(List list) {}\n"
+ " public static class ListHandler implements Handler {\n"
+ " List list = null;\n"
+ " public ListHandler(List list) {\n"
+ " this.list = list;\n"
+ " }\n"
+ " }\n"
+ "}\n"
+ "interface Handler {}\n";
addLibrary(project, "lib.jar", "src.zip", new String[] {"/P1/p/X.java", contents}, "1.5");
this.workingCopies[0] = getWorkingCopy("/P1/q/Y.java", true);
contents =
"package q;\n"
+ "import p.X.ListHandler;\n"
+ "public class Y {\n"
+ " public Object foo() {\n"
+ " ListHandler sortHandler = new ListHandler(null);\n"
+ " return sortHandler;"
+ " }\n"
+ "}\n";
ASTNode node = buildAST(contents, this.workingCopies[0], true);
assertTrue("Should be a compilation unit", node instanceof CompilationUnit);
CompilationUnit unit = (CompilationUnit) node;
node = getASTNode(unit, 0, 0, 0);
assertEquals(
"Not an expression statement",
ASTNode.VARIABLE_DECLARATION_STATEMENT,
node.getNodeType());
VariableDeclarationStatement statement = (VariableDeclarationStatement) node;
List fragments = statement.fragments();
assertEquals("Wrong size", 1, fragments.size());
VariableDeclarationFragment fragment = (VariableDeclarationFragment) fragments.get(0);
Expression expression = fragment.getInitializer();
assertEquals(
"Not a constructor invocation",
ASTNode.CLASS_INSTANCE_CREATION,
expression.getNodeType());
ClassInstanceCreation classInstanceCreation = (ClassInstanceCreation) expression;
IMethodBinding binding = classInstanceCreation.resolveConstructorBinding();
JavaElement element = (JavaElement) binding.getJavaElement();
assertNotNull("Null Element info", element.getElementInfo());
} finally {
deleteProject(project);
}
}
/** {@inheritDoc} */
public boolean visit(VariableDeclarationStatement node) {
if (fAddFinalLocals) handleFragments(node.fragments(), node);
List fragments = node.fragments();
for (Iterator iterator = fragments.iterator(); iterator.hasNext(); ) {
VariableDeclarationFragment fragment = (VariableDeclarationFragment) iterator.next();
Expression initializer = fragment.getInitializer();
if (initializer != null) {
initializer.accept(this);
}
}
return false;
}
/**
* Removes the current variable declaration from the AST and inserts it into the lowest possible
* scope where the variable is first used. Returns the modification to the AST within a Change
* object.
*/
private Change recordASTModifications() {
AST ast = compilationUnit.getAST();
ASTRewrite rewriter = ASTRewrite.create(ast);
// duplicate the original variable declaration in lower scope before getting rid of it
VariableDeclarationStatement oldDeclaration =
(VariableDeclarationStatement) variableVisitor.getDeclaration();
assert variableVisitor.getFirstAssignment() instanceof Assignment;
Assignment variableAssignment = (Assignment) variableVisitor.getFirstAssignment();
ASTNode newScopeParent = variableAssignment.getParent().getParent();
String codeString = oldDeclaration.toString();
ASTNode newDeclaration =
rewriter.createStringPlaceholder(
codeString.substring(0, codeString.length() - 1),
ASTNode.VARIABLE_DECLARATION_STATEMENT);
ListRewrite listRewrite = rewriter.getListRewrite(newScopeParent, Block.STATEMENTS_PROPERTY);
listRewrite.insertAt(newDeclaration, 0, null);
// get rid of the higher scope declaration
rewriter.remove(oldDeclaration, null);
ICompilationUnit iCompUnit = method.getCompilationUnit();
final String description = "ReduceScopeOfVariable";
final String comment = "ReduceScopeOfVariable does blah...";
// record the change
CompilationUnitChange change =
new CompilationUnitChange("Reduce scope of variable", iCompUnit) {
public ChangeDescriptor getDescriptor() {
Map<Object, Object> arguments = new HashMap<Object, Object>();
arguments.put("method", method);
arguments.put("var", varName);
return new RefactoringChangeDescriptor(
new ReduceScopeOfVariableDescriptor(
method.getJavaProject().getElementName(), description, comment, arguments));
}
};
try {
change.setEdit(rewriter.rewriteAST());
} catch (Exception e) {
}
return change;
}
/*
* @see ASTVisitor#visit(VariableDeclarationStatement)
*/
public boolean visit(VariableDeclarationStatement node) {
if (node.getAST().apiLevel() >= AST.JLS3) {
printModifiers(node.modifiers());
}
node.getType().accept(this);
this.fBuffer.append(" "); // $NON-NLS-1$
for (Iterator it = node.fragments().iterator(); it.hasNext(); ) {
VariableDeclarationFragment f = (VariableDeclarationFragment) it.next();
f.accept(this);
if (it.hasNext()) {
this.fBuffer.append(", "); // $NON-NLS-1$
}
}
this.fBuffer.append(";"); // $NON-NLS-1$
return false;
}
@Override
public void endVisit(VariableDeclarationStatement node) {
Collection<VMVariableDeclarationFragment> vars = new ArrayList<VMVariableDeclarationFragment>();
for (int i = 0; i < node.fragments().size(); i++) {
vars.add((VMVariableDeclarationFragment) (expressions.pop()));
}
VMVariableDeclarationStatement statement = VM.asVariableDeclarationStatement(node, vars);
topBlock.getStatements().add(statement);
}
@Override
public boolean visit(VariableDeclarationStatement node) {
Type typ = node.getType();
if (typ.isSimpleType()) {
SimpleType simple = (SimpleType) typ;
String typName = simple.getName().getFullyQualifiedName();
List<VariableDeclarationFragment> vars = node.fragments();
for (VariableDeclarationFragment var : vars) {
map.put(var.getName().getIdentifier(), typName);
}
}
if (typ.isQualifiedType()) {
QualifiedType qual = (QualifiedType) typ;
String typName = qual.getName().getFullyQualifiedName();
List<VariableDeclarationFragment> vars = node.fragments();
for (VariableDeclarationFragment var : vars) {
map.put(var.getName().getIdentifier(), typName);
}
}
if (typ.isPrimitiveType()) {
PrimitiveType prim = (PrimitiveType) typ;
String typName = prim.getPrimitiveTypeCode().toString();
List<VariableDeclarationFragment> vars = node.fragments();
for (VariableDeclarationFragment var : vars) {
map.put(var.getName().getIdentifier(), typName);
}
}
if (typ.isParameterizedType()) {
ParameterizedType prim = (ParameterizedType) typ;
String typName = prim.getType().toString();
List<VariableDeclarationFragment> vars = node.fragments();
for (VariableDeclarationFragment var : vars) {
map.put(var.getName().getIdentifier(), typName);
}
}
if (typ.isArrayType()) {
ArrayType prim = (ArrayType) typ;
String typName = "Array";
List<VariableDeclarationFragment> vars = node.fragments();
for (VariableDeclarationFragment var : vars) {
map.put(var.getName().getIdentifier(), typName);
}
}
return true;
}
@Override
public void endVisit(VariableDeclarationStatement node) {
checkTypeInDeclaration(node.getType());
super.endVisit(node);
}
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;
}
@Override
public Pair<List<Pair<String, Name>>, Boolean> tryMatch(
Statement s, Map<String, String> var2type, VariableContext context) {
List<Pair<String, Name>> matchedVarList = new ArrayList<Pair<String, Name>>();
Boolean matchedSuccessful = false;
// An assignment statement pattern should match both
// assignment statements
// as well as variabledelcaration statements
if (s instanceof ExpressionStatement) {
Expression exp = ((ExpressionStatement) s).getExpression();
if (exp instanceof Assignment) {
Assignment assignment = (Assignment) exp;
// Note that the left hand side expression of an assignment expression is always a *name*
Name lhsExp = null;
;
try {
lhsExp = (Name) assignment.getLeftHandSide();
} catch (Exception e) {
ErrorManager.error(
"AssignStmtPattrn@58",
"The left hand side pattern is not a name, instead: " + assignment);
return new Pair<List<Pair<String, Name>>, Boolean>(matchedVarList, matchedSuccessful);
}
// Debugging types
TypeHandler.printTypeMatchInfo(lhsExp, var2type.get(this.variable), "AssignStmtPattern@57");
// Check the type between the lhs metavariable and the name
// TypeHandler.typeMatchCheck(lhsExp, var2type.get(this.variable))
if (context.variableMatchCheck(lhsExp, this.variable)) {
matchedVarList.add(new Pair<String, Name>(this.variable.getName(), lhsExp));
} else {
// Type of the lhs expression does not match
matchedSuccessful = false;
}
// Try to match the expression pattern
Expression rhsExp = assignment.getRightHandSide();
Pair<List<Pair<String, Name>>, Boolean> expMatch =
this.expression.tryMatch(rhsExp, var2type, context);
if (expMatch.getSecond()) {
for (Pair<String, Name> p : expMatch.getFirst()) {
matchedVarList.add(p);
}
matchedSuccessful = true;
}
}
} else if (s instanceof VariableDeclarationStatement) {
VariableDeclarationStatement vds = (VariableDeclarationStatement) s;
if (vds.fragments().size() != 1) {
// If the error occurs, go and fix the bug in
ErrorManager.error(
"AssignStmtPattern@lien81", "The size of variable declaration fragments is not 1");
}
VariableDeclarationFragment vdf = (VariableDeclarationFragment) vds.fragments().get(0);
// Print debugging info for the lhs expression and its corresponding type pattern name
TypeHandler.printTypeMatchInfo(
vdf.getName(), var2type.get(this.variable), "AssignStmtPattern@line83");
// Type check on the lhs variable
// if (TypeHandler.typeMatchCheck(vdf.getName(), var2type.get(this.variable)))
if (context.variableMatchCheck(vdf.getName(), this.variable))
matchedVarList.add(new Pair<String, Name>(this.variable.getName(), vdf.getName()));
Pair<List<Pair<String, Name>>, Boolean> expMatch =
this.expression.tryMatch(vdf.getInitializer(), var2type, context);
if (expMatch.getSecond()) {
for (Pair<String, Name> p : expMatch.getFirst()) {
matchedVarList.add(p);
}
matchedSuccessful = true;
}
}
return new Pair<List<Pair<String, Name>>, Boolean>(matchedVarList, matchedSuccessful);
}
// 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;
}
public static void addFinalAndValAnnotationToVariableDeclarationStatement(
Object converter, VariableDeclarationStatement out, LocalDeclaration in) {
@SuppressWarnings("unchecked")
List<IExtendedModifier> modifiers = out.modifiers();
addFinalAndValAnnotationToModifierList(converter, modifiers, out.getAST(), in);
}
private void createTryCatchStatement(org.eclipse.jdt.core.IBuffer buffer, String lineDelimiter)
throws CoreException {
List<Statement> result = new ArrayList<>(1);
TryStatement tryStatement = getAST().newTryStatement();
ITypeBinding[] exceptions = fAnalyzer.getExceptions();
ImportRewriteContext context =
new ContextSensitiveImportRewriteContext(
fAnalyzer.getEnclosingBodyDeclaration(), fImportRewrite);
if (!fIsMultiCatch) {
for (int i = 0; i < exceptions.length; i++) {
ITypeBinding exception = exceptions[i];
CatchClause catchClause = getAST().newCatchClause();
tryStatement.catchClauses().add(catchClause);
SingleVariableDeclaration decl = getAST().newSingleVariableDeclaration();
String varName = StubUtility.getExceptionVariableName(fCUnit.getJavaProject());
String name = fScope.createName(varName, false);
decl.setName(getAST().newSimpleName(name));
Type type = fImportRewrite.addImport(exception, getAST(), context);
decl.setType(type);
catchClause.setException(decl);
Statement st = getCatchBody(ASTNodes.getQualifiedTypeName(type), name, lineDelimiter);
if (st != null) {
catchClause.getBody().statements().add(st);
}
fLinkedProposalModel
.getPositionGroup(GROUP_EXC_TYPE + i, true)
.addPosition(fRewriter.track(decl.getType()), i == 0);
fLinkedProposalModel
.getPositionGroup(GROUP_EXC_NAME + i, true)
.addPosition(fRewriter.track(decl.getName()), false);
}
} else {
List<ITypeBinding> filteredExceptions = filterSubtypeExceptions(exceptions);
CatchClause catchClause = getAST().newCatchClause();
SingleVariableDeclaration decl = getAST().newSingleVariableDeclaration();
String varName = StubUtility.getExceptionVariableName(fCUnit.getJavaProject());
String name = fScope.createName(varName, false);
decl.setName(getAST().newSimpleName(name));
UnionType unionType = getAST().newUnionType();
List<Type> types = unionType.types();
int i = 0;
for (ITypeBinding exception : filteredExceptions) {
Type type = fImportRewrite.addImport(exception, getAST(), context);
types.add(type);
fLinkedProposalModel
.getPositionGroup(GROUP_EXC_TYPE + i, true)
.addPosition(fRewriter.track(type), i == 0);
i++;
}
decl.setType(unionType);
catchClause.setException(decl);
fLinkedProposalModel
.getPositionGroup(GROUP_EXC_NAME + 0, true)
.addPosition(fRewriter.track(decl.getName()), false);
Statement st = getCatchBody("Exception", name, lineDelimiter); // $NON-NLS-1$
if (st != null) {
catchClause.getBody().statements().add(st);
}
tryStatement.catchClauses().add(catchClause);
}
List<ASTNode> variableDeclarations = getSpecialVariableDeclarationStatements();
ListRewrite statements =
fRewriter.getListRewrite(tryStatement.getBody(), Block.STATEMENTS_PROPERTY);
boolean selectedNodeRemoved = false;
ASTNode expressionStatement = null;
for (int i = 0; i < fSelectedNodes.length; i++) {
ASTNode node = fSelectedNodes[i];
if (node instanceof VariableDeclarationStatement && variableDeclarations.contains(node)) {
AST ast = getAST();
VariableDeclarationStatement statement = (VariableDeclarationStatement) node;
// Create a copy and remove the initializer
VariableDeclarationStatement copy =
(VariableDeclarationStatement) ASTNode.copySubtree(ast, statement);
List<IExtendedModifier> modifiers = copy.modifiers();
for (Iterator<IExtendedModifier> iter = modifiers.iterator(); iter.hasNext(); ) {
IExtendedModifier modifier = iter.next();
if (modifier.isModifier()
&& Modifier.isFinal(((Modifier) modifier).getKeyword().toFlagValue())) {
iter.remove();
}
}
List<VariableDeclarationFragment> fragments = copy.fragments();
for (Iterator<VariableDeclarationFragment> iter = fragments.iterator(); iter.hasNext(); ) {
VariableDeclarationFragment fragment = iter.next();
fragment.setInitializer(null);
}
CompilationUnit root = (CompilationUnit) statement.getRoot();
int extendedStart = root.getExtendedStartPosition(statement);
// we have a leading comment and the comment is covered by the selection
if (extendedStart != statement.getStartPosition()
&& extendedStart >= fSelection.getOffset()) {
String commentToken =
buffer.getText(extendedStart, statement.getStartPosition() - extendedStart);
commentToken = Strings.trimTrailingTabsAndSpaces(commentToken);
Type type = statement.getType();
String typeName = buffer.getText(type.getStartPosition(), type.getLength());
copy.setType(
(Type)
fRewriter.createStringPlaceholder(commentToken + typeName, type.getNodeType()));
}
result.add(copy);
// convert the fragments into expression statements
fragments = statement.fragments();
if (!fragments.isEmpty()) {
List<ExpressionStatement> newExpressionStatements = new ArrayList<>();
for (Iterator<VariableDeclarationFragment> iter = fragments.iterator();
iter.hasNext(); ) {
VariableDeclarationFragment fragment = iter.next();
Expression initializer = fragment.getInitializer();
if (initializer != null) {
Assignment assignment = ast.newAssignment();
assignment.setLeftHandSide(
(Expression) fRewriter.createCopyTarget(fragment.getName()));
assignment.setRightHandSide((Expression) fRewriter.createCopyTarget(initializer));
newExpressionStatements.add(ast.newExpressionStatement(assignment));
}
}
if (!newExpressionStatements.isEmpty()) {
if (fSelectedNodes.length == 1) {
expressionStatement =
fRewriter.createGroupNode(
newExpressionStatements.toArray(new ASTNode[newExpressionStatements.size()]));
} else {
fRewriter.replace(
statement,
fRewriter.createGroupNode(
newExpressionStatements.toArray(new ASTNode[newExpressionStatements.size()])),
null);
}
} else {
fRewriter.remove(statement, null);
selectedNodeRemoved = true;
}
} else {
fRewriter.remove(statement, null);
selectedNodeRemoved = true;
}
}
}
result.add(tryStatement);
ASTNode replacementNode;
if (result.size() == 1) {
replacementNode = result.get(0);
} else {
replacementNode = fRewriter.createGroupNode(result.toArray(new ASTNode[result.size()]));
}
if (fSelectedNodes.length == 1) {
ASTNode selectedNode = fSelectedNodes[0];
if (selectedNode instanceof MethodReference) {
MethodReference methodReference = (MethodReference) selectedNode;
IMethodBinding functionalMethod =
QuickAssistProcessor.getFunctionalMethodForMethodReference(methodReference);
// functionalMethod is non-null and non-generic. See
// ExceptionAnalyzer.handleMethodReference(MethodReference node).
Assert.isTrue(functionalMethod != null && !functionalMethod.isGenericMethod());
LambdaExpression lambda =
QuickAssistProcessor.convertMethodRefernceToLambda(
methodReference, functionalMethod, fRootNode, fRewriter, null, true);
ASTNode statementInBlock = (ASTNode) ((Block) lambda.getBody()).statements().get(0);
fRewriter.replace(statementInBlock, replacementNode, null);
statements.insertLast(statementInBlock, null);
return;
}
LambdaExpression enclosingLambda = ASTResolving.findEnclosingLambdaExpression(selectedNode);
if (enclosingLambda != null
&& selectedNode.getLocationInParent() == LambdaExpression.BODY_PROPERTY
&& enclosingLambda.resolveMethodBinding() != null) {
QuickAssistProcessor.changeLambdaBodyToBlock(enclosingLambda, getAST(), fRewriter);
Block blockBody = (Block) fRewriter.get(enclosingLambda, LambdaExpression.BODY_PROPERTY);
ASTNode statementInBlock = (ASTNode) blockBody.statements().get(0);
fRewriter.replace(statementInBlock, replacementNode, null);
statements.insertLast(statementInBlock, null);
return;
}
if (expressionStatement != null) {
statements.insertLast(expressionStatement, null);
} else {
if (!selectedNodeRemoved)
statements.insertLast(fRewriter.createMoveTarget(selectedNode), null);
}
fRewriter.replace(selectedNode, replacementNode, null);
} else {
ListRewrite source =
fRewriter.getListRewrite(
fSelectedNodes[0].getParent(),
(ChildListPropertyDescriptor) fSelectedNodes[0].getLocationInParent());
ASTNode toMove =
source.createMoveTarget(
fSelectedNodes[0], fSelectedNodes[fSelectedNodes.length - 1], replacementNode, null);
statements.insertLast(toMove, null);
}
}
