Cherry-pick 'analysis_rewrite_1.3.61'

14 files changed, 321 insertions, 353 deletions

diff --git a/.idea/codeStyles/codeStyleConfig.xml b/.idea/codeStyles/codeStyleConfig.xml
index 79ee123c..6e6eec11 100644
--- a/.idea/codeStyles/codeStyleConfig.xml
+++ b/.idea/codeStyles/codeStyleConfig.xml
@@ -1,5 +1,6 @@
 <component name="ProjectCodeStyleConfiguration">
   <state>
     <option name="USE_PER_PROJECT_SETTINGS" value="true" />
+    <option name="PREFERRED_PROJECT_CODE_STYLE" value="Default" />
   </state>
 </component>
\ No newline at end of file
diff --git a/.idea/compiler.xml b/.idea/compiler.xml
index f165d41a..feb731d8 100644
--- a/.idea/compiler.xml
+++ b/.idea/compiler.xml
@@ -58,6 +58,8 @@
       <module name="dokka.runners.gradle-plugin.test" target="1.8" />
       <module name="dokka.runners.maven-plugin.main" target="1.8" />
       <module name="dokka.runners.maven-plugin.test" target="1.8" />
+      <module name="dokka.testApi.main" target="1.8" />
+      <module name="dokka.testApi.test" target="1.8" />
       <module name="fatjar_main" target="1.8" />
       <module name="fatjar_test" target="1.8" />
       <module name="gradle-integration-tests.org.jetbrains.dokka.gradle-integration-tests.main" target="1.8" />
diff --git a/.idea/jarRepositories.xml b/.idea/jarRepositories.xml
index 8e7bd752..b5925b37 100644
--- a/.idea/jarRepositories.xml
+++ b/.idea/jarRepositories.xml
@@ -76,5 +76,15 @@
       <option name="name" value="Google" />
       <option name="url" value="https://dl.google.com/dl/android/maven2/" />
     </remote-repository>
+    <remote-repository>
+      <option name="id" value="maven10" />
+      <option name="name" value="maven10" />
+      <option name="url" value="https://kotlin.bintray.com/kotlin-plugin" />
+    </remote-repository>
+    <remote-repository>
+      <option name="id" value="maven6" />
+      <option name="name" value="maven6" />
+      <option name="url" value="https://teamcity.jetbrains.com/guestAuth/repository/download/Kotlin_dev_CompilerAllPlugins/1.3.61/maven" />
+    </remote-repository>
   </component>
 </project>
