KT-2744 Unneeded error message when the only super type is not resolved

#KT-2744 Fixed

compiler/frontend/src/org/jetbrains/jet/lang/descriptors/MutableClassDescriptorLite.java

@@ -212,11 +212,10 @@ public abstract class MutableClassDescriptorLite extends ClassDescriptorBase
 
 
     public void addSupertype(@NotNull JetType supertype) {
-        if (!ErrorUtils.isErrorType(supertype)) {
-            if (TypeUtils.getClassDescriptor(supertype) != null) {
-                // See the Errors.SUPERTYPE_NOT_A_CLASS_OR_TRAIT
-                supertypes.add(supertype);
-            }
+        assert !ErrorUtils.isErrorType(supertype) : "Error types must be filtered out in DescriptorResolver";
+        if (TypeUtils.getClassDescriptor(supertype) != null) {
+            // See the Errors.SUPERTYPE_NOT_A_CLASS_OR_TRAIT
+            supertypes.add(supertype);
         }
     }
 

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

@@ -130,25 +130,33 @@ public class DescriptorResolver {
     ) {
         List<JetType> supertypes = Lists.newArrayList();
         List<JetDelegationSpecifier> delegationSpecifiers = jetClass.getDelegationSpecifiers();
-        boolean isEnum = classDescriptor.getKind() == ClassKind.ENUM_CLASS;
-        if (delegationSpecifiers.isEmpty()) {
-            if (!isEnum) {
-                supertypes.add(getDefaultSupertype(jetClass, trace));
-            }
+        Collection<JetType> declaredSupertypes = resolveDelegationSpecifiers(
+                scope,
+                delegationSpecifiers,
+                typeResolver, trace, false);
+
+        for (JetType declaredSupertype : declaredSupertypes) {
+            addValidSupertype(supertypes, declaredSupertype);
         }
-        else {
-            Collection<JetType> declaredSupertypes = resolveDelegationSpecifiers(
-                    scope,
-                    delegationSpecifiers,
-                    typeResolver, trace, false);
-            supertypes.addAll(declaredSupertypes);
-        }
-        if (isEnum && !containsClass(supertypes)) {
+
+        if (classDescriptor.getKind() == ClassKind.ENUM_CLASS && !containsClass(supertypes)) {
             supertypes.add(0, JetStandardLibrary.getInstance().getEnumType(classDescriptor.getDefaultType()));
         }
+
+        if (supertypes.isEmpty()) {
+            JetType defaultSupertype = getDefaultSupertype(jetClass, trace);
+            addValidSupertype(supertypes, defaultSupertype);
+        }
+
         return supertypes;
     }
 
+    private static void addValidSupertype(List<JetType> supertypes, JetType declaredSupertype) {
+        if (!ErrorUtils.isErrorType(declaredSupertype)) {
+            supertypes.add(declaredSupertype);
+        }
+    }
+
     private boolean containsClass(Collection<JetType> result) {
         for (JetType type : result) {
             ClassifierDescriptor descriptor = type.getConstructor().getDeclarationDescriptor();

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

@@ -54,7 +54,8 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
     private static final Predicate<JetType> VALID_SUPERTYPE = new Predicate<JetType>() {
         @Override
         public boolean apply(JetType type) {
-            return !ErrorUtils.isErrorType(type) && (TypeUtils.getClassDescriptor(type) != null);
+            assert !ErrorUtils.isErrorType(type) : "Error types must be filtered out in DescriptorResolver";
+            return TypeUtils.getClassDescriptor(type) != null;
         }
     };
     private final ResolveSession resolveSession;