diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ClassDescriptorResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ClassDescriptorResolver.java index e7907de6ad0..2b0b2645e6a 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ClassDescriptorResolver.java +++ b/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 typeParameters - = resolveTypeParameters(classDescriptor, parameterScope, classElement.getTypeParameters()); - resolveGenericBounds(classElement, parameterScope, typeParameters); - - List delegationSpecifiers = classElement.getDelegationSpecifiers(); - // TODO : assuming that the hierarchy is acyclic - Collection 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 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(""); - 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 typeParameters = Lists.newArrayList(); @@ -398,7 +315,7 @@ public class ClassDescriptorResolver { return jetType; } - private Collection resolveDelegationSpecifiers(JetScope extensibleScope, List delegationSpecifiers, @NotNull TypeResolver resolver) { + public Collection resolveDelegationSpecifiers(JetScope extensibleScope, List delegationSpecifiers, @NotNull TypeResolver resolver) { if (delegationSpecifiers.isEmpty()) { return Collections.emptyList(); } diff --git a/idea/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java b/idea/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java index b3e2b853a99..d531312e086 100644 --- a/idea/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java +++ b/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.psi.JetClass; -import org.jetbrains.jet.lang.psi.JetExpression; +import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; +import org.jetbrains.jet.lang.psi.*; 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.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 typeParameters + = classDescriptorResolver.resolveTypeParameters(classDescriptor, parameterScope, classElement.getTypeParameters()); + classDescriptorResolver.resolveGenericBounds(classElement, parameterScope, typeParameters); + + List delegationSpecifiers = classElement.getDelegationSpecifiers(); + // TODO : assuming that the hierarchy is acyclic + Collection 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 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(""); + 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; + } + } }