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

private void findUnnecessaryStore(ReturnStatement node) {
    Block block = TraversalUtil.findClosestAncestor(node, Block.class);
    @SuppressWarnings("unchecked")
    List<Statement> blockStatements = block.statements();
    for (int i = 1; i < blockStatements.size(); i++) {
        Statement statement = blockStatements.get(i);
        if (statement == this.originalReturn) {
            for (int j = i - 1; j >= 0; j--) {
                Statement storeStatement = blockStatements.get(j);
                if (storeStatement instanceof VariableDeclarationStatement) {
                    splitStatementAndInitializer((VariableDeclarationStatement) storeStatement);
                    return;
                } else if (storeStatement instanceof ExpressionStatement) {
                    if (splitStatementAndInitializer((ExpressionStatement) storeStatement)) {
                        // we found our extra storage statement
                        return;
                    }
                }
            }
        }
    }
}

/**
 * Method that check statement type.
 * @author Mariana Azevedo
 * @since 13/07/2014
 * @param itStatement
 */
private void getStatementType(Object itStatement) {
    if (itStatement instanceof CatchClause){
        this.visitor.visit((CatchClause)itStatement);
    }else if (itStatement instanceof ForStatement){
        this.visitor.visit((ForStatement)itStatement);
    }else if (itStatement instanceof IfStatement){
        this.visitor.visit((IfStatement)itStatement);
    }else if (itStatement instanceof WhileStatement){
        this.visitor.visit((WhileStatement)itStatement);
    }else if (itStatement instanceof TryStatement){
        this.visitor.visit((TryStatement)itStatement);
    }else if (itStatement instanceof ConditionalExpression){
        this.visitor.visit((ConditionalExpression)itStatement);
    }else if (itStatement instanceof SwitchCase){
        this.visitor.visit((SwitchCase)itStatement);
    }else if (itStatement instanceof DoStatement){
        this.visitor.visit((DoStatement)itStatement);
    }else if (itStatement instanceof ExpressionStatement){
        this.visitor.visit((ExpressionStatement)itStatement);
    }
}

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 void removeVariableWithInitializer(ASTRewrite rewrite, ASTNode initializerNode, ASTNode statementNode, TextEditGroup group) {
    boolean performRemove= fForceRemove;
    if (!performRemove) {
        ArrayList<Expression> sideEffectNodes= new ArrayList<>();
        initializerNode.accept(new SideEffectFinder(sideEffectNodes));
        performRemove= sideEffectNodes.isEmpty();
    }
    if (performRemove) {
        removeStatement(rewrite, statementNode, group);
        fRemovedAssignmentsCount++;
    } else {
        ASTNode initNode = rewrite.createMoveTarget(initializerNode);
        ExpressionStatement statement = rewrite.getAST().newExpressionStatement((Expression) initNode);
        rewrite.replace(statementNode, statement, null);
        fAlteredAssignmentsCount++;
    }
}

private void removeVariableWithInitializer(
    ASTRewrite rewrite, ASTNode initializerNode, ASTNode statementNode, TextEditGroup group) {
  boolean performRemove = fForceRemove;
  if (!performRemove) {
    ArrayList<Expression> sideEffectNodes = new ArrayList<Expression>();
    initializerNode.accept(new SideEffectFinder(sideEffectNodes));
    performRemove = sideEffectNodes.isEmpty();
  }
  if (performRemove) {
    removeStatement(rewrite, statementNode, group);
    fRemovedAssignmentsCount++;
  } else {
    ASTNode initNode = rewrite.createMoveTarget(initializerNode);
    ExpressionStatement statement =
        rewrite.getAST().newExpressionStatement((Expression) initNode);
    rewrite.replace(statementNode, statement, null);
    fAlteredAssignmentsCount++;
  }
}

