getDeclarationsFromProject() is replaced by lazy resolve

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

@@ -17,7 +17,6 @@
 package org.jetbrains.jet.plugin.caches.resolve;
 
 import com.google.common.collect.Maps;
-import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.components.ServiceManager;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.DefaultModificationTracker;
@@ -42,16 +41,6 @@ public class KotlinCacheManager {
         cacheProviders.put(TargetPlatform.JS, new JSDeclarationsCacheProvider(project));
     }
 
-    /**
-     * Should be called under read lock.
-     */
-    @NotNull
-    public KotlinDeclarationsCache getDeclarationsFromProject(@NotNull TargetPlatform platform) {
-        // Computing declarations should be performed under read lock
-        ApplicationManager.getApplication().assertReadAccessAllowed();
-        return getRegisteredProvider(platform).getDeclarations();
-    }
-
     @NotNull
     public DeclarationsCacheProvider getRegisteredProvider(@NotNull TargetPlatform platform) {
         DeclarationsCacheProvider provider = cacheProviders.get(platform);
@@ -62,10 +51,6 @@ public class KotlinCacheManager {
         return provider;
     }
 
-    public void invalidateCache() {
-        kotlinDeclarationsTracker.incModificationCount();
-    }
-
     public ModificationTracker getDeclarationsTracker() {
         return kotlinDeclarationsTracker;
     }

idea/src/org/jetbrains/jet/plugin/caches/resolve/KotlinResolveCache.kt

@@ -57,6 +57,10 @@ fun JetElement.getLazyResolveSession(): ResolveSessionForBodies {
     return KotlinCacheService.getInstance(getProject()).getLazyResolveSession(this)
 }
 
+fun Project.getLazyResolveSession(platform: TargetPlatform): ResolveSessionForBodies {
+    return KotlinCacheService.getInstance(this).getGlobalLazyResolveSession(platform)
+}
+
 fun JetElement.getAnalysisResults(): AnalyzeExhaust {
     return KotlinCacheService.getInstance(getProject()).getAnalysisResults(listOf(this))
 }
@@ -140,6 +144,10 @@ class KotlinCacheService(val project: Project) {
 
     }
 
+    public fun getGlobalLazyResolveSession(platform: TargetPlatform): ResolveSessionForBodies {
+        return globalCachesPerPlatform[platform]!!.getLazyResolveSession()
+    }
+
     public fun getLazyResolveSession(element: JetElement): ResolveSessionForBodies {
         val file = element.getContainingJetFile()
         if (!isFileInScope(file)) {
@@ -148,7 +156,7 @@ class KotlinCacheService(val project: Project) {
             }
         }
 
-        return globalCachesPerPlatform[TargetPlatformDetector.getPlatform(file)]!!.getLazyResolveSession()
+        return getGlobalLazyResolveSession(TargetPlatformDetector.getPlatform(file))
     }
 
     public fun getAnalysisResults(elements: Collection<JetElement>): AnalyzeExhaust {
@@ -255,9 +263,6 @@ private class KotlinResolveCache(
                 catch (e: Throwable) {
                     handleError(e)
 
-                    // Exception during body resolve analyze can harm internal caches in declarations cache
-                    KotlinCacheManager.getInstance(project).invalidateCache()
-
                     val bindingTraceContext = BindingTraceContext()
                     return AnalyzeExhaust.error(bindingTraceContext.getBindingContext(), e)
                 }

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

@@ -39,8 +39,6 @@ import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor;
 import org.jetbrains.jet.lang.resolve.BindingContext;
-import org.jetbrains.jet.lang.resolve.BindingTrace;
-import org.jetbrains.jet.lang.resolve.DelegatingBindingTrace;
 import org.jetbrains.jet.lang.resolve.java.JavaBindingContext;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.java.descriptor.JavaClassDescriptor;
@@ -49,8 +47,7 @@ import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.plugin.JetIcons;
 import org.jetbrains.jet.plugin.caches.resolve.JavaResolveExtension;
-import org.jetbrains.jet.plugin.caches.resolve.KotlinCacheManager;
+import org.jetbrains.jet.plugin.caches.resolve.ResolvePackage;
-import org.jetbrains.jet.plugin.caches.resolve.KotlinDeclarationsCache;
 import org.jetbrains.jet.plugin.project.ProjectStructureUtil;
 import org.jetbrains.jet.plugin.project.TargetPlatform;
 
@@ -96,7 +93,7 @@ public class KotlinSignatureInJavaMarkerProvider implements LineMarkerProvider {
             return;
         }
 
-        BindingTrace trace = createDelegatingTrace(project);
+        BindingContext bindingContext = ResolvePackage.getLazyResolveSession(project, TargetPlatform.JVM).getBindingContext();
 
         JavaDescriptorResolver javaDescriptorResolver = JavaResolveExtension.instance$.get(project);
 
@@ -110,11 +107,11 @@ public class KotlinSignatureInJavaMarkerProvider implements LineMarkerProvider {
                 continue;
             }
 
-            DeclarationDescriptor memberDescriptor = getDescriptorForMember(javaDescriptorResolver, member, trace);
+            DeclarationDescriptor memberDescriptor = getDescriptorForMember(javaDescriptorResolver, member, bindingContext);
 
             if (memberDescriptor == null) continue;
 
-            List<String> errors = trace.get(JavaBindingContext.LOAD_FROM_JAVA_SIGNATURE_ERRORS, memberDescriptor);
+            List<String> errors = bindingContext.get(JavaBindingContext.LOAD_FROM_JAVA_SIGNATURE_ERRORS, memberDescriptor);
             boolean hasSignatureAnnotation = KotlinSignatureUtil.findKotlinSignatureAnnotation(element) != null;
 
             if (errors != null || hasSignatureAnnotation) {
@@ -123,18 +120,11 @@ public class KotlinSignatureInJavaMarkerProvider implements LineMarkerProvider {
         }
     }
 
-    @NotNull
-    static BindingTrace createDelegatingTrace(@NotNull Project project) {
-        KotlinDeclarationsCache declarationsCache = KotlinCacheManager.getInstance(project).getDeclarationsFromProject(TargetPlatform.JVM);
-        BindingContext bindingContext = declarationsCache.getBindingContext();
-        return new DelegatingBindingTrace(bindingContext, "wrapped context of declarations cache");
-    }
-
     @Nullable
     private static DeclarationDescriptor getDescriptorForMember(
             @NotNull JavaDescriptorResolver javaDescriptorResolver,
             @NotNull PsiMember member,
-            @NotNull BindingTrace trace
+            @NotNull BindingContext bindingContext
     ) {
         PsiClass containingClass = member.getContainingClass();
         if (containingClass == null) { // e.g., type parameter
@@ -153,7 +143,7 @@ public class KotlinSignatureInJavaMarkerProvider implements LineMarkerProvider {
         if (memberScope == null) {
             return null;
         }
-        return getDescriptorForMember(member, memberScope, trace);
+        return getDescriptorForMember(member, memberScope, bindingContext);
     }
 
     @Nullable
@@ -184,7 +174,7 @@ public class KotlinSignatureInJavaMarkerProvider implements LineMarkerProvider {
     private static DeclarationDescriptor getDescriptorForMember(
             @NotNull PsiMember member,
             @NotNull JetScope memberScope,
-            @NotNull BindingTrace trace
+            @NotNull BindingContext bindingContext
     ) {
         if (!(member instanceof PsiMethod) && !(member instanceof PsiField)) {
             return null;
@@ -211,7 +201,7 @@ public class KotlinSignatureInJavaMarkerProvider implements LineMarkerProvider {
         }
 
         PsiModifierListOwner annotationOwner = KotlinSignatureUtil.getAnnotationOwner(member);
-        return trace.get(BindingContext.DECLARATION_TO_DESCRIPTOR, annotationOwner);
+        return bindingContext.get(BindingContext.DECLARATION_TO_DESCRIPTOR, annotationOwner);
     }
 
     public static boolean isMarkersEnabled(@NotNull Project project) {