From 6132946ceda57a801d60cb1a5bee281113443b86 Mon Sep 17 00:00:00 2001 From: "Pavel V. Talanov" Date: Mon, 27 Aug 2012 14:21:53 +0400 Subject: [PATCH] Introduce ClassKind#CLASS_OBJECT and ClassKind#isObject and usages. Rename LazyClassDescriptor#onlyEnumEntries -> enumClassObjectInfo. Determine ClassKind in JetClassInfo and JetObjectInfo constructor. Remove complex constructor for enum entry in enum test. Logic simplified in LazyClassMemberScope. Minor refactorings. --- .../jet/codegen/ClosureAnnotator.java | 8 ++- .../jetbrains/jet/codegen/JetTypeMapper.java | 2 +- .../resolve/java/JavaDescriptorResolver.java | 6 +-- .../jet/lang/descriptors/ClassKind.java | 7 ++- .../MutableClassDescriptorLite.java | 6 +-- .../jet/lang/resolve/DescriptorUtils.java | 29 ++-------- .../resolve/QualifiedExpressionResolver.java | 2 +- .../lang/resolve/TypeHierarchyResolver.java | 16 +++--- .../lang/resolve/calls/TaskPrioritizer.java | 3 +- .../resolve/lazy/LazyClassDescriptor.java | 13 +++-- .../resolve/lazy/LazyClassMemberScope.java | 53 ++++++++++--------- .../lang/resolve/lazy/data/JetClassInfo.java | 24 +++++++-- .../resolve/lazy/data/JetClassInfoUtil.java | 6 +-- .../lang/resolve/lazy/data/JetObjectInfo.java | 12 ++++- .../scopes/InnerClassesScopeWrapper.java | 3 +- .../resolve/scopes/WritableScopeImpl.java | 18 +++++-- .../jet/resolve/DescriptorRenderer.java | 20 +++---- .../descriptorRenderer/ClassObject.kt | 2 +- .../lazyResolve/namespaceComparator/enum.kt | 3 +- .../lazyResolve/namespaceComparator/enum.txt | 9 +--- compiler/testData/renderer/Classes.kt | 2 +- .../jet/test/util/NamespaceComparator.java | 2 +- .../jet/plugin/JetDescriptorIconProvider.java | 2 + .../libraries/DecompiledDataFactory.java | 2 +- .../StandardLibraryReferenceResolver.java | 2 +- 25 files changed, 130 insertions(+), 122 deletions(-) diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ClosureAnnotator.java b/compiler/backend/src/org/jetbrains/jet/codegen/ClosureAnnotator.java index aba938743af..8bd1ff9b0ce 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ClosureAnnotator.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ClosureAnnotator.java @@ -22,7 +22,6 @@ import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; -import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.java.JvmAbi; import org.jetbrains.jet.lang.resolve.java.JvmClassName; import org.jetbrains.jet.lang.resolve.name.FqName; @@ -219,10 +218,9 @@ public class ClosureAnnotator { } public boolean hasThis0(ClassDescriptor classDescriptor) { - if (DescriptorUtils.isClassObject(classDescriptor)) { - return false; - } - if (classDescriptor.getKind() == ClassKind.ENUM_CLASS || classDescriptor.getKind() == ClassKind.ENUM_ENTRY) { + if (classDescriptor.getKind() == ClassKind.ENUM_CLASS + || classDescriptor.getKind() == ClassKind.ENUM_ENTRY + || classDescriptor.getKind() == ClassKind.CLASS_OBJECT) { return false; } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java b/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java index e6c80836b46..b5ad7be0287 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java @@ -375,7 +375,7 @@ public class JetTypeMapper { if (descriptor instanceof ClassDescriptor) { ClassDescriptor klass = (ClassDescriptor) descriptor; - if (klass.getKind() == ClassKind.OBJECT) { + if (klass.getKind() == ClassKind.OBJECT || klass.getKind() == ClassKind.CLASS_OBJECT) { if (klass.getContainingDeclaration() instanceof ClassDescriptor) { ClassDescriptor containingKlass = (ClassDescriptor) klass.getContainingDeclaration(); if (containingKlass.getKind() == ClassKind.ENUM_CLASS) { diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java index 64321be8af8..d41d96645eb 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java @@ -451,7 +451,7 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes PsiMethod[] psiConstructors = psiClass.getConstructors(); boolean isStatic = psiClass.hasModifierProperty(PsiModifier.STATIC); - if (classData.classDescriptor.getKind() == ClassKind.OBJECT) { + if (classData.classDescriptor.getKind() == ClassKind.OBJECT || classData.classDescriptor.getKind() == ClassKind.CLASS_OBJECT) { // TODO: wrong: class objects do not need visible constructors ConstructorDescriptorImpl constructor = new ConstructorDescriptorImpl(classData.classDescriptor, new ArrayList(0), true); Visibility visibility = psiConstructors.length != 0 @@ -592,7 +592,7 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes FqName fqName = new FqName(classObjectPsiClass.getQualifiedName()); ResolverClassData classData = new ClassDescriptorFromJvmBytecode( - containing, ClassKind.OBJECT, classObjectPsiClass, fqName, this) + containing, ClassKind.CLASS_OBJECT, classObjectPsiClass, fqName, this) .getResolverBinaryClassData(); ClassDescriptorFromJvmBytecode classObjectDescriptor = classData.classDescriptor; @@ -608,7 +608,7 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes assert psiClassQualifiedName != null : "Reading java class with no qualified name"; FqNameUnsafe fqName = new FqNameUnsafe(psiClassQualifiedName + "." + getClassObjectName(psiClass.getName()).getName()); ClassDescriptorFromJvmBytecode classObjectDescriptor = new ClassDescriptorFromJvmBytecode( - containing, ClassKind.OBJECT, psiClass, null, this); + containing, ClassKind.CLASS_OBJECT, psiClass, null, this); ResolverEnumClassObjectClassData data = new ResolverEnumClassObjectClassData(psiClass, null, classObjectDescriptor); setUpClassObjectDescriptor(containing, fqName, data, getClassObjectName(containing.getName().getName())); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ClassKind.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ClassKind.java index bbb1fec3b8d..507988ba204 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ClassKind.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ClassKind.java @@ -25,5 +25,10 @@ public enum ClassKind { ENUM_CLASS, ENUM_ENTRY, ANNOTATION_CLASS, - OBJECT + OBJECT, + CLASS_OBJECT; + + public boolean isObject() { + return this == OBJECT || this == CLASS_OBJECT || this == ENUM_ENTRY; + } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/MutableClassDescriptorLite.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/MutableClassDescriptorLite.java index b45513ba267..1a5a6affdb7 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/MutableClassDescriptorLite.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/MutableClassDescriptorLite.java @@ -107,7 +107,7 @@ public abstract class MutableClassDescriptorLite extends ClassDescriptorBase } else if (declarationDescriptor instanceof ClassDescriptor) { ClassDescriptor classDescriptor = (ClassDescriptor) declarationDescriptor; - return classDescriptor.getKind() == ClassKind.OBJECT || classDescriptor.getKind() == ClassKind.ENUM_CLASS; + return classDescriptor.getKind().isObject() || classDescriptor.getKind() == ClassKind.ENUM_CLASS; } else { return false; @@ -296,7 +296,7 @@ public abstract class MutableClassDescriptorLite extends ClassDescriptorBase @Override public ClassObjectStatus setClassObjectDescriptor(@NotNull MutableClassDescriptorLite classObjectDescriptor) { - if (getKind() == ClassKind.OBJECT) { + if (getKind().isObject()) { return ClassObjectStatus.NOT_ALLOWED; } @@ -308,7 +308,7 @@ public abstract class MutableClassDescriptorLite extends ClassDescriptorBase return ClassObjectStatus.NOT_ALLOWED; } - assert classObjectDescriptor.getKind() == ClassKind.OBJECT; + assert classObjectDescriptor.getKind() == ClassKind.CLASS_OBJECT; MutableClassDescriptorLite.this.classObjectDescriptor = classObjectDescriptor; return ClassObjectStatus.OK; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java index 78f5df9739e..cf4b4b98cd8 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java @@ -231,19 +231,6 @@ public class DescriptorUtils { return expectedType != null ? expectedType : TypeUtils.NO_EXPECTED_TYPE; } - public static boolean isObject(@NotNull ClassifierDescriptor classifier) { - if (classifier instanceof ClassDescriptor) { - ClassDescriptor clazz = (ClassDescriptor) classifier; - return clazz.getKind() == ClassKind.OBJECT || clazz.getKind() == ClassKind.ENUM_ENTRY; - } - else if (classifier instanceof TypeParameterDescriptor) { - return false; - } - else { - throw new IllegalStateException("unknown classifier: " + classifier); - } - } - public static boolean isSubclass(@NotNull ClassDescriptor subClass, @NotNull ClassDescriptor superClass) { return isSubtypeOfClass(subClass.getDefaultType(), superClass.getOriginal()); } @@ -292,18 +279,8 @@ public class DescriptorUtils { } public static boolean isClassObject(@NotNull DeclarationDescriptor descriptor) { - if (descriptor instanceof ClassDescriptor) { - ClassDescriptor classDescriptor = (ClassDescriptor) descriptor; - if (classDescriptor.getKind() == ClassKind.OBJECT) { - if (classDescriptor.getContainingDeclaration() instanceof ClassDescriptor) { - ClassDescriptor containingDeclaration = (ClassDescriptor) classDescriptor.getContainingDeclaration(); - if (classDescriptor.getDefaultType().equals(containingDeclaration.getClassObjectType())) { - return true; - } - } - } - } - return false; + return descriptor instanceof ClassDescriptor + && ((ClassDescriptor) descriptor).getKind() == ClassKind.CLASS_OBJECT; } @NotNull @@ -340,7 +317,7 @@ public class DescriptorUtils { if (containingDeclaration instanceof ClassDescriptor) { ClassDescriptor classDescriptor = (ClassDescriptor) containingDeclaration; - if (classDescriptor.getKind() == ClassKind.OBJECT) { + if (classDescriptor.getKind().isObject()) { return inStaticContext(classDescriptor.getContainingDeclaration()); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/QualifiedExpressionResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/QualifiedExpressionResolver.java index 613635d667a..aa43cdd006e 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/QualifiedExpressionResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/QualifiedExpressionResolver.java @@ -120,7 +120,7 @@ public class QualifiedExpressionResolver { if (descriptor instanceof NamespaceDescriptor) { return true; } - if (descriptor instanceof ClassDescriptor && ((ClassDescriptor)descriptor).getKind() != ClassKind.OBJECT) { + if (descriptor instanceof ClassDescriptor && !((ClassDescriptor)descriptor).getKind().isObject()) { return true; } trace.report(CANNOT_IMPORT_FROM_ELEMENT.on(reference, descriptor)); 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 5ebe4012f22..1cde4f00066 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java @@ -168,7 +168,7 @@ public class TypeHierarchyResolver { if (ownerDescriptor instanceof MutableClassDescriptor) { MutableClassDescriptor classDescriptor = (MutableClassDescriptor) ownerDescriptor; - if (classDescriptor.getKind() == ClassKind.OBJECT) { + if (classDescriptor.getKind() == ClassKind.CLASS_OBJECT) { return classDescriptor.getScopeForMemberResolution(); } @@ -231,8 +231,9 @@ public class TypeHierarchyResolver { @Override public void visitObjectDeclaration(JetObjectDeclaration declaration) { - final MutableClassDescriptor objectDescriptor = - createClassDescriptorForObject(declaration, owner, outerScope, JetPsiUtil.safeName(declaration.getName())); + MutableClassDescriptor objectDescriptor = + createClassDescriptorForObject(declaration, owner, outerScope, JetPsiUtil.safeName(declaration.getName()), + ClassKind.OBJECT); owner.addObjectDescriptor(objectDescriptor); trace.record(FQNAME_TO_CLASS_DESCRIPTOR, JetPsiUtil.getFQName(declaration), objectDescriptor); } @@ -274,7 +275,8 @@ public class TypeHierarchyResolver { if (objectDeclaration != null) { Name classObjectName = getClassObjectName(owner.getOwnerForChildren().getName()); MutableClassDescriptor classObjectDescriptor = - createClassDescriptorForObject(objectDeclaration, owner, getStaticScope(classObject, owner), classObjectName); + createClassDescriptorForObject(objectDeclaration, owner, getStaticScope(classObject, owner), + classObjectName, ClassKind.CLASS_OBJECT); NamespaceLikeBuilder.ClassObjectStatus status = owner.setClassObjectDescriptor(classObjectDescriptor); switch (status) { case DUPLICATE: @@ -293,7 +295,7 @@ public class TypeHierarchyResolver { private void createClassObjectForEnumClass(JetClass klass, MutableClassDescriptor mutableClassDescriptor) { if (klass.hasModifier(JetTokens.ENUM_KEYWORD)) { MutableClassDescriptor classObjectDescriptor = new MutableClassDescriptor( - mutableClassDescriptor, outerScope, ClassKind.OBJECT, + mutableClassDescriptor, outerScope, ClassKind.CLASS_OBJECT, getClassObjectName(klass.getName())); mutableClassDescriptor.getBuilder().setClassObjectDescriptor(classObjectDescriptor); classObjectDescriptor.setModality(Modality.FINAL); @@ -310,10 +312,10 @@ public class TypeHierarchyResolver { private MutableClassDescriptor createClassDescriptorForObject( @NotNull JetObjectDeclaration declaration, @NotNull NamespaceLikeBuilder owner, - @NotNull JetScope scope, @NotNull Name name + @NotNull JetScope scope, @NotNull Name name, @NotNull ClassKind kind ) { MutableClassDescriptor mutableClassDescriptor = new MutableClassDescriptor( - owner.getOwnerForChildren(), scope, ClassKind.OBJECT, name); + owner.getOwnerForChildren(), scope, kind, name); context.getObjects().put(declaration, mutableClassDescriptor); JetScope classScope = mutableClassDescriptor.getScopeForMemberResolution(); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TaskPrioritizer.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TaskPrioritizer.java index 03ff29fdcb6..5fd76ac61de 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TaskPrioritizer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TaskPrioritizer.java @@ -40,6 +40,7 @@ import java.util.Collection; import java.util.Collections; import java.util.List; +import static org.jetbrains.jet.lang.resolve.DescriptorUtils.isClassObject; import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor.NO_RECEIVER; /** @@ -209,7 +210,7 @@ import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor assert containingDeclaration != null; containingDeclaration = containingDeclaration.getContainingDeclaration(); } - if (containingDeclaration instanceof ClassDescriptor && DescriptorUtils.isClassObject(containingDeclaration)) { + if (containingDeclaration != null && isClassObject(containingDeclaration)) { ResolutionCandidate candidate = ResolutionCandidate.create(descriptor); candidate.setThisObject(new ClassReceiver((ClassDescriptor) containingDeclaration)); candidate.setExplicitReceiverKind(ExplicitReceiverKind.NO_EXPLICIT_RECEIVER); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyClassDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyClassDescriptor.java index 8999a04517c..b482f56421c 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyClassDescriptor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyClassDescriptor.java @@ -25,7 +25,10 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.*; 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.AnnotationResolver; +import org.jetbrains.jet.lang.resolve.BindingContext; +import org.jetbrains.jet.lang.resolve.DescriptorUtils; +import org.jetbrains.jet.lang.resolve.ModifiersChecker; import org.jetbrains.jet.lang.resolve.lazy.data.FilteringClassLikeInfo; import org.jetbrains.jet.lang.resolve.lazy.data.JetClassInfoUtil; import org.jetbrains.jet.lang.resolve.lazy.data.JetClassLikeInfo; @@ -102,7 +105,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes this.typeConstructor = new LazyClassTypeConstructor(); this.kind = classLikeInfo.getClassKind(); - if (kind == ClassKind.OBJECT) { + if (kind.isObject()) { this.modality = Modality.FINAL; } else { @@ -241,7 +244,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes else { if (getKind() == ClassKind.ENUM_CLASS) { // Enum classes always have class objects, and enum constants are their members - return onlyEnumEntries(originalClassInfo); + return enumClassObjectInfo(originalClassInfo); } } return null; @@ -395,7 +398,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes return new FilteringClassLikeInfo(classLikeInfo, Predicates.not(ONLY_ENUM_ENTRIES)); } - private static JetClassLikeInfo onlyEnumEntries(JetClassLikeInfo classLikeInfo) { + private static JetClassLikeInfo enumClassObjectInfo(JetClassLikeInfo classLikeInfo) { return new FilteringClassLikeInfo(classLikeInfo, ONLY_ENUM_ENTRIES) { @Override public JetClassOrObject getCorrespondingClassOrObject() { @@ -405,7 +408,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes @NotNull @Override public ClassKind getClassKind() { - return ClassKind.OBJECT; + return ClassKind.CLASS_OBJECT; } @NotNull diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyClassMemberScope.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyClassMemberScope.java index 0c082e269bf..e9ec962634b 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyClassMemberScope.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyClassMemberScope.java @@ -39,6 +39,11 @@ import java.util.*; */ public class LazyClassMemberScope extends AbstractLazyMemberScope { + @NotNull + private static final Set GENERATE_CONSTRUCTORS_FOR = + EnumSet.of(ClassKind.CLASS, ClassKind.ANNOTATION_CLASS, ClassKind.OBJECT, + ClassKind.ENUM_CLASS, ClassKind.ENUM_ENTRY, ClassKind.CLASS_OBJECT); + private interface MemberExtractor { MemberExtractor EXTRACT_FUNCTIONS = new MemberExtractor() { @NotNull @@ -277,33 +282,29 @@ public class LazyClassMemberScope extends AbstractLazyMemberScope generateConstructorsFor = - EnumSet.of(ClassKind.CLASS, ClassKind.ANNOTATION_CLASS, ClassKind.OBJECT, ClassKind.ENUM_CLASS, ClassKind.ENUM_ENTRY); - if (generateConstructorsFor.contains(thisDescriptor.getKind())) { - JetClassOrObject classOrObject = declarationProvider.getOwnerInfo().getCorrespondingClassOrObject(); - if ( - thisDescriptor.getKind() != ClassKind.OBJECT // a fake class object of an enum class - && !declaresObjectOrEnumConstant(classOrObject) // normal objects and enum entries with no constructors - ) { - JetClass jetClass = (JetClass) classOrObject; - ConstructorDescriptorImpl constructor = resolveSession.getInjector().getDescriptorResolver() - .resolvePrimaryConstructorDescriptor(thisDescriptor.getScopeForClassHeaderResolution(), - thisDescriptor, - jetClass, - resolveSession.getTrace()); - primaryConstructor = constructor; - setDeferredReturnType(constructor); - } - else { - ConstructorDescriptorImpl constructor = - DescriptorResolver.createPrimaryConstructorForObject(classOrObject, thisDescriptor, resolveSession.getTrace()); - setDeferredReturnType(constructor); - primaryConstructor = constructor; - } - } - primaryConstructorResolved = true; + if (primaryConstructorResolved) { + return primaryConstructor; } + if (GENERATE_CONSTRUCTORS_FOR.contains(thisDescriptor.getKind())) { + JetClassOrObject classOrObject = declarationProvider.getOwnerInfo().getCorrespondingClassOrObject(); + if (!thisDescriptor.getKind().isObject()) { + JetClass jetClass = (JetClass) classOrObject; + ConstructorDescriptorImpl constructor = resolveSession.getInjector().getDescriptorResolver() + .resolvePrimaryConstructorDescriptor(thisDescriptor.getScopeForClassHeaderResolution(), + thisDescriptor, + jetClass, + resolveSession.getTrace()); + primaryConstructor = constructor; + setDeferredReturnType(constructor); + } + else { + ConstructorDescriptorImpl constructor = + DescriptorResolver.createPrimaryConstructorForObject(classOrObject, thisDescriptor, resolveSession.getTrace()); + setDeferredReturnType(constructor); + primaryConstructor = constructor; + } + } + primaryConstructorResolved = true; return primaryConstructor; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/data/JetClassInfo.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/data/JetClassInfo.java index 03c10b3df65..87e67718767 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/data/JetClassInfo.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/data/JetClassInfo.java @@ -28,8 +28,26 @@ import java.util.List; */ public class JetClassInfo extends JetClassOrObjectInfo { + @NotNull + private final ClassKind kind; + protected JetClassInfo(@NotNull JetClass classOrObject) { super(classOrObject); + if (element instanceof JetEnumEntry) { + this.kind = ClassKind.ENUM_ENTRY; + } + else if (element.isTrait()) { + this.kind = ClassKind.TRAIT; + } + else if (element.hasModifier(JetTokens.ANNOTATION_KEYWORD)) { + this.kind = ClassKind.ANNOTATION_CLASS; + } + else if (element.hasModifier(JetTokens.ENUM_KEYWORD)) { + this.kind = ClassKind.ENUM_CLASS; + } + else { + this.kind = ClassKind.CLASS; + } } @Override @@ -52,10 +70,6 @@ public class JetClassInfo extends JetClassOrObjectInfo { @NotNull @Override public ClassKind getClassKind() { - if (element instanceof JetEnumEntry) return ClassKind.ENUM_ENTRY; - if (element.isTrait()) return ClassKind.TRAIT; - if (element.hasModifier(JetTokens.ANNOTATION_KEYWORD)) return ClassKind.ANNOTATION_CLASS; - if (element.hasModifier(JetTokens.ENUM_KEYWORD)) return ClassKind.ENUM_CLASS; - return ClassKind.CLASS; + return kind; } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/data/JetClassInfoUtil.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/data/JetClassInfoUtil.java index 57b4ef3fb87..a05cb66dc71 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/data/JetClassInfoUtil.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/data/JetClassInfoUtil.java @@ -28,12 +28,10 @@ public class JetClassInfoUtil { public static JetClassLikeInfo createClassLikeInfo(@NotNull JetClassOrObject classOrObject) { if (classOrObject instanceof JetClass) { - JetClass jetClass = (JetClass) classOrObject; - return new JetClassInfo(jetClass); + return new JetClassInfo((JetClass) classOrObject); } if (classOrObject instanceof JetObjectDeclaration) { - JetObjectDeclaration objectDeclaration = (JetObjectDeclaration) classOrObject; - return new JetObjectInfo(objectDeclaration); + return new JetObjectInfo(classOrObject); } throw new IllegalArgumentException("Unknown declaration type: " + classOrObject + classOrObject.getText()); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/data/JetObjectInfo.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/data/JetObjectInfo.java index 7ed92ee3966..f2bf26a7030 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/data/JetObjectInfo.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/data/JetObjectInfo.java @@ -18,7 +18,10 @@ package org.jetbrains.jet.lang.resolve.lazy.data; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.ClassKind; -import org.jetbrains.jet.lang.psi.*; +import org.jetbrains.jet.lang.psi.JetClassObject; +import org.jetbrains.jet.lang.psi.JetClassOrObject; +import org.jetbrains.jet.lang.psi.JetParameter; +import org.jetbrains.jet.lang.psi.JetTypeParameter; import java.util.Collections; import java.util.List; @@ -28,8 +31,13 @@ import java.util.List; */ public class JetObjectInfo extends JetClassOrObjectInfo { + @NotNull + private final ClassKind kind; + protected JetObjectInfo(@NotNull JetClassOrObject element) { super(element); + boolean isClassObject = element.getParent() instanceof JetClassObject; + this.kind = isClassObject ? ClassKind.CLASS_OBJECT : ClassKind.OBJECT; } @Override @@ -52,6 +60,6 @@ public class JetObjectInfo extends JetClassOrObjectInfo { @NotNull @Override public ClassKind getClassKind() { - return ClassKind.OBJECT; + return kind; } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/InnerClassesScopeWrapper.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/InnerClassesScopeWrapper.java index 26f0049a654..079b89c058c 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/InnerClassesScopeWrapper.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/InnerClassesScopeWrapper.java @@ -21,7 +21,6 @@ import com.google.common.collect.Collections2; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; -import org.jetbrains.jet.lang.descriptors.ClassKind; import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.resolve.AbstractScopeAdapter; @@ -49,7 +48,7 @@ public class InnerClassesScopeWrapper extends AbstractScopeAdapter { } private boolean isClass(DeclarationDescriptor descriptor) { - return descriptor instanceof ClassDescriptor && ((ClassDescriptor) descriptor).getKind() != ClassKind.OBJECT; + return descriptor instanceof ClassDescriptor && !((ClassDescriptor) descriptor).getKind().isObject(); } @Override diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeImpl.java index 469cfcf4e82..3499f6db6bd 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeImpl.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeImpl.java @@ -20,7 +20,6 @@ import com.google.common.collect.*; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.*; -import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.name.LabelName; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; @@ -314,7 +313,7 @@ public class WritableScopeImpl extends WritableScopeWithImports { public void addClassifierDescriptor(@NotNull ClassifierDescriptor classDescriptor) { checkMayWrite(); - if (DescriptorUtils.isObject(classDescriptor)) { + if (isObject(classDescriptor)) { throw new IllegalStateException("must not be object: " + classDescriptor); } @@ -325,7 +324,7 @@ public class WritableScopeImpl extends WritableScopeWithImports { public void addObjectDescriptor(@NotNull ClassDescriptor objectDescriptor) { checkMayWrite(); - if (!DescriptorUtils.isObject(objectDescriptor)) { + if (!objectDescriptor.getKind().isObject()) { throw new IllegalStateException("must be object: " + objectDescriptor); } @@ -539,4 +538,17 @@ public class WritableScopeImpl extends WritableScopeWithImports { public Collection getOwnDeclaredDescriptors() { return declaredDescriptorsAccessibleBySimpleName.values(); } + + private static boolean isObject(@NotNull ClassifierDescriptor classifier) { + if (classifier instanceof ClassDescriptor) { + ClassDescriptor clazz = (ClassDescriptor) classifier; + return clazz.getKind().isObject(); + } + else if (classifier instanceof TypeParameterDescriptor) { + return false; + } + else { + throw new IllegalStateException("unknown classifier: " + classifier); + } + } } diff --git a/compiler/frontend/src/org/jetbrains/jet/resolve/DescriptorRenderer.java b/compiler/frontend/src/org/jetbrains/jet/resolve/DescriptorRenderer.java index 75c339de6a9..c51a752d71c 100644 --- a/compiler/frontend/src/org/jetbrains/jet/resolve/DescriptorRenderer.java +++ b/compiler/frontend/src/org/jetbrains/jet/resolve/DescriptorRenderer.java @@ -541,6 +541,9 @@ public class DescriptorRenderer implements Renderer { case ANNOTATION_CLASS: keyword = "annotation class"; break; + case CLASS_OBJECT: + keyword = "class object"; + break; default: keyword = "class"; } @@ -548,25 +551,16 @@ public class DescriptorRenderer implements Renderer { return null; } - private boolean isClassObjectDescriptor(ClassDescriptor descriptor) { - if (descriptor.getKind() == ClassKind.OBJECT) { - DeclarationDescriptor containing = descriptor.getContainingDeclaration(); - if (containing instanceof ClassDescriptor) { - return ((ClassDescriptor)containing).getClassObjectDescriptor() == descriptor; - } - } - return false; - } - public void renderClassDescriptor(ClassDescriptor descriptor, StringBuilder builder, String keyword) { - if (!isClassObjectDescriptor(descriptor)) { + if (descriptor.getKind() != ClassKind.CLASS_OBJECT) { renderVisibility(descriptor.getVisibility(), builder); } - if (descriptor.getKind() != ClassKind.TRAIT && descriptor.getKind() != ClassKind.OBJECT) { + if (descriptor.getKind() != ClassKind.TRAIT && descriptor.getKind() != ClassKind.OBJECT + && descriptor.getKind() != ClassKind.CLASS_OBJECT) { renderModality(descriptor.getModality(), builder); } builder.append(renderKeyword(keyword)); - if (descriptor.getKind() != ClassKind.OBJECT) { + if (descriptor.getKind() != ClassKind.CLASS_OBJECT) { builder.append(" "); renderName(descriptor, builder); renderTypeParameters(descriptor.getTypeConstructor().getParameters(), builder); diff --git a/compiler/testData/lazyResolve/descriptorRenderer/ClassObject.kt b/compiler/testData/lazyResolve/descriptorRenderer/ClassObject.kt index 5c928f4503a..823d92433b2 100644 --- a/compiler/testData/lazyResolve/descriptorRenderer/ClassObject.kt +++ b/compiler/testData/lazyResolve/descriptorRenderer/ClassObject.kt @@ -4,4 +4,4 @@ trait TheTrait { } //internal trait TheTrait defined in root package -//object defined in TheTrait \ No newline at end of file +//class object defined in TheTrait \ No newline at end of file diff --git a/compiler/testData/lazyResolve/namespaceComparator/enum.kt b/compiler/testData/lazyResolve/namespaceComparator/enum.kt index bce37d628a4..b36ddafa03b 100644 --- a/compiler/testData/lazyResolve/namespaceComparator/enum.kt +++ b/compiler/testData/lazyResolve/namespaceComparator/enum.kt @@ -2,6 +2,5 @@ package test enum class Test(a : Int) { A : Test(0) - B(x : Int) : Test(x) - C : Test(0) {} + B : Test(0) {} } diff --git a/compiler/testData/lazyResolve/namespaceComparator/enum.txt b/compiler/testData/lazyResolve/namespaceComparator/enum.txt index c3a92c5cac5..8e0109d6947 100644 --- a/compiler/testData/lazyResolve/namespaceComparator/enum.txt +++ b/compiler/testData/lazyResolve/namespaceComparator/enum.txt @@ -7,19 +7,14 @@ internal final enum class test.Test : jet.Enum { internal final class object test.Test. { internal final /*constructor*/ fun (): test.Test. internal final val A: test.Test..A - internal final val C: test.Test..C + internal final val B: test.Test..B internal final enum entry test.Test..A : test.Test { internal final /*constructor*/ fun (): test.Test..A public final override /*1*/ fun name(): jet.String public final override /*1*/ fun ordinal(): jet.Int } internal final enum entry test.Test..B : test.Test { - public final /*constructor*/ fun (/*0*/ x: jet.Int): test.Test..B - public final override /*1*/ fun name(): jet.String - public final override /*1*/ fun ordinal(): jet.Int - } - internal final enum entry test.Test..C : test.Test { - internal final /*constructor*/ fun (): test.Test..C + internal final /*constructor*/ fun (): test.Test..B public final override /*1*/ fun name(): jet.String public final override /*1*/ fun ordinal(): jet.Int } diff --git a/compiler/testData/renderer/Classes.kt b/compiler/testData/renderer/Classes.kt index 9944c484b34..7cd2a36bad6 100644 --- a/compiler/testData/renderer/Classes.kt +++ b/compiler/testData/renderer/Classes.kt @@ -37,5 +37,5 @@ trait TheTrait { //internal final class InternalClass defined in rendererTest //internal trait TheTrait defined in rendererTest //internal abstract fun abstractFun() : Unit defined in rendererTest.TheTrait -//object : rendererTest.TheClass defined in rendererTest.TheTrait +//class object : rendererTest.TheClass defined in rendererTest.TheTrait //internal final fun classObjectFunction() : jet.Int defined in rendererTest.TheTrait. \ No newline at end of file diff --git a/compiler/tests/org/jetbrains/jet/test/util/NamespaceComparator.java b/compiler/tests/org/jetbrains/jet/test/util/NamespaceComparator.java index f562af15f7d..4245f50663c 100644 --- a/compiler/tests/org/jetbrains/jet/test/util/NamespaceComparator.java +++ b/compiler/tests/org/jetbrains/jet/test/util/NamespaceComparator.java @@ -779,7 +779,7 @@ public class NamespaceComparator { @Override public void serialize(ClassKind kind) { - assert kind == ClassKind.OBJECT : "Must be called for class objects only"; + assert kind == ClassKind.CLASS_OBJECT : "Must be called for class objects only"; sb.append("class object"); } } diff --git a/idea/src/org/jetbrains/jet/plugin/JetDescriptorIconProvider.java b/idea/src/org/jetbrains/jet/plugin/JetDescriptorIconProvider.java index 100aa481f00..93178395ac3 100644 --- a/idea/src/org/jetbrains/jet/plugin/JetDescriptorIconProvider.java +++ b/idea/src/org/jetbrains/jet/plugin/JetDescriptorIconProvider.java @@ -96,6 +96,8 @@ public final class JetDescriptorIconProvider { return PlatformIcons.ANNOTATION_TYPE_ICON; case OBJECT: return JetIcons.OBJECT; + case CLASS_OBJECT: + return JetIcons.OBJECT; case CLASS: return JetIcons.CLASS; default: diff --git a/idea/src/org/jetbrains/jet/plugin/libraries/DecompiledDataFactory.java b/idea/src/org/jetbrains/jet/plugin/libraries/DecompiledDataFactory.java index 12100d99530..1be94c058ca 100644 --- a/idea/src/org/jetbrains/jet/plugin/libraries/DecompiledDataFactory.java +++ b/idea/src/org/jetbrains/jet/plugin/libraries/DecompiledDataFactory.java @@ -150,7 +150,7 @@ class DecompiledDataFactory { String subindent = indent + " "; if (classDescriptor.getClassObjectDescriptor() != null) { firstPassed = true; - myBuilder.append(subindent).append("class "); + myBuilder.append(subindent); appendDescriptor(classDescriptor.getClassObjectDescriptor(), subindent); } for (DeclarationDescriptor member : sortDeclarations(classDescriptor.getDefaultType().getMemberScope().getAllDescriptors())) { diff --git a/idea/src/org/jetbrains/jet/plugin/references/StandardLibraryReferenceResolver.java b/idea/src/org/jetbrains/jet/plugin/references/StandardLibraryReferenceResolver.java index 1a384febea8..461fcf24780 100644 --- a/idea/src/org/jetbrains/jet/plugin/references/StandardLibraryReferenceResolver.java +++ b/idea/src/org/jetbrains/jet/plugin/references/StandardLibraryReferenceResolver.java @@ -116,7 +116,7 @@ public class StandardLibraryReferenceResolver extends AbstractProjectComponent { } private DeclarationDescriptor findCurrentDescriptorForClass(@NotNull ClassDescriptor originalDescriptor) { - if (originalDescriptor.getKind() == ClassKind.OBJECT) { + if (originalDescriptor.getKind().isObject()) { DeclarationDescriptor currentParent = findCurrentDescriptor(originalDescriptor.getContainingDeclaration()); if (currentParent == null) return null; return ((ClassDescriptor) currentParent).getClassObjectDescriptor();