private static ASTNode getInlineableMethodNode(ASTNode node, IJavaElement unit) {
  if (node == null) return null;
  switch (node.getNodeType()) {
    case ASTNode.SIMPLE_NAME:
      StructuralPropertyDescriptor locationInParent = node.getLocationInParent();
      if (locationInParent == MethodDeclaration.NAME_PROPERTY) {
        return node.getParent();
      } else if (locationInParent == MethodInvocation.NAME_PROPERTY
          || locationInParent == SuperMethodInvocation.NAME_PROPERTY) {
        return unit instanceof ICompilationUnit
            ? node.getParent()
            : null; // don't start on invocations in binary
      }
      return null;
    case ASTNode.EXPRESSION_STATEMENT:
      node = ((ExpressionStatement) node).getExpression();
  }
  switch (node.getNodeType()) {
    case ASTNode.METHOD_DECLARATION:
      return node;
    case ASTNode.METHOD_INVOCATION:
    case ASTNode.SUPER_METHOD_INVOCATION:
    case ASTNode.CONSTRUCTOR_INVOCATION:
      return unit instanceof ICompilationUnit
          ? node
          : null; // don't start on invocations in binary
  }
  return null;
}

private static boolean canReplace(IASTFragment fragment) {
  ASTNode node = fragment.getAssociatedNode();
  ASTNode parent = node.getParent();
  if (parent instanceof VariableDeclarationFragment) {
    VariableDeclarationFragment vdf = (VariableDeclarationFragment) parent;
    if (node.equals(vdf.getName())) return false;
  }
  if (isMethodParameter(node)) return false;
  if (isThrowableInCatchBlock(node)) return false;
  if (parent instanceof ExpressionStatement) return false;
  if (isLeftValue(node)) return false;
  if (isReferringToLocalVariableFromFor((Expression) node)) return false;
  if (isUsedInForInitializerOrUpdater((Expression) node)) return false;
  if (parent instanceof SwitchCase) return false;
  return true;
}

private void replaceSelectedExpressionWithTempDeclaration() throws CoreException {
  ASTRewrite rewrite = fCURewrite.getASTRewrite();
  Expression selectedExpression =
      getSelectedExpression().getAssociatedExpression(); // whole expression selected

  Expression initializer = (Expression) rewrite.createMoveTarget(selectedExpression);
  ASTNode replacement =
      createTempDeclaration(initializer); // creates a VariableDeclarationStatement

  ExpressionStatement parent = (ExpressionStatement) selectedExpression.getParent();
  if (ASTNodes.isControlStatementBody(parent.getLocationInParent())) {
    Block block = rewrite.getAST().newBlock();
    block.statements().add(replacement);
    replacement = block;
  }
  rewrite.replace(
      parent,
      replacement,
      fCURewrite.createGroupDescription(
          RefactoringCoreMessages.ExtractTempRefactoring_declare_local_variable));
}

private static ASTNode checkNode(ASTNode node) {
  if (node == null) return null;
  if (node.getNodeType() == ASTNode.SIMPLE_NAME) {
    node = node.getParent();
  } else if (node.getNodeType() == ASTNode.EXPRESSION_STATEMENT) {
    node = ((ExpressionStatement) node).getExpression();
  }
  switch (node.getNodeType()) {
    case ASTNode.METHOD_DECLARATION:
    case ASTNode.METHOD_INVOCATION:
      // not yet...
      //            case ASTNode.SUPER_METHOD_INVOCATION:
      //            case ASTNode.CONSTRUCTOR_INVOCATION:
      return node;
  }
  return null;
}

private static boolean canReplace(IASTFragment fragment) {
  ASTNode node = fragment.getAssociatedNode();
  ASTNode parent = node.getParent();
  if (parent instanceof VariableDeclarationFragment) {
    VariableDeclarationFragment vdf = (VariableDeclarationFragment) parent;
    if (node.equals(vdf.getName())) return false;
  }
  if (parent instanceof ExpressionStatement) return false;
  if (parent instanceof SwitchCase) {
    if (node instanceof Name) {
      Name name = (Name) node;
      ITypeBinding typeBinding = name.resolveTypeBinding();
      if (typeBinding != null) {
        return !typeBinding.isEnum();
      }
    }
  }
  return true;
}

