| /******************************************************************************* |
| * Copyright (c) 2000, 2010 IBM Corporation and others. |
| * This program and the accompanying materials are made available under the |
| * terms of the Eclipse Public License v. 2.0 which is available at |
| * http://www.eclipse.org/legal/epl-2.0. |
| * |
| * SPDX-License-Identifier: EPL-2.0 |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| * Benjamin Muskalla <bmuskalla@eclipsesource.com> - [extract method] Does not replace similar code in parent class of anonymous class - https://bugs.eclipse.org/bugs/show_bug.cgi?id=160853 |
| * 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] should declare method static if extracted from anonymous in static method - https://bugs.eclipse.org/bugs/show_bug.cgi?id=152004 |
| *******************************************************************************/ |
| package org.eclipse.dltk.internal.javascript.corext.refactoring.code; |
| |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.SubProgressMonitor; |
| import org.eclipse.dltk.core.IScriptProject; |
| import org.eclipse.dltk.core.ISourceModule; |
| import org.eclipse.dltk.core.manipulation.RefactoringChecks; |
| import org.eclipse.dltk.core.manipulation.SourceModuleChange; |
| import org.eclipse.dltk.internal.corext.refactoring.ScriptRefactoringDescriptor; |
| import org.eclipse.dltk.internal.corext.refactoring.util.ResourceUtil; |
| import org.eclipse.dltk.internal.javascript.core.manipulation.Messages; |
| import org.eclipse.dltk.internal.javascript.corext.refactoring.Checks; |
| import org.eclipse.dltk.internal.javascript.corext.refactoring.ParameterInfo; |
| import org.eclipse.dltk.internal.javascript.corext.refactoring.RefactoringCoreMessages; |
| import org.eclipse.dltk.internal.javascript.corext.refactoring.code.flow.VariableBinding; |
| import org.eclipse.dltk.internal.javascript.corext.refactoring.util.Selection; |
| import org.eclipse.dltk.javascript.core.dom.BinaryExpression; |
| import org.eclipse.dltk.javascript.core.dom.BinaryOperator; |
| import org.eclipse.dltk.javascript.core.dom.BlockStatement; |
| import org.eclipse.dltk.javascript.core.dom.CallExpression; |
| import org.eclipse.dltk.javascript.core.dom.DomFactory; |
| import org.eclipse.dltk.javascript.core.dom.DomPackage; |
| import org.eclipse.dltk.javascript.core.dom.Expression; |
| import org.eclipse.dltk.javascript.core.dom.ExpressionStatement; |
| import org.eclipse.dltk.javascript.core.dom.FunctionExpression; |
| import org.eclipse.dltk.javascript.core.dom.Identifier; |
| import org.eclipse.dltk.javascript.core.dom.Node; |
| import org.eclipse.dltk.javascript.core.dom.Parameter; |
| import org.eclipse.dltk.javascript.core.dom.ReturnStatement; |
| import org.eclipse.dltk.javascript.core.dom.Source; |
| import org.eclipse.dltk.javascript.core.dom.Statement; |
| import org.eclipse.dltk.javascript.core.dom.VariableDeclaration; |
| import org.eclipse.dltk.javascript.core.dom.VariableReference; |
| import org.eclipse.dltk.javascript.core.dom.VariableStatement; |
| import org.eclipse.dltk.javascript.core.dom.rewrite.ASTConverter; |
| import org.eclipse.dltk.javascript.core.dom.rewrite.Generator; |
| import org.eclipse.dltk.javascript.core.dom.rewrite.RewriteAnalyzer; |
| import org.eclipse.dltk.javascript.core.dom.rewrite.VariableLookup; |
| import org.eclipse.dltk.javascript.core.refactoring.descriptors.ExtractMethodDescriptor; |
| import org.eclipse.dltk.javascript.parser.JavaScriptParserUtil; |
| import org.eclipse.emf.common.util.EList; |
| import org.eclipse.emf.ecore.EReference; |
| import org.eclipse.emf.ecore.change.ChangeDescription; |
| import org.eclipse.emf.ecore.change.util.ChangeRecorder; |
| import org.eclipse.ltk.core.refactoring.Change; |
| import org.eclipse.ltk.core.refactoring.Refactoring; |
| import org.eclipse.ltk.core.refactoring.RefactoringChangeDescriptor; |
| import org.eclipse.ltk.core.refactoring.RefactoringDescriptor; |
| import org.eclipse.ltk.core.refactoring.RefactoringStatus; |
| import org.eclipse.ltk.core.refactoring.TextFileChange; |
| import org.eclipse.ltk.core.refactoring.participants.ResourceChangeChecker; |
| import org.eclipse.text.edits.InsertEdit; |
| import org.eclipse.text.edits.TextEdit; |
| |
| /** |
| * Extracts a method in a compilation unit based on a text selection range. |
| */ |
| public class ExtractMethodRefactoring extends Refactoring { |
| |
| //private static final String ATTRIBUTE_VISIBILITY= "visibility"; //$NON-NLS-1$ |
| private static final String ATTRIBUTE_DESTINATION= "destination"; //$NON-NLS-1$ |
| /*private static final String ATTRIBUTE_COMMENTS= "comments"; //$NON-NLS-1$ |
| private static final String ATTRIBUTE_REPLACE= "replace"; //$NON-NLS-1$ |
| private static final String ATTRIBUTE_EXCEPTIONS= "exceptions"; //$NON-NLS-1$*/ |
| |
| private ISourceModule fCUnit; |
| private String fSource; |
| private Source fRoot; |
| //private ImportRewrite fImportRewriter; |
| private int fSelectionStart; |
| private int fSelectionLength; |
| /*private AST fAST; |
| private ASTRewrite fRewriter;*/ |
| private ExtractMethodAnalyzer fAnalyzer; |
| //private int fVisibility; |
| private String fMethodName; |
| //private boolean fThrowRuntimeExceptions; |
| private List<ParameterInfo> fParameterInfos; |
| private Set<String> fUsedNames; |
| /*private boolean fGenerateScriptdoc; |
| private boolean fReplaceDuplicates; |
| private SnippetFinder.Match[] fDuplicates;*/ |
| private int fDestinationIndex= 0; |
| private Node fDestination; |
| private Node[] fDestinations; |
| //private LinkedProposalModel fLinkedProposalModel; |
| |
| private static final String EMPTY= ""; //$NON-NLS-1$ |
| |
| /*private static final String KEY_TYPE= "type"; //$NON-NLS-1$ |
| private static final String KEY_NAME= "name"; //$NON-NLS-1$ |
| |
| private static class UsedNamesCollector extends ASTVisitor { |
| private Set result= new HashSet(); |
| private Set fIgnore= new HashSet(); |
| public static Set perform(ASTNode[] nodes) { |
| UsedNamesCollector collector= new UsedNamesCollector(); |
| for (int i= 0; i < nodes.length; i++) { |
| nodes[i].accept(collector); |
| } |
| return collector.result; |
| } |
| public boolean visit(FieldAccess node) { |
| Expression exp= node.getExpression(); |
| if (exp != null) |
| fIgnore.add(node.getName()); |
| return true; |
| } |
| public void endVisit(FieldAccess node) { |
| fIgnore.remove(node.getName()); |
| } |
| public boolean visit(MethodInvocation node) { |
| Expression exp= node.getExpression(); |
| if (exp != null) |
| fIgnore.add(node.getName()); |
| return true; |
| } |
| public void endVisit(MethodInvocation node) { |
| fIgnore.remove(node.getName()); |
| } |
| public boolean visit(QualifiedName node) { |
| fIgnore.add(node.getName()); |
| return true; |
| } |
| public void endVisit(QualifiedName node) { |
| fIgnore.remove(node.getName()); |
| } |
| public boolean visit(SimpleName node) { |
| if (!fIgnore.contains(node)) |
| result.add(node.getIdentifier()); |
| return true; |
| } |
| public boolean visit(TypeDeclaration node) { |
| return visitType(node); |
| } |
| public boolean visit(AnnotationTypeDeclaration node) { |
| return visitType(node); |
| } |
| public boolean visit(EnumDeclaration node) { |
| return visitType(node); |
| } |
| private boolean visitType(AbstractTypeDeclaration node) { |
| result.add(node.getName().getIdentifier()); |
| // don't dive into type declaration since they open a new |
| // context. |
| return false; |
| } |
| } |
| |
| /** |
| * Creates a new extract method refactoring |
| * @param unit the compilation unit, or <code>null</code> if invoked by scripting |
| * @param selectionStart selection start |
| * @param selectionLength selection end |
| */ |
| public ExtractMethodRefactoring(ISourceModule unit, int selectionStart, int selectionLength) { |
| fCUnit= unit; |
| fRoot= null; |
| fMethodName= "extracted"; //$NON-NLS-1$ |
| fSelectionStart= selectionStart; |
| fSelectionLength= selectionLength; |
| //fVisibility= -1; |
| } |
| |
| /*public ExtractMethodRefactoring(ScriptRefactoringArguments arguments, RefactoringStatus status) { |
| this((ISourceModule) null, 0, 0); |
| RefactoringStatus initializeStatus= initialize(arguments); |
| status.merge(initializeStatus); |
| } |
| |
| /** |
| * Creates a new extract method refactoring |
| * @param astRoot the AST root of an AST created from a compilation unit |
| * @param selectionStart start |
| * @param selectionLength length |
| * |
| public ExtractMethodRefactoring(Source astRoot, int selectionStart, int selectionLength) { |
| this((ISourceModule) astRoot.getTypeRoot(), selectionStart, selectionLength); |
| fRoot= astRoot; |
| } |
| |
| public void setLinkedProposalModel(LinkedProposalModel linkedProposalModel) { |
| fLinkedProposalModel= linkedProposalModel; |
| }*/ |
| |
| public String getName() { |
| return RefactoringCoreMessages.ExtractMethodRefactoring_name; |
| } |
| |
| /** |
| * Checks if the refactoring can be activated. Activation typically means, if a |
| * corresponding menu entry can be added to the UI. |
| * |
| * @param pm a progress monitor to report progress during activation checking. |
| * @return the refactoring status describing the result of the activation check. |
| * @throws CoreException if checking fails |
| */ |
| public RefactoringStatus checkInitialConditions(IProgressMonitor pm) throws CoreException { |
| RefactoringStatus result= new RefactoringStatus(); |
| pm.beginTask("", 100); //$NON-NLS-1$ |
| |
| if (fSelectionStart < 0 || fSelectionLength == 0) { |
| result.addFatalError(RefactoringCoreMessages.ExtractMethodRefactoring_no_set_of_statements); |
| return result; |
| } |
| |
| IFile[] changedFiles= ResourceUtil.getFiles(new ISourceModule[]{fCUnit}); |
| result.merge(RefactoringChecks.validateModifiesFiles(changedFiles, getValidationContext())); |
| if (result.hasFatalError()) |
| return result; |
| result.merge(ResourceChangeChecker.checkFilesToBeChanged(changedFiles, new SubProgressMonitor(pm, 1))); |
| |
| if (fRoot == null) { |
| fRoot = (Source)ASTConverter.convert(JavaScriptParserUtil.parse(fCUnit)); |
| } |
| //fImportRewriter= StubUtility.createImportRewrite(fRoot, true); |
| |
| //fAST= fRoot.getAST(); |
| fAnalyzer= new ExtractMethodAnalyzer(fCUnit, Selection.createFromStartLength(fSelectionStart, fSelectionLength)); |
| //fRoot.accept(fAnalyzer); |
| |
| result.merge(fAnalyzer.checkInitialConditions(fRoot)); |
| if (result.hasFatalError()) |
| return result; |
| |
| fSource = fCUnit.getSource(); |
| Node[] nodes = fAnalyzer.getSelectedNodes(); |
| boolean badSelection = false; |
| for(int i=fSelectionStart;i<nodes[0].getBegin();i++) |
| if (!Character.isWhitespace(fSource.charAt(i))) badSelection = true; |
| for(int i=nodes[nodes.length-1].getEnd();i<fSelectionStart+fSelectionLength;i++) |
| if (!Character.isWhitespace(fSource.charAt(i))) badSelection = true; |
| if (badSelection) { |
| result.addFatalError(RefactoringCoreMessages.StatementAnalyzer_doesNotCover); |
| return result; |
| } |
| /*if (fVisibility == -1) { |
| setVisibility(Modifier.PRIVATE); |
| }*/ |
| initializeParameterInfos(); |
| initializeUsedNames(); |
| //initializeDuplicates(); |
| initializeDestinations(); |
| return result; |
| } |
| |
| /** |
| * Sets the method name to be used for the extracted method. |
| * |
| * @param name the new method name. |
| */ |
| public void setMethodName(String name) { |
| fMethodName= name; |
| } |
| |
| /** |
| * Returns the method name to be used for the extracted method. |
| * @return the method name to be used for the extracted method. |
| * |
| public String getMethodName() { |
| return fMethodName; |
| } |
| |
| /** |
| * Sets the visibility of the new method. |
| * |
| * @param visibility the visibility of the new method. Valid values are |
| * "public", "protected", "", and "private" |
| * |
| public void setVisibility(int visibility) { |
| fVisibility= visibility; |
| } |
| |
| /** |
| * Returns the visibility of the new method. |
| * |
| * @return the visibility of the new method |
| * |
| public int getVisibility() { |
| return fVisibility; |
| } |
| |
| /** |
| * Returns the parameter infos. |
| * @return a list of parameter infos. |
| */ |
| public List<ParameterInfo> getParameterInfos() { |
| return fParameterInfos; |
| } |
| |
| /** |
| * Sets whether the new method signature throws runtime exceptions. |
| * |
| * @param throwRuntimeExceptions flag indicating if the new method |
| * throws runtime exceptions |
| * |
| public void setThrowRuntimeExceptions(boolean throwRuntimeExceptions) { |
| fThrowRuntimeExceptions= throwRuntimeExceptions; |
| } |
| |
| /** |
| * Checks if the new method name is a valid method name. This method doesn't |
| * check if a method with the same name already exists in the hierarchy. This |
| * check is done in <code>checkInput</code> since it is expensive. |
| * @return validation status |
| */ |
| public RefactoringStatus checkMethodName() { |
| return Checks.validateIdentifier(fMethodName); |
| } |
| |
| public Node[] getDestinations() { |
| return fDestinations; |
| } |
| |
| public void setDestination(int index) { |
| fDestination= fDestinations[index]; |
| fDestinationIndex= index; |
| } |
| |
| /** |
| * Checks if the parameter names are valid. |
| * @return validation status |
| */ |
| public RefactoringStatus checkParameterNames() { |
| RefactoringStatus result= new RefactoringStatus(); |
| for (ParameterInfo parameter : fParameterInfos) { |
| result.merge(Checks.validateIdentifier(parameter.getNewName())); |
| for (ParameterInfo other : fParameterInfos) { |
| if (parameter != other && other.getNewName().equals(parameter.getNewName())) { |
| result.addError(Messages.format( |
| RefactoringCoreMessages.ExtractMethodRefactoring_error_sameParameter, |
| //BasicElementLabels.getScriptElementName(other.getNewName()) |
| other.getNewName())); |
| return result; |
| } |
| } |
| if (parameter.isRenamed() && fUsedNames.contains(parameter.getNewName())) { |
| result.addError(Messages.format( |
| RefactoringCoreMessages.ExtractMethodRefactoring_error_nameInUse, |
| //BasicElementLabels.getScriptElementName(parameter.getNewName()) |
| parameter.getNewName())); |
| return result; |
| } |
| } |
| return result; |
| } |
| |
| /** |
| * Checks if varargs are ordered correctly. |
| * @return validation status |
| * |
| public RefactoringStatus checkVarargOrder() { |
| for (Iterator iter= fParameterInfos.iterator(); iter.hasNext();) { |
| ParameterInfo info= (ParameterInfo)iter.next(); |
| if (info.isOldVarargs() && iter.hasNext()) { |
| return RefactoringStatus.createFatalErrorStatus(Messages.format( |
| RefactoringCoreMessages.ExtractMethodRefactoring_error_vararg_ordering, |
| BasicElementLabels.getScriptElementName(info.getOldName()))); |
| } |
| } |
| return new RefactoringStatus(); |
| } |
| |
| /** |
| * Returns the names already in use in the selected statements/expressions. |
| * |
| * @return names already in use. |
| * |
| public Set getUsedNames() { |
| return fUsedNames; |
| } |
| |
| /* (non-Scriptdoc) |
| * Method declared in Refactoring |
| */ |
| public RefactoringStatus checkFinalConditions(IProgressMonitor pm) throws CoreException { |
| pm.beginTask(RefactoringCoreMessages.ExtractMethodRefactoring_checking_new_name, 1); |
| pm.subTask(EMPTY); |
| |
| RefactoringStatus result= checkMethodName(); |
| result.merge(checkParameterNames()); |
| /*result.merge(checkVarargOrder()); |
| pm.worked(1); |
| if (pm.isCanceled()) |
| throw new OperationCanceledException(); |
| |
| Node node= fAnalyzer.getEnclosingNode(); |
| if (node != null) { |
| fAnalyzer.checkInput(result, fMethodName); |
| pm.worked(1); |
| }*/ |
| pm.done(); |
| return result; |
| } |
| |
| /* (non-Scriptdoc) |
| * Method declared in IRefactoring |
| */ |
| public Change createChange(IProgressMonitor pm) throws CoreException { |
| if (fMethodName == null) |
| return null; |
| pm.beginTask("", 2); //$NON-NLS-1$ |
| try { |
| ChangeRecorder cr = new ChangeRecorder(fRoot); |
| Node[] nodes = fAnalyzer.getSelectedNodes(); |
| boolean isExpr = fAnalyzer.isExpressionSelected(); |
| // replace method parameter names |
| Map<String,String> renamings = new HashMap<String,String>(); |
| for (ParameterInfo parameter : fParameterInfos) |
| if (parameter.isRenamed()) |
| renamings.put(parameter.getOldName(),parameter.getNewName()); |
| for (Node node : nodes) { |
| List<Identifier> oldNames = VariableLookup.findReferences(node, renamings.keySet()); |
| for (Identifier ref : oldNames) { |
| ref.setName(renamings.get(ref.getName())); |
| } |
| } |
| // create call |
| CallExpression invocation= DomFactory.eINSTANCE.createCallExpression(); |
| { |
| VariableReference ref = DomFactory.eINSTANCE.createVariableReference(); |
| Identifier id = DomFactory.eINSTANCE.createIdentifier(); |
| id.setName(fMethodName); |
| ref.setVariable(id); |
| invocation.setApplicant(ref); |
| } |
| for (ParameterInfo parameter : fParameterInfos) { |
| Identifier name = DomFactory.eINSTANCE.createIdentifier(); |
| name.setName(parameter.getOldName()); |
| VariableReference local = DomFactory.eINSTANCE.createVariableReference(); |
| local.setVariable(name); |
| invocation.getArguments().add(local); |
| } |
| if (isExpr) { |
| // replace with call |
| EReference ref = nodes[0].eContainmentFeature(); |
| if (ref.isMany()) { |
| EList<Expression> exprList = (EList<Expression>)nodes[0].eContainer().eGet(ref); |
| exprList.set(exprList.lastIndexOf(nodes[0]), (Expression)invocation); |
| } else { |
| nodes[0].eContainer().eSet(ref, invocation); |
| } |
| } else { |
| // create replacement |
| Node call; |
| int returnKind= fAnalyzer.getReturnKind(); |
| switch (returnKind) { |
| case ExtractMethodAnalyzer.ACCESS_TO_LOCAL: |
| VariableBinding binding= fAnalyzer.getReturnLocal(); |
| if (binding != null) { |
| call = createDeclaration(binding, invocation); |
| } else { |
| BinaryExpression assignment= DomFactory.eINSTANCE.createBinaryExpression(); |
| assignment.setOperation(BinaryOperator.ASSIGN); |
| VariableReference retVar = DomFactory.eINSTANCE.createVariableReference(); |
| Identifier id = DomFactory.eINSTANCE.createIdentifier(); |
| id.setName(fAnalyzer.getReturnValue().getName()); |
| retVar.setVariable(id); |
| assignment.setLeft(retVar); |
| assignment.setRight(invocation); |
| call = assignment; |
| } |
| break; |
| case ExtractMethodAnalyzer.RETURN_STATEMENT_VALUE: |
| ReturnStatement rs=DomFactory.eINSTANCE.createReturnStatement(); |
| rs.setExpression(invocation); |
| call = rs; |
| break; |
| default: |
| call = invocation; |
| } |
| if (call instanceof Expression) { |
| ExpressionStatement stmt = DomFactory.eINSTANCE.createExpressionStatement(); |
| stmt.setExpression((Expression)call); |
| call = stmt; |
| } |
| List<Statement> callNodes= new ArrayList<Statement>(2); |
| callNodes.add((Statement)call); |
| if (returnKind == ExtractMethodAnalyzer.RETURN_STATEMENT_VOID && !fAnalyzer.isLastStatementSelected()) { |
| callNodes.add(DomFactory.eINSTANCE.createReturnStatement()); |
| } |
| for (VariableBinding local : fAnalyzer.getCallerLocals()) |
| callNodes.add(createDeclaration(local, null)); |
| // replace with call |
| EReference ref = nodes[0].eContainmentFeature(); |
| if (ref.isMany()) { |
| EList<Statement> list = (EList<Statement>)nodes[0].eContainer().eGet(ref); |
| int index = list.lastIndexOf(nodes[0]); |
| for(int i=nodes.length-1;i>=0;i--) |
| list.remove(index+i); |
| list.addAll(index, callNodes); |
| } else if (callNodes.size() == 1) { |
| nodes[0].eContainer().eSet(ref, callNodes.get(0)); |
| } else { |
| BlockStatement block = DomFactory.eINSTANCE.createBlockStatement(); |
| block.getStatements().addAll(callNodes); |
| nodes[0].eContainer().eSet(ref, block); |
| } |
| } |
| // create declaration |
| FunctionExpression mm = createNewMethodDeclaration(); |
| List<Statement> statements = mm.getBody().getStatements(); |
| VariableBinding[] methodLocals= fAnalyzer.getMethodLocals(); |
| for (int i= 0; i < methodLocals.length; i++) { |
| if (methodLocals[i] != null) |
| statements.add(createDeclaration(methodLocals[i],null)); |
| } |
| if (isExpr) { |
| ReturnStatement rs = DomFactory.eINSTANCE.createReturnStatement(); |
| rs.setExpression((Expression)nodes[0]); |
| statements.add(rs); |
| } else { |
| for(Node node : nodes) |
| statements.add((Statement)node); |
| VariableBinding returnValue= fAnalyzer.getReturnValue(); |
| if (returnValue != null) { |
| ReturnStatement rs = DomFactory.eINSTANCE.createReturnStatement(); |
| VariableReference ret = DomFactory.eINSTANCE.createVariableReference(); |
| Identifier rid = DomFactory.eINSTANCE.createIdentifier(); |
| String name = returnValue.getName(); |
| if (renamings.containsKey(name)) |
| name = renamings.get(name); |
| rid.setName(name); |
| ret.setVariable(rid); |
| rs.setExpression(ret); |
| statements.add(rs); |
| } |
| } |
| // add declaration |
| final ExpressionStatement stmt = DomFactory.eINSTANCE.createExpressionStatement(); |
| stmt.setExpression(mm); |
| Node enclosing = fDestination; |
| EReference ref = enclosing.eContainmentFeature(); |
| assert ref.isMany(); |
| EList<Statement> list = (EList<Statement>)enclosing.eContainer().eGet(ref); |
| list.add(list.lastIndexOf(enclosing)+1,stmt); |
| // TODO replace branches |
| ChangeDescription cd = cr.endRecording(); |
| RewriteAnalyzer ra = new RewriteAnalyzer(cd, fSource) { |
| @Override |
| protected void addEdit(TextEdit edit, Node node) { |
| if (node == stmt) { |
| edit = new InsertEdit(edit.getOffset(), |
| lineDelimiter+((InsertEdit)edit).getText()); |
| } |
| super.addEdit(edit, node); |
| } |
| }; |
| SourceModuleChange result= new SourceModuleChange(RefactoringCoreMessages.ExtractMethodRefactoring_change_name, fCUnit); |
| ra.rewrite(fRoot); |
| result.setSaveMode(TextFileChange.KEEP_SAVE_STATE); |
| result.setDescriptor(new RefactoringChangeDescriptor(getRefactoringDescriptor())); |
| result.setEdit(ra.getEdit()); |
| cd.apply(); |
| return result; |
| } finally { |
| pm.done(); |
| } |
| } |
| |
| /*private void replaceBranches(final SourceModuleChange result) { |
| ASTNode[] selectedNodes= fAnalyzer.getSelectedNodes(); |
| for (int i= 0; i < selectedNodes.length; i++) { |
| ASTNode astNode= selectedNodes[i]; |
| astNode.accept(new ASTVisitor() { |
| private LinkedList fOpenLoopLabels= new LinkedList(); |
| |
| private void registerLoopLabel(Statement node) { |
| String identifier; |
| if (node.getParent() instanceof LabeledStatement) { |
| LabeledStatement labeledStatement= (LabeledStatement)node.getParent(); |
| identifier= labeledStatement.getLabel().getIdentifier(); |
| } else { |
| identifier= null; |
| } |
| fOpenLoopLabels.add(identifier); |
| } |
| |
| public boolean visit(ForStatement node) { |
| registerLoopLabel(node); |
| return super.visit(node); |
| } |
| |
| public void endVisit(ForStatement node) { |
| fOpenLoopLabels.removeLast(); |
| } |
| |
| public boolean visit(WhileStatement node) { |
| registerLoopLabel(node); |
| return super.visit(node); |
| } |
| |
| public void endVisit(WhileStatement node) { |
| fOpenLoopLabels.removeLast(); |
| } |
| |
| public boolean visit(EnhancedForStatement node) { |
| registerLoopLabel(node); |
| return super.visit(node); |
| } |
| |
| public void endVisit(EnhancedForStatement node) { |
| fOpenLoopLabels.removeLast(); |
| } |
| |
| public boolean visit(DoStatement node) { |
| registerLoopLabel(node); |
| return super.visit(node); |
| } |
| |
| public void endVisit(DoStatement node) { |
| fOpenLoopLabels.removeLast(); |
| } |
| |
| public void endVisit(ContinueStatement node) { |
| final SimpleName label= node.getLabel(); |
| if (fOpenLoopLabels.isEmpty() || (label != null && !fOpenLoopLabels.contains(label.getIdentifier()))) { |
| TextEditGroup description= new TextEditGroup(RefactoringCoreMessages.ExtractMethodRefactoring_replace_continue); |
| result.addTextEditGroup(description); |
| |
| ReturnStatement rs= fAST.newReturnStatement(); |
| IVariableBinding returnValue= fAnalyzer.getReturnValue(); |
| if (returnValue != null) { |
| rs.setExpression(fAST.newSimpleName(getName(returnValue))); |
| } |
| |
| fRewriter.replace(node, rs, description); |
| } |
| } |
| }); |
| } |
| }*/ |
| |
| private ExtractMethodDescriptor getRefactoringDescriptor() { |
| final Map arguments= new HashMap(); |
| String project= null; |
| IScriptProject ScriptProject= fCUnit.getScriptProject(); |
| if (ScriptProject != null) |
| project= ScriptProject.getElementName(); |
| /*ITypeBinding type= null; |
| if (fDestination instanceof AbstractTypeDeclaration) { |
| final AbstractTypeDeclaration decl= (AbstractTypeDeclaration) fDestination; |
| type= decl.resolveBinding(); |
| } else if (fDestination instanceof AnonymousClassDeclaration) { |
| final AnonymousClassDeclaration decl= (AnonymousClassDeclaration) fDestination; |
| type= decl.resolveBinding(); |
| } |
| IMethodBinding method= null; |
| final Node enclosing= fAnalyzer.getEnclosingNode(); |
| if (enclosing instanceof MethodDeclaration) { |
| final MethodDeclaration node= (MethodDeclaration) enclosing; |
| method= node.resolveBinding(); |
| }*/ |
| final int flags= RefactoringDescriptor.STRUCTURAL_CHANGE | ScriptRefactoringDescriptor.ARCHIVE_REFACTORABLE | ScriptRefactoringDescriptor.ARCHIVE_IMPORTABLE; |
| final String description= Messages.format(RefactoringCoreMessages.ExtractMethodRefactoring_descriptor_description_short, fMethodName); |
| //final String label= method != null ? BindingLabelProvider.getBindingLabel(method, ScriptElementLabels.ALL_FULLY_QUALIFIED) : '{' + ScriptElementLabels.ELLIPSIS_STRING + '}'; |
| //final String header= Messages.format(RefactoringCoreMessages.ExtractMethodRefactoring_descriptor_description, new String[] { BasicElementLabels.getScriptElementName(getSignature()), label, BindingLabelProvider.getBindingLabel(type, ScriptElementLabels.ALL_FULLY_QUALIFIED)}); |
| //final ScriptRefactoringDescriptorComment comment= new ScriptRefactoringDescriptorComment(project, this, header); |
| //comment.addSetting(Messages.format(RefactoringCoreMessages.ExtractMethodRefactoring_name_pattern, BasicElementLabels.getScriptElementName(fMethodName))); |
| //comment.addSetting(Messages.format(RefactoringCoreMessages.ExtractMethodRefactoring_destination_pattern, BindingLabelProvider.getBindingLabel(type, ScriptElementLabels.ALL_FULLY_QUALIFIED))); |
| //String visibility= JdtFlags.getVisibilityString(fVisibility); |
| //if ("".equals(visibility)) //$NON-NLS-1$ |
| // visibility= RefactoringCoreMessages.ExtractMethodRefactoring_default_visibility; |
| //comment.addSetting(Messages.format(RefactoringCoreMessages.ExtractMethodRefactoring_visibility_pattern, visibility)); |
| //if (fThrowRuntimeExceptions) |
| // comment.addSetting(RefactoringCoreMessages.ExtractMethodRefactoring_declare_thrown_exceptions); |
| //if (fReplaceDuplicates) |
| // comment.addSetting(RefactoringCoreMessages.ExtractMethodRefactoring_replace_occurrences); |
| //if (fGenerateScriptdoc) |
| // comment.addSetting(RefactoringCoreMessages.ExtractMethodRefactoring_generate_comment); |
| final ExtractMethodDescriptor descriptor= new ExtractMethodDescriptor(project, description, ""/*comment.asString()*/, arguments, flags); |
| arguments.put(ScriptRefactoringDescriptor.ATTRIBUTE_INPUT, ScriptRefactoringDescriptor.elementToHandle(project, fCUnit)); |
| arguments.put(ScriptRefactoringDescriptor.ATTRIBUTE_NAME, fMethodName); |
| arguments.put(ScriptRefactoringDescriptor.ATTRIBUTE_SELECTION, new Integer(fSelectionStart).toString() + " " + new Integer(fSelectionLength).toString()); //$NON-NLS-1$ |
| //arguments.put(ATTRIBUTE_VISIBILITY, new Integer(fVisibility).toString()); |
| arguments.put(ATTRIBUTE_DESTINATION, new Integer(fDestinationIndex).toString()); |
| //arguments.put(ATTRIBUTE_EXCEPTIONS, Boolean.valueOf(fThrowRuntimeExceptions).toString()); |
| //arguments.put(ATTRIBUTE_COMMENTS, Boolean.valueOf(fGenerateScriptdoc).toString()); |
| //arguments.put(ATTRIBUTE_REPLACE, Boolean.valueOf(fReplaceDuplicates).toString()); |
| return descriptor; |
| } |
| |
| /** |
| * Returns the signature of the new method. |
| * |
| * @return the signature of the extracted method |
| */ |
| public String getSignature() { |
| return getSignature(fMethodName); |
| } |
| |
| /** |
| * Returns the signature of the new method. |
| * |
| * @param methodName the method name used for the new method |
| * @return the signature of the extracted method |
| */ |
| public String getSignature(String methodName) { |
| FunctionExpression methodDecl= createNewMethodDeclaration(); |
| String str = new Generator(null,"",0,"").generate(methodDecl).toString(); |
| return str.substring(0, str.indexOf('{')-1); |
| } |
| |
| /* |
| * Returns the number of duplicate code snippets found. |
| * |
| * @return the number of duplicate code fragments |
| * |
| public int getNumberOfDuplicates() { |
| if (fDuplicates == null) |
| return 0; |
| int result=0; |
| for (int i= 0; i < fDuplicates.length; i++) { |
| if (!fDuplicates[i].isMethodBody()) |
| result++; |
| } |
| return result; |
| } |
| |
| public boolean getReplaceDuplicates() { |
| return fReplaceDuplicates; |
| } |
| |
| public void setReplaceDuplicates(boolean replace) { |
| fReplaceDuplicates= replace; |
| } |
| |
| public void setGenerateScriptdoc(boolean generate) { |
| fGenerateScriptdoc= generate; |
| } |
| |
| public boolean getGenerateScriptdoc() { |
| return fGenerateScriptdoc; |
| }*/ |
| |
| //---- Helper methods ------------------------------------------------------------------------ |
| |
| private void initializeParameterInfos() { |
| VariableBinding[] arguments= fAnalyzer.getArguments(); |
| fParameterInfos= new ArrayList<ParameterInfo>(arguments.length); |
| for (int i= 0; i < arguments.length; i++) { |
| String argument = arguments[i].getName(); |
| String type = arguments[i].getTypeName(); |
| if (type == null) |
| type = ""; |
| fParameterInfos.add(new ParameterInfo(type, argument, i)); |
| } |
| } |
| |
| private void initializeUsedNames() { |
| // TODO might need more thinking |
| fUsedNames = VariableLookup.getVisibleNames(fAnalyzer.getSelectedNodes()[0]); |
| //fUsedNames= UsedNamesCollector.perform(fAnalyzer.getSelectedNodes()); |
| for (ParameterInfo parameter : fParameterInfos) { |
| fUsedNames.remove(parameter.getOldName()); |
| } |
| } |
| |
| /*private void initializeDuplicates() { |
| ASTNode start= fAnalyzer.getEnclosingBodyDeclaration(); |
| while (!(start instanceof AbstractTypeDeclaration)) { |
| start= start.getParent(); |
| } |
| |
| fDuplicates= SnippetFinder.perform(start, fAnalyzer.getSelectedNodes()); |
| fReplaceDuplicates= fDuplicates.length > 0 && ! fAnalyzer.isLiteralNodeSelected(); |
| }*/ |
| |
| private void initializeDestinations() { |
| List<Node> result= new ArrayList<Node>(); |
| Node node= fAnalyzer.getEnclosingNode(); |
| Node parent = node == null ? null : (Node)node.eContainer(); |
| Node grandparent = parent == null ? null : (Node)parent.eContainer(); |
| if (node instanceof Source) { |
| Node cur = fAnalyzer.getSelectedNodes()[0]; |
| while (cur.eContainer() != node) |
| cur = (Node)cur.eContainer(); |
| result.add(cur); |
| } else { |
| while (node != null) { |
| if (parent instanceof Source) break; |
| boolean stop = false; |
| switch(grandparent.eClass().getClassifierID()) { |
| case DomPackage.GETTER_ASSIGNMENT: |
| case DomPackage.SETTER_ASSIGNMENT: |
| case DomPackage.FUNCTION_EXPRESSION: |
| stop = true; |
| } |
| if (stop) break; |
| node = parent; |
| parent = grandparent; |
| grandparent = parent == null ? null : (Node)parent.eContainer(); |
| } |
| if (node != null) result.add(node); |
| } |
| // TODO understand what we need here or we can just move manually after refactoring |
| /*if (decl instanceof FunctionExpression) { |
| //ITypeBinding binding= ASTNodes.getEnclosingType(current); |
| Node next= getNextParent(current); |
| while (next != null && binding != null && binding.isNested()) { |
| result.add(next); |
| current= next; |
| binding= ASTNodes.getEnclosingType(current); |
| next= getNextParent(next); |
| } |
| }*/ |
| fDestinations= (Node[])result.toArray(new Node[result.size()]); |
| fDestination= fDestinations[fDestinationIndex]; |
| } |
| |
| private FunctionExpression createNewMethodDeclaration() { |
| FunctionExpression result= DomFactory.eINSTANCE.createFunctionExpression(); |
| |
| //int modifiers= fVisibility; |
| /*Node enclosingBodyDeclaration= fAnalyzer.getEnclosingNode(); |
| while (enclosingBodyDeclaration != null && enclosingBodyDeclaration.eContainer() != fDestination) { |
| enclosingBodyDeclaration= (Node)enclosingBodyDeclaration.eContainer(); |
| } |
| if (enclosingBodyDeclaration instanceof BodyDeclaration) { // should always be the case |
| int enclosingModifiers= ((BodyDeclaration)enclosingBodyDeclaration).getModifiers(); |
| boolean shouldBeStatic= Modifier.isStatic(enclosingModifiers) || fAnalyzer.getForceStatic(); |
| if (shouldBeStatic) { |
| modifiers|= Modifier.STATIC; |
| } |
| } |
| |
| ITypeBinding[] typeVariables= computeLocalTypeVariables(); |
| List typeParameters= result.typeParameters(); |
| for (int i= 0; i < typeVariables.length; i++) { |
| TypeParameter parameter= fAST.newTypeParameter(); |
| parameter.setName(fAST.newSimpleName(typeVariables[i].getName())); |
| typeParameters.add(parameter); |
| } |
| |
| result.modifiers().addAll(ASTNodeFactory.newModifiers(fAST, modifiers)); |
| result.setReturnType2((Type)ASTNode.copySubtree(fAST, fAnalyzer.getReturnType()));*/ |
| if (fAnalyzer.getReturnTypeName() != null) { |
| // Type type = DomFactory.eINSTANCE.createType(); |
| // type.setName(fAnalyzer.getReturnTypeName()); |
| // result.setReturnType(type); |
| } |
| Identifier id = DomFactory.eINSTANCE.createIdentifier(); |
| id.setName(fMethodName); |
| result.setIdentifier(id); |
| |
| List<Parameter> parameters= result.getParameters(); |
| for (int i= 0; i < fParameterInfos.size(); i++) { |
| ParameterInfo info= (ParameterInfo)fParameterInfos.get(i); |
| Parameter parameter= DomFactory.eINSTANCE.createParameter(); |
| Identifier prmName = DomFactory.eINSTANCE.createIdentifier(); |
| prmName.setName(info.getNewName()); |
| parameter.setName(prmName); |
| if (!"".equals(info.getNewTypeName())) { //$NON-NLS-1 |
| // Type type = DomFactory.eINSTANCE.createType(); |
| // type.setName(info.getNewTypeName()); |
| // parameter.setType(type); |
| } |
| parameters.add(parameter); |
| } |
| |
| /*List exceptions= result.thrownExceptions(); |
| ITypeBinding[] exceptionTypes= fAnalyzer.getExceptions(fThrowRuntimeExceptions); |
| ImportRewriteContext context= new ContextSensitiveImportRewriteContext(enclosingBodyDeclaration, fImportRewriter); |
| for (int i= 0; i < exceptionTypes.length; i++) { |
| ITypeBinding exceptionType= exceptionTypes[i]; |
| exceptions.add(ASTNodeFactory.newName(fAST, fImportRewriter.addImport(exceptionType, context))); |
| }*/ |
| result.setBody(DomFactory.eINSTANCE.createBlockStatement()); |
| return result; |
| } |
| |
| /*private ITypeBinding[] computeLocalTypeVariables() { |
| List result= new ArrayList(Arrays.asList(fAnalyzer.getTypeVariables())); |
| for (int i= 0; i < fParameterInfos.size(); i++) { |
| ParameterInfo info= (ParameterInfo)fParameterInfos.get(i); |
| processVariable(result, info.getOldBinding()); |
| } |
| IVariableBinding[] methodLocals= fAnalyzer.getMethodLocals(); |
| for (int i= 0; i < methodLocals.length; i++) { |
| processVariable(result, methodLocals[i]); |
| } |
| return (ITypeBinding[])result.toArray(new ITypeBinding[result.size()]); |
| } |
| |
| private void processVariable(List result, IVariableBinding variable) { |
| if (variable == null) |
| return; |
| ITypeBinding binding= variable.getType(); |
| if (binding != null && binding.isParameterizedType()) { |
| ITypeBinding[] typeArgs= binding.getTypeArguments(); |
| for (int args= 0; args < typeArgs.length; args++) { |
| ITypeBinding arg= typeArgs[args]; |
| if (arg.isTypeVariable() && !result.contains(arg)) { |
| ASTNode decl= fRoot.findDeclaringNode(arg); |
| if (decl != null && decl.getParent() instanceof MethodDeclaration) { |
| result.add(arg); |
| } |
| } |
| } |
| } |
| }*/ |
| |
| /*private String getName(IVariableBinding binding) { |
| for (Iterator iter= fParameterInfos.iterator(); iter.hasNext();) { |
| ParameterInfo info= (ParameterInfo)iter.next(); |
| if (Bindings.equals(binding, info.getOldBinding())) { |
| return info.getNewName(); |
| } |
| } |
| return binding.getName(); |
| } |
| |
| private VariableDeclaration getVariableDeclaration(ParameterInfo parameter) { |
| return ASTNodes.findVariableDeclaration(parameter.getOldBinding(), fAnalyzer.getEnclosingBodyDeclaration()); |
| }*/ |
| |
| private VariableStatement createDeclaration(VariableBinding name, Expression initializer) { |
| Identifier id = DomFactory.eINSTANCE.createIdentifier(); |
| id.setName(name.getName()); |
| VariableDeclaration decl = DomFactory.eINSTANCE.createVariableDeclaration(); |
| decl.setIdentifier(id); |
| if (name.getTypeName() != null) { |
| // Type type = DomFactory.eINSTANCE.createType(); |
| // type.setName(name.getTypeName()); |
| } |
| if (initializer != null) |
| decl.setInitializer(initializer); |
| VariableStatement result = DomFactory.eINSTANCE.createVariableStatement(); |
| result.getDeclarations().add(decl); |
| return result; |
| } |
| |
| /*public ISourceModule getSource() { |
| return fCUnit; |
| } |
| |
| private RefactoringStatus initialize(ScriptRefactoringArguments arguments) { |
| final String selection= arguments.getAttribute(ScriptRefactoringDescriptorUtil.ATTRIBUTE_SELECTION); |
| if (selection == null) |
| return RefactoringStatus.createFatalErrorStatus(Messages.format(RefactoringCoreMessages.InitializableRefactoring_argument_not_exist, ScriptRefactoringDescriptorUtil.ATTRIBUTE_SELECTION)); |
| |
| int offset= -1; |
| int length= -1; |
| final StringTokenizer tokenizer= new StringTokenizer(selection); |
| if (tokenizer.hasMoreTokens()) |
| offset= Integer.valueOf(tokenizer.nextToken()).intValue(); |
| if (tokenizer.hasMoreTokens()) |
| length= Integer.valueOf(tokenizer.nextToken()).intValue(); |
| if (offset < 0 || length < 0) |
| return RefactoringStatus.createFatalErrorStatus(Messages.format(RefactoringCoreMessages.InitializableRefactoring_illegal_argument, new Object[] { selection, ScriptRefactoringDescriptorUtil.ATTRIBUTE_SELECTION})); |
| |
| fSelectionStart= offset; |
| fSelectionLength= length; |
| |
| final String handle= arguments.getAttribute(ScriptRefactoringDescriptorUtil.ATTRIBUTE_INPUT); |
| if (handle == null) |
| return RefactoringStatus.createFatalErrorStatus(Messages.format(RefactoringCoreMessages.InitializableRefactoring_argument_not_exist, ScriptRefactoringDescriptorUtil.ATTRIBUTE_INPUT)); |
| |
| IScriptElement element= ScriptRefactoringDescriptorUtil.handleToElement(arguments.getProject(), handle, false); |
| if (element == null || !element.exists() || element.getElementType() != IScriptElement.COMPILATION_UNIT) |
| return ScriptRefactoringDescriptorUtil.createInputFatalStatus(element, getName(), IScriptRefactorings.EXTRACT_METHOD); |
| |
| fCUnit= (ISourceModule) element; |
| final String visibility= arguments.getAttribute(ATTRIBUTE_VISIBILITY); |
| if (visibility != null && visibility.length() != 0) { |
| int flag= 0; |
| try { |
| flag= Integer.parseInt(visibility); |
| } catch (NumberFormatException exception) { |
| return RefactoringStatus.createFatalErrorStatus(Messages.format(RefactoringCoreMessages.InitializableRefactoring_argument_not_exist, ATTRIBUTE_VISIBILITY)); |
| } |
| fVisibility= flag; |
| } |
| final String name= arguments.getAttribute(ScriptRefactoringDescriptorUtil.ATTRIBUTE_NAME); |
| if (name == null || name.length() == 0) |
| return RefactoringStatus.createFatalErrorStatus(Messages.format(RefactoringCoreMessages.InitializableRefactoring_argument_not_exist, ScriptRefactoringDescriptorUtil.ATTRIBUTE_NAME)); |
| |
| fMethodName= name; |
| |
| final String destination= arguments.getAttribute(ATTRIBUTE_DESTINATION); |
| if (destination != null && destination.length() == 0) { |
| int index= 0; |
| try { |
| index= Integer.parseInt(destination); |
| } catch (NumberFormatException exception) { |
| return RefactoringStatus.createFatalErrorStatus(Messages.format(RefactoringCoreMessages.InitializableRefactoring_argument_not_exist, ATTRIBUTE_DESTINATION)); |
| } |
| fDestinationIndex= index; |
| } |
| final String replace= arguments.getAttribute(ATTRIBUTE_REPLACE); |
| if (replace == null) |
| return RefactoringStatus.createFatalErrorStatus(Messages.format(RefactoringCoreMessages.InitializableRefactoring_argument_not_exist, ATTRIBUTE_REPLACE)); |
| |
| fReplaceDuplicates= Boolean.valueOf(replace).booleanValue(); |
| |
| final String comments= arguments.getAttribute(ATTRIBUTE_COMMENTS); |
| if (comments == null) |
| return RefactoringStatus.createFatalErrorStatus(Messages.format(RefactoringCoreMessages.InitializableRefactoring_argument_not_exist, ATTRIBUTE_COMMENTS)); |
| |
| fGenerateScriptdoc= Boolean.valueOf(comments).booleanValue(); |
| |
| final String exceptions= arguments.getAttribute(ATTRIBUTE_EXCEPTIONS); |
| if (exceptions == null) |
| return RefactoringStatus.createFatalErrorStatus(Messages.format(RefactoringCoreMessages.InitializableRefactoring_argument_not_exist, ATTRIBUTE_EXCEPTIONS)); |
| |
| fThrowRuntimeExceptions= Boolean.valueOf(exceptions).booleanValue(); |
| |
| return new RefactoringStatus(); |
| }*/ |
| } |
