Additional resolve for annotations in lazy resolve

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSessionUtils.java

@@ -27,6 +27,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.di.InjectorForBodyResolve;
 import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.descriptors.annotations.Annotated;
 import org.jetbrains.jet.lang.descriptors.impl.ClassDescriptorBase;
 import org.jetbrains.jet.lang.descriptors.impl.MutableClassDescriptor;
 import org.jetbrains.jet.lang.psi.*;
@@ -119,15 +120,17 @@ public class ResolveSessionUtils {
     ) {
         DelegatingBindingTrace trace = new DelegatingBindingTrace(
                 resolveSession.getBindingContext(), "trace to resolve jetElement", jetElement);
-        JetFile file = (JetFile) jetElement.getContainingFile();
 
+        // All additional resolve should be done to separate trace
         @SuppressWarnings("unchecked")
         PsiElement topmostCandidateForAdditionalResolve = JetPsiUtil.getTopmostParentOfTypes(jetElement,
                 JetNamedFunction.class, JetClassInitializer.class,
                 JetProperty.class, JetDelegationSpecifierList.class,
-                JetImportDirective.class);
+                JetImportDirective.class, JetAnnotationEntry.class);
 
         if (topmostCandidateForAdditionalResolve != null) {
+            JetFile file = (JetFile) jetElement.getContainingFile();
+
             if (topmostCandidateForAdditionalResolve instanceof JetNamedFunction) {
                 functionAdditionalResolve(resolveSession, (JetNamedFunction) topmostCandidateForAdditionalResolve, trace, file);
             }
@@ -148,6 +151,10 @@ public class ResolveSessionUtils {
                 // Get all descriptors to force resolving all imports
                 scope.getAllDescriptors();
             }
+            else if (topmostCandidateForAdditionalResolve instanceof JetAnnotationEntry) {
+                annotationAdditionalResolve(resolveSession, (JetAnnotationEntry) topmostCandidateForAdditionalResolve);
+                return resolveSession.getBindingContext();
+            }
             else {
                 assert false : "Invalid type of the topmost parent";
             }
@@ -169,6 +176,16 @@ public class ResolveSessionUtils {
         return trace.getBindingContext();
     }
 
+    private static void annotationAdditionalResolve(KotlinCodeAnalyzer analyzer, JetAnnotationEntry jetAnnotationEntry) {
+        JetDeclaration declaration = PsiTreeUtil.getParentOfType(jetAnnotationEntry, JetDeclaration.class);
+        if (declaration != null) {
+            Annotated descriptor = analyzer.resolveToDescriptor(declaration);
+
+            // Activate annotation resolving
+            descriptor.getAnnotations();
+        }
+    }
+
     private static void delegationSpecifierAdditionalResolve(
             KotlinCodeAnalyzer analyzer,
             JetDelegationSpecifierList specifier, DelegatingBindingTrace trace, JetFile file) {

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyClassDescriptor.java

@@ -352,7 +352,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements LazyDesc
         if (modifierList != null) {
             AnnotationResolver annotationResolver = resolveSession.getInjector().getAnnotationResolver();
             JetScope scopeForDeclaration = getScopeProvider().getResolutionScopeForDeclaration(classInfo.getScopeAnchor());
-            return annotationResolver.resolveAnnotations(scopeForDeclaration, modifierList, resolveSession.getTrace());
+            return annotationResolver.resolveAnnotationsWithArguments(scopeForDeclaration, modifierList, resolveSession.getTrace());
         }
         else {
             return Collections.emptyList();

idea/testData/resolve/references/AnnotationForClass.kt

@@ -0,0 +1,7 @@
+package test
+
+annotation class Annotation
+
+<caret>Annotation class Some
+
+// REF: (test).Annotation

idea/testData/resolve/references/AnnotationInsideFunction.kt

@@ -0,0 +1,10 @@
+package test
+
+annotation class Annotation
+
+fun test() {
+  <caret>Annotation fun some() {
+  }
+}
+
+// REF: (test).Annotation

idea/testData/resolve/references/AnnotationParameter.kt

@@ -0,0 +1,9 @@
+package testing
+
+annotation class Annotation<T>(val clazz: Class<T>)
+class ATest
+
+[Annotation<ATest>(javaClass<<caret>ATest>())]
+class BTest
+
+// REF: (testing).ATest

idea/testData/resolve/references/AnnotationTypeParameter.kt

@@ -0,0 +1,9 @@
+package testing
+
+annotation class Annotation<T>(val clazz: Class<T>)
+class ATest
+
+[Annotation<<caret>ATest>(javaClass<ATest>())]
+class BTest
+
+// REF: (testing).ATest

idea/tests/org/jetbrains/jet/resolve/ReferenceResolveTestGenerated.java

@@ -36,6 +36,26 @@ public class ReferenceResolveTestGenerated extends AbstractResolveBaseTest {
         JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("idea/testData/resolve/references"), Pattern.compile("^(.+)\\.kt$"), true);
     }
     
+    @TestMetadata("AnnotationForClass.kt")
+    public void testAnnotationForClass() throws Exception {
+        doTest("idea/testData/resolve/references/AnnotationForClass.kt");
+    }
+    
+    @TestMetadata("AnnotationInsideFunction.kt")
+    public void testAnnotationInsideFunction() throws Exception {
+        doTest("idea/testData/resolve/references/AnnotationInsideFunction.kt");
+    }
+    
+    @TestMetadata("AnnotationParameter.kt")
+    public void testAnnotationParameter() throws Exception {
+        doTest("idea/testData/resolve/references/AnnotationParameter.kt");
+    }
+    
+    @TestMetadata("AnnotationTypeParameter.kt")
+    public void testAnnotationTypeParameter() throws Exception {
+        doTest("idea/testData/resolve/references/AnnotationTypeParameter.kt");
+    }
+    
     @TestMetadata("ClassReferenceInImport.kt")
     public void testClassReferenceInImport() throws Exception {
         doTest("idea/testData/resolve/references/ClassReferenceInImport.kt");