Java 类org.eclipse.jdt.core.dom.rewrite.ListRewrite 实例源码

项目：code 文件：RemoveAnnotations.java

@Override
      public boolean visit(VariableDeclarationFragment param) {

    ASTNode parent = param.getParent();
    if (parent instanceof VariableDeclarationStatement) {
        VariableDeclarationStatement statement = (VariableDeclarationStatement) parent;

        ASTNode annotation = getAnnotation(statement.modifiers(), "Domain");
        if (annotation != null) {
            ListRewrite paramRewrite = rewrite.getListRewrite(statement,
                    VariableDeclarationStatement.MODIFIERS2_PROPERTY);
            paramRewrite.remove(annotation, null);
        }
    }
    return super.visit(param);
}

项目：code 文件：RemoveAnnotations.java

@Override
      public boolean visit(VariableDeclarationFragment param) {

    ASTNode parent = param.getParent();
    if (parent instanceof VariableDeclarationStatement) {
        VariableDeclarationStatement statement = (VariableDeclarationStatement) parent;

        ASTNode annotation = getAnnotation(statement.modifiers(), "Domain");
        if (annotation != null) {
            ListRewrite paramRewrite = rewrite.getListRewrite(statement,
                    VariableDeclarationStatement.MODIFIERS2_PROPERTY);
            paramRewrite.remove(annotation, null);
        }
    }
    return super.visit(param);
}

项目：bayou 文件：Visitor.java

/**
 * Performs global post-processing of synthesized code:
 * - Adds import declarations
 *
 * @param ast      the owner of the document
 * @param env      environment that was used for synthesis
 * @param document draft program document
 * @throws BadLocationException if an error occurred when rewriting document
 */
private void postprocessGlobal(AST ast, Environment env, Document document)
        throws BadLocationException {
    /* add imports */
    ASTRewrite rewriter = ASTRewrite.create(ast);
    ListRewrite lrw = rewriter.getListRewrite(cu, CompilationUnit.IMPORTS_PROPERTY);
    Set<Class> toImport = new HashSet<>(env.imports);
    toImport.addAll(sketch.exceptionsThrown()); // add all catch(...) types to imports
    for (Class cls : toImport) {
        while (cls.isArray())
            cls = cls.getComponentType();
        if (cls.isPrimitive() || cls.getPackage().getName().equals("java.lang"))
            continue;
        ImportDeclaration impDecl = cu.getAST().newImportDeclaration();
        String className = cls.getName().replaceAll("\\$", "\\.");
        impDecl.setName(cu.getAST().newName(className.split("\\.")));
        lrw.insertLast(impDecl, null);
    }
    rewriter.rewriteAST(document, null).apply(document);
}

项目：SparkBuilderGenerator 文件：StagedBuilderCompilationUnitGenerator.java

public void generateBuilder(CompilationUnitModificationDomain modificationDomain, List<StagedBuilderProperties> stagedBuilderStages) {
    AST ast = modificationDomain.getAst();
    TypeDeclaration originalType = modificationDomain.getOriginalType();
    ListRewrite listRewrite = modificationDomain.getListRewrite();

    builderRemover.removeExistingBuilderWhenNeeded(modificationDomain);

    // TODO: eventually have a better design to avoid nulls here
    List<TypeDeclaration> stageInterfaces = createStageInterfaces(modificationDomain, stagedBuilderStages);
    TypeDeclaration builderType = stagedBuilderClassCreator.createBuilderClass(modificationDomain, stagedBuilderStages, stageInterfaces);

    privateConstructorPopulator.addPrivateConstructorToCompilationUnit(ast, originalType, builderType, listRewrite, collectAllFieldsFromAllStages(stagedBuilderStages));
    stagedBuilderStaticBuilderCreatorMethodCreator.addBuilderMethodToCompilationUnit(modificationDomain, builderType, stagedBuilderStages);

    stageInterfaces.stream().forEach(stageInterface -> listRewrite.insertLast(stageInterface, null));
    listRewrite.insertLast(builderType, null);

    importPopulator.populateImports(modificationDomain);
}

