| /* |
| * Copyright 2020 Google LLC |
| * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. |
| * |
| * 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 com.google.devtools.ksp.processing.impl |
| |
| import com.google.devtools.ksp.* |
| import com.google.devtools.ksp.processing.KSBuiltIns |
| import com.google.devtools.ksp.processing.Resolver |
| import com.google.devtools.ksp.processing.SymbolProcessor |
| import com.google.devtools.ksp.symbol.* |
| import com.google.devtools.ksp.symbol.ClassKind |
| import com.google.devtools.ksp.symbol.Variance |
| import com.google.devtools.ksp.symbol.impl.binary.* |
| import com.google.devtools.ksp.symbol.impl.declarationsInSourceOrder |
| import com.google.devtools.ksp.symbol.impl.findParentAnnotated |
| import com.google.devtools.ksp.symbol.impl.findPsi |
| import com.google.devtools.ksp.symbol.impl.getInstanceForCurrentRound |
| import com.google.devtools.ksp.symbol.impl.java.* |
| import com.google.devtools.ksp.symbol.impl.jvmAccessFlag |
| import com.google.devtools.ksp.symbol.impl.kotlin.* |
| import com.google.devtools.ksp.symbol.impl.resolveContainingClass |
| import com.google.devtools.ksp.symbol.impl.synthetic.* |
| import com.google.devtools.ksp.visitor.CollectAnnotatedSymbolsVisitor |
| import com.intellij.openapi.project.Project |
| import com.intellij.psi.* |
| import com.intellij.psi.impl.source.PsiClassReferenceType |
| import org.jetbrains.kotlin.builtins.KotlinBuiltIns |
| import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMap |
| import org.jetbrains.kotlin.codegen.ClassBuilderMode |
| import org.jetbrains.kotlin.codegen.OwnerKind |
| import org.jetbrains.kotlin.codegen.state.JVM_SUPPRESS_WILDCARDS_ANNOTATION_FQ_NAME |
| import org.jetbrains.kotlin.codegen.state.JVM_WILDCARD_ANNOTATION_FQ_NAME |
| import org.jetbrains.kotlin.codegen.state.KotlinTypeMapper |
| import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl |
| import org.jetbrains.kotlin.container.ComponentProvider |
| import org.jetbrains.kotlin.container.get |
| import org.jetbrains.kotlin.container.tryGetService |
| import org.jetbrains.kotlin.descriptors.* |
| import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor |
| import org.jetbrains.kotlin.descriptors.annotations.Annotations |
| import org.jetbrains.kotlin.incremental.components.NoLookupLocation |
| import org.jetbrains.kotlin.load.java.components.TypeUsage |
| import org.jetbrains.kotlin.load.java.descriptors.JavaForKotlinOverridePropertyDescriptor |
| import org.jetbrains.kotlin.load.java.lazy.JavaResolverComponents |
| import org.jetbrains.kotlin.load.java.lazy.LazyJavaResolverContext |
| import org.jetbrains.kotlin.load.java.lazy.ModuleClassResolver |
| import org.jetbrains.kotlin.load.java.lazy.TypeParameterResolver |
| import org.jetbrains.kotlin.load.java.lazy.childForClassOrPackage |
| import org.jetbrains.kotlin.load.java.lazy.childForMethod |
| import org.jetbrains.kotlin.load.java.lazy.descriptors.LazyJavaTypeParameterDescriptor |
| import org.jetbrains.kotlin.load.java.lazy.types.JavaTypeResolver |
| import org.jetbrains.kotlin.load.java.lazy.types.toAttributes |
| import org.jetbrains.kotlin.load.java.sources.JavaSourceElement |
| import org.jetbrains.kotlin.load.java.structure.JavaClass |
| import org.jetbrains.kotlin.load.java.structure.classId |
| import org.jetbrains.kotlin.load.java.structure.impl.JavaArrayTypeImpl |
| import org.jetbrains.kotlin.load.java.structure.impl.JavaClassImpl |
| import org.jetbrains.kotlin.load.java.structure.impl.JavaConstructorImpl |
| import org.jetbrains.kotlin.load.java.structure.impl.JavaFieldImpl |
| import org.jetbrains.kotlin.load.java.structure.impl.JavaMethodImpl |
| import org.jetbrains.kotlin.load.java.structure.impl.JavaTypeImpl |
| import org.jetbrains.kotlin.load.java.structure.impl.JavaTypeParameterImpl |
| import org.jetbrains.kotlin.load.java.structure.impl.classFiles.BinaryJavaClass |
| import org.jetbrains.kotlin.load.java.structure.impl.classFiles.BinaryJavaMethod |
| import org.jetbrains.kotlin.load.java.structure.impl.classFiles.BinaryJavaMethodBase |
| import org.jetbrains.kotlin.load.kotlin.TypeMappingMode |
| import org.jetbrains.kotlin.load.kotlin.VirtualFileKotlinClass |
| import org.jetbrains.kotlin.load.kotlin.getContainingKotlinJvmBinaryClass |
| import org.jetbrains.kotlin.load.kotlin.getOptimalModeForReturnType |
| import org.jetbrains.kotlin.load.kotlin.getOptimalModeForValueParameter |
| import org.jetbrains.kotlin.name.FqName |
| import org.jetbrains.kotlin.name.FqNameUnsafe |
| import org.jetbrains.kotlin.name.Name |
| import org.jetbrains.kotlin.psi.* |
| import org.jetbrains.kotlin.resolve.* |
| import org.jetbrains.kotlin.resolve.annotations.argumentValue |
| import org.jetbrains.kotlin.resolve.calls.inference.components.NewTypeSubstitutor |
| import org.jetbrains.kotlin.resolve.calls.inference.components.composeWith |
| import org.jetbrains.kotlin.resolve.calls.inference.substitute |
| import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo |
| import org.jetbrains.kotlin.resolve.constants.* |
| import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator |
| import org.jetbrains.kotlin.resolve.descriptorUtil.classId |
| import org.jetbrains.kotlin.resolve.descriptorUtil.getAllSuperClassifiers |
| import org.jetbrains.kotlin.resolve.descriptorUtil.module |
| import org.jetbrains.kotlin.resolve.descriptorUtil.propertyIfAccessor |
| import org.jetbrains.kotlin.resolve.lazy.DeclarationScopeProvider |
| import org.jetbrains.kotlin.resolve.lazy.ForceResolveUtil |
| import org.jetbrains.kotlin.resolve.lazy.ResolveSession |
| import org.jetbrains.kotlin.resolve.multiplatform.findActuals |
| import org.jetbrains.kotlin.resolve.multiplatform.findExpects |
| import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter |
| import org.jetbrains.kotlin.resolve.scopes.LexicalScope |
| import org.jetbrains.kotlin.resolve.scopes.MemberScope |
| import org.jetbrains.kotlin.types.* |
| import org.jetbrains.kotlin.types.checker.SimpleClassicTypeSystemContext |
| import org.jetbrains.kotlin.types.typeUtil.replaceArgumentsWithStarProjections |
| import org.jetbrains.kotlin.types.typeUtil.substitute |
| import org.jetbrains.kotlin.types.typeUtil.supertypes |
| import org.jetbrains.kotlin.util.containingNonLocalDeclaration |
| import org.jetbrains.org.objectweb.asm.ClassReader |
| import org.jetbrains.org.objectweb.asm.ClassVisitor |
| import org.jetbrains.org.objectweb.asm.MethodVisitor |
| import org.jetbrains.org.objectweb.asm.Opcodes |
| import org.jetbrains.org.objectweb.asm.Opcodes.API_VERSION |
| import java.io.File |
| import java.util.Stack |
| |
| class ResolverImpl( |
| val module: ModuleDescriptor, |
| val allKSFiles: Collection<KSFile>, |
| val newKSFiles: Collection<KSFile>, |
| private val deferredSymbols: Map<SymbolProcessor, List<KSAnnotated>>, |
| val bindingTrace: BindingTrace, |
| val project: Project, |
| componentProvider: ComponentProvider, |
| val incrementalContext: IncrementalContext, |
| val options: KspOptions, |
| ) : Resolver { |
| val psiDocumentManager = PsiDocumentManager.getInstance(project) |
| private val nameToKSMap: MutableMap<KSName, KSClassDeclaration> |
| private val javaTypeParameterMap: MutableMap<LazyJavaTypeParameterDescriptor, PsiTypeParameter> = mutableMapOf() |
| |
| /** |
| * Checking as member of is an expensive operation, hence we cache result values in this map. |
| */ |
| private val functionAsMemberOfCache: MutableMap<Pair<KSFunctionDeclaration, KSType>, KSFunction> |
| private val propertyAsMemberOfCache: MutableMap<Pair<KSPropertyDeclaration, KSType>, KSType> |
| |
| private val typeMapper = KotlinTypeMapper( |
| BindingContext.EMPTY, ClassBuilderMode.LIGHT_CLASSES, |
| module.name.getNonSpecialIdentifier(), |
| KotlinTypeMapper.LANGUAGE_VERSION_SETTINGS_DEFAULT, // TODO use proper LanguageVersionSettings |
| true |
| ) |
| private val qualifiedExpressionResolver = QualifiedExpressionResolver(LanguageVersionSettingsImpl.DEFAULT) |
| |
| private val aliasingFqNs: MutableMap<String, KSTypeAlias> = mutableMapOf() |
| private val aliasingNames: MutableSet<String> = mutableSetOf() |
| private val topDownAnalysisContext by lazy { |
| TopDownAnalysisContext(TopDownAnalysisMode.TopLevelDeclarations, DataFlowInfo.EMPTY, declarationScopeProvider) |
| } |
| |
| companion object { |
| var instance: ResolverImpl? = null |
| } |
| |
| var resolveSession: ResolveSession |
| var bodyResolver: BodyResolver |
| var constantExpressionEvaluator: ConstantExpressionEvaluator |
| var declarationScopeProvider: DeclarationScopeProvider |
| |
| lateinit var moduleClassResolver: ModuleClassResolver |
| lateinit var javaTypeResolver: JavaTypeResolver |
| lateinit var lazyJavaResolverContext: LazyJavaResolverContext |
| |
| init { |
| resolveSession = componentProvider.get() |
| bodyResolver = componentProvider.get() |
| declarationScopeProvider = componentProvider.get() |
| constantExpressionEvaluator = componentProvider.get() |
| |
| componentProvider.tryGetService(JavaResolverComponents::class.java)?.let { |
| lazyJavaResolverContext = LazyJavaResolverContext(it, TypeParameterResolver.EMPTY) { null } |
| javaTypeResolver = lazyJavaResolverContext.typeResolver |
| moduleClassResolver = lazyJavaResolverContext.components.moduleClassResolver |
| } |
| instance = this |
| |
| nameToKSMap = mutableMapOf() |
| functionAsMemberOfCache = mutableMapOf() |
| propertyAsMemberOfCache = mutableMapOf() |
| |
| val visitor = object : KSVisitorVoid() { |
| override fun visitFile(file: KSFile, data: Unit) { |
| file.declarations.forEach { it.accept(this, data) } |
| |
| // TODO: evaluate with benchmarks: cost of getContainingFile v.s. name collision |
| // Import aliases are file-scoped. `aliasingNamesByFile` could be faster |
| (file as? KSFileImpl)?.file?.importDirectives?.forEach { |
| it.aliasName?.let { aliasingNames.add(it) } |
| } |
| } |
| |
| override fun visitClassDeclaration(classDeclaration: KSClassDeclaration, data: Unit) { |
| val qualifiedName = classDeclaration.qualifiedName |
| if (qualifiedName != null) { |
| nameToKSMap[qualifiedName] = classDeclaration |
| } |
| classDeclaration.declarations.forEach { it.accept(this, data) } |
| } |
| |
| override fun visitTypeAlias(typeAlias: KSTypeAlias, data: Unit) { |
| typeAlias.qualifiedName?.asString()?.let { fqn -> |
| aliasingFqNs[fqn] = typeAlias |
| aliasingNames.add(fqn.substringAfterLast('.')) |
| } |
| } |
| } |
| |
| // FIXME: reuse results from previous rounds and only loop through newKSFiles. |
| allKSFiles.forEach { it.accept(visitor, Unit) } |
| } |
| |
| // Mitigation for processors with memory leaks |
| // https://github.com/google/ksp/issues/1063 |
| fun tearDown() { |
| instance = null |
| } |
| |
| override fun getNewFiles(): Sequence<KSFile> { |
| return newKSFiles.asSequence() |
| } |
| |
| override fun getAllFiles(): Sequence<KSFile> { |
| return allKSFiles.asSequence() |
| } |
| |
| override fun getClassDeclarationByName(name: KSName): KSClassDeclaration? { |
| nameToKSMap[name]?.let { return it } |
| |
| return module.resolveClassByFqName(FqName(name.asString()), NoLookupLocation.WHEN_FIND_BY_FQNAME) |
| ?.let { |
| val psi = it.findPsi() |
| if (psi != null) { |
| when (psi) { |
| is KtClassOrObject -> KSClassDeclarationImpl.getCached(psi) |
| is PsiClass -> KSClassDeclarationJavaImpl.getCached(psi) |
| else -> throw IllegalStateException("unexpected psi: ${psi.javaClass}") |
| } |
| } else { |
| KSClassDeclarationDescriptorImpl.getCached(it) |
| } |
| } |
| } |
| |
| override fun getFunctionDeclarationsByName( |
| name: KSName, |
| includeTopLevel: Boolean, |
| ): Sequence<KSFunctionDeclaration> { |
| val qualifier = name.getQualifier() |
| val functionName = name.getShortName() |
| val nonTopLevelResult = this.getClassDeclarationByName(qualifier)?.getDeclaredFunctions() |
| ?.filter { it.simpleName.asString() == functionName }?.asSequence() ?: emptySequence() |
| return if (!includeTopLevel) nonTopLevelResult else { |
| nonTopLevelResult.plus( |
| module.getPackage(FqName(qualifier)) |
| .memberScope.getContributedDescriptors(DescriptorKindFilter.FUNCTIONS) { |
| it.asString() == functionName |
| } |
| .filterIsInstance<MemberDescriptor>().mapNotNull { it.toKSDeclaration() as? KSFunctionDeclaration } |
| ) |
| } |
| } |
| |
| override fun getPropertyDeclarationByName(name: KSName, includeTopLevel: Boolean): KSPropertyDeclaration? { |
| val qualifier = name.getQualifier() |
| val propertyName = name.getShortName() |
| val nonTopLevelResult = this.getClassDeclarationByName(qualifier)?.getDeclaredProperties() |
| ?.singleOrNull { it.simpleName.asString() == propertyName } |
| return if (!includeTopLevel) nonTopLevelResult else { |
| val topLevelResult = ( |
| module.getPackage(FqName(qualifier)) |
| .memberScope.getContributedDescriptors(DescriptorKindFilter.VARIABLES) { |
| it.asString() == propertyName |
| } |
| .also { |
| if (it.size > 1) { |
| throw IllegalStateException("Found multiple properties with same qualified name") |
| } |
| } |
| .singleOrNull() as? MemberDescriptor |
| )?.toKSDeclaration() as? KSPropertyDeclaration |
| if (topLevelResult != null && nonTopLevelResult != null) { |
| throw IllegalStateException("Found multiple properties with same qualified name") |
| } |
| nonTopLevelResult ?: topLevelResult |
| } |
| } |
| |
| internal fun checkAnnotation(annotation: KSAnnotation, ksName: KSName, shortName: String): Boolean { |
| val annotationType = annotation.annotationType |
| val referencedName = (annotationType.element as? KSClassifierReference)?.referencedName() |
| val simpleName = referencedName?.substringAfterLast('.') |
| return (simpleName == shortName || simpleName in aliasingNames) && |
| annotationType.resolveToUnderlying().declaration.qualifiedName == ksName |
| } |
| |
| override fun getSymbolsWithAnnotation(annotationName: String, inDepth: Boolean): Sequence<KSAnnotated> { |
| // If annotationName is a typealias, resolve to underlying type. |
| val realAnnotationName = |
| aliasingFqNs[annotationName]?.type?.resolveToUnderlying()?.declaration?.qualifiedName?.asString() |
| ?: annotationName |
| |
| val ksName = KSNameImpl.getCached(realAnnotationName) |
| val shortName = ksName.getShortName() |
| |
| fun checkAnnotated(annotated: KSAnnotated): Boolean { |
| return annotated.annotations.any { |
| checkAnnotation(it, ksName, shortName) |
| } |
| } |
| |
| val allAnnotated = if (inDepth) newAnnotatedSymbolsWithLocals else newAnnotatedSymbols |
| return allAnnotated.asSequence().filter(::checkAnnotated) |
| } |
| |
| private fun collectAnnotatedSymbols(inDepth: Boolean): Collection<KSAnnotated> { |
| val visitor = CollectAnnotatedSymbolsVisitor(inDepth) |
| |
| for (file in newKSFiles) { |
| file.accept(visitor, Unit) |
| } |
| |
| return visitor.symbols |
| } |
| |
| private val deferredSymbolsUpdated: Collection<KSAnnotated> by lazy { |
| deferredSymbols.values.flatten().mapNotNull { it.getInstanceForCurrentRound() } |
| } |
| |
| private val newAnnotatedSymbols: Collection<KSAnnotated> by lazy { |
| collectAnnotatedSymbols(false) + deferredSymbolsUpdated |
| } |
| |
| private val newAnnotatedSymbolsWithLocals: Collection<KSAnnotated> by lazy { |
| collectAnnotatedSymbols(true) + deferredSymbolsUpdated |
| } |
| |
| override fun getKSNameFromString(name: String): KSName { |
| return KSNameImpl.getCached(name) |
| } |
| |
| override fun createKSTypeReferenceFromKSType(type: KSType): KSTypeReference { |
| return KSTypeReferenceSyntheticImpl.getCached(type, null) |
| } |
| |
| @KspExperimental |
| override fun mapToJvmSignature(declaration: KSDeclaration): String? = mapToJvmSignatureInternal(declaration) |
| |
| internal fun mapToJvmSignatureInternal(declaration: KSDeclaration): String? = when (declaration) { |
| is KSClassDeclaration -> resolveClassDeclaration(declaration)?.let { typeMapper.mapType(it).descriptor } |
| is KSFunctionDeclaration -> resolveFunctionDeclaration(declaration)?.let { |
| when (it) { |
| is FunctionDescriptor -> typeMapper.mapAsmMethod(it).descriptor |
| is PropertyDescriptor -> typeMapper.mapFieldSignature(it.type, it) ?: typeMapper.mapType(it).descriptor |
| else -> throw IllegalStateException("Unexpected descriptor type for declaration: $declaration") |
| } |
| } |
| is KSPropertyDeclaration -> resolvePropertyDeclaration(declaration)?.let { |
| typeMapper.mapFieldSignature(it.type, it) ?: typeMapper.mapType(it).descriptor |
| } |
| else -> null |
| } |
| |
| override fun overrides(overrider: KSDeclaration, overridee: KSDeclaration): Boolean { |
| fun resolveForOverride(declaration: KSDeclaration): DeclarationDescriptor? { |
| return when (declaration) { |
| is KSPropertyDeclaration -> resolvePropertyDeclaration(declaration) |
| is KSFunctionDeclarationJavaImpl -> resolveJavaDeclaration(declaration.psi) |
| is KSFunctionDeclaration -> resolveFunctionDeclaration(declaration) |
| else -> null |
| } |
| } |
| |
| if (!overridee.isOpen()) |
| return false |
| if (!overridee.isVisibleFrom(overrider)) |
| return false |
| if (!( |
| overridee is KSFunctionDeclaration || overrider is KSFunctionDeclaration || |
| (overridee is KSPropertyDeclaration && overrider is KSPropertyDeclaration) |
| ) |
| ) |
| return false |
| |
| if (overrider is KSPropertyDeclarationJavaImpl) |
| return false |
| |
| val superDescriptor = resolveForOverride(overridee) as? CallableMemberDescriptor ?: return false |
| val subDescriptor = resolveForOverride(overrider) as? CallableMemberDescriptor ?: return false |
| val subClassDescriptor = overrider.closestClassDeclaration()?.let { |
| resolveClassDeclaration(it) |
| } ?: return false |
| val superClassDescriptor = overridee.closestClassDeclaration()?.let { |
| resolveClassDeclaration(it) |
| } ?: return false |
| |
| incrementalContext.recordLookupWithSupertypes(subClassDescriptor.defaultType) |
| |
| val typeOverride = subClassDescriptor.getAllSuperClassifiers() |
| .filter { it != subClassDescriptor } // exclude subclass itself as it cannot override its own methods |
| .any { |
| it == superClassDescriptor |
| } |
| if (!typeOverride) return false |
| |
| incrementalContext.recordLookupForDeclaration(overrider) |
| incrementalContext.recordLookupForDeclaration(overridee) |
| |
| return OverridingUtil.overrides(subDescriptor, superDescriptor, true, true) |
| } |
| |
| // check if the candidate is overridden from the original declaration. |
| private fun isOriginal(original: KSDeclaration, candidate: KSDeclaration): Boolean { |
| incrementalContext.recordLookupForDeclaration(original) |
| incrementalContext.recordLookupForDeclaration(candidate) |
| val originalDescriptor = when (original) { |
| is KSPropertyDeclaration -> resolvePropertyDeclaration(original) |
| is KSFunctionDeclaration -> |
| (resolveFunctionDeclaration(original) as? FunctionDescriptor)?.propertyIfAccessor |
| else -> return false |
| } |
| |
| val candidateDescriptors = when (candidate) { |
| is KSPropertyDeclaration -> resolvePropertyDeclaration(candidate)?.overriddenDescriptors |
| is KSFunctionDeclaration -> resolveFunctionDeclaration(candidate)?.overriddenDescriptors |
| else -> return false |
| } |
| return candidateDescriptors?.any { it == originalDescriptor } ?: false |
| } |
| |
| override fun overrides( |
| overrider: KSDeclaration, |
| overridee: KSDeclaration, |
| containingClass: KSClassDeclaration |
| ): Boolean { |
| incrementalContext.recordLookupForDeclaration(containingClass) |
| return when (overrider) { |
| is KSPropertyDeclaration -> containingClass.getAllProperties().singleOrNull { |
| it.simpleName.asString() == overrider.simpleName.asString() && isOriginal(overrider, it) |
| }?.let { overrides(it, overridee) } ?: false |
| is KSFunctionDeclaration -> { |
| val candidates = containingClass.getAllFunctions().filter { |
| it.simpleName.asString() == overridee.simpleName.asString() |
| } |
| if (overrider.simpleName.asString().startsWith("get") || |
| overrider.simpleName.asString().startsWith("set") |
| ) { |
| candidates.plus( |
| containingClass.getAllProperties().filter { |
| val overriderName = overrider.simpleName.asString().substring(3) |
| .replaceFirstChar { it.lowercase() } |
| it.simpleName.asString() == overriderName || |
| it.simpleName.asString().replaceFirstChar { it.lowercase() } == overriderName |
| } |
| // TODO: It is currently not possible to do the overridden descriptor optimization for java overrides. |
| ).any { overrides(it, overridee) } |
| } else { |
| candidates.singleOrNull { isOriginal(overrider, it) }?.let { overrides(it, overridee) } ?: false |
| } |
| } |
| else -> false |
| } |
| } |
| |
| fun evaluateConstant(expression: KtExpression?, expectedType: KotlinType): ConstantValue<*>? { |
| return expression?.let { |
| if (it is KtClassLiteralExpression && it.receiverExpression != null) { |
| val parent = KtStubbedPsiUtil.getPsiOrStubParent(it, KtPrimaryConstructor::class.java, false) |
| val scope = resolveSession.declarationScopeProvider.getResolutionScopeForDeclaration(parent!!) |
| val result = qualifiedExpressionResolver |
| .resolveDescriptorForDoubleColonLHS(it.receiverExpression!!, scope, bindingTrace, false) |
| val classifier = result.classifierDescriptor ?: return null |
| val typeResolutionContext = TypeResolutionContext(scope, bindingTrace, true, true, false) |
| val possiblyBareType = resolveSession.typeResolver |
| .resolveTypeForClassifier(typeResolutionContext, classifier, result, it, Annotations.EMPTY) |
| var actualType = if (possiblyBareType.isBare) |
| possiblyBareType.bareTypeConstructor.declarationDescriptor!!.defaultType |
| else possiblyBareType.actualType |
| var arrayDimension = 0 |
| while (KotlinBuiltIns.isArray(actualType)) { |
| actualType = actualType.arguments.single().type |
| arrayDimension += 1 |
| } |
| KClassValue(actualType.constructor.declarationDescriptor.classId!!, arrayDimension) |
| } else { |
| constantExpressionEvaluator.evaluateExpression(it, bindingTrace)?.toConstantValue(expectedType) ?: run { |
| val parent = KtStubbedPsiUtil |
| .getPsiOrStubParent(expression, KtPrimaryConstructor::class.java, false) |
| val scope = resolveSession.declarationScopeProvider.getResolutionScopeForDeclaration(parent!!) |
| qualifiedExpressionResolver |
| .resolvePackageHeader(expression.containingKtFile.packageDirective!!, module, bindingTrace) |
| bodyResolver.resolveConstructorParameterDefaultValues( |
| topDownAnalysisContext.outerDataFlowInfo, bindingTrace, |
| parent, (scope.ownerDescriptor as ClassDescriptor).constructors.first(), scope, |
| resolveSession.inferenceSession |
| ) |
| constantExpressionEvaluator.evaluateExpression(it, bindingTrace)?.toConstantValue(expectedType) |
| } |
| } |
| } |
| } |
| |
| fun resolveDeclaration(declaration: KtDeclaration): DeclarationDescriptor? { |
| return if (KtPsiUtil.isLocal(declaration)) { |
| resolveDeclarationForLocal(declaration) |
| bindingTrace.bindingContext.get(BindingContext.DECLARATION_TO_DESCRIPTOR, declaration) |
| } else { |
| resolveSession.resolveToDescriptor(declaration) |
| } |
| } |
| |
| // TODO: Resolve Java variables is not supported by this function. Not needed currently. |
| fun resolveJavaDeclaration(psi: PsiElement): DeclarationDescriptor? { |
| return when (psi) { |
| is PsiClass -> moduleClassResolver.resolveClass( |
| JavaClassImpl(psi).apply { workaroundForNested(lazyJavaResolverContext) } |
| ) |
| is PsiMethod -> { |
| // TODO: get rid of hardcoded check if possible. |
| val property = if (psi.name.startsWith("set") || psi.name.startsWith("get")) { |
| moduleClassResolver |
| .resolveContainingClass(psi) |
| ?.findEnclosedDescriptor( |
| kindFilter = DescriptorKindFilter.CALLABLES |
| ) { |
| (it as? PropertyDescriptor)?.getter?.findPsi() == psi || |
| (it as? PropertyDescriptor)?.setter?.findPsi() == psi |
| } |
| } else null |
| property ?: moduleClassResolver |
| .resolveContainingClass(psi)?.let { containingClass -> |
| val filter = if (psi is SyntheticElement) { |
| { declaration: DeclarationDescriptor -> declaration.name.asString() == psi.name } |
| } else { |
| { declaration: DeclarationDescriptor -> declaration.findPsi() == psi } |
| } |
| containingClass.findEnclosedDescriptor( |
| kindFilter = DescriptorKindFilter.FUNCTIONS, |
| filter = filter |
| ) |
| } |
| } |
| is PsiField -> { |
| moduleClassResolver |
| .resolveClass( |
| JavaFieldImpl(psi).containingClass.apply { workaroundForNested(lazyJavaResolverContext) } |
| ) |
| ?.findEnclosedDescriptor( |
| kindFilter = DescriptorKindFilter.VARIABLES, |
| filter = { it.findPsi() == psi } |
| ) |
| } |
| else -> throw IllegalStateException("unhandled psi element kind: ${psi.javaClass}") |
| } |
| } |
| |
| fun resolveClassDeclaration(classDeclaration: KSClassDeclaration): ClassDescriptor? { |
| return when (classDeclaration) { |
| is KSClassDeclarationImpl -> resolveDeclaration(classDeclaration.ktClassOrObject) |
| is KSClassDeclarationDescriptorImpl -> classDeclaration.descriptor |
| is KSClassDeclarationJavaImpl -> resolveJavaDeclaration(classDeclaration.psi) |
| else -> throw IllegalStateException("unexpected class: ${classDeclaration.javaClass}") |
| } as ClassDescriptor? |
| } |
| |
| fun resolveFunctionDeclaration(function: KSFunctionDeclaration): CallableDescriptor? { |
| return when (function) { |
| is KSFunctionDeclarationImpl -> resolveDeclaration(function.ktFunction) |
| is KSFunctionDeclarationDescriptorImpl -> function.descriptor |
| is KSFunctionDeclarationJavaImpl -> { |
| val descriptor = resolveJavaDeclaration(function.psi) |
| if (descriptor is JavaForKotlinOverridePropertyDescriptor) { |
| if (function.simpleName.asString().startsWith("set")) { |
| descriptor.setter |
| } else { |
| descriptor.getter |
| } |
| } else { |
| descriptor |
| } |
| } |
| is KSConstructorSyntheticImpl -> { |
| // we might create synthetic constructor when it is not declared in code |
| // it is either for kotlin, where we can use primary constructor, or for java |
| // where we can use the only available constructor |
| val resolved = resolveClassDeclaration(function.ksClassDeclaration) |
| resolved?.unsubstitutedPrimaryConstructor ?: resolved?.constructors?.singleOrNull() |
| } |
| else -> throw IllegalStateException("unexpected class: ${function.javaClass}") |
| } as? CallableDescriptor |
| } |
| |
| fun resolvePropertyDeclaration(property: KSPropertyDeclaration): PropertyDescriptor? { |
| return when (property) { |
| is KSPropertyDeclarationImpl -> resolveDeclaration(property.ktProperty) |
| is KSPropertyDeclarationParameterImpl -> resolveDeclaration(property.ktParameter) |
| is KSPropertyDeclarationDescriptorImpl -> property.descriptor |
| is KSPropertyDeclarationJavaImpl -> resolveJavaDeclaration(property.psi) |
| else -> throw IllegalStateException("unexpected class: ${property.javaClass}") |
| } as PropertyDescriptor? |
| } |
| |
| fun resolvePropertyAccessorDeclaration(accessor: KSPropertyAccessor): PropertyAccessorDescriptor? { |
| return when (accessor) { |
| is KSPropertyAccessorDescriptorImpl -> accessor.descriptor |
| is KSPropertyAccessorImpl -> resolveDeclaration(accessor.ktPropertyAccessor) |
| is KSPropertySetterSyntheticImpl -> resolvePropertyDeclaration(accessor.receiver)?.setter |
| is KSPropertyGetterSyntheticImpl -> resolvePropertyDeclaration(accessor.receiver)?.getter |
| else -> throw IllegalStateException("unexpected class: ${accessor.javaClass}") |
| } as PropertyAccessorDescriptor? |
| } |
| |
| fun resolveJavaType(psi: PsiType, parentTypeReference: KSTypeReference? = null): KotlinType { |
| incrementalContext.recordLookup(psi) |
| val javaType = JavaTypeImpl.create(psi) |
| |
| var parent: KSNode? = parentTypeReference |
| |
| val stack = Stack<KSNode>() |
| while (parent != null) { |
| if (parent is KSFunctionDeclarationJavaImpl || parent is KSClassDeclarationJavaImpl) { |
| stack.push(parent) |
| } |
| parent = parent.parent |
| } |
| // Construct resolver context for the PsiType |
| var resolverContext = lazyJavaResolverContext |
| |
| for (e in stack) { |
| when (e) { |
| is KSFunctionDeclarationJavaImpl -> { |
| // Non-physical methods have no interesting scope and may have no containing class |
| if (!e.psi.isPhysical || e.psi.containingClass == null) |
| continue |
| resolverContext = resolverContext |
| .childForMethod( |
| resolveJavaDeclaration(e.psi)!!, |
| if (e.psi.isConstructor) JavaConstructorImpl(e.psi) else JavaMethodImpl(e.psi) |
| ) |
| } |
| is KSClassDeclarationJavaImpl -> { |
| resolverContext = resolverContext |
| .childForClassOrPackage(resolveJavaDeclaration(e.psi) as ClassDescriptor, JavaClassImpl(e.psi)) |
| } |
| } |
| } |
| return if (javaType is JavaArrayTypeImpl) |
| resolverContext |
| .typeResolver.transformArrayType(javaType, TypeUsage.COMMON.toAttributes(), psi is PsiEllipsisType) |
| else |
| resolverContext.typeResolver.transformJavaType(javaType, TypeUsage.COMMON.toAttributes()) |
| } |
| |
| /* |
| * Don't map Java types in annotation parameters |
| * |
| * Users may specify Java types explicitly by instances of `Class<T>`. |
| * The situation is similar to `getClassDeclarationByName` where we have |
| * decided to keep those Java types not mapped. |
| * |
| * It would be troublesome if users try to use reflection on types that |
| * were mapped to Kotlin builtins, becuase some of those builtins don't |
| * even exist in classpath. |
| * |
| * Therefore, ResolverImpl.resolveJavaType cannot be used. |
| */ |
| fun resolveJavaTypeInAnnotations(psiType: PsiType): KSType = if (options.mapAnnotationArgumentsInJava) { |
| getKSTypeCached(resolveJavaType(psiType)) |
| } else { |
| when (psiType) { |
| is PsiPrimitiveType -> { |
| getClassDeclarationByName(psiType.boxedTypeName!!)!!.asStarProjectedType() |
| } |
| is PsiArrayType -> { |
| val componentType = resolveJavaTypeInAnnotations(psiType.componentType) |
| val componentTypeRef = createKSTypeReferenceFromKSType(componentType) |
| val typeArgs = listOf(getTypeArgument(componentTypeRef, Variance.INVARIANT)) |
| builtIns.arrayType.replace(typeArgs) |
| } |
| else -> { |
| getClassDeclarationByName(psiType.canonicalText)?.asStarProjectedType() ?: KSErrorType |
| } |
| } |
| } |
| |
| fun KotlinType.expandNonRecursively(): KotlinType = |
| (constructor.declarationDescriptor as? TypeAliasDescriptor)?.expandedType?.withAbbreviation(this as SimpleType) |
| ?: this |
| |
| fun TypeProjection.expand(): TypeProjection { |
| val expandedType = type.expand() |
| return if (expandedType == type) this else substitute { expandedType } |
| } |
| |
| // TODO: Is this the most efficient way? |
| fun KotlinType.expand(): KotlinType = |
| replace(arguments.map { it.expand() }).expandNonRecursively() |
| |
| fun KtTypeReference.lookup(): KotlinType? = |
| bindingTrace.get(BindingContext.ABBREVIATED_TYPE, this)?.expand() ?: bindingTrace.get(BindingContext.TYPE, this) |
| |
| fun resolveUserType(type: KSTypeReference): KSType { |
| when (type) { |
| is KSTypeReferenceImpl -> { |
| val typeReference = type.ktTypeReference |
| typeReference.lookup()?.let { |
| return getKSTypeCached(it, type.element.typeArguments, type.annotations) |
| } |
| KtStubbedPsiUtil.getContainingDeclaration(typeReference)?.let { containingDeclaration -> |
| resolveDeclaration(containingDeclaration)?.let { |
| // TODO: only resolve relevant branch. |
| ForceResolveUtil.forceResolveAllContents(it) |
| } |
| // TODO: Fix resolution look up to avoid fallback to file scope. |
| typeReference.lookup()?.let { |
| return getKSTypeCached(it, type.element.typeArguments, type.annotations) |
| } |
| } |
| val scope = resolveSession.fileScopeProvider.getFileResolutionScope(typeReference.containingKtFile) |
| return resolveSession.typeResolver.resolveType(scope, typeReference, bindingTrace, false).let { |
| getKSTypeCached(it, type.element.typeArguments, type.annotations) |
| } |
| } |
| is KSTypeReferenceDescriptorImpl -> { |
| return getKSTypeCached(type.kotlinType) |
| } |
| is KSTypeReferenceJavaImpl -> { |
| val psi = (type.psi as? PsiClassReferenceType)?.resolve() |
| if (psi is PsiTypeParameter) { |
| (type.psi as PsiClassReferenceType).typeArguments().forEach { |
| if (it is PsiType) { |
| incrementalContext.recordLookup(it) |
| } |
| } |
| val containingDeclaration = if (psi.owner is PsiClass) { |
| moduleClassResolver.resolveClass( |
| JavaClassImpl(psi.owner as PsiClass).apply { workaroundForNested(lazyJavaResolverContext) } |
| ) |
| } else { |
| val owner = psi.owner |
| check(owner is PsiMethod) { |
| "unexpected owner type: $owner / ${owner?.javaClass}" |
| } |
| moduleClassResolver.resolveContainingClass(owner) |
| ?.findEnclosedDescriptor( |
| kindFilter = DescriptorKindFilter.FUNCTIONS, |
| filter = { it.findPsi() == owner } |
| ) as FunctionDescriptor |
| } as DeclarationDescriptor |
| val typeParameterDescriptor = LazyJavaTypeParameterDescriptor( |
| lazyJavaResolverContext, |
| JavaTypeParameterImpl(psi), |
| psi.index, |
| containingDeclaration |
| ) |
| javaTypeParameterMap[typeParameterDescriptor] = psi |
| } |
| return getKSTypeCached(resolveJavaType(type.psi, type), type.element.typeArguments, type.annotations) |
| } |
| else -> throw IllegalStateException("Unable to resolve type for $type, $ExceptionMessage") |
| } |
| } |
| |
| fun findDeclaration(kotlinType: KotlinType): KSDeclaration { |
| val descriptor = kotlinType.constructor.declarationDescriptor |
| val psi = descriptor?.findPsi() |
| return if (psi != null) { |
| when (psi) { |
| is KtClassOrObject -> KSClassDeclarationImpl.getCached(psi) |
| is PsiClass -> KSClassDeclarationJavaImpl.getCached(psi) |
| is KtTypeAlias -> KSTypeAliasImpl.getCached(psi) |
| is KtTypeParameter -> KSTypeParameterImpl.getCached(psi) |
| is PsiEnumConstant -> KSClassDeclarationJavaEnumEntryImpl.getCached(psi) |
| else -> throw IllegalStateException("Unexpected psi type: ${psi.javaClass}, $ExceptionMessage") |
| } |
| } else { |
| when (descriptor) { |
| is ClassDescriptor -> KSClassDeclarationDescriptorImpl.getCached(descriptor) |
| // LazyJavaTypeParameterDescriptor has `source` overridden to `NO_SOURCE`, therefore |
| // need to look up psi within KSP. |
| is TypeParameterDescriptor -> if (descriptor in javaTypeParameterMap) { |
| KSTypeParameterJavaImpl.getCached(javaTypeParameterMap[descriptor]!!) |
| } else { |
| KSTypeParameterDescriptorImpl.getCached(descriptor) |
| } |
| is TypeAliasDescriptor -> KSTypeAliasDescriptorImpl.getCached(descriptor) |
| null -> throw IllegalStateException("Failed to resolve descriptor for $kotlinType") |
| else -> throw IllegalStateException( |
| "Unexpected descriptor type: ${descriptor.javaClass}, $ExceptionMessage" |
| ) |
| } |
| } |
| } |
| |
| // Finds closest non-local scope. |
| fun KtElement.findLexicalScope(): LexicalScope { |
| return containingNonLocalDeclaration()?.let { |
| resolveSession.declarationScopeProvider.getResolutionScopeForDeclaration(it) |
| } ?: resolveSession.fileScopeProvider.getFileResolutionScope(this.containingKtFile) |
| } |
| |
| fun resolveAnnotationEntry(ktAnnotationEntry: KtAnnotationEntry): AnnotationDescriptor? { |
| bindingTrace.get(BindingContext.ANNOTATION, ktAnnotationEntry)?.let { return it } |
| KtStubbedPsiUtil.getContainingDeclaration(ktAnnotationEntry)?.let { containingDeclaration -> |
| if (KtPsiUtil.isLocal(containingDeclaration)) { |
| resolveDeclarationForLocal(containingDeclaration) |
| } else { |
| resolveSession.resolveToDescriptor(containingDeclaration).annotations.forEach {} |
| } |
| } ?: ktAnnotationEntry.containingKtFile.let { |
| resolveSession.getFileAnnotations(it).forEach {} |
| } |
| return bindingTrace.get(BindingContext.ANNOTATION, ktAnnotationEntry) |
| } |
| |
| fun resolveDeclarationForLocal(localDeclaration: KtDeclaration) { |
| var declaration = KtStubbedPsiUtil.getContainingDeclaration(localDeclaration) ?: return |
| while (KtPsiUtil.isLocal(declaration)) |
| declaration = KtStubbedPsiUtil.getContainingDeclaration(declaration)!! |
| |
| val containingFD = resolveSession.resolveToDescriptor(declaration).also { |
| ForceResolveUtil.forceResolveAllContents(it) |
| } |
| |
| if (declaration is KtNamedFunction) { |
| val dataFlowInfo = DataFlowInfo.EMPTY |
| val scope = resolveSession.declarationScopeProvider.getResolutionScopeForDeclaration(declaration) |
| bodyResolver.resolveFunctionBody( |
| dataFlowInfo, |
| bindingTrace, |
| declaration, |
| containingFD as FunctionDescriptor, |
| scope, |
| null |
| ) |
| } |
| } |
| |
| @KspExperimental |
| override fun getJvmName(accessor: KSPropertyAccessor): String? { |
| val descriptor = resolvePropertyAccessorDeclaration(accessor) |
| |
| return descriptor?.let { |
| // KotlinTypeMapper.mapSignature always uses OwnerKind.IMPLEMENTATION |
| typeMapper.mapFunctionName(descriptor, OwnerKind.IMPLEMENTATION) |
| } |
| } |
| |
| @KspExperimental |
| override fun getJvmName(declaration: KSFunctionDeclaration): String? { |
| // function names might be mangled if they receive inline class parameters or they are internal |
| val descriptor = resolveFunctionDeclaration(declaration) |
| return (descriptor as? FunctionDescriptor)?.let { |
| // KotlinTypeMapper.mapSignature always uses OwnerKind.IMPLEMENTATION |
| typeMapper.mapFunctionName(it, OwnerKind.IMPLEMENTATION) |
| } |
| } |
| |
| @KspExperimental |
| override fun getOwnerJvmClassName(declaration: KSPropertyDeclaration): String? { |
| val descriptor = resolvePropertyDeclaration(declaration) ?: return null |
| return getJvmOwnerQualifiedName(descriptor) |
| } |
| |
| @KspExperimental |
| override fun getOwnerJvmClassName(declaration: KSFunctionDeclaration): String? { |
| val descriptor = resolveFunctionDeclaration(declaration) ?: return null |
| return getJvmOwnerQualifiedName(descriptor) |
| } |
| |
| private fun getJvmOwnerQualifiedName(descriptor: DeclarationDescriptor): String? { |
| return try { |
| typeMapper.mapImplementationOwner(descriptor).className |
| } catch (unsupported: UnsupportedOperationException) { |
| null |
| } |
| } |
| |
| private fun extractThrowsFromClassFile( |
| virtualFileContent: ByteArray, |
| jvmDesc: String?, |
| simpleName: String? |
| ): Sequence<KSType> { |
| val exceptionNames = mutableListOf<String>() |
| ClassReader(virtualFileContent).accept( |
| object : ClassVisitor(API_VERSION) { |
| override fun visitMethod( |
| access: Int, |
| name: String?, |
| descriptor: String?, |
| signature: String?, |
| exceptions: Array<out String>?, |
| ): MethodVisitor { |
| if (name == simpleName && jvmDesc == descriptor) { |
| exceptions?.toList()?.let { exceptionNames.addAll(it) } |
| } |
| return object : MethodVisitor(API_VERSION) { |
| } |
| } |
| }, |
| ClassReader.SKIP_CODE or ClassReader.SKIP_DEBUG or ClassReader.SKIP_FRAMES |
| ) |
| return exceptionNames.mapNotNull { |
| this@ResolverImpl.getClassDeclarationByName(it.replace("/", "."))?.asStarProjectedType() |
| }.asSequence() |
| } |
| |
| @SuppressWarnings("UNCHECKED_CAST") |
| private fun extractThrowsAnnotation(annotated: KSAnnotated): Sequence<KSType> { |
| return annotated.annotations |
| .singleOrNull { |
| it.shortName.asString() == "Throws" && |
| it.annotationType.resolve().declaration.qualifiedName?.asString() == "kotlin.Throws" |
| }?.arguments |
| ?.singleOrNull() |
| ?.let { it.value as? ArrayList<KSType> } |
| ?.asSequence() ?: emptySequence() |
| } |
| |
| // TODO: refactor and reuse BinaryClassInfoCache |
| @KspExperimental |
| override fun getJvmCheckedException(function: KSFunctionDeclaration): Sequence<KSType> { |
| return when (function.origin) { |
| Origin.JAVA -> { |
| val psi = (function as KSFunctionDeclarationJavaImpl).psi |
| psi.throwsList.referencedTypes.asSequence().map { getKSTypeCached(resolveJavaType(it)) } |
| } |
| Origin.KOTLIN -> { |
| extractThrowsAnnotation(function) |
| } |
| Origin.KOTLIN_LIB, Origin.JAVA_LIB -> { |
| val descriptor = (function as KSFunctionDeclarationDescriptorImpl).descriptor |
| val jvmDesc = this.mapToJvmSignature(function) |
| val virtualFileContent = if (function.origin == Origin.KOTLIN_LIB) { |
| (descriptor.getContainingKotlinJvmBinaryClass() as? VirtualFileKotlinClass)?.file |
| ?.contentsToByteArray() |
| } else { |
| ( |
| ((descriptor.source as? JavaSourceElement)?.javaElement as? BinaryJavaMethodBase) |
| ?.containingClass as? BinaryJavaClass |
| )?.virtualFile?.contentsToByteArray() |
| } |
| if (virtualFileContent == null) { |
| return emptySequence() |
| } |
| extractThrowsFromClassFile(virtualFileContent, jvmDesc, function.simpleName.asString()) |
| } |
| else -> emptySequence() |
| } |
| } |
| |
| @KspExperimental |
| override fun getJvmCheckedException(accessor: KSPropertyAccessor): Sequence<KSType> { |
| return when (accessor.origin) { |
| Origin.KOTLIN, Origin.SYNTHETIC -> { |
| extractThrowsAnnotation(accessor) |
| } |
| Origin.KOTLIN_LIB -> { |
| val descriptor = (accessor as KSPropertyAccessorDescriptorImpl).descriptor |
| val jvmDesc = typeMapper.mapAsmMethod(descriptor).descriptor |
| val virtualFileContent = if (accessor.origin == Origin.KOTLIN_LIB) { |
| (descriptor.correspondingProperty.getContainingKotlinJvmBinaryClass() as? VirtualFileKotlinClass) |
| ?.file?.contentsToByteArray() |
| } else { |
| ( |
| ((descriptor.source as? JavaSourceElement)?.javaElement as? BinaryJavaMethod)?.containingClass |
| as? BinaryJavaClass |
| )?.virtualFile?.contentsToByteArray() |
| } |
| if (virtualFileContent == null) { |
| return emptySequence() |
| } |
| extractThrowsFromClassFile(virtualFileContent, jvmDesc, getJvmName(accessor)) |
| } |
| else -> emptySequence() |
| } |
| } |
| |
| private val javaPackageToClassMap: Map<String, List<KSDeclaration>> by lazy { |
| val packageToClassMapping = mutableMapOf<String, List<KSDeclaration>>() |
| allKSFiles |
| .filter { file -> |
| file.origin == Origin.JAVA && |
| options.javaSourceRoots.any { root -> |
| file.filePath.startsWith(root.absolutePath) && |
| file.filePath.substringAfter(root.absolutePath) |
| .dropLastWhile { c -> c != File.separatorChar }.dropLast(1).drop(1) |
| .replace(File.separatorChar, '.') == file.packageName.asString() |
| } |
| } |
| .forEach { |
| packageToClassMapping.put( |
| it.packageName.asString(), |
| packageToClassMapping.getOrDefault(it.packageName.asString(), emptyList()) |
| .plus( |
| it.declarations.filterNot { |
| it.containingFile?.fileName?.split(".")?.first() == it.simpleName.asString() |
| } |
| ) |
| ) |
| } |
| packageToClassMapping |
| } |
| |
| @KspExperimental |
| override fun getDeclarationsFromPackage(packageName: String): Sequence<KSDeclaration> { |
| val noPackageFilter = DescriptorKindFilter.ALL.withoutKinds(DescriptorKindFilter.PACKAGES_MASK) |
| return module.getPackage(FqName(packageName)) |
| .memberScope.getContributedDescriptors(noPackageFilter) |
| .asSequence() |
| .mapNotNull { (it as? MemberDescriptor)?.toKSDeclaration() } |
| .plus(javaPackageToClassMap.getOrDefault(packageName, emptyList()).asSequence()) |
| } |
| |
| override fun getTypeArgument(typeRef: KSTypeReference, variance: Variance): KSTypeArgument { |
| return KSTypeArgumentLiteImpl.getCached(typeRef, variance) |
| } |
| |
| internal fun asMemberOf( |
| property: KSPropertyDeclaration, |
| containing: KSType, |
| ): KSType { |
| val key = property to containing |
| return propertyAsMemberOfCache.getOrPut(key) { |
| computeAsMemberOf(property, containing) |
| } |
| } |
| |
| private fun computeAsMemberOf( |
| property: KSPropertyDeclaration, |
| containing: KSType, |
| ): KSType { |
| val propertyDeclaredIn = property.closestClassDeclaration() |
| ?: throw IllegalArgumentException( |
| "Cannot call asMemberOf with a property that is " + |
| "not declared in a class or an interface" |
| ) |
| val declaration = resolvePropertyDeclaration(property) |
| if (declaration != null && containing is KSTypeImpl && !containing.isError) { |
| incrementalContext.recordLookupWithSupertypes(containing.kotlinType) |
| incrementalContext.recordLookupForDeclaration(property) |
| if (!containing.kotlinType.isSubtypeOf(propertyDeclaredIn)) { |
| throw IllegalArgumentException( |
| "$containing is not a sub type of the class/interface that contains `$property` " + |
| "($propertyDeclaredIn)" |
| ) |
| } |
| val typeSubstitutor = containing.kotlinType.createTypeSubstitutor() |
| val substituted = declaration.substitute(typeSubstitutor) as? ValueDescriptor |
| substituted?.let { |
| return getKSTypeCached(substituted.type) |
| } |
| } |
| // if substitution fails, fallback to the type from the property |
| return KSErrorType |
| } |
| |
| internal fun asMemberOf( |
| function: KSFunctionDeclaration, |
| containing: KSType, |
| ): KSFunction { |
| val key = function to containing |
| return functionAsMemberOfCache.getOrPut(key) { |
| computeAsMemberOf(function, containing) |
| } |
| } |
| |
| private fun computeAsMemberOf( |
| function: KSFunctionDeclaration, |
| containing: KSType, |
| ): KSFunction { |
| val functionDeclaredIn = function.closestClassDeclaration() |
| ?: throw IllegalArgumentException( |
| "Cannot call asMemberOf with a function that is " + |
| "not declared in a class or an interface" |
| ) |
| val declaration = resolveFunctionDeclaration(function) |
| if (declaration != null && containing is KSTypeImpl && !containing.isError) { |
| incrementalContext.recordLookupWithSupertypes(containing.kotlinType) |
| incrementalContext.recordLookupForDeclaration(function) |
| if (!containing.kotlinType.isSubtypeOf(functionDeclaredIn)) { |
| throw IllegalArgumentException( |
| "$containing is not a sub type of the class/interface that contains " + |
| "`$function` ($functionDeclaredIn)" |
| ) |
| } |
| val typeSubstitutor = containing.kotlinType.createTypeSubstitutor() |
| if (declaration is PropertyAccessorDescriptor) { |
| val substitutedProperty = (declaration.correspondingProperty).substitute(typeSubstitutor) |
| // TODO: Fix in upstream for property accessors: https://github.com/JetBrains/kotlin/blob/master/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/PropertyAccessorDescriptorImpl.java#L122 |
| return KSFunctionImpl( |
| (substitutedProperty as PropertyDescriptor).accessors.single { |
| it.name == declaration.name |
| } |
| ) |
| } |
| val substituted = declaration.substitute(typeSubstitutor) |
| return KSFunctionImpl(substituted) |
| } |
| // if substitution fails, return an error function that resembles the original declaration |
| return KSFunctionErrorImpl(function) |
| } |
| |
| private fun KotlinType.isSubtypeOf(declaration: KSClassDeclaration): Boolean { |
| val classDeclaration = resolveClassDeclaration(declaration) |
| if (classDeclaration == null) { |
| throw IllegalArgumentException( |
| "Cannot find the declaration for class $classDeclaration" |
| ) |
| } |
| return constructor |
| .declarationDescriptor |
| ?.getAllSuperClassifiers() |
| ?.any { it == classDeclaration } == true |
| } |
| |
| override val builtIns: KSBuiltIns by lazy { |
| val builtIns = module.builtIns |
| object : KSBuiltIns { |
| override val anyType: KSType by lazy { getKSTypeCached(builtIns.anyType) } |
| override val nothingType by lazy { getKSTypeCached(builtIns.nothingType) } |
| override val unitType: KSType by lazy { getKSTypeCached(builtIns.unitType) } |
| override val numberType: KSType by lazy { getKSTypeCached(builtIns.numberType) } |
| override val byteType: KSType by lazy { getKSTypeCached(builtIns.byteType) } |
| override val shortType: KSType by lazy { getKSTypeCached(builtIns.shortType) } |
| override val intType: KSType by lazy { getKSTypeCached(builtIns.intType) } |
| override val longType: KSType by lazy { getKSTypeCached(builtIns.longType) } |
| override val floatType: KSType by lazy { getKSTypeCached(builtIns.floatType) } |
| override val doubleType: KSType by lazy { getKSTypeCached(builtIns.doubleType) } |
| override val charType: KSType by lazy { getKSTypeCached(builtIns.charType) } |
| override val booleanType: KSType by lazy { getKSTypeCached(builtIns.booleanType) } |
| override val stringType: KSType by lazy { getKSTypeCached(builtIns.stringType) } |
| override val iterableType: KSType by lazy { |
| getKSTypeCached(builtIns.iterableType.replaceArgumentsWithStarProjections()) |
| } |
| override val annotationType: KSType by lazy { getKSTypeCached(builtIns.annotationType) } |
| override val arrayType: KSType by lazy { |
| getKSTypeCached(builtIns.array.defaultType.replaceArgumentsWithStarProjections()) |
| } |
| } |
| } |
| |
| internal val mockSerializableType = module.builtIns.numberType.supertypes().singleOrNull { |
| it.constructor.declarationDescriptor?.name?.asString() == "Serializable" |
| } |
| |
| internal val javaSerializableType = module.resolveClassByFqName( |
| FqName("java.io.Serializable"), NoLookupLocation.WHEN_FIND_BY_FQNAME |
| )?.defaultType |
| |
| @KspExperimental |
| override fun mapJavaNameToKotlin(javaName: KSName): KSName? = |
| JavaToKotlinClassMap.mapJavaToKotlin(FqName(javaName.asString()))?.toKSName() |
| |
| @KspExperimental |
| override fun mapKotlinNameToJava(kotlinName: KSName): KSName? = |
| JavaToKotlinClassMap.mapKotlinToJava(FqNameUnsafe(kotlinName.asString()))?.toKSName() |
| |
| @KspExperimental |
| internal fun mapToJvmSignature(accessor: KSPropertyAccessor): String { |
| return resolvePropertyAccessorDeclaration(accessor)?.let { |
| typeMapper.mapAsmMethod(it).descriptor |
| } ?: "" |
| } |
| |
| @KspExperimental |
| override fun getDeclarationsInSourceOrder(container: KSDeclarationContainer): Sequence<KSDeclaration> { |
| return container.declarationsInSourceOrder |
| } |
| |
| @KspExperimental |
| override fun effectiveJavaModifiers(declaration: KSDeclaration): Set<Modifier> { |
| val modifiers = HashSet<Modifier>(declaration.modifiers.filter { it in javaModifiers }) |
| |
| // This is only needed by sources. |
| // PUBLIC, PRIVATE, PROTECTED are already handled in descriptor based impls. |
| fun addVisibilityModifiers() { |
| when { |
| declaration.isPublic() -> modifiers.add(Modifier.PUBLIC) |
| declaration.isPrivate() -> modifiers.add(Modifier.PRIVATE) |
| declaration.isProtected() -> modifiers.add(Modifier.PROTECTED) |
| } |
| } |
| |
| when (declaration.origin) { |
| Origin.JAVA -> { |
| addVisibilityModifiers() |
| if (declaration is KSClassDeclaration && declaration.classKind == ClassKind.INTERFACE) |
| modifiers.add(Modifier.ABSTRACT) |
| } |
| Origin.KOTLIN -> { |
| addVisibilityModifiers() |
| if (!declaration.isOpen()) |
| modifiers.add(Modifier.FINAL) |
| if (declaration.hasAnnotation(JVM_STATIC_ANNOTATION_FQN)) |
| modifiers.add(Modifier.JAVA_STATIC) |
| if (declaration.hasAnnotation(JVM_DEFAULT_ANNOTATION_FQN)) |
| modifiers.add(Modifier.JAVA_DEFAULT) |
| if (declaration.hasAnnotation(JVM_DEFAULT_WITHOUT_COMPATIBILITY_ANNOTATION_FQN)) |
| modifiers.add(Modifier.JAVA_DEFAULT) |
| if (declaration.hasAnnotation(JVM_STRICTFP_ANNOTATION_FQN)) |
| modifiers.add(Modifier.JAVA_STRICT) |
| if (declaration.hasAnnotation(JVM_SYNCHRONIZED_ANNOTATION_FQN)) |
| modifiers.add(Modifier.JAVA_SYNCHRONIZED) |
| if (declaration.hasAnnotation(JVM_TRANSIENT_ANNOTATION_FQN)) |
| modifiers.add(Modifier.JAVA_TRANSIENT) |
| if (declaration.hasAnnotation(JVM_VOLATILE_ANNOTATION_FQN)) |
| modifiers.add(Modifier.JAVA_VOLATILE) |
| when (declaration) { |
| is KSClassDeclaration -> { |
| if (declaration.isCompanionObject) |
| modifiers.add(Modifier.JAVA_STATIC) |
| if (declaration.classKind == ClassKind.INTERFACE) |
| modifiers.add(Modifier.ABSTRACT) |
| } |
| is KSPropertyDeclaration -> { |
| if (declaration.isAbstract()) |
| modifiers.add(Modifier.ABSTRACT) |
| } |
| is KSFunctionDeclaration -> { |
| if (declaration.isAbstract) |
| modifiers.add(Modifier.ABSTRACT) |
| } |
| } |
| } |
| Origin.KOTLIN_LIB, Origin.JAVA_LIB -> { |
| when (declaration) { |
| is KSPropertyDeclaration -> { |
| if (declaration.jvmAccessFlag and Opcodes.ACC_TRANSIENT != 0) |
| modifiers.add(Modifier.JAVA_TRANSIENT) |
| if (declaration.jvmAccessFlag and Opcodes.ACC_VOLATILE != 0) |
| modifiers.add(Modifier.JAVA_VOLATILE) |
| } |
| is KSFunctionDeclaration -> { |
| if (declaration.jvmAccessFlag and Opcodes.ACC_STRICT != 0) |
| modifiers.add(Modifier.JAVA_STRICT) |
| if (declaration.jvmAccessFlag and Opcodes.ACC_SYNCHRONIZED != 0) |
| modifiers.add(Modifier.JAVA_SYNCHRONIZED) |
| } |
| } |
| } |
| else -> Unit |
| } |
| return modifiers |
| } |
| |
| private enum class RefPosition { |
| PARAMETER_TYPE, |
| RETURN_TYPE, |
| SUPER_TYPE |
| } |
| |
| // Search in self and parents for the first type reference that is not part of a type argument. |
| private fun KSTypeReference.findOuterMostRef(): Pair<KSTypeReference, List<Int>> { |
| fun KSNode.findParentRef(): KSTypeReference? { |
| var parent = parent |
| while (parent != null && parent !is KSTypeReference) |
| parent = parent.parent |
| return parent as? KSTypeReference |
| } |
| |
| val fallback = Pair<KSTypeReference, List<Int>>(this, emptyList()) |
| val indexes = mutableListOf<Int>() |
| var candidate: KSTypeReference = this |
| // KSTypeArgument's parent can be either KSReferenceElement or KSType. |
| while (candidate.parent is KSTypeArgument) { |
| // If the parent is a KSType, it's a synthetic reference. |
| // Do nothing and reply on the fallback behavior. |
| val referenceElement = (candidate.parent!!.parent as? KSReferenceElement) ?: return fallback |
| indexes.add(referenceElement.typeArguments.indexOf(candidate.parent)) |
| // In case the program isn't properly structured, fallback. |
| candidate = referenceElement.findParentRef() ?: return fallback |
| } |
| return Pair(candidate, indexes) |
| } |
| |
| // TODO: Strict mode for catching unhandled cases. |
| private fun findRefPosition(ref: KSTypeReference): RefPosition = when (val parent = ref.parent) { |
| is KSCallableReference -> when (ref) { |
| parent.returnType -> RefPosition.RETURN_TYPE |
| else -> RefPosition.PARAMETER_TYPE |
| } |
| is KSFunctionDeclaration -> when (ref) { |
| parent.returnType -> RefPosition.RETURN_TYPE |
| else -> RefPosition.PARAMETER_TYPE |
| } |
| is KSPropertyGetter -> RefPosition.RETURN_TYPE |
| is KSPropertyDeclaration -> when (ref) { |
| parent.type -> RefPosition.RETURN_TYPE |
| else -> RefPosition.PARAMETER_TYPE |
| } |
| is KSClassDeclaration -> RefPosition.SUPER_TYPE |
| // is KSTypeArgument -> RefPosition.PARAMETER_TYPE |
| // is KSAnnotation -> RefPosition.PARAMETER_TYPE |
| // is KSTypeAlias -> RefPosition.PARAMETER_TYPE |
| // is KSValueParameter -> RefPosition.PARAMETER_TYPE |
| // is KSTypeParameter -> RefPosition.PARAMETER_TYPE |
| else -> RefPosition.PARAMETER_TYPE |
| } |
| |
| private fun KSTypeReference.isReturnTypeOfAnnotationMethod(): Boolean { |
| var candidate = this.parent |
| while (candidate !is KSClassDeclaration && candidate != null) |
| candidate = candidate.parent |
| return (candidate as? KSClassDeclaration)?.classKind == ClassKind.ANNOTATION_CLASS |
| } |
| |
| // Convert type arguments for Java wildcard, recursively. |
| private fun KotlinType.toWildcard(mode: TypeMappingMode): KotlinType? { |
| val parameters = constructor.parameters |
| val arguments = arguments |
| |
| val wildcardArguments = parameters.zip(arguments).map { (parameter, argument) -> |
| if (!argument.isStarProjection && |
| parameter.variance != argument.projectionKind && |
| parameter.variance != org.jetbrains.kotlin.types.Variance.INVARIANT && |
| argument.projectionKind != org.jetbrains.kotlin.types.Variance.INVARIANT |
| ) { |
| // conflicting variances |
| // TODO: error message |
| return null |
| } |
| |
| val argMode = mode.updateFromAnnotations(argument.type) |
| val variance = KotlinTypeMapper.getVarianceForWildcard(parameter, argument, argMode) |
| val genericMode = argMode.toGenericArgumentMode( |
| getEffectiveVariance(parameter.variance, argument.projectionKind) |
| ) |
| TypeProjectionImpl(variance, argument.type.toWildcard(genericMode) ?: return null) |
| } |
| |
| return replace(wildcardArguments) |
| } |
| |
| private val JVM_SUPPRESS_WILDCARDS_NAME = KSNameImpl.getCached("kotlin.jvm.JvmSuppressWildcards") |
| private val JVM_SUPPRESS_WILDCARDS_SHORT = "JvmSuppressWildcards" |
| private fun KSTypeReference.findJvmSuppressWildcards(): Boolean? { |
| var candidate: KSNode? = this |
| |
| while (candidate != null) { |
| if ((candidate is KSTypeReference || candidate is KSDeclaration)) { |
| ( |
| (candidate as KSAnnotated).annotations.firstOrNull { |
| checkAnnotation(it, JVM_SUPPRESS_WILDCARDS_NAME, JVM_SUPPRESS_WILDCARDS_SHORT) |
| }?.arguments?.firstOrNull()?.value as? Boolean |
| )?.let { |
| // KSAnnotated.getAnnotationsByType is handy but it uses reflection. |
| return it |
| } |
| } |
| candidate = candidate.parent |
| } |
| |
| return null |
| } |
| |
| private fun TypeMappingMode.updateFromAnnotations( |
| type: KotlinType |
| ): TypeMappingMode { |
| ( |
| type.annotations.findAnnotation(JVM_SUPPRESS_WILDCARDS_ANNOTATION_FQ_NAME) |
| ?.argumentValue("suppress")?.value as? Boolean |
| )?.let { |
| return this.suppressJvmWildcards(it) |
| } |
| |
| if (type.annotations.hasAnnotation(JVM_WILDCARD_ANNOTATION_FQ_NAME)) { |
| return TypeMappingMode.createWithConstantDeclarationSiteWildcardsMode( |
| skipDeclarationSiteWildcards = false, |
| isForAnnotationParameter = isForAnnotationParameter, |
| fallbackMode = this, |
| needInlineClassWrapping = needInlineClassWrapping, |
| mapTypeAliases = mapTypeAliases |
| ) |
| } |
| |
| return this |
| } |
| |
| private fun TypeMappingMode.suppressJvmWildcards( |
| suppress: Boolean |
| ): TypeMappingMode { |
| return TypeMappingMode.createWithConstantDeclarationSiteWildcardsMode( |
| skipDeclarationSiteWildcards = suppress, |
| isForAnnotationParameter = isForAnnotationParameter, |
| needInlineClassWrapping = needInlineClassWrapping, |
| mapTypeAliases = mapTypeAliases |
| ) |
| } |
| |
| private fun TypeMappingMode.updateFromParents( |
| ref: KSTypeReference |
| ): TypeMappingMode { |
| ref.findJvmSuppressWildcards()?.let { |
| return this.suppressJvmWildcards(it) |
| } |
| |
| return this |
| } |
| |
| // Type arguments need to be resolved recursively in a top-down manner. So we find and resolve the outer most |
| // reference that contains this argument. Then locate and return the argument. |
| @KspExperimental |
| override fun getJavaWildcard(reference: KSTypeReference): KSTypeReference { |
| // If the outer-most reference cannot be found, e.g., when this reference is nested in KSType.arguments, |
| // fallback to PARAMETER_TYPE effectively. |
| val (ref, indexes) = reference.findOuterMostRef() |
| |
| val type = ref.resolve() |
| if (type.isError) |
| return reference |
| |
| val position = findRefPosition(ref) |
| val kotlinType = (type as KSTypeImpl).kotlinType |
| |
| val typeSystem = SimpleClassicTypeSystemContext |
| val typeMappingMode = when (position) { |
| RefPosition.PARAMETER_TYPE -> typeSystem.getOptimalModeForValueParameter(kotlinType) |
| RefPosition.RETURN_TYPE -> |
| typeSystem.getOptimalModeForReturnType(kotlinType, ref.isReturnTypeOfAnnotationMethod()) |
| RefPosition.SUPER_TYPE -> TypeMappingMode.SUPER_TYPE |
| }.updateFromParents(ref) |
| |
| val parameters = kotlinType.constructor.parameters |
| val arguments = kotlinType.arguments |
| |
| parameters.zip(arguments).forEach { (parameter, argument) -> |
| if (position == RefPosition.SUPER_TYPE && |
| argument.projectionKind != org.jetbrains.kotlin.types.Variance.INVARIANT |
| ) { |
| // Type projection isn't allowed in immediate arguments to supertypes. |
| // TODO: error message |
| return KSTypeReferenceSyntheticImpl.getCached(KSErrorType, null) |
| } |
| } |
| |
| val wildcardType = kotlinType.toWildcard(typeMappingMode)?.let { |
| var candidate: KotlinType = it |
| for (i in indexes.reversed()) { |
| candidate = candidate.arguments[i].type |
| } |
| getKSTypeCached(candidate) |
| } ?: KSErrorType |
| |
| return KSTypeReferenceSyntheticImpl.getCached(wildcardType, null) |
| } |
| |
| @KspExperimental |
| override fun isJavaRawType(type: KSType): Boolean { |
| return type is KSTypeImpl && type.kotlinType.unwrap() is RawType |
| } |
| |
| private val psiJavaFiles = allKSFiles.filterIsInstance<KSFileJavaImpl>().map { |
| Pair(it.psi.virtualFile.path, it.psi) |
| }.toMap() |
| |
| internal fun findPsiJavaFile(path: String): PsiFile? = psiJavaFiles.get(path) |
| } |
| |
| // TODO: cross module resolution |
| fun DeclarationDescriptor.findExpectsInKSDeclaration(): Sequence<KSDeclaration> = |
| findExpects().asSequence().map { |
| it.toKSDeclaration() |
| } |
| |
| // TODO: cross module resolution |
| fun DeclarationDescriptor.findActualsInKSDeclaration(): Sequence<KSDeclaration> = |
| findActuals(this.module).asSequence().map { |
| it.toKSDeclaration() |
| } |
| |
| fun MemberDescriptor.toKSDeclaration(): KSDeclaration = |
| when (val psi = findPsi()) { |
| is KtClassOrObject -> KSClassDeclarationImpl.getCached(psi) |
| is KtFunction -> KSFunctionDeclarationImpl.getCached(psi) |
| is KtProperty -> KSPropertyDeclarationImpl.getCached((psi)) |
| is KtTypeAlias -> KSTypeAliasImpl.getCached(psi) |
| is PsiClass -> KSClassDeclarationJavaImpl.getCached(psi) |
| is PsiMethod -> KSFunctionDeclarationJavaImpl.getCached(psi) |
| is PsiField -> KSPropertyDeclarationJavaImpl.getCached(psi) |
| else -> when (this) { |
| is ClassDescriptor -> KSClassDeclarationDescriptorImpl.getCached(this) |
| is FunctionDescriptor -> KSFunctionDeclarationDescriptorImpl.getCached(this) |
| is PropertyDescriptor -> KSPropertyDeclarationDescriptorImpl.getCached(this) |
| else -> throw IllegalStateException("Unknown expect/actual implementation") |
| } |
| } |
| |
| /** |
| * [NewTypeSubstitutor] handles variance better than [TypeSubstitutor] so we use it when subtituting |
| * types in [ResolverImpl.asMemberOf] implementations. |
| */ |
| private fun TypeSubstitutor.toNewSubstitutor() = composeWith( |
| org.jetbrains.kotlin.resolve.calls.inference.components.EmptySubstitutor |
| ) |
| |
| private fun KotlinType.createTypeSubstitutor(): NewTypeSubstitutor { |
| return SubstitutionUtils.buildDeepSubstitutor(this).toNewSubstitutor() |
| } |
| |
| /** |
| * Extracts the identifier from a module Name. |
| * |
| * One caveat here is that kotlin passes a special name into the plugin which cannot be used as an identifier. |
| * On the other hand, to construct the correct TypeMapper, we need a non-special name. |
| * This function extracts the non-special name from a given name if it is special. |
| * |
| * @see: https://github.com/JetBrains/kotlin/blob/master/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/TopDownAnalyzerFacadeForJVM.kt#L305 |
| */ |
| private fun Name.getNonSpecialIdentifier(): String { |
| // the analyzer might pass down a special name which will break type mapper name computations. |
| // If it is a special name, we turn it back to an id |
| if (!isSpecial || asString().isBlank()) { |
| return asString() |
| } |
| // special names starts with a `<` and usually end with `>` |
| return if (asString().last() == '>') { |
| asString().substring(1, asString().length - 1) |
| } else { |
| asString().substring(1) |
| } |
| } |
| |
| private inline fun MemberScope.findEnclosedDescriptor( |
| kindFilter: DescriptorKindFilter, |
| crossinline filter: (DeclarationDescriptor) -> Boolean, |
| ): DeclarationDescriptor? { |
| return getContributedDescriptors( |
| kindFilter = kindFilter |
| ).firstOrNull(filter) |
| } |
| |
| private inline fun ClassDescriptor.findEnclosedDescriptor( |
| kindFilter: DescriptorKindFilter, |
| crossinline filter: (DeclarationDescriptor) -> Boolean, |
| ): DeclarationDescriptor? { |
| return this.unsubstitutedMemberScope.findEnclosedDescriptor( |
| kindFilter = kindFilter, |
| filter = filter |
| ) ?: this.staticScope.findEnclosedDescriptor( |
| kindFilter = kindFilter, |
| filter = filter |
| ) ?: constructors.firstOrNull { |
| kindFilter.accepts(it) && filter(it) |
| } |
| } |
| |
| internal fun KSAnnotated.findAnnotationFromUseSiteTarget(): Sequence<KSAnnotation> { |
| return when (this) { |
| is KSPropertyGetter -> (this.receiver as? KSDeclarationImpl)?.let { |
| it.originalAnnotations.asSequence().filter { it.useSiteTarget == AnnotationUseSiteTarget.GET } |
| } |
| is KSPropertySetter -> (this.receiver as? KSDeclarationImpl)?.let { |
| it.originalAnnotations.asSequence().filter { it.useSiteTarget == AnnotationUseSiteTarget.SET } |
| } |
| is KSValueParameter -> { |
| var parent = when (this) { |
| is KSValueParameterSyntheticImpl -> this.owner |
| is KSValueParameterImpl -> this.ktParameter.findParentAnnotated() |
| else -> null |
| } |
| // TODO: eliminate annotationsFromParents to make this fully sequence. |
| val annotationsFromParents = mutableListOf<KSAnnotation>() |
| (parent as? KSPropertyAccessorImpl)?.let { |
| annotationsFromParents.addAll( |
| it.originalAnnotations.asSequence() |
| .filter { it.useSiteTarget == AnnotationUseSiteTarget.SETPARAM } |
| ) |
| parent = (parent as KSPropertyAccessorImpl).receiver |
| } |
| (parent as? KSPropertyDeclarationImpl)?.let { |
| annotationsFromParents.addAll( |
| it.originalAnnotations.asSequence() |
| .filter { it.useSiteTarget == AnnotationUseSiteTarget.SETPARAM } |
| ) |
| } |
| annotationsFromParents.asSequence() |
| } |
| else -> emptySequence() |
| } ?: emptySequence() |
| } |
| |
| // Resolve to underlying type. |
| // Only slightly slower than resolving a plain type, because everything is resolved and cached in the first resolve(). |
| // FIXME: add a resolution mode in resolveUserType() to resolve to underlying type directly. |
| internal fun KSTypeReference.resolveToUnderlying(): KSType { |
| var candidate = resolve() |
| var declaration = candidate.declaration |
| while (declaration is KSTypeAlias) { |
| candidate = declaration.type.resolve() |
| declaration = candidate.declaration |
| } |
| return candidate |
| } |
| |
| // TODO: Remove this after upgrading to Kotlin 1.8.20. |
| // Temporary work around for https://github.com/google/ksp/issues/1034 |
| // Force resolve outer most class for Java nested classes. |
| internal fun JavaClass.workaroundForNested( |
| lazyJavaResolverContext: LazyJavaResolverContext = ResolverImpl.instance!!.lazyJavaResolverContext |
| ) { |
| var outerMost = outerClass |
| while (outerMost?.outerClass != null) { |
| outerMost = outerMost.outerClass |
| } |
| outerMost?.classId?.let { lazyJavaResolverContext.components.finder.findClass(it) } |
| } |
