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

Minor. Reformat LazyJavaClassMemberScope.kt

Browse Source
This commit is contained in:
Denis Zharkov
2018-06-20 16:10:56 +03:00
parent de60c9b635
commit 0fc9bb3f4a
1 changed files with 160 additions and 153 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassMemberScope.kt
+160 -153
View File
@@ -59,9 +59,9 @@ import org.jetbrains.kotlin.utils.ifEmpty
import java.util.* import java.util.*
class LazyJavaClassMemberScope( class LazyJavaClassMemberScope(
c: LazyJavaResolverContext, c: LazyJavaResolverContext,
override val ownerDescriptor: ClassDescriptor, override val ownerDescriptor: ClassDescriptor,
private val jClass: JavaClass private val jClass: JavaClass
) : LazyJavaScope(c) { ) : LazyJavaScope(c) {
override fun computeMemberIndex() = ClassDeclaredMemberIndex(jClass, { !it.isStatic }) override fun computeMemberIndex() = ClassDeclaredMemberIndex(jClass, { !it.isStatic })
@@ -83,8 +83,8 @@ class LazyJavaClassMemberScope(
} }
c.components.signatureEnhancement.enhanceSignatures( c.components.signatureEnhancement.enhanceSignatures(
c, c,
result.ifEmpty { listOfNotNull(createDefaultConstructor()) } result.ifEmpty { listOfNotNull(createDefaultConstructor()) }
).toList() ).toList()
} }
@@ -94,22 +94,19 @@ class LazyJavaClassMemberScope(
} }
private fun isVisibleAsFunctionInCurrentClass(function: SimpleFunctionDescriptor): Boolean { private fun isVisibleAsFunctionInCurrentClass(function: SimpleFunctionDescriptor): Boolean {
if (getPropertyNamesCandidatesByAccessorName(function.name).any { if (getPropertyNamesCandidatesByAccessorName(function.name).any { propertyName ->
propertyName -> getPropertiesFromSupertypes(propertyName).any { property ->
getPropertiesFromSupertypes(propertyName).any { doesClassOverridesProperty(property) { accessorName ->
property -> // This lambda should return property accessors available in this class by their name
doesClassOverridesProperty(property) { // If 'accessorName' is current function we return only it just because we check exactly
accessorName -> // that current method is override of accessor
// This lambda should return property accessors available in this class by their name if (function.name == accessorName)
// If 'accessorName' is current function we return only it just because we check exactly listOf(function)
// that current method is override of accessor else
if (function.name == accessorName) searchMethodsByNameWithoutBuiltinMagic(accessorName) + searchMethodsInSupertypesWithoutBuiltinMagic(accessorName)
listOf(function) } && (property.isVar || !JvmAbi.isSetterName(function.name.asString()))
else }
searchMethodsByNameWithoutBuiltinMagic(accessorName) + searchMethodsInSupertypesWithoutBuiltinMagic(accessorName) }) return false
} && (property.isVar || !JvmAbi.isSetterName(function.name.asString()))
}
}) return false
return !function.doesOverrideRenamedBuiltins() && !function.shouldBeVisibleAsOverrideOfBuiltInWithErasedValueParameters() return !function.doesOverrideRenamedBuiltins() && !function.shouldBeVisibleAsOverrideOfBuiltInWithErasedValueParameters()
} }
@@ -124,31 +121,30 @@ class LazyJavaClassMemberScope(
private fun SimpleFunctionDescriptor.shouldBeVisibleAsOverrideOfBuiltInWithErasedValueParameters(): Boolean { private fun SimpleFunctionDescriptor.shouldBeVisibleAsOverrideOfBuiltInWithErasedValueParameters(): Boolean {
if (!name.sameAsBuiltinMethodWithErasedValueParameters) return false if (!name.sameAsBuiltinMethodWithErasedValueParameters) return false
val candidatesToOverride = val candidatesToOverride =
getFunctionsFromSupertypes(name).mapNotNull { getFunctionsFromSupertypes(name).mapNotNull {
BuiltinMethodsWithSpecialGenericSignature.getOverriddenBuiltinFunctionWithErasedValueParametersInJava(it) BuiltinMethodsWithSpecialGenericSignature.getOverriddenBuiltinFunctionWithErasedValueParametersInJava(it)
} }
return candidatesToOverride.any { return candidatesToOverride.any { candidate ->
candidate ->
hasSameJvmDescriptorButDoesNotOverride(candidate) hasSameJvmDescriptorButDoesNotOverride(candidate)
} }
} }
private fun searchMethodsByNameWithoutBuiltinMagic(name: Name): Collection<SimpleFunctionDescriptor> = private fun searchMethodsByNameWithoutBuiltinMagic(name: Name): Collection<SimpleFunctionDescriptor> =
declaredMemberIndex().findMethodsByName(name).map { resolveMethodToFunctionDescriptor(it) } declaredMemberIndex().findMethodsByName(name).map { resolveMethodToFunctionDescriptor(it) }
private fun searchMethodsInSupertypesWithoutBuiltinMagic(name: Name): Collection<SimpleFunctionDescriptor> = private fun searchMethodsInSupertypesWithoutBuiltinMagic(name: Name): Collection<SimpleFunctionDescriptor> =
getFunctionsFromSupertypes(name).filterNot { getFunctionsFromSupertypes(name).filterNot {
it.doesOverrideBuiltinWithDifferentJvmName() it.doesOverrideBuiltinWithDifferentJvmName()
|| BuiltinMethodsWithSpecialGenericSignature.getOverriddenBuiltinFunctionWithErasedValueParametersInJava(it) != null || BuiltinMethodsWithSpecialGenericSignature.getOverriddenBuiltinFunctionWithErasedValueParametersInJava(it) != null
} }
private fun SimpleFunctionDescriptor.doesOverrideRenamedBuiltins(): Boolean { private fun SimpleFunctionDescriptor.doesOverrideRenamedBuiltins(): Boolean {
return BuiltinMethodsWithDifferentJvmName.getBuiltinFunctionNamesByJvmName(name).any { return BuiltinMethodsWithDifferentJvmName.getBuiltinFunctionNamesByJvmName(name).any {
// e.g. 'removeAt' or 'toInt' // e.g. 'removeAt' or 'toInt'
builtinName -> builtinName ->
val builtinSpecialFromSuperTypes = val builtinSpecialFromSuperTypes =
getFunctionsFromSupertypes(builtinName).filter { it.doesOverrideBuiltinWithDifferentJvmName() } getFunctionsFromSupertypes(builtinName).filter { it.doesOverrideBuiltinWithDifferentJvmName() }
if (builtinSpecialFromSuperTypes.isEmpty()) return@any false if (builtinSpecialFromSuperTypes.isEmpty()) return@any false
val methodDescriptor = this.createRenamedCopy(builtinName) val methodDescriptor = this.createRenamedCopy(builtinName)
@@ -158,15 +154,15 @@ class LazyJavaClassMemberScope(
} }
private fun SimpleFunctionDescriptor.createRenamedCopy(builtinName: Name): SimpleFunctionDescriptor = private fun SimpleFunctionDescriptor.createRenamedCopy(builtinName: Name): SimpleFunctionDescriptor =
this.newCopyBuilder().apply { this.newCopyBuilder().apply {
setName(builtinName) setName(builtinName)
setSignatureChange() setSignatureChange()
setPreserveSourceElement() setPreserveSourceElement()
}.build()!! }.build()!!
private fun doesOverrideRenamedDescriptor( private fun doesOverrideRenamedDescriptor(
superDescriptor: SimpleFunctionDescriptor, superDescriptor: SimpleFunctionDescriptor,
subDescriptor: FunctionDescriptor subDescriptor: FunctionDescriptor
): Boolean { ): Boolean {
// if we check 'removeAt', get original sub-descriptor to distinct `remove(int)` and `remove(E)` in Java // if we check 'removeAt', get original sub-descriptor to distinct `remove(int)` and `remove(E)` in Java
val subDescriptorToCheck = if (superDescriptor.isRemoveAtByIndex) subDescriptor.original else subDescriptor val subDescriptorToCheck = if (superDescriptor.isRemoveAtByIndex) subDescriptor.original else subDescriptor
@@ -176,15 +172,16 @@ class LazyJavaClassMemberScope(
private fun CallableDescriptor.doesOverride(superDescriptor: CallableDescriptor): Boolean { private fun CallableDescriptor.doesOverride(superDescriptor: CallableDescriptor): Boolean {
val commonOverridabilityResult = val commonOverridabilityResult =
OverridingUtil.DEFAULT.isOverridableByWithoutExternalConditions(superDescriptor, this, true).result OverridingUtil.DEFAULT.isOverridableByWithoutExternalConditions(superDescriptor, this, true).result
return commonOverridabilityResult == OverridingUtil.OverrideCompatibilityInfo.Result.OVERRIDABLE && return commonOverridabilityResult == OverridingUtil.OverrideCompatibilityInfo.Result.OVERRIDABLE &&
!JavaIncompatibilityRulesOverridabilityCondition.doesJavaOverrideHaveIncompatibleValueParameterKinds( !JavaIncompatibilityRulesOverridabilityCondition.doesJavaOverrideHaveIncompatibleValueParameterKinds(
superDescriptor, this) superDescriptor, this
)
} }
private fun PropertyDescriptor.findGetterOverride( private fun PropertyDescriptor.findGetterOverride(
functions: (Name) -> Collection<SimpleFunctionDescriptor> functions: (Name) -> Collection<SimpleFunctionDescriptor>
): SimpleFunctionDescriptor? { ): SimpleFunctionDescriptor? {
val overriddenBuiltinProperty = getter?.getOverriddenBuiltinWithDifferentJvmName() val overriddenBuiltinProperty = getter?.getOverriddenBuiltinWithDifferentJvmName()
val specialGetterName = overriddenBuiltinProperty?.getBuiltinSpecialPropertyGetterName() val specialGetterName = overriddenBuiltinProperty?.getBuiltinSpecialPropertyGetterName()
@@ -198,11 +195,10 @@ class LazyJavaClassMemberScope(
} }
private fun PropertyDescriptor.findGetterByName( private fun PropertyDescriptor.findGetterByName(
getterName: String, getterName: String,
functions: (Name) -> Collection<SimpleFunctionDescriptor> functions: (Name) -> Collection<SimpleFunctionDescriptor>
): SimpleFunctionDescriptor? { ): SimpleFunctionDescriptor? {
return functions(Name.identifier(getterName)).firstNotNullResult factory@{ return functions(Name.identifier(getterName)).firstNotNullResult factory@{ descriptor ->
descriptor ->
if (descriptor.valueParameters.size != 0) return@factory null if (descriptor.valueParameters.size != 0) return@factory null
descriptor.takeIf { KotlinTypeChecker.DEFAULT.isSubtypeOf(descriptor.returnType ?: return@takeIf false, type) } descriptor.takeIf { KotlinTypeChecker.DEFAULT.isSubtypeOf(descriptor.returnType ?: return@takeIf false, type) }
@@ -210,10 +206,9 @@ class LazyJavaClassMemberScope(
} }
private fun PropertyDescriptor.findSetterOverride( private fun PropertyDescriptor.findSetterOverride(
functions: (Name) -> Collection<SimpleFunctionDescriptor> functions: (Name) -> Collection<SimpleFunctionDescriptor>
): SimpleFunctionDescriptor? { ): SimpleFunctionDescriptor? {
return functions(Name.identifier(JvmAbi.setterName(name.asString()))).firstNotNullResult factory@{ return functions(Name.identifier(JvmAbi.setterName(name.asString()))).firstNotNullResult factory@{ descriptor ->
descriptor ->
if (descriptor.valueParameters.size != 1) return@factory null if (descriptor.valueParameters.size != 1) return@factory null
if (!KotlinBuiltIns.isUnit(descriptor.returnType ?: return@factory null)) return@factory null if (!KotlinBuiltIns.isUnit(descriptor.returnType ?: return@factory null)) return@factory null
@@ -222,8 +217,8 @@ class LazyJavaClassMemberScope(
} }
private fun doesClassOverridesProperty( private fun doesClassOverridesProperty(
property: PropertyDescriptor, property: PropertyDescriptor,
functions: (Name) -> Collection<SimpleFunctionDescriptor> functions: (Name) -> Collection<SimpleFunctionDescriptor>
): Boolean { ): Boolean {
if (property.isJavaField) return false if (property.isJavaField) return false
val getter = property.findGetterOverride(functions) val getter = property.findGetterOverride(functions)
@@ -241,9 +236,10 @@ class LazyJavaClassMemberScope(
if (!name.sameAsRenamedInJvmBuiltin && !name.sameAsBuiltinMethodWithErasedValueParameters) { if (!name.sameAsRenamedInJvmBuiltin && !name.sameAsBuiltinMethodWithErasedValueParameters) {
// Simple fast path in case of name is not suspicious (i.e. name is not one of builtins that have different signature in Java) // Simple fast path in case of name is not suspicious (i.e. name is not one of builtins that have different signature in Java)
addFunctionFromSupertypes( addFunctionFromSupertypes(
result, name, result, name,
functionsFromSupertypes.filter { isVisibleAsFunctionInCurrentClass(it) }, functionsFromSupertypes.filter { isVisibleAsFunctionInCurrentClass(it) },
isSpecialBuiltinName = false) isSpecialBuiltinName = false
)
return return
} }
@@ -251,57 +247,58 @@ class LazyJavaClassMemberScope(
// Merge functions with same signatures // Merge functions with same signatures
val mergedFunctionFromSuperTypes = resolveOverridesForNonStaticMembers( val mergedFunctionFromSuperTypes = resolveOverridesForNonStaticMembers(
name, functionsFromSupertypes, emptyList(), ownerDescriptor, ErrorReporter.DO_NOTHING) name, functionsFromSupertypes, emptyList(), ownerDescriptor, ErrorReporter.DO_NOTHING
)
// add declarations // add declarations
addOverriddenBuiltinMethods( addOverriddenBuiltinMethods(
name, result, mergedFunctionFromSuperTypes, result, name, result, mergedFunctionFromSuperTypes, result,
this::searchMethodsByNameWithoutBuiltinMagic) this::searchMethodsByNameWithoutBuiltinMagic
)
// add from super types // add from super types
addOverriddenBuiltinMethods( addOverriddenBuiltinMethods(
name, result, mergedFunctionFromSuperTypes, specialBuiltinsFromSuperTypes, name, result, mergedFunctionFromSuperTypes, specialBuiltinsFromSuperTypes,
this::searchMethodsInSupertypesWithoutBuiltinMagic) this::searchMethodsInSupertypesWithoutBuiltinMagic
)
val visibleFunctionsFromSupertypes = val visibleFunctionsFromSupertypes =
functionsFromSupertypes.filter { isVisibleAsFunctionInCurrentClass(it) } + specialBuiltinsFromSuperTypes functionsFromSupertypes.filter { isVisibleAsFunctionInCurrentClass(it) } + specialBuiltinsFromSuperTypes
addFunctionFromSupertypes(result, name, visibleFunctionsFromSupertypes, isSpecialBuiltinName = true) addFunctionFromSupertypes(result, name, visibleFunctionsFromSupertypes, isSpecialBuiltinName = true)
} }
private fun addFunctionFromSupertypes( private fun addFunctionFromSupertypes(
result: MutableCollection<SimpleFunctionDescriptor>, result: MutableCollection<SimpleFunctionDescriptor>,
name: Name, name: Name,
functionsFromSupertypes: Collection<SimpleFunctionDescriptor>, functionsFromSupertypes: Collection<SimpleFunctionDescriptor>,
isSpecialBuiltinName: Boolean isSpecialBuiltinName: Boolean
) { ) {
val additionalOverrides = resolveOverridesForNonStaticMembers( val additionalOverrides = resolveOverridesForNonStaticMembers(
name, functionsFromSupertypes, result, ownerDescriptor, c.components.errorReporter name, functionsFromSupertypes, result, ownerDescriptor, c.components.errorReporter
) )
if (!isSpecialBuiltinName) { if (!isSpecialBuiltinName) {
result.addAll(additionalOverrides) result.addAll(additionalOverrides)
} } else {
else {
val allDescriptors = result + additionalOverrides val allDescriptors = result + additionalOverrides
result.addAll( result.addAll(
additionalOverrides.map { additionalOverrides.map { resolvedOverride ->
resolvedOverride -> val overriddenBuiltin = resolvedOverride.getOverriddenSpecialBuiltin()
val overriddenBuiltin = resolvedOverride.getOverriddenSpecialBuiltin() ?: return@map resolvedOverride
?: return@map resolvedOverride
resolvedOverride.createHiddenCopyIfBuiltinAlreadyAccidentallyOverridden(overriddenBuiltin, allDescriptors) resolvedOverride.createHiddenCopyIfBuiltinAlreadyAccidentallyOverridden(overriddenBuiltin, allDescriptors)
}) })
} }
} }
private fun addOverriddenBuiltinMethods( private fun addOverriddenBuiltinMethods(
name: Name, name: Name,
alreadyDeclaredFunctions: Collection<SimpleFunctionDescriptor>, alreadyDeclaredFunctions: Collection<SimpleFunctionDescriptor>,
candidatesForOverride: Collection<SimpleFunctionDescriptor>, candidatesForOverride: Collection<SimpleFunctionDescriptor>,
result: MutableCollection<SimpleFunctionDescriptor>, result: MutableCollection<SimpleFunctionDescriptor>,
functions: (Name) -> Collection<SimpleFunctionDescriptor> functions: (Name) -> Collection<SimpleFunctionDescriptor>
) { ) {
for (descriptor in candidatesForOverride) { for (descriptor in candidatesForOverride) {
val overriddenBuiltin = descriptor.getOverriddenBuiltinWithDifferentJvmName() ?: continue val overriddenBuiltin = descriptor.getOverriddenBuiltinWithDifferentJvmName() ?: continue
@@ -312,7 +309,8 @@ class LazyJavaClassMemberScope(
if (doesOverrideRenamedDescriptor(overriddenBuiltin, renamedCopy)) { if (doesOverrideRenamedDescriptor(overriddenBuiltin, renamedCopy)) {
result.add( result.add(
renamedCopy.createHiddenCopyIfBuiltinAlreadyAccidentallyOverridden(overriddenBuiltin, alreadyDeclaredFunctions)) renamedCopy.createHiddenCopyIfBuiltinAlreadyAccidentallyOverridden(overriddenBuiltin, alreadyDeclaredFunctions)
)
break break
} }
} }
@@ -320,11 +318,10 @@ class LazyJavaClassMemberScope(
for (descriptor in candidatesForOverride) { for (descriptor in candidatesForOverride) {
val overriddenBuiltin = val overriddenBuiltin =
BuiltinMethodsWithSpecialGenericSignature.getOverriddenBuiltinFunctionWithErasedValueParametersInJava(descriptor) BuiltinMethodsWithSpecialGenericSignature.getOverriddenBuiltinFunctionWithErasedValueParametersInJava(descriptor)
?: continue ?: continue
createOverrideForBuiltinFunctionWithErasedParameterIfNeeded(overriddenBuiltin, functions)?.let { createOverrideForBuiltinFunctionWithErasedParameterIfNeeded(overriddenBuiltin, functions)?.let { override ->
override ->
if (isVisibleAsFunctionInCurrentClass(override)) { if (isVisibleAsFunctionInCurrentClass(override)) {
result.add(override.createHiddenCopyIfBuiltinAlreadyAccidentallyOverridden(overriddenBuiltin, alreadyDeclaredFunctions)) result.add(override.createHiddenCopyIfBuiltinAlreadyAccidentallyOverridden(overriddenBuiltin, alreadyDeclaredFunctions))
} }
@@ -339,8 +336,8 @@ class LazyJavaClassMemberScope(
// so when someone calls CharBuffer.get it results in invoking java method CharBuffer.get // so when someone calls CharBuffer.get it results in invoking java method CharBuffer.get
// But we still have the way to call 'charAt' java method by upcasting CharBuffer to kotlin.CharSequence // But we still have the way to call 'charAt' java method by upcasting CharBuffer to kotlin.CharSequence
private fun SimpleFunctionDescriptor.createHiddenCopyIfBuiltinAlreadyAccidentallyOverridden( private fun SimpleFunctionDescriptor.createHiddenCopyIfBuiltinAlreadyAccidentallyOverridden(
specialBuiltin: CallableDescriptor, specialBuiltin: CallableDescriptor,
alreadyDeclaredFunctions: Collection<SimpleFunctionDescriptor> alreadyDeclaredFunctions: Collection<SimpleFunctionDescriptor>
): SimpleFunctionDescriptor = ): SimpleFunctionDescriptor =
if (alreadyDeclaredFunctions.none { this != it && it.initialSignatureDescriptor == null && it.doesOverride(specialBuiltin) }) if (alreadyDeclaredFunctions.none { this != it && it.initialSignatureDescriptor == null && it.doesOverride(specialBuiltin) })
this this
@@ -348,17 +345,19 @@ class LazyJavaClassMemberScope(
newCopyBuilder().setHiddenToOvercomeSignatureClash().build()!! newCopyBuilder().setHiddenToOvercomeSignatureClash().build()!!
private fun createOverrideForBuiltinFunctionWithErasedParameterIfNeeded( private fun createOverrideForBuiltinFunctionWithErasedParameterIfNeeded(
overridden: FunctionDescriptor, overridden: FunctionDescriptor,
functions: (Name) -> Collection<SimpleFunctionDescriptor> functions: (Name) -> Collection<SimpleFunctionDescriptor>
): SimpleFunctionDescriptor? { ): SimpleFunctionDescriptor? {
return functions(overridden.name).firstOrNull { return functions(overridden.name).firstOrNull {
it.hasSameJvmDescriptorButDoesNotOverride(overridden) it.hasSameJvmDescriptorButDoesNotOverride(overridden)
}?.let { }?.let { override ->
override ->
override.newCopyBuilder().apply { override.newCopyBuilder().apply {
setValueParameters(copyValueParameters( setValueParameters(
copyValueParameters(
overridden.valueParameters.map { ValueParameterData(it.type, it.declaresDefaultValue()) }, overridden.valueParameters.map { ValueParameterData(it.type, it.declaresDefaultValue()) },
override.valueParameters, overridden)) override.valueParameters, overridden
)
)
setSignatureChange() setSignatureChange()
setPreserveSourceElement() setPreserveSourceElement()
}.build() }.build()
@@ -387,14 +386,17 @@ class LazyJavaClassMemberScope(
searchMethodsInSupertypesWithoutBuiltinMagic(it) searchMethodsInSupertypesWithoutBuiltinMagic(it)
} }
result.addAll(resolveOverridesForNonStaticMembers( result.addAll(
name, propertiesFromSupertypes + propertiesOverridesFromSuperTypes, result, ownerDescriptor, c.components.errorReporter)) resolveOverridesForNonStaticMembers(
name, propertiesFromSupertypes + propertiesOverridesFromSuperTypes, result, ownerDescriptor, c.components.errorReporter
)
)
} }
private fun addPropertyOverrideByMethod( private fun addPropertyOverrideByMethod(
propertiesFromSupertypes: Set<PropertyDescriptor>, propertiesFromSupertypes: Set<PropertyDescriptor>,
result: MutableCollection<PropertyDescriptor>, result: MutableCollection<PropertyDescriptor>,
functions: (Name) -> Collection<SimpleFunctionDescriptor> functions: (Name) -> Collection<SimpleFunctionDescriptor>
) { ) {
for (property in propertiesFromSupertypes) { for (property in propertiesFromSupertypes) {
val newProperty = createPropertyDescriptorByMethods(property, functions) val newProperty = createPropertyDescriptorByMethods(property, functions)
@@ -411,14 +413,14 @@ class LazyJavaClassMemberScope(
} }
private fun createPropertyDescriptorWithDefaultGetter( private fun createPropertyDescriptorWithDefaultGetter(
method: JavaMethod, givenType: KotlinType? = null, modality: Modality method: JavaMethod, givenType: KotlinType? = null, modality: Modality
): JavaPropertyDescriptor { ): JavaPropertyDescriptor {
val annotations = c.resolveAnnotations(method) val annotations = c.resolveAnnotations(method)
val propertyDescriptor = JavaPropertyDescriptor.create( val propertyDescriptor = JavaPropertyDescriptor.create(
ownerDescriptor, annotations, modality, method.visibility, ownerDescriptor, annotations, modality, method.visibility,
/* isVar = */ false, method.name, c.components.sourceElementFactory.source(method), /* isVar = */ false, method.name, c.components.sourceElementFactory.source(method),
/* isStaticFinal = */ false /* isStaticFinal = */ false
) )
val getter = DescriptorFactory.createDefaultGetter(propertyDescriptor, Annotations.EMPTY) val getter = DescriptorFactory.createDefaultGetter(propertyDescriptor, Annotations.EMPTY)
@@ -432,42 +434,43 @@ class LazyJavaClassMemberScope(
} }
private fun createPropertyDescriptorByMethods( private fun createPropertyDescriptorByMethods(
overriddenProperty: PropertyDescriptor, overriddenProperty: PropertyDescriptor,
functions: (Name) -> Collection<SimpleFunctionDescriptor> functions: (Name) -> Collection<SimpleFunctionDescriptor>
): JavaPropertyDescriptor? { ): JavaPropertyDescriptor? {
if (!doesClassOverridesProperty(overriddenProperty, functions)) return null if (!doesClassOverridesProperty(overriddenProperty, functions)) return null
val getterMethod = overriddenProperty.findGetterOverride(functions)!! val getterMethod = overriddenProperty.findGetterOverride(functions)!!
val setterMethod = val setterMethod =
if (overriddenProperty.isVar) if (overriddenProperty.isVar)
overriddenProperty.findSetterOverride(functions)!! overriddenProperty.findSetterOverride(functions)!!
else else
null null
assert(setterMethod?.let { it.modality == getterMethod.modality } ?: true) { assert(setterMethod?.let { it.modality == getterMethod.modality } ?: true) {
"Different accessors modalities when creating overrides for $overriddenProperty in $ownerDescriptor" + "Different accessors modalities when creating overrides for $overriddenProperty in $ownerDescriptor" +
"for getter is ${getterMethod.modality}, but for setter is ${setterMethod?.modality}" "for getter is ${getterMethod.modality}, but for setter is ${setterMethod?.modality}"
} }
val propertyDescriptor = JavaPropertyDescriptor.create( val propertyDescriptor = JavaPropertyDescriptor.create(
ownerDescriptor, Annotations.EMPTY, getterMethod.modality, getterMethod.visibility, ownerDescriptor, Annotations.EMPTY, getterMethod.modality, getterMethod.visibility,
/* isVar = */ setterMethod != null, overriddenProperty.name, getterMethod.source, /* isVar = */ setterMethod != null, overriddenProperty.name, getterMethod.source,
/* isStaticFinal = */ false /* isStaticFinal = */ false
) )
propertyDescriptor.setType(getterMethod.returnType!!, listOf(), getDispatchReceiverParameter(), null as KotlinType?) propertyDescriptor.setType(getterMethod.returnType!!, listOf(), getDispatchReceiverParameter(), null as KotlinType?)
val getter = DescriptorFactory.createGetter( val getter = DescriptorFactory.createGetter(
propertyDescriptor, getterMethod.annotations, /* isDefault = */false, propertyDescriptor, getterMethod.annotations, /* isDefault = */false,
/* isExternal = */ false, /* isInline = */ false, getterMethod.source /* isExternal = */ false, /* isInline = */ false, getterMethod.source
).apply { ).apply {
initialSignatureDescriptor = getterMethod initialSignatureDescriptor = getterMethod
initialize(propertyDescriptor.type) initialize(propertyDescriptor.type)
} }
val setter = setterMethod?.let { setterMethod -> val setter = setterMethod?.let { setterMethod ->
DescriptorFactory.createSetter(propertyDescriptor, setterMethod.annotations, /* isDefault = */false, DescriptorFactory.createSetter(
/* isExternal = */ false, /* isInline = */ false, setterMethod.visibility, setterMethod.source propertyDescriptor, setterMethod.annotations, /* isDefault = */false,
/* isExternal = */ false, /* isInline = */ false, setterMethod.visibility, setterMethod.source
).apply { ).apply {
initialSignatureDescriptor = setterMethod initialSignatureDescriptor = setterMethod
} }
@@ -483,39 +486,43 @@ class LazyJavaClassMemberScope(
} }
override fun resolveMethodSignature( override fun resolveMethodSignature(
method: JavaMethod, methodTypeParameters: List<TypeParameterDescriptor>, returnType: KotlinType, method: JavaMethod, methodTypeParameters: List<TypeParameterDescriptor>, returnType: KotlinType,
valueParameters: List<ValueParameterDescriptor> valueParameters: List<ValueParameterDescriptor>
): LazyJavaScope.MethodSignatureData { ): LazyJavaScope.MethodSignatureData {
val propagated = c.components.signaturePropagator.resolvePropagatedSignature( val propagated = c.components.signaturePropagator.resolvePropagatedSignature(
method, ownerDescriptor, returnType, null, valueParameters, methodTypeParameters method, ownerDescriptor, returnType, null, valueParameters, methodTypeParameters
) )
return LazyJavaScope.MethodSignatureData( return LazyJavaScope.MethodSignatureData(
propagated.returnType, propagated.receiverType, propagated.valueParameters, propagated.typeParameters, propagated.returnType, propagated.receiverType, propagated.valueParameters, propagated.typeParameters,
propagated.hasStableParameterNames(), propagated.errors propagated.hasStableParameterNames(), propagated.errors
) )
} }
private fun SimpleFunctionDescriptor.hasSameJvmDescriptorButDoesNotOverride( private fun SimpleFunctionDescriptor.hasSameJvmDescriptorButDoesNotOverride(
builtinWithErasedParameters: FunctionDescriptor builtinWithErasedParameters: FunctionDescriptor
): Boolean { ): Boolean {
return computeJvmDescriptor(withReturnType = false) == return computeJvmDescriptor(withReturnType = false) ==
builtinWithErasedParameters.original.computeJvmDescriptor(withReturnType = false) builtinWithErasedParameters.original.computeJvmDescriptor(withReturnType = false)
&& !doesOverride(builtinWithErasedParameters) && !doesOverride(builtinWithErasedParameters)
} }
private fun resolveConstructor(constructor: JavaConstructor): JavaClassConstructorDescriptor { private fun resolveConstructor(constructor: JavaConstructor): JavaClassConstructorDescriptor {
val classDescriptor = ownerDescriptor val classDescriptor = ownerDescriptor
val constructorDescriptor = JavaClassConstructorDescriptor.createJavaConstructor( val constructorDescriptor = JavaClassConstructorDescriptor.createJavaConstructor(
classDescriptor, c.resolveAnnotations(constructor), /* isPrimary = */ false, c.components.sourceElementFactory.source(constructor) classDescriptor,
c.resolveAnnotations(constructor), /* isPrimary = */
false,
c.components.sourceElementFactory.source(constructor)
) )
val c = c.childForMethod(constructorDescriptor, constructor, typeParametersIndexOffset = classDescriptor.declaredTypeParameters.size) val c =
c.childForMethod(constructorDescriptor, constructor, typeParametersIndexOffset = classDescriptor.declaredTypeParameters.size)
val valueParameters = resolveValueParameters(c, constructorDescriptor, constructor.valueParameters) val valueParameters = resolveValueParameters(c, constructorDescriptor, constructor.valueParameters)
val constructorTypeParameters = val constructorTypeParameters =
classDescriptor.declaredTypeParameters + classDescriptor.declaredTypeParameters +
constructor.typeParameters.map { p -> c.typeParameterResolver.resolveTypeParameter(p)!! } constructor.typeParameters.map { p -> c.typeParameterResolver.resolveTypeParameter(p)!! }
constructorDescriptor.initialize(valueParameters.descriptors, constructor.visibility, constructorTypeParameters) constructorDescriptor.initialize(valueParameters.descriptors, constructor.visibility, constructorTypeParameters)
constructorDescriptor.setHasStableParameterNames(false) constructorDescriptor.setHasStableParameterNames(false)
@@ -535,10 +542,10 @@ class LazyJavaClassMemberScope(
val classDescriptor = ownerDescriptor val classDescriptor = ownerDescriptor
val constructorDescriptor = JavaClassConstructorDescriptor.createJavaConstructor( val constructorDescriptor = JavaClassConstructorDescriptor.createJavaConstructor(
classDescriptor, Annotations.EMPTY, /* isPrimary = */ true, c.components.sourceElementFactory.source(jClass) classDescriptor, Annotations.EMPTY, /* isPrimary = */ true, c.components.sourceElementFactory.source(jClass)
) )
val valueParameters = if (isAnnotation) createAnnotationConstructorParameters(constructorDescriptor) val valueParameters = if (isAnnotation) createAnnotationConstructorParameters(constructorDescriptor)
else Collections.emptyList<ValueParameterDescriptor>() else Collections.emptyList<ValueParameterDescriptor>()
constructorDescriptor.setHasSynthesizedParameterNames(false) constructorDescriptor.setHasSynthesizedParameterNames(false)
constructorDescriptor.initialize(valueParameters, getConstructorVisibility(classDescriptor)) constructorDescriptor.initialize(valueParameters, getConstructorVisibility(classDescriptor))
@@ -562,8 +569,7 @@ class LazyJavaClassMemberScope(
val attr = TypeUsage.COMMON.toAttributes(isForAnnotationParameter = true) val attr = TypeUsage.COMMON.toAttributes(isForAnnotationParameter = true)
val (methodsNamedValue, otherMethods) = methods. val (methodsNamedValue, otherMethods) = methods.partition { it.name == JvmAnnotationNames.DEFAULT_ANNOTATION_MEMBER_NAME }
partition { it.name == JvmAnnotationNames.DEFAULT_ANNOTATION_MEMBER_NAME }
assert(methodsNamedValue.size <= 1) { "There can't be more than one method named 'value' in annotation class: $jClass" } assert(methodsNamedValue.size <= 1) { "There can't be more than one method named 'value' in annotation class: $jClass" }
val methodNamedValue = methodsNamedValue.firstOrNull() val methodNamedValue = methodsNamedValue.firstOrNull()
@@ -571,8 +577,10 @@ class LazyJavaClassMemberScope(
val parameterNamedValueJavaType = methodNamedValue.returnType val parameterNamedValueJavaType = methodNamedValue.returnType
val (parameterType, varargType) = val (parameterType, varargType) =
if (parameterNamedValueJavaType is JavaArrayType) if (parameterNamedValueJavaType is JavaArrayType)
Pair(c.typeResolver.transformArrayType(parameterNamedValueJavaType, attr, isVararg = true), Pair(
c.typeResolver.transformJavaType(parameterNamedValueJavaType.componentType, attr)) c.typeResolver.transformArrayType(parameterNamedValueJavaType, attr, isVararg = true),
c.typeResolver.transformJavaType(parameterNamedValueJavaType.componentType, attr)
)
else else
Pair(c.typeResolver.transformJavaType(parameterNamedValueJavaType, attr), null) Pair(c.typeResolver.transformJavaType(parameterNamedValueJavaType, attr), null)
@@ -589,13 +597,14 @@ class LazyJavaClassMemberScope(
} }
private fun MutableList<ValueParameterDescriptor>.addAnnotationValueParameter( private fun MutableList<ValueParameterDescriptor>.addAnnotationValueParameter(
constructor: ConstructorDescriptor, constructor: ConstructorDescriptor,
index: Int, index: Int,
method: JavaMethod, method: JavaMethod,
returnType: KotlinType, returnType: KotlinType,
varargElementType: KotlinType? varargElementType: KotlinType?
) { ) {
add(ValueParameterDescriptorImpl( add(
ValueParameterDescriptorImpl(
constructor, constructor,
null, null,
index, index,
@@ -609,7 +618,8 @@ class LazyJavaClassMemberScope(
// Nulls are not allowed in annotation arguments in Java // Nulls are not allowed in annotation arguments in Java
varargElementType?.let { TypeUtils.makeNotNullable(it) }, varargElementType?.let { TypeUtils.makeNotNullable(it) },
c.components.sourceElementFactory.source(method) c.components.sourceElementFactory.source(method)
)) )
)
} }
private val nestedClassIndex = c.storageManager.createLazyValue { private val nestedClassIndex = c.storageManager.createLazyValue {
@@ -620,8 +630,7 @@ class LazyJavaClassMemberScope(
jClass.fields.filter { it.isEnumEntry }.associateBy { f -> f.name } jClass.fields.filter { it.isEnumEntry }.associateBy { f -> f.name }
} }
private val nestedClasses = c.storageManager.createMemoizedFunctionWithNullableValues { private val nestedClasses = c.storageManager.createMemoizedFunctionWithNullableValues { name: Name ->
name: Name ->
if (name !in nestedClassIndex()) { if (name !in nestedClassIndex()) {
val field = enumEntryIndex()[name] val field = enumEntryIndex()[name]
if (field != null) { if (field != null) {
@@ -629,22 +638,20 @@ class LazyJavaClassMemberScope(
getFunctionNames() + getVariableNames() getFunctionNames() + getVariableNames()
} }
EnumEntrySyntheticClassDescriptor.create( EnumEntrySyntheticClassDescriptor.create(
c.storageManager, ownerDescriptor, name, enumMemberNames, c.resolveAnnotations(field), c.storageManager, ownerDescriptor, name, enumMemberNames, c.resolveAnnotations(field),
c.components.sourceElementFactory.source(field) c.components.sourceElementFactory.source(field)
) )
} } else null
else null } else {
}
else {
c.components.finder.findClass(ownerDescriptor.classId!!.createNestedClassId(name))?.let { c.components.finder.findClass(ownerDescriptor.classId!!.createNestedClassId(name))?.let {
LazyJavaClassDescriptor(c, ownerDescriptor, it) LazyJavaClassDescriptor(c, ownerDescriptor, it)
.also(c.components.javaClassesTracker::reportClass) .also(c.components.javaClassesTracker::reportClass)
} }
} }
} }
override fun getDispatchReceiverParameter(): ReceiverParameterDescriptor? = override fun getDispatchReceiverParameter(): ReceiverParameterDescriptor? =
DescriptorUtils.getDispatchReceiverParameterIfNeeded(ownerDescriptor) DescriptorUtils.getDispatchReceiverParameterIfNeeded(ownerDescriptor)
override fun getContributedClassifier(name: Name, location: LookupLocation): ClassifierDescriptor? { override fun getContributedClassifier(name: Name, location: LookupLocation): ClassifierDescriptor? {
recordLookup(name, location) recordLookup(name, location)
@@ -661,8 +668,8 @@ class LazyJavaClassMemberScope(
return super.getContributedVariables(name, location) return super.getContributedVariables(name, location)
} }
override fun computeClassNames(kindFilter: DescriptorKindFilter, nameFilter: ((Name) -> Boolean)?): Set<Name> override fun computeClassNames(kindFilter: DescriptorKindFilter, nameFilter: ((Name) -> Boolean)?): Set<Name> =
= nestedClassIndex() + enumEntryIndex().keys nestedClassIndex() + enumEntryIndex().keys
override fun computePropertyNames(kindFilter: DescriptorKindFilter, nameFilter: ((Name) -> Boolean)?): Set<Name> { override fun computePropertyNames(kindFilter: DescriptorKindFilter, nameFilter: ((Name) -> Boolean)?): Set<Name> {
if (jClass.isAnnotationType) return getFunctionNames() if (jClass.isAnnotationType) return getFunctionNames()