项目：SparkBuilderGenerator 文件：StagedBuilderCreationWithMethodAdder.java

public void addBuilderMethodToCompilationUnit(CompilationUnitModificationDomain modificationDomain, TypeDeclaration builderType,
        StagedBuilderProperties currentStage) {
    AST ast = modificationDomain.getAst();
    ListRewrite listRewrite = modificationDomain.getListRewrite();
    BuilderField firstField = currentStage.getNamedVariableDeclarationField().get(0);

    StagedBuilderProperties nextStage = currentStage.getNextStage().orElse(currentStage);
    MethodDeclaration staticWithMethod = stagedBuilderWithMethodDefiniationCreatorFragment.createNewWithMethod(ast, firstField, nextStage);
    staticWithMethod.modifiers().add(ast.newModifier(ModifierKeyword.STATIC_KEYWORD));

    String parameterName = firstField.getBuilderFieldName();
    String withMethodName = staticWithMethod.getName().toString();
    Block block = newBuilderAndWithMethodCallCreationFragment.createReturnBlock(ast, builderType, withMethodName, parameterName);

    javadocAdder.addJavadocForWithBuilderMethod(ast, builderType.getName().toString(), parameterName, staticWithMethod);

    staticWithMethod.setBody(block);

    listRewrite.insertLast(staticWithMethod, null);
}

项目：eclipse.jdt.ls 文件：ReplaceRewrite.java

protected void handleManyMany(ASTNode[] replacements, TextEditGroup description) {
    ListRewrite container= fRewrite.getListRewrite(fToReplace[0].getParent(), (ChildListPropertyDescriptor)fDescriptor);
    if (fToReplace.length == replacements.length) {
        for (int i= 0; i < fToReplace.length; i++) {
            container.replace(fToReplace[i], replacements[i], description);
        }
    } else if (fToReplace.length < replacements.length) {
        for (int i= 0; i < fToReplace.length; i++) {
            container.replace(fToReplace[i], replacements[i], description);
        }
        for (int i= fToReplace.length; i < replacements.length; i++) {
            container.insertAfter(replacements[i], replacements[i - 1], description);
        }
    } else if (fToReplace.length > replacements.length) {
        int delta= fToReplace.length - replacements.length;
        for(int i= 0; i < delta; i++) {
            container.remove(fToReplace[i], description);
        }
        for (int i= delta, r= 0; i < fToReplace.length; i++, r++) {
            container.replace(fToReplace[i], replacements[r], description);
        }
    }
}

项目：eclipse.jdt.ls 文件：StatementRewrite.java

@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);
        }
    }
}

项目：eclipse.jdt.ls 文件：TypeAnnotationRewrite.java

/**
 * Removes all {@link Annotation} whose only {@link Target} is {@link ElementType#TYPE_USE} from
 * <code>node</code>'s <code>childListProperty</code>.
 * <p>
 * In a combination of {@link ElementType#TYPE_USE} and {@link ElementType#TYPE_PARAMETER}
 * the latter is ignored, because this is implied by the former and creates no ambiguity.</p>
 *
 * @param node ASTNode
 * @param childListProperty child list property
 * @param rewrite rewrite that removes the nodes
 * @param editGroup the edit group in which to collect the corresponding text edits, or null if
 *            ungrouped
 */
public static void removePureTypeAnnotations(ASTNode node, ChildListPropertyDescriptor childListProperty, ASTRewrite rewrite, TextEditGroup editGroup) {
    CompilationUnit root= (CompilationUnit) node.getRoot();
    if (!JavaModelUtil.is18OrHigher(root.getJavaElement().getJavaProject())) {
        return;
    }
    ListRewrite listRewrite= rewrite.getListRewrite(node, childListProperty);
    @SuppressWarnings("unchecked")
    List<? extends ASTNode> children= (List<? extends ASTNode>) node.getStructuralProperty(childListProperty);
    for (ASTNode child : children) {
        if (child instanceof Annotation) {
            Annotation annotation= (Annotation) child;
            if (isPureTypeAnnotation(annotation)) {
                listRewrite.remove(child, editGroup);
            }
        }
    }
}

