[Analysis API] do not create multiple attachments inside exceptions

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/FirDesignationState.kt

@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir
 
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.FirDeclarationDesignation
-import org.jetbrains.kotlin.analysis.low.level.api.fir.util.firErrorWithAttachment
+import org.jetbrains.kotlin.analysis.low.level.api.fir.util.errorWithFirSpecificEntries
 
 abstract class ContextByDesignationCollector<C : Any>(private val designation: FirDeclarationDesignation) {
     private var context: C? = null
@@ -57,7 +57,7 @@ private class FirDesignationState(val designation: FirDeclarationDesignation) {
 
     val currentDeclaration: FirDeclaration
         get() = currentDeclarationIfPresent
-            ?: firErrorWithAttachment("Went inside target declaration")
+            ?: errorWithFirSpecificEntries("Went inside target declaration")
 
     fun goNext() {
         if (canGoNext()) {

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/LLFirResolveStateService.kt

@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLFirLibraryOrLibra
 import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLFirNotUnderContentRootResolvableResolveSession
 import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLFirResolvableResolveSession
 import org.jetbrains.kotlin.analysis.low.level.api.fir.state.LLFirSourceResolveSession
-import org.jetbrains.kotlin.analysis.low.level.api.fir.util.firErrorWithAttachment
+import org.jetbrains.kotlin.analysis.low.level.api.fir.util.errorWithFirSpecificEntries
 import org.jetbrains.kotlin.analysis.project.structure.*
 import org.jetbrains.kotlin.analysis.providers.createProjectWideOutOfBlockModificationTracker
 import org.jetbrains.kotlin.analysis.utils.caches.strongCachedValue
@@ -87,8 +87,8 @@ internal class LLFirResolveSessionService(project: Project) {
                 }
 
                 else -> {
-                    firErrorWithAttachment("Unexpected ${useSiteKtModule::class.java}") {
-                        withAttachment("module", useSiteKtModule.moduleDescription)
+                    errorWithFirSpecificEntries("Unexpected ${useSiteKtModule::class.java}") {
+                        withEntry("module", useSiteKtModule) { it.moduleDescription }
                     }
                 }
             }

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/FirDeclarationDesignation.kt

@@ -5,21 +5,19 @@
 
 package org.jetbrains.kotlin.analysis.low.level.api.fir.api
 
-import org.jetbrains.kotlin.analysis.low.level.api.fir.util.firErrorWithAttachment
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.getContainingFile
-import org.jetbrains.kotlin.analysis.low.level.api.fir.util.withFirAttachment
+import org.jetbrains.kotlin.analysis.low.level.api.fir.util.withFirEntry
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.containingClass
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.utils.classId
 import org.jetbrains.kotlin.fir.declarations.utils.isLocal
-import org.jetbrains.kotlin.fir.renderWithType
 import org.jetbrains.kotlin.fir.resolve.providers.firProvider
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
 import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLookupTagWithFixedSymbol
-import org.jetbrains.kotlin.utils.checkWithAttachment
-import org.jetbrains.kotlin.utils.errorWithAttachment
+import org.jetbrains.kotlin.analysis.utils.errors.buildErrorWithAttachment
+import org.jetbrains.kotlin.analysis.utils.errors.checkWithAttachmentBuilder
 
 class FirDeclarationDesignationWithFile(
     path: List<FirDeclaration>,
@@ -80,8 +78,8 @@ private fun collectDesignationPath(declaration: FirDeclaration): List<FirDeclara
         else -> return null
     } ?: return emptyList()
 
-    checkWithAttachment(containingClass is FirRegularClass, { "FirRegularClass as containing declaration expected" }) {
-        it.withFirAttachment("containingClassFir", containingClass)
+    checkWithAttachmentBuilder(containingClass is FirRegularClass, { "FirRegularClass as containing declaration expected" }) {
+        withFirEntry("containingClassFir", containingClass)
     }
     return if (!containingClass.isLocal) containingClass.collectForNonLocal().asReversed() else null
 }
@@ -92,20 +90,20 @@ private fun ConeClassLikeLookupTag.toFirRegularClassFromSameSession(useSiteSessi
 }
 
 fun FirDeclaration.collectDesignation(firFile: FirFile): FirDeclarationDesignationWithFile =
-    tryCollectDesignation(firFile) ?: errorWithAttachment("No designation of local declaration") {
-        withFirAttachment("firFile", firFile)
+    tryCollectDesignation(firFile) ?: buildErrorWithAttachment("No designation of local declaration") {
+        withFirEntry("firFile", firFile)
     }
 
 fun FirDeclaration.collectDesignation(): FirDeclarationDesignation =
     tryCollectDesignation()
-        ?: errorWithAttachment("No designation of local declaration") {
-            withFirAttachment("FirDeclaration", this@collectDesignation)
+        ?: buildErrorWithAttachment("No designation of local declaration") {
+            withFirEntry("FirDeclaration", this@collectDesignation)
         }
 
 fun FirDeclaration.collectDesignationWithFile(): FirDeclarationDesignationWithFile =
     tryCollectDesignationWithFile()
-        ?: errorWithAttachment("No designation of local declaration") {
-            withFirAttachment("FirDeclaration", this@collectDesignationWithFile)
+        ?: buildErrorWithAttachment("No designation of local declaration") {
+            withFirEntry("FirDeclaration", this@collectDesignationWithFile)
         }
 
 fun FirDeclaration.tryCollectDesignation(firFile: FirFile): FirDeclarationDesignationWithFile? =

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/InvalidFirElementTypeException.kt

@@ -5,15 +5,15 @@
 
 package org.jetbrains.kotlin.analysis.low.level.api.fir.api
 
-import org.jetbrains.kotlin.analysis.low.level.api.fir.util.withConeTypeAttachment
-import org.jetbrains.kotlin.analysis.low.level.api.fir.util.withFirAttachment
-import org.jetbrains.kotlin.analysis.low.level.api.fir.util.withFirSymbolAttachment
+import org.jetbrains.kotlin.analysis.low.level.api.fir.util.withConeTypeEntry
+import org.jetbrains.kotlin.analysis.low.level.api.fir.util.withFirEntry
+import org.jetbrains.kotlin.analysis.low.level.api.fir.util.withFirSymbolEntry
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.utils.KotlinExceptionWithAttachments
-import org.jetbrains.kotlin.utils.withAttachmentDetailed
+import org.jetbrains.kotlin.analysis.utils.errors.*
 import java.util.*
 import kotlin.reflect.KClass
 
@@ -23,12 +23,14 @@ class InvalidFirElementTypeException(
     expectedFirClasses: List<KClass<*>>,
 ) : KotlinExceptionWithAttachments("") {
     init {
-        when (actualFirElement) {
-            is FirElement -> withFirAttachment("firElement", actualFirElement)
-            is FirBasedSymbol<*> -> withFirSymbolAttachment("firSymbol", actualFirElement)
-            is ConeKotlinType -> withConeTypeAttachment("coneType", actualFirElement)
-            null -> {}
-            else -> withAttachmentDetailed("element", actualFirElement) { it.toString() }
+        buildAttachment {
+            when (actualFirElement) {
+                is FirElement -> withFirEntry("firElement", actualFirElement)
+                is FirBasedSymbol<*> -> withFirSymbolEntry("firSymbol", actualFirElement)
+                is ConeKotlinType -> withConeTypeEntry("coneType", actualFirElement)
+                null -> {}
+                else -> withEntry("element", actualFirElement) { it.toString() }
+            }
         }
     }
 

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/KtDeclarationAndFirDeclarationEqualityChecker.kt

@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.api
 
 import org.jetbrains.annotations.TestOnly
 import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.createEmptySession
-import org.jetbrains.kotlin.analysis.low.level.api.fir.util.firErrorWithAttachment
+import org.jetbrains.kotlin.analysis.low.level.api.fir.util.errorWithFirSpecificEntries
 import org.jetbrains.kotlin.builtins.StandardNames
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.builder.BodyBuildingMode
@@ -133,7 +133,7 @@ object KtDeclarationAndFirDeclarationEqualityChecker {
                     }
                 }
             }
-            else -> firErrorWithAttachment("Invalid type reference", fir = this)
+            else -> errorWithFirSpecificEntries("Invalid type reference", fir = this)
         }
         return if (isVararg) {
             rendered.asArrayType()
@@ -166,7 +166,7 @@ object KtDeclarationAndFirDeclarationEqualityChecker {
             }
             append(typeRef.renderTypeAsKotlinType())
         }
-        else -> firErrorWithAttachment("Invalid type reference", fir = this)
+        else -> errorWithFirSpecificEntries("Invalid type reference", fir = this)
     }
 
     private fun isTheSameTypes(
@@ -201,7 +201,7 @@ object KtDeclarationAndFirDeclarationEqualityChecker {
                 // Can be present as return type
                 "${lowerBound.renderTypeAsKotlinType()}..${upperBound.renderTypeAsKotlinType()}"
             }
-            else -> firErrorWithAttachment("Type should not be present in Kotlin declaration", coneType = this)
+            else -> errorWithFirSpecificEntries("Type should not be present in Kotlin declaration", coneType = this)
         }.replace('/', '.')
         return rendered + nullability.suffix
     }

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/api/LowLevelFirApiFacadeForResolveOnAir.kt

@@ -19,10 +19,9 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.lazy.resolve.*
 import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.LLFirResolvableModuleSession
 import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.llFirResolvableSession
 import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.llFirSession
-import org.jetbrains.kotlin.analysis.low.level.api.fir.util.firErrorWithAttachment
+import org.jetbrains.kotlin.analysis.low.level.api.fir.util.errorWithFirSpecificEntries
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.originalDeclaration
 import org.jetbrains.kotlin.analysis.project.structure.getKtModule
-import org.jetbrains.kotlin.analysis.utils.errors.withPsiAttachment
 import org.jetbrains.kotlin.analysis.utils.printer.getElementTextInContext
 import org.jetbrains.kotlin.analysis.utils.printer.parentOfType
 import org.jetbrains.kotlin.analysis.utils.printer.parentsOfType
@@ -40,7 +39,8 @@ import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.containingClassOrObject
 import org.jetbrains.kotlin.psi.psiUtil.isAncestor
-import org.jetbrains.kotlin.utils.errorWithAttachment
+import org.jetbrains.kotlin.analysis.utils.errors.buildErrorWithAttachment
+import org.jetbrains.kotlin.analysis.utils.errors.*
 
 object LowLevelFirApiFacadeForResolveOnAir {
 
@@ -91,9 +91,9 @@ object LowLevelFirApiFacadeForResolveOnAir {
         }
 
         declaration.accept(expressionLocator)
-        return expressionLocator.result ?: firErrorWithAttachment("Resolved on-air element was not found in containing declaration") {
-            withPsiAttachment("place", place)
-            withPsiAttachment("elementToResolve", elementToResolve)
+        return expressionLocator.result ?: errorWithFirSpecificEntries("Resolved on-air element was not found in containing declaration") {
+            withPsiEntry("place", place)
+            withPsiEntry("elementToResolve", elementToResolve)
         }
     }
 
@@ -159,9 +159,9 @@ object LowLevelFirApiFacadeForResolveOnAir {
 
 
         val sameDeclarationInOriginalFile = PsiTreeUtil.findSameElementInCopy(dependencyNonLocalDeclaration, originalKtFile)
-            ?: firErrorWithAttachment("Cannot find original function matching") {
-                withPsiAttachment("matchingPsi", dependencyNonLocalDeclaration)
-                withPsiAttachment("originalFile", originalKtFile)
+            ?: buildErrorWithAttachment("Cannot find original function matching") {
+                withPsiEntry("matchingPsi", dependencyNonLocalDeclaration)
+                withPsiEntry("originalFile", originalKtFile)
             }
 
         recordOriginalDeclaration(
@@ -194,8 +194,8 @@ object LowLevelFirApiFacadeForResolveOnAir {
             replacement = replacement
         )
         val llFirResolvableSession = firFile.llFirResolvableSession
-            ?: errorWithAttachment("FirFile session expected to be a resolvable session but was ${firFile.llFirSession::class.java}") {
-                withAttachment("firSession", firFile.llFirSession)
+            ?: buildErrorWithAttachment("FirFile session expected to be a resolvable session but was ${firFile.llFirSession::class.java}") {
+                withEntry("firSession", firFile.llFirSession) { it.toString() }
             }
         val declarationResolver = llFirResolvableSession.moduleComponents.lazyFirDeclarationsResolver
 

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/lazy/resolve/FirLazyDeclarationResolver.kt

@@ -19,7 +19,7 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LLFirFirProv
 import org.jetbrains.kotlin.analysis.low.level.api.fir.transformers.LazyTransformerFactory
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.checkCanceled
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.findSourceNonLocalFirDeclaration
-import org.jetbrains.kotlin.analysis.low.level.api.fir.util.withFirAttachment
+import org.jetbrains.kotlin.analysis.low.level.api.fir.util.withFirEntry
 import org.jetbrains.kotlin.analysis.utils.errors.shouldIjPlatformExceptionBeRethrown
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.declarations.*
@@ -33,8 +33,8 @@ import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirTowerDataCo
 import org.jetbrains.kotlin.psi.KtClassBody
 import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.psi.KtEnumEntry
-import org.jetbrains.kotlin.utils.errorWithAttachment
-import org.jetbrains.kotlin.utils.withAttachmentDetailed
+import org.jetbrains.kotlin.analysis.utils.errors.buildErrorWithAttachment
+import org.jetbrains.kotlin.analysis.utils.errors.*
 
 internal class FirLazyDeclarationResolver(val moduleComponents: LLFirModuleResolveComponents) {
     /**
@@ -430,7 +430,7 @@ private fun rethrowWithDetails(
     toPhase: FirResolvePhase?
 ): Nothing {
     if (shouldIjPlatformExceptionBeRethrown(e)) throw e
-    errorWithAttachment(
+    buildErrorWithAttachment(
         buildString {
             val moduleData = firDeclarationToResolve.llFirModuleData
             appendLine("Error while resolving ${firDeclarationToResolve::class.java.name} ")
@@ -444,10 +444,10 @@ private fun rethrowWithDetails(
         },
         cause = e,
     ) {
-        withAttachmentDetailed("KtModule", firDeclarationToResolve.llFirModuleData.ktModule) { it.moduleDescription }
-        withAttachmentDetailed("session", firDeclarationToResolve.llFirSession) { it.toString() }
-        withAttachmentDetailed("moduleData", firDeclarationToResolve.moduleData) { it.toString() }
-        withFirAttachment("firDeclarationToResolve", firDeclarationToResolve)
+        withEntry("KtModule", firDeclarationToResolve.llFirModuleData.ktModule) { it.moduleDescription }
+        withEntry("session", firDeclarationToResolve.llFirSession) { it.toString() }
+        withEntry("moduleData", firDeclarationToResolve.moduleData) { it.toString() }
+        withFirEntry("firDeclarationToResolve", firDeclarationToResolve)
     }
 }
 

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/providers/LLFirFirClassByPsiClassProvider.kt

@@ -7,11 +7,10 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.providers
 
 import com.intellij.psi.PsiClass
 import com.intellij.psi.PsiClassOwner
-import com.intellij.psi.PsiJavaFile
 import com.intellij.psi.PsiTypeParameter
 import com.intellij.psi.impl.compiled.ClsElementImpl
 import org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.LLFirSession
-import org.jetbrains.kotlin.analysis.utils.errors.withPsiAttachment
+import org.jetbrains.kotlin.analysis.utils.errors.*
 import org.jetbrains.kotlin.asJava.KtLightClassMarker
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.FirSessionComponent
@@ -22,9 +21,6 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.load.java.JvmAnnotationNames
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.utils.checkWithAttachment
-import org.jetbrains.kotlin.utils.errorWithAttachment
-import org.jetbrains.kotlin.utils.withAttachmentBuilder
 
 class LLFirFirClassByPsiClassProvider(private val session: LLFirSession) : FirSessionComponent {
     fun getFirClass(psiClass: PsiClass): FirRegularClassSymbol? {
@@ -36,16 +32,13 @@ class LLFirFirClassByPsiClassProvider(private val session: LLFirSession) : FirSe
             "${LLFirFirClassByPsiClassProvider::class.simpleName} can create only non-kotlin classes"
         }
 
-        checkWithAttachment(
+        checkWithAttachmentBuilder(
             psiClass !is ClsElementImpl || !psiClass.hasAnnotation(JvmAnnotationNames.METADATA_FQ_NAME.asString()), {
                 "${LLFirFirClassByPsiClassProvider::class.simpleName} can create only non-kotlin classes, but got ${psiClass::class} with ${JvmAnnotationNames.METADATA_FQ_NAME.asString()} annotation"
             }
         ) {
-            it.withAttachmentBuilder("psiClass") {
-                appendLine("file: ${psiClass.containingFile?.virtualFile?.path}")
-                appendLine("PsiClass:")
-                appendLine(psiClass.text)
-            }
+            withEntry("virtualFilePath", psiClass.containingFile.virtualFile?.path)
+            withPsiEntry("psiClass", psiClass)
         }
 
         if (psiClass.qualifiedName == null) {
@@ -53,18 +46,21 @@ class LLFirFirClassByPsiClassProvider(private val session: LLFirSession) : FirSe
         }
 
         val firClassSymbol = createFirClassFromFirProvider(psiClass)
-        checkWithAttachment(
-            firClassSymbol.fir.psi == psiClass,
+        val gotPsi = firClassSymbol.fir.psi
+        checkWithAttachmentBuilder(
+            gotPsi == psiClass,
             { "resulted FirClass.psi != requested PsiClass" }
         ) {
-            it.withAttachmentBuilder("info") {
-                appendLine("Requested ${psiClass::class.java.name}:")
-                appendLine("path: ${psiClass.containingFile?.virtualFile?.path}")
-                appendLine("modificationStamp: ${psiClass.containingFile.modificationStamp}")
-                appendLine()
-                appendLine("Got ${firClassSymbol.fir.psi!!::class.java.name}")
-                appendLine("path: ${firClassSymbol.fir.psi?.containingFile?.virtualFile?.path}")
-                appendLine("modificationStamp: ${firClassSymbol.fir.psi?.containingFile?.modificationStamp}")
+            withEntryGroup("Requested") {
+                withClassEntry("psiElementClass", psiClass)
+                withEntry("path", psiClass.containingFile?.virtualFile?.path)
+                withEntry("modificationStamp", psiClass.containingFile.modificationStamp.toString())
+            }
+
+            withEntryGroup("Got") {
+                withClassEntry("psiElementClass", gotPsi)
+                withEntry("path", gotPsi?.containingFile?.virtualFile?.path)
+                withEntry("modificationStamp", gotPsi?.containingFile?.modificationStamp.toString())
             }
         }
         return firClassSymbol
@@ -75,9 +71,9 @@ class LLFirFirClassByPsiClassProvider(private val session: LLFirSession) : FirSe
             ?: error("No classId for non-local class")
         val provider = session.nullableJavaSymbolProvider ?: session.symbolProvider
         val symbol = provider.getClassLikeSymbolByClassId(classId)
-            ?: errorWithAttachment("No classifier found") {
-                withPsiAttachment("psiClass", psiClass)
-                withAttachment("classId", classId.asString())
+            ?: buildErrorWithAttachment("No classifier found") {
+                withPsiEntry("psiClass", psiClass)
+                withEntry("classId", classId) { it.asString() }
             }
         return symbol as FirRegularClassSymbol
     }

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/state/LLFirResolvableResolveSession.kt

@@ -21,7 +21,6 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.util.originalDeclaration
 import org.jetbrains.kotlin.analysis.project.structure.KtModule
 import org.jetbrains.kotlin.analysis.project.structure.getKtModule
 import org.jetbrains.kotlin.analysis.utils.errors.requireIsInstance
-import org.jetbrains.kotlin.analysis.utils.errors.withPsiAttachment
 import org.jetbrains.kotlin.analysis.utils.printer.getElementTextInContext
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
@@ -35,8 +34,8 @@ import org.jetbrains.kotlin.fir.resolve.providers.firProvider
 import org.jetbrains.kotlin.fir.resolve.providers.symbolProvider
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.utils.errorWithAttachment
-import org.jetbrains.kotlin.utils.withAttachmentDetailed
+import org.jetbrains.kotlin.analysis.utils.errors.buildErrorWithAttachment
+import org.jetbrains.kotlin.analysis.utils.errors.*
 
 internal abstract class LLFirResolvableResolveSession(
     private val sessionProvider: LLFirSessionProvider,
@@ -103,9 +102,9 @@ internal abstract class LLFirResolvableResolveSession(
             "Declaration should be resolvable module, instead it had ${module::class}"
         }
         val nonLocalNamedDeclaration = ktDeclaration.getNonLocalContainingOrThisDeclaration()
-            ?: errorWithAttachment("Declaration should have non-local container") {
-                withPsiAttachment("ktDeclaration", ktDeclaration)
-                withAttachmentDetailed("module", module) { it.moduleDescription }
+            ?: buildErrorWithAttachment("Declaration should have non-local container") {
+                withPsiEntry("ktDeclaration", ktDeclaration)
+                withEntry("module", module) { it.moduleDescription }
             }
 
         if (ktDeclaration == nonLocalNamedDeclaration) {

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/util/FirDeclarationForCompiledElementSearcher.kt

@@ -7,7 +7,8 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.util
 
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.KtDeclarationAndFirDeclarationEqualityChecker
 import org.jetbrains.kotlin.analysis.low.level.api.fir.project.structure.llFirModuleData
-import org.jetbrains.kotlin.analysis.utils.printer.getElementTextInContext
+import org.jetbrains.kotlin.analysis.utils.errors.ExceptionAttachmentBuilder
+import org.jetbrains.kotlin.analysis.utils.errors.withClassEntry
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.providers.getClassDeclaredConstructors
@@ -19,8 +20,6 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.containingClassOrObject
-import org.jetbrains.kotlin.utils.KotlinExceptionWithAttachments
-import org.jetbrains.kotlin.utils.withAttachmentBuilder
 
 /**
  * Allows to search for FIR declarations by compiled [KtDeclaration]s.
@@ -34,17 +33,17 @@ internal class FirDeclarationForCompiledElementSearcher(private val symbolProvid
             is KtNamedFunction -> findNonLocalFunction(ktDeclaration)
             is KtProperty -> findNonLocalProperty(ktDeclaration)
 
-            else -> firErrorWithAttachment("Unsupported compiled declaration of type", psi = ktDeclaration)
+            else -> errorWithFirSpecificEntries("Unsupported compiled declaration of type", psi = ktDeclaration)
         }
     }
 
     private fun findNonLocalEnumEntry(declaration: KtEnumEntry): FirEnumEntry {
         require(!declaration.isLocal)
         val classId = declaration.containingClassOrObject?.getClassId()
-            ?: firErrorWithAttachment("Non-local class should have classId", psi = declaration)
+            ?: errorWithFirSpecificEntries("Non-local class should have classId", psi = declaration)
 
         val classCandidate = symbolProvider.getClassLikeSymbolByClassId(classId)
-            ?: firErrorWithAttachment("We should be able to find a symbol for $classId", psi = declaration)
+            ?: errorWithFirSpecificEntries("We should be able to find a symbol for $classId", psi = declaration)
 
         return (classCandidate.fir as? FirRegularClass)?.declarations?.first {
             it is FirEnumEntry && it.name == declaration.nameAsName
@@ -53,11 +52,11 @@ internal class FirDeclarationForCompiledElementSearcher(private val symbolProvid
 
     private fun findNonLocalClassLikeDeclaration(declaration: KtClassLikeDeclaration): FirClassLikeDeclaration {
         val classId = declaration.getClassId()
-            ?: firErrorWithAttachment("Non-local class should have classId", psi = declaration)
+            ?: errorWithFirSpecificEntries("Non-local class should have classId", psi = declaration)
 
         val classCandidate = symbolProvider.getClassLikeSymbolByClassId(classId)
-            ?: firErrorWithAttachment("We should be able to find a symbol for $classId", psi = declaration) {
-                withAttachment("classId", classId.asString())
+            ?: errorWithFirSpecificEntries("We should be able to find a symbol for $classId", psi = declaration) {
+                withEntry("classId", classId) { it.asString() }
             }
 
         return classCandidate.fir
@@ -65,16 +64,16 @@ internal class FirDeclarationForCompiledElementSearcher(private val symbolProvid
 
     private fun findConstructorOfNonLocalClass(declaration: KtConstructor<*>): FirConstructor {
         val containingClass = declaration.containingClassOrObject
-            ?: firErrorWithAttachment("Constructor must have outer class", psi = declaration)
+            ?: errorWithFirSpecificEntries("Constructor must have outer class", psi = declaration)
 
         require(!containingClass.isLocal)
         val classId = containingClass.getClassId()
-            ?: firErrorWithAttachment("Non-local class should have classId", psi = declaration)
+            ?: errorWithFirSpecificEntries("Non-local class should have classId", psi = declaration)
 
         val constructorCandidate =
             symbolProvider.getClassDeclaredConstructors(classId)
                 .singleOrNull { representSameConstructor(declaration, it.fir) }
-                ?: firErrorWithAttachment("We should be able to find a constructor", psi = declaration)
+                ?: errorWithFirSpecificEntries("We should be able to find a constructor", psi = declaration)
 
         return constructorCandidate.fir
     }
@@ -86,7 +85,7 @@ internal class FirDeclarationForCompiledElementSearcher(private val symbolProvid
         val functionCandidate =
             candidates
                 .singleOrNull { KtDeclarationAndFirDeclarationEqualityChecker.representsTheSameDeclaration(declaration, it.fir) }
-                ?: firErrorWithAttachment("We should be able to find a symbol for function", psi = declaration) {
+                ?: errorWithFirSpecificEntries("We should be able to find a symbol for function", psi = declaration) {
                     withCandidates(candidates)
                 }
 
@@ -100,7 +99,7 @@ internal class FirDeclarationForCompiledElementSearcher(private val symbolProvid
         val candidates = symbolProvider.findPropertyCandidates(declaration)
         val propertyCandidate =
             candidates.singleOrNull { KtDeclarationAndFirDeclarationEqualityChecker.representsTheSameDeclaration(declaration, it.fir) }
-                ?: firErrorWithAttachment("We should be able to find a symbol for property", psi = declaration) {
+                ?: errorWithFirSpecificEntries("We should be able to find a symbol for property", psi = declaration) {
                     withCandidates(candidates)
                 }
 
@@ -124,7 +123,7 @@ private fun FirSymbolProvider.findCallableCandidates(
     }
 
     val containerClassId = declaration.containingClassOrObject?.getClassId()
-        ?: firErrorWithAttachment("No containing non-local declaration found for", psi = declaration)
+        ?: errorWithFirSpecificEntries("No containing non-local declaration found for", psi = declaration)
 
     return getClassDeclaredFunctionSymbols(containerClassId, declaration.nameAsSafeName) +
             getClassDeclaredPropertySymbols(containerClassId, declaration.nameAsSafeName)
@@ -138,16 +137,16 @@ private fun representSameConstructor(psiConstructor: KtConstructor<*>, firConstr
     return KtDeclarationAndFirDeclarationEqualityChecker.representsTheSameDeclaration(psiConstructor, firConstructor)
 }
 
-private fun KotlinExceptionWithAttachments.withCandidates(candidates: List<FirBasedSymbol<*>>) {
-    withAttachmentBuilder("candidates") {
-        appendLine("Candidates count ${candidates.size}")
-        for ((index, candidate) in candidates.withIndex()) {
-            appendLine("Candidate $index, ${candidate::class.java}")
-            val ktModule = candidate.llFirModuleData.ktModule
-            appendLine("From ${ktModule::class.java} ${ktModule.moduleDescription}")
-            appendLine("Origin ${candidate.origin}")
-            appendLine(debugFirRenderer.renderElementAsString(candidate.fir))
-            appendLine()
+private fun ExceptionAttachmentBuilder.withCandidates(candidates: List<FirBasedSymbol<*>>) {
+    withEntry("Candidates count", candidates.size.toString())
+    for ((index, candidate) in candidates.withIndex()) {
+        val ktModule = candidate.llFirModuleData.ktModule
+        withEntryGroup(index.toString()) {
+            withClassEntry("candidateClass", candidate)
+            withEntry("module", ktModule) { it.moduleDescription }
+            withEntry("origin", candidate.origin.toString())
+            withFirEntry("candidateFir", candidate.fir)
+
         }
     }
 }

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/util/contrainingFileUtils.kt

@@ -17,6 +17,6 @@ fun FirDeclaration.getContainingFile(): FirFile? {
         is FirFile -> this
         is FirCallableDeclaration -> provider.getFirCallableContainerFile(symbol)
         is FirClassLikeDeclaration -> provider.getFirClassifierContainerFile(symbol)
-        else -> firErrorWithAttachment("Unsupported declaration ${this::class.java}", fir = this)
+        else -> errorWithFirSpecificEntries("Unsupported declaration ${this::class.java}", fir = this)
     }
 }

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/util/declarationUtils.kt

@@ -8,7 +8,6 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.util
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.throwUnexpectedFirElementError
 import org.jetbrains.kotlin.analysis.low.level.api.fir.element.builder.getNonLocalContainingOrThisDeclaration
 import org.jetbrains.kotlin.analysis.low.level.api.fir.file.builder.LLFirFileBuilder
-import org.jetbrains.kotlin.analysis.utils.printer.getElementTextInContext
 import org.jetbrains.kotlin.fir.declarations.FirClassLikeDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirFile
@@ -30,7 +29,7 @@ internal fun KtDeclaration.findSourceNonLocalFirDeclaration(
     //TODO test what way faster
     findSourceNonLocalFirDeclarationByProvider(firFileBuilder, provider, containerFirFile)?.let { return it }
     findSourceOfNonLocalFirDeclarationByTraversingWholeTree(firFileBuilder, containerFirFile)?.let { return it }
-    firErrorWithAttachment("No fir element was found for", psi = this)
+    errorWithFirSpecificEntries("No fir element was found for", psi = this)
 }
 
 internal fun KtDeclaration.findFirDeclarationForAnyFirSourceDeclaration(
@@ -45,7 +44,7 @@ internal fun KtDeclaration.findFirDeclarationForAnyFirSourceDeclaration(
         firDeclaration.psi == this || firDeclaration.psi == originalDeclaration
     }
     return fir
-        ?: firErrorWithAttachment("FirDeclaration was not found", psi = this)
+        ?: errorWithFirSpecificEntries("FirDeclaration was not found", psi = this)
 }
 
 internal inline fun <reified F : FirDeclaration> KtDeclaration.findFirDeclarationForAnyFirSourceDeclarationOfType(
@@ -95,12 +94,12 @@ private fun KtDeclaration.findSourceNonLocalFirDeclarationByProvider(
         }
         this is KtConstructor<*> -> {
             val containingClass = containingClassOrObject
-                ?: firErrorWithAttachment("Container class should be not null for KtConstructor", psi = this)
+                ?: errorWithFirSpecificEntries("Container class should be not null for KtConstructor", psi = this)
             val containerClassFir = containingClass.findFir(provider) as? FirRegularClass ?: return null
             containerClassFir.declarations.firstOrNull { it.psi === this }
         }
         this is KtTypeAlias -> findFir(provider)
-        else -> firErrorWithAttachment("Invalid container", psi = this)
+        else -> errorWithFirSpecificEntries("Invalid container", psi = this)
     }
     return candidate?.takeIf { it.realPsi == this }
 }

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/util/exceptionUtils.kt

@@ -6,8 +6,9 @@
 package org.jetbrains.kotlin.analysis.low.level.api.fir.util
 
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.analysis.utils.errors.withPsiAttachment
-import org.jetbrains.kotlin.analysis.utils.printer.getElementTextInContext
+import org.jetbrains.kotlin.analysis.utils.errors.ExceptionAttachmentBuilder
+import org.jetbrains.kotlin.analysis.utils.errors.buildErrorWithAttachment
+import org.jetbrains.kotlin.analysis.utils.errors.withPsiEntry
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.psi
 import org.jetbrains.kotlin.fir.renderer.ConeTypeRendererForDebugging
@@ -16,58 +17,49 @@ import org.jetbrains.kotlin.fir.renderer.FirRenderer
 import org.jetbrains.kotlin.fir.renderer.FirResolvePhaseRenderer
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
-import org.jetbrains.kotlin.psi.KtElement
-import org.jetbrains.kotlin.utils.KotlinExceptionWithAttachments
-import org.jetbrains.kotlin.utils.errorWithAttachment
-import org.jetbrains.kotlin.utils.withAttachmentDetailed
 
 
-fun KotlinExceptionWithAttachments.withFirAttachment(name: String, fir: FirElement): KotlinExceptionWithAttachments {
-    withAttachmentDetailed(name, fir, debugFirRenderer::renderElementAsString)
-    withPsiAttachment("${name}Psi", fir.psi)
-    return this
+fun ExceptionAttachmentBuilder.withFirEntry(name: String, fir: FirElement) {
+    withEntry(name, fir) {
+        FirRenderer(
+            resolvePhaseRenderer = FirResolvePhaseRenderer(),
+            declarationRenderer = FirDeclarationRendererWithAttributes()
+        ).renderElementAsString(it)
+    }
+    withPsiEntry("${name}Psi", fir.psi)
 }
 
-fun KotlinExceptionWithAttachments.withFirSymbolAttachment(name: String, symbol: FirBasedSymbol<*>): KotlinExceptionWithAttachments {
-    withAttachment("${name}Class", symbol::class.java.name)
-    withFirAttachment("${name}Fir", symbol.fir)
-    return this
+fun ExceptionAttachmentBuilder.withFirSymbolEntry(name: String, symbol: FirBasedSymbol<*>) {
+    withFirEntry("${name}Fir", symbol.fir)
 }
 
-fun KotlinExceptionWithAttachments.withConeTypeAttachment(name: String, coneType: ConeKotlinType): KotlinExceptionWithAttachments {
-    withAttachmentDetailed(name, coneType) {
+fun ExceptionAttachmentBuilder.withConeTypeEntry(name: String, coneType: ConeKotlinType) {
+    withEntry(name, coneType) {
         buildString { ConeTypeRendererForDebugging(this).render(it) }
     }
-    return this
 }
 
 
-
-
-fun firErrorWithAttachment(
+fun errorWithFirSpecificEntries(
     message: String,
     cause: Throwable? = null,
     fir: FirElement? = null,
     coneType: ConeKotlinType? = null,
     psi: PsiElement? = null,
-    attachments: KotlinExceptionWithAttachments.() -> Unit = {}
+    additionalInfos: ExceptionAttachmentBuilder.() -> Unit = {}
 ): Nothing {
-    errorWithAttachment(message, cause) {
+    buildErrorWithAttachment(message, cause) {
         if (fir != null) {
-            withFirAttachment("fir", fir)
+            withFirEntry("fir", fir)
         }
 
         if (psi != null) {
-            withPsiAttachment("psi", psi)
+            withPsiEntry("psi", psi)
         }
 
         if (coneType != null) {
-            withConeTypeAttachment("coneType", coneType)
+            withConeTypeEntry("coneType", coneType)
         }
-        attachments ()
+        additionalInfos()
     }
 }
-
-
-val debugFirRenderer =
-    FirRenderer(resolvePhaseRenderer = FirResolvePhaseRenderer(), declarationRenderer = FirDeclarationRendererWithAttributes())

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/util/utils.kt

@@ -7,12 +7,10 @@ package org.jetbrains.kotlin.analysis.low.level.api.fir.util
 
 import com.intellij.openapi.progress.ProgressManager
 import com.intellij.psi.util.*
-import org.jetbrains.kotlin.analysis.utils.printer.getElementTextInContext
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.diagnostics.FirDiagnosticHolder
 import org.jetbrains.kotlin.fir.psi
-import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.isObjectLiteral
 import java.util.concurrent.TimeUnit
@@ -54,11 +52,11 @@ internal val FirElement.isErrorElement
 internal val FirDeclaration.ktDeclaration: KtDeclaration
     get() {
         val psi = psi
-            ?: firErrorWithAttachment("PSI element was not found", fir = this)
+            ?: errorWithFirSpecificEntries("PSI element was not found", fir = this)
         return when (psi) {
             is KtDeclaration -> psi
             is KtObjectLiteralExpression -> psi.objectDeclaration
-            else -> firErrorWithAttachment(
+            else -> errorWithFirSpecificEntries(
                 "FirDeclaration.psi (${this::class.simpleName}) should be KtDeclaration but was ${psi::class.simpleName}",
                 fir = this,
                 psi = psi,