Abandon storing BindingContext in JetFunctionPsiElementCellRenderer

#EA-61357 Fixed

idea/src/org/jetbrains/jet/plugin/codeInsight/GotoSuperActionHandler.java

@@ -34,13 +34,12 @@ import com.intellij.util.containers.ContainerUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.psi.*;
-import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.DescriptorToSourceUtils;
 import org.jetbrains.jet.lang.resolve.OverrideResolver;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 import org.jetbrains.jet.plugin.JetBundle;
-import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache;
+import org.jetbrains.jet.plugin.caches.resolve.ResolvePackage;
 
 import java.util.Collection;
 import java.util.List;
@@ -60,9 +59,7 @@ public class GotoSuperActionHandler implements CodeInsightActionHandler {
                                             JetObjectDeclaration.class);
         if (declaration == null) return;
 
-        BindingContext bindingContext = AnalyzerFacadeWithCache.getContextForElement(declaration);
-
-        DeclarationDescriptor descriptor = bindingContext.get(BindingContext.DECLARATION_TO_DESCRIPTOR, declaration);
+        DeclarationDescriptor descriptor = ResolvePackage.getLazyResolveSession(declaration).resolveToDescriptor(declaration);
 
         Collection<? extends DeclarationDescriptor> superDescriptors;
         String message;
@@ -117,7 +114,7 @@ public class GotoSuperActionHandler implements CodeInsightActionHandler {
             JBPopup popup = descriptor instanceof ClassDescriptor
                             ? NavigationUtil.getPsiElementPopup(superDeclarationsArray, message)
                             : NavigationUtil.getPsiElementPopup(superDeclarationsArray,
-                                                                new JetFunctionPsiElementCellRenderer(bindingContext), message);
+                                                                new JetFunctionPsiElementCellRenderer(), message);
             popup.showInBestPositionFor(editor);
         }
     }

idea/src/org/jetbrains/jet/plugin/codeInsight/JetFunctionPsiElementCellRenderer.java

@@ -18,25 +18,18 @@ package org.jetbrains.jet.plugin.codeInsight;
 
 import com.intellij.ide.util.DefaultPsiElementCellRenderer;
 import com.intellij.psi.PsiElement;
