Refine search
@Override protected void handleOneMany(ASTNode[] replacements, TextEditGroup description) { AST ast= fToReplace[0].getAST(); // to replace == 1, but more than one replacement. Have to check if we // need to insert a block to not change structure if (ASTNodes.isControlStatementBody(fDescriptor)) { Block block= ast.newBlock(); ListRewrite statements= fRewrite.getListRewrite(block, Block.STATEMENTS_PROPERTY); for (int i= 0; i < replacements.length; i++) { statements.insertLast(replacements[i], description); } fRewrite.replace(fToReplace[0], block, description); } else { ListRewrite container= fRewrite.getListRewrite(fToReplace[0].getParent(), (ChildListPropertyDescriptor)fDescriptor); container.replace(fToReplace[0], replacements[0], description); for (int i= 1; i < replacements.length; i++) { container.insertAfter(replacements[i], replacements[i - 1], description); } } } }
/** * Sets the list property to the given array of values. For each string in the array, * a string place-holder node is created. * * @param node * @param values * @param property * @param nodeType of the string place holders to create */ protected void setListNodeProperty(ASTNode node, String[] values, ChildListPropertyDescriptor property, int nodeType) { ListRewrite listRewrite = rewriter.getListRewrite(node, property); @SuppressWarnings("unchecked") List<ASTNode> oldValues = listRewrite.getRewrittenList(); // clear old values for (ASTNode oldValue : oldValues) { listRewrite.remove(oldValue, null); } // insert new values for (String value : values) { listRewrite.insertLast(rewriter.createStringPlaceholder(value, nodeType), null); } }
private void addMethod(ListRewrite rewriter, ASTNode insertion, MethodDeclaration stub, BodyDeclaration replace) { if (replace != null) { rewriter.replace(replace, stub, null); } else { if (insertion != null) rewriter.insertBefore(stub, insertion, null); else rewriter.insertLast(stub, null); } }
private void addHelper(ListRewrite rewriter, ASTNode insertion, MethodDeclaration stub) { if (insertion != null) rewriter.insertBefore(stub, insertion, null); else rewriter.insertFirst(stub, null); }
private void insertTag(TagElement tag, TagElement previousTag, ListRewrite tagsRewrite) { if (previousTag == null) tagsRewrite.insertFirst(tag, fDescription); else tagsRewrite.insertAfter(tag, previousTag, fDescription); }
private void copyImportToDestination(IImportDeclaration declaration, ASTRewrite targetRewrite, CompilationUnit sourceCuNode, CompilationUnit destinationCuNode) throws JavaModelException { ImportDeclaration sourceNode= ASTNodeSearchUtil.getImportDeclarationNode(declaration, sourceCuNode); ImportDeclaration copiedNode= (ImportDeclaration) ASTNode.copySubtree(targetRewrite.getAST(), sourceNode); targetRewrite.getListRewrite(destinationCuNode, CompilationUnit.IMPORTS_PROPERTY).insertLast(copiedNode, null); }
public static void addOverrideAnnotation(ASTRewrite rewrite, MethodDeclaration decl, IMethodBinding binding) { String version= binding.getJavaElement().getJavaProject().getOption(JavaCore.COMPILER_COMPLIANCE, true); if (!binding.getDeclaringClass().isInterface() || !JavaModelUtil.isVersionLessThan(version, JavaCore.VERSION_1_6)) { final Annotation marker= rewrite.getAST().newMarkerAnnotation(); marker.setTypeName(rewrite.getAST().newSimpleName("Override")); //$NON-NLS-1$ rewrite.getListRewrite(decl, MethodDeclaration.MODIFIERS2_PROPERTY).insertFirst(marker, null); } }
public static void addFallThroughProposals(IInvocationContext context, IProblemLocation problem, Collection proposals) { ASTNode selectedNode= problem.getCoveringNode(context.getASTRoot()); if (selectedNode instanceof SwitchCase && selectedNode.getParent() instanceof SwitchStatement) { AST ast= selectedNode.getAST(); ASTRewrite rewrite= ASTRewrite.create(ast); ListRewrite listRewrite= rewrite.getListRewrite(selectedNode.getParent(), SwitchStatement.STATEMENTS_PROPERTY); listRewrite.insertBefore(ast.newBreakStatement(), selectedNode, null); String label= CorrectionMessages.LocalCorrectionsSubProcessor_insert_break_statement; Image image= JavaPluginImages.get(JavaPluginImages.IMG_CORRECTION_CHANGE); ASTRewriteCorrectionProposal proposal= new ASTRewriteCorrectionProposal(label, context.getCompilationUnit(), rewrite, 5, image); proposals.add(proposal); } }
private boolean updateParameterizedTypeReference(ITypeBinding[] parameters, ParameterizedType type, CompilationUnitRewrite targetRewrite, TextEditGroup group) { if (!(type.getParent() instanceof ClassInstanceCreation)) { final ListRewrite rewrite= targetRewrite.getASTRewrite().getListRewrite(type, ParameterizedType.TYPE_ARGUMENTS_PROPERTY); final AST ast= targetRewrite.getRoot().getAST(); Type simpleType= null; for (int index= type.typeArguments().size(); index < parameters.length; index++) { simpleType= ast.newSimpleType(ast.newSimpleName(parameters[index].getName())); rewrite.insertLast(simpleType, group); } } return true; }
public static ASTRewriteCorrectionProposal getMakeTypeAbstractProposal(ICompilationUnit cu, TypeDeclaration typeDeclaration, int relevance) { AST ast= typeDeclaration.getAST(); ASTRewrite rewrite= ASTRewrite.create(ast); Modifier newModifier= ast.newModifier(Modifier.ModifierKeyword.ABSTRACT_KEYWORD); rewrite.getListRewrite(typeDeclaration, TypeDeclaration.MODIFIERS2_PROPERTY).insertLast(newModifier, null); String label= Messages.format(CorrectionMessages.ModifierCorrectionSubProcessor_addabstract_description, typeDeclaration.getName().getIdentifier()); Image image= JavaPluginImages.get(JavaPluginImages.IMG_CORRECTION_CHANGE); LinkedCorrectionProposal proposal= new LinkedCorrectionProposal(label, cu, rewrite, relevance, image); proposal.addLinkedPosition(rewrite.track(newModifier), true, "modifier"); //$NON-NLS-1$ return proposal; }
private void addParameterToConstructor(final ASTRewrite rewrite, final MethodDeclaration declaration) throws JavaModelException { Assert.isNotNull(rewrite); Assert.isNotNull(declaration); final AST ast= declaration.getAST(); final String name= getNameForEnclosingInstanceConstructorParameter(); final SingleVariableDeclaration variable= ast.newSingleVariableDeclaration(); variable.setType(createEnclosingType(ast)); variable.setName(ast.newSimpleName(name)); rewrite.getListRewrite(declaration, MethodDeclaration.PARAMETERS_PROPERTY).insertFirst(variable, null); JavadocUtil.addParamJavadoc(name, declaration, rewrite, fType.getJavaProject(), null); }
private void updateConstructorReference(ITypeBinding[] parameters, ParameterizedType type, CompilationUnitRewrite targetRewrite, ICompilationUnit cu, TextEditGroup group) throws CoreException { final ListRewrite rewrite= targetRewrite.getASTRewrite().getListRewrite(type, ParameterizedType.TYPE_ARGUMENTS_PROPERTY); TypeParameter parameter= null; for (int index= type.typeArguments().size(); index < parameters.length; index++) { parameter= targetRewrite.getRoot().getAST().newTypeParameter(); parameter.setName(targetRewrite.getRoot().getAST().newSimpleName(parameters[index].getName())); rewrite.insertLast(parameter, group); } if (type.getParent() instanceof ClassInstanceCreation) updateConstructorReference((ClassInstanceCreation) type.getParent(), targetRewrite, cu, group); }
private MethodRefParameter createNewMethodRefParameter(ParameterInfo info) { MethodRefParameter newP= getASTRewrite().getAST().newMethodRefParameter(); // only add name iff first parameter already has a name: List<? extends ASTNode> parameters= getParamgumentsRewrite().getOriginalList(); if (parameters.size() > 0) if (((MethodRefParameter) parameters.get(0)).getName() != null) newP.setName(getASTRewrite().getAST().newSimpleName(info.getNewName())); newP.setType(createNewDocRefType(info)); newP.setVarargs(info.isNewVarargs()); return newP; }
private static void addExceptionToThrows(AST ast, MethodDeclaration methodDeclaration, ASTRewrite rewrite, Type type2) { ITypeBinding binding = type2.resolveBinding(); if (binding == null || isNotYetThrown(binding, methodDeclaration.thrownExceptionTypes())) { Type newType = (Type) ASTNode.copySubtree(ast, type2); ListRewrite listRewriter = rewrite.getListRewrite(methodDeclaration, MethodDeclaration.THROWN_EXCEPTION_TYPES_PROPERTY); listRewriter.insertLast(newType, null); } }
private TextEditGroup makeDeclarationPrivate(ASTRewrite rewriter, FieldDeclaration decl) { AST ast= rewriter.getAST(); TextEditGroup description= new TextEditGroup(RefactoringCoreMessages.SelfEncapsulateField_change_visibility); if (decl.fragments().size() > 1) { //TODO: doesn't work for cases like this: int field1, field2= field1, field3= field2; // keeping refs to field rewriter.remove(fFieldDeclaration, description); ChildListPropertyDescriptor descriptor= getBodyDeclarationsProperty(decl.getParent()); VariableDeclarationFragment newField= (VariableDeclarationFragment) rewriter.createCopyTarget(fFieldDeclaration); FieldDeclaration fieldDecl= ast.newFieldDeclaration(newField); fieldDecl.setType((Type)rewriter.createCopyTarget(decl.getType())); fieldDecl.modifiers().addAll(ASTNodeFactory.newModifiers(ast, Modifier.PRIVATE)); rewriter.getListRewrite(decl.getParent(), descriptor).insertAfter(fieldDecl, decl, description); } else { ModifierRewrite.create(rewriter, decl).setVisibility(Modifier.PRIVATE, description); } return description; }
private static void createMissingDefaultProposal(IInvocationContext context, SwitchStatement switchStatement, Image image, Collection<ICommandAccess> proposals) { AST ast= switchStatement.getAST(); ASTRewrite astRewrite= ASTRewrite.create(ast); ListRewrite listRewrite= astRewrite.getListRewrite(switchStatement, SwitchStatement.STATEMENTS_PROPERTY); SwitchCase newSwitchCase= ast.newSwitchCase(); newSwitchCase.setExpression(null); listRewrite.insertLast(newSwitchCase, null); listRewrite.insertLast(ast.newBreakStatement(), null); String label= CorrectionMessages.LocalCorrectionsSubProcessor_add_default_case_description; proposals.add(new ASTRewriteCorrectionProposal(label, context.getCompilationUnit(), astRewrite, IProposalRelevance.ADD_MISSING_DEFAULT_CASE, image)); }
private static void removeException(ASTRewrite rewrite, UnionType unionType, Type exception) { ListRewrite listRewrite = rewrite.getListRewrite(unionType, UnionType.TYPES_PROPERTY); List<Type> types = unionType.types(); for (Iterator<Type> iterator = types.iterator(); iterator.hasNext();) { Type type = iterator.next(); if (type.equals(exception)) { listRewrite.remove(type, null); } } }
@Override protected ASTRewrite getRewrite() { AST ast= fCallerNode.getAST(); ASTRewrite rewrite= ASTRewrite.create(ast); ChildListPropertyDescriptor property= getProperty(); for (int i= 0; i < fInsertIndexes.length; i++) { int idx= fInsertIndexes[i]; String key= "newarg_" + i; //$NON-NLS-1$ Expression newArg= evaluateArgumentExpressions(ast, fParamTypes[idx], key); ListRewrite listRewriter= rewrite.getListRewrite(fCallerNode, property); listRewriter.insertAt(newArg, idx, null); } return rewrite; }
@Override public void rewriteAST(CompilationUnitRewrite cuRewrite, LinkedProposalModel model) throws CoreException { TextEditGroup group= createTextEditGroup(FixMessages.TypeParametersFix_remove_redundant_type_arguments_description, cuRewrite); ASTRewrite rewrite= cuRewrite.getASTRewrite(); rewrite.setTargetSourceRangeComputer(new NoCommentSourceRangeComputer()); ListRewrite listRewrite= rewrite.getListRewrite(fParameterizedType, ParameterizedType.TYPE_ARGUMENTS_PROPERTY); List<Type> typeArguments= fParameterizedType.typeArguments(); for (Iterator<Type> iterator= typeArguments.iterator(); iterator.hasNext();) { listRewrite.remove(iterator.next(), group); } } }
private static void insertToType(ASTRewrite rewrite, ASTNode node, AbstractTypeDeclaration typeDeclaration) { switch (node.getNodeType()) { case ASTNode.ANNOTATION_TYPE_DECLARATION: case ASTNode.ENUM_DECLARATION: case ASTNode.TYPE_DECLARATION: case ASTNode.METHOD_DECLARATION: case ASTNode.FIELD_DECLARATION: case ASTNode.INITIALIZER: rewrite.getListRewrite(typeDeclaration, typeDeclaration.getBodyDeclarationsProperty()).insertAt(node, ASTNodes.getInsertionIndex((BodyDeclaration) node, typeDeclaration.bodyDeclarations()), null); break; default: Assert.isTrue(false, String.valueOf(node.getNodeType())); } }