From 66774c0fd1f47d139c9f762347055359c607a4e1 Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Fri, 28 Nov 2014 21:26:17 +0300 Subject: [PATCH] Remove utility method from AnnotationDescriptor interface --- .../lazy/descriptors/LazyAnnotations.kt | 42 ++++++--------- .../LazyJavaAnnotationDescriptor.kt | 54 +++++++++---------- .../annotations/AnnotationDescriptor.java | 4 -- .../annotations/AnnotationDescriptorImpl.java | 7 --- .../DeprecatedAnnotationVisitor.java | 2 +- 5 files changed, 41 insertions(+), 68 deletions(-) diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyAnnotations.kt b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyAnnotations.kt index 7f08aacabc6..76615369400 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyAnnotations.kt +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyAnnotations.kt @@ -29,7 +29,6 @@ import org.jetbrains.jet.storage.StorageManager import org.jetbrains.jet.lang.resolve.AnnotationResolver import org.jetbrains.jet.lang.resolve.BindingTrace import org.jetbrains.jet.lang.resolve.scopes.JetScope -import org.jetbrains.jet.utils.keysToMapExceptNulls import org.jetbrains.jet.lang.resolve.BindingContext abstract class LazyAnnotationsContext( @@ -95,16 +94,6 @@ public class LazyAnnotationDescriptor( c.trace.record(BindingContext.ANNOTATION, annotationEntry, this) } - private val resolutionResults = c.storageManager.createLazyValue { - val results = c.annotationResolver.resolveAnnotationCall( - annotationEntry, - c.scope, - c.trace - ) - AnnotationResolver.checkAnnotationType(annotationEntry, c.trace, results) - results - } - private val type = c.storageManager.createLazyValue { c.annotationResolver.resolveAnnotationType( c.scope, @@ -114,26 +103,25 @@ public class LazyAnnotationDescriptor( override fun getType() = type() - private val valueArguments = c.storageManager.createMemoizedFunctionWithNullableValues @f { - (valueParameterDescriptor: ValueParameterDescriptor): CompileTimeConstant<*>? -> - if (!resolutionResults().isSingleResult()) return@f null - - val resolvedValueArgument = resolutionResults().getResultingCall().getValueArguments()[valueParameterDescriptor] - if (resolvedValueArgument == null) return@f null - - AnnotationResolver.getAnnotationArgumentValue(c.trace, valueParameterDescriptor, resolvedValueArgument) + private val valueArguments = c.storageManager.createLazyValue { + computeValueArguments() } - override fun getValueArgument(valueParameterDescriptor: ValueParameterDescriptor): CompileTimeConstant? { - return valueArguments(valueParameterDescriptor) - } + override fun getAllValueArguments() = valueArguments() - override fun getAllValueArguments(): Map> { - if (!resolutionResults().isSingleResult()) return mapOf() + private fun computeValueArguments(): Map> { + val resolutionResults = c.annotationResolver.resolveAnnotationCall(annotationEntry, c.scope, c.trace) + AnnotationResolver.checkAnnotationType(annotationEntry, c.trace, resolutionResults) - return resolutionResults().getResultingCall().getValueArguments().keySet().keysToMapExceptNulls { - getValueArgument(it) - } + if (!resolutionResults.isSingleResult()) return mapOf() + + [suppress("UNCHECKED_CAST")] + return resolutionResults.getResultingCall().getValueArguments() + .mapValues { val (valueParameter, resolvedArgument) = it; + if (resolvedArgument == null) null + else AnnotationResolver.getAnnotationArgumentValue(c.trace, valueParameter, resolvedArgument) + } + .filterValues { it != null } as Map> } override fun forceResolveAllContents() { diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt index 810a0a2be5f..e7d8aba79ff 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt @@ -70,40 +70,36 @@ class LazyJavaAnnotationDescriptor( override fun getType(): JetType = type() - private val nameToArgument = c.storageManager.createLazyValue { - var arguments: Collection = javaAnnotation.getArguments() - if (arguments.isEmpty() && fqName()?.asString() == "java.lang.Deprecated") { - arguments = listOf(DEPRECATED_IN_JAVA) - } - arguments.valuesToMap { it.name } - } - - private val valueArguments = c.storageManager.createMemoizedFunctionWithNullableValues> { - valueParameter -> - val nameToArg = nameToArgument() - - var javaAnnotationArgument = nameToArg[valueParameter.getName()] - if (javaAnnotationArgument == null && valueParameter.getName() == DEFAULT_ANNOTATION_MEMBER_NAME) { - javaAnnotationArgument = nameToArg[null] - } - - resolveAnnotationArgument(javaAnnotationArgument) - } - - override fun getValueArgument(valueParameterDescriptor: ValueParameterDescriptor) = valueArguments(valueParameterDescriptor) - private val allValueArguments = c.storageManager.createLazyValue { - val constructors = getAnnotationClass().getConstructors() - if (constructors.isEmpty()) - mapOf>() - else - constructors.first().getValueParameters().keysToMapExceptNulls { - vp -> getValueArgument(vp) - } + computeValueArguments() } override fun getAllValueArguments() = allValueArguments() + private fun computeValueArguments(): Map> { + val constructors = getAnnotationClass().getConstructors() + if (constructors.isEmpty()) return mapOf() + + val nameToArg = nameToArgument() + + return constructors.first().getValueParameters().keysToMapExceptNulls { valueParameter -> + var javaAnnotationArgument = nameToArg[valueParameter.getName()] + if (javaAnnotationArgument == null && valueParameter.getName() == DEFAULT_ANNOTATION_MEMBER_NAME) { + javaAnnotationArgument = nameToArg[null] + } + + resolveAnnotationArgument(javaAnnotationArgument) + } + } + + private fun nameToArgument(): Map { + var arguments = javaAnnotation.getArguments() + if (arguments.isEmpty() && fqName()?.asString() == "java.lang.Deprecated") { + arguments = listOf(DEPRECATED_IN_JAVA) + } + return arguments.valuesToMap { it.name } + } + private fun getAnnotationClass() = getType().getConstructor().getDeclarationDescriptor() as ClassDescriptor private fun resolveAnnotationArgument(argument: JavaAnnotationArgument?): CompileTimeConstant<*>? { diff --git a/core/descriptors/src/org/jetbrains/jet/lang/descriptors/annotations/AnnotationDescriptor.java b/core/descriptors/src/org/jetbrains/jet/lang/descriptors/annotations/AnnotationDescriptor.java index ef814c7c443..ac0cf24c2d5 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/descriptors/annotations/AnnotationDescriptor.java +++ b/core/descriptors/src/org/jetbrains/jet/lang/descriptors/annotations/AnnotationDescriptor.java @@ -17,7 +17,6 @@ package org.jetbrains.jet.lang.descriptors.annotations; import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.ReadOnly; import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant; @@ -29,9 +28,6 @@ public interface AnnotationDescriptor { @NotNull JetType getType(); - @Nullable - CompileTimeConstant getValueArgument(@NotNull ValueParameterDescriptor valueParameterDescriptor); - @NotNull @ReadOnly Map> getAllValueArguments(); diff --git a/core/descriptors/src/org/jetbrains/jet/lang/descriptors/annotations/AnnotationDescriptorImpl.java b/core/descriptors/src/org/jetbrains/jet/lang/descriptors/annotations/AnnotationDescriptorImpl.java index 4f73ab247ca..474791f3a5b 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/descriptors/annotations/AnnotationDescriptorImpl.java +++ b/core/descriptors/src/org/jetbrains/jet/lang/descriptors/annotations/AnnotationDescriptorImpl.java @@ -17,7 +17,6 @@ package org.jetbrains.jet.lang.descriptors.annotations; import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant; import org.jetbrains.jet.lang.types.JetType; @@ -44,12 +43,6 @@ public class AnnotationDescriptorImpl implements AnnotationDescriptor { return annotationType; } - @Override - @Nullable - public CompileTimeConstant getValueArgument(@NotNull ValueParameterDescriptor valueParameterDescriptor) { - return getAllValueArguments().get(valueParameterDescriptor); - } - @Override @NotNull public Map> getAllValueArguments() { diff --git a/idea/idea-analysis/src/org/jetbrains/jet/plugin/highlighter/DeprecatedAnnotationVisitor.java b/idea/idea-analysis/src/org/jetbrains/jet/plugin/highlighter/DeprecatedAnnotationVisitor.java index e8eccd94e8e..fbfc1db9ee2 100644 --- a/idea/idea-analysis/src/org/jetbrains/jet/plugin/highlighter/DeprecatedAnnotationVisitor.java +++ b/idea/idea-analysis/src/org/jetbrains/jet/plugin/highlighter/DeprecatedAnnotationVisitor.java @@ -242,7 +242,7 @@ public class DeprecatedAnnotationVisitor extends AfterAnalysisHighlightingVisito ValueParameterDescriptor parameter = DescriptorResolverUtils.getAnnotationParameterByName(DEFAULT_ANNOTATION_MEMBER_NAME, classDescriptor); if (parameter != null) { - CompileTimeConstant valueArgument = descriptor.getValueArgument(parameter); + CompileTimeConstant valueArgument = descriptor.getAllValueArguments().get(parameter); if (valueArgument != null) { Object value = valueArgument.getValue(); if (value instanceof String) {