[Commonizer] Minor. Rename: 'dependee' -> 'dependency'

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/CommonizerParameters.kt

@@ -17,7 +17,7 @@ class CommonizerParameters(
     val sharedTarget: SharedTarget get() = SharedTarget(_targetProviders.keys)
 
     // common module dependencies (ex: Kotlin stdlib)
-    var dependeeModulesProvider: ModulesProvider? = null
+    var dependencyModulesProvider: ModulesProvider? = null
         set(value) {
             check(field == null)
             field = value

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/TargetProvider.kt

@@ -12,7 +12,7 @@ import java.io.File
 class TargetProvider(
     val target: LeafTarget,
     val modulesProvider: ModulesProvider,
-    val dependeeModulesProvider: ModulesProvider?
+    val dependencyModulesProvider: ModulesProvider?
 )
 
 interface ModulesProvider {

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/CommonizationVisitor.kt

@@ -126,7 +126,7 @@ internal class CommonizationVisitor(
         val supertypesMap: MutableMap<CirType, CommonizedGroup<CirType>> = linkedMapOf() // preserve supertype order
         for ((index, typeAlias) in targetDeclarations.withIndex()) {
             val expandedClassId = typeAlias!!.expandedType.classifierId
-            if (classifiers.commonDependeeLibraries.hasClassifier(expandedClassId))
+            if (classifiers.commonDependencies.hasClassifier(expandedClassId))
                 return null // this case is not supported yet
 
             val expandedClassNode = classifiers.commonized.classNode(expandedClassId) ?: return null

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/TypeCommonizer.kt

@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.descriptors.DescriptorVisibility
 import org.jetbrains.kotlin.descriptors.commonizer.cir.*
 import org.jetbrains.kotlin.descriptors.commonizer.cir.factory.CirTypeFactory
 import org.jetbrains.kotlin.descriptors.commonizer.core.CommonizedTypeAliasAnswer.Companion.FAILURE_MISSING_IN_SOME_TARGET
-import org.jetbrains.kotlin.descriptors.commonizer.core.CommonizedTypeAliasAnswer.Companion.SUCCESS_FROM_DEPENDEE_LIBRARY
+import org.jetbrains.kotlin.descriptors.commonizer.core.CommonizedTypeAliasAnswer.Companion.SUCCESS_FROM_DEPENDENCY_LIBRARY
 import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.CirKnownClassifiers
 import org.jetbrains.kotlin.descriptors.commonizer.utils.isUnderKotlinNativeSyntheticPackages
 
@@ -192,8 +192,8 @@ private class FlexibleTypeCommonizer(classifiers: CirKnownClassifiers) : Abstrac
 }
 
 private fun commonizeClass(classId: CirEntityId, classifiers: CirKnownClassifiers): Boolean {
-    if (classifiers.commonDependeeLibraries.hasClassifier(classId)) {
+    if (classifiers.commonDependencies.hasClassifier(classId)) {
-        // The class is from common fragment of dependee library (ex: stdlib). Already commonized.
+        // The class is from common fragment of dependency library (ex: stdlib). Already commonized.
         return true
     } else if (classId.packageName.isUnderKotlinNativeSyntheticPackages) {
         // C/Obj-C forward declarations are:
@@ -219,9 +219,9 @@ private fun commonizeClass(classId: CirEntityId, classifiers: CirKnownClassifier
 }
 
 private fun commonizeTypeAlias(typeAliasId: CirEntityId, classifiers: CirKnownClassifiers): CommonizedTypeAliasAnswer {
-    if (classifiers.commonDependeeLibraries.hasClassifier(typeAliasId)) {
+    if (classifiers.commonDependencies.hasClassifier(typeAliasId)) {
-        // The type alias is from common fragment of dependee library (ex: stdlib). Already commonized.
+        // The type alias is from common fragment of dependency library (ex: stdlib). Already commonized.
-        return SUCCESS_FROM_DEPENDEE_LIBRARY
+        return SUCCESS_FROM_DEPENDENCY_LIBRARY
     }
 
     return when (val node = classifiers.commonized.typeAliasNode(typeAliasId)) {
@@ -238,7 +238,7 @@ private fun commonizeTypeAlias(typeAliasId: CirEntityId, classifiers: CirKnownCl
 
 private class CommonizedTypeAliasAnswer(val commonized: Boolean, val commonClassifier: CirClassifier?) {
     companion object {
-        val SUCCESS_FROM_DEPENDEE_LIBRARY = CommonizedTypeAliasAnswer(true, null)
+        val SUCCESS_FROM_DEPENDENCY_LIBRARY = CommonizedTypeAliasAnswer(true, null)
         val FAILURE_MISSING_IN_SOME_TARGET = CommonizedTypeAliasAnswer(false, null)
 
         fun create(commonClassifier: CirClassifier?) =

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/core/typeAliasUtils.kt

@@ -25,7 +25,7 @@ internal tailrec fun computeSuitableUnderlyingType(
 ): CirClassOrTypeAliasType? {
     return when (underlyingType) {
         is CirClassType -> underlyingType.withCommonizedArguments(classifiers)
-        is CirTypeAliasType -> if (classifiers.commonDependeeLibraries.hasClassifier(underlyingType.classifierId))
+        is CirTypeAliasType -> if (classifiers.commonDependencies.hasClassifier(underlyingType.classifierId))
             underlyingType.withCommonizedArguments(classifiers)
         else
             computeSuitableUnderlyingType(classifiers, underlyingType.underlyingType)

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/facade.kt

@@ -41,10 +41,10 @@ private fun mergeAndCommonize(storageManager: StorageManager, parameters: Common
     val classifiers = CirKnownClassifiers(
         commonized = CirCommonizedClassifiers.default(),
         forwardDeclarations = CirForwardDeclarations.default(),
-        dependeeLibraries = mapOf(
+        dependencies = mapOf(
-            // for now, supply only common dependee libraries (ex: Kotlin stdlib)
+            // for now, supply only common dependency libraries (ex: Kotlin stdlib)
             parameters.sharedTarget to CirProvidedClassifiers.fromModules(storageManager) {
-                parameters.dependeeModulesProvider?.loadModules(emptyList())?.values.orEmpty()
+                parameters.dependencyModulesProvider?.loadModules(emptyList())?.values.orEmpty()
             }
         )
     )

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/konan/NativeDistributionCommonizer.kt

@@ -135,7 +135,7 @@ class NativeDistributionCommonizer(
                 copyEndorsedLibs = copyEndorsedLibs,
                 logProgress = ::logProgress
             )
-            dependeeModulesProvider = NativeDistributionModulesProvider.forStandardLibrary(storageManager, allLibraries.stdlib)
+            dependencyModulesProvider = NativeDistributionModulesProvider.forStandardLibrary(storageManager, allLibraries.stdlib)
 
             allLibraries.librariesByTargets.forEach { (target, librariesToCommonize) ->
                 if (librariesToCommonize.libraries.isEmpty()) return@forEach
@@ -146,7 +146,7 @@ class NativeDistributionCommonizer(
                     TargetProvider(
                         target = target,
                         modulesProvider = modulesProvider,
-                        dependeeModulesProvider = null // stdlib is already set as common dependency
+                        dependencyModulesProvider = null // stdlib is already set as common dependency
                     )
                 )
             }

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/mergedtree/CirTreeMerger.kt

@@ -63,11 +63,11 @@ class CirTreeMerger(
     private fun processRoot(): CirTreeMergeResult {
         val rootNode: CirRootNode = buildRootNode(storageManager, size)
 
-        // remember any exported forward declarations from common fragments of dependee modules
+        // remember any exported forward declarations from common fragments of dependency modules
-        parameters.dependeeModulesProvider?.loadModuleInfos()?.forEach(::processCInteropModuleAttributes)
+        parameters.dependencyModulesProvider?.loadModuleInfos()?.forEach(::processCInteropModuleAttributes)
 
         // load common dependencies
-        val dependeeModules = parameters.dependeeModulesProvider?.loadModules(emptyList())?.values.orEmpty()
+        val dependencyModules = parameters.dependencyModulesProvider?.loadModules(emptyList())?.values.orEmpty()
 
         val allModuleInfos: List<Map<String, ModuleInfo>> = parameters.targetProviders.map { targetProvider ->
             targetProvider.modulesProvider.loadModuleInfos().associateBy { it.name }
@@ -76,7 +76,7 @@ class CirTreeMerger(
 
         parameters.targetProviders.forEachIndexed { targetIndex, targetProvider ->
             val commonModuleInfos = allModuleInfos[targetIndex].filterKeys { it in commonModuleNames }
-            processTarget(rootNode, targetIndex, targetProvider, commonModuleInfos, dependeeModules)
+            processTarget(rootNode, targetIndex, targetProvider, commonModuleInfos, dependencyModules)
             parameters.progressLogger?.invoke("Loaded declarations for ${targetProvider.target.prettyName}")
             System.gc()
         }
@@ -98,14 +98,14 @@ class CirTreeMerger(
         targetIndex: Int,
         targetProvider: TargetProvider,
         commonModuleInfos: Map<String, ModuleInfo>,
-        dependeeModules: Collection<ModuleDescriptor>
+        dependencyModules: Collection<ModuleDescriptor>
     ) {
         rootNode.targetDeclarations[targetIndex] = CirRootFactory.create(targetProvider.target)
 
-        val targetDependeeModules = targetProvider.dependeeModulesProvider?.loadModules(dependeeModules)?.values.orEmpty()
+        val targetDependencyModules = targetProvider.dependencyModulesProvider?.loadModules(dependencyModules)?.values.orEmpty()
-        val allDependeeModules = targetDependeeModules + dependeeModules
+        val allDependencyModules = targetDependencyModules + dependencyModules
 
-        val moduleDescriptors: Map<String, ModuleDescriptor> = targetProvider.modulesProvider.loadModules(allDependeeModules)
+        val moduleDescriptors: Map<String, ModuleDescriptor> = targetProvider.modulesProvider.loadModules(allDependencyModules)
 
         moduleDescriptors.forEach { (name, moduleDescriptor) ->
             val moduleInfo = commonModuleInfos[name] ?: return@forEach

native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/mergedtree/classifierContainers.kt

@@ -21,11 +21,11 @@ import org.jetbrains.kotlin.storage.getValue
 class CirKnownClassifiers(
     val commonized: CirCommonizedClassifiers,
     val forwardDeclarations: CirForwardDeclarations,
-    val dependeeLibraries: Map<CommonizerTarget, CirProvidedClassifiers>
+    val dependencies: Map<CommonizerTarget, CirProvidedClassifiers>
 ) {
     // a shortcut for fast access
-    val commonDependeeLibraries: CirProvidedClassifiers =
+    val commonDependencies: CirProvidedClassifiers =
-        dependeeLibraries.filterKeys { it is SharedTarget }.values.singleOrNull() ?: CirProvidedClassifiers.EMPTY
+        dependencies.filterKeys { it is SharedTarget }.values.singleOrNull() ?: CirProvidedClassifiers.EMPTY
 }
 
 interface CirCommonizedClassifiers {

native/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/AbstractCommonizationFromSourcesTest.kt

@@ -118,7 +118,7 @@ private data class SourceModuleRoot(
 private class SourceModuleRoots(
     val originalRoots: Map<LeafTarget, SourceModuleRoot>,
     val commonizedRoots: Map<CommonizerTarget, SourceModuleRoot>,
-    val dependeeRoots: Map<CommonizerTarget, SourceModuleRoot>
+    val dependencyRoots: Map<CommonizerTarget, SourceModuleRoot>
 ) {
     val leafTargets: Set<LeafTarget> = originalRoots.keys
     val sharedTarget: SharedTarget
@@ -135,7 +135,7 @@ private class SourceModuleRoots(
 
         val allTargets = leafTargets + sharedTarget
         check(commonizedRoots.keys == allTargets)
-        check(allTargets.containsAll(dependeeRoots.keys))
+        check(allTargets.containsAll(dependencyRoots.keys))
     }
 
     companion object {
@@ -149,16 +149,16 @@ private class SourceModuleRoots(
                 if (targetName == SHARED_TARGET_NAME) sharedTarget else leafTargets.first { it.name == targetName }
 
             val commonizedRoots = listRoots(dataDir, COMMONIZED_ROOTS_DIR).mapKeys { getTarget(it.key) }
-            val dependeeRoots = listRoots(dataDir, DEPENDEE_ROOTS_DIR).mapKeys { getTarget(it.key) }
+            val dependencyRoots = listRoots(dataDir, DEPENDENCY_ROOTS_DIR).mapKeys { getTarget(it.key) }
 
-            SourceModuleRoots(originalRoots, commonizedRoots, dependeeRoots)
+            SourceModuleRoots(originalRoots, commonizedRoots, dependencyRoots)
         } catch (e: Exception) {
             fail("Source module misconfiguration in $dataDir", cause = e)
         }
 
         private const val ORIGINAL_ROOTS_DIR = "original"
         private const val COMMONIZED_ROOTS_DIR = "commonized"
-        private const val DEPENDEE_ROOTS_DIR = "dependee"
+        private const val DEPENDENCY_ROOTS_DIR = "dependency"
 
         private fun listRoots(dataDir: File, rootsDirName: String): Map<String, SourceModuleRoot> =
             dataDir.resolve(rootsDirName).listFiles()?.toSet().orEmpty().map(SourceModuleRoot::load).associateBy { it.targetName }
@@ -183,7 +183,7 @@ private class AnalyzedModuleDependencies(
 private class AnalyzedModules(
     val originalModules: Map<CommonizerTarget, ModuleDescriptor>,
     val commonizedModules: Map<CommonizerTarget, SerializedMetadata>,
-    val dependeeModules: Map<CommonizerTarget, List<ModuleDescriptor>>
+    val dependencyModules: Map<CommonizerTarget, List<ModuleDescriptor>>
 ) {
     val leafTargets: Set<LeafTarget>
     val sharedTarget: SharedTarget
@@ -200,13 +200,13 @@ private class AnalyzedModules(
         val allTargets = leafTargets + sharedTarget
 
         check(commonizedModules.keys == allTargets)
-        check(allTargets.containsAll(dependeeModules.keys))
+        check(allTargets.containsAll(dependencyModules.keys))
     }
 
     fun toCommonizerParameters(resultsConsumer: ResultsConsumer) =
         CommonizerParameters().also { parameters ->
             parameters.resultsConsumer = resultsConsumer
-            parameters.dependeeModulesProvider = dependeeModules[sharedTarget]?.let(MockModulesProvider::create)
+            parameters.dependencyModulesProvider = dependencyModules[sharedTarget]?.let(MockModulesProvider::create)
 
             leafTargets.forEach { leafTarget ->
                 val originalModule = originalModules.getValue(leafTarget)
@@ -215,7 +215,7 @@ private class AnalyzedModules(
                     TargetProvider(
                         target = leafTarget,
                         modulesProvider = MockModulesProvider.create(originalModule),
-                        dependeeModulesProvider = dependeeModules[leafTarget]?.let(MockModulesProvider::create)
+                        dependencyModulesProvider = dependencyModules[leafTarget]?.let(MockModulesProvider::create)
                     )
                 )
             }
@@ -227,8 +227,8 @@ private class AnalyzedModules(
             parentDisposable: Disposable
         ): AnalyzedModules = with(sourceModuleRoots) {
             // phase 1: provide the modules that are the dependencies for "original" and "commonized" modules
-            val (dependeeModules: Map<CommonizerTarget, List<ModuleDescriptor>>, dependencies: AnalyzedModuleDependencies) =
+            val (dependencyModules: Map<CommonizerTarget, List<ModuleDescriptor>>, dependencies: AnalyzedModuleDependencies) =
-                createDependeeModules(sharedTarget, dependeeRoots, parentDisposable)
+                createDependencyModules(sharedTarget, dependencyRoots, parentDisposable)
 
             // phase 2: build "original" and "commonized" modules
             val originalModules: Map<CommonizerTarget, ModuleDescriptor> =
@@ -238,27 +238,27 @@ private class AnalyzedModules(
                 createModules(sharedTarget, commonizedRoots, dependencies, parentDisposable)
                     .mapValues { (_, moduleDescriptor) -> MockModulesProvider.SERIALIZER.serializeModule(moduleDescriptor) }
 
-            return AnalyzedModules(originalModules, commonizedModules, dependeeModules)
+            return AnalyzedModules(originalModules, commonizedModules, dependencyModules)
         }
 
-        private fun createDependeeModules(
+        private fun createDependencyModules(
             sharedTarget: SharedTarget,
-            dependeeRoots: Map<out CommonizerTarget, SourceModuleRoot>,
+            dependencyRoots: Map<out CommonizerTarget, SourceModuleRoot>,
             parentDisposable: Disposable
         ): Pair<Map<CommonizerTarget, List<ModuleDescriptor>>, AnalyzedModuleDependencies> {
-            val customDependeeModules =
+            val customDependencyModules =
-                createModules(sharedTarget, dependeeRoots, AnalyzedModuleDependencies.EMPTY, parentDisposable, isDependeeModule = true)
+                createModules(sharedTarget, dependencyRoots, AnalyzedModuleDependencies.EMPTY, parentDisposable, isDependencyModule = true)
 
             val stdlibModule = DefaultBuiltIns.Instance.builtInsModule
 
-            val dependeeModules = (sharedTarget.targets + sharedTarget).associateWith { target ->
+            val dependencyModules = (sharedTarget.targets + sharedTarget).associateWith { target ->
                 // prepend stdlib for each target explicitly, so that the commonizer can see symbols from the stdlib
-                listOfNotNull(stdlibModule, customDependeeModules[target])
+                listOfNotNull(stdlibModule, customDependencyModules[target])
             }
 
-            return dependeeModules to AnalyzedModuleDependencies(
+            return dependencyModules to AnalyzedModuleDependencies(
-                regularDependencies = dependeeModules,
+                regularDependencies = dependencyModules,
-                expectByDependencies = dependeeModules.getValue(sharedTarget).filter { module -> module !== stdlibModule }
+                expectByDependencies = dependencyModules.getValue(sharedTarget).filter { module -> module !== stdlibModule }
             )
         }
 
@@ -267,7 +267,7 @@ private class AnalyzedModules(
             moduleRoots: Map<out CommonizerTarget, SourceModuleRoot>,
             dependencies: AnalyzedModuleDependencies,
             parentDisposable: Disposable,
-            isDependeeModule: Boolean = false
+            isDependencyModule: Boolean = false
         ): Map<CommonizerTarget, ModuleDescriptor> {
             val result = mutableMapOf<CommonizerTarget, ModuleDescriptor>()
 
@@ -275,7 +275,7 @@ private class AnalyzedModules(
 
             // first, process the common module
             moduleRoots[sharedTarget]?.let { moduleRoot ->
-                val commonModule = createModule(sharedTarget, sharedTarget, moduleRoot, dependencies, parentDisposable, isDependeeModule)
+                val commonModule = createModule(sharedTarget, sharedTarget, moduleRoot, dependencies, parentDisposable, isDependencyModule)
                 result[sharedTarget] = commonModule
                 dependenciesForOthers = dependencies.withExpectByDependency(commonModule)
             }
@@ -283,7 +283,7 @@ private class AnalyzedModules(
             // then, all platform modules
             moduleRoots.filterKeys { it != sharedTarget }.forEach { (leafTarget, moduleRoot) ->
                 result[leafTarget] =
-                    createModule(sharedTarget, leafTarget, moduleRoot, dependenciesForOthers, parentDisposable, isDependeeModule)
+                    createModule(sharedTarget, leafTarget, moduleRoot, dependenciesForOthers, parentDisposable, isDependencyModule)
             }
 
             return result
@@ -295,10 +295,10 @@ private class AnalyzedModules(
             moduleRoot: SourceModuleRoot,
             dependencies: AnalyzedModuleDependencies,
             parentDisposable: Disposable,
-            isDependeeModule: Boolean
+            isDependencyModule: Boolean
         ): ModuleDescriptor {
             val moduleName: String = moduleRoot.location.parentFile.parentFile.name.let {
-                if (isDependeeModule) "dependee-$it" else it
+                if (isDependencyModule) "dependency-$it" else it
             }
             check(Name.isValidIdentifier(moduleName))
 
@@ -329,7 +329,7 @@ private class AnalyzedModules(
                 environment.createPackagePartProvider(content.moduleContentScope)
             }.moduleDescriptor
 
-            if (!isDependeeModule)
+            if (!isDependencyModule)
                 module.accept(PatchingTestDescriptorVisitor, Unit)
 
             return module

native/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/CommonizerFacadeTest.kt

@@ -71,7 +71,7 @@ class CommonizerFacadeTest {
                         TargetProvider(
                             target = LeafTarget(targetName),
                             modulesProvider = MockModulesProvider.create(moduleNames),
-                            dependeeModulesProvider = null
+                            dependencyModulesProvider = null
                         )
                     )
                 }

native/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/core/TypeCommonizerTest.kt

@@ -35,7 +35,7 @@ class TypeCommonizerTest : AbstractCommonizerTest<CirType, CirType>() {
         classifiers = CirKnownClassifiers(
             commonized = CirCommonizedClassifiers.default(),
             forwardDeclarations = CirForwardDeclarations.default(),
-            dependeeLibraries = mapOf(
+            dependencies = mapOf(
                 FAKE_SHARED_TARGET to object : CirProvidedClassifiers {
                     override fun hasClassifier(classifierId: CirEntityId): Boolean = classifierId.packageName.isUnderStandardKotlinPackages
                 }

native/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/utils/mocks.kt

@@ -150,7 +150,7 @@ internal val MOCK_CLASSIFIERS = CirKnownClassifiers(
         override fun isExportedForwardDeclaration(classId: CirEntityId) = false
         override fun addExportedForwardDeclaration(classId: CirEntityId) = error("This method should not be called")
     },
-    dependeeLibraries = emptyMap()
+    dependencies = emptyMap()
 )
 
 internal class MockModulesProvider private constructor(