diff --git a/compiler/rmi/kotlinr/src/org/jetbrains/kotlin/rmi/kotlinr/CompilerCallbackServicesFacadeServer.kt b/compiler/rmi/kotlinr/src/org/jetbrains/kotlin/rmi/kotlinr/CompilerCallbackServicesFacadeServer.kt index fe56e6dfbb3..964d1f306e3 100644 --- a/compiler/rmi/kotlinr/src/org/jetbrains/kotlin/rmi/kotlinr/CompilerCallbackServicesFacadeServer.kt +++ b/compiler/rmi/kotlinr/src/org/jetbrains/kotlin/rmi/kotlinr/CompilerCallbackServicesFacadeServer.kt @@ -18,89 +18,69 @@ package org.jetbrains.kotlin.rmi.kotlinr import org.jetbrains.kotlin.incremental.components.LookupTracker import org.jetbrains.kotlin.incremental.components.ScopeKind -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.JvmPackagePartProto import org.jetbrains.kotlin.modules.TargetId import org.jetbrains.kotlin.progress.CompilationCanceledStatus -import org.jetbrains.kotlin.rmi.* +import org.jetbrains.kotlin.rmi.CompilerCallbackServicesFacade +import org.jetbrains.kotlin.rmi.LoopbackNetworkInterface +import org.jetbrains.kotlin.rmi.SOCKET_ANY_FREE_PORT import java.rmi.server.UnicastRemoteObject -public class RemoteIncrementalCompilationComponentsServer(val base: IncrementalCompilationComponents, val port: Int = SOCKET_ANY_FREE_PORT) : RemoteIncrementalCompilationComponents { + +public class CompilerCallbackServicesFacadeServer( + val incrementalCompilationComponents: IncrementalCompilationComponents? = null, + val compilationCancelledStatus: CompilationCanceledStatus? = null, + port: Int = SOCKET_ANY_FREE_PORT +) : CompilerCallbackServicesFacade { init { UnicastRemoteObject.exportObject(this, port, LoopbackNetworkInterface.clientLoopbackSocketFactory, LoopbackNetworkInterface.serverLoopbackSocketFactory) } - private val cacheServers = hashMapOf() - private val lookupTrackerServer by lazy { RemoteLookupTrackerServer(base.getLookupTracker()) } - - override fun getIncrementalCache(target: TargetId): RemoteIncrementalCache = - cacheServers.get(target) ?: { - val newServer = RemoteIncrementalCacheServer(base.getIncrementalCache(target), port) - cacheServers.put(target, newServer) - newServer - }() - - override fun getLookupTracker(): RemoteLookupTracker = lookupTrackerServer -} - - -public class RemoteIncrementalCacheServer(val cache: IncrementalCache, port: Int = SOCKET_ANY_FREE_PORT) : RemoteIncrementalCache { - - init { - UnicastRemoteObject.exportObject(this, port, LoopbackNetworkInterface.clientLoopbackSocketFactory, LoopbackNetworkInterface.serverLoopbackSocketFactory) - } - - override fun getObsoletePackageParts(): Collection = cache.getObsoletePackageParts() - - override fun getObsoleteMultifileClassFacades(): Collection = cache.getObsoleteMultifileClasses() - - override fun getMultifileFacadeParts(internalName: String): Collection? = cache.getStableMultifileFacadeParts(internalName) - - override fun getMultifileFacade(partInternalName: String): String? = cache.getMultifileFacade(partInternalName) - - override fun getPackagePartData(fqName: String): JvmPackagePartProto? = cache.getPackagePartData(fqName) - - override fun getModuleMappingData(): ByteArray? = cache.getModuleMappingData() - - override fun registerInline(fromPath: String, jvmSignature: String, toPath: String) { - cache.registerInline(fromPath, jvmSignature, toPath) - } - - override fun getClassFilePath(internalClassName: String): String = cache.getClassFilePath(internalClassName) - - override fun close() { - cache.close() - } - public fun disconnect() { UnicastRemoteObject.unexportObject(this, true) } + + override fun hasIncrementalCaches(): Boolean = incrementalCompilationComponents != null + + override fun hasLookupTracker(): Boolean = incrementalCompilationComponents != null + + override fun hasCompilationCanceledStatus(): Boolean = compilationCancelledStatus != null + + // TODO: consider replacing NPE with other reporting, although NPE here means most probably incorrect usage + + override fun incrementalCache_getObsoletePackageParts(target: TargetId): Collection = incrementalCompilationComponents!!.getIncrementalCache(target).getObsoletePackageParts() + + override fun incrementalCache_getObsoleteMultifileClassFacades(target: TargetId): Collection = incrementalCompilationComponents!!.getIncrementalCache(target).getObsoleteMultifileClasses() + + override fun incrementalCache_getMultifileFacadeParts(target: TargetId, internalName: String): Collection? = incrementalCompilationComponents!!.getIncrementalCache(target).getStableMultifileFacadeParts(internalName) + + override fun incrementalCache_getMultifileFacade(target: TargetId, partInternalName: String): String? = incrementalCompilationComponents!!.getIncrementalCache(target).getMultifileFacade(partInternalName) + + override fun incrementalCache_getPackagePartData(target: TargetId, fqName: String): JvmPackagePartProto? = incrementalCompilationComponents!!.getIncrementalCache(target).getPackagePartData(fqName) + + override fun incrementalCache_getModuleMappingData(target: TargetId): ByteArray? = incrementalCompilationComponents!!.getIncrementalCache(target).getModuleMappingData() + + override fun incrementalCache_registerInline(target: TargetId, fromPath: String, jvmSignature: String, toPath: String) { + incrementalCompilationComponents!!.getIncrementalCache(target).registerInline(fromPath, jvmSignature, toPath) + } + + override fun incrementalCache_getClassFilePath(target: TargetId, internalClassName: String): String = incrementalCompilationComponents!!.getIncrementalCache(target).getClassFilePath(internalClassName) + + override fun incrementalCache_close(target: TargetId) { + incrementalCompilationComponents!!.getIncrementalCache(target).close() + } + + override fun lookupTracker_record(lookupContainingFile: String, lookupLine: Int?, lookupColumn: Int?, scopeFqName: String, scopeKind: ScopeKind, name: String) { + incrementalCompilationComponents!!.getLookupTracker().record(lookupContainingFile, lookupLine, lookupColumn, scopeFqName, scopeKind, name) + } + + private val lookupTracker_isDoNothing: Boolean = incrementalCompilationComponents != null && incrementalCompilationComponents.getLookupTracker() == LookupTracker.DO_NOTHING + + override fun lookupTracker_isDoNothing(): Boolean = lookupTracker_isDoNothing + + override fun compilationCanceledStatus_checkCanceled() { + compilationCancelledStatus!!.checkCanceled() + } } - -public class RemoteLookupTrackerServer(val base: LookupTracker, port: Int = SOCKET_ANY_FREE_PORT) : RemoteLookupTracker { - - init { - UnicastRemoteObject.exportObject(this, port, LoopbackNetworkInterface.clientLoopbackSocketFactory, LoopbackNetworkInterface.serverLoopbackSocketFactory) - } - - override fun record(lookupContainingFile: String, lookupLine: Int?, lookupColumn: Int?, scopeFqName: String, scopeKind: ScopeKind, name: String) { - base.record(lookupContainingFile, lookupLine, lookupColumn, scopeFqName, scopeKind, name) - } - - private val _isDoNothing: Boolean = base == LookupTracker.DO_NOTHING - override fun isDoNothing(): Boolean = _isDoNothing -} - - -public class RemoteCompilationCanceledStatusServer(val base: CompilationCanceledStatus, port: Int = SOCKET_ANY_FREE_PORT) : RemoteCompilationCanceledStatus { - - init { - UnicastRemoteObject.exportObject(this, port, LoopbackNetworkInterface.clientLoopbackSocketFactory, LoopbackNetworkInterface.serverLoopbackSocketFactory) - } - - override fun checkCanceled() { - base.checkCanceled() - } -} \ No newline at end of file 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 967b7573566..826e4b1284b 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 @@ -114,10 +114,12 @@ public object KotlinCompilerClient { public fun compile(compiler: CompileService, args: Array, out: OutputStream): Int { val outStrm = RemoteOutputStreamServer(out) + val servicesFacade = CompilerCallbackServicesFacadeServer() try { - return compiler.remoteCompile(args, makeRemoteServices(CompilationServices()), outStrm, CompileService.OutputFormat.PLAIN, outStrm) + return compiler.remoteCompile(args, servicesFacade, outStrm, CompileService.OutputFormat.PLAIN, outStrm) } finally { + servicesFacade.disconnect() outStrm.disconnect() } } @@ -127,24 +129,17 @@ public object KotlinCompilerClient { val compilerOutStreamServer = RemoteOutputStreamServer(compilerOut) val daemonOutStreamServer = RemoteOutputStreamServer(daemonOut) - val cacheServers = hashMapOf() + val servicesFacade = CompilerCallbackServicesFacadeServer(incrementalCompilationComponents = services.incrementalCompilationComponents, compilationCancelledStatus = services.compilationCanceledStatus) try { - return profiler.withMeasure(this) { compiler.remoteIncrementalCompile(args, makeRemoteServices(services), compilerOutStreamServer, CompileService.OutputFormat.XML, daemonOutStreamServer) } + return profiler.withMeasure(this) { compiler.remoteIncrementalCompile(args, servicesFacade, compilerOutStreamServer, CompileService.OutputFormat.XML, daemonOutStreamServer) } } finally { - cacheServers.forEach { it.getValue().disconnect() } + servicesFacade.disconnect() compilerOutStreamServer.disconnect() daemonOutStreamServer.disconnect() } } - - fun makeRemoteServices(services: CompilationServices): RemoteCompilationServices = - RemoteCompilationServices( - incrementalCompilationComponents = if (services.incrementalCompilationComponents == null) null else RemoteIncrementalCompilationComponentsServer(services.incrementalCompilationComponents), - compilationCanceledStatus = if (services.compilationCanceledStatus == null) null else RemoteCompilationCanceledStatusServer(services.compilationCanceledStatus) - ) - data class ClientOptions( public var stop: Boolean = false ) : OptionsGroup { @@ -202,11 +197,12 @@ public object KotlinCompilerClient { else -> { println("Executing daemon compilation with args: " + filteredArgs.joinToString(" ")) val outStrm = RemoteOutputStreamServer(System.out) + val servicesFacade = CompilerCallbackServicesFacadeServer() try { val memBefore = daemon.getUsedMemory() / 1024 val startTime = System.nanoTime() - val res = daemon.remoteCompile(filteredArgs.toArrayList().toTypedArray(), makeRemoteServices(CompilationServices()), outStrm, CompileService.OutputFormat.PLAIN, outStrm) + val res = daemon.remoteCompile(filteredArgs.toArrayList().toTypedArray(), servicesFacade, outStrm, CompileService.OutputFormat.PLAIN, outStrm) val endTime = System.nanoTime() println("Compilation result code: $res") @@ -215,6 +211,7 @@ public object KotlinCompilerClient { println("Used memory $memAfter (${"%+d".format(memAfter - memBefore)} kb)") } finally { + servicesFacade.disconnect() outStrm.disconnect() } } 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 194c322a4a8..77d8cf25c0e 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 @@ -38,7 +38,7 @@ public interface CompileService : Remote { @Throws(RemoteException::class) public fun remoteCompile( args: Array, - services: RemoteCompilationServices, + servicesFacade: CompilerCallbackServicesFacade, compilerOutputStream: RemoteOutputStream, outputFormat: OutputFormat, serviceOutputStream: RemoteOutputStream @@ -47,7 +47,7 @@ public interface CompileService : Remote { @Throws(RemoteException::class) public fun remoteIncrementalCompile( args: Array, - services: RemoteCompilationServices, + servicesFacade: CompilerCallbackServicesFacade, compilerOutputStream: RemoteOutputStream, compilerOutputFormat: OutputFormat, serviceOutputStream: RemoteOutputStream diff --git a/compiler/rmi/rmi-interface/src/org/jetbrains/kotlin/rmi/CompilerCallbackServicesFacade.kt b/compiler/rmi/rmi-interface/src/org/jetbrains/kotlin/rmi/CompilerCallbackServicesFacade.kt index 30667fe2060..b51a1d917a2 100644 --- a/compiler/rmi/rmi-interface/src/org/jetbrains/kotlin/rmi/CompilerCallbackServicesFacade.kt +++ b/compiler/rmi/rmi-interface/src/org/jetbrains/kotlin/rmi/CompilerCallbackServicesFacade.kt @@ -19,42 +19,59 @@ package org.jetbrains.kotlin.rmi import org.jetbrains.kotlin.incremental.components.ScopeKind import org.jetbrains.kotlin.load.kotlin.incremental.components.JvmPackagePartProto import org.jetbrains.kotlin.modules.TargetId -import java.io.Serializable import java.rmi.Remote import java.rmi.RemoteException -public interface RemoteIncrementalCache : Remote { - @Throws(RemoteException::class) - public fun getObsoletePackageParts(): Collection + +/** + * common facade for compiler services exposed from client process (e.g. JPS) to the compiler running on daemon + * the reason for having common facade is attempt to reduce number of connections between client and daemon + * Note: non-standard naming convention used to denote combining several entities in one facade - prefix _ is used for every function belonging to the entity + */ +public interface CompilerCallbackServicesFacade : Remote { @Throws(RemoteException::class) - public fun getObsoleteMultifileClassFacades(): Collection + public fun hasIncrementalCaches(): Boolean @Throws(RemoteException::class) - public fun getMultifileFacade(partInternalName: String): String? + public fun hasLookupTracker(): Boolean @Throws(RemoteException::class) - public fun getPackagePartData(fqName: String): JvmPackagePartProto? + public fun hasCompilationCanceledStatus(): Boolean + + // ---------------------------------------------------- + // IncrementalCache + @Throws(RemoteException::class) + public fun incrementalCache_getObsoletePackageParts(target: TargetId): Collection @Throws(RemoteException::class) - public fun getModuleMappingData(): ByteArray? + public fun incrementalCache_getObsoleteMultifileClassFacades(target: TargetId): Collection @Throws(RemoteException::class) - public fun registerInline(fromPath: String, jvmSignature: String, toPath: String) + public fun incrementalCache_getMultifileFacade(target: TargetId, partInternalName: String): String? @Throws(RemoteException::class) - fun getClassFilePath(internalClassName: String): String + public fun incrementalCache_getPackagePartData(target: TargetId, fqName: String): JvmPackagePartProto? @Throws(RemoteException::class) - public fun close() + public fun incrementalCache_getModuleMappingData(target: TargetId): ByteArray? @Throws(RemoteException::class) - public fun getMultifileFacadeParts(internalName: String): Collection? -} + public fun incrementalCache_registerInline(target: TargetId, fromPath: String, jvmSignature: String, toPath: String) -public interface RemoteLookupTracker : Remote { @Throws(RemoteException::class) - fun record( + fun incrementalCache_getClassFilePath(target: TargetId, internalClassName: String): String + + @Throws(RemoteException::class) + public fun incrementalCache_close(target: TargetId) + + @Throws(RemoteException::class) + public fun incrementalCache_getMultifileFacadeParts(target: TargetId, internalName: String): Collection? + + // ---------------------------------------------------- + // LookupTracker + @Throws(RemoteException::class) + fun lookupTracker_record( lookupContainingFile: String, lookupLine: Int?, lookupColumn: Int?, @@ -62,25 +79,13 @@ public interface RemoteLookupTracker : Remote { scopeKind: ScopeKind, name: String ) + @Throws(RemoteException::class) - fun isDoNothing(): Boolean + fun lookupTracker_isDoNothing(): Boolean + + // ---------------------------------------------------- + // CompilationCanceledStatus + @Throws(RemoteException::class) + fun compilationCanceledStatus_checkCanceled(): Unit } -public interface RemoteIncrementalCompilationComponents : Remote { - @Throws(RemoteException::class) - public fun getIncrementalCache(target: TargetId): RemoteIncrementalCache - - @Throws(RemoteException::class) - public fun getLookupTracker(): RemoteLookupTracker -} - -public interface RemoteCompilationCanceledStatus : Remote { - @Throws(RemoteException::class) - fun checkCanceled(): Unit -} - -public data class RemoteCompilationServices( - public val incrementalCompilationComponents: RemoteIncrementalCompilationComponents? = null, - public val compilationCanceledStatus: RemoteCompilationCanceledStatus? = null -) : Serializable - 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 40b8148d4af..9ffcf44d214 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 @@ -59,7 +59,7 @@ class CompileServiceImpl>( } override fun remoteCompile(args: Array, - services: RemoteCompilationServices, + servicesFacade: CompilerCallbackServicesFacade, compilerOutputStream: RemoteOutputStream, outputFormat: CompileService.OutputFormat, serviceOutputStream: RemoteOutputStream @@ -67,12 +67,12 @@ class CompileServiceImpl>( doCompile(args, compilerOutputStream, serviceOutputStream) { printStream, profiler -> when (outputFormat) { CompileService.OutputFormat.PLAIN -> compiler.exec(printStream, *args) - CompileService.OutputFormat.XML -> compiler.execAndOutputXml(printStream, createCompileServices(services, profiler), *args) + CompileService.OutputFormat.XML -> compiler.execAndOutputXml(printStream, createCompileServices(servicesFacade, profiler), *args) } } override fun remoteIncrementalCompile(args: Array, - services: RemoteCompilationServices, + servicesFacade: CompilerCallbackServicesFacade, compilerOutputStream: RemoteOutputStream, compilerOutputFormat: CompileService.OutputFormat, serviceOutputStream: RemoteOutputStream @@ -80,7 +80,7 @@ class CompileServiceImpl>( doCompile(args, compilerOutputStream, serviceOutputStream) { printStream, profiler -> when (compilerOutputFormat) { CompileService.OutputFormat.PLAIN -> throw NotImplementedError("Only XML output is supported in remote incremental compilation") - CompileService.OutputFormat.XML -> compiler.execAndOutputXml(printStream, createCompileServices(services, profiler), *args) + CompileService.OutputFormat.XML -> compiler.execAndOutputXml(printStream, createCompileServices(servicesFacade, profiler), *args) } } @@ -134,10 +134,14 @@ class CompileServiceImpl>( } } - private fun createCompileServices(services: RemoteCompilationServices, rpcProfiler: Profiler): Services { + private fun createCompileServices(facade: CompilerCallbackServicesFacade, rpcProfiler: Profiler): Services { val builder = Services.Builder() - services.incrementalCompilationComponents?.let { builder.register(IncrementalCompilationComponents::class.java, RemoteIncrementalCompilationComponentsClient(it, rpcProfiler)) } - services.compilationCanceledStatus?.let { builder.register(CompilationCanceledStatus::class.java, RemoteCompilationCanceledStatusClient(it, rpcProfiler)) } + if (facade.hasIncrementalCaches() || facade.hasLookupTracker()) { + builder.register(IncrementalCompilationComponents::class.java, RemoteIncrementalCompilationComponentsClient(facade, rpcProfiler)) + } + if (facade.hasCompilationCanceledStatus()) { + builder.register(CompilationCanceledStatus::class.java, RemoteCompilationCanceledStatusClient(facade, rpcProfiler)) + } return builder.build() } diff --git a/compiler/rmi/rmi-server/src/org/jetbrains/kotlin/rmi/service/RemoteCompilationCanceledStatusClient.kt b/compiler/rmi/rmi-server/src/org/jetbrains/kotlin/rmi/service/RemoteCompilationCanceledStatusClient.kt index 679266e11bf..056aa640b89 100644 --- a/compiler/rmi/rmi-server/src/org/jetbrains/kotlin/rmi/service/RemoteCompilationCanceledStatusClient.kt +++ b/compiler/rmi/rmi-server/src/org/jetbrains/kotlin/rmi/service/RemoteCompilationCanceledStatusClient.kt @@ -17,13 +17,13 @@ package org.jetbrains.kotlin.rmi.service import org.jetbrains.kotlin.progress.CompilationCanceledStatus +import org.jetbrains.kotlin.rmi.CompilerCallbackServicesFacade import org.jetbrains.kotlin.rmi.DummyProfiler import org.jetbrains.kotlin.rmi.Profiler -import org.jetbrains.kotlin.rmi.RemoteCompilationCanceledStatus -class RemoteCompilationCanceledStatusClient(val proxy: RemoteCompilationCanceledStatus, val profiler: Profiler = DummyProfiler()): CompilationCanceledStatus { +class RemoteCompilationCanceledStatusClient(val facade: CompilerCallbackServicesFacade, val profiler: Profiler = DummyProfiler()): CompilationCanceledStatus { override fun checkCanceled() { - profiler.withMeasure(this) { proxy.checkCanceled() } + profiler.withMeasure(this) { facade.compilationCanceledStatus_checkCanceled() } } } diff --git a/compiler/rmi/rmi-server/src/org/jetbrains/kotlin/rmi/service/RemoteIncrementalCacheClient.kt b/compiler/rmi/rmi-server/src/org/jetbrains/kotlin/rmi/service/RemoteIncrementalCacheClient.kt index f3b68895c16..bd2e749c76f 100644 --- a/compiler/rmi/rmi-server/src/org/jetbrains/kotlin/rmi/service/RemoteIncrementalCacheClient.kt +++ b/compiler/rmi/rmi-server/src/org/jetbrains/kotlin/rmi/service/RemoteIncrementalCacheClient.kt @@ -18,29 +18,30 @@ package org.jetbrains.kotlin.rmi.service import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCache import org.jetbrains.kotlin.load.kotlin.incremental.components.JvmPackagePartProto +import org.jetbrains.kotlin.modules.TargetId +import org.jetbrains.kotlin.rmi.CompilerCallbackServicesFacade import org.jetbrains.kotlin.rmi.DummyProfiler import org.jetbrains.kotlin.rmi.Profiler -import org.jetbrains.kotlin.rmi.RemoteIncrementalCache -public class RemoteIncrementalCacheClient(val cache: RemoteIncrementalCache, val profiler: Profiler = DummyProfiler()): IncrementalCache { +public class RemoteIncrementalCacheClient(val facade: CompilerCallbackServicesFacade, val target: TargetId, val profiler: Profiler = DummyProfiler()): IncrementalCache { - override fun getObsoletePackageParts(): Collection = profiler.withMeasure(this) { cache.getObsoletePackageParts() } + override fun getObsoletePackageParts(): Collection = profiler.withMeasure(this) { facade.incrementalCache_getObsoletePackageParts(target) } - override fun getObsoleteMultifileClasses(): Collection = profiler.withMeasure(this) { cache.getObsoleteMultifileClassFacades() } + override fun getObsoleteMultifileClasses(): Collection = profiler.withMeasure(this) { facade.incrementalCache_getObsoleteMultifileClassFacades(target) } - override fun getStableMultifileFacadeParts(facadeInternalName: String): Collection? = profiler.withMeasure(this) { cache.getMultifileFacadeParts(facadeInternalName) } + override fun getStableMultifileFacadeParts(facadeInternalName: String): Collection? = profiler.withMeasure(this) { facade.incrementalCache_getMultifileFacadeParts(target, facadeInternalName) } - override fun getPackagePartData(fqName: String): JvmPackagePartProto? = profiler.withMeasure(this) { cache.getPackagePartData(fqName) } + override fun getPackagePartData(fqName: String): JvmPackagePartProto? = profiler.withMeasure(this) { facade.incrementalCache_getPackagePartData(target, fqName) } - override fun getMultifileFacade(partInternalName: String): String? = profiler.withMeasure(this) { cache.getMultifileFacade(partInternalName) } + override fun getMultifileFacade(partInternalName: String): String? = profiler.withMeasure(this) { facade.incrementalCache_getMultifileFacade(target, partInternalName) } - override fun getModuleMappingData(): ByteArray? = profiler.withMeasure(this) { cache.getModuleMappingData() } + override fun getModuleMappingData(): ByteArray? = profiler.withMeasure(this) { facade.incrementalCache_getModuleMappingData(target) } override fun registerInline(fromPath: String, jvmSignature: String, toPath: String) { - profiler.withMeasure(this) { cache.registerInline(fromPath, jvmSignature, toPath) } + profiler.withMeasure(this) { facade.incrementalCache_registerInline(target, fromPath, jvmSignature, toPath) } } - override fun getClassFilePath(internalClassName: String): String = profiler.withMeasure(this) { cache.getClassFilePath(internalClassName) } + override fun getClassFilePath(internalClassName: String): String = profiler.withMeasure(this) { facade.incrementalCache_getClassFilePath(target,internalClassName) } - override fun close(): Unit = profiler.withMeasure(this) { cache.close() } + override fun close(): Unit = profiler.withMeasure(this) { facade.incrementalCache_close(target) } } diff --git a/compiler/rmi/rmi-server/src/org/jetbrains/kotlin/rmi/service/RemoteIncrementalCompilationComponentsClient.kt b/compiler/rmi/rmi-server/src/org/jetbrains/kotlin/rmi/service/RemoteIncrementalCompilationComponentsClient.kt index 8181421966a..7af286c8327 100644 --- a/compiler/rmi/rmi-server/src/org/jetbrains/kotlin/rmi/service/RemoteIncrementalCompilationComponentsClient.kt +++ b/compiler/rmi/rmi-server/src/org/jetbrains/kotlin/rmi/service/RemoteIncrementalCompilationComponentsClient.kt @@ -20,14 +20,14 @@ 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.TargetId +import org.jetbrains.kotlin.rmi.CompilerCallbackServicesFacade import org.jetbrains.kotlin.rmi.DummyProfiler import org.jetbrains.kotlin.rmi.Profiler -import org.jetbrains.kotlin.rmi.RemoteIncrementalCompilationComponents -class RemoteIncrementalCompilationComponentsClient(val proxy: RemoteIncrementalCompilationComponents, val profiler: Profiler = DummyProfiler()) : IncrementalCompilationComponents { +class RemoteIncrementalCompilationComponentsClient(val facade: CompilerCallbackServicesFacade, val profiler: Profiler = DummyProfiler()) : IncrementalCompilationComponents { - override fun getIncrementalCache(target: TargetId): IncrementalCache = RemoteIncrementalCacheClient(profiler.withMeasure(this) { proxy.getIncrementalCache(target) }, profiler) + override fun getIncrementalCache(target: TargetId): IncrementalCache = RemoteIncrementalCacheClient(facade, target, profiler) - override fun getLookupTracker(): LookupTracker = RemoteLookupTrackerClient(profiler.withMeasure(this) { proxy.getLookupTracker() }, profiler) + override fun getLookupTracker(): LookupTracker = RemoteLookupTrackerClient(facade, profiler) } diff --git a/compiler/rmi/rmi-server/src/org/jetbrains/kotlin/rmi/service/RemoteLookupTrackerClient.kt b/compiler/rmi/rmi-server/src/org/jetbrains/kotlin/rmi/service/RemoteLookupTrackerClient.kt index 40092c01a3f..11fa0eb64c5 100644 --- a/compiler/rmi/rmi-server/src/org/jetbrains/kotlin/rmi/service/RemoteLookupTrackerClient.kt +++ b/compiler/rmi/rmi-server/src/org/jetbrains/kotlin/rmi/service/RemoteLookupTrackerClient.kt @@ -18,19 +18,19 @@ package org.jetbrains.kotlin.rmi.service import org.jetbrains.kotlin.incremental.components.LookupTracker import org.jetbrains.kotlin.incremental.components.ScopeKind +import org.jetbrains.kotlin.rmi.CompilerCallbackServicesFacade import org.jetbrains.kotlin.rmi.DummyProfiler import org.jetbrains.kotlin.rmi.Profiler -import org.jetbrains.kotlin.rmi.RemoteLookupTracker -class RemoteLookupTrackerClient(val proxy: RemoteLookupTracker, val profiler: Profiler = DummyProfiler()) : LookupTracker { +class RemoteLookupTrackerClient(val facade: CompilerCallbackServicesFacade, val profiler: Profiler = DummyProfiler()) : LookupTracker { - private val isDoNothing = profiler.withMeasure(this) { proxy.isDoNothing() } + private val isDoNothing = profiler.withMeasure(this) { facade.lookupTracker_isDoNothing() } override fun record(lookupContainingFile: String, lookupLine: Int?, lookupColumn: Int?, scopeFqName: String, scopeKind: ScopeKind, name: String) { if (!isDoNothing) { profiler.withMeasure(this) { - proxy.record(lookupContainingFile, lookupLine, lookupColumn, scopeFqName, scopeKind, name) + facade.lookupTracker_record(lookupContainingFile, lookupLine, lookupColumn, scopeFqName, scopeKind, name) } } }