Convert JetCoreEnvironment: clean up code

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

@@ -26,9 +26,7 @@ import com.intellij.core.JavaCoreApplicationEnvironment
 import com.intellij.core.JavaCoreProjectEnvironment
 import com.intellij.lang.java.JavaParserDefinition
 import com.intellij.mock.MockApplication
-import com.intellij.mock.MockProject
 import com.intellij.openapi.Disposable
-import com.intellij.openapi.application.Application
 import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.components.ServiceManager
 import com.intellij.openapi.extensions.Extensions
@@ -39,7 +37,6 @@ import com.intellij.openapi.fileTypes.PlainTextFileType
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.util.Disposer
 import com.intellij.openapi.util.io.FileUtil
-import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.psi.FileContextProvider
 import com.intellij.psi.PsiElementFinder
 import com.intellij.psi.PsiManager
@@ -52,9 +49,6 @@ import com.intellij.psi.impl.compiled.ClsStubBuilderFactory
 import com.intellij.psi.impl.file.impl.JavaFileManager
 import com.intellij.psi.meta.MetaDataContributor
 import com.intellij.psi.stubs.BinaryFileStubBuilders
-import com.intellij.util.containers.ContainerUtil
-import kotlin.Function1
-import kotlin.Unit
 import org.jetbrains.annotations.TestOnly
 import org.jetbrains.kotlin.asJava.JavaElementFinder
 import org.jetbrains.kotlin.asJava.KotlinLightClassForPackage
@@ -62,7 +56,8 @@ import org.jetbrains.kotlin.asJava.LightClassGenerationSupport
 import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageLocation
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
-import org.jetbrains.kotlin.cli.common.messages.MessageCollector
+import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity.ERROR
+import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity.WARNING
 import org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys
 import org.jetbrains.kotlin.codegen.extensions.ExpressionCodegenExtension
 import org.jetbrains.kotlin.compiler.plugin.ComponentRegistrar
@@ -80,84 +75,77 @@ import org.jetbrains.kotlin.resolve.jvm.KotlinJavaPsiFacade
 import org.jetbrains.kotlin.resolve.lazy.declarations.CliDeclarationProviderFactoryService
 import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactoryService
 import org.jetbrains.kotlin.utils.PathUtil
-
 import java.io.File
-import java.util.*
+import java.util.ArrayList
+import java.util.Comparator
+import kotlin.platform.platformStatic
 
