Remove utility method from AnnotationDescriptor interface

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<out Any?>? {
-        return valueArguments(valueParameterDescriptor)
-    }
+    override fun getAllValueArguments() = valueArguments()
 
-    override fun getAllValueArguments(): Map<ValueParameterDescriptor, CompileTimeConstant<out Any?>> {
-        if (!resolutionResults().isSingleResult()) return mapOf()
+    private fun computeValueArguments(): Map<ValueParameterDescriptor, CompileTimeConstant<*>> {
+        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<ValueParameterDescriptor, CompileTimeConstant<*>>
     }
 
     override fun forceResolveAllContents() {

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<JavaAnnotationArgument> = 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<ValueParameterDescriptor, CompileTimeConstant<*>> {
-        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<ValueParameterDescriptor, CompileTimeConstant<*>>()
-        else
-            constructors.first().getValueParameters().keysToMapExceptNulls {
-                vp -> getValueArgument(vp)
-            }
+        computeValueArguments()
     }
 
     override fun getAllValueArguments() = allValueArguments()
 
+    private fun computeValueArguments(): Map<ValueParameterDescriptor, CompileTimeConstant<*>> {
+        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<Name?, JavaAnnotationArgument> {
+        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<*>? {

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<ValueParameterDescriptor, CompileTimeConstant<?>> getAllValueArguments();

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<ValueParameterDescriptor, CompileTimeConstant<?>> getAllValueArguments() {

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) {