Allow to avoid declaration body resolution for function and property initializers if the return type is explicitly specified. This significantly reduces the analysis time in kapt3.

compiler/backend/src/org/jetbrains/kotlin/codegen/ClassBuilderFactories.java

@@ -55,6 +55,14 @@ public class ClassBuilderFactories {
             throw new IllegalStateException();
         }
     };
+
+    public static ClassBuilderFactory TEST_KAPT3 = new TestClassBuilderFactory(false) {
+        @NotNull
+        @Override
+        public ClassBuilderMode getClassBuilderMode() {
+            return ClassBuilderMode.KAPT3;
+        }
+    };
     
     public static ClassBuilderFactory TEST = new TestClassBuilderFactory(false);
 

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreEnvironment.kt

@@ -94,7 +94,7 @@ import org.jetbrains.kotlin.parsing.KotlinParserDefinition
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.CodeAnalyzerInitializer
 import org.jetbrains.kotlin.resolve.jvm.KotlinJavaPsiFacade
-import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisCompletedHandlerExtension
+import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisHandlerExtension
 import org.jetbrains.kotlin.resolve.jvm.extensions.PackageFragmentProviderExtension
 import org.jetbrains.kotlin.resolve.lazy.declarations.CliDeclarationProviderFactoryService
 import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactoryService
@@ -167,7 +167,7 @@ class KotlinCoreEnvironment private constructor(
 
         ExpressionCodegenExtension.registerExtensionPoint(project)
         ClassBuilderInterceptorExtension.registerExtensionPoint(project)
-        AnalysisCompletedHandlerExtension.registerExtensionPoint(project)
+        AnalysisHandlerExtension.registerExtensionPoint(project)
         PackageFragmentProviderExtension.registerExtensionPoint(project)
         StorageComponentContainerContributor.registerExtensionPoint(project)
 

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/TopDownAnalyzerFacadeForJVM.kt

@@ -30,6 +30,7 @@ import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
 import org.jetbrains.kotlin.container.ComponentProvider
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.context.ContextForNewModule
+import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.context.MutableModuleContext
 import org.jetbrains.kotlin.context.ProjectContext
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
@@ -55,7 +56,7 @@ import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.BindingTrace
 import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzer
 import org.jetbrains.kotlin.resolve.TopDownAnalysisMode
-import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisCompletedHandlerExtension
+import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisHandlerExtension
 import org.jetbrains.kotlin.resolve.jvm.extensions.PackageFragmentProviderExtension
 import org.jetbrains.kotlin.resolve.lazy.KotlinCodeAnalyzer
 import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
@@ -79,13 +80,31 @@ object TopDownAnalyzerFacadeForJVM {
                 project, files, trace, configuration, packagePartProvider, declarationProviderFactory, sourceModuleSearchScope
         )
 
+        val module = container.get<ModuleDescriptor>()
+        val moduleContext = container.get<ModuleContext>()
+
+        val analysisHandlerExtensions = AnalysisHandlerExtension.getInstances(project)
+
+        fun invokeExtensionsOnAnalysisComplete(): AnalysisResult? {
+            for (extension in analysisHandlerExtensions) {
+                val result = extension.analysisCompleted(project, module, trace, files)
+                if (result != null) return result
+            }
+
+            return null
+        }
+
+        for (extension in analysisHandlerExtensions) {
+            val result = extension.doAnalysis(project, module, moduleContext, files, trace, container)
+            if (result != null) {
+                invokeExtensionsOnAnalysisComplete()?.let { return it }
+                return result
+            }
+        }
+
         container.get<LazyTopDownAnalyzer>().analyzeDeclarations(TopDownAnalysisMode.TopLevelDeclarations, files)
 
-        val module = container.get<ModuleDescriptor>()
+        invokeExtensionsOnAnalysisComplete()?.let { return it }
-        for (extension in AnalysisCompletedHandlerExtension.getInstances(project)) {
-            val result = extension.analysisCompleted(project, module, trace, files)
-            if (result != null) return result
-        }
 
         return AnalysisResult.success(trace.bindingContext, module)
     }

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/extensions/AnalysisHandlerExtension.kt

