Removing unnecessary uses of analyzeFully

idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/resolutionApi.kt

@@ -44,6 +44,7 @@ public fun JetFile.resolveImportReference(fqName: FqName, isDefaultImport: Boole
 // analyze - see ResolveSessionForBodies, ResolveElementCache
 // analyzeFully - see KotlinResolveCache, KotlinResolveDataProvider
 // In the future these two approaches should be unified
+@jvmOverloads
 public fun JetElement.analyze(bodyResolveMode: BodyResolveMode = BodyResolveMode.FULL): BindingContext {
     return getResolutionFacade().analyze(this, bodyResolveMode)
 }

idea/idea-core/src/org/jetbrains/kotlin/idea/core/quickfix/QuickFixUtil.java

@@ -32,7 +32,6 @@ import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.renderer.DescriptorRenderer;
-import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilPackage;
@@ -62,8 +61,7 @@ public class QuickFixUtil {
     public static JetType getDeclarationReturnType(JetNamedDeclaration declaration) {
         PsiFile file = declaration.getContainingFile();
         if (!(file instanceof JetFile)) return null;
-        BindingContext bindingContext = ResolvePackage.analyzeFully((JetFile) file);
+        DeclarationDescriptor descriptor = ResolvePackage.resolveToDescriptor(declaration);
-        DeclarationDescriptor descriptor = bindingContext.get(BindingContext.DECLARATION_TO_DESCRIPTOR, declaration);
         if (!(descriptor instanceof CallableDescriptor)) return null;
         JetType type = ((CallableDescriptor) descriptor).getReturnType();
         if (type instanceof DeferredType) {
@@ -73,12 +71,7 @@ public class QuickFixUtil {
     }
 
     @Nullable
-    public static JetType findLowerBoundOfOverriddenCallablesReturnTypes(BindingContext context, JetDeclaration callable) {
+    public static JetType findLowerBoundOfOverriddenCallablesReturnTypes(@NotNull CallableDescriptor descriptor) {
-        DeclarationDescriptor descriptor = context.get(BindingContext.DECLARATION_TO_DESCRIPTOR, callable);
-        if (!(descriptor instanceof CallableDescriptor)) {
-            return null;
-        }
-
         JetType matchingReturnType = null;
         for (CallableDescriptor overriddenDescriptor : ((CallableDescriptor) descriptor).getOverriddenDescriptors()) {
             JetType overriddenReturnType = overriddenDescriptor.getReturnType();

idea/src/org/jetbrains/kotlin/idea/codeInsight/JetTypeDeclarationProvider.java

@@ -32,8 +32,7 @@ public class JetTypeDeclarationProvider implements TypeDeclarationProvider {
     @Override
     public PsiElement[] getSymbolTypeDeclarations(PsiElement symbol) {
         if (symbol instanceof JetElement && symbol.getContainingFile() instanceof JetFile) {
-            BindingContext bindingContext =
+            BindingContext bindingContext = ResolvePackage.analyze((JetElement)symbol);
-                    ResolvePackage.analyzeFully((JetFile) symbol.getContainingFile());
             DeclarationDescriptor descriptor = bindingContext.get(BindingContext.DECLARATION_TO_DESCRIPTOR, symbol);
             if (descriptor instanceof CallableDescriptor) {
                 JetType type = ((CallableDescriptor) descriptor).getReturnType();

idea/src/org/jetbrains/kotlin/idea/codeInsight/surroundWith/expression/KotlinRuntimeTypeCastSurrounder.kt

@@ -29,20 +29,16 @@ import com.intellij.openapi.progress.ProgressIndicator
 import com.intellij.openapi.progress.util.ProgressWindowWithNotification
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.util.TextRange
-import org.jetbrains.kotlin.psi.JetExpression
+import org.jetbrains.kotlin.idea.JetBundle
-import org.jetbrains.kotlin.psi.JetCodeFragment
+import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.debugger.evaluate.KotlinRuntimeTypeEvaluator
-import org.jetbrains.kotlin.psi.JetPsiFactory
-import org.jetbrains.kotlin.psi.JetBinaryExpressionWithTypeRHS
 import org.jetbrains.kotlin.idea.util.ShortenReferences
-import org.jetbrains.kotlin.psi.JetParenthesizedExpression
+import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.types.JetType
 import org.jetbrains.kotlin.resolve.DescriptorUtils
-import org.jetbrains.kotlin.idea.caches.resolve.analyzeFully
+import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
-import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.types.JetType
 import org.jetbrains.kotlin.types.TypeUtils
 import org.jetbrains.kotlin.types.checker.JetTypeChecker
-import org.jetbrains.kotlin.idea.JetBundle
 
 public class KotlinRuntimeTypeCastSurrounder: KotlinExpressionSurrounder() {
 
@@ -51,9 +47,7 @@ public class KotlinRuntimeTypeCastSurrounder: KotlinExpressionSurrounder() {
         val file = expression.getContainingFile()
         if (file !is JetCodeFragment) return false
 
-        val context = file.analyzeFully()
+        val type = expression.analyze(BodyResolveMode.PARTIAL).getType(expression) ?: return false
-        val type = context.getType(expression)
-        if (type == null) return false
 
         return TypeUtils.canHaveSubtypes(JetTypeChecker.DEFAULT, type)
     }

idea/src/org/jetbrains/kotlin/idea/hierarchy/KotlinTypeHierarchyProvider.java

@@ -69,7 +69,7 @@ public class KotlinTypeHierarchyProvider extends JavaTypeHierarchyProvider {
             else if (target instanceof JetNamedFunction) {
                 JetNamedFunction function = (JetNamedFunction) target;
                 String functionName = function.getName();
-                FunctionDescriptor functionDescriptor = ResolvePackage.analyzeFully(function)
+                FunctionDescriptor functionDescriptor = ResolvePackage.analyze(function)
                         .get(BindingContext.FUNCTION, target);
                 if (functionDescriptor != null) {
                     JetType type = functionDescriptor.getReturnType();

idea/src/org/jetbrains/kotlin/idea/intentions/MoveLambdaInsideParenthesesIntention.kt

@@ -18,6 +18,7 @@ package org.jetbrains.kotlin.idea.intentions
 
 import com.intellij.codeInsight.intention.LowPriorityAction
 import com.intellij.openapi.editor.Editor
+import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.caches.resolve.analyzeFully
 import org.jetbrains.kotlin.idea.core.moveInsideParentheses
 import org.jetbrains.kotlin.psi.JetFunctionLiteralArgument
@@ -29,7 +30,7 @@ public class MoveLambdaInsideParenthesesIntention : JetSelfTargetingIntention<Je
     }
 
     override fun applyTo(element: JetFunctionLiteralArgument, editor: Editor) {
-        element.moveInsideParentheses(element.analyzeFully())
+        element.moveInsideParentheses(element.analyze())
     }
 }
 

idea/src/org/jetbrains/kotlin/idea/intentions/SpecifyTypeExplicitlyIntention.kt

@@ -63,8 +63,8 @@ public class SpecifyTypeExplicitlyIntention : JetSelfTargetingIntention<JetCalla
     }
 
     private fun hasPublicMemberDiagnostic(declaration: JetNamedDeclaration): Boolean {
-        return declaration.getContainingJetFile().analyzeFully().getDiagnostics()
+        return declaration.analyze().getDiagnostics().forElement(declaration)
-                .any { Errors.PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE == it.getFactory() && declaration == it.getPsiElement() }
+                .any { it.getFactory() == Errors.PUBLIC_MEMBER_SHOULD_SPECIFY_TYPE }
     }
 
     override fun applyTo(element: JetCallableDeclaration, editor: Editor) {

idea/src/org/jetbrains/kotlin/idea/quickfix/AddNameToArgumentFix.java

@@ -71,7 +71,7 @@ public class AddNameToArgumentFix extends JetIntentionAction<JetValueArgument> {
         JetCallElement callElement = PsiTreeUtil.getParentOfType(argument, JetCallElement.class);
         assert callElement != null : "The argument has to be inside a function or constructor call";
 
-        BindingContext context = ResolvePackage.analyzeFully(argument.getContainingJetFile());
+        BindingContext context = ResolvePackage.analyze(argument);
         ResolvedCall<?> resolvedCall = CallUtilPackage.getResolvedCall(callElement, context);
         if (resolvedCall == null) return Collections.emptyList();
 

idea/src/org/jetbrains/kotlin/idea/quickfix/CastExpressionFix.java

@@ -28,10 +28,9 @@ 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.ResolvePackage;
-import org.jetbrains.kotlin.idea.util.ShortenReferences;
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers;
+import org.jetbrains.kotlin.idea.util.ShortenReferences;
 import org.jetbrains.kotlin.psi.*;
-import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.types.JetType;
 import org.jetbrains.kotlin.types.checker.JetTypeChecker;
 
@@ -64,8 +63,7 @@ public class CastExpressionFix extends JetIntentionAction<JetExpression> {
     @Override
     public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) {
         if (!super.isAvailable(project, editor, file)) return false;
-        BindingContext context = ResolvePackage.analyzeFully((JetFile) file);
+        JetType expressionType = ResolvePackage.analyze(element).getType(element);
-        JetType expressionType = context.getType(element);
         return expressionType != null && JetTypeChecker.DEFAULT.isSubtypeOf(type, expressionType);
     }
 

idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeFunctionReturnTypeFix.java

@@ -27,7 +27,6 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor;
-import org.jetbrains.kotlin.descriptors.SimpleFunctionDescriptor;
 import org.jetbrains.kotlin.diagnostics.Diagnostic;
 import org.jetbrains.kotlin.idea.JetBundle;
 import org.jetbrains.kotlin.idea.caches.resolve.ResolvePackage;
@@ -138,7 +137,7 @@ public class ChangeFunctionReturnTypeFix extends JetIntentionAction<JetFunction>
             @Override
             public IntentionAction createAction(@NotNull Diagnostic diagnostic) {
                 JetMultiDeclarationEntry entry = getMultiDeclarationEntryThatTypeMismatchComponentFunction(diagnostic);
-                BindingContext context = ResolvePackage.analyzeFully((JetFile) entry.getContainingFile().getContainingFile());
+                BindingContext context = ResolvePackage.analyze(entry);
                 ResolvedCall<FunctionDescriptor> resolvedCall = context.get(BindingContext.COMPONENT_RESOLVED_CALL, entry);
                 if (resolvedCall == null) return null;
                 JetFunction componentFunction = (JetFunction) DescriptorToSourceUtils
@@ -160,7 +159,7 @@ public class ChangeFunctionReturnTypeFix extends JetIntentionAction<JetFunction>
             public IntentionAction createAction(@NotNull Diagnostic diagnostic) {
                 JetExpression expression = QuickFixUtil.getParentElementOfType(diagnostic, JetExpression.class);
                 assert expression != null : "HAS_NEXT_FUNCTION_TYPE_MISMATCH reported on element that is not within any expression";
-                BindingContext context = ResolvePackage.analyzeFully(expression.getContainingJetFile());
+                BindingContext context = ResolvePackage.analyze(expression);
                 ResolvedCall<FunctionDescriptor> resolvedCall = context.get(BindingContext.LOOP_RANGE_HAS_NEXT_RESOLVED_CALL, expression);
                 if (resolvedCall == null) return null;
                 JetFunction hasNextFunction = (JetFunction) DescriptorToSourceUtils
@@ -181,7 +180,7 @@ public class ChangeFunctionReturnTypeFix extends JetIntentionAction<JetFunction>
             public IntentionAction createAction(@NotNull Diagnostic diagnostic) {
                 JetBinaryExpression expression = QuickFixUtil.getParentElementOfType(diagnostic, JetBinaryExpression.class);
                 assert expression != null : "COMPARE_TO_TYPE_MISMATCH reported on element that is not within any expression";
-                BindingContext context = ResolvePackage.analyzeFully(expression.getContainingJetFile());
+                BindingContext context = ResolvePackage.analyze(expression);
                 ResolvedCall<?> resolvedCall = CallUtilPackage.getResolvedCall(expression, context);
                 if (resolvedCall == null) return null;
                 PsiElement compareTo = DescriptorToSourceUtils.descriptorToDeclaration(resolvedCall.getCandidateDescriptor());
@@ -201,14 +200,13 @@ public class ChangeFunctionReturnTypeFix extends JetIntentionAction<JetFunction>
 
                 JetFunction function = QuickFixUtil.getParentElementOfType(diagnostic, JetFunction.class);
                 if (function != null) {
-                    BindingContext context = ResolvePackage.analyzeFully(function);
+                    FunctionDescriptor descriptor = (FunctionDescriptor)ResolvePackage.resolveToDescriptor(function);
-                    JetType matchingReturnType = QuickFixUtil.findLowerBoundOfOverriddenCallablesReturnTypes(context, function);
+
+                    JetType matchingReturnType = QuickFixUtil.findLowerBoundOfOverriddenCallablesReturnTypes(descriptor);
                     if (matchingReturnType != null) {
                         actions.add(new ChangeFunctionReturnTypeFix(function, matchingReturnType));
                     }
 
-                    SimpleFunctionDescriptor descriptor = context.get(BindingContext.FUNCTION, function);
-                    if (descriptor == null) return actions;
                     JetType functionType = descriptor.getReturnType();
                     if (functionType == null) return actions;
 

idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeFunctionSignatureFix.java

@@ -172,9 +172,7 @@ public abstract class ChangeFunctionSignatureFix extends JetIntentionAction<PsiE
                 DiagnosticWithParameters2<JetFunction, Integer, List<JetType>> diagnosticWithParameters =
                         EXPECTED_PARAMETERS_NUMBER_MISMATCH.cast(diagnostic);
                 JetFunction functionLiteral = diagnosticWithParameters.getPsiElement();
-                BindingContext bindingContext =
+                DeclarationDescriptor descriptor = ResolvePackage.resolveToDescriptor(functionLiteral);
-                        ResolvePackage.analyzeFully(functionLiteral.getContainingJetFile());
-                DeclarationDescriptor descriptor = bindingContext.get(BindingContext.DECLARATION_TO_DESCRIPTOR, functionLiteral);
 
                 if (descriptor instanceof FunctionDescriptor && functionLiteral instanceof JetFunctionLiteral) {
                     return new ChangeFunctionLiteralSignatureFix((JetFunctionLiteral) functionLiteral, (FunctionDescriptor) descriptor,
@@ -227,8 +225,6 @@ public abstract class ChangeFunctionSignatureFix extends JetIntentionAction<PsiE
             return null;
         }
 
-        BindingContext bindingContext =
-                ResolvePackage.analyzeFully((JetFile) context.getContainingFile());
         if (descriptor instanceof ValueParameterDescriptor) {
             return new RemoveFunctionParametersFix(context, functionDescriptor, (ValueParameterDescriptor) descriptor);
         }
@@ -237,6 +233,7 @@ public abstract class ChangeFunctionSignatureFix extends JetIntentionAction<PsiE
             List<? extends ValueArgument> arguments = callElement.getValueArguments();
 
             if (arguments.size() > parameters.size()) {
+                BindingContext bindingContext = ResolvePackage.analyze(callElement);
                 boolean hasTypeMismatches = hasTypeMismatches(parameters, arguments, bindingContext);
                 return new AddFunctionParametersFix(callElement, functionDescriptor, hasTypeMismatches);
             }

idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeMemberFunctionSignatureFix.java

@@ -48,7 +48,6 @@ import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.renderer.DescriptorRenderer;
 import org.jetbrains.kotlin.renderer.DescriptorRendererBuilder;
 import org.jetbrains.kotlin.renderer.NameShortness;
-import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.FunctionDescriptorUtil;
 import org.jetbrains.kotlin.resolve.VisibilityUtil;
 import org.jetbrains.kotlin.resolve.scopes.JetScope;
@@ -118,9 +117,7 @@ public class ChangeMemberFunctionSignatureFix extends JetHintAction<JetNamedFunc
             return Collections.emptyList();
         }
 
-        BindingContext context = ResolvePackage.analyzeFully(functionElement);
+        FunctionDescriptor functionDescriptor = (FunctionDescriptor) ResolvePackage.resolveToDescriptor(functionElement);
-        FunctionDescriptor functionDescriptor = context.get(BindingContext.FUNCTION, functionElement);
-        if (functionDescriptor == null) return Lists.newArrayList();
         List<FunctionDescriptor> superFunctions = getPossibleSuperFunctionsDescriptors(functionDescriptor);
         final Map<String, FunctionDescriptor> possibleSignatures = Maps.newHashMap();
         for (FunctionDescriptor superFunction : superFunctions) {

idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeVariableTypeFix.java

@@ -36,7 +36,6 @@ import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers;
 import org.jetbrains.kotlin.idea.util.ShortenReferences;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.psi.*;
-import org.jetbrains.kotlin.psi.psiUtil.PsiUtilPackage;
 import org.jetbrains.kotlin.resolve.BindingContext;
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
@@ -117,7 +116,7 @@ public class ChangeVariableTypeFix extends JetIntentionAction<JetVariableDeclara
             @Override
             public IntentionAction createAction(@NotNull Diagnostic diagnostic) {
                 JetMultiDeclarationEntry entry = ChangeFunctionReturnTypeFix.getMultiDeclarationEntryThatTypeMismatchComponentFunction(diagnostic);
-                BindingContext context = ResolvePackage.analyzeFully(entry.getContainingJetFile());
+                BindingContext context = ResolvePackage.analyze(entry);
                 ResolvedCall<FunctionDescriptor> resolvedCall = context.get(BindingContext.COMPONENT_RESOLVED_CALL, entry);
                 if (resolvedCall == null) return null;
                 JetFunction componentFunction = (JetFunction) DescriptorToSourceUtils
@@ -139,18 +138,12 @@ public class ChangeVariableTypeFix extends JetIntentionAction<JetVariableDeclara
 
                 if (diagnostic.getPsiElement() instanceof JetProperty) {
                     JetProperty property = (JetProperty) diagnostic.getPsiElement();
-                    BindingContext context = ResolvePackage.analyzeFully(property.getContainingJetFile());
+                    DeclarationDescriptor descriptor = ResolvePackage.resolveToDescriptor(property);
-                    JetType lowerBoundOfOverriddenPropertiesTypes = QuickFixUtil.findLowerBoundOfOverriddenCallablesReturnTypes(context, property);
+                    if (!(descriptor instanceof PropertyDescriptor)) return actions;
-
-                    DeclarationDescriptor descriptor = context.get(BindingContext.DECLARATION_TO_DESCRIPTOR, property);
-                    if (!(descriptor instanceof PropertyDescriptor)) {
-                        // Probably can happen in incomplete code.
-                        LOG.error("Property descriptor is expected: " + PsiUtilPackage.getElementTextWithContext(property));
-                        return actions;
-                    }
-
                     PropertyDescriptor propertyDescriptor = (PropertyDescriptor) descriptor;
 
+                    JetType lowerBoundOfOverriddenPropertiesTypes = QuickFixUtil.findLowerBoundOfOverriddenCallablesReturnTypes(propertyDescriptor);
+
                     JetType propertyType = propertyDescriptor.getReturnType();
                     assert propertyType != null : "Property type cannot be null if it mismatch something";
 

idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeVisibilityModifierFix.java

@@ -73,7 +73,7 @@ public class ChangeVisibilityModifierFix extends JetIntentionAction<JetModifierL
 
     @Nullable
     private JetModifierKeywordToken findVisibilityChangeTo(JetFile file) {
-        BindingContext bindingContext = ResolvePackage.analyzeFully(file);
+        BindingContext bindingContext = ResolvePackage.analyze(element);
         DeclarationDescriptor descriptor;
         if (element instanceof JetParameter) {
             descriptor = bindingContext.get(BindingContext.PRIMARY_CONSTRUCTOR_PARAMETER, element);

idea/src/org/jetbrains/kotlin/idea/quickfix/InsertDelegationCallQuickfix.kt

@@ -23,7 +23,8 @@ import com.intellij.psi.PsiFile
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.diagnostics.Diagnostic
 import org.jetbrains.kotlin.idea.JetBundle
-import org.jetbrains.kotlin.idea.caches.resolve.analyzeFully
+import org.jetbrains.kotlin.idea.caches.resolve.analyze
+import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor
 import org.jetbrains.kotlin.idea.quickfix.quickfixUtil.createIntentionForFirstParentOfType
 import org.jetbrains.kotlin.idea.search.usagesSearch.descriptor
 import org.jetbrains.kotlin.psi.JetClass
@@ -43,9 +44,8 @@ public class InsertDelegationCallQuickfix(val isThis: Boolean, element: JetSecon
     override fun invoke(project: Project, editor: Editor?, file: JetFile?) {
         val newDelegationCall = element.replaceImplicitDelegationCallWithExplicit(isThis)
 
-        val context = element.analyzeFully()
+        val resolvedCall = newDelegationCall.getResolvedCall(newDelegationCall.analyze())
-        val resolvedCall = newDelegationCall.getResolvedCall(context)
+        val descriptor = element.resolveToDescriptor()
-        val descriptor = element.descriptor
 
         // if empty call is ok and it's resolved to another constructor, do not move caret
         if (resolvedCall?.getStatus()?.isSuccess() ?: false && resolvedCall!!.getCandidateDescriptor().getOriginal() != descriptor) return

idea/src/org/jetbrains/kotlin/idea/quickfix/MapPlatformClassToKotlinFix.java

@@ -194,10 +194,7 @@ public class MapPlatformClassToKotlinFix extends JetIntentionAction<JetReference
                 JetReferenceExpression typeExpr = getImportOrUsageFromDiagnostic(diagnostic);
                 if (typeExpr == null) return null;
 
-                PsiFile psiFile = diagnostic.getPsiFile();
+                BindingContext context = ResolvePackage.analyze(typeExpr);
-                if (!(psiFile instanceof JetFile)) return null;
-
-                BindingContext context = ResolvePackage.analyzeFully((JetFile) psiFile);
                 ClassDescriptor platformClass = resolveToClass(typeExpr, context);
                 if (platformClass == null) return null;
 

idea/src/org/jetbrains/kotlin/idea/quickfix/RenameParameterToMatchOverriddenMethodFix.java

@@ -49,7 +49,7 @@ public class RenameParameterToMatchOverriddenMethodFix extends JetIntentionActio
             return false;
         }
 
-        BindingContext context = ResolvePackage.analyzeFully(parameter);
+        BindingContext context = ResolvePackage.analyze(parameter);
         VariableDescriptor parameterDescriptor = context.get(BindingContext.VALUE_PARAMETER, parameter);
         if (parameterDescriptor == null) {
             return false;