From 7e515e38200a095d76299c979e62a264cd12e052 Mon Sep 17 00:00:00 2001 From: Alexey Tsvetkov Date: Mon, 7 Sep 2015 16:46:04 +0300 Subject: [PATCH] Use simple data class TargetId instead of Module to get incremental cache --- .../kotlin/codegen/PackageCodegen.java | 2 +- .../kotlin/codegen/classFileUtils.kt | 4 +-- .../kotlin/codegen/inline/InlineCodegen.java | 9 +++--- .../kotlin/codegen/state/GenerationState.kt | 4 +-- .../compiler/KotlinToJVMBytecodeCompiler.java | 17 ++++++---- .../IncrementalPackageFragmentProvider.kt | 10 +++--- .../IncrementalPackagePartProvider.kt | 8 ++--- .../IncrementalCompilationComponents.kt | 4 +-- .../jvm/TopDownAnalyzerFacadeForJVM.java | 27 +++++++++++----- .../rmi/kotlinr/KotlinCompilerClient.kt | 6 ++-- .../jetbrains/kotlin/rmi/CompileService.kt | 4 +-- .../kotlin/rmi/service/CompileServiceImpl.kt | 10 +++--- .../org/jetbrains/kotlin/modules/Module.kt | 11 ------- .../org/jetbrains/kotlin/modules/TargetId.kt | 22 +++++++++++++ .../compilerRunner/KotlinCompilerRunner.java | 10 +++--- .../kotlin/jps/build/KotlinBuilder.kt | 12 +++---- .../IncrementalCompilationComponentsImpl.kt | 32 ++----------------- .../jetbrains/kotlin/modules/modulesUtil.kt | 22 +++++++++++++ 18 files changed, 118 insertions(+), 96 deletions(-) create mode 100644 compiler/util/src/org/jetbrains/kotlin/modules/TargetId.kt create mode 100644 jps-plugin/src/org/jetbrains/kotlin/modules/modulesUtil.kt diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/PackageCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/PackageCodegen.java index 05be3ed7879..18aa1e8c988 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/PackageCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/PackageCodegen.java @@ -143,7 +143,7 @@ public class PackageCodegen { // TODO rewrite it to something more robust when module system is implemented for (PackageFragmentDescriptor fragment : state.getModule().getPackage(fqName).getFragments()) { if (fragment instanceof IncrementalPackageFragmentProvider.IncrementalPackageFragment && - ((IncrementalPackageFragmentProvider.IncrementalPackageFragment) fragment).getTarget().equals(state.getTarget())) { + ((IncrementalPackageFragmentProvider.IncrementalPackageFragment) fragment).getTarget().equals(state.getTargetId())) { return fragment; } } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/classFileUtils.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/classFileUtils.kt index 77d5d50ae8c..f409a45afcc 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/classFileUtils.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/classFileUtils.kt @@ -33,9 +33,9 @@ fun List.addCompiledPartsAndSort(state: GenerationState): List.addCompiledParts(state: GenerationState): List { - if (state.incrementalCompilationComponents == null || state.target == null) return this + if (state.incrementalCompilationComponents == null || state.targetId == null) return this - val incrementalCache = state.incrementalCompilationComponents.getIncrementalCache(state.target) + val incrementalCache = state.incrementalCompilationComponents.getIncrementalCache(state.targetId) val moduleMappingData = incrementalCache.getModuleMappingData() ?: return this val mapping = ModuleMapping.create(moduleMappingData) diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegen.java index a503060981e..abd3ae87a30 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegen.java @@ -30,11 +30,10 @@ import org.jetbrains.kotlin.codegen.context.PackageContext; import org.jetbrains.kotlin.codegen.state.GenerationState; import org.jetbrains.kotlin.codegen.state.JetTypeMapper; import org.jetbrains.kotlin.descriptors.*; -import org.jetbrains.kotlin.load.kotlin.PackageClassUtils; import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCache; import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCompilationComponents; import org.jetbrains.kotlin.load.kotlin.incremental.components.InlineRegistering; -import org.jetbrains.kotlin.modules.Module; +import org.jetbrains.kotlin.modules.TargetId; import org.jetbrains.kotlin.name.ClassId; import org.jetbrains.kotlin.name.Name; import org.jetbrains.kotlin.psi.*; @@ -748,11 +747,11 @@ public class InlineCodegen extends CallGenerator { @NotNull FunctionDescriptor targetDescriptor ) { IncrementalCompilationComponents incrementalCompilationComponents = state.getIncrementalCompilationComponents(); - Module target = state.getTarget(); + TargetId targetId = state.getTargetId(); - if (incrementalCompilationComponents == null || target == null) return; + if (incrementalCompilationComponents == null || targetId == null) return; - IncrementalCache incrementalCache = incrementalCompilationComponents.getIncrementalCache(target); + IncrementalCache incrementalCache = incrementalCompilationComponents.getIncrementalCache(targetId); String sourceFile = getClassFilePath(sourceDescriptor, incrementalCache); String targetFile = getSourceFilePath(targetDescriptor); InlineRegistering inlineRegistering = incrementalCache.getInlineRegistering(); diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt index 4cfa71f16c3..faa57509228 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt @@ -28,7 +28,7 @@ import org.jetbrains.kotlin.descriptors.ModuleDescriptor import org.jetbrains.kotlin.descriptors.ScriptDescriptor import org.jetbrains.kotlin.diagnostics.DiagnosticSink import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCompilationComponents -import org.jetbrains.kotlin.modules.Module +import org.jetbrains.kotlin.modules.TargetId import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.psi.JetClassOrObject import org.jetbrains.kotlin.psi.JetFile @@ -52,7 +52,7 @@ public class GenerationState jvmOverloads constructor( public val diagnostics: DiagnosticSink = DiagnosticSink.DO_NOTHING, public val packagesWithObsoleteParts: Collection = emptySet(), // for PackageCodegen in incremental compilation mode - public val target: Module? = null, + public val targetId: TargetId? = null, moduleName: String? = null, // TODO: temporary hack, see JetTypeMapperWithOutDirectory state for details public val outDirectory: File? = null, diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java index f42ab4f6944..0171e7cbfd4 100644 --- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java +++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java @@ -34,7 +34,6 @@ import org.jetbrains.kotlin.cli.common.CompilerPlugin; import org.jetbrains.kotlin.cli.common.CompilerPluginContext; import org.jetbrains.kotlin.cli.common.messages.AnalyzerWithCompilerReport; import org.jetbrains.kotlin.cli.common.messages.MessageCollector; -import org.jetbrains.kotlin.modules.Module; import org.jetbrains.kotlin.cli.common.output.outputUtils.OutputUtilsPackage; import org.jetbrains.kotlin.cli.jvm.K2JVMCompiler; import org.jetbrains.kotlin.cli.jvm.config.JVMConfigurationKeys; @@ -46,6 +45,9 @@ import org.jetbrains.kotlin.idea.MainFunctionDetector; import org.jetbrains.kotlin.load.kotlin.PackageClassUtils; import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCache; import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCompilationComponents; +import org.jetbrains.kotlin.modules.Module; +import org.jetbrains.kotlin.modules.ModulesPackage; +import org.jetbrains.kotlin.modules.TargetId; import org.jetbrains.kotlin.name.FqName; import org.jetbrains.kotlin.parsing.JetScriptDefinition; import org.jetbrains.kotlin.parsing.JetScriptDefinitionProvider; @@ -357,7 +359,7 @@ public class KotlinToJVMBytecodeCompiler { @NotNull KotlinCoreEnvironment environment, @NotNull AnalysisResult result, @NotNull List sourceFiles, - @Nullable Module target, + @Nullable Module module, File outputDirectory, String moduleName ) { @@ -365,11 +367,14 @@ public class KotlinToJVMBytecodeCompiler { IncrementalCompilationComponents incrementalCompilationComponents = configuration.get(JVMConfigurationKeys.INCREMENTAL_COMPILATION_COMPONENTS); Collection packagesWithObsoleteParts; - if (target == null || incrementalCompilationComponents == null) { + TargetId targetId = null; + + if (module == null || incrementalCompilationComponents == null) { packagesWithObsoleteParts = Collections.emptySet(); } else { - IncrementalCache incrementalCache = incrementalCompilationComponents.getIncrementalCache(target); + targetId = ModulesPackage.TargetId(module); + IncrementalCache incrementalCache = incrementalCompilationComponents.getIncrementalCache(targetId); packagesWithObsoleteParts = new HashSet(); for (String internalName : incrementalCache.getObsoletePackageParts()) { packagesWithObsoleteParts.add(JvmClassName.byInternalName(internalName).getPackageFqName()); @@ -389,7 +394,7 @@ public class KotlinToJVMBytecodeCompiler { configuration.get(JVMConfigurationKeys.DISABLE_OPTIMIZATION, false), diagnosticHolder, packagesWithObsoleteParts, - target, + targetId, moduleName, outputDirectory, incrementalCompilationComponents @@ -401,7 +406,7 @@ public class KotlinToJVMBytecodeCompiler { KotlinCodegenFacade.compileCorrectFiles(generationState, CompilationErrorHandler.THROW_EXCEPTION); long generationNanos = PerformanceCounter.Companion.currentTime() - generationStart; - String desc = target != null ? "target " + target.getModuleName() + "-" + target.getModuleType() + " " : ""; + String desc = module != null ? "target " + module.getModuleName() + "-" + module.getModuleType() + " " : ""; String message = "GENERATE: " + sourceFiles.size() + " files (" + environment.countLinesOfCode(sourceFiles) + " lines) " + desc + "in " + TimeUnit.NANOSECONDS.toMillis(generationNanos) + " ms"; K2JVMCompiler.Companion.reportPerf(environment.getConfiguration(), message); diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/incremental/IncrementalPackageFragmentProvider.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/incremental/IncrementalPackageFragmentProvider.kt index 65433dc2c38..249c5ca3622 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/incremental/IncrementalPackageFragmentProvider.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/incremental/IncrementalPackageFragmentProvider.kt @@ -25,7 +25,7 @@ import org.jetbrains.kotlin.descriptors.impl.PackageFragmentDescriptorImpl import org.jetbrains.kotlin.load.kotlin.ModuleMapping import org.jetbrains.kotlin.load.kotlin.PackagePartClassUtils import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCache -import org.jetbrains.kotlin.modules.Module +import org.jetbrains.kotlin.modules.TargetId import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.psi.JetFile @@ -46,11 +46,11 @@ import java.util.* public class IncrementalPackageFragmentProvider( sourceFiles: Collection, - val module: ModuleDescriptor, + val moduleDescriptor: ModuleDescriptor, val storageManager: StorageManager, val deserializationComponents: DeserializationComponents, val incrementalCache: IncrementalCache, - val target: Module + val target: TargetId ) : PackageFragmentProvider { companion object { @@ -93,8 +93,8 @@ public class IncrementalPackageFragmentProvider( } - public inner class IncrementalPackageFragment(fqName: FqName) : PackageFragmentDescriptorImpl(module, fqName) { - public val target: Module + public inner class IncrementalPackageFragment(fqName: FqName) : PackageFragmentDescriptorImpl(moduleDescriptor, fqName) { + public val target: TargetId get() = this@IncrementalPackageFragmentProvider.target val memberScope: NotNullLazyValue = storageManager.createLazyValue { diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/incremental/IncrementalPackagePartProvider.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/incremental/IncrementalPackagePartProvider.kt index 9f96f2410d5..3e5f57332e3 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/incremental/IncrementalPackagePartProvider.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/incremental/IncrementalPackagePartProvider.kt @@ -20,7 +20,7 @@ import org.jetbrains.kotlin.descriptors.PackagePartProvider import org.jetbrains.kotlin.load.kotlin.ModuleMapping import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCache import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCompilationComponents -import org.jetbrains.kotlin.modules.Module +import org.jetbrains.kotlin.modules.TargetId import org.jetbrains.kotlin.psi.JetFile import org.jetbrains.kotlin.storage.StorageManager @@ -47,13 +47,13 @@ internal class IncrementalPackagePartProvider private constructor( public fun create( parent: PackagePartProvider, sourceFiles: Collection, - modules: List?, + targets: List?, incrementalCompilationComponents: IncrementalCompilationComponents?, storageManager: StorageManager ): PackagePartProvider { - if (modules == null || incrementalCompilationComponents == null) return parent + if (targets == null || incrementalCompilationComponents == null) return parent - val incrementalCaches = modules.map { incrementalCompilationComponents.getIncrementalCache(it) } + val incrementalCaches = targets.map { incrementalCompilationComponents.getIncrementalCache(it) } return IncrementalPackagePartProvider(parent, sourceFiles, incrementalCaches, storageManager) } } diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/incremental/components/IncrementalCompilationComponents.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/incremental/components/IncrementalCompilationComponents.kt index b7abea713f0..69ab35b14ba 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/incremental/components/IncrementalCompilationComponents.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/incremental/components/IncrementalCompilationComponents.kt @@ -17,9 +17,9 @@ package org.jetbrains.kotlin.load.kotlin.incremental.components import org.jetbrains.kotlin.incremental.components.LookupTracker -import org.jetbrains.kotlin.modules.Module +import org.jetbrains.kotlin.modules.TargetId public interface IncrementalCompilationComponents { - public fun getIncrementalCache(target: Module): IncrementalCache + public fun getIncrementalCache(target: TargetId): IncrementalCache public fun getLookupTracker(): LookupTracker } diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/TopDownAnalyzerFacadeForJVM.java b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/TopDownAnalyzerFacadeForJVM.java index 39d96ab4fc8..ac829c2b713 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/TopDownAnalyzerFacadeForJVM.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/TopDownAnalyzerFacadeForJVM.java @@ -33,6 +33,8 @@ import org.jetbrains.kotlin.load.kotlin.incremental.IncrementalPackagePartProvid import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCache; import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCompilationComponents; import org.jetbrains.kotlin.modules.Module; +import org.jetbrains.kotlin.modules.ModulesPackage; +import org.jetbrains.kotlin.modules.TargetId; import org.jetbrains.kotlin.name.Name; import org.jetbrains.kotlin.platform.JavaToKotlinClassMap; import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap; @@ -101,12 +103,12 @@ public enum TopDownAnalyzerFacadeForJVM { @NotNull ModuleContext moduleContext, @NotNull Collection files, @NotNull BindingTrace trace, - @Nullable List targets, + @Nullable List modules, @Nullable IncrementalCompilationComponents incrementalCompilationComponents, @NotNull PackagePartProvider packagePartProvider ) { return analyzeFilesWithJavaIntegration( - moduleContext, files, trace, TopDownAnalysisMode.TopLevelDeclarations, targets, incrementalCompilationComponents, + moduleContext, files, trace, TopDownAnalysisMode.TopLevelDeclarations, modules, incrementalCompilationComponents, packagePartProvider); } @@ -116,7 +118,7 @@ public enum TopDownAnalyzerFacadeForJVM { @NotNull Collection files, @NotNull BindingTrace trace, @NotNull TopDownAnalysisMode topDownAnalysisMode, - @Nullable List targets, + @Nullable List modules, @Nullable IncrementalCompilationComponents incrementalCompilationComponents, @NotNull PackagePartProvider packagePartProvider ) { @@ -129,7 +131,16 @@ public enum TopDownAnalyzerFacadeForJVM { LookupTracker lookupTracker = incrementalCompilationComponents != null ? incrementalCompilationComponents.getLookupTracker() : LookupTracker.DO_NOTHING; - packagePartProvider = IncrementalPackagePartProvider.create(packagePartProvider, files, targets, incrementalCompilationComponents, moduleContext.getStorageManager()); + List targetIds = null; + if (modules != null) { + targetIds = new ArrayList(modules.size()); + + for (Module module : modules) { + targetIds.add(ModulesPackage.TargetId(module)); + } + } + + packagePartProvider = IncrementalPackagePartProvider.create(packagePartProvider, files, targetIds, incrementalCompilationComponents, moduleContext.getStorageManager()); ContainerForTopDownAnalyzerForJvm container = DiPackage.createContainerForTopDownAnalyzerForJvm( moduleContext, @@ -142,15 +153,15 @@ public enum TopDownAnalyzerFacadeForJVM { List additionalProviders = new ArrayList(); - if (targets != null && incrementalCompilationComponents != null) { - for (Module target : targets) { - IncrementalCache incrementalCache = incrementalCompilationComponents.getIncrementalCache(target); + if (targetIds != null && incrementalCompilationComponents != null) { + for (TargetId targetId : targetIds) { + IncrementalCache incrementalCache = incrementalCompilationComponents.getIncrementalCache(targetId); additionalProviders.add( new IncrementalPackageFragmentProvider( files, moduleContext.getModule(), moduleContext.getStorageManager(), container.getDeserializationComponentsForJava().getComponents(), - incrementalCache, target + incrementalCache, targetId ) ); } diff --git a/compiler/rmi/kotlinr/src/org/jetbrains/kotlin/rmi/kotlinr/KotlinCompilerClient.kt b/compiler/rmi/kotlinr/src/org/jetbrains/kotlin/rmi/kotlinr/KotlinCompilerClient.kt index b4fb94432ff..cdcfe11ff62 100644 --- a/compiler/rmi/kotlinr/src/org/jetbrains/kotlin/rmi/kotlinr/KotlinCompilerClient.kt +++ b/compiler/rmi/kotlinr/src/org/jetbrains/kotlin/rmi/kotlinr/KotlinCompilerClient.kt @@ -17,7 +17,7 @@ package org.jetbrains.kotlin.rmi.kotlinr import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCache -import org.jetbrains.kotlin.modules.Module +import org.jetbrains.kotlin.modules.TargetId import org.jetbrains.kotlin.rmi.* import java.io.File import java.io.OutputStream @@ -176,10 +176,10 @@ public class KotlinCompilerClient { } } - public fun incrementalCompile(compiler: CompileService, args: Array, caches: Map, out: OutputStream): Int { + public fun incrementalCompile(compiler: CompileService, args: Array, caches: Map, out: OutputStream): Int { val outStrm = RemoteOutputStreamServer(out) - val cacheServers = hashMapOf() + val cacheServers = hashMapOf() try { caches.mapValuesTo(cacheServers, { RemoteIncrementalCacheServer( it.getValue()) }) return compiler.remoteIncrementalCompile(args, cacheServers, outStrm, CompileService.OutputFormat.XML) diff --git a/compiler/rmi/rmi-interface/src/org/jetbrains/kotlin/rmi/CompileService.kt b/compiler/rmi/rmi-interface/src/org/jetbrains/kotlin/rmi/CompileService.kt index bc486fd45d3..a89c535793e 100644 --- a/compiler/rmi/rmi-interface/src/org/jetbrains/kotlin/rmi/CompileService.kt +++ b/compiler/rmi/rmi-interface/src/org/jetbrains/kotlin/rmi/CompileService.kt @@ -17,7 +17,7 @@ package org.jetbrains.kotlin.rmi import org.jetbrains.kotlin.load.kotlin.incremental.components.InlineRegistering -import org.jetbrains.kotlin.modules.Module +import org.jetbrains.kotlin.modules.TargetId import java.rmi.Remote import java.rmi.RemoteException @@ -63,7 +63,7 @@ public interface CompileService : Remote { throws(RemoteException::class) public fun remoteIncrementalCompile( args: Array, - caches: Map, + caches: Map, outputStream: RemoteOutputStream, outputFormat: OutputFormat): Int } diff --git a/compiler/rmi/rmi-server/src/org/jetbrains/kotlin/rmi/service/CompileServiceImpl.kt b/compiler/rmi/rmi-server/src/org/jetbrains/kotlin/rmi/service/CompileServiceImpl.kt index 145dbcbbdd0..7b40d0efbb9 100644 --- a/compiler/rmi/rmi-server/src/org/jetbrains/kotlin/rmi/service/CompileServiceImpl.kt +++ b/compiler/rmi/rmi-server/src/org/jetbrains/kotlin/rmi/service/CompileServiceImpl.kt @@ -22,7 +22,7 @@ import org.jetbrains.kotlin.config.Services import org.jetbrains.kotlin.incremental.components.LookupTracker import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCache import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCompilationComponents -import org.jetbrains.kotlin.modules.Module +import org.jetbrains.kotlin.modules.TargetId import org.jetbrains.kotlin.rmi.* import org.jetbrains.kotlin.rmi.service.RemoteIncrementalCacheClient import org.jetbrains.kotlin.rmi.service.RemoteOutputStreamClient @@ -81,14 +81,14 @@ class CompileServiceImpl>( alive = true } - public class IncrementalCompilationComponentsImpl(val targetToCache: Map): IncrementalCompilationComponents { + public class IncrementalCompilationComponentsImpl(val targetToCache: Map): IncrementalCompilationComponents { // perf: cheap object, but still the pattern may be costly if there are too many calls to cache with the same id (which seems not to be the case now) - override fun getIncrementalCache(target: Module): IncrementalCache = RemoteIncrementalCacheClient(targetToCache[target]!!) + override fun getIncrementalCache(target: TargetId): IncrementalCache = RemoteIncrementalCacheClient(targetToCache[target]!!) // TODO: add appropriate proxy into interaction when lookup tracker is needed override fun getLookupTracker(): LookupTracker = LookupTracker.DO_NOTHING } - private fun createCompileServices(incrementalCaches: Map): Services = + private fun createCompileServices(incrementalCaches: Map): Services = Services.Builder() .register(IncrementalCompilationComponents::class.java, IncrementalCompilationComponentsImpl(incrementalCaches)) // TODO: add remote proxy for cancellation status tracking @@ -187,7 +187,7 @@ class CompileServiceImpl>( } } - override fun remoteIncrementalCompile(args: Array, caches: Map, outputStream: RemoteOutputStream, outputFormat: CompileService.OutputFormat): Int = + override fun remoteIncrementalCompile(args: Array, caches: Map, outputStream: RemoteOutputStream, outputFormat: CompileService.OutputFormat): Int = doCompile(args, outputStream) { printStream -> when (outputFormat) { CompileService.OutputFormat.PLAIN -> throw NotImplementedError("Only XML output is supported in remote incremental compilation") diff --git a/compiler/util/src/org/jetbrains/kotlin/modules/Module.kt b/compiler/util/src/org/jetbrains/kotlin/modules/Module.kt index a4f2da6b590..9b297639f40 100644 --- a/compiler/util/src/org/jetbrains/kotlin/modules/Module.kt +++ b/compiler/util/src/org/jetbrains/kotlin/modules/Module.kt @@ -30,15 +30,4 @@ public interface Module { public fun getAnnotationsRoots(): List public fun getJavaSourceRoots(): List - - override fun equals(other: Any?): Boolean = - when { - this === other -> true - other !is Module -> false - else -> getModuleName() == other.getModuleName() && - getModuleType() == other.getModuleType() - } - - override fun hashCode(): Int = - 31 * getModuleName().hashCode() + getModuleType().hashCode() } diff --git a/compiler/util/src/org/jetbrains/kotlin/modules/TargetId.kt b/compiler/util/src/org/jetbrains/kotlin/modules/TargetId.kt new file mode 100644 index 00000000000..1fe759659ee --- /dev/null +++ b/compiler/util/src/org/jetbrains/kotlin/modules/TargetId.kt @@ -0,0 +1,22 @@ +/* + * Copyright 2010-2015 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.modules + +public data class TargetId(public val name: String, public val type: String) + +public fun TargetId(module: Module): TargetId = + TargetId(module.getModuleName(), module.getModuleType()) \ No newline at end of file diff --git a/jps-plugin/src/org/jetbrains/kotlin/compilerRunner/KotlinCompilerRunner.java b/jps-plugin/src/org/jetbrains/kotlin/compilerRunner/KotlinCompilerRunner.java index 3a6d6c023e2..36f347dfb71 100644 --- a/jps-plugin/src/org/jetbrains/kotlin/compilerRunner/KotlinCompilerRunner.java +++ b/jps-plugin/src/org/jetbrains/kotlin/compilerRunner/KotlinCompilerRunner.java @@ -31,7 +31,7 @@ import org.jetbrains.kotlin.cli.common.messages.MessageCollector; import org.jetbrains.kotlin.cli.common.messages.MessageCollectorUtil; import org.jetbrains.kotlin.config.CompilerSettings; import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCache; -import org.jetbrains.kotlin.modules.Module; +import org.jetbrains.kotlin.modules.TargetId; import org.jetbrains.kotlin.rmi.*; import org.jetbrains.kotlin.rmi.kotlinr.KotlinCompilerClient; import org.jetbrains.kotlin.utils.UtilsPackage; @@ -59,7 +59,7 @@ public class KotlinCompilerRunner { CompilerSettings compilerSettings, MessageCollector messageCollector, CompilerEnvironment environment, - Map incrementalCaches, + Map incrementalCaches, File moduleFile, OutputItemsCollector collector ) { @@ -76,7 +76,7 @@ public class KotlinCompilerRunner { @NotNull CompilerSettings compilerSettings, @NotNull MessageCollector messageCollector, @NotNull CompilerEnvironment environment, - Map incrementalCaches, + Map incrementalCaches, @NotNull OutputItemsCollector collector, @NotNull Collection sourceFiles, @NotNull List libraryFiles, @@ -96,7 +96,7 @@ public class KotlinCompilerRunner { MessageCollector messageCollector, OutputItemsCollector collector, CompilerEnvironment environment, - Map incrementalCaches + Map incrementalCaches ) { ByteArrayOutputStream stream = new ByteArrayOutputStream(); PrintStream out = new PrintStream(stream); @@ -117,7 +117,7 @@ public class KotlinCompilerRunner { CommonCompilerArguments arguments, String additionalArguments, CompilerEnvironment environment, - Map incrementalCaches, + Map incrementalCaches, PrintStream out, MessageCollector messageCollector ) { diff --git a/jps-plugin/src/org/jetbrains/kotlin/jps/build/KotlinBuilder.kt b/jps-plugin/src/org/jetbrains/kotlin/jps/build/KotlinBuilder.kt index 81ba0203fd5..defd46693df 100644 --- a/jps-plugin/src/org/jetbrains/kotlin/jps/build/KotlinBuilder.kt +++ b/jps-plugin/src/org/jetbrains/kotlin/jps/build/KotlinBuilder.kt @@ -62,7 +62,7 @@ import org.jetbrains.kotlin.load.kotlin.PackageClassUtils import org.jetbrains.kotlin.load.kotlin.header.isCompatiblePackageFacadeKind import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCache import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCompilationComponents -import org.jetbrains.kotlin.modules.Module +import org.jetbrains.kotlin.modules.TargetId import org.jetbrains.kotlin.progress.CompilationCanceledException import org.jetbrains.kotlin.progress.CompilationCanceledStatus import org.jetbrains.kotlin.resolve.jvm.JvmClassName @@ -320,8 +320,8 @@ public class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR } return compileToJvm(allCompiledFiles, chunk, commonArguments, context, dirtyFilesHolder, environment, - incrementalCaches.mapKeysTo(HashMap(incrementalCaches.size()), - { ModuleToModuleBuildTargetAdapter(it.getKey()) }), + incrementalCaches.mapKeysTo(HashMap(incrementalCaches.size()), + { TargetId(it.getKey()) }), filesToCompile, messageCollector) } @@ -346,7 +346,7 @@ public class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR || className.startsWith("org.apache.log4j.") // For logging from compiler || className == "org.jetbrains.kotlin.progress.CompilationCanceledStatus" || className == "org.jetbrains.kotlin.progress.CompilationCanceledException" - || className == "org.jetbrains.kotlin.modules.Module" + || className == "org.jetbrains.kotlin.modules.TargetId" }, compilerServices ) @@ -488,7 +488,7 @@ public class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR private fun compileToJs(chunk: ModuleChunk, commonArguments: CommonCompilerArguments, environment: CompilerEnvironment, - incrementalCaches: MutableMap?, + incrementalCaches: MutableMap?, messageCollector: MessageCollectorAdapter, project: JpsProject ): OutputItemsCollectorImpl? { val outputItemCollector = OutputItemsCollectorImpl() @@ -543,7 +543,7 @@ public class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR context: CompileContext, dirtyFilesHolder: DirtyFilesHolder, environment: CompilerEnvironment, - incrementalCaches: MutableMap?, + incrementalCaches: MutableMap?, filesToCompile: MultiMap, messageCollector: MessageCollectorAdapter ): OutputItemsCollectorImpl? { val outputItemCollector = OutputItemsCollectorImpl() diff --git a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/IncrementalCompilationComponentsImpl.kt b/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/IncrementalCompilationComponentsImpl.kt index 850d9646f41..940313a74c1 100644 --- a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/IncrementalCompilationComponentsImpl.kt +++ b/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/IncrementalCompilationComponentsImpl.kt @@ -20,42 +20,16 @@ import org.jetbrains.jps.incremental.ModuleBuildTarget import org.jetbrains.kotlin.incremental.components.LookupTracker import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCache import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCompilationComponents -import org.jetbrains.kotlin.modules.Module +import org.jetbrains.kotlin.modules.TargetId public class IncrementalCompilationComponentsImpl( caches: Map, private val lookupTracker: LookupTracker ): IncrementalCompilationComponents { - private val caches = caches.mapKeys { ModuleToModuleBuildTargetAdapter(it.key) } + private val caches = caches.mapKeys { TargetId(it.key) } - override fun getIncrementalCache(target: Module): IncrementalCache = + override fun getIncrementalCache(target: TargetId): IncrementalCache = caches[target]!! override fun getLookupTracker(): LookupTracker = lookupTracker } - -public class ModuleToModuleBuildTargetAdapter( - private val moduleBuildTarget: ModuleBuildTarget -) : Module { - - override fun getModuleName(): String = - moduleBuildTarget.id - - override fun getModuleType(): String = - moduleBuildTarget.targetType.typeId - - override fun getAnnotationsRoots(): List = - throw UnsupportedOperationException() - - override fun getClasspathRoots(): List = - throw UnsupportedOperationException() - - override fun getJavaSourceRoots(): List = - throw UnsupportedOperationException() - - override fun getOutputDirectory(): String = - throw UnsupportedOperationException() - - override fun getSourceFiles(): List = - throw UnsupportedOperationException() -} diff --git a/jps-plugin/src/org/jetbrains/kotlin/modules/modulesUtil.kt b/jps-plugin/src/org/jetbrains/kotlin/modules/modulesUtil.kt new file mode 100644 index 00000000000..a972911e445 --- /dev/null +++ b/jps-plugin/src/org/jetbrains/kotlin/modules/modulesUtil.kt @@ -0,0 +1,22 @@ +/* + * Copyright 2010-2015 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.modules + +import org.jetbrains.jps.incremental.ModuleBuildTarget + +public fun TargetId(moduleBuildTarget: ModuleBuildTarget): TargetId = + TargetId(moduleBuildTarget.id, moduleBuildTarget.targetType.typeId)