diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeInfo.kt b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeInfo.kt index 34720ce21e3..b5134ebbf9f 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeInfo.kt +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeInfo.kt @@ -1,5 +1,5 @@ /* - * Copyright 2010-2013 JetBrains s.r.o. + * Copyright 2010-2014 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,312 +14,177 @@ * limitations under the License. */ -package org.jetbrains.jet.plugin.refactoring.changeSignature; +package org.jetbrains.jet.plugin.refactoring.changeSignature -import com.intellij.lang.Language; -import com.intellij.openapi.util.text.StringUtil; -import com.intellij.psi.PsiElement; -import com.intellij.psi.PsiMethod; -import com.intellij.psi.PsiModifier; -import com.intellij.psi.PsiType; -import com.intellij.refactoring.changeSignature.*; -import com.intellij.usageView.UsageInfo; -import com.intellij.util.Function; -import com.intellij.util.VisibilityUtil; -import com.intellij.util.containers.ContainerUtil; -import kotlin.Function1; -import kotlin.KotlinPackage; -import kotlin.Pair; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.asJava.AsJavaPackage; -import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; -import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; -import org.jetbrains.jet.lang.descriptors.Visibilities; -import org.jetbrains.jet.lang.descriptors.Visibility; -import org.jetbrains.jet.lang.psi.JetFunction; -import org.jetbrains.jet.lang.psi.JetFunctionLiteral; -import org.jetbrains.jet.lang.resolve.DescriptorToSourceUtils; -import org.jetbrains.jet.lang.types.JetType; -import org.jetbrains.jet.lang.types.TypeSubstitutor; -import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; -import org.jetbrains.jet.lexer.JetTokens; -import org.jetbrains.jet.plugin.JetLanguage; -import org.jetbrains.jet.plugin.caches.resolve.ResolvePackage; -import org.jetbrains.jet.plugin.refactoring.changeSignature.usages.JetFunctionDefinitionUsage; -import org.jetbrains.jet.plugin.util.IdeDescriptorRenderers; +import com.intellij.lang.Language +import com.intellij.openapi.util.text.StringUtil +import com.intellij.psi.PsiElement +import com.intellij.psi.PsiMethod +import com.intellij.psi.PsiModifier +import com.intellij.psi.PsiType +import com.intellij.refactoring.changeSignature.* +import com.intellij.usageView.UsageInfo +import com.intellij.util.Function +import com.intellij.util.VisibilityUtil +import com.intellij.util.containers.ContainerUtil +import kotlin.Function1 +import kotlin.Pair +import org.jetbrains.jet.asJava.* +import org.jetbrains.jet.lang.descriptors.FunctionDescriptor +import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor +import org.jetbrains.jet.lang.descriptors.Visibilities +import org.jetbrains.jet.lang.descriptors.Visibility +import org.jetbrains.jet.lang.psi.JetFunction +import org.jetbrains.jet.lang.psi.JetFunctionLiteral +import org.jetbrains.jet.lang.resolve.DescriptorToSourceUtils +import org.jetbrains.jet.lang.types.JetType +import org.jetbrains.jet.lang.types.TypeSubstitutor +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns +import org.jetbrains.jet.lexer.JetTokens +import org.jetbrains.jet.plugin.JetLanguage +import org.jetbrains.jet.plugin.caches.resolve.* +import org.jetbrains.jet.plugin.refactoring.changeSignature.usages.JetFunctionDefinitionUsage +import org.jetbrains.jet.plugin.util.IdeDescriptorRenderers +import java.util.HashMap +import kotlin.properties.Delegates -import java.util.Collection; -import java.util.HashMap; -import java.util.List; -import java.util.Map; +public class JetChangeInfo( + val methodDescriptor: JetMethodDescriptor, + private var name: String, + val newReturnType: JetType?, + var newReturnTypeText: String, + var newVisibility: Visibility, + parameterInfos: List, + val context: PsiElement +): ChangeInfo { + private val newParameters = parameterInfos.toArrayList() + private val originalPsiMethod: PsiMethod? = getCurrentPsiMethod() -public class JetChangeInfo implements ChangeInfo { - private final JetMethodDescriptor oldDescriptor; - private String newName; - private final JetType newReturnType; - private String newReturnTypeText; - private Visibility newVisibility; - private final List newParameters; - private final PsiElement context; - private Boolean parameterNamesChanged; - private Map oldNameToParameterIndex; - private boolean primaryMethodUpdated; - @Nullable - private JavaChangeInfo javaChangeInfo; - private final PsiMethod originalPsiMethod; + private val oldNameToParameterIndex: Map by Delegates.lazy { + val map = HashMap() - public JetChangeInfo( - JetMethodDescriptor oldDescriptor, - String newName, - JetType newReturnType, - String newReturnTypeText, - Visibility newVisibility, - List newParameters, - PsiElement context - ) { - this.oldDescriptor = oldDescriptor; - this.newName = newName; - this.newReturnType = newReturnType; - this.newReturnTypeText = newReturnTypeText; - this.newVisibility = newVisibility; - this.newParameters = newParameters; - this.context = context; - this.originalPsiMethod = getCurrentPsiMethod(); + val parameters = methodDescriptor.baseDescriptor.getValueParameters() + parameters.indices.forEach { i -> map[parameters.get(i).getName().asString()] = i } + + map } - @Nullable - private PsiMethod getCurrentPsiMethod() { - List psiMethods = AsJavaPackage.toLightMethods(getMethod()); - assert psiMethods.size() <= 1 : "Multiple light methods: " + getMethod().getText(); - return KotlinPackage.firstOrNull(psiMethods); + public val isParameterSetOrOrderChanged: Boolean by Delegates.lazy { + newParameters.size() != methodDescriptor.getParametersCount() || + newParameters.indices.any { i -> newParameters.get(i).getOldIndex() != i } } - public String getNewSignature(@NotNull JetFunctionDefinitionUsage inheritedFunction) { - StringBuilder buffer = new StringBuilder(); + private var isPrimaryMethodUpdated: Boolean = false + private var javaChangeInfo: JavaChangeInfo? = null - if (isConstructor()) { - buffer.append(newName); - - if (newVisibility != null && newVisibility != Visibilities.PUBLIC) - buffer.append(' ').append(newVisibility.toString()).append(' '); - } - else { - if (newVisibility != null && newVisibility != Visibilities.INTERNAL) - buffer.append(newVisibility.toString()).append(' '); - - buffer.append(JetTokens.FUN_KEYWORD).append(' ').append(newName); - } - - buffer.append(getNewParametersSignature(inheritedFunction, buffer.length())); - - if (newReturnType != null && !KotlinBuiltIns.isUnit(newReturnType) && !isConstructor()) - buffer.append(": ").append(newReturnTypeText); - - return buffer.toString(); + private fun getCurrentPsiMethod(): PsiMethod? { + val psiMethods = getMethod().toLightMethods() + assert(psiMethods.size() <= 1) { "Multiple light methods: " + getMethod().getText() } + return psiMethods.firstOrNull() } - public boolean isRefactoringTarget(FunctionDescriptor inheritedFunctionDescriptor) { - return inheritedFunctionDescriptor != null && - getMethod() == DescriptorToSourceUtils.descriptorToDeclaration(inheritedFunctionDescriptor); + public fun getOldParameterIndex(oldParameterName: String): Int? = oldNameToParameterIndex[oldParameterName] + + override fun isParameterTypesChanged(): Boolean = true + + override fun isParameterNamesChanged(): Boolean = true + + override fun isParameterSetOrOrderChanged(): Boolean = isParameterSetOrOrderChanged + + public fun getNewParametersCount(): Int = newParameters.size() + + override fun getNewParameters(): Array = newParameters.copyToArray() + + public fun setNewParameter(index: Int, parameterInfo: JetParameterInfo) { + newParameters.set(index, parameterInfo) } - public String getNewParametersSignature( - @NotNull JetFunctionDefinitionUsage inheritedFunction, - int indentLength - ) { - boolean isLambda = inheritedFunction.getDeclaration() instanceof JetFunctionLiteral; - if (isLambda && newParameters.size() == 1 && !newParameters.get(0).requiresExplicitType(inheritedFunction)) { - return newParameters.get(0).getDeclarationSignature(0, inheritedFunction); - } - - StringBuilder buffer = new StringBuilder("("); - String indent = StringUtil.repeatSymbol(' ', indentLength + 1); - - for (int i = 0; i < newParameters.size(); i++) { - JetParameterInfo parameterInfo = newParameters.get(i); - if (i > 0) { - buffer.append(","); - buffer.append(indent); - } - - buffer.append(parameterInfo.getDeclarationSignature(i, inheritedFunction)); - } - - buffer.append(")"); - return buffer.toString(); + public fun addParameter(parameterInfo: JetParameterInfo) { + newParameters.add(parameterInfo) } - private boolean innerParameterSetOrOrderChanged() { - if (newParameters.size() != oldDescriptor.getParametersCount()) - return true; - - for (int i = 0; i < newParameters.size(); i ++) { - if (newParameters.get(i).getOldIndex() != i) - return true; - } - - return false; - } - - private Map initOldNameToParameterIndex() { - Map map = new HashMap(); - FunctionDescriptor descriptor = oldDescriptor.getBaseDescriptor(); - - if (descriptor != null) { - List parameters = descriptor.getValueParameters(); - - for (int i = 0; i < parameters.size(); i++) { - ValueParameterDescriptor oldParameter = parameters.get(i); - map.put(oldParameter.getName().asString(), i); - } - } - - return map; - } - - public int getNewParametersCount() { - return newParameters.size(); - } - - @NotNull - @Override - public JetParameterInfo[] getNewParameters() { - return newParameters.toArray(new JetParameterInfo[newParameters.size()]); - } - - public void setNewParameter(int index, JetParameterInfo parameterInfo) { - newParameters.set(index, parameterInfo); - } - - public void addParameter(JetParameterInfo parameterInfo) { - newParameters.add(parameterInfo); - } - - public void removeParameter(int index) { + public fun removeParameter(index: Int) { newParameters.remove(index); } - @Override - public boolean isParameterSetOrOrderChanged() { - if (parameterNamesChanged == null) - parameterNamesChanged = innerParameterSetOrOrderChanged(); + override fun isGenerateDelegate(): Boolean = false - return parameterNamesChanged; + override fun getNewName(): String = name + + fun setNewName(value: String) { + name = value } - @Nullable - public Integer getOldParameterIndex(String oldParameterName) { - if (oldNameToParameterIndex == null) - oldNameToParameterIndex = initOldNameToParameterIndex(); + override fun isNameChanged(): Boolean = name != methodDescriptor.getName() - return oldNameToParameterIndex.get(oldParameterName); + public fun isVisibilityChanged(): Boolean = newVisibility != methodDescriptor.getVisibility() + + override fun getMethod(): PsiElement { + return methodDescriptor.getMethod() } - @Override - public boolean isParameterTypesChanged() { - return true; + override fun isReturnTypeChanged(): Boolean = newReturnTypeText != methodDescriptor.renderOriginalReturnType() + + override fun getLanguage(): Language = JetLanguage.INSTANCE + + public fun getNewSignature(inheritedFunction: JetFunctionDefinitionUsage): String { + val buffer = StringBuilder() + + if (isConstructor) { + buffer.append(name) + + if (newVisibility != Visibilities.PUBLIC) { + buffer.append(' ').append(newVisibility).append(' ') + } + } + else { + if (newVisibility != Visibilities.INTERNAL) { + buffer.append(newVisibility).append(' ') + } + + buffer.append(JetTokens.FUN_KEYWORD).append(' ').append(name) + } + + buffer.append(getNewParametersSignature(inheritedFunction, buffer.length())) + + if (newReturnType != null && !KotlinBuiltIns.isUnit(newReturnType) && !isConstructor) + buffer.append(": ").append(newReturnTypeText) + + return buffer.toString() } - @Override - public boolean isParameterNamesChanged() { - return true; + public fun isRefactoringTarget(inheritedFunctionDescriptor: FunctionDescriptor?): Boolean { + return inheritedFunctionDescriptor != null + && getMethod() == DescriptorToSourceUtils.descriptorToDeclaration(inheritedFunctionDescriptor) } - @Override - public boolean isGenerateDelegate() { - return false; + public fun getNewParametersSignature(inheritedFunction: JetFunctionDefinitionUsage, indentLength: Int): String { + val isLambda = inheritedFunction.getDeclaration() is JetFunctionLiteral + if (isLambda && newParameters.size() == 1 && !newParameters.get(0).requiresExplicitType(inheritedFunction)) { + return newParameters.get(0).getDeclarationSignature(0, inheritedFunction) + } + + val indent = StringUtil.repeatSymbol(' ', indentLength + 1) + return newParameters.indices + .map { i -> newParameters[i].getDeclarationSignature(i, inheritedFunction) } + .joinToString(prefix = "(", separator = ",$indent", postfix = ")") } - public void setNewName(String newName) { - this.newName = newName; + public fun renderReturnType(inheritedFunction: JetFunctionDefinitionUsage): String { + val typeSubstitutor = inheritedFunction.getOrCreateTypeSubstitutor() ?: return newReturnTypeText + val currentBaseFunction = inheritedFunction.getBaseFunction().getCurrentFunctionDescriptor() ?: return newReturnTypeText + return currentBaseFunction.getReturnType().renderTypeWithSubstitution(typeSubstitutor, newReturnTypeText, false) } - @Override - public boolean isNameChanged() { - return !newName.equals(oldDescriptor.getName()); + public fun primaryMethodUpdated() { + isPrimaryMethodUpdated = true + javaChangeInfo = null } - public boolean isVisibilityChanged() { - return !newVisibility.equals(oldDescriptor.getVisibility()); - } - - public Visibility getNewVisibility() { - return newVisibility; - } - - public void setNewVisibility(Visibility newVisibility) { - this.newVisibility = newVisibility; - } - - @Override - public PsiElement getMethod() { - return oldDescriptor.getMethod(); - } - - @Nullable - public FunctionDescriptor getOldDescriptor() { - return oldDescriptor.getBaseDescriptor(); - } - - public JetMethodDescriptor getFunctionDescriptor() { - return oldDescriptor; - } - - public boolean isConstructor() { - return ChangeSignaturePackage.getIsConstructor(oldDescriptor); - } - - public void setNewReturnTypeText(String newReturnTypeText) { - this.newReturnTypeText = newReturnTypeText; - } - - @Override - public boolean isReturnTypeChanged() { - return !newReturnTypeText.equals(ChangeSignaturePackage.renderOriginalReturnType(oldDescriptor)); - } - - @Nullable - public String getOldName() { - PsiElement function = oldDescriptor.getMethod(); - return function instanceof JetFunction ? ((JetFunction) function).getName() : null; - } - - @Override - public String getNewName() { - return newName; - } - - public PsiElement getContext() { - return context; - } - - @Override - public Language getLanguage() { - return JetLanguage.INSTANCE; - } - - @NotNull - public Collection getAffectedFunctions() { - return oldDescriptor.getAffectedFunctions(); - } - - public String renderReturnType(@NotNull JetFunctionDefinitionUsage inheritedFunction) { - TypeSubstitutor typeSubstitutor = inheritedFunction.getOrCreateTypeSubstitutor(); - if (typeSubstitutor == null) return newReturnTypeText; - - FunctionDescriptor currentBaseFunction = inheritedFunction.getBaseFunction().getCurrentFunctionDescriptor(); - if (currentBaseFunction == null) return newReturnTypeText; - - JetType originalType = currentBaseFunction.getReturnType(); - return ChangeSignaturePackage.renderTypeWithSubstitution(originalType, typeSubstitutor, newReturnTypeText, false); - } - - @Nullable - public JavaChangeInfo getOrCreateJavaChangeInfo() { + public fun getOrCreateJavaChangeInfo(): JavaChangeInfo? { if (javaChangeInfo == null) { - final PsiMethod currentPsiMethod = getCurrentPsiMethod(); - if (originalPsiMethod == null || currentPsiMethod == null) return null; + val currentPsiMethod = getCurrentPsiMethod() + if (originalPsiMethod == null || currentPsiMethod == null) return null /* * When primaryMethodUpdated is false, changes to the primary Kotlin declaration are already confirmed, but not yet applied. @@ -328,94 +193,77 @@ public class JetChangeInfo implements ChangeInfo { * to use in JavaChangeInfo. However they are not actually used at this point since only parameter count and order matters here * So we resort to this hack and pass around "default" type (void) and visibility (package-local) */ - String javaVisibility = primaryMethodUpdated - ? VisibilityUtil.getVisibilityModifier(currentPsiMethod.getModifierList()) - : PsiModifier.PACKAGE_LOCAL; + val javaVisibility = if (isPrimaryMethodUpdated) + VisibilityUtil.getVisibilityModifier(currentPsiMethod.getModifierList()) + else + PsiModifier.PACKAGE_LOCAL - JetParameterInfo[] newParameters = getNewParameters(); - ParameterInfoImpl[] newJavaParameters = ContainerUtil.map2Array( - KotlinPackage.withIndices(newParameters), - new ParameterInfoImpl[newParameters.length], - new Function, ParameterInfoImpl>() { - @Override - public ParameterInfoImpl fun(Pair pair) { - JetParameterInfo info = pair.getSecond(); - PsiType type = primaryMethodUpdated - ? currentPsiMethod.getParameterList().getParameters()[pair.getFirst()].getType() - : PsiType.VOID; - return new ParameterInfoImpl(info.getOldIndex(), info.getName(), type, info.getDefaultValueForCall()); - } - } - ); + val newJavaParameters = newParameters.withIndices().map { pair -> + val (i, info) = pair + val type = if (isPrimaryMethodUpdated) + currentPsiMethod.getParameterList().getParameters()[i].getType() + else + PsiType.VOID + ParameterInfoImpl(info.getOldIndex(), info.getName(), type, info.defaultValueForCall) + }.copyToArray() - PsiType returnType = primaryMethodUpdated ? currentPsiMethod.getReturnType() : PsiType.VOID; + val returnType = if (isPrimaryMethodUpdated) currentPsiMethod.getReturnType() else PsiType.VOID - javaChangeInfo = new ChangeSignatureProcessor( - getMethod().getProject(), originalPsiMethod, false, javaVisibility, getNewName(), returnType, newJavaParameters - ).getChangeInfo(); - javaChangeInfo.updateMethod(currentPsiMethod); + javaChangeInfo = ChangeSignatureProcessor(getMethod().getProject(), + originalPsiMethod, + false, + javaVisibility, + getNewName(), + returnType, + newJavaParameters).getChangeInfo() + javaChangeInfo!!.updateMethod(currentPsiMethod) } - return javaChangeInfo; - } - - public void primaryMethodUpdated() { - primaryMethodUpdated = true; - javaChangeInfo = null; - } - - @NotNull - public static JetChangeInfo fromJavaChangeInfo( - @NotNull ChangeInfo javaChangeInfo, - @NotNull JetMethodDescriptor originalChangeSignatureDescriptor - ) { - PsiMethod method = (PsiMethod) javaChangeInfo.getMethod(); - - FunctionDescriptor functionDescriptor = ResolvePackage.getJavaMethodDescriptor(method); - final List parameterDescriptors = functionDescriptor.getValueParameters(); - - //noinspection ConstantConditions - final List originalParameterDescriptors = - originalChangeSignatureDescriptor.getBaseDescriptor().getValueParameters(); - - - List newParameters = KotlinPackage.map( - KotlinPackage.withIndices(javaChangeInfo.getNewParameters()), - new Function1, JetParameterInfo>() { - @Override - public JetParameterInfo invoke(Pair pair) { - ParameterInfo info = pair.getSecond(); - int oldIndex = info.getOldIndex(); - JetType currentType = parameterDescriptors.get(pair.getFirst()).getType(); - JetType originalType = oldIndex >= 0 - ? originalParameterDescriptors.get(oldIndex).getType() - : currentType; - String defaultValue = info.getDefaultValue(); - - JetParameterInfo jetParameterInfo = - new JetParameterInfo(oldIndex, - info.getName(), - originalType, null, - defaultValue != null ? defaultValue : "", - null, - null); - jetParameterInfo.setCurrentTypeText(IdeDescriptorRenderers.SOURCE_CODE.renderType(currentType)); - return jetParameterInfo; - } - } - ); - - JetType returnType = functionDescriptor.getReturnType(); - String returnTypeText = returnType != null ? IdeDescriptorRenderers.SOURCE_CODE.renderType(returnType) : ""; - - return new JetChangeInfo( - originalChangeSignatureDescriptor, - javaChangeInfo.getNewName(), - returnType, - returnTypeText, - functionDescriptor.getVisibility(), - newParameters, - method - ); + return javaChangeInfo } } + +public val JetChangeInfo.originalBaseFunctionDescriptor: FunctionDescriptor + get() = methodDescriptor.baseDescriptor + +public val JetChangeInfo.isConstructor: Boolean get() = methodDescriptor.isConstructor + +public val JetChangeInfo.oldName: String? + get() = (methodDescriptor.getMethod() as? JetFunction)?.getName() + +public val JetChangeInfo.affectedFunctions: Collection get() = methodDescriptor.affectedFunctions + +public fun ChangeInfo.toJetChangeInfo(originalChangeSignatureDescriptor: JetMethodDescriptor): JetChangeInfo { + val method = getMethod() as PsiMethod + + val functionDescriptor = method.getJavaMethodDescriptor() + val parameterDescriptors = functionDescriptor.getValueParameters() + + //noinspection ConstantConditions + val originalParameterDescriptors = originalChangeSignatureDescriptor.baseDescriptor.getValueParameters() + + val newParameters = getNewParameters().withIndices().map { pair -> + val (i, info) = pair + val oldIndex = info.getOldIndex() + val currentType = parameterDescriptors[i].getType() + + with(JetParameterInfo(originalIndex = oldIndex, + name = info.getName(), + type = if (oldIndex >= 0) originalParameterDescriptors[oldIndex].getType() else currentType, + defaultValueForCall = info.getDefaultValue() ?: "")) { + currentTypeText = IdeDescriptorRenderers.SOURCE_CODE.renderType(currentType) + this + } + } + + val returnType = functionDescriptor.getReturnType() + val returnTypeText = if (returnType != null) IdeDescriptorRenderers.SOURCE_CODE.renderType(returnType) else "" + + return JetChangeInfo(originalChangeSignatureDescriptor, + getNewName(), + returnType, + returnTypeText, + functionDescriptor.getVisibility(), + newParameters, + method) +} \ No newline at end of file diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeSignatureProcessor.java b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeSignatureProcessor.java index efac889fefb..709b1c82064 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeSignatureProcessor.java +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeSignatureProcessor.java @@ -48,7 +48,7 @@ public class JetChangeSignatureProcessor extends ChangeSignatureProcessorBase { @NotNull @Override protected UsageViewDescriptor createUsageViewDescriptor(UsageInfo[] usages) { - String subject = getChangeInfo().isConstructor() ? "constructor" : "function"; + String subject = ChangeSignaturePackage.getIsConstructor(getChangeInfo()) ? "constructor" : "function"; return new JetUsagesViewDescriptor(myChangeInfo.getMethod(), RefactoringBundle.message("0.to.change.signature", subject)); } diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeSignatureUsageProcessor.java b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeSignatureUsageProcessor.java index 8312b64c78b..3f31e4eb5a2 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeSignatureUsageProcessor.java +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeSignatureUsageProcessor.java @@ -69,7 +69,7 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro } private static void findAllMethodUsages(JetChangeInfo changeInfo, Set result) { - for (UsageInfo functionUsageInfo : changeInfo.getAffectedFunctions()) { + for (UsageInfo functionUsageInfo : ChangeSignaturePackage.getAffectedFunctions(changeInfo)) { if (functionUsageInfo instanceof JetFunctionDefinitionUsage) { findOneMethodUsages((JetFunctionDefinitionUsage) functionUsageInfo, changeInfo, result); } @@ -111,7 +111,7 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro } } - String oldName = changeInfo.getOldName(); + String oldName = ChangeSignaturePackage.getOldName(changeInfo); if (oldName != null) TextOccurrencesUtil.findNonCodeUsages(functionPsi, oldName, true, true, changeInfo.getNewName(), result); @@ -203,7 +203,7 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro PsiElement function = info.getMethod(); PsiElement element = function != null ? function : changeInfo.getContext(); BindingContext bindingContext = ResolvePackage.analyze((JetElement) element); - FunctionDescriptor oldDescriptor = changeInfo.getOldDescriptor(); + FunctionDescriptor oldDescriptor = ChangeSignaturePackage.getOriginalBaseFunctionDescriptor(changeInfo); JetScope parametersScope = null; DeclarationDescriptor containingDeclaration = oldDescriptor != null ? oldDescriptor.getContainingDeclaration() : null; @@ -214,7 +214,7 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro JetScope functionScope = getFunctionScope(bindingContext, containingDeclaration); - if (!changeInfo.isConstructor() && functionScope != null && !info.getNewName().isEmpty()) { + if (!ChangeSignaturePackage.getIsConstructor(changeInfo) && functionScope != null && !info.getNewName().isEmpty()) { for (FunctionDescriptor conflict : functionScope.getFunctions(Name.identifier(info.getNewName()))) { if (conflict == oldDescriptor) continue; @@ -236,7 +236,7 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro result.putValue(element, "Duplicating parameter '" + parameterName + "'"); } if (parametersScope != null) { - if (changeInfo.isConstructor() && valOrVar != JetValVar.None) { + if (ChangeSignaturePackage.getIsConstructor(changeInfo) && valOrVar != JetValVar.None) { for (VariableDescriptor property : parametersScope.getProperties(Name.identifier(parameterName))) { PsiElement propertyDeclaration = DescriptorToSourceUtils.descriptorToDeclaration(property); @@ -320,7 +320,7 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro private final JetFunctionDefinitionUsage delegateUsage = new JetFunctionDefinitionUsage( samUsage.getFunctionLiteral(), samUsage.getFunctionDescriptor(), - javaMethodChangeInfo.getFunctionDescriptor().getOriginalPrimaryFunction(), + javaMethodChangeInfo.getMethodDescriptor().getOriginalPrimaryFunction(), samUsage.getSamCallType() ); @@ -453,7 +453,7 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro if (element == null) return false; if (isJavaMethodUsage && originalJavaMethodDescriptor != null) { - JetChangeInfo javaMethodChangeInfo = JetChangeInfo.fromJavaChangeInfo(changeInfo, originalJavaMethodDescriptor); + JetChangeInfo javaMethodChangeInfo = ChangeSignaturePackage.toJetChangeInfo(changeInfo, originalJavaMethodDescriptor); originalJavaMethodDescriptor = null; for (int i = 0; i < usages.length; i++) { @@ -493,7 +493,7 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro if (!(changeInfo instanceof JetChangeInfo)) return false; JetChangeInfo jetChangeInfo = (JetChangeInfo) changeInfo; - for (JetFunctionDefinitionUsage primaryFunction : jetChangeInfo.getFunctionDescriptor().getPrimaryFunctions()) { + for (JetFunctionDefinitionUsage primaryFunction : jetChangeInfo.getMethodDescriptor().getPrimaryFunctions()) { primaryFunction.processUsage(jetChangeInfo, primaryFunction.getDeclaration()); } jetChangeInfo.primaryMethodUpdated(); diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/usages/JavaMethodKotlinUsageWithDelegate.kt b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/usages/JavaMethodKotlinUsageWithDelegate.kt index 0de894f1b7b..fe3336a8467 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/usages/JavaMethodKotlinUsageWithDelegate.kt +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/usages/JavaMethodKotlinUsageWithDelegate.kt @@ -35,7 +35,7 @@ public abstract class JavaMethodKotlinUsageWithDelegate( public class JavaMethodKotlinCallUsage( callElement: JetCallElement, javaMethodChangeInfo: JetChangeInfo): JavaMethodKotlinUsageWithDelegate(callElement, javaMethodChangeInfo) { - override protected val delegateUsage = JetFunctionCallUsage(psiElement, javaMethodChangeInfo.getFunctionDescriptor().originalPrimaryFunction) + override protected val delegateUsage = JetFunctionCallUsage(psiElement, javaMethodChangeInfo.methodDescriptor.originalPrimaryFunction) } public class JavaMethodKotlinDerivedDefinitionUsage( @@ -46,7 +46,7 @@ public class JavaMethodKotlinDerivedDefinitionUsage( override protected val delegateUsage = JetFunctionDefinitionUsage( psiElement, functionDescriptor, - javaMethodChangeInfo.getFunctionDescriptor().originalPrimaryFunction, + javaMethodChangeInfo.methodDescriptor.originalPrimaryFunction, null ) } diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/usages/JetEnumEntryWithoutSuperCallUsage.kt b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/usages/JetEnumEntryWithoutSuperCallUsage.kt index de6b87afbaa..6387990a915 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/usages/JetEnumEntryWithoutSuperCallUsage.kt +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/usages/JetEnumEntryWithoutSuperCallUsage.kt @@ -35,7 +35,7 @@ public class JetEnumEntryWithoutSuperCallUsage(enumEntry: JetEnumEntry) : JetUsa ) as JetDelegatorToSuperCall element.addBefore(psiFactory.createColon(), delegatorToSuperCall) - return JetFunctionCallUsage(delegatorToSuperCall, changeInfo.getFunctionDescriptor().originalPrimaryFunction) + return JetFunctionCallUsage(delegatorToSuperCall, changeInfo.methodDescriptor.originalPrimaryFunction) .processUsage(changeInfo, delegatorToSuperCall) } diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/usages/JetFunctionDefinitionUsage.java b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/usages/JetFunctionDefinitionUsage.java index 0abdf6f084a..4f848e100d3 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/usages/JetFunctionDefinitionUsage.java +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/usages/JetFunctionDefinitionUsage.java @@ -175,7 +175,7 @@ public class JetFunctionDefinitionUsage extends JetUsageIn || function.getTypeReference() != null; if (changeInfo.isReturnTypeChanged() && returnTypeIsNeeded) { function.setTypeReference(null); - String returnTypeText = changeInfo.renderReturnType(this); + String returnTypeText = changeInfo.renderReturnType((JetFunctionDefinitionUsage) this); //TODO use ChangeFunctionReturnTypeFix.invoke when JetTypeCodeFragment.getType() is ready if (!KotlinBuiltIns.getInstance().getUnitType().toString().equals(returnTypeText)) { @@ -203,11 +203,15 @@ public class JetFunctionDefinitionUsage extends JetUsageIn } } else { - newParameterList = psiFactory.createFunctionLiteralParameterList(changeInfo.getNewParametersSignature(this, 0)); + newParameterList = psiFactory.createFunctionLiteralParameterList(changeInfo.getNewParametersSignature( + (JetFunctionDefinitionUsage) this, 0) + ); } } else { - newParameterList = psiFactory.createParameterList(changeInfo.getNewParametersSignature(this, 0)); + newParameterList = psiFactory.createParameterList(changeInfo.getNewParametersSignature( + (JetFunctionDefinitionUsage) this, 0) + ); } if (newParameterList != null) { diff --git a/idea/tests/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeSignatureTest.java b/idea/tests/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeSignatureTest.java index 7abdee7b00e..e241b73f61d 100644 --- a/idea/tests/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeSignatureTest.java +++ b/idea/tests/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeSignatureTest.java @@ -241,7 +241,7 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase { BindingContext context = ResolvePackage.analyze(method); ChangeSignaturePackage - .runChangeSignature(getProject(), changeInfo.getOldDescriptor(), empty, context, method, "test"); + .runChangeSignature(getProject(), ChangeSignaturePackage.getOriginalBaseFunctionDescriptor(changeInfo), empty, context, method, "test"); } catch (RuntimeException e) { assertTrue(e.getMessage().startsWith("Refactoring cannot be")); @@ -318,7 +318,8 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase { public void testFunctionJavaUsagesAndOverridesAddParam() throws Exception { JetChangeInfo changeInfo = getChangeInfo(); changeInfo.addParameter(new JetParameterInfo(-1, "s", KotlinBuiltIns.getInstance().getStringType(), null, "\"abc\"", null, null)); - changeInfo.addParameter(new JetParameterInfo(-1, "o", KotlinBuiltIns.getInstance().getNullableAnyType(), null, "\"def\"", null, null)); + changeInfo.addParameter(new JetParameterInfo(-1, "o", KotlinBuiltIns.getInstance().getNullableAnyType(), null, "\"def\"", null, + null)); doTest(changeInfo); }