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

private static boolean locationNeedsParentheses(StructuralPropertyDescriptor locationInParent) {
    if (locationInParent instanceof ChildListPropertyDescriptor && locationInParent != InfixExpression.EXTENDED_OPERANDS_PROPERTY) {
        // e.g. argument lists of MethodInvocation, ClassInstanceCreation, dimensions of ArrayCreation ...
        return false;
    }
    if (locationInParent == VariableDeclarationFragment.INITIALIZER_PROPERTY
            || locationInParent == SingleVariableDeclaration.INITIALIZER_PROPERTY
            || locationInParent == ReturnStatement.EXPRESSION_PROPERTY
            || locationInParent == EnhancedForStatement.EXPRESSION_PROPERTY
            || locationInParent == ForStatement.EXPRESSION_PROPERTY
            || locationInParent == WhileStatement.EXPRESSION_PROPERTY
            || locationInParent == DoStatement.EXPRESSION_PROPERTY
            || locationInParent == AssertStatement.EXPRESSION_PROPERTY
            || locationInParent == AssertStatement.MESSAGE_PROPERTY
            || locationInParent == IfStatement.EXPRESSION_PROPERTY
            || locationInParent == SwitchStatement.EXPRESSION_PROPERTY
            || locationInParent == SwitchCase.EXPRESSION_PROPERTY
            || locationInParent == ArrayAccess.INDEX_PROPERTY
            || locationInParent == ThrowStatement.EXPRESSION_PROPERTY
            || locationInParent == SynchronizedStatement.EXPRESSION_PROPERTY
            || locationInParent == ParenthesizedExpression.EXPRESSION_PROPERTY) {
        return false;
    }
    return true;
}

public static ChildListPropertyDescriptor getArgumentsProperty(ASTNode invocation) {
  switch (invocation.getNodeType()) {
    case ASTNode.METHOD_INVOCATION:
      return MethodInvocation.ARGUMENTS_PROPERTY;
    case ASTNode.SUPER_METHOD_INVOCATION:
      return SuperMethodInvocation.ARGUMENTS_PROPERTY;

    case ASTNode.CONSTRUCTOR_INVOCATION:
      return ConstructorInvocation.ARGUMENTS_PROPERTY;
    case ASTNode.SUPER_CONSTRUCTOR_INVOCATION:
      return SuperConstructorInvocation.ARGUMENTS_PROPERTY;

    case ASTNode.CLASS_INSTANCE_CREATION:
      return ClassInstanceCreation.ARGUMENTS_PROPERTY;
    case ASTNode.ENUM_CONSTANT_DECLARATION:
      return EnumConstantDeclaration.ARGUMENTS_PROPERTY;

    default:
      throw new IllegalArgumentException(invocation.toString());
  }
}

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

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

