[FIR] Introduce FirDiagnostic in FIR instead of errorReason

compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt

@@ -703,7 +703,7 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
 
     override fun visitErrorTypeRef(errorTypeRef: FirErrorTypeRef) {
         visitTypeRef(errorTypeRef)
-        print("<ERROR TYPE REF: ${errorTypeRef.reason}>")
+        print("<ERROR TYPE REF: ${errorTypeRef.diagnostic.reason}>")
     }
 
     override fun visitImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef) {
@@ -790,7 +790,7 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
             symbol != null -> {
                 print("R?C|${symbol.render()}|")
             }
-            namedReference is FirErrorNamedReference -> print("<${namedReference.errorReason}>#")
+            namedReference is FirErrorNamedReference -> print("<${namedReference.diagnostic.reason}>#")
             else -> print("${namedReference.name}#")
         }
     }
@@ -1000,7 +1000,7 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
     }
 
     override fun visitErrorExpression(errorExpression: FirErrorExpression) {
-        print("ERROR_EXPR(${errorExpression.reason})")
+        print("ERROR_EXPR(${errorExpression.diagnostic.reason})")
     }
 
     override fun visitResolvedQualifier(resolvedQualifier: FirResolvedQualifier) {

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

@@ -8,6 +8,8 @@ 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.FirDiagnosticHolder
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirBlock
 import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
@@ -20,7 +22,7 @@ import org.jetbrains.kotlin.fir.visitors.*
  * DO NOT MODIFY IT MANUALLY
  */
 
-abstract class FirErrorFunction : FirPureAbstractElement(), FirFunction<FirErrorFunction> {
+abstract class FirErrorFunction : FirPureAbstractElement(), FirFunction<FirErrorFunction>, FirDiagnosticHolder {
     abstract override val source: FirSourceElement?
     abstract override val session: FirSession
     abstract override val resolvePhase: FirResolvePhase
@@ -31,7 +33,7 @@ abstract class FirErrorFunction : FirPureAbstractElement(), FirFunction<FirError
     abstract override val typeParameters: List<FirTypeParameter>
     abstract override val valueParameters: List<FirValueParameter>
     abstract override val body: FirBlock?
-    abstract val reason: String
+    abstract override val diagnostic: FirDiagnostic
     abstract override val symbol: FirErrorFunctionSymbol
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitErrorFunction(this, data)

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

@@ -11,6 +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.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirBlock
 import org.jetbrains.kotlin.fir.impl.FirAbstractAnnotatedElement
@@ -29,12 +30,12 @@ import org.jetbrains.kotlin.fir.visitors.*
 class FirErrorFunctionImpl(
     override val source: FirSourceElement?,
     override val session: FirSession,
-    override val reason: String,
+    override val diagnostic: FirDiagnostic,
     override val symbol: FirErrorFunctionSymbol
 ) : FirErrorFunction(), FirAbstractAnnotatedElement {
     override var resolvePhase: FirResolvePhase = FirResolvePhase.RAW_FIR
     override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
-    override var returnTypeRef: FirTypeRef = FirErrorTypeRefImpl(null, reason)
+    override var returnTypeRef: FirTypeRef = FirErrorTypeRefImpl(null, diagnostic)
     override val receiverTypeRef: FirTypeRef? get() = null
     override var controlFlowGraphReference: FirControlFlowGraphReference = FirEmptyControlFlowGraphReference()
     override val typeParameters: MutableList<FirTypeParameter> = mutableListOf()

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

@@ -0,0 +1,10 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.fir.diagnostics
+
+abstract class FirDiagnostic {
+    abstract val reason: String
+}

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

@@ -0,0 +1,22 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.fir.diagnostics
+
+import org.jetbrains.kotlin.fir.FirElement
+import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.fir.visitors.*
+
+/*
+ * This file was generated automatically
+ * DO NOT MODIFY IT MANUALLY
+ */
+
+interface FirDiagnosticHolder : FirElement {
+    override val source: FirSourceElement?
+    val diagnostic: FirDiagnostic
+
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitDiagnosticHolder(this, data)
+}

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

@@ -0,0 +1,8 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.fir.diagnostics
+
+class FirSimpleDiagnostic(override val reason: String) : FirDiagnostic()

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

@@ -7,6 +7,8 @@ package org.jetbrains.kotlin.fir.expressions
 
 import org.jetbrains.kotlin.fir.FirPureAbstractElement
 import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.fir.diagnostics.FirDiagnostic
+import org.jetbrains.kotlin.fir.diagnostics.FirDiagnosticHolder
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.*
 
@@ -15,11 +17,11 @@ import org.jetbrains.kotlin.fir.visitors.*
  * DO NOT MODIFY IT MANUALLY
  */
 
-abstract class FirErrorExpression : FirPureAbstractElement(), FirExpression {
+abstract class FirErrorExpression : FirPureAbstractElement(), FirExpression, FirDiagnosticHolder {
     abstract override val source: FirSourceElement?
     abstract override val typeRef: FirTypeRef
     abstract override val annotations: List<FirAnnotationCall>
-    abstract val reason: String
+    abstract override val diagnostic: FirDiagnostic
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitErrorExpression(this, data)
 }

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

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.fir.expressions
+
+import org.jetbrains.kotlin.fir.FirLabel
+import org.jetbrains.kotlin.fir.FirPureAbstractElement
+import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.fir.diagnostics.FirDiagnostic
+import org.jetbrains.kotlin.fir.diagnostics.FirDiagnosticHolder
+import org.jetbrains.kotlin.fir.visitors.*
+
+/*
+ * This file was generated automatically
+ * DO NOT MODIFY IT MANUALLY
+ */
+
+abstract class FirErrorLoop : FirPureAbstractElement(), FirLoop, FirDiagnosticHolder {
+    abstract override val source: FirSourceElement?
+    abstract override val annotations: List<FirAnnotationCall>
+    abstract override val block: FirBlock
+    abstract override val condition: FirExpression
+    abstract override val label: FirLabel?
+    abstract override val diagnostic: FirDiagnostic
+
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitErrorLoop(this, data)
+
+    abstract override fun <D> transformBlock(transformer: FirTransformer<D>, data: D): FirErrorLoop
+
+    abstract override fun <D> transformCondition(transformer: FirTransformer<D>, data: D): FirErrorLoop
+
+    abstract override fun <D> transformOtherChildren(transformer: FirTransformer<D>, data: D): FirErrorLoop
+}

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

@@ -6,9 +6,10 @@
 package org.jetbrains.kotlin.fir.expressions
 
 import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic
 import org.jetbrains.kotlin.fir.expressions.impl.FirConstExpressionImpl
 import org.jetbrains.kotlin.fir.expressions.impl.FirErrorExpressionImpl
-import org.jetbrains.kotlin.fir.expressions.impl.FirErrorLoop
+import org.jetbrains.kotlin.fir.expressions.impl.FirErrorLoopImpl
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.types.ConeClassErrorType
@@ -24,7 +25,7 @@ inline val FirAnnotationCall.classId: ClassId?
     get() = coneClassLikeType?.lookupTag?.classId
 
 fun <T> FirConstExpressionImpl(source: FirSourceElement?, kind: IrConstKind<T>, value: T?, errorReason: String): FirExpression =
-    value?.let { FirConstExpressionImpl(source, kind, it) } ?: FirErrorExpressionImpl(source, errorReason)
+    value?.let { FirConstExpressionImpl(source, kind, it) } ?: FirErrorExpressionImpl(source, FirSimpleDiagnostic(errorReason))
 
 inline val FirTypeOperatorCall.argument: FirExpression get() = arguments.first()
 
@@ -36,6 +37,9 @@ fun FirExpression.toResolvedCallableSymbol(): FirCallableSymbol<*>? {
     return toResolvedCallableReference()?.resolvedSymbol as FirCallableSymbol<*>?
 }
 
-fun FirErrorLoop(source: FirSourceElement?, reason: String): FirErrorLoop = FirErrorLoop(source).apply {
-    condition = FirErrorExpressionImpl(source, reason)
+fun FirErrorLoop(source: FirSourceElement?, reason: String): FirErrorLoop {
+    val diagnostic = FirSimpleDiagnostic(reason)
+    return FirErrorLoopImpl(source, diagnostic).apply {
+        condition = FirErrorExpressionImpl(source, diagnostic)
+    }
 }

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

@@ -6,6 +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.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirErrorExpression
 import org.jetbrains.kotlin.fir.impl.FirAbstractAnnotatedElement
@@ -20,7 +21,7 @@ import org.jetbrains.kotlin.fir.visitors.*
 
 class FirErrorExpressionImpl(
     override val source: FirSourceElement?,
-    override val reason: String
+    override val diagnostic: FirDiagnostic
 ) : FirErrorExpression(), FirAbstractAnnotatedElement {
     override var typeRef: FirTypeRef = FirImplicitTypeRefImpl(null)
     override val annotations: MutableList<FirAnnotationCall> = mutableListOf()

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

@@ -6,12 +6,12 @@
 package org.jetbrains.kotlin.fir.expressions.impl
 
 import org.jetbrains.kotlin.fir.FirLabel
-import org.jetbrains.kotlin.fir.FirPureAbstractElement
 import org.jetbrains.kotlin.fir.FirSourceElement
+import org.jetbrains.kotlin.fir.diagnostics.FirDiagnostic
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirBlock
+import org.jetbrains.kotlin.fir.expressions.FirErrorLoop
 import org.jetbrains.kotlin.fir.expressions.FirExpression
-import org.jetbrains.kotlin.fir.expressions.FirLoop
 import org.jetbrains.kotlin.fir.impl.FirAbstractAnnotatedElement
 import org.jetbrains.kotlin.fir.visitors.*
 
@@ -20,12 +20,13 @@ import org.jetbrains.kotlin.fir.visitors.*
  * DO NOT MODIFY IT MANUALLY
  */
 
-class FirErrorLoop(
-    override val source: FirSourceElement?
-) : FirPureAbstractElement(), FirLoop, FirAbstractAnnotatedElement {
+class FirErrorLoopImpl(
+    override val source: FirSourceElement?,
+    override val diagnostic: FirDiagnostic
+) : FirErrorLoop(), FirAbstractAnnotatedElement {
     override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
     override var block: FirBlock = FirEmptyExpressionBlock()
-    override var condition: FirExpression = FirErrorExpressionImpl(source, "error loop")
+    override var condition: FirExpression = FirErrorExpressionImpl(source, diagnostic)
     override var label: FirLabel? = null
 
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
@@ -35,24 +36,24 @@ class FirErrorLoop(
         label?.accept(visitor, data)
     }
 
-    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirErrorLoop {
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirErrorLoopImpl {
         transformBlock(transformer, data)
         transformCondition(transformer, data)
         transformOtherChildren(transformer, data)
         return this
     }
 
-    override fun <D> transformBlock(transformer: FirTransformer<D>, data: D): FirErrorLoop {
+    override fun <D> transformBlock(transformer: FirTransformer<D>, data: D): FirErrorLoopImpl {
         block = block.transformSingle(transformer, data)
         return this
     }
 
-    override fun <D> transformCondition(transformer: FirTransformer<D>, data: D): FirErrorLoop {
+    override fun <D> transformCondition(transformer: FirTransformer<D>, data: D): FirErrorLoopImpl {
         condition = condition.transformSingle(transformer, data)
         return this
     }
 
-    override fun <D> transformOtherChildren(transformer: FirTransformer<D>, data: D): FirErrorLoop {
+    override fun <D> transformOtherChildren(transformer: FirTransformer<D>, data: D): FirErrorLoopImpl {
         annotations.transformInplace(transformer, data)
         label = label?.transformSingle(transformer, data)
         return this

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

@@ -6,6 +6,8 @@
 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.FirDiagnosticHolder
 import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.fir.visitors.*
@@ -15,11 +17,11 @@ import org.jetbrains.kotlin.fir.visitors.*
  * DO NOT MODIFY IT MANUALLY
  */
 
-abstract class FirErrorNamedReference : FirNamedReference() {
+abstract class FirErrorNamedReference : FirNamedReference(), FirDiagnosticHolder {
     abstract override val source: FirSourceElement?
     abstract override val name: Name
     abstract override val candidateSymbol: AbstractFirBasedSymbol<*>?
-    abstract val errorReason: String
+    abstract override val diagnostic: FirDiagnostic
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitErrorNamedReference(this, data)
 }

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

@@ -6,6 +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.references.FirErrorNamedReference
 import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
 import org.jetbrains.kotlin.name.Name
@@ -18,9 +19,9 @@ import org.jetbrains.kotlin.fir.visitors.*
 
 class FirErrorNamedReferenceImpl(
     override val source: FirSourceElement?,
-    override val errorReason: String
+    override val diagnostic: FirDiagnostic
 ) : FirErrorNamedReference() {
-    override val name: Name = Name.special("<$errorReason>")
+    override val name: Name = Name.special("<${diagnostic.reason}>")
     override val candidateSymbol: AbstractFirBasedSymbol<*>? get() = null
 
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {}

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

@@ -6,6 +6,8 @@
 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.FirDiagnosticHolder
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.visitors.*
 
@@ -14,11 +16,11 @@ import org.jetbrains.kotlin.fir.visitors.*
  * DO NOT MODIFY IT MANUALLY
  */
 
-abstract class FirErrorTypeRef : FirResolvedTypeRef() {
+abstract class FirErrorTypeRef : FirResolvedTypeRef(), FirDiagnosticHolder {
     abstract override val source: FirSourceElement?
     abstract override val annotations: List<FirAnnotationCall>
     abstract override val type: ConeKotlinType
-    abstract val reason: String
+    abstract override val diagnostic: FirDiagnostic
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitErrorTypeRef(this, data)
 }

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

@@ -6,6 +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.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.impl.FirAbstractAnnotatedElement
 import org.jetbrains.kotlin.fir.types.ConeClassErrorType
@@ -20,10 +21,10 @@ import org.jetbrains.kotlin.fir.visitors.*
 
 class FirErrorTypeRefImpl(
     override val source: FirSourceElement?,
-    override val reason: String
+    override val diagnostic: FirDiagnostic
 ) : FirErrorTypeRef(), FirAbstractAnnotatedElement {
     override val annotations: MutableList<FirAnnotationCall> = mutableListOf()
-    override val type: ConeKotlinType = ConeClassErrorType(reason)
+    override val type: ConeKotlinType = ConeClassErrorType(diagnostic.reason)
 
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
         annotations.forEach { it.accept(visitor, data) }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/FirTransformer.kt

@@ -48,7 +48,9 @@ import org.jetbrains.kotlin.fir.declarations.FirConstructor
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.declarations.FirAnonymousFunction
 import org.jetbrains.kotlin.fir.declarations.FirAnonymousObject
+import org.jetbrains.kotlin.fir.diagnostics.FirDiagnosticHolder
 import org.jetbrains.kotlin.fir.expressions.FirLoop
+import org.jetbrains.kotlin.fir.expressions.FirErrorLoop
 import org.jetbrains.kotlin.fir.expressions.FirDoWhileLoop
 import org.jetbrains.kotlin.fir.expressions.FirWhileLoop
 import org.jetbrains.kotlin.fir.expressions.FirBlock
@@ -294,10 +296,18 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformElement(anonymousObject, data)
     }
 
+    open fun transformDiagnosticHolder(diagnosticHolder: FirDiagnosticHolder, data: D): CompositeTransformResult<FirDiagnosticHolder> {
+        return transformElement(diagnosticHolder, data)
+    }
+
     open fun transformLoop(loop: FirLoop, data: D): CompositeTransformResult<FirStatement> {
         return transformElement(loop, data)
     }
 
+    open fun transformErrorLoop(errorLoop: FirErrorLoop, data: D): CompositeTransformResult<FirStatement> {
+        return transformElement(errorLoop, data)
+    }
+
     open fun transformDoWhileLoop(doWhileLoop: FirDoWhileLoop, data: D): CompositeTransformResult<FirStatement> {
         return transformElement(doWhileLoop, data)
     }
@@ -734,10 +744,18 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
         return transformAnonymousObject(anonymousObject, data)
     }
 
+    final override fun visitDiagnosticHolder(diagnosticHolder: FirDiagnosticHolder, data: D): CompositeTransformResult<FirDiagnosticHolder> {
+        return transformDiagnosticHolder(diagnosticHolder, data)
+    }
+
     final override fun visitLoop(loop: FirLoop, data: D): CompositeTransformResult<FirStatement> {
         return transformLoop(loop, data)
     }
 
+    final override fun visitErrorLoop(errorLoop: FirErrorLoop, data: D): CompositeTransformResult<FirStatement> {
+        return transformErrorLoop(errorLoop, data)
+    }
+
     final override fun visitDoWhileLoop(doWhileLoop: FirDoWhileLoop, data: D): CompositeTransformResult<FirStatement> {
         return transformDoWhileLoop(doWhileLoop, data)
     }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/FirVisitor.kt

@@ -48,7 +48,9 @@ import org.jetbrains.kotlin.fir.declarations.FirConstructor
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.declarations.FirAnonymousFunction
 import org.jetbrains.kotlin.fir.declarations.FirAnonymousObject
+import org.jetbrains.kotlin.fir.diagnostics.FirDiagnosticHolder
 import org.jetbrains.kotlin.fir.expressions.FirLoop
+import org.jetbrains.kotlin.fir.expressions.FirErrorLoop
 import org.jetbrains.kotlin.fir.expressions.FirDoWhileLoop
 import org.jetbrains.kotlin.fir.expressions.FirWhileLoop
 import org.jetbrains.kotlin.fir.expressions.FirBlock
@@ -208,8 +210,12 @@ abstract class FirVisitor<out R, in D> {
 
     open fun visitAnonymousObject(anonymousObject: FirAnonymousObject, data: D): R  = visitElement(anonymousObject, data)
 
+    open fun visitDiagnosticHolder(diagnosticHolder: FirDiagnosticHolder, data: D): R  = visitElement(diagnosticHolder, data)
+
     open fun visitLoop(loop: FirLoop, data: D): R  = visitElement(loop, data)
 
+    open fun visitErrorLoop(errorLoop: FirErrorLoop, data: D): R  = visitElement(errorLoop, data)
+
     open fun visitDoWhileLoop(doWhileLoop: FirDoWhileLoop, data: D): R  = visitElement(doWhileLoop, data)
 
     open fun visitWhileLoop(whileLoop: FirWhileLoop, data: D): R  = visitElement(whileLoop, data)

compiler/fir/tree/src/org/jetbrains/kotlin/fir/visitors/FirVisitorVoid.kt

@@ -48,7 +48,9 @@ import org.jetbrains.kotlin.fir.declarations.FirConstructor
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.declarations.FirAnonymousFunction
 import org.jetbrains.kotlin.fir.declarations.FirAnonymousObject
+import org.jetbrains.kotlin.fir.diagnostics.FirDiagnosticHolder
 import org.jetbrains.kotlin.fir.expressions.FirLoop
+import org.jetbrains.kotlin.fir.expressions.FirErrorLoop
 import org.jetbrains.kotlin.fir.expressions.FirDoWhileLoop
 import org.jetbrains.kotlin.fir.expressions.FirWhileLoop
 import org.jetbrains.kotlin.fir.expressions.FirBlock
@@ -292,10 +294,18 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitElement(anonymousObject)
     }
 
+    open fun visitDiagnosticHolder(diagnosticHolder: FirDiagnosticHolder) {
+        visitElement(diagnosticHolder)
+    }
+
     open fun visitLoop(loop: FirLoop) {
         visitElement(loop)
     }
 
+    open fun visitErrorLoop(errorLoop: FirErrorLoop) {
+        visitElement(errorLoop)
+    }
+
     open fun visitDoWhileLoop(doWhileLoop: FirDoWhileLoop) {
         visitElement(doWhileLoop)
     }
@@ -732,10 +742,18 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitAnonymousObject(anonymousObject)
     }
 
+    final override fun visitDiagnosticHolder(diagnosticHolder: FirDiagnosticHolder, data: Nothing?) {
+        visitDiagnosticHolder(diagnosticHolder)
+    }
+
     final override fun visitLoop(loop: FirLoop, data: Nothing?) {
         visitLoop(loop)
     }
 
+    final override fun visitErrorLoop(errorLoop: FirErrorLoop, data: Nothing?) {
+        visitErrorLoop(errorLoop)
+    }
+
     final override fun visitDoWhileLoop(doWhileLoop: FirDoWhileLoop, data: Nothing?) {
         visitDoWhileLoop(doWhileLoop)
     }

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

@@ -59,7 +59,10 @@ object FirTreeBuilder : AbstractFirTreeBuilder() {
     val anonymousFunction = element("AnonymousFunction", Declaration, function, expression)
     val anonymousObject = element("AnonymousObject", Declaration, klass, expression)
 
+    val diagnosticHolder = element("DiagnosticHolder", Diagnostics)
+
     val loop = element("Loop", Expression, statement, targetElement, annotationContainer)
+    val errorLoop = element("ErrorLoop", Expression, loop, diagnosticHolder)
     val doWhileLoop = element("DoWhileLoop", Expression, loop)
     val whileLoop = element("WhileLoop", Expression, loop)
 
@@ -88,8 +91,8 @@ object FirTreeBuilder : AbstractFirTreeBuilder() {
     val arrayOfCall = element("ArrayOfCall", Expression, expression, call)
     val arraySetCall = element("ArraySetCall", Expression, qualifiedAccess, call)
     val classReferenceExpression = element("ClassReferenceExpression", Expression, expression)
-    val errorExpression = element("ErrorExpression", Expression, expression)
-    val errorFunction = element("ErrorFunction", Declaration, function)
+    val errorExpression = element("ErrorExpression", Expression, expression, diagnosticHolder)
+    val errorFunction = element("ErrorFunction", Declaration, function, diagnosticHolder)
     val qualifiedAccessExpression = element("QualifiedAccessExpression", Expression, expression, qualifiedAccess)
     val functionCall = element("FunctionCall", Expression, qualifiedAccessExpression, call)
     val componentCall = element("ComponentCall", Expression, functionCall)
@@ -113,7 +116,7 @@ object FirTreeBuilder : AbstractFirTreeBuilder() {
     val wrappedDelegateExpression = element("WrappedDelegateExpression", Expression, wrappedExpression)
 
     val namedReference = element("NamedReference", Reference, reference)
-    val errorNamedReference = element("ErrorNamedReference", Reference, namedReference)
+    val errorNamedReference = element("ErrorNamedReference", Reference, namedReference, diagnosticHolder)
     val superReference = element("SuperReference", Reference, reference)
     val thisReference = element("ThisReference", Reference, reference)
     val controlFlowGraphReference = element("ControlFlowGraphReference", Reference, reference)
@@ -125,7 +128,7 @@ object FirTreeBuilder : AbstractFirTreeBuilder() {
     val resolvedCallableReference = element("ResolvedCallableReference", Reference, resolvedNamedReference)
 
     val resolvedTypeRef = element("ResolvedTypeRef", TypeRef, typeRef)
-    val errorTypeRef = element("ErrorTypeRef", TypeRef, resolvedTypeRef)
+    val errorTypeRef = element("ErrorTypeRef", TypeRef, resolvedTypeRef, diagnosticHolder)
     val delegatedTypeRef = element("DelegatedTypeRef", TypeRef, typeRef)
     val typeRefWithNullability = element("TypeRefWithNullability", TypeRef, typeRef)
     val userTypeRef = element("UserTypeRef", TypeRef, typeRefWithNullability)

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

@@ -224,11 +224,9 @@ object ImplementationConfigurator : AbstractFirTreeImplementationConfigurator()
             noSource()
         }
 
-        impl(errorExpression)
-
-        impl(loop, "FirErrorLoop") {
+        impl(errorLoop) {
             default("block", "FirEmptyExpressionBlock()")
-            default("condition", "FirErrorExpressionImpl(source, \"error loop\")")
+            default("condition", "FirErrorExpressionImpl(source, diagnostic)")
             defaultNull("label")
             useTypes(emptyExpressionBlock)
         }
@@ -496,13 +494,13 @@ object ImplementationConfigurator : AbstractFirTreeImplementationConfigurator()
         impl(resolvedTypeRef)
 
         val errorTypeRefImpl = impl(errorTypeRef) {
-            default("type", "ConeClassErrorType(reason)")
+            default("type", "ConeClassErrorType(diagnostic.reason)")
             useTypes(coneClassErrorTypeType)
         }
 
         impl(errorFunction) {
             defaultNull("receiverTypeRef", "body", withGetter = true)
-            default("returnTypeRef", "FirErrorTypeRefImpl(null, reason)")
+            default("returnTypeRef", "FirErrorTypeRefImpl(null, diagnostic)")
             useTypes(errorTypeRefImpl)
         }
 
@@ -524,7 +522,7 @@ object ImplementationConfigurator : AbstractFirTreeImplementationConfigurator()
         }
 
         impl(errorNamedReference) {
-            default("name", "Name.special(\"<\$errorReason>\")")
+            default("name", "Name.special(\"<\$diagnostic.reason>\")")
             defaultNull("candidateSymbol", withGetter = true)
         }
 

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

@@ -59,6 +59,10 @@ object NodeConfigurator : AbstractFieldConfigurator() {
             +field("calleeReference", reference).withTransform()
         }
 
+        diagnosticHolder.configure {
+            +field("diagnostic", firDiagnosticType)
+        }
+
         declaration.configure {
             +field("session", firSessionType)
             +field("resolvePhase", resolvePhaseType, withReplace = true).apply { isMutable = true }
@@ -95,7 +99,6 @@ object NodeConfigurator : AbstractFieldConfigurator() {
 
         errorFunction.configure {
             parentArg(function, "F", errorFunction)
-            +stringField("reason")
             +symbol("FirErrorFunctionSymbol")
         }
 
@@ -398,10 +401,6 @@ object NodeConfigurator : AbstractFieldConfigurator() {
             +intField("componentIndex")
         }
 
-        errorExpression.configure {
-            +stringField("reason")
-        }
-
         expressionWithSmartcast.configure {
             +field("originalExpression", qualifiedAccessExpression)
             +field("typesFromSmartcast", "Collection<ConeKotlinType>", null, customType = coneKotlinTypeType)
@@ -493,10 +492,6 @@ object NodeConfigurator : AbstractFieldConfigurator() {
             +field("type", coneKotlinTypeType)
         }
 
-        errorTypeRef.configure {
-            +stringField("reason")
-        }
-
         delegatedTypeRef.configure {
             +field("delegate", expression, nullable = true)
             +field(typeRef)
@@ -533,10 +528,6 @@ object NodeConfigurator : AbstractFieldConfigurator() {
             +field(varianceType)
         }
 
-        errorNamedReference.configure {
-            +stringField("errorReason")
-        }
-
         contractDescription.configure {
             +fieldList("effects", effectDeclarationType)
         }

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

@@ -62,4 +62,5 @@ val classSymbolType = type("fir.symbols.impl", "FirClassSymbol")
 
 val pureAbstractElementType = generatedType("FirPureAbstractElement")
 val effectDeclarationType = type("fir.contracts.description", "ConeEffectDeclaration")
-val emptyContractDescriptionType = generatedType("contracts.impl", "FirEmptyContractDescription")
+val emptyContractDescriptionType = generatedType("contracts.impl", "FirEmptyContractDescription")
+val firDiagnosticType = generatedType("diagnostics", "FirDiagnostic")

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

@@ -125,6 +125,7 @@ class Element(val name: String, kind: Kind) : AbstractElement {
         Reference("references"),
         TypeRef("types"),
         Contracts("contracts"),
+        Diagnostics("diagnostics"),
         Other("")
     }
 }