resolveMutableClassDescriptor() removed

compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java

@@ -108,43 +108,6 @@ public class DescriptorResolver {
         this.builtIns = builtIns;
     }
 
-    public void resolveMutableClassDescriptor(
-            @NotNull JetClass classElement,
-            @NotNull MutableClassDescriptor descriptor,
-            BindingTrace trace
-    ) {
-        // TODO : Where-clause
-        List<JetTypeParameter> typeParameters = classElement.getTypeParameters();
-        List<TypeParameterDescriptor> typeParameterDescriptors = new ArrayList<TypeParameterDescriptor>(typeParameters.size());
-        if (descriptor.getKind() == ClassKind.ENUM_CLASS) {
-            JetTypeParameterList typeParameterList = classElement.getTypeParameterList();
-            if (typeParameterList != null) {
-                trace.report(TYPE_PARAMETERS_IN_ENUM.on(typeParameterList));
-            }
-        }
-        int index = 0;
-        for (JetTypeParameter typeParameter : typeParameters) {
-            TypeParameterDescriptor typeParameterDescriptor = TypeParameterDescriptorImpl.createForFurtherModification(
-                    descriptor,
-                    Annotations.EMPTY,
-                    typeParameter.hasModifier(JetTokens.REIFIED_KEYWORD),
-                    typeParameter.getVariance(),
-                    JetPsiUtil.safeName(typeParameter.getName()),
-                    index,
-                    toSourceElement(typeParameter)
-            );
-            trace.record(BindingContext.TYPE_PARAMETER, typeParameter, typeParameterDescriptor);
-            typeParameterDescriptors.add(typeParameterDescriptor);
-            index++;
-        }
-        descriptor.setTypeParameterDescriptors(typeParameterDescriptors);
-        Modality defaultModality = descriptor.getKind() == ClassKind.TRAIT ? Modality.ABSTRACT : Modality.FINAL;
-        descriptor.setModality(resolveModalityFromModifiers(classElement, defaultModality));
-        descriptor.setVisibility(resolveVisibilityFromModifiers(classElement, getDefaultClassVisibility(descriptor)));
-
-        trace.record(BindingContext.CLASS, classElement, descriptor);
-    }
-
     public List<JetType> resolveSupertypes(
             @NotNull JetScope scope,
             @NotNull ClassDescriptor classDescriptor,

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

@@ -16,31 +16,33 @@
 
 package org.jetbrains.kotlin.types;
 
-import com.google.common.base.Predicates;
-import com.intellij.psi.PsiFile;
 import org.jetbrains.kotlin.analyzer.AnalysisResult;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.kotlin.context.ContextPackage;
+import org.jetbrains.kotlin.context.GlobalContextImpl;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
-import org.jetbrains.kotlin.descriptors.impl.MutableClassDescriptor;
+import org.jetbrains.kotlin.di.InjectorForLazyResolve;
 import org.jetbrains.kotlin.di.InjectorForTests;
 import org.jetbrains.kotlin.psi.*;
+import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider;
 import org.jetbrains.kotlin.resolve.BindingContext;
+import org.jetbrains.kotlin.resolve.BindingTraceContext;
 import org.jetbrains.kotlin.resolve.DescriptorResolver;
-import org.jetbrains.kotlin.resolve.TopDownAnalysisParameters;
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
 import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil;
+import org.jetbrains.kotlin.resolve.lazy.ResolveSession;
+import org.jetbrains.kotlin.resolve.lazy.declarations.FileBasedDeclarationProviderFactory;
 import org.jetbrains.kotlin.resolve.scopes.JetScope;
 import org.jetbrains.kotlin.resolve.scopes.RedeclarationHandler;
 import org.jetbrains.kotlin.resolve.scopes.WritableScope;
 import org.jetbrains.kotlin.resolve.scopes.WritableScopeImpl;
-import org.jetbrains.kotlin.storage.ExceptionTracker;
-import org.jetbrains.kotlin.storage.LockBasedStorageManager;
 import org.jetbrains.kotlin.test.ConfigurationKind;
 import org.jetbrains.kotlin.test.JetLiteFixture;
 import org.jetbrains.kotlin.test.JetTestUtils;
 
+import java.util.Collections;
 import java.util.List;
 
 import static org.jetbrains.kotlin.psi.PsiPackage.JetPsiFactory;
@@ -97,14 +99,19 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture {
         }
 
         private ClassDescriptorWithResolutionScopes createClassDescriptor(ClassKind kind, JetClass aClass) {
-            MutableClassDescriptor classDescriptor =
+            GlobalContextImpl globalContext = ContextPackage.GlobalContext();
-                    new MutableClassDescriptor(root, scope, kind, false, aClass.getNameAsSafeName(), SourceElement.NO_SOURCE);
+            ResolveSession resolveSession = new InjectorForLazyResolve(
-            TopDownAnalysisParameters parameters = TopDownAnalysisParameters.create(
+                    getProject(),
-                    LockBasedStorageManager.NO_LOCKS, new ExceptionTracker(), Predicates.<PsiFile>alwaysTrue(), false, false
+                    globalContext,
-            );
+                    root,
-            descriptorResolver.resolveMutableClassDescriptor(
+                    new FileBasedDeclarationProviderFactory(globalContext.getStorageManager(),
-                    aClass, classDescriptor, JetTestUtils.DUMMY_TRACE);
+                                                            Collections.singleton(aClass.getContainingJetFile())),
-            return classDescriptor;
+                    new BindingTraceContext(),
+                    AdditionalCheckerProvider.DefaultProvider.INSTANCE$,
+                    new DynamicTypesSettings()
+            ).getResolveSession();
+
+            return (ClassDescriptorWithResolutionScopes) resolveSession.getClassDescriptor(aClass);
         }
 
         private void testClassModality(String classDeclaration, ClassKind kind, Modality expectedModality) {