Test utility moved to tests

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

@@ -41,89 +41,6 @@ public class ClassDescriptorResolver {
         this.annotationResolver = new AnnotationResolver(semanticServices, trace);
     }
 
-    @Nullable
-    public ClassDescriptor resolveClassDescriptor(@NotNull JetScope scope, @NotNull JetClass classElement) {
-        final ClassDescriptorImpl classDescriptor = new ClassDescriptorImpl(
-                scope.getContainingDeclaration(),
-                annotationResolver.resolveAnnotations(scope, classElement.getModifierList()),
-                JetPsiUtil.safeName(classElement.getName()));
-
-        trace.record(BindingContext.CLASS, classElement, classDescriptor);
-
-        final WritableScope parameterScope = new WritableScopeImpl(scope, classDescriptor, trace.getErrorHandler());
-
-        // This call has side-effects on the parameterScope (fills it in)
-        List<TypeParameterDescriptor> typeParameters
-                = resolveTypeParameters(classDescriptor, parameterScope, classElement.getTypeParameters());
-        resolveGenericBounds(classElement, parameterScope, typeParameters);
-
-        List<JetDelegationSpecifier> delegationSpecifiers = classElement.getDelegationSpecifiers();
-        // TODO : assuming that the hierarchy is acyclic
-        Collection<JetType> supertypes = delegationSpecifiers.isEmpty()
-                ? Collections.singleton(JetStandardClasses.getAnyType())
-                : resolveDelegationSpecifiers(parameterScope, delegationSpecifiers, typeResolver);
-//        for (JetType supertype: supertypes) {
-//            if (supertype.getConstructor().isSealed()) {
-//                trace.getErrorHandler().genericError(classElement.getNameAsDeclaration().getNode(), "Class " + classElement.getName() + " can not extend final type " + supertype);
-//            }
-//        }
-        boolean open = classElement.hasModifier(JetTokens.OPEN_KEYWORD);
-
-        final WritableScope memberDeclarations = new WritableScopeImpl(JetScope.EMPTY, classDescriptor, trace.getErrorHandler());
-
-        List<JetDeclaration> declarations = classElement.getDeclarations();
-        for (JetDeclaration declaration : declarations) {
-            declaration.accept(new JetVisitorVoid() {
-                @Override
-                public void visitProperty(JetProperty property) {
-                    if (property.getPropertyTypeRef() != null) {
-                        memberDeclarations.addVariableDescriptor(resolvePropertyDescriptor(classDescriptor, parameterScope, property));
-                    } else {
-                        // TODO : Caution: a cyclic dependency possible
-                        throw new UnsupportedOperationException();
-                    }
-                }
-
-                @Override
-                public void visitNamedFunction(JetNamedFunction function) {
-                    if (function.getReturnTypeRef() != null) {
-                        memberDeclarations.addFunctionDescriptor(resolveFunctionDescriptor(classDescriptor, parameterScope, function));
-                    } else {
-                        // TODO : Caution: a cyclic dependency possible
-                        throw new UnsupportedOperationException();
-                    }
-                }
-
-                @Override
-                public void visitJetElement(JetElement element) {
-                    throw new UnsupportedOperationException(element.toString());
-                }
-            });
-        }
-
-        WritableFunctionGroup constructors = new WritableFunctionGroup("<init>");
-        classDescriptor.initialize(
-                !open,
-                typeParameters,
-                supertypes,
-                memberDeclarations,
-                constructors,
-                null
-        );
-        for (JetConstructor constructor : classElement.getSecondaryConstructors()) {
-            ConstructorDescriptorImpl functionDescriptor = resolveSecondaryConstructorDescriptor(memberDeclarations, classDescriptor, constructor);
-            functionDescriptor.setReturnType(classDescriptor.getDefaultType());
-            constructors.addFunction(functionDescriptor);
-        }
-        ConstructorDescriptorImpl primaryConstructorDescriptor = resolvePrimaryConstructorDescriptor(scope, classDescriptor, classElement);
-        if (primaryConstructorDescriptor != null) {
-            primaryConstructorDescriptor.setReturnType(classDescriptor.getDefaultType());
-            constructors.addFunction(primaryConstructorDescriptor);
-            classDescriptor.setPrimaryConstructor(primaryConstructorDescriptor);
-        }
-        return classDescriptor;
-    }
-
     public void resolveMutableClassDescriptor(@NotNull JetClass classElement, @NotNull MutableClassDescriptor descriptor) {
         // TODO : Where-clause
         List<TypeParameterDescriptor> typeParameters = Lists.newArrayList();
@@ -398,7 +315,7 @@ public class ClassDescriptorResolver {
         return jetType;
     }
 
-    private Collection<JetType> resolveDelegationSpecifiers(JetScope extensibleScope, List<JetDelegationSpecifier> delegationSpecifiers, @NotNull TypeResolver resolver) {
+    public Collection<JetType> resolveDelegationSpecifiers(JetScope extensibleScope, List<JetDelegationSpecifier> delegationSpecifiers, @NotNull TypeResolver resolver) {
         if (delegationSpecifiers.isEmpty()) {
             return Collections.emptyList();
         }

idea/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java

@@ -6,19 +6,20 @@ import com.intellij.openapi.application.PathManager;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.projectRoots.Sdk;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.JetTestCaseBase;
 import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.lang.ErrorHandler;
 import org.jetbrains.jet.lang.JetSemanticServices;
 import org.jetbrains.jet.lang.cfg.JetFlowInformationProvider;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.psi.JetChangeUtil;
+import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
-import org.jetbrains.jet.lang.psi.JetClass;
+import org.jetbrains.jet.lang.psi.*;
-import org.jetbrains.jet.lang.psi.JetExpression;
 import org.jetbrains.jet.lang.resolve.*;
 import org.jetbrains.jet.lang.resolve.java.JavaPackageScope;
 import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
 import org.jetbrains.jet.lang.types.*;
+import org.jetbrains.jet.lexer.JetTokens;
 import org.jetbrains.jet.parsing.JetParsingTest;
 
 import java.io.File;
@@ -34,6 +35,7 @@ public class JetTypeCheckerTest extends LightDaemonAnalyzerTestCase {
     private ClassDefinitions classDefinitions;
     private ClassDescriptorResolver classDescriptorResolver;
     private JetScope scopeWithImports;
+    private TypeResolver typeResolver;
 
     @Override
     public void setUp() throws Exception {
@@ -43,6 +45,7 @@ public class JetTypeCheckerTest extends LightDaemonAnalyzerTestCase {
         classDefinitions = new ClassDefinitions();
         classDescriptorResolver = semanticServices.getClassDescriptorResolver(JetTestUtils.DUMMY_TRACE);
         scopeWithImports = addImports(classDefinitions.BASIC_SCOPE);
+        typeResolver = new TypeResolver(semanticServices, JetTestUtils.DUMMY_TRACE, true);
     }
 
     @Override
@@ -592,7 +595,7 @@ public class JetTypeCheckerTest extends LightDaemonAnalyzerTestCase {
                 if (CLASSES.isEmpty()) {
                     for (String classDeclaration : CLASS_DECLARATIONS) {
                         JetClass classElement = JetChangeUtil.createClass(getProject(), classDeclaration);
-                        ClassDescriptor classDescriptor = classDescriptorResolver.resolveClassDescriptor(this, classElement);
+                        ClassDescriptor classDescriptor = resolveClassDescriptor(this, classElement);
                         CLASSES.put(classDescriptor.getName(), classDescriptor);
                     }
                 }
@@ -622,5 +625,91 @@ public class JetTypeCheckerTest extends LightDaemonAnalyzerTestCase {
                 return writableFunctionGroup;
             }
         };
+
+        @Nullable
+        public ClassDescriptor resolveClassDescriptor(@NotNull JetScope scope, @NotNull JetClass classElement) {
+            final ClassDescriptorImpl classDescriptor = new ClassDescriptorImpl(
+                    scope.getContainingDeclaration(),
+                    Collections.<AnnotationDescriptor>emptyList(),
+                    JetPsiUtil.safeName(classElement.getName()));
+
+            BindingTrace trace = JetTestUtils.DUMMY_TRACE;
+
+            trace.record(BindingContext.CLASS, classElement, classDescriptor);
+
+            final WritableScope parameterScope = new WritableScopeImpl(scope, classDescriptor, trace.getErrorHandler());
+
+            // This call has side-effects on the parameterScope (fills it in)
+            List<TypeParameterDescriptor> typeParameters
+                    = classDescriptorResolver.resolveTypeParameters(classDescriptor, parameterScope, classElement.getTypeParameters());
+            classDescriptorResolver.resolveGenericBounds(classElement, parameterScope, typeParameters);
+
+            List<JetDelegationSpecifier> delegationSpecifiers = classElement.getDelegationSpecifiers();
+            // TODO : assuming that the hierarchy is acyclic
+            Collection<JetType> supertypes = delegationSpecifiers.isEmpty()
+                    ? Collections.singleton(JetStandardClasses.getAnyType())
+                    : classDescriptorResolver.resolveDelegationSpecifiers(parameterScope, delegationSpecifiers, typeResolver);
+    //        for (JetType supertype: supertypes) {
+    //            if (supertype.getConstructor().isSealed()) {
+    //                trace.getErrorHandler().genericError(classElement.getNameAsDeclaration().getNode(), "Class " + classElement.getName() + " can not extend final type " + supertype);
+    //            }
+    //        }
+            boolean open = classElement.hasModifier(JetTokens.OPEN_KEYWORD);
+
+            final WritableScope memberDeclarations = new WritableScopeImpl(JetScope.EMPTY, classDescriptor, trace.getErrorHandler());
+
+            List<JetDeclaration> declarations = classElement.getDeclarations();
+            for (JetDeclaration declaration : declarations) {
+                declaration.accept(new JetVisitorVoid() {
+                    @Override
+                    public void visitProperty(JetProperty property) {
+                        if (property.getPropertyTypeRef() != null) {
+                            memberDeclarations.addVariableDescriptor(classDescriptorResolver.resolvePropertyDescriptor(classDescriptor, parameterScope, property));
+                        } else {
+                            // TODO : Caution: a cyclic dependency possible
+                            throw new UnsupportedOperationException();
+                        }
+                    }
+
+                    @Override
+                    public void visitNamedFunction(JetNamedFunction function) {
+                        if (function.getReturnTypeRef() != null) {
+                            memberDeclarations.addFunctionDescriptor(classDescriptorResolver.resolveFunctionDescriptor(classDescriptor, parameterScope, function));
+                        } else {
+                            // TODO : Caution: a cyclic dependency possible
+                            throw new UnsupportedOperationException();
+                        }
+                    }
+
+                    @Override
+                    public void visitJetElement(JetElement element) {
+                        throw new UnsupportedOperationException(element.toString());
+                    }
+                });
+            }
+
+            WritableFunctionGroup constructors = new WritableFunctionGroup("<init>");
+            classDescriptor.initialize(
+                    !open,
+                    typeParameters,
+                    supertypes,
+                    memberDeclarations,
+                    constructors,
+                    null
+            );
+            for (JetConstructor constructor : classElement.getSecondaryConstructors()) {
+                ConstructorDescriptorImpl functionDescriptor = classDescriptorResolver.resolveSecondaryConstructorDescriptor(memberDeclarations, classDescriptor, constructor);
+                functionDescriptor.setReturnType(classDescriptor.getDefaultType());
+                constructors.addFunction(functionDescriptor);
+            }
+            ConstructorDescriptorImpl primaryConstructorDescriptor = classDescriptorResolver.resolvePrimaryConstructorDescriptor(scope, classDescriptor, classElement);
+            if (primaryConstructorDescriptor != null) {
+                primaryConstructorDescriptor.setReturnType(classDescriptor.getDefaultType());
+                constructors.addFunction(primaryConstructorDescriptor);
+                classDescriptor.setPrimaryConstructor(primaryConstructorDescriptor);
+            }
+            return classDescriptor;
+        }
+
     }
 }