better error reporting on incomplete hierarchy in JDR

compiler/cli/src/org/jetbrains/jet/compiler/CompileSession.java

@@ -27,18 +27,25 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.codegen.ClassBuilderFactory;
 import org.jetbrains.jet.codegen.ClassFileFactory;
 import org.jetbrains.jet.codegen.GenerationState;
+import org.jetbrains.jet.codegen.JetTypeMapper;
 import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory;
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+import org.jetbrains.jet.lang.descriptors.ClassOrNamespaceDescriptor;
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.diagnostics.Diagnostic;
 import org.jetbrains.jet.lang.diagnostics.Severity;
 import org.jetbrains.jet.lang.diagnostics.SimpleDiagnosticFactory;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.java.AnalyzerFacade;
+import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.plugin.JetFileType;
 
 import java.io.File;
 import java.io.PrintStream;
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.List;
 
 /**
@@ -137,8 +144,33 @@ public class CompileSession {
         reportSyntaxErrors(errorCollector);
         analyzeAndReportSemanticErrors(errorCollector);
 
+
+        boolean hasIncompleteHierarchyErrors;
+        Collection<ClassDescriptor> incompletes = myBindingContext.getKeys(BindingContext.INCOMPLETE_HIERARCHY);
+        if (!incompletes.isEmpty()) {
+            out.println("following classes have incomplete hierarchies:");
+            for (ClassDescriptor incomplete : incompletes) {
+                out.println("    " + fqName(incomplete));
+            }
+            hasIncompleteHierarchyErrors = true;
+        } else {
+            hasIncompleteHierarchyErrors = false;
+        }
+
         errorCollector.flushTo(out);
-        return !errorCollector.hasErrors;
+        return !errorCollector.hasErrors && !hasIncompleteHierarchyErrors;
+    }
+
+    /**
+     * @see JetTypeMapper#getFQName(DeclarationDescriptor)
+     */
+    private String fqName(ClassOrNamespaceDescriptor descriptor) {
+        DeclarationDescriptor containingDeclaration = descriptor.getContainingDeclaration();
+        if (containingDeclaration == null || containingDeclaration instanceof ModuleDescriptor || containingDeclaration.getName().equals(JavaDescriptorResolver.JAVA_ROOT)) {
+            return descriptor.getName();
+        } else {
+            return fqName((ClassOrNamespaceDescriptor) containingDeclaration) + "." + descriptor.getName();
+        }
     }
 
     private void analyzeAndReportSemanticErrors(ErrorCollector errorCollector) {

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

@@ -309,7 +309,7 @@ public class JavaDescriptorResolver {
         TypeVariableResolverFromTypeDescriptors resolverForTypeParameters = new TypeVariableResolverFromTypeDescriptors(classData.getTypeParameters(), null);
 
         // TODO: ugly hack: tests crash if initializeTypeParameters called with class containing proper supertypes
-        supertypes.addAll(getSupertypes(new PsiClassWrapper(psiClass), classData.getTypeParameters()));
+        supertypes.addAll(getSupertypes(new PsiClassWrapper(psiClass), classData.classDescriptor, classData.getTypeParameters()));
 
         if (psiClass.isInterface()) {
             //classData.classDescriptor.setSuperclassType(JetStandardClasses.getAnyType()); // TODO : Make it java.lang.Object
@@ -669,7 +669,7 @@ public class JavaDescriptorResolver {
         }
     }
 
-    private Collection<? extends JetType> getSupertypes(PsiClassWrapper psiClass, List<TypeParameterDescriptor> typeParameters) {
+    private Collection<? extends JetType> getSupertypes(PsiClassWrapper psiClass, ClassDescriptor classDescriptor, List<TypeParameterDescriptor> typeParameters) {
         final List<JetType> result = new ArrayList<JetType>();
 
         if (psiClass.getJetClass().signature().length() > 0) {
@@ -703,6 +703,13 @@ public class JavaDescriptorResolver {
             transformSupertypeList(result, psiClass.getPsiClass().getExtendsListTypes(), new TypeVariableResolverFromTypeDescriptors(typeParameters, null));
             transformSupertypeList(result, psiClass.getPsiClass().getImplementsListTypes(), new TypeVariableResolverFromTypeDescriptors(typeParameters, null));
         }
+        
+        for (JetType supertype : result) {
+            if (ErrorUtils.isErrorType(supertype)) {
+                semanticServices.getTrace().record(BindingContext.INCOMPLETE_HIERARCHY, classDescriptor);
+            }
+        }
+        
         if (result.isEmpty()) {
             result.add(JetStandardClasses.getAnyType());
         }

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

@@ -171,6 +171,8 @@ public interface BindingContext {
 
     WritableSlice<String, ClassDescriptor> FQNAME_TO_CLASS_DESCRIPTOR = new BasicWritableSlice<String, ClassDescriptor>(DO_NOTHING, true);
     WritableSlice<String, NamespaceDescriptor> FQNAME_TO_NAMESPACE_DESCRIPTOR = new BasicWritableSlice<String, NamespaceDescriptor>(DO_NOTHING);
+    
+    WritableSlice<ClassDescriptor, Boolean> INCOMPLETE_HIERARCHY = Slices.createCollectiveSetSlice();
 
     @SuppressWarnings("UnusedDeclaration")
     @Deprecated // This field is needed only for the side effects of its initializer