Annotations on classes and class objects supported

compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java

@@ -79,8 +79,8 @@ public class InjectorForLazyResolve {
         this.typeResolver.setDescriptorResolver(descriptorResolver);
         this.typeResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
 
-        annotationResolver.setCallResolver(callResolver);
+        this.annotationResolver.setCallResolver(callResolver);
-        annotationResolver.setExpressionTypingServices(expressionTypingServices);
+        this.annotationResolver.setExpressionTypingServices(expressionTypingServices);
 
         callResolver.setDescriptorResolver(descriptorResolver);
         callResolver.setExpressionTypingServices(expressionTypingServices);
@@ -109,4 +109,8 @@ public class InjectorForLazyResolve {
         return this.scopeProvider;
     }
 
+    public AnnotationResolver getAnnotationResolver() {
+        return this.annotationResolver;
+    }
+
 }

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

@@ -41,7 +41,7 @@ public abstract class AbstractPsiBasedDeclarationProvider implements Declaration
 
     private boolean indexCreated = false;
 
-    private void createIndex() {
+    protected final void createIndex() {
         if (indexCreated) return;
         indexCreated = true;
 

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

@@ -17,6 +17,8 @@
 package org.jetbrains.jet.lang.resolve.lazy;
 
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.psi.JetClassObject;
 import org.jetbrains.jet.lang.psi.JetClassOrObject;
 
 /**
@@ -25,4 +27,7 @@ import org.jetbrains.jet.lang.psi.JetClassOrObject;
 public interface ClassMemberDeclarationProvider extends DeclarationProvider {
     @NotNull
     JetClassOrObject getOwnerClassOrObject();
+
+    @Nullable
+    JetClassObject getClassObject();
 }

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

@@ -20,6 +20,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.psi.*;
+import org.jetbrains.jet.lang.resolve.AnnotationResolver;
 import org.jetbrains.jet.lang.resolve.DescriptorResolver;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.*;
@@ -47,6 +48,9 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
     private final ClassKind kind;
 
     private ClassReceiver implicitReceiver;
+    private List<AnnotationDescriptor> annotations;
+    private ClassDescriptor classObjectDescriptor;
+    private boolean classObjectDescriptorResolved = false;
 
     private final LazyClassMemberScope unsubstitutedMemberScope;
     private final JetScope unsubstitutedInnerClassesScope;
@@ -162,17 +166,31 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
 
     @Override
     public JetType getClassObjectType() {
-        throw new UnsupportedOperationException(); // TODO
+        ClassDescriptor classObjectDescriptor = getClassObjectDescriptor();
+        return classObjectDescriptor == null ? null : classObjectDescriptor.getDefaultType();
     }
 
     @Override
     public boolean isClassObjectAValue() {
-        throw new UnsupportedOperationException(); // TODO
+        return true;
     }
 
     @Override
     public ClassDescriptor getClassObjectDescriptor() {
-        throw new UnsupportedOperationException(); // TODO
+        if (!classObjectDescriptorResolved) {
+            JetClassObject classObject = declarationProvider.getClassObject();
+            if (classObject != null) {
+                JetObjectDeclaration objectDeclaration = classObject.getObjectDeclaration();
+                if (objectDeclaration != null) {
+                    ClassMemberDeclarationProvider classMemberDeclarationProvider = resolveSession.getDeclarationProviderFactory()
+                            .getClassMemberDeclarationProvider(objectDeclaration);
+                    classObjectDescriptor = new LazyClassDescriptor(resolveSession, this, Name.special("<class object>"),
+                                                                    classMemberDeclarationProvider);
+                }
+            }
+            classObjectDescriptorResolved = true;
+        }
+        return classObjectDescriptor;
     }
 
     @NotNull
@@ -204,7 +222,19 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
 
     @Override
     public List<AnnotationDescriptor> getAnnotations() {
-        throw new UnsupportedOperationException(); // TODO
+        if (annotations == null) {
+            JetClassOrObject classOrObject = declarationProvider.getOwnerClassOrObject();
+            JetModifierList modifierList = classOrObject.getModifierList();
+            if (modifierList != null) {
+                AnnotationResolver annotationResolver = resolveSession.getInjector().getAnnotationResolver();
+                annotations = annotationResolver
+                        .resolveAnnotations(resolveSession.getResolutionScope(classOrObject), modifierList, resolveSession.getTrace());
+            }
+            else {
+                annotations = Collections.emptyList();
+            }
+        }
+        return annotations;
     }
 
     @NotNull

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

@@ -17,6 +17,7 @@
 package org.jetbrains.jet.lang.resolve.lazy;
 
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.psi.JetClassObject;
 import org.jetbrains.jet.lang.psi.JetClassOrObject;
 import org.jetbrains.jet.lang.psi.JetDeclaration;
 import org.jetbrains.jet.lang.resolve.name.Name;
@@ -27,6 +28,7 @@ import org.jetbrains.jet.lang.resolve.name.Name;
 public class PsiBasedClassMemberDeclarationProvider extends AbstractPsiBasedDeclarationProvider implements ClassMemberDeclarationProvider {
 
     private final JetClassOrObject classOrObject;
+    private JetClassObject jetClassObject;
 
     public PsiBasedClassMemberDeclarationProvider(@NotNull JetClassOrObject classOrObject) {
         this.classOrObject = classOrObject;
@@ -41,10 +43,21 @@ public class PsiBasedClassMemberDeclarationProvider extends AbstractPsiBasedDecl
     @Override
     protected void doCreateIndex() {
         for (JetDeclaration declaration : classOrObject.getDeclarations()) {
-            putToIndex(declaration);
+            if (declaration instanceof JetClassObject) {
+                jetClassObject = (JetClassObject) declaration;
+            }
+            else {
+                putToIndex(declaration);
+            }
         }
     }
 
+    @Override
+    public JetClassObject getClassObject() {
+        createIndex();
+        return jetClassObject;
+    }
+
     @Override
     public boolean isPackageDeclared(@NotNull Name name) {
         throw new UnsupportedOperationException("Shouldn't be called on a ClassMemberDeclarationProvider");

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

@@ -30,6 +30,7 @@ import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.BindingTraceContext;
 import org.jetbrains.jet.lang.resolve.name.FqName;
+import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 
@@ -60,7 +61,7 @@ public class ResolveSession {
         this.module = rootDescriptor;
         DeclarationProvider provider = declarationProviderFactory.getPackageMemberDeclarationProvider(FqName.ROOT);
         assert provider != null : "No declaration provider for root package in " + rootDescriptor;
-        this.rootPackage = new LazyPackageDescriptor(rootDescriptor, JetPsiUtil.ROOT_NAMESPACE_NAME, this, provider);
+        this.rootPackage = new LazyPackageDescriptor(rootDescriptor, FqNameUnsafe.ROOT_NAME, this, provider);
         rootDescriptor.setRootNs(rootPackage);
 
         this.declarationProviderFactory = declarationProviderFactory;

injector-generator/src/org/jetbrains/jet/di/AllInjectorsGenerator.java

@@ -61,6 +61,7 @@ public class AllInjectorsGenerator {
         generator.addPublicField(ExpressionTypingServices.class);
         generator.addPublicField(TypeResolver.class);
         generator.addPublicField(ScopeProvider.class);
+        generator.addPublicField(AnnotationResolver.class);
         generator.generate("compiler/frontend/src", "org.jetbrains.jet.di", "InjectorForLazyResolve");
     }