Make caching headers work for JS projects

idea/src/org/jetbrains/jet/plugin/caches/resolve/KotlinCacheManager.java

@@ -36,21 +36,26 @@ import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.BindingTraceContext;
 import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
 import org.jetbrains.jet.lang.resolve.java.JetFilesProvider;
+import org.jetbrains.jet.plugin.framework.KotlinFrameworkDetector;
+import org.jetbrains.jet.plugin.project.TargetPlatform;
+import org.jetbrains.k2js.analyze.AnalyzerFacadeForJS;
+import org.jetbrains.k2js.config.EcmaVersion;
+import org.jetbrains.k2js.config.LibrarySourcesConfig;
 
 import java.util.Collections;
 
 public class KotlinCacheManager {
-
     public static KotlinCacheManager getInstance(@NotNull Project project) {
         return ServiceManager.getService(project, KotlinCacheManager.class);
     }
 
     private static final Key<CachedValue<KotlinDeclarationsCache>> KOTLIN_DECLARATIONS_CACHE = Key.create("KOTLIN_DECLARATIONS_CACHE");
+    private static final Key<CachedValue<KotlinDeclarationsCache>> KOTLIN_JS_DECLARATIONS_CACHE = Key.create("KOTLIN_JS_DECLARATIONS_CACHE");
 
     private final Project project;
     private final Object declarationAnalysisLock = new Object();
 
-    private BindingTrace incompleteTrace;
+    private BindingTrace incompleteJvmTrace;
 
     public KotlinCacheManager(@NotNull Project project) {
         this.project = project;
@@ -62,12 +67,12 @@ public class KotlinCacheManager {
         ApplicationManager.getApplication().assertReadAccessAllowed();
         synchronized (declarationAnalysisLock) {
             if (allowIncomplete) {
-                if (incompleteTrace != null) {
+                if (incompleteJvmTrace != null) {
                     return new KotlinDeclarationsCache() {
                         @NotNull
                         @Override
                         public BindingContext getBindingContext() {
-                            return incompleteTrace.getBindingContext();
+                            return incompleteJvmTrace.getBindingContext();
                         }
                     };
                 }
@@ -76,15 +81,32 @@ public class KotlinCacheManager {
             return CachedValuesManager.getManager(project).getCachedValue(
                     project,
                     KOTLIN_DECLARATIONS_CACHE,
-                    new KotlinDeclarationsCacheProvider(),
+                    new KotlinDeclarationsJvmCacheProvider(),
                     false
             );
         }
     }
 
     @NotNull
-    public KotlinDeclarationsCache getDeclarationsFromProject() {
+    private KotlinDeclarationsCache getJsDeclarations() {
-        return getDeclarations(false);
+        // To prevent dead locks, the lock below must be obtained only inside a read action
+        ApplicationManager.getApplication().assertReadAccessAllowed();
+        synchronized (declarationAnalysisLock) {
+            return CachedValuesManager.getManager(project).getCachedValue(
+                    project,
+                    KOTLIN_JS_DECLARATIONS_CACHE,
+                    new KotlinDeclarationsJsCacheProvider(),
+                    false
+            );
+        }
+    }
+
+    /**
+     * Should be called under read lock.
+     */
+    @NotNull
+    public KotlinDeclarationsCache getDeclarationsFromProject(TargetPlatform platform) {
+        return platform == TargetPlatform.JVM ? getDeclarations(false) : getJsDeclarations();
     }
 
     @NotNull
@@ -107,7 +129,33 @@ public class KotlinCacheManager {
         return getDeclarations(true);
     }
 
-    private class KotlinDeclarationsCacheProvider implements CachedValueProvider<KotlinDeclarationsCache> {
+    private class KotlinDeclarationsJsCacheProvider implements CachedValueProvider<KotlinDeclarationsCache> {
+        @Nullable
+        @Override
+        public Result<KotlinDeclarationsCache> compute() {
+            // This lock is already acquired by the calling method,
+            // but we put it here to guard for the case of further modifications
+            synchronized (declarationAnalysisLock) {
+                LibrarySourcesConfig config = new LibrarySourcesConfig(
+                        project, "default",
+                        KotlinFrameworkDetector.getLibLocationAndTargetForProject(project).first,
+                        EcmaVersion.defaultVersion());
+
+                AnalyzeExhaust analyzeExhaust = AnalyzerFacadeForJS.analyzeFiles(
+                        JetFilesProvider.getInstance(project).allInScope(GlobalSearchScope.allScope(project)),
+                        Predicates.<PsiFile>alwaysFalse(),
+                        config,
+                        true);
+
+                return Result.<KotlinDeclarationsCache>create(
+                        new KotlinDeclarationsCacheImpl(analyzeExhaust),
+                        PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT
+                );
+            }
+        }
+    }
+
+    private class KotlinDeclarationsJvmCacheProvider implements CachedValueProvider<KotlinDeclarationsCache> {
         @Nullable
         @Override
         public Result<KotlinDeclarationsCache> compute() {
@@ -116,7 +164,7 @@ public class KotlinCacheManager {
             synchronized (declarationAnalysisLock) {
                 BindingTraceContext trace = new BindingTraceContext();
 
-                incompleteTrace = trace;
+                incompleteJvmTrace = trace;
                 AnalyzeExhaust analyzeExhaust;
                 try {
                     analyzeExhaust = AnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(
@@ -128,7 +176,7 @@ public class KotlinCacheManager {
                             true);
                 }
                 finally {
-                    incompleteTrace = null;
+                    incompleteJvmTrace = null;
                 }
 
                 return Result.<KotlinDeclarationsCache>create(

idea/src/org/jetbrains/jet/plugin/caches/resolve/KotlinCacheManagerUtil.java

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2010-2013 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.jet.plugin.caches.resolve;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.psi.JetElement;
+import org.jetbrains.jet.lang.psi.JetFile;
+import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.plugin.project.TargetPlatformDetector;
+
+public class KotlinCacheManagerUtil {
+    private KotlinCacheManagerUtil() {
+    }
+
+    @NotNull
+    public static KotlinDeclarationsCache getDeclarationsFromProject(@NotNull JetElement element) {
+        JetFile jetFile = (JetFile) element.getContainingFile();
+        return KotlinCacheManager.getInstance(jetFile.getProject()).getDeclarationsFromProject(TargetPlatformDetector.getPlatform(jetFile));
+    }
+
+    @NotNull
+    public static BindingContext getDeclarationsBindingContext(@NotNull JetElement element) {
+        JetFile jetFile = (JetFile) element.getContainingFile();
+        KotlinDeclarationsCache declarationsCache = KotlinCacheManager.getInstance(jetFile.getProject())
+                .getDeclarationsFromProject(TargetPlatformDetector.getPlatform(jetFile));
+        return declarationsCache.getBindingContext();
+    }
+}

idea/src/org/jetbrains/jet/plugin/codeInsight/ktSignature/KotlinSignatureInJavaMarkerProvider.java

@@ -25,7 +25,6 @@ import com.intellij.ide.DataManager;
 import com.intellij.ide.util.PropertiesComponent;
 import com.intellij.openapi.actionSystem.ActionGroup;
 import com.intellij.openapi.actionSystem.DefaultActionGroup;
-import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.editor.markup.GutterIconRenderer;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.text.StringUtil;
@@ -49,6 +48,7 @@ import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.plugin.JetIcons;
 import org.jetbrains.jet.plugin.caches.resolve.KotlinCacheManager;
 import org.jetbrains.jet.plugin.caches.resolve.KotlinDeclarationsCache;
+import org.jetbrains.jet.plugin.project.TargetPlatform;
 
 import java.awt.event.MouseEvent;
 import java.util.Collection;
@@ -67,8 +67,6 @@ public class KotlinSignatureInJavaMarkerProvider implements LineMarkerProvider {
             }
         }
     };
-    private static final Logger LOG = Logger.getInstance(KotlinSignatureInJavaMarkerProvider.class);
-
 
     @Override
     @Nullable
@@ -87,7 +85,7 @@ public class KotlinSignatureInJavaMarkerProvider implements LineMarkerProvider {
             return;
         }
 
-        KotlinDeclarationsCache declarationsCache = KotlinCacheManager.getInstance(project).getDeclarationsFromProject();
+        KotlinDeclarationsCache declarationsCache = KotlinCacheManager.getInstance(project).getDeclarationsFromProject(TargetPlatform.JVM);
         BindingContext bindingContext = declarationsCache.getBindingContext();
         DelegatingBindingTrace bindingTrace = new DelegatingBindingTrace(bindingContext, "wrapped context of declarations cache");
 

idea/src/org/jetbrains/jet/plugin/hierarchy/KotlinTypeHierarchyProvider.java

@@ -36,8 +36,7 @@ import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.psi.JetNamedFunction;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.types.JetType;
-import org.jetbrains.jet.plugin.JetPluginUtil;
+import org.jetbrains.jet.plugin.caches.resolve.KotlinCacheManagerUtil;
-import org.jetbrains.jet.plugin.caches.resolve.KotlinCacheManager;
 import org.jetbrains.jet.plugin.libraries.JetSourceNavigationHelper;
 import org.jetbrains.jet.plugin.stubindex.JetShortClassNameIndex;
 import org.jetbrains.jet.renderer.DescriptorRenderer;
@@ -47,7 +46,7 @@ import java.util.Collection;
 public class KotlinTypeHierarchyProvider extends JavaTypeHierarchyProvider {
 
     @Override
-    public PsiElement getTarget(@NotNull final DataContext dataContext) {
+    public PsiElement getTarget(@NotNull DataContext dataContext) {
         Project project = PlatformDataKeys.PROJECT.getData(dataContext);
         if (project == null) return null;
 
@@ -69,7 +68,7 @@ public class KotlinTypeHierarchyProvider extends JavaTypeHierarchyProvider {
             else if (target instanceof JetNamedFunction) {
                 JetNamedFunction function = (JetNamedFunction) target;
                 String functionName = function.getName();
-                FunctionDescriptor functionDescriptor = KotlinCacheManager.getInstance(project).getDeclarationsFromProject().getBindingContext()
+                FunctionDescriptor functionDescriptor = KotlinCacheManagerUtil.getDeclarationsBindingContext(function)
                         .get(BindingContext.FUNCTION, target);
                 if (functionDescriptor != null) {
                     JetType type = functionDescriptor.getReturnType();

idea/src/org/jetbrains/jet/plugin/project/AnalyzerFacadeWithCache.java

@@ -46,9 +46,9 @@ import org.jetbrains.jet.lang.resolve.*;
 import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
 import org.jetbrains.jet.lang.resolve.java.JetFilesProvider;
 import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
-import org.jetbrains.jet.plugin.caches.resolve.KotlinDeclarationsCacheImpl;
+import org.jetbrains.jet.plugin.caches.resolve.KotlinCacheManagerUtil;
-import org.jetbrains.jet.plugin.caches.resolve.KotlinCacheManager;
 import org.jetbrains.jet.plugin.caches.resolve.KotlinDeclarationsCache;
+import org.jetbrains.jet.plugin.caches.resolve.KotlinDeclarationsCacheImpl;
 import org.jetbrains.jet.plugin.util.ApplicationUtils;
 
 import java.util.Collection;
@@ -136,7 +136,8 @@ public final class AnalyzerFacadeWithCache {
                     Predicates.<PsiFile>alwaysFalse()
             );
         }
-        KotlinDeclarationsCache cache = KotlinCacheManager.getInstance(fileToCache.getProject()).getDeclarationsFromProject();
+
+        KotlinDeclarationsCache cache = KotlinCacheManagerUtil.getDeclarationsFromProject(fileToCache);
         return ((KotlinDeclarationsCacheImpl) cache).getAnalyzeExhaust();
     }
 

idea/src/org/jetbrains/jet/plugin/quickfix/ChangePropertyTypeToMatchOverriddenPropertyFix.java

@@ -25,13 +25,14 @@ import com.intellij.util.IncorrectOperationException;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.diagnostics.Diagnostic;
+import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.psi.JetProperty;
 import org.jetbrains.jet.lang.psi.JetPsiFactory;
 import org.jetbrains.jet.lang.psi.JetTypeReference;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.plugin.JetBundle;
-import org.jetbrains.jet.plugin.caches.resolve.KotlinCacheManager;
+import org.jetbrains.jet.plugin.caches.resolve.KotlinCacheManagerUtil;
 import org.jetbrains.jet.plugin.intentions.SpecifyTypeExplicitlyAction;
 
 public class ChangePropertyTypeToMatchOverriddenPropertyFix extends JetIntentionAction<JetProperty> {
@@ -47,7 +48,7 @@ public class ChangePropertyTypeToMatchOverriddenPropertyFix extends JetIntention
             return false;
         }
 
-        BindingContext context = KotlinCacheManager.getInstance(project).getDeclarationsFromProject().getBindingContext();
+        BindingContext context = KotlinCacheManagerUtil.getDeclarationsBindingContext((JetFile) file);
         matchingType = QuickFixUtil.findLowerBoundOfOverriddenCallablesReturnTypes(context, element);
         return matchingType != null;
     }

idea/src/org/jetbrains/jet/plugin/quickfix/ChangeReturnTypeToMatchOverriddenMethodFix.java

@@ -25,6 +25,7 @@ import com.intellij.util.IncorrectOperationException;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.diagnostics.Diagnostic;
+import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.psi.JetFunction;
 import org.jetbrains.jet.lang.psi.JetPsiFactory;
 import org.jetbrains.jet.lang.psi.JetTypeReference;
@@ -33,7 +34,9 @@ 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.caches.resolve.KotlinCacheManager;
+import org.jetbrains.jet.plugin.caches.resolve.KotlinCacheManagerUtil;
 import org.jetbrains.jet.plugin.intentions.SpecifyTypeExplicitlyAction;
+import org.jetbrains.jet.plugin.project.TargetPlatform;
 
 public class ChangeReturnTypeToMatchOverriddenMethodFix extends JetIntentionAction<JetFunction> {
     private JetType matchingReturnType;
@@ -48,7 +51,7 @@ public class ChangeReturnTypeToMatchOverriddenMethodFix extends JetIntentionActi
             return false;
         }
 
-        BindingContext context = KotlinCacheManager.getInstance(project).getDeclarationsFromProject().getBindingContext();
+        BindingContext context = KotlinCacheManagerUtil.getDeclarationsBindingContext((JetFile) file);
         matchingReturnType = QuickFixUtil.findLowerBoundOfOverriddenCallablesReturnTypes(context, element);
         return matchingReturnType != null;
     }

idea/src/org/jetbrains/jet/plugin/quickfix/ChangeToConstructorInvocationFix.java

@@ -30,7 +30,7 @@ import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.TypeUtils;
 import org.jetbrains.jet.plugin.JetBundle;
-import org.jetbrains.jet.plugin.caches.resolve.KotlinCacheManager;
+import org.jetbrains.jet.plugin.caches.resolve.KotlinCacheManagerUtil;
 
 import java.util.List;
 
@@ -54,8 +54,12 @@ public class ChangeToConstructorInvocationFix extends JetIntentionAction<JetDele
 
     @Override
     public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) {
+        if (!super.isAvailable(project, editor, file)) {
+            return false;
+        }
+
         JetTypeReference typeReference = element.getTypeReference();
-        BindingContext context = KotlinCacheManager.getInstance(project).getDeclarationsFromProject().getBindingContext();
+        BindingContext context = KotlinCacheManagerUtil.getDeclarationsBindingContext((JetFile) file);
         JetType supertype = context.get(BindingContext.TYPE, typeReference);
         if (supertype == null) return false;
         ClassDescriptor classDescriptor = TypeUtils.getClassDescriptor(supertype);

idea/src/org/jetbrains/jet/plugin/quickfix/JetIntentionAction.java

@@ -25,6 +25,7 @@ import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.diagnostics.Diagnostic;
+import org.jetbrains.jet.lang.psi.JetFile;
 
 public abstract class JetIntentionAction<T extends PsiElement> implements IntentionAction {
     protected @NotNull T element;
@@ -35,7 +36,7 @@ public abstract class JetIntentionAction<T extends PsiElement> implements Intent
 
     @Override
     public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) {
-        return element.isValid() && file.getManager().isInProject(file);
+        return element.isValid() && file.getManager().isInProject(file) && (file instanceof JetFile);
     }
 
     @Override

idea/src/org/jetbrains/jet/plugin/quickfix/MapPlatformClassToKotlinFix.java

@@ -37,7 +37,7 @@ import org.jetbrains.jet.lang.diagnostics.Errors;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.plugin.JetBundle;
-import org.jetbrains.jet.plugin.caches.resolve.KotlinCacheManager;
+import org.jetbrains.jet.plugin.caches.resolve.KotlinCacheManagerUtil;
 import org.jetbrains.jet.renderer.DescriptorRenderer;
 
 import java.util.ArrayList;
@@ -62,7 +62,6 @@ public class MapPlatformClassToKotlinFix extends JetIntentionAction<JetReference
     @NotNull
     @Override
     public String getText() {
-
         String platformClassQualifiedName = DescriptorRenderer.TEXT.renderType(platformClass.getDefaultType());
         return possibleClasses.size() == 1
                ? JetBundle.message("map.platform.class.to.kotlin", platformClassQualifiedName,
@@ -78,7 +77,7 @@ public class MapPlatformClassToKotlinFix extends JetIntentionAction<JetReference
 
     @Override
     public void invoke(@NotNull Project project, Editor editor, PsiFile file) throws IncorrectOperationException {
-        BindingContext context = KotlinCacheManager.getInstance(project).getDeclarationsFromProject().getBindingContext();
+        BindingContext context = KotlinCacheManagerUtil.getDeclarationsBindingContext((JetFile) file);
         Collection<Diagnostic> diagnostics = context.getDiagnostics();
         List<JetImportDirective> imports = new ArrayList<JetImportDirective>();
         List<JetUserType> usages = new ArrayList<JetUserType>();
@@ -192,8 +191,10 @@ public class MapPlatformClassToKotlinFix extends JetIntentionAction<JetReference
                 JetReferenceExpression typeExpr = getImportOrUsageFromDiagnostic(diagnostic);
                 if (typeExpr == null) return null;
 
-                Project project = diagnostic.getPsiFile().getProject();
+                PsiFile psiFile = diagnostic.getPsiFile();
-                BindingContext context = KotlinCacheManager.getInstance(project).getDeclarationsFromProject().getBindingContext();
+                if (!(psiFile instanceof JetFile)) return null;
+
+                BindingContext context = KotlinCacheManagerUtil.getDeclarationsBindingContext((JetFile) psiFile);
                 ClassDescriptor platformClass = resolveToClass(typeExpr, context);
                 if (platformClass == null) return null;
 

idea/src/org/jetbrains/jet/plugin/quickfix/RenameParameterToMatchOverriddenMethodFix.java

@@ -24,12 +24,13 @@ import com.intellij.refactoring.rename.RenameProcessor;
 import com.intellij.util.IncorrectOperationException;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
+import org.jetbrains.jet.lang.descriptors.VariableDescriptor;
 import org.jetbrains.jet.lang.diagnostics.Diagnostic;
 import org.jetbrains.jet.lang.psi.JetParameter;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.plugin.JetBundle;
-import org.jetbrains.jet.plugin.caches.resolve.KotlinCacheManager;
+import org.jetbrains.jet.plugin.caches.resolve.KotlinCacheManagerUtil;
 
 public class RenameParameterToMatchOverriddenMethodFix extends JetIntentionAction<JetParameter>{
     private final JetParameter parameter;
@@ -46,7 +47,7 @@ public class RenameParameterToMatchOverriddenMethodFix extends JetIntentionActio
             return false;
         }
 
-        BindingContext context = KotlinCacheManager.getInstance(project).getDeclarationsFromProject().getBindingContext();
+        BindingContext context = KotlinCacheManagerUtil.getDeclarationsBindingContext(parameter);
         VariableDescriptor parameterDescriptor = context.get(BindingContext.VALUE_PARAMETER, parameter);
         if (parameterDescriptor == null) {
             return false;

idea/src/org/jetbrains/jet/plugin/search/KotlinAnnotatedElementsSearcher.java

@@ -18,7 +18,6 @@ package org.jetbrains.jet.plugin.search;
 
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.diagnostic.Logger;
-import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.Computable;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.psi.PsiClass;
@@ -44,16 +43,12 @@ import org.jetbrains.jet.lang.psi.JetDeclaration;
 import org.jetbrains.jet.lang.psi.JetNamedFunction;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
-import org.jetbrains.jet.plugin.caches.resolve.KotlinCacheManager;
+import org.jetbrains.jet.plugin.caches.resolve.KotlinCacheManagerUtil;
-import org.jetbrains.jet.plugin.caches.resolve.KotlinDeclarationsCache;
 import org.jetbrains.jet.plugin.stubindex.JetAnnotationsIndex;
 
 import java.util.ArrayList;
 import java.util.Collection;
 
-/**
- * User: Natalia.Ukhorskaya
- */
 public class KotlinAnnotatedElementsSearcher extends AnnotatedElementsSearcher {
     private static final Logger LOG = Logger.getInstance("#com.intellij.psi.impl.search.AnnotatedMembersSearcher");
 
@@ -73,13 +68,12 @@ public class KotlinAnnotatedElementsSearcher extends AnnotatedElementsSearcher {
             ApplicationManager.getApplication().runReadAction(new Runnable() {
                 @Override
                 public void run() {
-                    //TODO LazyResolve
-                    Project project = elt.getProject();
-                    KotlinDeclarationsCache declarations = KotlinCacheManager.getInstance(project).getDeclarationsFromProject();
-                    BindingContext context = declarations.getBindingContext();
-
                     JetDeclaration parentOfType = PsiTreeUtil.getParentOfType(elt, JetDeclaration.class);
                     if (parentOfType == null) return;
+
+                    //TODO LazyResolve
+                    BindingContext context = KotlinCacheManagerUtil.getDeclarationsBindingContext(parentOfType);
+
                     AnnotationDescriptor annotationDescriptor = context.get(BindingContext.ANNOTATION, (JetAnnotationEntry) elt);
                     if (annotationDescriptor == null) return;