Use correct naming for additional built-in member lists

compiler/fir/jvm/src/org/jetbrains/kotlin/fir/scopes/jvm/JvmMappedScope.kt

@@ -19,14 +19,14 @@ class JvmMappedScope(
 ) : FirTypeScope() {
 
     override fun processFunctionsByName(name: Name, processor: (FirFunctionSymbol<*>) -> Unit) {
-        val whiteListSignatures = signatures.whiteListSignaturesByName[name]
+        val visibleMethods = signatures.visibleMethodSignaturesByName[name]
             ?: return declaredMemberScope.processFunctionsByName(name, processor)
         javaMappedClassUseSiteScope.processFunctionsByName(name) { symbol ->
             val jvmSignature = symbol.fir.computeJvmDescriptor()
                 .replace("kotlin/Any", "java/lang/Object")
                 .replace("kotlin/String", "java/lang/String")
                 .replace("kotlin/Throwable", "java/lang/Throwable")
-            if (jvmSignature in whiteListSignatures) {
+            if (jvmSignature in visibleMethods) {
                 processor(symbol)
             }
         }
@@ -40,14 +40,14 @@ class JvmMappedScope(
     ) = ProcessorAction.NONE
 
     override fun processDeclaredConstructors(processor: (FirConstructorSymbol) -> Unit) {
-        val constructorBlackList = signatures.constructorBlackList
-        if (constructorBlackList.isNotEmpty()) {
+        val hiddenConstructors = signatures.hiddenConstructors
+        if (hiddenConstructors.isNotEmpty()) {
             javaMappedClassUseSiteScope.processDeclaredConstructors { symbol ->
                 val jvmSignature = symbol.fir.computeJvmDescriptor()
                     .replace("kotlin/Any", "java/lang/Object")
                     .replace("kotlin/String", "java/lang/String")
                     .replace("kotlin/Throwable", "java/lang/Throwable")
-                if (jvmSignature !in constructorBlackList) {
+                if (jvmSignature !in hiddenConstructors) {
                     processor(symbol)
                 }
             }
@@ -80,14 +80,14 @@ class JvmMappedScope(
     }
 
     companion object {
-        data class Signatures(val whiteListSignaturesByName: Map<Name, Set<String>>, val constructorBlackList: Set<String>) {
-            fun isEmpty() = whiteListSignaturesByName.isEmpty() && constructorBlackList.isEmpty()
+        data class Signatures(val visibleMethodSignaturesByName: Map<Name, Set<String>>, val hiddenConstructors: Set<String>) {
+            fun isEmpty() = visibleMethodSignaturesByName.isEmpty() && hiddenConstructors.isEmpty()
             fun isNotEmpty() = !isEmpty()
         }
 
         // NOTE: No-arg constructors
         @OptIn(ExperimentalStdlibApi::class)
-        private val additionalConstructorBlackList = buildSet<String> {
+        private val additionalHiddenConstructors = buildSet<String> {
             // kotlin.text.String pseudo-constructors should be used instead of java.lang.String constructors
             listOf(
                 "",
@@ -113,22 +113,22 @@ class JvmMappedScope(
         fun prepareSignatures(klass: FirRegularClass): Signatures {
 
             val signaturePrefix = klass.symbol.classId.toString()
-            val whiteListSignaturesByName = mutableMapOf<Name, MutableSet<String>>()
-            JvmBuiltInsSignatures.WHITE_LIST_METHOD_SIGNATURES.filter { signature ->
+            val visibleMethodsByName = mutableMapOf<Name, MutableSet<String>>()
+            JvmBuiltInsSignatures.VISIBLE_METHOD_SIGNATURES.filter { signature ->
                 signature.startsWith(signaturePrefix)
             }.map { signature ->
                 // +1 to delete dot before function name
                 signature.substring(signaturePrefix.length + 1)
             }.forEach {
-                whiteListSignaturesByName.getOrPut(Name.identifier(it.substringBefore("("))) { mutableSetOf() }.add(it)
+                visibleMethodsByName.getOrPut(Name.identifier(it.substringBefore("("))) { mutableSetOf() }.add(it)
             }
 
-            val constructorBlackList =
-                (JvmBuiltInsSignatures.BLACK_LIST_CONSTRUCTOR_SIGNATURES + additionalConstructorBlackList)
+            val hiddenConstructors =
+                (JvmBuiltInsSignatures.HIDDEN_CONSTRUCTOR_SIGNATURES + additionalHiddenConstructors)
                     .filter { it.startsWith(signaturePrefix) }
                     .mapTo(mutableSetOf()) { it.substring(signaturePrefix.length + 1) }
 
-            return Signatures(whiteListSignaturesByName, constructorBlackList)
+            return Signatures(visibleMethodsByName, hiddenConstructors)
         }
     }
 }

compiler/tests-java8/tests/org/jetbrains/kotlin/serialization/builtins/AdditionalBuiltInsMembersSignatureListsTest.kt

@@ -38,22 +38,21 @@ class AdditionalBuiltInsMembersSignatureListsTest : KotlinTestWithEnvironment()
     fun testAllListedSignaturesExistInJdk() {
         val module = JvmResolveUtil.analyze(environment).moduleDescriptor as ModuleDescriptorImpl
 
-        val blackList =
-                JvmBuiltInsSignatures.BLACK_LIST_METHOD_SIGNATURES +
-                JvmBuiltInsSignatures.MUTABLE_METHOD_SIGNATURES +
-                JvmBuiltInsSignatures.BLACK_LIST_CONSTRUCTOR_SIGNATURES +
-                JvmBuiltInsSignatures.WHITE_LIST_METHOD_SIGNATURES +
-                JvmBuiltInsSignatures.WHITE_LIST_CONSTRUCTOR_SIGNATURES
+        val hiddenSignatures =
+            JvmBuiltInsSignatures.HIDDEN_METHOD_SIGNATURES +
+                    JvmBuiltInsSignatures.MUTABLE_METHOD_SIGNATURES +
+                    JvmBuiltInsSignatures.HIDDEN_CONSTRUCTOR_SIGNATURES +
+                    JvmBuiltInsSignatures.VISIBLE_METHOD_SIGNATURES +
+                    JvmBuiltInsSignatures.VISIBLE_CONSTRUCTOR_SIGNATURES
 
-        val groupedByInternalName = blackList.groupBy({ it.split(".")[0] }) { it.split(".")[1] }
+        val groupedByInternalName = hiddenSignatures.groupBy({ it.split(".")[0] }) { it.split(".")[1] }
 
-        groupedByInternalName.entries.forEach {
-            it ->
+        groupedByInternalName.entries.forEach { it ->
             val (internalName, jvmDescriptors) = it
             val classDescriptor =
-                    module.resolveClassByFqName(
-                            JvmClassName.byInternalName(internalName).fqNameForClassNameWithoutDollars, NoLookupLocation.FROM_TEST
-                    )!!
+                module.resolveClassByFqName(
+                    JvmClassName.byInternalName(internalName).fqNameForClassNameWithoutDollars, NoLookupLocation.FROM_TEST
+                )!!
 
             val scope = classDescriptor.unsubstitutedMemberScope
 
@@ -64,10 +63,10 @@ class AdditionalBuiltInsMembersSignatureListsTest : KotlinTestWithEnvironment()
 
                 val stringName = jvmDescriptor.split("(")[0]
                 val functions =
-                        if (stringName == "<init>")
-                            classDescriptor.constructors
-                        else
-                            scope.getContributedFunctions(Name.identifier(stringName), NoLookupLocation.FROM_TEST)
+                    if (stringName == "<init>")
+                        classDescriptor.constructors
+                    else
+                        scope.getContributedFunctions(Name.identifier(stringName), NoLookupLocation.FROM_TEST)
 
                 functions.singleOrNull {
                     it.isEffectivelyPublicApi && it.computeJvmDescriptor() == jvmDescriptor

core/compiler.common.jvm/src/org/jetbrains/kotlin/builtins/jvm/JvmBuiltInsSignatures.kt

@@ -20,7 +20,7 @@ object JvmBuiltInsSignatures {
             "toArray()[Ljava/lang/Object;", "toArray([Ljava/lang/Object;)[Ljava/lang/Object;"
         ) + "java/lang/annotation/Annotation.annotationType()Ljava/lang/Class;"
 
-    val BLACK_LIST_METHOD_SIGNATURES: Set<String> =
+    val HIDDEN_METHOD_SIGNATURES: Set<String> =
         signatures {
             buildPrimitiveValueMethodsSet() +
 
@@ -62,7 +62,7 @@ object JvmBuiltInsSignatures {
         }
 
 
-    val WHITE_LIST_METHOD_SIGNATURES: Set<String> =
+    val VISIBLE_METHOD_SIGNATURES: Set<String> =
         signatures {
             inJavaLang(
                 "CharSequence",
@@ -132,7 +132,7 @@ object JvmBuiltInsSignatures {
                     )
         }
 
-    val BLACK_LIST_CONSTRUCTOR_SIGNATURES: Set<String> =
+    val HIDDEN_CONSTRUCTOR_SIGNATURES: Set<String> =
         signatures {
             buildPrimitiveStringConstructorsSet() +
                     inJavaLang("Float", *constructors("D")) +
@@ -149,7 +149,7 @@ object JvmBuiltInsSignatures {
                     )
         }
 
-    val WHITE_LIST_CONSTRUCTOR_SIGNATURES: Set<String> =
+    val VISIBLE_CONSTRUCTOR_SIGNATURES: Set<String> =
         signatures {
             inJavaLang("Throwable", *constructors("Ljava/lang/String;Ljava/lang/Throwable;ZZ"))
         }

core/descriptors.jvm/src/org/jetbrains/kotlin/builtins/jvm/JvmBuiltInsSettings.kt

@@ -6,12 +6,12 @@
 package org.jetbrains.kotlin.builtins.jvm
 
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
-import org.jetbrains.kotlin.builtins.jvm.JvmBuiltInsSignatures.BLACK_LIST_CONSTRUCTOR_SIGNATURES
-import org.jetbrains.kotlin.builtins.jvm.JvmBuiltInsSignatures.BLACK_LIST_METHOD_SIGNATURES
 import org.jetbrains.kotlin.builtins.jvm.JvmBuiltInsSignatures.DROP_LIST_METHOD_SIGNATURES
+import org.jetbrains.kotlin.builtins.jvm.JvmBuiltInsSignatures.HIDDEN_CONSTRUCTOR_SIGNATURES
+import org.jetbrains.kotlin.builtins.jvm.JvmBuiltInsSignatures.HIDDEN_METHOD_SIGNATURES
 import org.jetbrains.kotlin.builtins.jvm.JvmBuiltInsSignatures.MUTABLE_METHOD_SIGNATURES
-import org.jetbrains.kotlin.builtins.jvm.JvmBuiltInsSignatures.WHITE_LIST_CONSTRUCTOR_SIGNATURES
-import org.jetbrains.kotlin.builtins.jvm.JvmBuiltInsSignatures.WHITE_LIST_METHOD_SIGNATURES
+import org.jetbrains.kotlin.builtins.jvm.JvmBuiltInsSignatures.VISIBLE_CONSTRUCTOR_SIGNATURES
+import org.jetbrains.kotlin.builtins.jvm.JvmBuiltInsSignatures.VISIBLE_METHOD_SIGNATURES
 import org.jetbrains.kotlin.builtins.jvm.JvmBuiltInsSignatures.isArrayOrPrimitiveArray
 import org.jetbrains.kotlin.builtins.jvm.JvmBuiltInsSignatures.isSerializableInJava
 import org.jetbrains.kotlin.descriptors.*
@@ -136,8 +136,8 @@ open class JvmBuiltInsSettings(
 
                 val memberStatus = additionalMember.getJdkMethodStatus()
                 when (memberStatus) {
-                    JDKMemberStatus.BLACK_LIST -> {
-                        // Black list methods in final class can't be overridden or called with 'super'
+                    JDKMemberStatus.HIDDEN -> {
+                        // hidden methods in final class can't be overridden or called with 'super'
                         if (classDescriptor.isFinalClass) return@mapNotNull null
                         setHiddenForResolutionEverywhereBesideSupercalls()
                     }
@@ -148,7 +148,7 @@ open class JvmBuiltInsSettings(
 
                     JDKMemberStatus.DROP -> return@mapNotNull null
 
-                    JDKMemberStatus.WHITE_LIST -> Unit // Do nothing
+                    JDKMemberStatus.VISIBLE -> Unit // Do nothing
                 }
 
             }.build()!!
@@ -229,7 +229,7 @@ open class JvmBuiltInsSettings(
         return DFS.dfs<ClassDescriptor, JDKMemberStatus>(
             listOf(owner),
             {
-                // Search through mapped supertypes to determine that Set.toArray is in blacklist, while we have only
+                // Search through mapped supertypes to determine that Set.toArray should be invisible, while we have only
                 // Collection.toArray there explicitly
                 // Note, that we can't find j.u.Collection.toArray within overriddenDescriptors of j.u.Set.toArray
                 it.typeConstructor.supertypes.mapNotNull {
@@ -240,8 +240,8 @@ open class JvmBuiltInsSettings(
                 override fun beforeChildren(javaClassDescriptor: ClassDescriptor): Boolean {
                     val signature = SignatureBuildingComponents.signature(javaClassDescriptor, jvmDescriptor)
                     when (signature) {
-                        in BLACK_LIST_METHOD_SIGNATURES -> result = JDKMemberStatus.BLACK_LIST
-                        in WHITE_LIST_METHOD_SIGNATURES -> result = JDKMemberStatus.WHITE_LIST
+                        in HIDDEN_METHOD_SIGNATURES -> result = JDKMemberStatus.HIDDEN
+                        in VISIBLE_METHOD_SIGNATURES -> result = JDKMemberStatus.VISIBLE
                         in DROP_LIST_METHOD_SIGNATURES -> result = JDKMemberStatus.DROP
                     }
 
@@ -253,7 +253,7 @@ open class JvmBuiltInsSettings(
     }
 
     private enum class JDKMemberStatus {
-        BLACK_LIST, WHITE_LIST, NOT_CONSIDERED, DROP
+        HIDDEN, VISIBLE, NOT_CONSIDERED, DROP
     }
 
     private fun ClassDescriptor.getJavaAnalogue(): LazyJavaClassDescriptor? {
@@ -293,7 +293,7 @@ open class JvmBuiltInsSettings(
                     SignatureBuildingComponents.signature(
                         javaAnalogueDescriptor,
                         javaConstructor.computeJvmDescriptor()
-                    ) !in BLACK_LIST_CONSTRUCTOR_SIGNATURES
+                    ) !in HIDDEN_CONSTRUCTOR_SIGNATURES
         }.map { javaConstructor ->
             javaConstructor.newCopyBuilder().apply {
                 setOwner(classDescriptor)
@@ -302,7 +302,7 @@ open class JvmBuiltInsSettings(
                 setSubstitution(substitutor.substitution)
                 if (SignatureBuildingComponents.signature(
                         javaAnalogueDescriptor, javaConstructor.computeJvmDescriptor()
-                    ) !in WHITE_LIST_CONSTRUCTOR_SIGNATURES
+                    ) !in VISIBLE_CONSTRUCTOR_SIGNATURES
                 ) {
                     setAdditionalAnnotations(notConsideredDeprecation)
                 }