@Override
public boolean visit(PostfixExpression node) {
  Expression operand = node.getOperand();
  if (!considerBinding(resolveBinding(operand), operand)) return true;

  ASTNode parent = node.getParent();
  if (!(parent instanceof ExpressionStatement)) {
    fStatus.addError(
        RefactoringCoreMessages
            .SelfEncapsulateField_AccessAnalyzer_cannot_convert_postfix_expression,
        JavaStatusContext.create(fCUnit, SourceRangeFactory.create(node)));
    return false;
  }
  fRewriter.replace(
      node,
      createInvocation(node.getAST(), node.getOperand(), node.getOperator().toString()),
      createGroupDescription(POSTFIX_ACCESS));
  return false;
}

public AssignToVariableAssistProposal(
    ICompilationUnit cu,
    int variableKind,
    ExpressionStatement node,
    ITypeBinding typeBinding,
    int relevance) {
  super("", cu, null, relevance, null); // $NON-NLS-1$

  fVariableKind = variableKind;
  fNodeToAssign = node;
  if (typeBinding.isWildcardType()) {
    typeBinding = ASTResolving.normalizeWildcardType(typeBinding, true, node.getAST());
  }

  fTypeBinding = typeBinding;
  if (variableKind == LOCAL) {
    setDisplayName(CorrectionMessages.AssignToVariableAssistProposal_assigntolocal_description);
    setImage(JavaPluginImages.get(JavaPluginImages.IMG_CORRECTION_LOCAL));
  } else {
    setDisplayName(CorrectionMessages.AssignToVariableAssistProposal_assigntofield_description);
    setImage(JavaPluginImages.get(JavaPluginImages.IMG_FIELD_PRIVATE));
  }
  createImportRewrite((CompilationUnit) node.getRoot());
}

private ASTRewrite doAddLocal() {
  Expression expression = ((ExpressionStatement) fNodeToAssign).getExpression();
  AST ast = fNodeToAssign.getAST();

  ASTRewrite rewrite = ASTRewrite.create(ast);

  createImportRewrite((CompilationUnit) fNodeToAssign.getRoot());

  String[] varNames = suggestLocalVariableNames(fTypeBinding, expression);
  for (int i = 0; i < varNames.length; i++) {
    addLinkedPositionProposal(KEY_NAME, varNames[i], null);
  }

  VariableDeclarationFragment newDeclFrag = ast.newVariableDeclarationFragment();
  newDeclFrag.setName(ast.newSimpleName(varNames[0]));
  newDeclFrag.setInitializer((Expression) rewrite.createCopyTarget(expression));

  Type type = evaluateType(ast);

  if (ASTNodes.isControlStatementBody(fNodeToAssign.getLocationInParent())) {
    Block block = ast.newBlock();
    block.statements().add(rewrite.createMoveTarget(fNodeToAssign));
    rewrite.replace(fNodeToAssign, block, null);
  }

  if (needsSemicolon(expression)) {
    VariableDeclarationStatement varStatement = ast.newVariableDeclarationStatement(newDeclFrag);
    varStatement.setType(type);
    rewrite.replace(expression, varStatement, null);
  } else {
    // trick for bug 43248: use an VariableDeclarationExpression and keep the ExpressionStatement
    VariableDeclarationExpression varExpression =
        ast.newVariableDeclarationExpression(newDeclFrag);
    varExpression.setType(type);
    rewrite.replace(expression, varExpression, null);
  }

  addLinkedPosition(rewrite.track(newDeclFrag.getName()), true, KEY_NAME);
  addLinkedPosition(rewrite.track(type), false, KEY_TYPE);
  setEndPosition(rewrite.track(fNodeToAssign)); // set cursor after expression statement

  return rewrite;
}

private VariableReference retrieveVariableReference(
        ClassInstanceCreation instanceCreation, Class<?> varType) {
    if ((instanceCreation.getParent() instanceof MethodInvocation)
            || (instanceCreation.getParent() instanceof ClassInstanceCreation)) {
        VariableReference result = new ValidVariableReference(
                testCase.getReference(),
                retrieveTypeClass(instanceCreation.getType()));
        nestedCallResults.push(result);
        return result;
    }
    if ((instanceCreation.getParent() instanceof ExpressionStatement)
            && (instanceCreation.getParent().getParent() instanceof Block)) {
        if (varType == null) {
            varType = retrieveTypeClass(instanceCreation);
        }
        VariableReference varRef = new ValidVariableReference(
                testCase.getReference(), varType);
        return varRef;
    }
    return retrieveVariableReference(instanceCreation.getParent(), varType);
}