/**
 * 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);
            }
        }
    }
}

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

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

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

private static boolean locationNeedsParentheses(StructuralPropertyDescriptor locationInParent) {
  if (locationInParent instanceof ChildListPropertyDescriptor
      && locationInParent != InfixExpression.EXTENDED_OPERANDS_PROPERTY) {
    // e.g. argument lists of MethodInvocation, ClassInstanceCreation, dimensions of ArrayCreation
    // ...
    return false;
  }
  if (locationInParent == VariableDeclarationFragment.INITIALIZER_PROPERTY
      || locationInParent == SingleVariableDeclaration.INITIALIZER_PROPERTY
      || locationInParent == ReturnStatement.EXPRESSION_PROPERTY
      || locationInParent == EnhancedForStatement.EXPRESSION_PROPERTY
      || locationInParent == ForStatement.EXPRESSION_PROPERTY
      || locationInParent == WhileStatement.EXPRESSION_PROPERTY
      || locationInParent == DoStatement.EXPRESSION_PROPERTY
      || locationInParent == AssertStatement.EXPRESSION_PROPERTY
      || locationInParent == AssertStatement.MESSAGE_PROPERTY
      || locationInParent == IfStatement.EXPRESSION_PROPERTY
      || locationInParent == SwitchStatement.EXPRESSION_PROPERTY
      || locationInParent == SwitchCase.EXPRESSION_PROPERTY
      || locationInParent == ArrayAccess.INDEX_PROPERTY
      || locationInParent == ThrowStatement.EXPRESSION_PROPERTY
      || locationInParent == SynchronizedStatement.EXPRESSION_PROPERTY
      || locationInParent == ParenthesizedExpression.EXPRESSION_PROPERTY) {
    return false;
  }
  return true;
}

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

    addLinkedPosition(rewrite.track(newArg), i == 0, key);
  }
  return rewrite;
}

private ASTRewrite doAddField(CompilationUnit astRoot) {
  SimpleName node = fOriginalNode;
  boolean isInDifferentCU = false;

  ASTNode newTypeDecl = astRoot.findDeclaringNode(fSenderBinding);
  if (newTypeDecl == null) {
    astRoot = ASTResolving.createQuickFixAST(getCompilationUnit(), null);
    newTypeDecl = astRoot.findDeclaringNode(fSenderBinding.getKey());
    isInDifferentCU = true;
  }
  ImportRewrite imports = createImportRewrite(astRoot);
  ImportRewriteContext importRewriteContext =
      new ContextSensitiveImportRewriteContext(
          ASTResolving.findParentBodyDeclaration(node), imports);

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

    ASTRewrite rewrite = ASTRewrite.create(ast);

    VariableDeclarationFragment fragment = ast.newVariableDeclarationFragment();
    fragment.setName(ast.newSimpleName(node.getIdentifier()));

    Type type = evaluateVariableType(ast, imports, importRewriteContext, fSenderBinding);

    FieldDeclaration newDecl = ast.newFieldDeclaration(fragment);
    newDecl.setType(type);
    newDecl
        .modifiers()
        .addAll(ASTNodeFactory.newModifiers(ast, evaluateFieldModifiers(newTypeDecl)));

    if (fSenderBinding.isInterface() || fVariableKind == CONST_FIELD) {
      fragment.setInitializer(ASTNodeFactory.newDefaultExpression(ast, type, 0));
    }

    ChildListPropertyDescriptor property = ASTNodes.getBodyDeclarationsProperty(newTypeDecl);
    List<BodyDeclaration> decls =
        ASTNodes.<BodyDeclaration>getChildListProperty(newTypeDecl, property);

    int maxOffset = isInDifferentCU ? -1 : node.getStartPosition();

    int insertIndex = findFieldInsertIndex(decls, newDecl, maxOffset);

    ListRewrite listRewriter = rewrite.getListRewrite(newTypeDecl, property);
    listRewriter.insertAt(newDecl, insertIndex, null);

    ModifierCorrectionSubProcessor.installLinkedVisibilityProposals(
        getLinkedProposalModel(), rewrite, newDecl.modifiers(), fSenderBinding.isInterface());

    addLinkedPosition(rewrite.track(newDecl.getType()), false, KEY_TYPE);
    if (!isInDifferentCU) {
      addLinkedPosition(rewrite.track(node), true, KEY_NAME);
    }
    addLinkedPosition(rewrite.track(fragment.getName()), false, KEY_NAME);

    if (fragment.getInitializer() != null) {
      addLinkedPosition(rewrite.track(fragment.getInitializer()), false, KEY_INITIALIZER);
    }
    return rewrite;
  }
  return null;
}

private VariableDeclarationFragment addFieldDeclaration(
    ASTRewrite rewrite, ASTNode newTypeDecl, int modifiers, Expression expression) {
  if (fExistingFragment != null) {
    return fExistingFragment;
  }

  ChildListPropertyDescriptor property = ASTNodes.getBodyDeclarationsProperty(newTypeDecl);
  List<BodyDeclaration> decls = ASTNodes.getBodyDeclarations(newTypeDecl);
  AST ast = newTypeDecl.getAST();
  String[] varNames = suggestFieldNames(fTypeBinding, expression, modifiers);
  for (int i = 0; i < varNames.length; i++) {
    addLinkedPositionProposal(KEY_NAME, varNames[i], null);
  }
  String varName = varNames[0];

  VariableDeclarationFragment newDeclFrag = ast.newVariableDeclarationFragment();
  newDeclFrag.setName(ast.newSimpleName(varName));

  FieldDeclaration newDecl = ast.newFieldDeclaration(newDeclFrag);

  Type type = evaluateType(ast);
  newDecl.setType(type);
  newDecl.modifiers().addAll(ASTNodeFactory.newModifiers(ast, modifiers));

  ModifierCorrectionSubProcessor.installLinkedVisibilityProposals(
      getLinkedProposalModel(), rewrite, newDecl.modifiers(), false);

  int insertIndex = findFieldInsertIndex(decls, fNodeToAssign.getStartPosition());
  rewrite.getListRewrite(newTypeDecl, property).insertAt(newDecl, insertIndex, null);

  return newDeclFrag;
}

@Override
protected ASTRewrite getRewrite() {
  CompilationUnit targetAstRoot = ASTResolving.createQuickFixAST(
      getCompilationUnit(), null);
  createImportRewrite(targetAstRoot);

  // Find the target type declaration
  TypeDeclaration typeDecl = JavaASTUtils.findTypeDeclaration(targetAstRoot,
      targetQualifiedTypeName);
  if (typeDecl == null) {
    return null;
  }

  ASTRewrite rewrite = ASTRewrite.create(targetAstRoot.getAST());

  // Generate the new method declaration
  MethodDeclaration methodDecl = createMethodDeclaration(rewrite.getAST());

  // Add the new method declaration to the interface
  ChildListPropertyDescriptor property = ASTNodes.getBodyDeclarationsProperty(typeDecl);
  ListRewrite listRewriter = rewrite.getListRewrite(typeDecl, property);
  listRewriter.insertLast(methodDecl, null);

  return rewrite;
}

public static ChildListPropertyDescriptor getArgumentsProperty(ASTNode invocation) {
    switch (invocation.getNodeType()) {
        case ASTNode.METHOD_INVOCATION:
            return MethodInvocation.ARGUMENTS_PROPERTY;
        case ASTNode.SUPER_METHOD_INVOCATION:
            return SuperMethodInvocation.ARGUMENTS_PROPERTY;

        case ASTNode.CONSTRUCTOR_INVOCATION:
            return ConstructorInvocation.ARGUMENTS_PROPERTY;
        case ASTNode.SUPER_CONSTRUCTOR_INVOCATION:
            return SuperConstructorInvocation.ARGUMENTS_PROPERTY;

        case ASTNode.CLASS_INSTANCE_CREATION:
            return ClassInstanceCreation.ARGUMENTS_PROPERTY;
        case ASTNode.ENUM_CONSTANT_DECLARATION:
            return EnumConstantDeclaration.ARGUMENTS_PROPERTY;

        default:
            throw new IllegalArgumentException(invocation.toString());
    }
}

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

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

private static boolean locationNeedsParentheses(StructuralPropertyDescriptor locationInParent) {
    if (locationInParent instanceof ChildListPropertyDescriptor && locationInParent != InfixExpression.EXTENDED_OPERANDS_PROPERTY) {
        // e.g. argument lists of MethodInvocation, ClassInstanceCreation, dimensions of ArrayCreation ...
        return false;
    }
    if (locationInParent == VariableDeclarationFragment.INITIALIZER_PROPERTY
            || locationInParent == SingleVariableDeclaration.INITIALIZER_PROPERTY
            || locationInParent == ReturnStatement.EXPRESSION_PROPERTY
            || locationInParent == EnhancedForStatement.EXPRESSION_PROPERTY
            || locationInParent == ForStatement.EXPRESSION_PROPERTY
            || locationInParent == WhileStatement.EXPRESSION_PROPERTY
            || locationInParent == DoStatement.EXPRESSION_PROPERTY
            || locationInParent == AssertStatement.EXPRESSION_PROPERTY
            || locationInParent == AssertStatement.MESSAGE_PROPERTY
            || locationInParent == IfStatement.EXPRESSION_PROPERTY
            || locationInParent == SwitchStatement.EXPRESSION_PROPERTY
            || locationInParent == SwitchCase.EXPRESSION_PROPERTY
            || locationInParent == ArrayAccess.INDEX_PROPERTY
            || locationInParent == ThrowStatement.EXPRESSION_PROPERTY
            || locationInParent == SynchronizedStatement.EXPRESSION_PROPERTY
            || locationInParent == ParenthesizedExpression.EXPRESSION_PROPERTY) {
        return false;
    }
    return true;
}

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

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

        addLinkedPosition(rewrite.track(newArg), i == 0, key);
    }
    return rewrite;
}

public static ChildListPropertyDescriptor getArgumentsProperty(ASTNode invocation) {
    switch (invocation.getNodeType()) {
        case ASTNode.METHOD_INVOCATION:
            return MethodInvocation.ARGUMENTS_PROPERTY;
        case ASTNode.SUPER_METHOD_INVOCATION:
            return SuperMethodInvocation.ARGUMENTS_PROPERTY;

        case ASTNode.CONSTRUCTOR_INVOCATION:
            return ConstructorInvocation.ARGUMENTS_PROPERTY;
        case ASTNode.SUPER_CONSTRUCTOR_INVOCATION:
            return SuperConstructorInvocation.ARGUMENTS_PROPERTY;

        case ASTNode.CLASS_INSTANCE_CREATION:
            return ClassInstanceCreation.ARGUMENTS_PROPERTY;
        case ASTNode.ENUM_CONSTANT_DECLARATION:
            return EnumConstantDeclaration.ARGUMENTS_PROPERTY;

        default:
            throw new IllegalArgumentException(invocation.toString());
    }
}

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

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

private static boolean locationNeedsParentheses(StructuralPropertyDescriptor locationInParent) {
    if (locationInParent instanceof ChildListPropertyDescriptor && locationInParent != InfixExpression.EXTENDED_OPERANDS_PROPERTY) {
        // e.g. argument lists of MethodInvocation, ClassInstanceCreation, dimensions of ArrayCreation ...
        return false;
    }
    if (locationInParent == VariableDeclarationFragment.INITIALIZER_PROPERTY
            || locationInParent == SingleVariableDeclaration.INITIALIZER_PROPERTY
            || locationInParent == ReturnStatement.EXPRESSION_PROPERTY
            || locationInParent == EnhancedForStatement.EXPRESSION_PROPERTY
            || locationInParent == ForStatement.EXPRESSION_PROPERTY
            || locationInParent == WhileStatement.EXPRESSION_PROPERTY
            || locationInParent == DoStatement.EXPRESSION_PROPERTY
            || locationInParent == AssertStatement.EXPRESSION_PROPERTY
            || locationInParent == AssertStatement.MESSAGE_PROPERTY
            || locationInParent == IfStatement.EXPRESSION_PROPERTY
            || locationInParent == SwitchStatement.EXPRESSION_PROPERTY
            || locationInParent == SwitchCase.EXPRESSION_PROPERTY
            || locationInParent == ArrayAccess.INDEX_PROPERTY
            || locationInParent == ThrowStatement.EXPRESSION_PROPERTY
            || locationInParent == SynchronizedStatement.EXPRESSION_PROPERTY
            || locationInParent == ParenthesizedExpression.EXPRESSION_PROPERTY) {
        return false;
    }
    return true;
}

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

        addLinkedPosition(rewrite.track(newArg), i == 0, key);
    }
    return rewrite;
}

public static ChildListPropertyDescriptor getThrownExceptionsPropertyDescriptor(MethodDeclaration node) {
    List<?> propertyDescriptors = MethodDeclaration.propertyDescriptors(node.getAST().apiLevel());
    for (Object propertyDescriptor : propertyDescriptors) {
        if (propertyDescriptor instanceof ChildListPropertyDescriptor) {
            ChildListPropertyDescriptor childListPropertyDescriptor = (ChildListPropertyDescriptor) propertyDescriptor;
            if (DESCRIPTOR_NAME_AST4.equals(childListPropertyDescriptor.getId())) {
                if (OptimusLogger.logger.isLoggable(Level.FINE)) {
                    OptimusLogger.logger.fine(String.format(DESCRIPTOR_RETURNED_MESSAGE, DESCRIPTOR_NAME_AST4));
                }
                return childListPropertyDescriptor;
            } else if (DESCRIPTOR_NAME_AST8.equals(childListPropertyDescriptor.getId())) {
                if (OptimusLogger.logger.isLoggable(Level.FINE)) {
                    OptimusLogger.logger.fine(String.format(DESCRIPTOR_RETURNED_MESSAGE, DESCRIPTOR_NAME_AST4));
                }
                return childListPropertyDescriptor;
            }
        }
    }
    return null;
}

protected ReplaceRewrite(ASTRewrite rewrite, ASTNode[] nodes) {
    Assert.isNotNull(rewrite);
    Assert.isNotNull(nodes);
    Assert.isTrue(nodes.length > 0);
    fRewrite= rewrite;
    fToReplace= nodes;
    fDescriptor= fToReplace[0].getLocationInParent();
    if (nodes.length > 1) {
        Assert.isTrue(fDescriptor instanceof ChildListPropertyDescriptor);
    }
}

/**
 * Returns the list that contains the given ASTNode. If the node
 * isn't part of any list, <code>null</code> is returned.
 *
 * @param node the node in question
 * @return the list that contains the node or <code>null</code>
 */
