From cc7ed2ba549424dc5c91bc9450b3ec9b8b47b590 Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Tue, 4 Jul 2017 15:45:16 +0300 Subject: [PATCH] Change map key type in AnnotationDescriptor.getAllValueArguments Turns out, only the parameter's name is needed at all usages of this method. Such a map is both easier to use (no need to call ValueParameterDescriptor.getName) and easier to construct (no need to resolve annotation class, its constructor, its parameters). In this commit, only usages have changed but the implementations are still using the old logic, this is going to be refactored in subsequent commits --- .../kotlin/codegen/AnnotationCodegen.java | 42 ++++++++----------- .../kotlin/resolve/AnnotationUtil.kt | 11 +---- .../lazy/descriptors/LazyAnnotations.kt | 2 +- .../serialization/AnnotationSerializer.kt | 4 +- .../java/AnnotationTypeQualifierResolver.kt | 2 +- .../java/components/JavaAnnotationMapper.kt | 8 ++-- .../LazyJavaAnnotationDescriptor.kt | 2 +- .../java/typeEnhancement/typeEnhancement.kt | 2 +- .../annotations/AnnotationDescriptor.kt | 7 +++- .../annotations/AnnotationDescriptorImpl.java | 9 +++- .../kotlin/renderer/DescriptorRendererImpl.kt | 17 ++++---- .../kotlin/resolve/DescriptorUtils.java | 4 +- .../kotlin/resolve/DescriptorUtils.kt | 9 ++-- .../idea/properties/referenceProviders.kt | 2 +- .../descriptors/ContainerOptionsProxy.kt | 15 +++---- 15 files changed, 65 insertions(+), 71 deletions(-) diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/AnnotationCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/AnnotationCodegen.java index 42e64da1497..257638cf059 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/AnnotationCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/AnnotationCodegen.java @@ -16,6 +16,7 @@ package org.jetbrains.kotlin.codegen; +import kotlin.collections.CollectionsKt; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.codegen.annotation.WrappedAnnotated; @@ -25,6 +26,7 @@ import org.jetbrains.kotlin.descriptors.annotations.*; import org.jetbrains.kotlin.descriptors.impl.AnonymousFunctionDescriptor; import org.jetbrains.kotlin.load.java.JvmAnnotationNames; import org.jetbrains.kotlin.name.FqName; +import org.jetbrains.kotlin.name.Name; import org.jetbrains.kotlin.resolve.AnnotationChecker; import org.jetbrains.kotlin.resolve.constants.*; import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt; @@ -291,32 +293,27 @@ public abstract class AnnotationCodegen { @Nullable private String genAnnotation(@NotNull AnnotationDescriptor annotationDescriptor) { - ClassifierDescriptor classifierDescriptor = getAnnotationClass(annotationDescriptor); - assert classifierDescriptor != null : "Annotation descriptor has no class: " + annotationDescriptor; - RetentionPolicy rp = getRetentionPolicy(classifierDescriptor); + ClassDescriptor classDescriptor = getAnnotationClass(annotationDescriptor); + assert classDescriptor != null : "Annotation descriptor has no class: " + annotationDescriptor; + RetentionPolicy rp = getRetentionPolicy(classDescriptor); if (rp == RetentionPolicy.SOURCE && !typeMapper.getClassBuilderMode().generateSourceRetentionAnnotations) { return null; } - String descriptor = typeMapper.mapType(annotationDescriptor.getType()).getDescriptor(); + innerClassConsumer.addInnerClassInfoFromAnnotation(classDescriptor); - if (classifierDescriptor instanceof ClassDescriptor) { - innerClassConsumer.addInnerClassInfoFromAnnotation(((ClassDescriptor) classifierDescriptor)); - } - - AnnotationVisitor annotationVisitor = visitAnnotation(descriptor, rp == RetentionPolicy.RUNTIME); + String asmTypeDescriptor = typeMapper.mapType(annotationDescriptor.getType()).getDescriptor(); + AnnotationVisitor annotationVisitor = visitAnnotation(asmTypeDescriptor, rp == RetentionPolicy.RUNTIME); genAnnotationArguments(annotationDescriptor, annotationVisitor); annotationVisitor.visitEnd(); - return descriptor; + return asmTypeDescriptor; } private void genAnnotationArguments(AnnotationDescriptor annotationDescriptor, AnnotationVisitor annotationVisitor) { - for (Map.Entry> entry : annotationDescriptor.getAllValueArguments().entrySet()) { - ValueParameterDescriptor descriptor = entry.getKey(); - String name = descriptor.getName().asString(); - genCompileTimeValue(name, entry.getValue(), annotationVisitor); + for (Map.Entry> entry : annotationDescriptor.getAllValueArguments().entrySet()) { + genCompileTimeValue(entry.getKey().asString(), entry.getValue(), annotationVisitor); } } @@ -475,16 +472,13 @@ public abstract class AnnotationCodegen { } AnnotationDescriptor retentionAnnotation = descriptor.getAnnotations().findAnnotation(new FqName(Retention.class.getName())); if (retentionAnnotation != null) { - Collection> valueArguments = retentionAnnotation.getAllValueArguments().values(); - if (!valueArguments.isEmpty()) { - ConstantValue compileTimeConstant = valueArguments.iterator().next(); - if (compileTimeConstant instanceof EnumValue) { - ClassDescriptor enumEntry = ((EnumValue) compileTimeConstant).getValue(); - KotlinType classObjectType = DescriptorUtilsKt.getClassValueType(enumEntry); - if (classObjectType != null) { - if ("java/lang/annotation/RetentionPolicy".equals(typeMapper.mapType(classObjectType).getInternalName())) { - return RetentionPolicy.valueOf(enumEntry.getName().asString()); - } + ConstantValue compileTimeConstant = CollectionsKt.firstOrNull(retentionAnnotation.getAllValueArguments().values()); + if (compileTimeConstant instanceof EnumValue) { + ClassDescriptor enumEntry = ((EnumValue) compileTimeConstant).getValue(); + KotlinType classObjectType = DescriptorUtilsKt.getClassValueType(enumEntry); + if (classObjectType != null) { + if ("java/lang/annotation/RetentionPolicy".equals(typeMapper.mapType(classObjectType).getInternalName())) { + return RetentionPolicy.valueOf(enumEntry.getName().asString()); } } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationUtil.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationUtil.kt index d7297b34507..d94017e8205 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationUtil.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationUtil.kt @@ -19,8 +19,8 @@ package org.jetbrains.kotlin.resolve.annotations import org.jetbrains.kotlin.descriptors.DeclarationDescriptor import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.resolve.DescriptorUtils -import org.jetbrains.kotlin.resolve.constants.ConstantValue import org.jetbrains.kotlin.resolve.constants.ErrorValue private val JVM_STATIC_ANNOTATION_FQ_NAME = FqName("kotlin.jvm.JvmStatic") @@ -42,12 +42,5 @@ fun DeclarationDescriptor.findStrictfpAnnotation() = DescriptorUtils.getAnnotationByFqName(annotations, STRICTFP_ANNOTATION_FQ_NAME) fun AnnotationDescriptor.argumentValue(parameterName: String): Any? { - val constant: ConstantValue<*>? = allValueArguments.entries - .singleOrNull { it.key.name.asString() == parameterName } - ?.value - - if (constant == null || constant is ErrorValue) - return null - - return constant.value + return allValueArguments[Name.identifier(parameterName)].takeUnless { it is ErrorValue }?.value } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyAnnotations.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyAnnotations.kt index f67c94ed9e8..0b0f9a63d3b 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyAnnotations.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyAnnotations.kt @@ -126,7 +126,7 @@ class LazyAnnotationDescriptor( c.scope } - override val allValueArguments by c.storageManager.createLazyValue { + override val valueArgumentsByParameterDescriptor by c.storageManager.createLazyValue { val resolutionResults = c.annotationResolver.resolveAnnotationCall(annotationEntry, scope, c.trace) AnnotationResolverImpl.checkAnnotationType(annotationEntry, c.trace, resolutionResults) diff --git a/compiler/serialization/src/org/jetbrains/kotlin/serialization/AnnotationSerializer.kt b/compiler/serialization/src/org/jetbrains/kotlin/serialization/AnnotationSerializer.kt index b8b3b64166d..5c0f2869a49 100644 --- a/compiler/serialization/src/org/jetbrains/kotlin/serialization/AnnotationSerializer.kt +++ b/compiler/serialization/src/org/jetbrains/kotlin/serialization/AnnotationSerializer.kt @@ -34,9 +34,9 @@ class AnnotationSerializer(private val stringTable: StringTable) { id = stringTable.getFqNameIndex(annotationClass) - for ((parameter, value) in annotation.allValueArguments) { + for ((name, value) in annotation.allValueArguments) { val argument = ProtoBuf.Annotation.Argument.newBuilder() - argument.nameId = stringTable.getStringIndex(parameter.name.asString()) + argument.nameId = stringTable.getStringIndex(name.asString()) argument.setValue(valueProto(value)) addArgument(argument) } diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/AnnotationTypeQualifierResolver.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/AnnotationTypeQualifierResolver.kt index a2f0681fb51..61380b84d84 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/AnnotationTypeQualifierResolver.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/AnnotationTypeQualifierResolver.kt @@ -92,7 +92,7 @@ class AnnotationTypeQualifierResolverImpl(storageManager: StorageManager) : Anno .annotations.findAnnotation(TYPE_QUALIFIER_DEFAULT_FQNAME)!! .allValueArguments .flatMap { (parameter, argument) -> - if (parameter.name == JvmAnnotationNames.DEFAULT_ANNOTATION_MEMBER_NAME) + if (parameter == JvmAnnotationNames.DEFAULT_ANNOTATION_MEMBER_NAME) argument.mapConstantToQualifierApplicabilityTypes() else emptyList() diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/JavaAnnotationMapper.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/JavaAnnotationMapper.kt index 9f09d478a5c..1c394bbd8ea 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/JavaAnnotationMapper.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/JavaAnnotationMapper.kt @@ -109,14 +109,14 @@ open class JavaAnnotationDescriptor( protected val firstArgument: JavaAnnotationArgument? = annotation?.arguments?.firstOrNull() - override val allValueArguments: Map> get() = emptyMap() + override val valueArgumentsByParameterDescriptor: Map> get() = emptyMap() } class JavaDeprecatedAnnotationDescriptor( annotation: JavaAnnotation?, c: LazyJavaResolverContext ): JavaAnnotationDescriptor(c, annotation, c.module.builtIns.deprecatedAnnotation) { - override val allValueArguments: Map> by c.storageManager.createLazyValue { + override val valueArgumentsByParameterDescriptor: Map> by c.storageManager.createLazyValue { val parameterDescriptor = valueParameters.firstOrNull { it.name == JavaAnnotationMapper.DEPRECATED_ANNOTATION_MESSAGE } @@ -130,7 +130,7 @@ class JavaTargetAnnotationDescriptor( annotation: JavaAnnotation, c: LazyJavaResolverContext ): JavaAnnotationDescriptor(c, annotation, c.module.builtIns.targetAnnotation) { - override val allValueArguments by c.storageManager.createLazyValue { + override val valueArgumentsByParameterDescriptor by c.storageManager.createLazyValue { val targetArgument = when (firstArgument) { is JavaArrayAnnotationArgument -> JavaAnnotationTargetMapper.mapJavaTargetArguments(firstArgument.getElements(), c.module.builtIns) is JavaEnumValueAnnotationArgument -> JavaAnnotationTargetMapper.mapJavaTargetArguments(listOf(firstArgument), c.module.builtIns) @@ -144,7 +144,7 @@ class JavaRetentionAnnotationDescriptor( annotation: JavaAnnotation, c: LazyJavaResolverContext ): JavaAnnotationDescriptor(c, annotation, c.module.builtIns.retentionAnnotation) { - override val allValueArguments by c.storageManager.createLazyValue { + override val valueArgumentsByParameterDescriptor by c.storageManager.createLazyValue { val retentionArgument = JavaAnnotationTargetMapper.mapJavaRetentionArgument(firstArgument, c.module.builtIns) retentionArgument?.let { mapOf(valueParameters.single() to it) }.orEmpty() } diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt index 5277dc53466..43148235a63 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt @@ -61,7 +61,7 @@ class LazyJavaAnnotationDescriptor( private val factory = ConstantValueFactory(c.module.builtIns) - override val allValueArguments by c.storageManager.createLazyValue { + override val valueArgumentsByParameterDescriptor by c.storageManager.createLazyValue { val constructors = annotationClass!!.constructors if (constructors.isEmpty()) return@createLazyValue emptyMap>() diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/typeEnhancement/typeEnhancement.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/typeEnhancement/typeEnhancement.kt index cda86430c3d..370f463a4d3 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/typeEnhancement/typeEnhancement.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/typeEnhancement/typeEnhancement.kt @@ -209,7 +209,7 @@ private class EnhancedTypeAnnotations(private val fqNameToMatch: FqName) : Annot private object EnhancedTypeAnnotationDescriptor : AnnotationDescriptor { private fun throwError(): Nothing = error("No methods should be called on this descriptor. Only its presence matters") override val type: KotlinType get() = throwError() - override val allValueArguments: Map> get() = throwError() + override val valueArgumentsByParameterDescriptor: Map> get() = throwError() override val source: SourceElement get() = throwError() override fun toString() = "[EnhancedType]" } diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationDescriptor.kt b/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationDescriptor.kt index 96677ca6a91..ddb37069e26 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationDescriptor.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationDescriptor.kt @@ -21,6 +21,7 @@ import org.jetbrains.kotlin.descriptors.SourceElement import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.FqNameUnsafe +import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.resolve.constants.ConstantValue import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameUnsafe import org.jetbrains.kotlin.types.KotlinType @@ -31,7 +32,11 @@ interface AnnotationDescriptor { val fqName: FqName? get() = (type.constructor.declarationDescriptor as? ClassDescriptor)?.fqNameUnsafe?.takeIf(FqNameUnsafe::isSafe)?.toSafe() - val allValueArguments: Map> + @Deprecated("Use allValueArguments instead") + val valueArgumentsByParameterDescriptor: Map> + + val allValueArguments: Map> + get() = valueArgumentsByParameterDescriptor.mapKeys { (parameter) -> parameter.name } val source: SourceElement } diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationDescriptorImpl.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationDescriptorImpl.java index 5e5a339bf27..7067598099f 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationDescriptorImpl.java +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationDescriptorImpl.java @@ -21,6 +21,7 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.descriptors.SourceElement; import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor; import org.jetbrains.kotlin.name.FqName; +import org.jetbrains.kotlin.name.Name; import org.jetbrains.kotlin.renderer.DescriptorRenderer; import org.jetbrains.kotlin.resolve.constants.ConstantValue; import org.jetbrains.kotlin.types.KotlinType; @@ -57,10 +58,16 @@ public class AnnotationDescriptorImpl implements AnnotationDescriptor { @Override @NotNull - public Map> getAllValueArguments() { + public Map> getValueArgumentsByParameterDescriptor() { return valueArguments; } + @NotNull + @Override + public Map> getAllValueArguments() { + return AnnotationDescriptor.DefaultImpls.getAllValueArguments(this); + } + @Override @NotNull public SourceElement getSource() { diff --git a/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererImpl.kt b/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererImpl.kt index 57b64f69ca7..f61e79791f0 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererImpl.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererImpl.kt @@ -429,17 +429,14 @@ internal class DescriptorRendererImpl( private fun renderAndSortAnnotationArguments(descriptor: AnnotationDescriptor): List { val allValueArguments = descriptor.allValueArguments val classDescriptor = if (renderDefaultAnnotationArguments) TypeUtils.getClassDescriptor(descriptor.type) else null - val parameterDescriptorsWithDefaultValue = classDescriptor?.unsubstitutedPrimaryConstructor?.valueParameters?.filter { - it.declaresDefaultValue() - } ?: emptyList() - val defaultList = parameterDescriptorsWithDefaultValue.filter { !allValueArguments.containsKey(it) }.map { - "${it.name.asString()} = ..." - } + val parameterDescriptorsWithDefaultValue = classDescriptor?.unsubstitutedPrimaryConstructor?.valueParameters + ?.filter { it.declaresDefaultValue() } + ?.map { it.name } + .orEmpty() + val defaultList = parameterDescriptorsWithDefaultValue.filter { it !in allValueArguments }.map { "${it.asString()} = ..." } val argumentList = allValueArguments.entries - .map { entry -> - val name = entry.key.name.asString() - val value = if (!parameterDescriptorsWithDefaultValue.contains(entry.key)) renderConstant(entry.value) else "..." - "$name = $value" + .map { (name, value) -> + "${name.asString()} = ${if (name !in parameterDescriptorsWithDefaultValue) renderConstant(value) else "..."}" } return (defaultList + argumentList).sorted() } diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorUtils.java b/core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorUtils.java index 6dce3292ffb..d9440d56873 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorUtils.java +++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorUtils.java @@ -522,10 +522,10 @@ public class DescriptorUtils { } @Nullable - public static String getJvmName(@Nullable AnnotationDescriptor jvmNameAnnotation) { + private static String getJvmName(@Nullable AnnotationDescriptor jvmNameAnnotation) { if (jvmNameAnnotation == null) return null; - Map> arguments = jvmNameAnnotation.getAllValueArguments(); + Map> arguments = jvmNameAnnotation.getAllValueArguments(); if (arguments.isEmpty()) return null; ConstantValue name = arguments.values().iterator().next(); diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorUtils.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorUtils.kt index 742f928ef4f..f0895e05798 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorUtils.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorUtils.kt @@ -27,6 +27,7 @@ import org.jetbrains.kotlin.incremental.components.LookupLocation import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.FqNameUnsafe +import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.resolve.DescriptorUtils import org.jetbrains.kotlin.resolve.DescriptorUtils.getContainingClass import org.jetbrains.kotlin.resolve.constants.EnumValue @@ -213,10 +214,10 @@ fun Annotated.isDocumentedAnnotation(): Boolean = annotations.findAnnotation(KotlinBuiltIns.FQ_NAMES.mustBeDocumented) != null fun Annotated.getAnnotationRetention(): KotlinRetention? { - val annotationEntryDescriptor = annotations.findAnnotation(KotlinBuiltIns.FQ_NAMES.retention) ?: return null - val retentionArgumentValue = annotationEntryDescriptor.allValueArguments.entries.firstOrNull { - it.key.name.asString() == "value" - }?.value as? EnumValue ?: return null + val retentionArgumentValue = annotations.findAnnotation(KotlinBuiltIns.FQ_NAMES.retention) + ?.allValueArguments + ?.get(Name.identifier("value")) + as? EnumValue ?: return null return KotlinRetention.valueOf(retentionArgumentValue.value.name.asString()) } diff --git a/idea/src/org/jetbrains/kotlin/idea/properties/referenceProviders.kt b/idea/src/org/jetbrains/kotlin/idea/properties/referenceProviders.kt index 88d8ad5592d..5e7e2ab354a 100644 --- a/idea/src/org/jetbrains/kotlin/idea/properties/referenceProviders.kt +++ b/idea/src/org/jetbrains/kotlin/idea/properties/referenceProviders.kt @@ -53,7 +53,7 @@ private val PROPERTY_KEY = FqName(AnnotationUtil.PROPERTY_KEY) private val PROPERTY_KEY_RESOURCE_BUNDLE = Name.identifier(AnnotationUtil.PROPERTY_KEY_RESOURCE_BUNDLE_PARAMETER) private fun AnnotationDescriptor.getBundleName(): String? { - return allValueArguments.entries.singleOrNull { it.key.name == PROPERTY_KEY_RESOURCE_BUNDLE }?.value?.value as? String + return allValueArguments[PROPERTY_KEY_RESOURCE_BUNDLE]?.value as? String } private fun DeclarationDescriptor.getBundleNameByAnnotation(): String? { diff --git a/plugins/android-extensions/android-extensions-compiler/src/org/jetbrains/kotlin/android/synthetic/descriptors/ContainerOptionsProxy.kt b/plugins/android-extensions/android-extensions-compiler/src/org/jetbrains/kotlin/android/synthetic/descriptors/ContainerOptionsProxy.kt index 967b5b71465..bda1274c0b1 100644 --- a/plugins/android-extensions/android-extensions-compiler/src/org/jetbrains/kotlin/android/synthetic/descriptors/ContainerOptionsProxy.kt +++ b/plugins/android-extensions/android-extensions-compiler/src/org/jetbrains/kotlin/android/synthetic/descriptors/ContainerOptionsProxy.kt @@ -16,7 +16,6 @@ package org.jetbrains.kotlin.android.synthetic.descriptors -import org.jetbrains.kotlin.resolve.constants.ConstantValue import kotlinx.android.extensions.CacheImplementation import kotlinx.android.extensions.CacheImplementation.* import kotlinx.android.extensions.ContainerOptions @@ -25,6 +24,7 @@ import org.jetbrains.kotlin.descriptors.ClassDescriptor import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.resolve.constants.EnumValue import org.jetbrains.kotlin.resolve.source.KotlinSourceElement @@ -59,17 +59,14 @@ class ContainerOptionsProxy(val containerType: AndroidContainerType, val cache: } } -private operator fun AnnotationDescriptor.get(name: String): ConstantValue<*>? { - return allValueArguments.entries.firstOrNull { it.key.name.asString() == name }?.value -} - -private fun > AnnotationDescriptor.getEnumValue(name: String, defaultValue: E, factory: (String) -> E): E { - val valueName = (this[name] as? EnumValue)?.value?.name?.asString() ?: defaultValue.name +private fun > AnnotationDescriptor.getEnumValue(name: String, defaultValue: E, factory: (String) -> E): E { + val valueName = (allValueArguments[Name.identifier(name)] as? EnumValue)?.value?.name?.asString() ?: defaultValue.name return try { factory(valueName) - } catch (e: IllegalArgumentException) { + } + catch (e: IllegalArgumentException) { // Enum.valueOf() may throw this defaultValue } -} \ No newline at end of file +}