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

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

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

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

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

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

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

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(
+    public JetType resolveAnnotationType(@NotNull JetScope scope, @NotNull JetAnnotationEntry entryElement) {
-            JetScope scope,
+        JetTypeReference typeReference = entryElement.getTypeReference();
-            JetAnnotationEntry entryElement,
+        if (typeReference == null) {
-            BindingTrace trace
+            return ErrorUtils.createErrorType("No type reference: " + entryElement.getText());
-    ) {
+        }
-        TemporaryBindingTrace temporaryBindingTrace = new TemporaryBindingTrace(trace, "Trace for resolve annotation type");
+
-        OverloadResolutionResults<FunctionDescriptor> results = resolveAnnotationCall(entryElement, scope, temporaryBindingTrace);
+        return typeResolver.resolveType(scope, typeReference, new BindingTraceContext(), true);
-        return getAnnotationTypeFromResolutionResults(entryElement, trace, results);
     }
 
-    @NotNull
+    public static void checkAnnotationType(
-    public static JetType getAnnotationTypeFromResolutionResults(
+            @NotNull JetAnnotationEntry entryElement,
-            JetAnnotationEntry entryElement,
+            @NotNull BindingTrace trace,
-            BindingTrace trace,
+            @NotNull OverloadResolutionResults<FunctionDescriptor> results
-            OverloadResolutionResults<FunctionDescriptor> results
     ) {
-        if (results.isSingleResult()) {
+        if (!results.isSingleResult()) return;
-            FunctionDescriptor descriptor = results.getResultingDescriptor();
+        FunctionDescriptor descriptor = results.getResultingDescriptor();
-            if (!ErrorUtils.isError(descriptor)) {
+        if (!ErrorUtils.isError(descriptor)) {
-                if (descriptor instanceof ConstructorDescriptor) {
+            if (descriptor instanceof ConstructorDescriptor) {
-                    ConstructorDescriptor constructor = (ConstructorDescriptor)descriptor;
+                ConstructorDescriptor constructor = (ConstructorDescriptor)descriptor;
-                    ClassDescriptor classDescriptor = constructor.getContainingDeclaration();
+                ClassDescriptor classDescriptor = constructor.getContainingDeclaration();
-                    if (classDescriptor.getKind() != ClassKind.ANNOTATION_CLASS) {
+                if (classDescriptor.getKind() != ClassKind.ANNOTATION_CLASS) {
-                        trace.report(Errors.NOT_AN_ANNOTATION_CLASS.on(entryElement, classDescriptor.getName().asString()));
+                    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()));
                 }
             }
-            JetType type = results.getResultingDescriptor().getReturnType();
+            else {
-            assert type != null : "No return type for " + results.getResultingDescriptor();
+                trace.report(Errors.NOT_AN_ANNOTATION_CLASS.on(entryElement, descriptor.getName().asString()));
-            return type;
+            }
-        }
-        else {
-            JetConstructorCalleeExpression calleeExpression = entryElement.getCalleeExpression();
-            return ErrorUtils.createErrorType("Unresolved annotation type: " +
-                                              (calleeExpression == null ? "null" : calleeExpression.getText()));
         }
     }
 
@@ -230,6 +225,7 @@ public class AnnotationResolver {
 
         OverloadResolutionResults<FunctionDescriptor> results = resolveAnnotationCall(annotationEntry, scope, trace);
         if (results.isSingleResult()) {
+            checkAnnotationType(annotationEntry, trace, results);
             resolveAnnotationArguments(annotationDescriptor, results.getResultingCall(), trace);
         }
     }

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 <class-object-for-SomeObject> : test.SomeObject {

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

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