From 298ddcf0adc46be3ad6fb0efd526d4c17d862ef2 Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Tue, 25 Mar 2014 22:04:22 +0400 Subject: [PATCH] Do not resolve annotation arguments when only a type is requested This replaces the logic that always did complete constructor call resolution by a request to typeResolver when only a type is needed --- .../di/InjectorForLazyResolveWithJava.java | 1 + .../di/InjectorForTopDownAnalyzerForJvm.java | 1 + .../jet/di/InjectorForBodyResolve.java | 1 + .../jet/di/InjectorForLazyResolve.java | 1 + .../jetbrains/jet/di/InjectorForMacros.java | 1 + .../di/InjectorForTopDownAnalyzerBasic.java | 1 + .../jet/lang/resolve/AnnotationResolver.java | 64 +++++++++---------- .../UnresolvedAnnotationOnObject.txt | 2 +- .../jetbrains/jet/di/InjectorForTests.java | 1 + .../di/InjectorForTopDownAnalyzerForJs.java | 1 + 10 files changed, 39 insertions(+), 35 deletions(-) diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java index 5e27587c391..38e1cd006ef 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java @@ -175,6 +175,7 @@ public class InjectorForLazyResolveWithJava { annotationResolver.setCallResolver(callResolver); annotationResolver.setStorageManager(lockBasedStorageManager); + annotationResolver.setTypeResolver(typeResolver); callResolver.setArgumentTypeResolver(argumentTypeResolver); callResolver.setCandidateResolver(candidateResolver); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java index 9191a4154c6..fdb9cd76176 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java @@ -220,6 +220,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly annotationResolver.setCallResolver(callResolver); annotationResolver.setStorageManager(storageManager); + annotationResolver.setTypeResolver(typeResolver); callResolver.setArgumentTypeResolver(argumentTypeResolver); callResolver.setCandidateResolver(candidateResolver); diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForBodyResolve.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForBodyResolve.java index 0b1379de471..1504b67fd6b 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForBodyResolve.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForBodyResolve.java @@ -121,6 +121,7 @@ public class InjectorForBodyResolve { annotationResolver.setCallResolver(callResolver); annotationResolver.setStorageManager(storageManager); + annotationResolver.setTypeResolver(typeResolver); callResolver.setArgumentTypeResolver(argumentTypeResolver); callResolver.setCandidateResolver(candidateResolver); diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java index 24dd8f85abd..b64170e828e 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java @@ -116,6 +116,7 @@ public class InjectorForLazyResolve { annotationResolver.setCallResolver(callResolver); annotationResolver.setStorageManager(lockBasedStorageManager); + annotationResolver.setTypeResolver(typeResolver); callResolver.setArgumentTypeResolver(argumentTypeResolver); callResolver.setCandidateResolver(candidateResolver); diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForMacros.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForMacros.java index 3972a7799f8..f8a49a53c51 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForMacros.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForMacros.java @@ -107,6 +107,7 @@ public class InjectorForMacros { annotationResolver.setCallResolver(callResolver); annotationResolver.setStorageManager(storageManager); + annotationResolver.setTypeResolver(typeResolver); callResolver.setArgumentTypeResolver(argumentTypeResolver); callResolver.setCandidateResolver(candidateResolver); diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java index a2b97b99956..9543d09fe88 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java @@ -162,6 +162,7 @@ public class InjectorForTopDownAnalyzerBasic { annotationResolver.setCallResolver(callResolver); annotationResolver.setStorageManager(storageManager); + annotationResolver.setTypeResolver(typeResolver); callResolver.setArgumentTypeResolver(argumentTypeResolver); callResolver.setCandidateResolver(candidateResolver); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnnotationResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnnotationResolver.java index 19567fbe0c7..6a8b123574a 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnnotationResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnnotationResolver.java @@ -57,6 +57,7 @@ public class AnnotationResolver { private CallResolver callResolver; private StorageManager storageManager; + private TypeResolver typeResolver; @Inject public void setCallResolver(CallResolver callResolver) { @@ -68,6 +69,11 @@ public class AnnotationResolver { this.storageManager = storageManager; } + @Inject + public void setTypeResolver(TypeResolver typeResolver) { + this.typeResolver = typeResolver; + } + @NotNull public Annotations resolveAnnotationsWithoutArguments( @NotNull JetScope scope, @@ -128,7 +134,7 @@ public class AnnotationResolver { } else { descriptor = new AnnotationDescriptorImpl(); - ((AnnotationDescriptorImpl) descriptor).setAnnotationType(resolveAnnotationType(scope, entryElement, trace)); + ((AnnotationDescriptorImpl) descriptor).setAnnotationType(resolveAnnotationType(scope, entryElement)); } trace.record(BindingContext.ANNOTATION, entryElement, descriptor); } @@ -142,44 +148,33 @@ public class AnnotationResolver { } @NotNull - private JetType resolveAnnotationType( - JetScope scope, - JetAnnotationEntry entryElement, - BindingTrace trace - ) { - TemporaryBindingTrace temporaryBindingTrace = new TemporaryBindingTrace(trace, "Trace for resolve annotation type"); - OverloadResolutionResults results = resolveAnnotationCall(entryElement, scope, temporaryBindingTrace); - return getAnnotationTypeFromResolutionResults(entryElement, trace, results); + public JetType resolveAnnotationType(@NotNull JetScope scope, @NotNull JetAnnotationEntry entryElement) { + JetTypeReference typeReference = entryElement.getTypeReference(); + if (typeReference == null) { + return ErrorUtils.createErrorType("No type reference: " + entryElement.getText()); + } + + return typeResolver.resolveType(scope, typeReference, new BindingTraceContext(), true); } - @NotNull - public static JetType getAnnotationTypeFromResolutionResults( - JetAnnotationEntry entryElement, - BindingTrace trace, - OverloadResolutionResults results + public static void checkAnnotationType( + @NotNull JetAnnotationEntry entryElement, + @NotNull BindingTrace trace, + @NotNull OverloadResolutionResults results ) { - if (results.isSingleResult()) { - FunctionDescriptor descriptor = results.getResultingDescriptor(); - if (!ErrorUtils.isError(descriptor)) { - if (descriptor instanceof ConstructorDescriptor) { - ConstructorDescriptor constructor = (ConstructorDescriptor)descriptor; - ClassDescriptor classDescriptor = constructor.getContainingDeclaration(); - if (classDescriptor.getKind() != ClassKind.ANNOTATION_CLASS) { - trace.report(Errors.NOT_AN_ANNOTATION_CLASS.on(entryElement, classDescriptor.getName().asString())); - } - } - else { - trace.report(Errors.NOT_AN_ANNOTATION_CLASS.on(entryElement, descriptor.getName().asString())); + if (!results.isSingleResult()) return; + FunctionDescriptor descriptor = results.getResultingDescriptor(); + if (!ErrorUtils.isError(descriptor)) { + if (descriptor instanceof ConstructorDescriptor) { + ConstructorDescriptor constructor = (ConstructorDescriptor)descriptor; + ClassDescriptor classDescriptor = constructor.getContainingDeclaration(); + if (classDescriptor.getKind() != ClassKind.ANNOTATION_CLASS) { + trace.report(Errors.NOT_AN_ANNOTATION_CLASS.on(entryElement, classDescriptor.getName().asString())); } } - JetType type = results.getResultingDescriptor().getReturnType(); - assert type != null : "No return type for " + results.getResultingDescriptor(); - return type; - } - else { - JetConstructorCalleeExpression calleeExpression = entryElement.getCalleeExpression(); - return ErrorUtils.createErrorType("Unresolved annotation type: " + - (calleeExpression == null ? "null" : calleeExpression.getText())); + else { + trace.report(Errors.NOT_AN_ANNOTATION_CLASS.on(entryElement, descriptor.getName().asString())); + } } } @@ -230,6 +225,7 @@ public class AnnotationResolver { OverloadResolutionResults results = resolveAnnotationCall(annotationEntry, scope, trace); if (results.isSingleResult()) { + checkAnnotationType(annotationEntry, trace, results); resolveAnnotationArguments(annotationDescriptor, results.getResultingCall(), trace); } } diff --git a/compiler/testData/lazyResolve/recursiveComparator/UnresolvedAnnotationOnObject.txt b/compiler/testData/lazyResolve/recursiveComparator/UnresolvedAnnotationOnObject.txt index 5c571dc2c99..c10bd0eca51 100644 --- a/compiler/testData/lazyResolve/recursiveComparator/UnresolvedAnnotationOnObject.txt +++ b/compiler/testData/lazyResolve/recursiveComparator/UnresolvedAnnotationOnObject.txt @@ -2,7 +2,7 @@ package test internal val some: test.SomeObject -[ERROR : Unresolved annotation type: BadAnnotation]() internal object SomeObject { +[ERROR : BadAnnotation]() internal object SomeObject { /*primary*/ private constructor SomeObject() public class object : test.SomeObject { diff --git a/compiler/tests/org/jetbrains/jet/di/InjectorForTests.java b/compiler/tests/org/jetbrains/jet/di/InjectorForTests.java index 4bdb65eb2c4..3a495f107a6 100644 --- a/compiler/tests/org/jetbrains/jet/di/InjectorForTests.java +++ b/compiler/tests/org/jetbrains/jet/di/InjectorForTests.java @@ -109,6 +109,7 @@ public class InjectorForTests { annotationResolver.setCallResolver(callResolver); annotationResolver.setStorageManager(storageManager); + annotationResolver.setTypeResolver(typeResolver); callResolver.setArgumentTypeResolver(argumentTypeResolver); callResolver.setCandidateResolver(candidateResolver); diff --git a/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java b/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java index fb72eb478e0..7d55d5ee7f1 100644 --- a/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java +++ b/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java @@ -162,6 +162,7 @@ public class InjectorForTopDownAnalyzerForJs { annotationResolver.setCallResolver(callResolver); annotationResolver.setStorageManager(storageManager); + annotationResolver.setTypeResolver(typeResolver); callResolver.setArgumentTypeResolver(argumentTypeResolver); callResolver.setCandidateResolver(candidateResolver);