From 51c01c15b8ab0652c8b71f42531aa2a0c9ab3d96 Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Fri, 15 Jun 2018 19:26:22 +0200 Subject: [PATCH] Refactor KotlinCoreEnvironment, fix warnings --- .../cli/jvm/compiler/KotlinCoreEnvironment.kt | 283 +++++++++--------- 1 file changed, 147 insertions(+), 136 deletions(-) diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreEnvironment.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreEnvironment.kt index a551c998d03..6dab0979e17 100644 --- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreEnvironment.kt +++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreEnvironment.kt @@ -115,41 +115,46 @@ import java.io.File import java.util.zip.ZipFile class KotlinCoreEnvironment private constructor( - parentDisposable: Disposable, - applicationEnvironment: JavaCoreApplicationEnvironment, - initialConfiguration: CompilerConfiguration, - configFiles: EnvironmentConfigFiles + parentDisposable: Disposable, + applicationEnvironment: JavaCoreApplicationEnvironment, + initialConfiguration: CompilerConfiguration, + configFiles: EnvironmentConfigFiles ) { - private val projectEnvironment: JavaCoreProjectEnvironment = object : KotlinCoreProjectEnvironment(parentDisposable, applicationEnvironment) { - override fun preregisterServices() { - registerProjectExtensionPoints(Extensions.getArea(project)) - } - - override fun registerJavaPsiFacade() { - with (project) { - registerService(CoreJavaFileManager::class.java, ServiceManager.getService(this, JavaFileManager::class.java) as CoreJavaFileManager) - - val traceHolder = CliTraceHolder() - val cliLightClassGenerationSupport = CliLightClassGenerationSupport(traceHolder) - val kotlinAsJavaSupport = CliKotlinAsJavaSupport(this, traceHolder) - registerService(LightClassGenerationSupport::class.java, cliLightClassGenerationSupport) - registerService(CliLightClassGenerationSupport::class.java, cliLightClassGenerationSupport) - registerService(KotlinAsJavaSupport::class.java, kotlinAsJavaSupport) - registerService(CodeAnalyzerInitializer::class.java, traceHolder) - - registerService(ExternalAnnotationsManager::class.java, MockExternalAnnotationsManager()) - registerService(InferredAnnotationsManager::class.java, MockInferredAnnotationsManager()) - - val area = Extensions.getArea(this) - - area.getExtensionPoint(PsiElementFinder.EP_NAME).registerExtension(JavaElementFinder(this, kotlinAsJavaSupport)) - area.getExtensionPoint(PsiElementFinder.EP_NAME).registerExtension( - PsiElementFinderImpl(this, ServiceManager.getService(this, JavaFileManager::class.java))) + private val projectEnvironment: JavaCoreProjectEnvironment = + object : KotlinCoreProjectEnvironment(parentDisposable, applicationEnvironment) { + override fun preregisterServices() { + registerProjectExtensionPoints(Extensions.getArea(project)) } - super.registerJavaPsiFacade() + override fun registerJavaPsiFacade() { + with(project) { + registerService( + CoreJavaFileManager::class.java, + ServiceManager.getService(this, JavaFileManager::class.java) as CoreJavaFileManager + ) + + val traceHolder = CliTraceHolder() + val cliLightClassGenerationSupport = CliLightClassGenerationSupport(traceHolder) + val kotlinAsJavaSupport = CliKotlinAsJavaSupport(this, traceHolder) + registerService(LightClassGenerationSupport::class.java, cliLightClassGenerationSupport) + registerService(CliLightClassGenerationSupport::class.java, cliLightClassGenerationSupport) + registerService(KotlinAsJavaSupport::class.java, kotlinAsJavaSupport) + registerService(CodeAnalyzerInitializer::class.java, traceHolder) + + registerService(ExternalAnnotationsManager::class.java, MockExternalAnnotationsManager()) + registerService(InferredAnnotationsManager::class.java, MockInferredAnnotationsManager()) + + val area = Extensions.getArea(this) + + area.getExtensionPoint(PsiElementFinder.EP_NAME).registerExtension(JavaElementFinder(this, kotlinAsJavaSupport)) + area.getExtensionPoint(PsiElementFinder.EP_NAME).registerExtension( + PsiElementFinderImpl(this, ServiceManager.getService(this, JavaFileManager::class.java)) + ) + } + + super.registerJavaPsiFacade() + } } - } private val sourceFiles = mutableListOf() private val rootsIndex: JvmDependenciesDynamicCompoundIndex @@ -162,8 +167,8 @@ class KotlinCoreEnvironment private constructor( init { PersistentFSConstants::class.java.getDeclaredField("ourMaxIntellisenseFileSize") - .apply { isAccessible = true } - .setInt(null, FileUtilRt.LARGE_FOR_CONTENT_LOADING) + .apply { isAccessible = true } + .setInt(null, FileUtilRt.LARGE_FOR_CONTENT_LOADING) val project = projectEnvironment.project @@ -182,41 +187,41 @@ class KotlinCoreEnvironment private constructor( try { registrar.registerProjectComponents(project, configuration) } catch (e: AbstractMethodError) { - throw IllegalStateException("The provided plugin ${registrar.javaClass.name} is not compatible with this version of compiler", e) + throw IllegalStateException( + "The provided plugin ${registrar.javaClass.name} is not compatible with this version of compiler", e + ) } } project.registerService(DeclarationProviderFactoryService::class.java, CliDeclarationProviderFactoryService(sourceFiles)) - project.registerService(ModuleVisibilityManager::class.java, CliModuleVisibilityManagerImpl(configFiles == EnvironmentConfigFiles.JVM_CONFIG_FILES)) + + val isJvm = configFiles == EnvironmentConfigFiles.JVM_CONFIG_FILES + project.registerService(ModuleVisibilityManager::class.java, CliModuleVisibilityManagerImpl(isJvm)) registerProjectServicesForCLI(projectEnvironment) val messageCollector = configuration.get(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY) registerProjectServices(projectEnvironment, messageCollector) - CompilerConfigurationExtension.getInstances(project).forEach { - it.updateConfiguration(configuration) + for (extension in CompilerConfigurationExtension.getInstances(project)) { + extension.updateConfiguration(configuration) } - sourceFiles += CompileEnvironmentUtil.getKtFiles(project, getSourceRootsCheckingForDuplicates(), this.configuration, { - message -> + sourceFiles += CompileEnvironmentUtil.getKtFiles(project, getSourceRootsCheckingForDuplicates(), this.configuration) { message -> report(ERROR, message) - }) + } sourceFiles.sortBy { it.virtualFile.path } val scriptDefinitionProvider = ScriptDefinitionProvider.getInstance(project) as? CliScriptDefinitionProvider if (scriptDefinitionProvider != null) { - scriptDefinitionProvider.setScriptDefinitionsSources( - configuration.getList(JVMConfigurationKeys.SCRIPT_DEFINITIONS_SOURCES) - ) - scriptDefinitionProvider.setScriptDefinitions( - configuration.getList(JVMConfigurationKeys.SCRIPT_DEFINITIONS)) + scriptDefinitionProvider.setScriptDefinitionsSources(configuration.getList(JVMConfigurationKeys.SCRIPT_DEFINITIONS_SOURCES)) + scriptDefinitionProvider.setScriptDefinitions(configuration.getList(JVMConfigurationKeys.SCRIPT_DEFINITIONS)) ScriptDependenciesProvider.getInstance(project).let { importsProvider -> configuration.addJvmClasspathRoots( - sourceFiles.mapNotNull(importsProvider::getScriptDependencies) - .flatMap { it.classpath } - .distinctBy { it.absolutePath }) + sourceFiles.mapNotNull(importsProvider::getScriptDependencies) + .flatMap { it.classpath } + .distinctBy { it.absolutePath }) } } @@ -227,17 +232,17 @@ class KotlinCoreEnvironment private constructor( }) val outputDirectory = - configuration.get(JVMConfigurationKeys.MODULES)?.singleOrNull()?.getOutputDirectory() - ?: configuration.get(JVMConfigurationKeys.OUTPUT_DIRECTORY)?.absolutePath + configuration.get(JVMConfigurationKeys.MODULES)?.singleOrNull()?.getOutputDirectory() + ?: configuration.get(JVMConfigurationKeys.OUTPUT_DIRECTORY)?.absolutePath classpathRootsResolver = ClasspathRootsResolver( - PsiManager.getInstance(project), - messageCollector, - configuration.getList(JVMConfigurationKeys.ADDITIONAL_JAVA_MODULES), - this::contentRootToVirtualFile, - javaModuleFinder, - !configuration.getBoolean(CLIConfigurationKeys.ALLOW_KOTLIN_PACKAGE), - outputDirectory?.let(this::findLocalFile) + PsiManager.getInstance(project), + messageCollector, + configuration.getList(JVMConfigurationKeys.ADDITIONAL_JAVA_MODULES), + this::contentRootToVirtualFile, + javaModuleFinder, + !configuration.getBoolean(CLIConfigurationKeys.ALLOW_KOTLIN_PACKAGE), + outputDirectory?.let(this::findLocalFile) ) val (initialRoots, javaModules) = @@ -246,9 +251,9 @@ class KotlinCoreEnvironment private constructor( if (!configuration.getBoolean(JVMConfigurationKeys.SKIP_RUNTIME_VERSION_CHECK) && messageCollector != null) { JvmRuntimeVersionsConsistencyChecker.checkCompilerClasspathConsistency( - messageCollector, - configuration, - initialRoots.mapNotNull { (file, type) -> if (type == JavaRoot.RootType.BINARY) file else null } + messageCollector, + configuration, + initialRoots.mapNotNull { (file, type) -> if (type == JavaRoot.RootType.BINARY) file else null } ) } @@ -262,15 +267,15 @@ class KotlinCoreEnvironment private constructor( } (ServiceManager.getService(project, CoreJavaFileManager::class.java) as KotlinCliJavaFileManagerImpl).initialize( - rootsIndex, - packagePartProviders, - SingleJavaFileRootsIndex(singleJavaFileRoots), - configuration.getBoolean(JVMConfigurationKeys.USE_FAST_CLASS_FILES_READING) + rootsIndex, + packagePartProviders, + SingleJavaFileRootsIndex(singleJavaFileRoots), + configuration.getBoolean(JVMConfigurationKeys.USE_FAST_CLASS_FILES_READING) ) project.registerService( - JavaModuleResolver::class.java, - CliJavaModuleResolver(classpathRootsResolver.javaModuleGraph, javaModules, javaModuleFinder.systemModules.toList()) + JavaModuleResolver::class.java, + CliJavaModuleResolver(classpathRootsResolver.javaModuleGraph, javaModules, javaModuleFinder.systemModules.toList()) ) val finderFactory = CliVirtualFileFinderFactory(rootsIndex) @@ -302,18 +307,21 @@ class KotlinCoreEnvironment private constructor( private val allJavaFiles: List get() = configuration.javaSourceRoots - .mapNotNull(this::findLocalFile) - .flatMap { it.javaFiles } - .map { File(it.canonicalPath) } + .mapNotNull(this::findLocalFile) + .flatMap { it.javaFiles } + .map { File(it.canonicalPath) } fun registerJavac( - javaFiles: List = allJavaFiles, - kotlinFiles: List = sourceFiles, - arguments: Array? = null, - bootClasspath: List? = null, - sourcePath: List? = null + javaFiles: List = allJavaFiles, + kotlinFiles: List = sourceFiles, + arguments: Array? = null, + bootClasspath: List? = null, + sourcePath: List? = null ): Boolean { - return JavacWrapperRegistrar.registerJavac(projectEnvironment.project, configuration, javaFiles, kotlinFiles, arguments, bootClasspath, sourcePath, LightClassGenerationSupport.getInstance(project)) + return JavacWrapperRegistrar.registerJavac( + projectEnvironment.project, configuration, javaFiles, kotlinFiles, arguments, bootClasspath, sourcePath, + LightClassGenerationSupport.getInstance(project) + ) } private val applicationEnvironment: CoreApplicationEnvironment @@ -322,11 +330,11 @@ class KotlinCoreEnvironment private constructor( val project: Project get() = projectEnvironment.project - internal fun countLinesOfCode(sourceFiles: List): Int = - sourceFiles.sumBy { sourceFile -> - val text = sourceFile.text - StringUtil.getLineBreakCount(text) + (if (StringUtil.endsWithLineBreak(text)) 0 else 1) - } + internal fun countLinesOfCode(sourceFiles: List): Int = + sourceFiles.sumBy { sourceFile -> + val text = sourceFile.text + StringUtil.getLineBreakCount(text) + (if (StringUtil.endsWithLineBreak(text)) 0 else 1) + } private fun updateClasspathFromRootsIndex(index: JvmDependenciesIndex) { index.indexedRoots.forEach { @@ -363,7 +371,7 @@ class KotlinCoreEnvironment private constructor( } internal fun findLocalFile(path: String): VirtualFile? = - applicationEnvironment.localFileSystem.findFileByPath(path) + applicationEnvironment.localFileSystem.findFileByPath(path) private fun findExistingRoot(root: JvmContentRoot, rootDescription: String): VirtualFile? { return findLocalFile(root.file.absolutePath).also { @@ -374,7 +382,7 @@ class KotlinCoreEnvironment private constructor( } private fun findJarRoot(file: File): VirtualFile? = - applicationEnvironment.jarFileSystem.findFileByPath("$file${URLUtil.JAR_SEPARATOR}") + applicationEnvironment.jarFileSystem.findFileByPath("$file${URLUtil.JAR_SEPARATOR}") private fun getSourceRootsCheckingForDuplicates(): Collection { val uniqueSourceRoots = linkedSetOf() @@ -405,7 +413,7 @@ class KotlinCoreEnvironment private constructor( @JvmStatic fun createForProduction( - parentDisposable: Disposable, configuration: CompilerConfiguration, configFiles: EnvironmentConfigFiles + parentDisposable: Disposable, configuration: CompilerConfiguration, configFiles: EnvironmentConfigFiles ): KotlinCoreEnvironment { setCompatibleBuild() // If not disabled explicitly, we should always support at least the standard script definition @@ -421,7 +429,7 @@ class KotlinCoreEnvironment private constructor( // 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, Disposable { - synchronized (APPLICATION_LOCK) { + synchronized(APPLICATION_LOCK) { if (--ourProjectCount <= 0) { disposeApplicationEnvironment() } @@ -430,7 +438,7 @@ class KotlinCoreEnvironment private constructor( } val environment = KotlinCoreEnvironment(parentDisposable, appEnv, configuration, configFiles) - synchronized (APPLICATION_LOCK) { + synchronized(APPLICATION_LOCK) { ourProjectCount++ } return environment @@ -447,7 +455,7 @@ class KotlinCoreEnvironment private constructor( @TestOnly @JvmStatic fun createForTests( - parentDisposable: Disposable, initialConfiguration: CompilerConfiguration, extensionConfigs: EnvironmentConfigFiles + parentDisposable: Disposable, initialConfiguration: CompilerConfiguration, extensionConfigs: EnvironmentConfigFiles ): KotlinCoreEnvironment { val configuration = initialConfiguration.copy() // in tests we assume that standard definition should only be added if no other explicit defs are already added @@ -458,10 +466,10 @@ class KotlinCoreEnvironment private constructor( } // Tests are supposed to create a single project and dispose it right after use return KotlinCoreEnvironment( - parentDisposable, - createApplicationEnvironment(parentDisposable, configuration, unitTestMode = true), - configuration, - extensionConfigs + parentDisposable, + createApplicationEnvironment(parentDisposable, configuration, unitTestMode = true), + configuration, + extensionConfigs ) } @@ -469,7 +477,7 @@ class KotlinCoreEnvironment private constructor( val applicationEnvironment: JavaCoreApplicationEnvironment? get() = ourApplicationEnvironment private fun getOrCreateApplicationEnvironmentForProduction(configuration: CompilerConfiguration): JavaCoreApplicationEnvironment { - synchronized (APPLICATION_LOCK) { + synchronized(APPLICATION_LOCK) { if (ourApplicationEnvironment != null) return ourApplicationEnvironment!! @@ -477,7 +485,7 @@ class KotlinCoreEnvironment private constructor( ourApplicationEnvironment = createApplicationEnvironment(parentDisposable, configuration, unitTestMode = false) ourProjectCount = 0 Disposer.register(parentDisposable, Disposable { - synchronized (APPLICATION_LOCK) { + synchronized(APPLICATION_LOCK) { ourApplicationEnvironment = null } }) @@ -486,7 +494,7 @@ class KotlinCoreEnvironment private constructor( } private fun disposeApplicationEnvironment() { - synchronized (APPLICATION_LOCK) { + synchronized(APPLICATION_LOCK) { val environment = ourApplicationEnvironment ?: return ourApplicationEnvironment = null Disposer.dispose(environment.parentDisposable) @@ -495,9 +503,7 @@ class KotlinCoreEnvironment private constructor( } private fun createApplicationEnvironment( - parentDisposable: Disposable, - configuration: CompilerConfiguration, - unitTestMode: Boolean + parentDisposable: Disposable, configuration: CompilerConfiguration, unitTestMode: Boolean ): JavaCoreApplicationEnvironment { Extensions.cleanRootArea(parentDisposable) registerAppExtensionPoints() @@ -514,43 +520,47 @@ class KotlinCoreEnvironment private constructor( } private fun registerAppExtensionPoints() { - CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), BinaryFileStubBuilders.EP_NAME, FileTypeExtensionPoint::class.java) - CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), FileContextProvider.EP_NAME, FileContextProvider::class.java) - // - CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), MetaDataContributor.EP_NAME, MetaDataContributor::class.java) - CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), PsiAugmentProvider.EP_NAME, PsiAugmentProvider::class.java) - CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), JavaMainMethodProvider.EP_NAME, JavaMainMethodProvider::class.java) - // - CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), ContainerProvider.EP_NAME, ContainerProvider::class.java) - CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), ClassFileDecompilers.EP_NAME, ClassFileDecompilers.Decompiler::class.java) - // - CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), TypeAnnotationModifier.EP_NAME, TypeAnnotationModifier::class.java) - CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), MetaLanguage.EP_NAME, MetaLanguage::class.java) - // - IdeaExtensionPoints.registerVersionSpecificAppExtensionPoints(Extensions.getRootArea()) + val area = Extensions.getRootArea() + + CoreApplicationEnvironment.registerExtensionPoint(area, BinaryFileStubBuilders.EP_NAME, FileTypeExtensionPoint::class.java) + CoreApplicationEnvironment.registerExtensionPoint(area, FileContextProvider.EP_NAME, FileContextProvider::class.java) + + CoreApplicationEnvironment.registerExtensionPoint(area, MetaDataContributor.EP_NAME, MetaDataContributor::class.java) + CoreApplicationEnvironment.registerExtensionPoint(area, PsiAugmentProvider.EP_NAME, PsiAugmentProvider::class.java) + CoreApplicationEnvironment.registerExtensionPoint(area, JavaMainMethodProvider.EP_NAME, JavaMainMethodProvider::class.java) + + CoreApplicationEnvironment.registerExtensionPoint(area, ContainerProvider.EP_NAME, ContainerProvider::class.java) + CoreApplicationEnvironment.registerExtensionPoint( + area, ClassFileDecompilers.EP_NAME, ClassFileDecompilers.Decompiler::class.java + ) + + CoreApplicationEnvironment.registerExtensionPoint(area, TypeAnnotationModifier.EP_NAME, TypeAnnotationModifier::class.java) + CoreApplicationEnvironment.registerExtensionPoint(area, MetaLanguage.EP_NAME, MetaLanguage::class.java) + + IdeaExtensionPoints.registerVersionSpecificAppExtensionPoints(area) } private fun registerApplicationExtensionPointsAndExtensionsFrom(configuration: CompilerConfiguration, configFilePath: String) { fun File.hasConfigFile(configFile: String): Boolean = - if (isDirectory) File(this, "META-INF" + File.separator + configFile).exists() - else try { - ZipFile(this).use { - it.getEntry("META-INF/" + configFile) != null - } - } - catch (e: Throwable) { - false + if (isDirectory) File(this, "META-INF" + File.separator + configFile).exists() + else try { + ZipFile(this).use { + it.getEntry("META-INF/$configFile") != null } + } catch (e: Throwable) { + false + } val pluginRoot = - configuration.get(CLIConfigurationKeys.INTELLIJ_PLUGIN_ROOT)?.let(::File) - ?: configuration.get(CLIConfigurationKeys.COMPILER_JAR_LOCATOR)?.compilerJar - ?: PathUtil.getResourcePathForClass(this::class.java).takeIf { it.hasConfigFile(configFilePath) } - // hack for load extensions when compiler run directly from project directory (e.g. in tests) - ?: File("idea/src").takeIf { it.hasConfigFile(configFilePath) } - ?: throw IllegalStateException( - "Unable to find extension point configuration $configFilePath " + - "(cp:\n ${(Thread.currentThread().contextClassLoader as? UrlClassLoader)?.urls?.joinToString("\n ") { it.file }})") + configuration.get(CLIConfigurationKeys.INTELLIJ_PLUGIN_ROOT)?.let(::File) + ?: configuration.get(CLIConfigurationKeys.COMPILER_JAR_LOCATOR)?.compilerJar + ?: PathUtil.getResourcePathForClass(this::class.java).takeIf { it.hasConfigFile(configFilePath) } + // hack for load extensions when compiler run directly from project directory (e.g. in tests) + ?: File("idea/src").takeIf { it.hasConfigFile(configFilePath) } + ?: throw IllegalStateException( + "Unable to find extension point configuration $configFilePath " + + "(cp:\n ${(Thread.currentThread().contextClassLoader as? UrlClassLoader)?.urls?.joinToString("\n ") { it.file }})" + ) CoreApplicationEnvironment.registerExtensionPointAndExtensions(pluginRoot, configFilePath, Extensions.getRootArea()) } @@ -562,7 +572,7 @@ class KotlinCoreEnvironment private constructor( } // made public for Upsource - @Suppress("MemberVisibilityCanPrivate") + @Suppress("MemberVisibilityCanBePrivate") @JvmStatic fun registerApplicationServices(applicationEnvironment: JavaCoreApplicationEnvironment) { with(applicationEnvironment) { @@ -576,7 +586,9 @@ class KotlinCoreEnvironment private constructor( } private fun registerProjectExtensionPoints(area: ExtensionsArea) { - CoreApplicationEnvironment.registerExtensionPoint(area, PsiTreeChangePreprocessor.EP_NAME, PsiTreeChangePreprocessor::class.java) + CoreApplicationEnvironment.registerExtensionPoint( + area, PsiTreeChangePreprocessor.EP_NAME, PsiTreeChangePreprocessor::class.java + ) CoreApplicationEnvironment.registerExtensionPoint(area, PsiElementFinder.EP_NAME, PsiElementFinder::class.java) IdeaExtensionPoints.registerVersionSpecificProjectExtensionPoints(area) @@ -585,10 +597,13 @@ class KotlinCoreEnvironment private constructor( // made public for Upsource @JvmStatic fun registerProjectServices(projectEnvironment: JavaCoreProjectEnvironment, messageCollector: MessageCollector?) { - with (projectEnvironment.project) { + with(projectEnvironment.project) { val scriptDefinitionProvider = CliScriptDefinitionProvider() registerService(ScriptDefinitionProvider::class.java, scriptDefinitionProvider) - registerService(ScriptDependenciesProvider::class.java, CliScriptDependenciesProvider(projectEnvironment.project, scriptDefinitionProvider)) + registerService( + ScriptDependenciesProvider::class.java, + CliScriptDependenciesProvider(projectEnvironment.project, scriptDefinitionProvider) + ) registerService(KotlinJavaPsiFacade::class.java, KotlinJavaPsiFacade(this)) registerService(KtLightClassForFacade.FacadeStubCache::class.java, KtLightClassForFacade.FacadeStubCache(this)) registerService(ModuleAnnotationsResolver::class.java, CliModuleAnnotationsResolver()) @@ -603,7 +618,6 @@ class KotlinCoreEnvironment private constructor( * Note that Kapt may restart code analysis process, and CLI services should be aware of that. * Use PsiManager.getModificationTracker() to ensure that all the data you cached is still valid. */ - } private fun CompilerConfiguration.setupJdkClasspathRoots(configFiles: EnvironmentConfigFiles) { @@ -618,8 +632,7 @@ class KotlinCoreEnvironment private constructor( put(JVMConfigurationKeys.JDK_HOME, javaHome) javaHome to PathUtil.getJdkClassesRootsFromCurrentJre() - } - else { + } else { jdkHome to PathUtil.getJdkClassesRoots(jdkHome) } @@ -627,12 +640,10 @@ class KotlinCoreEnvironment private constructor( if (classesRoots.isEmpty()) { val messageCollector = get(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY) messageCollector?.report(ERROR, "No class roots are found in the JDK path: $javaRoot") - } - else { + } else { addJvmSdkRoots(classesRoots) } } } - } }