private static ASTNode getInlineableMethodNode(ASTNode node, IJavaElement unit) {
    if (node == null)
        return null;
    switch (node.getNodeType()) {
        case ASTNode.SIMPLE_NAME:
            StructuralPropertyDescriptor locationInParent= node.getLocationInParent();
            if (locationInParent == MethodDeclaration.NAME_PROPERTY) {
                return node.getParent();
            } else if (locationInParent == MethodInvocation.NAME_PROPERTY
                    || locationInParent == SuperMethodInvocation.NAME_PROPERTY) {
                return unit instanceof ICompilationUnit ? node.getParent() : null; // don't start on invocations in binary
            }
            return null;
        case ASTNode.EXPRESSION_STATEMENT:
            node= ((ExpressionStatement)node).getExpression();
    }
    switch (node.getNodeType()) {
        case ASTNode.METHOD_DECLARATION:
            return node;
        case ASTNode.METHOD_INVOCATION:
        case ASTNode.SUPER_METHOD_INVOCATION:
        case ASTNode.CONSTRUCTOR_INVOCATION:
            return unit instanceof ICompilationUnit ? node : null; // don't start on invocations in binary
    }
    return null;
}

private static boolean canReplace(IASTFragment fragment) {
    ASTNode node= fragment.getAssociatedNode();
    ASTNode parent= node.getParent();
    if (parent instanceof VariableDeclarationFragment) {
        VariableDeclarationFragment vdf= (VariableDeclarationFragment) parent;
        if (node.equals(vdf.getName()))
            return false;
    }
    if (isMethodParameter(node))
        return false;
    if (isThrowableInCatchBlock(node))
        return false;
    if (parent instanceof ExpressionStatement)
        return false;
    if (isLeftValue(node))
        return false;
    if (isReferringToLocalVariableFromFor((Expression) node))
        return false;
    if (isUsedInForInitializerOrUpdater((Expression) node))
        return false;
    if (parent instanceof SwitchCase)
        return false;
    return true;
}

private void replaceSelectedExpressionWithTempDeclaration() throws CoreException {
    ASTRewrite rewrite= fCURewrite.getASTRewrite();
    Expression selectedExpression= getSelectedExpression().getAssociatedExpression(); // whole expression selected

    Expression initializer= (Expression) rewrite.createMoveTarget(selectedExpression);
    ASTNode replacement= createTempDeclaration(initializer); // creates a VariableDeclarationStatement

    ExpressionStatement parent= (ExpressionStatement) selectedExpression.getParent();
    if (ASTNodes.isControlStatementBody(parent.getLocationInParent())) {
        Block block= rewrite.getAST().newBlock();
        block.statements().add(replacement);
        replacement= block;

    }
    rewrite.replace(parent, replacement, fCURewrite.createGroupDescription(RefactoringCoreMessages.ExtractTempRefactoring_declare_local_variable));
}

private static ASTNode checkNode(ASTNode node) {
        if (node == null)
            return null;
        if (node.getNodeType() == ASTNode.SIMPLE_NAME) {
            node= node.getParent();
        } else if (node.getNodeType() == ASTNode.EXPRESSION_STATEMENT) {
            node= ((ExpressionStatement)node).getExpression();
        }
        switch(node.getNodeType()) {
            case ASTNode.METHOD_DECLARATION:
            case ASTNode.METHOD_INVOCATION:
// not yet...
//          case ASTNode.SUPER_METHOD_INVOCATION:
//          case ASTNode.CONSTRUCTOR_INVOCATION:
                return node;
        }
        return null;
    }

private static ASTNode checkNode(ASTNode node) {
    if (node == null)
        return null;
    if (node.getNodeType() == ASTNode.SIMPLE_NAME) {
        node= node.getParent();
    } else if (node.getNodeType() == ASTNode.EXPRESSION_STATEMENT) {
        node= ((ExpressionStatement) node).getExpression();
    }
    switch (node.getNodeType()) {
        case ASTNode.METHOD_INVOCATION:
        case ASTNode.METHOD_DECLARATION:
        case ASTNode.SUPER_METHOD_INVOCATION:
            return node;
    }
    return null;
}

