[FIR] Switch names of FirDiagnostic and ConeDiagnostic

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/AbstractDiagnosticCollector.kt

@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.analysis.checkers.context.PersistentCheckerContext
 import org.jetbrains.kotlin.fir.analysis.collectors.components.*
-import org.jetbrains.kotlin.fir.analysis.diagnostics.ConeDiagnostic
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnostic
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
@@ -27,7 +27,7 @@ abstract class AbstractDiagnosticCollector(
     override val session: FirSession,
     override val scopeSession: ScopeSession = ScopeSession()
 ) : SessionHolder {
-    fun collectDiagnostics(firFile: FirFile): Iterable<ConeDiagnostic> {
+    fun collectDiagnostics(firFile: FirFile): Iterable<FirDiagnostic> {
         if (!componentsInitialized) {
             throw IllegalStateException("Components are not initialized")
         }
@@ -37,7 +37,7 @@ abstract class AbstractDiagnosticCollector(
     }
 
     protected abstract fun initializeCollector()
-    protected abstract fun getCollectedDiagnostics(): Iterable<ConeDiagnostic>
+    protected abstract fun getCollectedDiagnostics(): Iterable<FirDiagnostic>
     abstract fun runCheck(block: (DiagnosticReporter) -> Unit)
 
     private val components: MutableList<AbstractDiagnosticCollectorComponent> = mutableListOf()

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/ParallelDiagnosticsCollector.kt

@@ -6,7 +6,7 @@
 package org.jetbrains.kotlin.fir.analysis.collectors
 
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.analysis.diagnostics.ConeDiagnostic
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnostic
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.SimpleDiagnosticReporter
 import java.util.*
@@ -42,10 +42,10 @@ class ParallelDiagnosticsCollector(session: FirSession, private val numberOfThre
         futures.clear()
     }
 
-    override fun getCollectedDiagnostics(): Iterable<ConeDiagnostic> {
+    override fun getCollectedDiagnostics(): Iterable<FirDiagnostic> {
         futures.forEach { it.get() }
         return Iterable {
-            object : Iterator<ConeDiagnostic> {
+            object : Iterator<FirDiagnostic> {
                 private val globalIterator = reporters.iterator()
                 private var localIterator = globalIterator.next().diagnostics.iterator()
 
@@ -60,7 +60,7 @@ class ParallelDiagnosticsCollector(session: FirSession, private val numberOfThre
                     return localIterator.hasNext()
                 }
 
-                override fun next(): ConeDiagnostic {
+                override fun next(): FirDiagnostic {
                     update()
                     return localIterator.next()
                 }

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/SimpleDiagnosticsCollector.kt

@@ -6,7 +6,7 @@
 package org.jetbrains.kotlin.fir.analysis.collectors
 
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.analysis.diagnostics.ConeDiagnostic
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnostic
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.SimpleDiagnosticReporter
 
@@ -17,7 +17,7 @@ class SimpleDiagnosticsCollector(session: FirSession) : AbstractDiagnosticCollec
         reporter = SimpleDiagnosticReporter()
     }
 
-    override fun getCollectedDiagnostics(): Iterable<ConeDiagnostic> {
+    override fun getCollectedDiagnostics(): Iterable<FirDiagnostic> {
         return reporter.diagnostics
     }
 

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/components/ErrorNodeDiagnosticCollectorComponent.kt

@@ -12,10 +12,7 @@ import org.jetbrains.kotlin.diagnostics.Errors
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.collectors.AbstractDiagnosticCollector
-import org.jetbrains.kotlin.fir.analysis.diagnostics.ConeDiagnostic
-import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
-import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
-import org.jetbrains.kotlin.fir.analysis.diagnostics.onSource
+import org.jetbrains.kotlin.fir.analysis.diagnostics.*
 import org.jetbrains.kotlin.fir.declarations.FirErrorFunction
 import org.jetbrains.kotlin.fir.diagnostics.*
 import org.jetbrains.kotlin.fir.expressions.FirErrorExpression
@@ -50,25 +47,25 @@ class ErrorNodeDiagnosticCollectorComponent(collector: AbstractDiagnosticCollect
         runCheck { reportFirDiagnostic(errorFunction.diagnostic, source, it) }
     }
 
-    private fun reportFirDiagnostic(diagnostic: FirDiagnostic, source: FirSourceElement, reporter: DiagnosticReporter) {
+    private fun reportFirDiagnostic(diagnostic: ConeDiagnostic, source: FirSourceElement, reporter: DiagnosticReporter) {
         val coneDiagnostic = when (diagnostic) {
-            is FirUnresolvedReferenceError -> FirErrors.UNRESOLVED_REFERENCE.onSource(source, diagnostic.name?.asString())
-            is FirUnresolvedSymbolError -> FirErrors.UNRESOLVED_REFERENCE.onSource(source, diagnostic.classId.asString())
-            is FirUnresolvedNameError -> FirErrors.UNRESOLVED_REFERENCE.onSource(source, diagnostic.name.asString())
-            is FirInapplicableCandidateError -> FirErrors.INAPPLICABLE_CANDIDATE.onSource(source, diagnostic.candidates.map { it.symbol })
-            is FirAmbiguityError -> FirErrors.AMBIGUITY.onSource(source, diagnostic.candidates)
-            is FirOperatorAmbiguityError -> FirErrors.ASSIGN_OPERATOR_AMBIGUITY.onSource(source, diagnostic.candidates)
-            is FirVariableExpectedError -> Errors.VARIABLE_EXPECTED.onSource(source)
-            is FirTypeMismatchError -> FirErrors.TYPE_MISMATCH.onSource(source, diagnostic.expectedType, diagnostic.actualType)
-            is FirSimpleDiagnostic -> diagnostic.getFactory().onSource(source)
-            is FirDiagnosticWithParameters1<*> -> diagnostic.getFactory().tryOnSource(source, diagnostic.a)
-            is FirStubDiagnostic -> null
+            is ConeUnresolvedReferenceError -> FirErrors.UNRESOLVED_REFERENCE.onSource(source, diagnostic.name?.asString())
+            is ConeUnresolvedSymbolError -> FirErrors.UNRESOLVED_REFERENCE.onSource(source, diagnostic.classId.asString())
+            is ConeUnresolvedNameError -> FirErrors.UNRESOLVED_REFERENCE.onSource(source, diagnostic.name.asString())
+            is ConeInapplicableCandidateError -> FirErrors.INAPPLICABLE_CANDIDATE.onSource(source, diagnostic.candidates.map { it.symbol })
+            is ConeAmbiguityError -> FirErrors.AMBIGUITY.onSource(source, diagnostic.candidates)
+            is ConeOperatorAmbiguityError -> FirErrors.ASSIGN_OPERATOR_AMBIGUITY.onSource(source, diagnostic.candidates)
+            is ConeVariableExpectedError -> Errors.VARIABLE_EXPECTED.onSource(source)
+            is ConeTypeMismatchError -> FirErrors.TYPE_MISMATCH.onSource(source, diagnostic.expectedType, diagnostic.actualType)
+            is ConeSimpleDiagnostic -> diagnostic.getFactory().onSource(source)
+            is ConeSimpleDiagnosticWithParameters1<*> -> diagnostic.getFactory().tryOnSource(source, diagnostic.a)
+            is ConeStubDiagnostic -> null
             else -> throw IllegalArgumentException("Unsupported diagnostic type: ${diagnostic.javaClass}")
         }
         reporter.report(coneDiagnostic)
     }
 
-    private fun FirSimpleDiagnostic.getFactory(): DiagnosticFactory0<PsiElement> {
+    private fun ConeSimpleDiagnostic.getFactory(): DiagnosticFactory0<PsiElement> {
         @Suppress("UNCHECKED_CAST")
         return when (kind) {
             DiagnosticKind.Syntax -> FirErrors.SYNTAX_ERROR
@@ -89,19 +86,11 @@ class ErrorNodeDiagnosticCollectorComponent(collector: AbstractDiagnosticCollect
         } as DiagnosticFactory0<PsiElement>
     }
 
-    private fun FirDiagnosticWithParameters1<*>.getFactory(): DiagnosticFactory1<PsiElement, Any?> {
+    private fun ConeSimpleDiagnosticWithParameters1<*>.getFactory(): DiagnosticFactory1<PsiElement, Any?> {
         @Suppress("UNCHECKED_CAST")
         return when (kind) {
             DiagnosticKind.SuperNotAllowed -> Errors.SUPER_IS_NOT_AN_EXPRESSION
             else -> throw IllegalArgumentException("Unsupported diagnostic kind: $kind at $javaClass")
         } as DiagnosticFactory1<PsiElement, Any?>
     }
-
-    private inline fun <reified E : PsiElement, reified A> DiagnosticFactory1<E, A>.tryOnSource(
-        source: FirSourceElement,
-        a: Any?
-    ): ConeDiagnostic? {
-        val aa = a as? A ?: throw IllegalArgumentException("Parameter passed to the factory is of incompatible type!")
-        return onSource(source, aa)
-    }
 }

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/DiagnosticReporter.kt

@@ -6,13 +6,13 @@
 package org.jetbrains.kotlin.fir.analysis.diagnostics
 
 abstract class DiagnosticReporter {
-    abstract fun report(diagnostic: ConeDiagnostic?)
+    abstract fun report(diagnostic: FirDiagnostic?)
 }
 
 class SimpleDiagnosticReporter : DiagnosticReporter() {
-    val diagnostics: MutableList<ConeDiagnostic> = mutableListOf()
+    val diagnostics: MutableList<FirDiagnostic> = mutableListOf()
 
-    override fun report(diagnostic: ConeDiagnostic?) {
+    override fun report(diagnostic: FirDiagnostic?) {
         if (diagnostic == null) return
         diagnostics += diagnostic
     }

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDiagnostic.kt

@@ -10,31 +10,39 @@ import org.jetbrains.kotlin.diagnostics.*
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.psi
 
-class ConeDiagnostic(
+class FirDiagnostic(
     val diagnostic: Diagnostic,
     val source: FirSourceElement
 )
 
-inline fun <reified E : PsiElement> DiagnosticFactory0<E>.onSource(source: FirSourceElement): ConeDiagnostic? {
+inline fun <reified E : PsiElement> DiagnosticFactory0<E>.onSource(source: FirSourceElement): FirDiagnostic? {
     val psi = source.psi as? E
         ?: throw IllegalArgumentException("Incompatible PSI: expected ${E::class}, actual ${source.psi?.let { it::class }}")
-    return ConeDiagnostic(this.on(psi), source)
+    return FirDiagnostic(this.on(psi), source)
 }
 
-inline fun <reified E : PsiElement, A> DiagnosticFactory1<E, A>.onSource(source: FirSourceElement, a: A): ConeDiagnostic? {
+inline fun <reified E : PsiElement, A> DiagnosticFactory1<E, A>.onSource(source: FirSourceElement, a: A): FirDiagnostic? {
     val psi = source.psi as? E
         ?: throw IllegalArgumentException("Incompatible PSI: expected ${E::class}, actual ${source.psi?.let { it::class }}")
-    return ConeDiagnostic(this.on(psi, a), source)
+    return FirDiagnostic(this.on(psi, a), source)
 }
 
-inline fun <reified E : PsiElement, A, B> DiagnosticFactory2<E, A, B>.onSource(source: FirSourceElement, a: A, b: B): ConeDiagnostic? {
+inline fun <reified E : PsiElement, A, B> DiagnosticFactory2<E, A, B>.onSource(source: FirSourceElement, a: A, b: B): FirDiagnostic? {
     val psi = source.psi as? E
         ?: throw IllegalArgumentException("Incompatible PSI: expected ${E::class}, actual ${source.psi?.let { it::class }}")
-    return ConeDiagnostic(this.on(psi, a, b), source)
+    return FirDiagnostic(this.on(psi, a, b), source)
 }
 
-inline fun <reified E : PsiElement, A, B, C> DiagnosticFactory3<E, A, B, C>.onSource(source: FirSourceElement, a: A, b: B, c: C): ConeDiagnostic? {
+inline fun <reified E : PsiElement, A, B, C> DiagnosticFactory3<E, A, B, C>.onSource(source: FirSourceElement, a: A, b: B, c: C): FirDiagnostic? {
     val psi = source.psi as? E
         ?: throw IllegalArgumentException("Incompatible PSI: expected ${E::class}, actual ${source.psi?.let { it::class }}")
-    return ConeDiagnostic(this.on(psi, a, b, c), source)
+    return FirDiagnostic(this.on(psi, a, b, c), source)
 }
+
+inline fun <reified E : PsiElement, reified A> DiagnosticFactory1<E, A>.tryOnSource(
+    source: FirSourceElement,
+    a: Any?
+): FirDiagnostic? {
+    val aa = a as? A ?: throw IllegalArgumentException("Parameter passed to the factory is of incompatible type!")
+    return onSource(source, aa)
+}

compiler/fir/dump/src/org/jetbrains/kotlin/fir/dump/HtmlFirDump.kt

@@ -17,14 +17,14 @@ import org.jetbrains.kotlin.fir.backend.left
 import org.jetbrains.kotlin.fir.backend.right
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor
-import org.jetbrains.kotlin.fir.diagnostics.FirDiagnostic
+import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.expressions.impl.FirElseIfTrueCondition
 import org.jetbrains.kotlin.fir.expressions.impl.FirUnitExpression
 import org.jetbrains.kotlin.fir.references.*
 import org.jetbrains.kotlin.fir.references.impl.FirSimpleNamedReference
-import org.jetbrains.kotlin.fir.resolve.diagnostics.FirAmbiguityError
-import org.jetbrains.kotlin.fir.resolve.diagnostics.FirInapplicableCandidateError
+import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeAmbiguityError
+import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeInapplicableCandidateError
 import org.jetbrains.kotlin.fir.resolve.directExpansionType
 import org.jetbrains.kotlin.fir.resolve.fullyExpandedType
 import org.jetbrains.kotlin.fir.resolve.toSymbol
@@ -1183,9 +1183,9 @@ class HtmlFirDump internal constructor(private var linkResolver: FirLinkResolver
         }
     }
 
-    private fun FlowContent.generate(diagnostic: FirDiagnostic) {
+    private fun FlowContent.generate(diagnostic: ConeDiagnostic) {
         when (diagnostic) {
-            is FirInapplicableCandidateError -> {
+            is ConeInapplicableCandidateError -> {
                 for (candidate in diagnostic.candidates) {
                     describeVerbose(candidate.symbol)
                     br
@@ -1210,7 +1210,7 @@ class HtmlFirDump internal constructor(private var linkResolver: FirLinkResolver
                     }
                 }
             }
-            is FirAmbiguityError -> {
+            is ConeAmbiguityError -> {
                 +"Ambiguity: "
                 br
                 for (candidate in diagnostic.candidates) {

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt

@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
 import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
-import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic
+import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.expressions.builder.*
 import org.jetbrains.kotlin.fir.java.declarations.buildJavaValueParameter
@@ -423,7 +423,7 @@ private fun JavaAnnotationArgument.toFirExpression(
                 }
                 this.calleeReference = calleeReference
                     ?: buildErrorNamedReference {
-                        diagnostic = FirSimpleDiagnostic("Strange Java enum value: $classId.$entryName", DiagnosticKind.Java)
+                        diagnostic = ConeSimpleDiagnostic("Strange Java enum value: $classId.$entryName", DiagnosticKind.Java)
                     }
             }
         }
@@ -437,7 +437,7 @@ private fun JavaAnnotationArgument.toFirExpression(
         }
         is JavaAnnotationAsAnnotationArgument -> getAnnotation().toFirAnnotationCall(session, javaTypeParameterStack)
         else -> buildErrorExpression {
-            diagnostic = FirSimpleDiagnostic("Unknown JavaAnnotationArgument: ${this::class.java}", DiagnosticKind.Java)
+            diagnostic = ConeSimpleDiagnostic("Unknown JavaAnnotationArgument: ${this::class.java}", DiagnosticKind.Java)
         }
     }
 }
@@ -475,7 +475,7 @@ internal fun Any?.createConstant(session: FirSession): FirExpression {
         null -> buildConstExpression(null, FirConstKind.Null, null)
 
         else -> buildErrorExpression {
-            diagnostic = FirSimpleDiagnostic("Unknown value in JavaLiteralAnnotationArgument: $this", DiagnosticKind.Java)
+            diagnostic = ConeSimpleDiagnostic("Unknown value in JavaLiteralAnnotationArgument: $this", DiagnosticKind.Java)
         }
     }
 }

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/deserialization/KotlinDeserializedJvmSymbolsProvider.kt

@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirSimpleFunctionImpl
 import org.jetbrains.kotlin.fir.deserialization.FirDeserializationContext
 import org.jetbrains.kotlin.fir.deserialization.deserializeClassToSymbol
 import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
-import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic
+import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.expressions.builder.*
 import org.jetbrains.kotlin.fir.java.JavaSymbolProvider
@@ -167,7 +167,7 @@ class KotlinDeserializedJvmSymbolsProvider(
             buildResolvedTypeRef {
                 type = it.constructType(emptyList(), isNullable = false)
             }
-        } ?: buildErrorTypeRef { diagnostic = FirSimpleDiagnostic("Symbol not found for $classId", DiagnosticKind.Java) }
+        } ?: buildErrorTypeRef { diagnostic = ConeSimpleDiagnostic("Symbol not found for $classId", DiagnosticKind.Java) }
 
     }
 
@@ -210,7 +210,7 @@ class KotlinDeserializedJvmSymbolsProvider(
                         }
                         else -> {
                             buildErrorNamedReference {
-                                diagnostic = FirSimpleDiagnostic(
+                                diagnostic = ConeSimpleDiagnostic(
                                     "Strange deserialized enum value: ${this@toEnumEntryReferenceExpression}.$name",
                                     DiagnosticKind.Java,
                                 )

compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/converter/DeclarationsConverter.kt

@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor
 import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyGetter
 import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertySetter
 import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
-import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic
+import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.expressions.builder.*
 import org.jetbrains.kotlin.fir.expressions.impl.FirSingleExpressionBlock
@@ -716,7 +716,7 @@ class DeclarationsConverter(
         val delegatedSelfTypeRef =
             if (classWrapper.isObjectLiteral()) buildErrorTypeRef {
                 source = secondaryConstructor.toFirSourceElement()
-                diagnostic = FirSimpleDiagnostic(
+                diagnostic = ConeSimpleDiagnostic(
                     "Constructor in object",
                     DiagnosticKind.ConstructorInObject
                 )
@@ -774,10 +774,10 @@ class DeclarationsConverter(
         val delegatedType =
             if (classWrapper.isObjectLiteral() || classWrapper.isInterface()) when {
                 isThis -> buildErrorTypeRef {
-                    diagnostic = FirSimpleDiagnostic("Constructor in object", DiagnosticKind.ConstructorInObject)
+                    diagnostic = ConeSimpleDiagnostic("Constructor in object", DiagnosticKind.ConstructorInObject)
                 }
                 else -> buildErrorTypeRef {
-                    diagnostic = FirSimpleDiagnostic("No super type", DiagnosticKind.Syntax)
+                    diagnostic = ConeSimpleDiagnostic("No super type", DiagnosticKind.Syntax)
                 }
             }
             else when {
@@ -945,7 +945,7 @@ class DeclarationsConverter(
         var isVar = false
         val entries = mutableListOf<FirVariable<*>>()
         var firExpression: FirExpression =
-            buildErrorExpression(null, FirSimpleDiagnostic("Destructuring declaration without initializer", DiagnosticKind.Syntax))
+            buildErrorExpression(null, ConeSimpleDiagnostic("Destructuring declaration without initializer", DiagnosticKind.Syntax))
         destructingDeclaration.forEachChildren {
             when (it.tokenType) {
                 VAR_KEYWORD -> isVar = true
@@ -1259,7 +1259,7 @@ class DeclarationsConverter(
     private fun convertExplicitDelegation(explicitDelegation: LighterASTNode): FirDelegatedTypeRef {
         lateinit var firTypeRef: FirTypeRef
         var firExpression: FirExpression? = buildErrorExpression(
-            explicitDelegation.toFirSourceElement(), FirSimpleDiagnostic("Should have delegate", DiagnosticKind.Syntax)
+            explicitDelegation.toFirSourceElement(), ConeSimpleDiagnostic("Should have delegate", DiagnosticKind.Syntax)
         )
         explicitDelegation.forEachChildren {
             when (it.tokenType) {
@@ -1355,10 +1355,10 @@ class DeclarationsConverter(
      */
     fun convertType(type: LighterASTNode): FirTypeRef {
         if (type.asText.isEmpty()) {
-            return buildErrorTypeRef { diagnostic = FirSimpleDiagnostic("Unwrapped type is null", DiagnosticKind.Syntax) }
+            return buildErrorTypeRef { diagnostic = ConeSimpleDiagnostic("Unwrapped type is null", DiagnosticKind.Syntax) }
         }
         var typeModifiers = TypeModifier() //TODO what with suspend?
-        var firType: FirTypeRef = buildErrorTypeRef { diagnostic = FirSimpleDiagnostic("Incomplete code", DiagnosticKind.Syntax) }
+        var firType: FirTypeRef = buildErrorTypeRef { diagnostic = ConeSimpleDiagnostic("Incomplete code", DiagnosticKind.Syntax) }
         var afterLPar = false
         type.forEachChildren {
             when (it.tokenType) {
@@ -1373,7 +1373,7 @@ class DeclarationsConverter(
                     isMarkedNullable = false
                 }
                 TokenType.ERROR_ELEMENT -> firType =
-                    buildErrorTypeRef { diagnostic = FirSimpleDiagnostic("Unwrapped type is null", DiagnosticKind.Syntax) }
+                    buildErrorTypeRef { diagnostic = ConeSimpleDiagnostic("Unwrapped type is null", DiagnosticKind.Syntax) }
             }
         }
 
@@ -1431,7 +1431,7 @@ class DeclarationsConverter(
         }
 
         if (identifier == null)
-            return buildErrorTypeRef { diagnostic = FirSimpleDiagnostic("Incomplete user type", DiagnosticKind.Syntax) }
+            return buildErrorTypeRef { diagnostic = ConeSimpleDiagnostic("Incomplete user type", DiagnosticKind.Syntax) }
 
         val qualifierPart = FirQualifierPartImpl(identifier.nameAsSafeName()).apply { typeArguments += firTypeArguments }
 

compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/converter/ExpressionsConverter.kt

@@ -19,8 +19,8 @@ import org.jetbrains.kotlin.fir.declarations.builder.buildProperty
 import org.jetbrains.kotlin.fir.declarations.builder.buildValueParameter
 import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl
 import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
-import org.jetbrains.kotlin.fir.diagnostics.FirDiagnosticWithParameters1
-import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic
+import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnosticWithParameters1
+import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.expressions.builder.*
 import org.jetbrains.kotlin.fir.expressions.impl.FirModifiableQualifiedAccess
@@ -55,7 +55,7 @@ class ExpressionsConverter(
 ) : BaseConverter(session, tree, context) {
 
     inline fun <reified R : FirElement> getAsFirExpression(expression: LighterASTNode?, errorReason: String = ""): R {
-        return expression?.let { convertExpression(it, errorReason) } as? R ?: (buildErrorExpression(null, FirSimpleDiagnostic(errorReason, DiagnosticKind.Syntax)) as R)
+        return expression?.let { convertExpression(it, errorReason) } as? R ?: (buildErrorExpression(null, ConeSimpleDiagnostic(errorReason, DiagnosticKind.Syntax)) as R)
     }
 
     /*****    EXPRESSIONS    *****/
@@ -103,7 +103,7 @@ class ExpressionsConverter(
 
                 OBJECT_LITERAL -> declarationsConverter.convertObjectLiteral(expression)
                 FUN -> declarationsConverter.convertFunctionDeclaration(expression)
-                else -> buildErrorExpression(null, FirSimpleDiagnostic(errorReason, DiagnosticKind.Syntax))
+                else -> buildErrorExpression(null, ConeSimpleDiagnostic(errorReason, DiagnosticKind.Syntax))
             }
         }
 
@@ -176,7 +176,7 @@ class ExpressionsConverter(
                     }
                 }.build()
             } else {
-                buildSingleExpressionBlock(buildErrorExpression(null, FirSimpleDiagnostic("Lambda has no body", DiagnosticKind.Syntax)))
+                buildSingleExpressionBlock(buildErrorExpression(null, ConeSimpleDiagnostic("Lambda has no body", DiagnosticKind.Syntax)))
             }
             context.firFunctionTargets.removeLast()
         }.also { 
@@ -192,7 +192,7 @@ class ExpressionsConverter(
         var isLeftArgument = true
         lateinit var operationTokenName: String
         var leftArgNode: LighterASTNode? = null
-        var rightArgAsFir: FirExpression = buildErrorExpression(null, FirSimpleDiagnostic("No right operand", DiagnosticKind.Syntax))
+        var rightArgAsFir: FirExpression = buildErrorExpression(null, ConeSimpleDiagnostic("No right operand", DiagnosticKind.Syntax))
         var rightArg: LighterASTNode? = null
         binaryExpression.forEachChildren {
             when (it.tokenType) {
@@ -265,7 +265,7 @@ class ExpressionsConverter(
         toFirOperation: String.() -> FirOperation
     ): FirTypeOperatorCall {
         lateinit var operationTokenName: String
-        var leftArgAsFir: FirExpression = buildErrorExpression(null, FirSimpleDiagnostic("No left operand", DiagnosticKind.Syntax))
+        var leftArgAsFir: FirExpression = buildErrorExpression(null, ConeSimpleDiagnostic("No left operand", DiagnosticKind.Syntax))
         lateinit var firType: FirTypeRef
         binaryExpression.forEachChildren {
             when (it.tokenType) {
@@ -303,7 +303,7 @@ class ExpressionsConverter(
             context.firLabels.removeLast()
             //println("Unused label: ${labeledExpression.getAsString()}")
         }
-        return firExpression ?: buildErrorExpression(null, FirSimpleDiagnostic("Empty label", DiagnosticKind.Syntax))
+        return firExpression ?: buildErrorExpression(null, ConeSimpleDiagnostic("Empty label", DiagnosticKind.Syntax))
     }
 
     /**
@@ -375,7 +375,7 @@ class ExpressionsConverter(
         return firExpression?.also {
             require(it is FirAnnotationContainer)
             (it.annotations as MutableList<FirAnnotationCall>) += firAnnotationList
-        } ?: buildErrorExpression(null, FirSimpleDiagnostic("Strange annotated expression: ${firExpression?.render()}", DiagnosticKind.Syntax))
+        } ?: buildErrorExpression(null, ConeSimpleDiagnostic("Strange annotated expression: ${firExpression?.render()}", DiagnosticKind.Syntax))
     }
 
     /**
@@ -383,7 +383,7 @@ class ExpressionsConverter(
      * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitClassLiteralExpression
      */
     private fun convertClassLiteralExpression(classLiteralExpression: LighterASTNode): FirExpression {
-        var firReceiverExpression: FirExpression = buildErrorExpression(null, FirSimpleDiagnostic("No receiver in class literal", DiagnosticKind.Syntax))
+        var firReceiverExpression: FirExpression = buildErrorExpression(null, ConeSimpleDiagnostic("No receiver in class literal", DiagnosticKind.Syntax))
         classLiteralExpression.forEachChildren {
             if (it.isExpression()) firReceiverExpression = getAsFirExpression(it, "No receiver in class literal")
         }
@@ -432,7 +432,7 @@ class ExpressionsConverter(
     private fun convertQualifiedExpression(dotQualifiedExpression: LighterASTNode): FirExpression {
         var isSelector = false
         var isSafe = false
-        var firSelector: FirExpression = buildErrorExpression(null, FirSimpleDiagnostic("Qualified expression without selector", DiagnosticKind.Syntax)) //after dot
+        var firSelector: FirExpression = buildErrorExpression(null, ConeSimpleDiagnostic("Qualified expression without selector", DiagnosticKind.Syntax)) //after dot
         var firReceiver: FirExpression? = null //before dot
         dotQualifiedExpression.forEachChildren {
             when (it.tokenType) {
@@ -504,11 +504,11 @@ class ExpressionsConverter(
                 buildErrorNamedReference {
                     val node = superNode!!
                     source = node.toFirSourceElement()
-                    diagnostic = FirDiagnosticWithParameters1("Super cannot be a callee", node.asText, DiagnosticKind.SuperNotAllowed)
+                    diagnostic = ConeSimpleDiagnosticWithParameters1("Super cannot be a callee", node.asText, DiagnosticKind.SuperNotAllowed)
                 } to null
             }
             else -> buildErrorNamedReference {
-                diagnostic = FirSimpleDiagnostic("Call has no callee", DiagnosticKind.Syntax)
+                diagnostic = ConeSimpleDiagnostic("Call has no callee", DiagnosticKind.Syntax)
             } to null
         }
 
@@ -541,7 +541,7 @@ class ExpressionsConverter(
     }
 
     private fun LighterASTNode?.convertShortOrLongStringTemplate(errorReason: String): FirExpression {
-        var firExpression: FirExpression = buildErrorExpression(null, FirSimpleDiagnostic(errorReason, DiagnosticKind.Syntax))
+        var firExpression: FirExpression = buildErrorExpression(null, ConeSimpleDiagnostic(errorReason, DiagnosticKind.Syntax))
         this?.forEachChildren(LONG_TEMPLATE_ENTRY_START, LONG_TEMPLATE_ENTRY_END) {
             firExpression = getAsFirExpression(it, errorReason)
         }
@@ -647,7 +647,7 @@ class ExpressionsConverter(
     }
 
     private fun convertWhenConditionExpression(whenCondition: LighterASTNode, subject: FirWhenSubject?): FirExpression {
-        var firExpression: FirExpression = buildErrorExpression(null, FirSimpleDiagnostic("No expression in condition with expression", DiagnosticKind.Syntax))
+        var firExpression: FirExpression = buildErrorExpression(null, ConeSimpleDiagnostic("No expression in condition with expression", DiagnosticKind.Syntax))
         whenCondition.forEachChildren {
             when (it.tokenType) {
                 else -> if (it.isExpression()) firExpression = getAsFirExpression(it, "No expression in condition with expression")
@@ -671,7 +671,7 @@ class ExpressionsConverter(
 
     private fun convertWhenConditionInRange(whenCondition: LighterASTNode, subject: FirWhenSubject?): FirExpression {
         var isNegate = false
-        var firExpression: FirExpression = buildErrorExpression(null, FirSimpleDiagnostic("No range in condition with range", DiagnosticKind.Syntax))
+        var firExpression: FirExpression = buildErrorExpression(null, ConeSimpleDiagnostic("No range in condition with range", DiagnosticKind.Syntax))
         whenCondition.forEachChildren {
             when {
                 it.tokenType == OPERATION_REFERENCE && it.asText == NOT_IN.value -> isNegate = true
@@ -686,7 +686,7 @@ class ExpressionsConverter(
         } else {
             return buildErrorExpression {
                 source = whenCondition.toFirSourceElement()
-                diagnostic = FirSimpleDiagnostic("No expression in condition with expression", DiagnosticKind.Syntax)
+                diagnostic = ConeSimpleDiagnostic("No expression in condition with expression", DiagnosticKind.Syntax)
             }
         }
 
@@ -716,7 +716,7 @@ class ExpressionsConverter(
         } else {
             return buildErrorExpression {
                 source = whenCondition.toFirSourceElement()
-                diagnostic = FirSimpleDiagnostic("No expression in condition with expression", DiagnosticKind.Syntax)
+                diagnostic = ConeSimpleDiagnostic("No expression in condition with expression", DiagnosticKind.Syntax)
             }
         }
 
@@ -733,7 +733,7 @@ class ExpressionsConverter(
      * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitArrayAccessExpression
      */
     private fun convertArrayAccessExpression(arrayAccess: LighterASTNode): FirFunctionCall {
-        var firExpression: FirExpression = buildErrorExpression(null, FirSimpleDiagnostic("No array expression", DiagnosticKind.Syntax))
+        var firExpression: FirExpression = buildErrorExpression(null, ConeSimpleDiagnostic("No array expression", DiagnosticKind.Syntax))
         val indices: MutableList<FirExpression> = mutableListOf()
         arrayAccess.forEachChildren {
             when (it.tokenType) {
@@ -801,7 +801,7 @@ class ExpressionsConverter(
      */
     private fun convertDoWhile(doWhileLoop: LighterASTNode): FirElement {
         var block: LighterASTNode? = null
-        var firCondition: FirExpression = buildErrorExpression(null, FirSimpleDiagnostic("No condition in do-while loop", DiagnosticKind.Syntax))
+        var firCondition: FirExpression = buildErrorExpression(null, ConeSimpleDiagnostic("No condition in do-while loop", DiagnosticKind.Syntax))
         doWhileLoop.forEachChildren {
             when (it.tokenType) {
                 BODY -> block = it
@@ -821,7 +821,7 @@ class ExpressionsConverter(
      */
     private fun convertWhile(whileLoop: LighterASTNode): FirElement {
         var block: LighterASTNode? = null
-        var firCondition: FirExpression = buildErrorExpression(null, FirSimpleDiagnostic("No condition in while loop", DiagnosticKind.Syntax))
+        var firCondition: FirExpression = buildErrorExpression(null, ConeSimpleDiagnostic("No condition in while loop", DiagnosticKind.Syntax))
         whileLoop.forEachChildren {
             when (it.tokenType) {
                 BODY -> block = it
@@ -841,7 +841,7 @@ class ExpressionsConverter(
      */
     private fun convertFor(forLoop: LighterASTNode): FirElement {
         var parameter: ValueParameter? = null
-        var rangeExpression: FirExpression = buildErrorExpression(null, FirSimpleDiagnostic("No range in for loop", DiagnosticKind.Syntax))
+        var rangeExpression: FirExpression = buildErrorExpression(null, ConeSimpleDiagnostic("No range in for loop", DiagnosticKind.Syntax))
         var blockNode: LighterASTNode? = null
         forLoop.forEachChildren {
             when (it.tokenType) {
@@ -989,7 +989,7 @@ class ExpressionsConverter(
      * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitIfExpression
      */
     private fun convertIfExpression(ifExpression: LighterASTNode): FirExpression {
-        var firCondition: FirExpression = buildErrorExpression(null, FirSimpleDiagnostic("If statement should have condition", DiagnosticKind.Syntax))
+        var firCondition: FirExpression = buildErrorExpression(null, ConeSimpleDiagnostic("If statement should have condition", DiagnosticKind.Syntax))
         var thenBlock: LighterASTNode? = null
         var elseBlock: LighterASTNode? = null
         ifExpression.forEachChildren {
@@ -1061,7 +1061,7 @@ class ExpressionsConverter(
      * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitThrowExpression
      */
     private fun convertThrow(throwExpression: LighterASTNode): FirExpression {
-        var firExpression: FirExpression = buildErrorExpression(null, FirSimpleDiagnostic("Nothing to throw", DiagnosticKind.Syntax))
+        var firExpression: FirExpression = buildErrorExpression(null, ConeSimpleDiagnostic("Nothing to throw", DiagnosticKind.Syntax))
         throwExpression.forEachChildren {
             if (it.isExpression()) firExpression = getAsFirExpression(it, "Nothing to throw")
         }
@@ -1128,7 +1128,7 @@ class ExpressionsConverter(
     private fun convertValueArgument(valueArgument: LighterASTNode): FirExpression {
         var identifier: String? = null
         var isSpread = false
-        var firExpression: FirExpression = buildErrorExpression(null, FirSimpleDiagnostic("Argument is absent", DiagnosticKind.Syntax))
+        var firExpression: FirExpression = buildErrorExpression(null, ConeSimpleDiagnostic("Argument is absent", DiagnosticKind.Syntax))
         valueArgument.forEachChildren {
             when (it.tokenType) {
                 VALUE_ARGUMENT_NAME -> identifier = it.asText

compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/fir/ValueParameter.kt

@@ -14,7 +14,7 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl
 import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyGetter
 import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertySetter
 import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
-import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic
+import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic
 import org.jetbrains.kotlin.fir.expressions.builder.buildQualifiedAccessExpression
 import org.jetbrains.kotlin.fir.lightTree.fir.modifier.Modifier
 import org.jetbrains.kotlin.fir.references.builder.buildPropertyFromParameterResolvedNamedReference
@@ -41,7 +41,7 @@ class ValueParameter(
             type = type.convertToArrayType()
         }
         if (type is FirImplicitTypeRef) {
-            type = buildErrorTypeRef { diagnostic = FirSimpleDiagnostic("Incomplete code", DiagnosticKind.Syntax) }
+            type = buildErrorTypeRef { diagnostic = ConeSimpleDiagnostic("Incomplete code", DiagnosticKind.Syntax) }
         }
 
         return buildProperty {

compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/fir/WhenEntry.kt

@@ -5,15 +5,12 @@
 
 package org.jetbrains.kotlin.fir.lightTree.fir
 
-import org.jetbrains.kotlin.fir.FirWhenSubject
 import org.jetbrains.kotlin.fir.builder.generateLazyLogicalOperation
 import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
-import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic
+import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic
 import org.jetbrains.kotlin.fir.expressions.FirBlock
 import org.jetbrains.kotlin.fir.expressions.FirExpression
-import org.jetbrains.kotlin.fir.expressions.FirOperatorCall
 import org.jetbrains.kotlin.fir.expressions.buildErrorExpression
-import org.jetbrains.kotlin.fir.expressions.builder.buildWhenSubjectExpression
 
 data class WhenEntry(
     val conditions: List<FirExpression>,
@@ -39,7 +36,7 @@ data class WhenEntry(
     fun toFirWhenConditionWithoutSubject(): FirExpression {
         return when (val condition = conditions.firstOrNull()) {
 //            is FirOperatorCall -> condition.arguments.first()
-            null -> buildErrorExpression(null, FirSimpleDiagnostic("No expression in condition with expression", DiagnosticKind.Syntax))
+            null -> buildErrorExpression(null, ConeSimpleDiagnostic("No expression in condition with expression", DiagnosticKind.Syntax))
             else -> condition
         }
     }

compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/BaseFirBuilder.kt

@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.builder.*
 import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl
 import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
-import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic
+import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.expressions.builder.*
 import org.jetbrains.kotlin.fir.expressions.impl.buildSingleExpressionBlock
@@ -108,7 +108,7 @@ abstract class BaseFirBuilder<T>(val baseSession: FirSession, val context: Conte
                     buildErrorFunction {
                         source = baseSource
                         session = this@BaseFirBuilder.baseSession
-                        diagnostic = FirSimpleDiagnostic(message, kind)
+                        diagnostic = ConeSimpleDiagnostic(message, kind)
                         symbol = FirErrorFunctionSymbol()
                     }
                 )
@@ -178,7 +178,7 @@ abstract class BaseFirBuilder<T>(val baseSession: FirSession, val context: Conte
                 bind(
                     buildErrorLoop(
                         expression.getSourceOrNull(),
-                        FirSimpleDiagnostic("Cannot bind unlabeled jump to a loop", DiagnosticKind.Syntax)
+                        ConeSimpleDiagnostic("Cannot bind unlabeled jump to a loop", DiagnosticKind.Syntax)
                     )
                 )
             }
@@ -192,7 +192,7 @@ abstract class BaseFirBuilder<T>(val baseSession: FirSession, val context: Conte
             target = FirLoopTarget(labelName).apply {
                 bind(
                     buildErrorLoop(
-                        expression.getSourceOrNull(), FirSimpleDiagnostic("Cannot bind label $labelName to a loop", DiagnosticKind.Syntax)
+                        expression.getSourceOrNull(), ConeSimpleDiagnostic("Cannot bind label $labelName to a loop", DiagnosticKind.Syntax)
                     )
                 )
             }
@@ -218,7 +218,7 @@ abstract class BaseFirBuilder<T>(val baseSession: FirSession, val context: Conte
                 val kind = when {
                     convertedText !is Long -> return buildErrorExpression {
                         source = expression.getSourceOrNull()
-                        diagnostic = FirSimpleDiagnostic(
+                        diagnostic = ConeSimpleDiagnostic(
                             "Incorrect constant expression: $text",
                             DiagnosticKind.IllegalConstExpression
                         )
@@ -243,7 +243,7 @@ abstract class BaseFirBuilder<T>(val baseSession: FirSession, val context: Conte
                     expression.getSourceOrNull(),
                     kind,
                     convertedText,
-                    FirSimpleDiagnostic("Incorrect integer literal: $text", DiagnosticKind.Syntax)
+                    ConeSimpleDiagnostic("Incorrect integer literal: $text", DiagnosticKind.Syntax)
                 )
             }
             FLOAT_CONSTANT ->
@@ -252,14 +252,14 @@ abstract class BaseFirBuilder<T>(val baseSession: FirSession, val context: Conte
                         expression.getSourceOrNull(),
                         FirConstKind.Float,
                         convertedText,
-                        FirSimpleDiagnostic("Incorrect float: $text", DiagnosticKind.Syntax)
+                        ConeSimpleDiagnostic("Incorrect float: $text", DiagnosticKind.Syntax)
                     )
                 } else {
                     buildConstOrErrorExpression(
                         expression.getSourceOrNull(),
                         FirConstKind.Double,
                         convertedText as Double,
-                        FirSimpleDiagnostic("Incorrect double: $text", DiagnosticKind.Syntax)
+                        ConeSimpleDiagnostic("Incorrect double: $text", DiagnosticKind.Syntax)
                     )
                 }
             CHARACTER_CONSTANT ->
@@ -267,7 +267,7 @@ abstract class BaseFirBuilder<T>(val baseSession: FirSession, val context: Conte
                     expression.getSourceOrNull(),
                     FirConstKind.Char,
                     text.parseCharacter(),
-                    FirSimpleDiagnostic("Incorrect character: $text", DiagnosticKind.Syntax)
+                    ConeSimpleDiagnostic("Incorrect character: $text", DiagnosticKind.Syntax)
                 )
             BOOLEAN_CONSTANT ->
                 buildConstExpression(
@@ -323,7 +323,7 @@ abstract class BaseFirBuilder<T>(val baseSession: FirSession, val context: Conte
                             hasExpressions = true
                             buildErrorExpression {
                                 source = entry.getSourceOrNull()
-                                diagnostic = FirSimpleDiagnostic("Incorrect template entry: ${entry.asText}", DiagnosticKind.Syntax)
+                                diagnostic = ConeSimpleDiagnostic("Incorrect template entry: ${entry.asText}", DiagnosticKind.Syntax)
                             }
                         }
                     }
@@ -370,7 +370,7 @@ abstract class BaseFirBuilder<T>(val baseSession: FirSession, val context: Conte
         if (argument == null) {
             return buildErrorExpression {
                 source = argument
-                diagnostic = FirSimpleDiagnostic("Inc/dec without operand", DiagnosticKind.Syntax)
+                diagnostic = ConeSimpleDiagnostic("Inc/dec without operand", DiagnosticKind.Syntax)
             }
         }
         return buildBlock {
@@ -451,7 +451,7 @@ abstract class BaseFirBuilder<T>(val baseSession: FirSession, val context: Conte
                     } else {
                         buildErrorNamedReference {
                             source = left.getSourceOrNull()
-                            diagnostic = FirSimpleDiagnostic("Unsupported qualified LValue: ${left.asText}", DiagnosticKind.Syntax)
+                            diagnostic = ConeSimpleDiagnostic("Unsupported qualified LValue: ${left.asText}", DiagnosticKind.Syntax)
                         }
                     }
                 }
@@ -462,7 +462,7 @@ abstract class BaseFirBuilder<T>(val baseSession: FirSession, val context: Conte
         }
         return buildErrorNamedReference {
             source = left.getSourceOrNull()
-            diagnostic = FirSimpleDiagnostic("Unsupported LValue: $tokenType", DiagnosticKind.Syntax)
+            diagnostic = ConeSimpleDiagnostic("Unsupported LValue: $tokenType", DiagnosticKind.Syntax)
         }
     }
 
@@ -497,7 +497,7 @@ abstract class BaseFirBuilder<T>(val baseSession: FirSession, val context: Conte
                 argumentList = buildBinaryArgumentList(
                     this@generateAssignment?.convert() ?: buildErrorExpression {
                         source = null
-                        diagnostic = FirSimpleDiagnostic("Unsupported left value of assignment: ${baseSource?.psi?.text}", DiagnosticKind.Syntax)
+                        diagnostic = ConeSimpleDiagnostic("Unsupported left value of assignment: ${baseSource?.psi?.text}", DiagnosticKind.Syntax)
                     },
                     value
                 )
@@ -543,7 +543,7 @@ abstract class BaseFirBuilder<T>(val baseSession: FirSession, val context: Conte
             argumentList = buildArgumentList {
                 arguments += rhs?.convert() ?: buildErrorExpression(
                     null,
-                    FirSimpleDiagnostic("No value for array set", DiagnosticKind.Syntax)
+                    ConeSimpleDiagnostic("No value for array set", DiagnosticKind.Syntax)
                 )
             }
         }
@@ -574,7 +574,7 @@ abstract class BaseFirBuilder<T>(val baseSession: FirSession, val context: Conte
                 "<array>",
                 baseCall.explicitReceiver ?: buildErrorExpression {
                     source = baseSource
-                    diagnostic = FirSimpleDiagnostic("No receiver for array access", DiagnosticKind.Syntax)
+                    diagnostic = ConeSimpleDiagnostic("No receiver for array access", DiagnosticKind.Syntax)
                 }
             )
             statements += arrayVariable
@@ -613,7 +613,7 @@ abstract class BaseFirBuilder<T>(val baseSession: FirSession, val context: Conte
                         argumentList = buildArgumentList {
                             arguments += rhs?.convert() ?: buildErrorExpression(
                                 null,
-                                FirSimpleDiagnostic(
+                                ConeSimpleDiagnostic(
                                     "No value for array set",
                                     DiagnosticKind.Syntax
                                 )

compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/ConversionUtils.kt

@@ -18,7 +18,7 @@ import org.jetbrains.kotlin.fir.declarations.builder.buildValueParameter
 import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl
 import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor
 import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
-import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic
+import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.expressions.builder.*
 import org.jetbrains.kotlin.fir.expressions.impl.FirSingleExpressionBlock
@@ -228,7 +228,7 @@ internal fun KtWhenCondition.toFirWhenCondition(
             }
         }
         else -> {
-            buildErrorExpression(baseSource, FirSimpleDiagnostic("Unsupported when condition: ${this.javaClass}", DiagnosticKind.Syntax))
+            buildErrorExpression(baseSource, ConeSimpleDiagnostic("Unsupported when condition: ${this.javaClass}", DiagnosticKind.Syntax))
         }
     }
 }

compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt

@@ -19,8 +19,8 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor
 import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyGetter
 import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertySetter
 import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
-import org.jetbrains.kotlin.fir.diagnostics.FirDiagnosticWithParameters1
-import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic
+import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnosticWithParameters1
+import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.expressions.builder.*
 import org.jetbrains.kotlin.fir.expressions.impl.FirModifiableQualifiedAccess
@@ -126,7 +126,7 @@ class RawFirBuilder(
         private fun KtTypeReference?.toFirOrErrorType(): FirTypeRef =
             convertSafe() ?: buildErrorTypeRef {
                 source = this@toFirOrErrorType?.toFirSourceElement()
-                diagnostic = FirSimpleDiagnostic(
+                diagnostic = ConeSimpleDiagnostic(
                     if (this@toFirOrErrorType == null) "Incomplete code" else "Conversion failed", DiagnosticKind.Syntax
                 )
             }
@@ -136,18 +136,18 @@ class RawFirBuilder(
             if (stubMode) buildExpressionStub()
             else with(this()) {
                 convertSafe() ?: buildErrorExpression(
-                    this?.toFirSourceElement(), FirSimpleDiagnostic(errorReason, DiagnosticKind.Syntax),
+                    this?.toFirSourceElement(), ConeSimpleDiagnostic(errorReason, DiagnosticKind.Syntax),
                 )
             }
 
         private fun KtExpression?.toFirExpression(errorReason: String): FirExpression =
             if (stubMode) buildExpressionStub()
             else convertSafe() ?: buildErrorExpression(
-                this?.toFirSourceElement(), FirSimpleDiagnostic(errorReason, DiagnosticKind.Syntax),
+                this?.toFirSourceElement(), ConeSimpleDiagnostic(errorReason, DiagnosticKind.Syntax),
             )
 
         private fun KtExpression.toFirStatement(errorReason: String): FirStatement =
-            convertSafe() ?: buildErrorExpression(this.toFirSourceElement(), FirSimpleDiagnostic(errorReason, DiagnosticKind.Syntax))
+            convertSafe() ?: buildErrorExpression(this.toFirSourceElement(), ConeSimpleDiagnostic(errorReason, DiagnosticKind.Syntax))
 
         private fun KtExpression.toFirStatement(): FirStatement =
             convert()
@@ -161,7 +161,7 @@ class RawFirBuilder(
                         delegatedSuperType,
                         delegatedSelfType ?: buildErrorTypeRef {
                             source = this@toFirDeclaration.toFirSourceElement()
-                            diagnostic = FirSimpleDiagnostic("Constructor in object", DiagnosticKind.ConstructorInObject)
+                            diagnostic = ConeSimpleDiagnostic("Constructor in object", DiagnosticKind.ConstructorInObject)
                         },
                         owner,
                         hasPrimaryConstructor,
@@ -209,7 +209,7 @@ class RawFirBuilder(
             if (this == null) {
                 return buildErrorExpression(
                     (this as? KtElement)?.toFirSourceElement(),
-                    FirSimpleDiagnostic("No argument given", DiagnosticKind.Syntax),
+                    ConeSimpleDiagnostic("No argument given", DiagnosticKind.Syntax),
                 )
             }
             val name = this.getArgumentName()?.asName
@@ -846,7 +846,7 @@ class RawFirBuilder(
                 }
                 val ktBody = literal.bodyExpression
                 body = if (ktBody == null) {
-                    val errorExpression = buildErrorExpression(source, FirSimpleDiagnostic("Lambda has no body", DiagnosticKind.Syntax))
+                    val errorExpression = buildErrorExpression(source, ConeSimpleDiagnostic("Lambda has no body", DiagnosticKind.Syntax))
                     FirSingleExpressionBlock(errorExpression.toReturn())
                 } else {
                     configureBlockWithoutBuilding(ktBody).apply {
@@ -909,7 +909,7 @@ class RawFirBuilder(
                 isThis -> delegatedSelfTypeRef
                 else -> delegatedSuperTypeRef ?: buildErrorTypeRef {
                     this.source = source
-                    diagnostic = FirSimpleDiagnostic("No super type", DiagnosticKind.Syntax)
+                    diagnostic = ConeSimpleDiagnostic("No super type", DiagnosticKind.Syntax)
                 }
             }
             return buildDelegatedConstructorCall {
@@ -1034,7 +1034,7 @@ class RawFirBuilder(
                     } else {
                         FirErrorTypeRefBuilder().apply {
                             this.source = source
-                            diagnostic = FirSimpleDiagnostic("Incomplete user type", DiagnosticKind.Syntax)
+                            diagnostic = ConeSimpleDiagnostic("Incomplete user type", DiagnosticKind.Syntax)
                         }
                     }
                 }
@@ -1055,7 +1055,7 @@ class RawFirBuilder(
                 }
                 null -> FirErrorTypeRefBuilder().apply {
                     this.source = source
-                    diagnostic = FirSimpleDiagnostic("Unwrapped type is null", DiagnosticKind.Syntax)
+                    diagnostic = ConeSimpleDiagnostic("Unwrapped type is null", DiagnosticKind.Syntax)
                 }
                 else -> throw AssertionError("Unexpected type element: ${unwrappedElement.text}")
             }
@@ -1487,13 +1487,13 @@ class RawFirBuilder(
                 is KtParenthesizedExpression -> splitToCalleeAndReceiver(calleeExpression.expression, defaultSource)
 
                 null -> {
-                    buildErrorNamedReference { diagnostic = FirSimpleDiagnostic("Call has no callee", DiagnosticKind.Syntax) } to null
+                    buildErrorNamedReference { diagnostic = ConeSimpleDiagnostic("Call has no callee", DiagnosticKind.Syntax) } to null
                 }
 
                 is KtSuperExpression -> {
                     buildErrorNamedReference {
                         source = calleeExpression.toFirSourceElement()
-                        diagnostic = FirDiagnosticWithParameters1("Super cannot be a callee", calleeExpression.text, DiagnosticKind.SuperNotAllowed)
+                        diagnostic = ConeSimpleDiagnosticWithParameters1("Super cannot be a callee", calleeExpression.text, DiagnosticKind.SuperNotAllowed)
                     } to null
                 }
 
@@ -1566,7 +1566,7 @@ class RawFirBuilder(
         override fun visitQualifiedExpression(expression: KtQualifiedExpression, data: Unit): FirElement {
             val selector = expression.selectorExpression
                 ?: return buildErrorExpression(
-                    expression.toFirSourceElement(), FirSimpleDiagnostic("Qualified expression without selector", DiagnosticKind.Syntax),
+                    expression.toFirSourceElement(), ConeSimpleDiagnostic("Qualified expression without selector", DiagnosticKind.Syntax),
                 )
             val firSelector = selector.toFirExpression("Incorrect selector expression")
             if (firSelector is FirModifiableQualifiedAccess) {
@@ -1601,7 +1601,7 @@ class RawFirBuilder(
 
         override fun visitParenthesizedExpression(expression: KtParenthesizedExpression, data: Unit): FirElement {
             return expression.expression?.accept(this, data)
-                ?: buildErrorExpression(expression.toFirSourceElement(), FirSimpleDiagnostic("Empty parentheses", DiagnosticKind.Syntax))
+                ?: buildErrorExpression(expression.toFirSourceElement(), ConeSimpleDiagnostic("Empty parentheses", DiagnosticKind.Syntax))
         }
 
         override fun visitLabeledExpression(expression: KtLabeledExpression, data: Unit): FirElement {
@@ -1615,7 +1615,7 @@ class RawFirBuilder(
                 }
             }
             val result = expression.baseExpression?.accept(this, data)
-                ?: buildErrorExpression(sourceElement, FirSimpleDiagnostic("Empty label", DiagnosticKind.Syntax))
+                ?: buildErrorExpression(sourceElement, ConeSimpleDiagnostic("Empty label", DiagnosticKind.Syntax))
             if (size != context.firLabels.size) {
                 context.firLabels.removeLast()
                 println("Unused label: ${expression.text}")
@@ -1633,7 +1633,7 @@ class RawFirBuilder(
             val result = rawResult as? FirAnnotationContainer
                 ?: return buildErrorExpression(
                     expression.toFirSourceElement(),
-                    FirSimpleDiagnostic("Strange annotated expression: ${rawResult?.render()}", DiagnosticKind.Syntax),
+                    ConeSimpleDiagnostic("Strange annotated expression: ${rawResult?.render()}", DiagnosticKind.Syntax),
                 )
             expression.extractAnnotationsTo(result.annotations as MutableList<FirAnnotationCall>)
             return result

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt

@@ -20,9 +20,9 @@ import org.jetbrains.kotlin.fir.references.builder.buildResolvedNamedReference
 import org.jetbrains.kotlin.fir.references.impl.FirSimpleNamedReference
 import org.jetbrains.kotlin.fir.resolve.*
 import org.jetbrains.kotlin.fir.resolve.calls.*
-import org.jetbrains.kotlin.fir.resolve.diagnostics.FirAmbiguityError
-import org.jetbrains.kotlin.fir.resolve.diagnostics.FirInapplicableCandidateError
-import org.jetbrains.kotlin.fir.resolve.diagnostics.FirUnresolvedNameError
+import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeAmbiguityError
+import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeInapplicableCandidateError
+import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeUnresolvedNameError
 import org.jetbrains.kotlin.fir.resolve.inference.ResolvedCallableReferenceAtom
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
 import org.jetbrains.kotlin.fir.resolve.transformers.StoreNameReference
@@ -392,15 +392,15 @@ class FirCallResolver(
         return when {
             candidates.isEmpty() -> buildErrorNamedReference {
                 this.source = source
-                diagnostic = FirUnresolvedNameError(name)
+                diagnostic = ConeUnresolvedNameError(name)
             }
             applicability < CandidateApplicability.SYNTHETIC_RESOLVED -> {
                 buildErrorNamedReference {
                     this.source = source
-                    diagnostic = FirInapplicableCandidateError(
+                    diagnostic = ConeInapplicableCandidateError(
                         applicability,
                         candidates.map {
-                            FirInapplicableCandidateError.CandidateInfo(
+                            ConeInapplicableCandidateError.CandidateInfo(
                                 it.symbol,
                                 if (it.systemInitialized) it.system.diagnostics else emptyList(),
                             )
@@ -432,7 +432,7 @@ class FirCallResolver(
             }
             else -> buildErrorNamedReference {
                 this.source = source
-                diagnostic = FirAmbiguityError(name, candidates.map { it.symbol })
+                diagnostic = ConeAmbiguityError(name, candidates.map { it.symbol })
             }
         }
     }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/AbstractAnnotationDeserializer.kt

@@ -11,13 +11,13 @@ import org.jetbrains.kotlin.fir.declarations.FirConstructor
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.declarations.collectEnumEntries
 import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
-import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic
+import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.expressions.builder.*
 import org.jetbrains.kotlin.fir.references.builder.buildErrorNamedReference
 import org.jetbrains.kotlin.fir.references.builder.buildResolvedNamedReference
 import org.jetbrains.kotlin.fir.resolve.constructType
-import org.jetbrains.kotlin.fir.resolve.diagnostics.FirUnresolvedSymbolError
+import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeUnresolvedSymbolError
 import org.jetbrains.kotlin.fir.resolve.toSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
@@ -100,7 +100,7 @@ abstract class AbstractAnnotationDeserializer(
                 buildResolvedTypeRef {
                     type = it.constructType(emptyList(), isNullable = false)
                 }
-            } ?: buildErrorTypeRef { diagnostic =FirUnresolvedSymbolError(classId) }
+            } ?: buildErrorTypeRef { diagnostic = ConeUnresolvedSymbolError(classId) }
             argumentList = buildArgumentList {
                 this.arguments += arguments
             }
@@ -151,7 +151,7 @@ abstract class AbstractAnnotationDeserializer(
                         resolvedSymbol = it.symbol
                     }
                 } ?: buildErrorNamedReference {
-                    diagnostic = FirSimpleDiagnostic("Strange deserialized enum value: $classId.$entryName", DiagnosticKind.DeserializationError)
+                    diagnostic = ConeSimpleDiagnostic("Strange deserialized enum value: $classId.$entryName", DiagnosticKind.DeserializationError)
                 }
             }
 //            ARRAY -> {

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt

@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.builtins.functions.FunctionClassDescriptor
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.diagnostics.FirStubDiagnostic
+import org.jetbrains.kotlin.fir.diagnostics.ConeStubDiagnostic
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccess
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression
 import org.jetbrains.kotlin.fir.expressions.FirResolvable
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.fir.references.FirSuperReference
 import org.jetbrains.kotlin.fir.references.FirThisReference
 import org.jetbrains.kotlin.fir.resolve.calls.FirNamedReferenceWithCandidate
 import org.jetbrains.kotlin.fir.resolve.calls.isSuperReferenceExpression
-import org.jetbrains.kotlin.fir.resolve.diagnostics.FirUnresolvedNameError
+import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeUnresolvedNameError
 import org.jetbrains.kotlin.fir.resolve.substitution.AbstractConeSubstitutor
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.resultType
 import org.jetbrains.kotlin.fir.scopes.impl.FirDeclaredMemberScopeProvider
@@ -308,7 +308,7 @@ fun <T : FirResolvable> BodyResolveComponents.typeFromCallee(access: T): FirReso
         is FirErrorNamedReference ->
             buildErrorTypeRef {
                 source = access.source
-                diagnostic = FirStubDiagnostic(newCallee.diagnostic)
+                diagnostic = ConeStubDiagnostic(newCallee.diagnostic)
             }
         is FirNamedReferenceWithCandidate -> {
             typeFromSymbol(newCallee.candidateSymbol, makeNullable)
@@ -327,7 +327,7 @@ fun <T : FirResolvable> BodyResolveComponents.typeFromCallee(access: T): FirReso
         is FirSuperReference -> {
             newCallee.superTypeRef as? FirResolvedTypeRef ?: buildErrorTypeRef {
                 source = newCallee.source
-                diagnostic = FirUnresolvedNameError(Name.identifier("super"))
+                diagnostic = ConeUnresolvedNameError(Name.identifier("super"))
             }
         }
         else -> error("Failed to extract type from: $newCallee")

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/diagnostics/FirDiagnostics.kt

@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.fir.resolve.diagnostics
 
-import org.jetbrains.kotlin.fir.diagnostics.FirDiagnostic
+import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
 import org.jetbrains.kotlin.fir.resolve.calls.CandidateApplicability
 import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
@@ -15,40 +15,40 @@ import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.calls.model.KotlinCallDiagnostic
 
-class FirUnresolvedReferenceError(val name: Name? = null) : FirDiagnostic() {
+class ConeUnresolvedReferenceError(val name: Name? = null) : ConeDiagnostic() {
     override val reason: String get() = "Unresolved reference" + if (name != null) ": ${name.asString()}" else ""
 }
 
-class FirUnresolvedSymbolError(val classId: ClassId) : FirDiagnostic() {
+class ConeUnresolvedSymbolError(val classId: ClassId) : ConeDiagnostic() {
     override val reason: String get() = "Symbol not found for $classId"
 }
 
-class FirUnresolvedNameError(val name: Name) : FirDiagnostic() {
+class ConeUnresolvedNameError(val name: Name) : ConeDiagnostic() {
     override val reason: String get() = "Unresolved name: $name"
 }
 
-class FirInapplicableCandidateError(
+class ConeInapplicableCandidateError(
     val applicability: CandidateApplicability,
     val candidates: Collection<CandidateInfo>
-) : FirDiagnostic() {
+) : ConeDiagnostic() {
     data class CandidateInfo(val symbol: AbstractFirBasedSymbol<*>, val diagnostics: List<KotlinCallDiagnostic>)
 
     override val reason: String get() = "Inapplicable($applicability): ${candidates.map { describeSymbol(it.symbol) }}"
 }
 
-class FirAmbiguityError(val name: Name, val candidates: Collection<AbstractFirBasedSymbol<*>>) : FirDiagnostic() {
+class ConeAmbiguityError(val name: Name, val candidates: Collection<AbstractFirBasedSymbol<*>>) : ConeDiagnostic() {
     override val reason: String get() = "Ambiguity: $name, ${candidates.map { describeSymbol(it) }}"
 }
 
-class FirOperatorAmbiguityError(val candidates: Collection<AbstractFirBasedSymbol<*>>) : FirDiagnostic() {
+class ConeOperatorAmbiguityError(val candidates: Collection<AbstractFirBasedSymbol<*>>) : ConeDiagnostic() {
     override val reason: String get() = "Operator overload ambiguity. Compatible candidates: ${candidates.map { describeSymbol(it) }}"
 }
 
-class FirVariableExpectedError : FirDiagnostic() {
+class ConeVariableExpectedError : ConeDiagnostic() {
     override val reason: String get() = "Variable expected"
 }
 
-class FirTypeMismatchError(val expectedType: ConeKotlinType, val actualType: ConeKotlinType) : FirDiagnostic() {
+class ConeTypeMismatchError(val expectedType: ConeKotlinType, val actualType: ConeKotlinType) : ConeDiagnostic() {
     override val reason: String
         get() = "Type mismatch. Expected: $expectedType, Actual: $actualType"
 }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/PostponedArgumentsAnalyzer.kt

@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.FirStatement
 import org.jetbrains.kotlin.fir.references.builder.buildErrorNamedReference
 import org.jetbrains.kotlin.fir.resolve.calls.*
-import org.jetbrains.kotlin.fir.resolve.diagnostics.FirUnresolvedReferenceError
+import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeUnresolvedReferenceError
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
 import org.jetbrains.kotlin.fir.resolve.transformers.StoreNameReference
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
@@ -81,7 +81,7 @@ class PostponedArgumentsAnalyzer(
             candidate == null || applicability < CandidateApplicability.SYNTHETIC_RESOLVED ->
                 buildErrorNamedReference {
                     source = callableReferenceAccess.source
-                    diagnostic = FirUnresolvedReferenceError(callableReferenceAccess.calleeReference.name)
+                    diagnostic = ConeUnresolvedReferenceError(callableReferenceAccess.calleeReference.name)
                 }
             else -> FirNamedReferenceWithCandidate(callableReferenceAccess.source, callableReferenceAccess.calleeReference.name, candidate)
         }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt

@@ -7,9 +7,8 @@ package org.jetbrains.kotlin.fir.resolve.transformers
 
 import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic
+import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic
 import org.jetbrains.kotlin.fir.expressions.*
-import org.jetbrains.kotlin.fir.expressions.builder.buildArgumentList
 import org.jetbrains.kotlin.fir.expressions.builder.buildVarargArgumentsExpression
 import org.jetbrains.kotlin.fir.references.builder.buildResolvedCallableReference
 import org.jetbrains.kotlin.fir.references.builder.buildResolvedNamedReference
@@ -62,7 +61,7 @@ class FirCallCompletionResultsWriterTransformer(
             typeCalculator.tryCalculateReturnType(it)
         } ?: buildErrorTypeRef {
             source = calleeReference.source
-            diagnostic = FirSimpleDiagnostic("Callee reference to candidate without return type: ${candidateFir.render()}")
+            diagnostic = ConeSimpleDiagnostic("Callee reference to candidate without return type: ${candidateFir.render()}")
         }
 
         qualifiedAccessExpression.replaceTypeRefWithSubstituted(calleeReference, typeRef).replaceTypeArguments(typeArguments)

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypesResolution.kt

@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.fir.resolve.transformers
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic
+import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic
 import org.jetbrains.kotlin.fir.expressions.FirStatement
 import org.jetbrains.kotlin.fir.resolve.*
 import org.jetbrains.kotlin.fir.scopes.FirIterableScope
@@ -266,7 +266,7 @@ private class FirSupertypeResolverVisitor(
 
 private fun createErrorTypeRef(fir: FirElement, message: String) = buildErrorTypeRef {
     source = fir.source
-    diagnostic = FirSimpleDiagnostic(message)
+    diagnostic = ConeSimpleDiagnostic(message)
 }
 
 private class SupertypeComputationSession {

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSyntheticCallGenerator.kt

@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.fir.references.builder.buildErrorNamedReference
 import org.jetbrains.kotlin.fir.references.impl.FirStubReference
 import org.jetbrains.kotlin.fir.resolve.BodyResolveComponents
 import org.jetbrains.kotlin.fir.resolve.calls.*
-import org.jetbrains.kotlin.fir.resolve.diagnostics.FirUnresolvedNameError
+import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeUnresolvedNameError
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirAbstractBodyResolveTransformer
 import org.jetbrains.kotlin.fir.symbols.CallableId
 import org.jetbrains.kotlin.fir.symbols.SyntheticCallableId
@@ -114,7 +114,7 @@ class FirSyntheticCallGenerator(
                 StoreCalleeReference,
                 buildErrorNamedReference {
                     source = callableReferenceAccess.source
-                    diagnostic = FirUnresolvedNameError(callableReferenceAccess.calleeReference.name)
+                    diagnostic = ConeUnresolvedNameError(callableReferenceAccess.calleeReference.name)
                 }
             )
         val fakeCallElement = buildFunctionCall {

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/ReturnTypeCalculator.kt

@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.fir.resolve.transformers
 
 import org.jetbrains.kotlin.fir.declarations.FirTypedDeclaration
 import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
-import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic
+import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic
 import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
 import org.jetbrains.kotlin.fir.types.builder.buildErrorTypeRef
@@ -23,7 +23,7 @@ class ReturnTypeCalculatorForFullBodyResolve : ReturnTypeCalculator {
         if (returnTypeRef is FirResolvedTypeRef) return returnTypeRef
 
         return buildErrorTypeRef {
-            diagnostic = FirSimpleDiagnostic(
+            diagnostic = ConeSimpleDiagnostic(
                 "Cannot calculate return type during full-body resolution (local class/object?): ${declaration.render()}",
                 DiagnosticKind.InferenceError
             )

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirControlFlowStatementsResolveTransformer.kt

@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.fir.resolve.transformers.body.resolve
 
 import org.jetbrains.kotlin.fir.FirTargetElement
 import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
-import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic
+import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.expressions.impl.FirElseIfTrueCondition
 import org.jetbrains.kotlin.fir.expressions.impl.FirEmptyExpressionBlock
@@ -17,7 +17,6 @@ import org.jetbrains.kotlin.fir.resolve.transformers.FirSyntheticCallGenerator
 import org.jetbrains.kotlin.fir.resolve.transformers.FirWhenExhaustivenessTransformer
 import org.jetbrains.kotlin.fir.resolvedTypeFromPrototype
 import org.jetbrains.kotlin.fir.scopes.impl.FirLocalScope
-import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef
 import org.jetbrains.kotlin.fir.types.builder.buildErrorTypeRef
 import org.jetbrains.kotlin.fir.types.coneTypeSafe
@@ -77,7 +76,7 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran
                         whenExpression = whenExpression.transformSingle(whenExhaustivenessTransformer, null)
                         dataFlowAnalyzer.exitWhenExpression(whenExpression, callCompleted = true)
                         whenExpression.resultType = buildErrorTypeRef {
-                            diagnostic = FirSimpleDiagnostic("Can't resolve when expression", DiagnosticKind.InferenceError)
+                            diagnostic = ConeSimpleDiagnostic("Can't resolve when expression", DiagnosticKind.InferenceError)
                         }
                         return@with whenExpression.compose()
                     }
@@ -150,7 +149,7 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran
             completionResult.result
         } ?: run {
             tryExpression.resultType = buildErrorTypeRef {
-                diagnostic = FirSimpleDiagnostic("Can't resolve try expression", DiagnosticKind.InferenceError)
+                diagnostic = ConeSimpleDiagnostic("Can't resolve try expression", DiagnosticKind.InferenceError)
             }
             callCompleted = true
             tryExpression

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt

@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.fir.declarations.builder.buildValueParameter
 import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor
 import org.jetbrains.kotlin.fir.declarations.synthetic.FirSyntheticProperty
 import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
-import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic
+import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.expressions.builder.buildReturnExpression
 import org.jetbrains.kotlin.fir.expressions.builder.buildUnitExpression
@@ -428,7 +428,7 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer)
             } else {
                 result.transformReturnTypeRef(
                     transformer,
-                    withExpectedType(buildErrorTypeRef { diagnostic = FirSimpleDiagnostic("empty body", DiagnosticKind.Other) })
+                    withExpectedType(buildErrorTypeRef { diagnostic = ConeSimpleDiagnostic("empty body", DiagnosticKind.Other) })
                 )
             }
         }
@@ -646,7 +646,7 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer)
                 initializer != null -> {
                     val expectedType = when (val resultType = initializer.resultType) {
                         is FirImplicitTypeRef -> buildErrorTypeRef {
-                            diagnostic = FirSimpleDiagnostic("No result type for initializer", DiagnosticKind.InferenceError)
+                            diagnostic = ConeSimpleDiagnostic("No result type for initializer", DiagnosticKind.InferenceError)
                         }
                         else -> resultType
                     }
@@ -658,7 +658,7 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer)
                 variable.getter != null && variable.getter !is FirDefaultPropertyAccessor -> {
                     val expectedType = when (val resultType = variable.getter?.returnTypeRef) {
                         is FirImplicitTypeRef -> buildErrorTypeRef {
-                            diagnostic = FirSimpleDiagnostic("No result type for getter", DiagnosticKind.InferenceError)
+                            diagnostic = ConeSimpleDiagnostic("No result type for getter", DiagnosticKind.InferenceError)
                         }
                         else -> resultType
                     }
@@ -672,7 +672,7 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer)
                         transformer,
                         withExpectedType(
                             buildErrorTypeRef {
-                                diagnostic = FirSimpleDiagnostic(
+                                diagnostic = ConeSimpleDiagnostic(
                                     "Cannot infer variable type without initializer / getter / delegate",
                                     DiagnosticKind.InferenceError,
                                 )

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt

@@ -9,7 +9,7 @@ import com.intellij.openapi.progress.ProcessCanceledException
 import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.declarations.FirTypeParametersOwner
 import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
-import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic
+import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.expressions.builder.buildErrorExpression
 import org.jetbrains.kotlin.fir.expressions.builder.buildFunctionCall
@@ -28,7 +28,6 @@ import org.jetbrains.kotlin.fir.resolve.transformers.InvocationKindTransformer
 import org.jetbrains.kotlin.fir.resolve.transformers.StoreReceiver
 import org.jetbrains.kotlin.fir.scopes.impl.withReplacedConeType
 import org.jetbrains.kotlin.fir.symbols.StandardClassIds
-import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLookupTagWithFixedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
 import org.jetbrains.kotlin.fir.symbols.invoke
@@ -52,7 +51,7 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
             val type = buildErrorTypeRef {
                 source = expression.source
                 diagnostic =
-                    FirSimpleDiagnostic("Type calculating for ${expression::class} is not supported", DiagnosticKind.InferenceError)
+                    ConeSimpleDiagnostic("Type calculating for ${expression::class} is not supported", DiagnosticKind.InferenceError)
             }
             expression.resultType = type
         }
@@ -94,7 +93,7 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
                             superTypeRefs?.isNotEmpty() != true -> {
                                 buildErrorTypeRef {
                                     source = qualifiedAccessExpression.source
-                                    diagnostic = FirSimpleDiagnostic("No super type", DiagnosticKind.NoSupertype)
+                                    diagnostic = ConeSimpleDiagnostic("No super type", DiagnosticKind.NoSupertype)
                                 }
                             }
                             superTypeRefs.size == 1 -> {
@@ -210,7 +209,7 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
             block.resultType.resolvedTypeFromPrototype(session.builtinTypes.unitType.type)
         } else {
             (resultExpression.resultType as? FirResolvedTypeRef) ?: buildErrorTypeRef {
-                diagnostic = FirSimpleDiagnostic("No type for block", DiagnosticKind.InferenceError)
+                diagnostic = ConeSimpleDiagnostic("No type for block", DiagnosticKind.InferenceError)
             }
         }
         dataFlowAnalyzer.exitBlock(block)
@@ -290,14 +289,14 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
                             else
                                 buildErrorNamedReference {
                                     source = operatorCall.argument.source
-                                    diagnostic = FirVariableExpectedError()
+                                    diagnostic = ConeVariableExpectedError()
                                 }
                         }
                     assignment.transform(transformer, ResolutionMode.ContextIndependent)
                 }
                 else -> buildErrorExpression {
                     source = operatorCall.source
-                    diagnostic = FirOperatorAmbiguityError(listOf(operatorCallReference.resolvedSymbol, assignCallReference.resolvedSymbol))
+                    diagnostic = ConeOperatorAmbiguityError(listOf(operatorCallReference.resolvedSymbol, assignCallReference.resolvedSymbol))
                 }.compose()
             }
         }
@@ -383,7 +382,7 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
         } ?: run {
             checkNotNullCall.resultType =
                 buildErrorTypeRef {
-                    diagnostic = FirSimpleDiagnostic("Can't resolve !! operator call", DiagnosticKind.InferenceError)
+                    diagnostic = ConeSimpleDiagnostic("Can't resolve !! operator call", DiagnosticKind.InferenceError)
                 }
             callCompleted = true
             checkNotNullCall
@@ -532,7 +531,7 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
                         dataFlowAnalyzer.exitConstExpresion(constExpression as FirConstExpression<*>)
                         constExpression.resultType = buildErrorTypeRef {
                             source = constExpression.source
-                            diagnostic = FirTypeMismatchError(expectedType, integerLiteralType.getApproximatedType())
+                            diagnostic = ConeTypeMismatchError(expectedType, integerLiteralType.getApproximatedType())
                         }
                         return constExpression.compose()
                     }
@@ -671,7 +670,7 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
                         buildErrorNamedReference {
                             // TODO: add better diagnostic
                             source = augmentedArraySetCall.source
-                            diagnostic = FirAmbiguityError(operatorName, emptyList())
+                            diagnostic = ConeAmbiguityError(operatorName, emptyList())
                         }
                     )
                 }
@@ -683,7 +682,7 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) :
                     it.replaceCalleeReference(
                         buildErrorNamedReference {
                             source = augmentedArraySetCall.source
-                            diagnostic = FirUnresolvedNameError(operatorName)
+                            diagnostic = ConeUnresolvedNameError(operatorName)
                         }
                     )
                 }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirImplicitBodyResolve.kt

@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.synthetic.FirSyntheticProperty
 import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
-import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic
+import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic
 import org.jetbrains.kotlin.fir.expressions.FirStatement
 import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.resolve.ResolutionMode
@@ -155,7 +155,7 @@ private class ReturnTypeCalculatorWithJump(
             declaration.transformReturnTypeRef(
                 TransformImplicitType,
                 buildErrorTypeRef {
-                    diagnostic = FirSimpleDiagnostic("Unsupported: implicit VP type")
+                    diagnostic = ConeSimpleDiagnostic("Unsupported: implicit VP type")
                 }
             )
         }
@@ -168,7 +168,7 @@ private class ReturnTypeCalculatorWithJump(
         return when (val status = implicitBodyResolveComputationSession.getStatus(declaration.symbol)) {
             is ImplicitBodyResolveComputationStatus.Computed -> status.resolvedTypeRef
             is ImplicitBodyResolveComputationStatus.Computing ->
-                buildErrorTypeRef {diagnostic = FirSimpleDiagnostic("cycle", DiagnosticKind.RecursionInImplicitTypes) }
+                buildErrorTypeRef {diagnostic = ConeSimpleDiagnostic("cycle", DiagnosticKind.RecursionInImplicitTypes) }
             else -> computeReturnTypeRef(declaration)
         }
     }
@@ -187,7 +187,7 @@ private class ReturnTypeCalculatorWithJump(
 
         if (file == null || outerClasses.any { it == null }) {
             return buildErrorTypeRef {
-                diagnostic = FirSimpleDiagnostic(
+                diagnostic = ConeSimpleDiagnostic(
                     "Cannot calculate return type (local class/object?)",
                     DiagnosticKind.InferenceError
                 )

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirErrorFunction.kt

@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.fir.declarations
 import org.jetbrains.kotlin.fir.FirPureAbstractElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.FirSourceElement
-import org.jetbrains.kotlin.fir.diagnostics.FirDiagnostic
+import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
 import org.jetbrains.kotlin.fir.diagnostics.FirDiagnosticHolder
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirBlock
@@ -33,7 +33,7 @@ abstract class FirErrorFunction : FirPureAbstractElement(), FirFunction<FirError
     abstract override val controlFlowGraphReference: FirControlFlowGraphReference
     abstract override val valueParameters: List<FirValueParameter>
     abstract override val body: FirBlock?
-    abstract override val diagnostic: FirDiagnostic
+    abstract override val diagnostic: ConeDiagnostic
     abstract override val symbol: FirErrorFunctionSymbol
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitErrorFunction(this, data)

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirErrorFunctionBuilder.kt

@@ -15,7 +15,7 @@ import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
 import org.jetbrains.kotlin.fir.declarations.impl.FirErrorFunctionImpl
-import org.jetbrains.kotlin.fir.diagnostics.FirDiagnostic
+import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirBlock
 import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
@@ -38,7 +38,7 @@ class FirErrorFunctionBuilder : FirAnnotationContainerBuilder {
     override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
     val typeParameters: MutableList<FirTypeParameter> = mutableListOf()
     val valueParameters: MutableList<FirValueParameter> = mutableListOf()
-    lateinit var diagnostic: FirDiagnostic
+    lateinit var diagnostic: ConeDiagnostic
     lateinit var symbol: FirErrorFunctionSymbol
 
     override fun build(): FirErrorFunction {

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirErrorFunctionImpl.kt

@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.fir.declarations.FirErrorFunction
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.declarations.FirTypeParameter
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
-import org.jetbrains.kotlin.fir.diagnostics.FirDiagnostic
+import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirBlock
 import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
@@ -33,7 +33,7 @@ internal class FirErrorFunctionImpl(
     override val annotations: MutableList<FirAnnotationCall>,
     override val typeParameters: MutableList<FirTypeParameter>,
     override val valueParameters: MutableList<FirValueParameter>,
-    override val diagnostic: FirDiagnostic,
+    override val diagnostic: ConeDiagnostic,
     override val symbol: FirErrorFunctionSymbol,
 ) : FirErrorFunction() {
     override var returnTypeRef: FirTypeRef = FirErrorTypeRefImpl(null, diagnostic)

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/diagnostics/FirDiagnosticHolder.kt

@@ -16,7 +16,7 @@ import org.jetbrains.kotlin.fir.visitors.*
 
 interface FirDiagnosticHolder : FirElement {
     override val source: FirSourceElement?
-    val diagnostic: FirDiagnostic
+    val diagnostic: ConeDiagnostic
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitDiagnosticHolder(this, data)
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirErrorExpression.kt

@@ -6,7 +6,7 @@
 package org.jetbrains.kotlin.fir.expressions
 
 import org.jetbrains.kotlin.fir.FirSourceElement
-import org.jetbrains.kotlin.fir.diagnostics.FirDiagnostic
+import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
 import org.jetbrains.kotlin.fir.diagnostics.FirDiagnosticHolder
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.*
@@ -20,7 +20,7 @@ abstract class FirErrorExpression : FirExpression(), FirDiagnosticHolder {
     abstract override val source: FirSourceElement?
     abstract override val typeRef: FirTypeRef
     abstract override val annotations: List<FirAnnotationCall>
-    abstract override val diagnostic: FirDiagnostic
+    abstract override val diagnostic: ConeDiagnostic
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitErrorExpression(this, data)
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirErrorLoop.kt

@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.fir.expressions
 
 import org.jetbrains.kotlin.fir.FirLabel
 import org.jetbrains.kotlin.fir.FirSourceElement
-import org.jetbrains.kotlin.fir.diagnostics.FirDiagnostic
+import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
 import org.jetbrains.kotlin.fir.diagnostics.FirDiagnosticHolder
 import org.jetbrains.kotlin.fir.visitors.*
 
@@ -22,7 +22,7 @@ abstract class FirErrorLoop : FirLoop(), FirDiagnosticHolder {
     abstract override val block: FirBlock
     abstract override val condition: FirExpression
     abstract override val label: FirLabel?
-    abstract override val diagnostic: FirDiagnostic
+    abstract override val diagnostic: ConeDiagnostic
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitErrorLoop(this, data)
 

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirErrorExpressionBuilder.kt

@@ -9,7 +9,7 @@ import kotlin.contracts.*
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.builder.FirAnnotationContainerBuilder
 import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
-import org.jetbrains.kotlin.fir.diagnostics.FirDiagnostic
+import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirErrorExpression
 import org.jetbrains.kotlin.fir.expressions.builder.FirExpressionBuilder
@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.fir.visitors.*
 @FirBuilderDsl
 class FirErrorExpressionBuilder : FirAnnotationContainerBuilder, FirExpressionBuilder {
     override var source: FirSourceElement? = null
-    lateinit var diagnostic: FirDiagnostic
+    lateinit var diagnostic: ConeDiagnostic
 
     override fun build(): FirErrorExpression {
         return FirErrorExpressionImpl(

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirErrorLoopBuilder.kt

@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.fir.FirLabel
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.builder.FirAnnotationContainerBuilder
 import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
-import org.jetbrains.kotlin.fir.diagnostics.FirDiagnostic
+import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirBlock
 import org.jetbrains.kotlin.fir.expressions.FirErrorLoop
@@ -29,7 +29,7 @@ class FirErrorLoopBuilder : FirAnnotationContainerBuilder {
     override var source: FirSourceElement? = null
     override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
     var label: FirLabel? = null
-    lateinit var diagnostic: FirDiagnostic
+    lateinit var diagnostic: ConeDiagnostic
 
     override fun build(): FirErrorLoop {
         return FirErrorLoopImpl(

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirErrorExpressionImpl.kt

@@ -6,7 +6,7 @@
 package org.jetbrains.kotlin.fir.expressions.impl
 
 import org.jetbrains.kotlin.fir.FirSourceElement
-import org.jetbrains.kotlin.fir.diagnostics.FirDiagnostic
+import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirErrorExpression
 import org.jetbrains.kotlin.fir.types.FirTypeRef
@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.fir.visitors.*
 
 internal class FirErrorExpressionImpl(
     override val source: FirSourceElement?,
-    override val diagnostic: FirDiagnostic,
+    override val diagnostic: ConeDiagnostic,
 ) : FirErrorExpression() {
     override var typeRef: FirTypeRef = FirErrorTypeRefImpl(source, diagnostic)
     override val annotations: List<FirAnnotationCall> get() = emptyList()

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirErrorLoopImpl.kt

@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.fir.expressions.impl
 
 import org.jetbrains.kotlin.fir.FirLabel
 import org.jetbrains.kotlin.fir.FirSourceElement
-import org.jetbrains.kotlin.fir.diagnostics.FirDiagnostic
+import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirBlock
 import org.jetbrains.kotlin.fir.expressions.FirErrorLoop
@@ -24,7 +24,7 @@ internal class FirErrorLoopImpl(
     override val source: FirSourceElement?,
     override val annotations: MutableList<FirAnnotationCall>,
     override var label: FirLabel?,
-    override val diagnostic: FirDiagnostic,
+    override val diagnostic: ConeDiagnostic,
 ) : FirErrorLoop() {
     override var block: FirBlock = FirEmptyExpressionBlock()
     override var condition: FirExpression = FirErrorExpressionImpl(source, diagnostic)

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/references/FirErrorNamedReference.kt

@@ -6,7 +6,7 @@
 package org.jetbrains.kotlin.fir.references
 
 import org.jetbrains.kotlin.fir.FirSourceElement
-import org.jetbrains.kotlin.fir.diagnostics.FirDiagnostic
+import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
 import org.jetbrains.kotlin.fir.diagnostics.FirDiagnosticHolder
 import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
 import org.jetbrains.kotlin.name.Name
@@ -21,7 +21,7 @@ abstract class FirErrorNamedReference : FirNamedReference(), FirDiagnosticHolder
     abstract override val source: FirSourceElement?
     abstract override val name: Name
     abstract override val candidateSymbol: AbstractFirBasedSymbol<*>?
-    abstract override val diagnostic: FirDiagnostic
+    abstract override val diagnostic: ConeDiagnostic
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitErrorNamedReference(this, data)
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/references/builder/FirErrorNamedReferenceBuilder.kt

@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.fir.references.builder
 import kotlin.contracts.*
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
-import org.jetbrains.kotlin.fir.diagnostics.FirDiagnostic
+import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
 import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
 import org.jetbrains.kotlin.fir.references.impl.FirErrorNamedReferenceImpl
 import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.name.Name
 @FirBuilderDsl
 class FirErrorNamedReferenceBuilder {
     var source: FirSourceElement? = null
-    lateinit var diagnostic: FirDiagnostic
+    lateinit var diagnostic: ConeDiagnostic
 
     fun build(): FirErrorNamedReference {
         return FirErrorNamedReferenceImpl(

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/references/impl/FirErrorNamedReferenceImpl.kt

@@ -6,7 +6,7 @@
 package org.jetbrains.kotlin.fir.references.impl
 
 import org.jetbrains.kotlin.fir.FirSourceElement
-import org.jetbrains.kotlin.fir.diagnostics.FirDiagnostic
+import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
 import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
 import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
 import org.jetbrains.kotlin.name.Name
@@ -19,7 +19,7 @@ import org.jetbrains.kotlin.fir.visitors.*
 
 internal class FirErrorNamedReferenceImpl(
     override val source: FirSourceElement?,
-    override val diagnostic: FirDiagnostic,
+    override val diagnostic: ConeDiagnostic,
 ) : FirErrorNamedReference() {
     override val name: Name = Name.special("<${diagnostic.reason}>")
     override val candidateSymbol: AbstractFirBasedSymbol<*>? get() = null

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/types/FirErrorTypeRef.kt

@@ -6,7 +6,7 @@
 package org.jetbrains.kotlin.fir.types
 
 import org.jetbrains.kotlin.fir.FirSourceElement
-import org.jetbrains.kotlin.fir.diagnostics.FirDiagnostic
+import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
 import org.jetbrains.kotlin.fir.diagnostics.FirDiagnosticHolder
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.visitors.*
@@ -21,7 +21,7 @@ abstract class FirErrorTypeRef : FirResolvedTypeRef(), FirDiagnosticHolder {
     abstract override val annotations: List<FirAnnotationCall>
     abstract override val type: ConeKotlinType
     abstract override val delegatedTypeRef: FirTypeRef?
-    abstract override val diagnostic: FirDiagnostic
+    abstract override val diagnostic: ConeDiagnostic
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitErrorTypeRef(this, data)
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/types/builder/FirErrorTypeRefBuilder.kt

@@ -9,7 +9,7 @@ import kotlin.contracts.*
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.builder.FirAnnotationContainerBuilder
 import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
-import org.jetbrains.kotlin.fir.diagnostics.FirDiagnostic
+import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.types.ConeClassErrorType
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.fir.visitors.*
 @FirBuilderDsl
 class FirErrorTypeRefBuilder : FirAnnotationContainerBuilder {
     override var source: FirSourceElement? = null
-    lateinit var diagnostic: FirDiagnostic
+    lateinit var diagnostic: ConeDiagnostic
 
     override fun build(): FirErrorTypeRef {
         return FirErrorTypeRefImpl(

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/types/impl/FirErrorTypeRefImpl.kt

@@ -6,7 +6,7 @@
 package org.jetbrains.kotlin.fir.types.impl
 
 import org.jetbrains.kotlin.fir.FirSourceElement
-import org.jetbrains.kotlin.fir.diagnostics.FirDiagnostic
+import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.types.ConeClassErrorType
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.fir.visitors.*
 
 internal class FirErrorTypeRefImpl(
     override val source: FirSourceElement?,
-    override val diagnostic: FirDiagnostic,
+    override val diagnostic: ConeDiagnostic,
 ) : FirErrorTypeRef() {
     override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
     override val type: ConeKotlinType = ConeClassErrorType(diagnostic.reason)

compiler/fir/tree/src/org/jetbrains/kotlin/fir/diagnostics/ConeDiagnostic.kt

@@ -5,10 +5,10 @@
 
 package org.jetbrains.kotlin.fir.diagnostics
 
-abstract class FirDiagnostic {
+abstract class ConeDiagnostic {
     abstract val reason: String
 }
 
-class FirStubDiagnostic(val original: FirDiagnostic) : FirDiagnostic() {
+class ConeStubDiagnostic(val original: ConeDiagnostic) : ConeDiagnostic() {
     override val reason: String get() = original.reason
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/diagnostics/ConeSimpleDiagnostic.kt

@@ -5,9 +5,13 @@
 
 package org.jetbrains.kotlin.fir.diagnostics
 
-class FirSimpleDiagnostic(override val reason: String, val kind: DiagnosticKind = DiagnosticKind.Other) : FirDiagnostic()
+class ConeSimpleDiagnostic(override val reason: String, val kind: DiagnosticKind = DiagnosticKind.Other) : ConeDiagnostic()
 
-class FirDiagnosticWithParameters1<A>(override val reason: String, val a: A, val kind: DiagnosticKind = DiagnosticKind.Other) : FirDiagnostic()
+class ConeSimpleDiagnosticWithParameters1<A>(
+    override val reason: String,
+    val a: A,
+    val kind: DiagnosticKind = DiagnosticKind.Other
+) : ConeDiagnostic()
 
 enum class DiagnosticKind {
     Syntax,

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirExpressionUtil.kt

@@ -7,7 +7,7 @@ package org.jetbrains.kotlin.fir.expressions
 
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
-import org.jetbrains.kotlin.fir.diagnostics.FirDiagnostic
+import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
 import org.jetbrains.kotlin.fir.expressions.builder.buildConstExpression
 import org.jetbrains.kotlin.fir.expressions.builder.buildErrorExpression
 import org.jetbrains.kotlin.fir.expressions.builder.buildErrorLoop
@@ -28,7 +28,7 @@ inline val FirAnnotationCall.coneClassLikeType: ConeClassLikeType?
 inline val FirAnnotationCall.classId: ClassId?
     get() = coneClassLikeType?.lookupTag?.classId
 
-fun <T> buildConstOrErrorExpression(source: FirSourceElement?, kind: FirConstKind<T>, value: T?, diagnostic: FirDiagnostic): FirExpression =
+fun <T> buildConstOrErrorExpression(source: FirSourceElement?, kind: FirConstKind<T>, value: T?, diagnostic: ConeDiagnostic): FirExpression =
     value?.let {
         buildConstExpression(source, kind, it)
     } ?: buildErrorExpression {
@@ -51,14 +51,14 @@ fun FirExpression.toResolvedCallableSymbol(): FirCallableSymbol<*>? {
     return toResolvedCallableReference()?.resolvedSymbol as FirCallableSymbol<*>?
 }
 
-fun buildErrorLoop(source: FirSourceElement?, diagnostic: FirDiagnostic): FirErrorLoop {
+fun buildErrorLoop(source: FirSourceElement?, diagnostic: ConeDiagnostic): FirErrorLoop {
     return buildErrorLoop {
         this.source = source
         this.diagnostic = diagnostic
     }
 }
 
-fun buildErrorExpression(source: FirSourceElement?, diagnostic: FirDiagnostic): FirErrorExpression {
+fun buildErrorExpression(source: FirSourceElement?, diagnostic: ConeDiagnostic): FirErrorExpression {
     return buildErrorExpression {
         this.source = source
         this.diagnostic = diagnostic

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/NodeConfigurator.kt

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.fir.tree.generator
 
-import org.jetbrains.kotlin.descriptors.effectiveVisibility
 import org.jetbrains.kotlin.fir.tree.generator.FieldSets.annotations
 import org.jetbrains.kotlin.fir.tree.generator.FieldSets.arguments
 import org.jetbrains.kotlin.fir.tree.generator.FieldSets.body
@@ -58,7 +57,7 @@ object NodeConfigurator : AbstractFieldConfigurator<FirTreeBuilder>(FirTreeBuild
         }
 
         diagnosticHolder.configure {
-            +field("diagnostic", firDiagnosticType)
+            +field("diagnostic", coneDiagnosticType)
         }
 
         declaration.configure {

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/Types.kt

@@ -64,7 +64,7 @@ val firScopeProviderType = type("fir.scopes", "FirScopeProvider")
 val pureAbstractElementType = generatedType("FirPureAbstractElement")
 val effectDeclarationType = type("fir.contracts.description", "ConeEffectDeclaration")
 val emptyContractDescriptionType = generatedType("contracts.impl", "FirEmptyContractDescription")
-val firDiagnosticType = generatedType("diagnostics", "FirDiagnostic")
+val coneDiagnosticType = generatedType("diagnostics", "ConeDiagnostic")
 
 val dslBuilderAnnotationType = generatedType("builder", "FirBuilderDsl")
 val firImplementationDetailType = generatedType("FirImplementationDetail")

compiler/tests-common/tests/org/jetbrains/kotlin/fir/AbstractFirBaseDiagnosticsTest.kt

@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.checkers.utils.CheckerTestUtil
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.cli.jvm.compiler.TopDownAnalyzerFacadeForJVM
 import org.jetbrains.kotlin.diagnostics.PsiDiagnosticUtils
-import org.jetbrains.kotlin.fir.analysis.diagnostics.ConeDiagnostic
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnostic
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
 import org.jetbrains.kotlin.fir.builder.RawFirBuilder
 import org.jetbrains.kotlin.fir.declarations.FirFile
@@ -196,7 +196,7 @@ abstract class AbstractFirBaseDiagnosticsTest : BaseDiagnosticsTest() {
         }
 
     protected fun TestFile.getActualText(
-        coneDiagnostics: Iterable<ConeDiagnostic>,
+        firDiagnostics: Iterable<FirDiagnostic>,
         actualText: StringBuilder
     ): Boolean {
         val ktFile = this.ktFile
@@ -211,7 +211,7 @@ abstract class AbstractFirBaseDiagnosticsTest : BaseDiagnosticsTest() {
         // TODO: report JVM signature diagnostics also for implementing modules
 
         val ok = booleanArrayOf(true)
-        val diagnostics = coneDiagnostics.toActualDiagnostic(ktFile)
+        val diagnostics = firDiagnostics.toActualDiagnostic(ktFile)
         val filteredDiagnostics = diagnostics // TODO
 
         actualDiagnostics.addAll(filteredDiagnostics)
@@ -308,7 +308,7 @@ abstract class AbstractFirBaseDiagnosticsTest : BaseDiagnosticsTest() {
         return ok[0]
     }
 
-    private fun Iterable<ConeDiagnostic>.toActualDiagnostic(root: PsiElement): List<ActualDiagnostic> {
+    private fun Iterable<FirDiagnostic>.toActualDiagnostic(root: PsiElement): List<ActualDiagnostic> {
         val result = mutableListOf<ActualDiagnostic>()
         filter { it.diagnostic.factory != FirErrors.SYNTAX_ERROR }.mapTo(result) { ActualDiagnostic(it.diagnostic, null, true) }
         for (errorElement in AnalyzingUtils.getSyntaxErrorRanges(root)) {

compiler/tests-common/tests/org/jetbrains/kotlin/fir/FirResolveBench.kt

@@ -8,7 +8,7 @@ import com.intellij.openapi.fileEditor.FileDocumentManager
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.builder.RawFirBuilder
 import org.jetbrains.kotlin.fir.declarations.FirFile
-import org.jetbrains.kotlin.fir.diagnostics.FirStubDiagnostic
+import org.jetbrains.kotlin.fir.diagnostics.ConeStubDiagnostic
 import org.jetbrains.kotlin.fir.expressions.FirFunctionCall
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression
 import org.jetbrains.kotlin.fir.lightTree.LightTree2Fir
@@ -255,7 +255,7 @@ class FirResolveBench(val withProgress: Boolean) {
                         unresolvedTypes++
 
                         if (typeRef.psi != null) {
-                            if (typeRef is FirErrorTypeRef && typeRef.diagnostic is FirStubDiagnostic) {
+                            if (typeRef is FirErrorTypeRef && typeRef.diagnostic is ConeStubDiagnostic) {
                                 return
                             }
                             val psi = typeRef.psi!!
@@ -278,7 +278,7 @@ class FirResolveBench(val withProgress: Boolean) {
                                 implicitTypes++
                             } else {
                                 errorTypes++
-                                if (resolvedTypeRef is FirErrorTypeRef && resolvedTypeRef.diagnostic is FirStubDiagnostic) {
+                                if (resolvedTypeRef is FirErrorTypeRef && resolvedTypeRef.diagnostic is ConeStubDiagnostic) {
                                     return
                                 }
                                 val psi = resolvedTypeRef.psi!!

idea/idea-analysis/src/org/jetbrains/kotlin/idea/fir/FirIdeDiagnosticsCollector.kt

@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.idea.fir
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.analysis.collectors.AbstractDiagnosticCollector
 import org.jetbrains.kotlin.fir.analysis.collectors.registerAllComponents
-import org.jetbrains.kotlin.fir.analysis.diagnostics.ConeDiagnostic
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnostic
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.psi
 import org.jetbrains.kotlin.psi.KtElement
@@ -20,7 +20,7 @@ class FirIdeDiagnosticsCollector(session: FirSession, private val resolveState:
     }
 
     private inner class Reporter : DiagnosticReporter() {
-        override fun report(diagnostic: ConeDiagnostic?) {
+        override fun report(diagnostic: FirDiagnostic?) {
             if (diagnostic == null) return
             val psi = diagnostic.source.psi as? KtElement ?: return
             resolveState.record(psi, diagnostic.diagnostic)
@@ -34,7 +34,7 @@ class FirIdeDiagnosticsCollector(session: FirSession, private val resolveState:
         reporter = Reporter()
     }
 
-    override fun getCollectedDiagnostics(): Iterable<ConeDiagnostic> {
+    override fun getCollectedDiagnostics(): Iterable<FirDiagnostic> {
         // Not necessary in IDE
         return emptyList()
     }

idea/idea-analysis/src/org/jetbrains/kotlin/idea/fir/FirModuleResolveState.kt

@@ -11,7 +11,7 @@ import com.intellij.psi.PsiElementVisitor
 import org.jetbrains.kotlin.diagnostics.Diagnostic
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.analysis.diagnostics.ConeDiagnostic
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnostic
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.java.FirProjectSessionProvider
 import org.jetbrains.kotlin.fir.psi
@@ -49,7 +49,7 @@ interface FirModuleResolveState {
 
     fun record(psi: KtElement, diagnostic: Diagnostic)
 
-    fun setDiagnosticsForFile(file: KtFile, fir: FirFile, diagnostics: Iterable<ConeDiagnostic> = emptyList())
+    fun setDiagnosticsForFile(file: KtFile, fir: FirFile, diagnostics: Iterable<FirDiagnostic> = emptyList())
 }
 
 class FirModuleResolveStateImpl(override val sessionProvider: FirProjectSessionProvider) : FirModuleResolveState {
@@ -91,7 +91,7 @@ class FirModuleResolveStateImpl(override val sessionProvider: FirProjectSessionP
         list += diagnostic
     }
 
-    override fun setDiagnosticsForFile(file: KtFile, fir: FirFile, diagnostics: Iterable<ConeDiagnostic>) {
+    override fun setDiagnosticsForFile(file: KtFile, fir: FirFile, diagnostics: Iterable<FirDiagnostic>) {
         for (diagnostic in diagnostics) {
             (diagnostic.source.psi as? KtElement)?.let { record(it, diagnostic.diagnostic) }
         }