\ No newline at end of file
diff --git a/build.gradle b/build.gradle
index 2dfc4e01..35fa8667 100644
--- a/build.gradle
+++ b/build.gradle
@@ -1,5 +1,3 @@
-import org.jetbrains.DependenciesVersionGetter
-
 allprojects {
     ext {
         if (!project.findProperty("dokka_version")) {
@@ -35,6 +33,8 @@ allprojects {
         jcenter()
         mavenCentral()
         mavenLocal()
+        maven { url 'https://kotlin.bintray.com/kotlin-plugin' }
+        maven { url 'https://www.jetbrains.com/intellij-repository/releases' }
         maven { url "https://dl.bintray.com/jetbrains/markdown" }
         maven { url "https://dl.bintray.com/kotlin/kotlin-eap" }
         maven { url "https://dl.bintray.com/kotlin/kotlin-dev" }
@@ -72,6 +72,21 @@ def bintrayPublication(project, List<String> _publications) {
 }
 
 
+configurations {
+    ideaIC
+    intellijCore
+}
+
+repositories {
+    maven { url 'https://kotlin.bintray.com/kotlin-plugin' }
+    maven { url 'https://www.jetbrains.com/intellij-repository/snapshots' }
+    maven { url 'https://www.jetbrains.com/intellij-repository/releases' }
+}
+
+dependencies {
+    intellijCore "com.jetbrains.intellij.idea:intellij-core:$idea_version"
+    ideaIC "com.jetbrains.intellij.idea:ideaIC:$idea_version"
+}
 
 def ideaRT() {
     return zipTree(project.configurations.ideaIC.singleFile).matching ({
@@ -102,30 +117,4 @@ allprojects {
         }
 
     }
-}
-
-ext.ivyrepo = {
-    artifactPattern("https://teamcity.jetbrains.com/guestAuth/repository/download/Kotlin_dev_CompilerAllPlugins/[revision]/internal/[module](.[ext])")
-    artifactPattern("https://teamcity.jetbrains.com/guestAuth/repository/download/Kotlin_dev_CompilerAllPlugins/[revision]/[module](.[ext])")
-    artifactPattern("https://teamcity.jetbrains.com/guestAuth/repository/download/IntelliJMarkdownParser_Build/[revision]/([module]_[ext]/)[module](.[ext])")
-}
-
-repositories {
-    ivy(ivyrepo)
-    maven { url 'https://www.jetbrains.com/intellij-repository/snapshots' }
-    maven { url 'https://www.jetbrains.com/intellij-repository/releases' }
-}
-
-configurations {
-    ideaIC
-    intellijCore
-}
-def versions = DependenciesVersionGetter.getVersions(project, bundled_kotlin_compiler_version)
-
-ext.ideaVersion = versions["idea.build.id"]
-ext.markdownVersion = versions["markdown.build.id"].replace("%20", " ")
-
-dependencies {
-    intellijCore "com.jetbrains.intellij.idea:intellij-core:$ideaVersion"
-    ideaIC "com.jetbrains.intellij.idea:ideaIC:$ideaVersion"
 }
\ No newline at end of file
diff --git a/core/build.gradle b/core/build.gradle
index 31833cf9..a7379595 100644
--- a/core/build.gradle
+++ b/core/build.gradle
@@ -34,10 +34,11 @@ dependencies {
     compile "org.jetbrains.kotlin:kotlin-compiler:$bundled_kotlin_compiler_version"
     compile "org.jetbrains.kotlin:kotlin-script-runtime:$bundled_kotlin_compiler_version"
 
-    compile "org.jetbrains:markdown:$markdownVersion"
+    compile "org.jetbrains:markdown:0.1.41"
 
     compile 'org.jetbrains.kotlinx:kotlinx-html-jvm:0.6.10'
 
+
     //tools.jar
 //    def toolsJar = files(((URLClassLoader) ToolProvider.getSystemToolClassLoader()).getURLs().findAll { it.path.endsWith("jar") })
 //    compileOnly toolsJar
diff --git a/core/src/main/kotlin/analysis/AnalysisEnvironment.kt b/core/src/main/kotlin/analysis/AnalysisEnvironment.kt
index 30a51136..36652242 100644
--- a/core/src/main/kotlin/analysis/AnalysisEnvironment.kt
+++ b/core/src/main/kotlin/analysis/AnalysisEnvironment.kt
@@ -3,8 +3,10 @@ package org.jetbrains.dokka.analysis
 import com.google.common.collect.ImmutableMap
 import com.intellij.core.CoreApplicationEnvironment
 import com.intellij.core.CoreModuleManager
+import com.intellij.mock.MockApplication
 import com.intellij.mock.MockComponentManager
 import com.intellij.openapi.Disposable
+import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.extensions.Extensions
 import com.intellij.openapi.module.Module
 import com.intellij.openapi.module.ModuleManager
@@ -16,15 +18,14 @@ import com.intellij.openapi.util.Disposer
 import com.intellij.openapi.vfs.StandardFileSystems
 import com.intellij.psi.PsiElement
 import com.intellij.psi.search.GlobalSearchScope
-import com.intellij.util.io.URLUtil
 import org.jetbrains.dokka.Platform
 import org.jetbrains.kotlin.analyzer.*
 import org.jetbrains.kotlin.analyzer.common.CommonAnalysisParameters
-import org.jetbrains.kotlin.analyzer.common.CommonAnalyzerFacade
+import org.jetbrains.kotlin.analyzer.common.CommonPlatformAnalyzerServices
+import org.jetbrains.kotlin.analyzer.common.CommonResolverForModuleFactory
 import org.jetbrains.kotlin.builtins.DefaultBuiltIns
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.builtins.jvm.JvmBuiltIns
-import org.jetbrains.kotlin.caches.project.LibraryModuleInfo
 import org.jetbrains.kotlin.caches.resolve.KotlinCacheService
 import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
 import org.jetbrains.kotlin.cli.common.config.ContentRoot
@@ -41,20 +42,36 @@ import org.jetbrains.kotlin.config.*
 import org.jetbrains.kotlin.container.getService
 import org.jetbrains.kotlin.container.tryGetService
 import org.jetbrains.kotlin.context.ProjectContext
+import org.jetbrains.kotlin.context.withModule
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
+import org.jetbrains.kotlin.ide.konan.NativeLibraryInfo
+import org.jetbrains.kotlin.ide.konan.analyzer.NativeResolverForModuleFactory
+import org.jetbrains.kotlin.ide.konan.decompiler.KotlinNativeLoadingMetadataCache
 import org.jetbrains.kotlin.idea.resolve.ResolutionFacade
 import org.jetbrains.kotlin.js.config.JSConfigurationKeys
-import org.jetbrains.kotlin.js.resolve.JsPlatform
+import org.jetbrains.kotlin.js.resolve.JsPlatformAnalyzerServices
+import org.jetbrains.kotlin.js.resolve.JsResolverForModuleFactory
+import org.jetbrains.kotlin.library.impl.createKotlinLibrary
 import org.jetbrains.kotlin.load.java.structure.impl.JavaClassImpl
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.platform.CommonPlatforms
+import org.jetbrains.kotlin.platform.TargetPlatform
+import org.jetbrains.kotlin.platform.js.JsPlatforms
+import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
+import org.jetbrains.kotlin.platform.jvm.JvmPlatforms.unspecifiedJvmPlatform
+import org.jetbrains.kotlin.platform.konan.KonanPlatforms
 import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.resolve.*
+import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.BindingTrace
+import org.jetbrains.kotlin.resolve.CompilerEnvironment
+import org.jetbrains.kotlin.resolve.PlatformDependentAnalyzerServices
 import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics
-import org.jetbrains.kotlin.resolve.jvm.JvmAnalyzerFacade
 import org.jetbrains.kotlin.resolve.jvm.JvmPlatformParameters
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
-import org.jetbrains.kotlin.resolve.konan.platform.KonanPlatform
+import org.jetbrains.kotlin.resolve.jvm.JvmResolverForModuleFactory
+import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatformAnalyzerServices
+import org.jetbrains.kotlin.resolve.konan.platform.NativePlatformAnalyzerServices
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession
 import org.jetbrains.kotlin.types.KotlinType
@@ -62,6 +79,9 @@ import org.jetbrains.kotlin.util.slicedMap.ReadOnlySlice
 import org.jetbrains.kotlin.util.slicedMap.WritableSlice
 import java.io.File
 
+const val JAR_SEPARATOR = "!/"
+const val KLIB_EXTENSION = "klib"
+
 /**
  * Kotlin as a service entry point
  *
@@ -85,65 +105,83 @@ class AnalysisEnvironment(val messageCollector: MessageCollector, val analysisPl
             Platform.native -> EnvironmentConfigFiles.NATIVE_CONFIG_FILES
             Platform.js -> EnvironmentConfigFiles.JS_CONFIG_FILES
         }
+
         val environment = KotlinCoreEnvironment.createForProduction(this, configuration, configFiles)
         val projectComponentManager = environment.project as MockComponentManager
 
-        val projectFileIndex = CoreProjectFileIndex(environment.project,
-                environment.configuration.getList(CLIConfigurationKeys.CONTENT_ROOTS))
-
+        val projectFileIndex = CoreProjectFileIndex(
+            environment.project,
+            environment.configuration.getList(CLIConfigurationKeys.CONTENT_ROOTS)
+        )
 
         val moduleManager = object : CoreModuleManager(environment.project, this) {
             override fun getModules(): Array<out Module> = arrayOf(projectFileIndex.module)
         }
 
-        CoreApplicationEnvironment.registerComponentInstance(projectComponentManager.picoContainer,
-                ModuleManager::class.java, moduleManager)
+        CoreApplicationEnvironment.registerComponentInstance(
+            projectComponentManager.picoContainer,
+            ModuleManager::class.java, moduleManager
+        )
 
         Extensions.registerAreaClass("IDEA_MODULE", null)
-        CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(),
-                OrderEnumerationHandler.EP_NAME, OrderEnumerationHandler.Factory::class.java)
+        CoreApplicationEnvironment.registerExtensionPoint(
+            Extensions.getRootArea(),
+            OrderEnumerationHandler.EP_NAME, OrderEnumerationHandler.Factory::class.java
+        )
+
+        projectComponentManager.registerService(
+            ProjectFileIndex::class.java,
+            projectFileIndex
+        )
+
+        projectComponentManager.registerService(
+            ProjectRootManager::class.java,
+            CoreProjectRootManager(projectFileIndex)
+        )
 
-        projectComponentManager.registerService(ProjectFileIndex::class.java,
-                projectFileIndex)
-        projectComponentManager.registerService(ProjectRootManager::class.java,
-                CoreProjectRootManager(projectFileIndex))
         return environment
     }
 
-    fun createSourceModuleSearchScope(project: Project, sourceFiles: List<KtFile>): GlobalSearchScope =
+    private fun createSourceModuleSearchScope(project: Project, sourceFiles: List<KtFile>): GlobalSearchScope =
         when (analysisPlatform) {
             Platform.jvm -> TopDownAnalyzerFacadeForJVM.newModuleSearchScope(project, sourceFiles)
-            Platform.js, Platform.common, Platform.native -> GlobalSearchScope.filesScope(project, sourceFiles.map { it.virtualFile }.toSet())
+            Platform.js, Platform.common, Platform.native -> GlobalSearchScope.filesScope(
+                project,
+                sourceFiles.map { it.virtualFile }.toSet()
+            )
         }
 
-
     fun createResolutionFacade(environment: KotlinCoreEnvironment): Pair<DokkaResolutionFacade, DokkaResolutionFacade> {
-
-        val projectContext = ProjectContext(environment.project)
+        val projectContext = ProjectContext(environment.project, "Dokka")
         val sourceFiles = environment.getSourceFiles()
 
 
         val targetPlatform = when (analysisPlatform) {
-            Platform.js -> JsPlatform
-            Platform.common -> TargetPlatform.Common
-            Platform.native -> KonanPlatform
-            Platform.jvm -> JvmPlatform
+            Platform.js -> JsPlatforms.defaultJsPlatform
+            Platform.common -> CommonPlatforms.defaultCommonPlatform
+            Platform.native -> KonanPlatforms.defaultKonanPlatform
+            Platform.jvm -> JvmPlatforms.defaultJvmPlatform
         }
 
-        val library = object : LibraryModuleInfo {
-            override val platform: TargetPlatform
-                get() = targetPlatform
-
-            override fun getLibraryRoots(): Collection<String> {
-                return classpath.map { it.absolutePath }
-            }
+        val nativeLibraries = classpath.filter { it.extension == KLIB_EXTENSION }
+            .map { createNativeLibraryModuleInfo(it) }
 
+        val library = object : LibraryModuleInfo {
+            override val analyzerServices: PlatformDependentAnalyzerServices =
+                analysisPlatform.analyzerServices()
             override val name: Name = Name.special("<library>")
+            override val platform: TargetPlatform = targetPlatform
             override fun dependencies(): List<ModuleInfo> = listOf(this)
+            override fun getLibraryRoots(): Collection<String> =
+                classpath.filterNot { it.extension == KLIB_EXTENSION }.map { it.absolutePath }
         }
+
         val module = object : ModuleInfo {
+            override val analyzerServices: PlatformDependentAnalyzerServices =
+                analysisPlatform.analyzerServices()
             override val name: Name = Name.special("<module>")
-            override fun dependencies(): List<ModuleInfo> = listOf(this, library)
+            override val platform: TargetPlatform = targetPlatform
+            override fun dependencies(): List<ModuleInfo> = listOf(this, library) + nativeLibraries
         }
 
         val sourcesScope = createSourceModuleSearchScope(environment.project, sourceFiles)
@@ -151,6 +189,7 @@ class AnalysisEnvironment(val messageCollector: MessageCollector, val analysisPl
             when (it) {
                 library -> ModuleContent(it, emptyList(), GlobalSearchScope.notScope(sourcesScope))
                 module -> ModuleContent(it, emptyList(), GlobalSearchScope.allScope(environment.project))
+                in nativeLibraries -> ModuleContent(it, emptyList(), GlobalSearchScope.notScope(sourcesScope))
                 else -> throw IllegalArgumentException("Unexpected module info")
             }
         }
@@ -159,20 +198,39 @@ class AnalysisEnvironment(val messageCollector: MessageCollector, val analysisPl
 
         val resolverForProject = when (analysisPlatform) {
             Platform.jvm -> {
-                builtIns = JvmBuiltIns(projectContext.storageManager)
-                createJvmResolverForProject(projectContext, module, library, modulesContent, sourcesScope, builtIns)
+                builtIns = JvmBuiltIns(
+                    projectContext.storageManager,
+                    JvmBuiltIns.Kind.FROM_CLASS_LOADER
+                ) // TODO we should use FROM_DEPENDENCIES
+                createJvmResolverForProject(
+                    projectContext,
+                    module,
+                    library,
+                    modulesContent,
+                    sourcesScope,
+                    builtIns
+                )
             }
-            Platform.common -> createCommonResolverForProject(projectContext, module, library, modulesContent, environment)
+            Platform.common -> createCommonResolverForProject(
+                projectContext,
+                module,
+                library,
+                modulesContent,
+                environment
+            )
             Platform.js -> createJsResolverForProject(projectContext, module, library, modulesContent)
             Platform.native -> createNativeResolverForProject(projectContext, module, library, modulesContent)
 
         }
-        val resolverForLibrary = resolverForProject.resolverForModule(library) // Required before module to initialize library properly
-        val resolverForModule = resolverForProject.resolverForModule(module)
         val libraryModuleDescriptor = resolverForProject.descriptorForModule(library)
         val moduleDescriptor = resolverForProject.descriptorForModule(module)
         builtIns?.initialize(moduleDescriptor, true)
-        val libraryResolutionFacade = DokkaResolutionFacade(environment.project, libraryModuleDescriptor, resolverForLibrary)
+
+        val resolverForLibrary =
+            resolverForProject.resolverForModule(library) // Required before module to initialize library properly
+        val resolverForModule = resolverForProject.resolverForModule(module)
+        val libraryResolutionFacade =
+            DokkaResolutionFacade(environment.project, libraryModuleDescriptor, resolverForLibrary)
         val created = DokkaResolutionFacade(environment.project, moduleDescriptor, resolverForModule)
         val projectComponentManager = environment.project as MockComponentManager
         projectComponentManager.registerService(KotlinCacheService::class.java, CoreKotlinCacheService(created))
@@ -180,29 +238,64 @@ class AnalysisEnvironment(val messageCollector: MessageCollector, val analysisPl
         return created to libraryResolutionFacade
     }
 
+    private fun Platform.analyzerServices() = when (this) {
+        Platform.js -> JsPlatformAnalyzerServices
+        Platform.common -> CommonPlatformAnalyzerServices
+        Platform.native -> NativePlatformAnalyzerServices
+        Platform.jvm -> JvmPlatformAnalyzerServices
+    }
+
+    private fun createNativeLibraryModuleInfo(libraryFile: File): LibraryModuleInfo {
+        val kotlinLibrary = createKotlinLibrary(org.jetbrains.kotlin.konan.file.File(libraryFile.absolutePath), false)
+        return object : LibraryModuleInfo {
+            override val analyzerServices: PlatformDependentAnalyzerServices =
+                analysisPlatform.analyzerServices()
+            override val name: Name = Name.special("<klib>")
+            override val platform: TargetPlatform = KonanPlatforms.defaultKonanPlatform
+            override fun dependencies(): List<ModuleInfo> = listOf(this)
+            override fun getLibraryRoots(): Collection<String> = listOf(libraryFile.absolutePath)
+            override val capabilities: Map<ModuleDescriptor.Capability<*>, Any?>
+                get() = super.capabilities + (NativeLibraryInfo.NATIVE_LIBRARY_CAPABILITY to kotlinLibrary)
+        }
+    }
+
     private fun createCommonResolverForProject(
         projectContext: ProjectContext,
         module: ModuleInfo,
         library: LibraryModuleInfo,
         modulesContent: (ModuleInfo) -> ModuleContent<ModuleInfo>,
         environment: KotlinCoreEnvironment
-    ): ResolverForProjectImpl<ModuleInfo> {
-        return ResolverForProjectImpl(
-            debugName = "Dokka",
-            projectContext = projectContext,
-            modules = listOf(module, library),
-            modulesContent = modulesContent,
-            modulePlatforms = { MultiTargetPlatform.Common },
-            moduleLanguageSettingsProvider = LanguageSettingsProvider.Default /* TODO: Fix this */,
-            resolverForModuleFactoryByPlatform = { CommonAnalyzerFacade },
-            platformParameters = { _ ->
-                CommonAnalysisParameters { content ->
-                    environment.createPackagePartProvider(content.moduleContentScope)
-                }
-            },
-            targetEnvironment = CompilerEnvironment,
-            builtIns = DefaultBuiltIns.Instance
-        )
+    ): ResolverForProject<ModuleInfo> {
+        return object : AbstractResolverForProject<ModuleInfo>(
+            "Dokka",
+            projectContext,
+            modules = listOf(module, library)
+        ) {
+            override fun sdkDependency(module: ModuleInfo): ModuleInfo? = null
+
+            override fun modulesContent(module: ModuleInfo): ModuleContent<ModuleInfo> = modulesContent(module)
+
+            override fun builtInsForModule(module: ModuleInfo): KotlinBuiltIns = DefaultBuiltIns.Instance
+
+            override fun createResolverForModule(
+                descriptor: ModuleDescriptor,
+                moduleInfo: ModuleInfo
+            ): ResolverForModule =
+                CommonResolverForModuleFactory(
+                    CommonAnalysisParameters { content ->
+                        environment.createPackagePartProvider(content.moduleContentScope)
+                    },
+                    CompilerEnvironment,
+                    unspecifiedJvmPlatform,
+                    true
+                ).createResolverForModule(
+                    descriptor as ModuleDescriptorImpl,
+                    projectContext.withModule(descriptor),
+                    modulesContent(moduleInfo),
+                    this,
+                    LanguageVersionSettingsImpl.DEFAULT
+                )
+        }
     }
 
     private fun createJsResolverForProject(
@@ -210,19 +303,30 @@ class AnalysisEnvironment(val messageCollector: MessageCollector, val analysisPl
         module: ModuleInfo,
         library: LibraryModuleInfo,
         modulesContent: (ModuleInfo) -> ModuleContent<ModuleInfo>
-    ): ResolverForProjectImpl<ModuleInfo> {
-        return ResolverForProjectImpl(
-            debugName = "Dokka",
-            projectContext = projectContext,
-            modules = listOf(module, library),
-            modulesContent = modulesContent,
-            modulePlatforms = { JsPlatform.multiTargetPlatform },
-            moduleLanguageSettingsProvider = LanguageSettingsProvider.Default /* TODO: Fix this */,
-            resolverForModuleFactoryByPlatform = { DokkaJsAnalyzerFacade },
-            platformParameters = { _ -> PlatformAnalysisParameters.Empty },
-            targetEnvironment = CompilerEnvironment,
-            builtIns = JsPlatform.builtIns
-        )
+    ): ResolverForProject<ModuleInfo> {
+        return object : AbstractResolverForProject<ModuleInfo>(
+            "Dokka",
+            projectContext,
+            modules = listOf(module, library)
+        ) {
+            override fun modulesContent(module: ModuleInfo): ModuleContent<ModuleInfo> = modulesContent(module)
+            override fun createResolverForModule(
+                descriptor: ModuleDescriptor,
+                moduleInfo: ModuleInfo
+            ): ResolverForModule = JsResolverForModuleFactory(
+                CompilerEnvironment
+            ).createResolverForModule(
+                descriptor as ModuleDescriptorImpl,
+                projectContext.withModule(descriptor),
+                modulesContent(moduleInfo),
+                this,
+                LanguageVersionSettingsImpl.DEFAULT
+            )
+
+            override fun builtInsForModule(module: ModuleInfo): KotlinBuiltIns = DefaultBuiltIns.Instance
+
+            override fun sdkDependency(module: ModuleInfo): ModuleInfo? = null
+        }
     }
 
     private fun createNativeResolverForProject(
@@ -230,19 +334,39 @@ class AnalysisEnvironment(val messageCollector: MessageCollector, val analysisPl
         module: ModuleInfo,
         library: LibraryModuleInfo,
         modulesContent: (ModuleInfo) -> ModuleContent<ModuleInfo>
-    ): ResolverForProjectImpl<ModuleInfo> {
-        return ResolverForProjectImpl(
-            debugName = "Dokka",
-            projectContext = projectContext,
-            modules = listOf(module, library),
-            modulesContent = modulesContent,
-            modulePlatforms = { KonanPlatform.multiTargetPlatform },
-            moduleLanguageSettingsProvider = LanguageSettingsProvider.Default /* TODO: Fix this */,
-            resolverForModuleFactoryByPlatform = { DokkaNativeAnalyzerFacade },
-            platformParameters = { _ -> PlatformAnalysisParameters.Empty },
-            targetEnvironment = CompilerEnvironment
-        )
+    ): ResolverForProject<ModuleInfo> {
+        return object : AbstractResolverForProject<ModuleInfo>(
+            "Dokka",
+            projectContext,
+            modules = module.dependencies()
+        ) {
+            override fun modulesContent(module: ModuleInfo): ModuleContent<ModuleInfo> = modulesContent(module)
+            override fun createResolverForModule(
+                descriptor: ModuleDescriptor,
+                moduleInfo: ModuleInfo
+            ): ResolverForModule {
+                (ApplicationManager.getApplication() as MockApplication).addComponent(
+                    KotlinNativeLoadingMetadataCache::class.java,
+                    KotlinNativeLoadingMetadataCache()
+                )
+
+                return NativeResolverForModuleFactory(
+                    PlatformAnalysisParameters.Empty,
+                    CompilerEnvironment,
+                    KonanPlatforms.defaultKonanPlatform
+                ).createResolverForModule(
+                    descriptor as ModuleDescriptorImpl,
+                    projectContext.withModule(descriptor),
+                    modulesContent(moduleInfo),
+                    this,
+                    LanguageVersionSettingsImpl.DEFAULT
+                )
+            }
 
+            override fun builtInsForModule(module: ModuleInfo): KotlinBuiltIns = DefaultBuiltIns.Instance
+
+            override fun sdkDependency(module: ModuleInfo): ModuleInfo? = null
+        }
     }
 
     private fun createJvmResolverForProject(
@@ -252,38 +376,39 @@ class AnalysisEnvironment(val messageCollector: MessageCollector, val analysisPl
         modulesContent: (ModuleInfo) -> ModuleContent<ModuleInfo>,
         sourcesScope: GlobalSearchScope,
         builtIns: KotlinBuiltIns
-    ): ResolverForProjectImpl<ModuleInfo> {
+    ): ResolverForProject<ModuleInfo> {
         val javaRoots = classpath
             .mapNotNull {
-                val rootFile = when {
-                    it.extension == "jar" ->
-                        StandardFileSystems.jar().findFileByPath("${it.absolutePath}${URLUtil.JAR_SEPARATOR}")
-                    else ->
-                        StandardFileSystems.local().findFileByPath(it.absolutePath)
+                val rootFile = when (it.extension) {
+                    "jar" -> StandardFileSystems.jar().findFileByPath("${it.absolutePath}${JAR_SEPARATOR}")
+                    else -> StandardFileSystems.local().findFileByPath(it.absolutePath)
                 }
-
                 rootFile?.let { JavaRoot(it, JavaRoot.RootType.BINARY) }
             }
 
-        return ResolverForProjectImpl(
-            debugName = "Dokka",
-            projectContext = projectContext,
-            modules = listOf(library, module),
-            modulesContent = {
-                when (it) {
-                    library -> ModuleContent(it, emptyList(), GlobalSearchScope.notScope(sourcesScope))
-                    module -> ModuleContent(it, emptyList(), sourcesScope)
+        return object : AbstractResolverForProject<ModuleInfo>(
+            "Dokka",
+            projectContext,
+            modules = listOf(module, library)
+        ) {
+            override fun modulesContent(module: ModuleInfo): ModuleContent<ModuleInfo> =
+                when (module) {
+                    library -> ModuleContent(module, emptyList(), GlobalSearchScope.notScope(sourcesScope))
+                    module -> ModuleContent(module, emptyList(), sourcesScope)
                     else -> throw IllegalArgumentException("Unexpected module info")
                 }
-            },
-            modulePlatforms = { JvmPlatform.multiTargetPlatform },
-            moduleLanguageSettingsProvider = LanguageSettingsProvider.Default /* TODO: Fix this */,
-            resolverForModuleFactoryByPlatform = { JvmAnalyzerFacade },
-            platformParameters = {
-                JvmPlatformParameters ({ content ->
+
+            override fun builtInsForModule(module: ModuleInfo): KotlinBuiltIns = builtIns
+
+            override fun createResolverForModule(
+                descriptor: ModuleDescriptor,
+                moduleInfo: ModuleInfo
+            ): ResolverForModule = JvmResolverForModuleFactory(
+                JvmPlatformParameters({ content ->
                     JvmPackagePartProvider(
                         configuration.languageVersionSettings,
-                        content.moduleContentScope)
+                        content.moduleContentScope
+                    )
                         .apply {
                             addRoots(javaRoots, messageCollector)
                         }
@@ -293,16 +418,25 @@ class AnalysisEnvironment(val messageCollector: MessageCollector, val analysisPl
                         module
                     else
                         library
-                })
-            },
-            targetEnvironment = CompilerEnvironment,
-            builtIns = builtIns
-        )
+                }),
+                CompilerEnvironment,
+                KonanPlatforms.defaultKonanPlatform
+            ).createResolverForModule(
+                descriptor as ModuleDescriptorImpl,
+                projectContext.withModule(descriptor),
+                modulesContent(moduleInfo),
+                this,
+                LanguageVersionSettingsImpl.DEFAULT
+            )
+
+            override fun sdkDependency(module: ModuleInfo): ModuleInfo? = null
+        }
     }
 
     fun loadLanguageVersionSettings(languageVersionString: String?, apiVersionString: String?) {
         val languageVersion = LanguageVersion.fromVersionString(languageVersionString) ?: LanguageVersion.LATEST_STABLE
-        val apiVersion = apiVersionString?.let { ApiVersion.parse(it) } ?: ApiVersion.createByLanguageVersion(languageVersion)
+        val apiVersion =
+            apiVersionString?.let { ApiVersion.parse(it) } ?: ApiVersion.createByLanguageVersion(languageVersion)
         configuration.languageVersionSettings = LanguageVersionSettingsImpl(languageVersion, apiVersion)
     }
 
@@ -339,8 +473,8 @@ class AnalysisEnvironment(val messageCollector: MessageCollector, val analysisPl
      */
     val sources: List<String>
         get() = configuration.get(CLIConfigurationKeys.CONTENT_ROOTS)
-                ?.filterIsInstance<KotlinSourceRoot>()
-                ?.map { it.path } ?: emptyList()
+            ?.filterIsInstance<KotlinSourceRoot>()
+            ?.map { it.path } ?: emptyList()
 
     /**
      * Adds list of paths to source roots.
@@ -374,9 +508,11 @@ fun contentRootFromPath(path: String): ContentRoot {
 }
 
 
-class DokkaResolutionFacade(override val project: Project,
-                            override val moduleDescriptor: ModuleDescriptor,
-                            val resolverForModule: ResolverForModule) : ResolutionFacade {
+class DokkaResolutionFacade(
+    override val project: Project,
+    override val moduleDescriptor: ModuleDescriptor,
+    val resolverForModule: ResolverForModule
+) : ResolutionFacade {
     override fun analyzeWithAllCompilerChecks(elements: Collection<KtElement>): AnalysisResult {
         throw UnsupportedOperationException()
     }
@@ -385,7 +521,10 @@ class DokkaResolutionFacade(override val project: Project,
         return resolverForModule.componentProvider.tryGetService(serviceClass)
     }
 
-    override fun resolveToDescriptor(declaration: KtDeclaration, bodyResolveMode: BodyResolveMode): DeclarationDescriptor {
+    override fun resolveToDescriptor(
+        declaration: KtDeclaration,
+        bodyResolveMode: BodyResolveMode
+    ): DeclarationDescriptor {
         return resolveSession.resolveToDescriptor(declaration)
     }
 
diff --git a/core/src/main/kotlin/analysis/CoreKotlinCacheService.kt b/core/src/main/kotlin/analysis/CoreKotlinCacheService.kt
index 509c4e10..bcf91225 100644
--- a/core/src/main/kotlin/analysis/CoreKotlinCacheService.kt
+++ b/core/src/main/kotlin/analysis/CoreKotlinCacheService.kt
@@ -5,7 +5,6 @@ import org.jetbrains.kotlin.analyzer.ModuleInfo
 import org.jetbrains.kotlin.caches.resolve.KotlinCacheService
 import org.jetbrains.kotlin.idea.resolve.ResolutionFacade
 import org.jetbrains.kotlin.psi.KtElement
-import org.jetbrains.kotlin.resolve.TargetPlatform
 import org.jetbrains.kotlin.resolve.diagnostics.KotlinSuppressCache
 
 
@@ -14,11 +13,24 @@ class CoreKotlinCacheService(private val resolutionFacade: DokkaResolutionFacade
         return resolutionFacade
     }
 
-    override fun getResolutionFacadeByFile(file: PsiFile, platform: TargetPlatform): ResolutionFacade {
+    override fun getResolutionFacade(
+        elements: List<KtElement>,
+        platform: org.jetbrains.kotlin.platform.TargetPlatform
+    ): ResolutionFacade {
         return resolutionFacade
     }
 
-    override fun getResolutionFacadeByModuleInfo(moduleInfo: ModuleInfo, platform: TargetPlatform): ResolutionFacade? {
+    override fun getResolutionFacadeByFile(
+        file: PsiFile,
+        platform: org.jetbrains.kotlin.platform.TargetPlatform
+    ): ResolutionFacade? {
+        return resolutionFacade