Make room for laziness in the Annotations interface

compiler/backend/src/org/jetbrains/jet/codegen/PropertyCodegen.java

@@ -149,7 +149,7 @@ public class PropertyCodegen extends GenerationStateAware {
     // Annotations on properties without backing fields are stored in bytecode on an empty synthetic method. This way they're still
     // accessible via reflection, and 'deprecated' and 'private' flags prevent this method from being called accidentally
     private void generateSyntheticMethodIfNeeded(@NotNull PropertyDescriptor descriptor) {
-        if (descriptor.getAnnotations().getAnnotationDescriptors().isEmpty()) return;
+        if (descriptor.getAnnotations().isEmpty()) return;
 
         ReceiverParameterDescriptor receiver = descriptor.getReceiverParameter();
         Type receiverAsmType = receiver == null ? null : typeMapper.mapType(receiver.getType());

compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/DescriptorSerializer.java

@@ -431,7 +431,7 @@ public class DescriptorSerializer {
     }
 
     private static boolean hasAnnotations(Annotated descriptor) {
-        return !descriptor.getAnnotations().getAnnotationDescriptors().isEmpty();
+        return !descriptor.getAnnotations().isEmpty();
     }
 
     @NotNull

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

@@ -155,7 +155,7 @@ public class DeclarationResolver {
             if (modifierList != null) {
                 MutableClassDescriptor descriptor = entry.getValue();
                 descriptor.addAnnotations(annotationResolver.resolveAnnotationsWithoutArguments(
-                        descriptor.getScopeForSupertypeResolution(), modifierList, trace).getAnnotationDescriptors());
+                        descriptor.getScopeForSupertypeResolution(), modifierList, trace));
             }
         }
     }

core/descriptors/src/org/jetbrains/jet/lang/descriptors/annotations/Annotations.java

@@ -17,28 +17,23 @@
 package org.jetbrains.jet.lang.descriptors.annotations;
 
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.ReadOnly;
 
 import java.util.Collections;
 import java.util.Iterator;
-import java.util.List;
 
 public interface Annotations extends Iterable<AnnotationDescriptor> {
     Annotations EMPTY = new Annotations() {
-        @NotNull
         @Override
-        public List<AnnotationDescriptor> getAnnotationDescriptors() {
+        public boolean isEmpty() {
-            return Collections.emptyList();
+            return true;
         }
 
         @NotNull
         @Override
         public Iterator<AnnotationDescriptor> iterator() {
-            return getAnnotationDescriptors().iterator();
+            return Collections.<AnnotationDescriptor>emptyList().iterator();
         }
     };
 
-    @NotNull
+    boolean isEmpty();
-    @ReadOnly
-    List<AnnotationDescriptor> getAnnotationDescriptors();
 }

core/descriptors/src/org/jetbrains/jet/lang/descriptors/annotations/AnnotationsImpl.java

@@ -29,11 +29,15 @@ public class AnnotationsImpl implements Annotations {
     }
 
     @NotNull
-    @Override
     public List<AnnotationDescriptor> getAnnotationDescriptors() {
         return annotations;
     }
 
+    @Override
+    public boolean isEmpty() {
+        return getAnnotationDescriptors().isEmpty();
+    }
+
     @NotNull
     @Override
     public Iterator<AnnotationDescriptor> iterator() {

core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/MutableClassDescriptorLite.java

@@ -39,7 +39,7 @@ import java.util.List;
 
 public abstract class MutableClassDescriptorLite extends ClassDescriptorBase {
 
-    private Annotations annotations = new AnnotationsImpl(new ArrayList<AnnotationDescriptor>(0));
+    private Annotations annotations;
 
     private List<TypeParameterDescriptor> typeParameters;
     private Collection<JetType> supertypes = Lists.newArrayList();
@@ -183,6 +183,9 @@ public abstract class MutableClassDescriptorLite extends ClassDescriptorBase {
     @NotNull
     @Override
     public Annotations getAnnotations() {
+        if (annotations == null) {
+            annotations = new AnnotationsImpl(new ArrayList<AnnotationDescriptor>(0));
+        }
         return annotations;
     }
 
@@ -190,8 +193,12 @@ public abstract class MutableClassDescriptorLite extends ClassDescriptorBase {
         this.annotations = annotations;
     }
 
-    public void addAnnotations(@NotNull List<AnnotationDescriptor> annotationDescriptors) {
+    public void addAnnotations(@NotNull Iterable<AnnotationDescriptor> annotationDescriptors) {
-        this.annotations.getAnnotationDescriptors().addAll(annotationDescriptors);
+
+        AnnotationsImpl annotationsImpl = (AnnotationsImpl) getAnnotations();
+        for (AnnotationDescriptor annotationDescriptor : annotationDescriptors) {
+            annotationsImpl.getAnnotationDescriptors().add(annotationDescriptor);
+        }
     }
 
     private PackageLikeBuilder builder = null;

idea/src/org/jetbrains/jet/plugin/project/ResolveElementCache.java

@@ -29,6 +29,7 @@ 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.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.MutableClassDescriptor;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.*;
@@ -216,7 +217,9 @@ public class ResolveElementCache {
             Annotated descriptor = analyzer.resolveToDescriptor(declaration);
 
             // Activate annotation resolving
-            descriptor.getAnnotations().getAnnotationDescriptors();
+            for (AnnotationDescriptor annotationDescriptor : descriptor.getAnnotations()) {
+                // do nothing, all we need is iteration
+            }
         }
     }