-import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity.ERROR
+public class JetCoreEnvironment private(
-import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity.WARNING
+        parentDisposable: Disposable, 
+        applicationEnvironment: JavaCoreApplicationEnvironment, 
+        configuration: CompilerConfiguration
+) {
 
-SuppressWarnings("AssignmentToStaticFieldFromInstanceMethod")
+    private val projectEnvironment: JavaCoreProjectEnvironment = object : JavaCoreProjectEnvironment(parentDisposable, applicationEnvironment) {
-public class JetCoreEnvironment private(parentDisposable: Disposable, applicationEnvironment: JavaCoreApplicationEnvironment, configuration: CompilerConfiguration) {
+        override fun preregisterServices() {
-
+            registerProjectExtensionPoints(Extensions.getArea(getProject()))
-    private val projectEnvironment: JavaCoreProjectEnvironment
+        }
+    }
     private val sourceFiles = ArrayList<JetFile>()
     private val classPath = ClassPath()
 
     private val annotationsManager: CoreExternalAnnotationsManager
 
-    public val configuration: CompilerConfiguration
+    public val configuration: CompilerConfiguration = configuration.copy().let {
-
+        it.setReadOnly(true)
-    {
+        it
-        this.configuration = configuration.copy()
+    }
-        this.configuration.setReadOnly(true)
-
-        projectEnvironment = object : JavaCoreProjectEnvironment(parentDisposable, applicationEnvironment) {
-            override fun preregisterServices() {
-                registerProjectExtensionPoints(Extensions.getArea(getProject()))
-            }
-        }
 
+    init {
         val project = projectEnvironment.getProject()
-        annotationsManager = CoreExternalAnnotationsManager(project.getComponent<PsiManager>(javaClass<PsiManager>()))
+        annotationsManager = CoreExternalAnnotationsManager(project.getComponent(javaClass<PsiManager>()))
-        project.registerService<ExternalAnnotationsManager>(javaClass<ExternalAnnotationsManager>(), annotationsManager)
+        project.registerService(javaClass<ExternalAnnotationsManager>(), annotationsManager)
-        project.registerService<DeclarationProviderFactoryService>(javaClass<DeclarationProviderFactoryService>(), CliDeclarationProviderFactoryService(sourceFiles))
+        project.registerService(javaClass<DeclarationProviderFactoryService>(), CliDeclarationProviderFactoryService(sourceFiles))
 
         registerProjectServicesForCLI(projectEnvironment)
         registerProjectServices(projectEnvironment)
 
-        for (path in configuration.getList<File>(JVMConfigurationKeys.CLASSPATH_KEY)) {
+        for (path in configuration.getList(JVMConfigurationKeys.CLASSPATH_KEY)) {
             addToClasspath(path)
         }
-        for (path in configuration.getList<File>(JVMConfigurationKeys.ANNOTATIONS_PATH_KEY)) {
+        for (path in configuration.getList(JVMConfigurationKeys.ANNOTATIONS_PATH_KEY)) {
             addExternalAnnotationsRoot(path)
         }
-        sourceFiles.addAll(CompileEnvironmentUtil.getJetFiles(getProject(), getSourceRootsCheckingForDuplicates(), object : Function1<String, Unit> {
+        sourceFiles.addAll(CompileEnvironmentUtil.getJetFiles(project, getSourceRootsCheckingForDuplicates(), {
-            override fun invoke(s: String): Unit {
+            message ->
-                report(ERROR, s)
+            report(ERROR, message)
-                return Unit.`INSTANCE$`
-            }
         }))
-
+        sourceFiles.sortBy(object : Comparator<JetFile> {
-        ContainerUtil.sort<JetFile>(sourceFiles, object : Comparator<JetFile> {
             override fun compare(o1: JetFile, o2: JetFile): Int {
                 return o1.getVirtualFile().getPath().compareToIgnoreCase(o2.getVirtualFile().getPath())
             }
         })
 
-        JetScriptDefinitionProvider.getInstance(project).addScriptDefinitions(configuration.getList<JetScriptDefinition>(CommonConfigurationKeys.SCRIPT_DEFINITIONS_KEY))
+        JetScriptDefinitionProvider.getInstance(project).addScriptDefinitions(configuration.getList(CommonConfigurationKeys.SCRIPT_DEFINITIONS_KEY))
 
-        project.registerService<VirtualFileFinderFactory>(javaClass<VirtualFileFinderFactory>(), CliVirtualFileFinderFactory(classPath))
+        project.registerService(javaClass<VirtualFileFinderFactory>(), CliVirtualFileFinderFactory(classPath))
 
         ExternalDeclarationsProvider.registerExtensionPoint(project)
         ExpressionCodegenExtension.registerExtensionPoint(project)
 
-        for (registrar in configuration.getList<ComponentRegistrar>(ComponentRegistrar.PLUGIN_COMPONENT_REGISTRARS)) {
+        for (registrar in configuration.getList(ComponentRegistrar.PLUGIN_COMPONENT_REGISTRARS)) {
             registrar.registerProjectComponents(project, configuration)
         }
     }
 
-    private fun getMyApplicationEnvironment(): CoreApplicationEnvironment {
+    private val applicationEnvironment: CoreApplicationEnvironment
-        return projectEnvironment.getEnvironment()
+        get() = projectEnvironment.getEnvironment()
-    }
 
-    public fun getApplication(): MockApplication {
+    public val application: MockApplication
-        return getMyApplicationEnvironment().getApplication()
+        get() = applicationEnvironment.getApplication()
-    }
 
-    public fun getProject(): Project {
+    public val project: Project
-        return projectEnvironment.getProject()
+        get() = projectEnvironment.getProject()
-    }
 
     private fun addExternalAnnotationsRoot(path: File) {
         if (!path.exists()) {
@@ -169,18 +157,18 @@ public class JetCoreEnvironment private(parentDisposable: Disposable, applicatio
 
     private fun addToClasspath(path: File) {
         if (path.isFile()) {
-            val jarFile = getMyApplicationEnvironment().getJarFileSystem().findFileByPath(path + "!/")
+            val jarFile = applicationEnvironment.getJarFileSystem().findFileByPath("${path}!/")
             if (jarFile == null) {
-                report(WARNING, "Classpath entry points to a file that is not a JAR archive: " + path)
+                report(WARNING, "Classpath entry points to a file that is not a JAR archive: $path")
                 return
             }
             projectEnvironment.addJarToClassPath(path)
             classPath.add(jarFile)
         }
         else {
-            val root = getMyApplicationEnvironment().getLocalFileSystem().findFileByPath(path.getAbsolutePath())
+            val root = applicationEnvironment.getLocalFileSystem().findFileByPath(path.getAbsolutePath())
             if (root == null) {
-                report(WARNING, "Classpath entry points to a non-existent location: " + path)
+                report(WARNING, "Classpath entry points to a non-existent location: $path")
                 return
             }
             projectEnvironment.addSourcesToClasspath(root)
@@ -191,7 +179,7 @@ public class JetCoreEnvironment private(parentDisposable: Disposable, applicatio
     private fun getSourceRootsCheckingForDuplicates(): Collection<String> {
         val uniqueSourceRoots = Sets.newLinkedHashSet<String>()
 
-        for (sourceRoot in configuration.getList<String>(CommonConfigurationKeys.SOURCE_ROOTS_KEY)) {
+        for (sourceRoot in configuration.getList(CommonConfigurationKeys.SOURCE_ROOTS_KEY)) {
             if (!uniqueSourceRoots.add(sourceRoot)) {
                 report(WARNING, "Duplicate source root: " + sourceRoot)
             }
@@ -200,18 +188,12 @@ public class JetCoreEnvironment private(parentDisposable: Disposable, applicatio
         return uniqueSourceRoots
     }
 
-    public fun getSourceFiles(): List<JetFile> {
+    public fun getSourceFiles(): List<JetFile> = sourceFiles
-        return sourceFiles
-    }
 
     private fun report(severity: CompilerMessageSeverity, message: String) {
-        val messageCollector = configuration.get<MessageCollector>(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY)
+        val messageCollector = configuration.get(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY)
-        if (messageCollector != null) {
+                               ?: throw CompileEnvironmentException(message)
-            messageCollector.report(severity, message, CompilerMessageLocation.NO_LOCATION)
+        messageCollector.report(severity, message, CompilerMessageLocation.NO_LOCATION)
-        }
-        else {
-            throw CompileEnvironmentException(message)
-        }
     }
 
     companion object {
@@ -220,7 +202,9 @@ public class JetCoreEnvironment private(parentDisposable: Disposable, applicatio
         private var ourApplicationEnvironment: JavaCoreApplicationEnvironment? = null
         private var ourProjectCount = 0
 
-        public fun createForProduction(parentDisposable: Disposable, configuration: CompilerConfiguration, configFilePaths: List<String>): JetCoreEnvironment {
+        platformStatic public fun createForProduction(
+                parentDisposable: Disposable, configuration: CompilerConfiguration, configFilePaths: List<String>
+        ): JetCoreEnvironment {
             // JPS may run many instances of the compiler in parallel (there's an option for compiling independent modules in parallel in IntelliJ)
             // All projects share the same ApplicationEnvironment, and when the last project is disposed, the ApplicationEnvironment is disposed as well
             Disposer.register(parentDisposable, object : Disposable {
@@ -240,15 +224,16 @@ public class JetCoreEnvironment private(parentDisposable: Disposable, applicatio
             return environment
         }
 
-        TestOnly
+        TestOnly platformStatic public fun createForTests(
-        public fun createForTests(parentDisposable: Disposable, configuration: CompilerConfiguration, extensionConfigs: List<String>): JetCoreEnvironment {
+                parentDisposable: Disposable, configuration: CompilerConfiguration, extensionConfigs: List<String>
+        ): JetCoreEnvironment {
             // Tests are supposed to create a single project and dispose it right after use
             return JetCoreEnvironment(parentDisposable, createApplicationEnvironment(parentDisposable, configuration, extensionConfigs), configuration)
         }
 
         private fun getOrCreateApplicationEnvironmentForProduction(configuration: CompilerConfiguration, configFilePaths: List<String>): JavaCoreApplicationEnvironment {
             synchronized (APPLICATION_LOCK) {
-                if (ourApplicationEnvironment != null) return ourApplicationEnvironment
+                if (ourApplicationEnvironment != null) return ourApplicationEnvironment!!
 
                 val parentDisposable = Disposer.newDisposable()
                 ourApplicationEnvironment = createApplicationEnvironment(parentDisposable, configuration, configFilePaths)
@@ -260,7 +245,7 @@ public class JetCoreEnvironment private(parentDisposable: Disposable, applicatio
                         }
                     }
                 })
-                return ourApplicationEnvironment
+                return ourApplicationEnvironment!!
             }
         }
 
@@ -269,7 +254,7 @@ public class JetCoreEnvironment private(parentDisposable: Disposable, applicatio
                 if (ourApplicationEnvironment == null) return
                 val environment = ourApplicationEnvironment
                 ourApplicationEnvironment = null
-                Disposer.dispose(environment.getParentDisposable())
+                Disposer.dispose(environment!!.getParentDisposable())
             }
         }
 
@@ -289,28 +274,29 @@ public class JetCoreEnvironment private(parentDisposable: Disposable, applicatio
         }
 
         private fun registerAppExtensionPoints() {
-            CoreApplicationEnvironment.registerExtensionPoint<ContentBasedFileSubstitutor>(Extensions.getRootArea(), ContentBasedFileSubstitutor.EP_NAME, javaClass<ContentBasedFileSubstitutor>())
+            CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), ContentBasedFileSubstitutor.EP_NAME, javaClass<ContentBasedFileSubstitutor>())
-            CoreApplicationEnvironment.registerExtensionPoint<FileTypeExtensionPoint<Any>>(Extensions.getRootArea(), BinaryFileStubBuilders.EP_NAME, javaClass<FileTypeExtensionPoint<Any>>())
+            CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), BinaryFileStubBuilders.EP_NAME, javaClass<FileTypeExtensionPoint<Any>>())
-            CoreApplicationEnvironment.registerExtensionPoint<FileContextProvider>(Extensions.getRootArea(), FileContextProvider.EP_NAME, javaClass<FileContextProvider>())
+            CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), FileContextProvider.EP_NAME, javaClass<FileContextProvider>())
             //
-            CoreApplicationEnvironment.registerExtensionPoint<MetaDataContributor>(Extensions.getRootArea(), MetaDataContributor.EP_NAME, javaClass<MetaDataContributor>())
+            CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), MetaDataContributor.EP_NAME, javaClass<MetaDataContributor>())
-            CoreApplicationEnvironment.registerExtensionPoint<ClsStubBuilderFactory>(Extensions.getRootArea(), ClsStubBuilderFactory.EP_NAME, javaClass<ClsStubBuilderFactory<PsiFile>>())
+            CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), ClsStubBuilderFactory.EP_NAME, javaClass<ClsStubBuilderFactory<*>>())
-            CoreApplicationEnvironment.registerExtensionPoint<PsiAugmentProvider>(Extensions.getRootArea(), PsiAugmentProvider.EP_NAME, javaClass<PsiAugmentProvider>())
+            CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), PsiAugmentProvider.EP_NAME, javaClass<PsiAugmentProvider>())
-            CoreApplicationEnvironment.registerExtensionPoint<JavaMainMethodProvider>(Extensions.getRootArea(), JavaMainMethodProvider.EP_NAME, javaClass<JavaMainMethodProvider>())
+            CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), JavaMainMethodProvider.EP_NAME, javaClass<JavaMainMethodProvider>())
             //
-            CoreApplicationEnvironment.registerExtensionPoint<ContainerProvider>(Extensions.getRootArea(), ContainerProvider.EP_NAME, javaClass<ContainerProvider>())
+            CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), ContainerProvider.EP_NAME, javaClass<ContainerProvider>())
-            CoreApplicationEnvironment.registerExtensionPoint<ClsCustomNavigationPolicy>(Extensions.getRootArea(), ClsCustomNavigationPolicy.EP_NAME, javaClass<ClsCustomNavigationPolicy>())
+            CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), ClsCustomNavigationPolicy.EP_NAME, javaClass<ClsCustomNavigationPolicy>())
-            CoreApplicationEnvironment.registerExtensionPoint<Decompiler>(Extensions.getRootArea(), ClassFileDecompilers.EP_NAME, javaClass<ClassFileDecompilers.Decompiler>())
+            CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), ClassFileDecompilers.EP_NAME, javaClass<ClassFileDecompilers.Decompiler>())
         }
 
         private fun registerApplicationExtensionPointsAndExtensionsFrom(configuration: CompilerConfiguration, configFilePath: String) {
-            val locator = configuration.get<CompilerJarLocator>(JVMConfigurationKeys.COMPILER_JAR_LOCATOR)
+            val locator = configuration.get(JVMConfigurationKeys.COMPILER_JAR_LOCATOR)
             var pluginRoot = if (locator == null) PathUtil.getPathUtilJar() else locator.getCompilerJar()
 
             val app = ApplicationManager.getApplication()
             val parentFile = pluginRoot.getParentFile()
 
-            if (pluginRoot.isDirectory() && app != null && app.isUnitTestMode() && FileUtil.toCanonicalPath(parentFile.getPath()).endsWith("out/production")) {
+            if (pluginRoot.isDirectory() && app != null && app.isUnitTestMode()
+                && FileUtil.toCanonicalPath(parentFile.getPath()).endsWith("out/production")) {
                 // hack for load extensions when compiler run directly from out directory(e.g. in tests)
                 val srcDir = parentFile.getParentFile().getParentFile()
                 pluginRoot = File(srcDir, "idea/src")
@@ -326,42 +312,42 @@ public class JetCoreEnvironment private(parentDisposable: Disposable, applicatio
         }
 
         // made public for Upsource
-        public fun registerApplicationServices(applicationEnvironment: JavaCoreApplicationEnvironment) {
+        platformStatic public fun registerApplicationServices(applicationEnvironment: JavaCoreApplicationEnvironment) {
-            applicationEnvironment.registerFileType(JetFileType.INSTANCE, "kt")
+            with(applicationEnvironment) {
-            applicationEnvironment.registerFileType(JetFileType.INSTANCE, "ktm")
+                registerFileType(JetFileType.INSTANCE, "kt")
-            applicationEnvironment.registerFileType(JetFileType.INSTANCE, JetParserDefinition.STD_SCRIPT_SUFFIX) // should be renamed to kts
+                registerFileType(JetFileType.INSTANCE, "ktm")
-            applicationEnvironment.registerParserDefinition(JetParserDefinition())
+                registerFileType(JetFileType.INSTANCE, JetParserDefinition.STD_SCRIPT_SUFFIX)
-
+                registerParserDefinition(JetParserDefinition())
-            applicationEnvironment.getApplication().registerService<KotlinBinaryClassCache>(javaClass<KotlinBinaryClassCache>(), KotlinBinaryClassCache())
+                getApplication().registerService(javaClass<KotlinBinaryClassCache>(), KotlinBinaryClassCache())
+            }
         }
 
         private fun registerProjectExtensionPoints(area: ExtensionsArea) {
-            CoreApplicationEnvironment.registerExtensionPoint<PsiTreeChangePreprocessor>(area, PsiTreeChangePreprocessor.EP_NAME, javaClass<PsiTreeChangePreprocessor>())
+            CoreApplicationEnvironment.registerExtensionPoint(area, PsiTreeChangePreprocessor.EP_NAME, javaClass<PsiTreeChangePreprocessor>())
-            CoreApplicationEnvironment.registerExtensionPoint<PsiElementFinder>(area, PsiElementFinder.EP_NAME, javaClass<PsiElementFinder>())
+            CoreApplicationEnvironment.registerExtensionPoint(area, PsiElementFinder.EP_NAME, javaClass<PsiElementFinder>())
         }
 
         // made public for Upsource
-        public fun registerProjectServices(projectEnvironment: JavaCoreProjectEnvironment) {
+        platformStatic public fun registerProjectServices(projectEnvironment: JavaCoreProjectEnvironment) {
-            val project = projectEnvironment.getProject()
+            with (projectEnvironment.getProject()) {
-            project.registerService<JetScriptDefinitionProvider>(javaClass<JetScriptDefinitionProvider>(), JetScriptDefinitionProvider())
+                registerService(javaClass<JetScriptDefinitionProvider>(), JetScriptDefinitionProvider())
-
+                registerService(javaClass<KotlinJavaPsiFacade>(), KotlinJavaPsiFacade(this))
-            project.registerService<KotlinJavaPsiFacade>(javaClass<KotlinJavaPsiFacade>(), KotlinJavaPsiFacade(project))
+                registerService(javaClass<KotlinLightClassForPackage.FileStubCache>(), KotlinLightClassForPackage.FileStubCache(this))
-            project.registerService<KotlinLightClassForPackage.FileStubCache>(javaClass<KotlinLightClassForPackage.FileStubCache>(), KotlinLightClassForPackage.FileStubCache(project))
+            }
         }
 
         private fun registerProjectServicesForCLI(projectEnvironment: JavaCoreProjectEnvironment) {
-            val project = projectEnvironment.getProject()
+            with (projectEnvironment.getProject()) {
-            project.registerService<CoreJavaFileManager>(javaClass<CoreJavaFileManager>(), ServiceManager.getService<JavaFileManager>(project, javaClass<JavaFileManager>()) as CoreJavaFileManager)
+                registerService(javaClass<CoreJavaFileManager>(), ServiceManager.getService(this, javaClass<JavaFileManager>()) as CoreJavaFileManager)
-            val cliLightClassGenerationSupport = CliLightClassGenerationSupport(project)
+                val cliLightClassGenerationSupport = CliLightClassGenerationSupport(this)
-            project.registerService<LightClassGenerationSupport>(javaClass<LightClassGenerationSupport>(), cliLightClassGenerationSupport)
+                registerService(javaClass<LightClassGenerationSupport>(), cliLightClassGenerationSupport)
-            project.registerService<CliLightClassGenerationSupport>(javaClass<CliLightClassGenerationSupport>(), cliLightClassGenerationSupport)
+                registerService(javaClass<CliLightClassGenerationSupport>(), cliLightClassGenerationSupport)
-            project.registerService<CodeAnalyzerInitializer>(javaClass<CodeAnalyzerInitializer>(), cliLightClassGenerationSupport)
+                registerService(javaClass<CodeAnalyzerInitializer>(), cliLightClassGenerationSupport)
 
-            val area = Extensions.getArea(project)
+                val area = Extensions.getArea(this)
-
+                area.getExtensionPoint(PsiElementFinder.EP_NAME).registerExtension(PsiElementFinderImpl(this, ServiceManager.getService(this, javaClass<JavaFileManager>())))
-            area.getExtensionPoint<PsiElementFinder>(PsiElementFinder.EP_NAME).registerExtension(PsiElementFinderImpl(project, ServiceManager.getService<JavaFileManager>(project, javaClass<JavaFileManager>())))
+                area.getExtensionPoint(PsiElementFinder.EP_NAME).registerExtension(JavaElementFinder(this, cliLightClassGenerationSupport))
-
+            }
-            area.getExtensionPoint<PsiElementFinder>(PsiElementFinder.EP_NAME).registerExtension(JavaElementFinder(project, cliLightClassGenerationSupport))
         }
     }
 }