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.

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)) {
+        if (classDescriptor.getKind() == ClassKind.ENUM_CLASS
-            return false;
+            || classDescriptor.getKind() == ClassKind.ENUM_ENTRY
-        }
+            || classDescriptor.getKind() == ClassKind.CLASS_OBJECT) {
-        if (classDescriptor.getKind() == ClassKind.ENUM_CLASS || classDescriptor.getKind() == ClassKind.ENUM_ENTRY) {
             return false;
         }
 

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) {

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<AnnotationDescriptor>(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()));

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;
+    }
 }

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;

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) {
+        return descriptor instanceof ClassDescriptor
-            ClassDescriptor classDescriptor = (ClassDescriptor) descriptor;
+               && ((ClassDescriptor) descriptor).getKind() == ClassKind.CLASS_OBJECT;
-            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;
     }
 
     @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());
             }
 

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));

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 =
+                    MutableClassDescriptor objectDescriptor =
-                            createClassDescriptorForObject(declaration, owner, outerScope, JetPsiUtil.safeName(declaration.getName()));
+                            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();

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<D> candidate = ResolutionCandidate.create(descriptor);
                         candidate.setThisObject(new ClassReceiver((ClassDescriptor) containingDeclaration));
                         candidate.setExplicitReceiverKind(ExplicitReceiverKind.NO_EXPLICIT_RECEIVER);

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

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyClassMemberScope.java

@@ -39,6 +39,11 @@ import java.util.*;
 */
 public class LazyClassMemberScope extends AbstractLazyMemberScope<LazyClassDescriptor, ClassMemberDeclarationProvider> {
 
+    @NotNull
+    private static final Set<ClassKind> GENERATE_CONSTRUCTORS_FOR =
+            EnumSet.of(ClassKind.CLASS, ClassKind.ANNOTATION_CLASS, ClassKind.OBJECT,
+                       ClassKind.ENUM_CLASS, ClassKind.ENUM_ENTRY, ClassKind.CLASS_OBJECT);
+
     private interface MemberExtractor<T extends CallableMemberDescriptor> {
         MemberExtractor<FunctionDescriptor> EXTRACT_FUNCTIONS = new MemberExtractor<FunctionDescriptor>() {
             @NotNull
@@ -277,15 +282,12 @@ public class LazyClassMemberScope extends AbstractLazyMemberScope<LazyClassDescr
 
     @Nullable
     public ConstructorDescriptor getPrimaryConstructor() {
-        if (!primaryConstructorResolved) {
+        if (primaryConstructorResolved) {
-            Set<ClassKind> generateConstructorsFor =
+            return primaryConstructor;
-                    EnumSet.of(ClassKind.CLASS, ClassKind.ANNOTATION_CLASS, ClassKind.OBJECT, ClassKind.ENUM_CLASS, ClassKind.ENUM_ENTRY);
+        }
-            if (generateConstructorsFor.contains(thisDescriptor.getKind())) {
+        if (GENERATE_CONSTRUCTORS_FOR.contains(thisDescriptor.getKind())) {
             JetClassOrObject classOrObject = declarationProvider.getOwnerInfo().getCorrespondingClassOrObject();
-                if (
+            if (!thisDescriptor.getKind().isObject()) {
-                        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(),
@@ -303,7 +305,6 @@ public class LazyClassMemberScope extends AbstractLazyMemberScope<LazyClassDescr
             }
         }
         primaryConstructorResolved = true;
-        }
         return primaryConstructor;
     }
 

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<JetClass> {
 
+    @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<JetClass> {
     @NotNull
     @Override
     public ClassKind getClassKind() {
-        if (element instanceof JetEnumEntry) return ClassKind.ENUM_ENTRY;
+        return kind;
-        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;
     }
 }

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) classOrObject);
-            return new JetClassInfo(jetClass);
         }
         if (classOrObject instanceof JetObjectDeclaration) {
-            JetObjectDeclaration objectDeclaration = (JetObjectDeclaration) classOrObject;
+            return new JetObjectInfo(classOrObject);
-            return new JetObjectInfo(objectDeclaration);
         }
         throw new IllegalArgumentException("Unknown declaration type: " + classOrObject + classOrObject.getText());
     }

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<JetClassOrObject> {
 
+    @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<JetClassOrObject> {
     @NotNull
     @Override
     public ClassKind getClassKind() {
-        return ClassKind.OBJECT;
+        return kind;
     }
 }

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

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<DeclarationDescriptor> 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);
+        }
+    }
 }

compiler/frontend/src/org/jetbrains/jet/resolve/DescriptorRenderer.java

@@ -541,6 +541,9 @@ public class DescriptorRenderer implements Renderer<DeclarationDescriptor> {
                 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<DeclarationDescriptor> {
             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);

compiler/testData/lazyResolve/descriptorRenderer/ClassObject.kt

@@ -4,4 +4,4 @@ trait TheTrait {
 }
 
 //internal trait TheTrait defined in root package
-//object defined in TheTrait
+//class object defined in TheTrait

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)
+  B : Test(0) {}
-  C : Test(0) {}
 }

compiler/testData/lazyResolve/namespaceComparator/enum.txt

@@ -7,19 +7,14 @@ internal final enum class test.Test : jet.Enum<test.Test> {
     internal final class object test.Test.<class-object-for-Test> {
         internal final /*constructor*/ fun <init>(): test.Test.<class-object-for-Test>
         internal final val A: test.Test.<class-object-for-Test>.A
-        internal final val C: test.Test.<class-object-for-Test>.C
+        internal final val B: test.Test.<class-object-for-Test>.B
         internal final enum entry test.Test.<class-object-for-Test>.A : test.Test {
             internal final /*constructor*/ fun <init>(): test.Test.<class-object-for-Test>.A
             public final override /*1*/ fun name(): jet.String
             public final override /*1*/ fun ordinal(): jet.Int
         }
         internal final enum entry test.Test.<class-object-for-Test>.B : test.Test {
-            public final /*constructor*/ fun <init>(/*0*/ x: jet.Int): test.Test.<class-object-for-Test>.B
+            internal final /*constructor*/ fun <init>(): test.Test.<class-object-for-Test>.B
-            public final override /*1*/ fun name(): jet.String
-            public final override /*1*/ fun ordinal(): jet.Int
-        }
-        internal final enum entry test.Test.<class-object-for-Test>.C : test.Test {
-            internal final /*constructor*/ fun <init>(): test.Test.<class-object-for-Test>.C
             public final override /*1*/ fun name(): jet.String
             public final override /*1*/ fun ordinal(): jet.Int
         }

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<jet.Int, jet.Int> defined in rendererTest.TheTrait
+//class object : rendererTest.TheClass<jet.Int, jet.Int> defined in rendererTest.TheTrait
 //internal final fun classObjectFunction() : jet.Int defined in rendererTest.TheTrait.<class-object-for-TheTrait>

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");
         }
     }

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:

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())) {

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();