[Misc] Provide meaningful debugName for StorageManager everywhere

compiler/cli/cli-common/src/org/jetbrains/kotlin/analyzer/common/CommonResolverForModuleFactory.kt

@@ -90,7 +90,7 @@ object CommonResolverForModuleFactory : ResolverForModuleFactory() {
         @Suppress("NAME_SHADOWING")
         val resolver = ResolverForProjectImpl(
             "sources for metadata serializer",
-            ProjectContext(project),
+            ProjectContext(project, "metadata serializer"),
             listOf(moduleInfo),
             modulesContent = { ModuleContent(it, files, GlobalSearchScope.allScope(project)) },
             moduleLanguageSettingsProvider = object : LanguageSettingsProvider {

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/TopDownAnalyzerFacadeForJVM.kt

@@ -276,7 +276,7 @@ object TopDownAnalyzerFacadeForJVM {
     }
 
     private fun createModuleContext(project: Project, configuration: CompilerConfiguration): MutableModuleContext {
-        val projectContext = ProjectContext(project)
+        val projectContext = ProjectContext(project, "TopDownAnalyzer for JVM")
         val builtIns = JvmBuiltIns(projectContext.storageManager, JvmBuiltIns.Kind.FROM_DEPENDENCIES)
         return ContextForNewModule(
             projectContext, Name.special("<${configuration.getNotNull(CommonConfigurationKeys.MODULE_NAME)}>"), builtIns, null

compiler/frontend/src/org/jetbrains/kotlin/context/context.kt

@@ -83,14 +83,14 @@ class MutableModuleContextImpl(
     projectContext: ProjectContext
 ) : MutableModuleContext, ProjectContext by projectContext
 
-fun GlobalContext(): GlobalContextImpl {
+fun GlobalContext(debugName: String): GlobalContextImpl {
     val tracker = ExceptionTracker()
-    return GlobalContextImpl(LockBasedStorageManager.createWithExceptionHandling("GlobalContext", tracker), tracker)
+    return GlobalContextImpl(LockBasedStorageManager.createWithExceptionHandling(debugName, tracker), tracker)
 }
 
-fun ProjectContext(project: Project): ProjectContext = ProjectContextImpl(project, GlobalContext())
+fun ProjectContext(project: Project, debugName: String): ProjectContext = ProjectContextImpl(project, GlobalContext(debugName))
-fun ModuleContext(module: ModuleDescriptor, project: Project): ModuleContext =
+fun ModuleContext(module: ModuleDescriptor, project: Project, debugName: String): ModuleContext =
-    ModuleContextImpl(module, ProjectContext(project))
+    ModuleContextImpl(module, ProjectContext(project, debugName))
 
 fun GlobalContext.withProject(project: Project): ProjectContext = ProjectContextImpl(project, this)
 fun ProjectContext.withModule(module: ModuleDescriptor): ModuleContext = ModuleContextImpl(module, this)

compiler/tests-common/tests/org/jetbrains/kotlin/resolve/lazy/lazyResolveTestUtils.kt

@@ -39,7 +39,7 @@ fun createResolveSessionForFiles(
         syntheticFiles: Collection<KtFile>,
         addBuiltIns: Boolean
 ): ResolveSession {
-    val projectContext = ProjectContext(project)
+    val projectContext = ProjectContext(project, "lazy resolve test utils")
     val testModule = TestModule(addBuiltIns)
     val resolverForProject = ResolverForProjectImpl(
         "test",

compiler/tests-common/tests/org/jetbrains/kotlin/tests/di/injection.kt

@@ -35,7 +35,7 @@ import org.jetbrains.kotlin.types.expressions.FakeCallResolver
 fun createContainerForTests(project: Project, module: ModuleDescriptor): ContainerForTests {
     return ContainerForTests(createContainer("Tests", JvmPlatformCompilerServices) {
         configureModule(
-            ModuleContext(module, project),
+            ModuleContext(module, project, "container for tests"),
             JvmPlatforms.defaultJvmPlatform,
             JvmPlatformCompilerServices,
             BindingTraceContext(),

compiler/tests/org/jetbrains/kotlin/jvm/compiler/MultiModuleJavaAnalysisCustomTest.kt

@@ -72,7 +72,7 @@ class MultiModuleJavaAnalysisCustomTest : KtUsefulTestCase() {
         val moduleDirs = File(PATH_TO_TEST_ROOT_DIR).listFiles { it -> it.isDirectory }!!
         val environment = createEnvironment(moduleDirs)
         val modules = setupModules(environment, moduleDirs)
-        val projectContext = ProjectContext(environment.project)
+        val projectContext = ProjectContext(environment.project, "MultiModuleJavaAnalysisTest")
         val builtIns = JvmBuiltIns(projectContext.storageManager, JvmBuiltIns.Kind.FROM_CLASS_LOADER)
         val resolverForProject = ResolverForProjectImpl(
             "test",

compiler/tests/org/jetbrains/kotlin/serialization/js/JsVersionRequirementTest.kt

@@ -76,7 +76,10 @@ class JsVersionRequirementTest : AbstractVersionRequirementTest() {
 
     private fun createModule(environment: KotlinCoreEnvironment): MutableModuleContext {
         val config = JsConfig(environment.project, environment.configuration)
-        return ContextForNewModule(ProjectContext(environment.project), Name.special("<test>"), JsPlatformCompilerServices.builtIns, null).apply {
+        return ContextForNewModule(
+            ProjectContext(environment.project, "ProjectContext"),
+            Name.special("<test>"), JsPlatformCompilerServices.builtIns, null
+        ).apply {
             setDependencies(listOf(module) + config.moduleDescriptors + module.builtIns.builtInsModule)
         }
     }

compiler/tests/org/jetbrains/kotlin/types/DefaultModalityModifiersTest.java

@@ -109,7 +109,7 @@ public class DefaultModalityModifiersTest extends KotlinTestWithEnvironment {
         }
 
         private ClassDescriptorWithResolutionScopes createClassDescriptor(ClassKind kind, KtClass aClass) {
-            ModuleContext moduleContext = ContextKt.ModuleContext(root, getProject());
+            ModuleContext moduleContext = ContextKt.ModuleContext(root, getProject(), "DefaultModalityModifiersTest");
             Collection<KtFile> files = Collections.singleton(aClass.getContainingKtFile());
 
             StorageComponentContainer container = createContainerForLazyResolve(

idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/lightClasses/IDELightClassContexts.kt

@@ -308,7 +308,7 @@ internal object IDELightClassContexts {
         val container = createContainer("LightClassStub", JvmPlatformCompilerServices) {
             val jvmTarget = IDELanguageSettingsProvider.getTargetPlatform(moduleInfo, project) as? JvmTarget ?: JvmTarget.DEFAULT
             configureModule(
-                ModuleContext(moduleDescriptor, project), JvmPlatforms.jvmPlatformByTargetVersion(jvmTarget),
+                ModuleContext(moduleDescriptor, project, "ad hoc resolve"), JvmPlatforms.jvmPlatformByTargetVersion(jvmTarget),
                 JvmPlatformCompilerServices, trace,
                 IDELanguageSettingsProvider.getLanguageVersionSettings(moduleInfo, project)
             )

idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinCacheServiceImpl.kt

@@ -119,7 +119,7 @@ class KotlinCacheServiceImpl(val project: Project) : KotlinCacheService {
                 getOrBuildGlobalFacade(settings).facadeForSdk
             }
 
-        val globalContext = globalFacade.globalContext.contextWithNewLockAndCompositeExceptionTracker()
+        val globalContext = globalFacade.globalContext.contextWithNewLockAndCompositeExceptionTracker("facadeForScriptDependencies")
         return ProjectResolutionFacade(
             "facadeForScriptDependencies",
             resolverForScriptDependenciesName,
@@ -136,7 +136,7 @@ class KotlinCacheServiceImpl(val project: Project) : KotlinCacheService {
 
 
     private inner class GlobalFacade(settings: PlatformAnalysisSettings) {
-        private val sdkContext = GlobalContext()
+        private val sdkContext = GlobalContext(resolverForSdkName)
         val facadeForSdk = ProjectResolutionFacade(
             "facadeForSdk", "$resolverForSdkName ${settings.sdk}",
             project, sdkContext, settings,
@@ -149,7 +149,7 @@ class KotlinCacheServiceImpl(val project: Project) : KotlinCacheService {
             reuseDataFrom = null
         )
 
-        private val librariesContext = sdkContext.contextWithNewLockAndCompositeExceptionTracker()
+        private val librariesContext = sdkContext.contextWithNewLockAndCompositeExceptionTracker(resolverForLibrariesName)
         val facadeForLibraries = ProjectResolutionFacade(
             "facadeForLibraries", "$resolverForLibrariesName for platform ${settings.sdk}",
             project, librariesContext, settings,
@@ -162,7 +162,7 @@ class KotlinCacheServiceImpl(val project: Project) : KotlinCacheService {
             )
         )
 
-        private val modulesContext = librariesContext.contextWithNewLockAndCompositeExceptionTracker()
+        private val modulesContext = librariesContext.contextWithNewLockAndCompositeExceptionTracker(resolverForModulesName)
         val facadeForModules = ProjectResolutionFacade(
             "facadeForModules", "$resolverForModulesName for platform ${settings.platform}",
             project, modulesContext, settings,
@@ -259,7 +259,7 @@ class KotlinCacheServiceImpl(val project: Project) : KotlinCacheService {
             specialModuleInfo is ModuleSourceInfo -> {
                 val dependentModules = specialModuleInfo.getDependentModules()
                 val modulesFacade = globalFacade(settings)
-                val globalContext = modulesFacade.globalContext.contextWithNewLockAndCompositeExceptionTracker()
+                val globalContext = modulesFacade.globalContext.contextWithNewLockAndCompositeExceptionTracker("facadeForSpecialModuleInfo (ModuleSourceInfo)")
                 makeProjectResolutionFacade(
                     "facadeForSpecialModuleInfo (ModuleSourceInfo)",
                     globalContext,
@@ -272,7 +272,7 @@ class KotlinCacheServiceImpl(val project: Project) : KotlinCacheService {
                 val facadeForScriptDependencies = createFacadeForScriptDependencies(
                     ScriptDependenciesInfo.ForFile(project, specialModuleInfo.scriptFile, specialModuleInfo.scriptDefinition)
                 )
-                val globalContext = facadeForScriptDependencies.globalContext.contextWithNewLockAndCompositeExceptionTracker()
+                val globalContext = facadeForScriptDependencies.globalContext.contextWithNewLockAndCompositeExceptionTracker("facadeForSpecialModuleInfo (ScriptModuleInfo)")
                 makeProjectResolutionFacade(
                     "facadeForSpecialModuleInfo (ScriptModuleInfo)",
                     globalContext,
@@ -283,7 +283,7 @@ class KotlinCacheServiceImpl(val project: Project) : KotlinCacheService {
             }
             specialModuleInfo is ScriptDependenciesInfo -> facadeForScriptDependenciesForProject
             specialModuleInfo is ScriptDependenciesSourceInfo -> {
-                val globalContext = facadeForScriptDependenciesForProject.globalContext.contextWithNewLockAndCompositeExceptionTracker()
+                val globalContext = facadeForScriptDependenciesForProject.globalContext.contextWithNewLockAndCompositeExceptionTracker("facadeForSpecialModuleInfo (ScriptDependenciesSourceInfo)")
                 makeProjectResolutionFacade(
                     "facadeForSpecialModuleInfo (ScriptDependenciesSourceInfo)",
                     globalContext,
@@ -295,9 +295,11 @@ class KotlinCacheServiceImpl(val project: Project) : KotlinCacheService {
 
             specialModuleInfo is LibrarySourceInfo || specialModuleInfo === NotUnderContentRootModuleInfo -> {
                 val librariesFacade = librariesFacade(settings)
-                val globalContext = librariesFacade.globalContext.contextWithNewLockAndCompositeExceptionTracker()
+                val debugName = "facadeForSpecialModuleInfo (LibrarySourceInfo or NotUnderContentRootModuleInfo)"
+                val globalContext = librariesFacade.globalContext.contextWithNewLockAndCompositeExceptionTracker(debugName)
+                
                 makeProjectResolutionFacade(
-                    "facadeForSpecialModuleInfo (LibrarySourceInfo or NotUnderContentRootModuleInfo)",
+                    debugName,
                     globalContext,
                     reuseDataFrom = librariesFacade,
                     moduleFilter = { it == specialModuleInfo }
@@ -309,7 +311,7 @@ class KotlinCacheServiceImpl(val project: Project) : KotlinCacheService {
                 // currently the only known scenario is when we cannot determine that file is a library source
                 // (file under both classes and sources root)
                 LOG.warn("Creating cache with synthetic files ($files) in classes of library $specialModuleInfo")
-                val globalContext = GlobalContext()
+                val globalContext = GlobalContext("facadeForSpecialModuleInfo for file under both classes and root")
                 makeProjectResolutionFacade(
                     "facadeForSpecialModuleInfo for file under both classes and root",
                     globalContext

idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/util/globalContextUtils.kt

@@ -9,10 +9,10 @@ import org.jetbrains.kotlin.context.GlobalContextImpl
 import org.jetbrains.kotlin.storage.ExceptionTracker
 import org.jetbrains.kotlin.storage.LockBasedStorageManager
 
-internal fun GlobalContextImpl.contextWithNewLockAndCompositeExceptionTracker(): GlobalContextImpl {
+internal fun GlobalContextImpl.contextWithNewLockAndCompositeExceptionTracker(debugName: String): GlobalContextImpl {
     val newExceptionTracker = CompositeExceptionTracker(this.exceptionTracker)
     return GlobalContextImpl(
-        LockBasedStorageManager.createWithExceptionHandling("GlobalContextUtils", newExceptionTracker),
+        LockBasedStorageManager.createWithExceptionHandling(debugName, newExceptionTracker),
         newExceptionTracker
     )
 }

js/js.frontend/src/org/jetbrains/kotlin/js/analyze/TopDownAnalyzerFacadeForJS.kt

@@ -64,7 +64,7 @@ object TopDownAnalyzerFacadeForJS {
 
         val moduleName = configuration[CommonConfigurationKeys.MODULE_NAME]!!
         val context = ContextForNewModule(
-            ProjectContext(project),
+            ProjectContext(project, "TopDownAnalyzer for JS"),
             Name.special("<$moduleName>"),
             builtIns,
             platform = null