Refactoring to not pass BindingContext

2015-10-14 16:43:05 +03:00
parent c79d93b46c
commit 4816003efd
17 changed files with 43 additions and 62 deletions
@@ -48,9 +48,9 @@ import org.jetbrains.kotlin.psi.psiUtil.getParentOfTypeAndBranch
 import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
 import org.jetbrains.kotlin.psi.psiUtil.siblings
 import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import org.jetbrains.kotlin.synthetic.SyntheticJavaPropertyDescriptor
-import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
 import org.jetbrains.kotlin.types.expressions.OperatorConventions
 import org.jetbrains.kotlin.types.typeUtil.supertypes
 import java.util.*
@@ -60,9 +60,8 @@ public class ConvertFunctionToPropertyIntention : JetSelfTargetingIntention<JetN

    private inner class Converter(
            project: Project,
-            descriptor: FunctionDescriptor,
-            context: BindingContext
-    ): CallableRefactoring<FunctionDescriptor>(project, descriptor, context, getText()) {
+            descriptor: FunctionDescriptor
+    ): CallableRefactoring<FunctionDescriptor>(project, descriptor, getText()) {
        private val elementsToShorten = ArrayList<JetElement>()

        private val newName: String by lazy {
@@ -123,7 +122,7 @@ public class ConvertFunctionToPropertyIntention : JetSelfTargetingIntention<JetN
                        callable.typeFqNameToAdd = IdeDescriptorRenderers.SOURCE_CODE.renderType(typeToInsert)
                    }

-                    callableDescriptor.getContainingScope(bindingContext)
+                    callableDescriptor.getContainingScope()
                            ?.getProperties(callableDescriptor.name, NoLookupLocation.FROM_IDE)
                            ?.firstOrNull()
                            ?.let { DescriptorToSourceUtilsIde.getAnyDeclaration(project, it) }
@@ -214,6 +213,6 @@ public class ConvertFunctionToPropertyIntention : JetSelfTargetingIntention<JetN
    override fun applyTo(element: JetNamedFunction, editor: Editor) {
        val context = element.analyze(BodyResolveMode.PARTIAL)
        val descriptor = context[BindingContext.DECLARATION_TO_DESCRIPTOR, element] as FunctionDescriptor
-        Converter(element.getProject(), descriptor, context).run()
+        Converter(element.getProject(), descriptor).run()
    }
 }