@@ -18,20 +18,32 @@ package org.jetbrains.kotlin.resolve.jvm.extensions
 
 import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.analyzer.AnalysisResult
+import org.jetbrains.kotlin.container.ComponentProvider
+import org.jetbrains.kotlin.context.ProjectContext
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.extensions.ProjectExtensionDescriptor
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.BindingTrace
 
-interface AnalysisCompletedHandlerExtension {
+interface AnalysisHandlerExtension {
-    companion object : ProjectExtensionDescriptor<AnalysisCompletedHandlerExtension>(
+    companion object : ProjectExtensionDescriptor<AnalysisHandlerExtension>(
             "org.jetbrains.kotlin.analyzeCompleteHandlerExtension",
-            AnalysisCompletedHandlerExtension::class.java
+            AnalysisHandlerExtension::class.java
     )
 
+    fun doAnalysis(
+            project: Project,
+            module: ModuleDescriptor,
+            projectContext: ProjectContext,
+            files: Collection<KtFile>,
+            bindingTrace: BindingTrace,
+            componentProvider: ComponentProvider
+    ): AnalysisResult? = null
+
     fun analysisCompleted(
             project: Project,
             module: ModuleDescriptor,
             bindingTrace: BindingTrace,
-            files: Collection<KtFile>): AnalysisResult?
+            files: Collection<KtFile>
+    ): AnalysisResult? = null
 }

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/extensions/PartialAnalysisHandlerExtension.kt

@@ -0,0 +1,131 @@
+/*
+ * Copyright 2010-2016 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.jvm.extensions
+
+import com.intellij.openapi.project.Project
+import org.jetbrains.kotlin.analyzer.AnalysisResult
+import org.jetbrains.kotlin.container.ComponentProvider
+import org.jetbrains.kotlin.container.get
+import org.jetbrains.kotlin.context.ProjectContext
+import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.resolve.*
+import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo
+import org.jetbrains.kotlin.resolve.lazy.DeclarationScopeProvider
+import org.jetbrains.kotlin.resolve.lazy.ForceResolveUtil
+import org.jetbrains.kotlin.resolve.lazy.ResolveSession
+import org.jetbrains.kotlin.resolve.scopes.LexicalScope
+import org.jetbrains.kotlin.resolve.scopes.utils.memberScopeAsImportingScope
+
+open class PartialAnalysisHandlerExtension : AnalysisHandlerExtension {
+    protected open val analyzePartially: Boolean
+        get() = true
+
+    override fun doAnalysis(
+            project: Project,
+            module: ModuleDescriptor,
+            projectContext: ProjectContext,
+            files: Collection<KtFile>,
+            bindingTrace: BindingTrace,
+            componentProvider: ComponentProvider
+    ): AnalysisResult? {
+        if (!analyzePartially) {
+            return null
+        }
+
+        val resolveSession = componentProvider.get<ResolveSession>()
+        val bodyResolver = componentProvider.get<BodyResolver>()
+        val declarationScopeProvider = componentProvider.get<DeclarationScopeProvider>()
+
+        val topDownAnalysisContext = TopDownAnalysisContext(
+                TopDownAnalysisMode.TopLevelDeclarations, DataFlowInfo.EMPTY, declarationScopeProvider)
+
+        for (file in files) {
+            ForceResolveUtil.forceResolveAllContents(resolveSession.getFileAnnotations(file))
+        }
+
+        doForEachDeclaration(files) { declaration ->
+            val descriptor = resolveSession.resolveToDescriptor(declaration)
+
+            when (descriptor) {
+                is ClassDescriptor -> {
+                    ForceResolveUtil.forceResolveAllContents(descriptor)
+                    ForceResolveUtil.forceResolveAllContents(descriptor.typeConstructor.supertypes)
+
+                    if (declaration is KtClassOrObject && descriptor is ClassDescriptorWithResolutionScopes) {
+                        bodyResolver.resolveSuperTypeEntryList(DataFlowInfo.EMPTY,
+                                                               declaration,
+                                                               descriptor,
+                                                               descriptor.unsubstitutedPrimaryConstructor,
+                                                               descriptor.scopeForConstructorHeaderResolution,
+                                                               descriptor.scopeForMemberDeclarationResolution)
+                    }
+                }
+                is PropertyDescriptor -> {
+                    if (declaration is KtProperty) {
+                        /* TODO Now we analyse body with anonymous object initializers. Check if we can't avoid it
+                         * val a: Runnable = object : Runnable { ... } */
+                        bodyResolver.resolveProperty(topDownAnalysisContext, declaration, descriptor)
+                    }
+                    else if (declaration is KtParameter) { // Annotation parameter
+                        val ownerElement = declaration.ownerFunction
+                        val ownerDescriptor = bindingTrace[BindingContext.VALUE_PARAMETER, declaration]?.containingDeclaration
+                        val containingScope = ownerDescriptor?.containingScope
+
+                        if (ownerElement is KtPrimaryConstructor && ownerDescriptor is ConstructorDescriptor && containingScope != null) {
+                            bodyResolver.resolveConstructorParameterDefaultValues(
+                                    topDownAnalysisContext.outerDataFlowInfo, bindingTrace, ownerElement, ownerDescriptor, containingScope)
+                        }
+                    }
+                }
+            }
+        }
+
+        return AnalysisResult.Companion.success(bindingTrace.bindingContext, module, true)
+    }
+
+    private val DeclarationDescriptor.containingScope: LexicalScope?
+        get() {
+            val containingDescriptor = containingDeclaration ?: return null
+            return when (containingDescriptor) {
+                is ClassDescriptorWithResolutionScopes -> containingDescriptor.scopeForInitializerResolution
+                is PackageFragmentDescriptor -> LexicalScope.Empty(containingDescriptor.getMemberScope().memberScopeAsImportingScope(), this)
+                else -> null
+            }
+        }
+
+    private fun doForEachDeclaration(declaration: KtDeclaration, f: (KtDeclaration) -> Unit) {
+        if (declaration !is KtAnonymousInitializer) {
+            f(declaration)
+        }
+
+        if (declaration is KtClassOrObject) {
+            declaration.declarations.forEach { doForEachDeclaration(it, f) }
+        }
+
+        if (declaration is KtClass && declaration.isAnnotation()) {
+            declaration.getPrimaryConstructorParameters().forEach { doForEachDeclaration(it, f) }
+        }
+    }
+
+    private fun doForEachDeclaration(files: Collection<KtFile>, f: (KtDeclaration) -> Unit) {
+        for (file in files) {
+            file.declarations.forEach { doForEachDeclaration(it, f) }
+        }
+    }
+
+}

