/*
* @see ASTVisitor#visit(MethodInvocation)
*/
public boolean visit(MethodInvocation node) {
if (node.getExpression() != null) {
node.getExpression().accept(this);
this.fBuffer.append("."); // $NON-NLS-1$
}
if (node.getAST().apiLevel() >= AST.JLS3) {
if (!node.typeArguments().isEmpty()) {
this.fBuffer.append("<"); // $NON-NLS-1$
for (Iterator it = node.typeArguments().iterator(); it.hasNext(); ) {
Type t = (Type) it.next();
t.accept(this);
if (it.hasNext()) {
this.fBuffer.append(","); // $NON-NLS-1$
}
}
this.fBuffer.append(">"); // $NON-NLS-1$
}
}
node.getName().accept(this);
this.fBuffer.append("("); // $NON-NLS-1$
for (Iterator it = node.arguments().iterator(); it.hasNext(); ) {
Expression e = (Expression) it.next();
e.accept(this);
if (it.hasNext()) {
this.fBuffer.append(","); // $NON-NLS-1$
}
}
this.fBuffer.append(")"); // $NON-NLS-1$
return false;
}
/*
* @see ASTVisitor#visit(ClassInstanceCreation)
*/
public boolean visit(ClassInstanceCreation node) {
if (node.getExpression() != null) {
node.getExpression().accept(this);
this.fBuffer.append("."); // $NON-NLS-1$
}
this.fBuffer.append("new "); // $NON-NLS-1$
if (node.getAST().apiLevel() >= AST.JLS3) {
if (!node.typeArguments().isEmpty()) {
this.fBuffer.append("<"); // $NON-NLS-1$
for (Iterator it = node.typeArguments().iterator(); it.hasNext(); ) {
Type t = (Type) it.next();
t.accept(this);
if (it.hasNext()) {
this.fBuffer.append(","); // $NON-NLS-1$
}
}
this.fBuffer.append(">"); // $NON-NLS-1$
}
node.getType().accept(this);
}
this.fBuffer.append("("); // $NON-NLS-1$
for (Iterator it = node.arguments().iterator(); it.hasNext(); ) {
Expression e = (Expression) it.next();
e.accept(this);
if (it.hasNext()) {
this.fBuffer.append(","); // $NON-NLS-1$
}
}
this.fBuffer.append(")"); // $NON-NLS-1$
if (node.getAnonymousClassDeclaration() != null) {
node.getAnonymousClassDeclaration().accept(this);
}
return false;
}
@Override
public boolean visit(MethodInvocation node) {
String mName = node.getName().getFullyQualifiedName().toString();
Expression e = node.getExpression();
String typName = "";
if (e instanceof StringLiteral) {
typName = "string";
} else if (e instanceof FieldAccess) {
FieldAccess field = (FieldAccess) e;
typName = field.getName().getFullyQualifiedName();
} else if (e instanceof Name) {
typName = ((Name) e).getFullyQualifiedName();
if (varTypMap.containsKey(typName)) {
typName = varTypMap.get(typName);
}
} else {
if (e != null) {
typName = e.toString();
if (typName.contains(".")) typName = typName.substring(0, typName.indexOf('.', 0));
if (varTypMap.containsKey(typName)) typName = varTypMap.get(typName);
}
}
String key = typName + "->" + mName;
if (freqRecord.containsKey(key)) {
freqRecord.put(key, freqRecord.get(key) + 1);
} else {
freqRecord.put(key, 1);
}
return super.visit(node);
}
private RefactoringStatus checkExpression() throws JavaModelException {
RefactoringStatus result = new RefactoringStatus();
result.merge(checkExpressionBinding());
if (result.hasFatalError()) return result;
checkAllStaticFinal();
IExpressionFragment selectedExpression = getSelectedExpression();
Expression associatedExpression = selectedExpression.getAssociatedExpression();
if (associatedExpression instanceof NullLiteral)
result.merge(
RefactoringStatus.createFatalErrorStatus(
RefactoringCoreMessages.ExtractConstantRefactoring_null_literals));
else if (!ConstantChecks.isLoadTimeConstant(selectedExpression))
result.merge(
RefactoringStatus.createFatalErrorStatus(
RefactoringCoreMessages.ExtractConstantRefactoring_not_load_time_constant));
else if (associatedExpression instanceof SimpleName) {
if (associatedExpression.getParent() instanceof QualifiedName
&& associatedExpression.getLocationInParent() == QualifiedName.NAME_PROPERTY
|| associatedExpression.getParent() instanceof FieldAccess
&& associatedExpression.getLocationInParent() == FieldAccess.NAME_PROPERTY)
return RefactoringStatus.createFatalErrorStatus(
RefactoringCoreMessages.ExtractConstantRefactoring_select_expression);
}
return result;
}
/*
* @see ASTVisitor#visit(ConstructorInvocation)
*/
@Override
public boolean visit(ConstructorInvocation node) {
if (node.getAST().apiLevel() >= JLS3) {
if (!node.typeArguments().isEmpty()) {
this.fBuffer.append("<"); // $NON-NLS-1$
for (Iterator<Type> it = node.typeArguments().iterator(); it.hasNext(); ) {
Type t = it.next();
t.accept(this);
if (it.hasNext()) {
this.fBuffer.append(","); // $NON-NLS-1$
}
}
this.fBuffer.append(">"); // $NON-NLS-1$
}
}
this.fBuffer.append("this("); // $NON-NLS-1$
for (Iterator<Expression> it = node.arguments().iterator(); it.hasNext(); ) {
Expression e = it.next();
e.accept(this);
if (it.hasNext()) {
this.fBuffer.append(","); // $NON-NLS-1$
}
}
this.fBuffer.append(");"); // $NON-NLS-1$
return false;
}
/*
* @see ASTVisitor#visit(SuperMethodInvocation)
*/
@Override
public boolean visit(SuperMethodInvocation node) {
if (node.getQualifier() != null) {
node.getQualifier().accept(this);
this.fBuffer.append("."); // $NON-NLS-1$
}
this.fBuffer.append("super."); // $NON-NLS-1$
if (node.getAST().apiLevel() >= JLS3) {
if (!node.typeArguments().isEmpty()) {
this.fBuffer.append("<"); // $NON-NLS-1$
for (Iterator<Type> it = node.typeArguments().iterator(); it.hasNext(); ) {
Type t = it.next();
t.accept(this);
if (it.hasNext()) {
this.fBuffer.append(","); // $NON-NLS-1$
}
}
this.fBuffer.append(">"); // $NON-NLS-1$
}
}
node.getName().accept(this);
this.fBuffer.append("("); // $NON-NLS-1$
for (Iterator<Expression> it = node.arguments().iterator(); it.hasNext(); ) {
Expression e = it.next();
e.accept(this);
if (it.hasNext()) {
this.fBuffer.append(","); // $NON-NLS-1$
}
}
this.fBuffer.append(")"); // $NON-NLS-1$
return false;
}
@Override
public boolean visit(SingleMemberAnnotation node) {
if (nestLevel != 1) return false;
String typeFqn = node.resolveTypeBinding().getQualifiedName();
if ("org.apache.ibatis.annotations.Select".equals(typeFqn)
|| "org.apache.ibatis.annotations.Update".equals(typeFqn)
|| "org.apache.ibatis.annotations.Insert".equals(typeFqn)
|| "org.apache.ibatis.annotations.Delete".equals(typeFqn)) {
Expression value = node.getValue();
int valueType = value.getNodeType();
if (valueType == ASTNode.STRING_LITERAL) {
mapperMethod.setStatement(((StringLiteral) value).getLiteralValue());
} else if (valueType == ASTNode.ARRAY_INITIALIZER) {
StringBuilder buffer = new StringBuilder();
@SuppressWarnings("unchecked")
List<Expression> expressions =
(List<Expression>) ((ArrayInitializer) value).expressions();
for (Expression expression : expressions) {
int expressionType = expression.getNodeType();
if (expressionType == ASTNode.STRING_LITERAL) {
if (buffer.length() > 0) buffer.append(' ');
buffer.append(((StringLiteral) expression).getLiteralValue());
} else if (expressionType == ASTNode.INFIX_EXPRESSION) {
buffer.append(parseInfixExpression((InfixExpression) expression));
}
}
mapperMethod.setStatement(buffer.toString());
} else if (valueType == ASTNode.INFIX_EXPRESSION) {
mapperMethod.setStatement(parseInfixExpression((InfixExpression) value));
}
}
return false;
}
// 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);
}
}
/**
* Negates the provided expression and applies the provided copy operation on the returned
* expression.
*
* @param expr the expression to negate
* @param copy the copy operation to perform
* @return the negated expression, copied according to the copy operation
*/
public Expression negate(Expression expr, Copy copy) {
final Expression exprNoParen = removeParentheses(expr);
if (exprNoParen.getNodeType() == PREFIX_EXPRESSION) {
final PrefixExpression pe = (PrefixExpression) exprNoParen;
if (hasOperator(pe, NOT)) {
return copy.perform(this, removeParentheses(pe.getOperand()));
}
}
return not(parenthesizeIfNeeded(copy.perform(this, expr)));
}
public void testPartialCU1() throws Exception {
IPackageFragment pack1 = fSourceFolder.createPackageFragment("test1", false, null);
StringBuffer buf = new StringBuffer();
buf.append("package test1;\n");
buf.append("import java.util.Vector;\n");
buf.append("public class E {\n");
buf.append(" private int fField1;\n");
buf.append(" private int fField2;\n");
buf.append(" public void foo1() {\n");
buf.append(" fField1 = fField2;\n");
buf.append(" }\n");
buf.append(" public int foo1(int i) {\n");
buf.append(" return i;\n");
buf.append(" }\n");
buf.append("}");
String existing = buf.toString();
ICompilationUnit cu = pack1.createCompilationUnit("E.java", existing, false, null);
String statement = "fField1 = fField2;";
int offset = existing.indexOf(statement);
CompilationUnit astRoot = getPartialCompilationUnit(cu, offset);
String string = ASTNodes.asFormattedString(astRoot, 0, String.valueOf('\n'), null);
buf = new StringBuffer();
buf.append("package test1;\n");
buf.append("import java.util.Vector;\n");
buf.append("public class E {\n");
buf.append(" private int fField1;\n");
buf.append(" private int fField2;\n");
buf.append(" public void foo1() {\n");
buf.append(" fField1 = fField2;\n");
buf.append(" }\n");
buf.append(" public int foo1(int i) {\n");
buf.append(" }\n");
buf.append("}");
String expected = buf.toString();
assertEqualString(string, expected);
offset = expected.indexOf(statement);
ASTNode node = NodeFinder.perform(astRoot, offset, statement.length());
Assignment assignment = (Assignment) ((ExpressionStatement) node).getExpression();
Expression e1 = assignment.getLeftHandSide();
Expression e2 = assignment.getRightHandSide();
assertNotNull(e1.resolveTypeBinding());
assertNotNull(e2.resolveTypeBinding());
assertTrue(((SimpleName) e1).resolveBinding() instanceof IVariableBinding);
assertTrue(((SimpleName) e2).resolveBinding() instanceof IVariableBinding);
assertAllBindings(astRoot);
}
/*
* @see ASTVisitor#visit(ArrayInitializer)
*/
public boolean visit(ArrayInitializer node) {
this.fBuffer.append("{"); // $NON-NLS-1$
for (Iterator it = node.expressions().iterator(); it.hasNext(); ) {
Expression e = (Expression) it.next();
e.accept(this);
if (it.hasNext()) {
this.fBuffer.append(","); // $NON-NLS-1$
}
}
this.fBuffer.append("}"); // $NON-NLS-1$
return false;
}
// test is for fourth calloutMapping in Testdata (Role)
public void testGetExpression_InstanceType3() {
CalloutMappingDeclaration calloutDecl =
(CalloutMappingDeclaration) _role.bodyDeclarations().get(7);
List parameterMappings = calloutDecl.getParameterMappings();
ParameterMapping testObj = (ParameterMapping) parameterMappings.get(0);
Expression actual = (Expression) testObj.getExpression();
assertTrue(
"Wrong Type of given expression, type is " + actual.getClass(),
actual instanceof SimpleName);
}
/*
* Visit the AST expression and get the ParseTree Expression.
* This is used by the individual visits when parsing a tree.
* It passes to the top method (createExpression), which can
* handle the InvalidExpressionException.
*
* If any visit doesn't return an expression, then an invalid
* expression exception will be thrown to indicate this. If the
* incoming expression is <code>null</code>, then return of <code>null</code> is ok because
* this would be for an optional expression which didn't exist.
*
* @return The new ParseTree Expression or <code>null</code> if incoming expression was null.
*
* @see createExpression(org.eclipse.jdt.core.dom.Expression)
* @exception InvalidExpressionException
* @since 1.0.0
*/
protected final PTExpression perform(Expression astExpression) {
if (astExpression != null) {
expression = null;
astExpression.accept(this);
if (expression == null)
throw new InvalidExpressionException(
MessageFormat.format(
WorkbenchUtilityMessages.ParseTreeCreationFromAST_ExpressionTooComplicated_EXC_,
new Object[] {astExpression.toString()}));
return expression;
} else return null; // This is ok. It means an optional expression was being processed and the
// expression didn't exist.
}
private boolean visitLiteral(Expression node) {
fToken.update(node);
for (int i = 0, n = fJobSemanticHighlightings.length; i < n; i++) {
SemanticHighlighting semanticHighlighting = fJobSemanticHighlightings[i];
if (fJobHighlightings[i].isEnabled() && semanticHighlighting.consumesLiteral(fToken)) {
int offset = node.getStartPosition();
int length = node.getLength();
if (offset > -1 && length > 0) addPosition(offset, length, fJobHighlightings[i]);
break;
}
}
fToken.clear();
return false;
}
/** {@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;
}
// !!! -- same as in ExtractTempRefactoring
private boolean isLiteralNodeSelected() throws JavaModelException {
IExpressionFragment fragment = getSelectedExpression();
if (fragment == null) return false;
Expression expression = fragment.getAssociatedExpression();
if (expression == null) return false;
switch (expression.getNodeType()) {
case ASTNode.BOOLEAN_LITERAL:
case ASTNode.CHARACTER_LITERAL:
case ASTNode.NULL_LITERAL:
case ASTNode.NUMBER_LITERAL:
return true;
default:
return false;
}
}
private ITypeBinding guessBindingForReference(Expression expression) {
ITypeBinding binding = expression.resolveTypeBinding();
if (binding == null) {
binding = ASTResolving.guessBindingForReference(expression);
}
return binding;
}
/**
* If given expression is constant value expression, return its value string; or return null.
*
* @param node
* @return
*/
protected String checkConstantValue(Expression node) {
Object constValue = node.resolveConstantExpressionValue();
if (constValue != null
&& (constValue instanceof Number
|| constValue instanceof Character
|| constValue instanceof Boolean)) {
StringBuffer buffer = new StringBuffer();
if (constValue instanceof Character) {
buffer.append('\'');
char charValue = ((Character) constValue).charValue();
buffer.append(checkCharValue(charValue));
buffer.append('\'');
} else {
buffer.append(constValue);
}
return buffer.toString();
}
if (constValue != null && (constValue instanceof String)) {
StringBuffer buffer = new StringBuffer();
String str = (String) constValue;
int length = str.length();
/*
if (length > 20) {
return null;
}*/
buffer.append("\"");
for (int i = 0; i < length; i++) {
char c = str.charAt(i);
buffer.append(checkCharValue(c));
}
buffer.append("\"");
return buffer.toString();
}
return null;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((matchExpression == null) ? 0 : matchExpression.hashCode());
return result;
}
/**
* Converts an assignment, postfix expression or prefix expression into an assignable equivalent
* expression using the getter.
*
* @param node the assignment/prefix/postfix node
* @param astRewrite the astRewrite to use
* @param getterExpression the expression to insert for read accesses or <code>null</code> if such
* an expression does not exist
* @param variableType the type of the variable that the result will be assigned to
* @param is50OrHigher <code>true</code> if a 5.0 or higher environment can be used
* @return an expression that can be assigned to the type variableType with node being replaced by
* a equivalent expression using the getter
*/
public static Expression getAssignedValue(
ASTNode node,
ASTRewrite astRewrite,
Expression getterExpression,
ITypeBinding variableType,
boolean is50OrHigher) {
InfixExpression.Operator op = null;
AST ast = astRewrite.getAST();
if (isNotInBlock(node)) return null;
if (node.getNodeType() == ASTNode.ASSIGNMENT) {
Assignment assignment = ((Assignment) node);
Expression rightHandSide = assignment.getRightHandSide();
Expression copiedRightOp = (Expression) astRewrite.createCopyTarget(rightHandSide);
if (assignment.getOperator() == Operator.ASSIGN) {
ITypeBinding rightHandSideType = rightHandSide.resolveTypeBinding();
copiedRightOp =
createNarrowCastIfNessecary(
copiedRightOp, rightHandSideType, ast, variableType, is50OrHigher);
return copiedRightOp;
}
if (getterExpression != null) {
InfixExpression infix = ast.newInfixExpression();
infix.setLeftOperand(getterExpression);
infix.setOperator(ASTNodes.convertToInfixOperator(assignment.getOperator()));
infix.setRightOperand(copiedRightOp);
ITypeBinding infixType = infix.resolveTypeBinding();
return createNarrowCastIfNessecary(infix, infixType, ast, variableType, is50OrHigher);
}
} else if (node.getNodeType() == ASTNode.POSTFIX_EXPRESSION) {
PostfixExpression po = (PostfixExpression) node;
if (po.getOperator() == PostfixExpression.Operator.INCREMENT)
op = InfixExpression.Operator.PLUS;
if (po.getOperator() == PostfixExpression.Operator.DECREMENT)
op = InfixExpression.Operator.MINUS;
} else if (node.getNodeType() == ASTNode.PREFIX_EXPRESSION) {
PrefixExpression pe = (PrefixExpression) node;
if (pe.getOperator() == PrefixExpression.Operator.INCREMENT)
op = InfixExpression.Operator.PLUS;
if (pe.getOperator() == PrefixExpression.Operator.DECREMENT)
op = InfixExpression.Operator.MINUS;
}
if (op != null && getterExpression != null) {
return createInfixInvocationFromPostPrefixExpression(
op, getterExpression, ast, variableType, is50OrHigher);
}
return null;
}
@Override
public boolean visit(IfStatement node) {
final ASTBuilder b = this.ctx.getASTBuilder();
final Refactorings r = this.ctx.getRefactorings();
final Statement thenStmt = node.getThenStatement();
final Statement elseStmt = node.getElseStatement();
final Expression condition = node.getExpression();
if (elseStmt != null && asList(elseStmt).isEmpty()) {
r.remove(elseStmt);
return DO_NOT_VISIT_SUBTREE;
} else if (thenStmt != null && asList(thenStmt).isEmpty()) {
if (elseStmt != null) {
r.replace(node, b.if0(b.negate(condition), b.move(elseStmt)));
} else {
final List<Expression> sideEffectExprs = new ArrayList<Expression>();
collectSideEffects(condition, sideEffectExprs);
if (!sideEffectExprs.isEmpty()) {
for (Expression sideEffectExpr : sideEffectExprs) {
r.insertBefore(b.toStmt(b.move(sideEffectExpr)), node);
}
}
r.remove(node);
}
return DO_NOT_VISIT_SUBTREE;
}
final Object constantCondition = condition.resolveConstantExpressionValue();
if (Boolean.TRUE.equals(constantCondition)) {
r.replace(node, b.copy(thenStmt));
if (lastStmtIsThrowOrReturn(thenStmt)) {
r.remove(getNextSiblings(node));
}
return DO_NOT_VISIT_SUBTREE;
} else if (Boolean.FALSE.equals(constantCondition)) {
if (elseStmt != null) {
r.replace(node, b.copy(elseStmt));
if (lastStmtIsThrowOrReturn(elseStmt)) {
r.remove(getNextSiblings(node));
}
} else {
r.remove(node);
}
return DO_NOT_VISIT_SUBTREE;
}
return VISIT_SUBTREE;
}
@Override
public boolean visit(NormalAnnotation node) {
//
// Test method?
//
if (isTestAnnotation(node.getTypeName().toString())) {
ASTNode parent = node.getParent();
if (parent instanceof MethodDeclaration) {
addTestMethod((MethodDeclaration) parent, JDK15_ANNOTATION);
} else if (parent instanceof TypeDeclaration) {
m_typeIsTest = true;
m_annotationType = JDK15_ANNOTATION;
}
List pairs = node.values();
for (Iterator it = pairs.iterator(); it.hasNext(); ) {
MemberValuePair mvp = (MemberValuePair) it.next();
Name attribute = mvp.getName();
String name = attribute.getFullyQualifiedName();
if ("groups".equals(name)) {
Expression value = mvp.getValue();
// Array?
if (value instanceof ArrayInitializer) {
ArrayInitializer ai = (ArrayInitializer) value;
List expressions = ai.expressions();
for (Iterator it2 = expressions.iterator(); it2.hasNext(); ) {
Expression e = (Expression) it2.next();
addGroup(e.toString());
}
} else if (value instanceof SimpleName) {
Object boundValue = value.resolveConstantExpressionValue();
addGroup(boundValue.toString());
} else if (value instanceof StringLiteral) {
addGroup(value.toString());
}
}
}
} else if (isFactoryAnnotation(node.getTypeName().toString())) {
if (node.getParent() instanceof MethodDeclaration) {
m_annotationType = JDK15_ANNOTATION;
addFactoryMethod((MethodDeclaration) node.getParent(), JDK15_ANNOTATION);
}
}
return false;
}
/*
* @see ASTVisitor#visit(InfixExpression)
*/
public boolean visit(InfixExpression node) {
node.getLeftOperand().accept(this);
this.fBuffer.append(' '); // for cases like x= i - -1; or x= i++ + ++i;
this.fBuffer.append(node.getOperator().toString());
this.fBuffer.append(' ');
node.getRightOperand().accept(this);
final List extendedOperands = node.extendedOperands();
if (extendedOperands.size() != 0) {
this.fBuffer.append(' ');
for (Iterator it = extendedOperands.iterator(); it.hasNext(); ) {
this.fBuffer.append(node.getOperator().toString()).append(' ');
Expression e = (Expression) it.next();
e.accept(this);
}
}
return false;
}
/* (non-Javadoc)
* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ArrayAccess)
*/
public boolean visit(ArrayAccess node) {
PTArrayAccess aa = InstantiationFactory.eINSTANCE.createPTArrayAccess();
List indexes = aa.getIndexes();
Expression arrayExp = node;
while (arrayExp.getNodeType() == ASTNode.ARRAY_ACCESS) {
// Visit the index to get the index expression.
ArrayAccess array = (ArrayAccess) arrayExp;
indexes.add(
0,
perform(
array
.getIndex())); // We're trying to create the final expression from inside out, the
// indexes are created in reverse order.
arrayExp = array.getArray();
}
aa.setArray(perform(arrayExp)); // Final arrayExp is the true expression.
expression = aa; // Set the return expression for this visit.
return false;
}
/*
* @see ASTVisitor#visit(ForStatement)
*/
public boolean visit(ForStatement node) {
this.fBuffer.append("for ("); // $NON-NLS-1$
for (Iterator it = node.initializers().iterator(); it.hasNext(); ) {
Expression e = (Expression) it.next();
e.accept(this);
}
this.fBuffer.append("; "); // $NON-NLS-1$
if (node.getExpression() != null) {
node.getExpression().accept(this);
}
this.fBuffer.append("; "); // $NON-NLS-1$
for (Iterator it = node.updaters().iterator(); it.hasNext(); ) {
Expression e = (Expression) it.next();
e.accept(this);
}
this.fBuffer.append(") "); // $NON-NLS-1$
node.getBody().accept(this);
return false;
}
/**
* If the passed node is a method invocation or class creation then return the return type of the
* method based on what is the returned value assigned to.
*
* @param node
* @return return type
*/
private String getReturnType(Expression node) {
ASTNode parent = node.getParent();
if (parent instanceof VariableDeclarationFragment) {
ASTNode grandParent = parent.getParent();
if (grandParent instanceof VariableDeclarationStatement) {
Type typ = ((VariableDeclarationStatement) grandParent).getType();
return removeSpecialSymbols(getFullyQualifiedNameFor(typ.toString()));
}
}
return null;
}
@Override
public boolean equals(Object obj) {
if (this == obj) return true;
if (obj == null) return false;
if (getClass() != obj.getClass()) return false;
final SwitchLabel other = (SwitchLabel) obj;
if (matchExpression == null) {
if (other.matchExpression != null) return false;
} else if (!matchExpression.equals(other.matchExpression)) return false;
return true;
}
private SingleVariableDeclaration createParameterDeclaration(
String parameterName,
VariableDeclarationFragment fragement,
Expression arrayAccess,
ForStatement statement,
ImportRewrite importRewrite,
ASTRewrite rewrite,
TextEditGroup group,
LinkedProposalPositionGroup pg,
boolean makeFinal) {
CompilationUnit compilationUnit = (CompilationUnit) arrayAccess.getRoot();
AST ast = compilationUnit.getAST();
SingleVariableDeclaration result = ast.newSingleVariableDeclaration();
SimpleName name = ast.newSimpleName(parameterName);
pg.addPosition(rewrite.track(name), true);
result.setName(name);
ITypeBinding arrayTypeBinding = arrayAccess.resolveTypeBinding();
Type type =
importType(arrayTypeBinding.getElementType(), statement, importRewrite, compilationUnit);
if (arrayTypeBinding.getDimensions() != 1) {
type = ast.newArrayType(type, arrayTypeBinding.getDimensions() - 1);
}
result.setType(type);
if (fragement != null) {
VariableDeclarationStatement declaration =
(VariableDeclarationStatement) fragement.getParent();
ModifierRewrite.create(rewrite, result).copyAllModifiers(declaration, group);
}
if (makeFinal
&& (fragement == null
|| ASTNodes.findModifierNode(Modifier.FINAL, ASTNodes.getModifiers(fragement))
== null)) {
ModifierRewrite.create(rewrite, result).setModifiers(Modifier.FINAL, 0, group);
}
return result;
}
@Override
public String getIntroducedVariableName() {
if (fElementDeclaration != null) {
return fElementDeclaration.getName().getIdentifier();
} else {
ForStatement forStatement = getForStatement();
IJavaProject javaProject =
((CompilationUnit) forStatement.getRoot()).getJavaElement().getJavaProject();
String[] proposals = getVariableNameProposals(fArrayAccess.resolveTypeBinding(), javaProject);
return proposals[0];
}
}
@Override
protected Statement convert(
CompilationUnitRewrite cuRewrite, TextEditGroup group, LinkedProposalModel positionGroups)
throws CoreException {
ASTRewrite rewrite = cuRewrite.getASTRewrite();
ImportRewrite importRewrite = cuRewrite.getImportRewrite();
ForStatement forStatement = getForStatement();
IJavaProject javaProject =
((CompilationUnit) forStatement.getRoot()).getJavaElement().getJavaProject();
String[] proposals = getVariableNameProposals(fArrayAccess.resolveTypeBinding(), javaProject);
String parameterName;
if (fElementDeclaration != null) {
parameterName = fElementDeclaration.getName().getIdentifier();
} else {
parameterName = proposals[0];
}
LinkedProposalPositionGroup pg = positionGroups.getPositionGroup(parameterName, true);
if (fElementDeclaration != null) pg.addProposal(parameterName, null, 10);
for (int i = 0; i < proposals.length; i++) {
pg.addProposal(proposals[i], null, 10);
}
AST ast = forStatement.getAST();
EnhancedForStatement result = ast.newEnhancedForStatement();
SingleVariableDeclaration parameterDeclaration =
createParameterDeclaration(
parameterName,
fElementDeclaration,
fArrayAccess,
forStatement,
importRewrite,
rewrite,
group,
pg,
fMakeFinal);
result.setParameter(parameterDeclaration);
result.setExpression((Expression) rewrite.createCopyTarget(fArrayAccess));
convertBody(
forStatement.getBody(), fIndexBinding, fArrayBinding, parameterName, rewrite, group, pg);
result.setBody(getBody(cuRewrite, group, positionGroups));
positionGroups.setEndPosition(rewrite.track(result));
return result;
}
