Merging callback services into single facade - phase 2 - rewriting interfaces and implementations

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<TargetId, RemoteIncrementalCacheServer>()
-    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<String> = cache.getObsoletePackageParts()
-
-    override fun getObsoleteMultifileClassFacades(): Collection<String> = cache.getObsoleteMultifileClasses()
-
-    override fun getMultifileFacadeParts(internalName: String): Collection<String>? = 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<String> = incrementalCompilationComponents!!.getIncrementalCache(target).getObsoletePackageParts()
+
+    override fun incrementalCache_getObsoleteMultifileClassFacades(target: TargetId): Collection<String> = incrementalCompilationComponents!!.getIncrementalCache(target).getObsoleteMultifileClasses()
+
+    override fun incrementalCache_getMultifileFacadeParts(target: TargetId, internalName: String): Collection<String>? = 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()
-    }
-}

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 String>, 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<TargetId, RemoteIncrementalCacheServer>()
+        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()
                 }
             }

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<out String>,
-            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<out String>,
-            services: RemoteCompilationServices,
+            servicesFacade: CompilerCallbackServicesFacade,
             compilerOutputStream: RemoteOutputStream,
             compilerOutputFormat: OutputFormat,
             serviceOutputStream: RemoteOutputStream

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<String>
+ * 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 <entityName>_ is used for every function belonging to the entity
+ */
+public interface CompilerCallbackServicesFacade : Remote {
 
     @Throws(RemoteException::class)
-    public fun getObsoleteMultifileClassFacades(): Collection<String>
+    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<String>
 
     @Throws(RemoteException::class)
-    public fun getModuleMappingData(): ByteArray?
+    public fun incrementalCache_getObsoleteMultifileClassFacades(target: TargetId): Collection<String>
 
     @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<String>?
+    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<String>?
+
+    // ----------------------------------------------------
+    // 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
-

compiler/rmi/rmi-server/src/org/jetbrains/kotlin/rmi/service/CompileServiceImpl.kt

@@ -59,7 +59,7 @@ class CompileServiceImpl<Compiler: CLICompiler<*>>(
     }
 
     override fun remoteCompile(args: Array<out String>,
-                               services: RemoteCompilationServices,
+                               servicesFacade: CompilerCallbackServicesFacade,
                                compilerOutputStream: RemoteOutputStream,
                                outputFormat: CompileService.OutputFormat,
                                serviceOutputStream: RemoteOutputStream
@@ -67,12 +67,12 @@ class CompileServiceImpl<Compiler: CLICompiler<*>>(
             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<out String>,
-                                          services: RemoteCompilationServices,
+                                          servicesFacade: CompilerCallbackServicesFacade,
                                           compilerOutputStream: RemoteOutputStream,
                                           compilerOutputFormat: CompileService.OutputFormat,
                                           serviceOutputStream: RemoteOutputStream
@@ -80,7 +80,7 @@ class CompileServiceImpl<Compiler: CLICompiler<*>>(
             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<Compiler: CLICompiler<*>>(
                 }
             }
 
-    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)) }
+        if (facade.hasIncrementalCaches() || facade.hasLookupTracker()) {
-        services.compilationCanceledStatus?.let { builder.register(CompilationCanceledStatus::class.java, RemoteCompilationCanceledStatusClient(it, rpcProfiler)) }
+            builder.register(IncrementalCompilationComponents::class.java, RemoteIncrementalCompilationComponentsClient(facade, rpcProfiler))
+        }
+        if (facade.hasCompilationCanceledStatus()) {
+            builder.register(CompilationCanceledStatus::class.java, RemoteCompilationCanceledStatusClient(facade, rpcProfiler))
+        }
         return builder.build()
     }
 

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() }
     }
 }

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<String> = profiler.withMeasure(this) { cache.getObsoletePackageParts() }
+    override fun getObsoletePackageParts(): Collection<String> = profiler.withMeasure(this) { facade.incrementalCache_getObsoletePackageParts(target) }
 
-    override fun getObsoleteMultifileClasses(): Collection<String> = profiler.withMeasure(this) { cache.getObsoleteMultifileClassFacades() }
+    override fun getObsoleteMultifileClasses(): Collection<String> = profiler.withMeasure(this) { facade.incrementalCache_getObsoleteMultifileClassFacades(target) }
 
-    override fun getStableMultifileFacadeParts(facadeInternalName: String): Collection<String>? = profiler.withMeasure(this) { cache.getMultifileFacadeParts(facadeInternalName) }
+    override fun getStableMultifileFacadeParts(facadeInternalName: String): Collection<String>? = 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) }
 }

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)
 }

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)
             }
         }
     }