Provide API to get frontend services from plugin code via resoltion facade

API to create ide-side services using frontend services (for now "ide services" cannot be injected into other ide services)

compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt

@@ -70,7 +70,7 @@ public fun StorageComponentContainer.configureJavaTopDownAnalysis(moduleContentS
 public fun createContainerForLazyResolveWithJava(
         moduleContext: ModuleContext, bindingTrace: BindingTrace, declarationProviderFactory: DeclarationProviderFactory,
         moduleContentScope: GlobalSearchScope, moduleClassResolver: ModuleClassResolver, targetEnvironment: TargetEnvironment = CompilerEnvironment
-): Pair<ResolveSession, JavaDescriptorResolver> = createContainer("LazyResolveWithJava") {
+): ComponentProvider = createContainer("LazyResolveWithJava") {
     configureModule(moduleContext, JvmPlatform, bindingTrace)
     configureJavaTopDownAnalysis(moduleContentScope, moduleContext.project, LookupTracker.DO_NOTHING)
 
@@ -82,10 +82,8 @@ public fun createContainerForLazyResolveWithJava(
 
     useImpl<FileScopeProviderImpl>()
     useImpl<LazyResolveToken>()
-}.let {
-    it.javaAnalysisInit()
-
-    Pair(it.get<ResolveSession>(), it.get<JavaDescriptorResolver>())
+}.apply {
+    javaAnalysisInit()
 }
 
 

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmAnalyzerFacade.kt

@@ -19,9 +19,9 @@ package org.jetbrains.kotlin.resolve.jvm
 import com.intellij.openapi.project.Project
 import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.analyzer.*
+import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.descriptors.ModuleParameters
-import org.jetbrains.kotlin.descriptors.PackageFragmentProvider
 import org.jetbrains.kotlin.descriptors.impl.CompositePackageFragmentProvider
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.extensions.ExternalDeclarationsProvider
@@ -36,18 +36,12 @@ import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
 import java.util.ArrayList
 import kotlin.platform.platformStatic
 
-public class JvmResolverForModule(
-        override val lazyResolveSession: ResolveSession,
-        override val packageFragmentProvider: PackageFragmentProvider,
-        public val javaDescriptorResolver: JavaDescriptorResolver
-) : ResolverForModule
-
 public class JvmPlatformParameters(
         public val moduleByJavaClass: (JavaClass) -> ModuleInfo
 ) : PlatformAnalysisParameters
 
 
-public object JvmAnalyzerFacade : AnalyzerFacade<JvmResolverForModule, JvmPlatformParameters> {
+public object JvmAnalyzerFacade : AnalyzerFacade<JvmPlatformParameters> {
     override fun <M : ModuleInfo> createResolverForModule(
             moduleInfo: M,
             moduleDescriptor: ModuleDescriptorImpl,
@@ -55,8 +49,8 @@ public object JvmAnalyzerFacade : AnalyzerFacade<JvmResolverForModule, JvmPlatfo
             moduleContent: ModuleContent,
             platformParameters: JvmPlatformParameters,
             targetEnvironment: TargetEnvironment,
-            resolverForProject: ResolverForProject<M, JvmResolverForModule>
-    ): JvmResolverForModule {
+            resolverForProject: ResolverForProject<M>
+    ): ResolverForModule {
         val (syntheticFiles, moduleContentScope) = moduleContent
         val project = moduleContext.project
         val filesToAnalyze = getAllFilesToAnalyze(project, moduleInfo, syntheticFiles)
@@ -67,9 +61,9 @@ public object JvmAnalyzerFacade : AnalyzerFacade<JvmResolverForModule, JvmPlatfo
 
         val moduleClassResolver = ModuleClassResolverImpl { javaClass ->
             val moduleInfo = platformParameters.moduleByJavaClass(javaClass)
-            resolverForProject.resolverForModule(moduleInfo as M).javaDescriptorResolver
+            resolverForProject.resolverForModule(moduleInfo as M).componentProvider.get<JavaDescriptorResolver>()
         }
-        val (resolveSession, javaDescriptorResolver) = createContainerForLazyResolveWithJava(
+        val container = createContainerForLazyResolveWithJava(
                 moduleContext,
                 CodeAnalyzerInitializer.getInstance(project).createTrace(),
                 declarationProviderFactory,
@@ -77,9 +71,11 @@ public object JvmAnalyzerFacade : AnalyzerFacade<JvmResolverForModule, JvmPlatfo
                 moduleClassResolver,
                 targetEnvironment
         )
+        val resolveSession = container.get<ResolveSession>()
+        val javaDescriptorResolver = container.get<JavaDescriptorResolver>()
 
         val providersForModule = listOf(resolveSession.getPackageFragmentProvider(), javaDescriptorResolver.packageFragmentProvider)
-        return JvmResolverForModule(resolveSession, CompositePackageFragmentProvider(providersForModule), javaDescriptorResolver)
+        return ResolverForModule(CompositePackageFragmentProvider(providersForModule), container)
     }
 
     override val moduleParameters: ModuleParameters