private static boolean canReplace(IASTFragment fragment) {
    ASTNode node= fragment.getAssociatedNode();
    ASTNode parent= node.getParent();
    if (parent instanceof VariableDeclarationFragment) {
        VariableDeclarationFragment vdf= (VariableDeclarationFragment) parent;
        if (node.equals(vdf.getName()))
            return false;
    }
    if (parent instanceof ExpressionStatement)
        return false;
    if (parent instanceof SwitchCase) {
        if (node instanceof Name) {
            Name name= (Name) node;
            ITypeBinding typeBinding= name.resolveTypeBinding();
            if (typeBinding != null) {
                return !typeBinding.isEnum();
            }
        }
    }
    return true;
}

@Override
public boolean visit(PostfixExpression node) {
    Expression operand= node.getOperand();
    if (!considerBinding(resolveBinding(operand), operand))
        return true;

    ASTNode parent= node.getParent();
    if (!(parent instanceof ExpressionStatement)) {
        fStatus.addError(RefactoringCoreMessages.SelfEncapsulateField_AccessAnalyzer_cannot_convert_postfix_expression,
            JavaStatusContext.create(fCUnit, SourceRangeFactory.create(node)));
        return false;
    }
    fRewriter.replace(node,
        createInvocation(node.getAST(), node.getOperand(), node.getOperator().toString()),
        createGroupDescription(POSTFIX_ACCESS));
    return false;
}

private MethodDeclaration getWritingConstructor(SimpleName name) {
Assignment assignement= (Assignment)ASTNodes.getParent(name, Assignment.class);
if (assignement == null)
    return null;

ASTNode expression= assignement.getParent();
if (!(expression instanceof ExpressionStatement))
    return null;

ASTNode block= expression.getParent();
if (!(block instanceof Block))
    return null;

ASTNode methodDeclaration= block.getParent();
if (!(methodDeclaration instanceof MethodDeclaration))
    return null;

      return (MethodDeclaration)methodDeclaration;
     }

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 void removeVariableWithInitializer(ASTRewrite rewrite, ASTNode initializerNode, ASTNode statementNode, TextEditGroup group) {
    boolean performRemove= fForceRemove;
    if (!performRemove) {
        ArrayList<Expression> sideEffectNodes= new ArrayList<Expression>();
        initializerNode.accept(new SideEffectFinder(sideEffectNodes));
        performRemove= sideEffectNodes.isEmpty();
    }
    if (performRemove) {
        removeStatement(rewrite, statementNode, group);
        fRemovedAssignmentsCount++;
    } else {
        ASTNode initNode = rewrite.createMoveTarget(initializerNode);
        ExpressionStatement statement = rewrite.getAST().newExpressionStatement((Expression) initNode);
        rewrite.replace(statementNode, statement, null);
        fAlteredAssignmentsCount++;
    }
}

public AssignToVariableAssistProposal(ICompilationUnit cu, int variableKind, ExpressionStatement node, ITypeBinding typeBinding, int relevance) {
    super("", cu, null, relevance, null); //$NON-NLS-1$

    fVariableKind= variableKind;
    fNodeToAssign= node;
    if (typeBinding.isWildcardType()) {
        typeBinding= ASTResolving.normalizeWildcardType(typeBinding, true, node.getAST());
    }

    fTypeBinding= typeBinding;
    if (variableKind == LOCAL) {
        setDisplayName(CorrectionMessages.AssignToVariableAssistProposal_assigntolocal_description);
        setImage(JavaPluginImages.get(JavaPluginImages.IMG_CORRECTION_LOCAL));
    } else {
        setDisplayName(CorrectionMessages.AssignToVariableAssistProposal_assigntofield_description);
        setImage(JavaPluginImages.get(JavaPluginImages.IMG_FIELD_PRIVATE));
    }
    createImportRewrite((CompilationUnit) node.getRoot());
}

