From c79d93b46c6b1e7e2c9c62292739dd25d359b786 Mon Sep 17 00:00:00 2001 From: Valentin Kipyatkov Date: Wed, 14 Oct 2015 16:24:52 +0300 Subject: [PATCH] Converted to Kotlin --- .../idea/quickfix/AddFunctionParametersFix.kt | 2 +- .../ChangeFunctionLiteralSignatureFix.java | 6 +- .../quickfix/ChangeFunctionSignatureFix.java | 247 ------------------ .../quickfix/ChangeFunctionSignatureFix.kt | 213 +++++++++++++++ .../DeprecatedFunctionConventionFix.kt | 6 +- .../quickfix/RemoveFunctionParametersFix.java | 84 ------ .../quickfix/RemoveFunctionParametersFix.kt | 63 +++++ 7 files changed, 284 insertions(+), 337 deletions(-) delete mode 100644 idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeFunctionSignatureFix.java create mode 100644 idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeFunctionSignatureFix.kt delete mode 100644 idea/src/org/jetbrains/kotlin/idea/quickfix/RemoveFunctionParametersFix.java create mode 100644 idea/src/org/jetbrains/kotlin/idea/quickfix/RemoveFunctionParametersFix.kt diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/AddFunctionParametersFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/AddFunctionParametersFix.kt index be3b4e654c8..a2c95d86ef4 100644 --- a/idea/src/org/jetbrains/kotlin/idea/quickfix/AddFunctionParametersFix.kt +++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/AddFunctionParametersFix.kt @@ -104,7 +104,7 @@ public class AddFunctionParametersFix( } } else { - val parameterInfo = ChangeFunctionSignatureFix.getNewParameterInfo( + val parameterInfo = getNewParameterInfo( originalDescriptor.baseDescriptor as FunctionDescriptor, bindingContext, argument, diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeFunctionLiteralSignatureFix.java b/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeFunctionLiteralSignatureFix.java index 58229fe3807..83f88ee898a 100644 --- a/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeFunctionLiteralSignatureFix.java +++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeFunctionLiteralSignatureFix.java @@ -56,7 +56,7 @@ public class ChangeFunctionLiteralSignatureFix extends ChangeFunctionSignatureFi @Override protected void invoke(@NotNull Project project, Editor editor, JetFile file) { BindingContext bindingContext = ResolutionUtils.analyzeFully(file); - JetChangeSignatureKt.runChangeSignature(project, functionDescriptor, new JetChangeSignatureConfiguration() { + JetChangeSignatureKt.runChangeSignature(project, getFunctionDescriptor(), new JetChangeSignatureConfiguration() { @NotNull @Override public JetMethodDescriptor configure(@NotNull JetMethodDescriptor originalDescriptor, @NotNull BindingContext bindingContext) { @@ -70,7 +70,7 @@ public class ChangeFunctionLiteralSignatureFix extends ChangeFunctionSignatureFi for (JetType type : parameterTypes) { String name = KotlinNameSuggester.INSTANCE$.suggestNamesByType(type, validator, "param").get(0); descriptor.addParameter( - new JetParameterInfo(functionDescriptor, -1, name, type, null, null, JetValVar.None, null) + new JetParameterInfo(getFunctionDescriptor(), -1, name, type, null, null, JetValVar.None, null) ); } return null; @@ -88,6 +88,6 @@ public class ChangeFunctionLiteralSignatureFix extends ChangeFunctionSignatureFi public boolean forcePerformForSelectedFunctionOnly() { return false; } - }, bindingContext, context, getText()); + }, bindingContext, getContext(), getText()); } } diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeFunctionSignatureFix.java b/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeFunctionSignatureFix.java deleted file mode 100644 index 02910b7ca1e..00000000000 --- a/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeFunctionSignatureFix.java +++ /dev/null @@ -1,247 +0,0 @@ -/* - * Copyright 2010-2015 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. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.jetbrains.kotlin.idea.quickfix; - -import com.intellij.openapi.editor.Editor; -import com.intellij.openapi.project.Project; -import com.intellij.psi.PsiElement; -import com.intellij.psi.PsiFile; -import com.intellij.psi.util.PsiTreeUtil; -import kotlin.jvm.functions.Function1; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.kotlin.descriptors.CallableDescriptor; -import org.jetbrains.kotlin.descriptors.DeclarationDescriptor; -import org.jetbrains.kotlin.descriptors.FunctionDescriptor; -import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor; -import org.jetbrains.kotlin.diagnostics.Diagnostic; -import org.jetbrains.kotlin.diagnostics.DiagnosticFactory; -import org.jetbrains.kotlin.diagnostics.DiagnosticWithParameters2; -import org.jetbrains.kotlin.diagnostics.Errors; -import org.jetbrains.kotlin.idea.JetBundle; -import org.jetbrains.kotlin.idea.caches.resolve.ResolutionUtils; -import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde; -import org.jetbrains.kotlin.idea.core.KotlinNameSuggester; -import org.jetbrains.kotlin.idea.core.quickfix.QuickFixUtil; -import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetParameterInfo; -import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetValVar; -import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers; -import org.jetbrains.kotlin.psi.*; -import org.jetbrains.kotlin.resolve.BindingContext; -import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt; -import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode; -import org.jetbrains.kotlin.types.JetType; -import org.jetbrains.kotlin.types.checker.JetTypeChecker; - -import java.util.Collection; -import java.util.List; - -import static org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.SYNTHESIZED; -import static org.jetbrains.kotlin.diagnostics.Errors.EXPECTED_PARAMETERS_NUMBER_MISMATCH; -import static org.jetbrains.kotlin.diagnostics.Errors.UNUSED_PARAMETER; - -public abstract class ChangeFunctionSignatureFix extends KotlinQuickFixAction { - protected final PsiElement context; - protected final FunctionDescriptor functionDescriptor; - - public ChangeFunctionSignatureFix( - @NotNull PsiElement context, - @NotNull FunctionDescriptor functionDescriptor - ) { - super(context); - this.context = context; - this.functionDescriptor = functionDescriptor; - } - - @NotNull - @Override - public String getFamilyName() { - return JetBundle.message("change.signature.family"); - } - - @Override - public boolean startInWriteAction() { - return false; - } - - @Override - public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) { - if (!super.isAvailable(project, editor, file)) { - return false; - } - - Collection declarations = DescriptorToSourceUtilsIde.INSTANCE$.getAllDeclarations(project, functionDescriptor); - if (declarations.isEmpty()) { - return false; - } - - for (PsiElement declaration : declarations) { - if (!declaration.isValid() || !QuickFixUtil.canModifyElement(declaration)) { - return false; - } - } - - return true; - } - - protected static String getNewArgumentName(ValueArgument argument, Function1 validator) { - ValueArgumentName argumentName = argument.getArgumentName(); - JetExpression expression = argument.getArgumentExpression(); - - if (argumentName != null) { - return KotlinNameSuggester.INSTANCE$.suggestNameByName(argumentName.getAsName().asString(), validator); - } - else if (expression != null) { - BindingContext bindingContext = ResolutionUtils.analyze(expression, BodyResolveMode.PARTIAL); - return KotlinNameSuggester.INSTANCE$.suggestNamesByExpressionAndType(expression, bindingContext, validator, "param").iterator().next(); - } - else { - return KotlinNameSuggester.INSTANCE$.suggestNameByName("param", validator); - } - } - - protected static JetParameterInfo getNewParameterInfo( - FunctionDescriptor functionDescriptor, - BindingContext bindingContext, - ValueArgument argument, - Function1 validator - ) { - String name = getNewArgumentName(argument, validator); - JetExpression expression = argument.getArgumentExpression(); - JetType type = expression != null ? bindingContext.getType(expression) : null; - type = type != null ? type : DescriptorUtilsKt.getBuiltIns(functionDescriptor).getNullableAnyType(); - JetParameterInfo parameterInfo = - new JetParameterInfo(functionDescriptor, -1, name, type, null, null, JetValVar.None, null); - parameterInfo.setCurrentTypeText(IdeDescriptorRenderers.SOURCE_CODE.renderType(type)); - - return parameterInfo; - } - - private static boolean hasTypeMismatches( - List parameters, - List arguments, - BindingContext bindingContext - ) { - for (int i = 0; i < parameters.size(); i++) { - assert i < arguments .size(); // number of parameters must not be greater than the number of arguments (it's called only for TOO_MANY_ARGUMENTS error) - JetExpression argumentExpression = arguments.get(i).getArgumentExpression(); - JetType argumentType = - argumentExpression != null ? bindingContext.getType(argumentExpression) : null; - JetType parameterType = parameters.get(i).getType(); - - if (argumentType == null || !JetTypeChecker.DEFAULT.isSubtypeOf(argumentType, parameterType)) { - return true; - } - } - - return false; - } - - public static JetSingleIntentionActionFactory createFactory() { - return new JetSingleIntentionActionFactory() { - @Override - public ChangeFunctionSignatureFix createAction(@NotNull Diagnostic diagnostic) { - JetCallElement callElement = PsiTreeUtil.getParentOfType(diagnostic.getPsiElement(), JetCallElement.class); - //noinspection unchecked - CallableDescriptor descriptor = DiagnosticFactory.cast(diagnostic, Errors.TOO_MANY_ARGUMENTS, Errors.NO_VALUE_FOR_PARAMETER).getA(); - - if (callElement != null) { - return createFix(callElement, callElement, descriptor); - } - - return null; - } - }; - } - - public static JetSingleIntentionActionFactory createFactoryForParametersNumberMismatch() { - return new JetSingleIntentionActionFactory() { - @Override - public ChangeFunctionSignatureFix createAction(@NotNull Diagnostic diagnostic) { - DiagnosticWithParameters2> diagnosticWithParameters = - EXPECTED_PARAMETERS_NUMBER_MISMATCH.cast(diagnostic); - JetFunction functionLiteral = diagnosticWithParameters.getPsiElement(); - DeclarationDescriptor descriptor = ResolutionUtils.resolveToDescriptor(functionLiteral); - - if (descriptor instanceof FunctionDescriptor && functionLiteral instanceof JetFunctionLiteral) { - return new ChangeFunctionLiteralSignatureFix((JetFunctionLiteral) functionLiteral, (FunctionDescriptor) descriptor, - diagnosticWithParameters.getB()); - } - else { - return null; - } - } - }; - } - - public static JetSingleIntentionActionFactory createFactoryForUnusedParameter() { - return new JetSingleIntentionActionFactory() { - @Override - public ChangeFunctionSignatureFix createAction(@NotNull Diagnostic diagnostic) { - @SuppressWarnings("unchecked") - Object descriptor = UNUSED_PARAMETER.cast(diagnostic).getA(); - - if (descriptor instanceof ValueParameterDescriptor) { - return createFix(null, diagnostic.getPsiElement(), (CallableDescriptor) descriptor); - } - else { - return null; - } - } - }; - } - - @Nullable - private static ChangeFunctionSignatureFix createFix(JetCallElement callElement, PsiElement context, CallableDescriptor descriptor) { - FunctionDescriptor functionDescriptor = null; - - if (descriptor instanceof FunctionDescriptor) { - functionDescriptor = (FunctionDescriptor) descriptor; - } - else if (descriptor instanceof ValueParameterDescriptor) { - DeclarationDescriptor containingDescriptor = descriptor.getContainingDeclaration(); - - if (containingDescriptor instanceof FunctionDescriptor) { - functionDescriptor = (FunctionDescriptor) containingDescriptor; - } - } - - if (functionDescriptor == null) { - return null; - } - - if (functionDescriptor.getKind() == SYNTHESIZED) { - return null; - } - - if (descriptor instanceof ValueParameterDescriptor) { - return new RemoveFunctionParametersFix(context, functionDescriptor, (ValueParameterDescriptor) descriptor); - } - else { - List parameters = functionDescriptor.getValueParameters(); - List arguments = callElement.getValueArguments(); - - if (arguments.size() > parameters.size()) { - BindingContext bindingContext = ResolutionUtils.analyze(callElement); - boolean hasTypeMismatches = hasTypeMismatches(parameters, arguments, bindingContext); - return new AddFunctionParametersFix(callElement, functionDescriptor, hasTypeMismatches); - } - } - - return null; - } -} diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeFunctionSignatureFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeFunctionSignatureFix.kt new file mode 100644 index 00000000000..695f5784026 --- /dev/null +++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeFunctionSignatureFix.kt @@ -0,0 +1,213 @@ +/* + * Copyright 2010-2015 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. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.kotlin.idea.quickfix + +import com.intellij.openapi.editor.Editor +import com.intellij.openapi.project.Project +import com.intellij.psi.PsiElement +import com.intellij.psi.PsiFile +import com.intellij.psi.util.PsiTreeUtil +import org.jetbrains.kotlin.descriptors.CallableDescriptor +import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.SYNTHESIZED +import org.jetbrains.kotlin.descriptors.FunctionDescriptor +import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor +import org.jetbrains.kotlin.diagnostics.Diagnostic +import org.jetbrains.kotlin.diagnostics.DiagnosticFactory +import org.jetbrains.kotlin.diagnostics.Errors +import org.jetbrains.kotlin.diagnostics.Errors.EXPECTED_PARAMETERS_NUMBER_MISMATCH +import org.jetbrains.kotlin.diagnostics.Errors.UNUSED_PARAMETER +import org.jetbrains.kotlin.idea.JetBundle +import org.jetbrains.kotlin.idea.caches.resolve.analyze +import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor +import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde +import org.jetbrains.kotlin.idea.core.KotlinNameSuggester +import org.jetbrains.kotlin.idea.core.quickfix.QuickFixUtil +import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetParameterInfo +import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetValVar +import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers +import org.jetbrains.kotlin.psi.JetCallElement +import org.jetbrains.kotlin.psi.JetFunctionLiteral +import org.jetbrains.kotlin.psi.ValueArgument +import org.jetbrains.kotlin.resolve.BindingContext +import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns +import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode +import org.jetbrains.kotlin.types.JetType +import org.jetbrains.kotlin.types.checker.JetTypeChecker + +abstract class ChangeFunctionSignatureFix( + protected val context: PsiElement, + protected val functionDescriptor: FunctionDescriptor +) : KotlinQuickFixAction(context) { + + override fun getFamilyName() = JetBundle.message("change.signature.family") + + override fun startInWriteAction() = false + + override fun isAvailable(project: Project, editor: Editor?, file: PsiFile): Boolean { + if (!super.isAvailable(project, editor, file)) { + return false + } + + val declarations = DescriptorToSourceUtilsIde.getAllDeclarations(project, functionDescriptor) + if (declarations.isEmpty()) { + return false + } + + for (declaration in declarations) { + if (!declaration.isValid || !QuickFixUtil.canModifyElement(declaration)) { + return false + } + } + + return true + } + + protected fun getNewArgumentName(argument: ValueArgument, validator: Function1): String { + val argumentName = argument.getArgumentName() + val expression = argument.getArgumentExpression() + + if (argumentName != null) { + return KotlinNameSuggester.suggestNameByName(argumentName.asName.asString(), validator) + } else if (expression != null) { + val bindingContext = expression.analyze(BodyResolveMode.PARTIAL) + return KotlinNameSuggester.suggestNamesByExpressionAndType(expression, bindingContext, validator, "param").iterator().next() + } else { + return KotlinNameSuggester.suggestNameByName("param", validator) + } + } + + protected fun getNewParameterInfo( + functionDescriptor: FunctionDescriptor, + bindingContext: BindingContext, + argument: ValueArgument, + validator: Function1): JetParameterInfo { + val name = getNewArgumentName(argument, validator) + val expression = argument.getArgumentExpression() + var type: JetType? = if (expression != null) bindingContext.getType(expression) else null + type = if (type != null) type else functionDescriptor.builtIns.nullableAnyType + val parameterInfo = JetParameterInfo(functionDescriptor, -1, name, type, null, null, JetValVar.None, null) + parameterInfo.currentTypeText = IdeDescriptorRenderers.SOURCE_CODE.renderType(type) + + return parameterInfo + } + + companion object { + + fun createFactory(): JetSingleIntentionActionFactory { + return object : JetSingleIntentionActionFactory() { + public override fun createAction(diagnostic: Diagnostic): ChangeFunctionSignatureFix? { + val callElement = PsiTreeUtil.getParentOfType(diagnostic.psiElement, JetCallElement::class.java) + //noinspection unchecked + val descriptor = DiagnosticFactory.cast(diagnostic, Errors.TOO_MANY_ARGUMENTS, Errors.NO_VALUE_FOR_PARAMETER).a + + if (callElement != null) { + return createFix(callElement, callElement, descriptor) + } + + return null + } + } + } + + fun createFactoryForParametersNumberMismatch(): JetSingleIntentionActionFactory { + return object : JetSingleIntentionActionFactory() { + public override fun createAction(diagnostic: Diagnostic): ChangeFunctionSignatureFix? { + val diagnosticWithParameters = EXPECTED_PARAMETERS_NUMBER_MISMATCH.cast(diagnostic) + val functionLiteral = diagnosticWithParameters.psiElement + val descriptor = functionLiteral.resolveToDescriptor() + + if (descriptor is FunctionDescriptor && functionLiteral is JetFunctionLiteral) { + return ChangeFunctionLiteralSignatureFix(functionLiteral, descriptor, + diagnosticWithParameters.b) + } else { + return null + } + } + } + } + + fun createFactoryForUnusedParameter(): JetSingleIntentionActionFactory { + return object : JetSingleIntentionActionFactory() { + public override fun createAction(diagnostic: Diagnostic): ChangeFunctionSignatureFix? { + @SuppressWarnings("unchecked") + val descriptor = UNUSED_PARAMETER.cast(diagnostic).a + + if (descriptor is ValueParameterDescriptor) { + return createFix(null, diagnostic.psiElement, descriptor as CallableDescriptor) + } else { + return null + } + } + } + } + + private fun createFix(callElement: JetCallElement?, context: PsiElement, descriptor: CallableDescriptor): ChangeFunctionSignatureFix? { + var functionDescriptor: FunctionDescriptor? = null + + if (descriptor is FunctionDescriptor) { + functionDescriptor = descriptor + } else if (descriptor is ValueParameterDescriptor) { + val containingDescriptor = descriptor.containingDeclaration + + if (containingDescriptor is FunctionDescriptor) { + functionDescriptor = containingDescriptor + } + } + + if (functionDescriptor == null) { + return null + } + + if (functionDescriptor.kind == SYNTHESIZED) { + return null + } + + if (descriptor is ValueParameterDescriptor) { + return RemoveFunctionParametersFix(context, functionDescriptor, descriptor) + } else { + val parameters = functionDescriptor.valueParameters + val arguments = callElement!!.valueArguments + + if (arguments.size() > parameters.size()) { + val bindingContext = callElement.analyze() + val hasTypeMismatches = hasTypeMismatches(parameters, arguments, bindingContext) + return AddFunctionParametersFix(callElement, functionDescriptor, hasTypeMismatches) + } + } + + return null + } + + private fun hasTypeMismatches( + parameters: List, + arguments: List, + bindingContext: BindingContext): Boolean { + for (i in parameters.indices) { + assert(i < arguments.size()) // number of parameters must not be greater than the number of arguments (it's called only for TOO_MANY_ARGUMENTS error) + val argumentExpression = arguments.get(i).getArgumentExpression() + val argumentType = if (argumentExpression != null) bindingContext.getType(argumentExpression) else null + val parameterType = parameters.get(i).type + + if (argumentType == null || !JetTypeChecker.DEFAULT.isSubtypeOf(argumentType, parameterType)) { + return true + } + } + + return false + } + } +} diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/DeprecatedFunctionConventionFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/DeprecatedFunctionConventionFix.kt index edf123c6ce1..8685f661bd2 100644 --- a/idea/src/org/jetbrains/kotlin/idea/quickfix/DeprecatedFunctionConventionFix.kt +++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/DeprecatedFunctionConventionFix.kt @@ -27,12 +27,14 @@ import org.jetbrains.kotlin.diagnostics.Diagnostic import org.jetbrains.kotlin.diagnostics.DiagnosticWithParameters2 import org.jetbrains.kotlin.diagnostics.DiagnosticWithParameters3 import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde -import org.jetbrains.kotlin.psi.* +import org.jetbrains.kotlin.psi.JetFile +import org.jetbrains.kotlin.psi.JetNamedFunction +import org.jetbrains.kotlin.psi.JetOperationReferenceExpression class DeprecatedFunctionConventionFix( element: JetNamedFunction, private val newName: String -) : JetIntentionAction(element), CleanupFix { +) : KotlinQuickFixAction(element), CleanupFix { override fun getText(): String = "Rename to '$newName'" override fun getFamilyName(): String = text diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/RemoveFunctionParametersFix.java b/idea/src/org/jetbrains/kotlin/idea/quickfix/RemoveFunctionParametersFix.java deleted file mode 100644 index dd043c3304b..00000000000 --- a/idea/src/org/jetbrains/kotlin/idea/quickfix/RemoveFunctionParametersFix.java +++ /dev/null @@ -1,84 +0,0 @@ -/* - * Copyright 2010-2015 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. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.jetbrains.kotlin.idea.quickfix; - -import com.intellij.openapi.editor.Editor; -import com.intellij.openapi.project.Project; -import com.intellij.psi.PsiElement; -import kotlin.Unit; -import kotlin.jvm.functions.Function1; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.kotlin.descriptors.FunctionDescriptor; -import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor; -import org.jetbrains.kotlin.idea.JetBundle; -import org.jetbrains.kotlin.idea.caches.resolve.ResolutionUtils; -import org.jetbrains.kotlin.idea.refactoring.changeSignature.*; -import org.jetbrains.kotlin.psi.JetFile; -import org.jetbrains.kotlin.resolve.BindingContext; - -import java.util.Collection; - -public class RemoveFunctionParametersFix extends ChangeFunctionSignatureFix { - private final ValueParameterDescriptor parameterToRemove; - - public RemoveFunctionParametersFix( - @NotNull PsiElement context, - @NotNull FunctionDescriptor functionDescriptor, - @NotNull ValueParameterDescriptor parameterToRemove - ) { - super(context, functionDescriptor); - this.parameterToRemove = parameterToRemove; - } - - @NotNull - @Override - public String getText() { - return JetBundle.message("remove.parameter", parameterToRemove.getName().asString()); - } - - @Override - protected void invoke(@NotNull Project project, Editor editor, JetFile file) { - BindingContext bindingContext = ResolutionUtils.analyzeFully(file); - JetChangeSignatureKt.runChangeSignature(project, functionDescriptor, new JetChangeSignatureConfiguration() { - @NotNull - @Override - public JetMethodDescriptor configure(@NotNull JetMethodDescriptor originalDescriptor, @NotNull BindingContext bindingContext) { - return JetChangeSignatureKt.modify( - originalDescriptor, - new Function1() { - @Override - public Unit invoke(JetMutableMethodDescriptor descriptor) { - int index = functionDescriptor.getValueParameters().indexOf(parameterToRemove); - descriptor.removeParameter(descriptor.getReceiver() != null ? index + 1 : index); - return null; - } - } - ); - } - - @Override - public boolean performSilently(@NotNull Collection elements) { - return false; - } - - @Override - public boolean forcePerformForSelectedFunctionOnly() { - return false; - } - }, bindingContext, context, getText()); - } -} diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/RemoveFunctionParametersFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/RemoveFunctionParametersFix.kt new file mode 100644 index 00000000000..5926b6893cf --- /dev/null +++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/RemoveFunctionParametersFix.kt @@ -0,0 +1,63 @@ +/* + * Copyright 2010-2015 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. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.kotlin.idea.quickfix + +import com.intellij.openapi.editor.Editor +import com.intellij.openapi.project.Project +import com.intellij.psi.PsiElement +import org.jetbrains.kotlin.descriptors.FunctionDescriptor +import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor +import org.jetbrains.kotlin.idea.JetBundle +import org.jetbrains.kotlin.idea.caches.resolve.analyzeFully +import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetChangeSignatureConfiguration +import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetMethodDescriptor +import org.jetbrains.kotlin.idea.refactoring.changeSignature.modify +import org.jetbrains.kotlin.idea.refactoring.changeSignature.runChangeSignature +import org.jetbrains.kotlin.psi.JetFile +import org.jetbrains.kotlin.resolve.BindingContext + +class RemoveFunctionParametersFix( + context: PsiElement, + functionDescriptor: FunctionDescriptor, + private val parameterToRemove: ValueParameterDescriptor +) : ChangeFunctionSignatureFix(context, functionDescriptor) { + + override fun getText(): String { + return JetBundle.message("remove.parameter", parameterToRemove.name.asString()) + } + + override fun invoke(project: Project, editor: Editor?, file: JetFile) { + val bindingContext = file.analyzeFully() + runChangeSignature( + project, + functionDescriptor, + object : JetChangeSignatureConfiguration { + override fun configure(originalDescriptor: JetMethodDescriptor, bindingContext: BindingContext): JetMethodDescriptor { + return originalDescriptor.modify { descriptor -> + val index = functionDescriptor.valueParameters.indexOf(parameterToRemove) + descriptor.removeParameter(if (descriptor.receiver != null) index + 1 else index) + } + } + + override fun performSilently(affectedFunctions: Collection) = false + override fun forcePerformForSelectedFunctionOnly() = false + }, + bindingContext, + context, + text) + } +}