Introduce BodyResolveCache for storing resolve function body task in IDE

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/di/injection.kt

@@ -25,6 +25,7 @@ import org.jetbrains.kotlin.load.java.JavaClassFinderImpl
 import org.jetbrains.kotlin.load.java.lazy.SingleModuleClassResolver
 import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider
 import org.jetbrains.kotlin.resolve.BindingTrace
+import org.jetbrains.kotlin.resolve.BodyResolveCache
 import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzerForTopLevel
 import org.jetbrains.kotlin.resolve.jvm.JavaClassFinderPostConstruct
 import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver
@@ -39,9 +40,9 @@ public fun createContainerForReplWithJava(
     configureModule(moduleContext, KotlinJvmCheckerProvider, bindingTrace)
     configureJavaTopDownAnalysis(moduleContentScope, moduleContext.project)
 
-
     useInstance(additionalFileScopeProvider)
     useInstance(declarationProviderFactory)
+    useInstance(BodyResolveCache.ThrowException)
 
     useImpl<ScopeProvider>()
     useImpl<SingleModuleClassResolver>()

compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt

@@ -33,6 +33,7 @@ import org.jetbrains.kotlin.load.kotlin.DeserializationComponentsForJava
 import org.jetbrains.kotlin.load.kotlin.JvmVirtualFileFinderFactory
 import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider
 import org.jetbrains.kotlin.resolve.BindingTrace
+import org.jetbrains.kotlin.resolve.BodyResolveCache
 import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzer
 import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzerForTopLevel
 import org.jetbrains.kotlin.resolve.jvm.JavaClassFinderPostConstruct
@@ -76,6 +77,7 @@ public fun createContainerForLazyResolveWithJava(
     useInstance(moduleClassResolver)
 
     useInstance(declarationProviderFactory)
+    useInstance(BodyResolveCache.ThrowException)
     useImpl<ScopeProvider>()
     useImpl<LazyResolveToken>()
 }.let {
@@ -93,6 +95,7 @@ public fun createContainerForTopDownAnalyzerForJvm(
     configureModule(moduleContext, KotlinJvmCheckerProvider, bindingTrace)
     configureJavaTopDownAnalysis(moduleContentScope, moduleContext.project)
     useInstance(declarationProviderFactory)
+    useInstance(BodyResolveCache.ThrowException)
 
     useImpl<SingleModuleClassResolver>()
     useImpl<ScopeProvider>()

compiler/frontend/src/org/jetbrains/kotlin/frontend/di/injection.kt

@@ -53,24 +53,29 @@ public fun StorageComponentContainer.configureModule(
 
 public fun createContainerForBodyResolve(
         moduleContext: ModuleContext, bindingTrace: BindingTrace,
-        additionalCheckerProvider: AdditionalCheckerProvider, statementFilter: StatementFilter
+        additionalCheckerProvider: AdditionalCheckerProvider, statementFilter: StatementFilter,
+        dynamicTypesSettings: DynamicTypesSettings
 ): StorageComponentContainer = createContainer("BodyResolve") {
     configureModule(moduleContext, additionalCheckerProvider, bindingTrace)
 
     useInstance(statementFilter)
+    useInstance(dynamicTypesSettings)
+    useInstance(BodyResolveCache.ThrowException)
     useImpl<BodyResolver>()
 }
 
 public fun createContainerForLazyBodyResolve(
         moduleContext: ModuleContext, kotlinCodeAnalyzer: KotlinCodeAnalyzer,
         bindingTrace: BindingTrace, additionalCheckerProvider: AdditionalCheckerProvider,
-        dynamicTypesSettings: DynamicTypesSettings
+        dynamicTypesSettings: DynamicTypesSettings,
+        bodyResolveCache: BodyResolveCache
 ): StorageComponentContainer = createContainer("LazyBodyResolve") {
     configureModule(moduleContext, additionalCheckerProvider, bindingTrace)
 
     useInstance(kotlinCodeAnalyzer)
     useInstance(kotlinCodeAnalyzer.getScopeProvider())
     useInstance(dynamicTypesSettings)
+    useInstance(bodyResolveCache)
     useImpl<LazyTopDownAnalyzerForTopLevel>()
 }
 
@@ -90,6 +95,7 @@ public fun createContainerForLazyLocalClassifierAnalyzer(
 
     useInstance(NoTopLevelDescriptorProvider)
     useInstance(NoFileScopeProvider)
+    useInstance(BodyResolveCache.ThrowException)
 
     useImpl<DeclarationScopeProviderForLocalClassifierAnalyzer>()
     useImpl<LocalLazyDeclarationResolver>()

compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolveCache.kt

@@ -0,0 +1,30 @@
+/*
+ * Copyright 2010-2015 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.kotlin.resolve
+
+import org.jetbrains.kotlin.psi.JetNamedFunction
+
+public interface BodyResolveCache {
+    public open fun resolveFunctionBody(function: JetNamedFunction): BindingContext
+
+    public object ThrowException : BodyResolveCache {
+        public override fun resolveFunctionBody(function: JetNamedFunction): BindingContext {
+            throw UnsupportedOperationException()
+        }
+    }
+}
+

compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java

@@ -26,6 +26,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.lexer.JetTokens;
 import org.jetbrains.kotlin.psi.*;
+import org.jetbrains.kotlin.psi.psiUtil.PsiUtilPackage;
 import org.jetbrains.kotlin.resolve.calls.CallResolver;
 import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
@@ -65,6 +66,7 @@ public class BodyResolver {
     private FunctionAnalyzerExtension functionAnalyzerExtension;
     private AdditionalCheckerProvider additionalCheckerProvider;
     private ValueParameterResolver valueParameterResolver;
+    private BodyResolveCache bodyResolveCache;
 
     //<editor-fold desc="Injector Setters">
     @Inject
@@ -121,6 +123,11 @@ public class BodyResolver {
     public void setValueParameterResolver(ValueParameterResolver valueParameterResolver) {
         this.valueParameterResolver = valueParameterResolver;
     }
+
+    @Inject
+    public void setBodyResolveCache(BodyResolveCache bodyResolveCache) {
+        this.bodyResolveCache = bodyResolveCache;
+    }
     //</editor-fold>
 
     private void resolveBehaviorDeclarationBodies(@NotNull BodiesResolveContext c) {
@@ -745,16 +752,17 @@ public class BodyResolver {
     private void resolveFunctionBodies(@NotNull BodiesResolveContext c) {
         for (Map.Entry<JetNamedFunction, SimpleFunctionDescriptor> entry : c.getFunctions().entrySet()) {
             JetNamedFunction declaration = entry.getKey();
-            SimpleFunctionDescriptor descriptor = entry.getValue();
 
-            computeDeferredType(descriptor.getReturnType());
+            JetScope scope = c.getDeclaringScope(declaration);
+            assert scope != null : "Scope is null: " + PsiUtilPackage.getElementTextWithContext(declaration);
 
-            JetScope declaringScope = c.getDeclaringScope(declaration);
-            assert declaringScope != null;
-
-            resolveFunctionBody(c.getOuterDataFlowInfo(), trace, declaration, descriptor, declaringScope);
-
-            assert descriptor.getReturnType() != null;
+            if (!c.getTopDownAnalysisMode().getIsLocalDeclarations() && !(bodyResolveCache instanceof BodyResolveCache.ThrowException) &&
+                expressionTypingServices.getStatementFilter() != StatementFilter.NONE) {
+                bodyResolveCache.resolveFunctionBody(declaration).addOwnDataTo(trace, true);
+            }
+            else {
+                resolveFunctionBody(c.getOuterDataFlowInfo(), trace, declaration, entry.getValue(), scope);
+            }
         }
     }
 
@@ -765,7 +773,11 @@ public class BodyResolver {
             @NotNull FunctionDescriptor functionDescriptor,
             @NotNull JetScope declaringScope
     ) {
+        computeDeferredType(functionDescriptor.getReturnType());
+
         resolveFunctionBody(outerDataFlowInfo, trace, function, functionDescriptor, declaringScope, null, null);
+
+        assert functionDescriptor.getReturnType() != null;
     }
 
     public void resolveFunctionBody(

compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingServices.java

@@ -62,6 +62,10 @@ public class ExpressionTypingServices {
         this.expressionTypingFacade = ExpressionTypingVisitorDispatcher.create(components);
     }
 
+    public StatementFilter getStatementFilter() {
+        return statementFilter;
+    }
+
     @NotNull
     public JetType safeGetType(
             @NotNull JetScope scope,