From 0e2e3b3e65d745a1a544fb5b7a8bf8e1bedfde93 Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Fri, 16 Jun 2017 20:03:46 +0300 Subject: [PATCH] Cleanup KotlinCoreEnvironment and usages Remove unused API, weaken declaration visibility, reformat --- .../cli/jvm/compiler/KotlinCoreEnvironment.kt | 68 ++++++++----------- .../compiler/KotlinToJVMBytecodeCompiler.kt | 13 ++-- .../cli/jvm/KotlinCliJavaFileManagerTest.kt | 11 +-- 3 files changed, 41 insertions(+), 51 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 717489331d8..11590da1595 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 @@ -16,7 +16,6 @@ package org.jetbrains.kotlin.cli.jvm.compiler -import com.google.common.collect.Sets import com.intellij.codeInsight.ContainerProvider import com.intellij.codeInsight.ExternalAnnotationsManager import com.intellij.codeInsight.InferredAnnotationsManager @@ -29,7 +28,6 @@ import com.intellij.ide.highlighter.JavaFileType import com.intellij.ide.plugins.PluginManagerCore import com.intellij.lang.MetaLanguage import com.intellij.lang.java.JavaParserDefinition -import com.intellij.mock.MockApplication import com.intellij.openapi.Disposable import com.intellij.openapi.application.ApplicationManager import com.intellij.openapi.application.TransactionGuard @@ -113,7 +111,6 @@ class KotlinCoreEnvironment private constructor( configuration: CompilerConfiguration, configFiles: EnvironmentConfigFiles ) { - private val projectEnvironment: JavaCoreProjectEnvironment = object : KotlinCoreProjectEnvironment(parentDisposable, applicationEnvironment) { override fun preregisterServices() { registerProjectExtensionPoints(Extensions.getArea(project)) @@ -141,6 +138,7 @@ class KotlinCoreEnvironment private constructor( super.registerJavaPsiFacade() } } + private val sourceFiles = mutableListOf() private val rootsIndex: JvmDependenciesDynamicCompoundIndex private val packagePartProviders = mutableListOf() @@ -152,9 +150,7 @@ class KotlinCoreEnvironment private constructor( init { PersistentFSConstants.setMaxIntellisenseFileSize(FileUtilRt.LARGE_FOR_CONTENT_LOADING) - } - init { val project = projectEnvironment.project ExpressionCodegenExtension.registerExtensionPoint(project) @@ -224,6 +220,10 @@ class KotlinCoreEnvironment private constructor( val finderFactory = CliVirtualFileFinderFactory(rootsIndex) project.registerService(MetadataFinderFactory::class.java, finderFactory) project.registerService(VirtualFileFinderFactory::class.java, finderFactory) + + project.putUserData(APPEND_JAVA_SOURCE_ROOTS_HANDLER_KEY, fun(roots: List) { + updateClasspath(roots.map { JavaSourceRoot(it, null) }) + }) } fun createPackagePartProvider(scope: GlobalSearchScope): JvmPackagePartProvider { @@ -260,15 +260,10 @@ class KotlinCoreEnvironment private constructor( private val applicationEnvironment: CoreApplicationEnvironment get() = projectEnvironment.environment - val application: MockApplication - get() = applicationEnvironment.application - val project: Project get() = projectEnvironment.project - val sourceLinesOfCode: Int by lazy { countLinesOfCode(sourceFiles) } - - fun countLinesOfCode(sourceFiles: List): Int = + internal fun countLinesOfCode(sourceFiles: List): Int = sourceFiles.sumBy { sourceFile -> val text = sourceFile.text StringUtil.getLineBreakCount(text) + (if (StringUtil.endsWithLineBreak(text)) 0 else 1) @@ -280,15 +275,7 @@ class KotlinCoreEnvironment private constructor( } } - val appendJavaSourceRootsHandler = fun(roots: List) { - updateClasspath(roots.map { JavaSourceRoot(it, null) }) - } - - init { - project.putUserData(APPEND_JAVA_SOURCE_ROOTS_HANDLER_KEY, appendJavaSourceRootsHandler) - } - - fun updateClasspath(contentRoots: List): List? { + internal fun updateClasspath(contentRoots: List): List? { val newRoots = classpathRootsResolver.convertClasspathRoots(contentRoots) for (packagePartProvider in packagePartProviders) { @@ -297,15 +284,13 @@ class KotlinCoreEnvironment private constructor( return rootsIndex.addNewIndexForRoots(newRoots)?.let { newIndex -> updateClasspathFromRootsIndex(newIndex) - newIndex.indexedRoots.mapNotNull { (file) -> File(file.path.substringBefore(URLUtil.JAR_SEPARATOR)) }.toList() + newIndex.indexedRoots.mapNotNull { (file) -> + VfsUtilCore.virtualToIoFile(VfsUtilCore.getVirtualFileForJar(file) ?: file) + }.toList() }.orEmpty() } - @Suppress("unused") // used externally - @Deprecated("Use updateClasspath() instead.", ReplaceWith("updateClasspath(files)")) - fun tryUpdateClasspath(files: Iterable): List? = updateClasspath(files.map(::JvmClasspathRoot)) - - fun contentRootToVirtualFile(root: JvmContentRoot): VirtualFile? { + private fun contentRootToVirtualFile(root: JvmContentRoot): VirtualFile? { return when (root) { is JvmClasspathRoot -> if (root.file.isFile) findJarRoot(root) else findLocalFile(root) is JavaSourceRoot -> findLocalFile(root) @@ -316,20 +301,18 @@ class KotlinCoreEnvironment private constructor( internal fun findLocalFile(path: String) = applicationEnvironment.localFileSystem.findFileByPath(path) private fun findLocalFile(root: JvmContentRoot): VirtualFile? { - val path = root.file - val localFile = findLocalFile(path.absolutePath) - if (localFile == null) { - report(STRONG_WARNING, "Classpath entry points to a non-existent location: $path") - return null + return findLocalFile(root.file.absolutePath).also { + if (it == null) { + report(STRONG_WARNING, "Classpath entry points to a non-existent location: ${root.file}") + } } - return localFile } private fun findJarRoot(root: JvmClasspathRoot): VirtualFile? = applicationEnvironment.jarFileSystem.findFileByPath("${root.file}${URLUtil.JAR_SEPARATOR}") private fun getSourceRootsCheckingForDuplicates(): Collection { - val uniqueSourceRoots = Sets.newLinkedHashSet() + val uniqueSourceRoots = linkedSetOf() configuration.kotlinSourceRoots.forEach { path -> if (!uniqueSourceRoots.add(path)) { @@ -403,7 +386,9 @@ class KotlinCoreEnvironment private constructor( // used in the daemon for jar cache cleanup val applicationEnvironment: JavaCoreApplicationEnvironment? get() = ourApplicationEnvironment - private fun getOrCreateApplicationEnvironmentForProduction(configuration: CompilerConfiguration, configFilePaths: List): JavaCoreApplicationEnvironment { + private fun getOrCreateApplicationEnvironmentForProduction( + configuration: CompilerConfiguration, configFilePaths: List + ): JavaCoreApplicationEnvironment { synchronized (APPLICATION_LOCK) { if (ourApplicationEnvironment != null) return ourApplicationEnvironment!! @@ -420,7 +405,7 @@ class KotlinCoreEnvironment private constructor( } } - fun disposeApplicationEnvironment() { + private fun disposeApplicationEnvironment() { synchronized (APPLICATION_LOCK) { val environment = ourApplicationEnvironment ?: return ourApplicationEnvironment = null @@ -429,7 +414,9 @@ class KotlinCoreEnvironment private constructor( } } - private fun createApplicationEnvironment(parentDisposable: Disposable, configuration: CompilerConfiguration, configFilePaths: List): JavaCoreApplicationEnvironment { + private fun createApplicationEnvironment( + parentDisposable: Disposable, configuration: CompilerConfiguration, configFilePaths: List + ): JavaCoreApplicationEnvironment { Extensions.cleanRootArea(parentDisposable) registerAppExtensionPoints() val applicationEnvironment = object : JavaCoreApplicationEnvironment(parentDisposable) { @@ -491,7 +478,9 @@ class KotlinCoreEnvironment private constructor( } // made public for Upsource - @JvmStatic fun registerApplicationServices(applicationEnvironment: JavaCoreApplicationEnvironment) { + @Suppress("MemberVisibilityCanPrivate") + @JvmStatic + fun registerApplicationServices(applicationEnvironment: JavaCoreApplicationEnvironment) { with(applicationEnvironment) { registerFileType(KotlinFileType.INSTANCE, "kt") registerFileType(KotlinFileType.INSTANCE, KotlinParserDefinition.STD_SCRIPT_SUFFIX) @@ -508,7 +497,8 @@ class KotlinCoreEnvironment private constructor( } // made public for Upsource - @JvmStatic fun registerProjectServices(projectEnvironment: JavaCoreProjectEnvironment) { + @JvmStatic + fun registerProjectServices(projectEnvironment: JavaCoreProjectEnvironment) { with (projectEnvironment.project) { val kotlinScriptDefinitionProvider = KotlinScriptDefinitionProvider() registerService(KotlinScriptDefinitionProvider::class.java, kotlinScriptDefinitionProvider) @@ -518,7 +508,7 @@ class KotlinCoreEnvironment private constructor( } } - private fun registerProjectServicesForCLI(projectEnvironment: JavaCoreProjectEnvironment) { + private fun registerProjectServicesForCLI(@Suppress("UNUSED_PARAMETER") projectEnvironment: JavaCoreProjectEnvironment) { /** * 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. diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.kt index 9994c9c6a67..7dfb7fe5f1d 100644 --- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.kt +++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.kt @@ -360,24 +360,24 @@ object KotlinToJVMBytecodeCompiler { } private fun analyze(environment: KotlinCoreEnvironment, targetDescription: String?): AnalysisResult? { + val sourceFiles = environment.getSourceFiles() val collector = environment.messageCollector val analysisStart = PerformanceCounter.currentTime() val analyzerWithCompilerReport = AnalyzerWithCompilerReport(collector) - analyzerWithCompilerReport.analyzeAndReport( - environment.getSourceFiles(), object : AnalyzerWithCompilerReport.Analyzer { + analyzerWithCompilerReport.analyzeAndReport(sourceFiles, object : AnalyzerWithCompilerReport.Analyzer { override fun analyze(): AnalysisResult { val project = environment.project val moduleOutputs = environment.configuration.get(JVMConfigurationKeys.MODULES)?.mapNotNull { module -> environment.findLocalFile(module.getOutputDirectory()) }.orEmpty() - val sourcesOnly = TopDownAnalyzerFacadeForJVM.newModuleSearchScope(project, environment.getSourceFiles()) + val sourcesOnly = TopDownAnalyzerFacadeForJVM.newModuleSearchScope(project, sourceFiles) // To support partial and incremental compilation, we add the scope which contains binaries from output directories // of the compiled modules (.class) to the list of scopes of the source module val scope = if (moduleOutputs.isEmpty()) sourcesOnly else sourcesOnly.uniteWith(DirectoriesScope(project, moduleOutputs)) return TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration( project, - environment.getSourceFiles(), + sourceFiles, CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(), environment.configuration, environment::createPackagePartProvider, @@ -392,12 +392,11 @@ object KotlinToJVMBytecodeCompiler { val analysisNanos = PerformanceCounter.currentTime() - analysisStart - val sourceLinesOfCode = environment.sourceLinesOfCode - val numberOfFiles = environment.getSourceFiles().size + val sourceLinesOfCode = environment.countLinesOfCode(sourceFiles) val time = TimeUnit.NANOSECONDS.toMillis(analysisNanos) val speed = sourceLinesOfCode.toFloat() * 1000 / time - val message = "ANALYZE: $numberOfFiles files ($sourceLinesOfCode lines) ${targetDescription ?: ""}" + + val message = "ANALYZE: ${sourceFiles.size} files ($sourceLinesOfCode lines) ${targetDescription ?: ""}" + "in $time ms - ${"%.3f".format(speed)} loc/s" K2JVMCompiler.reportPerf(environment.configuration, message) diff --git a/compiler/tests/org/jetbrains/kotlin/cli/jvm/KotlinCliJavaFileManagerTest.kt b/compiler/tests/org/jetbrains/kotlin/cli/jvm/KotlinCliJavaFileManagerTest.kt index 2865ec5b50e..d31943755ae 100644 --- a/compiler/tests/org/jetbrains/kotlin/cli/jvm/KotlinCliJavaFileManagerTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/cli/jvm/KotlinCliJavaFileManagerTest.kt @@ -13,17 +13,18 @@ * See the License for the specific language governing permissions and * limitations under the License. */ + package org.jetbrains.kotlin.cli.jvm import com.intellij.core.CoreJavaFileManager import com.intellij.openapi.components.ServiceManager +import com.intellij.openapi.vfs.StandardFileSystems import com.intellij.psi.search.GlobalSearchScope import junit.framework.TestCase import org.intellij.lang.annotations.Language import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCliJavaFileManagerImpl import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment -import org.jetbrains.kotlin.cli.jvm.config.JavaSourceRoot import org.jetbrains.kotlin.cli.jvm.index.JavaRoot import org.jetbrains.kotlin.cli.jvm.index.JvmDependenciesIndexImpl import org.jetbrains.kotlin.cli.jvm.index.SingleJavaFileRootsIndex @@ -38,7 +39,7 @@ import org.jetbrains.kotlin.test.TestJdkKind import java.io.File class KotlinCliJavaFileManagerTest : KotlinTestWithEnvironment() { - private var javaFilesDir: File? = null + private lateinit var javaFilesDir: File fun testCommon() { val manager = configureManager( @@ -184,7 +185,7 @@ class KotlinCliJavaFileManagerTest : KotlinTestWithEnvironment() { javaFilesDir = KotlinTestUtils.tmpDir("java-file-manager-test") val configuration = KotlinTestUtils.newConfiguration( - ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK, emptyList(), listOf(javaFilesDir!!) + ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK, emptyList(), listOf(javaFilesDir) ) return KotlinCoreEnvironment.createForTests(testRootDisposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES) @@ -200,7 +201,7 @@ class KotlinCliJavaFileManagerTest : KotlinTestWithEnvironment() { val coreJavaFileFinder = VirtualFileFinder.SERVICE.getInstance(project) val coreJavaFileManager = ServiceManager.getService(project, CoreJavaFileManager::class.java) as KotlinCliJavaFileManagerImpl - val root = environment.contentRootToVirtualFile(JavaSourceRoot(javaFilesDir!!, null))!! + val root = StandardFileSystems.local().findFileByPath(javaFilesDir.path)!! coreJavaFileManager.initialize( JvmDependenciesIndexImpl(listOf(JavaRoot(root, JavaRoot.RootType.SOURCE))), SingleJavaFileRootsIndex(emptyList()), @@ -223,7 +224,7 @@ class KotlinCliJavaFileManagerTest : KotlinTestWithEnvironment() { TestCase.assertNotNull("Could not find: $stringRequest", foundByString) TestCase.assertEquals(foundByClassId, foundByString) - TestCase.assertEquals("Found ${foundByClassId!!.qualifiedName} instead of $packageFQName", packageFQName + "." + classFqName, + TestCase.assertEquals("Found ${foundByClassId.qualifiedName} instead of $packageFQName", packageFQName + "." + classFqName, foundByClassId.qualifiedName) }