Annotation resolve refactoring: AnnotationResolver.resolveAnnotationArguments --> ForceResolveUtil.forceResolveAllContents

compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationResolver.java

@@ -46,6 +46,7 @@ import org.jetbrains.kotlin.resolve.constants.ArrayValue;
 import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
 import org.jetbrains.kotlin.resolve.constants.IntegerValueTypeConstant;
 import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator;
+import org.jetbrains.kotlin.resolve.lazy.ForceResolveUtil;
 import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyAnnotationDescriptor;
 import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyAnnotationsContextImpl;
 import org.jetbrains.kotlin.resolve.scopes.JetScope;
@@ -153,7 +154,7 @@ public class AnnotationResolver {
                 descriptor = new LazyAnnotationDescriptor(new LazyAnnotationsContextImpl(this, storageManager, trace, scope), entryElement);
             }
             if (shouldResolveArguments) {
-                resolveAnnotationArguments(descriptor);
+                ForceResolveUtil.forceResolveAllContents(descriptor);
             }
 
             result.add(descriptor);
@@ -211,18 +212,6 @@ public class AnnotationResolver {
         );
     }
 
-    public static void resolveAnnotationsArguments(@NotNull Annotations annotations) {
-        for (AnnotationDescriptor annotationDescriptor : annotations) {
-            resolveAnnotationArguments(annotationDescriptor);
-        }
-    }
-
-    private static void resolveAnnotationArguments(@NotNull AnnotationDescriptor annotationDescriptor) {
-        if (annotationDescriptor instanceof LazyAnnotationDescriptor) {
-            ((LazyAnnotationDescriptor) annotationDescriptor).forceResolveAllContents();
-        }
-    }
-
     @NotNull
     public static Map<ValueParameterDescriptor, CompileTimeConstant<?>> resolveAnnotationArguments(
             @NotNull ResolvedCall<?> resolvedCall,

compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java

@@ -33,6 +33,7 @@ import org.jetbrains.kotlin.resolve.calls.results.OverloadResolutionResults;
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
 import org.jetbrains.kotlin.resolve.calls.util.CallMaker;
 import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
+import org.jetbrains.kotlin.resolve.lazy.ForceResolveUtil;
 import org.jetbrains.kotlin.resolve.scopes.*;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.kotlin.types.*;
@@ -159,7 +160,7 @@ public class BodyResolver {
             @NotNull final ConstructorDescriptor descriptor,
             @NotNull JetScope declaringScope
     ) {
-        AnnotationResolver.resolveAnnotationsArguments(descriptor.getAnnotations());
+        ForceResolveUtil.forceResolveAllContents(descriptor.getAnnotations());
 
         final CallChecker callChecker = new ConstructorHeaderCallChecker(descriptor, additionalCheckerProvider.getCallChecker());
         resolveFunctionBody(c, trace, constructor, descriptor, declaringScope,
@@ -505,7 +506,7 @@ public class BodyResolver {
             ClassDescriptorWithResolutionScopes classDescriptor = entry.getValue();
             ConstructorDescriptor unsubstitutedPrimaryConstructor = classDescriptor.getUnsubstitutedPrimaryConstructor();
             if (unsubstitutedPrimaryConstructor != null) {
-                AnnotationResolver.resolveAnnotationsArguments(unsubstitutedPrimaryConstructor.getAnnotations());
+                ForceResolveUtil.forceResolveAllContents(unsubstitutedPrimaryConstructor.getAnnotations());
 
                 WritableScope parameterScope = getPrimaryConstructorParametersScope(classDescriptor.getScopeForClassHeaderResolution(),
                                                                                     unsubstitutedPrimaryConstructor);
@@ -559,7 +560,7 @@ public class BodyResolver {
                     resolvePropertyDelegate(c, property, propertyDescriptor, delegateExpression, classDescriptor.getScopeForMemberDeclarationResolution(), propertyScope);
                 }
 
-                AnnotationResolver.resolveAnnotationsArguments(propertyDescriptor.getAnnotations());
+                ForceResolveUtil.forceResolveAllContents(propertyDescriptor.getAnnotations());
 
                 resolvePropertyAccessors(c, property, propertyDescriptor);
                 processed.add(property);
@@ -608,7 +609,7 @@ public class BodyResolver {
         PropertyGetterDescriptor getterDescriptor = propertyDescriptor.getGetter();
         if (getter != null && getterDescriptor != null) {
             JetScope accessorScope = makeScopeForPropertyAccessor(c, getter, propertyDescriptor);
-            AnnotationResolver.resolveAnnotationsArguments(getterDescriptor.getAnnotations());
+            ForceResolveUtil.forceResolveAllContents(getterDescriptor.getAnnotations());
             resolveFunctionBody(c, fieldAccessTrackingTrace, getter, getterDescriptor, accessorScope);
         }
 
@@ -616,7 +617,7 @@ public class BodyResolver {
         PropertySetterDescriptor setterDescriptor = propertyDescriptor.getSetter();
         if (setter != null && setterDescriptor != null) {
             JetScope accessorScope = makeScopeForPropertyAccessor(c, setter, propertyDescriptor);
-            AnnotationResolver.resolveAnnotationsArguments(setterDescriptor.getAnnotations());
+            ForceResolveUtil.forceResolveAllContents(setterDescriptor.getAnnotations());
             resolveFunctionBody(c, fieldAccessTrackingTrace, setter, setterDescriptor, accessorScope);
         }
     }

compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java

@@ -41,6 +41,7 @@ import org.jetbrains.kotlin.resolve.constants.IntegerValueTypeConstant;
 import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator;
 import org.jetbrains.kotlin.resolve.constants.evaluate.EvaluatePackage;
 import org.jetbrains.kotlin.resolve.dataClassUtils.DataClassUtilsPackage;
+import org.jetbrains.kotlin.resolve.lazy.ForceResolveUtil;
 import org.jetbrains.kotlin.resolve.scopes.JetScope;
 import org.jetbrains.kotlin.resolve.scopes.JetScopeUtils;
 import org.jetbrains.kotlin.resolve.scopes.WritableScope;
@@ -613,7 +614,7 @@ public class DescriptorResolver {
         );
         trace.record(BindingContext.VALUE_PARAMETER, parameter, variableDescriptor);
         // Type annotations also should be resolved
-        AnnotationResolver.resolveAnnotationsArguments(type.getAnnotations());
+        ForceResolveUtil.forceResolveAllContents(type.getAnnotations());
         return variableDescriptor;
     }
 
@@ -657,7 +658,7 @@ public class DescriptorResolver {
             result = variableDescriptor;
         }
         // Type annotations also should be resolved
-        AnnotationResolver.resolveAnnotationsArguments(type.getAnnotations());
+        ForceResolveUtil.forceResolveAllContents(type.getAnnotations());
         return result;
     }
 

compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt

@@ -32,6 +32,7 @@ import org.jetbrains.kotlin.resolve.ModifiersChecker.*
 import org.jetbrains.kotlin.resolve.DescriptorUtils.*
 import org.jetbrains.kotlin.resolve.DescriptorResolver.*
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo
+import org.jetbrains.kotlin.resolve.lazy.ForceResolveUtil
 import org.jetbrains.kotlin.resolve.scopes.WritableScope
 import org.jetbrains.kotlin.resolve.scopes.WritableScopeImpl
 import org.jetbrains.kotlin.resolve.source.toSourceElement
@@ -166,9 +167,9 @@ class FunctionDescriptorResolver(
                 modality,
                 visibility
         )
-        receiverType?.let { AnnotationResolver.resolveAnnotationsArguments(it.getAnnotations()) }
+        receiverType?.let { ForceResolveUtil.forceResolveAllContents(it.getAnnotations()) }
         for (valueParameterDescriptor in valueParameterDescriptors) {
-            AnnotationResolver.resolveAnnotationsArguments(valueParameterDescriptor.getType().getAnnotations())
+            ForceResolveUtil.forceResolveAllContents(valueParameterDescriptor.getType().getAnnotations())
         }
     }
 

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ForceResolveUtil.java

@@ -36,7 +36,7 @@ public class ForceResolveUtil {
 
     private ForceResolveUtil() {}
 
-    public static <T extends DeclarationDescriptor> T forceResolveAllContents(@NotNull T descriptor) {
+    public static <T> T forceResolveAllContents(@NotNull T descriptor) {
         doForceResolveAllContents(descriptor);
         return descriptor;
     }
@@ -63,7 +63,6 @@ public class ForceResolveUtil {
 
     public static void forceResolveAllContents(@NotNull Annotations annotations) {
         doForceResolveAllContents(annotations);
-        AnnotationResolver.resolveAnnotationsArguments(annotations);
         for (AnnotationDescriptor annotation : annotations) {
             doForceResolveAllContents(annotation);
         }

compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FunctionsTypingVisitor.kt

@@ -29,6 +29,7 @@ import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getAnnotationEntries
 import org.jetbrains.kotlin.resolve.*
 import org.jetbrains.kotlin.resolve.BindingContext.EXPECTED_RETURN_TYPE
+import org.jetbrains.kotlin.resolve.lazy.ForceResolveUtil
 import org.jetbrains.kotlin.resolve.scopes.WritableScope
 import org.jetbrains.kotlin.resolve.source.toSourceElement
 import org.jetbrains.kotlin.types.CommonSupertypes
@@ -91,7 +92,7 @@ public class FunctionsTypingVisitor(facade: ExpressionTypingInternals) : Express
             )
         }
         // Necessary for local functions
-        AnnotationResolver.resolveAnnotationsArguments(functionDescriptor.getAnnotations());
+        ForceResolveUtil.forceResolveAllContents(functionDescriptor.getAnnotations());
 
         val functionInnerScope = FunctionDescriptorUtil.getFunctionInnerScope(context.scope, functionDescriptor, context.trace)
         components.expressionTypingServices.checkFunctionReturnType(
@@ -168,7 +169,7 @@ public class FunctionsTypingVisitor(facade: ExpressionTypingInternals) : Express
                 initializeFunctionDescriptorAndExplicitReturnType(context.scope.getContainingDeclaration(), context.scope, functionLiteral,
                                                                   functionDescriptor, context.trace, context.expectedType)
         for (parameterDescriptor in functionDescriptor.getValueParameters()) {
-            AnnotationResolver.resolveAnnotationsArguments(parameterDescriptor.getAnnotations())
+            ForceResolveUtil.forceResolveAllContents(parameterDescriptor.getAnnotations())
         }
         BindingContextUtils.recordFunctionDeclarationToDescriptor(context.trace, functionLiteral, functionDescriptor)
         return functionDescriptor

compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ValueParameterResolver.kt

@@ -22,6 +22,7 @@ import org.jetbrains.kotlin.psi.JetParameter
 import org.jetbrains.kotlin.resolve.*
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo
 import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator
+import org.jetbrains.kotlin.resolve.lazy.ForceResolveUtil
 import org.jetbrains.kotlin.resolve.scopes.JetScope
 import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator
 import org.jetbrains.kotlin.types.TypeUtils
@@ -49,7 +50,7 @@ public class ValueParameterResolver(
             context: ExpressionTypingContext
     ) {
         for ((descriptor, parameter) in valueParameterDescriptors zip valueParameters) {
-            AnnotationResolver.resolveAnnotationsArguments(descriptor.getAnnotations())
+            ForceResolveUtil.forceResolveAllContents(descriptor.getAnnotations())
             resolveDefaultValue(descriptor, parameter, context)
         }
     }