项目：eclipse.jdt.ls 文件：StubUtility2.java

/**
 * Evaluates the insertion position of a new node.
 *
 * @param listRewrite The list rewriter to which the new node will be added
 * @param sibling The Java element before which the new element should be added.
 * @return the AST node of the list to insert before or null to insert as last.
 * @throws JavaModelException thrown if accessing the Java element failed
 */

public static ASTNode getNodeToInsertBefore(ListRewrite listRewrite, IJavaElement sibling) throws JavaModelException {
    if (sibling instanceof IMember) {
        ISourceRange sourceRange= ((IMember) sibling).getSourceRange();
        if (sourceRange == null) {
            return null;
        }
        int insertPos= sourceRange.getOffset();

        List<? extends ASTNode> members= listRewrite.getOriginalList();
        for (int i= 0; i < members.size(); i++) {
            ASTNode curr= members.get(i);
            if (curr.getStartPosition() >= insertPos) {
                return curr;
            }
        }
    }
    return null;
}

项目：eclipse.jdt.ls 文件：UnusedCodeFix.java

private void splitUpDeclarations(ASTRewrite rewrite, TextEditGroup group, VariableDeclarationFragment frag, VariableDeclarationStatement originalStatement, List<Expression> sideEffects) {
    if (sideEffects.size() > 0) {
        ListRewrite statementRewrite= rewrite.getListRewrite(originalStatement.getParent(), (ChildListPropertyDescriptor) originalStatement.getLocationInParent());

        Statement previousStatement= originalStatement;
        for (int i= 0; i < sideEffects.size(); i++) {
            Expression sideEffect= sideEffects.get(i);
            Expression movedInit= (Expression) rewrite.createMoveTarget(sideEffect);
            ExpressionStatement wrapped= rewrite.getAST().newExpressionStatement(movedInit);
            statementRewrite.insertAfter(wrapped, previousStatement, group);
            previousStatement= wrapped;
        }

        VariableDeclarationStatement newDeclaration= null;
        List<VariableDeclarationFragment> fragments= originalStatement.fragments();
        int fragIndex= fragments.indexOf(frag);
        ListIterator<VariableDeclarationFragment> fragmentIterator= fragments.listIterator(fragIndex+1);
        while (fragmentIterator.hasNext()) {
            VariableDeclarationFragment currentFragment= fragmentIterator.next();
            VariableDeclarationFragment movedFragment= (VariableDeclarationFragment) rewrite.createMoveTarget(currentFragment);
            if (newDeclaration == null) {
                newDeclaration= rewrite.getAST().newVariableDeclarationStatement(movedFragment);
                Type copiedType= (Type) rewrite.createCopyTarget(originalStatement.getType());
                newDeclaration.setType(copiedType);
            } else {
                newDeclaration.fragments().add(movedFragment);
            }
        }
        if (newDeclaration != null){
            statementRewrite.insertAfter(newDeclaration, previousStatement, group);
            if (originalStatement.fragments().size() == newDeclaration.fragments().size() + 1){
                rewrite.remove(originalStatement, group);
            }
        }
    }
}

项目：eclipse.jdt.ls 文件：ImplementInterfaceProposal.java

@Override
protected ASTRewrite getRewrite() throws CoreException {
    ASTNode boundNode= fAstRoot.findDeclaringNode(fBinding);
    ASTNode declNode= null;
    CompilationUnit newRoot= fAstRoot;
    if (boundNode != null) {
        declNode= boundNode; // is same CU
    } else {
        newRoot= ASTResolving.createQuickFixAST(getCompilationUnit(), null);
        declNode= newRoot.findDeclaringNode(fBinding.getKey());
    }
    ImportRewrite imports= createImportRewrite(newRoot);

    if (declNode instanceof TypeDeclaration) {
        AST ast= declNode.getAST();
        ASTRewrite rewrite= ASTRewrite.create(ast);

        ImportRewriteContext importRewriteContext= new ContextSensitiveImportRewriteContext(declNode, imports);
        Type newInterface= imports.addImport(fNewInterface, ast, importRewriteContext, TypeLocation.OTHER);
        ListRewrite listRewrite= rewrite.getListRewrite(declNode, TypeDeclaration.SUPER_INTERFACE_TYPES_PROPERTY);
        listRewrite.insertLast(newInterface, null);

        return rewrite;
    }
    return null;
}

