JavaDescriptorResolver is cached by KotlinResolveCache

Accessible via JavaResolveExtension
2014-04-22 18:31:58 +04:00
parent ed79be6d2d
commit 1a92964250
7 changed files with 113 additions and 42 deletions
@@ -0,0 +1,33 @@
+/*
+ * Copyright 2010-2014 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.jet.lang.resolve.java.JavaDescriptorResolver
+import org.jetbrains.jet.analyzer.AnalyzerFacade
+import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM.JvmSetup
+import org.jetbrains.jet.plugin.project.TargetPlatform
+import com.intellij.openapi.project.Project
+
+object JavaResolveExtension : CacheExtension<JavaDescriptorResolver> {
+    override val platform: TargetPlatform = TargetPlatform.JVM
+
+    override fun getData(setup: AnalyzerFacade.Setup): JavaDescriptorResolver {
+        return (setup as JvmSetup).getJavaDescriptorResolver()
+    }
+
+    public fun get(project: Project): JavaDescriptorResolver = KotlinCacheService.getInstance(project)[this]
+}
@@ -48,12 +48,8 @@ import org.jetbrains.jet.plugin.project.TargetPlatform
 import org.jetbrains.jet.plugin.project.TargetPlatform.*
 import org.jetbrains.jet.plugin.project.ResolveSessionForBodies
 import org.jetbrains.jet.plugin.project.TargetPlatformDetector
-import com.google.common.collect.ImmutableMap
-import org.jetbrains.jet.lang.resolve.Diagnostics
-import org.jetbrains.jet.util.slicedmap.ReadOnlySlice
-import org.jetbrains.jet.util.slicedmap.WritableSlice
-import org.jetbrains.jet.lang.diagnostics.Diagnostic
 import java.util.HashSet
+import org.jetbrains.jet.analyzer.AnalyzerFacade

 private val LOG = Logger.getInstance(javaClass<KotlinResolveCache>())

@@ -75,6 +71,12 @@ fun getAnalysisResultsForElements(elements: Collection<JetElement>): AnalyzeExha
    return KotlinCacheService.getInstance(element.getProject()).getAnalysisResults(elements)
 }

+private class SessionAndSetup(
+        val platform: TargetPlatform,
+        val resolveSessionForBodies: ResolveSessionForBodies,
+        val setup: AnalyzerFacade.Setup
+)
+
 class KotlinCacheService(val project: Project) {
    class object {
        fun getInstance(project: Project) = ServiceManager.getService(project, javaClass<KotlinCacheService>())!!
@@ -84,8 +86,17 @@ class KotlinCacheService(val project: Project) {
        val allFiles = JetFilesProvider.getInstance(project).allInScope(GlobalSearchScope.allScope(project))

        val files = if (syntheticFile == null) allFiles else collectFilesForSyntheticFile(allFiles, syntheticFile)
-        val resolveSession = AnalyzerFacadeProvider.getAnalyzerFacade(platform).createSetup(project, files).getLazyResolveSession()
-        CachedValueProvider.Result.create(ResolveSessionForBodies(project, resolveSession), PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT)
+        val setup = AnalyzerFacadeProvider.getAnalyzerFacade(platform).createSetup(project, files)
+        val resolveSessionForBodies = ResolveSessionForBodies(project, setup.getLazyResolveSession())
+        CachedValueProvider.Result.create(
+                SessionAndSetup(
+                        platform,
+                        resolveSessionForBodies,
+                        setup
+                ),
+                PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT,
+                resolveSessionForBodies
+        )
    }

    private fun collectFilesForSyntheticFile(allFiles: Collection<JetFile>, syntheticFile: JetFile): Collection<JetFile> {
@@ -160,16 +171,32 @@ class KotlinCacheService(val project: Project) {
        val project = jetFile.getProject()
        return JetFilesProvider.getInstance(project).isFileInScope(jetFile, GlobalSearchScope.allScope(project))
    }
+
+    public fun <T> get(extension: CacheExtension<T>): T {
+        return globalCachesPerPlatform[extension.platform]!![extension]
+    }
+}
+
+trait CacheExtension<T> {
+    val platform: TargetPlatform
+    fun getData(setup: AnalyzerFacade.Setup): T
 }

 private class KotlinResolveCache(
        val project: Project,
-        val resolveSessionProvider: () -> CachedValueProvider.Result<ResolveSessionForBodies>
+        val resolveSessionProvider: () -> CachedValueProvider.Result<SessionAndSetup>
 ) {

-    private val resolveSessionCache = SynchronizedCachedValue(project, resolveSessionProvider)
+    private val setupCache = SynchronizedCachedValue(project, resolveSessionProvider, trackValue = false)

-    public fun getLazyResolveSession(): ResolveSessionForBodies = resolveSessionCache.getValue()
+    public fun getLazyResolveSession(): ResolveSessionForBodies = setupCache.getValue().resolveSessionForBodies
+
+    public fun <T> get(extension: CacheExtension<T>): T {
+        val sessionAndSetup = setupCache.getValue()
+        assert(extension.platform == sessionAndSetup.platform,
+               "Extension $extension declares platfrom ${extension.platform} which is incompatible with ${sessionAndSetup.platform}")
+        return extension.getData(sessionAndSetup.setup)
+    }

    private data class Task(
            val elements: Set<JetElement>
@@ -33,8 +33,6 @@ import com.intellij.util.IncorrectOperationException;
 import com.intellij.util.messages.MessageBusConnection;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver;
-import org.jetbrains.jet.di.InjectorForJavaDescriptorResolverUtil;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingTraceContext;
@@ -44,6 +42,7 @@ import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.plugin.JetBundle;
 import org.jetbrains.jet.plugin.JetIcons;
+import org.jetbrains.jet.plugin.caches.resolve.JavaResolveExtension;
 import org.jetbrains.jet.renderer.DescriptorRenderer;
 import org.jetbrains.jet.renderer.DescriptorRendererBuilder;

@@ -164,8 +163,7 @@ public class KotlinSignatureAnnotationIntention extends BaseIntentionAction impl
    @NotNull
    private static String getDefaultSignature(@NotNull Project project, @NotNull PsiMember psiMember) {
        BindingTraceContext trace = new BindingTraceContext();
-        InjectorForJavaDescriptorResolver injector = InjectorForJavaDescriptorResolverUtil.create(project, trace);
-        JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver();
+        JavaDescriptorResolver javaDescriptorResolver = JavaResolveExtension.instance$.get(project);

        PsiClass containingClass = psiMember.getContainingClass();
        assert containingClass != null;
@@ -35,8 +35,6 @@ import com.intellij.util.Function;
 import com.intellij.util.ui.UIUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver;
-import org.jetbrains.jet.di.InjectorForJavaDescriptorResolverUtil;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor;
@@ -50,6 +48,7 @@ import org.jetbrains.jet.lang.resolve.name.FqName;
 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.KotlinDeclarationsCache;
 import org.jetbrains.jet.plugin.project.ProjectStructureUtil;
@@ -98,9 +97,8 @@ public class KotlinSignatureInJavaMarkerProvider implements LineMarkerProvider {
        }

        BindingTrace trace = createDelegatingTrace(project);
-        InjectorForJavaDescriptorResolver injector = InjectorForJavaDescriptorResolverUtil.create(project, trace);

-        JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver();
+        JavaDescriptorResolver javaDescriptorResolver = JavaResolveExtension.instance$.get(project);

        for (PsiElement element : elements) {
            if (!(element instanceof PsiMember)) {