Remove kotlin source analysis from :core to :kotlin-analysis (thanks to Afzal Najam)

18 files changed, 68 insertions, 2261 deletions

diff --git a/core/build.gradle.kts b/core/build.gradle.kts
index 1d61e410..fc62b73d 100644
--- a/core/build.gradle.kts
+++ b/core/build.gradle.kts
@@ -6,12 +6,9 @@ plugins {
 }
 
 dependencies {
-    api(project(":coreDependencies", configuration = "shadow"))
+    api(project("dependencies", configuration = "shadow"))
 
-    val kotlin_version: String by project
-    api("org.jetbrains.kotlin:kotlin-compiler:$kotlin_version")
-    implementation("org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version")
-    implementation("org.jetbrains.kotlin:kotlin-reflect:$kotlin_version")
+    implementation(kotlin("reflect"))
     implementation("com.google.code.gson:gson:2.8.5")
     implementation("org.jsoup:jsoup:1.12.1")
 
diff --git a/core/dependencies/build.gradle.kts b/core/dependencies/build.gradle.kts
new file mode 100644
index 00000000..a26d109e
--- /dev/null
+++ b/core/dependencies/build.gradle.kts
@@ -0,0 +1,40 @@
+import org.jetbrains.configureBintrayPublication
+
+plugins {
+    id("com.github.johnrengelman.shadow")
+    `maven-publish`
+    id("com.jfrog.bintray")
+}
+
+repositories {
+    maven(url = "https://kotlin.bintray.com/kotlin-plugin")
+}
+
+dependencies {
+    // TODO (see https://github.com/Kotlin/dokka/issues/1009)
+    implementation(kotlin("stdlib"))
+    implementation(kotlin("reflect"))
+
+    implementation("org.jetbrains:markdown:0.1.41") {
+        because("it's published only on bintray")
+    }
+}
+
+tasks {
+    shadowJar {
+        val dokka_version: String by project
+        archiveFileName.set("dokka-dependencies-$dokka_version.jar")
+        archiveClassifier.set("")
+    }
+}
+
+publishing {
+    publications {
+        register<MavenPublication>("dokkaCoreDependencies") {
+            artifactId = "dokka-core-dependencies"
+            project.shadow.component(this)
+        }
+    }
+}
+
+configureBintrayPublication("dokkaCoreDependencies")
diff --git a/core/src/main/kotlin/DokkaGenerator.kt b/core/src/main/kotlin/DokkaGenerator.kt
index b2e572d4..b88c6223 100644
--- a/core/src/main/kotlin/DokkaGenerator.kt
+++ b/core/src/main/kotlin/DokkaGenerator.kt
@@ -1,7 +1,5 @@
 package org.jetbrains.dokka
 
-import org.jetbrains.dokka.analysis.AnalysisEnvironment
-import org.jetbrains.dokka.analysis.DokkaResolutionFacade
 import org.jetbrains.dokka.model.DModule
 import org.jetbrains.dokka.model.SourceSetCache
 import org.jetbrains.dokka.model.SourceSetData
@@ -9,13 +7,7 @@ import org.jetbrains.dokka.pages.RootPageNode
 import org.jetbrains.dokka.plugability.DokkaContext
 import org.jetbrains.dokka.plugability.DokkaPlugin
 import org.jetbrains.dokka.utilities.DokkaLogger
-import org.jetbrains.kotlin.cli.common.messages.CompilerMessageLocation
-import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
-import org.jetbrains.kotlin.cli.common.messages.MessageCollector
-import org.jetbrains.kotlin.cli.common.messages.MessageRenderer
-import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
-import org.jetbrains.kotlin.utils.PathUtil
-import java.io.File
+
 
 /**
  * DokkaGenerator is the main entry point for generating documentation
@@ -26,15 +18,13 @@ class DokkaGenerator(
     private val logger: DokkaLogger
 ) {
     fun generate() = timed {
-        report("Setting up analysis environments")
         val sourceSetsCache = SourceSetCache()
-        val sourceSets: Map<SourceSetData, EnvironmentAndFacade> = setUpAnalysis(configuration, sourceSetsCache)
 
         report("Initializing plugins")
-        val context = initializePlugins(configuration, logger, sourceSets, sourceSetsCache)
+        val context = initializePlugins(configuration, logger, sourceSetsCache)
 
         report("Creating documentation models")
-        val modulesFromPlatforms = createDocumentationModels(sourceSets, context)
+        val modulesFromPlatforms = createDocumentationModels(context, sourceSetsCache)
 
         report("Transforming documentation model before merging")
         val transformedDocumentationBeforeMerge = transformDocumentationModelBeforeMerge(modulesFromPlatforms, context)
@@ -59,9 +49,8 @@ class DokkaGenerator(
 
     fun generateAllModulesPage() = timed {
         val sourceSetsCache = SourceSetCache()
-        val sourceSets = emptyMap<SourceSetData, EnvironmentAndFacade>()
         report("Initializing plugins")
-        val context = initializePlugins(configuration, logger, sourceSets, sourceSetsCache)
+        val context = initializePlugins(configuration, logger, sourceSetsCache)
 
         report("Creating all modules page")
         val pages = createAllModulePage(context)
@@ -73,26 +62,20 @@ class DokkaGenerator(
         render(transformedPages, context)
     }.dump("\n\n === TIME MEASUREMENT ===\n")
 
-    fun setUpAnalysis(
-        configuration: DokkaConfiguration,
-        sourceSetsCache: SourceSetCache
-    ): Map<SourceSetData, EnvironmentAndFacade> =
-        configuration.passesConfigurations.map {
-            sourceSetsCache.getSourceSet(it) to createEnvironmentAndFacade(configuration, it)
-        }.toMap()
 
     fun initializePlugins(
         configuration: DokkaConfiguration,
         logger: DokkaLogger,
-        sourceSets: Map<SourceSetData, EnvironmentAndFacade>,
         sourceSetsCache: SourceSetCache,
         pluginOverrides: List<DokkaPlugin> = emptyList()
-    ) = DokkaContext.create(configuration, logger, sourceSets, sourceSetsCache, pluginOverrides)
+    ) = DokkaContext.create(configuration, logger, sourceSetsCache, pluginOverrides)
 
     fun createDocumentationModels(
-        platforms: Map<SourceSetData, EnvironmentAndFacade>,
-        context: DokkaContext
-    ) = platforms.flatMap { (pdata, _) -> translateSources(pdata, context) }
+        context: DokkaContext,
+        sourceSetsCache: SourceSetCache
+    ) = context.configuration.passesConfigurations
+        .map { passConfiguration -> sourceSetsCache.getSourceSet(passConfiguration) }
+        .flatMap { passConfiguration -> translateSources(passConfiguration, context) }
 
     fun transformDocumentationModelBeforeMerge(
         modulesFromPlatforms: List<DModule>,
@@ -150,56 +133,10 @@ class DokkaGenerator(
         }
     }
 
-    private fun createEnvironmentAndFacade(
-        configuration: DokkaConfiguration,
-        pass: DokkaConfiguration.PassConfiguration
-    ): EnvironmentAndFacade =
-        AnalysisEnvironment(DokkaMessageCollector(logger), pass.analysisPlatform).run {
-            if (analysisPlatform == Platform.jvm) {
-                addClasspath(PathUtil.getJdkClassesRootsFromCurrentJre())
-            }
-            pass.classpath.forEach { addClasspath(File(it)) }
-
-            addSources(
-                (pass.sourceRoots + configuration.passesConfigurations.filter { it.sourceSetID in pass.dependentSourceSets }
-                    .flatMap { it.sourceRoots })
-                    .map { it.path }
-            )
-
-            loadLanguageVersionSettings(pass.languageVersion, pass.apiVersion)
-
-            val environment = createCoreEnvironment()
-            val (facade, _) = createResolutionFacade(environment)
-            EnvironmentAndFacade(environment, facade)
-        }
-
     private fun translateSources(platformData: SourceSetData, context: DokkaContext) =
         context[CoreExtensions.sourceToDocumentableTranslator].map {
             it.invoke(platformData, context)
         }
-
-    class DokkaMessageCollector(private val logger: DokkaLogger) : MessageCollector {
-        override fun clear() {
-            seenErrors = false
-        }
-
-        private var seenErrors = false
-
-        override fun report(severity: CompilerMessageSeverity, message: String, location: CompilerMessageLocation?) {
-            if (severity == CompilerMessageSeverity.ERROR) {
-                seenErrors = true
-            }
-            logger.info(MessageRenderer.PLAIN_FULL_PATHS.render(severity, message, location))
-        }
-
-        override fun hasErrors() = seenErrors
-    }
-}
-
-// It is not data class due to ill-defined equals
-class EnvironmentAndFacade(val environment: KotlinCoreEnvironment, val facade: DokkaResolutionFacade) {
-    operator fun component1() = environment
-    operator fun component2() = facade
 }
 
 private class Timer(startTime: Long, private val logger: DokkaLogger?) {
diff --git a/core/src/main/kotlin/analysis/AnalysisEnvironment.kt b/core/src/main/kotlin/analysis/AnalysisEnvironment.kt
deleted file mode 100644
index 33451dd6..00000000
--- a/core/src/main/kotlin/analysis/AnalysisEnvironment.kt
+++ /dev/null
@@ -1,625 +0,0 @@
-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.MockComponentManager
-import com.intellij.openapi.Disposable
-import com.intellij.openapi.extensions.Extensions
-import com.intellij.openapi.module.Module
-import com.intellij.openapi.module.ModuleManager
-import com.intellij.openapi.project.Project
-import com.intellij.openapi.roots.OrderEnumerationHandler
-import com.intellij.openapi.roots.ProjectFileIndex
-import com.intellij.openapi.roots.ProjectRootManager
-import com.intellij.openapi.util.Disposer
-import com.intellij.openapi.vfs.StandardFileSystems
-import com.intellij.psi.PsiElement
-import com.intellij.psi.search.GlobalSearchScope
-import org.jetbrains.dokka.Platform
-import org.jetbrains.kotlin.analyzer.*
-import org.jetbrains.kotlin.analyzer.common.CommonAnalysisParameters
-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.resolve.*
-import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
-import org.jetbrains.kotlin.cli.common.config.ContentRoot
-import org.jetbrains.kotlin.cli.common.config.KotlinSourceRoot
-import org.jetbrains.kotlin.cli.common.config.addKotlinSourceRoot
-import org.jetbrains.kotlin.cli.common.messages.MessageCollector
-import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
-import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackagePartProvider
-import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
-import org.jetbrains.kotlin.cli.jvm.compiler.TopDownAnalyzerFacadeForJVM
-import org.jetbrains.kotlin.cli.jvm.config.*
-import org.jetbrains.kotlin.cli.jvm.index.JavaRoot
-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.analyzer.NativeResolverForModuleFactory
-import org.jetbrains.kotlin.js.config.JSConfigurationKeys
-import org.jetbrains.kotlin.js.resolve.JsPlatformAnalyzerServices
-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.psi.*
-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.JvmPlatformParameters
-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.ResolveSession
-import org.jetbrains.kotlin.types.KotlinType
-import org.jetbrains.kotlin.util.slicedMap.ReadOnlySlice
-import org.jetbrains.kotlin.util.slicedMap.WritableSlice
-import org.jetbrains.kotlin.idea.resolve.ResolutionFacade
-import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
-import org.jetbrains.kotlin.descriptors.konan.KlibModuleOrigin
-import org.jetbrains.kotlin.extensions.ApplicationExtensionDescriptor
-import org.jetbrains.kotlin.ide.konan.NativePlatformKindResolution
-import org.jetbrains.kotlin.load.java.structure.impl.classFiles.BinaryJavaClass
-import org.jetbrains.kotlin.platform.IdePlatformKind
-import org.jetbrains.kotlin.platform.impl.CommonIdePlatformKind
-import org.jetbrains.kotlin.platform.impl.JsIdePlatformKind
-import org.jetbrains.kotlin.platform.impl.JvmIdePlatformKind
-import org.jetbrains.kotlin.platform.impl.NativeIdePlatformKind
-import org.jetbrains.kotlin.platform.konan.NativePlatforms
-import java.io.File
-
-const val JAR_SEPARATOR = "!/"
-const val KLIB_EXTENSION = "klib"
-
-/**
- * Kotlin as a service entry point
- *
- * Configures environment, analyses files and provides facilities to perform code processing without emitting bytecode
- *
- * $messageCollector: required by compiler infrastructure and will receive all compiler messages
- * $body: optional and can be used to configure environment without creating local variable
- */
-class AnalysisEnvironment(val messageCollector: MessageCollector, val analysisPlatform: Platform) : Disposable {
-    val configuration = CompilerConfiguration()
-
-    init {
-        configuration.put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, messageCollector)
-    }
-
-    fun createCoreEnvironment(): KotlinCoreEnvironment {
-        System.setProperty("idea.io.use.nio2", "true")
-
-        val configFiles = when (analysisPlatform) {
-            Platform.jvm, Platform.common -> EnvironmentConfigFiles.JVM_CONFIG_FILES
-            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 moduleManager = object : CoreModuleManager(environment.project, this) {
-            override fun getModules(): Array<out Module> = arrayOf(projectFileIndex.module)
-        }
-
-        CoreApplicationEnvironment.registerComponentInstance(
-            projectComponentManager.picoContainer,
-            ModuleManager::class.java, moduleManager
-        )
-
-        CoreApplicationEnvironment.registerExtensionPoint(
-            Extensions.getRootArea(),
-            OrderEnumerationHandler.EP_NAME, OrderEnumerationHandler.Factory::class.java
-        )
-
-        projectComponentManager.registerService(
-            ProjectFileIndex::class.java,
-            projectFileIndex
-        )
-
-        projectComponentManager.registerService(
-            ProjectRootManager::class.java,
-            CoreProjectRootManager(projectFileIndex)
-        )
-
-        registerExtensionPoint(
-            ApplicationExtensionDescriptor("org.jetbrains.kotlin.idePlatformKind", IdePlatformKind::class.java),
-            listOf(
-                CommonIdePlatformKind,
-                JvmIdePlatformKind,
-                JsIdePlatformKind,
-                NativeIdePlatformKind
-            )
-        )
-
-        registerExtensionPoint(
-            IdePlatformKindResolution.Companion,
-            listOf(
-                CommonPlatformKindResolution(),
-                JvmPlatformKindResolution(),
-                JsPlatformKindResolution(),
-                NativePlatformKindResolution()
-            )
-        )
-
-        return environment
-    }
-
-    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()
-            )
-        }
-
-    fun createResolutionFacade(environment: KotlinCoreEnvironment): Pair<DokkaResolutionFacade, DokkaResolutionFacade> {
-        val projectContext = ProjectContext(environment.project, "Dokka")
-        val sourceFiles = environment.getSourceFiles()
-
-
-        val targetPlatform = when (analysisPlatform) {
-            Platform.js -> JsPlatforms.defaultJsPlatform
-            Platform.common -> CommonPlatforms.defaultCommonPlatform
-            Platform.native -> NativePlatforms.unspecifiedNativePlatform
-            Platform.jvm -> JvmPlatforms.defaultJvmPlatform
-        }
-
-        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 val platform: TargetPlatform = targetPlatform
-            override fun dependencies(): List<ModuleInfo> = listOf(this, library) + nativeLibraries
-        }
-
-        val sourcesScope = createSourceModuleSearchScope(environment.project, sourceFiles)
-        val modulesContent: (ModuleInfo) -> ModuleContent<ModuleInfo> = {
-            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")
-            }
-        }
-
-        var builtIns: JvmBuiltIns? = null
-
-        val resolverForProject = when (analysisPlatform) {
-            Platform.jvm -> {
-                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.js -> createJsResolverForProject(projectContext, module, library, modulesContent)
-            Platform.native -> createNativeResolverForProject(projectContext, module, library, modulesContent)
-
-        }
-        val libraryModuleDescriptor = resolverForProject.descriptorForModule(library)
-        val moduleDescriptor = resolverForProject.descriptorForModule(module)
-        builtIns?.initialize(moduleDescriptor, true)
-
-        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))
-
-        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 = NativePlatforms.unspecifiedNativePlatform
-            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 + (KlibModuleOrigin.CAPABILITY to kotlinLibrary)
-        }
-    }
-
-    private fun createCommonResolverForProject(
-        projectContext: ProjectContext,
-        module: ModuleInfo,
-        library: LibraryModuleInfo,
-        modulesContent: (ModuleInfo) -> ModuleContent<ModuleInfo>,
-        environment: KotlinCoreEnvironment
-    ): 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(
-        projectContext: ProjectContext,
-        module: ModuleInfo,
-        library: LibraryModuleInfo,
-        modulesContent: (ModuleInfo) -> ModuleContent<ModuleInfo>
-    ): 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(
-        projectContext: ProjectContext,
-        module: ModuleInfo,
-        library: LibraryModuleInfo,
-        modulesContent: (ModuleInfo) -> ModuleContent<ModuleInfo>
-    ): 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 {
-
-                return NativeResolverForModuleFactory(
-                    PlatformAnalysisParameters.Empty,
-                    CompilerEnvironment,
-                    NativePlatforms.unspecifiedNativePlatform
-                ).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(
-        projectContext: ProjectContext,
-        module: ModuleInfo,
-        library: LibraryModuleInfo,
-        modulesContent: (ModuleInfo) -> ModuleContent<ModuleInfo>,
-        sourcesScope: GlobalSearchScope,
-        builtIns: KotlinBuiltIns
-    ): ResolverForProject<ModuleInfo> {
-        val javaRoots = classpath
-            .mapNotNull {
-                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 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")
-                }
-
-            override fun builtInsForModule(module: ModuleInfo): KotlinBuiltIns = builtIns
-
-            override fun createResolverForModule(
-                descriptor: ModuleDescriptor,
-                moduleInfo: ModuleInfo
-            ): ResolverForModule = JvmResolverForModuleFactory(
-                JvmPlatformParameters({ content ->
-                    JvmPackagePartProvider(
-                        configuration.languageVersionSettings,
-                        content.moduleContentScope
-                    )
-                        .apply {
-                            addRoots(javaRoots, messageCollector)
-                        }
-                }, {
-                    val file =  (it as? BinaryJavaClass)?.virtualFile ?: (it as JavaClassImpl).psi.containingFile.virtualFile
-                    if (file in sourcesScope)
-                        module
-                    else
-                        library
-                }),
-                CompilerEnvironment,
-                unspecifiedJvmPlatform
-            ).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)
-        configuration.languageVersionSettings = LanguageVersionSettingsImpl(languageVersion, apiVersion)
-    }
-
-    /**
-     * Classpath for this environment.
-     */
-    val classpath: List<File>
-        get() = configuration.jvmClasspathRoots
-
-    /**
-     * Adds list of paths to classpath.
-     * $paths: collection of files to add
-     */
-    fun addClasspath(paths: List<File>) {
-        if (analysisPlatform == Platform.js) {
-            configuration.addAll(JSConfigurationKeys.LIBRARIES, paths.map { it.absolutePath })
-        }
-        configuration.addJvmClasspathRoots(paths)
-    }
-
-    /**
-     * Adds path to classpath.
-     * $path: path to add
-     */
-    fun addClasspath(path: File) {
-        if (analysisPlatform == Platform.js) {
-            configuration.add(JSConfigurationKeys.LIBRARIES, path.absolutePath)
-        }
-        configuration.addJvmClasspathRoot(path)
-    }
-
-    /**
-     * List of source roots for this environment.
-     */
-    val sources: List<String>
-        get() = configuration.get(CLIConfigurationKeys.CONTENT_ROOTS)
-            ?.filterIsInstance<KotlinSourceRoot>()
-            ?.map { it.path } ?: emptyList()
-
-    /**
-     * Adds list of paths to source roots.
-     * $list: collection of files to add
-     */
-    fun addSources(list: List<String>) {
-        list.forEach {
-            configuration.addKotlinSourceRoot(it)
-            val file = File(it)
-            if (file.isDirectory || file.extension == ".java") {
-                configuration.addJavaSourceRoot(file)
-            }
-        }
-    }
-
-    fun addRoots(list: List<ContentRoot>) {
-        configuration.addAll(CLIConfigurationKeys.CONTENT_ROOTS, list)
-    }
-
-    /**
-     * Disposes the environment and frees all associated resources.
-     */
-    override fun dispose() {
-        Disposer.dispose(this)
-    }
-
-    companion object {
-        private fun <T : Any> registerExtensionPoint(
-            appExtension: ApplicationExtensionDescriptor<T>,
-            instances: List<T>
-        ) {
-            if (Extensions.getRootArea().hasExtensionPoint(appExtension.extensionPointName))
-                return
-
-            appExtension.registerExtensionPoint()
-            instances.forEach(appExtension::registerExtension)
-        }
-    }
-}
-
-fun contentRootFromPath(path: String): ContentRoot {
-    val file = File(path)
-    return if (file.extension == "java") JavaSourceRoot(file, null) else KotlinSourceRoot(path, false)
-}
-
-
-class DokkaResolutionFacade(
-    override val project: Project,
-    override val moduleDescriptor: ModuleDescriptor,
-    val resolverForModule: ResolverForModule
-) : ResolutionFacade {
-    override fun analyzeWithAllCompilerChecks(elements: Collection<KtElement>): AnalysisResult {
-        throw UnsupportedOperationException()
-    }
-
-    override fun <T : Any> tryGetFrontendService(element: PsiElement, serviceClass: Class<T>): T? {
-        return resolverForModule.componentProvider.tryGetService(serviceClass)
-    }
-
-    override fun resolveToDescriptor(
-        declaration: KtDeclaration,
-        bodyResolveMode: BodyResolveMode
-    ): DeclarationDescriptor {
-        return resolveSession.resolveToDescriptor(declaration)
-    }
-
-    override fun analyze(elements: Collection<KtElement>, bodyResolveMode: BodyResolveMode): BindingContext {
-        throw UnsupportedOperationException()
-    }
-
-    val resolveSession: ResolveSession get() = getFrontendService(ResolveSession::class.java)
-
-    override fun analyze(element: KtElement, bodyResolveMode: BodyResolveMode): BindingContext {
-        if (element is KtDeclaration) {
-            val descriptor = resolveToDescriptor(element)
-            return object : BindingContext {
-                override fun <K : Any?, V : Any?> getKeys(p0: WritableSlice<K, V>?): Collection<K> {
-                    throw UnsupportedOperationException()
-                }
-
-                override fun getType(p0: KtExpression): KotlinType? {
-                    throw UnsupportedOperationException()
-                }
-
-                override fun <K : Any?, V : Any?> get(slice: ReadOnlySlice<K, V>?, key: K): V? {
-                    if (key != element) {
-                        throw UnsupportedOperationException()
-                    }
-                    return when {
-                        slice == BindingContext.DECLARATION_TO_DESCRIPTOR -> descriptor as V
-                        slice == BindingContext.PRIMARY_CONSTRUCTOR_PARAMETER && (element as KtParameter).hasValOrVar() -> descriptor as V
-                        else -> null
-                    }
-                }
-
-                override fun getDiagnostics(): Diagnostics {
-                    throw UnsupportedOperationException()
-                }
-
-                override fun addOwnDataTo(p0: BindingTrace, p1: Boolean) {
-                    throw UnsupportedOperationException()
-                }
-
-                override fun <K : Any?, V : Any?> getSliceContents(p0: ReadOnlySlice<K, V>): ImmutableMap<K, V> {
-                    throw UnsupportedOperationException()
-                }
-
-            }
-        }
-        throw UnsupportedOperationException()
-    }
-
-    override fun <T : Any> getFrontendService(element: PsiElement, serviceClass: Class<T>): T {
-        throw UnsupportedOperationException()
-    }
-
-    override fun <T : Any> getFrontendService(serviceClass: Class<T>): T {
-        return resolverForModule.componentProvider.getService(serviceClass)
-    }
-
-    override fun <T : Any> getFrontendService(moduleDescriptor: ModuleDescriptor, serviceClass: Class<T>): T {
-        return resolverForModule.componentProvider.getService(serviceClass)
-    }
-
-    override fun <T : Any> getIdeService(serviceClass: Class<T>): T {
-        throw UnsupportedOperationException()
-    }
-
-}
diff --git a/core/src/main/kotlin/analysis/CoreKotlinCacheService.kt b/core/src/main/kotlin/analysis/CoreKotlinCacheService.kt
deleted file mode 100644
index bcf91225..00000000
--- a/core/src/main/kotlin/analysis/CoreKotlinCacheService.kt
+++ /dev/null
@@ -1,42 +0,0 @@
-package org.jetbrains.dokka.analysis
-
-import com.intellij.psi.PsiFile
-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.diagnostics.KotlinSuppressCache
-
-
-class CoreKotlinCacheService(private val resolutionFacade: DokkaResolutionFacade) : KotlinCacheService {
-    override fun getResolutionFacade(elements: List<KtElement>): ResolutionFacade {
-        return resolutionFacade
-    }
-
-    override fun getResolutionFacade(
-        elements: List<KtElement>,
-        platform: org.jetbrains.kotlin.platform.TargetPlatform
-    ): ResolutionFacade {
-        return resolutionFacade
-    }
-
-    override fun getResolutionFacadeByFile(
-        file: PsiFile,
-        platform: org.jetbrains.kotlin.platform.TargetPlatform
-    ): ResolutionFacade? {
-        return resolutionFacade
-    }
-
-    override fun getResolutionFacadeByModuleInfo(
-        moduleInfo: ModuleInfo,
-        platform: org.jetbrains.kotlin.platform.TargetPlatform
-    ): ResolutionFacade? {
-        return resolutionFacade
-    }
-
-    override fun getSuppressionCache(): KotlinSuppressCache {
-        throw UnsupportedOperationException()
-    }
-
-}
-
diff --git a/core/src/main/kotlin/analysis/CoreProjectFileIndex.kt b/core/src/main/kotlin/analysis/CoreProjectFileIndex.kt
deleted file mode 100644
index 45138e39..00000000
--- a/core/src/main/kotlin/analysis/CoreProjectFileIndex.kt
+++ /dev/null
@@ -1,569 +0,0 @@
-package org.jetbrains.dokka.analysis
-
-import com.intellij.openapi.Disposable
-import com.intellij.openapi.components.BaseComponent
-import com.intellij.openapi.extensions.ExtensionPointName
-import com.intellij.openapi.module.Module
-import com.intellij.openapi.project.Project
-import com.intellij.openapi.projectRoots.Sdk
-import com.intellij.openapi.projectRoots.SdkAdditionalData
-import com.intellij.openapi.projectRoots.SdkModificator
-import com.intellij.openapi.projectRoots.SdkTypeId
-import com.intellij.openapi.roots.*
-import com.intellij.openapi.roots.impl.ProjectOrderEnumerator
-import com.intellij.openapi.util.Condition
-import com.intellij.openapi.util.Key
-import com.intellij.openapi.util.UserDataHolderBase
-import com.intellij.openapi.vfs.StandardFileSystems
-import com.intellij.openapi.vfs.VfsUtilCore.getVirtualFileForJar
-import com.intellij.openapi.vfs.VirtualFile
-import com.intellij.openapi.vfs.VirtualFileFilter
-import com.intellij.psi.search.GlobalSearchScope
-import com.intellij.util.messages.MessageBus
-import org.jetbrains.jps.model.module.JpsModuleSourceRootType
-import org.jetbrains.kotlin.cli.common.config.ContentRoot
-import org.jetbrains.kotlin.cli.common.config.KotlinSourceRoot
-import org.jetbrains.kotlin.cli.jvm.config.JvmClasspathRoot
-import org.jetbrains.kotlin.cli.jvm.config.JvmContentRoot
-import org.picocontainer.PicoContainer
-import java.io.File
-
-/**
- * Workaround for the lack of ability to create a ProjectFileIndex implementation using only
- * classes from projectModel-{api,impl}.
- */
-class CoreProjectFileIndex(private val project: Project, contentRoots: List<ContentRoot>) : ProjectFileIndex, ModuleFileIndex {
-    override fun iterateContent(p0: ContentIterator, p1: VirtualFileFilter?): Boolean {
-        throw UnsupportedOperationException()
-    }
-
-    override fun iterateContentUnderDirectory(p0: VirtualFile, p1: ContentIterator, p2: VirtualFileFilter?): Boolean {
-        throw UnsupportedOperationException()
-    }
-
-    override fun isInLibrary(p0: VirtualFile): Boolean {
-        throw UnsupportedOperationException()
-    }
-
-    val sourceRoots = contentRoots.filter { it !is JvmClasspathRoot }
-    val classpathRoots = contentRoots.filterIsInstance<JvmClasspathRoot>()
-
-    val module: Module = object : UserDataHolderBase(), Module {
-        override fun isDisposed(): Boolean {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getOptionValue(p0: String): String? {
-            throw UnsupportedOperationException()
-        }
-
-        override fun clearOption(p0: String) {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getName(): String = "<Dokka module>"
-
-        override fun getModuleWithLibrariesScope(): GlobalSearchScope {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getModuleWithDependentsScope(): GlobalSearchScope {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getModuleContentScope(): GlobalSearchScope {
-            throw UnsupportedOperationException()
-        }
-
-        override fun isLoaded(): Boolean {
-            throw UnsupportedOperationException()
-        }
-
-        override fun setOption(p0: String, p1: String?) {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getModuleWithDependenciesScope(): GlobalSearchScope {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getModuleWithDependenciesAndLibrariesScope(p0: Boolean): GlobalSearchScope {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getProject(): Project = this@CoreProjectFileIndex.project
-
-        override fun getModuleContentWithDependenciesScope(): GlobalSearchScope {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getModuleFilePath(): String {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getModuleTestsWithDependentsScope(): GlobalSearchScope {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getModuleScope(): GlobalSearchScope {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getModuleScope(p0: Boolean): GlobalSearchScope {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getModuleRuntimeScope(p0: Boolean): GlobalSearchScope {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getModuleFile(): VirtualFile? {
-            throw UnsupportedOperationException()
-        }
-
-        override fun <T : Any?> getExtensions(p0: ExtensionPointName<T>): Array<out T> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getComponent(p0: String): BaseComponent? {
-            throw UnsupportedOperationException()
-        }
-
-        override fun <T : Any?> getComponent(p0: Class<T>, p1: T): T {
-            throw UnsupportedOperationException()
-        }
-
-        override fun <T : Any?> getComponent(interfaceClass: Class<T>): T? {
-            if (interfaceClass == ModuleRootManager::class.java) {
-                return moduleRootManager as T
-            }
-            throw UnsupportedOperationException()
-        }
-
-        override fun getDisposed(): Condition<*> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun <T : Any?> getComponents(p0: Class<T>): Array<out T> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getPicoContainer(): PicoContainer {
-            throw UnsupportedOperationException()
-        }
-
-        override fun hasComponent(p0: Class<*>): Boolean {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getMessageBus(): MessageBus {
-            throw UnsupportedOperationException()
-        }
-
-        override fun dispose() {
-            throw UnsupportedOperationException()
-        }
-    }
-
-    private val sdk: Sdk = object : Sdk, RootProvider {
-        override fun getFiles(rootType: OrderRootType): Array<out VirtualFile> = classpathRoots
-                .mapNotNull { StandardFileSystems.local().findFileByPath(it.file.path) }
-                .toTypedArray()
-
-        override fun addRootSetChangedListener(p0: RootProvider.RootSetChangedListener) {
-            throw UnsupportedOperationException()
-        }
-
-        override fun addRootSetChangedListener(p0: RootProvider.RootSetChangedListener, p1: Disposable) {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getUrls(p0: OrderRootType): Array<out String> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun removeRootSetChangedListener(p0: RootProvider.RootSetChangedListener) {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getSdkModificator(): SdkModificator {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getName(): String = "<dokka SDK>"
-
-        override fun getRootProvider(): RootProvider = this
-
-        override fun getHomePath(): String? {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getVersionString(): String? {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getSdkAdditionalData(): SdkAdditionalData? {
-            throw UnsupportedOperationException()
-        }
-
-        override fun clone(): Any {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getSdkType(): SdkTypeId {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getHomeDirectory(): VirtualFile? {
-            throw UnsupportedOperationException()
-        }
-
-        override fun <T : Any?> getUserData(p0: Key<T>): T? {
-            throw UnsupportedOperationException()
-        }
-
-        override fun <T : Any?> putUserData(p0: Key<T>, p1: T?) {
-            throw UnsupportedOperationException()
-        }
-    }
-
-    private val moduleSourceOrderEntry = object : ModuleSourceOrderEntry {
-        override fun getFiles(p0: OrderRootType): Array<VirtualFile> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getUrls(p0: OrderRootType): Array<String> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun <R : Any?> accept(p0: RootPolicy<R>, p1: R?): R {
-            throw UnsupportedOperationException()
-        }
-
-
-        override fun getPresentableName(): String {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getOwnerModule(): Module = module
-
-
-        override fun isValid(): Boolean {
-            throw UnsupportedOperationException()
-        }
-
-        override fun compareTo(other: OrderEntry?): Int {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getRootModel(): ModuleRootModel = moduleRootManager
-
-        override fun isSynthetic(): Boolean {
-            throw UnsupportedOperationException()
-        }
-    }
-
-    private val sdkOrderEntry = object : JdkOrderEntry {
-        override fun getFiles(p0: OrderRootType): Array<VirtualFile> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getUrls(p0: OrderRootType): Array<String> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun <R : Any?> accept(p0: RootPolicy<R>, p1: R?): R {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getJdkName(): String? {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getJdk(): Sdk = sdk
-
-        override fun getPresentableName(): String {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getOwnerModule(): Module {
-            throw UnsupportedOperationException()
-        }
-
-        override fun isValid(): Boolean {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getRootFiles(p0: OrderRootType): Array<out VirtualFile> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getRootUrls(p0: OrderRootType): Array<out String> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun compareTo(other: OrderEntry?): Int {
-            throw UnsupportedOperationException()
-        }
-
-        override fun isSynthetic(): Boolean {
-            throw UnsupportedOperationException()
-        }
-
-    }
-
-    inner class MyModuleRootManager : ModuleRootManager() {
-        override fun getExternalSource(): ProjectModelExternalSource? {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getExcludeRoots(): Array<out VirtualFile> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getContentEntries(): Array<out ContentEntry> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getExcludeRootUrls(): Array<out String> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun <R : Any?> processOrder(p0: RootPolicy<R>, p1: R): R {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getSourceRoots(p0: Boolean): Array<out VirtualFile> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getSourceRoots(): Array<out VirtualFile> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getSourceRoots(p0: JpsModuleSourceRootType<*>): MutableList<VirtualFile> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getSourceRoots(p0: MutableSet<out JpsModuleSourceRootType<*>>): MutableList<VirtualFile> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getContentRoots(): Array<out VirtualFile> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun orderEntries(): OrderEnumerator =
-                ProjectOrderEnumerator(project, null).using(object : RootModelProvider {
-                    override fun getModules(): Array<out Module> = arrayOf(module)
-
-                    override fun getRootModel(p0: Module): ModuleRootModel = this@MyModuleRootManager
-                })
-
-        override fun <T : Any?> getModuleExtension(p0: Class<T>): T {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getDependencyModuleNames(): Array<out String> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getModule(): Module = this@CoreProjectFileIndex.module
-
-        override fun isSdkInherited(): Boolean {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getOrderEntries(): Array<out OrderEntry> = arrayOf(moduleSourceOrderEntry, sdkOrderEntry)
-
-        override fun getSourceRootUrls(): Array<out String> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getSourceRootUrls(p0: Boolean): Array<out String> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getSdk(): Sdk? {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getContentRootUrls(): Array<out String> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getModuleDependencies(): Array<out Module> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getModuleDependencies(p0: Boolean): Array<out Module> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getModifiableModel(): ModifiableRootModel {
-            throw UnsupportedOperationException()
-        }
-
-        override fun isDependsOn(p0: Module): Boolean {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getFileIndex(): ModuleFileIndex {
-            return this@CoreProjectFileIndex
-        }
-
-        override fun getDependencies(): Array<out Module> {
-            throw UnsupportedOperationException()
-        }
-
-        override fun getDependencies(p0: Boolean): Array<out Module> {
-            throw UnsupportedOperationException()
-        }
-    }
-
-    val moduleRootManager = MyModuleRootManager()
-
-    override fun getContentRootForFile(p0: VirtualFile): VirtualFile? {
-        throw UnsupportedOperationException()
-    }
-
-    override fun getContentRootForFile(p0: VirtualFile, p1: Boolean): VirtualFile? {
-        throw UnsupportedOperationException()
-    }
-
-    override fun getPackageNameByDirectory(p0: VirtualFile): String? {
-        throw UnsupportedOperationException()
-    }
-
-    override fun isInLibrarySource(file: VirtualFile): Boolean = false
-
-    override fun getClassRootForFile(file: VirtualFile): VirtualFile? =
-        classpathRoots.firstOrNull { it.contains(file) }?.let { StandardFileSystems.local().findFileByPath(it.file.path) }
-
-    override fun getOrderEntriesForFile(file: VirtualFile): List<OrderEntry> =
-        if (classpathRoots.contains(file)) listOf(sdkOrderEntry) else emptyList()
-
-    override fun isInLibraryClasses(file: VirtualFile): Boolean = classpathRoots.contains(file)
-
-    override fun isExcluded(p0: VirtualFile): Boolean {
-        throw UnsupportedOperationException()
-    }
-
-    override fun getSourceRootForFile(p0: VirtualFile): VirtualFile? {
-        throw UnsupportedOperationException()
-    }
-
-    override fun isUnderIgnored(p0: VirtualFile): Boolean {
-        throw UnsupportedOperationException()
-    }
-
-    override fun isLibraryClassFile(p0: VirtualFile): Boolean {
-        throw UnsupportedOperationException()
-    }
-
-    override fun getModuleForFile(file: VirtualFile): Module? =
-            if (sourceRoots.contains(file)) module else null
-
-    private fun List<ContentRoot>.contains(file: VirtualFile): Boolean = any { it.contains(file) }
-
-    override fun getModuleForFile(p0: VirtualFile, p1: Boolean): Module? {
-        throw UnsupportedOperationException()
-    }
-
-    override fun isInSource(p0: VirtualFile): Boolean {
-        throw UnsupportedOperationException()
-    }
-
-    override fun isIgnored(p0: VirtualFile): Boolean {
-        throw UnsupportedOperationException()
-    }
-
-    override fun isContentSourceFile(p0: VirtualFile): Boolean {
-        throw UnsupportedOperationException()
-    }
-
-    override fun isInSourceContent(file: VirtualFile): Boolean = sourceRoots.contains(file)
-
-    override fun iterateContent(p0: ContentIterator): Boolean {
-        throw UnsupportedOperationException()
-    }
-
-    override fun isInContent(p0: VirtualFile): Boolean {
-        throw UnsupportedOperationException()
-    }
-
-    override fun iterateContentUnderDirectory(p0: VirtualFile, p1: ContentIterator): Boolean {
-        throw UnsupportedOperationException()
-    }
-
-    override fun isInTestSourceContent(file: VirtualFile): Boolean = false
-
-    override fun isUnderSourceRootOfType(p0: VirtualFile, p1: MutableSet<out JpsModuleSourceRootType<*>>): Boolean {
-        throw UnsupportedOperationException()
-    }
-
-    override fun getOrderEntryForFile(p0: VirtualFile): OrderEntry? {
-        throw UnsupportedOperationException()
-    }
-}
-
-class CoreProjectRootManager(val projectFileIndex: CoreProjectFileIndex) : ProjectRootManager() {
-    override fun orderEntries(): OrderEnumerator {
-        throw UnsupportedOperationException()
-    }
-
-    override fun orderEntries(p0: MutableCollection<out Module>): OrderEnumerator {
-        throw UnsupportedOperationException()
-    }
-
-    override fun getContentRootsFromAllModules(): Array<out VirtualFile> {
-        throw UnsupportedOperationException()
-    }
-
-    override fun setProjectSdk(p0: Sdk?) {
-        throw UnsupportedOperationException()
-    }
-
-    override fun setProjectSdkName(p0: String) {
-        throw UnsupportedOperationException()
-    }
-
-    override fun getModuleSourceRoots(p0: MutableSet<out JpsModuleSourceRootType<*>>): MutableList<VirtualFile> {
-        throw UnsupportedOperationException()
-    }
-
-    override fun getContentSourceRoots(): Array<out VirtualFile> {
-        throw UnsupportedOperationException()
-    }
-
-    override fun getFileIndex(): ProjectFileIndex = projectFileIndex
-
-    override fun getProjectSdkName(): String? {
-        throw UnsupportedOperationException()
-    }
-
-    override fun getProjectSdk(): Sdk? {
-        throw UnsupportedOperationException()
-    }
-
-    override fun getContentRoots(): Array<out VirtualFile> {
-        throw UnsupportedOperationException()
-    }
-
-    override fun getContentRootUrls(): MutableList<String> {
-        throw UnsupportedOperationException()
-    }
-
-}
-
-fun ContentRoot.contains(file: VirtualFile) = when (this) {
-    is JvmContentRoot -> {
-        val path = if (file.fileSystem.protocol == StandardFileSystems.JAR_PROTOCOL)
-            getVirtualFileForJar(file)?.path ?: file.path
-        else
-            file.path
-        File(path).startsWith(this.file.absoluteFile)
-    }
-    is KotlinSourceRoot -> File(file.path).startsWith(File(this.path).absoluteFile)
-    else -> false
-}
diff --git a/core/src/main/kotlin/analysis/JavaResolveExtension.kt b/core/src/main/kotlin/analysis/JavaResolveExtension.kt
deleted file mode 100644
index ab6bec9c..00000000
--- a/core/src/main/kotlin/analysis/JavaResolveExtension.kt
+++ /dev/null
@@ -1,128 +0,0 @@
-/*
- * Copyright 2010-2017 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-@file:JvmName("JavaResolutionUtils")
-
-package org.jetbrains.dokka.analysis
-
-import com.intellij.psi.*
-import org.jetbrains.kotlin.asJava.unwrapped
-import org.jetbrains.kotlin.caches.resolve.KotlinCacheService
-import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.idea.resolve.ResolutionFacade
-import org.jetbrains.kotlin.incremental.components.NoLookupLocation
-import org.jetbrains.kotlin.load.java.sources.JavaSourceElement
-import org.jetbrains.kotlin.load.java.structure.*
-import org.jetbrains.kotlin.load.java.structure.impl.*
-import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.platform.jvm.JvmPlatforms
-import org.jetbrains.kotlin.psi.KtDeclaration
-import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver
-import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
-import org.jetbrains.kotlin.resolve.scopes.MemberScope
-
-// TODO: Remove that file
-
-@JvmOverloads
-fun PsiMethod.getJavaMethodDescriptor(resolutionFacade: ResolutionFacade = javaResolutionFacade()): DeclarationDescriptor? {
-    val method = originalElement as? PsiMethod ?: return null
-    if (method.containingClass == null || !Name.isValidIdentifier(method.name)) return null
-    val resolver = method.getJavaDescriptorResolver(resolutionFacade)
-    return when {
-        method.isConstructor -> resolver?.resolveConstructor(JavaConstructorImpl(method))
-        else -> resolver?.resolveMethod(JavaMethodImpl(method))
-    }
-}
-
-@JvmOverloads
-fun PsiClass.getJavaClassDescriptor(resolutionFacade: ResolutionFacade = javaResolutionFacade()): ClassDescriptor? {
-    val psiClass = originalElement as? PsiClass ?: return null
-    return psiClass.getJavaDescriptorResolver(resolutionFacade)?.resolveClass(JavaClassImpl(psiClass))
-}
-
-@JvmOverloads
-fun PsiField.getJavaFieldDescriptor(resolutionFacade: ResolutionFacade = javaResolutionFacade()): PropertyDescriptor? {
-    val field = originalElement as? PsiField ?: return null
-    return field.getJavaDescriptorResolver(resolutionFacade)?.resolveField(JavaFieldImpl(field))
-}
-
-@JvmOverloads
-fun PsiMember.getJavaMemberDescriptor(resolutionFacade: ResolutionFacade = javaResolutionFacade()): DeclarationDescriptor? {
-    return when (this) {
-        is PsiEnumConstant -> containingClass?.getJavaClassDescriptor(resolutionFacade)
-        is PsiClass -> getJavaClassDescriptor(resolutionFacade)
-        is PsiMethod -> getJavaMethodDescriptor(resolutionFacade)
-        is PsiField -> getJavaFieldDescriptor(resolutionFacade)
-        else -> null
-    }
-}
-
-@JvmOverloads
-fun PsiMember.getJavaOrKotlinMemberDescriptor(resolutionFacade: ResolutionFacade = javaResolutionFacade()): DeclarationDescriptor? {
-    val callable = unwrapped
-    return when (callable) {
-        is PsiMember -> getJavaMemberDescriptor(resolutionFacade)
-        is KtDeclaration -> {
-            val descriptor = resolutionFacade.resolveToDescriptor(callable)
-            if (descriptor is ClassDescriptor && this is PsiMethod) descriptor.unsubstitutedPrimaryConstructor else descriptor
-        }
-        else -> null
-    }
-}
-
-private fun PsiElement.getJavaDescriptorResolver(resolutionFacade: ResolutionFacade): JavaDescriptorResolver? {
-    return resolutionFacade.tryGetFrontendService(this, JavaDescriptorResolver::class.java)
-}
-
-private fun JavaDescriptorResolver.resolveMethod(method: JavaMethod): DeclarationDescriptor? {
-    return getContainingScope(method)
-            ?.getContributedDescriptors(nameFilter = { true }, kindFilter = DescriptorKindFilter.CALLABLES)
-            ?.filterIsInstance<DeclarationDescriptorWithSource>()
-            ?.findByJavaElement(method)
-}
-
-private fun JavaDescriptorResolver.resolveConstructor(constructor: JavaConstructor): ConstructorDescriptor? {
-    return resolveClass(constructor.containingClass)?.constructors?.findByJavaElement(constructor)
-}
-
-private fun JavaDescriptorResolver.resolveField(field: JavaField): PropertyDescriptor? {
-    return getContainingScope(field)?.getContributedVariables(field.name, NoLookupLocation.FROM_IDE)?.findByJavaElement(field)
-}
-
-private fun JavaDescriptorResolver.getContainingScope(member: JavaMember): MemberScope? {
-    val containingClass = resolveClass(member.containingClass)
-    return if (member.isStatic)
-        containingClass?.staticScope
-    else
-        containingClass?.defaultType?.memberScope
-}
-
-private fun <T : DeclarationDescriptorWithSource> Collection<T>.findByJavaElement(javaElement: JavaElement): T? {
-    return firstOrNull { member ->
-        val memberJavaElement = (member.original.source as? JavaSourceElement)?.javaElement
-        when {
-            memberJavaElement == javaElement ->
-                true
-            memberJavaElement is JavaElementImpl<*> && javaElement is JavaElementImpl<*> ->
-                memberJavaElement.psi.isEquivalentTo(javaElement.psi)
-            else ->
-                false
-        }
-    }
-}
-
-fun PsiElement.javaResolutionFacade() =
-    KotlinCacheService.getInstance(project).getResolutionFacadeByFile(this.originalElement.containingFile, JvmPlatforms.defaultJvmPlatform)!!
diff --git a/core/src/main/kotlin/links/DRI.kt b/core/src/main/kotlin/links/DRI.kt
index 9cc51fb7..3f6d886f 100644
--- a/core/src/main/kotlin/links/DRI.kt
+++ b/core/src/main/kotlin/links/DRI.kt
@@ -1,15 +1,5 @@
 package org.jetbrains.dokka.links
 
-import com.intellij.psi.*
-import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.psi.psiUtil.parentsWithSelf
-import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
-import org.jetbrains.kotlin.resolve.descriptorUtil.parentsWithSelf
-import org.jetbrains.kotlin.resolve.scopes.receivers.ExtensionReceiver
-import org.jetbrains.kotlin.types.KotlinType
-import org.jetbrains.kotlin.types.TypeProjection
-import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
-
 /**
  * [DRI] stands for DokkaResourceIdentifier
  */
@@ -21,33 +11,10 @@ data class DRI(
     val extra: String? = null
 ) {
     override fun toString(): String =
-        "${packageName.orEmpty()}/${classNames.orEmpty()}/${callable?.name.orEmpty()}/${callable?.signature().orEmpty()}/$target/${extra.orEmpty()}"
+        "${packageName.orEmpty()}/${classNames.orEmpty()}/${callable?.name.orEmpty()}/${callable?.signature()
+            .orEmpty()}/$target/${extra.orEmpty()}"
 
     companion object {
-        fun from(descriptor: DeclarationDescriptor) = descriptor.parentsWithSelf.run {
-            val callable = firstIsInstanceOrNull<CallableDescriptor>()
-            DRI(
-                firstIsInstanceOrNull<PackageFragmentDescriptor>()?.fqName?.asString(),
-                (filterIsInstance<ClassDescriptor>() + filterIsInstance<TypeAliasDescriptor>()).toList()
-                    .takeIf { it.isNotEmpty() }
-                    ?.asReversed()
-                    ?.joinToString(separator = ".") { it.name.asString() },
-                callable?.let { Callable.from(it) },
-                DriTarget.from(descriptor)
-            )
-        }
-
-        fun from(psi: PsiElement) = psi.parentsWithSelf.run {
-            val psiMethod = firstIsInstanceOrNull<PsiMethod>()
-            val psiField = firstIsInstanceOrNull<PsiField>()
-            val classes = filterIsInstance<PsiClass>().toList()
-            DRI(
-                classes.lastOrNull()?.qualifiedName?.substringBeforeLast('.', ""),
-                classes.toList().takeIf { it.isNotEmpty() }?.asReversed()?.mapNotNull { it.name }?.joinToString("."),
-                psiMethod?.let { Callable.from(it) }  ?: psiField?.let { Callable.from(it) } ,
-                DriTarget.from(psi)
-            )
-        }
         val topLevel = DRI()
     }
 }
@@ -78,71 +45,11 @@ data class Callable(
 ) {
     fun signature() = "${receiver?.toString().orEmpty()}#${params.joinToString("#")}"
 
-    companion object {
-        fun from(descriptor: CallableDescriptor) = with(descriptor) {
-            Callable(
-                name.asString(),
-                extensionReceiverParameter?.let { TypeReference.from(it) },
-                valueParameters.mapNotNull { TypeReference.from(it) }
-            )
-        }
-
-        fun from(psi: PsiMethod) = with(psi) {
-            Callable(
-                name,
-                null,
-                parameterList.parameters.map { param -> JavaClassReference(param.type.canonicalText) })
-        }
-
-        fun from(psi: PsiField): Callable {
-            return Callable(
-                name = psi.name,
-                receiver = null,
-                params = emptyList()
-            )
-        }
-    }
+    companion object
 }
 
 sealed class TypeReference {
-    companion object {
-        fun from(d: ReceiverParameterDescriptor): TypeReference? =
-            when (d.value) {
-                is ExtensionReceiver -> fromPossiblyNullable(d.type)
-                else -> run {
-                    println("Unknown value type for $d")
-                    null
-                }
-            }
-
-        fun from(d: ValueParameterDescriptor): TypeReference? =
-            fromPossiblyNullable(d.type)
-
-        fun from(p: PsiClass) = TypeReference
-
-        private fun fromPossiblyNullable(t: KotlinType, self: KotlinType? = null): TypeReference =
-            from(t, self).let { if (t.isMarkedNullable) Nullable(it) else it }
-
-        private fun from(t: KotlinType, self: KotlinType? = null): TypeReference =
-            if (self is KotlinType && self.constructor == t.constructor && self.arguments == t.arguments)
-                SelfType
-            else when (val d = t.constructor.declarationDescriptor) {
-                is TypeParameterDescriptor -> TypeParam(
-                    d.upperBounds.map { fromPossiblyNullable(it, self ?: t) }
-                )
-                else -> TypeConstructor(
-                    t.constructorName.orEmpty(),
-                    t.arguments.map { fromProjection(it, self) }
-                )
-            }
-
-        private fun fromProjection(t: TypeProjection, r: KotlinType? = null): TypeReference =
-            if (t.isStarProjection) {
-                StarProjection
-            } else {
-                fromPossiblyNullable(t.type, r)
-            }
-    }
+    companion object
 }
 
 data class JavaClassReference(val name: String) : TypeReference() {
@@ -171,39 +78,10 @@ object StarProjection : TypeReference() {
     override fun toString() = "*"
 }
 
-private val KotlinType.constructorName
-    get() = constructor.declarationDescriptor?.fqNameSafe?.asString()
-
 sealed class DriTarget {
     override fun toString(): String = this.javaClass.simpleName
 
-    companion object {
-        fun from(descriptor: DeclarationDescriptor): DriTarget = descriptor.parentsWithSelf.run {
-            return when (descriptor) {
-                is TypeParameterDescriptor -> PointingToGenericParameters(descriptor.index)
-                else -> {
-                    val callable = firstIsInstanceOrNull<CallableDescriptor>()
-                    val params =
-                        callable?.let { listOfNotNull(it.extensionReceiverParameter) + it.valueParameters }.orEmpty()
-                    val parameterDescriptor = firstIsInstanceOrNull<ParameterDescriptor>()
-
-                    parameterDescriptor?.let { PointingToCallableParameters(params.indexOf(it)) }
-                        ?: PointingToDeclaration
-                }
-            }
-        }
-
-        fun from(psi: PsiElement): DriTarget = psi.parentsWithSelf.run {
-            return when (psi) {
-                is PsiTypeParameter -> PointingToGenericParameters(psi.index)
-                else -> firstIsInstanceOrNull<PsiParameter>()?.let {
-                    val callable = firstIsInstanceOrNull<PsiMethod>()
-                    val params = (callable?.parameterList?.parameters).orEmpty()
-                    PointingToCallableParameters(params.indexOf(it))
-                } ?: PointingToDeclaration
-            }
-        }
-    }
+    companion object
 }
 
 data class PointingToGenericParameters(val parameterIndex: Int) : DriTarget() {
diff --git a/core/src/main/kotlin/model/Documentable.kt b/core/src/main/kotlin/model/Documentable.kt
index 90958210..768bddc5 100644
--- a/core/src/main/kotlin/model/Documentable.kt
+++ b/core/src/main/kotlin/model/Documentable.kt
@@ -1,12 +1,10 @@
 package org.jetbrains.dokka.model
 
-import com.intellij.psi.PsiNamedElement
 import org.jetbrains.dokka.links.DRI
 import org.jetbrains.dokka.model.doc.DocumentationNode
 import org.jetbrains.dokka.model.properties.PropertyContainer
 import org.jetbrains.dokka.model.properties.WithExtraProperties
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
-import org.jetbrains.kotlin.load.kotlin.toSourceElement
+
 
 abstract class Documentable {
     abstract val name: String?
@@ -406,11 +404,3 @@ fun <T> SourceSetDependent<T>?.orEmpty(): SourceSetDependent<T> = this ?: emptyM
 interface DocumentableSource {
     val path: String
 }
-
-class DescriptorDocumentableSource(val descriptor: DeclarationDescriptor) : DocumentableSource {
-    override val path = descriptor.toSourceElement.containingFile.toString()
-}
-
-class PsiDocumentableSource(val psi: PsiNamedElement) : DocumentableSource {
-    override val path = psi.containingFile.virtualFile.path
-}
\ No newline at end of file
diff --git a/core/src/main/kotlin/model/properties/PropertyContainer.kt b/core/src/main/kotlin/model/properties/PropertyContainer.kt
index 107bede5..e1e0250e 100644
--- a/core/src/main/kotlin/model/properties/PropertyContainer.kt
+++ b/core/src/main/kotlin/model/properties/PropertyContainer.kt
@@ -1,7 +1,5 @@
 package org.jetbrains.dokka.model.properties
 
-import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
-
 class PropertyContainer<C : Any> internal constructor(
     @PublishedApi internal val map: Map<ExtraProperty.Key<C, *>, ExtraProperty<C>>
 ) {
@@ -45,7 +43,7 @@ fun <C> C.mergeExtras(left: C, right: C): C where C : Any, C : WithExtraProperti
         (l.key as ExtraProperty.Key<C, ExtraProperty<C>>).mergeStrategyFor(l, r)
     }
 
-    strategies.firstIsInstanceOrNull<MergeStrategy.Fail>()?.error?.invoke()
+    strategies.filterIsInstance<MergeStrategy.Fail>().firstOrNull()?.error?.invoke()
 
     val replaces: List<ExtraProperty<C>> =
         strategies.filterIsInstance<MergeStrategy.Replace<C>>().map { it.newProperty }
diff --git a/core/src/main/kotlin/parsers/HtmlParser.kt b/core/src/main/kotlin/parsers/HtmlParser.kt
deleted file mode 100644
index a0652b95..00000000
--- a/core/src/main/kotlin/parsers/HtmlParser.kt
+++ /dev/null
@@ -1,89 +0,0 @@
-package org.jetbrains.dokka.parsers
-
-import org.jetbrains.dokka.model.doc.*
-import org.jetbrains.dokka.parsers.factories.DocTagsFromStringFactory
-import org.jsoup.Jsoup
-import org.jsoup.nodes.Node
-import org.jsoup.select.NodeFilter
-import org.jsoup.select.NodeTraversor
-
-class HtmlParser : Parser() {
-
-    inner class NodeFilterImpl : NodeFilter {
-
-        private val nodesCache: MutableMap<Int, MutableList<DocTag>> = mutableMapOf()
-        private var currentDepth = 0
-
-        fun collect(): DocTag = nodesCache[currentDepth]!![0]
-
-        override fun tail(node: Node?, depth: Int): NodeFilter.FilterResult {
-            val nodeName = node!!.nodeName()
-            val nodeAttributes = node.attributes()
-
-            if(nodeName in listOf("#document", "html", "head"))
-                return NodeFilter.FilterResult.CONTINUE
-
-            val body: String
-            val params: Map<String, String>
-
-
-            if(nodeName != "#text") {
-                body = ""
-                params = nodeAttributes.map { it.key to it.value }.toMap()
-            } else {
-                body = nodeAttributes["#text"]
-                params = emptyMap()
-            }
-
-            val docNode = if(depth < currentDepth) {
-                DocTagsFromStringFactory.getInstance(nodeName, nodesCache.getOrDefault(currentDepth, mutableListOf()).toList(), params, body).also {
-                    nodesCache[currentDepth] = mutableListOf()
-                    currentDepth = depth
-                }
-            } else {
-                DocTagsFromStringFactory.getInstance(nodeName, emptyList(), params, body)
-            }
-
-            nodesCache.getOrDefault(depth, mutableListOf()) += docNode
-            return NodeFilter.FilterResult.CONTINUE
-        }
-
-        override fun head(node: Node?, depth: Int): NodeFilter.FilterResult {
-
-            val nodeName = node!!.nodeName()
-
-            if(currentDepth < depth) {
-                currentDepth = depth
-                nodesCache[currentDepth] = mutableListOf()
-            }
-
-            if(nodeName in listOf("#document", "html", "head"))
-                return NodeFilter.FilterResult.CONTINUE
-
-            return NodeFilter.FilterResult.CONTINUE
-        }
-    }
-
-
-    private fun htmlToDocNode(string: String): DocTag {
-        val document = Jsoup.parse(string)
-        val nodeFilterImpl = NodeFilterImpl()
-        NodeTraversor.filter(nodeFilterImpl, document.root())
-        return nodeFilterImpl.collect()
-    }
-
-    private fun replaceLinksWithHrefs(javadoc: String): String = Regex("\\{@link .*?}").replace(javadoc) {
-        val split = it.value.dropLast(1).split(" ")
-        if(split.size !in listOf(2, 3))
-            return@replace it.value
-        if(split.size == 3)
-            return@replace "<documentationlink href=\"${split[1]}\">${split[2]}</documentationlink>"
-        else
-            return@replace "<documentationlink href=\"${split[1]}\">${split[1]}</documentationlink>"
-    }
-
-    override fun parseStringToDocNode(extractedString: String) = htmlToDocNode(extractedString)
-    override fun preparse(text: String) = replaceLinksWithHrefs(text)
-}
-
-
diff --git a/core/src/main/kotlin/parsers/MarkdownParser.kt b/core/src/main/kotlin/parsers/MarkdownParser.kt
deleted file mode 100644
index 07e1fcc3..00000000
--- a/core/src/main/kotlin/parsers/MarkdownParser.kt
+++ /dev/null
@@ -1,418 +0,0 @@
-package org.jetbrains.dokka.parsers
-
-import com.intellij.psi.PsiElement
-import org.jetbrains.dokka.model.doc.*
-import org.intellij.markdown.MarkdownElementTypes
-import org.intellij.markdown.MarkdownTokenTypes
-import org.intellij.markdown.ast.ASTNode
-import org.intellij.markdown.ast.CompositeASTNode
-import org.intellij.markdown.ast.LeafASTNode
-import org.intellij.markdown.ast.impl.ListItemCompositeNode
-import org.intellij.markdown.flavours.gfm.GFMElementTypes
-import org.intellij.markdown.flavours.gfm.GFMFlavourDescriptor
-import org.intellij.markdown.flavours.gfm.GFMTokenTypes
-import org.jetbrains.dokka.analysis.DokkaResolutionFacade
-import org.jetbrains.dokka.links.DRI
-import org.jetbrains.dokka.parsers.factories.DocTagsFromIElementFactory
-import org.jetbrains.dokka.utilities.DokkaLogger
-import org.jetbrains.kotlin.descriptors.ClassDescriptor
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
-import org.jetbrains.kotlin.idea.kdoc.resolveKDocLink
-import org.jetbrains.kotlin.kdoc.parser.KDocKnownTag
-import org.jetbrains.kotlin.kdoc.psi.impl.KDocSection
-import org.jetbrains.kotlin.kdoc.psi.impl.KDocTag
-import java.net.MalformedURLException
-import org.intellij.markdown.parser.MarkdownParser as IntellijMarkdownParser
-
-class MarkdownParser(
-    private val resolutionFacade: DokkaResolutionFacade? = null,
-    private val declarationDescriptor: DeclarationDescriptor? = null,
-    private val logger: DokkaLogger
-) : Parser() {
-
-    inner class MarkdownVisitor(val text: String, val destinationLinksMap: Map<String, String>) {
-
-        private fun headersHandler(node: ASTNode): DocTag =
-            DocTagsFromIElementFactory.getInstance(
-                node.type,
-                visitNode(node.children.find { it.type == MarkdownTokenTypes.ATX_CONTENT }
-                    ?: throw IllegalStateException("Wrong AST Tree. ATX Header does not contain expected content")).children
-            )
-
-        private fun horizontalRulesHandler(node: ASTNode): DocTag =
-            DocTagsFromIElementFactory.getInstance(MarkdownTokenTypes.HORIZONTAL_RULE)
-
-        private fun emphasisHandler(node: ASTNode): DocTag =
-            DocTagsFromIElementFactory.getInstance(
-                node.type,
-                children = listOf(visitNode(node.children[node.children.size / 2]))
-            )
-
-        private fun blockquotesHandler(node: ASTNode): DocTag =
-            DocTagsFromIElementFactory.getInstance(
-                node.type, children = node.children
-                    .filterIsInstance<CompositeASTNode>()
-                    .evaluateChildren()
-            )
-
-        private fun listsHandler(node: ASTNode): DocTag {
-
-            val children = node.children.filterIsInstance<ListItemCompositeNode>().flatMap {
-                if (it.children.last().type in listOf(
-                        MarkdownElementTypes.ORDERED_LIST,
-                        MarkdownElementTypes.UNORDERED_LIST
-                    )
-                ) {
-                    val nestedList = it.children.last()
-                    (it.children as MutableList).removeAt(it.children.lastIndex)
-                    listOf(it, nestedList)
-                } else
-                    listOf(it)
-            }
-
-            return DocTagsFromIElementFactory.getInstance(
-                node.type,
-                children =
-                children
-                    .map {
-                        if (it.type == MarkdownElementTypes.LIST_ITEM)
-                            DocTagsFromIElementFactory.getInstance(
-                                it.type,
-                                children = it
-                                    .children
-                                    .filterIsInstance<CompositeASTNode>()
-                                    .evaluateChildren()
-                            )
-                        else
-                            visitNode(it)
-                    },
-                params =
-                if (node.type == MarkdownElementTypes.ORDERED_LIST) {
-                    val listNumberNode = node.children.first().children.first()
-                    mapOf(
-                        "start" to text.substring(
-                            listNumberNode.startOffset,
-                            listNumberNode.endOffset
-                        ).trim().dropLast(1)
-                    )
-                } else
-                    emptyMap()
-            )
-        }
-
-        private fun resolveDRI(mdLink: String): DRI? =
-            mdLink
-                .removePrefix("[")
-                .removeSuffix("]")
-                .let { link ->
-                    try {
-                        java.net.URL(link)
-                        null
-                    } catch (e: MalformedURLException) {
-                        try {
-                            if (resolutionFacade != null && declarationDescriptor != null) {
-                                resolveKDocLink(
-                                    resolutionFacade.resolveSession.bindingContext,
-                                    resolutionFacade,
-                                    declarationDescriptor,
-                                    null,
-                                    link.split('.')
-                                ).minBy { it is ClassDescriptor }?.let { DRI.from(it) }
-                            } else null
-                        } catch (e1: IllegalArgumentException) {
-                            null
-                        }
-                    }
-                }
-
-        private fun referenceLinksHandler(node: ASTNode): DocTag {
-            val linkLabel = node.children.find { it.type == MarkdownElementTypes.LINK_LABEL }
-                ?: throw IllegalStateException("Wrong AST Tree. Reference link does not contain expected content")
-            val linkText = node.children.findLast { it.type == MarkdownElementTypes.LINK_TEXT } ?: linkLabel
-
-            val linkKey = text.substring(linkLabel.startOffset, linkLabel.endOffset)
-
-            val link = destinationLinksMap[linkKey.toLowerCase()] ?: linkKey
-
-            return linksHandler(linkText, link)
-        }
-
-        private fun inlineLinksHandler(node: ASTNode): DocTag {
-            val linkText = node.children.find { it.type == MarkdownElementTypes.LINK_TEXT }
-                ?: throw IllegalStateException("Wrong AST Tree. Inline link does not contain expected content")
-            val linkDestination = node.children.find { it.type == MarkdownElementTypes.LINK_DESTINATION }
-                ?: throw IllegalStateException("Wrong AST Tree. Inline link does not contain expected content")
-            val linkTitle = node.children.find { it.type == MarkdownElementTypes.LINK_TITLE }
-
-            val link = text.substring(linkDestination.startOffset, linkDestination.endOffset)
-
-            return linksHandler(linkText, link, linkTitle)
-        }
-
-        private fun autoLinksHandler(node: ASTNode): DocTag {
-            val link = text.substring(node.startOffset + 1, node.endOffset - 1)
-
-            return linksHandler(node, link)
-        }
-
-        private fun linksHandler(linkText: ASTNode, link: String, linkTitle: ASTNode? = null): DocTag {
-            val dri: DRI? = resolveDRI(link)
-            val params = if (linkTitle == null)
-                mapOf("href" to link)
-            else
-                mapOf("href" to link, "title" to text.substring(linkTitle.startOffset + 1, linkTitle.endOffset - 1))
-
-            return DocTagsFromIElementFactory.getInstance(
-                MarkdownElementTypes.INLINE_LINK,
-                params = params,
-                children = linkText.children.drop(1).dropLast(1).evaluateChildren(),
-                dri = dri
-            )
-        }
-
-        private fun imagesHandler(node: ASTNode): DocTag {
-            val linkNode =
-                node.children.last().children.find { it.type == MarkdownElementTypes.LINK_LABEL }!!.children[1]
-            val link = text.substring(linkNode.startOffset, linkNode.endOffset)
-            val src = mapOf("src" to link)
-            return DocTagsFromIElementFactory.getInstance(
-                node.type,
-                params = src,
-                children = listOf(visitNode(node.children.last().children.find { it.type == MarkdownElementTypes.LINK_TEXT }!!))
-            )
-        }
-
-        private fun codeSpansHandler(node: ASTNode): DocTag =
-            DocTagsFromIElementFactory.getInstance(
-                node.type,
-                children = listOf(
-                    DocTagsFromIElementFactory.getInstance(
-                        MarkdownTokenTypes.TEXT,
-                        body = text.substring(node.startOffset + 1, node.endOffset - 1).replace('\n', ' ').trimIndent()
-                    )
-
-                )
-            )
-
-        private fun codeFencesHandler(node: ASTNode): DocTag =
-            DocTagsFromIElementFactory.getInstance(
-                node.type,
-                children = node
-                    .children
-                    .dropWhile { it.type != MarkdownTokenTypes.CODE_FENCE_CONTENT }
-                    .dropLastWhile { it.type != MarkdownTokenTypes.CODE_FENCE_CONTENT }
-                    .map {
-                        if (it.type == MarkdownTokenTypes.EOL)
-                            LeafASTNode(MarkdownTokenTypes.HARD_LINE_BREAK, 0, 0)
-                        else
-                            it
-                    }.evaluateChildren(),
-                params = node
-                    .children
-                    .find { it.type == MarkdownTokenTypes.FENCE_LANG }
-                    ?.let { mapOf("lang" to text.substring(it.startOffset, it.endOffset)) }
-                    ?: emptyMap()
-            )
-
-        private fun codeBlocksHandler(node: ASTNode): DocTag =
-            DocTagsFromIElementFactory.getInstance(node.type, children = node.children.evaluateChildren())
-
-        private fun defaultHandler(node: ASTNode): DocTag =
-            DocTagsFromIElementFactory.getInstance(
-                MarkdownElementTypes.PARAGRAPH,
-                children = node.children.evaluateChildren()
-            )
-
-        fun visitNode(node: ASTNode): DocTag =
-            when (node.type) {
-                MarkdownElementTypes.ATX_1,
-                MarkdownElementTypes.ATX_2,
-                MarkdownElementTypes.ATX_3,
-                MarkdownElementTypes.ATX_4,
-                MarkdownElementTypes.ATX_5,
-                MarkdownElementTypes.ATX_6 -> headersHandler(node)
-                MarkdownTokenTypes.HORIZONTAL_RULE -> horizontalRulesHandler(node)
-                MarkdownElementTypes.STRONG,
-                MarkdownElementTypes.EMPH -> emphasisHandler(node)
-                MarkdownElementTypes.FULL_REFERENCE_LINK,
-                MarkdownElementTypes.SHORT_REFERENCE_LINK -> referenceLinksHandler(node)
-                MarkdownElementTypes.INLINE_LINK -> inlineLinksHandler(node)
-                MarkdownElementTypes.AUTOLINK -> autoLinksHandler(node)
-                MarkdownElementTypes.BLOCK_QUOTE -> blockquotesHandler(node)
-                MarkdownElementTypes.UNORDERED_LIST,
-                MarkdownElementTypes.ORDERED_LIST -> listsHandler(node)
-                MarkdownElementTypes.CODE_BLOCK -> codeBlocksHandler(node)
-                MarkdownElementTypes.CODE_FENCE -> codeFencesHandler(node)
-                MarkdownElementTypes.CODE_SPAN -> codeSpansHandler(node)
-                MarkdownElementTypes.IMAGE -> imagesHandler(node)
-                MarkdownTokenTypes.HARD_LINE_BREAK -> DocTagsFromIElementFactory.getInstance(node.type)
-                MarkdownTokenTypes.CODE_FENCE_CONTENT,
-                MarkdownTokenTypes.CODE_LINE,
-                MarkdownTokenTypes.TEXT -> DocTagsFromIElementFactory.getInstance(
-                    MarkdownTokenTypes.TEXT,
-                    body = text
-                        .substring(node.startOffset, node.endOffset).transform()
-                )
-                MarkdownElementTypes.MARKDOWN_FILE -> if (node.children.size == 1) visitNode(node.children.first()) else defaultHandler(
-                    node
-                )
-                GFMElementTypes.STRIKETHROUGH -> DocTagsFromIElementFactory.getInstance(
-                    GFMElementTypes.STRIKETHROUGH,
-                    body = text
-                        .substring(node.startOffset, node.endOffset).transform()
-                )
-                GFMElementTypes.TABLE -> DocTagsFromIElementFactory.getInstance(
-                    GFMElementTypes.TABLE,
-                    children = node.children.filterTabSeparators().evaluateChildren()
-                )
-                GFMElementTypes.HEADER -> DocTagsFromIElementFactory.getInstance(
-                    GFMElementTypes.HEADER,
-                    children = node.children.filterTabSeparators().evaluateChildren()
-                )
-                GFMElementTypes.ROW -> DocTagsFromIElementFactory.getInstance(
-                    GFMElementTypes.ROW,
-                    children = node.children.filterTabSeparators().evaluateChildren()
-                )
-                else -> defaultHandler(node)
-            }
-
-        private fun List<ASTNode>.filterTabSeparators() =
-            this.filterNot { it.type == GFMTokenTypes.TABLE_SEPARATOR }
-
-        private fun List<ASTNode>.evaluateChildren(): List<DocTag> =
-            this.removeUselessTokens().mergeLeafASTNodes().map { visitNode(it) }
-
-        private fun List<ASTNode>.removeUselessTokens(): List<ASTNode> =
-            this.filterIndexed { index, node ->
-                !(node.type == MarkdownElementTypes.LINK_DEFINITION || (
-                        node.type == MarkdownTokenTypes.EOL &&
-                                this.getOrNull(index - 1)?.type == MarkdownTokenTypes.HARD_LINE_BREAK
-                        ))
-            }
-
-        private val notLeafNodes = listOf(MarkdownTokenTypes.HORIZONTAL_RULE, MarkdownTokenTypes.HARD_LINE_BREAK)
-
-        private fun List<ASTNode>.isNotLeaf(index: Int): Boolean =
-            if (index in 0..this.lastIndex)
-                (this[index] is CompositeASTNode) || this[index].type in notLeafNodes
-            else
-                false
-
-        private fun List<ASTNode>.mergeLeafASTNodes(): List<ASTNode> {
-            val children: MutableList<ASTNode> = mutableListOf()
-            var index = 0
-            while (index <= this.lastIndex) {
-                if (this.isNotLeaf(index)) {
-                    children += this[index]
-                } else {
-                    val startOffset = this[index].startOffset
-                    while (index < this.lastIndex) {
-                        if (this.isNotLeaf(index + 1) || this[index + 1].startOffset != this[index].endOffset) {
-                            val endOffset = this[index].endOffset
-                            if (text.substring(startOffset, endOffset).transform().trim().isNotEmpty())
-                                children += LeafASTNode(MarkdownTokenTypes.TEXT, startOffset, endOffset)
-                            break
-                        }
-                        index++
-                    }
-                    if (index == this.lastIndex) {
-                        val endOffset = this[index].endOffset
-                        if (text.substring(startOffset, endOffset).transform().trim().isNotEmpty())
-                            children += LeafASTNode(MarkdownTokenTypes.TEXT, startOffset, endOffset)
-                    }
-                }
-                index++
-            }
-            return children
-        }
-
-        private fun String.transform() = this
-            .replace(Regex("\n\n+"), "")        // Squashing new lines between paragraphs
-            .replace(Regex("\n"), " ")
-            .replace(Regex(" >+ +"), " ")      // Replacement used in blockquotes, get rid of garbage
-    }
-
-
-    private fun getAllDestinationLinks(text: String, node: ASTNode): List<Pair<String, String>> =
-        node.children
-            .filter { it.type == MarkdownElementTypes.LINK_DEFINITION }
-            .map {
-                text.substring(it.children[0].startOffset, it.children[0].endOffset).toLowerCase() to
-                        text.substring(it.children[2].startOffset, it.children[2].endOffset)
-            } +
-                node.children.filterIsInstance<CompositeASTNode>().flatMap { getAllDestinationLinks(text, it) }
-
-
-    private fun markdownToDocNode(text: String): DocTag {
-
-        val flavourDescriptor = GFMFlavourDescriptor()
-        val markdownAstRoot: ASTNode = IntellijMarkdownParser(flavourDescriptor).buildMarkdownTreeFromString(text)
-
-        return MarkdownVisitor(text, getAllDestinationLinks(text, markdownAstRoot).toMap()).visitNode(markdownAstRoot)
-    }
-
-    override fun parseStringToDocNode(extractedString: String) = markdownToDocNode(extractedString)
-    override fun preparse(text: String) = text
-
-    private fun findParent(kDoc: PsiElement): PsiElement =
-        if (kDoc is KDocSection) findParent(kDoc.parent) else kDoc
-
-    private fun getAllKDocTags(kDocImpl: PsiElement): List<KDocTag> =
-        kDocImpl.children.filterIsInstance<KDocTag>().filterNot { it is KDocSection } + kDocImpl.children.flatMap {
-            getAllKDocTags(
-                it
-            )
-        }
-
-    fun parseFromKDocTag(kDocTag: KDocTag?): DocumentationNode {
-        return if (kDocTag == null)
-            DocumentationNode(emptyList())
-        else
-            DocumentationNode(
-                (listOf(kDocTag) + getAllKDocTags(findParent(kDocTag))).map {
-                    when (it.knownTag) {
-                        null -> if (it.name == null) Description(parseStringToDocNode(it.getContent())) else CustomTagWrapper(
-                            parseStringToDocNode(it.getContent()),
-                            it.name!!
-                        )
-                        KDocKnownTag.AUTHOR -> Author(parseStringToDocNode(it.getContent()))
-                        KDocKnownTag.THROWS -> Throws(
-                            parseStringToDocNode(it.getContent()),
-                            it.getSubjectName().orEmpty()
-                        )
-                        KDocKnownTag.EXCEPTION -> Throws(
-                            parseStringToDocNode(it.getContent()),
-                            it.getSubjectName().orEmpty()
-                        )
-                        KDocKnownTag.PARAM -> Param(
-                            parseStringToDocNode(it.getContent()),
-                            it.getSubjectName().orEmpty()
-                        )
-                        KDocKnownTag.RECEIVER -> Receiver(parseStringToDocNode(it.getContent()))
-                        KDocKnownTag.RETURN -> Return(parseStringToDocNode(it.getContent()))
-                        KDocKnownTag.SEE -> See(
-                            parseStringToDocNode(it.getContent()),
-                            it.getSubjectName().orEmpty(),
-                            parseStringToDocNode("[${it.getSubjectName()}]")
-                                .let {
-                                    val link = it.children[0]
-                                    if (link is DocumentationLink) link.dri
-                                    else null
-                                }
-                        )
-                        KDocKnownTag.SINCE -> Since(parseStringToDocNode(it.getContent()))
-                        KDocKnownTag.CONSTRUCTOR -> Constructor(parseStringToDocNode(it.getContent()))
-                        KDocKnownTag.PROPERTY -> Property(
-                            parseStringToDocNode(it.getContent()),
-                            it.getSubjectName().orEmpty()
-                        )
-                        KDocKnownTag.SAMPLE -> Sample(
-                            parseStringToDocNode(it.getContent()),
-                            it.getSubjectName().orEmpty()
-                        )
-                        KDocKnownTag.SUPPRESS -> Suppress(parseStringToDocNode(it.getContent()))
-                    }
-                }
-            )
-    }
-}
\ No newline at end of file
diff --git a/core/src/main/kotlin/parsers/Parser.kt b/core/src/main/kotlin/parsers/Parser.kt
deleted file mode 100644
index 05adc4d5..00000000
--- a/core/src/main/kotlin/parsers/Parser.kt
+++ /dev/null
@@ -1,42 +0,0 @@
-package org.jetbrains.dokka.parsers
-
-import org.jetbrains.dokka.model.doc.*
-
-abstract class Parser {
-
-    abstract fun parseStringToDocNode(extractedString: String): DocTag
-    abstract fun preparse(text: String): String
-
-    fun parse(text: String): DocumentationNode {
-
-        val list = jkdocToListOfPairs(preparse(text))
-
-        val mappedList: List<TagWrapper> = list.map {
-            when(it.first) {
-                "description"         -> Description(parseStringToDocNode(it.second))
-                "author"              -> Author(parseStringToDocNode(it.second))
-                "version"             -> Version(parseStringToDocNode(it.second))
-                "since"               -> Since(parseStringToDocNode(it.second))
-                "see"                 -> See(parseStringToDocNode(it.second.substringAfter(' ')), it.second.substringBefore(' '), null)
-                "param"               -> Param(parseStringToDocNode(it.second.substringAfter(' ')), it.second.substringBefore(' '))
-                "property"            -> Property(parseStringToDocNode(it.second.substringAfter(' ')), it.second.substringBefore(' '))
-                "return"              -> Return(parseStringToDocNode(it.second))
-                "constructor"         -> Constructor(parseStringToDocNode(it.second))
-                "receiver"            -> Receiver(parseStringToDocNode(it.second))
-                "throws", "exception" -> Throws(parseStringToDocNode(it.second.substringAfter(' ')), it.second.substringBefore(' '))
-                "deprecated"          -> Deprecated(parseStringToDocNode(it.second))
-                "sample"              -> Sample(parseStringToDocNode(it.second.substringAfter(' ')), it.second.substringBefore(' '))
-                "suppress"            -> Suppress(parseStringToDocNode(it.second))
-                else                  -> CustomTagWrapper(parseStringToDocNode(it.second), it.first)
-            }
-        }
-        return DocumentationNode(mappedList)
-    }
-
-    private fun jkdocToListOfPairs(javadoc: String): List<Pair<String, String>> =
-        "description $javadoc"
-            .split("\n@")
-            .map {
-                it.substringBefore(' ') to it.substringAfter(' ')
-            }
-}
\ No newline at end of file
diff --git a/core/src/main/kotlin/parsers/factories/DocTagsFromIElementFactory.kt b/core/src/main/kotlin/parsers/factories/DocTagsFromIElementFactory.kt
deleted file mode 100644
index dda6c627..00000000
--- a/core/src/main/kotlin/parsers/factories/DocTagsFromIElementFactory.kt
+++ /dev/null
@@ -1,43 +0,0 @@
-package org.jetbrains.dokka.parsers.factories
-
-import org.jetbrains.dokka.model.doc.*
-import org.intellij.markdown.IElementType
-import org.intellij.markdown.MarkdownElementTypes
-import org.intellij.markdown.MarkdownTokenTypes
-import org.intellij.markdown.flavours.gfm.GFMElementTypes
-import org.jetbrains.dokka.links.DRI
-import java.lang.NullPointerException
-
-object DocTagsFromIElementFactory {
-    fun getInstance(type: IElementType, children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap(), body: String? = null, dri: DRI? = null) =
-        when(type) {
-            MarkdownElementTypes.SHORT_REFERENCE_LINK,
-            MarkdownElementTypes.FULL_REFERENCE_LINK,
-            MarkdownElementTypes.INLINE_LINK            -> if(dri == null) A(children, params) else DocumentationLink(dri, children, params)
-            MarkdownElementTypes.STRONG                 -> B(children, params)
-            MarkdownElementTypes.BLOCK_QUOTE            -> BlockQuote(children, params)
-            MarkdownElementTypes.CODE_SPAN,
-            MarkdownElementTypes.CODE_BLOCK,
-            MarkdownElementTypes.CODE_FENCE             -> Code(children, params)
-            MarkdownElementTypes.ATX_1                  -> H1(children, params)
-            MarkdownElementTypes.ATX_2                  -> H2(children, params)
-            MarkdownElementTypes.ATX_3                  -> H3(children, params)
-            MarkdownElementTypes.ATX_4                  -> H4(children, params)
-            MarkdownElementTypes.ATX_5                  -> H5(children, params)
-            MarkdownElementTypes.ATX_6                  -> H6(children, params)
-            MarkdownElementTypes.EMPH                   -> I(children, params)
-            MarkdownElementTypes.IMAGE                  -> Img(children, params)
-            MarkdownElementTypes.LIST_ITEM              -> Li(children, params)
-            MarkdownElementTypes.ORDERED_LIST           -> Ol(children, params)
-            MarkdownElementTypes.UNORDERED_LIST         -> Ul(children, params)
-            MarkdownElementTypes.PARAGRAPH              -> P(children, params)
-            MarkdownTokenTypes.TEXT                     -> Text(body ?: throw NullPointerException("Text body should be at least empty string passed to DocNodes factory!"), children, params )
-            MarkdownTokenTypes.HORIZONTAL_RULE          -> HorizontalRule
-            MarkdownTokenTypes.HARD_LINE_BREAK          -> Br
-            GFMElementTypes.STRIKETHROUGH               -> Strikethrough(children, params)
-            GFMElementTypes.TABLE                       -> Table(children, params)
-            GFMElementTypes.HEADER                      -> Th(children, params)
-            GFMElementTypes.ROW                         -> Tr(children, params)
-            else                                        -> CustomDocTag(children, params)
-        }
-}
\ No newline at end of file
diff --git a/core/src/main/kotlin/parsers/factories/DocTagsFromStringFactory.kt b/core/src/main/kotlin/parsers/factories/DocTagsFromStringFactory.kt
deleted file mode 100644
index 3425f52e..00000000
--- a/core/src/main/kotlin/parsers/factories/DocTagsFromStringFactory.kt
+++ /dev/null
@@ -1,77 +0,0 @@
-package org.jetbrains.dokka.parsers.factories
-
-import org.jetbrains.dokka.model.doc.*
-import org.jetbrains.dokka.links.DRI
-import java.lang.NullPointerException
-
-object DocTagsFromStringFactory {
-    fun getInstance(name: String, children: List<DocTag> = emptyList(), params: Map<String, String> = emptyMap(), body: String? = null, dri: DRI? = null) =
-        when(name) {
-            "a" -> A(children, params)
-            "big" -> Big(children, params)
-            "b" -> B(children, params)
-            "blockquote" -> BlockQuote(children, params)
-            "br" -> Br
-            "cite" -> Cite(children, params)
-            "code" -> Code(children, params)
-            "dd" -> Dd(children, params)
-            "dfn" -> Dfn(children, params)
-            "dir" -> Dir(children, params)
-            "div" -> Div(children, params)
-            "dl" -> Dl(children, params)
-            "dt" -> Dt(children, params)
-            "Em" -> Em(children, params)
-            "font" -> Font(children, params)
-            "footer" -> Footer(children, params)
-            "frame" -> Frame(children, params)
-            "frameset" -> FrameSet(children, params)
-            "h1" -> H1(children, params)
-            "h2" -> H2(children, params)
-            "h3" -> H3(children, params)
-            "h4" -> H4(children, params)
-            "h5" -> H5(children, params)
-            "h6" -> H6(children, params)
-            "head" -> Head(children, params)
-            "header" -> Header(children, params)
-            "html" -> Html(children, params)
-            "i" -> I(children, params)
-            "iframe" -> IFrame(children, params)
-            "img" -> Img(children, params)
-            "input" -> Input(children, params)
-            "li" -> Li(children, params)
-            "link" -> Link(children, params)
-            "listing" -> Listing(children, params)
-            "main" -> Main(children, params)
-            "menu" -> Menu(children, params)
-            "meta" -> Meta(children, params)
-            "nav" -> Nav(children, params)
-            "noframes" -> NoFrames(children, params)
-            "noscript" -> NoScript(children, params)
-            "ol" -> Ol(children, params)
-            "p" -> P(children, params)
-            "pre" -> Pre(children, params)
-            "script" -> Script(children, params)
-            "section" -> Section(children, params)
-            "small" -> Small(children, params)
-            "span" -> Span(children, params)
-            "strong" -> Strong(children, params)
-            "sub" -> Sub(children, params)
-            "sup" -> Sup(children, params)
-            "table" -> Table(children, params)
-            "#text" -> Text(body ?: throw NullPointerException("Text body should be at least empty string passed to DocNodes factory!"), children, params)
-            "tBody" -> TBody(children, params)
-            "td" -> Td(children, params)
-            "tFoot" -> TFoot(children, params)
-            "th" -> Th(children, params)
-            "tHead" -> THead(children, params)
-            "title" -> Title(children, params)
-            "tr" -> Tr(children, params)
-            "tt" -> Tt(children, params)
-            "u" -> U(children, params)
-            "ul" -> Ul(children, params)
-            "var" -> Var(children, params)
-            "documentationlink" -> DocumentationLink(dri ?: throw NullPointerException("DRI cannot be passed null while constructing documentation link!"), children, params)
-            "hr" -> HorizontalRule
-            else -> CustomDocTag(children, params)
-        }
-}
\ No newline at end of file
diff --git a/core/src/main/kotlin/plugability/DokkaContext.kt b/core/src/main/kotlin/plugability/DokkaContext.kt
index 692803dd..a2ff26c7 100644
--- a/core/src/main/kotlin/plugability/DokkaContext.kt
+++ b/core/src/main/kotlin/plugability/DokkaContext.kt
@@ -1,9 +1,7 @@
 package org.jetbrains.dokka.plugability
 
 import org.jetbrains.dokka.DokkaConfiguration
-import org.jetbrains.dokka.EnvironmentAndFacade
 import org.jetbrains.dokka.model.SourceSetCache
-import org.jetbrains.dokka.model.SourceSetData
 import org.jetbrains.dokka.utilities.DokkaLogger
 import java.io.File
 import java.net.URLClassLoader
@@ -23,7 +21,6 @@ interface DokkaContext {
     val sourceSetCache: SourceSetCache
     val logger: DokkaLogger
     val configuration: DokkaConfiguration
-    val platforms: Map<SourceSetData, EnvironmentAndFacade>
     val unusedPoints: Collection<ExtensionPoint<*>>
 
 
@@ -31,11 +28,10 @@ interface DokkaContext {
         fun create(
             configuration: DokkaConfiguration,
             logger: DokkaLogger,
-            sourceSets: Map<SourceSetData, EnvironmentAndFacade>,
             sourceSetsCache: SourceSetCache,
             pluginOverrides: List<DokkaPlugin>
         ): DokkaContext =
-            DokkaContextConfigurationImpl(logger, configuration, sourceSets, sourceSetsCache).apply {
+            DokkaContextConfigurationImpl(logger, configuration, sourceSetsCache).apply {
                 // File(it.path) is a workaround for an incorrect filesystem in a File instance returned by Gradle.
                 configuration.pluginsClasspath.map { File(it.path).toURI().toURL() }
                     .toTypedArray()
@@ -59,7 +55,6 @@ interface DokkaContextConfiguration {
 private class DokkaContextConfigurationImpl(
     override val logger: DokkaLogger,
     override val configuration: DokkaConfiguration,
-    override val platforms: Map<SourceSetData, EnvironmentAndFacade>,
     override val sourceSetCache: SourceSetCache
 ) : DokkaContext, DokkaContextConfiguration {
     private val plugins = mutableMapOf<KClass<*>, DokkaPlugin>()
diff --git a/core/src/main/kotlin/plugability/DokkaPlugin.kt b/core/src/main/kotlin/plugability/DokkaPlugin.kt
index 24f417d8..fe472b12 100644
--- a/core/src/main/kotlin/plugability/DokkaPlugin.kt
+++ b/core/src/main/kotlin/plugability/DokkaPlugin.kt
@@ -2,7 +2,6 @@ package org.jetbrains.dokka.plugability
 
 import com.google.gson.Gson
 import org.jetbrains.dokka.DokkaConfiguration
-import org.jetbrains.kotlin.utils.addToStdlib.cast
 import kotlin.properties.ReadOnlyProperty
 import kotlin.reflect.KProperty
 import kotlin.reflect.KProperty1
@@ -60,8 +59,9 @@ interface ConfigurableBlock
 
 inline fun <reified P : DokkaPlugin, reified T : ConfigurableBlock> Configurable.pluginConfiguration(block: T.() -> Unit) {
     val instance = T::class.createInstance().apply(block)
-    pluginsConfiguration.cast<MutableMap<String, String>>()[P::class.qualifiedName!!] =
-        Gson().toJson(instance, T::class.java)
+
+    val mutablePluginsConfiguration = pluginsConfiguration as MutableMap<String, String>
+    mutablePluginsConfiguration[P::class.qualifiedName!!] = Gson().toJson(instance, T::class.java)
 }
 
 inline fun <reified P : DokkaPlugin, reified E : Any> P.query(extension: P.() -> ExtensionPoint<E>): List<E> =
diff --git a/core/src/main/kotlin/utilities/cast.kt b/core/src/main/kotlin/utilities/cast.kt
new file mode 100644
index 00000000..d4a8d73d
--- /dev/null
+++ b/core/src/main/kotlin/utilities/cast.kt
@@ -0,0 +1,5 @@
+package org.jetbrains.dokka.utilities
+
+inline fun <reified T> Any.cast(): T {
+    return this as T
+}