From 6544294f8f8bad0e17e16c33435cff23a1cdf82d Mon Sep 17 00:00:00 2001 From: Alexey Sedunov Date: Mon, 8 Dec 2014 18:48:44 +0300 Subject: [PATCH] Change Signature: Translate JetParameterInfo to Kotlin --- .../quickfix/AddFunctionParametersFix.java | 8 +- .../ChangeFunctionLiteralSignatureFix.java | 2 +- .../quickfix/ChangeFunctionSignatureFix.java | 4 +- .../CreateParameterActionFactory.kt | 4 +- ...teParameterByNamedArgumentActionFactory.kt | 7 +- .../changeSignature/JetChangeInfo.java | 14 +- .../changeSignature/JetChangeSignatureData.kt | 17 +- .../JetChangeSignatureDialog.java | 10 +- .../JetConstructorParameterTableModel.java | 2 +- .../JetFunctionParameterTableModel.java | 6 +- .../changeSignature/JetParameterInfo.kt | 266 ++++++------------ .../refactoring/changeSignature/JetValVar.kt | 12 + .../usages/JetFunctionCallUsage.java | 4 +- .../usages/JetFunctionDefinitionUsage.java | 5 +- .../JetChangeSignatureTest.java | 65 ++--- 15 files changed, 171 insertions(+), 255 deletions(-) diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/AddFunctionParametersFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/AddFunctionParametersFix.java index 656b8e32503..d87defa07f9 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/AddFunctionParametersFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/AddFunctionParametersFix.java @@ -137,16 +137,18 @@ public class AddFunctionParametersFix extends ChangeFunctionSignatureFix { JetType parameterType = parameters.get(i).getType(); if (argumentType != null && !JetTypeChecker.DEFAULT.isSubtypeOf(argumentType, parameterType)) { - changeSignatureData.getParameters().get(i).setTypeText(IdeDescriptorRenderers.SOURCE_CODE.renderType(argumentType)); + changeSignatureData.getParameters().get(i).setCurrentTypeText( + IdeDescriptorRenderers.SOURCE_CODE.renderType(argumentType) + ); typesToShorten.add(argumentType); } } else { JetParameterInfo parameterInfo = getNewParameterInfo(bindingContext, argument, validator); - typesToShorten.add(parameterInfo.getType()); + typesToShorten.add(parameterInfo.getOriginalType()); if (expression != null) { - parameterInfo.setDefaultValueText(expression.getText()); + parameterInfo.setDefaultValueForCall(expression.getText()); } changeSignatureData.addParameter(parameterInfo); diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionLiteralSignatureFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionLiteralSignatureFix.java index 8710ad7c81b..d963214ccc5 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionLiteralSignatureFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionLiteralSignatureFix.java @@ -66,7 +66,7 @@ public class ChangeFunctionLiteralSignatureFix extends ChangeFunctionSignatureFi changeSignatureData.clearParameters(); for (JetType type : parameterTypes) { String name = JetNameSuggester.suggestNames(type, validator, "param")[0]; - changeSignatureData.addParameter(new JetParameterInfo(name, type)); + changeSignatureData.addParameter(new JetParameterInfo(-1, name, type, null, "", null, null)); } } diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionSignatureFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionSignatureFix.java index e5648d5d867..f10a4d180d0 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionSignatureFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/ChangeFunctionSignatureFix.java @@ -117,8 +117,8 @@ public abstract class ChangeFunctionSignatureFix extends JetIntentionAction() as? JetClass } diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/createFromUsage/createVariable/CreateParameterByNamedArgumentActionFactory.kt b/idea/src/org/jetbrains/jet/plugin/quickfix/createFromUsage/createVariable/CreateParameterByNamedArgumentActionFactory.kt index ce514fb2a4d..1ce493e18db 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/createFromUsage/createVariable/CreateParameterByNamedArgumentActionFactory.kt +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/createFromUsage/createVariable/CreateParameterByNamedArgumentActionFactory.kt @@ -59,8 +59,11 @@ public object CreateParameterByNamedArgumentActionFactory: JetSingleIntentionAct } ?: anyType if (paramType.hasTypeParametersToAdd(functionDescriptor, context)) return null - val parameterInfo = JetParameterInfo(name, paramType) - parameterInfo.setDefaultValueText(argumentExpression.getText() ?: "") + val parameterInfo = JetParameterInfo( + name = name, + type = paramType, + defaultValueForCall = argumentExpression.getText() ?: "" + ) return CreateParameterFromUsageFix(functionDescriptor, context, parameterInfo, argument) } } \ No newline at end of file diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeInfo.java b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeInfo.java index 10f6593042a..34720ce21e3 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeInfo.java +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeInfo.java @@ -343,7 +343,7 @@ public class JetChangeInfo implements ChangeInfo { PsiType type = primaryMethodUpdated ? currentPsiMethod.getParameterList().getParameters()[pair.getFirst()].getType() : PsiType.VOID; - return new ParameterInfoImpl(info.getOldIndex(), info.getName(), type, info.getDefaultValueText()); + return new ParameterInfoImpl(info.getOldIndex(), info.getName(), type, info.getDefaultValueForCall()); } } ); @@ -390,10 +390,16 @@ public class JetChangeInfo implements ChangeInfo { JetType originalType = oldIndex >= 0 ? originalParameterDescriptors.get(oldIndex).getType() : currentType; + String defaultValue = info.getDefaultValue(); - JetParameterInfo jetParameterInfo = new JetParameterInfo(oldIndex, info.getName(), originalType, null, null); - jetParameterInfo.setDefaultValueText(info.getDefaultValue()); - jetParameterInfo.setTypeText(IdeDescriptorRenderers.SOURCE_CODE.renderType(currentType)); + JetParameterInfo jetParameterInfo = + new JetParameterInfo(oldIndex, + info.getName(), + originalType, null, + defaultValue != null ? defaultValue : "", + null, + null); + jetParameterInfo.setCurrentTypeText(IdeDescriptorRenderers.SOURCE_CODE.renderType(currentType)); return jetParameterInfo; } } diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeSignatureData.kt b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeSignatureData.kt index f6775f69570..e88e3910964 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeSignatureData.kt +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeSignatureData.kt @@ -40,7 +40,7 @@ public class JetChangeSignatureData( ) : JetMethodDescriptor { private val parameters: MutableList - ;{ + ;{ val valueParameters = when { baseDeclaration is JetFunction -> baseDeclaration.getValueParameters() baseDeclaration is JetClass -> baseDeclaration.getPrimaryConstructorParameters() @@ -48,15 +48,14 @@ public class JetChangeSignatureData( } parameters = baseDescriptor.getValueParameters().mapTo(ArrayList()) { parameterDescriptor -> val jetParameter = valueParameters?.get(parameterDescriptor.getIndex()) - val parameterInfo = JetParameterInfo( - parameterDescriptor.getIndex(), - parameterDescriptor.getName().asString(), - parameterDescriptor.getType(), - jetParameter?.getDefaultValue(), - jetParameter?.getValOrVarNode() + JetParameterInfo( + originalIndex = parameterDescriptor.getIndex(), + name = parameterDescriptor.getName().asString(), + type = parameterDescriptor.getType(), + defaultValueForParameter = jetParameter?.getDefaultValue(), + valOrVarNode = jetParameter?.getValOrVarNode(), + modifierList = jetParameter?.getModifierList() ) - parameterInfo.setModifierList(jetParameter?.getModifierList()) - parameterInfo } } diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeSignatureDialog.java b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeSignatureDialog.java index e65bfc064df..eb85baf41e3 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeSignatureDialog.java +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeSignatureDialog.java @@ -223,7 +223,7 @@ public class JetChangeSignatureDialog extends ChangeSignatureDialogBase< protected JBTableRowEditor getTableEditor(final JTable t, final ParameterTableModelItemBase item) { return new JBTableRowEditor() { private final List components = new ArrayList(); - private final boolean defaultValueColumnEnabled = item.parameter.isNewParameter(); + private final boolean defaultValueColumnEnabled = item.parameter.getIsNewParameter(); @Override public void prepareEditor(JTable table, final int row) { @@ -414,8 +414,8 @@ public class JetChangeSignatureDialog extends ChangeSignatureDialogBase< for (int i = 0; i < parameters.size(); i++) { JetParameterInfo parameter = parameters.get(i); - parameter.setTypeText(myParametersTableModel.getItems().get(i).typeCodeFragment.getText().trim()); - parameter.setDefaultValueText(myParametersTableModel.getItems().get(i).defaultValueCodeFragment.getText().trim()); + parameter.setCurrentTypeText(myParametersTableModel.getItems().get(i).typeCodeFragment.getText().trim()); + parameter.setDefaultValueForCall(myParametersTableModel.getItems().get(i).defaultValueCodeFragment.getText().trim()); } String returnTypeText = myReturnTypeCodeFragment != null ? myReturnTypeCodeFragment.getText().trim() : ""; @@ -429,9 +429,7 @@ public class JetChangeSignatureDialog extends ChangeSignatureDialogBase< List parameters = myMethod.getParameters(); for (int i = 0; i < parameters.size(); i++) { JetParameterInfo info = parameters.get(i); - if (info.isNewParameter()) { - return i; - } + if (info.getIsNewParameter()) return i; } return super.getSelectedIdx(); } diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetConstructorParameterTableModel.java b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetConstructorParameterTableModel.java index 0d8631efa52..8f12e10cdcb 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetConstructorParameterTableModel.java +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetConstructorParameterTableModel.java @@ -48,7 +48,7 @@ public class JetConstructorParameterTableModel extends JetFunctionParameterTable @Override public boolean isCellEditable(ParameterTableModelItemBase item) { - return !item.isEllipsisType() && item.parameter.isNewParameter(); + return !item.isEllipsisType() && item.parameter.getIsNewParameter(); } @Override diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetFunctionParameterTableModel.java b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetFunctionParameterTableModel.java index 2105972f5e0..d017c46b1cc 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetFunctionParameterTableModel.java +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetFunctionParameterTableModel.java @@ -46,11 +46,11 @@ public class JetFunctionParameterTableModel extends ParameterTableModelBase createRowItem(@Nullable JetParameterInfo parameterInfo) { if (parameterInfo == null) { - parameterInfo = new JetParameterInfo(-1); + parameterInfo = new JetParameterInfo(-1, "", null, null, "", null, null); } JetPsiFactory psiFactory = JetPsiFactory(project); - final PsiCodeFragment paramTypeCodeFragment = psiFactory.createTypeCodeFragment(parameterInfo.getTypeText(), myTypeContext); - final PsiCodeFragment defaultValueCodeFragment = psiFactory.createExpressionCodeFragment(parameterInfo.getDefaultValueText(), myDefaultValueContext); + PsiCodeFragment paramTypeCodeFragment = psiFactory.createTypeCodeFragment(parameterInfo.getTypeText(), myTypeContext); + PsiCodeFragment defaultValueCodeFragment = psiFactory.createExpressionCodeFragment(parameterInfo.getDefaultValueForCall(), myDefaultValueContext); return new ParameterTableModelItemBase(parameterInfo, paramTypeCodeFragment, defaultValueCodeFragment) { @Override public boolean isEllipsisType() { diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetParameterInfo.kt b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetParameterInfo.kt index fe18e58b5a9..632ec893962 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetParameterInfo.kt +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetParameterInfo.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,212 +14,118 @@ * limitations under the License. */ -package org.jetbrains.jet.plugin.refactoring.changeSignature; +package org.jetbrains.jet.plugin.refactoring.changeSignature -import com.intellij.lang.ASTNode; -import com.intellij.refactoring.changeSignature.ParameterInfo; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; -import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; -import org.jetbrains.jet.lang.descriptors.impl.AnonymousFunctionDescriptor; -import org.jetbrains.jet.lang.psi.JetExpression; -import org.jetbrains.jet.lang.psi.JetModifierList; -import org.jetbrains.jet.lang.psi.JetParameter; -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.lexer.JetTokens; -import org.jetbrains.jet.plugin.refactoring.changeSignature.usages.JetFunctionDefinitionUsage; -import org.jetbrains.jet.plugin.util.IdeDescriptorRenderers; +import com.intellij.lang.ASTNode +import com.intellij.refactoring.changeSignature.ParameterInfo +import org.jetbrains.jet.lang.psi.JetExpression +import org.jetbrains.jet.lang.types.JetType +import org.jetbrains.jet.plugin.util.IdeDescriptorRenderers +import org.jetbrains.jet.plugin.refactoring.changeSignature.usages.JetFunctionDefinitionUsage +import com.intellij.psi.PsiElement +import org.jetbrains.jet.lang.descriptors.impl.AnonymousFunctionDescriptor +import org.jetbrains.jet.lang.resolve.DescriptorToSourceUtils +import org.jetbrains.jet.lang.psi.JetParameter +import org.jetbrains.jet.lang.psi.JetModifierList -import java.util.List; +public class JetParameterInfo( + val originalIndex: Int = -1, + private var name: String, + type: JetType? = null, + var defaultValueForParameter: JetExpression? = null, + var defaultValueForCall: String = "", + valOrVarNode: ASTNode? = null, + val modifierList: JetModifierList? = null +): ParameterInfo { + val originalType: JetType? = type + var currentTypeText: String = getOldTypeText() + var valOrVar: JetValVar = valOrVarNode.toValVar() -public class JetParameterInfo implements ParameterInfo { - private String name = ""; - private final int oldIndex; - private JetType type; - private String typeText; - private String defaultValueText = ""; - private JetValVar valOrVar; - @Nullable private JetExpression defaultValue; - @Nullable JetModifierList modifierList; + private fun getOldTypeText() = originalType?.let { IdeDescriptorRenderers.SOURCE_CODE.renderType(it) } ?: "" - public JetParameterInfo(int oldIndex, String name, JetType type, @Nullable JetExpression defaultValue, @Nullable ASTNode valOrVar) { - this.oldIndex = oldIndex; - this.name = name; - this.type = type; - this.typeText = getOldTypeText(); - this.defaultValue = defaultValue; + override fun getOldIndex(): Int = originalIndex - if (valOrVar == null) - this.valOrVar = JetValVar.None; - else if (valOrVar.getElementType() == JetTokens.VAL_KEYWORD) - this.valOrVar = JetValVar.Val; - else if (valOrVar.getElementType() == JetTokens.VAR_KEYWORD) - this.valOrVar = JetValVar.Var; - else - throw new IllegalArgumentException("Unknown val/var token: " + valOrVar.getText()); + public val isNewParameter: Boolean + get() = originalIndex == -1 + + override fun getDefaultValue(): String? = null + + override fun getName(): String = name + + override fun setName(name: String?) { + this.name = name ?: "" } - public JetParameterInfo(String name, JetType type) { - this(-1, name, type, null, null); + override fun getTypeText(): String = currentTypeText + + public val isTypeChanged: Boolean get() = getOldTypeText() != currentTypeText + + override fun isUseAnySingleVariable(): Boolean = false + + override fun setUseAnySingleVariable(b: Boolean) { + throw UnsupportedOperationException() } - public JetParameterInfo(int index) { - oldIndex = index; - typeText = ""; - valOrVar = JetValVar.None; + public fun renderType(parameterIndex: Int, inheritedFunction: JetFunctionDefinitionUsage<*>): String { + val typeSubstitutor = inheritedFunction.getOrCreateTypeSubstitutor() ?: return currentTypeText + val currentBaseFunction = inheritedFunction.getBaseFunction().getCurrentFunctionDescriptor() ?: return currentTypeText + val parameterType = currentBaseFunction.getValueParameters().get(parameterIndex).getType() + return parameterType.renderTypeWithSubstitution(typeSubstitutor, currentTypeText, true) } - @Override - public String getName() { - return name; + public fun getInheritedName(inheritedFunction: JetFunctionDefinitionUsage): String { + if (!inheritedFunction.isInherited()) return name + + val baseFunction = inheritedFunction.getBaseFunction() + val baseFunctionDescriptor = baseFunction.getOriginalFunctionDescriptor() + + val inheritedFunctionDescriptor = inheritedFunction.getOriginalFunctionDescriptor() + val inheritedParameterDescriptors = inheritedFunctionDescriptor.getValueParameters() + if (originalIndex < 0 + || originalIndex >= baseFunctionDescriptor.getValueParameters().size() + || originalIndex >= inheritedParameterDescriptors.size()) return name + + val inheritedParamName = inheritedParameterDescriptors.get(originalIndex).getName().asString() + val oldParamName = baseFunctionDescriptor.getValueParameters().get(originalIndex).getName().asString() + + return when { + oldParamName == inheritedParamName && inheritedFunctionDescriptor !is AnonymousFunctionDescriptor -> name + else -> inheritedParamName + } } - public String renderType(int parameterIndex, @NotNull JetFunctionDefinitionUsage inheritedFunction) { - TypeSubstitutor typeSubstitutor = inheritedFunction.getOrCreateTypeSubstitutor(); - if (typeSubstitutor == null) return typeText; + public fun requiresExplicitType(inheritedFunction: JetFunctionDefinitionUsage): Boolean { + val inheritedFunctionDescriptor = inheritedFunction.getOriginalFunctionDescriptor() + if (inheritedFunctionDescriptor !is AnonymousFunctionDescriptor) return true - FunctionDescriptor currentBaseFunction = inheritedFunction.getBaseFunction().getCurrentFunctionDescriptor(); - if (currentBaseFunction == null) return typeText; + if (originalIndex < 0) return !inheritedFunction.hasExpectedType() - JetType parameterType = currentBaseFunction.getValueParameters().get(parameterIndex).getType(); - - return ChangeSignaturePackage.renderTypeWithSubstitution(parameterType, typeSubstitutor, typeText, true); + val inheritedParameterDescriptor = inheritedFunctionDescriptor.getValueParameters().get(originalIndex) + val parameter = DescriptorToSourceUtils.descriptorToDeclaration(inheritedParameterDescriptor) as? JetParameter ?: return false + return parameter.getTypeReference() != null } - public String getInheritedName(@NotNull JetFunctionDefinitionUsage inheritedFunction) { - if (!inheritedFunction.isInherited()) return name; - - JetFunctionDefinitionUsage baseFunction = inheritedFunction.getBaseFunction(); - FunctionDescriptor baseFunctionDescriptor = baseFunction.getOriginalFunctionDescriptor(); - - FunctionDescriptor inheritedFunctionDescriptor = inheritedFunction.getOriginalFunctionDescriptor(); - List inheritedParameterDescriptors = inheritedFunctionDescriptor.getValueParameters(); - if (oldIndex < 0 - || oldIndex >= baseFunctionDescriptor.getValueParameters().size() - || oldIndex >= inheritedParameterDescriptors.size()) return name; - - String inheritedParamName = inheritedParameterDescriptors.get(oldIndex).getName().asString(); - String oldParamName = baseFunctionDescriptor.getValueParameters().get(oldIndex).getName().asString(); - - return oldParamName.equals(inheritedParamName) && !(inheritedFunctionDescriptor instanceof AnonymousFunctionDescriptor) - ? name - : inheritedParamName; - } - - @Override - public int getOldIndex() { - return oldIndex; - } - - public boolean isNewParameter() { - return oldIndex == -1; - } - - @Nullable - @Override - public String getDefaultValue() { - return null; - } - - @Override - public void setName(String name) { - this.name = name != null ? name : ""; - } - - @Override - public boolean isUseAnySingleVariable() { - return false; - } - - @Override - public void setUseAnySingleVariable(boolean b) { - throw new UnsupportedOperationException(); - } - - private String getOldTypeText() { - return IdeDescriptorRenderers.SOURCE_CODE.renderType(type); - } - - @Override - public String getTypeText() { - return typeText; - } - - public void setTypeText(String typeText) { - this.typeText = typeText; - } - - public boolean isTypeChanged() { - return !getOldTypeText().equals(typeText); - } - - public String getDefaultValueText() { - return defaultValueText; - } - - public void setDefaultValueText(String defaultValueText) { - this.defaultValueText = defaultValueText; - } - - public JetValVar getValOrVar() { - return valOrVar != null ? valOrVar : JetValVar.None; - } - - public void setValOrVar(JetValVar valOrVar) { - this.valOrVar = valOrVar; - } - - public JetType getType() { - return type; - } - - @Nullable - public JetModifierList getModifierList() { - return modifierList; - } - - public void setModifierList(@Nullable JetModifierList modifierList) { - this.modifierList = modifierList; - } - - public boolean requiresExplicitType(@NotNull JetFunctionDefinitionUsage inheritedFunction) { - FunctionDescriptor inheritedFunctionDescriptor = inheritedFunction.getOriginalFunctionDescriptor(); - if (!(inheritedFunctionDescriptor instanceof AnonymousFunctionDescriptor)) return true; - - if (oldIndex < 0) return !inheritedFunction.hasExpectedType(); - - ValueParameterDescriptor inheritedParameterDescriptor = inheritedFunctionDescriptor.getValueParameters().get(oldIndex); - JetParameter parameter = (JetParameter) DescriptorToSourceUtils.descriptorToDeclaration(inheritedParameterDescriptor); - if (parameter == null) return false; - - return parameter.getTypeReference() != null; - } - - public String getDeclarationSignature(int parameterIndex, @NotNull JetFunctionDefinitionUsage inheritedFunction) { - StringBuilder buffer = new StringBuilder(); + public fun getDeclarationSignature(parameterIndex: Int, inheritedFunction: JetFunctionDefinitionUsage): String { + val buffer = StringBuilder() if (modifierList != null) { - buffer.append(modifierList.getText()).append(' '); + buffer.append(modifierList.getText()).append(' ') } - JetValVar valVar = getValOrVar(); - if (valVar != JetValVar.None) { - buffer.append(valVar.toString()).append(' '); + if (valOrVar != JetValVar.None) { + buffer.append(valOrVar).append(' ') } - buffer.append(getInheritedName(inheritedFunction)); + buffer.append(getInheritedName(inheritedFunction)) if (requiresExplicitType(inheritedFunction)) { - buffer.append(": ").append(renderType(parameterIndex, inheritedFunction)); + buffer.append(": ").append(renderType(parameterIndex, inheritedFunction)) } - if (defaultValue != null && !inheritedFunction.isInherited()) { - buffer.append(" = ").append(defaultValue.getText()); + if (!inheritedFunction.isInherited()) { + defaultValueForParameter?.let { buffer.append(" = ").append(it.getText()) } } - return buffer.toString(); + return buffer.toString() } -} +} \ No newline at end of file diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetValVar.kt b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetValVar.kt index c018ff68fe9..00c7a3f30db 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetValVar.kt +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetValVar.kt @@ -16,6 +16,9 @@ package org.jetbrains.jet.plugin.refactoring.changeSignature +import com.intellij.lang.ASTNode +import org.jetbrains.jet.lexer.JetTokens + public enum class JetValVar(val name: String) { None: JetValVar("none") Val: JetValVar("val") @@ -23,3 +26,12 @@ public enum class JetValVar(val name: String) { override fun toString(): String = name } + +fun ASTNode?.toValVar(): JetValVar { + return when { + this == null -> JetValVar.None + getElementType() == JetTokens.VAL_KEYWORD -> JetValVar.Val + getElementType() == JetTokens.VAR_KEYWORD -> JetValVar.Var + else -> throw IllegalArgumentException("Unknown val/var token: " + getText()) + } +} \ No newline at end of file diff --git a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/usages/JetFunctionCallUsage.java b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/usages/JetFunctionCallUsage.java index 58a01e2f887..0d0566a6cf7 100644 --- a/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/usages/JetFunctionCallUsage.java +++ b/idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/usages/JetFunctionCallUsage.java @@ -70,7 +70,7 @@ public class JetFunctionCallUsage extends JetUsageInfo { else parametersBuilder.append(','); - String defaultValueText = parameterInfo.getDefaultValueText(); + String defaultValueText = parameterInfo.getDefaultValueForCall(); if (isNamedCall) { String newName = parameterInfo.getInheritedName(callee); @@ -96,7 +96,7 @@ public class JetFunctionCallUsage extends JetUsageInfo { changeArgumentName(argumentNameExpression, parameterInfo); newArgument.replace(oldArgument); } - else if (parameterInfo.getDefaultValueText().isEmpty()) + else if (parameterInfo.getDefaultValueForCall().isEmpty()) newArgument.delete(); } 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 206277415b7..0abdf6f084a 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 @@ -292,7 +292,7 @@ public class JetFunctionDefinitionUsage extends JetUsageIn parameter.addBefore(psiFactory.createWhiteSpace(), firstChild); } - if (parameterInfo.isTypeChanged() && parameter.getTypeReference() != null) { + if (parameterInfo.getIsTypeChanged() && parameter.getTypeReference() != null) { String renderedType = parameterInfo.renderType(parameterIndex, this); parameter.setTypeReference(psiFactory.createType(renderedType)); } @@ -300,7 +300,8 @@ public class JetFunctionDefinitionUsage extends JetUsageIn PsiElement identifier = parameter.getNameIdentifier(); if (identifier != null) { - String newName = parameterInfo.getInheritedName(this); + //noinspection unchecked + String newName = parameterInfo.getInheritedName((JetFunctionDefinitionUsage) this); identifier.replace(psiFactory.createIdentifier(newName)); } } 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 72c0b7ad661..7abdee7b00e 100644 --- a/idea/tests/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeSignatureTest.java +++ b/idea/tests/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeSignatureTest.java @@ -108,8 +108,7 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase { JetChangeInfo changeInfo = getChangeInfo(); changeInfo.setNewVisibility(Visibilities.PROTECTED); JetParameterInfo newParameter = new JetParameterInfo(-1, "x", KotlinBuiltIns.getInstance().getAnyType(), - null, JetPsiFactory(getProject()).createValOrVarNode("val")); - newParameter.setDefaultValueText("12"); + null, "12", JetPsiFactory(getProject()).createValOrVarNode("val"), null); changeInfo.addParameter(newParameter); doTest(changeInfo); } @@ -123,7 +122,7 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase { changeInfo.getNewParameters()[0].setName("_x1"); changeInfo.getNewParameters()[1].setName("_x2"); changeInfo.getNewParameters()[2].setName("_x3"); - changeInfo.getNewParameters()[1].setTypeText("Float?"); + changeInfo.getNewParameters()[1].setCurrentTypeText("Float?"); doTest(changeInfo); } @@ -136,7 +135,7 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase { changeInfo.getNewParameters()[0].setName("_x1"); changeInfo.getNewParameters()[1].setName("_x2"); changeInfo.getNewParameters()[2].setName("_x3"); - changeInfo.getNewParameters()[1].setTypeText("Double?"); + changeInfo.getNewParameters()[1].setCurrentTypeText("Double?"); doTest(changeInfo); } @@ -156,7 +155,7 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase { changeInfo.getNewParameters()[0].setName("_x1"); changeInfo.getNewParameters()[1].setName("_x2"); changeInfo.getNewParameters()[2].setName("_x3"); - changeInfo.getNewParameters()[1].setTypeText("Float?"); + changeInfo.getNewParameters()[1].setCurrentTypeText("Float?"); doTest(changeInfo); } @@ -166,14 +165,14 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase { changeInfo.getNewParameters()[0].setName("_x1"); changeInfo.getNewParameters()[1].setName("_x2"); changeInfo.getNewParameters()[2].setName("_x3"); - changeInfo.getNewParameters()[1].setTypeText("Double?"); + changeInfo.getNewParameters()[1].setCurrentTypeText("Double?"); doTest(changeInfo); } public void testExpressionFunction() throws Exception { JetChangeInfo changeInfo = getChangeInfo(); changeInfo.getNewParameters()[0].setName("x1"); - changeInfo.addParameter(new JetParameterInfo("y1", KotlinBuiltIns.getInstance().getIntType())); + changeInfo.addParameter(new JetParameterInfo(-1, "y1", KotlinBuiltIns.getInstance().getIntType(), null, "", null, null)); doTest(changeInfo); } @@ -182,15 +181,14 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase { changeInfo.setNewVisibility(Visibilities.INTERNAL); changeInfo.setNewParameter(2, changeInfo.getNewParameters()[1]); changeInfo.setNewParameter(1, changeInfo.getNewParameters()[0]); - JetParameterInfo newParameter = new JetParameterInfo("x0", KotlinBuiltIns.getInstance().getNullableAnyType()); - newParameter.setDefaultValueText("null"); + JetParameterInfo newParameter = new JetParameterInfo(-1, "x0", KotlinBuiltIns.getInstance().getNullableAnyType(), null, "null", null, null); changeInfo.setNewParameter(0, newParameter); doTest(changeInfo); } public void testFakeOverride() throws Exception { JetChangeInfo changeInfo = getChangeInfo(); - JetParameterInfo newParameter = new JetParameterInfo("i", KotlinBuiltIns.getInstance().getIntType()); + JetParameterInfo newParameter = new JetParameterInfo(-1, "i", KotlinBuiltIns.getInstance().getIntType(), null, "", null, null); changeInfo.addParameter(newParameter); doTest(changeInfo); } @@ -198,7 +196,7 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase { public void testFunctionLiteral() throws Exception { JetChangeInfo changeInfo = getChangeInfo(); changeInfo.getNewParameters()[1].setName("y1"); - changeInfo.addParameter(new JetParameterInfo("x", KotlinBuiltIns.getInstance().getAnyType())); + changeInfo.addParameter(new JetParameterInfo(-1, "x", KotlinBuiltIns.getInstance().getAnyType(), null, "", null, null)); changeInfo.setNewReturnTypeText("Int"); doTest(changeInfo); } @@ -290,15 +288,14 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase { public void testOverridesInEnumEntries() throws Exception { JetChangeInfo changeInfo = getChangeInfo(); - JetParameterInfo newParameter = new JetParameterInfo("s", KotlinBuiltIns.getInstance().getStringType()); + JetParameterInfo newParameter = new JetParameterInfo(-1, "s", KotlinBuiltIns.getInstance().getStringType(), null, "", null, null); changeInfo.addParameter(newParameter); doTest(changeInfo); } public void testEnumEntriesWithoutSuperCalls() throws Exception { JetChangeInfo changeInfo = getChangeInfo(); - JetParameterInfo newParameter = new JetParameterInfo("n", KotlinBuiltIns.getInstance().getIntType()); - newParameter.setDefaultValueText("1"); + JetParameterInfo newParameter = new JetParameterInfo(-1, "n", KotlinBuiltIns.getInstance().getIntType(), null, "1", null, null); changeInfo.addParameter(newParameter); doTest(changeInfo); } @@ -307,29 +304,21 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase { JetChangeInfo changeInfo = getChangeInfo(); JetParameterInfo parameterInfo = changeInfo.getNewParameters()[0]; parameterInfo.setName("n"); - parameterInfo.setTypeText("Int"); + parameterInfo.setCurrentTypeText("Int"); doTest(changeInfo); } public void testConstructorJavaUsages() throws Exception { JetChangeInfo changeInfo = getChangeInfo(); - JetParameterInfo newParameter = new JetParameterInfo("s", KotlinBuiltIns.getInstance().getStringType()); - newParameter.setDefaultValueText("\"abc\""); + JetParameterInfo newParameter = new JetParameterInfo(-1, "s", KotlinBuiltIns.getInstance().getStringType(), null, "\"abc\"", null, null); changeInfo.addParameter(newParameter); doTest(changeInfo); } public void testFunctionJavaUsagesAndOverridesAddParam() throws Exception { JetChangeInfo changeInfo = getChangeInfo(); - - JetParameterInfo param1 = new JetParameterInfo("s", KotlinBuiltIns.getInstance().getStringType()); - param1.setDefaultValueText("\"abc\""); - changeInfo.addParameter(param1); - - JetParameterInfo param2 = new JetParameterInfo("o", KotlinBuiltIns.getInstance().getNullableAnyType()); - param2.setDefaultValueText("\"def\""); - changeInfo.addParameter(param2); - + 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)); doTest(changeInfo); } @@ -337,8 +326,8 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase { JetChangeInfo changeInfo = getChangeInfo(); JetParameterInfo[] newParameters = changeInfo.getNewParameters(); - newParameters[1].setTypeText("String?"); - newParameters[2].setTypeText("Any"); + newParameters[1].setCurrentTypeText("String?"); + newParameters[2].setCurrentTypeText("Any"); changeInfo.setNewReturnTypeText("String?"); @@ -349,9 +338,9 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase { JetChangeInfo changeInfo = getChangeInfo(); JetParameterInfo[] newParameters = changeInfo.getNewParameters(); - newParameters[0].setTypeText("String?"); - newParameters[1].setTypeText("Int"); - newParameters[2].setTypeText("Long?"); + newParameters[0].setCurrentTypeText("String?"); + newParameters[1].setCurrentTypeText("Int"); + newParameters[2].setCurrentTypeText("Long?"); changeInfo.setNewReturnTypeText("Any?"); @@ -362,9 +351,9 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase { JetChangeInfo changeInfo = getChangeInfo(); JetParameterInfo[] newParameters = changeInfo.getNewParameters(); - newParameters[0].setTypeText("List"); - newParameters[1].setTypeText("A?"); - newParameters[2].setTypeText("U"); + newParameters[0].setCurrentTypeText("List"); + newParameters[1].setCurrentTypeText("A?"); + newParameters[2].setCurrentTypeText("U"); changeInfo.setNewReturnTypeText("U?"); @@ -408,7 +397,7 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase { @Override ParameterInfoImpl[] getNewParameters(@NotNull PsiMethod method) { PsiType paramType = PsiType.getJavaLangString(getPsiManager(), GlobalSearchScope.allScope(getProject())); - return new ParameterInfoImpl[] { new ParameterInfoImpl(-1, "s", paramType) }; + return new ParameterInfoImpl[] {new ParameterInfoImpl(-1, "s", paramType)}; } } ); @@ -555,14 +544,14 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase { public void testParameterModifiers() throws Exception { JetChangeInfo changeInfo = getChangeInfo(); - changeInfo.addParameter(new JetParameterInfo("n", KotlinBuiltIns.getInstance().getIntType())); + changeInfo.addParameter(new JetParameterInfo(-1, "n", KotlinBuiltIns.getInstance().getIntType(), null, "", null, null)); doTest(changeInfo); } public void testFqNameShortening() throws Exception { JetChangeInfo changeInfo = getChangeInfo(); - JetParameterInfo parameterInfo = new JetParameterInfo("s", KotlinBuiltIns.getInstance().getAnyType()); - parameterInfo.setTypeText("kotlin.String"); + JetParameterInfo parameterInfo = new JetParameterInfo(-1, "s", KotlinBuiltIns.getInstance().getAnyType(), null, "", null, null); + parameterInfo.setCurrentTypeText("kotlin.String"); changeInfo.addParameter(parameterInfo); doTest(changeInfo); }