public static List<? extends ASTNode> getContainingList(ASTNode node) {
    StructuralPropertyDescriptor locationInParent= node.getLocationInParent();
    if (locationInParent != null && locationInParent.isChildListProperty()) {
        return getChildListProperty(node.getParent(), (ChildListPropertyDescriptor) locationInParent);
    }
    return null;
}

/**
 * Returns the structural property descriptor for the "bodyDeclarations" property
 * of this node (element type: {@link BodyDeclaration}).
 *
 * @param node the node, either an {@link AbstractTypeDeclaration} or an {@link AnonymousClassDeclaration}
 * @return the property descriptor
 */
public static ChildListPropertyDescriptor getBodyDeclarationsProperty(ASTNode node) {
    if (node instanceof AbstractTypeDeclaration) {
        return ((AbstractTypeDeclaration)node).getBodyDeclarationsProperty();
    } else if (node instanceof AnonymousClassDeclaration) {
        return AnonymousClassDeclaration.BODY_DECLARATIONS_PROPERTY;
    }
    // should not happen.
    Assert.isTrue(false);
    return null;
}

/**
 * Removes all children in <code>node</code>'s <code>childListProperty</code>.
 *
 * @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 removeAllChildren(ASTNode node, ChildListPropertyDescriptor childListProperty, ASTRewrite rewrite, TextEditGroup editGroup) {
    ListRewrite listRewrite= rewrite.getListRewrite(node, childListProperty);
    @SuppressWarnings("unchecked")
    List<? extends ASTNode> children= (List<? extends ASTNode>) node.getStructuralProperty(childListProperty);
    for (ASTNode child : children) {
        listRewrite.remove(child, editGroup);
    }
}

@Override
protected ASTRewrite getRewrite() throws CoreException {
    CompilationUnit astRoot = ASTResolving.findParentCompilationUnit(fNode);
    ASTNode typeDecl = astRoot.findDeclaringNode(fSenderBinding);
    ASTNode newTypeDecl = null;
    if (typeDecl != null) {
        newTypeDecl = typeDecl;
    } else {
        astRoot = ASTResolving.createQuickFixAST(getCompilationUnit(), null);
        newTypeDecl = astRoot.findDeclaringNode(fSenderBinding.getKey());
    }
    createImportRewrite(astRoot);

    if (newTypeDecl != null) {
        ASTRewrite rewrite = ASTRewrite.create(astRoot.getAST());

        ChildListPropertyDescriptor property = ASTNodes.getBodyDeclarationsProperty(newTypeDecl);
        List<BodyDeclaration> members = ASTNodes.getBodyDeclarations(newTypeDecl);

        int insertIndex = members.size();
        ListRewrite listRewriter = rewrite.getListRewrite(newTypeDecl, property);

        isGetter = true;
        MethodDeclaration newStub = getStub(rewrite, newTypeDecl);
        listRewriter.insertAt(newStub, insertIndex, null);

        isGetter = false;
        newStub = getStub(rewrite, newTypeDecl);
        listRewriter.insertAt(newStub, insertIndex + 1, null);

        return rewrite;
    }
    return 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;
}

private ChildListPropertyDescriptor getProperty() {
    List<StructuralPropertyDescriptor> list= fCallerNode.structuralPropertiesForType();
    for (int i= 0; i < list.size(); i++) {
        StructuralPropertyDescriptor curr= list.get(i);
        if (curr.isChildListProperty() && "arguments".equals(curr.getId())) { //$NON-NLS-1$
            return (ChildListPropertyDescriptor) curr;
        }
    }
    return null;

}

private ASTRewrite doAddField(CompilationUnit astRoot) {
    SimpleName node= fOriginalNode;
    boolean isInDifferentCU= false;

    ASTNode newTypeDecl= astRoot.findDeclaringNode(fSenderBinding);
    if (newTypeDecl == null) {
        astRoot= ASTResolving.createQuickFixAST(getCompilationUnit(), null);
        newTypeDecl= astRoot.findDeclaringNode(fSenderBinding.getKey());
        isInDifferentCU= true;
    }
    ImportRewrite imports= createImportRewrite(astRoot);
    ImportRewriteContext importRewriteContext= new ContextSensitiveImportRewriteContext(ASTResolving.findParentBodyDeclaration(node), imports);

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

        ASTRewrite rewrite= ASTRewrite.create(ast);

        VariableDeclarationFragment fragment= ast.newVariableDeclarationFragment();
        fragment.setName(ast.newSimpleName(node.getIdentifier()));

        Type type= evaluateVariableType(ast, imports, importRewriteContext, fSenderBinding, TypeLocation.FIELD);

        FieldDeclaration newDecl= ast.newFieldDeclaration(fragment);
        newDecl.setType(type);
        newDecl.modifiers().addAll(ASTNodeFactory.newModifiers(ast, evaluateFieldModifiers(newTypeDecl)));

        if (fSenderBinding.isInterface() || fVariableKind == CONST_FIELD) {
            fragment.setInitializer(ASTNodeFactory.newDefaultExpression(ast, type, 0));
        }

        ChildListPropertyDescriptor property= ASTNodes.getBodyDeclarationsProperty(newTypeDecl);
        List<BodyDeclaration> decls= ASTNodes.<BodyDeclaration>getChildListProperty(newTypeDecl, property);

        int maxOffset= isInDifferentCU ? -1 : node.getStartPosition();

        int insertIndex= findFieldInsertIndex(decls, newDecl, maxOffset);

        ListRewrite listRewriter= rewrite.getListRewrite(newTypeDecl, property);
        listRewriter.insertAt(newDecl, insertIndex, null);

        return rewrite;
    }
    return null;
}

@Override
protected ASTRewrite getRewrite() throws CoreException {
    CompilationUnit astRoot= ASTResolving.findParentCompilationUnit(fNode);
    ASTNode typeDecl= astRoot.findDeclaringNode(fSenderBinding);
    ASTNode newTypeDecl= null;
    boolean isInDifferentCU;
    if (typeDecl != null) {
        isInDifferentCU= false;
        newTypeDecl= typeDecl;
    } else {
        isInDifferentCU= true;
        astRoot= ASTResolving.createQuickFixAST(getCompilationUnit(), null);
        newTypeDecl= astRoot.findDeclaringNode(fSenderBinding.getKey());
    }
    createImportRewrite(astRoot);

    if (newTypeDecl != null) {
        ASTRewrite rewrite= ASTRewrite.create(astRoot.getAST());

        MethodDeclaration newStub= getStub(rewrite, newTypeDecl);

        ChildListPropertyDescriptor property= ASTNodes.getBodyDeclarationsProperty(newTypeDecl);
        List<BodyDeclaration> members= ASTNodes.getBodyDeclarations(newTypeDecl);

        int insertIndex;
        if (isConstructor()) {
            insertIndex= findConstructorInsertIndex(members);
        } else if (!isInDifferentCU) {
            insertIndex= findMethodInsertIndex(members, fNode.getStartPosition());
        } else {
            insertIndex= members.size();
        }
        ListRewrite listRewriter= rewrite.getListRewrite(newTypeDecl, property);
        listRewriter.insertAt(newStub, insertIndex, null);

        return rewrite;
    }
    return null;
}

@Override
/**
 * Annotate local variables by visiting the enclosing statement.
 * 
 * Handles both VariableDeclarationStatement and VariableDeclarationExpression
 */