-import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptor;
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.psi.JetNamedFunction;
-import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.plugin.caches.resolve.ResolvePackage;
 import org.jetbrains.jet.renderer.DescriptorRenderer;
 
 public class JetFunctionPsiElementCellRenderer extends DefaultPsiElementCellRenderer {
-    private final BindingContext bindingContext;
-
-    public JetFunctionPsiElementCellRenderer(BindingContext bindingContext) {
-        this.bindingContext = bindingContext;
-    }
-
     @Override
     public String getElementText(PsiElement element) {
         if (element instanceof JetNamedFunction) {
             JetNamedFunction function = (JetNamedFunction) element;
-            SimpleFunctionDescriptor fd = bindingContext.get(BindingContext.FUNCTION, function);
-            assert fd != null;
-            return DescriptorRenderer.SHORT_NAMES_IN_TYPES.render(fd);
+            DeclarationDescriptor descriptor = ResolvePackage.getLazyResolveSession(function).resolveToDescriptor(function);
+            return DescriptorRenderer.SHORT_NAMES_IN_TYPES.render(descriptor);
         }
         return super.getElementText(element);
     }

idea/src/org/jetbrains/jet/plugin/highlighter/JetLineMarkerProvider.java

@@ -190,7 +190,7 @@ public class JetLineMarkerProvider implements LineMarkerProvider {
 
         // NOTE: Don't store descriptors in line markers because line markers are not deleted while editing other files and this can prevent
         // clearing the whole BindingTrace.
-        LineMarkerInfo<JetElement> marker = new LineMarkerInfo<JetElement>(
+        LineMarkerInfo<JetDeclaration> marker = new LineMarkerInfo<JetDeclaration>(
                 declaration,
                 declaration.getTextOffset(),
                 isImplementsAndNotOverrides(resolveWithParents.getDescriptor(), resolveWithParents.getOverriddenDescriptors()) ?

idea/src/org/jetbrains/jet/plugin/highlighter/markers/SuperDeclarationMarker.kt

@@ -16,9 +16,6 @@
 
 package org.jetbrains.jet.plugin.highlighter.markers
 
-import org.jetbrains.jet.lang.psi.JetElement
-import org.jetbrains.jet.lang.resolve.BindingContext
-import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache
 import org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor
 import org.jetbrains.jet.lang.resolve.OverrideResolver
 import org.jetbrains.jet.lang.descriptors.Modality
@@ -37,13 +34,12 @@ import org.jetbrains.annotations.TestOnly
 import com.intellij.codeInsight.daemon.GutterIconNavigationHandler
 import java.util.ArrayList
 import com.intellij.util.Function
+import org.jetbrains.jet.plugin.caches.resolve.getLazyResolveSession
+import org.jetbrains.jet.lang.psi.JetDeclaration
 
-object SuperDeclarationMarkerTooltip: Function<JetElement, String> {
-    override fun `fun`(param: JetElement?): String? {
-        val element = param!!
-
-        [suppress("UNUSED_VARIABLE")]
-        val (elementDescriptor, _, overriddenDescriptors) = resolveDeclarationWithParents(element)
+object SuperDeclarationMarkerTooltip: Function<JetDeclaration, String> {
+    override fun `fun`(jetDeclaration: JetDeclaration?): String? {
+        val (elementDescriptor, overriddenDescriptors) = resolveDeclarationWithParents(jetDeclaration!!)
         if (overriddenDescriptors.isEmpty()) return ""
 
         val isAbstract = elementDescriptor!!.getModality() == Modality.ABSTRACT
@@ -67,7 +63,7 @@ object SuperDeclarationMarkerTooltip: Function<JetElement, String> {
     }
 }
 
-public class SuperDeclarationMarkerNavigationHandler : GutterIconNavigationHandler<JetElement> {
+public class SuperDeclarationMarkerNavigationHandler : GutterIconNavigationHandler<JetDeclaration> {
     private var testNavigableElements: List<NavigatablePsiElement>? = null
 
     TestOnly
@@ -77,10 +73,10 @@ public class SuperDeclarationMarkerNavigationHandler : GutterIconNavigationHandl
         return navigationResult
     }
 
-    override fun navigate(e: MouseEvent?, element: JetElement?) {
+    override fun navigate(e: MouseEvent?, element: JetDeclaration?) {
         if (element == null) return
 
-        val (elementDescriptor, bindingContext, overriddenDescriptors) = resolveDeclarationWithParents(element)
+        val (elementDescriptor, overriddenDescriptors) = resolveDeclarationWithParents(element)
         if (overriddenDescriptors.isEmpty()) return
 
         val superDeclarations = ArrayList<NavigatablePsiElement>()
@@ -101,7 +97,7 @@ public class SuperDeclarationMarkerNavigationHandler : GutterIconNavigationHandl
                     superDeclarations.copyToArray(),
                     JetBundle.message("navigation.title.super.declaration", elementName),
                     JetBundle.message("navigation.findUsages.title.super.declaration", elementName),
-                    JetFunctionPsiElementCellRenderer(bindingContext))
+                    JetFunctionPsiElementCellRenderer())
         }
         else {
             // Only store elements for retrieve in test
@@ -112,15 +108,13 @@ public class SuperDeclarationMarkerNavigationHandler : GutterIconNavigationHandl
 
 public data class ResolveWithParentsResult(
         val descriptor: CallableMemberDescriptor?,
-        val bindingContext: BindingContext,
         val overriddenDescriptors: Collection<CallableMemberDescriptor>)
 
-public fun resolveDeclarationWithParents(element: JetElement): ResolveWithParentsResult {
-    val bindingContext = AnalyzerFacadeWithCache.getContextForElement(element)
-    val descriptor = bindingContext.get(BindingContext.DECLARATION_TO_DESCRIPTOR, element)
+public fun resolveDeclarationWithParents(element: JetDeclaration): ResolveWithParentsResult {
+    val descriptor = element.getLazyResolveSession().resolveToDescriptor(element)
 
-    if (descriptor !is CallableMemberDescriptor) return ResolveWithParentsResult(null, bindingContext, listOf())
+    if (descriptor !is CallableMemberDescriptor) return ResolveWithParentsResult(null, listOf())
 
     val overriddenMembers = OverrideResolver.getDirectlyOverriddenDeclarations(descriptor)
-    return ResolveWithParentsResult(descriptor, bindingContext, overriddenMembers)
+    return ResolveWithParentsResult(descriptor, overriddenMembers)
 }