Converted to Kotlin

2015-10-14 16:24:52 +03:00
parent 23025b072e
commit c79d93b46c
7 changed files with 284 additions and 337 deletions
@@ -104,7 +104,7 @@ public class AddFunctionParametersFix(
                            }
                        }
                        else {
-                            val parameterInfo = ChangeFunctionSignatureFix.getNewParameterInfo(
+                            val parameterInfo = getNewParameterInfo(
                                    originalDescriptor.baseDescriptor as FunctionDescriptor,
                                    bindingContext,
                                    argument,
@@ -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());
    }
 }
@@ -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<PsiElement> {
-    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<PsiElement> 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<String, Boolean> 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<String, Boolean> 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<ValueParameterDescriptor> parameters,
-            List<? extends ValueArgument> 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<JetFunction, Integer, List<JetType>> 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<ValueParameterDescriptor> parameters = functionDescriptor.getValueParameters();
-            List<? extends ValueArgument> 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;
-    }
-}
@@ -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<PsiElement>(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, Boolean>): 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<String, Boolean>): 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<ValueParameterDescriptor>,
+                arguments: List<ValueArgument>,
+                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
+        }
+    }
+}
@@ -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<JetNamedFunction>(element), CleanupFix {
+) : KotlinQuickFixAction<JetNamedFunction>(element), CleanupFix {
    override fun getText(): String = "Rename to '$newName'"
    override fun getFamilyName(): String = text

@@ -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<JetMutableMethodDescriptor, Unit>() {
-                            @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<? extends PsiElement> elements) {
-                return false;
-            }
-
-            @Override
-            public boolean forcePerformForSelectedFunctionOnly() {
-                return false;
-            }
-        }, bindingContext, context, getText());
-    }
-}
@@ -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<PsiElement>) = false
+                    override fun forcePerformForSelectedFunctionOnly() = false
+                },
+                bindingContext,
+                context,
+                text)
+    }
+}