From 3debca09eaf256e4628f15f27160c85ecfa8ea25 Mon Sep 17 00:00:00 2001 From: Dmitry Jemerov Date: Wed, 26 Jul 2017 12:24:42 +0200 Subject: [PATCH] Remove callback hell from LazyModuleDependencies --- .../kotlin/analyzer/AnalyzerFacade.kt | 79 ++++++++++++------- .../descriptors/impl/ModuleDescriptorImpl.kt | 15 ---- 2 files changed, 50 insertions(+), 44 deletions(-) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/analyzer/AnalyzerFacade.kt b/compiler/frontend/src/org/jetbrains/kotlin/analyzer/AnalyzerFacade.kt index 0d691b15185..c45fce6ae18 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/analyzer/AnalyzerFacade.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/analyzer/AnalyzerFacade.kt @@ -32,7 +32,7 @@ import org.jetbrains.kotlin.descriptors.ModuleDescriptor import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor import org.jetbrains.kotlin.descriptors.PackageFragmentProvider import org.jetbrains.kotlin.descriptors.PackagePartProvider -import org.jetbrains.kotlin.descriptors.impl.LazyModuleDependencies +import org.jetbrains.kotlin.descriptors.impl.ModuleDependencies import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name @@ -42,6 +42,7 @@ import org.jetbrains.kotlin.resolve.MultiTargetPlatform import org.jetbrains.kotlin.resolve.TargetEnvironment import org.jetbrains.kotlin.resolve.TargetPlatform import org.jetbrains.kotlin.storage.NotNullLazyValue +import org.jetbrains.kotlin.storage.StorageManager import org.jetbrains.kotlin.utils.keysToMap import java.util.* import kotlin.coroutines.experimental.buildSequence @@ -183,34 +184,10 @@ abstract class AnalyzerFacade { val moduleDescriptor = resolverForProject.descriptorForModule(module) moduleDescriptor.setDependencies(LazyModuleDependencies( storageManager, - computeDependencies = { - buildSequence { - if (firstDependency != null) { - yield(resolverForProject.descriptorForModule(firstDependency)) - } - if (module.dependencyOnBuiltIns() == ModuleInfo.DependencyOnBuiltIns.AFTER_SDK) { - yield(moduleDescriptor.builtIns.builtInsModule) - } - for (dependency in module.dependencies()) { - yield(resolverForProject.descriptorForModule(dependency as M)) - } - if (module.dependencyOnBuiltIns() == ModuleInfo.DependencyOnBuiltIns.LAST) { - yield(moduleDescriptor.builtIns.builtInsModule) - } - }.toList() - }, - computeModulesWhoseInternalsAreVisible = { - module.modulesWhoseInternalsAreVisible().mapTo(LinkedHashSet()) { - resolverForProject.descriptorForModule(it as M) - } - }, - computeImplementingModules = { - if (modulePlatforms(module) != MultiTargetPlatform.Common) emptySet() - else modules - .filter { modulePlatforms(it) != MultiTargetPlatform.Common && module in it.dependencies() } - .mapTo(mutableSetOf(), resolverForProject::descriptorForModule) - } - )) + module, + modulePlatforms, + firstDependency, + resolverForProject)) } for (module in modules) { @@ -251,6 +228,50 @@ abstract class AnalyzerFacade { abstract val targetPlatform: TargetPlatform } +class LazyModuleDependencies( + storageManager: StorageManager, + module: M, + modulePlatforms: (M) -> MultiTargetPlatform?, + firstDependency: M? = null, + resolverForProject: ResolverForProjectImpl +) : ModuleDependencies { + private val dependencies = storageManager.createLazyValue { + val moduleDescriptor = resolverForProject.descriptorForModule(module) + buildSequence { + if (firstDependency != null) { + yield(resolverForProject.descriptorForModule(firstDependency)) + } + if (module.dependencyOnBuiltIns() == ModuleInfo.DependencyOnBuiltIns.AFTER_SDK) { + yield(moduleDescriptor.builtIns.builtInsModule) + } + for (dependency in module.dependencies()) { + yield(resolverForProject.descriptorForModule(dependency as M)) + } + if (module.dependencyOnBuiltIns() == ModuleInfo.DependencyOnBuiltIns.LAST) { + yield(moduleDescriptor.builtIns.builtInsModule) + } + }.toList() + } + + private val visibleInternals = storageManager.createLazyValue { + module.modulesWhoseInternalsAreVisible().mapTo(LinkedHashSet()) { + resolverForProject.descriptorForModule(it as M) + } + } + + private val implementingModules = storageManager.createLazyValue { + if (modulePlatforms(module) != MultiTargetPlatform.Common) emptySet() + else resolverForProject.descriptorByModule.keys + .filter { modulePlatforms(it) != MultiTargetPlatform.Common && module in it.dependencies() } + .mapTo(mutableSetOf(), resolverForProject::descriptorForModule) + } + + override val allDependencies: List get() = dependencies() + override val modulesWhoseInternalsAreVisible: Set get() = visibleInternals() + override val allImplementingModules: Set get() = implementingModules() +} + + private class DelegatingPackageFragmentProvider( moduleContent: ModuleContent, private val packageOracle: PackageOracle, diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ModuleDescriptorImpl.kt b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ModuleDescriptorImpl.kt index 17ccc4658e8..f61eaaa28f6 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ModuleDescriptorImpl.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ModuleDescriptorImpl.kt @@ -135,18 +135,3 @@ class ModuleDependenciesImpl( ) : ModuleDependencies { override val allImplementingModules: Set = emptySet() } - -class LazyModuleDependencies( - storageManager: StorageManager, - computeDependencies: () -> List, - computeModulesWhoseInternalsAreVisible: () -> Set, - computeImplementingModules: () -> Set -) : ModuleDependencies { - private val dependencies = storageManager.createLazyValue(computeDependencies) - private val visibleInternals = storageManager.createLazyValue(computeModulesWhoseInternalsAreVisible) - private val implementingModules = storageManager.createLazyValue(computeImplementingModules) - - override val allDependencies: List get() = dependencies() - override val modulesWhoseInternalsAreVisible: Set get() = visibleInternals() - override val allImplementingModules: Set get() = implementingModules() -}