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

Refactoring: AnnotationTarget / AnnotationRetention renamed to KotlinTarget / KotlinRetention

Browse Source 
(for not clashing with the same built-in classes)
This commit is contained in:
Mikhail Glukhikh
2015-07-22 18:56:36 +03:00
parent 414c44ade5
commit f551d64ea2
7 changed files with 75 additions and 75 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/backend/src/org/jetbrains/kotlin/codegen/AnnotationCodegen.java
+20 -20
View File
@@ -168,26 +168,26 @@ public abstract class AnnotationCodegen {
generateAnnotationIfNotPresent(annotationDescriptorsAlreadyPresent, annotationClass);
}
private static final Map<AnnotationTarget, ElementType> annotationTargetMap =
new EnumMap<AnnotationTarget, ElementType>(AnnotationTarget.class);
private static final Map<KotlinTarget, ElementType> annotationTargetMap =
new EnumMap<KotlinTarget, ElementType>(KotlinTarget.class);
static {
annotationTargetMap.put(AnnotationTarget.PACKAGE, ElementType.PACKAGE);
annotationTargetMap.put(AnnotationTarget.CLASSIFIER, ElementType.TYPE);
annotationTargetMap.put(AnnotationTarget.ANNOTATION_CLASS, ElementType.ANNOTATION_TYPE);
annotationTargetMap.put(AnnotationTarget.CONSTRUCTOR, ElementType.CONSTRUCTOR);
annotationTargetMap.put(AnnotationTarget.LOCAL_VARIABLE, ElementType.LOCAL_VARIABLE);
annotationTargetMap.put(AnnotationTarget.FUNCTION, ElementType.METHOD);
annotationTargetMap.put(AnnotationTarget.PROPERTY_GETTER, ElementType.METHOD);
annotationTargetMap.put(AnnotationTarget.PROPERTY_SETTER, ElementType.METHOD);
annotationTargetMap.put(AnnotationTarget.FIELD, ElementType.FIELD);
annotationTargetMap.put(AnnotationTarget.VALUE_PARAMETER, ElementType.PARAMETER);
annotationTargetMap.put(KotlinTarget.PACKAGE, ElementType.PACKAGE);
annotationTargetMap.put(KotlinTarget.CLASSIFIER, ElementType.TYPE);
annotationTargetMap.put(KotlinTarget.ANNOTATION_CLASS, ElementType.ANNOTATION_TYPE);
annotationTargetMap.put(KotlinTarget.CONSTRUCTOR, ElementType.CONSTRUCTOR);
annotationTargetMap.put(KotlinTarget.LOCAL_VARIABLE, ElementType.LOCAL_VARIABLE);
annotationTargetMap.put(KotlinTarget.FUNCTION, ElementType.METHOD);
annotationTargetMap.put(KotlinTarget.PROPERTY_GETTER, ElementType.METHOD);
annotationTargetMap.put(KotlinTarget.PROPERTY_SETTER, ElementType.METHOD);
annotationTargetMap.put(KotlinTarget.FIELD, ElementType.FIELD);
annotationTargetMap.put(KotlinTarget.VALUE_PARAMETER, ElementType.PARAMETER);
}
private void generateTargetAnnotation(@NotNull ClassDescriptor classDescriptor, @NotNull Set<String> annotationDescriptorsAlreadyPresent) {
String descriptor = Type.getType(Target.class).getDescriptor();
if (!annotationDescriptorsAlreadyPresent.add(descriptor)) return;
Set<AnnotationTarget> targets = AnnotationTargetChecker.INSTANCE$.possibleTargetSet(classDescriptor);
Set<KotlinTarget> targets = AnnotationTargetChecker.INSTANCE$.possibleTargetSet(classDescriptor);
Set<ElementType> javaTargets;
if (targets == null) {
javaTargets = getJavaTargetList(classDescriptor);
@@ -195,7 +195,7 @@ public abstract class AnnotationCodegen {
}
else {
javaTargets = EnumSet.noneOf(ElementType.class);
for (AnnotationTarget target : targets) {
for (KotlinTarget target : targets) {
if (annotationTargetMap.get(target) == null) continue;
javaTargets.add(annotationTargetMap.get(target));
}
@@ -368,13 +368,13 @@ public abstract class AnnotationCodegen {
value.accept(argumentVisitor, null);
}
private static final Map<AnnotationRetention, RetentionPolicy> annotationRetentionMap =
new EnumMap<AnnotationRetention, RetentionPolicy>(AnnotationRetention.class);
private static final Map<KotlinRetention, RetentionPolicy> annotationRetentionMap =
new EnumMap<KotlinRetention, RetentionPolicy>(KotlinRetention.class);
static {
annotationRetentionMap.put(AnnotationRetention.SOURCE, RetentionPolicy.SOURCE);
annotationRetentionMap.put(AnnotationRetention.BINARY, RetentionPolicy.CLASS);
annotationRetentionMap.put(AnnotationRetention.RUNTIME, RetentionPolicy.RUNTIME);
annotationRetentionMap.put(KotlinRetention.SOURCE, RetentionPolicy.SOURCE);
annotationRetentionMap.put(KotlinRetention.BINARY, RetentionPolicy.CLASS);
annotationRetentionMap.put(KotlinRetention.RUNTIME, RetentionPolicy.RUNTIME);
}
@Nullable
@@ -415,7 +415,7 @@ public abstract class AnnotationCodegen {
JetType classObjectType = getClassObjectType(enumEntry);
if (classObjectType != null) {
if ("kotlin/annotation/AnnotationRetention".equals(typeMapper.mapType(classObjectType).getInternalName())) {
AnnotationRetention retention = AnnotationRetention.valueOf(enumEntry.getName().asString());
KotlinRetention retention = KotlinRetention.valueOf(enumEntry.getName().asString());
return annotationRetentionMap.get(retention);
}
}
compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationTargetChecker.kt
+23 -23
View File
@@ -29,7 +29,7 @@ import org.jetbrains.kotlin.types.JetType
import org.jetbrains.kotlin.types.TypeUtils
import java.lang.annotation.ElementType
import java.util.*
import org.jetbrains.kotlin.descriptors.annotations.AnnotationTarget
import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget
import kotlin.annotation
public object AnnotationTargetChecker {
@@ -62,7 +62,7 @@ public object AnnotationTargetChecker {
public fun checkExpression(expression: JetExpression, trace: BindingTrace) {
for (entry in expression.getAnnotationEntries()) {
checkAnnotationEntry(entry, listOf(AnnotationTarget.EXPRESSION), trace)
checkAnnotationEntry(entry, listOf(KotlinTarget.EXPRESSION), trace)
}
if (expression is JetFunctionLiteralExpression) {
for (parameter in expression.getValueParameters()) {
@@ -71,55 +71,55 @@ public object AnnotationTargetChecker {
}
}
public fun possibleTargetSet(classDescriptor: ClassDescriptor): Set<AnnotationTarget>? {
public fun possibleTargetSet(classDescriptor: ClassDescriptor): Set<KotlinTarget>? {
val targetEntryDescriptor = classDescriptor.getAnnotations().findAnnotation(KotlinBuiltIns.FQ_NAMES.target)
?: return null
val valueArguments = targetEntryDescriptor.getAllValueArguments()
val valueArgument = valueArguments.entrySet().firstOrNull()?.getValue() as? ArrayValue ?: return null
return valueArgument.value.filterIsInstance<EnumValue>().map {
AnnotationTarget.valueOrNull(it.value.getName().asString())
KotlinTarget.valueOrNull(it.value.getName().asString())
}.filterNotNull().toSet()
}
private fun possibleTargetSet(entry: JetAnnotationEntry, trace: BindingTrace): Set<AnnotationTarget> {
val descriptor = trace.get(BindingContext.ANNOTATION, entry) ?: return AnnotationTarget.DEFAULT_TARGET_SET
private fun possibleTargetSet(entry: JetAnnotationEntry, trace: BindingTrace): Set<KotlinTarget> {
val descriptor = trace.get(BindingContext.ANNOTATION, entry) ?: return KotlinTarget.DEFAULT_TARGET_SET
// For descriptor with error type, all targets are considered as possible
if (descriptor.getType().isError()) return AnnotationTarget.ALL_TARGET_SET
val classDescriptor = TypeUtils.getClassDescriptor(descriptor.getType()) ?: return AnnotationTarget.DEFAULT_TARGET_SET
return possibleTargetSet(classDescriptor) ?: AnnotationTarget.DEFAULT_TARGET_SET
if (descriptor.getType().isError()) return KotlinTarget.ALL_TARGET_SET
val classDescriptor = TypeUtils.getClassDescriptor(descriptor.getType()) ?: return KotlinTarget.DEFAULT_TARGET_SET
return possibleTargetSet(classDescriptor) ?: KotlinTarget.DEFAULT_TARGET_SET
}
private fun checkAnnotationEntry(entry: JetAnnotationEntry, actualTargets: List<AnnotationTarget>, trace: BindingTrace) {
private fun checkAnnotationEntry(entry: JetAnnotationEntry, actualTargets: List<KotlinTarget>, trace: BindingTrace) {
val possibleTargets = possibleTargetSet(entry, trace)
if (actualTargets.any { it in possibleTargets }) return
trace.report(Errors.WRONG_ANNOTATION_TARGET.on(entry, actualTargets.firstOrNull()?.description ?: "unidentified target"))
}
private fun getActualTargetList(annotated: JetAnnotated, descriptor: ClassDescriptor?): List<AnnotationTarget> {
private fun getActualTargetList(annotated: JetAnnotated, descriptor: ClassDescriptor?): List<KotlinTarget> {
if (annotated is JetClassOrObject) {
if (annotated is JetEnumEntry) return listOf(AnnotationTarget.PROPERTY, AnnotationTarget.FIELD)
if (annotated is JetEnumEntry) return listOf(KotlinTarget.PROPERTY, KotlinTarget.FIELD)
return if (descriptor?.getKind() == ClassKind.ANNOTATION_CLASS) {
listOf(AnnotationTarget.ANNOTATION_CLASS, AnnotationTarget.CLASSIFIER)
listOf(KotlinTarget.ANNOTATION_CLASS, KotlinTarget.CLASSIFIER)
}
else {
listOf(AnnotationTarget.CLASSIFIER)
listOf(KotlinTarget.CLASSIFIER)
}
}
if (annotated is JetProperty) {
return if (annotated.isLocal()) listOf(AnnotationTarget.LOCAL_VARIABLE) else listOf(AnnotationTarget.PROPERTY, AnnotationTarget.FIELD)
return if (annotated.isLocal()) listOf(KotlinTarget.LOCAL_VARIABLE) else listOf(KotlinTarget.PROPERTY, KotlinTarget.FIELD)
}
if (annotated is JetParameter) {
return if (annotated.hasValOrVar()) listOf(AnnotationTarget.PROPERTY, AnnotationTarget.FIELD) else listOf(AnnotationTarget.VALUE_PARAMETER)
return if (annotated.hasValOrVar()) listOf(KotlinTarget.PROPERTY, KotlinTarget.FIELD) else listOf(KotlinTarget.VALUE_PARAMETER)
}
if (annotated is JetConstructor<*>) return listOf(AnnotationTarget.CONSTRUCTOR)
if (annotated is JetFunction) return listOf(AnnotationTarget.FUNCTION)
if (annotated is JetConstructor<*>) return listOf(KotlinTarget.CONSTRUCTOR)
if (annotated is JetFunction) return listOf(KotlinTarget.FUNCTION)
if (annotated is JetPropertyAccessor) {
return if (annotated.isGetter()) listOf(AnnotationTarget.PROPERTY_GETTER) else listOf(AnnotationTarget.PROPERTY_SETTER)
return if (annotated.isGetter()) listOf(KotlinTarget.PROPERTY_GETTER) else listOf(KotlinTarget.PROPERTY_SETTER)
}
if (annotated is JetPackageDirective) return listOf(AnnotationTarget.PACKAGE)
if (annotated is JetTypeReference) return listOf(AnnotationTarget.TYPE)
if (annotated is JetFile) return listOf(AnnotationTarget.FILE)
if (annotated is JetTypeParameter) return listOf(AnnotationTarget.TYPE_PARAMETER)
if (annotated is JetPackageDirective) return listOf(KotlinTarget.PACKAGE)
if (annotated is JetTypeReference) return listOf(KotlinTarget.TYPE)
if (annotated is JetFile) return listOf(KotlinTarget.FILE)
if (annotated is JetTypeParameter) return listOf(KotlinTarget.TYPE_PARAMETER)
return listOf()
}
}
core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/JavaAnnotationMapper.kt
+18 -18
View File
@@ -34,10 +34,10 @@ import org.jetbrains.kotlin.resolve.constants.ConstantValue
import org.jetbrains.kotlin.resolve.constants.EnumValue
import org.jetbrains.kotlin.types.ErrorUtils
import org.jetbrains.kotlin.types.JetType
import org.jetbrains.kotlin.descriptors.annotations.AnnotationTarget
import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget
import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.descriptors.annotations.AnnotationRetention
import org.jetbrains.kotlin.descriptors.annotations.KotlinRetention
import org.jetbrains.kotlin.storage.StorageManager
import java.lang.annotation.Retention
import java.lang.annotation.Target
@@ -113,21 +113,21 @@ class JavaTargetAnnotationDescriptor(
}
public object JavaAnnotationTargetMapper {
private val targetNameLists = mapOf("PACKAGE" to EnumSet.of(AnnotationTarget.PACKAGE),
"TYPE" to EnumSet.of(AnnotationTarget.CLASSIFIER),
"ANNOTATION_TYPE" to EnumSet.of(AnnotationTarget.ANNOTATION_CLASS),
"TYPE_PARAMETER" to EnumSet.of(AnnotationTarget.TYPE_PARAMETER),
"FIELD" to EnumSet.of(AnnotationTarget.FIELD),
"LOCAL_VARIABLE" to EnumSet.of(AnnotationTarget.LOCAL_VARIABLE),
"PARAMETER" to EnumSet.of(AnnotationTarget.VALUE_PARAMETER),
"CONSTRUCTOR" to EnumSet.of(AnnotationTarget.CONSTRUCTOR),
"METHOD" to EnumSet.of(AnnotationTarget.FUNCTION,
AnnotationTarget.PROPERTY_GETTER,
AnnotationTarget.PROPERTY_SETTER),
"TYPE_USE" to EnumSet.of(AnnotationTarget.TYPE)
private val targetNameLists = mapOf("PACKAGE" to EnumSet.of(KotlinTarget.PACKAGE),
"TYPE" to EnumSet.of(KotlinTarget.CLASSIFIER),
"ANNOTATION_TYPE" to EnumSet.of(KotlinTarget.ANNOTATION_CLASS),
"TYPE_PARAMETER" to EnumSet.of(KotlinTarget.TYPE_PARAMETER),
"FIELD" to EnumSet.of(KotlinTarget.FIELD),
"LOCAL_VARIABLE" to EnumSet.of(KotlinTarget.LOCAL_VARIABLE),
"PARAMETER" to EnumSet.of(KotlinTarget.VALUE_PARAMETER),
"CONSTRUCTOR" to EnumSet.of(KotlinTarget.CONSTRUCTOR),
"METHOD" to EnumSet.of(KotlinTarget.FUNCTION,
KotlinTarget.PROPERTY_GETTER,
KotlinTarget.PROPERTY_SETTER),
"TYPE_USE" to EnumSet.of(KotlinTarget.TYPE)
)
public fun mapJavaTargetArgumentByName(argumentName: String?): Set<AnnotationTarget> = targetNameLists[argumentName] ?: emptySet()
public fun mapJavaTargetArgumentByName(argumentName: String?): Set<KotlinTarget> = targetNameLists[argumentName] ?: emptySet()
public fun mapJavaTargetArguments(arguments: List<JavaAnnotationArgument>, builtIns: KotlinBuiltIns): ConstantValue<*>? {
// Map arguments: java.lang.annotation.Target -> kotlin.annotation.target
@@ -141,9 +141,9 @@ public object JavaAnnotationTargetMapper {
return ArrayValue(kotlinTargets, parameterDescriptor?.type ?: ErrorUtils.createErrorType("Error: AnnotationTarget[]"), builtIns)
}
private val retentionNameList = mapOf("RUNTIME" to AnnotationRetention.RUNTIME,
"CLASS" to AnnotationRetention.BINARY,
"SOURCE" to AnnotationRetention.SOURCE
private val retentionNameList = mapOf("RUNTIME" to KotlinRetention.RUNTIME,
"CLASS" to KotlinRetention.BINARY,
"SOURCE" to KotlinRetention.SOURCE
)
public fun mapJavaRetentionArgument(element: JavaAnnotationArgument, builtIns: KotlinBuiltIns): ConstantValue<*>? {
core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java
+2 -2
View File
@@ -398,7 +398,7 @@ public class KotlinBuiltIns {
}
@Nullable
public ClassDescriptor getAnnotationTargetEnumEntry(@NotNull AnnotationTarget target) {
public ClassDescriptor getAnnotationTargetEnumEntry(@NotNull KotlinTarget target) {
ClassifierDescriptor result = getAnnotationTargetEnum().getUnsubstitutedInnerClassesScope().getClassifier(
Name.identifier(target.name()), UsageLocation.NO_LOCATION
);
@@ -411,7 +411,7 @@ public class KotlinBuiltIns {
}
@Nullable
public ClassDescriptor getAnnotationRetentionEnumEntry(@NotNull AnnotationRetention retention) {
public ClassDescriptor getAnnotationRetentionEnumEntry(@NotNull KotlinRetention retention) {
ClassifierDescriptor result = getAnnotationRetentionEnum().getUnsubstitutedInnerClassesScope().getClassifier(
Name.identifier(retention.name()), UsageLocation.NO_LOCATION
);
core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationRetention.kt → core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/KotlinRetention.kt
+1 -1
View File
@@ -16,7 +16,7 @@
package org.jetbrains.kotlin.descriptors.annotations
public enum class AnnotationRetention {
public enum class KotlinRetention {
RUNTIME,
BINARY,
SOURCE
core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationTarget.kt → core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/KotlinTarget.kt
+6 -6
View File
@@ -20,7 +20,7 @@ import java.util.*
import kotlin.annotation
// NOTE: this enum must have the same entries with kotlin.annotation.AnnotationTarget
public enum class AnnotationTarget(val description: String, val isDefault: Boolean = true) {
public enum class KotlinTarget(val description: String, val isDefault: Boolean = true) {
PACKAGE("package"),
CLASSIFIER("classifier"),
ANNOTATION_CLASS("annotation class"),
@@ -39,19 +39,19 @@ public enum class AnnotationTarget(val description: String, val isDefault: Boole
companion object {
private val map = HashMap<String, AnnotationTarget>()
private val map = HashMap<String, KotlinTarget>()
init {
for (target in AnnotationTarget.values()) {
for (target in KotlinTarget.values()) {
map[target.name()] = target
}
}
public fun valueOrNull(name: String): AnnotationTarget? = map[name]
public fun valueOrNull(name: String): KotlinTarget? = map[name]
public val DEFAULT_TARGET_SET: Set<AnnotationTarget> = values().filter { it.isDefault }.toSet()
public val DEFAULT_TARGET_SET: Set<KotlinTarget> = values().filter { it.isDefault }.toSet()
public val ALL_TARGET_SET: Set<AnnotationTarget> = values().toSet()
public val ALL_TARGET_SET: Set<KotlinTarget> = values().toSet()
}
}
j2k/src/org/jetbrains/kotlin/j2k/AnnotationConverter.kt
+5 -5
View File
@@ -20,7 +20,7 @@ import com.intellij.codeInsight.NullableNotNullManager
import com.intellij.openapi.util.text.StringUtil
import com.intellij.psi.*
import com.intellij.psi.javadoc.PsiDocTag
import org.jetbrains.kotlin.descriptors.annotations.AnnotationTarget
import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget
import org.jetbrains.kotlin.j2k.ast.*
import org.jetbrains.kotlin.j2k.ast.Annotation
import org.jetbrains.kotlin.load.java.components.JavaAnnotationTargetMapper
@@ -96,7 +96,7 @@ class AnnotationConverter(private val converter: Converter) {
PsiModifier.TRANSIENT to "transient"
)
private fun mapTargetByName(expr: PsiReferenceExpression): Set<AnnotationTarget> {
private fun mapTargetByName(expr: PsiReferenceExpression): Set<KotlinTarget> {
return expr.referenceName?.let { JavaAnnotationTargetMapper.mapJavaTargetArgumentByName(it) } ?: emptySet()
}
@@ -108,9 +108,9 @@ class AnnotationConverter(private val converter: Converter) {
}
if (qualifiedName == CommonClassNames.JAVA_LANG_ANNOTATION_TARGET) {
val attributes = annotation.parameterList.attributes
val arguments: Set<AnnotationTarget>
val arguments: Set<KotlinTarget>
if (attributes.isEmpty()) {
arguments = setOf<AnnotationTarget>()
arguments = setOf<KotlinTarget>()
}
else {
val value = attributes[0].value
@@ -119,7 +119,7 @@ class AnnotationConverter(private val converter: Converter) {
.flatMap { mapTargetByName(it) }
.toSet()
is PsiReferenceExpression -> mapTargetByName(value)
else -> setOf<AnnotationTarget>()
else -> setOf<KotlinTarget>()
}
}
val deferredExpressionList = arguments.map {