Metadata: 'non-stable parameter names' flag for callables

^KT-34602
2020-07-20 18:21:34 +07:00
parent 8cace2bab4
commit 3d9093583f
16 changed files with 334 additions and 15 deletions
@@ -0,0 +1,105 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.serialization
+
+import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.descriptors.impl.FunctionDescriptorImpl
+import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
+import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
+import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter.Companion.CLASSIFIERS_MASK
+import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter.Companion.FUNCTIONS_MASK
+import org.jetbrains.kotlin.resolve.scopes.MemberScope
+import org.jetbrains.kotlin.test.KlibTestUtil
+import org.jetbrains.kotlin.test.TestCaseWithTmpdir
+import org.jetbrains.kotlin.utils.addToStdlib.assertedCast
+import org.jetbrains.kotlin.utils.alwaysTrue
+import java.io.File
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+class NonStableParameterNamesSerializationTest : TestCaseWithTmpdir() {
+    fun testNonStableParameterNames() {
+        val originalKlibName = File(SOURCE_FILE).nameWithoutExtension
+        val originalKlibFile = File(tmpdir, "$originalKlibName.klib")
+        KlibTestUtil.compileCommonSourcesToKlib(listOf(File(SOURCE_FILE)), originalKlibName, originalKlibFile)
+
+        val originalModule = KlibTestUtil.deserializeKlibToCommonModule(originalKlibFile)
+        val originalCallables = collectCallablesForPatch(originalModule)
+
+        assertTrue { originalCallables.isNotEmpty() }
+        assertTrue { originalCallables.all { it.hasStableParameterNames() } }
+
+        originalCallables.forEach { it.setHasStableParameterNames(false) }
+
+        val patchedKlibName = "${originalKlibFile.nameWithoutExtension}-patched"
+        val patchedKlibFile = originalKlibFile.resolveSibling("$patchedKlibName.klib")
+        KlibTestUtil.serializeCommonModuleToKlib(originalModule, patchedKlibName, patchedKlibFile)
+
+        val patchedModule = KlibTestUtil.deserializeKlibToCommonModule(patchedKlibFile)
+        val patchedCallables = collectCallablesForPatch(patchedModule)
+
+        assertEquals(expected = originalCallables.size, actual = patchedCallables.size)
+        assertEquals(expected = originalCallables.map { it.signature }.toSet(), actual = patchedCallables.map { it.signature }.toSet())
+        assertTrue { patchedCallables.all { !it.hasStableParameterNames() } }
+    }
+
+    companion object {
+        private const val SOURCE_FILE = "compiler/testData/serialization/nonStableParameterNames/test.kt"
+
+        private fun collectCallablesForPatch(module: ModuleDescriptorImpl): List<FunctionDescriptorImpl> {
+            fun DeclarationDescriptor.castToFunctionImpl(): FunctionDescriptorImpl =
+                assertedCast { "Not an instance of ${FunctionDescriptorImpl::class.java}: ${this::class.java}, $this" }
+
+            val result = mutableListOf<FunctionDescriptorImpl>()
+
+            fun recurse(memberScope: MemberScope) {
+                memberScope
+                    .getContributedDescriptors(DescriptorKindFilter(FUNCTIONS_MASK or CLASSIFIERS_MASK))
+                    .forEach { descriptor ->
+                        when (descriptor) {
+                            is SimpleFunctionDescriptor -> {
+                                if (descriptor.kind != CallableMemberDescriptor.Kind.FAKE_OVERRIDE)
+                                    result += descriptor.castToFunctionImpl()
+                            }
+                            is ClassDescriptor -> {
+                                descriptor.constructors.mapTo(result) { it.castToFunctionImpl() }
+                                recurse(descriptor.unsubstitutedMemberScope)
+                            }
+                        }
+                    }
+            }
+
+            val packageFragmentProvider = module.packageFragmentProviderForModuleContentWithoutDependencies
+
+            fun recurse(packageFqName: FqName) {
+                packageFragmentProvider
+                    .getPackageFragments(packageFqName)
+                    .forEach { packageFragment ->
+                        recurse(packageFragment.getMemberScope())
+                    }
+
+                packageFragmentProvider
+                    .getSubPackagesOf(packageFqName, alwaysTrue())
+                    .toSet()
+                    .forEach { recurse(it) }
+            }
+
+            recurse(FqName.ROOT)
+
+            return result
+        }
+
+        private val FunctionDescriptorImpl.signature: String
+            get() = buildString {
+                append(fqNameSafe)
+                append('(')
+                valueParameters.joinTo(this, ",") { it.type.constructor.declarationDescriptor?.fqNameSafe?.asString().orEmpty() }
+                append(')')
+            }
+    }
+}