@Override
protected ASTRewrite getRewrite() throws CoreException {
AST ast = fBodyDecl.getAST();
ASTRewrite rewrite = ASTRewrite.create(ast);
insertMissingJavadocTag(rewrite, fMissingNode, fBodyDecl);
return rewrite;
}
/**
* Updates a javadoc tag, by either adding a new one or removing an existing one
*
* @param body
*/
private void updateTag(BodyDeclaration body) {
Javadoc docnode = body.getJavadoc();
AST ast = body.getAST();
if (docnode == null) {
docnode = ast.newJavadoc();
rewrite.set(body, body.getJavadocProperty(), docnode, null);
}
ListRewrite lrewrite = rewrite.getListRewrite(docnode, Javadoc.TAGS_PROPERTY);
if (remove) {
List<TagElement> tags =
(List<TagElement>) docnode.getStructuralProperty(Javadoc.TAGS_PROPERTY);
if (tags != null) {
TagElement tag = null;
for (int i = 0; i < tags.size(); i++) {
tag = tags.get(i);
if (tagname.equals(tag.getTagName())) {
lrewrite.remove(tag, null);
}
}
}
} else {
TagElement newtag = ast.newTagElement();
newtag.setTagName(tagname);
lrewrite.insertLast(newtag, null);
}
}
@SuppressWarnings("deprecation")
protected IValueList parseExtendedModifiers(BodyDeclaration node) {
if (node.getAST().apiLevel() == AST.JLS2) {
return parseModifiers(node.getModifiers());
} else {
return parseExtendedModifiers(node.modifiers());
}
}
@Override
protected ASTRewrite getRewrite() throws CoreException {
ASTRewrite rewrite = ASTRewrite.create(fBodyDecl.getAST());
if (fBodyDecl instanceof MethodDeclaration) {
insertAllMissingMethodTags(rewrite, (MethodDeclaration) fBodyDecl);
} else {
insertAllMissingTypeTags(rewrite, (TypeDeclaration) fBodyDecl);
}
return rewrite;
}
private boolean isVoidMethod() {
ITypeBinding binding = null;
LambdaExpression enclosingLambdaExpr =
ASTResolving.findEnclosingLambdaExpression(getFirstSelectedNode());
if (enclosingLambdaExpr != null) {
IMethodBinding methodBinding = enclosingLambdaExpr.resolveMethodBinding();
if (methodBinding != null) {
binding = methodBinding.getReturnType();
}
} else {
// if we have an initializer
if (fEnclosingMethodBinding == null) return true;
binding = fEnclosingMethodBinding.getReturnType();
}
if (fEnclosingBodyDeclaration
.getAST()
.resolveWellKnownType("void")
.equals(binding)) // $NON-NLS-1$
return true;
return false;
}
private void initReturnType(ImportRewrite rewriter) {
AST ast = fEnclosingBodyDeclaration.getAST();
fReturnType = null;
fReturnTypeBinding = null;
switch (fReturnKind) {
case ACCESS_TO_LOCAL:
VariableDeclaration declaration =
ASTNodes.findVariableDeclaration(fReturnValue, fEnclosingBodyDeclaration);
fReturnType =
ASTNodeFactory.newType(
ast,
declaration,
rewriter,
new ContextSensitiveImportRewriteContext(declaration, rewriter));
if (declaration.resolveBinding() != null) {
fReturnTypeBinding = declaration.resolveBinding().getType();
}
break;
case EXPRESSION:
Expression expression = (Expression) getFirstSelectedNode();
if (expression.getNodeType() == ASTNode.CLASS_INSTANCE_CREATION) {
fExpressionBinding = ((ClassInstanceCreation) expression).getType().resolveBinding();
} else {
fExpressionBinding = expression.resolveTypeBinding();
}
if (fExpressionBinding != null) {
if (fExpressionBinding.isNullType()) {
getStatus()
.addFatalError(
RefactoringCoreMessages.ExtractMethodAnalyzer_cannot_extract_null_type,
JavaStatusContext.create(fCUnit, expression));
} else {
ITypeBinding normalizedBinding =
Bindings.normalizeForDeclarationUse(fExpressionBinding, ast);
if (normalizedBinding != null) {
ImportRewriteContext context =
new ContextSensitiveImportRewriteContext(fEnclosingBodyDeclaration, rewriter);
fReturnType = rewriter.addImport(normalizedBinding, ast, context);
fReturnTypeBinding = normalizedBinding;
}
}
} else {
fReturnType = ast.newPrimitiveType(PrimitiveType.VOID);
fReturnTypeBinding = ast.resolveWellKnownType("void"); // $NON-NLS-1$
getStatus()
.addError(
RefactoringCoreMessages.ExtractMethodAnalyzer_cannot_determine_return_type,
JavaStatusContext.create(fCUnit, expression));
}
break;
case RETURN_STATEMENT_VALUE:
LambdaExpression enclosingLambdaExpr =
ASTResolving.findEnclosingLambdaExpression(getFirstSelectedNode());
if (enclosingLambdaExpr != null) {
fReturnType = ASTNodeFactory.newReturnType(enclosingLambdaExpr, ast, rewriter, null);
IMethodBinding methodBinding = enclosingLambdaExpr.resolveMethodBinding();
fReturnTypeBinding = methodBinding != null ? methodBinding.getReturnType() : null;
} else if (fEnclosingBodyDeclaration.getNodeType() == ASTNode.METHOD_DECLARATION) {
fReturnType = ((MethodDeclaration) fEnclosingBodyDeclaration).getReturnType2();
fReturnTypeBinding = fReturnType != null ? fReturnType.resolveBinding() : null;
}
break;
default:
fReturnType = ast.newPrimitiveType(PrimitiveType.VOID);
fReturnTypeBinding = ast.resolveWellKnownType("void"); // $NON-NLS-1$
}
if (fReturnType == null) {
fReturnType = ast.newPrimitiveType(PrimitiveType.VOID);
fReturnTypeBinding = ast.resolveWellKnownType("void"); // $NON-NLS-1$
}
}
private void insertMissingJavadocTag(
ASTRewrite rewrite, ASTNode missingNode, BodyDeclaration bodyDecl) {
AST ast = bodyDecl.getAST();
Javadoc javadoc = bodyDecl.getJavadoc();
if (javadoc == null) {
javadoc = ast.newJavadoc();
rewrite.set(bodyDecl, bodyDecl.getJavadocProperty(), javadoc, null);
}
ListRewrite tagsRewriter = rewrite.getListRewrite(javadoc, Javadoc.TAGS_PROPERTY);
StructuralPropertyDescriptor location = missingNode.getLocationInParent();
TagElement newTag;
if (location == SingleVariableDeclaration.NAME_PROPERTY) {
// normal parameter
SingleVariableDeclaration decl = (SingleVariableDeclaration) missingNode.getParent();
String name = ((SimpleName) missingNode).getIdentifier();
newTag = ast.newTagElement();
newTag.setTagName(TagElement.TAG_PARAM);
newTag.fragments().add(ast.newSimpleName(name));
MethodDeclaration methodDeclaration = (MethodDeclaration) bodyDecl;
List<SingleVariableDeclaration> params = methodDeclaration.parameters();
Set<String> sameKindLeadingNames = getPreviousParamNames(params, decl);
List<TypeParameter> typeParams = methodDeclaration.typeParameters();
for (int i = 0; i < typeParams.size(); i++) {
String curr = '<' + typeParams.get(i).getName().getIdentifier() + '>';
sameKindLeadingNames.add(curr);
}
insertTag(tagsRewriter, newTag, sameKindLeadingNames);
} else if (location == TypeParameter.NAME_PROPERTY) {
// type parameter
TypeParameter typeParam = (TypeParameter) missingNode.getParent();
String name = '<' + ((SimpleName) missingNode).getIdentifier() + '>';
newTag = ast.newTagElement();
newTag.setTagName(TagElement.TAG_PARAM);
TextElement text = ast.newTextElement();
text.setText(name);
newTag.fragments().add(text);
List<TypeParameter> params;
if (bodyDecl instanceof TypeDeclaration) {
params = ((TypeDeclaration) bodyDecl).typeParameters();
} else {
params = ((MethodDeclaration) bodyDecl).typeParameters();
}
insertTag(tagsRewriter, newTag, getPreviousTypeParamNames(params, typeParam));
} else if (location == MethodDeclaration.RETURN_TYPE2_PROPERTY) {
newTag = ast.newTagElement();
newTag.setTagName(TagElement.TAG_RETURN);
insertTag(tagsRewriter, newTag, null);
} else if (location == MethodDeclaration.THROWN_EXCEPTION_TYPES_PROPERTY) {
newTag = ast.newTagElement();
newTag.setTagName(TagElement.TAG_THROWS);
TextElement excNode = ast.newTextElement();
excNode.setText(ASTNodes.getQualifiedTypeName((Type) missingNode));
newTag.fragments().add(excNode);
List<Type> exceptions = ((MethodDeclaration) bodyDecl).thrownExceptionTypes();
insertTag(tagsRewriter, newTag, getPreviousExceptionNames(exceptions, missingNode));
} else {
Assert.isTrue(
false, "AddMissingJavadocTagProposal: unexpected node location"); // $NON-NLS-1$
return;
}
TextElement textElement = ast.newTextElement();
textElement.setText(""); // $NON-NLS-1$
newTag.fragments().add(textElement);
addLinkedPosition(rewrite.track(textElement), false, "comment_start"); // $NON-NLS-1$
if (bodyDecl.getJavadoc() == null) {
// otherwise the linked position spans over a line delimiter
newTag.fragments().add(ast.newTextElement());
}
}