Create proper annotation descriptors when annotation arguments don't match

compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnnotationResolver.java

@@ -118,7 +118,7 @@ public class AnnotationResolver {
     ) {
         TemporaryBindingTrace temporaryBindingTrace = new TemporaryBindingTrace(trace, "Trace for resolve annotation type");
         OverloadResolutionResults<FunctionDescriptor> results = resolveAnnotationCall(entryElement, scope, temporaryBindingTrace);
-        if (results.isSuccess()) {
+        if (results.isSingleResult()) {
             FunctionDescriptor descriptor = results.getResultingDescriptor();
             if (!ErrorUtils.isError(descriptor)) {
                 if (descriptor instanceof ConstructorDescriptor) {
@@ -136,7 +136,9 @@ public class AnnotationResolver {
             annotationDescriptor.setAnnotationType(annotationType);
         }
         else {
-            annotationDescriptor.setAnnotationType(ErrorUtils.createErrorType("Unresolved annotation type"));
+            JetConstructorCalleeExpression calleeExpression = entryElement.getCalleeExpression();
+            annotationDescriptor.setAnnotationType(ErrorUtils.createErrorType("Unresolved annotation type: " +
+                                                                              (calleeExpression == null ? "null" : calleeExpression.getText())));
         }
     }
 
@@ -176,7 +178,7 @@ public class AnnotationResolver {
             @NotNull BindingTrace trace
     ) {
         OverloadResolutionResults<FunctionDescriptor> results = resolveAnnotationCall(annotationEntry, scope, trace);
-        if (results.isSuccess()) {
+        if (results.isSingleResult()) {
             AnnotationDescriptor annotationDescriptor = trace.getBindingContext().get(BindingContext.ANNOTATION, annotationEntry);
             assert annotationDescriptor != null : "Annotation descriptor should be created before resolving arguments for " + annotationEntry.getText();
             resolveAnnotationArgument(annotationDescriptor, results.getResultingCall(), trace);

compiler/testData/lazyResolve/namespaceComparator/UnresolvedAnnotationOnObject.txt

@@ -1,8 +1,8 @@
 package test
 
-[ERROR : Unresolved annotation type]() internal val SomeObject: test.SomeObject
+[ERROR : Unresolved annotation type: BadAnnotation]() internal val SomeObject: test.SomeObject
 internal val some: test.SomeObject
 
-[ERROR : Unresolved annotation type]() internal object SomeObject {
+[ERROR : Unresolved annotation type: BadAnnotation]() internal object SomeObject {
     /*primary*/ private constructor SomeObject()
 }

compiler/testData/lazyResolve/namespaceComparator/WrongAnnotationArgsOnObject.kt

@@ -0,0 +1,8 @@
+package test
+
+BadAnnotation(1)
+object SomeObject
+
+val some = SomeObject
+
+annotation class BadAnnotation(s: String)

compiler/testData/lazyResolve/namespaceComparator/WrongAnnotationArgsOnObject.txt

@@ -0,0 +1,12 @@
+package test
+
+test.BadAnnotation(s = 1.toInt(): jet.Int) internal val SomeObject: test.SomeObject
+internal val some: test.SomeObject
+
+internal final annotation class BadAnnotation : jet.Annotation {
+    /*primary*/ public constructor BadAnnotation(/*0*/ s: jet.String)
+}
+
+test.BadAnnotation(s = 1.toInt(): jet.Int) internal object SomeObject {
+    /*primary*/ private constructor SomeObject()
+}

compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java

@@ -2409,6 +2409,11 @@ public class LazyResolveNamespaceComparingTestGenerated extends AbstractLazyReso
             doTestCheckingPrimaryConstructors("compiler/testData/lazyResolve/namespaceComparator/varargIterator.kt");
         }
         
+        @TestMetadata("WrongAnnotationArgsOnObject.kt")
+        public void testWrongAnnotationArgsOnObject() throws Exception {
+            doTestCheckingPrimaryConstructors("compiler/testData/lazyResolve/namespaceComparator/WrongAnnotationArgsOnObject.kt");
+        }
+        
     }
     
     public static Test suite() {