More compact and meaningful error reporting in ResolverForProject

No more enormous module lists

compiler/frontend/src/org/jetbrains/kotlin/analyzer/AnalyzerFacade.kt

@@ -40,33 +40,43 @@ public class ResolverForModule(
     public val componentProvider: ComponentProvider
 )
 
-public interface ResolverForProject<M : ModuleInfo> {
-    public fun resolverForModule(moduleInfo: M): ResolverForModule = resolverForModuleDescriptor(descriptorForModule(moduleInfo))
-    public fun descriptorForModule(moduleInfo: M): ModuleDescriptor
-    public fun resolverForModuleDescriptor(descriptor: ModuleDescriptor): ResolverForModule
+abstract class ResolverForProject<M : ModuleInfo> {
+    fun resolverForModule(moduleInfo: M): ResolverForModule = resolverForModuleDescriptor(descriptorForModule(moduleInfo))
+    abstract fun descriptorForModule(moduleInfo: M): ModuleDescriptor
+    abstract fun resolverForModuleDescriptor(descriptor: ModuleDescriptor): ResolverForModule
 
-    val allModules: Collection<M>
+    abstract val name: String
+    abstract val allModules: Collection<M>
+
+    override fun toString() = "$name"
 }
 
-public class EmptyResolverForProject<M : ModuleInfo> : ResolverForProject<M> {
+public class EmptyResolverForProject<M : ModuleInfo> : ResolverForProject<M>() {
+    override val name: String
+        get() = "Empty resolver"
+
     override fun resolverForModuleDescriptor(descriptor: ModuleDescriptor): ResolverForModule = throw IllegalStateException("$descriptor is not contained in this resolver")
     override fun descriptorForModule(moduleInfo: M) = throw IllegalStateException("Should not be called for $moduleInfo")
     override val allModules: Collection<M> = listOf()
 }
 
 public class ResolverForProjectImpl<M : ModuleInfo>(
+        private val debugName: String,
         val descriptorByModule: Map<M, ModuleDescriptorImpl>,
         val delegateResolver: ResolverForProject<M> = EmptyResolverForProject()
-) : ResolverForProject<M> {
+) : ResolverForProject<M>() {
     val resolverByModuleDescriptor: MutableMap<ModuleDescriptor, () -> ResolverForModule> = HashMap()
 
     override val allModules: Collection<M> by lazy {
         (descriptorByModule.keySet() + delegateResolver.allModules).toSet()
     }
 
+    override val name: String
+        get() = "Resolver for '$debugName'"
+
     private fun assertCorrectModuleInfo(moduleInfo: M) {
         if (moduleInfo !in allModules) {
-            throw AssertionError("Requested data for $moduleInfo not contained in this resolver.\nThis resolver was created for following infos:\n${allModules.joinToString("\n")}")
+            throw AssertionError("$name does not know how to resolve $moduleInfo")
         }
     }
 
@@ -123,6 +133,7 @@ public interface ModuleInfo {
 
 public abstract class AnalyzerFacade<in P : PlatformAnalysisParameters> {
     public fun <M : ModuleInfo> setupResolverForProject(
+            debugName: String,
             projectContext: ProjectContext,
             modules: Collection<M>,
             modulesContent: (M) -> ModuleContent,
@@ -138,7 +149,7 @@ public abstract class AnalyzerFacade<in P : PlatformAnalysisParameters> {
                 module ->
                 descriptorByModule[module] = targetPlatform.createModule(module.name, storageManager)
             }
-            return ResolverForProjectImpl(descriptorByModule, delegateResolver)
+            return ResolverForProjectImpl(debugName, descriptorByModule, delegateResolver)
         }
 
         val resolverForProject = createResolverForProject()