From 1ce6f8d2fa052d8c49cdc41b83aa9b45e2771aaf Mon Sep 17 00:00:00 2001 From: "Anna.Kozlova" Date: Mon, 25 Apr 2016 10:54:43 +0200 Subject: [PATCH] introduce param object: pass substitution around which won't be available after method signature is changed (IDEA-154208) --- .../changeSignature/JavaChangeInfoImpl.java | 2 +- .../JavaChangeSignatureUsageProcessor.java | 25 +++++++------- .../changeSignature/JavaParameterInfo.java | 3 +- ...troduceParameterObjectClassDescriptor.java | 12 ++----- .../JavaIntroduceParameterObjectDelegate.java | 34 ++++++++++++++----- .../after/Param.java | 13 +++++++ .../after/Test.java | 11 ++++++ .../before/Test.java | 12 +++++++ .../IntroduceParameterObjectTest.java | 14 ++++++++ .../changeSignature/ChangeInfo.java | 9 ----- .../changeSignature/ParameterInfo.java | 2 +- .../IntroduceParameterObjectDelegate.java | 4 ++- .../changeSignature/GrChangeInfoImpl.java | 2 +- .../GrChangeSignatureUsageProcessor.java | 7 ++-- ...roovyIntroduceParameterObjectDelegate.java | 7 ++-- 15 files changed, 107 insertions(+), 50 deletions(-) create mode 100644 java/java-tests/testData/refactoring/introduceParameterObject/typeParametersWithSubstitution/after/Param.java create mode 100644 java/java-tests/testData/refactoring/introduceParameterObject/typeParametersWithSubstitution/after/Test.java create mode 100644 java/java-tests/testData/refactoring/introduceParameterObject/typeParametersWithSubstitution/before/Test.java diff --git a/java/java-impl/src/com/intellij/refactoring/changeSignature/JavaChangeInfoImpl.java b/java/java-impl/src/com/intellij/refactoring/changeSignature/JavaChangeInfoImpl.java index 46021270acde..cb1b753898f4 100644 --- a/java/java-impl/src/com/intellij/refactoring/changeSignature/JavaChangeInfoImpl.java +++ b/java/java-impl/src/com/intellij/refactoring/changeSignature/JavaChangeInfoImpl.java @@ -309,7 +309,7 @@ public class JavaChangeInfoImpl extends UserDataHolderBase implements JavaChange @Nullable public PsiExpression getValue(int i, PsiCallExpression expr) throws IncorrectOperationException { if (defaultValues[i] != null) return defaultValues[i]; - final PsiElement valueAtCallSite = newParms[i].getActualValue(expr); + final PsiElement valueAtCallSite = newParms[i].getActualValue(expr, PsiSubstitutor.EMPTY); return valueAtCallSite instanceof PsiExpression ? (PsiExpression)valueAtCallSite : null; } diff --git a/java/java-impl/src/com/intellij/refactoring/changeSignature/JavaChangeSignatureUsageProcessor.java b/java/java-impl/src/com/intellij/refactoring/changeSignature/JavaChangeSignatureUsageProcessor.java index 1cdde7c66a3f..5d9eb7b102b1 100644 --- a/java/java-impl/src/com/intellij/refactoring/changeSignature/JavaChangeSignatureUsageProcessor.java +++ b/java/java-impl/src/com/intellij/refactoring/changeSignature/JavaChangeSignatureUsageProcessor.java @@ -410,7 +410,8 @@ public class JavaChangeSignatureUsageProcessor implements ChangeSignatureUsagePr //This methods works equally well for primary usages as well as for propagated callers' usages private static void fixActualArgumentsList(PsiExpressionList list, JavaChangeInfo changeInfo, - boolean toInsertDefaultValue, PsiSubstitutor substitutor) throws IncorrectOperationException { + boolean toInsertDefaultValue, + PsiSubstitutor substitutor) throws IncorrectOperationException { final PsiElementFactory factory = JavaPsiFacade.getInstance(list.getProject()).getElementFactory(); if (changeInfo.isParameterSetOrOrderChanged()) { if (changeInfo instanceof JavaChangeInfoImpl && ((JavaChangeInfoImpl)changeInfo).isPropagationEnabled) { @@ -418,7 +419,7 @@ public class JavaChangeSignatureUsageProcessor implements ChangeSignatureUsagePr for (ParameterInfoImpl info : createdParmsInfo) { PsiExpression newArg; if (toInsertDefaultValue) { - newArg = createDefaultValue(changeInfo, factory, info, list); + newArg = createDefaultValue(changeInfo, factory, info, list, substitutor); } else { newArg = factory.createExpressionFromText(info.getName(), list); @@ -486,12 +487,12 @@ public class JavaChangeSignatureUsageProcessor implements ChangeSignatureUsagePr continue; } } - newArgs[i] = createActualArgument(changeInfo, list, newParms[i], toInsertDefaultValue, args); + newArgs[i] = createActualArgument(changeInfo, list, newParms[i], toInsertDefaultValue, args, substitutor); } if (changeInfo.isArrayToVarargs()) { if (newVarargInitializers == null) { newArgs[newNonVarargCount] = - createActualArgument(changeInfo, list, newParms[newNonVarargCount], toInsertDefaultValue, args); + createActualArgument(changeInfo, list, newParms[newNonVarargCount], toInsertDefaultValue, args, substitutor); } else { System.arraycopy(newVarargInitializers, 0, newArgs, newNonVarargCount, newVarargInitializers.length); @@ -503,7 +504,7 @@ public class JavaChangeSignatureUsageProcessor implements ChangeSignatureUsagePr for (int i = newNonVarargCount; i < newArgsLength; i++){ final int oldIndex = newParms[newNonVarargCount].getOldIndex(); if (oldIndex >= 0 && oldIndex != nonVarargCount) { - newArgs[i] = createActualArgument(changeInfo, list, newParms[newNonVarargCount], toInsertDefaultValue, args); + newArgs[i] = createActualArgument(changeInfo, list, newParms[newNonVarargCount], toInsertDefaultValue, args, substitutor); } else { System.arraycopy(args, nonVarargCount, newArgs, newNonVarargCount, newVarargCount); break; @@ -526,7 +527,8 @@ public class JavaChangeSignatureUsageProcessor implements ChangeSignatureUsagePr final PsiExpressionList list, final JavaParameterInfo info, final boolean toInsertDefaultValue, - final PsiExpression[] args) throws IncorrectOperationException { + final PsiExpression[] args, + PsiSubstitutor substitutor) throws IncorrectOperationException { final PsiElementFactory factory = JavaPsiFacade.getInstance(list.getProject()).getElementFactory(); final int index = info.getOldIndex(); if (index >= 0 && index < args.length) { @@ -534,7 +536,7 @@ public class JavaChangeSignatureUsageProcessor implements ChangeSignatureUsagePr } else { if (toInsertDefaultValue) { - return createDefaultValue(changeInfo, factory, info, list); + return createDefaultValue(changeInfo, factory, info, list, substitutor); } else { return factory.createExpressionFromText(info.getName(), list); @@ -546,7 +548,7 @@ public class JavaChangeSignatureUsageProcessor implements ChangeSignatureUsagePr private static PsiExpression createDefaultValue(JavaChangeInfo changeInfo, final PsiElementFactory factory, final JavaParameterInfo info, - final PsiExpressionList list) + final PsiExpressionList list, PsiSubstitutor substitutor) throws IncorrectOperationException { if (info.isUseAnySingleVariable()) { final PsiResolveHelper resolveHelper = JavaPsiFacade.getInstance(list.getProject()).getResolveHelper(); @@ -593,7 +595,7 @@ public class JavaChangeSignatureUsageProcessor implements ChangeSignatureUsagePr } final PsiCallExpression callExpression = PsiTreeUtil.getParentOfType(list, PsiCallExpression.class); final String defaultValue = info.getDefaultValue(); - return callExpression != null ? (PsiExpression)info.getActualValue(callExpression) + return callExpression != null ? (PsiExpression)info.getActualValue(callExpression, substitutor) : !StringUtil.isEmpty(defaultValue) ? factory.createExpressionFromText(defaultValue, list) : null; } @@ -706,14 +708,13 @@ public class JavaChangeSignatureUsageProcessor implements ChangeSignatureUsagePr private static void addDelegateArguments(JavaChangeInfo changeInfo, PsiElementFactory factory, final PsiCallExpression callExpression) throws IncorrectOperationException { final JavaParameterInfo[] newParms = changeInfo.getNewParameters(); final String[] oldParameterNames = changeInfo.getOldParameterNames(); - for (int i = 0; i < newParms.length; i++) { - JavaParameterInfo newParm = newParms[i]; + for (JavaParameterInfo newParm : newParms) { final PsiExpression actualArg; if (newParm.getOldIndex() >= 0) { actualArg = factory.createExpressionFromText(oldParameterNames[newParm.getOldIndex()], callExpression); } else { - actualArg = (PsiExpression)changeInfo.getActualValue(i, callExpression); + actualArg = (PsiExpression)newParm.getActualValue(callExpression, PsiSubstitutor.EMPTY); } final PsiExpressionList argumentList = callExpression.getArgumentList(); if (actualArg != null && argumentList != null) { diff --git a/java/java-impl/src/com/intellij/refactoring/changeSignature/JavaParameterInfo.java b/java/java-impl/src/com/intellij/refactoring/changeSignature/JavaParameterInfo.java index bc5740508172..b2dd2e8f0dbe 100644 --- a/java/java-impl/src/com/intellij/refactoring/changeSignature/JavaParameterInfo.java +++ b/java/java-impl/src/com/intellij/refactoring/changeSignature/JavaParameterInfo.java @@ -34,8 +34,7 @@ public interface JavaParameterInfo extends ParameterInfo { PsiExpression getValue(PsiCallExpression callExpression); @Nullable - @Override - default PsiElement getActualValue(PsiElement callExpression) { + default PsiElement getActualValue(PsiElement callExpression, Object substitutor) { return callExpression instanceof PsiCallExpression ? getValue((PsiCallExpression)callExpression) : null; } diff --git a/java/java-impl/src/com/intellij/refactoring/introduceparameterobject/JavaIntroduceParameterObjectClassDescriptor.java b/java/java-impl/src/com/intellij/refactoring/introduceparameterobject/JavaIntroduceParameterObjectClassDescriptor.java index f19c14328fad..ef2387ea2f8f 100644 --- a/java/java-impl/src/com/intellij/refactoring/introduceparameterobject/JavaIntroduceParameterObjectClassDescriptor.java +++ b/java/java-impl/src/com/intellij/refactoring/introduceparameterobject/JavaIntroduceParameterObjectClassDescriptor.java @@ -32,20 +32,19 @@ import com.intellij.refactoring.MoveDestination; import com.intellij.refactoring.changeSignature.ParameterInfoImpl; import com.intellij.refactoring.introduceParameterObject.IntroduceParameterObjectClassDescriptor; import com.intellij.refactoring.introduceParameterObject.IntroduceParameterObjectDelegate; -import com.intellij.util.Function; import com.intellij.util.IncorrectOperationException; import com.intellij.util.containers.HashMap; import org.jetbrains.annotations.NonNls; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import java.util.HashSet; +import java.util.LinkedHashSet; import java.util.Map; import java.util.Set; public class JavaIntroduceParameterObjectClassDescriptor extends IntroduceParameterObjectClassDescriptor { private static final Logger LOG = Logger.getInstance("#" + JavaIntroduceParameterObjectClassDescriptor.class.getName()); - private final Set myTypeParameters = new HashSet<>(); + private final Set myTypeParameters = new LinkedHashSet<>(); private final Map myExistingClassProperties = new HashMap<>(); private final MoveDestination myMoveDestination; @@ -106,12 +105,7 @@ public class JavaIntroduceParameterObjectClassDescriptor extends IntroduceParame public String createFakeClassTypeText() { String text = StringUtil.getQualifiedName(getPackageName(), getClassName()); if (!myTypeParameters.isEmpty()) { - text += "<" + StringUtil.join(myTypeParameters, new Function() { - @Override - public String fun(PsiTypeParameter parameter) { - return parameter.getName(); - } - }, ", ") + ">"; + text += "<" + StringUtil.join(myTypeParameters, PsiNamedElement::getName, ", ") + ">"; } return text; } diff --git a/java/java-impl/src/com/intellij/refactoring/introduceparameterobject/JavaIntroduceParameterObjectDelegate.java b/java/java-impl/src/com/intellij/refactoring/introduceparameterobject/JavaIntroduceParameterObjectDelegate.java index 713afe952eb5..09ce3b828eaf 100644 --- a/java/java-impl/src/com/intellij/refactoring/introduceparameterobject/JavaIntroduceParameterObjectDelegate.java +++ b/java/java-impl/src/com/intellij/refactoring/introduceparameterobject/JavaIntroduceParameterObjectDelegate.java @@ -22,6 +22,7 @@ import com.intellij.pom.java.LanguageLevel; import com.intellij.psi.*; import com.intellij.psi.codeStyle.JavaCodeStyleManager; import com.intellij.psi.codeStyle.VariableKind; +import com.intellij.psi.impl.PsiDiamondTypeUtil; import com.intellij.psi.search.LocalSearchScope; import com.intellij.psi.search.searches.ReferencesSearch; import com.intellij.psi.util.PsiTreeUtil; @@ -42,6 +43,7 @@ import com.intellij.util.VisibilityUtil; import com.intellij.util.containers.MultiMap; import org.jetbrains.annotations.Nullable; +import java.util.ArrayList; import java.util.Collection; import java.util.Collections; import java.util.List; @@ -86,9 +88,9 @@ public class JavaIntroduceParameterObjectDelegate return new ParameterInfoImpl(-1, paramName, facade.getElementFactory().createTypeFromText(classTypeText, method), null) { @Nullable @Override - public PsiElement getActualValue(PsiElement exp) { + public PsiElement getActualValue(PsiElement exp, Object substitutor) { final IntroduceParameterObjectDelegate> delegate = findDelegate(exp); - return delegate != null ? delegate.createNewParameterInitializerAtCallSite(exp, descriptor, oldMethodParameters) : null; + return delegate != null ? delegate.createNewParameterInitializerAtCallSite(exp, descriptor, oldMethodParameters, substitutor) : null; } }; } @@ -96,7 +98,8 @@ public class JavaIntroduceParameterObjectDelegate @Override public PsiElement createNewParameterInitializerAtCallSite(PsiElement callExpression, IntroduceParameterObjectClassDescriptor descriptor, - List oldMethodParameters) { + List oldMethodParameters, + Object substitutor) { if (callExpression instanceof PsiCallExpression) { final PsiCallExpression expr = (PsiCallExpression)callExpression; final JavaPsiFacade facade = JavaPsiFacade.getInstance(expr.getProject()); @@ -109,16 +112,31 @@ public class JavaIntroduceParameterObjectDelegate final PsiExpression[] args = argumentList.getExpressions(); StringBuilder newExpression = new StringBuilder(); - final JavaResolveResult resolvant = expr.resolveMethodGenerics(); - final PsiSubstitutor substitutor = resolvant.getSubstitutor(); - newExpression.append("new ") - .append(JavaPsiFacade.getElementFactory(expr.getProject()).createType(existingClass, substitutor).getCanonicalText()); + newExpression.append("new ").append(existingClass.getQualifiedName()); + if (descriptor instanceof JavaIntroduceParameterObjectClassDescriptor) { + List types = new ArrayList<>(); + for (PsiTypeParameter parameter : ((JavaIntroduceParameterObjectClassDescriptor)descriptor).getTypeParameters()) { + PsiType type = ((PsiSubstitutor)substitutor).substitute(parameter); + if (type == null) { + types.clear(); + break; + } + types.add(type.getCanonicalText()); + } + if (!types.isEmpty()) { + newExpression.append("<").append(StringUtil.join(types, ", ")).append(">"); + } + } newExpression.append('('); newExpression.append(getMergedArgs(descriptor, oldMethodParameters, args)); newExpression.append(')'); - return JavaCodeStyleManager.getInstance(callExpression.getProject()) + PsiNewExpression newClassExpression = (PsiNewExpression)JavaCodeStyleManager.getInstance(callExpression.getProject()) .shortenClassReferences(facade.getElementFactory().createExpressionFromText(newExpression.toString(), expr)); + if (PsiDiamondTypeUtil.canChangeContextForDiamond(newClassExpression, newClassExpression.getType())) { + PsiDiamondTypeUtil.replaceExplicitWithDiamond(newClassExpression.getClassOrAnonymousClassReference().getParameterList()); + } + return newClassExpression; } return null; } diff --git a/java/java-tests/testData/refactoring/introduceParameterObject/typeParametersWithSubstitution/after/Param.java b/java/java-tests/testData/refactoring/introduceParameterObject/typeParametersWithSubstitution/after/Param.java new file mode 100644 index 000000000000..1bb40430e713 --- /dev/null +++ b/java/java-tests/testData/refactoring/introduceParameterObject/typeParametersWithSubstitution/after/Param.java @@ -0,0 +1,13 @@ +import java.util.List; + +public class Param { + private final List y; + + public Param(List y) { + this.y = y; + } + + public List getY() { + return y; + } +} diff --git a/java/java-tests/testData/refactoring/introduceParameterObject/typeParametersWithSubstitution/after/Test.java b/java/java-tests/testData/refactoring/introduceParameterObject/typeParametersWithSubstitution/after/Test.java new file mode 100644 index 000000000000..68610f7ba8ee --- /dev/null +++ b/java/java-tests/testData/refactoring/introduceParameterObject/typeParametersWithSubstitution/after/Test.java @@ -0,0 +1,11 @@ +import java.util.List; + +public class Test { + public static String foo(Param param) { + return null; + } + + void bar(List list) { + System.out.println(foo(new Param<>(list))); + } +} diff --git a/java/java-tests/testData/refactoring/introduceParameterObject/typeParametersWithSubstitution/before/Test.java b/java/java-tests/testData/refactoring/introduceParameterObject/typeParametersWithSubstitution/before/Test.java new file mode 100644 index 000000000000..f13937986913 --- /dev/null +++ b/java/java-tests/testData/refactoring/introduceParameterObject/typeParametersWithSubstitution/before/Test.java @@ -0,0 +1,12 @@ +import java.util.Collection; +import java.util.List; + +public class Test { + public static String foo(List y) { + return null; + } + + void bar(List list) { + System.out.println(foo(list)); + } +} diff --git a/java/java-tests/testSrc/com/intellij/refactoring/IntroduceParameterObjectTest.java b/java/java-tests/testSrc/com/intellij/refactoring/IntroduceParameterObjectTest.java index 1f82ad987ab0..c35b9fd93c79 100644 --- a/java/java-tests/testSrc/com/intellij/refactoring/IntroduceParameterObjectTest.java +++ b/java/java-tests/testSrc/com/intellij/refactoring/IntroduceParameterObjectTest.java @@ -22,7 +22,9 @@ package com.intellij.refactoring; import com.intellij.JavaTestUtil; import com.intellij.openapi.fileEditor.FileDocumentManager; +import com.intellij.openapi.roots.LanguageLevelProjectExtension; import com.intellij.openapi.vfs.LocalFileSystem; +import com.intellij.pom.java.LanguageLevel; import com.intellij.psi.*; import com.intellij.psi.search.GlobalSearchScope; import com.intellij.refactoring.changeSignature.JavaMethodDescriptor; @@ -132,6 +134,18 @@ public class IntroduceParameterObjectTest extends MultiFileTestCase{ doTest(); } + public void testTypeParametersWithSubstitution() throws Exception { + final LanguageLevelProjectExtension projectExtension = LanguageLevelProjectExtension.getInstance(getProject()); + final LanguageLevel oldLevel = projectExtension.getLanguageLevel(); + try { + projectExtension.setLanguageLevel(LanguageLevel.HIGHEST); + doTest(); + } + finally { + projectExtension.setLanguageLevel(oldLevel); + } + } + public void testSameTypeAndVarargs() throws Exception { doTest(false, false, method -> { final PsiParameter[] parameters = method.getParameterList().getParameters(); diff --git a/platform/lang-api/src/com/intellij/refactoring/changeSignature/ChangeInfo.java b/platform/lang-api/src/com/intellij/refactoring/changeSignature/ChangeInfo.java index deee40749a0e..6e37873a3118 100644 --- a/platform/lang-api/src/com/intellij/refactoring/changeSignature/ChangeInfo.java +++ b/platform/lang-api/src/com/intellij/refactoring/changeSignature/ChangeInfo.java @@ -52,13 +52,4 @@ public interface ChangeInfo { String getNewName(); Language getLanguage(); - - /** - * For added parameters, return expression to be inserted as argument at the parameter position in callExpression. - * Based on parameter default value {@link ParameterInfo#getActualValue(PsiElement)} - */ - default PsiElement getActualValue(int i, PsiElement callExpression) { - final ParameterInfo[] parameters = getNewParameters(); - return i < parameters.length ? parameters[i].getActualValue(callExpression) : null; - } } diff --git a/platform/lang-api/src/com/intellij/refactoring/changeSignature/ParameterInfo.java b/platform/lang-api/src/com/intellij/refactoring/changeSignature/ParameterInfo.java index 2a9f07a8e736..61198c412b68 100644 --- a/platform/lang-api/src/com/intellij/refactoring/changeSignature/ParameterInfo.java +++ b/platform/lang-api/src/com/intellij/refactoring/changeSignature/ParameterInfo.java @@ -55,7 +55,7 @@ public interface ParameterInfo { * Could be overridden to provide values which depend on the call site */ @Nullable - default PsiElement getActualValue(PsiElement callExpression) { + default PsiElement getActualValue(PsiElement callExpression, Object substitutor) { return null; } diff --git a/platform/lang-impl/src/com/intellij/refactoring/introduceParameterObject/IntroduceParameterObjectDelegate.java b/platform/lang-impl/src/com/intellij/refactoring/introduceParameterObject/IntroduceParameterObjectDelegate.java index e7c53c24066b..def9b138945c 100644 --- a/platform/lang-impl/src/com/intellij/refactoring/introduceParameterObject/IntroduceParameterObjectDelegate.java +++ b/platform/lang-impl/src/com/intellij/refactoring/introduceParameterObject/IntroduceParameterObjectDelegate.java @@ -100,10 +100,12 @@ public abstract class IntroduceParameterObjectDelegate oldMethodParameters); + List oldMethodParameters, + Object substitutor); /** * Pass new parameter infos to the change info constructor which corresponds to the language of this delegate diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/changeSignature/GrChangeInfoImpl.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/changeSignature/GrChangeInfoImpl.java index 63ac08423815..e8e1fe8f2d75 100644 --- a/plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/changeSignature/GrChangeInfoImpl.java +++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/changeSignature/GrChangeInfoImpl.java @@ -336,7 +336,7 @@ public class GrChangeInfoImpl implements JavaChangeInfo { @Override public PsiExpression getValue(int i, PsiCallExpression callExpression) { if (defaultValues[i] != null) return defaultValues[i]; - final PsiElement valueAtCallSite = parameters.get(i).getActualValue(callExpression); + final PsiElement valueAtCallSite = parameters.get(i).getActualValue(callExpression, PsiSubstitutor.EMPTY); return valueAtCallSite instanceof PsiExpression ? (PsiExpression)valueAtCallSite : null; } diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/changeSignature/GrChangeSignatureUsageProcessor.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/changeSignature/GrChangeSignatureUsageProcessor.java index 63e9e67d663f..312a53febdeb 100644 --- a/plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/changeSignature/GrChangeSignatureUsageProcessor.java +++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/changeSignature/GrChangeSignatureUsageProcessor.java @@ -529,7 +529,7 @@ public class GrChangeSignatureUsageProcessor implements ChangeSignatureUsageProc argsToDelete.removeAll(map[index].args); } else { - values[i] = createDefaultValue(factory, changeInfo, parameter, argumentList); + values[i] = createDefaultValue(factory, changeInfo, parameter, argumentList, substitutor); } } @@ -640,7 +640,8 @@ public class GrChangeSignatureUsageProcessor implements ChangeSignatureUsageProc private static GrExpression createDefaultValue(GroovyPsiElementFactory factory, JavaChangeInfo changeInfo, JavaParameterInfo info, - final GrArgumentList list) { + final GrArgumentList list, + PsiSubstitutor substitutor) { if (info.isUseAnySingleVariable()) { final PsiResolveHelper resolveHelper = JavaPsiFacade.getInstance(list.getProject()).getResolveHelper(); final PsiType type = info.getTypeWrapper().getType(changeInfo.getMethod(), list.getManager()); @@ -689,7 +690,7 @@ public class GrChangeSignatureUsageProcessor implements ChangeSignatureUsageProc } } - final PsiElement element = info.getActualValue(list.getParent()); + final PsiElement element = info.getActualValue(list.getParent(), substitutor); if (element instanceof GrExpression) { return (GrExpression)element; } diff --git a/plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/introduceParameterObject/GroovyIntroduceParameterObjectDelegate.java b/plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/introduceParameterObject/GroovyIntroduceParameterObjectDelegate.java index 63d8b3bdc52f..3985d2d2aa3f 100644 --- a/plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/introduceParameterObject/GroovyIntroduceParameterObjectDelegate.java +++ b/plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/introduceParameterObject/GroovyIntroduceParameterObjectDelegate.java @@ -76,10 +76,10 @@ public class GroovyIntroduceParameterObjectDelegate return new GrParameterInfo(descriptor.getClassName(), null, null, classType, -1, false) { @Nullable @Override - public PsiElement getActualValue(PsiElement callExpression) { + public PsiElement getActualValue(PsiElement callExpression, Object substitutor) { final IntroduceParameterObjectDelegate> delegate = findDelegate(callExpression); - return delegate != null ? delegate.createNewParameterInitializerAtCallSite(callExpression, descriptor, oldMethodParameters) : null; + return delegate != null ? delegate.createNewParameterInitializerAtCallSite(callExpression, descriptor, oldMethodParameters, substitutor) : null; } }; } @@ -87,7 +87,8 @@ public class GroovyIntroduceParameterObjectDelegate @Override public PsiElement createNewParameterInitializerAtCallSite(PsiElement callExpression, IntroduceParameterObjectClassDescriptor descriptor, - List oldMethodParameters) { + List oldMethodParameters, + Object substitutor) { if (callExpression instanceof GrCallExpression) { final GrArgumentList list = ((GrCallExpression)callExpression).getArgumentList(); if (list == null) {