plugins/annotation-collector/src/org/jetbrains/kotlin/annotation/AnnotationCollectorPlugin.kt

@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.compiler.plugin.CommandLineProcessor
 import org.jetbrains.kotlin.compiler.plugin.ComponentRegistrar
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.CompilerConfigurationKey
-import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisCompletedHandlerExtension
+import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisHandlerExtension
 import java.io.File
 
 object AnnotationCollectorConfigurationKeys {
@@ -91,7 +91,7 @@ class AnnotationCollectorComponentRegistrar : ComponentRegistrar {
         val stubs = configuration.get(AnnotationCollectorConfigurationKeys.STUBS_PATH)
         val messageCollector = configuration.get(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, MessageCollector.NONE)
         if (stubs != null) {
-            AnalysisCompletedHandlerExtension.registerExtension(project, StubProducerExtension(File(stubs), messageCollector))
+            AnalysisHandlerExtension.registerExtension(project, StubProducerExtension(File(stubs), messageCollector))
         }
     }
 }

plugins/annotation-collector/src/org/jetbrains/kotlin/annotation/StubProducerExtension.kt

@@ -28,11 +28,11 @@ import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.BindingTrace
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin
-import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisCompletedHandlerExtension
+import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisHandlerExtension
 import org.jetbrains.org.objectweb.asm.ClassWriter
 import java.io.File
 
