| /******************************************************************************* |
| * Copyright (c) 2000, 2010 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 |
| *******************************************************************************/ |
| package org.eclipse.dltk.internal.javascript.corext.refactoring.code; |
| |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| import org.eclipse.core.runtime.Assert; |
| 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.ModelException; |
| 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.JavascriptManipulationPlugin; |
| 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.RefactoringCoreMessages; |
| import org.eclipse.dltk.javascript.core.dom.BlockStatement; |
| 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.Identifier; |
| import org.eclipse.dltk.javascript.core.dom.Node; |
| 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.NodeFinder; |
| 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.ExtractLocalDescriptor; |
| import org.eclipse.dltk.javascript.parser.JavaScriptParserUtil; |
| import org.eclipse.emf.common.util.EList; |
| import org.eclipse.emf.common.util.TreeIterator; |
| import org.eclipse.emf.ecore.EAttribute; |
| import org.eclipse.emf.ecore.EClass; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.ecore.EReference; |
| import org.eclipse.emf.ecore.EStructuralFeature; |
| 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.text.edits.TextEdit; |
| import org.eclipse.text.edits.TextEditGroup; |
| |
| /** |
| * Extract Local Variable (from selected expression inside method or |
| * initializer). |
| */ |
| public class ExtractTempRefactoring extends Refactoring { |
| |
| //private static final String ATTRIBUTE_REPLACE = "replace"; //$NON-NLS-1$ |
| //private static final String ATTRIBUTE_FINAL = "final"; //$NON-NLS-1$ |
| |
| /*private static final class ForStatementChecker extends ASTVisitor { |
| |
| private final Collection fForInitializerVariables; |
| |
| private boolean fReferringToForVariable = false; |
| |
| public ForStatementChecker(Collection forInitializerVariables) { |
| Assert.isNotNull(forInitializerVariables); |
| fForInitializerVariables = forInitializerVariables; |
| } |
| |
| public boolean isReferringToForVariable() { |
| return fReferringToForVariable; |
| } |
| |
| public boolean visit(SimpleName node) { |
| IBinding binding = node.resolveBinding(); |
| if (binding != null && fForInitializerVariables.contains(binding)) { |
| fReferringToForVariable = true; |
| } |
| return false; |
| } |
| } |
| |
| private static boolean allArraysEqual(Object[][] arrays, int position) { |
| Object element = arrays[0][position]; |
| for (int i = 0; i < arrays.length; i++) { |
| Object[] array = arrays[i]; |
| if (!element.equals(array[position])) |
| return false; |
| } |
| return true; |
| } |
| |
| 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 static Object[] getArrayPrefix(Object[] array, int prefixLength) { |
| Assert.isTrue(prefixLength <= array.length); |
| Assert.isTrue(prefixLength >= 0); |
| Object[] prefix = new Object[prefixLength]; |
| for (int i = 0; i < prefix.length; i++) { |
| prefix[i] = array[i]; |
| } |
| return prefix; |
| } |
| |
| // return List<IVariableBinding> |
| private static List getForInitializedVariables( |
| VariableDeclarationExpression variableDeclarations) { |
| List forInitializerVariables = new ArrayList(1); |
| for (Iterator iter = variableDeclarations.fragments().iterator(); iter |
| .hasNext();) { |
| VariableDeclarationFragment fragment = (VariableDeclarationFragment) iter |
| .next(); |
| IVariableBinding binding = fragment.resolveBinding(); |
| if (binding != null) |
| forInitializerVariables.add(binding); |
| } |
| return forInitializerVariables; |
| } |
| |
| private static Object[] getLongestArrayPrefix(Object[][] arrays) { |
| int length = -1; |
| if (arrays.length == 0) |
| return new Object[0]; |
| int minArrayLength = arrays[0].length; |
| for (int i = 1; i < arrays.length; i++) |
| minArrayLength = Math.min(minArrayLength, arrays[i].length); |
| |
| for (int i = 0; i < minArrayLength; i++) { |
| if (!allArraysEqual(arrays, i)) |
| break; |
| length++; |
| } |
| if (length == -1) |
| return new Object[0]; |
| return getArrayPrefix(arrays[0], length + 1); |
| } |
| |
| private static ASTNode[] getParents(ASTNode node) { |
| ASTNode current = node; |
| List parents = new ArrayList(); |
| do { |
| parents.add(current.getParent()); |
| current = current.getParent(); |
| } while (current.getParent() != null); |
| Collections.reverse(parents); |
| return (ASTNode[]) parents.toArray(new ASTNode[parents.size()]); |
| } |
| |
| private static boolean isLeftValue(ASTNode node) { |
| ASTNode parent = node.getParent(); |
| if (parent instanceof Assignment) { |
| Assignment assignment = (Assignment) parent; |
| if (assignment.getLeftHandSide() == node) |
| return true; |
| } |
| if (parent instanceof PostfixExpression) |
| return true; |
| if (parent instanceof PrefixExpression) { |
| PrefixExpression.Operator op = ((PrefixExpression) parent) |
| .getOperator(); |
| if (op.equals(PrefixExpression.Operator.DECREMENT)) |
| return true; |
| if (op.equals(PrefixExpression.Operator.INCREMENT)) |
| return true; |
| return false; |
| } |
| return false; |
| } |
| |
| private static boolean isMethodParameter(ASTNode node) { |
| return (node instanceof SimpleName) |
| && (node.getParent() instanceof SingleVariableDeclaration) |
| && (node.getParent().getParent() instanceof MethodDeclaration); |
| }*/ |
| |
| /*private static boolean isThrowableInCatchBlock(ASTNode node) { |
| return (node instanceof SimpleName) |
| && (node.getParent() instanceof SingleVariableDeclaration) |
| && (node.getParent().getParent() instanceof CatchClause); |
| }*/ |
| |
| private static boolean isUsedInFor(Expression expression) { |
| EStructuralFeature sf = expression.eContainingFeature(); |
| if (sf == DomPackage.eINSTANCE.getForStatement_Initialization()) return true; |
| if (sf == DomPackage.eINSTANCE.getForStatement_Condition()) return true; |
| if (sf == DomPackage.eINSTANCE.getForStatement_Increment()) return true; |
| if (sf == DomPackage.eINSTANCE.getForInStatement_Item()) return true; |
| if (sf == DomPackage.eINSTANCE.getForEachInStatement_Item()) return true; |
| return false; |
| } |
| |
| /*private static IASTFragment[] retainOnlyReplacableMatches( |
| IASTFragment[] allMatches) { |
| List result = new ArrayList(allMatches.length); |
| for (int i = 0; i < allMatches.length; i++) { |
| if (canReplace(allMatches[i])) |
| result.add(allMatches[i]); |
| } |
| return (IASTFragment[]) result.toArray(new IASTFragment[result.size()]); |
| }*/ |
| |
| private Source fCompilationUnitNode; |
| |
| //private CompilationUnitRewrite fCURewrite; |
| |
| private ISourceModule fCu; |
| private String fSource; |
| |
| //private boolean fDeclareFinal; |
| |
| private String[] fExcludedVariableNames; |
| |
| private boolean fReplaceAllOccurrences; |
| |
| // caches: |
| private Expression fSelectedExpression; |
| |
| private int fSelectionLength; |
| |
| private int fSelectionStart; |
| |
| private String fTempName; |
| /*private String[] fGuessedTempNames; |
| |
| private boolean fCheckResultForCompileProblems;*/ |
| |
| private SourceModuleChange fChange; |
| |
| //private LinkedProposalModel fLinkedProposalModel; |
| |
| //private static final String KEY_NAME = "name"; //$NON-NLS-1$ |
| //private static final String KEY_TYPE = "type"; //$NON-NLS-1$ |
| |
| /** |
| * Creates a new extract temp refactoring |
| * |
| * @param unit |
| * the compilation unit, or <code>null</code> if invoked by |
| * scripting |
| * @param selectionStart |
| * start of selection |
| * @param selectionLength |
| * length of selection |
| */ |
| public ExtractTempRefactoring(ISourceModule unit, int selectionStart, |
| int selectionLength) { |
| Assert.isTrue(selectionStart >= 0); |
| Assert.isTrue(selectionLength >= 0); |
| fSelectionStart = selectionStart; |
| fSelectionLength = selectionLength; |
| fCu = unit; |
| fCompilationUnitNode = null; |
| |
| fReplaceAllOccurrences = true; // default |
| //fDeclareFinal = false; // default |
| fTempName = ""; //$NON-NLS-1$ |
| |
| //fLinkedProposalModel = null; |
| //fCheckResultForCompileProblems = true; |
| } |
| |
| /*public ExtractTempRefactoring(CompilationUnit astRoot, int selectionStart, |
| int selectionLength) { |
| Assert.isTrue(selectionStart >= 0); |
| Assert.isTrue(selectionLength >= 0); |
| Assert.isTrue(astRoot.getTypeRoot() instanceof ISourceModule); |
| |
| fSelectionStart = selectionStart; |
| fSelectionLength = selectionLength; |
| fCu = (ISourceModule) astRoot.getTypeRoot(); |
| fCompilationUnitNode = astRoot; |
| |
| fReplaceAllOccurrences = true; // default |
| fDeclareFinal = false; // default |
| fTempName = ""; //$NON-NLS-1$ |
| |
| fLinkedProposalModel = null; |
| fCheckResultForCompileProblems = true; |
| } |
| |
| public ExtractTempRefactoring(JavaRefactoringArguments arguments, |
| RefactoringStatus status) { |
| this((ISourceModule) null, 0, 0); |
| RefactoringStatus initializeStatus = initialize(arguments); |
| status.merge(initializeStatus); |
| } |
| |
| public void setCheckResultForCompileProblems( |
| boolean checkResultForCompileProblems) { |
| fCheckResultForCompileProblems = checkResultForCompileProblems; |
| } |
| |
| public void setLinkedProposalModel(LinkedProposalModel linkedProposalModel) { |
| fLinkedProposalModel = linkedProposalModel; |
| } |
| |
| private void addReplaceExpressionWithTemp() throws JavaModelException { |
| IASTFragment[] fragmentsToReplace = retainOnlyReplacableMatches(getMatchingFragments()); |
| // TODO: should not have to prune duplicates here... |
| ASTRewrite rewrite = fCURewrite.getASTRewrite(); |
| HashSet seen = new HashSet(); |
| for (int i = 0; i < fragmentsToReplace.length; i++) { |
| IASTFragment fragment = fragmentsToReplace[i]; |
| if (!seen.add(fragment)) |
| continue; |
| SimpleName tempName = fCURewrite.getAST().newSimpleName(fTempName); |
| TextEditGroup description = fCURewrite |
| .createGroupDescription(RefactoringCoreMessages.ExtractTempRefactoring_replace); |
| |
| fragment.replace(rewrite, tempName, description); |
| if (fLinkedProposalModel != null) |
| fLinkedProposalModel.getPositionGroup(KEY_NAME, true) |
| .addPosition(rewrite.track(tempName), false); |
| } |
| }*/ |
| |
| // !! Same as in ExtractConstantRefactoring |
| /*private RefactoringStatus checkExpressionFragmentIsRValue() throws ModelException { |
| switch (Checks.checkExpressionIsRValue(getSelectedExpression() |
| .getAssociatedExpression())) { |
| case Checks.NOT_RVALUE_MISC: |
| return RefactoringStatus |
| .createStatus( |
| RefactoringStatus.FATAL, |
| RefactoringCoreMessages.ExtractTempRefactoring_select_expression, |
| null, Corext.getPluginId(), |
| RefactoringStatusCodes.EXPRESSION_NOT_RVALUE, null); |
| case Checks.NOT_RVALUE_VOID: |
| return RefactoringStatus.createStatus(RefactoringStatus.FATAL, |
| RefactoringCoreMessages.ExtractTempRefactoring_no_void, |
| null, Corext.getPluginId(), |
| RefactoringStatusCodes.EXPRESSION_NOT_RVALUE_VOID, null); |
| case Checks.IS_RVALUE_GUESSED: |
| case Checks.IS_RVALUE: |
| return new RefactoringStatus(); |
| default: |
| Assert.isTrue(false); |
| return null; |
| } |
| }*/ |
| |
| /*private ITypeBinding guessBindingForReference(Expression expression) { |
| ITypeBinding binding = expression.resolveTypeBinding(); |
| if (binding == null) { |
| binding = ASTResolving.guessBindingForReference(expression); |
| } |
| return binding; |
| }*/ |
| |
| public RefactoringStatus checkFinalConditions(IProgressMonitor pm) |
| throws CoreException { |
| try { |
| pm.beginTask( |
| RefactoringCoreMessages.ExtractTempRefactoring_checking_preconditions, |
| 4); |
| ChangeRecorder cr = new ChangeRecorder(fCompilationUnitNode); |
| // Expression |
| Expression selected = getSelectedExpression(); |
| Expression[] expressions; |
| if (fReplaceAllOccurrences) { |
| expressions = findSimilarExpressions(selected); |
| } else { |
| expressions = new Expression[]{ selected }; |
| } |
| // Statement |
| Statement stmt = findFirstStatement(expressions[0],expressions[expressions.length-1]); |
| EReference stmtRef = stmt.eContainmentFeature(); |
| // Expression -> Reference |
| for(Expression expr : expressions) { |
| Identifier refId = DomFactory.eINSTANCE.createIdentifier(); |
| refId.setName(fTempName); |
| VariableReference varRef = DomFactory.eINSTANCE.createVariableReference(); |
| varRef.setVariable(refId); |
| EReference exprRef = expr.eContainmentFeature(); |
| if (exprRef.isMany()) { |
| EList<Expression> exprList = (EList<Expression>)expr.eContainer().eGet(exprRef); |
| exprList.set(exprList.lastIndexOf(expr), varRef); |
| } else { |
| expr.eContainer().eSet(exprRef, varRef); |
| } |
| } |
| // Declaration |
| Identifier declId = DomFactory.eINSTANCE.createIdentifier(); |
| declId.setName(fTempName); |
| VariableDeclaration decl = DomFactory.eINSTANCE.createVariableDeclaration(); |
| decl.setIdentifier(declId); |
| decl.setInitializer(selected); |
| VariableStatement varStmt = DomFactory.eINSTANCE.createVariableStatement(); |
| varStmt.getDeclarations().add(decl); |
| // << Declaration |
| if (stmtRef.isMany()) { |
| EList<Statement> stmtList = (EList<Statement>)stmt.eContainer().eGet(stmtRef); |
| stmtList.add(stmtList.lastIndexOf(stmt), varStmt); |
| } else { |
| BlockStatement block = DomFactory.eINSTANCE.createBlockStatement(); |
| block.getStatements().add(varStmt); |
| stmt.eContainer().eSet(stmtRef, block); |
| block.getStatements().add(stmt); |
| } |
| ChangeDescription cd = cr.endRecording(); |
| final SourceModuleChange change = new SourceModuleChange(RefactoringCoreMessages.ExtractTempRefactoring_name, fCu); |
| final TextEditGroup addDecl = new TextEditGroup(RefactoringCoreMessages.ExtractTempRefactoring_declare_local_variable); |
| RewriteAnalyzer ra = new RewriteAnalyzer(cd, fCu.getSource()) { |
| @Override |
| protected void addEdit(TextEdit edit, Node node) { |
| if (node instanceof VariableReference) |
| change.addTextEditGroup(new TextEditGroup(RefactoringCoreMessages.ExtractTempRefactoring_replace, edit)); |
| else |
| addDecl.addTextEdit(edit); |
| super.addEdit(edit, node); |
| } |
| }; |
| change.setEdit(ra.getEdit()); |
| ra.rewrite(fCompilationUnitNode); |
| change.addTextEditGroup(addDecl); |
| cd.apply(); |
| fChange = change; |
| return new RefactoringStatus(); |
| } finally { |
| pm.done(); |
| } |
| } |
| |
| private static Expression[] findSimilarExpressions(Expression expr) { |
| List<Expression> res = new ArrayList<Expression>(); |
| Node root = (Node)expr.eContainer(); |
| while (true) { |
| int cl = root.eClass().getClassifierID(); |
| if (cl == DomPackage.GETTER_ASSIGNMENT |
| || cl == DomPackage.SETTER_ASSIGNMENT |
| || cl == DomPackage.FUNCTION_EXPRESSION |
| || cl == DomPackage.SOURCE) break; |
| root = (Node)root.eContainer(); |
| } |
| Set<Identifier> set = new HashSet<Identifier>(); |
| set.addAll(VariableLookup.findReferences(root, VariableLookup.getVisibleNames(expr))); |
| TreeIterator<EObject> it = root.eAllContents(); |
| while(it.hasNext()) { |
| Node cur = (Node)it.next(); |
| if (match(expr,cur,set)) { |
| res.add((Expression)cur); |
| it.prune(); |
| } |
| } |
| return res.toArray(new Expression[res.size()]); |
| } |
| |
| private static boolean match(Node one, Node another, Set<Identifier> resolved) { |
| if (one == null) |
| return another == null; |
| EClass cl = one.eClass(); |
| if (cl != another.eClass()) { |
| return false; |
| } |
| if (resolved.contains(one) != resolved.contains(another)) |
| return false; |
| for(EAttribute attr : cl.getEAllAttributes()) { |
| if (attr.getFeatureID() == DomPackage.NODE__BEGIN |
| || attr.getFeatureID() == DomPackage.NODE__END |
| || attr == DomPackage.eINSTANCE.getBinaryExpression_OperatorPosition() |
| || attr == DomPackage.eINSTANCE.getFunctionExpression_ParametersPosition()) continue; |
| if (!one.eGet(attr).equals(another.eGet(attr))) |
| return false; |
| } |
| for(EReference ref : cl.getEAllReferences()) { |
| if (ref.isMany()) { |
| List<? extends Node> first = (List<? extends Node>)one.eGet(ref); |
| List<? extends Node> second = (List<? extends Node>)another.eGet(ref); |
| if (first.size() != second.size()) |
| return false; |
| for(int i=0;i<first.size();i++) |
| if (!match(first.get(i),second.get(i),resolved)) |
| return false; |
| } else |
| if (!match((Node)one.eGet(ref),(Node)another.eGet(ref),resolved)) |
| return false; |
| } |
| return true; |
| } |
| |
| private static Statement findFirstStatement(EObject first,EObject last) { |
| int x = getDepth(first); |
| int y = getDepth(last); |
| while (x>y) { |
| x--; |
| first = first.eContainer(); |
| } |
| while (y>x) { |
| y--; |
| last = last.eContainer(); |
| } |
| while (first.eContainer() != last.eContainer()) { |
| first = first.eContainer(); |
| last = last.eContainer(); |
| } |
| while (first.eContainmentFeature().getEReferenceType() != DomPackage.eINSTANCE.getStatement()) |
| first = first.eContainer(); |
| return (Statement)first; |
| } |
| |
| private static int getDepth(EObject node) { |
| int i=0; |
| while (node != null) { |
| i++; |
| node = node.eContainer(); |
| } |
| return i; |
| } |
| |
| private ExtractLocalDescriptor createRefactoringDescriptor() { |
| String project = null; |
| IScriptProject scriptProject = fCu.getScriptProject(); |
| if (scriptProject != null) |
| project = scriptProject.getElementName(); |
| //final String description = Messages.format(RefactoringCoreMessages.ExtractTempRefactoring_descriptor_description_short, |
| // BasicElementLabels.getModelElementName(fTempName)); |
| final String description = Messages.format(RefactoringCoreMessages.ExtractTempRefactoring_descriptor_description_short,fTempName); |
| //final String expression = ASTNodes.asString(fSelectedExpression.getAssociatedExpression()); |
| //final String header = Messages |
| // .format(RefactoringCoreMessages.ExtractTempRefactoring_descriptor_description, |
| // new String[] { |
| // BasicElementLabels |
| // .getJavaElementName(fTempName), |
| // BasicElementLabels |
| // .getJavaCodeString(expression) }); |
| //final ScriptRefactoringDescriptorComment comment = new JDTRefactoringDescriptorComment( |
| // project, this, header); |
| //comment.addSetting(Messages.format( |
| // RefactoringCoreMessages.ExtractTempRefactoring_name_pattern, |
| // BasicElementLabels.getJavaElementName(fTempName))); |
| //final BodyDeclaration decl = (BodyDeclaration) ASTNodes.getParent( |
| // fSelectedExpression.getAssociatedExpression(), |
| // BodyDeclaration.class); |
| //if (decl instanceof MethodDeclaration) { |
| // final IMethodBinding method = ((MethodDeclaration) decl) |
| // .resolveBinding(); |
| // final String label = method != null ? BindingLabelProvider |
| // .getBindingLabel(method, |
| // JavaElementLabels.ALL_FULLY_QUALIFIED) |
| // : BasicElementLabels |
| // .getJavaElementName('{' + JavaElementLabels.ELLIPSIS_STRING + '}'); |
| // comment.addSetting(Messages |
| // .format(RefactoringCoreMessages.ExtractTempRefactoring_destination_pattern, |
| // label)); |
| //} |
| //comment.addSetting(Messages |
| // .format(RefactoringCoreMessages.ExtractTempRefactoring_expression_pattern, |
| // BasicElementLabels.getJavaCodeString(expression))); |
| //if (fReplaceAllOccurrences) |
| // comment.addSetting(RefactoringCoreMessages.ExtractTempRefactoring_replace_occurrences); |
| //if (fDeclareFinal) |
| // comment.addSetting(RefactoringCoreMessages.ExtractTempRefactoring_declare_final); |
| final Map arguments = new HashMap(); |
| arguments.put(ScriptRefactoringDescriptor.ATTRIBUTE_INPUT, |
| ScriptRefactoringDescriptor.elementToHandle(project, fCu)); |
| arguments.put(ScriptRefactoringDescriptor.ATTRIBUTE_NAME, fTempName); |
| arguments.put(ScriptRefactoringDescriptor.ATTRIBUTE_SELECTION, |
| new Integer(fSelectionStart).toString() |
| + " " + new Integer(fSelectionLength).toString()); //$NON-NLS-1$ |
| //arguments.put(ATTRIBUTE_REPLACE, Boolean |
| // .valueOf(fReplaceAllOccurrences).toString()); |
| //arguments.put(ATTRIBUTE_FINAL, Boolean.valueOf(fDeclareFinal) |
| // .toString()); |
| final ExtractLocalDescriptor descriptor = new ExtractLocalDescriptor(project, description, /*comment.asString()*/ "", arguments, RefactoringDescriptor.NONE); |
| return descriptor; |
| } |
| |
| /*private void doCreateChange(IProgressMonitor pm) throws CoreException { |
| try { |
| pm.beginTask( |
| RefactoringCoreMessages.ExtractTempRefactoring_checking_preconditions, |
| 1); |
| try { |
| createTempDeclaration(); |
| } catch (CoreException exception) { |
| JavaPlugin.log(exception); |
| } |
| addReplaceExpressionWithTemp(); |
| } finally { |
| pm.done(); |
| } |
| } |
| |
| private void checkNewSource(SubProgressMonitor monitor, |
| RefactoringStatus result) throws CoreException { |
| String newCuSource = fChange |
| .getPreviewContent(new NullProgressMonitor()); |
| CompilationUnit newCUNode = new RefactoringASTParser(AST.JLS3).parse( |
| newCuSource, fCu, true, true, monitor); |
| IProblem[] newProblems = RefactoringAnalyzeUtil |
| .getIntroducedCompileProblems(newCUNode, fCompilationUnitNode); |
| for (int i = 0; i < newProblems.length; i++) { |
| IProblem problem = newProblems[i]; |
| if (problem.isError()) |
| result.addEntry(new RefactoringStatusEntry( |
| (problem.isError() ? RefactoringStatus.ERROR |
| : RefactoringStatus.WARNING), problem |
| .getMessage(), |
| new JavaStringStatusContext(newCuSource, |
| SourceRangeFactory.create(problem)))); |
| } |
| }*/ |
| |
| public RefactoringStatus checkInitialConditions(IProgressMonitor pm) |
| throws CoreException { |
| try { |
| pm.beginTask("", 6); //$NON-NLS-1$ |
| |
| RefactoringStatus result = RefactoringChecks.validateModifiesFiles( |
| ResourceUtil.getFiles(new ISourceModule[] { fCu }), |
| getValidationContext()); |
| if (result.hasFatalError()) |
| return result; |
| |
| if (fCompilationUnitNode == null) { |
| fCompilationUnitNode = (Source)ASTConverter.convert(JavaScriptParserUtil.parse(fCu)); |
| } |
| pm.worked(3); |
| |
| fSource = fCu.getSource(); |
| result.merge(checkSelection(new SubProgressMonitor(pm, 3))); |
| //if (!result.hasFatalError() && isLiteralNodeSelected()) |
| // fReplaceAllOccurrences = false; |
| return result; |
| |
| } finally { |
| pm.done(); |
| } |
| } |
| |
| /*private RefactoringStatus checkMatchingFragments() |
| throws JavaModelException { |
| RefactoringStatus result = new RefactoringStatus(); |
| IASTFragment[] matchingFragments = getMatchingFragments(); |
| for (int i = 0; i < matchingFragments.length; i++) { |
| ASTNode node = matchingFragments[i].getAssociatedNode(); |
| if (isLeftValue(node) |
| && !isReferringToLocalVariableFromFor((Expression) node)) { |
| String msg = RefactoringCoreMessages.ExtractTempRefactoring_assigned_to; |
| result.addWarning(msg, JavaStatusContext.create(fCu, node)); |
| } |
| } |
| return result; |
| }*/ |
| |
| private RefactoringStatus checkSelection(IProgressMonitor pm) throws ModelException { |
| try { |
| pm.beginTask("", 2); //$NON-NLS-1$ |
| |
| Expression selectedExpression = getSelectedExpression(); |
| |
| if (selectedExpression == null) { |
| String message = RefactoringCoreMessages.ExtractTempRefactoring_select_expression; |
| //return CodeRefactoringUtil.checkMethodSyntaxErrors( |
| // fSelectionStart, fSelectionLength, |
| // fCompilationUnitNode, message); |
| return RefactoringStatus.createFatalErrorStatus(message); |
| } |
| pm.worked(1); |
| |
| if (isUsedInFor(getSelectedExpression())) |
| return RefactoringStatus |
| .createFatalErrorStatus(RefactoringCoreMessages.ExtractTempRefactoring_for_initializer_updater); |
| pm.worked(1); |
| |
| return new RefactoringStatus(); |
| } finally { |
| pm.done(); |
| } |
| } |
| |
| public RefactoringStatus checkTempName(String newName) { |
| RefactoringStatus status = Checks.validateIdentifier(newName); |
| if (status.hasFatalError()) |
| return status; |
| if (Arrays.asList(getExcludedVariableNames()).contains(newName)) |
| status.addWarning(Messages |
| .format(RefactoringCoreMessages.ExtractTempRefactoring_another_variable, |
| newName /*BasicElementLabels.getJavaElementName(newName)*/)); |
| return status; |
| } |
| |
| /*private void createAndInsertTempDeclaration() throws CoreException { |
| Expression initializer = getSelectedExpression().createCopyTarget( |
| fCURewrite.getASTRewrite(), true); |
| VariableDeclarationStatement vds = createTempDeclaration(initializer); |
| |
| if ((!fReplaceAllOccurrences) |
| || (retainOnlyReplacableMatches(getMatchingFragments()).length <= 1)) { |
| insertAt(getSelectedExpression().getAssociatedNode(), vds); |
| return; |
| } |
| |
| ASTNode[] firstReplaceNodeParents = getParents(getFirstReplacedExpression() |
| .getAssociatedNode()); |
| ASTNode[] commonPath = findDeepestCommonSuperNodePathForReplacedNodes(); |
| Assert.isTrue(commonPath.length <= firstReplaceNodeParents.length); |
| |
| ASTNode deepestCommonParent = firstReplaceNodeParents[commonPath.length - 1]; |
| if (deepestCommonParent instanceof Block) |
| insertAt(firstReplaceNodeParents[commonPath.length], vds); |
| else |
| insertAt(deepestCommonParent, vds); |
| } |
| |
| private VariableDeclarationStatement createTempDeclaration( |
| Expression initializer) throws CoreException { |
| AST ast = fCURewrite.getAST(); |
| |
| VariableDeclarationFragment vdf = ast.newVariableDeclarationFragment(); |
| vdf.setName(ast.newSimpleName(fTempName)); |
| vdf.setInitializer(initializer); |
| |
| VariableDeclarationStatement vds = ast |
| .newVariableDeclarationStatement(vdf); |
| if (fDeclareFinal) { |
| vds.modifiers().add(ast.newModifier(ModifierKeyword.FINAL_KEYWORD)); |
| } |
| vds.setType(createTempType()); |
| |
| if (fLinkedProposalModel != null) { |
| ASTRewrite rewrite = fCURewrite.getASTRewrite(); |
| LinkedProposalPositionGroup nameGroup = fLinkedProposalModel |
| .getPositionGroup(KEY_NAME, true); |
| nameGroup.addPosition(rewrite.track(vdf.getName()), true); |
| |
| String[] nameSuggestions = guessTempNames(); |
| if (nameSuggestions.length > 0 |
| && !nameSuggestions[0].equals(fTempName)) { |
| nameGroup.addProposal(fTempName, null, |
| nameSuggestions.length + 1); |
| } |
| for (int i = 0; i < nameSuggestions.length; i++) { |
| nameGroup.addProposal(nameSuggestions[i], null, |
| nameSuggestions.length - i); |
| } |
| } |
| return vds; |
| } |
| |
| private void insertAt(ASTNode target, Statement declaration) { |
| ASTRewrite rewrite = fCURewrite.getASTRewrite(); |
| TextEditGroup groupDescription = fCURewrite |
| .createGroupDescription(RefactoringCoreMessages.ExtractTempRefactoring_declare_local_variable); |
| |
| ASTNode parent = target.getParent(); |
| StructuralPropertyDescriptor locationInParent = target |
| .getLocationInParent(); |
| while (locationInParent != Block.STATEMENTS_PROPERTY |
| && locationInParent != SwitchStatement.STATEMENTS_PROPERTY) { |
| if (locationInParent == IfStatement.THEN_STATEMENT_PROPERTY |
| || locationInParent == IfStatement.ELSE_STATEMENT_PROPERTY |
| || locationInParent == ForStatement.BODY_PROPERTY |
| || locationInParent == EnhancedForStatement.BODY_PROPERTY |
| || locationInParent == DoStatement.BODY_PROPERTY |
| || locationInParent == WhileStatement.BODY_PROPERTY) { |
| // create intermediate block if target was the body property of |
| // a control statement: |
| Block replacement = rewrite.getAST().newBlock(); |
| ListRewrite replacementRewrite = rewrite.getListRewrite( |
| replacement, Block.STATEMENTS_PROPERTY); |
| replacementRewrite.insertFirst(declaration, null); |
| replacementRewrite.insertLast(rewrite.createMoveTarget(target), |
| null); |
| rewrite.replace(target, replacement, groupDescription); |
| return; |
| } |
| target = parent; |
| parent = parent.getParent(); |
| locationInParent = target.getLocationInParent(); |
| } |
| ListRewrite listRewrite = rewrite.getListRewrite(parent, |
| (ChildListPropertyDescriptor) locationInParent); |
| listRewrite.insertBefore(declaration, target, groupDescription); |
| }*/ |
| |
| public Change createChange(IProgressMonitor pm) throws CoreException { |
| try { |
| pm.beginTask( |
| RefactoringCoreMessages.ExtractTempRefactoring_checking_preconditions, |
| 1); |
| |
| ExtractLocalDescriptor descriptor = createRefactoringDescriptor(); |
| fChange.setDescriptor(new RefactoringChangeDescriptor(descriptor)); |
| return fChange; |
| } finally { |
| pm.done(); |
| } |
| } |
| |
| private String[] getExcludedVariableNames() { |
| if (fExcludedVariableNames == null) { |
| try { |
| //ScopeLookup look = new ScopeLookup(); |
| //look.findNamesInScope(getSelectedExpression()); |
| Set<String> visible = VariableLookup.getVisibleNames(getSelectedExpression()); |
| fExcludedVariableNames = visible.toArray(new String[visible.size()]); |
| } catch (ModelException e) { |
| JavascriptManipulationPlugin.log(e); //who cares, but still |
| fExcludedVariableNames = new String[0]; |
| } |
| } |
| return fExcludedVariableNames; |
| } |
| |
| /*private IExpressionFragment getFirstReplacedExpression() |
| throws JavaModelException { |
| if (!fReplaceAllOccurrences) |
| return getSelectedExpression(); |
| IASTFragment[] nodesToReplace = retainOnlyReplacableMatches(getMatchingFragments()); |
| if (nodesToReplace.length == 0) |
| return getSelectedExpression(); |
| Comparator comparator = new Comparator() { |
| |
| public int compare(Object o1, Object o2) { |
| return ((IASTFragment) o1).getStartPosition() |
| - ((IASTFragment) o2).getStartPosition(); |
| } |
| }; |
| Arrays.sort(nodesToReplace, comparator); |
| return (IExpressionFragment) nodesToReplace[0]; |
| } |
| |
| private IASTFragment[] getMatchingFragments() throws JavaModelException { |
| if (fReplaceAllOccurrences) { |
| IASTFragment[] allMatches = ASTFragmentFactory |
| .createFragmentForFullSubtree(getEnclosingBodyNode()) |
| .getSubFragmentsMatching(getSelectedExpression()); |
| return allMatches; |
| } else |
| return new IASTFragment[] { getSelectedExpression() }; |
| } |
| |
| private ASTNode[] getMatchNodes() throws JavaModelException { |
| IASTFragment[] matches = retainOnlyReplacableMatches(getMatchingFragments()); |
| ASTNode[] result = new ASTNode[matches.length]; |
| for (int i = 0; i < matches.length; i++) |
| result[i] = matches[i].getAssociatedNode(); |
| return result; |
| }*/ |
| |
| public String getName() { |
| return RefactoringCoreMessages.ExtractTempRefactoring_name; |
| } |
| |
| private Expression getSelectedExpression() throws ModelException { |
| if (fSelectedExpression != null) |
| return fSelectedExpression; |
| Node node = NodeFinder.findNode(fCompilationUnitNode, fSelectionStart, fSelectionStart+fSelectionLength); |
| if (node == null) return null; |
| for(int i=fSelectionStart;i<node.getBegin();i++) |
| if (!Character.isWhitespace(fSource.charAt(i))) return null; |
| for(int i=node.getEnd();i<fSelectionStart+fSelectionLength;i++) |
| if (!Character.isWhitespace(fSource.charAt(i))) return null; |
| if (node instanceof ExpressionStatement) |
| return fSelectedExpression = ((ExpressionStatement)node).getExpression(); |
| if (node instanceof Expression) |
| return fSelectedExpression = (Expression)node; |
| return null; |
| /*IASTFragment selectedFragment = ASTFragmentFactory |
| .createFragmentForSourceRange(new SourceRange(fSelectionStart, |
| fSelectionLength), fCompilationUnitNode, fCu); |
| |
| if (selectedFragment instanceof IExpressionFragment |
| && !Checks |
| .isInsideJavadoc(selectedFragment.getAssociatedNode())) { |
| fSelectedExpression = (IExpressionFragment) selectedFragment; |
| } else if (selectedFragment != null) { |
| if (selectedFragment.getAssociatedNode() instanceof ExpressionStatement) { |
| ExpressionStatement exprStatement = (ExpressionStatement) selectedFragment |
| .getAssociatedNode(); |
| Expression expression = exprStatement.getExpression(); |
| fSelectedExpression = (IExpressionFragment) ASTFragmentFactory |
| .createFragmentForFullSubtree(expression); |
| } else if (selectedFragment.getAssociatedNode() instanceof Assignment) { |
| Assignment assignment = (Assignment) selectedFragment |
| .getAssociatedNode(); |
| fSelectedExpression = (IExpressionFragment) ASTFragmentFactory |
| .createFragmentForFullSubtree(assignment); |
| } |
| } |
| |
| if (fSelectedExpression != null |
| && Checks.isEnumCase(fSelectedExpression |
| .getAssociatedExpression().getParent())) { |
| fSelectedExpression = null; |
| } |
| |
| return fSelectedExpression;*/ |
| } |
| |
| /*private Type createTempType() throws CoreException { |
| Expression expression = getSelectedExpression() |
| .getAssociatedExpression(); |
| |
| Type resultingType = null; |
| ITypeBinding typeBinding = expression.resolveTypeBinding(); |
| |
| ASTRewrite rewrite = fCURewrite.getASTRewrite(); |
| AST ast = rewrite.getAST(); |
| |
| if (expression instanceof ClassInstanceCreation) { |
| resultingType = (Type) rewrite |
| .createCopyTarget(((ClassInstanceCreation) expression) |
| .getType()); |
| } else if (expression instanceof CastExpression) { |
| resultingType = (Type) rewrite |
| .createCopyTarget(((CastExpression) expression).getType()); |
| } else { |
| if (typeBinding == null) { |
| typeBinding = ASTResolving.guessBindingForReference(expression); |
| } |
| if (typeBinding != null) { |
| typeBinding = Bindings.normalizeForDeclarationUse(typeBinding, |
| ast); |
| ImportRewrite importRewrite = fCURewrite.getImportRewrite(); |
| ImportRewriteContext context = new ContextSensitiveImportRewriteContext( |
| expression, importRewrite); |
| resultingType = importRewrite.addImport(typeBinding, ast, |
| context); |
| } else { |
| resultingType = ast.newSimpleType(ast.newSimpleName("Object")); //$NON-NLS-1$ |
| } |
| } |
| if (fLinkedProposalModel != null) { |
| LinkedProposalPositionGroup typeGroup = fLinkedProposalModel |
| .getPositionGroup(KEY_TYPE, true); |
| typeGroup.addPosition(rewrite.track(resultingType), false); |
| if (typeBinding != null) { |
| ITypeBinding[] relaxingTypes = ASTResolving.getNarrowingTypes( |
| ast, typeBinding); |
| for (int i = 0; i < relaxingTypes.length; i++) { |
| typeGroup.addProposal(relaxingTypes[i], fCURewrite.getCu(), |
| relaxingTypes.length - i); |
| } |
| } |
| } |
| return resultingType; |
| } |
| |
| public String guessTempName() { |
| String[] proposals = guessTempNames(); |
| if (proposals.length == 0) |
| return fTempName; |
| else |
| return proposals[0]; |
| }*/ |
| |
| /** |
| * @return proposed variable names (may be empty, but not null). The first |
| * proposal should be used as "best guess" (if it exists). |
| */ |
| /*public String[] guessTempNames() { |
| if (fGuessedTempNames == null) { |
| try { |
| Expression expression = getSelectedExpression() |
| .getAssociatedExpression(); |
| if (expression != null) { |
| ITypeBinding binding = guessBindingForReference(expression); |
| fGuessedTempNames = StubUtility.getVariableNameSuggestions( |
| NamingConventions.VK_LOCAL, fCu.getJavaProject(), |
| binding, expression, |
| Arrays.asList(getExcludedVariableNames())); |
| } |
| } catch (JavaModelException e) { |
| } |
| if (fGuessedTempNames == null) |
| fGuessedTempNames = new String[0]; |
| } |
| return fGuessedTempNames; |
| } |
| |
| private boolean isLiteralNodeSelected() throws JavaModelException { |
| IExpressionFragment fragment = getSelectedExpression(); |
| if (fragment == null) |
| return false; |
| Expression expression = fragment.getAssociatedExpression(); |
| if (expression == null) |
| return false; |
| switch (expression.getNodeType()) { |
| case ASTNode.BOOLEAN_LITERAL: |
| case ASTNode.CHARACTER_LITERAL: |
| case ASTNode.NULL_LITERAL: |
| case ASTNode.NUMBER_LITERAL: |
| return true; |
| |
| default: |
| return false; |
| } |
| } |
| |
| private boolean isUsedInExplicitConstructorCall() throws JavaModelException { |
| Expression selectedExpression = getSelectedExpression() |
| .getAssociatedExpression(); |
| if (ASTNodes.getParent(selectedExpression, ConstructorInvocation.class) != null) |
| return true; |
| if (ASTNodes.getParent(selectedExpression, |
| SuperConstructorInvocation.class) != null) |
| return true; |
| return false; |
| }*/ |
| |
| public boolean replaceAllOccurrences() { |
| return fReplaceAllOccurrences; |
| } |
| |
| /*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)); |
| } |
| |
| public void setDeclareFinal(boolean declareFinal) { |
| fDeclareFinal = declareFinal; |
| }*/ |
| |
| public void setReplaceAllOccurrences(boolean replaceAllOccurrences) { |
| fReplaceAllOccurrences = replaceAllOccurrences; |
| } |
| |
| public void setTempName(String newName) { |
| fTempName = newName; |
| } |
| |
| /*private boolean shouldReplaceSelectedExpressionWithTempDeclaration() |
| throws JavaModelException { |
| IExpressionFragment selectedFragment = getSelectedExpression(); |
| return selectedFragment.getAssociatedNode().getParent() instanceof ExpressionStatement |
| && selectedFragment.matches(ASTFragmentFactory |
| .createFragmentForFullSubtree(selectedFragment |
| .getAssociatedNode())); |
| } |
| |
| private RefactoringStatus initialize(RefactoringArguments arguments) { |
| final String selection = arguments |
| .getAttribute(JavaRefactoringDescriptorUtil.ATTRIBUTE_SELECTION); |
| if (selection != null) { |
| 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) { |
| fSelectionStart = offset; |
| fSelectionLength = length; |
| } else |
| return RefactoringStatus |
| .createFatalErrorStatus(Messages |
| .format(RefactoringCoreMessages.InitializableRefactoring_illegal_argument, |
| new Object[] { |
| selection, |
| JavaRefactoringDescriptorUtil.ATTRIBUTE_SELECTION })); |
| } else |
| return RefactoringStatus |
| .createFatalErrorStatus(Messages |
| .format(RefactoringCoreMessages.InitializableRefactoring_argument_not_exist, |
| JavaRefactoringDescriptorUtil.ATTRIBUTE_SELECTION)); |
| final String handle = arguments |
| .getAttribute(JavaRefactoringDescriptorUtil.ATTRIBUTE_INPUT); |
| if (handle != null) { |
| final IJavaElement element = JavaRefactoringDescriptorUtil |
| .handleToElement(arguments.getProject(), handle, false); |
| if (element == null |
| || !element.exists() |
| || element.getElementType() != IJavaElement.COMPILATION_UNIT) |
| return JavaRefactoringDescriptorUtil.createInputFatalStatus( |
| element, getName(), |
| IJavaRefactorings.EXTRACT_LOCAL_VARIABLE); |
| else |
| fCu = (ISourceModule) element; |
| } else |
| return RefactoringStatus |
| .createFatalErrorStatus(Messages |
| .format(RefactoringCoreMessages.InitializableRefactoring_argument_not_exist, |
| JavaRefactoringDescriptorUtil.ATTRIBUTE_INPUT)); |
| final String name = arguments |
| .getAttribute(JavaRefactoringDescriptorUtil.ATTRIBUTE_NAME); |
| if (name != null && !"".equals(name)) //$NON-NLS-1$ |
| fTempName = name; |
| else |
| return RefactoringStatus |
| .createFatalErrorStatus(Messages |
| .format(RefactoringCoreMessages.InitializableRefactoring_argument_not_exist, |
| JavaRefactoringDescriptorUtil.ATTRIBUTE_NAME)); |
| final String replace = arguments.getAttribute(ATTRIBUTE_REPLACE); |
| if (replace != null) { |
| fReplaceAllOccurrences = Boolean.valueOf(replace).booleanValue(); |
| } else |
| return RefactoringStatus |
| .createFatalErrorStatus(Messages |
| .format(RefactoringCoreMessages.InitializableRefactoring_argument_not_exist, |
| ATTRIBUTE_REPLACE)); |
| final String declareFinal = arguments.getAttribute(ATTRIBUTE_FINAL); |
| if (declareFinal != null) { |
| fDeclareFinal = Boolean.valueOf(declareFinal).booleanValue(); |
| } else |
| return RefactoringStatus |
| .createFatalErrorStatus(Messages |
| .format(RefactoringCoreMessages.InitializableRefactoring_argument_not_exist, |
| ATTRIBUTE_FINAL)); |
| return new RefactoringStatus(); |
| }*/ |
| } |
