From 40513bda56e33bed604cad99e55e0ab3a5fa6684 Mon Sep 17 00:00:00 2001 From: Mikhail Glukhikh Date: Wed, 10 Jun 2015 14:56:51 +0300 Subject: [PATCH] Annotation resolve refactoring: AnnotationResolver.resolveAnnotationArguments --> ForceResolveUtil.forceResolveAllContents --- .../kotlin/resolve/AnnotationResolver.java | 15 ++------------- .../jetbrains/kotlin/resolve/BodyResolver.java | 11 ++++++----- .../kotlin/resolve/DescriptorResolver.java | 5 +++-- .../kotlin/resolve/FunctionDescriptorResolver.kt | 5 +++-- .../kotlin/resolve/lazy/ForceResolveUtil.java | 3 +-- .../types/expressions/FunctionsTypingVisitor.kt | 5 +++-- .../types/expressions/ValueParameterResolver.kt | 3 ++- 7 files changed, 20 insertions(+), 27 deletions(-) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationResolver.java index 03757caa657..6e10d89f9aa 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationResolver.java +++ b/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> resolveAnnotationArguments( @NotNull ResolvedCall resolvedCall, diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java index 6cad4d16cf4..65276c68d7e 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java +++ b/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); } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java index 6b2b9465f28..1bf6ac534a9 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java +++ b/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; } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt index 5cce36b9a1b..9d62018e9e7 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt +++ b/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()) } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ForceResolveUtil.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ForceResolveUtil.java index 21063b96f87..7a77e8ec5e2 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ForceResolveUtil.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/ForceResolveUtil.java @@ -36,7 +36,7 @@ public class ForceResolveUtil { private ForceResolveUtil() {} - public static T forceResolveAllContents(@NotNull T descriptor) { + public static 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); } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FunctionsTypingVisitor.kt b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FunctionsTypingVisitor.kt index 9f871813b4c..fbc931ea56b 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FunctionsTypingVisitor.kt +++ b/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 diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ValueParameterResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ValueParameterResolver.kt index d967702491f..43706b62fb4 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ValueParameterResolver.kt +++ b/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) } }