-class StubProducerExtension(val stubsOutputDir: File, val messageCollector: MessageCollector) : AnalysisCompletedHandlerExtension {
+class StubProducerExtension(val stubsOutputDir: File, val messageCollector: MessageCollector) : AnalysisHandlerExtension {
     override fun analysisCompleted(
             project: Project,
             module: ModuleDescriptor,

plugins/annotation-processing/src/org/jetbrains/kotlin/annotation/processing/AnnotationProcessingExtension.kt

@@ -39,7 +39,7 @@ import org.jetbrains.kotlin.java.model.elements.JeTypeElement
 import org.jetbrains.kotlin.load.java.JvmAbi
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.BindingTrace
-import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisCompletedHandlerExtension
+import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisHandlerExtension
 import java.io.File
 import java.io.IOException
 import java.io.PrintWriter
@@ -74,7 +74,7 @@ abstract class AbstractAnnotationProcessingExtension(
         val verboseOutput: Boolean,
         val incrementalDataFile: File? = null,
         val sourceRetentionAnnotationHandler: SourceRetentionAnnotationHandler? = null
-) : AnalysisCompletedHandlerExtension {
+) : AnalysisHandlerExtension {
     private companion object {
         val LINE_SEPARATOR = System.getProperty("line.separator") ?: "\n"
     }

plugins/annotation-processing/src/org/jetbrains/kotlin/annotation/processing/AnnotationProcessingPlugin.kt

@@ -32,7 +32,7 @@ import org.jetbrains.kotlin.config.CompilerConfigurationKey
 import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import org.jetbrains.kotlin.diagnostics.rendering.DefaultErrorMessages
 import org.jetbrains.kotlin.java.model.internal.JeElementRegistry
-import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisCompletedHandlerExtension
+import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisHandlerExtension
 import java.io.File
 
 import org.jetbrains.kotlin.annotation.processing.AnnotationProcessingConfigurationKeys.ANNOTATION_PROCESSOR_CLASSPATH
@@ -150,6 +150,6 @@ class AnnotationProcessingComponentRegistrar : ComponentRegistrar {
 
         project.registerService(JeElementRegistry::class.java, JeElementRegistry())
         
-        AnalysisCompletedHandlerExtension.registerExtension(project, annotationProcessingExtension)
+        AnalysisHandlerExtension.registerExtension(project, annotationProcessingExtension)
     }
 }

plugins/kapt3/src/org/jetbrains/kotlin/kapt3/Kapt3Extension.kt

@@ -32,7 +32,8 @@ import org.jetbrains.kotlin.kapt3.util.KaptLogger
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.BindingTrace
-import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisCompletedHandlerExtension
+import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisHandlerExtension
+import org.jetbrains.kotlin.resolve.jvm.extensions.PartialAnalysisHandlerExtension
 import java.io.File
 import java.net.URLClassLoader
 import java.util.*
@@ -49,7 +50,7 @@ class Kapt3Extension(
         val aptOnly: Boolean,
         val pluginInitializedTime: Long,
         val logger: KaptLogger
-) : AnalysisCompletedHandlerExtension {
+) : PartialAnalysisHandlerExtension() {
     private var annotationProcessingComplete = false
 
     private fun setAnnotationProcessingComplete(): Boolean {

plugins/kapt3/src/org/jetbrains/kotlin/kapt3/Kapt3Plugin.kt

@@ -32,7 +32,7 @@ import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import org.jetbrains.kotlin.diagnostics.rendering.DefaultErrorMessages
 import org.jetbrains.kotlin.kapt3.diagnostic.DefaultErrorMessagesKapt3
 import org.jetbrains.kotlin.kapt3.util.KaptLogger
-import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisCompletedHandlerExtension
+import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisHandlerExtension
 import java.io.File
 
 object Kapt3ConfigurationKeys {
@@ -155,6 +155,6 @@ class Kapt3ComponentRegistrar : ComponentRegistrar {
         val kapt3AnalysisCompletedHandlerExtension = Kapt3Extension(
                 classpath, javaSourceRoots, sourcesOutputDir, classFilesOutputDir, stubsOutputDir, apOptions,
                 isAptOnly, System.currentTimeMillis(), logger)
-        AnalysisCompletedHandlerExtension.registerExtension(project, kapt3AnalysisCompletedHandlerExtension)
+        AnalysisHandlerExtension.registerExtension(project, kapt3AnalysisCompletedHandlerExtension)
     }
 }

plugins/kapt3/test/org/jetbrains/kotlin/kapt3/test/AbstractKotlinKapt3Test.kt

@@ -19,12 +19,15 @@ package org.jetbrains.kotlin.kapt3.test
 import com.intellij.openapi.util.text.StringUtil
 import com.sun.tools.javac.comp.CompileStates
 import com.sun.tools.javac.tree.JCTree.JCCompilationUnit
+import com.sun.tools.javac.util.Log
 import org.jetbrains.kotlin.codegen.CodegenTestCase
 import org.jetbrains.kotlin.codegen.CodegenTestUtil
 import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper
 import org.jetbrains.kotlin.kapt3.*
 import org.jetbrains.kotlin.kapt3.stubs.ClassFileToSourceStubConverter
 import org.jetbrains.kotlin.kapt3.util.KaptLogger
+import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisHandlerExtension
+import org.jetbrains.kotlin.resolve.jvm.extensions.PartialAnalysisHandlerExtension
 import org.jetbrains.kotlin.test.ConfigurationKind
 import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.util.trimTrailingWhitespacesAndAddNewlineAtEOF
@@ -41,6 +44,10 @@ abstract class AbstractKotlinKapt3Test : CodegenTestCase() {
         val javaSources = javaFilesDir?.let { arrayOf(it) } ?: emptyArray()
 
         createEnvironmentWithMockJdkAndIdeaAnnotations(ConfigurationKind.ALL, *javaSources)
+
+        // Use light analysis mode in tests
+        AnalysisHandlerExtension.registerExtension(myEnvironment.project, PartialAnalysisHandlerExtension())
+
         loadMultiFiles(files)
 
         val txtFile = File(wholeFile.parentFile, wholeFile.nameWithoutExtension + ".txt")
@@ -77,6 +84,7 @@ abstract class AbstractClassFileToSourceStubConverterTest : AbstractKotlinKapt3T
         val actual = StringUtil.convertLineSeparators(actualRaw.trim({ it <= ' ' })).trimTrailingWhitespacesAndAddNewlineAtEOF()
 
         if (kaptRunner.compiler.shouldStop(CompileStates.CompileState.ENTER)) {
+            Log.instance(kaptRunner.context).flush()
             error("There were errors during analysis. See errors above. Stubs:\n\n$actual")
         }
         KotlinTestUtils.assertEqualsToFile(txtFile, actual)

plugins/plugins-tests/tests/org/jetbrains/kotlin/annotation/AbstractAnnotationProcessorBoxTest.kt

@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.codegen.CodegenTestFiles
 import org.jetbrains.kotlin.codegen.CodegenTestUtil
 import org.jetbrains.kotlin.codegen.extensions.ClassBuilderInterceptorExtension
 import org.jetbrains.kotlin.diagnostics.DiagnosticSink
-import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisCompletedHandlerExtension
+import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisHandlerExtension
 import org.jetbrains.kotlin.test.ConfigurationKind
 import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.KotlinTestWithEnvironment
@@ -63,7 +63,7 @@ abstract class AbstractAnnotationProcessorBoxTest : KotlinTestWithEnvironment()
         if (supportStubs) {
             val stubsDir = KotlinTestUtils.tmpDir("class-stubs")
             val stubProducerExtension = StubProducerExtension(stubsDir, MessageCollector.NONE)
-            AnalysisCompletedHandlerExtension.registerExtension(project, stubProducerExtension)
+            AnalysisHandlerExtension.registerExtension(project, stubProducerExtension)
         }
 
         val testFiles = ktFiles.map { KotlinTestUtils.createFile(it.name, KotlinTestUtils.doLoadFile(it), environment.project) }

plugins/plugins-tests/tests/org/jetbrains/kotlin/annotation/processing/test/processor/AbstractProcessorTest.kt

@@ -31,7 +31,7 @@ import org.jetbrains.kotlin.java.model.elements.JeMethodExecutableElement
 import org.jetbrains.kotlin.java.model.elements.JeTypeElement
 import org.jetbrains.kotlin.java.model.elements.JeVariableElement
 import org.jetbrains.kotlin.java.model.internal.JeElementRegistry
-import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisCompletedHandlerExtension
+import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisHandlerExtension
 import org.jetbrains.kotlin.test.ConfigurationKind
 import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.TestJdkKind
@@ -73,7 +73,7 @@ abstract class AbstractProcessorTest : AbstractBytecodeTextTest() {
         val project = environment.project
         
         val apExtension = AnnotationProcessingExtensionForTests(processors)
-        AnalysisCompletedHandlerExtension.registerExtension(project, apExtension)
+        AnalysisHandlerExtension.registerExtension(project, apExtension)
 
         project.registerServiceInstance(JeElementRegistry::class.java, JeElementRegistry())
 

plugins/plugins-tests/tests/org/jetbrains/kotlin/annotation/processing/test/processor/ProcessorTests.kt

@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.incremental.SourceRetentionAnnotationHandlerImpl
 import org.jetbrains.kotlin.java.model.elements.*
 import org.jetbrains.kotlin.java.model.types.JeDeclaredType
 import org.jetbrains.kotlin.java.model.types.JeMethodExecutableTypeMirror
-import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisCompletedHandlerExtension
+import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisHandlerExtension
 import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstance
 import javax.annotation.processing.ProcessingEnvironment
 import javax.lang.model.element.AnnotationMirror
@@ -243,7 +243,7 @@ class ProcessorTests : AbstractProcessorTest() {
             "KotlinAnnotations",
             "i AnnoAnnotated")
     
-    private fun getKapt2Extension() = AnalysisCompletedHandlerExtension.getInstances(myEnvironment.project)
+    private fun getKapt2Extension() = AnalysisHandlerExtension.getInstances(myEnvironment.project)
             .firstIsInstance<AnnotationProcessingExtensionForTests>()
     
     private fun incrementalDataTest(fileName: String, @Language("TEXT") expectedText: String) {

plugins/uast-kotlin/src/org/jetbrains/uast/kotlin/internal/CliKotlinUastBindingContextProviderService.kt

@@ -12,13 +12,13 @@ import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.BindingTrace
-import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisCompletedHandlerExtension
+import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisHandlerExtension
 import org.jetbrains.uast.kotlin.KotlinUastBindingContextProviderService
 
 class CliKotlinUastBindingContextProviderService : KotlinUastBindingContextProviderService {
-    val Project.analysisCompletedHandler: UastAnalysisCompletedHandlerExtension?
+    val Project.analysisCompletedHandler: UastAnalysisHandlerExtension?
-        get() = getExtensions(AnalysisCompletedHandlerExtension.extensionPointName)
+        get() = getExtensions(AnalysisHandlerExtension.extensionPointName)
-                .filterIsInstance<UastAnalysisCompletedHandlerExtension>()
+                .filterIsInstance<UastAnalysisHandlerExtension>()
                 .firstOrNull()
 
     override fun getBindingContext(element: KtElement): BindingContext {
@@ -30,7 +30,7 @@ class CliKotlinUastBindingContextProviderService : KotlinUastBindingContextProvi
     }
 }
 
-class UastAnalysisCompletedHandlerExtension : AnalysisCompletedHandlerExtension {
+class UastAnalysisHandlerExtension : AnalysisHandlerExtension {
     private var context: BindingContext? = null
     private var typeMapper: KotlinTypeMapper? = null