Drop BodiesResolveContext.getObjects()

Objects are stored in the same place where classes are

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

@@ -19,7 +19,9 @@ package org.jetbrains.jet.lang.resolve;
 import com.google.common.base.Function;
 import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.descriptors.PropertyDescriptor;
+import org.jetbrains.jet.lang.descriptors.ScriptDescriptor;
+import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.MutableClassDescriptor;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo;
@@ -32,7 +34,6 @@ import java.util.Map;
 public interface BodiesResolveContext {
     Collection<JetFile> getFiles();
     Map<JetClassOrObject, MutableClassDescriptor> getClasses();
-    Map<JetObjectDeclaration, MutableClassDescriptor> getObjects();
     Map<JetProperty, PropertyDescriptor> getProperties();
     Map<JetNamedFunction, SimpleFunctionDescriptor> getFunctions();
     Function<JetDeclaration, JetScope> getDeclaringScopes();

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

@@ -160,18 +160,13 @@ public class BodyResolver {
     private void resolveDelegationSpecifierLists() {
         // TODO : Make sure the same thing is not initialized twice
         for (Map.Entry<JetClassOrObject, MutableClassDescriptor> entry : context.getClasses().entrySet()) {
-            resolveDelegationSpecifierList(entry.getKey(), entry.getValue());
+            JetClassOrObject classOrObject = entry.getKey();
+            MutableClassDescriptor descriptor = entry.getValue();
+            resolveDelegationSpecifierList(classOrObject, descriptor,
+                                           descriptor.getUnsubstitutedPrimaryConstructor(),
+                                           descriptor.getScopeForSupertypeResolution(),
+                                           descriptor.getScopeForMemberResolution());
         }
-        for (Map.Entry<JetObjectDeclaration, MutableClassDescriptor> entry : context.getObjects().entrySet()) {
-            resolveDelegationSpecifierList(entry.getKey(), entry.getValue());
-        }
-    }
-
-    private void resolveDelegationSpecifierList(JetClassOrObject jetClass, MutableClassDescriptor descriptor) {
-        resolveDelegationSpecifierList(jetClass, descriptor,
-                                       descriptor.getUnsubstitutedPrimaryConstructor(),
-                                       descriptor.getScopeForSupertypeResolution(),
-                                       descriptor.getScopeForMemberResolution());
     }
 
     public void resolveDelegationSpecifierList(@NotNull JetClassOrObject jetClass, @NotNull final ClassDescriptor descriptor,
@@ -338,23 +333,15 @@ public class BodyResolver {
         for (Map.Entry<JetClassOrObject, MutableClassDescriptor> entry : context.getClasses().entrySet()) {
             resolveAnnotationArguments(entry.getValue().getScopeForSupertypeResolution(), entry.getKey());
         }
-        for (Map.Entry<JetObjectDeclaration, MutableClassDescriptor> entry : context.getObjects().entrySet()) {
-            resolveAnnotationArguments(entry.getValue().getScopeForSupertypeResolution(), entry.getKey());
-        }
     }
 
     private void resolveAnonymousInitializers() {
         for (Map.Entry<JetClassOrObject, MutableClassDescriptor> entry : context.getClasses().entrySet()) {
-            resolveAnonymousInitializers(entry.getKey(), entry.getValue());
+            JetClassOrObject classOrObject = entry.getKey();
+            MutableClassDescriptor descriptor = entry.getValue();
+            resolveAnonymousInitializers(classOrObject, descriptor.getUnsubstitutedPrimaryConstructor(),
+                                         descriptor.getScopeForInitializers());
         }
-        for (Map.Entry<JetObjectDeclaration, MutableClassDescriptor> entry : context.getObjects().entrySet()) {
-            resolveAnonymousInitializers(entry.getKey(), entry.getValue());
-        }
-    }
-
-    private void resolveAnonymousInitializers(JetClassOrObject jetClassOrObject, MutableClassDescriptor classDescriptor) {
-        resolveAnonymousInitializers(jetClassOrObject, classDescriptor.getUnsubstitutedPrimaryConstructor(),
-                                     classDescriptor.getScopeForInitializers());
     }
 
     public void resolveAnonymousInitializers(JetClassOrObject jetClassOrObject,

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

@@ -40,7 +40,6 @@ import java.util.Map;
 public class CachedBodiesResolveContext implements BodiesResolveContext {
     private final Collection<JetFile> files;
     private final Map<JetClassOrObject, MutableClassDescriptor> classes;
-    private final Map<JetObjectDeclaration, MutableClassDescriptor> objects;
     private final Map<JetProperty, PropertyDescriptor> properties;
     private final Map<JetNamedFunction, SimpleFunctionDescriptor> functions;
     private final Function<JetDeclaration, JetScope> declaringScopes;
@@ -53,7 +52,6 @@ public class CachedBodiesResolveContext implements BodiesResolveContext {
     public CachedBodiesResolveContext(TopDownAnalysisContext context) {
         files = Collections.unmodifiableCollection(context.getFiles());
         classes = Collections.unmodifiableMap(context.getClasses());
-        objects = Collections.unmodifiableMap(context.getObjects());
         properties = Collections.unmodifiableMap(context.getProperties());
         functions = Collections.unmodifiableMap(context.getFunctions());
         declaringScopes = context.getDeclaringScopes();
@@ -74,11 +72,6 @@ public class CachedBodiesResolveContext implements BodiesResolveContext {
         return classes;
     }
 
-    @Override
-    public Map<JetObjectDeclaration, MutableClassDescriptor> getObjects() {
-        return objects;
-    }
-
     @Override
     public Map<JetProperty, PropertyDescriptor> getProperties() {
         return properties;

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

@@ -52,10 +52,6 @@ public class ControlFlowAnalyzer {
             if (!bodiesResolveContext.completeAnalysisNeeded(aClass)) continue;
             checkDeclarationContainer(aClass);
         }
-        for (JetObjectDeclaration objectDeclaration : bodiesResolveContext.getObjects().keySet()) {
-            if (!bodiesResolveContext.completeAnalysisNeeded(objectDeclaration)) continue;
-            checkDeclarationContainer(objectDeclaration);
-        }
         for (Map.Entry<JetNamedFunction, SimpleFunctionDescriptor> entry : bodiesResolveContext.getFunctions().entrySet()) {
             JetNamedFunction function = entry.getKey();
             SimpleFunctionDescriptor functionDescriptor = entry.getValue();

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

@@ -150,18 +150,12 @@ public class DeclarationResolver {
 
     private void resolveAnnotationStubsOnClassesAndConstructors() {
         for (Map.Entry<JetClassOrObject, MutableClassDescriptor> entry : context.getClasses().entrySet()) {
-            resolveAnnotationsForClassOrObject(annotationResolver, entry.getKey(), entry.getValue());
+            JetModifierList modifierList = entry.getKey().getModifierList();
-        }
+            if (modifierList != null) {
-        for (Map.Entry<JetObjectDeclaration, MutableClassDescriptor> entry : context.getObjects().entrySet()) {
+                MutableClassDescriptor descriptor = entry.getValue();
-            resolveAnnotationsForClassOrObject(annotationResolver, entry.getKey(), entry.getValue());
+                descriptor.getAnnotations().addAll(annotationResolver.resolveAnnotationsWithoutArguments(
-        }
+                        descriptor.getScopeForSupertypeResolution(), modifierList, trace));
-    }
+            }
-
-    private void resolveAnnotationsForClassOrObject(AnnotationResolver annotationResolver, JetClassOrObject jetClass, MutableClassDescriptor descriptor) {
-        JetModifierList modifierList = jetClass.getModifierList();
-        if (modifierList != null) {
-            descriptor.getAnnotations().addAll(annotationResolver.resolveAnnotationsWithoutArguments(
-                    descriptor.getScopeForSupertypeResolution(), modifierList, trace));
         }
     }
 
@@ -187,14 +181,6 @@ public class DeclarationResolver {
                     classDescriptor.getScopeForInitializers(), classDescriptor.getScopeForMemberResolution(),
                     classDescriptor.getBuilder());
         }
-        for (Map.Entry<JetObjectDeclaration, MutableClassDescriptor> entry : context.getObjects().entrySet()) {
-            JetObjectDeclaration object = entry.getKey();
-            MutableClassDescriptor classDescriptor = entry.getValue();
-
-            resolveFunctionAndPropertyHeaders(object.getDeclarations(), classDescriptor.getScopeForMemberResolution(),
-                                              classDescriptor.getScopeForInitializers(), classDescriptor.getScopeForMemberResolution(),
-                                              classDescriptor.getBuilder());
-        }
 
         scriptHeaderResolver.resolveScriptDeclarations();
 
@@ -389,8 +375,7 @@ public class DeclarationResolver {
     }
 
     private void checkRedeclarationsInInnerClassNames() {
-        Iterable<MutableClassDescriptor> classesAndObjects = Iterables.concat(context.getClasses().values(), context.getObjects().values());
+        for (MutableClassDescriptor classDescriptor : context.getClasses().values()) {
-        for (MutableClassDescriptor classDescriptor : classesAndObjects) {
             if (classDescriptor.getKind() == ClassKind.CLASS_OBJECT) {
                 // Class objects should be considered during analysing redeclarations in classes
                 continue;

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

@@ -64,16 +64,6 @@ public class DeclarationsChecker {
             modifiersChecker.checkModifiersForDeclaration(classOrObject, classDescriptor);
         }
 
-        Map<JetObjectDeclaration, MutableClassDescriptor> objects = bodiesResolveContext.getObjects();
-        for (Map.Entry<JetObjectDeclaration, MutableClassDescriptor> entry : objects.entrySet()) {
-            JetObjectDeclaration objectDeclaration = entry.getKey();
-            MutableClassDescriptor objectDescriptor = entry.getValue();
-
-            if (!bodiesResolveContext.completeAnalysisNeeded(objectDeclaration)) continue;
-            checkObject(objectDeclaration);
-            modifiersChecker.checkModifiersForDeclaration(objectDeclaration, objectDescriptor);
-        }
-
         Map<JetNamedFunction, SimpleFunctionDescriptor> functions = bodiesResolveContext.getFunctions();
         for (Map.Entry<JetNamedFunction, SimpleFunctionDescriptor> entry : functions.entrySet()) {
             JetNamedFunction function = entry.getKey();

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

@@ -62,9 +62,6 @@ public class OverloadResolver {
         for (Map.Entry<JetClassOrObject, MutableClassDescriptor> entry : context.getClasses().entrySet()) {
             checkOverloadsInAClass(entry.getValue(), entry.getKey(), inClasses.get(entry.getValue()));
         }
-        for (Map.Entry<JetObjectDeclaration, MutableClassDescriptor> entry : context.getObjects().entrySet()) {
-            checkOverloadsInAClass(entry.getValue(), entry.getKey(), inClasses.get(entry.getValue()));
-        }
         checkOverloadsInANamespace(inNamespaces);
     }
 

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

@@ -84,10 +84,7 @@ public class OverrideResolver {
      * Generate fake overrides and add overridden descriptors to existing descriptors.
      */
     private void generateOverridesAndDelegation() {
-        Set<MutableClassDescriptor> ourClasses = new HashSet<MutableClassDescriptor>();
+        Set<MutableClassDescriptor> ourClasses = new HashSet<MutableClassDescriptor>(context.getClasses().values());
-        ourClasses.addAll(context.getClasses().values());
-        ourClasses.addAll(context.getObjects().values());
-        
         Set<ClassifierDescriptor> processed = new HashSet<ClassifierDescriptor>();
 
         for (MutableClassDescriptorLite klass : ContainerUtil.reverse(context.getClassesTopologicalOrder())) {
@@ -224,9 +221,6 @@ public class OverrideResolver {
         for (Map.Entry<JetClassOrObject, MutableClassDescriptor> entry : context.getClasses().entrySet()) {
             checkOverridesInAClass(entry.getValue(), entry.getKey());
         }
-        for (Map.Entry<JetObjectDeclaration, MutableClassDescriptor> entry : context.getObjects().entrySet()) {
-            checkOverridesInAClass(entry.getValue(), entry.getKey());
-        }
     }
 
     protected void checkOverridesInAClass(@NotNull MutableClassDescriptor classDescriptor, @NotNull JetClassOrObject klass) {
@@ -655,17 +649,14 @@ public class OverrideResolver {
     }
 
     private void checkParameterOverridesForAllClasses() {
-        List<MutableClassDescriptor> allClasses = Lists.newArrayList(context.getClasses().values());
+        for (MutableClassDescriptor classDescriptor : context.getClasses().values()) {
-        allClasses.addAll(context.getObjects().values());
+            for (CallableMemberDescriptor member : classDescriptor.getAllCallableMembers()) {
-        for (MutableClassDescriptor classDescriptor : allClasses) {
-            Collection<CallableMemberDescriptor> members = classDescriptor.getAllCallableMembers();
-            for (CallableMemberDescriptor member : members) {
                 checkOverridesForParameters(member);
             }
         }
     }
 
-    private void checkOverridesForParameters(CallableMemberDescriptor declared) {
+    private void checkOverridesForParameters(@NotNull CallableMemberDescriptor declared) {
         boolean noDeclaration = declared.getKind() != CallableMemberDescriptor.Kind.DECLARATION;
         if (!noDeclaration) {
             // No check if the function is not marked as 'override'

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

@@ -42,7 +42,6 @@ public class TopDownAnalysisContext implements BodiesResolveContext {
     private DataFlowInfo outerDataFlowInfo = DataFlowInfo.EMPTY;
 
     private final Map<JetClassOrObject, MutableClassDescriptor> classes = Maps.newLinkedHashMap();
-    private final Map<JetObjectDeclaration, MutableClassDescriptor> objects = Maps.newLinkedHashMap();
     protected final Map<JetFile, NamespaceDescriptorImpl> namespaceDescriptors = Maps.newHashMap();
     private List<MutableClassDescriptorLite> classesTopologicalOrder = null;
 
@@ -111,11 +110,6 @@ public class TopDownAnalysisContext implements BodiesResolveContext {
         return classes;
     }
 
-    @Override
-    public Map<JetObjectDeclaration, MutableClassDescriptor> getObjects() {
-        return objects;
-    }
-
     public Map<JetFile, WritableScope> getNamespaceScopes() {
         return namespaceScopes;
     }

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

@@ -142,9 +142,6 @@ public class TopDownAnalyzer {
         for (MutableClassDescriptor mutableClassDescriptor : context.getClasses().values()) {
             mutableClassDescriptor.lockScopes();
         }
-        for (MutableClassDescriptor mutableClassDescriptor : context.getObjects().values()) {
-            mutableClassDescriptor.lockScopes();
-        }
         for (Map.Entry<JetFile, WritableScope> namespaceScope : context.getNamespaceScopes().entrySet()) {
             // todo: this is hack in favor of REPL
             if(!namespaceScope.getKey().isScript())

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

@@ -21,7 +21,6 @@ import com.google.common.collect.Multimap;
 import com.google.common.collect.Sets;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiNameIdentifierOwner;
-import com.intellij.util.containers.ContainerUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
@@ -188,9 +187,6 @@ public class TypeHierarchyResolver {
                 initializeObject((JetObjectDeclaration) classOrObject, descriptor);
             }
         }
-        for (Map.Entry<JetObjectDeclaration, MutableClassDescriptor> entry : context.getObjects().entrySet()) {
-            initializeObject(entry.getKey(), entry.getValue());
-        }
     }
 
     private static void initializeObject(@NotNull JetObjectDeclaration declaration, @NotNull MutableClassDescriptor descriptor) {
@@ -209,23 +205,20 @@ public class TypeHierarchyResolver {
             JetClassOrObject classOrObject = entry.getKey();
             MutableClassDescriptor descriptor = entry.getValue();
             if (classOrObject instanceof JetClass) {
+                //noinspection unchecked
                 descriptorResolver.resolveGenericBounds((JetClass) classOrObject, descriptor.getScopeForSupertypeResolution(),
                                                         (List) descriptor.getTypeConstructor().getParameters(), trace);
             }
             descriptorResolver.resolveSupertypesForMutableClassDescriptor(classOrObject, descriptor, trace);
         }
-        for (Map.Entry<JetObjectDeclaration, MutableClassDescriptor> entry : context.getObjects().entrySet()) {
-            JetClassOrObject jetClass = entry.getKey();
-            MutableClassDescriptor descriptor = entry.getValue();
-            descriptorResolver.resolveSupertypesForMutableClassDescriptor(jetClass, descriptor, trace);
-        }
     }
 
     private List<MutableClassDescriptorLite> topologicallySortClassesAndObjects() {
         // A topsort is needed only for better diagnostics:
         //    edges that get removed to disconnect loops are more reasonable in this case
+        //noinspection unchecked
         return DFS.topologicalOrder(
-                ContainerUtil.<MutableClassDescriptorLite>concat(context.getClasses().values(), context.getObjects().values()),
+                (Iterable) context.getClasses().values(),
                 new DFS.Neighbors<MutableClassDescriptorLite>() {
                     @NotNull
                     @Override
@@ -425,12 +418,6 @@ public class TypeHierarchyResolver {
                 checkBoundsForTypeInClassHeader(constraint.getBoundTypeReference());
             }
         }
-
-        for (JetObjectDeclaration object : context.getObjects().keySet()) {
-            for (JetDelegationSpecifier delegationSpecifier : object.getDelegationSpecifiers()) {
-                checkBoundsForTypeInClassHeader(delegationSpecifier.getTypeReference());
-            }
-        }
     }
 
     private void checkBoundsForTypeInClassHeader(@Nullable JetTypeReference typeReference) {
@@ -523,7 +510,7 @@ public class TypeHierarchyResolver {
             MutableClassDescriptor classObjectDescriptor =
                     createClassDescriptorForObject(objectDeclaration, getClassObjectName(owner.getOwnerForChildren().getName()),
                                                    ClassKind.CLASS_OBJECT);
-            context.getObjects().put(objectDeclaration, classObjectDescriptor);
+            context.getClasses().put(objectDeclaration, classObjectDescriptor);
 
             NamespaceLikeBuilder.ClassObjectStatus status = owner.setClassObjectDescriptor(classObjectDescriptor);
             switch (status) {

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

@@ -432,11 +432,6 @@ public class ResolveElementCache {
             return Collections.emptyMap();
         }
 
-        @Override
-        public Map<JetObjectDeclaration, MutableClassDescriptor> getObjects() {
-            return Collections.emptyMap();
-        }
-
         @Override
         public Map<JetProperty, PropertyDescriptor> getProperties() {
             return Collections.emptyMap();