Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
org.jetbrains.kotlin.load.java.lazy.descriptors.LazyJavaClassMemberScope.kt Maven / Gradle / Ivy
/*
* Copyright 2010-2015 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.kotlin.load.java.lazy.descriptors
import org.jetbrains.kotlin.descriptors.*
import org.jetbrains.kotlin.descriptors.annotations.Annotations
import org.jetbrains.kotlin.descriptors.impl.ConstructorDescriptorImpl
import org.jetbrains.kotlin.descriptors.impl.EnumEntrySyntheticClassDescriptor
import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl
import org.jetbrains.kotlin.incremental.components.LookupLocation
import org.jetbrains.kotlin.incremental.components.NoLookupLocation
import org.jetbrains.kotlin.load.java.JavaVisibilities
import org.jetbrains.kotlin.load.java.JvmAnnotationNames
import org.jetbrains.kotlin.load.java.components.DescriptorResolverUtils
import org.jetbrains.kotlin.load.java.components.TypeUsage
import org.jetbrains.kotlin.load.java.descriptors.JavaConstructorDescriptor
import org.jetbrains.kotlin.load.java.descriptors.JavaPropertyDescriptor
import org.jetbrains.kotlin.load.java.lazy.LazyJavaResolverContext
import org.jetbrains.kotlin.load.java.lazy.child
import org.jetbrains.kotlin.load.java.lazy.resolveAnnotations
import org.jetbrains.kotlin.load.java.lazy.types.toAttributes
import org.jetbrains.kotlin.load.java.structure.JavaArrayType
import org.jetbrains.kotlin.load.java.structure.JavaClass
import org.jetbrains.kotlin.load.java.structure.JavaConstructor
import org.jetbrains.kotlin.load.java.structure.JavaMethod
import org.jetbrains.kotlin.load.java.typeEnhacement.enhanceSignatures
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.resolve.DescriptorFactory
import org.jetbrains.kotlin.resolve.DescriptorUtils
import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
import org.jetbrains.kotlin.types.JetType
import org.jetbrains.kotlin.types.TypeUtils
import org.jetbrains.kotlin.utils.*
import java.util.*
public class LazyJavaClassMemberScope(
c: LazyJavaResolverContext,
containingDeclaration: ClassDescriptor,
private val jClass: JavaClass
) : LazyJavaScope(c, containingDeclaration) {
override fun computeMemberIndex(): MemberIndex {
return object : ClassMemberIndex(jClass, { !it.isStatic() }) {
// For SAM-constructors
override fun getMethodNames(nameFilter: (Name) -> Boolean): Collection
= super.getMethodNames(nameFilter) + getClassNames(DescriptorKindFilter.CLASSIFIERS, nameFilter)
}
}
internal val constructors = c.storageManager.createLazyValue {
val constructors = jClass.getConstructors()
val result = ArrayList(constructors.size())
for (constructor in constructors) {
val descriptor = resolveConstructor(constructor)
result.add(descriptor)
result.addIfNotNull(c.components.samConversionResolver.resolveSamAdapter(descriptor))
}
enhanceSignatures(
result ifEmpty { emptyOrSingletonList(createDefaultConstructor()) }
).toReadOnlyList()
}
override fun computeNonDeclaredFunctions(result: MutableCollection, name: Name) {
val functionsFromSupertypes = getFunctionsFromSupertypes(name, getContainingDeclaration())
result.addAll(DescriptorResolverUtils.resolveOverrides(name, functionsFromSupertypes, result, getContainingDeclaration(), c.components.errorReporter))
}
private fun getFunctionsFromSupertypes(name: Name, descriptor: ClassDescriptor): Set {
return descriptor.typeConstructor.supertypes.flatMap {
it.memberScope.getFunctions(name, NoLookupLocation.WHEN_GET_SUPER_MEMBERS).map { f -> f as SimpleFunctionDescriptor }
}.toSet()
}
override fun computeNonDeclaredProperties(name: Name, result: MutableCollection) {
if (jClass.isAnnotationType()) {
computeAnnotationProperties(name, result)
}
val propertiesFromSupertypes = getPropertiesFromSupertypes(name, getContainingDeclaration())
result.addAll(DescriptorResolverUtils.resolveOverrides(name, propertiesFromSupertypes, result, getContainingDeclaration(),
c.components.errorReporter))
}
private fun computeAnnotationProperties(name: Name, result: MutableCollection) {
val method = memberIndex().findMethodsByName(name).singleOrNull() ?: return
val annotations = c.resolveAnnotations(method)
val propertyDescriptor = JavaPropertyDescriptor(
getContainingDeclaration(), annotations, method.getVisibility(),
/* isVar = */ false, method.getName(), c.components.sourceElementFactory.source(method), /* original */ null,
/* isStaticFinal = */ false
)
// default getter is necessary because there is no real field in annotation
val getter = DescriptorFactory.createDefaultGetter(propertyDescriptor, Annotations.EMPTY)
propertyDescriptor.initialize(getter, null)
val returnType = computeMethodReturnType(method, annotations, c.child(propertyDescriptor, method))
propertyDescriptor.setType(returnType, listOf(), getDispatchReceiverParameter(), null as JetType?)
getter.initialize(returnType)
result.add(propertyDescriptor)
}
private fun getPropertiesFromSupertypes(name: Name, descriptor: ClassDescriptor): Set {
return descriptor.typeConstructor.supertypes.flatMap {
it.memberScope.getProperties(name, NoLookupLocation.WHEN_GET_SUPER_MEMBERS).map { p -> p as PropertyDescriptor }
}.toSet()
}
override fun resolveMethodSignature(
method: JavaMethod, methodTypeParameters: List, returnType: JetType,
valueParameters: LazyJavaScope.ResolvedValueParameters
): LazyJavaScope.MethodSignatureData {
val propagated = c.components.externalSignatureResolver.resolvePropagatedSignature(
method, getContainingDeclaration(), returnType, null, valueParameters.descriptors, methodTypeParameters
)
val effectiveSignature = c.components.externalSignatureResolver.resolveAlternativeMethodSignature(
method, !propagated.getSuperMethods().isEmpty(), propagated.getReturnType(),
propagated.getReceiverType(), propagated.getValueParameters(), propagated.getTypeParameters(),
propagated.hasStableParameterNames()
)
return LazyJavaScope.MethodSignatureData(effectiveSignature, propagated.getErrors() + effectiveSignature.getErrors())
}
private fun resolveConstructor(constructor: JavaConstructor): JavaConstructorDescriptor {
val classDescriptor = getContainingDeclaration()
val constructorDescriptor = JavaConstructorDescriptor.createJavaConstructor(
classDescriptor, c.resolveAnnotations(constructor), /* isPrimary = */ false, c.components.sourceElementFactory.source(constructor)
)
val valueParameters = resolveValueParameters(c, constructorDescriptor, constructor.getValueParameters())
val effectiveSignature = c.components.externalSignatureResolver.resolveAlternativeMethodSignature(
constructor, false, null, null, valueParameters.descriptors, Collections.emptyList(), false)
constructorDescriptor.initialize(
classDescriptor.getTypeConstructor().getParameters(),
effectiveSignature.getValueParameters(),
constructor.getVisibility()
)
constructorDescriptor.setHasStableParameterNames(effectiveSignature.hasStableParameterNames())
constructorDescriptor.setHasSynthesizedParameterNames(valueParameters.hasSynthesizedNames)
constructorDescriptor.setReturnType(classDescriptor.getDefaultType())
val signatureErrors = effectiveSignature.getErrors()
if (!signatureErrors.isEmpty()) {
c.components.externalSignatureResolver.reportSignatureErrors(constructorDescriptor, signatureErrors)
}
c.components.javaResolverCache.recordConstructor(constructor, constructorDescriptor)
return constructorDescriptor
}
private fun createDefaultConstructor(): ConstructorDescriptor? {
val isAnnotation: Boolean = jClass.isAnnotationType()
if (jClass.isInterface() && !isAnnotation)
return null
val classDescriptor = getContainingDeclaration()
val constructorDescriptor = JavaConstructorDescriptor.createJavaConstructor(
classDescriptor, Annotations.EMPTY, /* isPrimary = */ true, c.components.sourceElementFactory.source(jClass)
)
val typeParameters = classDescriptor.getTypeConstructor().getParameters()
val valueParameters = if (isAnnotation) createAnnotationConstructorParameters(constructorDescriptor)
else Collections.emptyList()
constructorDescriptor.setHasSynthesizedParameterNames(false)
constructorDescriptor.initialize(typeParameters, valueParameters, getConstructorVisibility(classDescriptor))
constructorDescriptor.setHasStableParameterNames(true)
constructorDescriptor.setReturnType(classDescriptor.getDefaultType())
c.components.javaResolverCache.recordConstructor(jClass, constructorDescriptor);
return constructorDescriptor
}
private fun getConstructorVisibility(classDescriptor: ClassDescriptor): Visibility {
val visibility = classDescriptor.getVisibility()
if (visibility == JavaVisibilities.PROTECTED_STATIC_VISIBILITY) {
return JavaVisibilities.PROTECTED_AND_PACKAGE
}
return visibility
}
private fun createAnnotationConstructorParameters(constructor: ConstructorDescriptorImpl): List {
val methods = jClass.getMethods()
val result = ArrayList(methods.size())
val attr = TypeUsage.MEMBER_SIGNATURE_INVARIANT.toAttributes(allowFlexible = false, isForAnnotationParameter = true)
val (methodsNamedValue, otherMethods) = methods.
partition { it.getName() == JvmAnnotationNames.DEFAULT_ANNOTATION_MEMBER_NAME }
assert(methodsNamedValue.size() <= 1) { "There can't be more than one method named 'value' in annotation class: $jClass" }
val methodNamedValue = methodsNamedValue.firstOrNull()
if (methodNamedValue != null) {
val parameterNamedValueJavaType = methodNamedValue.getReturnType()
val (parameterType, varargType) =
if (parameterNamedValueJavaType is JavaArrayType)
Pair(c.typeResolver.transformArrayType(parameterNamedValueJavaType, attr, isVararg = true),
c.typeResolver.transformJavaType(parameterNamedValueJavaType.getComponentType(), attr))
else
Pair(c.typeResolver.transformJavaType(parameterNamedValueJavaType, attr), null)
result.addAnnotationValueParameter(constructor, 0, methodNamedValue, parameterType, varargType)
}
val startIndex = if (methodNamedValue != null) 1 else 0
for ((index, method) in otherMethods.withIndex()) {
val parameterType = c.typeResolver.transformJavaType(method.getReturnType(), attr)
result.addAnnotationValueParameter(constructor, index + startIndex, method, parameterType, null)
}
return result
}
private fun MutableList.addAnnotationValueParameter(
constructor: ConstructorDescriptor,
index: Int,
method: JavaMethod,
returnType: JetType,
varargElementType: JetType?
) {
add(ValueParameterDescriptorImpl(
constructor,
null,
index,
Annotations.EMPTY,
method.getName(),
// Parameters of annotation constructors in Java are never nullable
TypeUtils.makeNotNullable(returnType),
method.hasAnnotationParameterDefaultValue(),
// Nulls are not allowed in annotation arguments in Java
varargElementType?.let { TypeUtils.makeNotNullable(it) },
c.components.sourceElementFactory.source(method)
))
}
private val nestedClassIndex = c.storageManager.createLazyValue {
jClass.getInnerClasses().valuesToMap { c -> c.getName() }
}
private val enumEntryIndex = c.storageManager.createLazyValue {
jClass.getFields().filter { it.isEnumEntry() }.valuesToMap { f -> f.getName() }
}
private val nestedClasses = c.storageManager.createMemoizedFunctionWithNullableValues {
name: Name ->
val jNestedClass = nestedClassIndex()[name]
if (jNestedClass == null) {
val field = enumEntryIndex()[name]
if (field != null) {
EnumEntrySyntheticClassDescriptor.create(c.storageManager, getContainingDeclaration(), name,
c.storageManager.createLazyValue {
memberIndex().getAllFieldNames() + memberIndex().getMethodNames({true})
}, c.components.sourceElementFactory.source(field))
}
else null
}
else {
LazyJavaClassDescriptor(
c, getContainingDeclaration(), DescriptorUtils.getFqName(getContainingDeclaration()).child(name).toSafe(), jNestedClass
)
}
}
override fun getDispatchReceiverParameter(): ReceiverParameterDescriptor? =
DescriptorUtils.getDispatchReceiverParameterIfNeeded(getContainingDeclaration())
override fun getClassifier(name: Name, location: LookupLocation): ClassifierDescriptor? = nestedClasses(name)
override fun getClassNames(kindFilter: DescriptorKindFilter, nameFilter: (Name) -> Boolean): Collection
= nestedClassIndex().keySet() + enumEntryIndex().keySet()
override fun getPropertyNames(kindFilter: DescriptorKindFilter, nameFilter: (Name) -> Boolean): Collection {
if (jClass.isAnnotationType()) return memberIndex().getMethodNames(nameFilter)
return memberIndex().getAllFieldNames() +
getContainingDeclaration().getTypeConstructor().getSupertypes().flatMapTo(LinkedHashSet()) { supertype ->
supertype.getMemberScope().getDescriptors(kindFilter, nameFilter).map { variable ->
variable.getName()
}
}
}
// TODO
override fun getImplicitReceiversHierarchy(): List = listOf()
override fun getContainingDeclaration() = super.getContainingDeclaration() as ClassDescriptor
// namespaces should be resolved elsewhere
override fun getPackage(name: Name) = null
override fun toString() = "Lazy java member scope for " + jClass.getFqName()
}