public boolean visit(VariableDeclarationFragment varDecl) {
    ASTNode parent = varDecl.getParent();
    Type declaredType = null;
    List parentMods = null;
    if(parent instanceof VariableDeclarationStatement ) {
        VariableDeclarationStatement varDeclStmt = (VariableDeclarationStatement)parent;
        parent = varDeclStmt;
        declaredType = varDeclStmt.getType();
        parentMods = varDeclStmt.modifiers();
    }
    else if (parent instanceof VariableDeclarationExpression ) {
        VariableDeclarationExpression varDeclExpr = (VariableDeclarationExpression)parent;
        parent = varDeclExpr;
        declaredType = varDeclExpr.getType();
        // Not allowed to call varExpr.modifiers();
        parentMods = null;
    }
    else {
        parent = null;
        // We handle FieldDeclaration elsewhere...
        return false;
    }

    ITypeBinding type = declaredType.resolveBinding();
    // XXX. Why would type be null here? Need to investigate.
    if (type != null && !type.isPrimitive()) {

        String annotation = "lent"; // XXX. Bad hard-coded default. What about <p>?
        if (HARD_CODE_STATICS && isStaticScope(parent)) {
            annotation = "shared<shared>";
        }
        else {
            annotation = strategy.getAnnotationForLocalVariable(varDecl);
        }

        ChildListPropertyDescriptor property = parent instanceof VariableDeclarationStatement ? 
                    VariableDeclarationStatement.MODIFIERS2_PROPERTY
                    : VariableDeclarationExpression.MODIFIERS2_PROPERTY;

        SingleMemberAnnotation currentAnnotation = getCurrentAnnotation(parentMods);
        if (currentAnnotation == null) {
            setVariableAnnotation2(parent, annotation, property);
        }
        else {
            updateVariableAnnotation2(parent, annotation, currentAnnotation, property);
        }       


        // XXX. Lookup enclosing type declaration from local variable
        String srcType = type.getQualifiedName();
        String dstType = Utils.getEnclosingTypeName(varDecl);
        // XXX. Come up with a better key
        trackChanges(varDecl.toString(), annotation, getValue(currentAnnotation), CSVConst.VARIABLE, srcType, dstType);

    }
    return super.visit(varDecl);
}