private ASTNode prepareLambdaBody(Block body, List<Statement> statements) {
    ASTNode lambdaBody = body;
    if (statements.size() == 1) {
        // use short form with just an expression body if possible
        Statement statement = statements.get(0);
        if (statement instanceof ExpressionStatement) {
            lambdaBody = ((ExpressionStatement) statement).getExpression();
        } else if (statement instanceof ReturnStatement) {
            Expression returnExpression = ((ReturnStatement) statement).getExpression();
            if (returnExpression != null) {
                lambdaBody = returnExpression;
            }
        }
    }
    return lambdaBody;
}

/**
 * Returns all statements within a method.
 * 
 * @return Set of all statements
 */
private ArraySet<AbstractJavaStatement> statements() {
    final List<AbstractJavaStatement> list = new ArrayList<AbstractJavaStatement>();
    methodDeclaration.accept(new ASTVisitor() {
        @Override
        public boolean visit(ExpressionStatement node) {
            if (node.getExpression() instanceof MethodInvocation) {
                MethodInvocation methodInvocation = (MethodInvocation) node.getExpression();
                String methodName = methodInvocation.getName().toString();
                if (null != methodInvocation.getExpression()) {
                    ITypeBinding typeBinding = methodInvocation.getExpression().resolveTypeBinding();
                    if (null != typeBinding) {
                        JavaCall javaCall = new JavaCall(node, methodName, typeBinding, JavaMethod.this);
                        list.add(javaCall);
                    }
                }
            }
            return false;
        }
    });
    return new ArraySet<AbstractJavaStatement>(list.toArray(new JavaCall[list.size()]), JavaCall.class);
}

/**
 * Returns all statements within a method.
 * 
 * @return Set of all statements
 */
private ArraySet<AbstractJavaStatement> assignments() {
    final List<AbstractJavaStatement> list = new ArrayList<AbstractJavaStatement>();
    methodDeclaration.accept(new ASTVisitor() {
        @Override
        public boolean visit(Assignment node) {
            Expression lhs = node.getLeftHandSide();
            ITypeBinding typeBinding = lhs.resolveTypeBinding();
            Expression rhs = node.getRightHandSide();
            if (rhs instanceof ClassInstanceCreation && node.getParent() instanceof ExpressionStatement) {
                ExpressionStatement parent = (ExpressionStatement) node.getParent();
                JavaAssignment assignment = new JavaAssignment(JavaMethod.this, parent, lhs.toString(), typeBinding,
                        (ClassInstanceCreation) rhs);
                list.add(assignment);
            }
            // TODO SE: (Static) method invocations, e.g. call of another
            // factory are not supported.

            return false;
        }
    });
    return new ArraySet<AbstractJavaStatement>(list.toArray(new JavaAssignment[list.size()]), JavaAssignment.class);
}

public boolean visit(final ExpressionStatement node) {
    if (node.getExpression() instanceof MethodInvocation) {
        final MethodInvocation method = (MethodInvocation)node.getExpression();
        Expression expression;
        for (expression = method.getExpression(); expression instanceof MethodInvocation; expression = ((MethodInvocation)expression).getExpression()) {}
        final IVariableBinding field = this.getLocalField(expression);
        if (field != null) {
            MethodAnalyzer.this.setFields.add(field);
        }
        int index = this.getVariableIndex(method.getExpression());
        if (index != -1) {
            MethodAnalyzer.this.variables.get(index).setModified(true);
        } else {
            index = this.getParameterIndex(method.getExpression());
            if (index != -1) {
                MethodAnalyzer.this.parameters.get(index).setModified(true);
            }
        }
        if (this.isLocalMethod(method)) {
            MethodAnalyzer.this.invokedLocalMethods.add(method.resolveMethodBinding());
        }
    }
    return super.visit(node);
}

