Do not run partial body resolve if full body resolve already cached

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ResolveSession.java

@@ -139,9 +139,8 @@ public class ResolveSession implements KotlinCodeAnalyzer, LazyClassContext {
         this.module = rootDescriptor;
 
         this.packages =
-                storageManager.createMemoizedFunctionWithNullableValues(new MemoizedFunctionToNullable<FqName, LazyPackageDescriptor>() {
+                storageManager.createMemoizedFunctionWithNullableValues(new Function1<FqName, LazyPackageDescriptor>() {
                     @Nullable
-                    @Override
                     public LazyPackageDescriptor invoke(FqName fqName) {
                         return createPackage(fqName);
                     }

core/util.runtime/src/org/jetbrains/kotlin/storage/LockBasedStorageManager.java

@@ -411,6 +411,12 @@ public class LockBasedStorageManager implements StorageManager {
                 lock.unlock();
             }
         }
+
+        @Override
+        public boolean isComputed(K key) {
+            Object value = cache.get(key);
+            return value != null && value != NotValue.COMPUTING;
+        }
     }
 
     private class MapBasedMemoizedFunctionToNotNull<K, V> extends MapBasedMemoizedFunction<K, V> implements MemoizedFunctionToNotNull<K, V> {

core/util.runtime/src/org/jetbrains/kotlin/storage/storage.kt

@@ -16,8 +16,13 @@
 
 package org.jetbrains.kotlin.storage
 
-public trait MemoizedFunctionToNotNull<P, R : Any> : Function1<P, R>
-public trait MemoizedFunctionToNullable<P, R : Any> : Function1<P, R?>
+public trait MemoizedFunctionToNotNull<P, R : Any> : Function1<P, R> {
+    public fun isComputed(key: P): Boolean
+}
+
+public trait MemoizedFunctionToNullable<P, R : Any> : Function1<P, R?> {
+    public fun isComputed(key: P): Boolean
+}
 
 public trait NotNullLazyValue<T : Any> : Function0<T> {
     public fun isComputed(): Boolean

idea/ide-common/src/org/jetbrains/kotlin/resolve/lazy/ElementResolver.java

@@ -61,6 +61,10 @@ public abstract class ElementResolver {
         return elementAdditionalResolve(jetElement, jetElement, BodyResolveMode.FULL);
     }
 
+    public boolean hasElementAdditionalResolveCached(@NotNull JetElement jetElement) {
+        return false;
+    }
+
     @NotNull
     public BindingContext resolveToElement(@NotNull JetElement jetElement) {
         return resolveToElement(jetElement, BodyResolveMode.FULL);
@@ -95,8 +99,7 @@ public abstract class ElementResolver {
                 elementOfAdditionalResolve = jetElement;
             }
 
-            if (bodyResolveMode != BodyResolveMode.FULL) {
-                //TODO: do not resolve with filter if whole body resolve cached already
+            if (bodyResolveMode != BodyResolveMode.FULL && !hasElementAdditionalResolveCached(jetElement)) {
                 return elementAdditionalResolve(elementOfAdditionalResolve, jetElement, bodyResolveMode);
             }
 

idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/ResolveElementCache.java

@@ -76,6 +76,12 @@ public class ResolveElementCache extends ElementResolver {
         return additionalResolveCache.getValue().invoke(jetElement);
     }
 
+    @Override
+    public boolean hasElementAdditionalResolveCached(@NotNull JetElement jetElement) {
+        if (!additionalResolveCache.hasUpToDateValue()) return false;
+        return additionalResolveCache.getValue().isComputed(jetElement);
+    }
+
     @NotNull
     @Override
     public AdditionalCheckerProvider getAdditionalCheckerProvider(@NotNull JetFile jetFile) {