@Override
/**
 * Annotate local variables by visiting the enclosing statement.
 * 
 * Handles both VariableDeclarationStatement and VariableDeclarationExpression
 */
public boolean visit(VariableDeclarationFragment varDecl) {
    ASTNode parent = varDecl.getParent();
    Type declaredType = null;
    List parentMods = null;
    if(parent instanceof VariableDeclarationStatement ) {
        VariableDeclarationStatement varDeclStmt = (VariableDeclarationStatement)parent;
        parent = varDeclStmt;
        declaredType = varDeclStmt.getType();
        parentMods = varDeclStmt.modifiers();
    }
    else if (parent instanceof VariableDeclarationExpression ) {
        VariableDeclarationExpression varDeclExpr = (VariableDeclarationExpression)parent;
        parent = varDeclExpr;
        declaredType = varDeclExpr.getType();
        // Not allowed to call varExpr.modifiers();
        parentMods = null;
    }
    else {
        parent = null;
        // We handle FieldDeclaration elsewhere...
        return false;
    }

    ITypeBinding type = declaredType.resolveBinding();
    // XXX. Why would type be null here? Need to investigate.
    if (type != null && !type.isPrimitive()) {

        String annotation = "lent"; // XXX. Bad hard-coded default. What about <p>?
        if (HARD_CODE_STATICS && isStaticScope(parent)) {
            annotation = "shared<shared>";
        }
        else {
            annotation = strategy.getAnnotationForLocalVariable(varDecl);
        }

        ChildListPropertyDescriptor property = parent instanceof VariableDeclarationStatement ? 
                    VariableDeclarationStatement.MODIFIERS2_PROPERTY
                    : VariableDeclarationExpression.MODIFIERS2_PROPERTY;

        SingleMemberAnnotation currentAnnotation = getCurrentAnnotation(parentMods);
        if (currentAnnotation == null) {
            setVariableAnnotation2(parent, annotation, property);
        }
        else {
            updateVariableAnnotation2(parent, annotation, currentAnnotation, property);
        }       


        // XXX. Lookup enclosing type declaration from local variable
        String srcType = type.getQualifiedName();
        String dstType = Utils.getEnclosingTypeName(varDecl);
        // XXX. Come up with a better key
        trackChanges(varDecl.toString(), annotation, getValue(currentAnnotation), CSVConst.VARIABLE, srcType, dstType);

    }
    return super.visit(varDecl);
}