项目：eclipse.jdt.ls 文件：NewVariableCorrectionProposal.java

private ASTRewrite doAddEnumConst(CompilationUnit astRoot) {
    SimpleName node= fOriginalNode;

    ASTNode newTypeDecl= astRoot.findDeclaringNode(fSenderBinding);
    if (newTypeDecl == null) {
        astRoot= ASTResolving.createQuickFixAST(getCompilationUnit(), null);
        newTypeDecl= astRoot.findDeclaringNode(fSenderBinding.getKey());
    }

    if (newTypeDecl != null) {
        AST ast= newTypeDecl.getAST();

        ASTRewrite rewrite= ASTRewrite.create(ast);

        EnumConstantDeclaration constDecl= ast.newEnumConstantDeclaration();
        constDecl.setName(ast.newSimpleName(node.getIdentifier()));

        ListRewrite listRewriter= rewrite.getListRewrite(newTypeDecl, EnumDeclaration.ENUM_CONSTANTS_PROPERTY);
        listRewriter.insertLast(constDecl, null);

        return rewrite;
    }
    return null;
}

项目：eclipse.jdt.ls 文件：JavadocTagsSubProcessor.java

private void insertAllMissingTypeTags(ASTRewrite rewriter, TypeDeclaration typeDecl) {
    AST ast= typeDecl.getAST();
    Javadoc javadoc= typeDecl.getJavadoc();
    ListRewrite tagsRewriter= rewriter.getListRewrite(javadoc, Javadoc.TAGS_PROPERTY);

    List<TypeParameter> typeParams= typeDecl.typeParameters();
    for (int i= typeParams.size() - 1; i >= 0; i--) {
        TypeParameter decl= typeParams.get(i);
        String name= '<' + decl.getName().getIdentifier() + '>';
        if (findTag(javadoc, TagElement.TAG_PARAM, name) == null) {
            TagElement newTag= ast.newTagElement();
            newTag.setTagName(TagElement.TAG_PARAM);
            TextElement text= ast.newTextElement();
            text.setText(name);
            newTag.fragments().add(text);
            insertTabStop(rewriter, newTag.fragments(), "typeParam" + i); //$NON-NLS-1$
            insertTag(tagsRewriter, newTag, getPreviousTypeParamNames(typeParams, decl));
        }
    }
}

项目：code 文件：RemoveAnnotations.java

private void setFieldAnnotation(ASTRewrite rewrite, FieldDeclaration fieldDeclaration, String annotation) {
    SingleMemberAnnotation newFieldAnnotation = fieldDeclaration.getAST().newSingleMemberAnnotation();
    newFieldAnnotation.setTypeName(rewrite.getAST().newSimpleName("Domain"));
    StringLiteral newStringLiteral = rewrite.getAST().newStringLiteral();
    newStringLiteral.setLiteralValue(annotation);
    newFieldAnnotation.setValue(newStringLiteral);
    ASTNode modifier = getModifier(fieldDeclaration.modifiers());
    if (modifier != null) {
        ListRewrite paramRewrite = rewrite.getListRewrite(fieldDeclaration, FieldDeclaration.MODIFIERS2_PROPERTY);
        paramRewrite.insertAfter(newFieldAnnotation, modifier, null);
    }
    else {
        ListRewrite fieldRewrite = rewrite.getListRewrite(fieldDeclaration, FieldDeclaration.MODIFIERS2_PROPERTY);
        fieldRewrite.insertFirst(newFieldAnnotation, null);
    }

}