| /******************************************************************************* |
| * Copyright (c) 2000, 2011 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| * Benjamin Muskalla <bmuskalla@eclipsesource.com> - [extract method] Extract method and continue https://bugs.eclipse.org/bugs/show_bug.cgi?id=48056 |
| * Benjamin Muskalla <bmuskalla@eclipsesource.com> - [extract method] Name ambiguous return value in error message - https://bugs.eclipse.org/bugs/show_bug.cgi?id=50607 |
| *******************************************************************************/ |
| package org.eclipse.jdt.internal.corext.refactoring.code; |
| |
| import java.util.ArrayList; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Set; |
| |
| import com.ibm.icu.text.MessageFormat; |
| |
| import org.eclipse.core.runtime.CoreException; |
| |
| import org.eclipse.jface.text.IRegion; |
| |
| import org.eclipse.ltk.core.refactoring.RefactoringStatus; |
| |
| import org.eclipse.jdt.core.ICompilationUnit; |
| import org.eclipse.jdt.core.compiler.ITerminalSymbols; |
| import org.eclipse.jdt.core.dom.AST; |
| import org.eclipse.jdt.core.dom.ASTNode; |
| import org.eclipse.jdt.core.dom.ASTVisitor; |
| import org.eclipse.jdt.core.dom.Annotation; |
| import org.eclipse.jdt.core.dom.AnonymousClassDeclaration; |
| import org.eclipse.jdt.core.dom.Assignment; |
| import org.eclipse.jdt.core.dom.Block; |
| import org.eclipse.jdt.core.dom.BodyDeclaration; |
| import org.eclipse.jdt.core.dom.BreakStatement; |
| import org.eclipse.jdt.core.dom.ClassInstanceCreation; |
| import org.eclipse.jdt.core.dom.CompilationUnit; |
| import org.eclipse.jdt.core.dom.ConstructorInvocation; |
| import org.eclipse.jdt.core.dom.ContinueStatement; |
| import org.eclipse.jdt.core.dom.DoStatement; |
| import org.eclipse.jdt.core.dom.EnhancedForStatement; |
| import org.eclipse.jdt.core.dom.Expression; |
| import org.eclipse.jdt.core.dom.FieldAccess; |
| import org.eclipse.jdt.core.dom.ForStatement; |
| import org.eclipse.jdt.core.dom.IMethodBinding; |
| import org.eclipse.jdt.core.dom.ITypeBinding; |
| import org.eclipse.jdt.core.dom.IVariableBinding; |
| import org.eclipse.jdt.core.dom.Initializer; |
| import org.eclipse.jdt.core.dom.LabeledStatement; |
| import org.eclipse.jdt.core.dom.Message; |
| import org.eclipse.jdt.core.dom.MethodDeclaration; |
| import org.eclipse.jdt.core.dom.Name; |
| import org.eclipse.jdt.core.dom.PrimitiveType; |
| import org.eclipse.jdt.core.dom.QualifiedName; |
| import org.eclipse.jdt.core.dom.SimpleName; |
| import org.eclipse.jdt.core.dom.Statement; |
| import org.eclipse.jdt.core.dom.StructuralPropertyDescriptor; |
| import org.eclipse.jdt.core.dom.SuperConstructorInvocation; |
| import org.eclipse.jdt.core.dom.SwitchCase; |
| import org.eclipse.jdt.core.dom.ThisExpression; |
| import org.eclipse.jdt.core.dom.TryStatement; |
| import org.eclipse.jdt.core.dom.Type; |
| import org.eclipse.jdt.core.dom.VariableDeclaration; |
| import org.eclipse.jdt.core.dom.VariableDeclarationExpression; |
| import org.eclipse.jdt.core.dom.VariableDeclarationFragment; |
| import org.eclipse.jdt.core.dom.VariableDeclarationStatement; |
| import org.eclipse.jdt.core.dom.WhileStatement; |
| import org.eclipse.jdt.core.dom.rewrite.ImportRewrite; |
| import org.eclipse.jdt.core.dom.rewrite.ImportRewrite.ImportRewriteContext; |
| |
| import org.eclipse.jdt.internal.corext.codemanipulation.ContextSensitiveImportRewriteContext; |
| import org.eclipse.jdt.internal.corext.dom.ASTNodeFactory; |
| import org.eclipse.jdt.internal.corext.dom.ASTNodes; |
| import org.eclipse.jdt.internal.corext.dom.Bindings; |
| import org.eclipse.jdt.internal.corext.dom.LocalVariableIndex; |
| import org.eclipse.jdt.internal.corext.dom.Selection; |
| import org.eclipse.jdt.internal.corext.refactoring.Checks; |
| import org.eclipse.jdt.internal.corext.refactoring.RefactoringCoreMessages; |
| import org.eclipse.jdt.internal.corext.refactoring.base.JavaStatusContext; |
| import org.eclipse.jdt.internal.corext.refactoring.code.flow.FlowContext; |
| import org.eclipse.jdt.internal.corext.refactoring.code.flow.FlowInfo; |
| import org.eclipse.jdt.internal.corext.refactoring.code.flow.InOutFlowAnalyzer; |
| import org.eclipse.jdt.internal.corext.refactoring.code.flow.InputFlowAnalyzer; |
| import org.eclipse.jdt.internal.corext.refactoring.util.CodeAnalyzer; |
| import org.eclipse.jdt.internal.corext.util.Messages; |
| |
| import org.eclipse.jdt.ui.JavaElementLabels; |
| |
| import org.eclipse.jdt.internal.ui.viewsupport.BasicElementLabels; |
| import org.eclipse.jdt.internal.ui.viewsupport.BindingLabelProvider; |
| |
| /* package */ class ExtractMethodAnalyzer extends CodeAnalyzer { |
| |
| public static final int ERROR= -2; |
| public static final int UNDEFINED= -1; |
| public static final int NO= 0; |
| public static final int EXPRESSION= 1; |
| public static final int ACCESS_TO_LOCAL= 2; |
| public static final int RETURN_STATEMENT_VOID= 3; |
| public static final int RETURN_STATEMENT_VALUE= 4; |
| public static final int MULTIPLE= 5; |
| |
| /** This is either a method declaration or an initializer */ |
| private BodyDeclaration fEnclosingBodyDeclaration; |
| private IMethodBinding fEnclosingMethodBinding; |
| private int fMaxVariableId; |
| |
| private int fReturnKind; |
| private Type fReturnType; |
| private ITypeBinding fReturnTypeBinding; |
| |
| private FlowInfo fInputFlowInfo; |
| private FlowContext fInputFlowContext; |
| |
| private IVariableBinding[] fArguments; |
| private IVariableBinding[] fMethodLocals; |
| private ITypeBinding[] fTypeVariables; |
| |
| private IVariableBinding fReturnValue; |
| private IVariableBinding[] fCallerLocals; |
| private IVariableBinding fReturnLocal; |
| |
| private ITypeBinding[] fAllExceptions; |
| private ITypeBinding fExpressionBinding; |
| |
| private boolean fForceStatic; |
| private boolean fIsLastStatementSelected; |
| private SimpleName fEnclosingLoopLabel; |
| |
| public ExtractMethodAnalyzer(ICompilationUnit unit, Selection selection) throws CoreException { |
| super(unit, selection, false); |
| } |
| |
| public BodyDeclaration getEnclosingBodyDeclaration() { |
| return fEnclosingBodyDeclaration; |
| } |
| |
| public int getReturnKind() { |
| return fReturnKind; |
| } |
| |
| public boolean extractsExpression() { |
| return fReturnKind == EXPRESSION; |
| } |
| |
| public Type getReturnType() { |
| return fReturnType; |
| } |
| |
| public ITypeBinding getReturnTypeBinding() { |
| return fReturnTypeBinding; |
| } |
| |
| public boolean generateImport() { |
| switch (fReturnKind) { |
| case EXPRESSION: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| public IVariableBinding[] getArguments() { |
| return fArguments; |
| } |
| |
| public IVariableBinding[] getMethodLocals() { |
| return fMethodLocals; |
| } |
| |
| public IVariableBinding getReturnValue() { |
| return fReturnValue; |
| } |
| |
| public IVariableBinding[] getCallerLocals() { |
| return fCallerLocals; |
| } |
| |
| public IVariableBinding getReturnLocal() { |
| return fReturnLocal; |
| } |
| |
| public ITypeBinding getExpressionBinding() { |
| return fExpressionBinding; |
| } |
| |
| public boolean getForceStatic() { |
| return fForceStatic; |
| } |
| |
| public ITypeBinding[] getTypeVariables() { |
| return fTypeVariables; |
| } |
| |
| //---- Activation checking --------------------------------------------------------------------------- |
| |
| public RefactoringStatus checkInitialConditions(ImportRewrite rewriter) { |
| RefactoringStatus result= getStatus(); |
| checkExpression(result); |
| if (result.hasFatalError()) |
| return result; |
| |
| fReturnKind= UNDEFINED; |
| fMaxVariableId= LocalVariableIndex.perform(fEnclosingBodyDeclaration); |
| if (analyzeSelection(result).hasFatalError()) |
| return result; |
| |
| int returns= fReturnKind == NO ? 0 : 1; |
| if (fReturnValue != null) { |
| fReturnKind= ACCESS_TO_LOCAL; |
| returns++; |
| } |
| if (isExpressionSelected()) { |
| fReturnKind= EXPRESSION; |
| returns++; |
| } |
| |
| if (returns > 1) { |
| result.addFatalError(RefactoringCoreMessages.ExtractMethodAnalyzer_ambiguous_return_value, JavaStatusContext.create(fCUnit, getSelection())); |
| fReturnKind= MULTIPLE; |
| return result; |
| } |
| initReturnType(rewriter); |
| return result; |
| } |
| |
| private void checkExpression(RefactoringStatus status) { |
| ASTNode[] nodes= getSelectedNodes(); |
| if (nodes != null && nodes.length == 1) { |
| ASTNode node= nodes[0]; |
| if (node instanceof Type) { |
| status.addFatalError(RefactoringCoreMessages.ExtractMethodAnalyzer_cannot_extract_type_reference, JavaStatusContext.create(fCUnit, node)); |
| } else if (node.getLocationInParent() == SwitchCase.EXPRESSION_PROPERTY) { |
| status.addFatalError(RefactoringCoreMessages.ExtractMethodAnalyzer_cannot_extract_switch_case, JavaStatusContext.create(fCUnit, node)); |
| } else if (node instanceof Annotation || ASTNodes.getParent(node, Annotation.class) != null) { |
| status.addFatalError(RefactoringCoreMessages.ExtractMethodAnalyzer_cannot_extract_from_annotation, JavaStatusContext.create(fCUnit, node)); |
| } |
| } |
| } |
| |
| private void initReturnType(ImportRewrite rewriter) { |
| AST ast= fEnclosingBodyDeclaration.getAST(); |
| fReturnType= null; |
| fReturnTypeBinding= null; |
| switch (fReturnKind) { |
| case ACCESS_TO_LOCAL: |
| VariableDeclaration declaration= ASTNodes.findVariableDeclaration(fReturnValue, fEnclosingBodyDeclaration); |
| fReturnType= ASTNodeFactory.newType(ast, declaration, rewriter, new ContextSensitiveImportRewriteContext(declaration, rewriter)); |
| if (declaration.resolveBinding() != null) { |
| fReturnTypeBinding= declaration.resolveBinding().getType(); |
| } |
| break; |
| case EXPRESSION: |
| Expression expression= (Expression)getFirstSelectedNode(); |
| if (expression.getNodeType() == ASTNode.CLASS_INSTANCE_CREATION) { |
| fExpressionBinding= ((ClassInstanceCreation)expression).getType().resolveBinding(); |
| } else { |
| fExpressionBinding= expression.resolveTypeBinding(); |
| } |
| if (fExpressionBinding != null) { |
| if (fExpressionBinding.isNullType()) { |
| getStatus().addFatalError(RefactoringCoreMessages.ExtractMethodAnalyzer_cannot_extract_null_type, JavaStatusContext.create(fCUnit, expression)); |
| } else { |
| ITypeBinding normalizedBinding= Bindings.normalizeForDeclarationUse(fExpressionBinding, ast); |
| if (normalizedBinding != null) { |
| ImportRewriteContext context= new ContextSensitiveImportRewriteContext(fEnclosingBodyDeclaration, rewriter); |
| fReturnType= rewriter.addImport(normalizedBinding, ast, context); |
| fReturnTypeBinding= normalizedBinding; |
| } |
| } |
| } else { |
| fReturnType= ast.newPrimitiveType(PrimitiveType.VOID); |
| fReturnTypeBinding= ast.resolveWellKnownType("void"); //$NON-NLS-1$ |
| getStatus().addError(RefactoringCoreMessages.ExtractMethodAnalyzer_cannot_determine_return_type, JavaStatusContext.create(fCUnit, expression)); |
| } |
| break; |
| case RETURN_STATEMENT_VALUE: |
| if (fEnclosingBodyDeclaration.getNodeType() == ASTNode.METHOD_DECLARATION) { |
| fReturnType= ((MethodDeclaration) fEnclosingBodyDeclaration).getReturnType2(); |
| fReturnTypeBinding= fReturnType != null ? fReturnType.resolveBinding() : null; |
| } |
| break; |
| default: |
| fReturnType= ast.newPrimitiveType(PrimitiveType.VOID); |
| fReturnTypeBinding= ast.resolveWellKnownType("void"); //$NON-NLS-1$ |
| } |
| if (fReturnType == null) |
| fReturnType= ast.newPrimitiveType(PrimitiveType.VOID); |
| fReturnTypeBinding= ast.resolveWellKnownType("void"); //$NON-NLS-1$ |
| } |
| |
| // !!! -- +/- same as in ExtractTempRefactoring |
| public boolean isLiteralNodeSelected() { |
| ASTNode[] nodes= getSelectedNodes(); |
| if (nodes.length != 1) |
| return false; |
| ASTNode node= nodes[0]; |
| switch (node.getNodeType()) { |
| case ASTNode.BOOLEAN_LITERAL : |
| case ASTNode.CHARACTER_LITERAL : |
| case ASTNode.NULL_LITERAL : |
| case ASTNode.NUMBER_LITERAL : |
| return true; |
| |
| default : |
| return false; |
| } |
| } |
| |
| //---- Input checking ----------------------------------------------------------------------------------- |
| |
| public void checkInput(RefactoringStatus status, String methodName, ASTNode destination) { |
| ITypeBinding[] arguments= getArgumentTypes(); |
| ITypeBinding type= ASTNodes.getEnclosingType(destination); |
| status.merge(Checks.checkMethodInType(type, methodName, arguments)); |
| status.merge(Checks.checkMethodInHierarchy(type.getSuperclass(), methodName, null, arguments)); |
| } |
| |
| private ITypeBinding[] getArgumentTypes() { |
| ITypeBinding[] result= new ITypeBinding[fArguments.length]; |
| for (int i= 0; i < fArguments.length; i++) { |
| result[i]= fArguments[i].getType(); |
| } |
| return result; |
| } |
| |
| private RefactoringStatus analyzeSelection(RefactoringStatus status) { |
| fInputFlowContext= new FlowContext(0, fMaxVariableId + 1); |
| fInputFlowContext.setConsiderAccessMode(true); |
| fInputFlowContext.setComputeMode(FlowContext.ARGUMENTS); |
| |
| InOutFlowAnalyzer flowAnalyzer= new InOutFlowAnalyzer(fInputFlowContext); |
| fInputFlowInfo= flowAnalyzer.perform(getSelectedNodes()); |
| |
| if (fInputFlowInfo.branches()) { |
| String canHandleBranchesProblem= canHandleBranches(); |
| if (canHandleBranchesProblem != null) { |
| status.addFatalError(canHandleBranchesProblem, JavaStatusContext.create(fCUnit, getSelection())); |
| fReturnKind= ERROR; |
| return status; |
| } |
| } |
| if (fInputFlowInfo.isValueReturn()) { |
| fReturnKind= RETURN_STATEMENT_VALUE; |
| } else if (fInputFlowInfo.isVoidReturn() || (fInputFlowInfo.isPartialReturn() && isVoidMethod() && isLastStatementSelected())) { |
| fReturnKind= RETURN_STATEMENT_VOID; |
| } else if (fInputFlowInfo.isNoReturn() || fInputFlowInfo.isThrow() || fInputFlowInfo.isUndefined()) { |
| fReturnKind= NO; |
| } |
| |
| if (fReturnKind == UNDEFINED) { |
| status.addError(RefactoringCoreMessages.FlowAnalyzer_execution_flow, JavaStatusContext.create(fCUnit, getSelection())); |
| fReturnKind= NO; |
| } |
| computeInput(); |
| computeExceptions(); |
| computeOutput(status); |
| if (status.hasFatalError()) |
| return status; |
| |
| adjustArgumentsAndMethodLocals(); |
| compressArrays(); |
| return status; |
| } |
| |
| private String canHandleBranches() { |
| if (fReturnValue != null) |
| return RefactoringCoreMessages.ExtractMethodAnalyzer_branch_mismatch; |
| |
| ASTNode[] selectedNodes= getSelectedNodes(); |
| final ASTNode lastSelectedNode= selectedNodes[selectedNodes.length - 1]; |
| Statement body= getParentLoopBody(lastSelectedNode.getParent()); |
| if (!(body instanceof Block)) |
| return RefactoringCoreMessages.ExtractMethodAnalyzer_branch_mismatch; |
| |
| if (body != lastSelectedNode) { |
| Block block= (Block)body; |
| List<Statement> statements= block.statements(); |
| ASTNode lastStatementInLoop= statements.get(statements.size() - 1); |
| if (lastSelectedNode != lastStatementInLoop) |
| return RefactoringCoreMessages.ExtractMethodAnalyzer_branch_mismatch; |
| } |
| |
| final String continueMatchesLoopProblem[]= { null }; |
| for (int i= 0; i < selectedNodes.length; i++) { |
| final ASTNode astNode= selectedNodes[i]; |
| astNode.accept(new ASTVisitor() { |
| ArrayList<String> fLocalLoopLabels= new ArrayList<String>(); |
| |
| @Override |
| public boolean visit(BreakStatement node) { |
| SimpleName label= node.getLabel(); |
| if (label != null && !fLocalLoopLabels.contains(label.getIdentifier())) { |
| continueMatchesLoopProblem[0]= Messages.format( |
| RefactoringCoreMessages.ExtractMethodAnalyzer_branch_break_mismatch, |
| new Object[] { ("break " + label.getIdentifier()) }); //$NON-NLS-1$ |
| } |
| return false; |
| } |
| |
| @Override |
| public boolean visit(LabeledStatement node) { |
| SimpleName label= node.getLabel(); |
| if (label != null) |
| fLocalLoopLabels.add(label.getIdentifier()); |
| return true; |
| } |
| |
| @Override |
| public void endVisit(ContinueStatement node) { |
| SimpleName label= node.getLabel(); |
| if (label != null && !fLocalLoopLabels.contains(label.getIdentifier())) { |
| if (fEnclosingLoopLabel == null || ! label.getIdentifier().equals(fEnclosingLoopLabel.getIdentifier())) { |
| continueMatchesLoopProblem[0]= Messages.format( |
| RefactoringCoreMessages.ExtractMethodAnalyzer_branch_continue_mismatch, |
| new Object[] { "continue " + label.getIdentifier() }); //$NON-NLS-1$ |
| } |
| } |
| } |
| }); |
| } |
| return continueMatchesLoopProblem[0]; |
| } |
| |
| private Statement getParentLoopBody(ASTNode node) { |
| Statement stmt= null; |
| ASTNode start= node; |
| while (start != null |
| && !(start instanceof ForStatement) |
| && !(start instanceof DoStatement) |
| && !(start instanceof WhileStatement) |
| && !(start instanceof EnhancedForStatement)) { |
| start= start.getParent(); |
| } |
| if (start instanceof ForStatement) { |
| stmt= ((ForStatement)start).getBody(); |
| } else if (start instanceof DoStatement) { |
| stmt= ((DoStatement)start).getBody(); |
| } else if (start instanceof WhileStatement) { |
| stmt= ((WhileStatement)start).getBody(); |
| } else if (start instanceof EnhancedForStatement) { |
| stmt= ((EnhancedForStatement)start).getBody(); |
| } |
| if (start.getParent() instanceof LabeledStatement) { |
| LabeledStatement labeledStatement= (LabeledStatement)start.getParent(); |
| fEnclosingLoopLabel= labeledStatement.getLabel(); |
| } |
| return stmt; |
| } |
| |
| private boolean isVoidMethod() { |
| // if we have an initializer |
| if (fEnclosingMethodBinding == null) |
| return true; |
| ITypeBinding binding= fEnclosingMethodBinding.getReturnType(); |
| if (fEnclosingBodyDeclaration.getAST().resolveWellKnownType("void").equals(binding)) //$NON-NLS-1$ |
| return true; |
| return false; |
| } |
| |
| public boolean isLastStatementSelected() { |
| return fIsLastStatementSelected; |
| } |
| |
| private void computeLastStatementSelected() { |
| ASTNode[] nodes= getSelectedNodes(); |
| if (nodes.length == 0) { |
| fIsLastStatementSelected= false; |
| } else { |
| Block body= null; |
| if (fEnclosingBodyDeclaration instanceof MethodDeclaration) { |
| body= ((MethodDeclaration) fEnclosingBodyDeclaration).getBody(); |
| } else if (fEnclosingBodyDeclaration instanceof Initializer) { |
| body= ((Initializer) fEnclosingBodyDeclaration).getBody(); |
| } |
| if (body != null) { |
| List<Statement> statements= body.statements(); |
| fIsLastStatementSelected= nodes[nodes.length - 1] == statements.get(statements.size() - 1); |
| } |
| } |
| } |
| |
| private void computeInput() { |
| int argumentMode= FlowInfo.READ | FlowInfo.READ_POTENTIAL | FlowInfo.WRITE_POTENTIAL | FlowInfo.UNKNOWN; |
| fArguments= removeSelectedDeclarations(fInputFlowInfo.get(fInputFlowContext, argumentMode)); |
| fMethodLocals= removeSelectedDeclarations(fInputFlowInfo.get(fInputFlowContext, FlowInfo.WRITE | FlowInfo.WRITE_POTENTIAL)); |
| fTypeVariables= computeTypeVariables(fInputFlowInfo.getTypeVariables()); |
| } |
| |
| private IVariableBinding[] removeSelectedDeclarations(IVariableBinding[] bindings) { |
| List<IVariableBinding> result= new ArrayList<IVariableBinding>(bindings.length); |
| Selection selection= getSelection(); |
| for (int i= 0; i < bindings.length; i++) { |
| ASTNode decl= ((CompilationUnit)fEnclosingBodyDeclaration.getRoot()).findDeclaringNode(bindings[i]); |
| if (!selection.covers(decl)) |
| result.add(bindings[i]); |
| } |
| return result.toArray(new IVariableBinding[result.size()]); |
| } |
| |
| private ITypeBinding[] computeTypeVariables(ITypeBinding[] bindings) { |
| Selection selection= getSelection(); |
| Set<ITypeBinding> result= new HashSet<ITypeBinding>(); |
| // first remove all type variables that come from outside of the method |
| // or are covered by the selection |
| CompilationUnit compilationUnit= (CompilationUnit)fEnclosingBodyDeclaration.getRoot(); |
| for (int i= 0; i < bindings.length; i++) { |
| ASTNode decl= compilationUnit.findDeclaringNode(bindings[i]); |
| if (decl == null || (!selection.covers(decl) && decl.getParent() instanceof MethodDeclaration)) |
| result.add(bindings[i]); |
| } |
| // all all type variables which are needed since a local variable uses it |
| for (int i= 0; i < fArguments.length; i++) { |
| IVariableBinding arg= fArguments[i]; |
| ITypeBinding type= arg.getType(); |
| if (type != null && type.isTypeVariable()) { |
| ASTNode decl= compilationUnit.findDeclaringNode(type); |
| if (decl == null || (!selection.covers(decl) && decl.getParent() instanceof MethodDeclaration)) |
| result.add(type); |
| } |
| } |
| return result.toArray(new ITypeBinding[result.size()]); |
| } |
| |
| private void computeOutput(RefactoringStatus status) { |
| // First find all writes inside the selection. |
| FlowContext flowContext= new FlowContext(0, fMaxVariableId + 1); |
| flowContext.setConsiderAccessMode(true); |
| flowContext.setComputeMode(FlowContext.RETURN_VALUES); |
| FlowInfo returnInfo= new InOutFlowAnalyzer(flowContext).perform(getSelectedNodes()); |
| IVariableBinding[] returnValues= returnInfo.get(flowContext, FlowInfo.WRITE | FlowInfo.WRITE_POTENTIAL | FlowInfo.UNKNOWN); |
| |
| // Compute a selection that exactly covers the selected nodes |
| IRegion region= getSelectedNodeRange(); |
| Selection selection= Selection.createFromStartLength(region.getOffset(), region.getLength()); |
| |
| List<IVariableBinding> localReads= new ArrayList<IVariableBinding>(); |
| flowContext.setComputeMode(FlowContext.ARGUMENTS); |
| FlowInfo argInfo= new InputFlowAnalyzer(flowContext, selection, true).perform(fEnclosingBodyDeclaration); |
| IVariableBinding[] reads= argInfo.get(flowContext, FlowInfo.READ | FlowInfo.READ_POTENTIAL | FlowInfo.UNKNOWN); |
| outer: for (int i= 0; i < returnValues.length && localReads.size() < returnValues.length; i++) { |
| IVariableBinding binding= returnValues[i]; |
| for (int x= 0; x < reads.length; x++) { |
| if (reads[x] == binding) { |
| localReads.add(binding); |
| fReturnValue= binding; |
| continue outer; |
| } |
| } |
| } |
| switch (localReads.size()) { |
| case 0: |
| fReturnValue= null; |
| break; |
| case 1: |
| break; |
| default: |
| fReturnValue= null; |
| StringBuffer affectedLocals= new StringBuffer(); |
| for (int i= 0; i < localReads.size(); i++) { |
| IVariableBinding binding= localReads.get(i); |
| String bindingName= BindingLabelProvider.getBindingLabel(binding, BindingLabelProvider.DEFAULT_TEXTFLAGS | JavaElementLabels.F_PRE_TYPE_SIGNATURE); |
| affectedLocals.append(bindingName); |
| if (i != localReads.size() - 1) { |
| affectedLocals.append('\n'); |
| } |
| } |
| String message= MessageFormat.format(RefactoringCoreMessages.ExtractMethodAnalyzer_assignments_to_local, new Object[] { affectedLocals.toString() }); |
| status.addFatalError(message, JavaStatusContext.create(fCUnit, getSelection())); |
| return; |
| } |
| List<IVariableBinding> callerLocals= new ArrayList<IVariableBinding>(5); |
| FlowInfo localInfo= new InputFlowAnalyzer(flowContext, selection, false).perform(fEnclosingBodyDeclaration); |
| IVariableBinding[] writes= localInfo.get(flowContext, FlowInfo.WRITE | FlowInfo.WRITE_POTENTIAL | FlowInfo.UNKNOWN); |
| for (int i= 0; i < writes.length; i++) { |
| IVariableBinding write= writes[i]; |
| if (getSelection().covers(ASTNodes.findDeclaration(write, fEnclosingBodyDeclaration))) |
| callerLocals.add(write); |
| } |
| fCallerLocals= callerLocals.toArray(new IVariableBinding[callerLocals.size()]); |
| if (fReturnValue != null && getSelection().covers(ASTNodes.findDeclaration(fReturnValue, fEnclosingBodyDeclaration))) |
| fReturnLocal= fReturnValue; |
| } |
| |
| private void adjustArgumentsAndMethodLocals() { |
| for (int i= 0; i < fArguments.length; i++) { |
| IVariableBinding argument= fArguments[i]; |
| // Both arguments and locals consider FlowInfo.WRITE_POTENTIAL. But at the end a variable |
| // can either be a local of an argument. Fix this based on the compute return type which |
| // didn't exist when we computed the locals and arguments (see computeInput()) |
| if (fInputFlowInfo.hasAccessMode(fInputFlowContext, argument, FlowInfo.WRITE_POTENTIAL)) { |
| if (argument != fReturnValue) |
| fArguments[i]= null; |
| // We didn't remove the argument. So we have to remove the local declaration |
| if (fArguments[i] != null) { |
| for (int l= 0; l < fMethodLocals.length; l++) { |
| if (fMethodLocals[l] == argument) |
| fMethodLocals[l]= null; |
| } |
| } |
| } |
| } |
| } |
| |
| private void compressArrays() { |
| fArguments= compressArray(fArguments); |
| fCallerLocals= compressArray(fCallerLocals); |
| fMethodLocals= compressArray(fMethodLocals); |
| } |
| |
| private IVariableBinding[] compressArray(IVariableBinding[] array) { |
| if (array == null) |
| return null; |
| int size= 0; |
| for (int i= 0; i < array.length; i++) { |
| if (array[i] != null) |
| size++; |
| } |
| if (size == array.length) |
| return array; |
| IVariableBinding[] result= new IVariableBinding[size]; |
| for (int i= 0, r= 0; i < array.length; i++) { |
| if (array[i] != null) |
| result[r++]= array[i]; |
| } |
| return result; |
| } |
| |
| //---- Change creation ---------------------------------------------------------------------------------- |
| |
| public void aboutToCreateChange() { |
| } |
| |
| //---- Exceptions ----------------------------------------------------------------------------------------- |
| |
| public ITypeBinding[] getExceptions(boolean includeRuntimeExceptions) { |
| if (includeRuntimeExceptions) |
| return fAllExceptions; |
| List<ITypeBinding> result= new ArrayList<ITypeBinding>(fAllExceptions.length); |
| for (int i= 0; i < fAllExceptions.length; i++) { |
| ITypeBinding exception= fAllExceptions[i]; |
| if (!includeRuntimeExceptions && Bindings.isRuntimeException(exception)) |
| continue; |
| result.add(exception); |
| } |
| return result.toArray(new ITypeBinding[result.size()]); |
| } |
| |
| private void computeExceptions() { |
| fAllExceptions= ExceptionAnalyzer.perform(getSelectedNodes()); |
| } |
| |
| //---- Special visitor methods --------------------------------------------------------------------------- |
| |
| @Override |
| protected void handleNextSelectedNode(ASTNode node) { |
| super.handleNextSelectedNode(node); |
| checkParent(node); |
| } |
| |
| @Override |
| protected boolean handleSelectionEndsIn(ASTNode node) { |
| invalidSelection(RefactoringCoreMessages.StatementAnalyzer_doesNotCover, JavaStatusContext.create(fCUnit, node)); |
| return super.handleSelectionEndsIn(node); |
| } |
| |
| private void checkParent(ASTNode node) { |
| ASTNode firstParent= getFirstSelectedNode().getParent(); |
| do { |
| node= node.getParent(); |
| if (node == firstParent) |
| return; |
| } while (node != null); |
| invalidSelection(RefactoringCoreMessages.ExtractMethodAnalyzer_parent_mismatch); |
| } |
| |
| @Override |
| public void endVisit(CompilationUnit node) { |
| RefactoringStatus status= getStatus(); |
| superCall: { |
| if (status.hasFatalError()) |
| break superCall; |
| if (!hasSelectedNodes()) { |
| ASTNode coveringNode= getLastCoveringNode(); |
| if (coveringNode instanceof Block && coveringNode.getParent() instanceof MethodDeclaration) { |
| MethodDeclaration methodDecl= (MethodDeclaration)coveringNode.getParent(); |
| Message[] messages= ASTNodes.getMessages(methodDecl, ASTNodes.NODE_ONLY); |
| if (messages.length > 0) { |
| status.addFatalError(Messages.format( |
| RefactoringCoreMessages.ExtractMethodAnalyzer_compile_errors, |
| BasicElementLabels.getJavaElementName(methodDecl.getName().getIdentifier())), JavaStatusContext.create(fCUnit, methodDecl)); |
| break superCall; |
| } |
| } |
| status.addFatalError(RefactoringCoreMessages.ExtractMethodAnalyzer_only_method_body); |
| break superCall; |
| } |
| fEnclosingBodyDeclaration= (BodyDeclaration)ASTNodes.getParent(getFirstSelectedNode(), BodyDeclaration.class); |
| if (fEnclosingBodyDeclaration == null || |
| (fEnclosingBodyDeclaration.getNodeType() != ASTNode.METHOD_DECLARATION && |
| fEnclosingBodyDeclaration.getNodeType() != ASTNode.FIELD_DECLARATION && |
| fEnclosingBodyDeclaration.getNodeType() != ASTNode.INITIALIZER)) { |
| status.addFatalError(RefactoringCoreMessages.ExtractMethodAnalyzer_only_method_body); |
| break superCall; |
| } else if (ASTNodes.getEnclosingType(fEnclosingBodyDeclaration) == null) { |
| status.addFatalError(RefactoringCoreMessages.ExtractMethodAnalyzer_compile_errors_no_parent_binding); |
| break superCall; |
| } else if (fEnclosingBodyDeclaration.getNodeType() == ASTNode.METHOD_DECLARATION) { |
| fEnclosingMethodBinding= ((MethodDeclaration)fEnclosingBodyDeclaration).resolveBinding(); |
| } |
| if (!isSingleExpressionOrStatementSet()) { |
| status.addFatalError(RefactoringCoreMessages.ExtractMethodAnalyzer_single_expression_or_set); |
| break superCall; |
| } |
| if (isExpressionSelected()) { |
| ASTNode expression= getFirstSelectedNode(); |
| if (expression instanceof Name) { |
| Name name= (Name)expression; |
| if (name.resolveBinding() instanceof ITypeBinding) { |
| status.addFatalError(RefactoringCoreMessages.ExtractMethodAnalyzer_cannot_extract_type_reference); |
| break superCall; |
| } |
| if (name.resolveBinding() instanceof IMethodBinding) { |
| status.addFatalError(RefactoringCoreMessages.ExtractMethodAnalyzer_cannot_extract_method_name_reference); |
| break superCall; |
| } |
| if (name.resolveBinding() instanceof IVariableBinding) { |
| StructuralPropertyDescriptor locationInParent= name.getLocationInParent(); |
| if (locationInParent == QualifiedName.NAME_PROPERTY || (locationInParent == FieldAccess.NAME_PROPERTY && !(((FieldAccess) name.getParent()).getExpression() instanceof ThisExpression))) { |
| status.addFatalError(RefactoringCoreMessages.ExtractMethodAnalyzer_cannot_extract_part_of_qualified_name); |
| break superCall; |
| } |
| } |
| if (name.isSimpleName() && ((SimpleName)name).isDeclaration()) { |
| status.addFatalError(RefactoringCoreMessages.ExtractMethodAnalyzer_cannot_extract_name_in_declaration); |
| break superCall; |
| } |
| } |
| fForceStatic= |
| ASTNodes.getParent(expression, ASTNode.SUPER_CONSTRUCTOR_INVOCATION) != null || |
| ASTNodes.getParent(expression, ASTNode.CONSTRUCTOR_INVOCATION) != null; |
| } |
| status.merge(LocalTypeAnalyzer.perform(fEnclosingBodyDeclaration, getSelection())); |
| computeLastStatementSelected(); |
| } |
| super.endVisit(node); |
| } |
| |
| @Override |
| public boolean visit(AnonymousClassDeclaration node) { |
| boolean result= super.visit(node); |
| if (isFirstSelectedNode(node)) { |
| invalidSelection(RefactoringCoreMessages.ExtractMethodAnalyzer_cannot_extract_anonymous_type, JavaStatusContext.create(fCUnit, node)); |
| return false; |
| } |
| return result; |
| } |
| |
| @Override |
| public boolean visit(Assignment node) { |
| boolean result= super.visit(node); |
| if (getSelection().covers(node.getLeftHandSide()) || getSelection().coveredBy(node.getLeftHandSide())) { |
| invalidSelection( |
| RefactoringCoreMessages.ExtractMethodAnalyzer_leftHandSideOfAssignment, |
| JavaStatusContext.create(fCUnit, node)); |
| return false; |
| } |
| return result; |
| } |
| |
| @Override |
| public boolean visit(DoStatement node) { |
| boolean result= super.visit(node); |
| |
| try { |
| int actionStart= getTokenScanner().getTokenEndOffset(ITerminalSymbols.TokenNamedo, node.getStartPosition()); |
| if (getSelection().getOffset() == actionStart) { |
| invalidSelection(RefactoringCoreMessages.ExtractMethodAnalyzer_after_do_keyword, JavaStatusContext.create(fCUnit, getSelection())); |
| return false; |
| } |
| } catch (CoreException e) { |
| // ignore |
| } |
| |
| return result; |
| } |
| |
| @Override |
| public boolean visit(MethodDeclaration node) { |
| Block body= node.getBody(); |
| if (body == null) |
| return false; |
| Selection selection= getSelection(); |
| int nodeStart= body.getStartPosition(); |
| int nodeExclusiveEnd= nodeStart + body.getLength(); |
| // if selection node inside of the method body ignore method |
| if (!(nodeStart < selection.getOffset() && selection.getExclusiveEnd() < nodeExclusiveEnd)) |
| return false; |
| return super.visit(node); |
| } |
| |
| @Override |
| public boolean visit(ConstructorInvocation node) { |
| return visitConstructorInvocation(node, super.visit(node)); |
| } |
| |
| @Override |
| public boolean visit(SuperConstructorInvocation node) { |
| return visitConstructorInvocation(node, super.visit(node)); |
| } |
| |
| private boolean visitConstructorInvocation(ASTNode node, boolean superResult) { |
| if (getSelection().getVisitSelectionMode(node) == Selection.SELECTED) { |
| invalidSelection(RefactoringCoreMessages.ExtractMethodAnalyzer_super_or_this, JavaStatusContext.create(fCUnit, node)); |
| return false; |
| } |
| return superResult; |
| } |
| |
| @Override |
| public boolean visit(VariableDeclarationFragment node) { |
| boolean result= super.visit(node); |
| if (isFirstSelectedNode(node)) { |
| invalidSelection(RefactoringCoreMessages.ExtractMethodAnalyzer_cannot_extract_variable_declaration_fragment, JavaStatusContext.create(fCUnit, node)); |
| return false; |
| } |
| return result; |
| } |
| |
| @Override |
| public void endVisit(ForStatement node) { |
| if (getSelection().getEndVisitSelectionMode(node) == Selection.AFTER) { |
| if (node.initializers().contains(getFirstSelectedNode())) { |
| invalidSelection(RefactoringCoreMessages.ExtractMethodAnalyzer_cannot_extract_for_initializer, JavaStatusContext.create(fCUnit, getSelection())); |
| } else if (node.updaters().contains(getLastSelectedNode())) { |
| invalidSelection(RefactoringCoreMessages.ExtractMethodAnalyzer_cannot_extract_for_updater, JavaStatusContext.create(fCUnit, getSelection())); |
| } |
| } |
| super.endVisit(node); |
| } |
| |
| @Override |
| public void endVisit(VariableDeclarationExpression node) { |
| if (getSelection().getEndVisitSelectionMode(node) == Selection.SELECTED && getFirstSelectedNode() == node) { |
| if (node.getLocationInParent() == TryStatement.RESOURCES_PROPERTY) { |
| invalidSelection(RefactoringCoreMessages.ExtractMethodAnalyzer_resource_in_try_with_resources, JavaStatusContext.create(fCUnit, getSelection())); |
| } |
| } |
| checkTypeInDeclaration(node.getType()); |
| super.endVisit(node); |
| } |
| |
| @Override |
| public void endVisit(VariableDeclarationStatement node) { |
| checkTypeInDeclaration(node.getType()); |
| super.endVisit(node); |
| } |
| |
| private boolean isFirstSelectedNode(ASTNode node) { |
| return getSelection().getVisitSelectionMode(node) == Selection.SELECTED && getFirstSelectedNode() == node; |
| } |
| |
| private void checkTypeInDeclaration(Type node) { |
| if (getSelection().getEndVisitSelectionMode(node) == Selection.SELECTED && getFirstSelectedNode() == node) { |
| invalidSelection(RefactoringCoreMessages.ExtractMethodAnalyzer_cannot_extract_variable_declaration, JavaStatusContext.create(fCUnit, getSelection())); |
| } |
| } |
| |
| private boolean isSingleExpressionOrStatementSet() { |
| ASTNode first= getFirstSelectedNode(); |
| if (first == null) |
| return true; |
| if (first instanceof Expression && getSelectedNodes().length != 1) |
| return false; |
| return true; |
| } |
| } |
| |
