diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java
index fc891b5d73a..97a39e3e61b 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java
@@ -86,8 +86,10 @@ public class OverrideResolver {
         
         Set<ClassifierDescriptor> processed = new HashSet<ClassifierDescriptor>();
 
-        for (MutableClassDescriptor clazz : ourClasses) {
-            generateOverridesAndDelegationInAClass(clazz, processed, ourClasses);
+        for (MutableClassDescriptorLite klass : ContainerUtil.reverse(context.getClassesTopologicalOrder())) {
+            if (klass instanceof MutableClassDescriptor && ourClasses.contains(klass)) {
+                generateOverridesAndDelegationInAClass((MutableClassDescriptor) klass, processed, ourClasses);
+            }
         }
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java
index 6f262c6672d..3268bc4f540 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java
@@ -30,6 +30,7 @@ import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
 import javax.inject.Inject;
 import java.io.PrintStream;
 import java.util.Collection;
+import java.util.List;
 import java.util.Map;
 
 public class TopDownAnalysisContext implements BodiesResolveContext {
@@ -37,6 +38,7 @@ public class TopDownAnalysisContext implements BodiesResolveContext {
     private final Map<JetClass, 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;
 
     private final Map<JetDeclaration, JetScope> declaringScopes = Maps.newHashMap();
     private final Map<JetNamedFunction, SimpleFunctionDescriptor> functions = Maps.newLinkedHashMap();
@@ -165,4 +167,13 @@ public class TopDownAnalysisContext implements BodiesResolveContext {
         }
         return members;
     }
+
+    @NotNull
+    public List<MutableClassDescriptorLite> getClassesTopologicalOrder() {
+        return classesTopologicalOrder;
+    }
+
+    public void setClassesTopologicalOrder(@NotNull List<MutableClassDescriptorLite> classesTopologicalOrder) {
+        this.classesTopologicalOrder = classesTopologicalOrder;
+    }
 }
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java
index e6bf31e5ab6..8ef9b1a7c21 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java
@@ -62,9 +62,6 @@ public class TypeHierarchyResolver {
     @NotNull
     private BindingTrace trace;
 
-    // state
-    private List<MutableClassDescriptor> topologicalOrder;
-
     @Inject
     public void setContext(@NotNull TopDownAnalysisContext context) {
         this.context = context;
@@ -138,7 +135,7 @@ public class TypeHierarchyResolver {
         createTypeConstructors(); // create type constructors for classes and generic parameters, supertypes are not filled in
         resolveTypesInClassHeaders(); // Generic bounds and types in supertype lists (no expressions or constructor resolution)
 
-        topologicalOrder = topologicallySortClassesAndObjects();
+        context.setClassesTopologicalOrder(topologicallySortClassesAndObjects());
 
         // Detect and disconnect all loops in the hierarchy
         detectAndDisconnectLoops();
@@ -245,20 +242,20 @@ public class TypeHierarchyResolver {
         }
     }
 
-    private List<MutableClassDescriptor> topologicallySortClassesAndObjects() {
+    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
         return DFS.topologicalOrder(
-                ContainerUtil.<MutableClassDescriptor>concat(context.getClasses().values(), context.getObjects().values()),
-                new DFS.Neighbors<MutableClassDescriptor>() {
+                ContainerUtil.<MutableClassDescriptorLite>concat(context.getClasses().values(), context.getObjects().values()),
+                new DFS.Neighbors<MutableClassDescriptorLite>() {
                     @NotNull
                     @Override
-                    public Iterable<MutableClassDescriptor> getNeighbors(MutableClassDescriptor current) {
-                        List<MutableClassDescriptor> result = Lists.newArrayList();
+                    public Iterable<MutableClassDescriptorLite> getNeighbors(MutableClassDescriptorLite current) {
+                        List<MutableClassDescriptorLite> result = Lists.newArrayList();
                         for (JetType supertype : current.getSupertypes()) {
                             DeclarationDescriptor declarationDescriptor = supertype.getConstructor().getDeclarationDescriptor();
-                            if (declarationDescriptor instanceof MutableClassDescriptor) {
-                                MutableClassDescriptor classDescriptor = (MutableClassDescriptor) declarationDescriptor;
+                            if (declarationDescriptor instanceof MutableClassDescriptorLite) {
+                                MutableClassDescriptorLite classDescriptor = (MutableClassDescriptorLite) declarationDescriptor;
                                 result.add(classDescriptor);
                             }
                         }
@@ -273,13 +270,13 @@ public class TypeHierarchyResolver {
         Set<ClassDescriptor> visited = Sets.newHashSet();
         Set<ClassDescriptor> beingProcessed = Sets.newHashSet();
         List<ClassDescriptor> currentPath = Lists.newArrayList();
-        for (MutableClassDescriptor mutableClassDescriptor : topologicalOrder) {
-            traverseTypeHierarchy(mutableClassDescriptor, visited, beingProcessed, currentPath);
+        for (MutableClassDescriptorLite klass : context.getClassesTopologicalOrder()) {
+            traverseTypeHierarchy(klass, visited, beingProcessed, currentPath);
         }
     }
 
     private void traverseTypeHierarchy(
-            MutableClassDescriptor currentClass,
+            MutableClassDescriptorLite currentClass,
             Set<ClassDescriptor> visited,
             Set<ClassDescriptor> beingProcessed,
             List<ClassDescriptor> currentPath
@@ -355,7 +352,7 @@ public class TypeHierarchyResolver {
     }
 
     private void checkSupertypesForConsistency() {
-        for (MutableClassDescriptor mutableClassDescriptor : topologicalOrder) {
+        for (MutableClassDescriptorLite mutableClassDescriptor : context.getClassesTopologicalOrder()) {
             Multimap<TypeConstructor, TypeProjection> multimap = SubstitutionUtils
                     .buildDeepSubstitutionMultimap(mutableClassDescriptor.getDefaultType());
             for (Map.Entry<TypeConstructor, Collection<TypeProjection>> entry : multimap.asMap().entrySet()) {