/*
* Evaluates possible return expressions. The favourite expression is returned.
*/
private Expression evaluateReturnExpressions(
AST ast, ITypeBinding returnBinding, int returnOffset) {
CompilationUnit root = (CompilationUnit) fMethodDecl.getRoot();
Expression result = null;
if (returnBinding != null) {
ScopeAnalyzer analyzer = new ScopeAnalyzer(root);
IBinding[] bindings =
analyzer.getDeclarationsInScope(
returnOffset, ScopeAnalyzer.VARIABLES | ScopeAnalyzer.CHECK_VISIBILITY);
for (int i = 0; i < bindings.length; i++) {
IVariableBinding curr = (IVariableBinding) bindings[i];
ITypeBinding type = curr.getType();
if (type != null && type.isAssignmentCompatible(returnBinding) && testModifier(curr)) {
if (result == null) {
result = ast.newSimpleName(curr.getName());
}
addLinkedPositionProposal(RETURN_EXPRESSION_KEY, curr.getName(), null);
}
}
}
Expression defaultExpression =
ASTNodeFactory.newDefaultExpression(
ast, fMethodDecl.getReturnType2(), fMethodDecl.getExtraDimensions());
addLinkedPositionProposal(RETURN_EXPRESSION_KEY, ASTNodes.asString(defaultExpression), null);
if (result == null) {
return defaultExpression;
}
return result;
}
private void assertAllBindings(CompilationUnit astRoot) {
List<AbstractTypeDeclaration> list = astRoot.types();
for (int i = 0; i < list.size(); i++) {
TypeDeclaration decl = (TypeDeclaration) list.get(i);
assertTrue(decl.resolveBinding() != null);
if (!decl.isInterface() && decl.getSuperclassType() != null) {
assertTrue(decl.getSuperclassType().resolveBinding() != null);
}
List<Type> interfaces = decl.superInterfaceTypes();
for (int j = 0; j < interfaces.size(); j++) {
assertTrue(interfaces.get(j).resolveBinding() != null);
}
MethodDeclaration[] declarations = decl.getMethods();
for (int k = 0; k < declarations.length; k++) {
MethodDeclaration meth = declarations[k];
assertTrue(meth.resolveBinding() != null);
List<SingleVariableDeclaration> params = meth.parameters();
for (int n = 0; n < params.size(); n++) {
SingleVariableDeclaration arg = params.get(n);
assertTrue(arg.resolveBinding() != null);
}
if (!meth.isConstructor()) {
assertTrue(meth.getReturnType2().resolveBinding() != null);
}
}
}
}
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;
}
private MethodDecl getMethodDecl(MethodDeclaration node) {
String qualifiedTypeName = currentPackage + "." + Joiner.on(".").skipNulls().join(typesInFile);
SimpleName nameNode = node.getName();
String methodName = nameNode.toString();
String returnType = "";
if (node.getReturnType2() != null) {
returnType = getNameOfType(node.getReturnType2());
}
Map<String, String> params = new HashMap<>();
for (Object p : node.parameters()) {
String typeName = OBJECT_TYPE;
if (p instanceof SingleVariableDeclaration) {
SingleVariableDeclaration svd = (SingleVariableDeclaration) p;
String varName = svd.getName().toString();
Type type = svd.getType();
typeName = getNameOfType(type);
params.put(varName, typeName);
} else {
System.err.println("Unxepected AST node type for param - " + p);
}
}
return new MethodDecl(
methodName, qualifiedTypeName, returnType, nameNode.getStartPosition(), params);
}
@Override
public boolean visit(MethodDeclaration node) {
if (node.getBody() == null) {
return VISIT_SUBTREE;
}
List<Statement> bodyStmts = statements(node.getBody());
if (bodyStmts.size() == 1) {
SuperMethodInvocation bodyMi = asExpression(bodyStmts.get(0), SuperMethodInvocation.class);
if (bodyMi != null) {
IMethodBinding bodyMethodBinding = bodyMi.resolveMethodBinding();
IMethodBinding declMethodBinding = node.resolveBinding();
if (declMethodBinding != null
&& bodyMethodBinding != null
&& declMethodBinding.overrides(bodyMethodBinding)
&& !hasSignificantAnnotations(declMethodBinding)
&& haveSameModifiers(bodyMethodBinding, declMethodBinding)) {
if (Modifier.isProtected(declMethodBinding.getModifiers())
&& !declaredInSamePackage(bodyMethodBinding, declMethodBinding)) {
// protected also means package visibility, so check if it is required
if (!isMethodUsedInItsPackage(declMethodBinding, node)) {
this.ctx.getRefactorings().remove(node);
return DO_NOT_VISIT_SUBTREE;
}
} else {
this.ctx.getRefactorings().remove(node);
return DO_NOT_VISIT_SUBTREE;
}
}
}
}
return VISIT_SUBTREE;
}
private static void gatherDuplicateFixes(
HashMap<String, ArrayList<IProblem>> duplicates,
HashMap<String, ArrayList<FixTypes>> ret,
SourceKey src) {
for (Map.Entry<String, ArrayList<IProblem>> ent : duplicates.entrySet()) {
IProblem p = ent.getValue().get(0);
TypeDeclaration cls = null;
for (TypeDeclaration t : src.classes) {
if (t.getStartPosition() <= p.getSourceStart()
&& (t.getStartPosition() + t.getLength()) >= p.getSourceEnd()) {
cls = t;
break;
}
}
if (cls == null) {
System.out.println("WTF! COULD NOT FIND DUPLICATE CLASS");
System.exit(1);
}
for (MethodDeclaration mtd : cls.getMethods()) {
if (mtd.getName().toString().equals(ent.getKey())) {
// Resolving will fail on duplicate methods.. HOPE that the real
// one is the first one, only real case is the synthetic method
// in Mooshroom, which this works
if (mtd.resolveBinding() == null) {
String clsName = cls.resolveBinding().getQualifiedName().replace('.', '/');
if (!ret.containsKey(clsName)) ret.put(clsName, new ArrayList<FixTypes>());
ret.get(clsName).add(new FixTypes.RemoveMethod(mtd));
}
}
}
}
}
private boolean callsWritingConstructor(
MethodDeclaration methodDeclaration,
HashSet writingConstructorBindings,
Set visitedMethodDeclarations) {
Block body = methodDeclaration.getBody();
if (body == null) return false;
List statements = body.statements();
if (statements.size() == 0) return false;
Statement statement = (Statement) statements.get(0);
if (!(statement instanceof ConstructorInvocation)) return false;
ConstructorInvocation invocation = (ConstructorInvocation) statement;
IMethodBinding constructorBinding = invocation.resolveConstructorBinding();
if (constructorBinding == null) return false;
if (writingConstructorBindings.contains(constructorBinding)) {
return true;
} else {
ASTNode declaration =
ASTNodes.findDeclaration(constructorBinding, methodDeclaration.getParent());
if (!(declaration instanceof MethodDeclaration)) return false;
if (visitedMethodDeclarations.contains(declaration)) {
return false;
}
visitedMethodDeclarations.add(methodDeclaration);
return callsWritingConstructor(
(MethodDeclaration) declaration, writingConstructorBindings, visitedMethodDeclarations);
}
}
@SuppressWarnings("rawtypes")
private void getASTConstructor(
final AbstractTypeDeclaration typeDecl, final List<ConstructorDeclaration> results) {
final List bodyDecls = typeDecl.bodyDeclarations();
IFile file = null;
for (int i = 0, len = bodyDecls.size(); i < len; i++) {
final BodyDeclaration bodyDecl = (BodyDeclaration) bodyDecls.get(i);
if (bodyDecl.getNodeType() == ASTNode.METHOD_DECLARATION) {
final org.eclipse.jdt.core.dom.MethodDeclaration methodDecl =
(org.eclipse.jdt.core.dom.MethodDeclaration) bodyDecl;
if (methodDecl.isConstructor()) {
final IMethodBinding methodBinding = methodDecl.resolveBinding();
// built an ast based representation.
if (methodBinding == null) {
if (file == null) file = getResource();
ConstructorDeclaration mirrorDecl =
(ConstructorDeclaration) Factory.createDeclaration(methodDecl, file, _env);
if (mirrorDecl != null) results.add(mirrorDecl);
}
}
}
}
}
/** Adds the onReceive method to the broadcast receiver class */
@SuppressWarnings("unchecked")
private void addOnReceiveMethod() {
MethodDeclaration onReceiveMethod = ast.newMethodDeclaration();
onReceiveMethod.modifiers().add(ast.newModifier(ModifierKeyword.PUBLIC_KEYWORD));
onReceiveMethod.setReturnType2(ast.newPrimitiveType(PrimitiveType.VOID));
onReceiveMethod.setName(ast.newSimpleName(ONRECEIVE_METHOD_NAME));
addMethodParameter(
onReceiveMethod,
getName(CONTEXT_CLASS).toLowerCase(),
ast.newSimpleType(ast.newSimpleName(getName(CONTEXT_CLASS))));
addMethodParameter(
onReceiveMethod,
getName(INTENT_CLASS).toLowerCase(),
ast.newSimpleType(ast.newSimpleName(getName(INTENT_CLASS))));
addEmptyBlock(onReceiveMethod);
classDecl.bodyDeclarations().add(onReceiveMethod);
// Adds JavaDoc to the method
addComment(
onReceiveMethod, CodeUtilsNLS.MODEL_BroadcastReceiverClass_onReceiveMethodDescription);
addMethodReference(
onReceiveMethod,
BROADCAST_RECEIVER_SUPERCLASS,
ONRECEIVE_METHOD_NAME,
new Type[] {
ast.newSimpleType(ast.newSimpleName(getName(CONTEXT_CLASS))),
ast.newSimpleType(ast.newSimpleName(getName(INTENT_CLASS)))
});
}
private void printStaticInterface(
AbstractTypeDeclaration node,
String typeName,
List<FieldDeclaration> fields,
List<MethodDeclaration> methods) {
List<IVariableBinding> staticFields =
getStaticFieldsNeedingAccessors(fields, /* isInterface */ true);
if (staticFields.isEmpty()) {
if (!Options.stripReflection()) {
printf("\n@interface %s : NSObject\n@end\n", typeName);
} else {
return;
}
}
printf("\n@implementation %s\n\n", typeName);
printStaticVars(fields, /* isInterface */ true);
printStaticFieldAccessors(staticFields, methods);
for (MethodDeclaration method : methods) {
if (method.getBody() != null) {
printNormalMethod(method);
}
}
if (!Options.stripReflection()) {
printMetadata(node);
}
println("@end");
}
/**
* Visits the method invocation to get number of assertion in this test method.
*
* @param md Visit method declaration in source code.
* @return False because we don't look into child nodes.
*/
public boolean visit(MethodDeclaration md) {
if (md.getName() != null) {
this.numOfMethods++;
if (md.getName().getIdentifier().startsWith("test")) {
this.numOfTestMethods++;
} else if (isJUnit4Test(md)) {
this.numOfTestMethods++;
}
// Check test method body to look for assertion statement.
Block methodBody = md.getBody();
if (methodBody != null && methodBody.statements() != null) {
List stmts = methodBody.statements();
this.numOfStatements += stmts.size();
// Looks through all statements in this method body.
for (Iterator i = stmts.iterator(); i.hasNext(); ) {
Statement stmt = (Statement) i.next(); // NOPMD
// MethodInvocation is one kind of expression statement.
if (stmt instanceof ExpressionStatement) {
ExpressionStatement estmt = (ExpressionStatement) stmt;
checkAssertions(estmt);
}
}
}
}
// No need to visit child nodes anymore.
return false;
}
private static boolean canAddFinal(IBinding binding, ASTNode declNode) {
if (!(binding instanceof IVariableBinding)) return false;
IVariableBinding varbinding = (IVariableBinding) binding;
int modifiers = varbinding.getModifiers();
if (Modifier.isFinal(modifiers)
|| Modifier.isVolatile(modifiers)
|| Modifier.isTransient(modifiers)) return false;
ASTNode parent = ASTNodes.getParent(declNode, VariableDeclarationExpression.class);
if (parent != null && ((VariableDeclarationExpression) parent).fragments().size() > 1)
return false;
if (varbinding.isField() && !Modifier.isPrivate(modifiers)) return false;
if (varbinding.isParameter()) {
ASTNode varDecl = declNode.getParent();
if (varDecl instanceof MethodDeclaration) {
MethodDeclaration declaration = (MethodDeclaration) varDecl;
if (declaration.getBody() == null) return false;
}
}
return true;
}
public boolean visit(MethodDeclaration node) {
if (null != m_methodFilter) {
return node.getName().getIdentifier().equals(m_methodFilter.getElementName())
&& node.parameters().size() == m_methodFilter.getNumberOfParameters();
} else {
return true;
}
}
public static MethodDeclaration findMethodDeclarationByName(TypeDeclaration owner, String name) {
for (MethodDeclaration methodDeclaration : owner.getMethods()) {
if (methodDeclaration.getName().getFullyQualifiedName().equals(name)) {
return methodDeclaration;
}
}
return null;
}
/* (non-Javadoc)
* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.Javadoc)
*/
public boolean visit(Javadoc node) {
List tags = node.tags();
ASTNode parent = node.getParent();
if (parent != null) {
switch (parent.getNodeType()) {
case ASTNode.TYPE_DECLARATION:
{
TypeDeclaration type = (TypeDeclaration) parent;
if (type.isInterface()) {
processTags(
fType,
pruneTags(tags, type),
IApiJavadocTag.TYPE_INTERFACE,
IApiJavadocTag.MEMBER_NONE);
} else {
processTags(
fType,
pruneTags(tags, type),
IApiJavadocTag.TYPE_CLASS,
IApiJavadocTag.MEMBER_NONE);
}
break;
}
case ASTNode.METHOD_DECLARATION:
{
MethodDeclaration method = (MethodDeclaration) parent;
String signature = Signatures.getMethodSignatureFromNode(method);
if (signature != null) {
String methodname = method.getName().getFullyQualifiedName();
int member = IApiJavadocTag.MEMBER_METHOD;
if (method.isConstructor()) {
member = IApiJavadocTag.MEMBER_CONSTRUCTOR;
methodname = "<init>"; // $NON-NLS-1$
}
IMethodDescriptor descriptor = fType.getMethod(methodname, signature);
processTags(descriptor, pruneTags(tags, method), getEnclosingType(method), member);
}
break;
}
case ASTNode.FIELD_DECLARATION:
{
FieldDeclaration field = (FieldDeclaration) parent;
List fields = field.fragments();
VariableDeclarationFragment fragment = null;
for (Iterator iter = fields.iterator(); iter.hasNext(); ) {
fragment = (VariableDeclarationFragment) iter.next();
processTags(
fType.getField(fragment.getName().getFullyQualifiedName()),
pruneTags(tags, field),
getEnclosingType(field),
IApiJavadocTag.MEMBER_FIELD);
}
break;
}
}
}
return false;
}
private String extractNativeMethodBody(MethodDeclaration m) {
assert (m.getModifiers() & Modifier.NATIVE) > 0;
String nativeCode = extractNativeCode(m.getStartPosition(), m.getLength());
if (nativeCode == null) {
ErrorUtil.warning(m, "no native code found");
return "";
}
return '{' + nativeCode + '}';
}
public boolean visit(MethodDeclaration node) {
String signature = getSignature(node);
push(
node.isConstructor() ? JavaNode.CONSTRUCTOR : JavaNode.METHOD,
signature,
node.getStartPosition(),
node.getLength());
return false;
}
private ASTRewrite doAddParam(CompilationUnit cu) {
AST ast = cu.getAST();
SimpleName node = fOriginalNode;
BodyDeclaration decl = ASTResolving.findParentBodyDeclaration(node);
if (decl instanceof MethodDeclaration) {
MethodDeclaration methodDeclaration = (MethodDeclaration) decl;
ASTRewrite rewrite = ASTRewrite.create(ast);
ImportRewrite imports = createImportRewrite((CompilationUnit) decl.getRoot());
ImportRewriteContext importRewriteContext =
new ContextSensitiveImportRewriteContext(decl, imports);
SingleVariableDeclaration newDecl = ast.newSingleVariableDeclaration();
newDecl.setType(
evaluateVariableType(
ast, imports, importRewriteContext, methodDeclaration.resolveBinding()));
newDecl.setName(ast.newSimpleName(node.getIdentifier()));
ListRewrite listRewriter =
rewrite.getListRewrite(decl, MethodDeclaration.PARAMETERS_PROPERTY);
listRewriter.insertLast(newDecl, null);
addLinkedPosition(rewrite.track(node), true, KEY_NAME);
// add javadoc tag
Javadoc javadoc = methodDeclaration.getJavadoc();
if (javadoc != null) {
HashSet<String> leadingNames = new HashSet<String>();
for (Iterator<SingleVariableDeclaration> iter = methodDeclaration.parameters().iterator();
iter.hasNext(); ) {
SingleVariableDeclaration curr = iter.next();
leadingNames.add(curr.getName().getIdentifier());
}
SimpleName newTagRef = ast.newSimpleName(node.getIdentifier());
TagElement newTagElement = ast.newTagElement();
newTagElement.setTagName(TagElement.TAG_PARAM);
newTagElement.fragments().add(newTagRef);
TextElement commentStart = ast.newTextElement();
newTagElement.fragments().add(commentStart);
addLinkedPosition(rewrite.track(newTagRef), false, KEY_NAME);
addLinkedPosition(rewrite.track(commentStart), false, "comment_start"); // $NON-NLS-1$
ListRewrite tagsRewriter = rewrite.getListRewrite(javadoc, Javadoc.TAGS_PROPERTY);
JavadocTagsSubProcessor.insertTag(tagsRewriter, newTagElement, leadingNames);
}
addLinkedPosition(rewrite.track(newDecl.getType()), false, KEY_TYPE);
addLinkedPosition(rewrite.track(newDecl.getName()), false, KEY_NAME);
return rewrite;
}
return null;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.andmore.android.model.java.JavaClass#addComments()
*/
@Override
protected void addComments() throws AndroidException {
ASTNode todoComment;
ASTParser parser = ASTParser.newParser(AST.JLS3);
parser.setSource(document.get().toCharArray());
compUnit = (CompilationUnit) parser.createAST(null);
ast = compUnit.getAST();
rewrite = ASTRewrite.create(ast);
todoComment =
rewrite.createStringPlaceholder(
CodeUtilsNLS.MODEL_Common_ToDoPutYourCodeHere, ASTNode.EMPTY_STATEMENT);
TypeDeclaration receiverClass = (TypeDeclaration) compUnit.types().get(0);
MethodDeclaration method;
Block block;
// Adds the Override annotation and ToDo comment to all overridden
// methods
for (int i = 0; i < receiverClass.bodyDeclarations().size(); i++) {
method = (MethodDeclaration) receiverClass.bodyDeclarations().get(i);
// Adds the Override annotation
rewrite
.getListRewrite(method, method.getModifiersProperty())
.insertFirst(OVERRIDE_ANNOTATION, null);
// Adds the ToDo comment
block = method.getBody();
rewrite.getListRewrite(block, Block.STATEMENTS_PROPERTY).insertFirst(todoComment, null);
}
try {
// Writes the modifications
TextEdit modifications = rewrite.rewriteAST(document, null);
modifications.apply(document);
} catch (IllegalArgumentException e) {
String errMsg = NLS.bind(CodeUtilsNLS.EXC_JavaClass_ErrorApplyingCommentsToCode, className);
AndmoreLogger.error(BroadcastReceiverClass.class, errMsg, e);
throw new AndroidException(errMsg);
} catch (MalformedTreeException e) {
String errMsg = NLS.bind(CodeUtilsNLS.EXC_JavaClass_ErrorApplyingCommentsToCode, className);
AndmoreLogger.error(BroadcastReceiverClass.class, errMsg, e);
throw new AndroidException(errMsg);
} catch (BadLocationException e) {
String errMsg = NLS.bind(CodeUtilsNLS.EXC_JavaClass_ErrorApplyingCommentsToCode, className);
AndmoreLogger.error(BroadcastReceiverClass.class, errMsg, e);
throw new AndroidException(errMsg);
}
}
private Statement createInnerConstructorInvocation(MethodDeclaration m) {
ConstructorInvocation invocation = m.getAST().newConstructorInvocation();
Types.addBinding(invocation, Types.getBinding(m));
for (SingleVariableDeclaration param : ASTUtil.getParameters(m)) {
SimpleName paramName = param.getName();
IVariableBinding paramBinding = Types.getVariableBinding(paramName);
SimpleName argName = m.getAST().newSimpleName(paramName.getIdentifier());
Types.addBinding(argName, paramBinding);
ASTUtil.getArguments(invocation).add(argName);
}
return invocation;
}
@Override
public boolean visit(MethodDeclaration node) {
methods.add(
new OutlineMethod(
node.getName().toString(),
node.getReturnType2(),
node.isConstructor(),
node.getModifiers(),
node.parameters(),
clazz));
return super.visit(node);
}
@Override
public boolean visit(MethodDeclaration node) {
if (nestLevel != 1) return false;
if (targetMethod.getElementName().equals(node.getName().getFullyQualifiedName())) {
IMethod method = (IMethod) node.resolveBinding().getJavaElement();
if (targetMethod.isSimilar(method)) {
mapperMethod = new MapperMethod();
mapperMethod.setMethodDeclaration(node);
return true;
}
}
return false;
}
private Delta deduplicate(CompilationUnit root, ASTRewrite rewrite, Cause cause) {
final List<ASTNode> nodes = cause.getAffectedNodes();
final int size = nodes.size();
final int cloneNumber = size == 0 ? size : size - 1; // minus the original declaration
if (cloneNumber == 0) {
throw new RuntimeException("calling deduplicate() when there are no detected clones");
} else if (cloneNumber >= 1) {
// NOTE: THIS WORKS ONLY AT METHOD LEVEL, other forms of duplication will
// will be ignored.
// The strategy this code follows to perform deduplication is the following:
// per duplicated method declaration, find all of its invocations. Then
// rename each found invocation using the name of the original method declaration.
// After that, remove the duplicated method declaration.
if (AstUtil.isOfType(MethodDeclaration.class, nodes.get(0))) {
final MethodDeclaration original = AstUtil.exactCast(MethodDeclaration.class, nodes.get(0));
final Iterable<ASTNode> rest = Iterables.skip(nodes, 1);
for (ASTNode eachClone : rest) {
final MethodDeclaration duplicate = AstUtil.exactCast(MethodDeclaration.class, eachClone);
final MethodDeclaration copied =
AstUtil.copySubtree(MethodDeclaration.class, root.getAST(), duplicate);
final boolean sameReturn = sameReturnType(original, copied);
if (!sameReturn) { // all or none. We don't do partial deduplication
throw new RuntimeException(
"automatic deduplication cannot be done on methods "
+ "with different return types; please consider "
+ "manual deduplication.");
}
final MethodInvocationVisitor invokesOfDuplication =
new MethodInvocationVisitor(copied.getName());
root.accept(invokesOfDuplication);
final Set<MethodInvocation> invokes = invokesOfDuplication.getMethodInvocations();
for (MethodInvocation each : invokes) {
final MethodInvocation copiedInvoke =
AstUtil.copySubtree(MethodInvocation.class, root.getAST(), each);
copiedInvoke.setName(root.getAST().newSimpleName(original.getName().getIdentifier()));
rewrite.replace(each, copiedInvoke, null);
}
rewrite.remove(duplicate, null);
}
}
}
return createDelta(root, rewrite);
}
/**
* Constructor.
*
* @param methodDeclarationNode the method declaration of this manager handles.
*/
public StubMethodBindingManager(MethodDeclaration methodDeclarationNode) {
this.methodDeclarationNode = methodDeclarationNode;
this.stubMethodLen = methodDeclarationNode.getLength();
this.stubMethodStartPosition = methodDeclarationNode.getStartPosition();
ASTNode astNode = methodDeclarationNode.getRoot();
System.out.println(
"Stub Method, stubMethodLen = "
+ stubMethodLen
+ ", StubMethodStartPosition = "
+ stubMethodStartPosition);
}
private void addMethodDoc(MethodDeclaration node) {
if (node.getJavadoc() != null && node.getParent() instanceof AbstractTypeDeclaration) {
String typeName =
((AbstractTypeDeclaration) node.getParent()).getName().getFullyQualifiedName();
String fullTypeName = currentPackage + "." + removeSpecialSymbols(typeName);
TypeJavadoc typeJavadoc = typeJavadocs.get(fullTypeName);
if (typeJavadoc != null) {
typeJavadoc
.getMethodJavadocs()
.add(
new MethodJavadoc(
node.getName().getFullyQualifiedName(), node.getJavadoc().toString()));
}
}
}
@Override
public void run(IProgressMonitor monitor) throws CoreException {
if (monitor == null) monitor = new NullProgressMonitor();
try {
monitor.beginTask("", 1); // $NON-NLS-1$
monitor.setTaskName(CodeGenerationMessages.GenerateToStringOperation_description);
AbstractTypeDeclaration declaration =
(AbstractTypeDeclaration)
ASTNodes.findDeclaration(fContext.getTypeBinding(), fRewrite.getRoot());
ListRewrite rewriter =
fRewrite
.getASTRewrite()
.getListRewrite(declaration, declaration.getBodyDeclarationsProperty());
if (fContext.getTypeBinding() != null && rewriter != null) {
MethodDeclaration toStringMethod = fGenerator.generateToStringMethod();
List<BodyDeclaration> list = declaration.bodyDeclarations();
BodyDeclaration replace = findMethodToReplace(list, toStringMethod);
if (replace == null
|| ((Boolean)
toStringMethod.getProperty(AbstractToStringGenerator.OVERWRITE_METHOD_PROPERTY))
.booleanValue()) insertMethod(toStringMethod, rewriter, replace);
List<MethodDeclaration> helperMethods = fGenerator.generateHelperMethods();
for (Iterator<MethodDeclaration> iterator = helperMethods.iterator();
iterator.hasNext(); ) {
MethodDeclaration method = iterator.next();
replace = findMethodToReplace(list, method);
if (replace == null
|| ((Boolean) method.getProperty(AbstractToStringGenerator.OVERWRITE_METHOD_PROPERTY))
.booleanValue()) {
insertMethod(method, rewriter, replace);
}
}
JavaModelUtil.applyEdit(
(ICompilationUnit) fUnit.getJavaElement(),
fRewrite.createChange(true).getEdit(),
false,
monitor);
}
} finally {
monitor.done();
}
}
private ITypeBinding getReturnTypeBinding() {
IMethodBinding methodBinding = fMethodDecl.resolveBinding();
if (methodBinding != null && methodBinding.getReturnType() != null) {
return methodBinding.getReturnType();
}
return null;
}
public static MethodDescriptor fromMethodDeclaration(
MethodDeclaration md, BinaryNameResolver resolver) {
MethodDescriptor desc = new MethodDescriptor();
for (Object fragment : md.parameters()) {
SingleVariableDeclaration parameter = (SingleVariableDeclaration) fragment;
Type t = parameter.getType();
if (t.isPrimitiveType()) {
PrimitiveType type = (PrimitiveType) t;
desc.fParameters.add(DescriptorPart.fromPrimitiveType(type));
} else if (t.isArrayType()) {
ArrayType type = (ArrayType) t;
desc.fParameters.add(DescriptorPart.fromArrayType(type, resolver));
} else if (t.isSimpleType()) {
SimpleType type = (SimpleType) t;
desc.fParameters.add(DescriptorPart.fromSimpleType(type, resolver));
} else if (t.isQualifiedType()) {
/*
QualifiedType type = (QualifiedType) t;
System.out.println("DESCRIPTOR QUALIFIED");
*/
} else if (t.isNameQualifiedType()) {
/*
NameQualifiedType type = (NameQualifiedType) t;
System.out.println("DESCRIPTOR NAME_QUALIFIED");
*/
}
}
return desc;
}
// Metodo para tratamento de declarações de métodos
private void methodDeclarationHandler(MethodDeclaration methodDeclaration, ApiClass apiClass) {
IMethodBinding mb = methodDeclaration.resolveBinding();
if (mb == null) {
return;
}
LinkedList<String> paramsType = new LinkedList<String>();
for (ITypeBinding pt : mb.getParameterTypes()) {
paramsType.add(pt.getQualifiedName().toString());
}
ApiMethod apiMethod = new ApiMethod(apiClass, mb.getName(), paramsType);
this.setModifiers(apiMethod, methodDeclaration);
if (mb.isConstructor()) {
apiMethod.setConstructor(true);
apiMethod.setVoid(false);
apiMethod.setFunction(false);
apiMethod.setReturnType(null);
} else if (mb.getReturnType().getQualifiedName().equalsIgnoreCase("void")) {
apiMethod.setVoid(true);
apiMethod.setFunction(false);
apiMethod.setReturnType(null);
} else {
apiMethod.setVoid(false);
apiMethod.setFunction(true);
apiMethod.setReturnType(mb.getReturnType().getQualifiedName());
}
apiClass.getApiMethods().add(apiMethod);
this.methodMap.put(mb, apiMethod);
}
/* (non-Javadoc)
* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.MethodDeclaration)
*/
@Override
public boolean visit(MethodDeclaration node) {
String[] specialMethods = {
"initEvoSuiteFramework",
"initializeClasses",
"resetClasses",
"setSystemProperties",
"clearEvoSuiteFramework"
};
if (!ArrayUtil.contains(specialMethods, node.getName().toString())) {
// System.out.println("Listing method to add:\n"+node.toString());
result += node.toString();
methods.add(node);
}
return super.visit(node);
}
