Delete ErrorUtils.isError(TypeConstructor)

compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/TypeDeserializer.java

@@ -259,7 +259,8 @@ public class TypeDeserializer {
 
         @Override
         public boolean isError() {
-            return ErrorUtils.isError(getConstructor());
+            ClassifierDescriptor descriptor = getConstructor().getDeclarationDescriptor();
+            return descriptor != null && ErrorUtils.isError(descriptor);
         }
 
         @Override

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

@@ -264,7 +264,7 @@ public class BodyResolver {
                 ClassDescriptor classDescriptor = TypeUtils.getClassDescriptor(supertype);
                 if (classDescriptor == null) return;
                 if (descriptor.getKind() != ClassKind.TRAIT && !classDescriptor.getConstructors().isEmpty() &&
-                    !ErrorUtils.isError(classDescriptor.getTypeConstructor()) && classDescriptor.getKind() != ClassKind.TRAIT) {
+                    !ErrorUtils.isError(classDescriptor) && classDescriptor.getKind() != ClassKind.TRAIT) {
                     trace.report(SUPERTYPE_NOT_INITIALIZED.on(specifier));
                 }
             }

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

@@ -146,7 +146,7 @@ public class TypeResolver {
                         List<TypeParameterDescriptor> parameters = typeConstructor.getParameters();
                         int expectedArgumentCount = parameters.size();
                         int actualArgumentCount = arguments.size();
-                        if (ErrorUtils.isError(typeConstructor)) {
+                        if (ErrorUtils.isError(classDescriptor)) {
                             result[0] = type(ErrorUtils.createErrorType("[Error type: " + typeConstructor + "]"));
                         }
                         else {

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/tasks/CallableDescriptorCollectors.java

@@ -72,9 +72,8 @@ public class CallableDescriptorCollectors {
 
         private static void addConstructors(JetScope scope, Name name, Collection<FunctionDescriptor> functions) {
             ClassifierDescriptor classifier = scope.getClassifier(name);
-            if (classifier instanceof ClassDescriptor && !ErrorUtils.isError(classifier.getTypeConstructor())) {
+            if (classifier instanceof ClassDescriptor && !ErrorUtils.isError(classifier)) {
-                ClassDescriptor classDescriptor = (ClassDescriptor) classifier;
+                functions.addAll(((ClassDescriptor) classifier).getConstructors());
-                functions.addAll(classDescriptor.getConstructors());
             }
         }
 

compiler/frontend/src/org/jetbrains/jet/lang/types/ErrorUtils.java

@@ -255,19 +255,6 @@ public class ErrorUtils {
 
     private static final ErrorClassDescriptor ERROR_CLASS = new ErrorClassDescriptor("");
 
-    private static final class ErrorTypeConstructor extends TypeConstructorImpl {
-        private ErrorTypeConstructor(
-                @Nullable ClassifierDescriptor classifierDescriptor,
-                @NotNull List<AnnotationDescriptor> annotations,
-                boolean sealed,
-                @NotNull String debugName,
-                @NotNull List<? extends TypeParameterDescriptor> parameters,
-                @NotNull Collection<JetType> supertypes
-        ) {
-            super(classifierDescriptor, annotations, sealed, debugName, parameters, supertypes);
-        }
-    }
-
     private static final Set<ConstructorDescriptor> ERROR_CONSTRUCTOR_GROUP = Collections.singleton(createErrorConstructor());
 
     private static final ConstructorDescriptor ERROR_CONSTRUCTOR = new ConstructorDescriptorImpl(ERROR_CLASS, Collections.<AnnotationDescriptor>emptyList(), true);
@@ -343,21 +330,24 @@ public class ErrorUtils {
 
     @NotNull
     public static JetType createErrorType(@NotNull String debugMessage) {
-        return createErrorTypeWithCustomDebugName(createErrorScope(debugMessage), "[ERROR : " + debugMessage + "]");
+        return new ErrorTypeImpl(createErrorTypeConstructor(debugMessage), createErrorScope(debugMessage));
     }
 
     @NotNull
     public static JetType createErrorTypeWithCustomDebugName(@NotNull String debugName) {
-        return createErrorTypeWithCustomDebugName(createErrorScope(debugName), debugName);
+        return new ErrorTypeImpl(createErrorTypeConstructorWithCustomDebugName(debugName), createErrorScope(debugName));
     }
 
     @NotNull
-    private static JetType createErrorTypeWithCustomDebugName(@NotNull JetScope memberScope, @NotNull String debugName) {
+    public static TypeConstructor createErrorTypeConstructor(@NotNull String debugMessage) {
-        TypeConstructorImpl constructor =
+        return createErrorTypeConstructorWithCustomDebugName("[ERROR : " + debugMessage + "]");
-                new ErrorTypeConstructor(ERROR_CLASS, Collections.<AnnotationDescriptor>emptyList(), false, debugName,
+    }
-                                        Collections.<TypeParameterDescriptorImpl>emptyList(),
+
-                                        Collections.singleton(KotlinBuiltIns.getInstance().getAnyType()));
+    @NotNull
-        return new ErrorTypeImpl(constructor, memberScope);
+    private static TypeConstructor createErrorTypeConstructorWithCustomDebugName(@NotNull String debugName) {
+        return new TypeConstructorImpl(ERROR_CLASS, Collections.<AnnotationDescriptor>emptyList(), false, debugName,
+                                Collections.<TypeParameterDescriptorImpl>emptyList(),
+                                Collections.singleton(KotlinBuiltIns.getInstance().getAnyType()));
     }
 
     @NotNull
@@ -365,10 +355,6 @@ public class ErrorUtils {
         return ERROR_CLASS;
     }
 
-    public static boolean isError(@NotNull TypeConstructor typeConstructor) {
-        return typeConstructor == ERROR_CLASS.getTypeConstructor() || typeConstructor instanceof ErrorTypeConstructor;
-    }
-
     public static boolean containsErrorType(@Nullable JetType type) {
         if (type == null) return false;
         if (type instanceof NamespaceType) return false;

compiler/frontend/src/org/jetbrains/jet/lang/types/TypeUtils.java

@@ -359,14 +359,10 @@ public class TypeUtils {
 
     @NotNull
     public static JetType makeUnsubstitutedType(ClassDescriptor classDescriptor, JetScope unsubstitutedMemberScope) {
-        return makeUnsubstitutedType(classDescriptor.getTypeConstructor(), unsubstitutedMemberScope);
+        if (ErrorUtils.isError(classDescriptor)) {
-    }
+            return ErrorUtils.createErrorType("Unsubstituted type for " + classDescriptor);
-
-    @NotNull
-    public static JetType makeUnsubstitutedType(TypeConstructor typeConstructor, JetScope unsubstitutedMemberScope) {
-        if (ErrorUtils.isError(typeConstructor)) {
-            return ErrorUtils.createErrorType("Unsubstituted type for " + typeConstructor);
         }
+        TypeConstructor typeConstructor = classDescriptor.getTypeConstructor();
         List<TypeProjection> arguments = getDefaultTypeProjections(typeConstructor.getParameters());
         return new JetTypeImpl(
                 Collections.<AnnotationDescriptor>emptyList(),