private static ASTNode getInlineableMethodNode(ASTNode node, IJavaElement unit) {
    if (node == null)
        return null;
    switch (node.getNodeType()) {
        case ASTNode.SIMPLE_NAME:
            StructuralPropertyDescriptor locationInParent= node.getLocationInParent();
            if (locationInParent == MethodDeclaration.NAME_PROPERTY) {
                return node.getParent();
            } else if (locationInParent == MethodInvocation.NAME_PROPERTY
                    || locationInParent == SuperMethodInvocation.NAME_PROPERTY) {
                return unit instanceof ICompilationUnit ? node.getParent() : null; // don't start on invocations in binary
            }
            return null;
        case ASTNode.EXPRESSION_STATEMENT:
            node= ((ExpressionStatement)node).getExpression();
    }
    switch (node.getNodeType()) {
        case ASTNode.METHOD_DECLARATION:
            return node;
        case ASTNode.METHOD_INVOCATION:
        case ASTNode.SUPER_METHOD_INVOCATION:
        case ASTNode.CONSTRUCTOR_INVOCATION:
            return unit instanceof ICompilationUnit ? node : null; // don't start on invocations in binary
    }
    return null;
}

private static boolean canReplace(IASTFragment fragment) {
    ASTNode node= fragment.getAssociatedNode();
    ASTNode parent= node.getParent();
    if (parent instanceof VariableDeclarationFragment) {
        VariableDeclarationFragment vdf= (VariableDeclarationFragment) parent;
        if (node.equals(vdf.getName()))
            return false;
    }
    if (isMethodParameter(node))
        return false;
    if (isThrowableInCatchBlock(node))
        return false;
    if (parent instanceof ExpressionStatement)
        return false;
    if (isLeftValue(node))
        return false;
    if (isReferringToLocalVariableFromFor((Expression) node))
        return false;
    if (isUsedInForInitializerOrUpdater((Expression) node))
        return false;
    if (parent instanceof SwitchCase)
        return false;
    return true;
}

private void replaceSelectedExpressionWithTempDeclaration() throws CoreException {
    ASTRewrite rewrite= fCURewrite.getASTRewrite();
    Expression selectedExpression= getSelectedExpression().getAssociatedExpression(); // whole expression selected

    Expression initializer= (Expression) rewrite.createMoveTarget(selectedExpression);
    ASTNode replacement= createTempDeclaration(initializer); // creates a VariableDeclarationStatement

    ExpressionStatement parent= (ExpressionStatement) selectedExpression.getParent();
    if (ASTNodes.isControlStatementBody(parent.getLocationInParent())) {
        Block block= rewrite.getAST().newBlock();
        block.statements().add(replacement);
        replacement= block;

    }
    rewrite.replace(parent, replacement, fCURewrite.createGroupDescription(RefactoringCoreMessages.ExtractTempRefactoring_declare_local_variable));
}

private static ASTNode checkNode(ASTNode node) {
        if (node == null)
            return null;
        if (node.getNodeType() == ASTNode.SIMPLE_NAME) {
            node= node.getParent();
        } else if (node.getNodeType() == ASTNode.EXPRESSION_STATEMENT) {
            node= ((ExpressionStatement)node).getExpression();
        }
        switch(node.getNodeType()) {
            case ASTNode.METHOD_DECLARATION:
            case ASTNode.METHOD_INVOCATION:
// not yet...
//          case ASTNode.SUPER_METHOD_INVOCATION:
//          case ASTNode.CONSTRUCTOR_INVOCATION:
                return node;
        }
        return null;
    }

private static ASTNode checkNode(ASTNode node) {
    if (node == null)
        return null;
    if (node.getNodeType() == ASTNode.SIMPLE_NAME) {
        node= node.getParent();
    } else if (node.getNodeType() == ASTNode.EXPRESSION_STATEMENT) {
        node= ((ExpressionStatement) node).getExpression();
    }
    switch (node.getNodeType()) {
        case ASTNode.METHOD_INVOCATION:
        case ASTNode.METHOD_DECLARATION:
        case ASTNode.SUPER_METHOD_INVOCATION:
            return node;
    }
    return null;
}

private static boolean canReplace(IASTFragment fragment) {
    ASTNode node= fragment.getAssociatedNode();
    ASTNode parent= node.getParent();
    if (parent instanceof VariableDeclarationFragment) {
        VariableDeclarationFragment vdf= (VariableDeclarationFragment) parent;
        if (node.equals(vdf.getName()))
            return false;
    }
    if (parent instanceof ExpressionStatement)
        return false;
    if (parent instanceof SwitchCase) {
        if (node instanceof Name) {
            Name name= (Name) node;
            ITypeBinding typeBinding= name.resolveTypeBinding();
            if (typeBinding != null) {
                return !typeBinding.isEnum();
            }
        }
    }
    return true;
}

