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.

2016-11-23 17:50:36 +03:00
parent 90cbf172d2
commit d884830700
16 changed files with 214 additions and 35 deletions
@@ -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);

@@ -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)

@@ -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>()
-        for (extension in AnalysisCompletedHandlerExtension.getInstances(project)) {
-            val result = extension.analysisCompleted(project, module, trace, files)
-            if (result != null) return result
-        }
+        invokeExtensionsOnAnalysisComplete()?.let { return it }

        return AnalysisResult.success(trace.bindingContext, module)
    }
@@ -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 {
-    companion object : ProjectExtensionDescriptor<AnalysisCompletedHandlerExtension>(
+interface AnalysisHandlerExtension {
+    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
 }
@@ -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) }
+        }
+    }
+
+}
@@ -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))
        }
    }
 }
@@ -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,
@@ -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"
    }
@@ -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)
    }
 }
@@ -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 {
@@ -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)
    }
 }
@@ -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)
@@ -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) }
@@ -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())

@@ -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) {
@@ -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?
-        get() = getExtensions(AnalysisCompletedHandlerExtension.extensionPointName)
-                .filterIsInstance<UastAnalysisCompletedHandlerExtension>()
+    val Project.analysisCompletedHandler: UastAnalysisHandlerExtension?
+        get() = getExtensions(AnalysisHandlerExtension.extensionPointName)
+                .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