Frontend: added the support file annotations to LazyTopDownAnalyzer.

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

@@ -23,7 +23,6 @@ import kotlin.KotlinPackage;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.descriptors.annotations.Annotated;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.descriptors.annotations.Annotations;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationsImpl;
@@ -42,7 +41,7 @@ import org.jetbrains.jet.lang.resolve.constants.ArrayValue;
 import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
 import org.jetbrains.jet.lang.resolve.constants.IntegerValueTypeConstant;
 import org.jetbrains.jet.lang.resolve.lazy.descriptors.LazyAnnotationDescriptor;
-import org.jetbrains.jet.lang.resolve.lazy.descriptors.LazyAnnotationsContext;
+import org.jetbrains.jet.lang.resolve.lazy.descriptors.LazyAnnotationsContextImpl;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.jet.lang.types.ErrorUtils;
@@ -123,7 +122,7 @@ public class AnnotationResolver {
     }
 
     private Annotations resolveAnnotationEntries(
-            @NotNull final JetScope scope,
+            @NotNull JetScope scope,
             @NotNull List<JetAnnotationEntry> annotationEntryElements,
             @NotNull BindingTrace trace,
             boolean shouldResolveArguments
@@ -133,17 +132,7 @@ public class AnnotationResolver {
         for (JetAnnotationEntry entryElement : annotationEntryElements) {
             AnnotationDescriptor descriptor = trace.get(BindingContext.ANNOTATION, entryElement);
             if (descriptor == null) {
-                descriptor = new LazyAnnotationDescriptor(
+                descriptor = new LazyAnnotationDescriptor(new LazyAnnotationsContextImpl(this, storageManager, trace, scope), entryElement);
-                        new LazyAnnotationsContext(this, storageManager, trace) {
-
-                            @NotNull
-                            @Override
-                            public JetScope getScope() {
-                                return scope;
-                            }
-                        },
-                        entryElement
-                );
             }
             if (shouldResolveArguments) {
                 resolveAnnotationArguments(entryElement, trace);
@@ -210,8 +199,8 @@ public class AnnotationResolver {
         }
     }
 
-    public static void resolveAnnotationsArguments(@NotNull Annotated descriptor, @NotNull BindingTrace trace) {
+    public static void resolveAnnotationsArguments(@NotNull Annotations annotations, @NotNull BindingTrace trace) {
-        for (AnnotationDescriptor annotationDescriptor : descriptor.getAnnotations()) {
+        for (AnnotationDescriptor annotationDescriptor : annotations) {
             JetAnnotationEntry annotationEntry = trace.getBindingContext().get(ANNOTATION_DESCRIPTOR_TO_PSI_ELEMENT, annotationDescriptor);
             assert annotationEntry != null : "Cannot find annotation entry: " + annotationDescriptor;
             resolveAnnotationArguments(annotationEntry, trace);

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

@@ -34,6 +34,7 @@ import org.jetbrains.jet.lang.diagnostics.Errors;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.calls.CallsPackage;
 import org.jetbrains.jet.lang.resolve.lazy.KotlinCodeAnalyzer;
+import org.jetbrains.jet.lang.resolve.lazy.ScopeProvider;
 import org.jetbrains.jet.lang.resolve.lazy.descriptors.LazyPackageDescriptor;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
@@ -41,6 +42,7 @@ import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 import org.jetbrains.jet.renderer.DescriptorRenderer;
+import org.jetbrains.jet.utils.UtilsPackage;
 
 import javax.inject.Inject;
 import java.util.*;
@@ -97,6 +99,17 @@ public class DeclarationResolver {
         checkRedeclarationsInInnerClassNames(c);
     }
 
+    public void resolveAnnotationsOnFiles(@NotNull TopDownAnalysisContext c, @NotNull final ScopeProvider scopeProvider) {
+        Map<JetFile, JetScope> file2scope = UtilsPackage.keysToMap(c.getFiles(), new Function1<JetFile, JetScope>() {
+            @Override
+            public JetScope invoke(JetFile file) {
+                return scopeProvider.getFileScope(file);
+            }
+        });
+
+        resolveAnnotationsOnFiles(file2scope);
+    }
+
     private void resolveAnnotationsOnFiles(@NotNull Map<JetFile, ? extends JetScope> file2scope) {
         for (Map.Entry<JetFile, ? extends JetScope> entry : file2scope.entrySet()) {
             JetFile file = entry.getKey();

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

@@ -263,6 +263,8 @@ public class LazyTopDownAnalyzer {
 
         resolveImportsInAllFiles(c, resolveSession);
 
+        declarationResolver.resolveAnnotationsOnFiles(c, resolveSession.getScopeProvider());
+
         overloadResolver.process(c);
 
         bodyResolver.resolveBodies(c);

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

@@ -28,6 +28,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.ReadOnly;
 import org.jetbrains.jet.context.GlobalContext;
 import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.descriptors.annotations.Annotations;
 import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.*;
@@ -35,9 +36,7 @@ import org.jetbrains.jet.lang.resolve.lazy.data.JetClassLikeInfo;
 import org.jetbrains.jet.lang.resolve.lazy.data.JetScriptInfo;
 import org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProviderFactory;
 import org.jetbrains.jet.lang.resolve.lazy.declarations.PackageMemberDeclarationProvider;
-import org.jetbrains.jet.lang.resolve.lazy.descriptors.LazyClassDescriptor;
+import org.jetbrains.jet.lang.resolve.lazy.descriptors.*;
-import org.jetbrains.jet.lang.resolve.lazy.descriptors.LazyPackageDescriptor;
-import org.jetbrains.jet.lang.resolve.lazy.descriptors.LazyScriptDescriptor;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
@@ -63,6 +62,8 @@ public class ResolveSession implements KotlinCodeAnalyzer {
 
     private final MemoizedFunctionToNotNull<JetScript, LazyScriptDescriptor> scriptDescriptors;
 
+    private final MemoizedFunctionToNotNull<JetFile, LazyAnnotations> annotations;
+
     private ScopeProvider scopeProvider;
 
     private JetImportsFactory jetImportFactory;
@@ -164,6 +165,15 @@ public class ResolveSession implements KotlinCodeAnalyzer {
                     }
                 }
         );
+
+        annotations = storageManager.createMemoizedFunction(new Function1<JetFile, LazyAnnotations>() {
+            @Override
+            public LazyAnnotations invoke(JetFile file) {
+                JetScope scope = getScopeProvider().getFileScope(file);
+                LazyAnnotationsContextImpl lazyAnnotationContext = new LazyAnnotationsContextImpl(annotationResolve, storageManager, trace, scope);
+                return new LazyAnnotations(lazyAnnotationContext, file.getAnnotationEntries());
+            }
+        });
     }
 
     @NotNull
@@ -420,6 +430,11 @@ public class ResolveSession implements KotlinCodeAnalyzer {
         return result;
     }
 
+    @NotNull
+    public Annotations getFileAnnotations(@NotNull JetFile file) {
+        return annotations.invoke(file);
+    }
+
     @NotNull
     private List<LazyPackageDescriptor> getAllPackages() {
         LazyPackageDescriptor rootPackage = getPackageFragment(FqName.ROOT);

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

@@ -184,7 +184,7 @@ public abstract class AbstractLazyMemberScope<D extends DeclarationDescriptor, D
                            DataFlowInfo.EMPTY
                     );
             result.add(propertyDescriptor);
-            AnnotationResolver.resolveAnnotationsArguments(propertyDescriptor, trace);
+            AnnotationResolver.resolveAnnotationsArguments(propertyDescriptor.getAnnotations(), trace);
         }
 
         getNonDeclaredProperties(name, result);

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyAnnotations.kt

@@ -40,6 +40,13 @@ abstract class LazyAnnotationsContext(
     abstract val scope: JetScope
 }
 
+class LazyAnnotationsContextImpl(
+        annotationResolver: AnnotationResolver,
+        storageManager: StorageManager,
+        trace: BindingTrace,
+        override val scope: JetScope
+) : LazyAnnotationsContext(annotationResolver, storageManager, trace)
+
 public class LazyAnnotations(
         val c: LazyAnnotationsContext,
         val annotationEntries: List<JetAnnotationEntry>
@@ -133,4 +140,4 @@ public class LazyAnnotationDescriptor(
         ForceResolveUtil.forceResolveAllContents(getType())
         getAllValueArguments()
     }
-}
+}

idea/ide-lazy-resolve/src/org/jetbrains/jet/lang/resolve/lazy/ElementResolver.java

@@ -28,6 +28,7 @@ import org.jetbrains.jet.di.InjectorForBodyResolve;
 import org.jetbrains.jet.lang.cfg.JetFlowInformationProvider;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.Annotated;
+import org.jetbrains.jet.lang.descriptors.annotations.Annotations;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.*;
 import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo;
@@ -231,16 +232,23 @@ public class ElementResolver {
     }
 
     private static void annotationAdditionalResolve(ResolveSession resolveSession, JetAnnotationEntry jetAnnotationEntry) {
+        Annotations annotations = null;
+
         JetDeclaration declaration = PsiTreeUtil.getParentOfType(jetAnnotationEntry, JetDeclaration.class);
         if (declaration != null) {
             Annotated descriptor = resolveSession.resolveToDescriptor(declaration);
+            annotations = descriptor.getAnnotations();
+        }
+        else {
+            JetFileAnnotationList fileAnnotationList = PsiTreeUtil.getParentOfType(jetAnnotationEntry, JetFileAnnotationList.class);
+            if (fileAnnotationList != null) {
+                annotations = resolveSession.getFileAnnotations(fileAnnotationList.getContainingJetFile());
+            }
+        }
 
-            AnnotationResolver.resolveAnnotationsArguments(
+        if (annotations != null) {
-                    descriptor,
+            AnnotationResolver.resolveAnnotationsArguments(annotations, resolveSession.getTrace());
-                    resolveSession.getTrace()
+            ForceResolveUtil.forceResolveAllContents(annotations);
-            );
-
-            ForceResolveUtil.forceResolveAllContents(descriptor.getAnnotations());
         }
     }
 

idea/testData/checker/AnnotationOnFile.kt

@@ -0,0 +1,22 @@
+[file: kotlin.deprecated("message")]
+[file: suppress(<error>BAR</error>)]
+[file: suppress(BAZ)]
+
+[<error>k</error>otlin.deprecated("message")]
+[<error>s</error>uppress(<error>BAR</error>)]
+[<error>s</error>uppress(BAZ)]
+
+[file: myAnnotation(1, "string")]
+[file: boo.myAnnotation(1, <error>BAR</error>)]
+[file: myAnnotation(N, BAZ)]
+
+[<error>m</error>yAnnotation(1, "string")]
+[<error>b</error>oo.myAnnotation(1, "string")]
+[<error>m</error>yAnnotation(N, BAZ)]
+
+package boo
+
+val BAZ = "baz"
+val N = 0
+
+annotation class myAnnotation(val i: Int, val s: String)

idea/testData/resolve/references/AnnotationOnFile.kt

@@ -0,0 +1,5 @@
+[file: kotlin.<caret>deprecated("message")]
+
+package foo
+
+// REF: (kotlin).deprecated

idea/testData/resolve/references/AnnotationOnFileWithImport.kt

@@ -0,0 +1,7 @@
+[file: <caret>D("message")]
+
+package foo
+
+import kotlin.deprecated as D
+
+// REF: (kotlin).deprecated

idea/tests/org/jetbrains/jet/checkers/JetPsiCheckerTestGenerated.java

@@ -47,6 +47,12 @@ public class JetPsiCheckerTestGenerated extends AbstractJetPsiCheckerTest {
             JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/checker"), Pattern.compile("^(.+)\\.kt$"), false);
         }
         
+        @TestMetadata("AnnotationOnFile.kt")
+        public void testAnnotationOnFile() throws Exception {
+            String fileName = JetTestUtils.navigationMetadata("idea/testData/checker/AnnotationOnFile.kt");
+            doTest(fileName);
+        }
+        
         @TestMetadata("AnonymousInitializers.kt")
         public void testAnonymousInitializers() throws Exception {
             String fileName = JetTestUtils.navigationMetadata("idea/testData/checker/AnonymousInitializers.kt");

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

@@ -51,6 +51,18 @@ public class ReferenceResolveTestGenerated extends AbstractReferenceResolveTest
         doTest(fileName);
     }
     
+    @TestMetadata("AnnotationOnFile.kt")
+    public void testAnnotationOnFile() throws Exception {
+        String fileName = JetTestUtils.navigationMetadata("idea/testData/resolve/references/AnnotationOnFile.kt");
+        doTest(fileName);
+    }
+    
+    @TestMetadata("AnnotationOnFileWithImport.kt")
+    public void testAnnotationOnFileWithImport() throws Exception {
+        String fileName = JetTestUtils.navigationMetadata("idea/testData/resolve/references/AnnotationOnFileWithImport.kt");
+        doTest(fileName);
+    }
+    
     @TestMetadata("AnnotationParameter.kt")
     public void testAnnotationParameter() throws Exception {
         String fileName = JetTestUtils.navigationMetadata("idea/testData/resolve/references/AnnotationParameter.kt");