@Override
public boolean visit(PostfixExpression node) {
    Expression operand= node.getOperand();
    if (!considerBinding(resolveBinding(operand), operand))
        return true;

    ASTNode parent= node.getParent();
    if (!(parent instanceof ExpressionStatement)) {
        fStatus.addError(RefactoringCoreMessages.SelfEncapsulateField_AccessAnalyzer_cannot_convert_postfix_expression,
            JavaStatusContext.create(fCUnit, SourceRangeFactory.create(node)));
        return false;
    }
    fRewriter.replace(node,
        createInvocation(node.getAST(), node.getOperand(), node.getOperator().toString()),
        createGroupDescription(POSTFIX_ACCESS));
    return false;
}

private MethodDeclaration getWritingConstructor(SimpleName name) {
Assignment assignement= (Assignment)ASTNodes.getParent(name, Assignment.class);
if (assignement == null)
    return null;

ASTNode expression= assignement.getParent();
if (!(expression instanceof ExpressionStatement))
    return null;

ASTNode block= expression.getParent();
if (!(block instanceof Block))
    return null;

ASTNode methodDeclaration= block.getParent();
if (!(methodDeclaration instanceof MethodDeclaration))
    return null;

      return (MethodDeclaration)methodDeclaration;
     }

private void splitUpDeclarations(ASTRewrite rewrite, TextEditGroup group, VariableDeclarationFragment frag, ListRewrite statementRewrite, VariableDeclarationStatement originalStatement) {
    Expression initializer = frag.getInitializer();
    //keep constructors and method invocations
    if (initializer instanceof MethodInvocation || initializer instanceof ClassInstanceCreation){
        Expression movedInitializer= (Expression) rewrite.createMoveTarget(initializer);

        ExpressionStatement newInitializer= rewrite.getAST().newExpressionStatement( movedInitializer);
        statementRewrite.insertAfter(newInitializer, originalStatement, group);

        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, newInitializer, group);
        }
        if (originalStatement.fragments().size() == newDeclaration.fragments().size() + 1){
            rewrite.remove(originalStatement, group);
        }
    }
}

private void removeVariableWithInitializer(ASTRewrite rewrite, ASTNode initializerNode, ASTNode statementNode, TextEditGroup group) {
    boolean performRemove= fForceRemove;
    if (!performRemove) {
        ArrayList<Expression> sideEffectNodes= new ArrayList<Expression>();
        initializerNode.accept(new SideEffectFinder(sideEffectNodes));
        performRemove= sideEffectNodes.isEmpty();
    }
    if (performRemove) {
        removeStatement(rewrite, statementNode, group);
        fRemovedAssignmentsCount++;
    } else {
        ASTNode initNode = rewrite.createMoveTarget(initializerNode);
        ExpressionStatement statement = rewrite.getAST().newExpressionStatement((Expression) initNode);
        rewrite.replace(statementNode, statement, null);
        fAlteredAssignmentsCount++;
    }
}

public AssignToVariableAssistProposal(ICompilationUnit cu, int variableKind, ExpressionStatement node, ITypeBinding typeBinding, int relevance) {
    super("", cu, null, relevance, null); //$NON-NLS-1$

    fVariableKind= variableKind;
    fNodeToAssign= node;
    if (typeBinding.isWildcardType()) {
        typeBinding= ASTResolving.normalizeWildcardType(typeBinding, true, node.getAST());
    }

    fTypeBinding= typeBinding;
    if (variableKind == LOCAL) {
        setDisplayName(CorrectionMessages.AssignToVariableAssistProposal_assigntolocal_description);
        setImage(JavaPluginImages.get(JavaPluginImages.IMG_CORRECTION_LOCAL));
    } else {
        setDisplayName(CorrectionMessages.AssignToVariableAssistProposal_assigntofield_description);
        setImage(JavaPluginImages.get(JavaPluginImages.IMG_FIELD_PRIVATE));
    }
    createImportRewrite((CompilationUnit) node.getRoot());
}