azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Use fq-names instead of descriptors when computing ambigious names

Browse Source 
Because there can be different descriptors that are essentially equal
(from different modules)

See J2K test: testNullableField
This commit is contained in:
Denis Zharkov
2016-04-21 12:49:00 +03:00
parent 28e33aaf56
commit a1d4214a39
2 changed files with 17 additions and 13 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/adaptiveClassifierNamePolicy.kt
+13 -9
View File
@@ -20,9 +20,12 @@ import org.jetbrains.kotlin.descriptors.CallableDescriptor
import org.jetbrains.kotlin.descriptors.ClassDescriptor import org.jetbrains.kotlin.descriptors.ClassDescriptor
import org.jetbrains.kotlin.descriptors.ClassifierDescriptor import org.jetbrains.kotlin.descriptors.ClassifierDescriptor
import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.FqNameUnsafe
import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.renderer.ClassifierNamePolicy import org.jetbrains.kotlin.renderer.ClassifierNamePolicy
import org.jetbrains.kotlin.renderer.DescriptorRenderer import org.jetbrains.kotlin.renderer.DescriptorRenderer
import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameUnsafe import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameUnsafe
import org.jetbrains.kotlin.types.KotlinType import org.jetbrains.kotlin.types.KotlinType
import org.jetbrains.kotlin.types.typeUtil.contains import org.jetbrains.kotlin.types.typeUtil.contains
@@ -66,35 +69,36 @@ private class AdaptiveClassifierNamePolicy(private val ambiguousNames: List<Name
private val ADAPTIVE_CLASSIFIER_POLICY_KEY = object : RenderingContext.Key<ClassifierNamePolicy>("ADAPTIVE_CLASSIFIER_POLICY") { private val ADAPTIVE_CLASSIFIER_POLICY_KEY = object : RenderingContext.Key<ClassifierNamePolicy>("ADAPTIVE_CLASSIFIER_POLICY") {
override fun compute(objectsToRender: Collection<Any?>): ClassifierNamePolicy { override fun compute(objectsToRender: Collection<Any?>): ClassifierNamePolicy {
val ambiguousNames = collectClassifiers(objectsToRender).groupBy { it.name }.filter { it.value.size > 1 }.map { it.key } val ambiguousNames =
collectClassifiersFqNames(objectsToRender).groupBy { it.shortNameOrSpecial() }.filter { it.value.size > 1 }.map { it.key }
return AdaptiveClassifierNamePolicy(ambiguousNames) return AdaptiveClassifierNamePolicy(ambiguousNames)
} }
} }
private fun collectClassifiers(objectsToRender: Collection<Any?>): Set<ClassifierDescriptor> = LinkedHashSet<ClassifierDescriptor>().apply { private fun collectClassifiersFqNames(objectsToRender: Collection<Any?>): Set<FqNameUnsafe> = LinkedHashSet<FqNameUnsafe>().apply {
collectMentionedClassifiers(objectsToRender, this) collectMentionedClassifiersFqNames(objectsToRender, this)
} }
private fun collectMentionedClassifiers(contextObjects: Collection<Any?>, result: MutableSet<ClassifierDescriptor>) { private fun collectMentionedClassifiersFqNames(contextObjects: Collection<Any?>, result: MutableSet<FqNameUnsafe>) {
contextObjects.filterIsInstance<KotlinType>().forEach { diagnosticType -> contextObjects.filterIsInstance<KotlinType>().forEach { diagnosticType ->
diagnosticType.contains { diagnosticType.contains {
innerType -> innerType ->
innerType.constructor.declarationDescriptor?.let { result.add(it) } innerType.constructor.declarationDescriptor?.let { result.add(it.fqNameUnsafe) }
false false
} }
} }
contextObjects.filterIsInstance<Collection<*>>().forEach { contextObjects.filterIsInstance<Collection<*>>().forEach {
collectMentionedClassifiers(it, result) collectMentionedClassifiersFqNames(it, result)
} }
contextObjects.filterIsInstance<ClassifierDescriptor>().forEach { contextObjects.filterIsInstance<ClassifierDescriptor>().forEach {
result.add(it) result.add(it.fqNameUnsafe)
} }
contextObjects.filterIsInstance<TypeParameterDescriptor>().forEach { contextObjects.filterIsInstance<TypeParameterDescriptor>().forEach {
collectMentionedClassifiers(it.upperBounds, result) collectMentionedClassifiersFqNames(it.upperBounds, result)
} }
contextObjects.filterIsInstance<CallableDescriptor>().forEach { contextObjects.filterIsInstance<CallableDescriptor>().forEach {
collectMentionedClassifiers(listOf( collectMentionedClassifiersFqNames(listOf(
it.typeParameters, it.typeParameters,
it.returnType, it.returnType,
it.valueParameters, it.valueParameters,
jps-plugin/testData/incremental/pureKotlin/conflictingPlatformDeclarations/build.log
Vendored
+4 -4
View File
@@ -12,8 +12,8 @@ Exit code: ABORT
------------------------------------------ ------------------------------------------
COMPILATION FAILED COMPILATION FAILED
Platform declaration clash: The following declarations have the same JVM signature (function(Ljava/util/List;)V): Platform declaration clash: The following declarations have the same JVM signature (function(Ljava/util/List;)V):
fun function(list: List<Any>): kotlin.Unit fun function(list: List<Any>): Unit
fun function(list: List<String>): kotlin.Unit fun function(list: List<String>): Unit
Platform declaration clash: The following declarations have the same JVM signature (function(Ljava/util/List;)V): Platform declaration clash: The following declarations have the same JVM signature (function(Ljava/util/List;)V):
fun function(list: List<Any>): kotlin.Unit fun function(list: List<Any>): Unit
fun function(list: List<String>): kotlin.Unit fun function(list: List<String>): Unit