Annotations used instead of List<AnnotationDescriptor>

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

@@ -18,7 +18,7 @@ package org.jetbrains.jet.codegen;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.descriptors.annotations.Annotations;
 import org.jetbrains.jet.lang.descriptors.impl.SimpleFunctionDescriptorImpl;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.name.Name;
@@ -35,7 +35,7 @@ public class AccessorForFunctionDescriptor extends SimpleFunctionDescriptorImpl
             @NotNull DeclarationDescriptor containingDeclaration,
             int index
     ) {
-        super(containingDeclaration, Collections.<AnnotationDescriptor>emptyList(),
+        super(containingDeclaration, Annotations.EMPTY,
               Name.identifier((descriptor instanceof ConstructorDescriptor ? "$init" : descriptor.getName()) + "$b$" + index),
               Kind.DECLARATION);
 

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

@@ -19,7 +19,7 @@ package org.jetbrains.jet.codegen;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.descriptors.annotations.Annotations;
 import org.jetbrains.jet.lang.descriptors.impl.PropertyDescriptorImpl;
 import org.jetbrains.jet.lang.descriptors.impl.PropertyGetterDescriptorImpl;
 import org.jetbrains.jet.lang.descriptors.impl.PropertySetterDescriptorImpl;
@@ -43,7 +43,7 @@ public class AccessorForPropertyDescriptor extends PropertyDescriptorImpl {
             @NotNull DeclarationDescriptor containingDeclaration,
             int index
     ) {
-        super(containingDeclaration, Collections.<AnnotationDescriptor>emptyList(), Modality.FINAL, Visibilities.LOCAL,
+        super(containingDeclaration, Annotations.EMPTY, Modality.FINAL, Visibilities.LOCAL,
               original.isVar(), Name.identifier(original.getName() + "$b$" + index),
               Kind.DECLARATION);
 
@@ -53,7 +53,7 @@ public class AccessorForPropertyDescriptor extends PropertyDescriptorImpl {
 
     public static class Getter extends PropertyGetterDescriptorImpl {
         public Getter(AccessorForPropertyDescriptor property) {
-            super(property, Collections.<AnnotationDescriptor>emptyList(), Modality.FINAL, Visibilities.LOCAL,
+            super(property, Annotations.EMPTY, Modality.FINAL, Visibilities.LOCAL,
                   false,
                   false, Kind.DECLARATION);
             initialize(property.getType());
@@ -62,7 +62,7 @@ public class AccessorForPropertyDescriptor extends PropertyDescriptorImpl {
 
     public static class Setter extends PropertySetterDescriptorImpl {
         public Setter(AccessorForPropertyDescriptor property) {
-            super(property, Collections.<AnnotationDescriptor>emptyList(), Modality.FINAL, Visibilities.LOCAL,
+            super(property, Annotations.EMPTY, Modality.FINAL, Visibilities.LOCAL,
                   false,
                   false, Kind.DECLARATION);
             initializeDefault();

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

@@ -23,7 +23,7 @@ import org.jetbrains.asm4.Type;
 import org.jetbrains.jet.codegen.context.ClassContext;
 import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.descriptors.annotations.Annotations;
 import org.jetbrains.jet.lang.descriptors.impl.SimpleFunctionDescriptorImpl;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
@@ -180,7 +180,7 @@ public abstract class ClassBodyCodegen extends MemberCodegen {
             MethodVisitor method = createOrGetClInitMethod();
             method.visitCode();
             SimpleFunctionDescriptorImpl clInit =
-                    new SimpleFunctionDescriptorImpl(descriptor, Collections.<AnnotationDescriptor>emptyList(),
+                    new SimpleFunctionDescriptorImpl(descriptor, Annotations.EMPTY,
                                                      Name.special("<clinit>"),
                                                      CallableMemberDescriptor.Kind.SYNTHESIZED);
             clInit.initialize(null, null, Collections.<TypeParameterDescriptor>emptyList(),

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

@@ -28,7 +28,7 @@ import org.jetbrains.jet.codegen.context.CodegenContext;
 import org.jetbrains.jet.codegen.context.PackageContext;
 import org.jetbrains.jet.codegen.state.JetTypeMapper;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.descriptors.annotations.Annotations;
 import org.jetbrains.jet.lang.descriptors.impl.SimpleFunctionDescriptorImpl;
 import org.jetbrains.jet.lang.descriptors.impl.TypeParameterDescriptorImpl;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
@@ -67,7 +67,7 @@ public class CodegenUtil {
         SimpleFunctionDescriptorImpl invokeDescriptor = new SimpleFunctionDescriptorImpl(
                 fd.getExpectedThisObject() != null
                 ? KotlinBuiltIns.getInstance().getExtensionFunction(arity) : KotlinBuiltIns.getInstance().getFunction(arity),
-                Collections.<AnnotationDescriptor>emptyList(),
+                Annotations.EMPTY,
                 Name.identifier("invoke"),
                 CallableMemberDescriptor.Kind.DECLARATION);
 

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

@@ -25,7 +25,7 @@ import org.jetbrains.asm4.Type;
 import org.jetbrains.jet.codegen.context.FieldOwnerContext;
 import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.descriptors.annotations.Annotations;
 import org.jetbrains.jet.lang.descriptors.impl.SimpleFunctionDescriptorImpl;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
@@ -108,7 +108,7 @@ public class PackagePartCodegen extends MemberCodegen {
             FrameMap frameMap = new FrameMap();
 
             SimpleFunctionDescriptorImpl clInit =
-                    new SimpleFunctionDescriptorImpl(this.descriptor, Collections.<AnnotationDescriptor>emptyList(),
+                    new SimpleFunctionDescriptorImpl(this.descriptor, Annotations.EMPTY,
                                                      Name.special("<clinit>"),
                                                      CallableMemberDescriptor.Kind.SYNTHESIZED);
             clInit.initialize(null, null, Collections.<TypeParameterDescriptor>emptyList(),

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().isEmpty()) return;
+        if (descriptor.getAnnotations().getAnnotationDescriptors().isEmpty()) return;
 
         ReceiverParameterDescriptor receiver = descriptor.getReceiverParameter();
         Type receiverAsmType = receiver == null ? null : typeMapper.mapType(receiver.getType());

compiler/backend/src/org/jetbrains/jet/codegen/context/CodegenContext.java

@@ -26,7 +26,7 @@ import org.jetbrains.jet.codegen.binding.MutableClosure;
 import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.codegen.state.JetTypeMapper;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.descriptors.annotations.Annotations;
 import org.jetbrains.jet.lang.descriptors.impl.ConstructorDescriptorImpl;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
@@ -190,7 +190,7 @@ public abstract class CodegenContext<T extends DeclarationDescriptor> {
     @NotNull
     public ConstructorContext intoConstructor(@Nullable ConstructorDescriptor descriptor, @Nullable MutableClosure closure) {
         if (descriptor == null) {
-            descriptor = new ConstructorDescriptorImpl(getThisDescriptor(), Collections.<AnnotationDescriptor>emptyList(), true)
+            descriptor = new ConstructorDescriptorImpl(getThisDescriptor(), Annotations.EMPTY, true)
                     .initialize(Collections.<TypeParameterDescriptor>emptyList(), Collections.<ValueParameterDescriptor>emptyList(),
                                 Visibilities.PUBLIC);
         }

compiler/backend/src/org/jetbrains/jet/codegen/context/RootContext.java

@@ -20,12 +20,10 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.codegen.OwnerKind;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptorVisitor;
-import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.descriptors.annotations.Annotations;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.types.TypeSubstitutor;
 
-import java.util.List;
-
 class RootContext extends CodegenContext {
     public RootContext() {
         super(new FakeDescriptor(), OwnerKind.PACKAGE, null, null, null, null);
@@ -70,7 +68,7 @@ class RootContext extends CodegenContext {
 
         @NotNull
         @Override
-        public List<AnnotationDescriptor> getAnnotations() {
+        public Annotations getAnnotations() {
             throw new IllegalStateException();
         }
 

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

@@ -23,6 +23,8 @@ import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedSimpl
 import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedTypeParameterDescriptor;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.descriptors.annotations.Annotations;
+import org.jetbrains.jet.lang.descriptors.annotations.AnnotationsImpl;
 import org.jetbrains.jet.lang.descriptors.impl.*;
 import org.jetbrains.jet.lang.resolve.DescriptorFactory;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
@@ -248,11 +250,11 @@ public class DescriptorDeserializer {
     }
 
     @NotNull
-    private List<AnnotationDescriptor> getAnnotations(@NotNull Callable proto, int flags, @NotNull AnnotatedCallableKind kind) {
+    private Annotations getAnnotations(@NotNull Callable proto, int flags, @NotNull AnnotatedCallableKind kind) {
         return getAnnotations(containingDeclaration, proto, flags, kind, annotationDeserializer, nameResolver);
     }
 
-    public static List<AnnotationDescriptor> getAnnotations(
+    public static Annotations getAnnotations(
             @NotNull DeclarationDescriptor containingDeclaration,
             @NotNull Callable proto,
             int flags,
@@ -265,7 +267,7 @@ public class DescriptorDeserializer {
         return Flags.HAS_ANNOTATIONS.get(flags)
                ? annotationDeserializer
                        .loadCallableAnnotations((ClassOrPackageFragmentDescriptor) containingDeclaration, proto, nameResolver, kind)
-               : Collections.<AnnotationDescriptor>emptyList();
+               : Annotations.EMPTY;
     }
 
     public static CallableMemberDescriptor.Kind memberKind(Callable.MemberKind memberKind) {
@@ -393,7 +395,7 @@ public class DescriptorDeserializer {
     }
 
     @NotNull
-    private List<AnnotationDescriptor> getAnnotations(
+    private Annotations getAnnotations(
             @NotNull ClassOrPackageFragmentDescriptor classOrPackage,
             @NotNull Callable callable,
             @NotNull AnnotatedCallableKind kind,
@@ -401,6 +403,6 @@ public class DescriptorDeserializer {
     ) {
         return Flags.HAS_ANNOTATIONS.get(valueParameter.getFlags())
                ? annotationDeserializer.loadValueParameterAnnotations(classOrPackage, callable, nameResolver, kind, valueParameter)
-               : Collections.<AnnotationDescriptor>emptyList();
+               : Annotations.EMPTY;
     }
 }

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().isEmpty();
+        return !descriptor.getAnnotations().getAnnotationDescriptors().isEmpty();
     }
 
     @NotNull

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

@@ -25,7 +25,7 @@ import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedTypeP
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor;
 import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
-import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.descriptors.annotations.Annotations;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.types.*;
 import org.jetbrains.jet.storage.MemoizedFunctionToNullable;
@@ -270,8 +270,8 @@ public class TypeDeserializer {
 
         @NotNull
         @Override
-        public List<AnnotationDescriptor> getAnnotations() {
-            return Collections.emptyList();
+        public Annotations getAnnotations() {
+            return Annotations.EMPTY;
         }
     }
 }

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

@@ -21,21 +21,19 @@ import org.jetbrains.jet.descriptors.serialization.NameResolver;
 import org.jetbrains.jet.descriptors.serialization.ProtoBuf;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.ClassOrPackageFragmentDescriptor;
-import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
-
-import java.util.List;
+import org.jetbrains.jet.lang.descriptors.annotations.Annotations;
 
 public interface AnnotationDeserializer {
     AnnotationDeserializer UNSUPPORTED = new AnnotationDeserializer() {
         @NotNull
         @Override
-        public List<AnnotationDescriptor> loadClassAnnotations(@NotNull ClassDescriptor descriptor, @NotNull ProtoBuf.Class classProto) {
+        public Annotations loadClassAnnotations(@NotNull ClassDescriptor descriptor, @NotNull ProtoBuf.Class classProto) {
             return notSupported();
         }
 
         @NotNull
         @Override
-        public List<AnnotationDescriptor> loadCallableAnnotations(
+        public Annotations loadCallableAnnotations(
                 @NotNull ClassOrPackageFragmentDescriptor container,
                 @NotNull ProtoBuf.Callable proto,
                 @NotNull NameResolver nameResolver,
@@ -46,7 +44,7 @@ public interface AnnotationDeserializer {
 
         @NotNull
         @Override
-        public List<AnnotationDescriptor> loadValueParameterAnnotations(
+        public Annotations loadValueParameterAnnotations(
                 @NotNull ClassOrPackageFragmentDescriptor container,
                 @NotNull ProtoBuf.Callable callable,
                 @NotNull NameResolver nameResolver,
@@ -57,7 +55,7 @@ public interface AnnotationDeserializer {
         }
 
         @NotNull
-        private List<AnnotationDescriptor> notSupported() {
+        private Annotations notSupported() {
             throw new UnsupportedOperationException("Annotations are not supported");
         }
     };
@@ -70,10 +68,10 @@ public interface AnnotationDeserializer {
     }
 
     @NotNull
-    List<AnnotationDescriptor> loadClassAnnotations(@NotNull ClassDescriptor descriptor, @NotNull ProtoBuf.Class classProto);
+    Annotations loadClassAnnotations(@NotNull ClassDescriptor descriptor, @NotNull ProtoBuf.Class classProto);
 
     @NotNull
-    List<AnnotationDescriptor> loadCallableAnnotations(
+    Annotations loadCallableAnnotations(
             @NotNull ClassOrPackageFragmentDescriptor container,
             @NotNull ProtoBuf.Callable proto,
             @NotNull NameResolver nameResolver,
@@ -81,7 +79,7 @@ public interface AnnotationDeserializer {
     );
 
     @NotNull
-    List<AnnotationDescriptor> loadValueParameterAnnotations(
+    Annotations loadValueParameterAnnotations(
             @NotNull ClassOrPackageFragmentDescriptor container,
             @NotNull ProtoBuf.Callable callable,
             @NotNull NameResolver nameResolver,

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

@@ -24,6 +24,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.descriptors.serialization.*;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.descriptors.annotations.Annotations;
 import org.jetbrains.jet.lang.descriptors.impl.AbstractClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.ConstructorDescriptorImpl;
 import org.jetbrains.jet.lang.descriptors.impl.EnumEntrySyntheticClassDescriptor;
@@ -59,7 +60,7 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme
     private final NullableLazyValue<ConstructorDescriptor> primaryConstructor;
 
     private final AnnotationDeserializer annotationDeserializer;
-    private final NotNullLazyValue<List<AnnotationDescriptor>> annotations;
+    private final NotNullLazyValue<Annotations> annotations;
 
     private final NullableLazyValue<ClassDescriptor> classObjectDescriptor;
 
@@ -114,9 +115,9 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme
         this.isInner = Flags.INNER.get(flags);
 
         this.annotationDeserializer = annotationResolver;
-        this.annotations = storageManager.createLazyValue(new Function0<List<AnnotationDescriptor>>() {
+        this.annotations = storageManager.createLazyValue(new Function0<Annotations>() {
             @Override
-            public List<AnnotationDescriptor> invoke() {
+            public Annotations invoke() {
                 return computeAnnotations();
             }
         });
@@ -187,16 +188,16 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme
         return isInner;
     }
 
-    private List<AnnotationDescriptor> computeAnnotations() {
+    private Annotations computeAnnotations() {
         if (!Flags.HAS_ANNOTATIONS.get(classProto.getFlags())) {
-            return Collections.emptyList();
+            return Annotations.EMPTY;
         }
         return annotationDeserializer.loadClassAnnotations(this, classProto);
     }
 
     @NotNull
     @Override
-    public List<AnnotationDescriptor> getAnnotations() {
+    public Annotations getAnnotations() {
         return annotations.invoke();
     }
 
@@ -349,8 +350,8 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme
 
         @NotNull
         @Override
-        public List<AnnotationDescriptor> getAnnotations() {
-            return Collections.emptyList(); // TODO
+        public Annotations getAnnotations() {
+            return Annotations.EMPTY; // TODO
         }
 
         @Override

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

@@ -23,13 +23,11 @@ import org.jetbrains.jet.descriptors.serialization.NameResolver;
 import org.jetbrains.jet.descriptors.serialization.ProtoBuf;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptor;
-import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.descriptors.annotations.Annotations;
 import org.jetbrains.jet.lang.descriptors.impl.FunctionDescriptorImpl;
 import org.jetbrains.jet.lang.descriptors.impl.SimpleFunctionDescriptorImpl;
 import org.jetbrains.jet.lang.resolve.name.Name;
 
-import java.util.List;
-
 public class DeserializedSimpleFunctionDescriptor extends SimpleFunctionDescriptorImpl {
 
     private final ProtoBuf.Callable functionProto;
@@ -37,7 +35,7 @@ public class DeserializedSimpleFunctionDescriptor extends SimpleFunctionDescript
 
     private DeserializedSimpleFunctionDescriptor(
             @NotNull DeclarationDescriptor containingDeclaration,
-            @NotNull List<AnnotationDescriptor> annotations,
+            @NotNull Annotations annotations,
             @NotNull Name name,
             @NotNull Kind kind,
             @NotNull ProtoBuf.Callable functionProto,
@@ -51,7 +49,7 @@ public class DeserializedSimpleFunctionDescriptor extends SimpleFunctionDescript
     private DeserializedSimpleFunctionDescriptor(
             @NotNull DeclarationDescriptor containingDeclaration,
             @NotNull SimpleFunctionDescriptor original,
-            @NotNull List<AnnotationDescriptor> annotations,
+            @NotNull Annotations annotations,
             @NotNull Name name,
             @NotNull Kind kind,
             @NotNull ProtoBuf.Callable functionProto,

compiler/frontend/src/org/jetbrains/jet/lang/descriptors/impl/LocalVariableDescriptor.java

@@ -22,19 +22,17 @@ import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptorVisitor;
 import org.jetbrains.jet.lang.descriptors.Visibilities;
 import org.jetbrains.jet.lang.descriptors.Visibility;
-import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.descriptors.annotations.Annotations;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.TypeSubstitutor;
 
-import java.util.List;
-
 public class LocalVariableDescriptor extends VariableDescriptorImpl {
     private final boolean isVar;
 
     public LocalVariableDescriptor(
             @NotNull DeclarationDescriptor containingDeclaration,
-            @NotNull List<AnnotationDescriptor> annotations,
+            @NotNull Annotations annotations,
             @NotNull Name name,
             @Nullable JetType type,
             boolean mutable

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

@@ -20,9 +20,7 @@ import com.google.common.collect.Lists;
 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.AnnotationDescriptorImpl;
+import org.jetbrains.jet.lang.descriptors.annotations.*;
 import org.jetbrains.jet.lang.diagnostics.Errors;
 import org.jetbrains.jet.lang.evaluate.ConstantExpressionEvaluator;
 import org.jetbrains.jet.lang.psi.*;
@@ -67,7 +65,7 @@ public class AnnotationResolver {
     }
 
     @NotNull
-    public List<AnnotationDescriptor> resolveAnnotationsWithoutArguments(
+    public Annotations resolveAnnotationsWithoutArguments(
             @NotNull JetScope scope,
             @Nullable JetModifierList modifierList,
             @NotNull BindingTrace trace
@@ -76,7 +74,7 @@ public class AnnotationResolver {
     }
 
     @NotNull
-    public List<AnnotationDescriptor> resolveAnnotationsWithArguments(
+    public Annotations resolveAnnotationsWithArguments(
             @NotNull JetScope scope,
             @Nullable JetModifierList modifierList,
             @NotNull BindingTrace trace
@@ -85,7 +83,7 @@ public class AnnotationResolver {
     }
 
     @NotNull
-    public List<AnnotationDescriptor> resolveAnnotationsWithArguments(
+    public Annotations resolveAnnotationsWithArguments(
             @NotNull JetScope scope,
             @NotNull List<JetAnnotationEntry> annotationEntries,
             @NotNull BindingTrace trace
@@ -93,26 +91,26 @@ public class AnnotationResolver {
         return resolveAnnotationEntries(scope, annotationEntries, trace, true);
     }
 
-    private List<AnnotationDescriptor> resolveAnnotations(
+    private Annotations resolveAnnotations(
             @NotNull JetScope scope,
             @Nullable JetModifierList modifierList,
             @NotNull BindingTrace trace,
             boolean shouldResolveArguments
     ) {
         if (modifierList == null) {
-            return Collections.emptyList();
+            return Annotations.EMPTY;
         }
         List<JetAnnotationEntry> annotationEntryElements = modifierList.getAnnotationEntries();
 
         return resolveAnnotationEntries(scope, annotationEntryElements, trace, shouldResolveArguments);
     }
 
-    private List<AnnotationDescriptor> resolveAnnotationEntries(
+    private Annotations resolveAnnotationEntries(
             @NotNull JetScope scope,
             @NotNull List<JetAnnotationEntry> annotationEntryElements, @NotNull BindingTrace trace,
             boolean shouldResolveArguments
     ) {
-        if (annotationEntryElements.isEmpty()) return Collections.emptyList();
+        if (annotationEntryElements.isEmpty()) return Annotations.EMPTY;
         List<AnnotationDescriptor> result = Lists.newArrayList();
         for (JetAnnotationEntry entryElement : annotationEntryElements) {
             AnnotationDescriptorImpl descriptor = trace.get(BindingContext.ANNOTATION, entryElement);
@@ -128,7 +126,7 @@ public class AnnotationResolver {
 
             result.add(descriptor);
         }
-        return result;
+        return new AnnotationsImpl(result);
     }
 
     public void resolveAnnotationStub(
@@ -280,7 +278,7 @@ public class AnnotationResolver {
 
     @SuppressWarnings("MethodMayBeStatic")
     @NotNull
-    public List<AnnotationDescriptor> getResolvedAnnotations(@NotNull List<JetAnnotationEntry> annotations, @NotNull BindingTrace trace) {
+    public Annotations getResolvedAnnotations(@NotNull List<JetAnnotationEntry> annotations, @NotNull BindingTrace trace) {
         List<AnnotationDescriptor> result = new ArrayList<AnnotationDescriptor>(annotations.size());
         for (JetAnnotationEntry annotation : annotations) {
             AnnotationDescriptor annotationDescriptor = trace.get(BindingContext.ANNOTATION, annotation);
@@ -291,7 +289,7 @@ public class AnnotationResolver {
             result.add(annotationDescriptor);
         }
 
-        return result;
+        return new AnnotationsImpl(result);
     }
 
     public static void reportUnsupportedAnnotationForTypeParameter(@NotNull JetModifierListOwner modifierListOwner, BindingTrace trace) {

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

@@ -17,8 +17,11 @@
 package org.jetbrains.jet.lang.resolve;
 
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+import org.jetbrains.jet.lang.descriptors.PropertyDescriptor;
+import org.jetbrains.jet.lang.descriptors.VariableDescriptor;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.descriptors.annotations.Annotations;
 import org.jetbrains.jet.lang.psi.JetParameter;
 import org.jetbrains.jet.lang.psi.JetTypeReference;
 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall;
@@ -89,26 +92,22 @@ public class AnnotationUtils {
     }
 
     public static boolean isArrayMethodCall(@NotNull ResolvedCall resolvedCall) {
-        List<AnnotationDescriptor> annotations = resolvedCall.getResultingDescriptor().getOriginal().getAnnotations();
-        if (annotations != null) {
-            for (AnnotationDescriptor annotation : annotations) {
-                //noinspection ConstantConditions
-                if ("Intrinsic".equals(annotation.getType().getConstructor().getDeclarationDescriptor().getName().asString())) {
-                    return "kotlin.arrays.array".equals(annotation.getAllValueArguments().values().iterator().next().getValue());
-                }
+        Annotations annotations = resolvedCall.getResultingDescriptor().getOriginal().getAnnotations();
+        for (AnnotationDescriptor annotation : annotations) {
+            //noinspection ConstantConditions
+            if ("Intrinsic".equals(annotation.getType().getConstructor().getDeclarationDescriptor().getName().asString())) {
+                return "kotlin.arrays.array".equals(annotation.getAllValueArguments().values().iterator().next().getValue());
             }
         }
         return false;
     }
 
     public static boolean isJavaClassMethodCall(@NotNull ResolvedCall resolvedCall) {
-        List<AnnotationDescriptor> annotations = resolvedCall.getResultingDescriptor().getOriginal().getAnnotations();
-        if (annotations != null) {
-            for (AnnotationDescriptor annotation : annotations) {
-                //noinspection ConstantConditions
-                if ("Intrinsic".equals(annotation.getType().getConstructor().getDeclarationDescriptor().getName().asString())) {
-                    return "kotlin.javaClass.function".equals(annotation.getAllValueArguments().values().iterator().next().getValue());
-                }
+        Annotations annotations = resolvedCall.getResultingDescriptor().getOriginal().getAnnotations();
+        for (AnnotationDescriptor annotation : annotations) {
+            //noinspection ConstantConditions
+            if ("Intrinsic".equals(annotation.getType().getConstructor().getDeclarationDescriptor().getName().asString())) {
+                return "kotlin.javaClass.function".equals(annotation.getAllValueArguments().values().iterator().next().getValue());
             }
         }
         return false;

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

@@ -154,8 +154,8 @@ public class DeclarationResolver {
             JetModifierList modifierList = entry.getKey().getModifierList();
             if (modifierList != null) {
                 MutableClassDescriptor descriptor = entry.getValue();
-                descriptor.getAnnotations().addAll(annotationResolver.resolveAnnotationsWithoutArguments(
-                        descriptor.getScopeForSupertypeResolution(), modifierList, trace));
+                descriptor.addAnnotations(annotationResolver.resolveAnnotationsWithoutArguments(
+                        descriptor.getScopeForSupertypeResolution(), modifierList, trace).getAnnotationDescriptors());
             }
         }
     }

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

@@ -26,7 +26,7 @@ import jet.Function0;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.descriptors.annotations.Annotations;
 import org.jetbrains.jet.lang.descriptors.impl.*;
 import org.jetbrains.jet.lang.diagnostics.DiagnosticFactory1;
 import org.jetbrains.jet.lang.psi.*;
@@ -101,7 +101,7 @@ public class DescriptorResolver {
 
             TypeParameterDescriptor typeParameterDescriptor = TypeParameterDescriptorImpl.createForFurtherModification(
                     descriptor,
-                    Collections.<AnnotationDescriptor>emptyList(),
+                    Annotations.EMPTY,
                     typeParameter.hasModifier(JetTokens.REIFIED_KEYWORD),
                     typeParameter.getVariance(),
                     JetPsiUtil.safeName(typeParameter.getName()),
@@ -274,7 +274,7 @@ public class DescriptorResolver {
             @NotNull final JetNamedFunction function,
             @NotNull final BindingTrace trace,
             @NotNull final DataFlowInfo dataFlowInfo,
-            @NotNull List<AnnotationDescriptor> annotations
+            @NotNull Annotations annotations
     ) {
         final SimpleFunctionDescriptorImpl functionDescriptor = new SimpleFunctionDescriptorImpl(
                 containingDescriptor,
@@ -366,7 +366,7 @@ public class DescriptorResolver {
 
         SimpleFunctionDescriptorImpl functionDescriptor = new SimpleFunctionDescriptorImpl(
                 classDescriptor,
-                Collections.<AnnotationDescriptor>emptyList(),
+                Annotations.EMPTY,
                 Name.identifier(functionName),
                 CallableMemberDescriptor.Kind.SYNTHESIZED
         );
@@ -396,7 +396,7 @@ public class DescriptorResolver {
 
         SimpleFunctionDescriptorImpl functionDescriptor = new SimpleFunctionDescriptorImpl(
                 classDescriptor,
-                Collections.<AnnotationDescriptor>emptyList(),
+                Annotations.EMPTY,
                 COPY_METHOD_NAME,
                 CallableMemberDescriptor.Kind.SYNTHESIZED
         );
@@ -521,7 +521,7 @@ public class DescriptorResolver {
     private static ValueParameterDescriptorImpl resolveValueParameterDescriptor(
             DeclarationDescriptor declarationDescriptor,
             JetParameter valueParameter, int index, JetType type, BindingTrace trace,
-            List<AnnotationDescriptor> annotations
+            Annotations annotations
     ) {
         JetType varargElementType = null;
         JetType variableType = type;
@@ -574,7 +574,7 @@ public class DescriptorResolver {
 
         TypeParameterDescriptorImpl typeParameterDescriptor = TypeParameterDescriptorImpl.createForFurtherModification(
                 containingDescriptor,
-                Collections.<AnnotationDescriptor>emptyList(),
+                Annotations.EMPTY,
                 typeParameter.hasModifier(JetTokens.REIFIED_KEYWORD),
                 typeParameter.getVariance(),
                 JetPsiUtil.safeName(typeParameter.getName()),
@@ -1041,7 +1041,7 @@ public class DescriptorResolver {
         JetPropertyAccessor setter = property.getSetter();
         PropertySetterDescriptorImpl setterDescriptor = null;
         if (setter != null) {
-            List<AnnotationDescriptor> annotations =
+            Annotations annotations =
                     annotationResolver.resolveAnnotationsWithoutArguments(scope, setter.getModifierList(), trace);
             JetParameter parameter = setter.getParameter();
 
@@ -1109,7 +1109,7 @@ public class DescriptorResolver {
         PropertyGetterDescriptorImpl getterDescriptor;
         JetPropertyAccessor getter = property.getGetter();
         if (getter != null) {
-            List<AnnotationDescriptor> annotations =
+            Annotations annotations =
                     annotationResolver.resolveAnnotationsWithoutArguments(scope, getter.getModifierList(), trace);
 
             JetType outType = propertyDescriptor.getType();

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

@@ -23,7 +23,7 @@ import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor;
 import org.jetbrains.jet.lang.descriptors.ScriptDescriptor;
 import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor;
-import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.descriptors.annotations.Annotations;
 import org.jetbrains.jet.lang.descriptors.impl.ValueParameterDescriptorImpl;
 import org.jetbrains.jet.lang.parsing.JetScriptDefinition;
 import org.jetbrains.jet.lang.parsing.JetScriptDefinitionProvider;
@@ -43,7 +43,6 @@ import org.jetbrains.jet.lang.types.ref.JetTypeName;
 
 import javax.inject.Inject;
 import java.util.ArrayList;
-import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 
@@ -114,7 +113,7 @@ public class ScriptHeaderResolver {
             int index,
             @NotNull ScriptDescriptor script) {
         JetType type = resolveTypeName(scriptParameter.getType());
-        return new ValueParameterDescriptorImpl(script, index, Collections.<AnnotationDescriptor>emptyList(), scriptParameter.getName(), type, false, null);
+        return new ValueParameterDescriptorImpl(script, index, Annotations.EMPTY, scriptParameter.getName(), type, false, null);
     }
 
     public void processScriptHierarchy(@NotNull JetScript script, @NotNull JetScope outerScope) {

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

@@ -20,7 +20,7 @@ import jet.Function0;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.descriptors.annotations.Annotations;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.LazyScopeAdapter;
@@ -76,7 +76,7 @@ public class TypeResolver {
         JetType cachedType = c.trace.getBindingContext().get(BindingContext.TYPE, typeReference);
         if (cachedType != null) return type(cachedType);
 
-        List<AnnotationDescriptor> annotations = annotationResolver.getResolvedAnnotations(typeReference.getAnnotations(), c.trace);
+        Annotations annotations = annotationResolver.getResolvedAnnotations(typeReference.getAnnotations(), c.trace);
 
         JetTypeElement typeElement = typeReference.getTypeElement();
         PossiblyBareType type = resolveTypeElement(c, annotations, typeElement);
@@ -91,7 +91,7 @@ public class TypeResolver {
     @NotNull
     private PossiblyBareType resolveTypeElement(
             final TypeResolutionContext c,
-            final List<AnnotationDescriptor> annotations,
+            final Annotations annotations,
             JetTypeElement typeElement
     ) {
 

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ArgumentTypeResolver.java

@@ -20,7 +20,7 @@ import com.google.common.collect.Lists;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
-import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.descriptors.annotations.Annotations;
 import org.jetbrains.jet.lang.diagnostics.Errors;
 import org.jetbrains.jet.lang.evaluate.ConstantExpressionEvaluator;
 import org.jetbrains.jet.lang.psi.*;
@@ -213,7 +213,7 @@ public class ArgumentTypeResolver {
     ) {
         if (expression.getFunctionLiteral().getValueParameterList() == null) {
             return expectedTypeIsUnknown ? PLACEHOLDER_FUNCTION_TYPE : KotlinBuiltIns.getInstance().getFunctionType(
-                    Collections.<AnnotationDescriptor>emptyList(), null, Collections.<JetType>emptyList(), DONT_CARE);
+                    Annotations.EMPTY, null, Collections.<JetType>emptyList(), DONT_CARE);
         }
         List<JetParameter> valueParameters = expression.getValueParameters();
         TemporaryBindingTrace temporaryTrace = TemporaryBindingTrace.create(
@@ -226,7 +226,7 @@ public class ArgumentTypeResolver {
         JetType returnType = resolveTypeRefWithDefault(functionLiteral.getReturnTypeRef(), scope, temporaryTrace, DONT_CARE);
         assert returnType != null;
         JetType receiverType = resolveTypeRefWithDefault(functionLiteral.getReceiverTypeRef(), scope, temporaryTrace, null);
-        return KotlinBuiltIns.getInstance().getFunctionType(Collections.<AnnotationDescriptor>emptyList(), receiverType, parameterTypes,
+        return KotlinBuiltIns.getInstance().getFunctionType(Annotations.EMPTY, receiverType, parameterTypes,
                                                             returnType);
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolverUtil.java

@@ -24,22 +24,14 @@ import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.psi.Call;
 import org.jetbrains.jet.lang.psi.CallKey;
 import org.jetbrains.jet.lang.psi.JetExpression;
-import org.jetbrains.jet.lang.resolve.BindingContext;
-import org.jetbrains.jet.lang.resolve.TraceUtil;
 import org.jetbrains.jet.lang.resolve.calls.context.BasicCallResolutionContext;
-import org.jetbrains.jet.lang.resolve.calls.context.CallResolutionContext;
 import org.jetbrains.jet.lang.resolve.calls.inference.ConstraintPosition;
 import org.jetbrains.jet.lang.resolve.calls.inference.ConstraintSystem;
-import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCallImpl;
-import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCallWithTrace;
-import org.jetbrains.jet.lang.resolve.calls.model.ResolvedValueArgument;
-import org.jetbrains.jet.lang.resolve.calls.tasks.ResolutionCandidate;
 import org.jetbrains.jet.lang.types.*;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 
 import java.util.Collections;
 import java.util.List;
-import java.util.Map;
 
 import static org.jetbrains.jet.lang.types.TypeUtils.CANT_INFER_TYPE_PARAMETER;
 import static org.jetbrains.jet.lang.types.TypeUtils.DONT_CARE;

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/util/ExpressionAsFunctionDescriptor.java

@@ -17,20 +17,21 @@
 package org.jetbrains.jet.lang.resolve.calls.util;
 
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
+import org.jetbrains.jet.lang.descriptors.Modality;
+import org.jetbrains.jet.lang.descriptors.Visibility;
+import org.jetbrains.jet.lang.descriptors.annotations.Annotations;
 import org.jetbrains.jet.lang.descriptors.impl.FunctionDescriptorImpl;
 import org.jetbrains.jet.lang.psi.JetExpression;
 import org.jetbrains.jet.lang.resolve.name.Name;
 
-import java.util.Collections;
-
 public class ExpressionAsFunctionDescriptor extends FunctionDescriptorImpl {
 
     private final JetExpression expression;
 
     public ExpressionAsFunctionDescriptor(DeclarationDescriptor containingDeclaration, Name name, JetExpression expression) {
-        super(containingDeclaration, Collections.<AnnotationDescriptor>emptyList(), name, Kind.DECLARATION);
+        super(containingDeclaration, Annotations.EMPTY, name, Kind.DECLARATION);
         this.expression = expression;
     }
 

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

@@ -27,6 +27,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.descriptors.annotations.Annotations;
 import org.jetbrains.jet.lang.descriptors.impl.ClassDescriptorBase;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.AnnotationResolver;
@@ -74,7 +75,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements LazyDesc
     private final ClassKind kind;
     private final boolean isInner;
 
-    private final NotNullLazyValue<List<AnnotationDescriptor>> annotations;
+    private final NotNullLazyValue<Annotations> annotations;
     private final NullableLazyValue<ClassDescriptor> classObjectDescriptor;
 
     private final LazyClassMemberScope unsubstitutedMemberScope;
@@ -119,9 +120,9 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements LazyDesc
         this.isInner = isInnerClass(modifierList);
 
         StorageManager storageManager = resolveSession.getStorageManager();
-        this.annotations = storageManager.createLazyValue(new Function0<List<AnnotationDescriptor>>() {
+        this.annotations = storageManager.createLazyValue(new Function0<Annotations>() {
             @Override
-            public List<AnnotationDescriptor> invoke() {
+            public Annotations invoke() {
                 return resolveAnnotations();
             }
         });
@@ -293,12 +294,12 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements LazyDesc
 
     @NotNull
     @Override
-    public List<AnnotationDescriptor> getAnnotations() {
+    public Annotations getAnnotations() {
         return annotations.invoke();
     }
 
     @NotNull
-    private List<AnnotationDescriptor> resolveAnnotations() {
+    private Annotations resolveAnnotations() {
         JetClassLikeInfo classInfo = declarationProvider.getOwnerInfo();
         JetModifierList modifierList = classInfo.getModifierList();
         if (modifierList != null) {
@@ -307,7 +308,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements LazyDesc
             return annotationResolver.resolveAnnotationsWithArguments(scopeForDeclaration, modifierList, resolveSession.getTrace());
         }
         else {
-            return Collections.emptyList();
+            return Annotations.EMPTY;
         }
     }
 
@@ -449,8 +450,8 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements LazyDesc
 
         @NotNull
         @Override
-        public List<AnnotationDescriptor> getAnnotations() {
-            return Collections.emptyList(); // TODO
+        public Annotations getAnnotations() {
+            return Annotations.EMPTY; // TODO
         }
 
         @Override

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

@@ -19,18 +19,16 @@ package org.jetbrains.jet.lang.resolve.lazy.descriptors;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.descriptors.annotations.Annotations;
 import org.jetbrains.jet.lang.descriptors.impl.DeclarationDescriptorImpl;
 import org.jetbrains.jet.lang.resolve.lazy.ForceResolveUtil;
 import org.jetbrains.jet.lang.resolve.lazy.LazyDescriptor;
 import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
 import org.jetbrains.jet.lang.resolve.lazy.declarations.PackageMemberDeclarationProvider;
 import org.jetbrains.jet.lang.resolve.name.FqName;
-import org.jetbrains.jet.lang.resolve.scopes.*;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.types.TypeSubstitutor;
 
-import java.util.Collections;
-
 public class LazyPackageDescriptor extends DeclarationDescriptorImpl implements LazyDescriptor, PackageFragmentDescriptor {
     private final ResolveSession resolveSession;
     private final ModuleDescriptor module;
@@ -44,7 +42,7 @@ public class LazyPackageDescriptor extends DeclarationDescriptorImpl implements
             @NotNull ResolveSession resolveSession,
             @NotNull PackageMemberDeclarationProvider declarationProvider
     ) {
-        super(Collections.<AnnotationDescriptor>emptyList(), fqName.shortNameOrSpecial());
+        super(Annotations.EMPTY, fqName.shortNameOrSpecial());
         this.resolveSession = resolveSession;
         this.module = module;
         this.fqName = fqName;

compiler/frontend/src/org/jetbrains/jet/lang/types/DeferredType.java

@@ -18,7 +18,7 @@ package org.jetbrains.jet.lang.types;
 
 import jet.Function0;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.descriptors.annotations.Annotations;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.storage.LockBasedStorageManager;
@@ -87,7 +87,7 @@ public class DeferredType implements LazyType {
 
     @NotNull
     @Override
-    public List<AnnotationDescriptor> getAnnotations() {
+    public Annotations getAnnotations() {
         return getActualType().getAnnotations();
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java

@@ -25,6 +25,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.descriptors.annotations.Annotations;
 import org.jetbrains.jet.lang.descriptors.impl.AnonymousFunctionDescriptor;
 import org.jetbrains.jet.lang.diagnostics.Errors;
 import org.jetbrains.jet.lang.evaluate.ConstantExpressionEvaluator;
@@ -505,7 +506,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
 
         //noinspection ConstantConditions
         JetType type = KotlinBuiltIns.getInstance().getKFunctionType(
-                Collections.<AnnotationDescriptor>emptyList(),
+                Annotations.EMPTY,
                 receiverType,
                 DescriptorUtils.getValueParametersTypes(descriptor.getValueParameters()),
                 descriptor.getReturnType(),
@@ -514,7 +515,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
 
         AnonymousFunctionDescriptor functionDescriptor = new AnonymousFunctionDescriptor(
                 context.scope.getContainingDeclaration(),
-                Collections.<AnnotationDescriptor>emptyList(),
+                Annotations.EMPTY,
                 CallableMemberDescriptor.Kind.DECLARATION);
 
         FunctionDescriptorUtil.initializeFromFunctionType(functionDescriptor, type, null, Modality.FINAL, Visibilities.PUBLIC);

compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java

@@ -24,7 +24,7 @@ import jet.Function0;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.descriptors.annotations.Annotations;
 import org.jetbrains.jet.lang.descriptors.impl.*;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.*;
@@ -119,7 +119,7 @@ public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor {
         JetType receiver = DescriptorUtils.getReceiverParameterType(functionDescriptor.getReceiverParameter());
         List<JetType> valueParametersTypes = DescriptorUtils.getValueParametersTypes(functionDescriptor.getValueParameters());
         JetType resultType = KotlinBuiltIns.getInstance().getFunctionType(
-                Collections.<AnnotationDescriptor>emptyList(), receiver, valueParametersTypes, safeReturnType);
+                Annotations.EMPTY, receiver, valueParametersTypes, safeReturnType);
         if (!noExpectedType(expectedType) && KotlinBuiltIns.getInstance().isFunctionOrExtensionFunctionType(expectedType)) {
             // all checks were done before
             return JetTypeInfo.create(resultType, context.dataFlowInfo);
@@ -176,7 +176,7 @@ public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor {
         JetFunctionLiteral functionLiteral = expression.getFunctionLiteral();
         JetTypeReference receiverTypeRef = functionLiteral.getReceiverTypeRef();
         AnonymousFunctionDescriptor functionDescriptor = new AnonymousFunctionDescriptor(
-                context.scope.getContainingDeclaration(), Collections.<AnnotationDescriptor>emptyList(), CallableMemberDescriptor.Kind.DECLARATION);
+                context.scope.getContainingDeclaration(), Annotations.EMPTY, CallableMemberDescriptor.Kind.DECLARATION);
 
         List<ValueParameterDescriptor> valueParameterDescriptors = createValueParameterDescriptors(context, functionLiteral,
                                                                                                    functionDescriptor, functionTypeExpected);
@@ -224,7 +224,7 @@ public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor {
         if (functionTypeExpected && !hasDeclaredValueParameters && expectedValueParameters.size() == 1) {
             ValueParameterDescriptor valueParameterDescriptor = expectedValueParameters.get(0);
             ValueParameterDescriptor it = new ValueParameterDescriptorImpl(
-                    functionDescriptor, 0, Collections.<AnnotationDescriptor>emptyList(), Name.identifier("it"),
+                    functionDescriptor, 0, Annotations.EMPTY, Name.identifier("it"),
                     valueParameterDescriptor.getType(), valueParameterDescriptor.hasDefaultValue(), valueParameterDescriptor.getVarargElementType()
             );
             valueParameterDescriptors.add(it);

compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingUtils.java

@@ -23,7 +23,7 @@ import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.descriptors.annotations.Annotations;
 import org.jetbrains.jet.lang.descriptors.impl.SimpleFunctionDescriptorImpl;
 import org.jetbrains.jet.lang.descriptors.impl.TypeParameterDescriptorImpl;
 import org.jetbrains.jet.lang.descriptors.impl.ValueParameterDescriptorImpl;
@@ -32,11 +32,7 @@ import org.jetbrains.jet.lang.resolve.BindingContextUtils;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.calls.CallResolver;
 import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo;
-import org.jetbrains.jet.lang.resolve.calls.inference.ConstraintPosition;
-import org.jetbrains.jet.lang.resolve.calls.inference.ConstraintSystem;
-import org.jetbrains.jet.lang.resolve.calls.inference.ConstraintSystemStatus;
-import org.jetbrains.jet.lang.resolve.calls.inference.ConstraintsUtil;
-import org.jetbrains.jet.lang.resolve.calls.inference.InferenceErrorData;
+import org.jetbrains.jet.lang.resolve.calls.inference.*;
 import org.jetbrains.jet.lang.resolve.calls.model.MutableDataFlowInfoForArguments;
 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall;
 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCallWithTrace;
@@ -90,26 +86,25 @@ public class ControlStructureTypingUtils {
     ) {
         assert argumentNames.size() == isArgumentNullable.size();
 
-        List<AnnotationDescriptor> noAnnotations = Collections.emptyList();
         Name specialFunctionName = Name.identifierNoValidate("<SPECIAL-FUNCTION-FOR-" + constructionName + "-RESOLVE>");
 
         SimpleFunctionDescriptorImpl function = new SimpleFunctionDescriptorImpl(
                 ErrorUtils.getErrorModule(),//todo hack to avoid returning true in 'isError(DeclarationDescriptor)'
-                noAnnotations, specialFunctionName, CallableMemberDescriptor.Kind.DECLARATION);
+                Annotations.EMPTY, specialFunctionName, CallableMemberDescriptor.Kind.DECLARATION);
 
         TypeParameterDescriptor typeParameter = TypeParameterDescriptorImpl.createWithDefaultBound(
-                function, noAnnotations, false, Variance.INVARIANT,
+                function, Annotations.EMPTY, false, Variance.INVARIANT,
                 Name.identifierNoValidate("<TYPE-PARAMETER-FOR-" + constructionName + "-RESOLVE>"), 0);
 
         JetType type = new JetTypeImpl(typeParameter.getTypeConstructor(), JetScope.EMPTY);
         JetType nullableType = new JetTypeImpl(
-                noAnnotations, typeParameter.getTypeConstructor(), true, Collections.<TypeProjection>emptyList(), JetScope.EMPTY);
+                Annotations.EMPTY, typeParameter.getTypeConstructor(), true, Collections.<TypeProjection>emptyList(), JetScope.EMPTY);
 
         List<ValueParameterDescriptor> valueParameters = Lists.newArrayList();
         for (int i = 0; i < argumentNames.size(); i++) {
             JetType argumentType = isArgumentNullable.get(i) ? nullableType : type;
             ValueParameterDescriptorImpl valueParameter = new ValueParameterDescriptorImpl(
-                    function, i, noAnnotations, Name.identifier(argumentNames.get(i)), argumentType, false, null);
+                    function, i, Annotations.EMPTY, Name.identifier(argumentNames.get(i)), argumentType, false, null);
             valueParameters.add(valueParameter);
         }
         function.initialize(

compiler/tests/org/jetbrains/jet/types/TypeUnifierTest.java

@@ -27,7 +27,7 @@ import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.di.InjectorForTests;
 import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
-import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
+import org.jetbrains.jet.lang.descriptors.annotations.Annotations;
 import org.jetbrains.jet.lang.descriptors.impl.TypeParameterDescriptorImpl;
 import org.jetbrains.jet.lang.psi.JetPsiFactory;
 import org.jetbrains.jet.lang.psi.JetTypeProjection;
@@ -41,7 +41,6 @@ import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
 import org.jetbrains.jet.lang.types.*;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 
-import java.util.Collections;
 import java.util.Map;
 import java.util.Set;
 
@@ -73,7 +72,7 @@ public class TypeUnifierTest extends JetLiteFixture {
 
     private static TypeParameterDescriptor createTypeVariable(String name) {
         return TypeParameterDescriptorImpl.createWithDefaultBound(
-                KotlinBuiltIns.getInstance().getBuiltInsModule(), Collections.<AnnotationDescriptor>emptyList(), false, Variance.INVARIANT,
+                KotlinBuiltIns.getInstance().getBuiltInsModule(), Annotations.EMPTY, false, Variance.INVARIANT,
                 Name.identifier(name), 0);
     }