Migrate from MutableClassDescriptor to ClassDescriptorWithResolutionScopes

Cast to MutableClassDescriptor where needed. The code with casts will be removed shortly

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

@@ -23,7 +23,6 @@ import org.jetbrains.annotations.NotNull;
 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;
@@ -262,7 +261,7 @@ public class DeserializedClassDescriptor extends AbstractClassDescriptor impleme
     }
 
     @NotNull
-    private MutableClassDescriptor createEnumClassObject() {
+    private ClassDescriptorWithResolutionScopes createEnumClassObject() {
         MutableClassDescriptor classObject = new MutableClassDescriptor(this, getScopeForMemberLookup(), ClassKind.CLASS_OBJECT,
                                                                         false, getClassObjectName(getName()));
         classObject.setSupertypes(Collections.singleton(KotlinBuiltIns.getInstance().getAnyType()));

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

@@ -22,10 +22,10 @@ import org.jetbrains.annotations.Mutable;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.ReadOnly;
 import org.jetbrains.jet.context.GlobalContext;
+import org.jetbrains.jet.lang.descriptors.ClassDescriptorWithResolutionScopes;
 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;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
@@ -48,7 +48,7 @@ public interface BodiesResolveContext extends GlobalContext {
     Collection<JetFile> getFiles();
 
     @Mutable
-    Map<JetClassOrObject, MutableClassDescriptor> getClasses();
+    Map<JetClassOrObject, ClassDescriptorWithResolutionScopes> getClasses();
     @Mutable
     Map<JetProperty, PropertyDescriptor> getProperties();
     @Mutable

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

@@ -24,7 +24,6 @@ import com.intellij.util.containers.Queue;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.descriptors.impl.MutableClassDescriptor;
 import org.jetbrains.jet.lang.evaluate.EvaluatePackage;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.calls.CallResolver;
@@ -161,9 +160,9 @@ 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()) {
+        for (Map.Entry<JetClassOrObject, ClassDescriptorWithResolutionScopes> entry : context.getClasses().entrySet()) {
             JetClassOrObject classOrObject = entry.getKey();
-            MutableClassDescriptor descriptor = entry.getValue();
+            ClassDescriptorWithResolutionScopes descriptor = entry.getValue();
             resolveDelegationSpecifierList(classOrObject, descriptor,
                                            descriptor.getUnsubstitutedPrimaryConstructor(),
                                            descriptor.getScopeForClassHeaderResolution(),
@@ -341,15 +340,15 @@ public class BodyResolver {
     }
 
     private void resolveClassAnnotations() {
-        for (Map.Entry<JetClassOrObject, MutableClassDescriptor> entry : context.getClasses().entrySet()) {
+        for (Map.Entry<JetClassOrObject, ClassDescriptorWithResolutionScopes> entry : context.getClasses().entrySet()) {
             resolveAnnotationArguments(entry.getValue().getScopeForClassHeaderResolution(), entry.getKey());
         }
     }
 
     private void resolveAnonymousInitializers() {
-        for (Map.Entry<JetClassOrObject, MutableClassDescriptor> entry : context.getClasses().entrySet()) {
+        for (Map.Entry<JetClassOrObject, ClassDescriptorWithResolutionScopes> entry : context.getClasses().entrySet()) {
             JetClassOrObject classOrObject = entry.getKey();
-            MutableClassDescriptor descriptor = entry.getValue();
+            ClassDescriptorWithResolutionScopes descriptor = entry.getValue();
             resolveAnonymousInitializers(classOrObject, descriptor.getUnsubstitutedPrimaryConstructor(),
                                          descriptor.getScopeForInitializerResolution());
         }
@@ -388,10 +387,10 @@ public class BodyResolver {
     }
 
     private void resolvePrimaryConstructorParameters() {
-        for (Map.Entry<JetClassOrObject, MutableClassDescriptor> entry : context.getClasses().entrySet()) {
+        for (Map.Entry<JetClassOrObject, ClassDescriptorWithResolutionScopes> entry : context.getClasses().entrySet()) {
             if (!(entry.getKey() instanceof JetClass)) continue;
             JetClass klass = (JetClass) entry.getKey();
-            MutableClassDescriptor classDescriptor = entry.getValue();
+            ClassDescriptorWithResolutionScopes classDescriptor = entry.getValue();
             ConstructorDescriptor unsubstitutedPrimaryConstructor = classDescriptor.getUnsubstitutedPrimaryConstructor();
 
             annotationResolver.resolveAnnotationsArguments(classDescriptor.getScopeForClassHeaderResolution(), klass.getPrimaryConstructorModifierList(), trace);
@@ -424,10 +423,10 @@ public class BodyResolver {
 
         // Member properties
         Set<JetProperty> processed = Sets.newHashSet();
-        for (Map.Entry<JetClassOrObject, MutableClassDescriptor> entry : context.getClasses().entrySet()) {
+        for (Map.Entry<JetClassOrObject, ClassDescriptorWithResolutionScopes> entry : context.getClasses().entrySet()) {
             if (!(entry.getKey() instanceof JetClass)) continue;
             JetClass jetClass = (JetClass) entry.getKey();
-            MutableClassDescriptor classDescriptor = entry.getValue();
+            ClassDescriptorWithResolutionScopes classDescriptor = entry.getValue();
 
             for (JetProperty property : jetClass.getProperties()) {
                 PropertyDescriptor propertyDescriptor = this.context.getProperties().get(property);

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

@@ -20,10 +20,10 @@ import com.google.common.base.Function;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiFile;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.descriptors.ClassDescriptorWithResolutionScopes;
 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;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
@@ -41,7 +41,7 @@ import java.util.Map;
 */
 public class CachedBodiesResolveContext implements BodiesResolveContext {
     private final Collection<JetFile> files;
-    private final Map<JetClassOrObject, MutableClassDescriptor> classes;
+    private final Map<JetClassOrObject, ClassDescriptorWithResolutionScopes> classes;
     private final Map<JetProperty, PropertyDescriptor> properties;
     private final Map<JetNamedFunction, SimpleFunctionDescriptor> functions;
     private final Function<JetDeclaration, JetScope> declaringScopes;
@@ -80,7 +80,7 @@ public class CachedBodiesResolveContext implements BodiesResolveContext {
     }
 
     @Override
-    public Map<JetClassOrObject, MutableClassDescriptor> getClasses() {
+    public Map<JetClassOrObject, ClassDescriptorWithResolutionScopes> getClasses() {
         return classes;
     }
 

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

@@ -128,9 +128,9 @@ public class DeclarationResolver {
     }
 
     private void resolveAnnotationConstructors() {
-        for (Map.Entry<JetClassOrObject, MutableClassDescriptor> entry : context.getClasses().entrySet()) {
+        for (Map.Entry<JetClassOrObject, ClassDescriptorWithResolutionScopes> entry : context.getClasses().entrySet()) {
             JetClassOrObject classOrObject = entry.getKey();
-            MutableClassDescriptor classDescriptor = entry.getValue();
+            MutableClassDescriptor classDescriptor = (MutableClassDescriptor) entry.getValue();
 
             if (classOrObject instanceof JetClass && DescriptorUtils.isAnnotationClass(classDescriptor)) {
                 processPrimaryConstructor(classDescriptor, (JetClass) classOrObject);
@@ -139,9 +139,9 @@ public class DeclarationResolver {
     }
 
     private void resolveConstructorHeaders() {
-        for (Map.Entry<JetClassOrObject, MutableClassDescriptor> entry : context.getClasses().entrySet()) {
+        for (Map.Entry<JetClassOrObject, ClassDescriptorWithResolutionScopes> entry : context.getClasses().entrySet()) {
             JetClassOrObject classOrObject = entry.getKey();
-            MutableClassDescriptor classDescriptor = entry.getValue();
+            MutableClassDescriptor classDescriptor = (MutableClassDescriptor) entry.getValue();
 
             if (classOrObject instanceof JetClass && !DescriptorUtils.isAnnotationClass(classDescriptor)) {
                 processPrimaryConstructor(classDescriptor, (JetClass) classOrObject);
@@ -150,10 +150,10 @@ public class DeclarationResolver {
     }
 
     private void resolveAnnotationStubsOnClassesAndConstructors() {
-        for (Map.Entry<JetClassOrObject, MutableClassDescriptor> entry : context.getClasses().entrySet()) {
+        for (Map.Entry<JetClassOrObject, ClassDescriptorWithResolutionScopes> entry : context.getClasses().entrySet()) {
             JetModifierList modifierList = entry.getKey().getModifierList();
             if (modifierList != null) {
-                MutableClassDescriptor descriptor = entry.getValue();
+                MutableClassDescriptor descriptor = (MutableClassDescriptor) entry.getValue();
                 descriptor.addAnnotations(annotationResolver.resolveAnnotationsWithoutArguments(
                         descriptor.getScopeForClassHeaderResolution(), modifierList, trace));
             }
@@ -168,9 +168,9 @@ public class DeclarationResolver {
 
             resolveFunctionAndPropertyHeaders(file.getDeclarations(), fileScope, fileScope, fileScope, packageBuilder);
         }
-        for (Map.Entry<JetClassOrObject, MutableClassDescriptor> entry : context.getClasses().entrySet()) {
+        for (Map.Entry<JetClassOrObject, ClassDescriptorWithResolutionScopes> entry : context.getClasses().entrySet()) {
             JetClassOrObject classOrObject = entry.getKey();
-            MutableClassDescriptor classDescriptor = entry.getValue();
+            MutableClassDescriptor classDescriptor = (MutableClassDescriptor) entry.getValue();
 
             JetClassBody jetClassBody = classOrObject.getBody();
             if (classDescriptor.getKind() == ClassKind.ANNOTATION_CLASS && jetClassBody != null) {
@@ -236,9 +236,9 @@ public class DeclarationResolver {
     }
 
     private void createFunctionsForDataClasses() {
-        for (Map.Entry<JetClassOrObject, MutableClassDescriptor> entry : context.getClasses().entrySet()) {
+        for (Map.Entry<JetClassOrObject, ClassDescriptorWithResolutionScopes> entry : context.getClasses().entrySet()) {
             JetClassOrObject klass = entry.getKey();
-            MutableClassDescriptor classDescriptor = entry.getValue();
+            MutableClassDescriptor classDescriptor = (MutableClassDescriptor) entry.getValue();
 
             if (klass instanceof JetClass && klass.hasPrimaryConstructor() && KotlinBuiltIns.getInstance().isData(classDescriptor)) {
                 ConstructorDescriptor constructor = DescriptorUtils.getConstructorOfDataClass(classDescriptor);
@@ -375,15 +375,16 @@ public class DeclarationResolver {
     }
 
     private void checkRedeclarationsInInnerClassNames() {
-        for (MutableClassDescriptor classDescriptor : context.getClasses().values()) {
+        for (ClassDescriptorWithResolutionScopes classDescriptor : context.getClasses().values()) {
+            MutableClassDescriptor mutableClassDescriptor = (MutableClassDescriptor) classDescriptor;
             if (classDescriptor.getKind() == ClassKind.CLASS_OBJECT) {
                 // Class objects should be considered during analysing redeclarations in classes
                 continue;
             }
 
-            Collection<DeclarationDescriptor> allDescriptors = classDescriptor.getScopeForMemberLookup().getOwnDeclaredDescriptors();
+            Collection<DeclarationDescriptor> allDescriptors = mutableClassDescriptor.getScopeForMemberLookup().getOwnDeclaredDescriptors();
 
-            MutableClassDescriptorLite classObj = classDescriptor.getClassObjectDescriptor();
+            MutableClassDescriptorLite classObj = mutableClassDescriptor.getClassObjectDescriptor();
             if (classObj != null) {
                 Collection<DeclarationDescriptor> classObjDescriptors = classObj.getScopeForMemberLookup().getOwnDeclaredDescriptors();
                 if (!classObjDescriptors.isEmpty()) {
@@ -399,7 +400,7 @@ public class DeclarationResolver {
                 }
             }
 
-           reportRedeclarations(descriptorMap);
+            reportRedeclarations(descriptorMap);
         }
     }
 

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

@@ -20,7 +20,6 @@ import com.google.common.collect.Sets;
 import com.intellij.lang.ASTNode;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.descriptors.impl.MutableClassDescriptor;
 import org.jetbrains.jet.lang.diagnostics.Errors;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.types.DeferredType;
@@ -48,10 +47,10 @@ public class DeclarationsChecker {
     }
 
     public void process(@NotNull BodiesResolveContext bodiesResolveContext) {
-        Map<JetClassOrObject, MutableClassDescriptor> classes = bodiesResolveContext.getClasses();
+        Map<JetClassOrObject, ClassDescriptorWithResolutionScopes> classes = bodiesResolveContext.getClasses();
-        for (Map.Entry<JetClassOrObject, MutableClassDescriptor> entry : classes.entrySet()) {
+        for (Map.Entry<JetClassOrObject, ClassDescriptorWithResolutionScopes> entry : classes.entrySet()) {
             JetClassOrObject classOrObject = entry.getKey();
-            MutableClassDescriptor classDescriptor = entry.getValue();
+            ClassDescriptorWithResolutionScopes classDescriptor = entry.getValue();
             if (!bodiesResolveContext.completeAnalysisNeeded(classOrObject)) continue;
 
             if (classOrObject instanceof JetClass) {
@@ -99,7 +98,7 @@ public class DeclarationsChecker {
         reportErrorIfHasIllegalModifier(declaration);
     }
 
-    private void checkClass(JetClass aClass, MutableClassDescriptor classDescriptor) {
+    private void checkClass(JetClass aClass, ClassDescriptorWithResolutionScopes classDescriptor) {
         checkOpenMembers(classDescriptor);
         if (aClass.isTrait()) {
             checkTraitModifiers(aClass);
@@ -128,7 +127,7 @@ public class DeclarationsChecker {
     }
 
 
-    private void checkOpenMembers(MutableClassDescriptor classDescriptor) {
+    private void checkOpenMembers(ClassDescriptorWithResolutionScopes classDescriptor) {
         for (CallableMemberDescriptor memberDescriptor : classDescriptor.getDeclaredCallableMembers()) {
             if (memberDescriptor.getKind() != CallableMemberDescriptor.Kind.DECLARATION) continue;
             JetNamedDeclaration member = (JetNamedDeclaration) BindingContextUtils.descriptorToDeclaration(trace.getBindingContext(), memberDescriptor);

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

@@ -21,7 +21,6 @@ import com.intellij.openapi.util.Pair;
 import com.intellij.util.containers.MultiMap;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.descriptors.impl.MutableClassDescriptor;
 import org.jetbrains.jet.lang.diagnostics.Errors;
 import org.jetbrains.jet.lang.psi.JetClassOrObject;
 import org.jetbrains.jet.lang.psi.JetDeclaration;
@@ -62,7 +61,7 @@ public class OverloadResolver {
         MultiMap<FqNameUnsafe, ConstructorDescriptor> inPackages = MultiMap.create();
         fillGroupedConstructors(inClasses, inPackages);
 
-        for (Map.Entry<JetClassOrObject, MutableClassDescriptor> entry : context.getClasses().entrySet()) {
+        for (Map.Entry<JetClassOrObject, ClassDescriptorWithResolutionScopes> entry : context.getClasses().entrySet()) {
             checkOverloadsInAClass(entry.getValue(), entry.getKey(), inClasses.get(entry.getValue()));
         }
         checkOverloadsInPackages(inPackages);
@@ -72,7 +71,7 @@ public class OverloadResolver {
             @NotNull MultiMap<ClassDescriptor, ConstructorDescriptor> inClasses,
             @NotNull MultiMap<FqNameUnsafe, ConstructorDescriptor> inPackages
     ) {
-        for (MutableClassDescriptor klass : context.getClasses().values()) {
+        for (ClassDescriptorWithResolutionScopes klass : context.getClasses().values()) {
             if (klass.getKind().isSingleton()) {
                 // Constructors of singletons aren't callable from the code, so they shouldn't participate in overload name checking
                 continue;
@@ -131,13 +130,13 @@ public class OverloadResolver {
     }
 
     private void checkOverloadsInAClass(
-            MutableClassDescriptor classDescriptor, JetClassOrObject klass,
+            ClassDescriptorWithResolutionScopes classDescriptor, JetClassOrObject klass,
             Collection<ConstructorDescriptor> nestedClassConstructors
     ) {
         MultiMap<Name, CallableMemberDescriptor> functionsByName = MultiMap.create();
         
         if (classDescriptor.getKind() == ClassKind.ENUM_CLASS) {
-            MutableClassDescriptor classObjectDescriptor = (MutableClassDescriptor) classDescriptor.getClassObjectDescriptor();
+            ClassDescriptorWithResolutionScopes classObjectDescriptor = (ClassDescriptorWithResolutionScopes) classDescriptor.getClassObjectDescriptor();
             assert classObjectDescriptor != null;
             for (CallableMemberDescriptor memberDescriptor : classObjectDescriptor.getDeclaredCallableMembers()) {
                 functionsByName.putValue(memberDescriptor.getName(), memberDescriptor);

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

@@ -21,7 +21,6 @@ import com.google.common.collect.Maps;
 import com.google.common.collect.Multimap;
 import com.google.common.collect.Sets;
 import com.intellij.lang.ASTNode;
-import com.intellij.openapi.util.Condition;
 import com.intellij.psi.PsiElement;
 import com.intellij.util.containers.ContainerUtil;
 import com.intellij.util.containers.LinkedMultiMap;
@@ -86,7 +85,7 @@ public class OverrideResolver {
      * Generate fake overrides and add overridden descriptors to existing descriptors.
      */
     private void generateOverridesAndDelegation() {
-        Set<MutableClassDescriptor> ourClasses = new HashSet<MutableClassDescriptor>(context.getClasses().values());
+        Set<ClassDescriptorWithResolutionScopes> ourClasses = new HashSet<ClassDescriptorWithResolutionScopes>(context.getClasses().values());
         Set<ClassifierDescriptor> processed = new HashSet<ClassifierDescriptor>();
 
         for (MutableClassDescriptorLite klass : ContainerUtil.reverse(context.getClassesTopologicalOrder())) {
@@ -104,7 +103,7 @@ public class OverrideResolver {
     private void generateOverridesAndDelegationInAClass(
             @NotNull MutableClassDescriptor classDescriptor,
             @NotNull Set<ClassifierDescriptor> processed,
-            @NotNull Set<MutableClassDescriptor> classesBeingAnalyzed
+            @NotNull Set<ClassDescriptorWithResolutionScopes> classesBeingAnalyzed
             // to filter out classes such as stdlib and others that come from dependencies
     ) {
         if (!processed.add(classDescriptor)) {
@@ -220,8 +219,8 @@ public class OverrideResolver {
     }
 
     private void checkOverrides() {
-        for (Map.Entry<JetClassOrObject, MutableClassDescriptor> entry : context.getClasses().entrySet()) {
+        for (Map.Entry<JetClassOrObject, ClassDescriptorWithResolutionScopes> entry : context.getClasses().entrySet()) {
-            checkOverridesInAClass(entry.getValue(), entry.getKey());
+            checkOverridesInAClass((MutableClassDescriptor) entry.getValue(), entry.getKey());
         }
     }
 
@@ -685,9 +684,11 @@ public class OverrideResolver {
     }
 
     private void checkParameterOverridesForAllClasses() {
-        for (MutableClassDescriptor classDescriptor : context.getClasses().values()) {
+        for (ClassDescriptorWithResolutionScopes classDescriptor : context.getClasses().values()) {
-            for (CallableMemberDescriptor member : classDescriptor.getAllCallableMembers()) {
+            for (DeclarationDescriptor member : classDescriptor.getDefaultType().getMemberScope().getAllDescriptors()) {
-                checkOverridesForParameters(member);
+                if (member instanceof CallableMemberDescriptor) {
+                    checkOverridesForParameters((CallableMemberDescriptor) member);
+                }
             }
         }
     }

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

@@ -23,7 +23,6 @@ import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiFile;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.descriptors.impl.MutableClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.MutableClassDescriptorLite;
 import org.jetbrains.jet.lang.descriptors.impl.MutablePackageFragmentDescriptor;
 import org.jetbrains.jet.lang.psi.*;
@@ -43,7 +42,7 @@ public class TopDownAnalysisContext implements BodiesResolveContext {
 
     private DataFlowInfo outerDataFlowInfo = DataFlowInfo.EMPTY;
 
-    private final Map<JetClassOrObject, MutableClassDescriptor> classes = Maps.newLinkedHashMap();
+    private final Map<JetClassOrObject, ClassDescriptorWithResolutionScopes> classes = Maps.newLinkedHashMap();
     protected final Map<JetFile, MutablePackageFragmentDescriptor> packageFragments = Maps.newHashMap();
     private List<MutableClassDescriptorLite> classesTopologicalOrder = null;
 
@@ -108,7 +107,7 @@ public class TopDownAnalysisContext implements BodiesResolveContext {
     }
 
     @Override
-    public Map<JetClassOrObject, MutableClassDescriptor> getClasses() {
+    public Map<JetClassOrObject, ClassDescriptorWithResolutionScopes> getClasses() {
         return classes;
     }
 

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

@@ -141,8 +141,8 @@ public class TopDownAnalyzer {
     }
 
     private void lockScopes() {
-        for (MutableClassDescriptor mutableClassDescriptor : context.getClasses().values()) {
+        for (ClassDescriptorWithResolutionScopes mutableClassDescriptor : context.getClasses().values()) {
-            mutableClassDescriptor.lockScopes();
+            ((MutableClassDescriptor) mutableClassDescriptor).lockScopes();
         }
         Set<FqName> scriptFqNames = Sets.newHashSet();
         for (JetFile file : context.getFileScopes().keySet()) {

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

@@ -173,9 +173,9 @@ public class TypeHierarchyResolver {
     }
 
     private void createTypeConstructors() {
-        for (Map.Entry<JetClassOrObject, MutableClassDescriptor> entry : context.getClasses().entrySet()) {
+        for (Map.Entry<JetClassOrObject, ClassDescriptorWithResolutionScopes> entry : context.getClasses().entrySet()) {
             JetClassOrObject classOrObject = entry.getKey();
-            MutableClassDescriptor descriptor = entry.getValue();
+            MutableClassDescriptor descriptor = (MutableClassDescriptor) entry.getValue();
             if (classOrObject instanceof JetClass) {
                 descriptorResolver.resolveMutableClassDescriptor((JetClass) classOrObject, descriptor, trace);
             }
@@ -210,18 +210,18 @@ public class TypeHierarchyResolver {
     }
 
     private void resolveTypesInClassHeaders() {
-        for (Map.Entry<JetClassOrObject, MutableClassDescriptor> entry : context.getClasses().entrySet()) {
+        for (Map.Entry<JetClassOrObject, ClassDescriptorWithResolutionScopes> entry : context.getClasses().entrySet()) {
             JetClassOrObject classOrObject = entry.getKey();
             if (classOrObject instanceof JetClass) {
-                MutableClassDescriptor descriptor = entry.getValue();
+                ClassDescriptorWithResolutionScopes descriptor = entry.getValue();
                 //noinspection unchecked
                 descriptorResolver.resolveGenericBounds((JetClass) classOrObject, descriptor.getScopeForClassHeaderResolution(),
                                                         (List) descriptor.getTypeConstructor().getParameters(), trace);
             }
         }
 
-        for (Map.Entry<JetClassOrObject, MutableClassDescriptor> entry : context.getClasses().entrySet()) {
+        for (Map.Entry<JetClassOrObject, ClassDescriptorWithResolutionScopes> entry : context.getClasses().entrySet()) {
-            descriptorResolver.resolveSupertypesForMutableClassDescriptor(entry.getKey(), entry.getValue(), trace);
+            descriptorResolver.resolveSupertypesForMutableClassDescriptor(entry.getKey(), (MutableClassDescriptor) entry.getValue(), trace);
         }
     }
 

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

@@ -92,7 +92,7 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture {
             return scope;
         }
 
-        private MutableClassDescriptor createClassDescriptor(ClassKind kind, JetClass aClass) {
+        private ClassDescriptorWithResolutionScopes createClassDescriptor(ClassKind kind, JetClass aClass) {
             MutableClassDescriptor classDescriptor = new MutableClassDescriptor(root, scope, kind, false, Name.identifier(aClass.getName()));
             descriptorResolver.resolveMutableClassDescriptor(aClass, classDescriptor, JetTestUtils.DUMMY_TRACE);
             return classDescriptor;
@@ -100,7 +100,7 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture {
 
         private void testClassModality(String classDeclaration, ClassKind kind, Modality expectedModality) {
             JetClass aClass = JetPsiFactory.createClass(getProject(), classDeclaration);
-            MutableClassDescriptor classDescriptor = createClassDescriptor(kind, aClass);
+            ClassDescriptorWithResolutionScopes classDescriptor = createClassDescriptor(kind, aClass);
 
             assertEquals(expectedModality, classDescriptor.getModality());
         }
@@ -108,7 +108,7 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture {
 
         private void testFunctionModality(String classWithFunction, ClassKind kind, Modality expectedFunctionModality) {
             JetClass aClass = JetPsiFactory.createClass(getProject(), classWithFunction);
-            MutableClassDescriptor classDescriptor = createClassDescriptor(kind, aClass);
+            ClassDescriptorWithResolutionScopes classDescriptor = createClassDescriptor(kind, aClass);
 
             List<JetDeclaration> declarations = aClass.getDeclarations();
             JetNamedFunction function = (JetNamedFunction) declarations.get(0);
@@ -121,7 +121,7 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture {
 
         private void testPropertyModality(String classWithProperty, ClassKind kind, Modality expectedPropertyModality) {
             JetClass aClass = JetPsiFactory.createClass(getProject(), classWithProperty);
-            MutableClassDescriptor classDescriptor = createClassDescriptor(kind, aClass);
+            ClassDescriptorWithResolutionScopes classDescriptor = createClassDescriptor(kind, aClass);
 
             List<JetDeclaration> declarations = aClass.getDeclarations();
             JetProperty property = (JetProperty) declarations.get(0);
@@ -134,7 +134,7 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture {
 
         private void testPropertyAccessorModality(String classWithPropertyWithAccessor, ClassKind kind, Modality expectedPropertyAccessorModality, boolean isGetter) {
             JetClass aClass = JetPsiFactory.createClass(getProject(), classWithPropertyWithAccessor);
-            MutableClassDescriptor classDescriptor = createClassDescriptor(kind, aClass);
+            ClassDescriptorWithResolutionScopes classDescriptor = createClassDescriptor(kind, aClass);
 
             List<JetDeclaration> declarations = aClass.getDeclarations();
             JetProperty property = (JetProperty) declarations.get(0);

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

@@ -29,7 +29,6 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.di.InjectorForBodyResolve;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.Annotated;
-import org.jetbrains.jet.lang.descriptors.impl.MutableClassDescriptor;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.*;
 import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo;
@@ -457,7 +456,7 @@ public class ResolveElementCache {
         }
 
         @Override
-        public Map<JetClassOrObject, MutableClassDescriptor> getClasses() {
+        public Map<JetClassOrObject, ClassDescriptorWithResolutionScopes> getClasses() {
             return Collections.emptyMap();
         }
 

idea/src/org/jetbrains/jet/plugin/quickfix/CreateFunctionFromUsageFix.java

@@ -51,8 +51,10 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.analyzer.AnalyzeExhaust;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.descriptors.impl.MutableClassDescriptor;
+import org.jetbrains.jet.lang.diagnostics.Diagnostic;
-import org.jetbrains.jet.lang.diagnostics.*;
+import org.jetbrains.jet.lang.diagnostics.DiagnosticWithParameters1;
+import org.jetbrains.jet.lang.diagnostics.DiagnosticWithParameters2;
+import org.jetbrains.jet.lang.diagnostics.Errors;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingContextUtils;
@@ -669,8 +671,7 @@ public class CreateFunctionFromUsageFix extends CreateFromUsageFixBase {
         if (isExtension) {
             scope = currentFileModule.getPackage(JetPsiUtil.getFQName(currentFile)).getMemberScope();
         } else {
-            assert ownerClassDescriptor instanceof MutableClassDescriptor;
+            scope = ((ClassDescriptorWithResolutionScopes) ownerClassDescriptor).getScopeForMemberDeclarationResolution();
-            scope = ((MutableClassDescriptor) ownerClassDescriptor).getScopeForMemberDeclarationResolution();
         }
 
         // figure out type substitutions for type parameters