/*******************************************************************************
* 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
* Felix Pahl (fpahl@web.de) - contributed fix for:
* o introduce parameter throws NPE if there are compiler errors
* (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=48325)
*******************************************************************************/
package org.eclipse.dltk.internal.javascript.corext.refactoring.code;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
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.IMethod;
import org.eclipse.dltk.core.IModelElement;
import org.eclipse.dltk.core.ISourceModule;
import org.eclipse.dltk.core.ModelException;
import org.eclipse.dltk.core.SourceRange;
import org.eclipse.dltk.internal.corext.refactoring.ScriptRefactoringDescriptor;
import org.eclipse.dltk.internal.corext.refactoring.base.ScriptStatusContext;
import org.eclipse.dltk.internal.corext.refactoring.changes.DynamicValidationRefactoringChange;
import org.eclipse.dltk.internal.javascript.core.manipulation.Messages;
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.structure.BodyUpdater;
import org.eclipse.dltk.internal.javascript.corext.refactoring.structure.ChangeSignatureProcessor;
import org.eclipse.dltk.javascript.core.JavaScriptPlugin;
import org.eclipse.dltk.javascript.core.dom.BinaryExpression;
import org.eclipse.dltk.javascript.core.dom.DomFactory;
import org.eclipse.dltk.javascript.core.dom.Expression;
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.Source;
import org.eclipse.dltk.javascript.core.dom.VariableReference;
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.RefactoringUtils;
import org.eclipse.dltk.javascript.core.refactoring.descriptors.ChangeMethodSignatureDescriptor;
import org.eclipse.dltk.javascript.core.refactoring.descriptors.IntroduceParameterDescriptor;
import org.eclipse.dltk.javascript.parser.JavaScriptParserUtil;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.ltk.core.refactoring.Change;
import org.eclipse.ltk.core.refactoring.Refactoring;
import org.eclipse.ltk.core.refactoring.RefactoringStatus;
import org.eclipse.ltk.core.refactoring.participants.ProcessorBasedRefactoring;
public class IntroduceParameterRefactoring extends Refactoring {
private static final String ATTRIBUTE_ARGUMENT= "argument"; //$NON-NLS-1$
//private static final String[] KNOWN_METHOD_NAME_PREFIXES= {"get", "is"}; //$NON-NLS-2$ //$NON-NLS-1$
private ISourceModule fSourceCU;
private Source root;
private String source;
private int fSelectionStart;
private int fSelectionLength;
private IMethod fMethod;
private Refactoring fChangeSignatureRefactoring;
private ChangeSignatureProcessor fChangeSignatureProcessor;
private ParameterInfo fParameter;
//private String fParameterName;
//private ScriptRefactoringArguments fArguments;
private Expression fSelectedExpression;
//private String[] fExcludedParameterNames;
/**
* Creates a new introduce parameter refactoring.
* @param unit the compilation unit, or <code>null</code> if invoked by scripting
* @param selectionStart start
* @param selectionLength length
*/
public IntroduceParameterRefactoring(ISourceModule unit, int selectionStart, int selectionLength) {
Assert.isTrue(selectionStart >= 0);
Assert.isTrue(selectionLength >= 0);
fSourceCU= unit;
fSelectionStart= selectionStart;
fSelectionLength= selectionLength;
}
/*public IntroduceParameterRefactoring(ScriptRefactoringArguments arguments, RefactoringStatus status) {
this(null, 0, 0);
RefactoringStatus initializeStatus= initialize(arguments);
status.merge(initializeStatus);
}
// ------------------- IDelegateUpdating ----------------------
public boolean canEnableDelegateUpdating() {
return true;
}
public boolean getDelegateUpdating() {
return (fChangeSignatureProcessor != null) ? fChangeSignatureProcessor.getDelegateUpdating() : false;
}
public void setDelegateUpdating(boolean updating) {
if (fChangeSignatureProcessor != null)
fChangeSignatureProcessor.setDelegateUpdating(updating);
}
public void setDeprecateDelegates(boolean deprecate) {
if (fChangeSignatureProcessor != null)
fChangeSignatureProcessor.setDeprecateDelegates(deprecate);
}
public boolean getDeprecateDelegates() {
return (fChangeSignatureProcessor != null) ? fChangeSignatureProcessor.getDeprecateDelegates() : false;
}*/
// ------------------- /IDelegateUpdating ---------------------
public String getName() {
return RefactoringCoreMessages.IntroduceParameterRefactoring_name;
}
//--- checkActivation
public RefactoringStatus checkInitialConditions(IProgressMonitor pm) throws CoreException {
try {
pm.beginTask("", 7); //$NON-NLS-1$
if (! fSourceCU.isStructureKnown())
return RefactoringStatus.createFatalErrorStatus(RefactoringCoreMessages.IntroduceParameterRefactoring_syntax_error);
root = (Source)ASTConverter.convert(JavaScriptParserUtil.parse(fSourceCU));
source = fSourceCU.getSource();
initializeSelectedExpression();
RefactoringStatus result= new RefactoringStatus();
result.merge(checkSelection());
if (result.hasFatalError())
return result;
pm.worked(1);
/*if (fArguments != null) {
// invoked by script
fChangeSignatureProcessor= new ChangeSignatureProcessor(fArguments, result);
if (!result.hasFatalError()) {
fChangeSignatureRefactoring= new ProcessorBasedRefactoring(fChangeSignatureProcessor);
fChangeSignatureRefactoring.setValidationContext(getValidationContext());
result.merge(fChangeSignatureProcessor.checkInitialConditions(new SubProgressMonitor(pm, 2)));
if (result.hasFatalError())
return result;
} else {
pm.worked(2);
return result;
}
} else {*/
// first try:
fChangeSignatureProcessor= new ChangeSignatureProcessor(fMethod);
fChangeSignatureRefactoring= new ProcessorBasedRefactoring(fChangeSignatureProcessor);
fChangeSignatureRefactoring.setValidationContext(getValidationContext());
result.merge(fChangeSignatureProcessor.checkInitialConditions(new SubProgressMonitor(pm, 1)));
/*if (result.hasFatalError()) {
RefactoringStatusEntry entry= result.getEntryMatchingSeverity(RefactoringStatus.FATAL);
if (entry.getCode() == RefactoringStatusCodes.OVERRIDES_ANOTHER_METHOD || entry.getCode() == RefactoringStatusCodes.METHOD_DECLARED_IN_INTERFACE) {
// second try:
IMethod method= (IMethod) entry.getData();
fChangeSignatureProcessor= RefactoringAvailabilityTester.isChangeSignatureAvailable(method) ? new ChangeSignatureProcessor(method) : null;
if (fChangeSignatureProcessor == null) {
String msg= Messages.format(RefactoringCoreMessages.IntroduceParameterRefactoring_cannot_introduce, entry.getMessage());
return RefactoringStatus.createFatalErrorStatus(msg);
}
result= fChangeSignatureProcessor.checkInitialConditions(new SubProgressMonitor(pm, 1));
if (result.hasFatalError())
return result;
} else {
return result;
}
} else {
pm.worked(1);
}*/
if (result.hasFatalError())
return result;
//}
//CompilationUnitRewrite cuRewrite= fChangeSignatureProcessor.getBaseCuRewrite();
//if (! cuRewrite.getCu().equals(fSourceCU))
// cuRewrite= new CompilationUnitRewrite(fSourceCU); // TODO: should try to avoid throwing away this AST
//initializeExcludedParameterNames();
addParameterInfo();
fChangeSignatureProcessor.setBodyUpdater(new BodyUpdater() {
public void updateBody(FunctionExpression methodDeclaration) {
replaceSelectedExpression(methodDeclaration);
}
});
return result;
} finally {
pm.done();
/*if (fChangeSignatureRefactoring != null)
fChangeSignatureRefactoring.setValidationContext(null);*/
}
}
private void addParameterInfo() throws ModelException {
//ITypeBinding typeBinding= Bindings.normalizeForDeclarationUse(fSelectedExpression.resolveTypeBinding(), fSelectedExpression.getAST());
//String typeName= cuRewrite.getImportRewrite().addImport(typeBinding);
//String name= fParameterName != null ? fParameterName : guessedParameterName();
String defaultValue= fSourceCU.getBuffer().getText(fSelectedExpression.getBegin(), fSelectedExpression.getEnd()-fSelectedExpression.getBegin());
//fParameter= ParameterInfo.createInfoForAddedParameter(typeBinding, typeName, name, defaultValue);
fParameter= ParameterInfo.createInfoForAddedParameter("","",defaultValue);
//if (fArguments == null) {
fChangeSignatureProcessor.getParameterInfos().add(fParameter);
//}
}
private void replaceSelectedExpression(Node root) {
// cannot use fSelectedExpression here, since it could be from another AST (if method was replaced by overridden):
Expression expression=(Expression)NodeFinder.findNode(root, fSelectedExpression.getBegin(), fSelectedExpression.getEnd());
VariableReference result = DomFactory.eINSTANCE.createVariableReference();
Identifier id = DomFactory.eINSTANCE.createIdentifier();
id.setName(fParameter.getNewName());
result.setVariable(id);
EReference ref = expression.eContainmentFeature();
if (ref.isMany()) {
EList<Expression> exprList = (EList<Expression>)expression.eContainer().eGet(ref);
exprList.set(exprList.lastIndexOf(expression), result);
} else {
expression.eContainer().eSet(ref, result);
}
}
private void initializeSelectedExpression() {
Node selected = NodeFinder.findNode(root, fSelectionStart, fSelectionStart+fSelectionLength);
if (!(selected instanceof Expression))
return;
for(int i=fSelectionStart;i<selected.getBegin();i++)
if (!Character.isWhitespace(source.charAt(i))) return;
for(int i=selected.getEnd();i<fSelectionStart+fSelectionLength;i++)
if (!Character.isWhitespace(source.charAt(i))) return;
fSelectedExpression=(Expression)selected;
}
private RefactoringStatus createFatalError(String message) {
SourceRange range = new SourceRange(fSelectionStart,fSelectionLength);
return RefactoringStatus.createFatalErrorStatus(message, ScriptStatusContext.create(fSourceCU, range));
}
private RefactoringStatus checkSelection() throws ModelException {
if (fSelectedExpression == null) {
return createFatalError(RefactoringCoreMessages.IntroduceParameterRefactoring_select);
}
Node node = NodeFinder.findEnclosingNode(fSelectedExpression);
if (!(node instanceof FunctionExpression))
return RefactoringStatus.createFatalErrorStatus(RefactoringCoreMessages.IntroduceParameterRefactoring_expression_in_method);
IModelElement element = fSourceCU.getElementAt(fSelectionStart);
if (element == null || !(element instanceof IMethod))
return RefactoringStatus.createFatalErrorStatus(RefactoringCoreMessages.IntroduceParameterRefactoring_expression_in_method);
fMethod = (IMethod)element;
return checkExpression();
//result.merge(checkExpressionBinding());
//if (result.hasFatalError())
// return result;
// if (isUsedInForInitializerOrUpdater(getSelectedExpression().getAssociatedExpression()))
// return RefactoringStatus.createFatalErrorStatus(RefactoringCoreMessages.getString("ExtractTempRefactoring.for_initializer_updater")); //$NON-NLS-1$
// pm.worked(1);
//
// if (isReferringToLocalVariableFromFor(getSelectedExpression().getAssociatedExpression()))
// return RefactoringStatus.createFatalErrorStatus(RefactoringCoreMessages.getString("ExtractTempRefactoring.refers_to_for_variable")); //$NON-NLS-1$
// pm.worked(1);
}
private RefactoringStatus checkExpression() {
//TODO: adjust error messages (or generalize for all refactorings on expression-selections?)
Expression selectedExpression= fSelectedExpression;
if (selectedExpression instanceof BinaryExpression
&& selectedExpression.eContainer() instanceof Expression
&& RefactoringUtils.isAssignment(((BinaryExpression)selectedExpression).getOperation()))
return RefactoringStatus.createFatalErrorStatus(RefactoringCoreMessages.ExtractTempRefactoring_assignment);
return null;
}
public List<ParameterInfo> getParameterInfos() {
return fChangeSignatureProcessor.getParameterInfos();
}
public ParameterInfo getAddedParameterInfo() {
return fParameter;
}
public String getMethodSignaturePreview() throws ModelException {
return fChangeSignatureProcessor.getNewMethodSignature();
}
//--- Input setting/validation
/*public void setParameterName(String name) {
Assert.isNotNull(name);
fParameter.setNewName(name);
}
/**
* must only be called <i>after</i> checkActivation()
* @return guessed parameter name
*
public String guessedParameterName() {
String[] proposals= guessParameterNames();
if (proposals.length == 0)
return ""; //$NON-NLS-1$
else
return proposals[0];
}
// --- TODO: copied from ExtractTempRefactoring - should extract ------------------------------
/**
* Must only be called <i>after</i> checkActivation().
* The first proposal should be used as "best guess" (if it exists).
* @return proposed variable names (may be empty, but not null).
*
public String[] guessParameterNames() {
LinkedHashSet proposals= new LinkedHashSet(); //retain ordering, but prevent duplicates
if (fSelectedExpression instanceof MethodInvocation){
proposals.addAll(guessTempNamesFromMethodInvocation((MethodInvocation) fSelectedExpression, fExcludedParameterNames));
}
proposals.addAll(guessTempNamesFromExpression(fSelectedExpression, fExcludedParameterNames));
return (String[]) proposals.toArray(new String[proposals.size()]);
}
private List/*<String>* guessTempNamesFromMethodInvocation(MethodInvocation selectedMethodInvocation, String[] excludedVariableNames) {
String methodName= selectedMethodInvocation.getName().getIdentifier();
for (int i= 0; i < KNOWN_METHOD_NAME_PREFIXES.length; i++) {
String prefix= KNOWN_METHOD_NAME_PREFIXES[i];
if (! methodName.startsWith(prefix))
continue; //not this prefix
if (methodName.length() == prefix.length())
return Collections.EMPTY_LIST; // prefix alone -> don't take method name
char firstAfterPrefix= methodName.charAt(prefix.length());
if (! Character.isUpperCase(firstAfterPrefix))
continue; //not uppercase after prefix
//found matching prefix
String proposal= Character.toLowerCase(firstAfterPrefix) + methodName.substring(prefix.length() + 1);
methodName= proposal;
break;
}
String[] proposals= StubUtility.getLocalNameSuggestions(fSourceCU.getJavaProject(), methodName, 0, excludedVariableNames);
return Arrays.asList(proposals);
}
private List/*<String>* guessTempNamesFromExpression(Expression selectedExpression, String[] excluded) {
ITypeBinding expressionBinding= Bindings.normalizeForDeclarationUse(
selectedExpression.resolveTypeBinding(),
selectedExpression.getAST());
String typeName= getQualifiedName(expressionBinding);
if (typeName.length() == 0)
typeName= expressionBinding.getName();
if (typeName.length() == 0)
return Collections.EMPTY_LIST;
int typeParamStart= typeName.indexOf("<"); //$NON-NLS-1$
if (typeParamStart != -1)
typeName= typeName.substring(0, typeParamStart);
String[] proposals= StubUtility.getLocalNameSuggestions(fSourceCU.getJavaProject(), typeName, expressionBinding.getDimensions(), excluded);
return Arrays.asList(proposals);
}
// ----------------------------------------------------------------------
private static String getQualifiedName(ITypeBinding typeBinding) {
if (typeBinding.isAnonymous())
return getQualifiedName(typeBinding.getSuperclass());
if (! typeBinding.isArray())
return typeBinding.getQualifiedName();
else
return typeBinding.getElementType().getQualifiedName();
}
private void initializeExcludedParameterNames() {
Set<String> visible = VariableLookup.getVisibleNames(fSelectedExpression);
fExcludedParameterNames = visible.toArray(new String[visible.size()]);
}*/
public RefactoringStatus validateInput() {
return fChangeSignatureProcessor.checkSignature();
}
//--- checkInput
public RefactoringStatus checkFinalConditions(IProgressMonitor pm) throws CoreException {
fChangeSignatureRefactoring.setValidationContext(getValidationContext());
try {
return fChangeSignatureRefactoring.checkFinalConditions(pm);
} finally {
fChangeSignatureRefactoring.setValidationContext(null);
}
}
public Change createChange(IProgressMonitor pm) throws CoreException {
fChangeSignatureRefactoring.setValidationContext(getValidationContext());
try {
Change[] changes= fChangeSignatureProcessor.getAllChanges();
return new DynamicValidationRefactoringChange(getRefactoringDescriptor(), RefactoringCoreMessages.IntroduceParameterRefactoring_name, changes);
} finally {
fChangeSignatureRefactoring.setValidationContext(null);
pm.done();
}
}
private IntroduceParameterDescriptor getRefactoringDescriptor() {
ChangeMethodSignatureDescriptor extended= (ChangeMethodSignatureDescriptor) fChangeSignatureProcessor.createDescriptor();
//RefactoringContribution contribution= RefactoringCore.getRefactoringContribution(IScriptRefactorings.CHANGE_METHOD_SIGNATURE);
//Map argumentsMap= contribution.retrieveArgumentMap(extended);
final Map arguments= new HashMap();
arguments.put(ATTRIBUTE_ARGUMENT, fParameter.getNewName());
arguments.put(ScriptRefactoringDescriptor.ATTRIBUTE_SELECTION, new Integer(fSelectionStart).toString() + " " + new Integer(fSelectionLength).toString()); //$NON-NLS-1$
//arguments.putAll(argumentsMap);
String signature= fChangeSignatureProcessor.getMethodName();
try {
signature= fChangeSignatureProcessor.getOldMethodSignature();
} catch (ModelException exception) {
JavaScriptPlugin.error(exception);
}
final String description= Messages.format(RefactoringCoreMessages.IntroduceParameterRefactoring_descriptor_description_short, fChangeSignatureProcessor.getMethod().getElementName());
//final String header= Messages.format(RefactoringCoreMessages.IntroduceParameterRefactoring_descriptor_description, new String[] { fParameter.getNewName(), signature, fSelectedExpression});
//final JDTRefactoringDescriptorComment comment= new JDTRefactoringDescriptorComment(extended.getProject(), this, header);
//comment.addSetting(Messages.format(RefactoringCoreMessages.IntroduceParameterRefactoring_original_pattern, JavaElementLabels.getTextLabel(fChangeSignatureProcessor.getMethod(),
// JavaElementLabels.ALL_FULLY_QUALIFIED)));
//comment.addSetting(Messages.format(RefactoringCoreMessages.IntroduceParameterRefactoring_expression_pattern, BasicElementLabels.getJavaCodeString(ASTNodes.asString(fSelectedExpression))));
//comment.addSetting(Messages.format(RefactoringCoreMessages.IntroduceParameterRefactoring_parameter_pattern, BasicElementLabels.getJavaElementName(getAddedParameterInfo().getNewName())));
return new IntroduceParameterDescriptor(extended.getProject(), description, ""/*comment.asString()*/, arguments, extended.getFlags());
}
/*private RefactoringStatus initialize(JavaRefactoringArguments arguments) {
fArguments= 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.INTRODUCE_PARAMETER);
else
fSourceCU= ((IMethod) element).getCompilationUnit();
} else
return RefactoringStatus.createFatalErrorStatus(Messages.format(RefactoringCoreMessages.InitializableRefactoring_argument_not_exist, JavaRefactoringDescriptorUtil.ATTRIBUTE_INPUT));
final String name= arguments.getAttribute(ATTRIBUTE_ARGUMENT);
if (name != null && !"".equals(name)) //$NON-NLS-1$
fParameterName= name;
else
return RefactoringStatus.createFatalErrorStatus(Messages.format(RefactoringCoreMessages.InitializableRefactoring_argument_not_exist, ATTRIBUTE_ARGUMENT));
return new RefactoringStatus();
}
/**
* {@inheritDoc}
*
public String getDelegateUpdatingTitle(boolean plural) {
if (plural)
return RefactoringCoreMessages.DelegateCreator_keep_original_changed_plural;
else
return RefactoringCoreMessages.DelegateCreator_keep_original_changed_singular;
}*/
}