@@ -40,7 +40,7 @@ public class ConvertParameterToReceiverIntention : JetSelfTargetingIntention<Jet

    private fun configureChangeSignature(parameterIndex: Int): JetChangeSignatureConfiguration {
        return object : JetChangeSignatureConfiguration {
-            override fun configure(originalDescriptor: JetMethodDescriptor, bindingContext: BindingContext): JetMethodDescriptor {
+            override fun configure(originalDescriptor: JetMethodDescriptor): JetMethodDescriptor {
                return originalDescriptor.modify { it.receiver = originalDescriptor.getParameters()[parameterIndex] }
            }

@@ -55,6 +55,6 @@ public class ConvertParameterToReceiverIntention : JetSelfTargetingIntention<Jet
        val parameterIndex = function.getValueParameters().indexOf(element)
        val context = function.analyze()
        val descriptor = context[BindingContext.DECLARATION_TO_DESCRIPTOR, function] as? FunctionDescriptor ?: return
-        runChangeSignature(element.getProject(), descriptor, configureChangeSignature(parameterIndex), context, element, getText())
+        runChangeSignature(element.project, descriptor, configureChangeSignature(parameterIndex), element, getText())
    }
 }
@@ -52,9 +52,8 @@ import java.util.*
 public class ConvertPropertyToFunctionIntention : JetSelfTargetingIntention<JetProperty>(javaClass(), "Convert property to function"), LowPriorityAction {
    private inner class Converter(
            project: Project,
-            descriptor: CallableDescriptor,
-            context: BindingContext
-    ): CallableRefactoring<CallableDescriptor>(project, descriptor, context, getText()) {
+            descriptor: CallableDescriptor
+    ): CallableRefactoring<CallableDescriptor>(project, descriptor, getText()) {
        private val newName: String = JvmAbi.getterName(callableDescriptor.name.asString())

        private fun convertProperty(originalProperty: JetProperty, psiFactory: JetPsiFactory) {
@@ -102,7 +101,7 @@ public class ConvertPropertyToFunctionIntention : JetSelfTargetingIntention<JetP
                }

                if (callable is JetProperty) {
-                    callableDescriptor.getContainingScope(bindingContext)
+                    callableDescriptor.getContainingScope()
                            ?.getFunctions(callableDescriptor.name, NoLookupLocation.FROM_IDE)
                            ?.firstOrNull { it.getValueParameters().isEmpty() }
                            ?.let { DescriptorToSourceUtilsIde.getAnyDeclaration(project, it) }
@@ -190,6 +189,6 @@ public class ConvertPropertyToFunctionIntention : JetSelfTargetingIntention<JetP
    override fun applyTo(element: JetProperty, editor: Editor) {
        val context = element.analyze()
        val descriptor = context[BindingContext.DECLARATION_TO_DESCRIPTOR, element] as? CallableDescriptor ?: return
-        Converter(element.getProject(), descriptor, context).run()
+        Converter(element.getProject(), descriptor).run()
    }
 }
@@ -35,7 +35,7 @@ public class ConvertReceiverToParameterIntention : JetSelfTargetingOffsetIndepen

    private fun configureChangeSignature(): JetChangeSignatureConfiguration {
        return object : JetChangeSignatureConfiguration {
-            override fun configure(originalDescriptor: JetMethodDescriptor, bindingContext: BindingContext): JetMethodDescriptor {
+            override fun configure(originalDescriptor: JetMethodDescriptor): JetMethodDescriptor {
                return originalDescriptor.modify { it.receiver = null }
            }
        }
@@ -47,6 +47,6 @@ public class ConvertReceiverToParameterIntention : JetSelfTargetingOffsetIndepen
        val function = element.getParent() as? JetNamedFunction ?: return
        val context = function.analyze()
        val descriptor = context[BindingContext.DECLARATION_TO_DESCRIPTOR, function] as? FunctionDescriptor ?: return
-        runChangeSignature(element.getProject(), descriptor, configureChangeSignature(), context, element, getText())
+        runChangeSignature(element.project, descriptor, configureChangeSignature(), element, getText())
    }
 }
@@ -23,7 +23,7 @@ import com.intellij.psi.PsiFile
 import com.intellij.psi.search.searches.ReferencesSearch
 import org.jetbrains.kotlin.descriptors.ConstructorDescriptor
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
-import org.jetbrains.kotlin.idea.caches.resolve.analyzeFully
+import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.core.CollectingNameValidator
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetChangeSignatureConfiguration
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetMethodDescriptor
@@ -76,12 +76,12 @@ public class AddFunctionParametersFix(
    }

    override fun invoke(project: Project, editor: Editor?, file: JetFile) {
-        runChangeSignature(project, functionDescriptor, addParameterConfiguration(), callElement.analyzeFully(), callElement, text)
+        runChangeSignature(project, functionDescriptor, addParameterConfiguration(), callElement, text)
    }

    private fun addParameterConfiguration(): JetChangeSignatureConfiguration {
        return object : JetChangeSignatureConfiguration {
-            override fun configure(originalDescriptor: JetMethodDescriptor, bindingContext: BindingContext): JetMethodDescriptor {
+            override fun configure(originalDescriptor: JetMethodDescriptor): JetMethodDescriptor {
                return originalDescriptor.modify {
                    val parameters = functionDescriptor.valueParameters
                    val arguments = callElement.valueArguments
@@ -94,6 +94,7 @@ public class AddFunctionParametersFix(
                        if (i < parameters.size()) {
                            validator.addName(parameters.get(i).name.asString())
                            val argumentType = expression?.let {
+                                val bindingContext = it.analyze()
                                bindingContext[BindingContext.SMARTCAST, it] ?: bindingContext.getType(it)
                            }
                            val parameterType = parameters.get(i).type
@@ -106,7 +107,6 @@ public class AddFunctionParametersFix(
                        else {
                            val parameterInfo = getNewParameterInfo(
                                    originalDescriptor.baseDescriptor as FunctionDescriptor,
-                                    bindingContext,
                                    argument,
                                    validator
                            )
@@ -55,11 +55,10 @@ public class ChangeFunctionLiteralSignatureFix extends ChangeFunctionSignatureFi

    @Override
    protected void invoke(@NotNull Project project, Editor editor, JetFile file) {
-        BindingContext bindingContext = ResolutionUtils.analyzeFully(file);
        JetChangeSignatureKt.runChangeSignature(project, getFunctionDescriptor(), new JetChangeSignatureConfiguration() {
            @NotNull
            @Override
-            public JetMethodDescriptor configure(@NotNull JetMethodDescriptor originalDescriptor, @NotNull BindingContext bindingContext) {
+            public JetMethodDescriptor configure(@NotNull JetMethodDescriptor originalDescriptor) {
                return JetChangeSignatureKt.modify(
                        originalDescriptor,
                        new Function1<JetMutableMethodDescriptor, Unit>() {
@@ -88,6 +87,6 @@ public class ChangeFunctionLiteralSignatureFix extends ChangeFunctionSignatureFi
            public boolean forcePerformForSelectedFunctionOnly() {
                return false;
            }
-        }, bindingContext, getContext(), getText());
+        }, getContext(), getText());
    }
 }
@@ -45,7 +45,6 @@ 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(
@@ -92,13 +91,11 @@ abstract class ChangeFunctionSignatureFix(

    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 type = expression?.let { it.analyze().getType(it) } ?: functionDescriptor.builtIns.nullableAnyType
        val parameterInfo = JetParameterInfo(functionDescriptor, -1, name, type, null, null, JetValVar.None, null)
        parameterInfo.currentTypeText = IdeDescriptorRenderers.SOURCE_CODE.renderType(type)

@@ -22,13 +22,11 @@ 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,
@@ -41,12 +39,11 @@ class RemoveFunctionParametersFix(
    }

    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 {
+                    override fun configure(originalDescriptor: JetMethodDescriptor): JetMethodDescriptor {
                        return originalDescriptor.modify { descriptor ->
                            val index = functionDescriptor.valueParameters.indexOf(parameterToRemove)
                            descriptor.removeParameter(if (descriptor.receiver != null) index + 1 else index)
@@ -56,7 +53,6 @@ class RemoveFunctionParametersFix(
                    override fun performSilently(affectedFunctions: Collection<PsiElement>) = false
                    override fun forcePerformForSelectedFunctionOnly() = false
                },
-                bindingContext,
                context,
                text)
    }
@@ -41,8 +41,7 @@ abstract class CreateParameterFromUsageFactory<E : JetElement>: CreateFromUsageF
        return QuickFixWithDelegateFactory {
            quickFixDataFactory(originalElementPointer)?.let { data ->
                CreateParameterFromUsageFix(data.parameterInfo.callableDescriptor as FunctionDescriptor,
-                                            data.context,
-                                            data.parameterInfo,
+                        data.parameterInfo,
                                            data.originalExpression)
            } ?: NullQuickFix
        }
@@ -25,11 +25,9 @@ import org.jetbrains.kotlin.idea.quickfix.createFromUsage.CreateFromUsageFixBase
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.*
 import org.jetbrains.kotlin.psi.JetElement
 import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.resolve.BindingContext

 public class CreateParameterFromUsageFix<E : JetElement>(
        val functionDescriptor: FunctionDescriptor,
-        val bindingContext: BindingContext,
        val parameterInfo: JetParameterInfo,
        val defaultValueContext: E
 ) : CreateFromUsageFixBase<E>(defaultValueContext) {
@@ -41,13 +39,13 @@ public class CreateParameterFromUsageFix<E : JetElement>(

    override fun invoke(project: Project, editor: Editor?, file: JetFile) {
        val config = object : JetChangeSignatureConfiguration {
-            override fun configure(originalDescriptor: JetMethodDescriptor, bindingContext: BindingContext): JetMethodDescriptor {
+            override fun configure(originalDescriptor: JetMethodDescriptor): JetMethodDescriptor {
                return originalDescriptor.modify { it.addParameter(parameterInfo) }
            }

            override fun performSilently(affectedFunctions: Collection<PsiElement>): Boolean = false
        }

-        runChangeSignature(project, functionDescriptor, config, bindingContext, defaultValueContext, text)
+        runChangeSignature(project, functionDescriptor, config, defaultValueContext, text)
    }
 }
@@ -33,6 +33,7 @@ import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.DELEGATION
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.FAKE_OVERRIDE
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.SYNTHESIZED
 import org.jetbrains.kotlin.idea.JetBundle
+import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde
 import org.jetbrains.kotlin.idea.core.quickfix.QuickFixUtil
 import org.jetbrains.kotlin.psi.JetBlockExpression
@@ -49,7 +50,6 @@ import java.util.*
 public abstract class CallableRefactoring<T: CallableDescriptor>(
        val project: Project,
        val callableDescriptor: T,
-        val bindingContext: BindingContext,
        val commandName: String) {
    private val LOG = Logger.getInstance(javaClass<CallableRefactoring<*>>())

@@ -183,11 +183,12 @@ fun getAffectedCallables(project: Project, descriptorsForChange: Collection<Call
    }
 }

-fun DeclarationDescriptor.getContainingScope(bindingContext: BindingContext): JetScope? {
+fun DeclarationDescriptor.getContainingScope(): JetScope? {
    val declaration = DescriptorToSourceUtils.descriptorToDeclaration(this)
    val block = declaration?.getParent() as? JetBlockExpression
    if (block != null) {
-        return bindingContext[BindingContext.RESOLUTION_SCOPE, block.getStatements().last()]
+        val lastStatement = block.statements.last()
+        return lastStatement.analyze()[BindingContext.RESOLUTION_SCOPE, lastStatement]
    }
    else {
        val containingDescriptor = getContainingDeclaration() ?: return null
@@ -48,7 +48,7 @@ import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.OverrideResolver

 public interface JetChangeSignatureConfiguration {
-    fun configure(originalDescriptor: JetMethodDescriptor, bindingContext: BindingContext): JetMethodDescriptor = originalDescriptor
+    fun configure(originalDescriptor: JetMethodDescriptor): JetMethodDescriptor = originalDescriptor
    fun performSilently(affectedFunctions: Collection<PsiElement>): Boolean = false
    fun forcePerformForSelectedFunctionOnly(): Boolean = false

@@ -64,20 +64,17 @@ fun JetMethodDescriptor.modify(action: (JetMutableMethodDescriptor) -> Unit): Je
 public fun runChangeSignature(project: Project,
                              callableDescriptor: CallableDescriptor,
                              configuration: JetChangeSignatureConfiguration,
-                              bindingContext: BindingContext,
                              defaultValueContext: PsiElement,
                              commandName: String? = null): Boolean {
-    return JetChangeSignature(project, callableDescriptor, configuration, bindingContext, defaultValueContext, commandName).run()
+    return JetChangeSignature(project, callableDescriptor, configuration, defaultValueContext, commandName).run()
 }

 public class JetChangeSignature(project: Project,
                                callableDescriptor: CallableDescriptor,
                                val configuration: JetChangeSignatureConfiguration,
-                                bindingContext: BindingContext,
                                val defaultValueContext: PsiElement,
                                commandName: String?): CallableRefactoring<CallableDescriptor>(project,
                                                                                               callableDescriptor,
-                                                                                               bindingContext,
                                                                                               commandName ?: ChangeSignatureHandler.REFACTORING_NAME) {

    private val LOG = Logger.getInstance(javaClass<JetChangeSignature>())
@@ -205,7 +202,7 @@ public class JetChangeSignature(project: Project,
        }

        val originalDescriptor = JetChangeSignatureData(baseDescriptor, functionDeclaration, descriptorsForSignatureChange)
-        return configuration.configure(originalDescriptor, bindingContext)
+        return configuration.configure(originalDescriptor)
    }

    private fun preferContainedInClass(descriptorsForSignatureChange: Collection<CallableDescriptor>): CallableDescriptor {
@@ -225,10 +222,9 @@ public fun createChangeInfo(
        project: Project,
        callableDescriptor: CallableDescriptor,
        configuration: JetChangeSignatureConfiguration,
-        bindingContext: BindingContext,
        defaultValueContext: PsiElement
 ): JetChangeInfo? {
-    val jetChangeSignature = JetChangeSignature(project, callableDescriptor, configuration, bindingContext, defaultValueContext, null)
+    val jetChangeSignature = JetChangeSignature(project, callableDescriptor, configuration, defaultValueContext, null)
    val declarations = if (callableDescriptor is CallableMemberDescriptor) {
        OverrideResolver.getDeepestSuperDeclarations(callableDescriptor)
    } else listOf(callableDescriptor)
@@ -18,7 +18,6 @@ package org.jetbrains.kotlin.idea.refactoring.changeSignature

 import com.intellij.openapi.actionSystem.CommonDataKeys
 import com.intellij.openapi.actionSystem.DataContext
-import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.editor.ScrollType
 import com.intellij.openapi.project.Project
@@ -27,7 +26,6 @@ import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiFile
 import com.intellij.psi.PsiMethod
 import com.intellij.psi.util.PsiTreeUtil
-import com.intellij.refactoring.BaseRefactoringProcessor
 import com.intellij.refactoring.HelpID
 import com.intellij.refactoring.RefactoringBundle
 import com.intellij.refactoring.changeSignature.ChangeSignatureHandler
@@ -151,7 +149,7 @@ public class JetChangeSignatureHandler : ChangeSignatureHandler {
                return
            }

-            runChangeSignature(project, callableDescriptor, JetChangeSignatureConfiguration.Empty, bindingContext, context, null)
+            runChangeSignature(project, callableDescriptor, JetChangeSignatureConfiguration.Empty, context, null)
        }

        private fun getDescriptor(bindingContext: BindingContext, element: PsiElement): DeclarationDescriptor? {
@@ -621,7 +621,7 @@ public class JetChangeSignatureUsageProcessor implements ChangeSignatureUsagePro
        else if (function instanceof JetFunction)
            parametersScope = CallableRefactoringKt.getBodyScope((JetFunction) function, bindingContext);

-        JetScope callableScope = CallableRefactoringKt.getContainingScope(oldDescriptor, bindingContext);
+        JetScope callableScope = CallableRefactoringKt.getContainingScope(oldDescriptor);

        JetMethodDescriptor.Kind kind = JetChangeInfoKt.getKind(changeInfo);
        if (!kind.isConstructor() && callableScope != null && !info.getNewName().isEmpty()) {
@@ -124,7 +124,7 @@ fun getParametersToRemove(
 fun IntroduceParameterDescriptor.performRefactoring() {
    runWriteAction {
        val config = object : JetChangeSignatureConfiguration {
-            override fun configure(originalDescriptor: JetMethodDescriptor, bindingContext: BindingContext): JetMethodDescriptor {
+            override fun configure(originalDescriptor: JetMethodDescriptor): JetMethodDescriptor {
                return originalDescriptor.modify { methodDescriptor ->
                    if (!withDefaultValue) {
                        val parameters = callable.getValueParameters()
@@ -153,7 +153,7 @@ fun IntroduceParameterDescriptor.performRefactoring() {
        }

        val project = callable.getProject();
-        val changeSignature = { runChangeSignature(project, callableDescriptor, config, callable.analyze(), callable, INTRODUCE_PARAMETER) }
+        val changeSignature = { runChangeSignature(project, callableDescriptor, config, callable, INTRODUCE_PARAMETER) }
        changeSignature.runRefactoringWithPostprocessing(project, "refactoring.changeSignature") {
            try {
                occurrencesToReplace.forEach { occurrenceReplacer(it) }
@@ -21,6 +21,7 @@ import com.intellij.refactoring.listeners.RefactoringElementListener
 import com.intellij.usageView.UsageInfo
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
+import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetChangeSignatureConfiguration
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetMethodDescriptor
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.modify
@@ -41,8 +42,7 @@ public class RenameKotlinParameterProcessor : RenameKotlinPsiProcessor() {
        val paramIndex = function.getValueParameters().indexOf(element)
        assert(paramIndex != -1, { "couldn't find parameter in parent ${element.getElementTextWithContext()}" })

-        val context = function.analyze()
-        val functionDescriptor = context[BindingContext.DECLARATION_TO_DESCRIPTOR, function] as? FunctionDescriptor ?: return
+        val functionDescriptor = function.resolveToDescriptor() as? FunctionDescriptor ?: return
        val parameterDescriptor = functionDescriptor.getValueParameters()[paramIndex]

        val parameterNameChangedOnOverride = parameterDescriptor.getOverriddenDescriptors().any {
@@ -50,7 +50,7 @@ public class RenameKotlinParameterProcessor : RenameKotlinPsiProcessor() {
        }

        val changeSignatureConfiguration = object : JetChangeSignatureConfiguration {
-            override fun configure(originalDescriptor: JetMethodDescriptor, bindingContext: BindingContext): JetMethodDescriptor {
+            override fun configure(originalDescriptor: JetMethodDescriptor): JetMethodDescriptor {
                val paramInfoIndex = if (functionDescriptor.getExtensionReceiverParameter() != null) paramIndex + 1 else paramIndex
                return originalDescriptor.modify { it.renameParameter(paramInfoIndex, newName) }
            }
@@ -60,6 +60,6 @@ public class RenameKotlinParameterProcessor : RenameKotlinPsiProcessor() {
            override fun forcePerformForSelectedFunctionOnly() = parameterNameChangedOnOverride
        }

-        runChangeSignature(element.getProject(), functionDescriptor, changeSignatureConfiguration, context, element, "Rename parameter")
+        runChangeSignature(element.getProject(), functionDescriptor, changeSignatureConfiguration, element, "Rename parameter")
    }
 }
@@ -250,7 +250,7 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase {
            JetChangeSignatureConfiguration empty = new JetChangeSignatureConfiguration() {
                @NotNull
                @Override
-                public JetMethodDescriptor configure(@NotNull JetMethodDescriptor originalDescriptor, @NotNull BindingContext bindingContext) {
+                public JetMethodDescriptor configure(@NotNull JetMethodDescriptor originalDescriptor) {
                    return originalDescriptor;
                }

@@ -264,10 +264,9 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase {
                    return false;
                }
            };
-            BindingContext context = ResolutionUtils.analyze(method, BodyResolveMode.FULL);

            JetChangeSignatureKt
-                    .runChangeSignature(getProject(), JetChangeInfoKt.getOriginalBaseFunctionDescriptor(changeInfo), empty, context, method, "test");
+                    .runChangeSignature(getProject(), JetChangeInfoKt.getOriginalBaseFunctionDescriptor(changeInfo), empty, method, "test");
        }
        catch (RuntimeException e) {
            assertTrue(e.getMessage().startsWith("Refactoring cannot be"));
@@ -1406,7 +1405,7 @@ public class JetChangeSignatureTest extends KotlinCodeInsightTestCase {
        assertNotNull(callableDescriptor);

        return JetChangeSignatureKt.createChangeInfo(
-                project, callableDescriptor, JetChangeSignatureConfiguration.Empty.INSTANCE$, bindingContext, context
+                project, callableDescriptor, JetChangeSignatureConfiguration.Empty.INSTANCE$, context
        );
    }