protected ReplaceRewrite(ASTRewrite rewrite, ASTNode[] nodes) {
  Assert.isNotNull(rewrite);
  Assert.isNotNull(nodes);
  Assert.isTrue(nodes.length > 0);
  fRewrite = rewrite;
  fToReplace = nodes;
  fDescriptor = fToReplace[0].getLocationInParent();
  if (nodes.length > 1) {
    Assert.isTrue(fDescriptor instanceof ChildListPropertyDescriptor);
  }
}

/**
 * Removes all children in <code>node</code>'s <code>childListProperty</code>.
 *
 * @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 removeAllChildren(
    ASTNode node,
    ChildListPropertyDescriptor childListProperty,
    ASTRewrite rewrite,
    TextEditGroup editGroup) {
  ListRewrite listRewrite = rewrite.getListRewrite(node, childListProperty);
  @SuppressWarnings("unchecked")
  List<? extends ASTNode> children =
      (List<? extends ASTNode>) node.getStructuralProperty(childListProperty);
  for (ASTNode child : children) {
    listRewrite.remove(child, editGroup);
  }
}

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

private ChildListPropertyDescriptor getTypeBodyDeclarationsProperty() {
  ASTNode parent = fDeclaration.getParent();

  if (parent instanceof AbstractTypeDeclaration)
    return ((AbstractTypeDeclaration) parent).getBodyDeclarationsProperty();
  else if (parent instanceof AnonymousClassDeclaration)
    return AnonymousClassDeclaration.BODY_DECLARATIONS_PROPERTY;

  Assert.isTrue(false);
  return null;
}