From 7675ea3c23e7288b4fd3dabe325583d3aa38cf16 Mon Sep 17 00:00:00 2001 From: Mikhail Glukhikh Date: Mon, 17 May 2021 16:27:04 +0300 Subject: [PATCH] Move AnnotationTargetLists & KotlinTarget to common compiler code --- .../kotlin/resolve/AnnotationChecker.kt | 156 +++--------------- .../kotlin/resolve/ModifiersChecker.kt | 7 +- .../checkers/SealedInterfaceAllowedChecker.kt | 1 - .../descriptors/annotations/KotlinTarget.kt | 57 ++++--- .../kotlin/resolve/AnnotationTargetLists.kt | 142 ++++++++++++++++ .../java/components/JavaAnnotationMapper.kt | 1 - .../idea/quickfix/AddAnnotationTargetFix.kt | 23 ++- 7 files changed, 208 insertions(+), 179 deletions(-) rename core/{descriptors => compiler.common}/src/org/jetbrains/kotlin/descriptors/annotations/KotlinTarget.kt (72%) create mode 100644 core/compiler.common/src/org/jetbrains/kotlin/resolve/AnnotationTargetLists.kt diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationChecker.kt index aae33a5fc63..bdfd21074c6 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationChecker.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationChecker.kt @@ -15,7 +15,6 @@ import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget import org.jetbrains.kotlin.descriptors.annotations.KotlinRetention import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget -import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget.* import org.jetbrains.kotlin.diagnostics.Errors import org.jetbrains.kotlin.diagnostics.reportDiagnosticOnce import org.jetbrains.kotlin.name.Name @@ -101,7 +100,8 @@ class AnnotationChecker( } private fun checkPropertyUseSiteTargetAnnotations(property: KtProperty, trace: BindingTrace) { - fun List?.getDescriptors() = this?.mapNotNull { trace.get(BindingContext.ANNOTATION, it)?.annotationClass } ?: listOf() + fun List?.getDescriptors() = + this?.mapNotNull { trace.get(BindingContext.ANNOTATION, it)?.annotationClass } ?: listOf() val reportError = languageVersionSettings.supportsFeature(ProhibitRepeatedUseSiteTargetAnnotations) @@ -116,7 +116,7 @@ class AnnotationChecker( val classDescriptor = descriptor.annotationClass ?: continue val useSiteTarget = entry.useSiteTarget?.getAnnotationUseSiteTarget() ?: property.getDefaultUseSiteTarget(descriptor) - val existingAnnotations = propertyAnnotations.get(useSiteTarget) ?: continue + val existingAnnotations = propertyAnnotations[useSiteTarget] ?: continue if (classDescriptor in existingAnnotations && !classDescriptor.isRepeatableAnnotation()) { if (reportError) { trace.reportDiagnosticOnce(Errors.REPEATED_ANNOTATION.on(entry)) @@ -176,7 +176,7 @@ class AnnotationChecker( private fun KtAnnotated?.getDefaultUseSiteTarget(descriptor: AnnotationDescriptor) = getImplicitUseSiteTargetList().firstOrNull { - KotlinTarget.USE_SITE_MAPPING[it] in AnnotationChecker.applicableTargetSet(descriptor) + KotlinTarget.USE_SITE_MAPPING[it] in applicableTargetSet(descriptor) } private fun checkEntries( @@ -306,8 +306,18 @@ class AnnotationChecker( fun getActualTargetList(annotated: KtElement, descriptor: DeclarationDescriptor?, context: BindingContext): TargetList { return when (annotated) { - is KtClassOrObject -> - (descriptor as? ClassDescriptor)?.let { TargetList(KotlinTarget.classActualTargets(it)) } ?: TargetLists.T_CLASSIFIER + is KtClassOrObject -> { + (descriptor as? ClassDescriptor)?.let { + TargetList( + KotlinTarget.classActualTargets( + it.kind, + isInnerClass = it.isInner, + isCompanionObject = it.isCompanionObject, + isLocalClass = DescriptorUtils.isLocal(it) + ) + ) + } ?: TargetLists.T_CLASSIFIER + } is KtDestructuringDeclarationEntry -> TargetLists.T_LOCAL_VARIABLE is KtProperty -> { when { @@ -348,139 +358,13 @@ class AnnotationChecker( else -> TargetLists.EMPTY } } - - object TargetLists { - val T_CLASSIFIER = targetList(CLASS) - val T_TYPEALIAS = targetList(TYPEALIAS) - - val T_LOCAL_VARIABLE = targetList(LOCAL_VARIABLE) { - onlyWithUseSiteTarget(PROPERTY_SETTER, VALUE_PARAMETER) - } - - val T_DESTRUCTURING_DECLARATION = targetList(DESTRUCTURING_DECLARATION) - - private fun TargetListBuilder.propertyTargets(backingField: Boolean, delegate: Boolean) { - if (backingField) extraTargets(FIELD) - if (delegate) { - onlyWithUseSiteTarget(VALUE_PARAMETER, PROPERTY_GETTER, PROPERTY_SETTER, FIELD) - } else { - onlyWithUseSiteTarget(VALUE_PARAMETER, PROPERTY_GETTER, PROPERTY_SETTER) - } - } - - fun T_MEMBER_PROPERTY(backingField: Boolean, delegate: Boolean) = - targetList( - when { - backingField -> MEMBER_PROPERTY_WITH_BACKING_FIELD - delegate -> MEMBER_PROPERTY_WITH_DELEGATE - else -> MEMBER_PROPERTY_WITHOUT_FIELD_OR_DELEGATE - }, MEMBER_PROPERTY, PROPERTY - ) { - propertyTargets(backingField, delegate) - } - - fun T_TOP_LEVEL_PROPERTY(backingField: Boolean, delegate: Boolean) = - targetList( - when { - backingField -> TOP_LEVEL_PROPERTY_WITH_BACKING_FIELD - delegate -> TOP_LEVEL_PROPERTY_WITH_DELEGATE - else -> TOP_LEVEL_PROPERTY_WITHOUT_FIELD_OR_DELEGATE - }, TOP_LEVEL_PROPERTY, PROPERTY - ) { - propertyTargets(backingField, delegate) - } - - val T_PROPERTY_GETTER = targetList(PROPERTY_GETTER) - val T_PROPERTY_SETTER = targetList(PROPERTY_SETTER) - - val T_VALUE_PARAMETER_WITHOUT_VAL = targetList(VALUE_PARAMETER) - - val T_VALUE_PARAMETER_WITH_VAL = targetList(VALUE_PARAMETER, PROPERTY, MEMBER_PROPERTY) { - extraTargets(FIELD) - onlyWithUseSiteTarget(PROPERTY_GETTER, PROPERTY_SETTER) - } - - val T_FILE = targetList(FILE) - - val T_CONSTRUCTOR = targetList(CONSTRUCTOR) - - val T_LOCAL_FUNCTION = targetList(LOCAL_FUNCTION, FUNCTION) { - onlyWithUseSiteTarget(VALUE_PARAMETER) - } - - val T_MEMBER_FUNCTION = targetList(MEMBER_FUNCTION, FUNCTION) { - onlyWithUseSiteTarget(VALUE_PARAMETER) - } - - val T_TOP_LEVEL_FUNCTION = targetList(TOP_LEVEL_FUNCTION, FUNCTION) { - onlyWithUseSiteTarget(VALUE_PARAMETER) - } - - val T_EXPRESSION = targetList(EXPRESSION) - - val T_FUNCTION_LITERAL = targetList(LAMBDA_EXPRESSION, FUNCTION, EXPRESSION) - - val T_FUNCTION_EXPRESSION = targetList(ANONYMOUS_FUNCTION, FUNCTION, EXPRESSION) - - val T_OBJECT_LITERAL = targetList(OBJECT_LITERAL, CLASS, EXPRESSION) - - val T_TYPE_REFERENCE = targetList(TYPE) { - onlyWithUseSiteTarget(VALUE_PARAMETER) - } - - val T_TYPE_PARAMETER = targetList(TYPE_PARAMETER) - - val T_STAR_PROJECTION = targetList(STAR_PROJECTION) - val T_TYPE_PROJECTION = targetList(TYPE_PROJECTION) - - val T_INITIALIZER = targetList(INITIALIZER) - - - private fun targetList(vararg target: KotlinTarget, otherTargets: TargetListBuilder.() -> Unit = {}): TargetList { - val builder = TargetListBuilder(*target) - builder.otherTargets() - return builder.build() - } - - val EMPTY = targetList() - - private class TargetListBuilder(vararg val defaultTargets: KotlinTarget) { - private var canBeSubstituted: List = listOf() - private var onlyWithUseSiteTarget: List = listOf() - - fun extraTargets(vararg targets: KotlinTarget) { - canBeSubstituted = targets.toList() - } - - fun onlyWithUseSiteTarget(vararg targets: KotlinTarget) { - onlyWithUseSiteTarget = targets.toList() - } - - fun build() = TargetList(defaultTargets.toList(), canBeSubstituted, onlyWithUseSiteTarget) - } - } - - class TargetList( - val defaultTargets: List, - val canBeSubstituted: List = emptyList(), - val onlyWithUseSiteTarget: List = emptyList() - ) - - private object UseSiteTargetsList { - val T_CONSTRUCTOR_PARAMETER = listOf( - AnnotationUseSiteTarget.CONSTRUCTOR_PARAMETER, - AnnotationUseSiteTarget.PROPERTY, - AnnotationUseSiteTarget.FIELD - ) - - val T_PROPERTY = listOf( - AnnotationUseSiteTarget.PROPERTY, - AnnotationUseSiteTarget.FIELD - ) - } } } +private typealias TargetLists = AnnotationTargetLists + +private typealias TargetList = AnnotationTargetList + interface AdditionalAnnotationChecker { fun checkEntries(entries: List, actualTargets: List, trace: BindingTrace) } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.kt index 0b1ef0cbc0d..60510625de1 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.kt @@ -395,7 +395,12 @@ object ModifierCheckerCore { ): Boolean { val modifier = node.elementType as KtModifierKeywordToken val actualParents: List = when (parentDescriptor) { - is ClassDescriptor -> KotlinTarget.classActualTargets(parentDescriptor) + is ClassDescriptor -> KotlinTarget.classActualTargets( + parentDescriptor.kind, + isInnerClass = parentDescriptor.isInner, + isCompanionObject = parentDescriptor.isCompanionObject, + isLocalClass = DescriptorUtils.isLocal(parentDescriptor) + ) is PropertySetterDescriptor -> listOf(PROPERTY_SETTER) is PropertyGetterDescriptor -> listOf(PROPERTY_GETTER) is FunctionDescriptor -> listOf(FUNCTION) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/SealedInterfaceAllowedChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/SealedInterfaceAllowedChecker.kt index c2d661947c8..bcd495646ff 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/SealedInterfaceAllowedChecker.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/SealedInterfaceAllowedChecker.kt @@ -7,7 +7,6 @@ package org.jetbrains.kotlin.resolve.checkers import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.descriptors.* -import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget import org.jetbrains.kotlin.diagnostics.Errors import org.jetbrains.kotlin.lexer.KtTokens import org.jetbrains.kotlin.psi.KtDeclaration diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/KotlinTarget.kt b/core/compiler.common/src/org/jetbrains/kotlin/descriptors/annotations/KotlinTarget.kt similarity index 72% rename from core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/KotlinTarget.kt rename to core/compiler.common/src/org/jetbrains/kotlin/descriptors/annotations/KotlinTarget.kt index ac98b99d1ce..3d7144c4f97 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/KotlinTarget.kt +++ b/core/compiler.common/src/org/jetbrains/kotlin/descriptors/annotations/KotlinTarget.kt @@ -1,13 +1,11 @@ /* - * Copyright 2000-2018 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors. * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ package org.jetbrains.kotlin.descriptors.annotations -import org.jetbrains.kotlin.descriptors.ClassDescriptor import org.jetbrains.kotlin.descriptors.ClassKind -import org.jetbrains.kotlin.resolve.DescriptorUtils import java.util.* // NOTE: this enum must have the same entries with kotlin.annotation.AnnotationTarget, @@ -33,8 +31,11 @@ enum class KotlinTarget(val description: String, val isDefault: Boolean = true) STAR_PROJECTION("star projection", false), PROPERTY_PARAMETER("property constructor parameter", false), - CLASS_ONLY("class", false), // includes only top level classes and nested/inner classes (but not enums, objects, interfaces and local classes) - OBJECT("object", false), // does not include OBJECT_LITERAL but DOES include COMPANION_OBJECT + // includes only top level classes and nested/inner classes (but not enums, objects, interfaces and local classes) + CLASS_ONLY("class", false), + + // does not include OBJECT_LITERAL but DOES include COMPANION_OBJECT + OBJECT("object", false), COMPANION_OBJECT("companion object", false), INTERFACE("interface", false), ENUM_CLASS("enum class", false), @@ -59,7 +60,7 @@ enum class KotlinTarget(val description: String, val isDefault: Boolean = true) DESTRUCTURING_DECLARATION("destructuring declaration", false), LAMBDA_EXPRESSION("lambda expression", false), ANONYMOUS_FUNCTION("anonymous function", false), - OBJECT_LITERAL("object literal", false) + OBJECT_LITERAL("object literal", false), ; companion object { @@ -67,7 +68,7 @@ enum class KotlinTarget(val description: String, val isDefault: Boolean = true) private val map = HashMap() init { - for (target in KotlinTarget.values()) { + for (target in values()) { map[target.name] = target } } @@ -78,44 +79,46 @@ enum class KotlinTarget(val description: String, val isDefault: Boolean = true) val ALL_TARGET_SET: Set = values().toSet() - fun classActualTargets(descriptor: ClassDescriptor): List = when (descriptor.kind) { + fun classActualTargets( + kind: ClassKind, + isInnerClass: Boolean, + isCompanionObject: Boolean, + isLocalClass: Boolean + ): List = when (kind) { ClassKind.ANNOTATION_CLASS -> listOf(ANNOTATION_CLASS, CLASS) ClassKind.CLASS -> // inner local classes should be CLASS_ONLY, not LOCAL_CLASS - if (!descriptor.isInner && DescriptorUtils.isLocal(descriptor)) { + if (!isInnerClass && isLocalClass) { listOf(LOCAL_CLASS, CLASS) - } - else { + } else { listOf(CLASS_ONLY, CLASS) } ClassKind.OBJECT -> - if (descriptor.isCompanionObject) { + if (isCompanionObject) { listOf(COMPANION_OBJECT, OBJECT, CLASS) - } - else { + } else { listOf(OBJECT, CLASS) } ClassKind.INTERFACE -> listOf(INTERFACE, CLASS) ClassKind.ENUM_CLASS -> - if (DescriptorUtils.isLocal(descriptor)) { + if (isLocalClass) { listOf(LOCAL_CLASS, CLASS) - } - else { + } else { listOf(ENUM_CLASS, CLASS) } ClassKind.ENUM_ENTRY -> listOf(ENUM_ENTRY, PROPERTY, FIELD) } val USE_SITE_MAPPING: Map = mapOf( - AnnotationUseSiteTarget.CONSTRUCTOR_PARAMETER to VALUE_PARAMETER, - AnnotationUseSiteTarget.FIELD to FIELD, - AnnotationUseSiteTarget.PROPERTY to PROPERTY, - AnnotationUseSiteTarget.FILE to FILE, - AnnotationUseSiteTarget.PROPERTY_GETTER to PROPERTY_GETTER, - AnnotationUseSiteTarget.PROPERTY_SETTER to PROPERTY_SETTER, - AnnotationUseSiteTarget.RECEIVER to VALUE_PARAMETER, - AnnotationUseSiteTarget.SETTER_PARAMETER to VALUE_PARAMETER, - AnnotationUseSiteTarget.PROPERTY_DELEGATE_FIELD to FIELD) - + AnnotationUseSiteTarget.CONSTRUCTOR_PARAMETER to VALUE_PARAMETER, + AnnotationUseSiteTarget.FIELD to FIELD, + AnnotationUseSiteTarget.PROPERTY to PROPERTY, + AnnotationUseSiteTarget.FILE to FILE, + AnnotationUseSiteTarget.PROPERTY_GETTER to PROPERTY_GETTER, + AnnotationUseSiteTarget.PROPERTY_SETTER to PROPERTY_SETTER, + AnnotationUseSiteTarget.RECEIVER to VALUE_PARAMETER, + AnnotationUseSiteTarget.SETTER_PARAMETER to VALUE_PARAMETER, + AnnotationUseSiteTarget.PROPERTY_DELEGATE_FIELD to FIELD + ) } } diff --git a/core/compiler.common/src/org/jetbrains/kotlin/resolve/AnnotationTargetLists.kt b/core/compiler.common/src/org/jetbrains/kotlin/resolve/AnnotationTargetLists.kt new file mode 100644 index 00000000000..85231f8e119 --- /dev/null +++ b/core/compiler.common/src/org/jetbrains/kotlin/resolve/AnnotationTargetLists.kt @@ -0,0 +1,142 @@ +/* + * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +@file:Suppress("FunctionName") + +package org.jetbrains.kotlin.resolve + +import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget +import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget +import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget.* + +object AnnotationTargetLists { + val T_CLASSIFIER = targetList(CLASS) + val T_TYPEALIAS = targetList(TYPEALIAS) + + val T_LOCAL_VARIABLE = targetList(LOCAL_VARIABLE) { + onlyWithUseSiteTarget(PROPERTY_SETTER, VALUE_PARAMETER) + } + + val T_DESTRUCTURING_DECLARATION = targetList(DESTRUCTURING_DECLARATION) + + private fun TargetListBuilder.propertyTargets(backingField: Boolean, delegate: Boolean) { + if (backingField) extraTargets(FIELD) + if (delegate) { + onlyWithUseSiteTarget(VALUE_PARAMETER, PROPERTY_GETTER, PROPERTY_SETTER, FIELD) + } else { + onlyWithUseSiteTarget(VALUE_PARAMETER, PROPERTY_GETTER, PROPERTY_SETTER) + } + } + + fun T_MEMBER_PROPERTY(backingField: Boolean, delegate: Boolean) = + targetList( + when { + backingField -> MEMBER_PROPERTY_WITH_BACKING_FIELD + delegate -> MEMBER_PROPERTY_WITH_DELEGATE + else -> MEMBER_PROPERTY_WITHOUT_FIELD_OR_DELEGATE + }, MEMBER_PROPERTY, PROPERTY + ) { + propertyTargets(backingField, delegate) + } + + fun T_TOP_LEVEL_PROPERTY(backingField: Boolean, delegate: Boolean) = + targetList( + when { + backingField -> TOP_LEVEL_PROPERTY_WITH_BACKING_FIELD + delegate -> TOP_LEVEL_PROPERTY_WITH_DELEGATE + else -> TOP_LEVEL_PROPERTY_WITHOUT_FIELD_OR_DELEGATE + }, TOP_LEVEL_PROPERTY, PROPERTY + ) { + propertyTargets(backingField, delegate) + } + + val T_PROPERTY_GETTER = targetList(PROPERTY_GETTER) + val T_PROPERTY_SETTER = targetList(PROPERTY_SETTER) + + val T_VALUE_PARAMETER_WITHOUT_VAL = targetList(VALUE_PARAMETER) + + val T_VALUE_PARAMETER_WITH_VAL = targetList(VALUE_PARAMETER, PROPERTY, MEMBER_PROPERTY) { + extraTargets(FIELD) + onlyWithUseSiteTarget(PROPERTY_GETTER, PROPERTY_SETTER) + } + + val T_FILE = targetList(FILE) + + val T_CONSTRUCTOR = targetList(CONSTRUCTOR) + + val T_LOCAL_FUNCTION = targetList(LOCAL_FUNCTION, FUNCTION) { + onlyWithUseSiteTarget(VALUE_PARAMETER) + } + + val T_MEMBER_FUNCTION = targetList(MEMBER_FUNCTION, FUNCTION) { + onlyWithUseSiteTarget(VALUE_PARAMETER) + } + + val T_TOP_LEVEL_FUNCTION = targetList(TOP_LEVEL_FUNCTION, FUNCTION) { + onlyWithUseSiteTarget(VALUE_PARAMETER) + } + + val T_EXPRESSION = targetList(EXPRESSION) + + val T_FUNCTION_LITERAL = targetList(LAMBDA_EXPRESSION, FUNCTION, EXPRESSION) + + val T_FUNCTION_EXPRESSION = targetList(ANONYMOUS_FUNCTION, FUNCTION, EXPRESSION) + + val T_OBJECT_LITERAL = targetList(OBJECT_LITERAL, CLASS, EXPRESSION) + + val T_TYPE_REFERENCE = targetList(TYPE) { + onlyWithUseSiteTarget(VALUE_PARAMETER) + } + + val T_TYPE_PARAMETER = targetList(TYPE_PARAMETER) + + val T_STAR_PROJECTION = targetList(STAR_PROJECTION) + val T_TYPE_PROJECTION = targetList(TYPE_PROJECTION) + + val T_INITIALIZER = targetList(INITIALIZER) + + + private fun targetList(vararg target: KotlinTarget, otherTargets: TargetListBuilder.() -> Unit = {}): AnnotationTargetList { + val builder = TargetListBuilder(*target) + builder.otherTargets() + return builder.build() + } + + val EMPTY = targetList() + + private class TargetListBuilder(vararg val defaultTargets: KotlinTarget) { + private var canBeSubstituted: List = listOf() + private var onlyWithUseSiteTarget: List = listOf() + + fun extraTargets(vararg targets: KotlinTarget) { + canBeSubstituted = targets.toList() + } + + fun onlyWithUseSiteTarget(vararg targets: KotlinTarget) { + onlyWithUseSiteTarget = targets.toList() + } + + fun build() = AnnotationTargetList(defaultTargets.toList(), canBeSubstituted, onlyWithUseSiteTarget) + } +} + +class AnnotationTargetList( + val defaultTargets: List, + val canBeSubstituted: List = emptyList(), + val onlyWithUseSiteTarget: List = emptyList() +) + +object UseSiteTargetsList { + val T_CONSTRUCTOR_PARAMETER = listOf( + AnnotationUseSiteTarget.CONSTRUCTOR_PARAMETER, + AnnotationUseSiteTarget.PROPERTY, + AnnotationUseSiteTarget.FIELD + ) + + val T_PROPERTY = listOf( + AnnotationUseSiteTarget.PROPERTY, + AnnotationUseSiteTarget.FIELD + ) +} diff --git a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/components/JavaAnnotationMapper.kt b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/components/JavaAnnotationMapper.kt index 64f86419be9..7e8322220a5 100644 --- a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/components/JavaAnnotationMapper.kt +++ b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/components/JavaAnnotationMapper.kt @@ -21,7 +21,6 @@ import org.jetbrains.kotlin.descriptors.SourceElement import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor import org.jetbrains.kotlin.descriptors.annotations.KotlinRetention import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget -import org.jetbrains.kotlin.load.java.JvmAnnotationNames import org.jetbrains.kotlin.load.java.JvmAnnotationNames.* import org.jetbrains.kotlin.load.java.descriptors.PossiblyExternalAnnotationDescriptor import org.jetbrains.kotlin.load.java.lazy.LazyJavaResolverContext diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/AddAnnotationTargetFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/AddAnnotationTargetFix.kt index b9d52d37725..ba8155c89c6 100644 --- a/idea/src/org/jetbrains/kotlin/idea/quickfix/AddAnnotationTargetFix.kt +++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/AddAnnotationTargetFix.kt @@ -22,18 +22,15 @@ import org.jetbrains.kotlin.idea.caches.resolve.analyze import org.jetbrains.kotlin.psi.* import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType -import org.jetbrains.kotlin.resolve.AnnotationChecker -import org.jetbrains.kotlin.resolve.AnnotationChecker.Companion.TargetLists.EMPTY -import org.jetbrains.kotlin.resolve.AnnotationChecker.Companion.TargetLists.T_CLASSIFIER -import org.jetbrains.kotlin.resolve.AnnotationChecker.Companion.TargetLists.T_CONSTRUCTOR -import org.jetbrains.kotlin.resolve.AnnotationChecker.Companion.TargetLists.T_EXPRESSION -import org.jetbrains.kotlin.resolve.AnnotationChecker.Companion.TargetLists.T_LOCAL_VARIABLE -import org.jetbrains.kotlin.resolve.AnnotationChecker.Companion.TargetLists.T_MEMBER_FUNCTION -import org.jetbrains.kotlin.resolve.AnnotationChecker.Companion.TargetLists.T_MEMBER_PROPERTY -import org.jetbrains.kotlin.resolve.AnnotationChecker.Companion.TargetLists.T_VALUE_PARAMETER_WITHOUT_VAL -import org.jetbrains.kotlin.resolve.BindingContext -import org.jetbrains.kotlin.resolve.BindingTraceContext -import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils +import org.jetbrains.kotlin.resolve.* +import org.jetbrains.kotlin.resolve.AnnotationTargetLists.EMPTY +import org.jetbrains.kotlin.resolve.AnnotationTargetLists.T_CLASSIFIER +import org.jetbrains.kotlin.resolve.AnnotationTargetLists.T_CONSTRUCTOR +import org.jetbrains.kotlin.resolve.AnnotationTargetLists.T_EXPRESSION +import org.jetbrains.kotlin.resolve.AnnotationTargetLists.T_LOCAL_VARIABLE +import org.jetbrains.kotlin.resolve.AnnotationTargetLists.T_MEMBER_FUNCTION +import org.jetbrains.kotlin.resolve.AnnotationTargetLists.T_MEMBER_PROPERTY +import org.jetbrains.kotlin.resolve.AnnotationTargetLists.T_VALUE_PARAMETER_WITHOUT_VAL import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode class AddAnnotationTargetFix(annotationEntry: KtAnnotationEntry) : KotlinQuickFixAction(annotationEntry) { @@ -100,7 +97,7 @@ private fun KtAnnotationEntry.getRequiredAnnotationTargets(annotationClass: KtCl .toList() } -private fun getActualTargetList(annotated: PsiTarget): AnnotationChecker.Companion.TargetList { +private fun getActualTargetList(annotated: PsiTarget): AnnotationTargetList { return when (annotated) { is PsiClass -> T_CLASSIFIER is PsiMethod ->