diff --git a/analysis/analysis-api-fir/analysis-api-fir-generator/src/org/jetbrains/kotlin/analysis/api/fir/generator/rendererrs/KtDiagnosticClassImplementationRenderer.kt b/analysis/analysis-api-fir/analysis-api-fir-generator/src/org/jetbrains/kotlin/analysis/api/fir/generator/rendererrs/KtDiagnosticClassImplementationRenderer.kt
index 67d789e6131..b371f5f46c6 100644
--- a/analysis/analysis-api-fir/analysis-api-fir-generator/src/org/jetbrains/kotlin/analysis/api/fir/generator/rendererrs/KtDiagnosticClassImplementationRenderer.kt
+++ b/analysis/analysis-api-fir/analysis-api-fir-generator/src/org/jetbrains/kotlin/analysis/api/fir/generator/rendererrs/KtDiagnosticClassImplementationRenderer.kt
@@ -32,17 +32,17 @@ object KtDiagnosticClassImplementationRenderer : AbstractDiagnosticsDataClassRen
         withIndent {
             printParameters(diagnostic, diagnosticList)
         }
-        print(") : KtFirDiagnostic.${diagnostic.className}(), KtAbstractFirDiagnostic<")
+        print(") : KtAbstractFirDiagnostic<")
         printTypeWithShortNames(diagnostic.original.psiType)
-        println(">")
+        println(">(firDiagnostic, token), KtFirDiagnostic.${diagnostic.className}")
     }
 
     private fun SmartPrinter.printParameters(diagnostic: HLDiagnostic, diagnosticList: HLDiagnosticList) {
         for (parameter in diagnostic.parameters) {
             printParameter(parameter, diagnosticList)
         }
-        println("override val firDiagnostic: KtPsiDiagnostic,")
-        println("override val token: KtLifetimeToken,")
+        println("firDiagnostic: KtPsiDiagnostic,")
+        println("token: KtLifetimeToken,")
     }
 
     private fun SmartPrinter.printParameter(parameter: HLDiagnosticParameter, diagnosticList: HLDiagnosticList) {
diff --git a/analysis/analysis-api-fir/analysis-api-fir-generator/src/org/jetbrains/kotlin/analysis/api/fir/generator/rendererrs/KtDiagnosticClassRenderer.kt b/analysis/analysis-api-fir/analysis-api-fir-generator/src/org/jetbrains/kotlin/analysis/api/fir/generator/rendererrs/KtDiagnosticClassRenderer.kt
index 324dcacfd3e..b1187232762 100644
--- a/analysis/analysis-api-fir/analysis-api-fir-generator/src/org/jetbrains/kotlin/analysis/api/fir/generator/rendererrs/KtDiagnosticClassRenderer.kt
+++ b/analysis/analysis-api-fir/analysis-api-fir-generator/src/org/jetbrains/kotlin/analysis/api/fir/generator/rendererrs/KtDiagnosticClassRenderer.kt
@@ -18,7 +18,7 @@ object KtDiagnosticClassRenderer : AbstractDiagnosticsDataClassRenderer() {
     }
 
     private fun SmartPrinter.printDiagnosticClasses(diagnosticList: HLDiagnosticList) {
-        inBracketsWithIndent("sealed class KtFirDiagnostic<PSI : PsiElement> : KtDiagnosticWithPsi<PSI>") {
+        inBracketsWithIndent("sealed interface KtFirDiagnostic<PSI : PsiElement> : KtDiagnosticWithPsi<PSI>") {
             for (diagnostic in diagnosticList.diagnostics) {
                 printDiagnosticClass(diagnostic, diagnosticList)
                 println()
@@ -27,9 +27,9 @@ object KtDiagnosticClassRenderer : AbstractDiagnosticsDataClassRenderer() {
     }
 
     private fun SmartPrinter.printDiagnosticClass(diagnostic: HLDiagnostic, diagnosticList: HLDiagnosticList) {
-        print("abstract class ${diagnostic.className} : KtFirDiagnostic<")
+        print("interface ${diagnostic.className} : KtFirDiagnostic<")
         printTypeWithShortNames(diagnostic.original.psiType)
-        print(">()")
+        print(">")
         inBracketsWithIndent {
             println("override val diagnosticClass get() = ${diagnostic.className}::class")
             printDiagnosticParameters(diagnostic, diagnosticList)
@@ -38,7 +38,7 @@ object KtDiagnosticClassRenderer : AbstractDiagnosticsDataClassRenderer() {
 
     private fun SmartPrinter.printDiagnosticParameters(diagnostic: HLDiagnostic, diagnosticList: HLDiagnosticList) {
         diagnostic.parameters.forEach { parameter ->
-            print("abstract val ${parameter.name}: ")
+            print("val ${parameter.name}: ")
             printTypeWithShortNames(parameter.type) { type ->
                 diagnosticList.containsClashingBySimpleNameType(type)
             }
diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtAbstractFirDiagnostic.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtAbstractFirDiagnostic.kt
index a1d7ed35633..fbe84d0f801 100644
--- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtAbstractFirDiagnostic.kt
+++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtAbstractFirDiagnostic.kt
@@ -9,14 +9,17 @@ import com.intellij.openapi.util.TextRange
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeOwner
 import org.jetbrains.kotlin.analysis.api.diagnostics.KtDiagnosticWithPsi
+import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken
 import org.jetbrains.kotlin.analysis.api.lifetime.withValidityAssertion
 import org.jetbrains.kotlin.diagnostics.KtDiagnostic
 import org.jetbrains.kotlin.diagnostics.KtPsiDiagnostic
 import org.jetbrains.kotlin.diagnostics.Severity
 import org.jetbrains.kotlin.diagnostics.rendering.RootDiagnosticRendererFactory
 
-internal interface KtAbstractFirDiagnostic<PSI : PsiElement> : KtDiagnosticWithPsi<PSI>, KtLifetimeOwner {
-    val firDiagnostic: KtPsiDiagnostic
+internal abstract class KtAbstractFirDiagnostic<PSI : PsiElement>(
+    private val firDiagnostic: KtPsiDiagnostic,
+    override val token: KtLifetimeToken,
+) : KtDiagnosticWithPsi<PSI>, KtLifetimeOwner {
 
     override val factoryName: String
         get() = withValidityAssertion { firDiagnostic.factory.name }
diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtCompilerPluginDiagnostic.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtCompilerPluginDiagnostic.kt
index 25506374726..caa39af515f 100644
--- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtCompilerPluginDiagnostic.kt
+++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtCompilerPluginDiagnostic.kt
@@ -7,41 +7,41 @@ package org.jetbrains.kotlin.analysis.api.fir.diagnostics
 
 import com.intellij.psi.PsiElement
 
-abstract class KtCompilerPluginDiagnostic0 : KtFirDiagnostic<PsiElement>(), KtAbstractFirDiagnostic<PsiElement> {
-    final override val diagnosticClass
+interface KtCompilerPluginDiagnostic0 : KtFirDiagnostic<PsiElement> {
+    override val diagnosticClass
         get() = KtCompilerPluginDiagnostic0::class
 }
 
-abstract class KtCompilerPluginDiagnostic1 : KtFirDiagnostic<PsiElement>(), KtAbstractFirDiagnostic<PsiElement> {
-    abstract val parameter1: Any?
+interface KtCompilerPluginDiagnostic1 : KtFirDiagnostic<PsiElement> {
+    val parameter1: Any?
 
-    final override val diagnosticClass
+    override val diagnosticClass
         get() = KtCompilerPluginDiagnostic1::class
 }
 
-abstract class KtCompilerPluginDiagnostic2 : KtFirDiagnostic<PsiElement>(), KtAbstractFirDiagnostic<PsiElement> {
-    abstract val parameter1: Any?
-    abstract val parameter2: Any?
+interface KtCompilerPluginDiagnostic2 : KtFirDiagnostic<PsiElement> {
+    val parameter1: Any?
+    val parameter2: Any?
 
-    final override val diagnosticClass
+    override val diagnosticClass
         get() = KtCompilerPluginDiagnostic2::class
 }
 
-abstract class KtCompilerPluginDiagnostic3 : KtFirDiagnostic<PsiElement>(), KtAbstractFirDiagnostic<PsiElement> {
-    abstract val parameter1: Any?
-    abstract val parameter2: Any?
-    abstract val parameter3: Any?
+interface KtCompilerPluginDiagnostic3 : KtFirDiagnostic<PsiElement> {
+    val parameter1: Any?
+    val parameter2: Any?
+    val parameter3: Any?
 
-    final override val diagnosticClass
+    override val diagnosticClass
         get() = KtCompilerPluginDiagnostic3::class
 }
 
-abstract class KtCompilerPluginDiagnostic4 : KtFirDiagnostic<PsiElement>(), KtAbstractFirDiagnostic<PsiElement> {
-    abstract val parameter1: Any?
-    abstract val parameter2: Any?
-    abstract val parameter3: Any?
-    abstract val parameter4: Any?
+interface KtCompilerPluginDiagnostic4 : KtFirDiagnostic<PsiElement> {
+    val parameter1: Any?
+    val parameter2: Any?
+    val parameter3: Any?
+    val parameter4: Any?
 
-    final override val diagnosticClass
+    override val diagnosticClass
         get() = KtCompilerPluginDiagnostic4::class
 }
diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtCompilerPluginDiagnosticImpl.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtCompilerPluginDiagnosticImpl.kt
index 5420d891932..87b2679d149 100644
--- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtCompilerPluginDiagnosticImpl.kt
+++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtCompilerPluginDiagnosticImpl.kt
@@ -5,40 +5,41 @@
 
 package org.jetbrains.kotlin.analysis.api.fir.diagnostics
 
+import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken
 import org.jetbrains.kotlin.diagnostics.*
 
 internal class KtCompilerPluginDiagnostic0Impl(
-    override val firDiagnostic: KtPsiSimpleDiagnostic,
-    override val token: KtLifetimeToken
-) : KtCompilerPluginDiagnostic0()
+    firDiagnostic: KtPsiSimpleDiagnostic,
+    token: KtLifetimeToken
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtCompilerPluginDiagnostic0
 
 internal class KtCompilerPluginDiagnostic1Impl(
-    override val firDiagnostic: KtPsiDiagnosticWithParameters1<*>,
-    override val token: KtLifetimeToken,
+    firDiagnostic: KtPsiDiagnosticWithParameters1<*>,
+    token: KtLifetimeToken,
     override val parameter1: Any?
-) : KtCompilerPluginDiagnostic1()
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtCompilerPluginDiagnostic1
 
 internal class KtCompilerPluginDiagnostic2Impl(
-    override val firDiagnostic: KtPsiDiagnosticWithParameters2<*, *>,
-    override val token: KtLifetimeToken,
+    firDiagnostic: KtPsiDiagnosticWithParameters2<*, *>,
+    token: KtLifetimeToken,
     override val parameter1: Any?,
     override val parameter2: Any?
-) : KtCompilerPluginDiagnostic2()
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtCompilerPluginDiagnostic2
 
 internal class KtCompilerPluginDiagnostic3Impl(
-    override val firDiagnostic: KtPsiDiagnosticWithParameters3<*, *, *>,
-    override val token: KtLifetimeToken,
+    firDiagnostic: KtPsiDiagnosticWithParameters3<*, *, *>,
+    token: KtLifetimeToken,
     override val parameter1: Any?,
     override val parameter2: Any?,
     override val parameter3: Any?
-) : KtCompilerPluginDiagnostic3()
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtCompilerPluginDiagnostic3
 
 internal class KtCompilerPluginDiagnostic4Impl(
-    override val firDiagnostic: KtPsiDiagnosticWithParameters4<*, *, *, *>,
-    override val token: KtLifetimeToken,
+    firDiagnostic: KtPsiDiagnosticWithParameters4<*, *, *, *>,
+    token: KtLifetimeToken,
     override val parameter1: Any?,
     override val parameter2: Any?,
     override val parameter3: Any?,
     override val parameter4: Any?
-) : KtCompilerPluginDiagnostic4()
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtCompilerPluginDiagnostic4
diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnostics.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnostics.kt
index caa404c7ff0..5bb244e650f 100644
--- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnostics.kt
+++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnostics.kt
@@ -89,3478 +89,3478 @@ import org.jetbrains.kotlin.types.Variance
  * DO NOT MODIFY IT MANUALLY
  */
 
-sealed class KtFirDiagnostic<PSI : PsiElement> : KtDiagnosticWithPsi<PSI> {
-    abstract class Unsupported : KtFirDiagnostic<PsiElement>() {
+sealed interface KtFirDiagnostic<PSI : PsiElement> : KtDiagnosticWithPsi<PSI> {
+    interface Unsupported : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = Unsupported::class
-        abstract val unsupported: String
+        val unsupported: String
     }
 
-    abstract class UnsupportedFeature : KtFirDiagnostic<PsiElement>() {
+    interface UnsupportedFeature : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = UnsupportedFeature::class
-        abstract val unsupportedFeature: Pair<LanguageFeature, LanguageVersionSettings>
+        val unsupportedFeature: Pair<LanguageFeature, LanguageVersionSettings>
     }
 
-    abstract class NewInferenceError : KtFirDiagnostic<PsiElement>() {
+    interface NewInferenceError : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = NewInferenceError::class
-        abstract val error: String
+        val error: String
     }
 
-    abstract class OtherError : KtFirDiagnostic<PsiElement>() {
+    interface OtherError : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = OtherError::class
     }
 
-    abstract class IllegalConstExpression : KtFirDiagnostic<PsiElement>() {
+    interface IllegalConstExpression : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = IllegalConstExpression::class
     }
 
-    abstract class IllegalUnderscore : KtFirDiagnostic<PsiElement>() {
+    interface IllegalUnderscore : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = IllegalUnderscore::class
     }
 
-    abstract class ExpressionExpected : KtFirDiagnostic<PsiElement>() {
+    interface ExpressionExpected : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = ExpressionExpected::class
     }
 
-    abstract class AssignmentInExpressionContext : KtFirDiagnostic<KtBinaryExpression>() {
+    interface AssignmentInExpressionContext : KtFirDiagnostic<KtBinaryExpression> {
         override val diagnosticClass get() = AssignmentInExpressionContext::class
     }
 
-    abstract class BreakOrContinueOutsideALoop : KtFirDiagnostic<PsiElement>() {
+    interface BreakOrContinueOutsideALoop : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = BreakOrContinueOutsideALoop::class
     }
 
-    abstract class NotALoopLabel : KtFirDiagnostic<PsiElement>() {
+    interface NotALoopLabel : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = NotALoopLabel::class
     }
 
-    abstract class BreakOrContinueJumpsAcrossFunctionBoundary : KtFirDiagnostic<KtExpressionWithLabel>() {
+    interface BreakOrContinueJumpsAcrossFunctionBoundary : KtFirDiagnostic<KtExpressionWithLabel> {
         override val diagnosticClass get() = BreakOrContinueJumpsAcrossFunctionBoundary::class
     }
 
-    abstract class VariableExpected : KtFirDiagnostic<PsiElement>() {
+    interface VariableExpected : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = VariableExpected::class
     }
 
-    abstract class DelegationInInterface : KtFirDiagnostic<PsiElement>() {
+    interface DelegationInInterface : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = DelegationInInterface::class
     }
 
-    abstract class DelegationNotToInterface : KtFirDiagnostic<PsiElement>() {
+    interface DelegationNotToInterface : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = DelegationNotToInterface::class
     }
 
-    abstract class NestedClassNotAllowed : KtFirDiagnostic<KtNamedDeclaration>() {
+    interface NestedClassNotAllowed : KtFirDiagnostic<KtNamedDeclaration> {
         override val diagnosticClass get() = NestedClassNotAllowed::class
-        abstract val declaration: String
+        val declaration: String
     }
 
-    abstract class IncorrectCharacterLiteral : KtFirDiagnostic<PsiElement>() {
+    interface IncorrectCharacterLiteral : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = IncorrectCharacterLiteral::class
     }
 
-    abstract class EmptyCharacterLiteral : KtFirDiagnostic<PsiElement>() {
+    interface EmptyCharacterLiteral : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = EmptyCharacterLiteral::class
     }
 
-    abstract class TooManyCharactersInCharacterLiteral : KtFirDiagnostic<PsiElement>() {
+    interface TooManyCharactersInCharacterLiteral : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = TooManyCharactersInCharacterLiteral::class
     }
 
-    abstract class IllegalEscape : KtFirDiagnostic<PsiElement>() {
+    interface IllegalEscape : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = IllegalEscape::class
     }
 
-    abstract class IntLiteralOutOfRange : KtFirDiagnostic<PsiElement>() {
+    interface IntLiteralOutOfRange : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = IntLiteralOutOfRange::class
     }
 
-    abstract class FloatLiteralOutOfRange : KtFirDiagnostic<PsiElement>() {
+    interface FloatLiteralOutOfRange : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = FloatLiteralOutOfRange::class
     }
 
-    abstract class WrongLongSuffix : KtFirDiagnostic<KtElement>() {
+    interface WrongLongSuffix : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = WrongLongSuffix::class
     }
 
-    abstract class UnsignedLiteralWithoutDeclarationsOnClasspath : KtFirDiagnostic<KtElement>() {
+    interface UnsignedLiteralWithoutDeclarationsOnClasspath : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = UnsignedLiteralWithoutDeclarationsOnClasspath::class
     }
 
-    abstract class DivisionByZero : KtFirDiagnostic<KtExpression>() {
+    interface DivisionByZero : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = DivisionByZero::class
     }
 
-    abstract class ValOrVarOnLoopParameter : KtFirDiagnostic<KtParameter>() {
+    interface ValOrVarOnLoopParameter : KtFirDiagnostic<KtParameter> {
         override val diagnosticClass get() = ValOrVarOnLoopParameter::class
-        abstract val valOrVar: KtKeywordToken
+        val valOrVar: KtKeywordToken
     }
 
-    abstract class ValOrVarOnFunParameter : KtFirDiagnostic<KtParameter>() {
+    interface ValOrVarOnFunParameter : KtFirDiagnostic<KtParameter> {
         override val diagnosticClass get() = ValOrVarOnFunParameter::class
-        abstract val valOrVar: KtKeywordToken
+        val valOrVar: KtKeywordToken
     }
 
-    abstract class ValOrVarOnCatchParameter : KtFirDiagnostic<KtParameter>() {
+    interface ValOrVarOnCatchParameter : KtFirDiagnostic<KtParameter> {
         override val diagnosticClass get() = ValOrVarOnCatchParameter::class
-        abstract val valOrVar: KtKeywordToken
+        val valOrVar: KtKeywordToken
     }
 
-    abstract class ValOrVarOnSecondaryConstructorParameter : KtFirDiagnostic<KtParameter>() {
+    interface ValOrVarOnSecondaryConstructorParameter : KtFirDiagnostic<KtParameter> {
         override val diagnosticClass get() = ValOrVarOnSecondaryConstructorParameter::class
-        abstract val valOrVar: KtKeywordToken
+        val valOrVar: KtKeywordToken
     }
 
-    abstract class InvisibleSetter : KtFirDiagnostic<PsiElement>() {
+    interface InvisibleSetter : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = InvisibleSetter::class
-        abstract val property: KtVariableSymbol
-        abstract val visibility: Visibility
-        abstract val callableId: CallableId
+        val property: KtVariableSymbol
+        val visibility: Visibility
+        val callableId: CallableId
     }
 
-    abstract class InvisibleReference : KtFirDiagnostic<PsiElement>() {
+    interface InvisibleReference : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = InvisibleReference::class
-        abstract val reference: KtSymbol
+        val reference: KtSymbol
     }
 
-    abstract class UnresolvedReference : KtFirDiagnostic<PsiElement>() {
+    interface UnresolvedReference : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = UnresolvedReference::class
-        abstract val reference: String
+        val reference: String
     }
 
-    abstract class UnresolvedLabel : KtFirDiagnostic<PsiElement>() {
+    interface UnresolvedLabel : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = UnresolvedLabel::class
     }
 
-    abstract class DeserializationError : KtFirDiagnostic<PsiElement>() {
+    interface DeserializationError : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = DeserializationError::class
     }
 
-    abstract class ErrorFromJavaResolution : KtFirDiagnostic<PsiElement>() {
+    interface ErrorFromJavaResolution : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = ErrorFromJavaResolution::class
     }
 
-    abstract class MissingStdlibClass : KtFirDiagnostic<PsiElement>() {
+    interface MissingStdlibClass : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = MissingStdlibClass::class
     }
 
-    abstract class NoThis : KtFirDiagnostic<PsiElement>() {
+    interface NoThis : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = NoThis::class
     }
 
-    abstract class DeprecationError : KtFirDiagnostic<PsiElement>() {
+    interface DeprecationError : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = DeprecationError::class
-        abstract val reference: KtSymbol
-        abstract val message: String
+        val reference: KtSymbol
+        val message: String
     }
 
-    abstract class Deprecation : KtFirDiagnostic<PsiElement>() {
+    interface Deprecation : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = Deprecation::class
-        abstract val reference: KtSymbol
-        abstract val message: String
+        val reference: KtSymbol
+        val message: String
     }
 
-    abstract class TypealiasExpansionDeprecationError : KtFirDiagnostic<PsiElement>() {
+    interface TypealiasExpansionDeprecationError : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = TypealiasExpansionDeprecationError::class
-        abstract val alias: KtSymbol
-        abstract val reference: KtSymbol
-        abstract val message: String
+        val alias: KtSymbol
+        val reference: KtSymbol
+        val message: String
     }
 
-    abstract class TypealiasExpansionDeprecation : KtFirDiagnostic<PsiElement>() {
+    interface TypealiasExpansionDeprecation : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = TypealiasExpansionDeprecation::class
-        abstract val alias: KtSymbol
-        abstract val reference: KtSymbol
-        abstract val message: String
+        val alias: KtSymbol
+        val reference: KtSymbol
+        val message: String
     }
 
-    abstract class ApiNotAvailable : KtFirDiagnostic<PsiElement>() {
+    interface ApiNotAvailable : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = ApiNotAvailable::class
-        abstract val sinceKotlinVersion: ApiVersion
-        abstract val currentVersion: ApiVersion
+        val sinceKotlinVersion: ApiVersion
+        val currentVersion: ApiVersion
     }
 
-    abstract class UnresolvedReferenceWrongReceiver : KtFirDiagnostic<PsiElement>() {
+    interface UnresolvedReferenceWrongReceiver : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = UnresolvedReferenceWrongReceiver::class
-        abstract val candidates: List<KtSymbol>
+        val candidates: List<KtSymbol>
     }
 
-    abstract class UnresolvedImport : KtFirDiagnostic<PsiElement>() {
+    interface UnresolvedImport : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = UnresolvedImport::class
-        abstract val reference: String
+        val reference: String
     }
 
-    abstract class CreatingAnInstanceOfAbstractClass : KtFirDiagnostic<KtExpression>() {
+    interface CreatingAnInstanceOfAbstractClass : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = CreatingAnInstanceOfAbstractClass::class
     }
 
-    abstract class FunctionCallExpected : KtFirDiagnostic<PsiElement>() {
+    interface FunctionCallExpected : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = FunctionCallExpected::class
-        abstract val functionName: String
-        abstract val hasValueParameters: Boolean
+        val functionName: String
+        val hasValueParameters: Boolean
     }
 
-    abstract class IllegalSelector : KtFirDiagnostic<PsiElement>() {
+    interface IllegalSelector : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = IllegalSelector::class
     }
 
-    abstract class NoReceiverAllowed : KtFirDiagnostic<PsiElement>() {
+    interface NoReceiverAllowed : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = NoReceiverAllowed::class
     }
 
-    abstract class FunctionExpected : KtFirDiagnostic<PsiElement>() {
+    interface FunctionExpected : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = FunctionExpected::class
-        abstract val expression: String
-        abstract val type: KtType
+        val expression: String
+        val type: KtType
     }
 
-    abstract class ResolutionToClassifier : KtFirDiagnostic<PsiElement>() {
+    interface ResolutionToClassifier : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = ResolutionToClassifier::class
-        abstract val classSymbol: KtClassLikeSymbol
+        val classSymbol: KtClassLikeSymbol
     }
 
-    abstract class AmbiguousAlteredAssign : KtFirDiagnostic<PsiElement>() {
+    interface AmbiguousAlteredAssign : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = AmbiguousAlteredAssign::class
-        abstract val altererNames: List<String?>
+        val altererNames: List<String?>
     }
 
-    abstract class ForbiddenBinaryMod : KtFirDiagnostic<PsiElement>() {
+    interface ForbiddenBinaryMod : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = ForbiddenBinaryMod::class
-        abstract val forbiddenFunction: KtSymbol
-        abstract val suggestedFunction: String
+        val forbiddenFunction: KtSymbol
+        val suggestedFunction: String
     }
 
-    abstract class DeprecatedBinaryMod : KtFirDiagnostic<PsiElement>() {
+    interface DeprecatedBinaryMod : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = DeprecatedBinaryMod::class
-        abstract val forbiddenFunction: KtSymbol
-        abstract val suggestedFunction: String
+        val forbiddenFunction: KtSymbol
+        val suggestedFunction: String
     }
 
-    abstract class SuperIsNotAnExpression : KtFirDiagnostic<PsiElement>() {
+    interface SuperIsNotAnExpression : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = SuperIsNotAnExpression::class
     }
 
-    abstract class SuperNotAvailable : KtFirDiagnostic<PsiElement>() {
+    interface SuperNotAvailable : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = SuperNotAvailable::class
     }
 
-    abstract class AbstractSuperCall : KtFirDiagnostic<PsiElement>() {
+    interface AbstractSuperCall : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = AbstractSuperCall::class
     }
 
-    abstract class AbstractSuperCallWarning : KtFirDiagnostic<PsiElement>() {
+    interface AbstractSuperCallWarning : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = AbstractSuperCallWarning::class
     }
 
-    abstract class InstanceAccessBeforeSuperCall : KtFirDiagnostic<PsiElement>() {
+    interface InstanceAccessBeforeSuperCall : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = InstanceAccessBeforeSuperCall::class
-        abstract val target: String
+        val target: String
     }
 
-    abstract class SuperCallWithDefaultParameters : KtFirDiagnostic<PsiElement>() {
+    interface SuperCallWithDefaultParameters : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = SuperCallWithDefaultParameters::class
-        abstract val name: String
+        val name: String
     }
 
-    abstract class InterfaceCantCallDefaultMethodViaSuper : KtFirDiagnostic<PsiElement>() {
+    interface InterfaceCantCallDefaultMethodViaSuper : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = InterfaceCantCallDefaultMethodViaSuper::class
     }
 
-    abstract class NotASupertype : KtFirDiagnostic<PsiElement>() {
+    interface NotASupertype : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = NotASupertype::class
     }
 
-    abstract class TypeArgumentsRedundantInSuperQualifier : KtFirDiagnostic<KtElement>() {
+    interface TypeArgumentsRedundantInSuperQualifier : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = TypeArgumentsRedundantInSuperQualifier::class
     }
 
-    abstract class SuperclassNotAccessibleFromInterface : KtFirDiagnostic<PsiElement>() {
+    interface SuperclassNotAccessibleFromInterface : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = SuperclassNotAccessibleFromInterface::class
     }
 
-    abstract class QualifiedSupertypeExtendedByOtherSupertype : KtFirDiagnostic<KtTypeReference>() {
+    interface QualifiedSupertypeExtendedByOtherSupertype : KtFirDiagnostic<KtTypeReference> {
         override val diagnosticClass get() = QualifiedSupertypeExtendedByOtherSupertype::class
-        abstract val otherSuperType: KtSymbol
+        val otherSuperType: KtSymbol
     }
 
-    abstract class SupertypeInitializedInInterface : KtFirDiagnostic<KtTypeReference>() {
+    interface SupertypeInitializedInInterface : KtFirDiagnostic<KtTypeReference> {
         override val diagnosticClass get() = SupertypeInitializedInInterface::class
     }
 
-    abstract class InterfaceWithSuperclass : KtFirDiagnostic<KtTypeReference>() {
+    interface InterfaceWithSuperclass : KtFirDiagnostic<KtTypeReference> {
         override val diagnosticClass get() = InterfaceWithSuperclass::class
     }
 
-    abstract class FinalSupertype : KtFirDiagnostic<KtTypeReference>() {
+    interface FinalSupertype : KtFirDiagnostic<KtTypeReference> {
         override val diagnosticClass get() = FinalSupertype::class
     }
 
-    abstract class ClassCannotBeExtendedDirectly : KtFirDiagnostic<KtTypeReference>() {
+    interface ClassCannotBeExtendedDirectly : KtFirDiagnostic<KtTypeReference> {
         override val diagnosticClass get() = ClassCannotBeExtendedDirectly::class
-        abstract val classSymbol: KtClassLikeSymbol
+        val classSymbol: KtClassLikeSymbol
     }
 
-    abstract class SupertypeIsExtensionFunctionType : KtFirDiagnostic<KtTypeReference>() {
+    interface SupertypeIsExtensionFunctionType : KtFirDiagnostic<KtTypeReference> {
         override val diagnosticClass get() = SupertypeIsExtensionFunctionType::class
     }
 
-    abstract class SingletonInSupertype : KtFirDiagnostic<KtTypeReference>() {
+    interface SingletonInSupertype : KtFirDiagnostic<KtTypeReference> {
         override val diagnosticClass get() = SingletonInSupertype::class
     }
 
-    abstract class NullableSupertype : KtFirDiagnostic<KtTypeReference>() {
+    interface NullableSupertype : KtFirDiagnostic<KtTypeReference> {
         override val diagnosticClass get() = NullableSupertype::class
     }
 
-    abstract class ManyClassesInSupertypeList : KtFirDiagnostic<KtTypeReference>() {
+    interface ManyClassesInSupertypeList : KtFirDiagnostic<KtTypeReference> {
         override val diagnosticClass get() = ManyClassesInSupertypeList::class
     }
 
-    abstract class SupertypeAppearsTwice : KtFirDiagnostic<KtTypeReference>() {
+    interface SupertypeAppearsTwice : KtFirDiagnostic<KtTypeReference> {
         override val diagnosticClass get() = SupertypeAppearsTwice::class
     }
 
-    abstract class ClassInSupertypeForEnum : KtFirDiagnostic<KtTypeReference>() {
+    interface ClassInSupertypeForEnum : KtFirDiagnostic<KtTypeReference> {
         override val diagnosticClass get() = ClassInSupertypeForEnum::class
     }
 
-    abstract class SealedSupertype : KtFirDiagnostic<KtTypeReference>() {
+    interface SealedSupertype : KtFirDiagnostic<KtTypeReference> {
         override val diagnosticClass get() = SealedSupertype::class
     }
 
-    abstract class SealedSupertypeInLocalClass : KtFirDiagnostic<KtTypeReference>() {
+    interface SealedSupertypeInLocalClass : KtFirDiagnostic<KtTypeReference> {
         override val diagnosticClass get() = SealedSupertypeInLocalClass::class
-        abstract val declarationType: String
-        abstract val sealedClassKind: ClassKind
+        val declarationType: String
+        val sealedClassKind: ClassKind
     }
 
-    abstract class SealedInheritorInDifferentPackage : KtFirDiagnostic<KtTypeReference>() {
+    interface SealedInheritorInDifferentPackage : KtFirDiagnostic<KtTypeReference> {
         override val diagnosticClass get() = SealedInheritorInDifferentPackage::class
     }
 
-    abstract class SealedInheritorInDifferentModule : KtFirDiagnostic<KtTypeReference>() {
+    interface SealedInheritorInDifferentModule : KtFirDiagnostic<KtTypeReference> {
         override val diagnosticClass get() = SealedInheritorInDifferentModule::class
     }
 
-    abstract class ClassInheritsJavaSealedClass : KtFirDiagnostic<KtTypeReference>() {
+    interface ClassInheritsJavaSealedClass : KtFirDiagnostic<KtTypeReference> {
         override val diagnosticClass get() = ClassInheritsJavaSealedClass::class
     }
 
-    abstract class SupertypeNotAClassOrInterface : KtFirDiagnostic<KtElement>() {
+    interface SupertypeNotAClassOrInterface : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = SupertypeNotAClassOrInterface::class
-        abstract val reason: String
+        val reason: String
     }
 
-    abstract class CyclicInheritanceHierarchy : KtFirDiagnostic<PsiElement>() {
+    interface CyclicInheritanceHierarchy : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = CyclicInheritanceHierarchy::class
     }
 
-    abstract class ExpandedTypeCannotBeInherited : KtFirDiagnostic<KtTypeReference>() {
+    interface ExpandedTypeCannotBeInherited : KtFirDiagnostic<KtTypeReference> {
         override val diagnosticClass get() = ExpandedTypeCannotBeInherited::class
-        abstract val type: KtType
+        val type: KtType
     }
 
-    abstract class ProjectionInImmediateArgumentToSupertype : KtFirDiagnostic<KtModifierListOwner>() {
+    interface ProjectionInImmediateArgumentToSupertype : KtFirDiagnostic<KtModifierListOwner> {
         override val diagnosticClass get() = ProjectionInImmediateArgumentToSupertype::class
     }
 
-    abstract class InconsistentTypeParameterValues : KtFirDiagnostic<KtClass>() {
+    interface InconsistentTypeParameterValues : KtFirDiagnostic<KtClass> {
         override val diagnosticClass get() = InconsistentTypeParameterValues::class
-        abstract val typeParameter: KtTypeParameterSymbol
-        abstract val type: KtClassLikeSymbol
-        abstract val bounds: List<KtType>
+        val typeParameter: KtTypeParameterSymbol
+        val type: KtClassLikeSymbol
+        val bounds: List<KtType>
     }
 
-    abstract class InconsistentTypeParameterBounds : KtFirDiagnostic<PsiElement>() {
+    interface InconsistentTypeParameterBounds : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = InconsistentTypeParameterBounds::class
-        abstract val typeParameter: KtTypeParameterSymbol
-        abstract val type: KtClassLikeSymbol
-        abstract val bounds: List<KtType>
+        val typeParameter: KtTypeParameterSymbol
+        val type: KtClassLikeSymbol
+        val bounds: List<KtType>
     }
 
-    abstract class AmbiguousSuper : KtFirDiagnostic<KtSuperExpression>() {
+    interface AmbiguousSuper : KtFirDiagnostic<KtSuperExpression> {
         override val diagnosticClass get() = AmbiguousSuper::class
-        abstract val candidates: List<KtType>
+        val candidates: List<KtType>
     }
 
-    abstract class WrongMultipleInheritance : KtFirDiagnostic<KtElement>() {
+    interface WrongMultipleInheritance : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = WrongMultipleInheritance::class
-        abstract val symbol: KtCallableSymbol
+        val symbol: KtCallableSymbol
     }
 
-    abstract class ConstructorInObject : KtFirDiagnostic<KtDeclaration>() {
+    interface ConstructorInObject : KtFirDiagnostic<KtDeclaration> {
         override val diagnosticClass get() = ConstructorInObject::class
     }
 
-    abstract class ConstructorInInterface : KtFirDiagnostic<KtDeclaration>() {
+    interface ConstructorInInterface : KtFirDiagnostic<KtDeclaration> {
         override val diagnosticClass get() = ConstructorInInterface::class
     }
 
-    abstract class NonPrivateConstructorInEnum : KtFirDiagnostic<PsiElement>() {
+    interface NonPrivateConstructorInEnum : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = NonPrivateConstructorInEnum::class
     }
 
-    abstract class NonPrivateOrProtectedConstructorInSealed : KtFirDiagnostic<PsiElement>() {
+    interface NonPrivateOrProtectedConstructorInSealed : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = NonPrivateOrProtectedConstructorInSealed::class
     }
 
-    abstract class CyclicConstructorDelegationCall : KtFirDiagnostic<PsiElement>() {
+    interface CyclicConstructorDelegationCall : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = CyclicConstructorDelegationCall::class
     }
 
-    abstract class PrimaryConstructorDelegationCallExpected : KtFirDiagnostic<PsiElement>() {
+    interface PrimaryConstructorDelegationCallExpected : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = PrimaryConstructorDelegationCallExpected::class
     }
 
-    abstract class SupertypeNotInitialized : KtFirDiagnostic<KtTypeReference>() {
+    interface SupertypeNotInitialized : KtFirDiagnostic<KtTypeReference> {
         override val diagnosticClass get() = SupertypeNotInitialized::class
     }
 
-    abstract class SupertypeInitializedWithoutPrimaryConstructor : KtFirDiagnostic<PsiElement>() {
+    interface SupertypeInitializedWithoutPrimaryConstructor : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = SupertypeInitializedWithoutPrimaryConstructor::class
     }
 
-    abstract class DelegationSuperCallInEnumConstructor : KtFirDiagnostic<PsiElement>() {
+    interface DelegationSuperCallInEnumConstructor : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = DelegationSuperCallInEnumConstructor::class
     }
 
-    abstract class PrimaryConstructorRequiredForDataClass : KtFirDiagnostic<KtNamedDeclaration>() {
+    interface PrimaryConstructorRequiredForDataClass : KtFirDiagnostic<KtNamedDeclaration> {
         override val diagnosticClass get() = PrimaryConstructorRequiredForDataClass::class
     }
 
-    abstract class ExplicitDelegationCallRequired : KtFirDiagnostic<PsiElement>() {
+    interface ExplicitDelegationCallRequired : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = ExplicitDelegationCallRequired::class
     }
 
-    abstract class SealedClassConstructorCall : KtFirDiagnostic<PsiElement>() {
+    interface SealedClassConstructorCall : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = SealedClassConstructorCall::class
     }
 
-    abstract class DataClassWithoutParameters : KtFirDiagnostic<KtPrimaryConstructor>() {
+    interface DataClassWithoutParameters : KtFirDiagnostic<KtPrimaryConstructor> {
         override val diagnosticClass get() = DataClassWithoutParameters::class
     }
 
-    abstract class DataClassVarargParameter : KtFirDiagnostic<KtParameter>() {
+    interface DataClassVarargParameter : KtFirDiagnostic<KtParameter> {
         override val diagnosticClass get() = DataClassVarargParameter::class
     }
 
-    abstract class DataClassNotPropertyParameter : KtFirDiagnostic<KtParameter>() {
+    interface DataClassNotPropertyParameter : KtFirDiagnostic<KtParameter> {
         override val diagnosticClass get() = DataClassNotPropertyParameter::class
     }
 
-    abstract class AnnotationArgumentKclassLiteralOfTypeParameterError : KtFirDiagnostic<KtExpression>() {
+    interface AnnotationArgumentKclassLiteralOfTypeParameterError : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = AnnotationArgumentKclassLiteralOfTypeParameterError::class
     }
 
-    abstract class AnnotationArgumentMustBeConst : KtFirDiagnostic<KtExpression>() {
+    interface AnnotationArgumentMustBeConst : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = AnnotationArgumentMustBeConst::class
     }
 
-    abstract class AnnotationArgumentMustBeEnumConst : KtFirDiagnostic<KtExpression>() {
+    interface AnnotationArgumentMustBeEnumConst : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = AnnotationArgumentMustBeEnumConst::class
     }
 
-    abstract class AnnotationArgumentMustBeKclassLiteral : KtFirDiagnostic<KtExpression>() {
+    interface AnnotationArgumentMustBeKclassLiteral : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = AnnotationArgumentMustBeKclassLiteral::class
     }
 
-    abstract class AnnotationClassMember : KtFirDiagnostic<PsiElement>() {
+    interface AnnotationClassMember : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = AnnotationClassMember::class
     }
 
-    abstract class AnnotationParameterDefaultValueMustBeConstant : KtFirDiagnostic<KtExpression>() {
+    interface AnnotationParameterDefaultValueMustBeConstant : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = AnnotationParameterDefaultValueMustBeConstant::class
     }
 
-    abstract class InvalidTypeOfAnnotationMember : KtFirDiagnostic<KtTypeReference>() {
+    interface InvalidTypeOfAnnotationMember : KtFirDiagnostic<KtTypeReference> {
         override val diagnosticClass get() = InvalidTypeOfAnnotationMember::class
     }
 
-    abstract class LocalAnnotationClassError : KtFirDiagnostic<KtClassOrObject>() {
+    interface LocalAnnotationClassError : KtFirDiagnostic<KtClassOrObject> {
         override val diagnosticClass get() = LocalAnnotationClassError::class
     }
 
-    abstract class MissingValOnAnnotationParameter : KtFirDiagnostic<KtParameter>() {
+    interface MissingValOnAnnotationParameter : KtFirDiagnostic<KtParameter> {
         override val diagnosticClass get() = MissingValOnAnnotationParameter::class
     }
 
-    abstract class NonConstValUsedInConstantExpression : KtFirDiagnostic<KtExpression>() {
+    interface NonConstValUsedInConstantExpression : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = NonConstValUsedInConstantExpression::class
     }
 
-    abstract class CycleInAnnotationParameterError : KtFirDiagnostic<KtParameter>() {
+    interface CycleInAnnotationParameterError : KtFirDiagnostic<KtParameter> {
         override val diagnosticClass get() = CycleInAnnotationParameterError::class
     }
 
-    abstract class CycleInAnnotationParameterWarning : KtFirDiagnostic<KtParameter>() {
+    interface CycleInAnnotationParameterWarning : KtFirDiagnostic<KtParameter> {
         override val diagnosticClass get() = CycleInAnnotationParameterWarning::class
     }
 
-    abstract class AnnotationClassConstructorCall : KtFirDiagnostic<KtCallExpression>() {
+    interface AnnotationClassConstructorCall : KtFirDiagnostic<KtCallExpression> {
         override val diagnosticClass get() = AnnotationClassConstructorCall::class
     }
 
-    abstract class NotAnAnnotationClass : KtFirDiagnostic<PsiElement>() {
+    interface NotAnAnnotationClass : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = NotAnAnnotationClass::class
-        abstract val annotationName: String
+        val annotationName: String
     }
 
-    abstract class NullableTypeOfAnnotationMember : KtFirDiagnostic<KtTypeReference>() {
+    interface NullableTypeOfAnnotationMember : KtFirDiagnostic<KtTypeReference> {
         override val diagnosticClass get() = NullableTypeOfAnnotationMember::class
     }
 
-    abstract class VarAnnotationParameter : KtFirDiagnostic<KtParameter>() {
+    interface VarAnnotationParameter : KtFirDiagnostic<KtParameter> {
         override val diagnosticClass get() = VarAnnotationParameter::class
     }
 
-    abstract class SupertypesForAnnotationClass : KtFirDiagnostic<KtClass>() {
+    interface SupertypesForAnnotationClass : KtFirDiagnostic<KtClass> {
         override val diagnosticClass get() = SupertypesForAnnotationClass::class
     }
 
-    abstract class AnnotationUsedAsAnnotationArgument : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface AnnotationUsedAsAnnotationArgument : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = AnnotationUsedAsAnnotationArgument::class
     }
 
-    abstract class IllegalKotlinVersionStringValue : KtFirDiagnostic<KtExpression>() {
+    interface IllegalKotlinVersionStringValue : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = IllegalKotlinVersionStringValue::class
     }
 
-    abstract class NewerVersionInSinceKotlin : KtFirDiagnostic<KtExpression>() {
+    interface NewerVersionInSinceKotlin : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = NewerVersionInSinceKotlin::class
-        abstract val specifiedVersion: String
+        val specifiedVersion: String
     }
 
-    abstract class DeprecatedSinceKotlinWithUnorderedVersions : KtFirDiagnostic<PsiElement>() {
+    interface DeprecatedSinceKotlinWithUnorderedVersions : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = DeprecatedSinceKotlinWithUnorderedVersions::class
     }
 
-    abstract class DeprecatedSinceKotlinWithoutArguments : KtFirDiagnostic<PsiElement>() {
+    interface DeprecatedSinceKotlinWithoutArguments : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = DeprecatedSinceKotlinWithoutArguments::class
     }
 
-    abstract class DeprecatedSinceKotlinWithoutDeprecated : KtFirDiagnostic<PsiElement>() {
+    interface DeprecatedSinceKotlinWithoutDeprecated : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = DeprecatedSinceKotlinWithoutDeprecated::class
     }
 
-    abstract class DeprecatedSinceKotlinWithDeprecatedLevel : KtFirDiagnostic<PsiElement>() {
+    interface DeprecatedSinceKotlinWithDeprecatedLevel : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = DeprecatedSinceKotlinWithDeprecatedLevel::class
     }
 
-    abstract class DeprecatedSinceKotlinOutsideKotlinSubpackage : KtFirDiagnostic<PsiElement>() {
+    interface DeprecatedSinceKotlinOutsideKotlinSubpackage : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = DeprecatedSinceKotlinOutsideKotlinSubpackage::class
     }
 
-    abstract class OverrideDeprecation : KtFirDiagnostic<KtNamedDeclaration>() {
+    interface OverrideDeprecation : KtFirDiagnostic<KtNamedDeclaration> {
         override val diagnosticClass get() = OverrideDeprecation::class
-        abstract val overridenSymbol: KtSymbol
-        abstract val deprecationInfo: DeprecationInfo
+        val overridenSymbol: KtSymbol
+        val deprecationInfo: DeprecationInfo
     }
 
-    abstract class AnnotationOnSuperclassError : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface AnnotationOnSuperclassError : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = AnnotationOnSuperclassError::class
     }
 
-    abstract class AnnotationOnSuperclassWarning : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface AnnotationOnSuperclassWarning : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = AnnotationOnSuperclassWarning::class
     }
 
-    abstract class RestrictedRetentionForExpressionAnnotationError : KtFirDiagnostic<PsiElement>() {
+    interface RestrictedRetentionForExpressionAnnotationError : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = RestrictedRetentionForExpressionAnnotationError::class
     }
 
-    abstract class RestrictedRetentionForExpressionAnnotationWarning : KtFirDiagnostic<PsiElement>() {
+    interface RestrictedRetentionForExpressionAnnotationWarning : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = RestrictedRetentionForExpressionAnnotationWarning::class
     }
 
-    abstract class WrongAnnotationTarget : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface WrongAnnotationTarget : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = WrongAnnotationTarget::class
-        abstract val actualTarget: String
+        val actualTarget: String
     }
 
-    abstract class WrongAnnotationTargetWithUseSiteTarget : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface WrongAnnotationTargetWithUseSiteTarget : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = WrongAnnotationTargetWithUseSiteTarget::class
-        abstract val actualTarget: String
-        abstract val useSiteTarget: String
+        val actualTarget: String
+        val useSiteTarget: String
     }
 
-    abstract class InapplicableTargetOnProperty : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface InapplicableTargetOnProperty : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = InapplicableTargetOnProperty::class
-        abstract val useSiteDescription: String
+        val useSiteDescription: String
     }
 
-    abstract class InapplicableTargetOnPropertyWarning : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface InapplicableTargetOnPropertyWarning : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = InapplicableTargetOnPropertyWarning::class
-        abstract val useSiteDescription: String
+        val useSiteDescription: String
     }
 
-    abstract class InapplicableTargetPropertyImmutable : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface InapplicableTargetPropertyImmutable : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = InapplicableTargetPropertyImmutable::class
-        abstract val useSiteDescription: String
+        val useSiteDescription: String
     }
 
-    abstract class InapplicableTargetPropertyHasNoDelegate : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface InapplicableTargetPropertyHasNoDelegate : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = InapplicableTargetPropertyHasNoDelegate::class
     }
 
-    abstract class InapplicableTargetPropertyHasNoBackingField : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface InapplicableTargetPropertyHasNoBackingField : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = InapplicableTargetPropertyHasNoBackingField::class
     }
 
-    abstract class InapplicableParamTarget : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface InapplicableParamTarget : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = InapplicableParamTarget::class
     }
 
-    abstract class RedundantAnnotationTarget : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface RedundantAnnotationTarget : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = RedundantAnnotationTarget::class
-        abstract val useSiteDescription: String
+        val useSiteDescription: String
     }
 
-    abstract class InapplicableFileTarget : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface InapplicableFileTarget : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = InapplicableFileTarget::class
     }
 
-    abstract class RepeatedAnnotation : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface RepeatedAnnotation : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = RepeatedAnnotation::class
     }
 
-    abstract class RepeatedAnnotationWarning : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface RepeatedAnnotationWarning : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = RepeatedAnnotationWarning::class
     }
 
-    abstract class NotAClass : KtFirDiagnostic<PsiElement>() {
+    interface NotAClass : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = NotAClass::class
     }
 
-    abstract class WrongExtensionFunctionType : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface WrongExtensionFunctionType : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = WrongExtensionFunctionType::class
     }
 
-    abstract class WrongExtensionFunctionTypeWarning : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface WrongExtensionFunctionTypeWarning : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = WrongExtensionFunctionTypeWarning::class
     }
 
-    abstract class AnnotationInWhereClauseError : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface AnnotationInWhereClauseError : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = AnnotationInWhereClauseError::class
     }
 
-    abstract class PluginAnnotationAmbiguity : KtFirDiagnostic<PsiElement>() {
+    interface PluginAnnotationAmbiguity : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = PluginAnnotationAmbiguity::class
-        abstract val typeFromCompilerPhase: KtType
-        abstract val typeFromTypesPhase: KtType
+        val typeFromCompilerPhase: KtType
+        val typeFromTypesPhase: KtType
     }
 
-    abstract class AmbiguousAnnotationArgument : KtFirDiagnostic<PsiElement>() {
+    interface AmbiguousAnnotationArgument : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = AmbiguousAnnotationArgument::class
-        abstract val symbols: List<KtSymbol>
+        val symbols: List<KtSymbol>
     }
 
-    abstract class VolatileOnValue : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface VolatileOnValue : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = VolatileOnValue::class
     }
 
-    abstract class VolatileOnDelegate : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface VolatileOnDelegate : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = VolatileOnDelegate::class
     }
 
-    abstract class WrongJsQualifier : KtFirDiagnostic<KtElement>() {
+    interface WrongJsQualifier : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = WrongJsQualifier::class
     }
 
-    abstract class JsModuleProhibitedOnVar : KtFirDiagnostic<KtElement>() {
+    interface JsModuleProhibitedOnVar : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = JsModuleProhibitedOnVar::class
     }
 
-    abstract class JsModuleProhibitedOnNonNative : KtFirDiagnostic<KtElement>() {
+    interface JsModuleProhibitedOnNonNative : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = JsModuleProhibitedOnNonNative::class
     }
 
-    abstract class NestedJsModuleProhibited : KtFirDiagnostic<KtElement>() {
+    interface NestedJsModuleProhibited : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = NestedJsModuleProhibited::class
     }
 
-    abstract class RuntimeAnnotationNotSupported : KtFirDiagnostic<PsiElement>() {
+    interface RuntimeAnnotationNotSupported : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = RuntimeAnnotationNotSupported::class
     }
 
-    abstract class RuntimeAnnotationOnExternalDeclaration : KtFirDiagnostic<PsiElement>() {
+    interface RuntimeAnnotationOnExternalDeclaration : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = RuntimeAnnotationOnExternalDeclaration::class
     }
 
-    abstract class NativeAnnotationsAllowedOnlyOnMemberOrExtensionFun : KtFirDiagnostic<KtElement>() {
+    interface NativeAnnotationsAllowedOnlyOnMemberOrExtensionFun : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = NativeAnnotationsAllowedOnlyOnMemberOrExtensionFun::class
-        abstract val type: KtType
+        val type: KtType
     }
 
-    abstract class NativeIndexerKeyShouldBeStringOrNumber : KtFirDiagnostic<KtElement>() {
+    interface NativeIndexerKeyShouldBeStringOrNumber : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = NativeIndexerKeyShouldBeStringOrNumber::class
-        abstract val kind: String
+        val kind: String
     }
 
-    abstract class NativeIndexerWrongParameterCount : KtFirDiagnostic<KtElement>() {
+    interface NativeIndexerWrongParameterCount : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = NativeIndexerWrongParameterCount::class
-        abstract val parametersCount: Int
-        abstract val kind: String
+        val parametersCount: Int
+        val kind: String
     }
 
-    abstract class NativeIndexerCanNotHaveDefaultArguments : KtFirDiagnostic<KtElement>() {
+    interface NativeIndexerCanNotHaveDefaultArguments : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = NativeIndexerCanNotHaveDefaultArguments::class
-        abstract val kind: String
+        val kind: String
     }
 
-    abstract class NativeGetterReturnTypeShouldBeNullable : KtFirDiagnostic<KtDeclaration>() {
+    interface NativeGetterReturnTypeShouldBeNullable : KtFirDiagnostic<KtDeclaration> {
         override val diagnosticClass get() = NativeGetterReturnTypeShouldBeNullable::class
     }
 
-    abstract class NativeSetterWrongReturnType : KtFirDiagnostic<KtDeclaration>() {
+    interface NativeSetterWrongReturnType : KtFirDiagnostic<KtDeclaration> {
         override val diagnosticClass get() = NativeSetterWrongReturnType::class
     }
 
-    abstract class JsNameIsNotOnAllAccessors : KtFirDiagnostic<KtElement>() {
+    interface JsNameIsNotOnAllAccessors : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = JsNameIsNotOnAllAccessors::class
     }
 
-    abstract class JsNameProhibitedForNamedNative : KtFirDiagnostic<KtElement>() {
+    interface JsNameProhibitedForNamedNative : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = JsNameProhibitedForNamedNative::class
     }
 
-    abstract class JsNameProhibitedForOverride : KtFirDiagnostic<KtElement>() {
+    interface JsNameProhibitedForOverride : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = JsNameProhibitedForOverride::class
     }
 
-    abstract class JsNameOnPrimaryConstructorProhibited : KtFirDiagnostic<KtElement>() {
+    interface JsNameOnPrimaryConstructorProhibited : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = JsNameOnPrimaryConstructorProhibited::class
     }
 
-    abstract class JsNameOnAccessorAndProperty : KtFirDiagnostic<KtElement>() {
+    interface JsNameOnAccessorAndProperty : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = JsNameOnAccessorAndProperty::class
     }
 
-    abstract class JsNameProhibitedForExtensionProperty : KtFirDiagnostic<KtElement>() {
+    interface JsNameProhibitedForExtensionProperty : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = JsNameProhibitedForExtensionProperty::class
     }
 
-    abstract class OptInUsage : KtFirDiagnostic<PsiElement>() {
+    interface OptInUsage : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = OptInUsage::class
-        abstract val optInMarkerFqName: FqName
-        abstract val message: String
+        val optInMarkerFqName: FqName
+        val message: String
     }
 
-    abstract class OptInUsageError : KtFirDiagnostic<PsiElement>() {
+    interface OptInUsageError : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = OptInUsageError::class
-        abstract val optInMarkerFqName: FqName
-        abstract val message: String
+        val optInMarkerFqName: FqName
+        val message: String
     }
 
-    abstract class OptInOverride : KtFirDiagnostic<PsiElement>() {
+    interface OptInOverride : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = OptInOverride::class
-        abstract val optInMarkerFqName: FqName
-        abstract val message: String
+        val optInMarkerFqName: FqName
+        val message: String
     }
 
-    abstract class OptInOverrideError : KtFirDiagnostic<PsiElement>() {
+    interface OptInOverrideError : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = OptInOverrideError::class
-        abstract val optInMarkerFqName: FqName
-        abstract val message: String
+        val optInMarkerFqName: FqName
+        val message: String
     }
 
-    abstract class OptInIsNotEnabled : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface OptInIsNotEnabled : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = OptInIsNotEnabled::class
     }
 
-    abstract class OptInCanOnlyBeUsedAsAnnotation : KtFirDiagnostic<PsiElement>() {
+    interface OptInCanOnlyBeUsedAsAnnotation : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = OptInCanOnlyBeUsedAsAnnotation::class
     }
 
-    abstract class OptInMarkerCanOnlyBeUsedAsAnnotationOrArgumentInOptIn : KtFirDiagnostic<PsiElement>() {
+    interface OptInMarkerCanOnlyBeUsedAsAnnotationOrArgumentInOptIn : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = OptInMarkerCanOnlyBeUsedAsAnnotationOrArgumentInOptIn::class
     }
 
-    abstract class OptInWithoutArguments : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface OptInWithoutArguments : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = OptInWithoutArguments::class
     }
 
-    abstract class OptInArgumentIsNotMarker : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface OptInArgumentIsNotMarker : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = OptInArgumentIsNotMarker::class
-        abstract val notMarkerFqName: FqName
+        val notMarkerFqName: FqName
     }
 
-    abstract class OptInMarkerWithWrongTarget : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface OptInMarkerWithWrongTarget : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = OptInMarkerWithWrongTarget::class
-        abstract val target: String
+        val target: String
     }
 
-    abstract class OptInMarkerWithWrongRetention : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface OptInMarkerWithWrongRetention : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = OptInMarkerWithWrongRetention::class
     }
 
-    abstract class OptInMarkerOnWrongTarget : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface OptInMarkerOnWrongTarget : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = OptInMarkerOnWrongTarget::class
-        abstract val target: String
+        val target: String
     }
 
-    abstract class OptInMarkerOnOverride : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface OptInMarkerOnOverride : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = OptInMarkerOnOverride::class
     }
 
-    abstract class OptInMarkerOnOverrideWarning : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface OptInMarkerOnOverrideWarning : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = OptInMarkerOnOverrideWarning::class
     }
 
-    abstract class SubclassOptInInapplicable : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface SubclassOptInInapplicable : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = SubclassOptInInapplicable::class
-        abstract val target: String
+        val target: String
     }
 
-    abstract class ExposedTypealiasExpandedType : KtFirDiagnostic<KtNamedDeclaration>() {
+    interface ExposedTypealiasExpandedType : KtFirDiagnostic<KtNamedDeclaration> {
         override val diagnosticClass get() = ExposedTypealiasExpandedType::class
-        abstract val elementVisibility: EffectiveVisibility
-        abstract val restrictingDeclaration: KtSymbol
-        abstract val restrictingVisibility: EffectiveVisibility
+        val elementVisibility: EffectiveVisibility
+        val restrictingDeclaration: KtSymbol
+        val restrictingVisibility: EffectiveVisibility
     }
 
-    abstract class ExposedFunctionReturnType : KtFirDiagnostic<KtNamedDeclaration>() {
+    interface ExposedFunctionReturnType : KtFirDiagnostic<KtNamedDeclaration> {
         override val diagnosticClass get() = ExposedFunctionReturnType::class
-        abstract val elementVisibility: EffectiveVisibility
-        abstract val restrictingDeclaration: KtSymbol
-        abstract val restrictingVisibility: EffectiveVisibility
+        val elementVisibility: EffectiveVisibility
+        val restrictingDeclaration: KtSymbol
+        val restrictingVisibility: EffectiveVisibility
     }
 
-    abstract class ExposedReceiverType : KtFirDiagnostic<KtTypeReference>() {
+    interface ExposedReceiverType : KtFirDiagnostic<KtTypeReference> {
         override val diagnosticClass get() = ExposedReceiverType::class
-        abstract val elementVisibility: EffectiveVisibility
-        abstract val restrictingDeclaration: KtSymbol
-        abstract val restrictingVisibility: EffectiveVisibility
+        val elementVisibility: EffectiveVisibility
+        val restrictingDeclaration: KtSymbol
+        val restrictingVisibility: EffectiveVisibility
     }
 
-    abstract class ExposedPropertyType : KtFirDiagnostic<KtNamedDeclaration>() {
+    interface ExposedPropertyType : KtFirDiagnostic<KtNamedDeclaration> {
         override val diagnosticClass get() = ExposedPropertyType::class
-        abstract val elementVisibility: EffectiveVisibility
-        abstract val restrictingDeclaration: KtSymbol
-        abstract val restrictingVisibility: EffectiveVisibility
+        val elementVisibility: EffectiveVisibility
+        val restrictingDeclaration: KtSymbol
+        val restrictingVisibility: EffectiveVisibility
     }
 
-    abstract class ExposedPropertyTypeInConstructorError : KtFirDiagnostic<KtNamedDeclaration>() {
+    interface ExposedPropertyTypeInConstructorError : KtFirDiagnostic<KtNamedDeclaration> {
         override val diagnosticClass get() = ExposedPropertyTypeInConstructorError::class
-        abstract val elementVisibility: EffectiveVisibility
-        abstract val restrictingDeclaration: KtSymbol
-        abstract val restrictingVisibility: EffectiveVisibility
+        val elementVisibility: EffectiveVisibility
+        val restrictingDeclaration: KtSymbol
+        val restrictingVisibility: EffectiveVisibility
     }
 
-    abstract class ExposedPropertyTypeInConstructorWarning : KtFirDiagnostic<KtNamedDeclaration>() {
+    interface ExposedPropertyTypeInConstructorWarning : KtFirDiagnostic<KtNamedDeclaration> {
         override val diagnosticClass get() = ExposedPropertyTypeInConstructorWarning::class
-        abstract val elementVisibility: EffectiveVisibility
-        abstract val restrictingDeclaration: KtSymbol
-        abstract val restrictingVisibility: EffectiveVisibility
+        val elementVisibility: EffectiveVisibility
+        val restrictingDeclaration: KtSymbol
+        val restrictingVisibility: EffectiveVisibility
     }
 
-    abstract class ExposedParameterType : KtFirDiagnostic<KtParameter>() {
+    interface ExposedParameterType : KtFirDiagnostic<KtParameter> {
         override val diagnosticClass get() = ExposedParameterType::class
-        abstract val elementVisibility: EffectiveVisibility
-        abstract val restrictingDeclaration: KtSymbol
-        abstract val restrictingVisibility: EffectiveVisibility
+        val elementVisibility: EffectiveVisibility
+        val restrictingDeclaration: KtSymbol
+        val restrictingVisibility: EffectiveVisibility
     }
 
-    abstract class ExposedSuperInterface : KtFirDiagnostic<KtTypeReference>() {
+    interface ExposedSuperInterface : KtFirDiagnostic<KtTypeReference> {
         override val diagnosticClass get() = ExposedSuperInterface::class
-        abstract val elementVisibility: EffectiveVisibility
-        abstract val restrictingDeclaration: KtSymbol
-        abstract val restrictingVisibility: EffectiveVisibility
+        val elementVisibility: EffectiveVisibility
+        val restrictingDeclaration: KtSymbol
+        val restrictingVisibility: EffectiveVisibility
     }
 
-    abstract class ExposedSuperClass : KtFirDiagnostic<KtTypeReference>() {
+    interface ExposedSuperClass : KtFirDiagnostic<KtTypeReference> {
         override val diagnosticClass get() = ExposedSuperClass::class
-        abstract val elementVisibility: EffectiveVisibility
-        abstract val restrictingDeclaration: KtSymbol
-        abstract val restrictingVisibility: EffectiveVisibility
+        val elementVisibility: EffectiveVisibility
+        val restrictingDeclaration: KtSymbol
+        val restrictingVisibility: EffectiveVisibility
     }
 
-    abstract class ExposedTypeParameterBound : KtFirDiagnostic<KtTypeReference>() {
+    interface ExposedTypeParameterBound : KtFirDiagnostic<KtTypeReference> {
         override val diagnosticClass get() = ExposedTypeParameterBound::class
-        abstract val elementVisibility: EffectiveVisibility
-        abstract val restrictingDeclaration: KtSymbol
-        abstract val restrictingVisibility: EffectiveVisibility
+        val elementVisibility: EffectiveVisibility
+        val restrictingDeclaration: KtSymbol
+        val restrictingVisibility: EffectiveVisibility
     }
 
-    abstract class InapplicableInfixModifier : KtFirDiagnostic<PsiElement>() {
+    interface InapplicableInfixModifier : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = InapplicableInfixModifier::class
     }
 
-    abstract class RepeatedModifier : KtFirDiagnostic<PsiElement>() {
+    interface RepeatedModifier : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = RepeatedModifier::class
-        abstract val modifier: KtModifierKeywordToken
+        val modifier: KtModifierKeywordToken
     }
 
-    abstract class RedundantModifier : KtFirDiagnostic<PsiElement>() {
+    interface RedundantModifier : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = RedundantModifier::class
-        abstract val redundantModifier: KtModifierKeywordToken
-        abstract val conflictingModifier: KtModifierKeywordToken
+        val redundantModifier: KtModifierKeywordToken
+        val conflictingModifier: KtModifierKeywordToken
     }
 
-    abstract class DeprecatedModifier : KtFirDiagnostic<PsiElement>() {
+    interface DeprecatedModifier : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = DeprecatedModifier::class
-        abstract val deprecatedModifier: KtModifierKeywordToken
-        abstract val actualModifier: KtModifierKeywordToken
+        val deprecatedModifier: KtModifierKeywordToken
+        val actualModifier: KtModifierKeywordToken
     }
 
-    abstract class DeprecatedModifierPair : KtFirDiagnostic<PsiElement>() {
+    interface DeprecatedModifierPair : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = DeprecatedModifierPair::class
-        abstract val deprecatedModifier: KtModifierKeywordToken
-        abstract val conflictingModifier: KtModifierKeywordToken
+        val deprecatedModifier: KtModifierKeywordToken
+        val conflictingModifier: KtModifierKeywordToken
     }
 
-    abstract class DeprecatedModifierForTarget : KtFirDiagnostic<PsiElement>() {
+    interface DeprecatedModifierForTarget : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = DeprecatedModifierForTarget::class
-        abstract val deprecatedModifier: KtModifierKeywordToken
-        abstract val target: String
+        val deprecatedModifier: KtModifierKeywordToken
+        val target: String
     }
 
-    abstract class RedundantModifierForTarget : KtFirDiagnostic<PsiElement>() {
+    interface RedundantModifierForTarget : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = RedundantModifierForTarget::class
-        abstract val redundantModifier: KtModifierKeywordToken
-        abstract val target: String
+        val redundantModifier: KtModifierKeywordToken
+        val target: String
     }
 
-    abstract class IncompatibleModifiers : KtFirDiagnostic<PsiElement>() {
+    interface IncompatibleModifiers : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = IncompatibleModifiers::class
-        abstract val modifier1: KtModifierKeywordToken
-        abstract val modifier2: KtModifierKeywordToken
+        val modifier1: KtModifierKeywordToken
+        val modifier2: KtModifierKeywordToken
     }
 
-    abstract class RedundantOpenInInterface : KtFirDiagnostic<KtModifierListOwner>() {
+    interface RedundantOpenInInterface : KtFirDiagnostic<KtModifierListOwner> {
         override val diagnosticClass get() = RedundantOpenInInterface::class
     }
 
-    abstract class WrongModifierTarget : KtFirDiagnostic<PsiElement>() {
+    interface WrongModifierTarget : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = WrongModifierTarget::class
-        abstract val modifier: KtModifierKeywordToken
-        abstract val target: String
+        val modifier: KtModifierKeywordToken
+        val target: String
     }
 
-    abstract class OperatorModifierRequired : KtFirDiagnostic<PsiElement>() {
+    interface OperatorModifierRequired : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = OperatorModifierRequired::class
-        abstract val functionSymbol: KtFunctionLikeSymbol
-        abstract val name: String
+        val functionSymbol: KtFunctionLikeSymbol
+        val name: String
     }
 
-    abstract class InfixModifierRequired : KtFirDiagnostic<PsiElement>() {
+    interface InfixModifierRequired : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = InfixModifierRequired::class
-        abstract val functionSymbol: KtFunctionLikeSymbol
+        val functionSymbol: KtFunctionLikeSymbol
     }
 
-    abstract class WrongModifierContainingDeclaration : KtFirDiagnostic<PsiElement>() {
+    interface WrongModifierContainingDeclaration : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = WrongModifierContainingDeclaration::class
-        abstract val modifier: KtModifierKeywordToken
-        abstract val target: String
+        val modifier: KtModifierKeywordToken
+        val target: String
     }
 
-    abstract class DeprecatedModifierContainingDeclaration : KtFirDiagnostic<PsiElement>() {
+    interface DeprecatedModifierContainingDeclaration : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = DeprecatedModifierContainingDeclaration::class
-        abstract val modifier: KtModifierKeywordToken
-        abstract val target: String
+        val modifier: KtModifierKeywordToken
+        val target: String
     }
 
-    abstract class InapplicableOperatorModifier : KtFirDiagnostic<PsiElement>() {
+    interface InapplicableOperatorModifier : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = InapplicableOperatorModifier::class
-        abstract val message: String
+        val message: String
     }
 
-    abstract class NoExplicitVisibilityInApiMode : KtFirDiagnostic<KtDeclaration>() {
+    interface NoExplicitVisibilityInApiMode : KtFirDiagnostic<KtDeclaration> {
         override val diagnosticClass get() = NoExplicitVisibilityInApiMode::class
     }
 
-    abstract class NoExplicitVisibilityInApiModeWarning : KtFirDiagnostic<KtDeclaration>() {
+    interface NoExplicitVisibilityInApiModeWarning : KtFirDiagnostic<KtDeclaration> {
         override val diagnosticClass get() = NoExplicitVisibilityInApiModeWarning::class
     }
 
-    abstract class NoExplicitReturnTypeInApiMode : KtFirDiagnostic<KtDeclaration>() {
+    interface NoExplicitReturnTypeInApiMode : KtFirDiagnostic<KtDeclaration> {
         override val diagnosticClass get() = NoExplicitReturnTypeInApiMode::class
     }
 
-    abstract class NoExplicitReturnTypeInApiModeWarning : KtFirDiagnostic<KtDeclaration>() {
+    interface NoExplicitReturnTypeInApiModeWarning : KtFirDiagnostic<KtDeclaration> {
         override val diagnosticClass get() = NoExplicitReturnTypeInApiModeWarning::class
     }
 
-    abstract class ValueClassNotTopLevel : KtFirDiagnostic<KtDeclaration>() {
+    interface ValueClassNotTopLevel : KtFirDiagnostic<KtDeclaration> {
         override val diagnosticClass get() = ValueClassNotTopLevel::class
     }
 
-    abstract class ValueClassNotFinal : KtFirDiagnostic<KtDeclaration>() {
+    interface ValueClassNotFinal : KtFirDiagnostic<KtDeclaration> {
         override val diagnosticClass get() = ValueClassNotFinal::class
     }
 
-    abstract class AbsenceOfPrimaryConstructorForValueClass : KtFirDiagnostic<KtDeclaration>() {
+    interface AbsenceOfPrimaryConstructorForValueClass : KtFirDiagnostic<KtDeclaration> {
         override val diagnosticClass get() = AbsenceOfPrimaryConstructorForValueClass::class
     }
 
-    abstract class InlineClassConstructorWrongParametersSize : KtFirDiagnostic<KtElement>() {
+    interface InlineClassConstructorWrongParametersSize : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = InlineClassConstructorWrongParametersSize::class
     }
 
-    abstract class ValueClassEmptyConstructor : KtFirDiagnostic<KtElement>() {
+    interface ValueClassEmptyConstructor : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = ValueClassEmptyConstructor::class
     }
 
-    abstract class ValueClassConstructorNotFinalReadOnlyParameter : KtFirDiagnostic<KtParameter>() {
+    interface ValueClassConstructorNotFinalReadOnlyParameter : KtFirDiagnostic<KtParameter> {
         override val diagnosticClass get() = ValueClassConstructorNotFinalReadOnlyParameter::class
     }
 
-    abstract class PropertyWithBackingFieldInsideValueClass : KtFirDiagnostic<KtProperty>() {
+    interface PropertyWithBackingFieldInsideValueClass : KtFirDiagnostic<KtProperty> {
         override val diagnosticClass get() = PropertyWithBackingFieldInsideValueClass::class
     }
 
-    abstract class DelegatedPropertyInsideValueClass : KtFirDiagnostic<PsiElement>() {
+    interface DelegatedPropertyInsideValueClass : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = DelegatedPropertyInsideValueClass::class
     }
 
-    abstract class ValueClassHasInapplicableParameterType : KtFirDiagnostic<KtTypeReference>() {
+    interface ValueClassHasInapplicableParameterType : KtFirDiagnostic<KtTypeReference> {
         override val diagnosticClass get() = ValueClassHasInapplicableParameterType::class
-        abstract val type: KtType
+        val type: KtType
     }
 
-    abstract class ValueClassCannotImplementInterfaceByDelegation : KtFirDiagnostic<PsiElement>() {
+    interface ValueClassCannotImplementInterfaceByDelegation : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = ValueClassCannotImplementInterfaceByDelegation::class
     }
 
-    abstract class ValueClassCannotExtendClasses : KtFirDiagnostic<KtTypeReference>() {
+    interface ValueClassCannotExtendClasses : KtFirDiagnostic<KtTypeReference> {
         override val diagnosticClass get() = ValueClassCannotExtendClasses::class
     }
 
-    abstract class ValueClassCannotBeRecursive : KtFirDiagnostic<KtTypeReference>() {
+    interface ValueClassCannotBeRecursive : KtFirDiagnostic<KtTypeReference> {
         override val diagnosticClass get() = ValueClassCannotBeRecursive::class
     }
 
-    abstract class MultiFieldValueClassPrimaryConstructorDefaultParameter : KtFirDiagnostic<KtExpression>() {
+    interface MultiFieldValueClassPrimaryConstructorDefaultParameter : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = MultiFieldValueClassPrimaryConstructorDefaultParameter::class
     }
 
-    abstract class SecondaryConstructorWithBodyInsideValueClass : KtFirDiagnostic<PsiElement>() {
+    interface SecondaryConstructorWithBodyInsideValueClass : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = SecondaryConstructorWithBodyInsideValueClass::class
     }
 
-    abstract class ReservedMemberInsideValueClass : KtFirDiagnostic<KtFunction>() {
+    interface ReservedMemberInsideValueClass : KtFirDiagnostic<KtFunction> {
         override val diagnosticClass get() = ReservedMemberInsideValueClass::class
-        abstract val name: String
+        val name: String
     }
 
-    abstract class TypeArgumentOnTypedValueClassEquals : KtFirDiagnostic<KtTypeReference>() {
+    interface TypeArgumentOnTypedValueClassEquals : KtFirDiagnostic<KtTypeReference> {
         override val diagnosticClass get() = TypeArgumentOnTypedValueClassEquals::class
     }
 
-    abstract class InnerClassInsideValueClass : KtFirDiagnostic<KtDeclaration>() {
+    interface InnerClassInsideValueClass : KtFirDiagnostic<KtDeclaration> {
         override val diagnosticClass get() = InnerClassInsideValueClass::class
     }
 
-    abstract class ValueClassCannotBeCloneable : KtFirDiagnostic<KtDeclaration>() {
+    interface ValueClassCannotBeCloneable : KtFirDiagnostic<KtDeclaration> {
         override val diagnosticClass get() = ValueClassCannotBeCloneable::class
     }
 
-    abstract class AnnotationOnIllegalMultiFieldValueClassTypedTarget : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface AnnotationOnIllegalMultiFieldValueClassTypedTarget : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = AnnotationOnIllegalMultiFieldValueClassTypedTarget::class
-        abstract val name: String
+        val name: String
     }
 
-    abstract class NoneApplicable : KtFirDiagnostic<PsiElement>() {
+    interface NoneApplicable : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = NoneApplicable::class
-        abstract val candidates: List<KtSymbol>
+        val candidates: List<KtSymbol>
     }
 
-    abstract class InapplicableCandidate : KtFirDiagnostic<PsiElement>() {
+    interface InapplicableCandidate : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = InapplicableCandidate::class
-        abstract val candidate: KtSymbol
+        val candidate: KtSymbol
     }
 
-    abstract class TypeMismatch : KtFirDiagnostic<PsiElement>() {
+    interface TypeMismatch : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = TypeMismatch::class
-        abstract val expectedType: KtType
-        abstract val actualType: KtType
-        abstract val isMismatchDueToNullability: Boolean
+        val expectedType: KtType
+        val actualType: KtType
+        val isMismatchDueToNullability: Boolean
     }
 
-    abstract class TypeInferenceOnlyInputTypesError : KtFirDiagnostic<PsiElement>() {
+    interface TypeInferenceOnlyInputTypesError : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = TypeInferenceOnlyInputTypesError::class
-        abstract val typeParameter: KtTypeParameterSymbol
+        val typeParameter: KtTypeParameterSymbol
     }
 
-    abstract class ThrowableTypeMismatch : KtFirDiagnostic<PsiElement>() {
+    interface ThrowableTypeMismatch : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = ThrowableTypeMismatch::class
-        abstract val actualType: KtType
-        abstract val isMismatchDueToNullability: Boolean
+        val actualType: KtType
+        val isMismatchDueToNullability: Boolean
     }
 
-    abstract class ConditionTypeMismatch : KtFirDiagnostic<PsiElement>() {
+    interface ConditionTypeMismatch : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = ConditionTypeMismatch::class
-        abstract val actualType: KtType
-        abstract val isMismatchDueToNullability: Boolean
+        val actualType: KtType
+        val isMismatchDueToNullability: Boolean
     }
 
-    abstract class ArgumentTypeMismatch : KtFirDiagnostic<PsiElement>() {
+    interface ArgumentTypeMismatch : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = ArgumentTypeMismatch::class
-        abstract val expectedType: KtType
-        abstract val actualType: KtType
-        abstract val isMismatchDueToNullability: Boolean
+        val expectedType: KtType
+        val actualType: KtType
+        val isMismatchDueToNullability: Boolean
     }
 
-    abstract class NullForNonnullType : KtFirDiagnostic<PsiElement>() {
+    interface NullForNonnullType : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = NullForNonnullType::class
     }
 
-    abstract class InapplicableLateinitModifier : KtFirDiagnostic<KtModifierListOwner>() {
+    interface InapplicableLateinitModifier : KtFirDiagnostic<KtModifierListOwner> {
         override val diagnosticClass get() = InapplicableLateinitModifier::class
-        abstract val reason: String
+        val reason: String
     }
 
-    abstract class VarargOutsideParentheses : KtFirDiagnostic<KtElement>() {
+    interface VarargOutsideParentheses : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = VarargOutsideParentheses::class
     }
 
-    abstract class NamedArgumentsNotAllowed : KtFirDiagnostic<KtValueArgument>() {
+    interface NamedArgumentsNotAllowed : KtFirDiagnostic<KtValueArgument> {
         override val diagnosticClass get() = NamedArgumentsNotAllowed::class
-        abstract val forbiddenNamedArgumentsTarget: ForbiddenNamedArgumentsTarget
+        val forbiddenNamedArgumentsTarget: ForbiddenNamedArgumentsTarget
     }
 
-    abstract class NonVarargSpread : KtFirDiagnostic<LeafPsiElement>() {
+    interface NonVarargSpread : KtFirDiagnostic<LeafPsiElement> {
         override val diagnosticClass get() = NonVarargSpread::class
     }
 
-    abstract class ArgumentPassedTwice : KtFirDiagnostic<KtValueArgument>() {
+    interface ArgumentPassedTwice : KtFirDiagnostic<KtValueArgument> {
         override val diagnosticClass get() = ArgumentPassedTwice::class
     }
 
-    abstract class TooManyArguments : KtFirDiagnostic<PsiElement>() {
+    interface TooManyArguments : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = TooManyArguments::class
-        abstract val function: KtCallableSymbol
+        val function: KtCallableSymbol
     }
 
-    abstract class NoValueForParameter : KtFirDiagnostic<KtElement>() {
+    interface NoValueForParameter : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = NoValueForParameter::class
-        abstract val violatedParameter: KtSymbol
+        val violatedParameter: KtSymbol
     }
 
-    abstract class NamedParameterNotFound : KtFirDiagnostic<KtValueArgument>() {
+    interface NamedParameterNotFound : KtFirDiagnostic<KtValueArgument> {
         override val diagnosticClass get() = NamedParameterNotFound::class
-        abstract val name: String
+        val name: String
     }
 
-    abstract class NameForAmbiguousParameter : KtFirDiagnostic<KtValueArgument>() {
+    interface NameForAmbiguousParameter : KtFirDiagnostic<KtValueArgument> {
         override val diagnosticClass get() = NameForAmbiguousParameter::class
     }
 
-    abstract class AssignmentTypeMismatch : KtFirDiagnostic<KtExpression>() {
+    interface AssignmentTypeMismatch : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = AssignmentTypeMismatch::class
-        abstract val expectedType: KtType
-        abstract val actualType: KtType
-        abstract val isMismatchDueToNullability: Boolean
+        val expectedType: KtType
+        val actualType: KtType
+        val isMismatchDueToNullability: Boolean
     }
 
-    abstract class ResultTypeMismatch : KtFirDiagnostic<KtExpression>() {
+    interface ResultTypeMismatch : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = ResultTypeMismatch::class
-        abstract val expectedType: KtType
-        abstract val actualType: KtType
+        val expectedType: KtType
+        val actualType: KtType
     }
 
-    abstract class ManyLambdaExpressionArguments : KtFirDiagnostic<KtValueArgument>() {
+    interface ManyLambdaExpressionArguments : KtFirDiagnostic<KtValueArgument> {
         override val diagnosticClass get() = ManyLambdaExpressionArguments::class
     }
 
-    abstract class NewInferenceNoInformationForParameter : KtFirDiagnostic<KtElement>() {
+    interface NewInferenceNoInformationForParameter : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = NewInferenceNoInformationForParameter::class
-        abstract val name: String
+        val name: String
     }
 
-    abstract class SpreadOfNullable : KtFirDiagnostic<PsiElement>() {
+    interface SpreadOfNullable : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = SpreadOfNullable::class
     }
 
-    abstract class AssigningSingleElementToVarargInNamedFormFunctionError : KtFirDiagnostic<KtExpression>() {
+    interface AssigningSingleElementToVarargInNamedFormFunctionError : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = AssigningSingleElementToVarargInNamedFormFunctionError::class
-        abstract val expectedArrayType: KtType
+        val expectedArrayType: KtType
     }
 
-    abstract class AssigningSingleElementToVarargInNamedFormFunctionWarning : KtFirDiagnostic<KtExpression>() {
+    interface AssigningSingleElementToVarargInNamedFormFunctionWarning : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = AssigningSingleElementToVarargInNamedFormFunctionWarning::class
-        abstract val expectedArrayType: KtType
+        val expectedArrayType: KtType
     }
 
-    abstract class AssigningSingleElementToVarargInNamedFormAnnotationError : KtFirDiagnostic<KtExpression>() {
+    interface AssigningSingleElementToVarargInNamedFormAnnotationError : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = AssigningSingleElementToVarargInNamedFormAnnotationError::class
     }
 
-    abstract class AssigningSingleElementToVarargInNamedFormAnnotationWarning : KtFirDiagnostic<KtExpression>() {
+    interface AssigningSingleElementToVarargInNamedFormAnnotationWarning : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = AssigningSingleElementToVarargInNamedFormAnnotationWarning::class
     }
 
-    abstract class RedundantSpreadOperatorInNamedFormInAnnotation : KtFirDiagnostic<KtExpression>() {
+    interface RedundantSpreadOperatorInNamedFormInAnnotation : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = RedundantSpreadOperatorInNamedFormInAnnotation::class
     }
 
-    abstract class RedundantSpreadOperatorInNamedFormInFunction : KtFirDiagnostic<KtExpression>() {
+    interface RedundantSpreadOperatorInNamedFormInFunction : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = RedundantSpreadOperatorInNamedFormInFunction::class
     }
 
-    abstract class InferenceUnsuccessfulFork : KtFirDiagnostic<PsiElement>() {
+    interface InferenceUnsuccessfulFork : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = InferenceUnsuccessfulFork::class
-        abstract val message: String
+        val message: String
     }
 
-    abstract class OverloadResolutionAmbiguity : KtFirDiagnostic<PsiElement>() {
+    interface OverloadResolutionAmbiguity : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = OverloadResolutionAmbiguity::class
-        abstract val candidates: List<KtSymbol>
+        val candidates: List<KtSymbol>
     }
 
-    abstract class AssignOperatorAmbiguity : KtFirDiagnostic<PsiElement>() {
+    interface AssignOperatorAmbiguity : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = AssignOperatorAmbiguity::class
-        abstract val candidates: List<KtSymbol>
+        val candidates: List<KtSymbol>
     }
 
-    abstract class IteratorAmbiguity : KtFirDiagnostic<PsiElement>() {
+    interface IteratorAmbiguity : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = IteratorAmbiguity::class
-        abstract val candidates: List<KtSymbol>
+        val candidates: List<KtSymbol>
     }
 
-    abstract class HasNextFunctionAmbiguity : KtFirDiagnostic<PsiElement>() {
+    interface HasNextFunctionAmbiguity : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = HasNextFunctionAmbiguity::class
-        abstract val candidates: List<KtSymbol>
+        val candidates: List<KtSymbol>
     }
 
-    abstract class NextAmbiguity : KtFirDiagnostic<PsiElement>() {
+    interface NextAmbiguity : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = NextAmbiguity::class
-        abstract val candidates: List<KtSymbol>
+        val candidates: List<KtSymbol>
     }
 
-    abstract class AmbiguousFunctionTypeKind : KtFirDiagnostic<PsiElement>() {
+    interface AmbiguousFunctionTypeKind : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = AmbiguousFunctionTypeKind::class
-        abstract val kinds: List<FunctionTypeKind>
+        val kinds: List<FunctionTypeKind>
     }
 
-    abstract class NoContextReceiver : KtFirDiagnostic<KtElement>() {
+    interface NoContextReceiver : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = NoContextReceiver::class
-        abstract val contextReceiverRepresentation: KtType
+        val contextReceiverRepresentation: KtType
     }
 
-    abstract class MultipleArgumentsApplicableForContextReceiver : KtFirDiagnostic<KtElement>() {
+    interface MultipleArgumentsApplicableForContextReceiver : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = MultipleArgumentsApplicableForContextReceiver::class
-        abstract val contextReceiverRepresentation: KtType
+        val contextReceiverRepresentation: KtType
     }
 
-    abstract class AmbiguousCallWithImplicitContextReceiver : KtFirDiagnostic<KtElement>() {
+    interface AmbiguousCallWithImplicitContextReceiver : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = AmbiguousCallWithImplicitContextReceiver::class
     }
 
-    abstract class UnsupportedContextualDeclarationCall : KtFirDiagnostic<KtElement>() {
+    interface UnsupportedContextualDeclarationCall : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = UnsupportedContextualDeclarationCall::class
     }
 
-    abstract class RecursionInImplicitTypes : KtFirDiagnostic<PsiElement>() {
+    interface RecursionInImplicitTypes : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = RecursionInImplicitTypes::class
     }
 
-    abstract class InferenceError : KtFirDiagnostic<PsiElement>() {
+    interface InferenceError : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = InferenceError::class
     }
 
-    abstract class ProjectionOnNonClassTypeArgument : KtFirDiagnostic<PsiElement>() {
+    interface ProjectionOnNonClassTypeArgument : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = ProjectionOnNonClassTypeArgument::class
     }
 
-    abstract class UpperBoundViolated : KtFirDiagnostic<PsiElement>() {
+    interface UpperBoundViolated : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = UpperBoundViolated::class
-        abstract val expectedUpperBound: KtType
-        abstract val actualUpperBound: KtType
+        val expectedUpperBound: KtType
+        val actualUpperBound: KtType
     }
 
-    abstract class UpperBoundViolatedInTypealiasExpansion : KtFirDiagnostic<PsiElement>() {
+    interface UpperBoundViolatedInTypealiasExpansion : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = UpperBoundViolatedInTypealiasExpansion::class
-        abstract val expectedUpperBound: KtType
-        abstract val actualUpperBound: KtType
+        val expectedUpperBound: KtType
+        val actualUpperBound: KtType
     }
 
-    abstract class TypeArgumentsNotAllowed : KtFirDiagnostic<PsiElement>() {
+    interface TypeArgumentsNotAllowed : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = TypeArgumentsNotAllowed::class
     }
 
-    abstract class WrongNumberOfTypeArguments : KtFirDiagnostic<PsiElement>() {
+    interface WrongNumberOfTypeArguments : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = WrongNumberOfTypeArguments::class
-        abstract val expectedCount: Int
-        abstract val classifier: KtClassLikeSymbol
+        val expectedCount: Int
+        val classifier: KtClassLikeSymbol
     }
 
-    abstract class NoTypeArgumentsOnRhs : KtFirDiagnostic<PsiElement>() {
+    interface NoTypeArgumentsOnRhs : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = NoTypeArgumentsOnRhs::class
-        abstract val expectedCount: Int
-        abstract val classifier: KtClassLikeSymbol
+        val expectedCount: Int
+        val classifier: KtClassLikeSymbol
     }
 
-    abstract class OuterClassArgumentsRequired : KtFirDiagnostic<PsiElement>() {
+    interface OuterClassArgumentsRequired : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = OuterClassArgumentsRequired::class
-        abstract val outer: KtClassLikeSymbol
+        val outer: KtClassLikeSymbol
     }
 
-    abstract class TypeParametersInObject : KtFirDiagnostic<PsiElement>() {
+    interface TypeParametersInObject : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = TypeParametersInObject::class
     }
 
-    abstract class TypeParametersInAnonymousObject : KtFirDiagnostic<PsiElement>() {
+    interface TypeParametersInAnonymousObject : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = TypeParametersInAnonymousObject::class
     }
 
-    abstract class IllegalProjectionUsage : KtFirDiagnostic<PsiElement>() {
+    interface IllegalProjectionUsage : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = IllegalProjectionUsage::class
     }
 
-    abstract class TypeParametersInEnum : KtFirDiagnostic<PsiElement>() {
+    interface TypeParametersInEnum : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = TypeParametersInEnum::class
     }
 
-    abstract class ConflictingProjection : KtFirDiagnostic<KtTypeProjection>() {
+    interface ConflictingProjection : KtFirDiagnostic<KtTypeProjection> {
         override val diagnosticClass get() = ConflictingProjection::class
-        abstract val type: KtType
+        val type: KtType
     }
 
-    abstract class ConflictingProjectionInTypealiasExpansion : KtFirDiagnostic<KtElement>() {
+    interface ConflictingProjectionInTypealiasExpansion : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = ConflictingProjectionInTypealiasExpansion::class
-        abstract val type: KtType
+        val type: KtType
     }
 
-    abstract class RedundantProjection : KtFirDiagnostic<KtTypeProjection>() {
+    interface RedundantProjection : KtFirDiagnostic<KtTypeProjection> {
         override val diagnosticClass get() = RedundantProjection::class
-        abstract val type: KtType
+        val type: KtType
     }
 
-    abstract class VarianceOnTypeParameterNotAllowed : KtFirDiagnostic<KtTypeParameter>() {
+    interface VarianceOnTypeParameterNotAllowed : KtFirDiagnostic<KtTypeParameter> {
         override val diagnosticClass get() = VarianceOnTypeParameterNotAllowed::class
     }
 
-    abstract class CatchParameterWithDefaultValue : KtFirDiagnostic<PsiElement>() {
+    interface CatchParameterWithDefaultValue : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = CatchParameterWithDefaultValue::class
     }
 
-    abstract class ReifiedTypeInCatchClause : KtFirDiagnostic<PsiElement>() {
+    interface ReifiedTypeInCatchClause : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = ReifiedTypeInCatchClause::class
     }
 
-    abstract class TypeParameterInCatchClause : KtFirDiagnostic<PsiElement>() {
+    interface TypeParameterInCatchClause : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = TypeParameterInCatchClause::class
     }
 
-    abstract class GenericThrowableSubclass : KtFirDiagnostic<KtTypeParameter>() {
+    interface GenericThrowableSubclass : KtFirDiagnostic<KtTypeParameter> {
         override val diagnosticClass get() = GenericThrowableSubclass::class
     }
 
-    abstract class InnerClassOfGenericThrowableSubclass : KtFirDiagnostic<KtClassOrObject>() {
+    interface InnerClassOfGenericThrowableSubclass : KtFirDiagnostic<KtClassOrObject> {
         override val diagnosticClass get() = InnerClassOfGenericThrowableSubclass::class
     }
 
-    abstract class KclassWithNullableTypeParameterInSignature : KtFirDiagnostic<KtNamedDeclaration>() {
+    interface KclassWithNullableTypeParameterInSignature : KtFirDiagnostic<KtNamedDeclaration> {
         override val diagnosticClass get() = KclassWithNullableTypeParameterInSignature::class
-        abstract val typeParameter: KtTypeParameterSymbol
+        val typeParameter: KtTypeParameterSymbol
     }
 
-    abstract class TypeParameterAsReified : KtFirDiagnostic<PsiElement>() {
+    interface TypeParameterAsReified : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = TypeParameterAsReified::class
-        abstract val typeParameter: KtTypeParameterSymbol
+        val typeParameter: KtTypeParameterSymbol
     }
 
-    abstract class TypeParameterAsReifiedArrayError : KtFirDiagnostic<PsiElement>() {
+    interface TypeParameterAsReifiedArrayError : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = TypeParameterAsReifiedArrayError::class
-        abstract val typeParameter: KtTypeParameterSymbol
+        val typeParameter: KtTypeParameterSymbol
     }
 
-    abstract class TypeParameterAsReifiedArrayWarning : KtFirDiagnostic<PsiElement>() {
+    interface TypeParameterAsReifiedArrayWarning : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = TypeParameterAsReifiedArrayWarning::class
-        abstract val typeParameter: KtTypeParameterSymbol
+        val typeParameter: KtTypeParameterSymbol
     }
 
-    abstract class ReifiedTypeForbiddenSubstitution : KtFirDiagnostic<PsiElement>() {
+    interface ReifiedTypeForbiddenSubstitution : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = ReifiedTypeForbiddenSubstitution::class
-        abstract val type: KtType
+        val type: KtType
     }
 
-    abstract class DefinitelyNonNullableAsReified : KtFirDiagnostic<PsiElement>() {
+    interface DefinitelyNonNullableAsReified : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = DefinitelyNonNullableAsReified::class
     }
 
-    abstract class FinalUpperBound : KtFirDiagnostic<KtTypeReference>() {
+    interface FinalUpperBound : KtFirDiagnostic<KtTypeReference> {
         override val diagnosticClass get() = FinalUpperBound::class
-        abstract val type: KtType
+        val type: KtType
     }
 
-    abstract class UpperBoundIsExtensionFunctionType : KtFirDiagnostic<KtTypeReference>() {
+    interface UpperBoundIsExtensionFunctionType : KtFirDiagnostic<KtTypeReference> {
         override val diagnosticClass get() = UpperBoundIsExtensionFunctionType::class
     }
 
-    abstract class BoundsNotAllowedIfBoundedByTypeParameter : KtFirDiagnostic<KtElement>() {
+    interface BoundsNotAllowedIfBoundedByTypeParameter : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = BoundsNotAllowedIfBoundedByTypeParameter::class
     }
 
-    abstract class OnlyOneClassBoundAllowed : KtFirDiagnostic<KtTypeReference>() {
+    interface OnlyOneClassBoundAllowed : KtFirDiagnostic<KtTypeReference> {
         override val diagnosticClass get() = OnlyOneClassBoundAllowed::class
     }
 
-    abstract class RepeatedBound : KtFirDiagnostic<KtTypeReference>() {
+    interface RepeatedBound : KtFirDiagnostic<KtTypeReference> {
         override val diagnosticClass get() = RepeatedBound::class
     }
 
-    abstract class ConflictingUpperBounds : KtFirDiagnostic<KtNamedDeclaration>() {
+    interface ConflictingUpperBounds : KtFirDiagnostic<KtNamedDeclaration> {
         override val diagnosticClass get() = ConflictingUpperBounds::class
-        abstract val typeParameter: KtTypeParameterSymbol
+        val typeParameter: KtTypeParameterSymbol
     }
 
-    abstract class NameInConstraintIsNotATypeParameter : KtFirDiagnostic<KtSimpleNameExpression>() {
+    interface NameInConstraintIsNotATypeParameter : KtFirDiagnostic<KtSimpleNameExpression> {
         override val diagnosticClass get() = NameInConstraintIsNotATypeParameter::class
-        abstract val typeParameterName: Name
-        abstract val typeParametersOwner: KtSymbol
+        val typeParameterName: Name
+        val typeParametersOwner: KtSymbol
     }
 
-    abstract class BoundOnTypeAliasParameterNotAllowed : KtFirDiagnostic<KtTypeReference>() {
+    interface BoundOnTypeAliasParameterNotAllowed : KtFirDiagnostic<KtTypeReference> {
         override val diagnosticClass get() = BoundOnTypeAliasParameterNotAllowed::class
     }
 
-    abstract class ReifiedTypeParameterNoInline : KtFirDiagnostic<KtTypeParameter>() {
+    interface ReifiedTypeParameterNoInline : KtFirDiagnostic<KtTypeParameter> {
         override val diagnosticClass get() = ReifiedTypeParameterNoInline::class
     }
 
-    abstract class TypeParametersNotAllowed : KtFirDiagnostic<KtDeclaration>() {
+    interface TypeParametersNotAllowed : KtFirDiagnostic<KtDeclaration> {
         override val diagnosticClass get() = TypeParametersNotAllowed::class
     }
 
-    abstract class TypeParameterOfPropertyNotUsedInReceiver : KtFirDiagnostic<KtTypeParameter>() {
+    interface TypeParameterOfPropertyNotUsedInReceiver : KtFirDiagnostic<KtTypeParameter> {
         override val diagnosticClass get() = TypeParameterOfPropertyNotUsedInReceiver::class
     }
 
-    abstract class ReturnTypeMismatch : KtFirDiagnostic<KtExpression>() {
+    interface ReturnTypeMismatch : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = ReturnTypeMismatch::class
-        abstract val expectedType: KtType
-        abstract val actualType: KtType
-        abstract val targetFunction: KtSymbol
-        abstract val isMismatchDueToNullability: Boolean
+        val expectedType: KtType
+        val actualType: KtType
+        val targetFunction: KtSymbol
+        val isMismatchDueToNullability: Boolean
     }
 
-    abstract class ImplicitNothingReturnType : KtFirDiagnostic<PsiElement>() {
+    interface ImplicitNothingReturnType : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = ImplicitNothingReturnType::class
     }
 
-    abstract class ImplicitNothingPropertyType : KtFirDiagnostic<PsiElement>() {
+    interface ImplicitNothingPropertyType : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = ImplicitNothingPropertyType::class
     }
 
-    abstract class CyclicGenericUpperBound : KtFirDiagnostic<PsiElement>() {
+    interface CyclicGenericUpperBound : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = CyclicGenericUpperBound::class
     }
 
-    abstract class DeprecatedTypeParameterSyntax : KtFirDiagnostic<KtDeclaration>() {
+    interface DeprecatedTypeParameterSyntax : KtFirDiagnostic<KtDeclaration> {
         override val diagnosticClass get() = DeprecatedTypeParameterSyntax::class
     }
 
-    abstract class MisplacedTypeParameterConstraints : KtFirDiagnostic<KtTypeParameter>() {
+    interface MisplacedTypeParameterConstraints : KtFirDiagnostic<KtTypeParameter> {
         override val diagnosticClass get() = MisplacedTypeParameterConstraints::class
     }
 
-    abstract class DynamicSupertype : KtFirDiagnostic<KtTypeReference>() {
+    interface DynamicSupertype : KtFirDiagnostic<KtTypeReference> {
         override val diagnosticClass get() = DynamicSupertype::class
     }
 
-    abstract class DynamicUpperBound : KtFirDiagnostic<KtTypeReference>() {
+    interface DynamicUpperBound : KtFirDiagnostic<KtTypeReference> {
         override val diagnosticClass get() = DynamicUpperBound::class
     }
 
-    abstract class DynamicReceiverNotAllowed : KtFirDiagnostic<KtElement>() {
+    interface DynamicReceiverNotAllowed : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = DynamicReceiverNotAllowed::class
     }
 
-    abstract class IncompatibleTypes : KtFirDiagnostic<KtElement>() {
+    interface IncompatibleTypes : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = IncompatibleTypes::class
-        abstract val typeA: KtType
-        abstract val typeB: KtType
+        val typeA: KtType
+        val typeB: KtType
     }
 
-    abstract class IncompatibleTypesWarning : KtFirDiagnostic<KtElement>() {
+    interface IncompatibleTypesWarning : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = IncompatibleTypesWarning::class
-        abstract val typeA: KtType
-        abstract val typeB: KtType
+        val typeA: KtType
+        val typeB: KtType
     }
 
-    abstract class TypeVarianceConflictError : KtFirDiagnostic<PsiElement>() {
+    interface TypeVarianceConflictError : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = TypeVarianceConflictError::class
-        abstract val typeParameter: KtTypeParameterSymbol
-        abstract val typeParameterVariance: Variance
-        abstract val variance: Variance
-        abstract val containingType: KtType
+        val typeParameter: KtTypeParameterSymbol
+        val typeParameterVariance: Variance
+        val variance: Variance
+        val containingType: KtType
     }
 
-    abstract class TypeVarianceConflictInExpandedType : KtFirDiagnostic<PsiElement>() {
+    interface TypeVarianceConflictInExpandedType : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = TypeVarianceConflictInExpandedType::class
-        abstract val typeParameter: KtTypeParameterSymbol
-        abstract val typeParameterVariance: Variance
-        abstract val variance: Variance
-        abstract val containingType: KtType
+        val typeParameter: KtTypeParameterSymbol
+        val typeParameterVariance: Variance
+        val variance: Variance
+        val containingType: KtType
     }
 
-    abstract class SmartcastImpossible : KtFirDiagnostic<KtExpression>() {
+    interface SmartcastImpossible : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = SmartcastImpossible::class
-        abstract val desiredType: KtType
-        abstract val subject: KtExpression
-        abstract val description: String
-        abstract val isCastToNotNull: Boolean
+        val desiredType: KtType
+        val subject: KtExpression
+        val description: String
+        val isCastToNotNull: Boolean
     }
 
-    abstract class RedundantNullable : KtFirDiagnostic<KtTypeReference>() {
+    interface RedundantNullable : KtFirDiagnostic<KtTypeReference> {
         override val diagnosticClass get() = RedundantNullable::class
     }
 
-    abstract class PlatformClassMappedToKotlin : KtFirDiagnostic<PsiElement>() {
+    interface PlatformClassMappedToKotlin : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = PlatformClassMappedToKotlin::class
-        abstract val kotlinClass: FqName
+        val kotlinClass: FqName
     }
 
-    abstract class InferredTypeVariableIntoEmptyIntersectionError : KtFirDiagnostic<PsiElement>() {
+    interface InferredTypeVariableIntoEmptyIntersectionError : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = InferredTypeVariableIntoEmptyIntersectionError::class
-        abstract val typeVariableDescription: String
-        abstract val incompatibleTypes: List<KtType>
-        abstract val description: String
-        abstract val causingTypes: String
+        val typeVariableDescription: String
+        val incompatibleTypes: List<KtType>
+        val description: String
+        val causingTypes: String
     }
 
-    abstract class InferredTypeVariableIntoEmptyIntersectionWarning : KtFirDiagnostic<PsiElement>() {
+    interface InferredTypeVariableIntoEmptyIntersectionWarning : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = InferredTypeVariableIntoEmptyIntersectionWarning::class
-        abstract val typeVariableDescription: String
-        abstract val incompatibleTypes: List<KtType>
-        abstract val description: String
-        abstract val causingTypes: String
+        val typeVariableDescription: String
+        val incompatibleTypes: List<KtType>
+        val description: String
+        val causingTypes: String
     }
 
-    abstract class InferredTypeVariableIntoPossibleEmptyIntersection : KtFirDiagnostic<PsiElement>() {
+    interface InferredTypeVariableIntoPossibleEmptyIntersection : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = InferredTypeVariableIntoPossibleEmptyIntersection::class
-        abstract val typeVariableDescription: String
-        abstract val incompatibleTypes: List<KtType>
-        abstract val description: String
-        abstract val causingTypes: String
+        val typeVariableDescription: String
+        val incompatibleTypes: List<KtType>
+        val description: String
+        val causingTypes: String
     }
 
-    abstract class IncorrectLeftComponentOfIntersection : KtFirDiagnostic<KtTypeReference>() {
+    interface IncorrectLeftComponentOfIntersection : KtFirDiagnostic<KtTypeReference> {
         override val diagnosticClass get() = IncorrectLeftComponentOfIntersection::class
     }
 
-    abstract class IncorrectRightComponentOfIntersection : KtFirDiagnostic<KtTypeReference>() {
+    interface IncorrectRightComponentOfIntersection : KtFirDiagnostic<KtTypeReference> {
         override val diagnosticClass get() = IncorrectRightComponentOfIntersection::class
     }
 
-    abstract class NullableOnDefinitelyNotNullable : KtFirDiagnostic<KtTypeReference>() {
+    interface NullableOnDefinitelyNotNullable : KtFirDiagnostic<KtTypeReference> {
         override val diagnosticClass get() = NullableOnDefinitelyNotNullable::class
     }
 
-    abstract class ExtensionInClassReferenceNotAllowed : KtFirDiagnostic<KtExpression>() {
+    interface ExtensionInClassReferenceNotAllowed : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = ExtensionInClassReferenceNotAllowed::class
-        abstract val referencedDeclaration: KtCallableSymbol
+        val referencedDeclaration: KtCallableSymbol
     }
 
-    abstract class CallableReferenceLhsNotAClass : KtFirDiagnostic<KtExpression>() {
+    interface CallableReferenceLhsNotAClass : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = CallableReferenceLhsNotAClass::class
     }
 
-    abstract class CallableReferenceToAnnotationConstructor : KtFirDiagnostic<KtExpression>() {
+    interface CallableReferenceToAnnotationConstructor : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = CallableReferenceToAnnotationConstructor::class
     }
 
-    abstract class ClassLiteralLhsNotAClass : KtFirDiagnostic<KtExpression>() {
+    interface ClassLiteralLhsNotAClass : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = ClassLiteralLhsNotAClass::class
     }
 
-    abstract class NullableTypeInClassLiteralLhs : KtFirDiagnostic<KtExpression>() {
+    interface NullableTypeInClassLiteralLhs : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = NullableTypeInClassLiteralLhs::class
     }
 
-    abstract class ExpressionOfNullableTypeInClassLiteralLhs : KtFirDiagnostic<PsiElement>() {
+    interface ExpressionOfNullableTypeInClassLiteralLhs : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = ExpressionOfNullableTypeInClassLiteralLhs::class
-        abstract val lhsType: KtType
+        val lhsType: KtType
     }
 
-    abstract class NothingToOverride : KtFirDiagnostic<KtModifierListOwner>() {
+    interface NothingToOverride : KtFirDiagnostic<KtModifierListOwner> {
         override val diagnosticClass get() = NothingToOverride::class
-        abstract val declaration: KtCallableSymbol
+        val declaration: KtCallableSymbol
     }
 
-    abstract class CannotOverrideInvisibleMember : KtFirDiagnostic<KtNamedDeclaration>() {
+    interface CannotOverrideInvisibleMember : KtFirDiagnostic<KtNamedDeclaration> {
         override val diagnosticClass get() = CannotOverrideInvisibleMember::class
-        abstract val overridingMember: KtCallableSymbol
-        abstract val baseMember: KtCallableSymbol
+        val overridingMember: KtCallableSymbol
+        val baseMember: KtCallableSymbol
     }
 
-    abstract class DataClassOverrideConflict : KtFirDiagnostic<KtClassOrObject>() {
+    interface DataClassOverrideConflict : KtFirDiagnostic<KtClassOrObject> {
         override val diagnosticClass get() = DataClassOverrideConflict::class
-        abstract val overridingMember: KtCallableSymbol
-        abstract val baseMember: KtCallableSymbol
+        val overridingMember: KtCallableSymbol
+        val baseMember: KtCallableSymbol
     }
 
-    abstract class CannotWeakenAccessPrivilege : KtFirDiagnostic<KtModifierListOwner>() {
+    interface CannotWeakenAccessPrivilege : KtFirDiagnostic<KtModifierListOwner> {
         override val diagnosticClass get() = CannotWeakenAccessPrivilege::class
-        abstract val overridingVisibility: Visibility
-        abstract val overridden: KtCallableSymbol
-        abstract val containingClassName: Name
+        val overridingVisibility: Visibility
+        val overridden: KtCallableSymbol
+        val containingClassName: Name
     }
 
-    abstract class CannotChangeAccessPrivilege : KtFirDiagnostic<KtModifierListOwner>() {
+    interface CannotChangeAccessPrivilege : KtFirDiagnostic<KtModifierListOwner> {
         override val diagnosticClass get() = CannotChangeAccessPrivilege::class
-        abstract val overridingVisibility: Visibility
-        abstract val overridden: KtCallableSymbol
-        abstract val containingClassName: Name
+        val overridingVisibility: Visibility
+        val overridden: KtCallableSymbol
+        val containingClassName: Name
     }
 
-    abstract class OverridingFinalMember : KtFirDiagnostic<KtNamedDeclaration>() {
+    interface OverridingFinalMember : KtFirDiagnostic<KtNamedDeclaration> {
         override val diagnosticClass get() = OverridingFinalMember::class
-        abstract val overriddenDeclaration: KtCallableSymbol
-        abstract val containingClassName: Name
+        val overriddenDeclaration: KtCallableSymbol
+        val containingClassName: Name
     }
 
-    abstract class ReturnTypeMismatchOnInheritance : KtFirDiagnostic<KtClassOrObject>() {
+    interface ReturnTypeMismatchOnInheritance : KtFirDiagnostic<KtClassOrObject> {
         override val diagnosticClass get() = ReturnTypeMismatchOnInheritance::class
-        abstract val conflictingDeclaration1: KtCallableSymbol
-        abstract val conflictingDeclaration2: KtCallableSymbol
+        val conflictingDeclaration1: KtCallableSymbol
+        val conflictingDeclaration2: KtCallableSymbol
     }
 
-    abstract class PropertyTypeMismatchOnInheritance : KtFirDiagnostic<KtClassOrObject>() {
+    interface PropertyTypeMismatchOnInheritance : KtFirDiagnostic<KtClassOrObject> {
         override val diagnosticClass get() = PropertyTypeMismatchOnInheritance::class
-        abstract val conflictingDeclaration1: KtCallableSymbol
-        abstract val conflictingDeclaration2: KtCallableSymbol
+        val conflictingDeclaration1: KtCallableSymbol
+        val conflictingDeclaration2: KtCallableSymbol
     }
 
-    abstract class VarTypeMismatchOnInheritance : KtFirDiagnostic<KtClassOrObject>() {
+    interface VarTypeMismatchOnInheritance : KtFirDiagnostic<KtClassOrObject> {
         override val diagnosticClass get() = VarTypeMismatchOnInheritance::class
-        abstract val conflictingDeclaration1: KtCallableSymbol
-        abstract val conflictingDeclaration2: KtCallableSymbol
+        val conflictingDeclaration1: KtCallableSymbol
+        val conflictingDeclaration2: KtCallableSymbol
     }
 
-    abstract class ReturnTypeMismatchByDelegation : KtFirDiagnostic<KtClassOrObject>() {
+    interface ReturnTypeMismatchByDelegation : KtFirDiagnostic<KtClassOrObject> {
         override val diagnosticClass get() = ReturnTypeMismatchByDelegation::class
-        abstract val delegateDeclaration: KtCallableSymbol
-        abstract val baseDeclaration: KtCallableSymbol
+        val delegateDeclaration: KtCallableSymbol
+        val baseDeclaration: KtCallableSymbol
     }
 
-    abstract class PropertyTypeMismatchByDelegation : KtFirDiagnostic<KtClassOrObject>() {
+    interface PropertyTypeMismatchByDelegation : KtFirDiagnostic<KtClassOrObject> {
         override val diagnosticClass get() = PropertyTypeMismatchByDelegation::class
-        abstract val delegateDeclaration: KtCallableSymbol
-        abstract val baseDeclaration: KtCallableSymbol
+        val delegateDeclaration: KtCallableSymbol
+        val baseDeclaration: KtCallableSymbol
     }
 
-    abstract class VarOverriddenByValByDelegation : KtFirDiagnostic<KtClassOrObject>() {
+    interface VarOverriddenByValByDelegation : KtFirDiagnostic<KtClassOrObject> {
         override val diagnosticClass get() = VarOverriddenByValByDelegation::class
-        abstract val delegateDeclaration: KtCallableSymbol
-        abstract val baseDeclaration: KtCallableSymbol
+        val delegateDeclaration: KtCallableSymbol
+        val baseDeclaration: KtCallableSymbol
     }
 
-    abstract class ConflictingInheritedMembers : KtFirDiagnostic<KtClassOrObject>() {
+    interface ConflictingInheritedMembers : KtFirDiagnostic<KtClassOrObject> {
         override val diagnosticClass get() = ConflictingInheritedMembers::class
-        abstract val owner: KtClassLikeSymbol
-        abstract val conflictingDeclarations: List<KtCallableSymbol>
+        val owner: KtClassLikeSymbol
+        val conflictingDeclarations: List<KtCallableSymbol>
     }
 
-    abstract class AbstractMemberNotImplemented : KtFirDiagnostic<KtClassOrObject>() {
+    interface AbstractMemberNotImplemented : KtFirDiagnostic<KtClassOrObject> {
         override val diagnosticClass get() = AbstractMemberNotImplemented::class
-        abstract val classOrObject: KtClassLikeSymbol
-        abstract val missingDeclaration: KtCallableSymbol
+        val classOrObject: KtClassLikeSymbol
+        val missingDeclaration: KtCallableSymbol
     }
 
-    abstract class AbstractClassMemberNotImplemented : KtFirDiagnostic<KtClassOrObject>() {
+    interface AbstractClassMemberNotImplemented : KtFirDiagnostic<KtClassOrObject> {
         override val diagnosticClass get() = AbstractClassMemberNotImplemented::class
-        abstract val classOrObject: KtClassLikeSymbol
-        abstract val missingDeclaration: KtCallableSymbol
+        val classOrObject: KtClassLikeSymbol
+        val missingDeclaration: KtCallableSymbol
     }
 
-    abstract class InvisibleAbstractMemberFromSuperError : KtFirDiagnostic<KtClassOrObject>() {
+    interface InvisibleAbstractMemberFromSuperError : KtFirDiagnostic<KtClassOrObject> {
         override val diagnosticClass get() = InvisibleAbstractMemberFromSuperError::class
-        abstract val classOrObject: KtClassLikeSymbol
-        abstract val invisibleDeclaration: KtCallableSymbol
+        val classOrObject: KtClassLikeSymbol
+        val invisibleDeclaration: KtCallableSymbol
     }
 
-    abstract class InvisibleAbstractMemberFromSuperWarning : KtFirDiagnostic<KtClassOrObject>() {
+    interface InvisibleAbstractMemberFromSuperWarning : KtFirDiagnostic<KtClassOrObject> {
         override val diagnosticClass get() = InvisibleAbstractMemberFromSuperWarning::class
-        abstract val classOrObject: KtClassLikeSymbol
-        abstract val invisibleDeclaration: KtCallableSymbol
+        val classOrObject: KtClassLikeSymbol
+        val invisibleDeclaration: KtCallableSymbol
     }
 
-    abstract class AmbiguousAnonymousTypeInferred : KtFirDiagnostic<KtDeclaration>() {
+    interface AmbiguousAnonymousTypeInferred : KtFirDiagnostic<KtDeclaration> {
         override val diagnosticClass get() = AmbiguousAnonymousTypeInferred::class
-        abstract val superTypes: List<KtType>
+        val superTypes: List<KtType>
     }
 
-    abstract class ManyImplMemberNotImplemented : KtFirDiagnostic<KtClassOrObject>() {
+    interface ManyImplMemberNotImplemented : KtFirDiagnostic<KtClassOrObject> {
         override val diagnosticClass get() = ManyImplMemberNotImplemented::class
-        abstract val classOrObject: KtClassLikeSymbol
-        abstract val missingDeclaration: KtCallableSymbol
+        val classOrObject: KtClassLikeSymbol
+        val missingDeclaration: KtCallableSymbol
     }
 
-    abstract class ManyInterfacesMemberNotImplemented : KtFirDiagnostic<KtClassOrObject>() {
+    interface ManyInterfacesMemberNotImplemented : KtFirDiagnostic<KtClassOrObject> {
         override val diagnosticClass get() = ManyInterfacesMemberNotImplemented::class
-        abstract val classOrObject: KtClassLikeSymbol
-        abstract val missingDeclaration: KtCallableSymbol
+        val classOrObject: KtClassLikeSymbol
+        val missingDeclaration: KtCallableSymbol
     }
 
-    abstract class OverridingFinalMemberByDelegation : KtFirDiagnostic<KtClassOrObject>() {
+    interface OverridingFinalMemberByDelegation : KtFirDiagnostic<KtClassOrObject> {
         override val diagnosticClass get() = OverridingFinalMemberByDelegation::class
-        abstract val delegatedDeclaration: KtCallableSymbol
-        abstract val overriddenDeclaration: KtCallableSymbol
+        val delegatedDeclaration: KtCallableSymbol
+        val overriddenDeclaration: KtCallableSymbol
     }
 
-    abstract class DelegatedMemberHidesSupertypeOverride : KtFirDiagnostic<KtClassOrObject>() {
+    interface DelegatedMemberHidesSupertypeOverride : KtFirDiagnostic<KtClassOrObject> {
         override val diagnosticClass get() = DelegatedMemberHidesSupertypeOverride::class
-        abstract val delegatedDeclaration: KtCallableSymbol
-        abstract val overriddenDeclaration: KtCallableSymbol
+        val delegatedDeclaration: KtCallableSymbol
+        val overriddenDeclaration: KtCallableSymbol
     }
 
-    abstract class ReturnTypeMismatchOnOverride : KtFirDiagnostic<KtNamedDeclaration>() {
+    interface ReturnTypeMismatchOnOverride : KtFirDiagnostic<KtNamedDeclaration> {
         override val diagnosticClass get() = ReturnTypeMismatchOnOverride::class
-        abstract val function: KtCallableSymbol
-        abstract val superFunction: KtCallableSymbol
+        val function: KtCallableSymbol
+        val superFunction: KtCallableSymbol
     }
 
-    abstract class PropertyTypeMismatchOnOverride : KtFirDiagnostic<KtNamedDeclaration>() {
+    interface PropertyTypeMismatchOnOverride : KtFirDiagnostic<KtNamedDeclaration> {
         override val diagnosticClass get() = PropertyTypeMismatchOnOverride::class
-        abstract val property: KtCallableSymbol
-        abstract val superProperty: KtCallableSymbol
+        val property: KtCallableSymbol
+        val superProperty: KtCallableSymbol
     }
 
-    abstract class VarTypeMismatchOnOverride : KtFirDiagnostic<KtNamedDeclaration>() {
+    interface VarTypeMismatchOnOverride : KtFirDiagnostic<KtNamedDeclaration> {
         override val diagnosticClass get() = VarTypeMismatchOnOverride::class
-        abstract val variable: KtCallableSymbol
-        abstract val superVariable: KtCallableSymbol
+        val variable: KtCallableSymbol
+        val superVariable: KtCallableSymbol
     }
 
-    abstract class VarOverriddenByVal : KtFirDiagnostic<KtNamedDeclaration>() {
+    interface VarOverriddenByVal : KtFirDiagnostic<KtNamedDeclaration> {
         override val diagnosticClass get() = VarOverriddenByVal::class
-        abstract val overridingDeclaration: KtCallableSymbol
-        abstract val overriddenDeclaration: KtCallableSymbol
+        val overridingDeclaration: KtCallableSymbol
+        val overriddenDeclaration: KtCallableSymbol
     }
 
-    abstract class VarImplementedByInheritedValError : KtFirDiagnostic<KtNamedDeclaration>() {
+    interface VarImplementedByInheritedValError : KtFirDiagnostic<KtNamedDeclaration> {
         override val diagnosticClass get() = VarImplementedByInheritedValError::class
-        abstract val classOrObject: KtClassLikeSymbol
-        abstract val overridingDeclaration: KtCallableSymbol
-        abstract val overriddenDeclaration: KtCallableSymbol
+        val classOrObject: KtClassLikeSymbol
+        val overridingDeclaration: KtCallableSymbol
+        val overriddenDeclaration: KtCallableSymbol
     }
 
-    abstract class VarImplementedByInheritedValWarning : KtFirDiagnostic<KtNamedDeclaration>() {
+    interface VarImplementedByInheritedValWarning : KtFirDiagnostic<KtNamedDeclaration> {
         override val diagnosticClass get() = VarImplementedByInheritedValWarning::class
-        abstract val classOrObject: KtClassLikeSymbol
-        abstract val overridingDeclaration: KtCallableSymbol
-        abstract val overriddenDeclaration: KtCallableSymbol
+        val classOrObject: KtClassLikeSymbol
+        val overridingDeclaration: KtCallableSymbol
+        val overriddenDeclaration: KtCallableSymbol
     }
 
-    abstract class NonFinalMemberInFinalClass : KtFirDiagnostic<KtNamedDeclaration>() {
+    interface NonFinalMemberInFinalClass : KtFirDiagnostic<KtNamedDeclaration> {
         override val diagnosticClass get() = NonFinalMemberInFinalClass::class
     }
 
-    abstract class NonFinalMemberInObject : KtFirDiagnostic<KtNamedDeclaration>() {
+    interface NonFinalMemberInObject : KtFirDiagnostic<KtNamedDeclaration> {
         override val diagnosticClass get() = NonFinalMemberInObject::class
     }
 
-    abstract class VirtualMemberHidden : KtFirDiagnostic<KtNamedDeclaration>() {
+    interface VirtualMemberHidden : KtFirDiagnostic<KtNamedDeclaration> {
         override val diagnosticClass get() = VirtualMemberHidden::class
-        abstract val declared: KtCallableSymbol
-        abstract val overriddenContainer: KtClassLikeSymbol
+        val declared: KtCallableSymbol
+        val overriddenContainer: KtClassLikeSymbol
     }
 
-    abstract class ManyCompanionObjects : KtFirDiagnostic<KtObjectDeclaration>() {
+    interface ManyCompanionObjects : KtFirDiagnostic<KtObjectDeclaration> {
         override val diagnosticClass get() = ManyCompanionObjects::class
     }
 
-    abstract class ConflictingOverloads : KtFirDiagnostic<PsiElement>() {
+    interface ConflictingOverloads : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = ConflictingOverloads::class
-        abstract val conflictingOverloads: List<KtSymbol>
+        val conflictingOverloads: List<KtSymbol>
     }
 
-    abstract class Redeclaration : KtFirDiagnostic<KtNamedDeclaration>() {
+    interface Redeclaration : KtFirDiagnostic<KtNamedDeclaration> {
         override val diagnosticClass get() = Redeclaration::class
-        abstract val conflictingDeclarations: List<KtSymbol>
+        val conflictingDeclarations: List<KtSymbol>
     }
 
-    abstract class PackageOrClassifierRedeclaration : KtFirDiagnostic<KtNamedDeclaration>() {
+    interface PackageOrClassifierRedeclaration : KtFirDiagnostic<KtNamedDeclaration> {
         override val diagnosticClass get() = PackageOrClassifierRedeclaration::class
-        abstract val conflictingDeclarations: List<KtSymbol>
+        val conflictingDeclarations: List<KtSymbol>
     }
 
-    abstract class MethodOfAnyImplementedInInterface : KtFirDiagnostic<PsiElement>() {
+    interface MethodOfAnyImplementedInInterface : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = MethodOfAnyImplementedInInterface::class
     }
 
-    abstract class LocalObjectNotAllowed : KtFirDiagnostic<KtNamedDeclaration>() {
+    interface LocalObjectNotAllowed : KtFirDiagnostic<KtNamedDeclaration> {
         override val diagnosticClass get() = LocalObjectNotAllowed::class
-        abstract val objectName: Name
+        val objectName: Name
     }
 
-    abstract class LocalInterfaceNotAllowed : KtFirDiagnostic<KtNamedDeclaration>() {
+    interface LocalInterfaceNotAllowed : KtFirDiagnostic<KtNamedDeclaration> {
         override val diagnosticClass get() = LocalInterfaceNotAllowed::class
-        abstract val interfaceName: Name
+        val interfaceName: Name
     }
 
-    abstract class AbstractFunctionInNonAbstractClass : KtFirDiagnostic<KtFunction>() {
+    interface AbstractFunctionInNonAbstractClass : KtFirDiagnostic<KtFunction> {
         override val diagnosticClass get() = AbstractFunctionInNonAbstractClass::class
-        abstract val function: KtCallableSymbol
-        abstract val containingClass: KtClassLikeSymbol
+        val function: KtCallableSymbol
+        val containingClass: KtClassLikeSymbol
     }
 
-    abstract class AbstractFunctionWithBody : KtFirDiagnostic<KtFunction>() {
+    interface AbstractFunctionWithBody : KtFirDiagnostic<KtFunction> {
         override val diagnosticClass get() = AbstractFunctionWithBody::class
-        abstract val function: KtCallableSymbol
+        val function: KtCallableSymbol
     }
 
-    abstract class NonAbstractFunctionWithNoBody : KtFirDiagnostic<KtFunction>() {
+    interface NonAbstractFunctionWithNoBody : KtFirDiagnostic<KtFunction> {
         override val diagnosticClass get() = NonAbstractFunctionWithNoBody::class
-        abstract val function: KtCallableSymbol
+        val function: KtCallableSymbol
     }
 
-    abstract class PrivateFunctionWithNoBody : KtFirDiagnostic<KtFunction>() {
+    interface PrivateFunctionWithNoBody : KtFirDiagnostic<KtFunction> {
         override val diagnosticClass get() = PrivateFunctionWithNoBody::class
-        abstract val function: KtCallableSymbol
+        val function: KtCallableSymbol
     }
 
-    abstract class NonMemberFunctionNoBody : KtFirDiagnostic<KtFunction>() {
+    interface NonMemberFunctionNoBody : KtFirDiagnostic<KtFunction> {
         override val diagnosticClass get() = NonMemberFunctionNoBody::class
-        abstract val function: KtCallableSymbol
+        val function: KtCallableSymbol
     }
 
-    abstract class FunctionDeclarationWithNoName : KtFirDiagnostic<KtFunction>() {
+    interface FunctionDeclarationWithNoName : KtFirDiagnostic<KtFunction> {
         override val diagnosticClass get() = FunctionDeclarationWithNoName::class
     }
 
-    abstract class AnonymousFunctionWithName : KtFirDiagnostic<KtFunction>() {
+    interface AnonymousFunctionWithName : KtFirDiagnostic<KtFunction> {
         override val diagnosticClass get() = AnonymousFunctionWithName::class
     }
 
-    abstract class AnonymousFunctionParameterWithDefaultValue : KtFirDiagnostic<KtParameter>() {
+    interface AnonymousFunctionParameterWithDefaultValue : KtFirDiagnostic<KtParameter> {
         override val diagnosticClass get() = AnonymousFunctionParameterWithDefaultValue::class
     }
 
-    abstract class UselessVarargOnParameter : KtFirDiagnostic<KtParameter>() {
+    interface UselessVarargOnParameter : KtFirDiagnostic<KtParameter> {
         override val diagnosticClass get() = UselessVarargOnParameter::class
     }
 
-    abstract class MultipleVarargParameters : KtFirDiagnostic<KtParameter>() {
+    interface MultipleVarargParameters : KtFirDiagnostic<KtParameter> {
         override val diagnosticClass get() = MultipleVarargParameters::class
     }
 
-    abstract class ForbiddenVarargParameterType : KtFirDiagnostic<KtParameter>() {
+    interface ForbiddenVarargParameterType : KtFirDiagnostic<KtParameter> {
         override val diagnosticClass get() = ForbiddenVarargParameterType::class
-        abstract val varargParameterType: KtType
+        val varargParameterType: KtType
     }
 
-    abstract class ValueParameterWithNoTypeAnnotation : KtFirDiagnostic<KtParameter>() {
+    interface ValueParameterWithNoTypeAnnotation : KtFirDiagnostic<KtParameter> {
         override val diagnosticClass get() = ValueParameterWithNoTypeAnnotation::class
     }
 
-    abstract class CannotInferParameterType : KtFirDiagnostic<KtElement>() {
+    interface CannotInferParameterType : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = CannotInferParameterType::class
     }
 
-    abstract class NoTailCallsFound : KtFirDiagnostic<KtNamedFunction>() {
+    interface NoTailCallsFound : KtFirDiagnostic<KtNamedFunction> {
         override val diagnosticClass get() = NoTailCallsFound::class
     }
 
-    abstract class TailrecOnVirtualMemberError : KtFirDiagnostic<KtNamedFunction>() {
+    interface TailrecOnVirtualMemberError : KtFirDiagnostic<KtNamedFunction> {
         override val diagnosticClass get() = TailrecOnVirtualMemberError::class
     }
 
-    abstract class NonTailRecursiveCall : KtFirDiagnostic<PsiElement>() {
+    interface NonTailRecursiveCall : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = NonTailRecursiveCall::class
     }
 
-    abstract class TailRecursionInTryIsNotSupported : KtFirDiagnostic<PsiElement>() {
+    interface TailRecursionInTryIsNotSupported : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = TailRecursionInTryIsNotSupported::class
     }
 
-    abstract class DataObjectCustomEqualsOrHashCode : KtFirDiagnostic<KtNamedFunction>() {
+    interface DataObjectCustomEqualsOrHashCode : KtFirDiagnostic<KtNamedFunction> {
         override val diagnosticClass get() = DataObjectCustomEqualsOrHashCode::class
     }
 
-    abstract class FunInterfaceConstructorReference : KtFirDiagnostic<KtExpression>() {
+    interface FunInterfaceConstructorReference : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = FunInterfaceConstructorReference::class
     }
 
-    abstract class FunInterfaceWrongCountOfAbstractMembers : KtFirDiagnostic<KtClass>() {
+    interface FunInterfaceWrongCountOfAbstractMembers : KtFirDiagnostic<KtClass> {
         override val diagnosticClass get() = FunInterfaceWrongCountOfAbstractMembers::class
     }
 
-    abstract class FunInterfaceCannotHaveAbstractProperties : KtFirDiagnostic<KtDeclaration>() {
+    interface FunInterfaceCannotHaveAbstractProperties : KtFirDiagnostic<KtDeclaration> {
         override val diagnosticClass get() = FunInterfaceCannotHaveAbstractProperties::class
     }
 
-    abstract class FunInterfaceAbstractMethodWithTypeParameters : KtFirDiagnostic<KtDeclaration>() {
+    interface FunInterfaceAbstractMethodWithTypeParameters : KtFirDiagnostic<KtDeclaration> {
         override val diagnosticClass get() = FunInterfaceAbstractMethodWithTypeParameters::class
     }
 
-    abstract class FunInterfaceAbstractMethodWithDefaultValue : KtFirDiagnostic<KtDeclaration>() {
+    interface FunInterfaceAbstractMethodWithDefaultValue : KtFirDiagnostic<KtDeclaration> {
         override val diagnosticClass get() = FunInterfaceAbstractMethodWithDefaultValue::class
     }
 
-    abstract class FunInterfaceWithSuspendFunction : KtFirDiagnostic<KtDeclaration>() {
+    interface FunInterfaceWithSuspendFunction : KtFirDiagnostic<KtDeclaration> {
         override val diagnosticClass get() = FunInterfaceWithSuspendFunction::class
     }
 
-    abstract class AbstractPropertyInNonAbstractClass : KtFirDiagnostic<KtModifierListOwner>() {
+    interface AbstractPropertyInNonAbstractClass : KtFirDiagnostic<KtModifierListOwner> {
         override val diagnosticClass get() = AbstractPropertyInNonAbstractClass::class
-        abstract val property: KtCallableSymbol
-        abstract val containingClass: KtClassLikeSymbol
+        val property: KtCallableSymbol
+        val containingClass: KtClassLikeSymbol
     }
 
-    abstract class PrivatePropertyInInterface : KtFirDiagnostic<KtProperty>() {
+    interface PrivatePropertyInInterface : KtFirDiagnostic<KtProperty> {
         override val diagnosticClass get() = PrivatePropertyInInterface::class
     }
 
-    abstract class AbstractPropertyWithInitializer : KtFirDiagnostic<KtExpression>() {
+    interface AbstractPropertyWithInitializer : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = AbstractPropertyWithInitializer::class
     }
 
-    abstract class PropertyInitializerInInterface : KtFirDiagnostic<KtExpression>() {
+    interface PropertyInitializerInInterface : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = PropertyInitializerInInterface::class
     }
 
-    abstract class PropertyWithNoTypeNoInitializer : KtFirDiagnostic<KtProperty>() {
+    interface PropertyWithNoTypeNoInitializer : KtFirDiagnostic<KtProperty> {
         override val diagnosticClass get() = PropertyWithNoTypeNoInitializer::class
     }
 
-    abstract class MustBeInitialized : KtFirDiagnostic<KtProperty>() {
+    interface MustBeInitialized : KtFirDiagnostic<KtProperty> {
         override val diagnosticClass get() = MustBeInitialized::class
     }
 
-    abstract class MustBeInitializedWarning : KtFirDiagnostic<KtProperty>() {
+    interface MustBeInitializedWarning : KtFirDiagnostic<KtProperty> {
         override val diagnosticClass get() = MustBeInitializedWarning::class
     }
 
-    abstract class MustBeInitializedOrBeFinal : KtFirDiagnostic<KtProperty>() {
+    interface MustBeInitializedOrBeFinal : KtFirDiagnostic<KtProperty> {
         override val diagnosticClass get() = MustBeInitializedOrBeFinal::class
     }
 
-    abstract class MustBeInitializedOrBeFinalWarning : KtFirDiagnostic<KtProperty>() {
+    interface MustBeInitializedOrBeFinalWarning : KtFirDiagnostic<KtProperty> {
         override val diagnosticClass get() = MustBeInitializedOrBeFinalWarning::class
     }
 
-    abstract class MustBeInitializedOrBeAbstract : KtFirDiagnostic<KtProperty>() {
+    interface MustBeInitializedOrBeAbstract : KtFirDiagnostic<KtProperty> {
         override val diagnosticClass get() = MustBeInitializedOrBeAbstract::class
     }
 
-    abstract class MustBeInitializedOrBeAbstractWarning : KtFirDiagnostic<KtProperty>() {
+    interface MustBeInitializedOrBeAbstractWarning : KtFirDiagnostic<KtProperty> {
         override val diagnosticClass get() = MustBeInitializedOrBeAbstractWarning::class
     }
 
-    abstract class MustBeInitializedOrFinalOrAbstract : KtFirDiagnostic<KtProperty>() {
+    interface MustBeInitializedOrFinalOrAbstract : KtFirDiagnostic<KtProperty> {
         override val diagnosticClass get() = MustBeInitializedOrFinalOrAbstract::class
     }
 
-    abstract class MustBeInitializedOrFinalOrAbstractWarning : KtFirDiagnostic<KtProperty>() {
+    interface MustBeInitializedOrFinalOrAbstractWarning : KtFirDiagnostic<KtProperty> {
         override val diagnosticClass get() = MustBeInitializedOrFinalOrAbstractWarning::class
     }
 
-    abstract class ExtensionPropertyMustHaveAccessorsOrBeAbstract : KtFirDiagnostic<KtProperty>() {
+    interface ExtensionPropertyMustHaveAccessorsOrBeAbstract : KtFirDiagnostic<KtProperty> {
         override val diagnosticClass get() = ExtensionPropertyMustHaveAccessorsOrBeAbstract::class
     }
 
-    abstract class UnnecessaryLateinit : KtFirDiagnostic<KtProperty>() {
+    interface UnnecessaryLateinit : KtFirDiagnostic<KtProperty> {
         override val diagnosticClass get() = UnnecessaryLateinit::class
     }
 
-    abstract class BackingFieldInInterface : KtFirDiagnostic<KtProperty>() {
+    interface BackingFieldInInterface : KtFirDiagnostic<KtProperty> {
         override val diagnosticClass get() = BackingFieldInInterface::class
     }
 
-    abstract class ExtensionPropertyWithBackingField : KtFirDiagnostic<KtExpression>() {
+    interface ExtensionPropertyWithBackingField : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = ExtensionPropertyWithBackingField::class
     }
 
-    abstract class PropertyInitializerNoBackingField : KtFirDiagnostic<KtExpression>() {
+    interface PropertyInitializerNoBackingField : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = PropertyInitializerNoBackingField::class
     }
 
-    abstract class AbstractDelegatedProperty : KtFirDiagnostic<KtExpression>() {
+    interface AbstractDelegatedProperty : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = AbstractDelegatedProperty::class
     }
 
-    abstract class DelegatedPropertyInInterface : KtFirDiagnostic<KtExpression>() {
+    interface DelegatedPropertyInInterface : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = DelegatedPropertyInInterface::class
     }
 
-    abstract class AbstractPropertyWithGetter : KtFirDiagnostic<KtPropertyAccessor>() {
+    interface AbstractPropertyWithGetter : KtFirDiagnostic<KtPropertyAccessor> {
         override val diagnosticClass get() = AbstractPropertyWithGetter::class
     }
 
-    abstract class AbstractPropertyWithSetter : KtFirDiagnostic<KtPropertyAccessor>() {
+    interface AbstractPropertyWithSetter : KtFirDiagnostic<KtPropertyAccessor> {
         override val diagnosticClass get() = AbstractPropertyWithSetter::class
     }
 
-    abstract class PrivateSetterForAbstractProperty : KtFirDiagnostic<KtModifierListOwner>() {
+    interface PrivateSetterForAbstractProperty : KtFirDiagnostic<KtModifierListOwner> {
         override val diagnosticClass get() = PrivateSetterForAbstractProperty::class
     }
 
-    abstract class PrivateSetterForOpenProperty : KtFirDiagnostic<KtModifierListOwner>() {
+    interface PrivateSetterForOpenProperty : KtFirDiagnostic<KtModifierListOwner> {
         override val diagnosticClass get() = PrivateSetterForOpenProperty::class
     }
 
-    abstract class ValWithSetter : KtFirDiagnostic<KtPropertyAccessor>() {
+    interface ValWithSetter : KtFirDiagnostic<KtPropertyAccessor> {
         override val diagnosticClass get() = ValWithSetter::class
     }
 
-    abstract class ConstValNotTopLevelOrObject : KtFirDiagnostic<KtElement>() {
+    interface ConstValNotTopLevelOrObject : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = ConstValNotTopLevelOrObject::class
     }
 
-    abstract class ConstValWithGetter : KtFirDiagnostic<KtElement>() {
+    interface ConstValWithGetter : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = ConstValWithGetter::class
     }
 
-    abstract class ConstValWithDelegate : KtFirDiagnostic<KtExpression>() {
+    interface ConstValWithDelegate : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = ConstValWithDelegate::class
     }
 
-    abstract class TypeCantBeUsedForConstVal : KtFirDiagnostic<KtProperty>() {
+    interface TypeCantBeUsedForConstVal : KtFirDiagnostic<KtProperty> {
         override val diagnosticClass get() = TypeCantBeUsedForConstVal::class
-        abstract val constValType: KtType
+        val constValType: KtType
     }
 
-    abstract class ConstValWithoutInitializer : KtFirDiagnostic<KtProperty>() {
+    interface ConstValWithoutInitializer : KtFirDiagnostic<KtProperty> {
         override val diagnosticClass get() = ConstValWithoutInitializer::class
     }
 
-    abstract class ConstValWithNonConstInitializer : KtFirDiagnostic<KtExpression>() {
+    interface ConstValWithNonConstInitializer : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = ConstValWithNonConstInitializer::class
     }
 
-    abstract class WrongSetterParameterType : KtFirDiagnostic<KtTypeReference>() {
+    interface WrongSetterParameterType : KtFirDiagnostic<KtTypeReference> {
         override val diagnosticClass get() = WrongSetterParameterType::class
-        abstract val expectedType: KtType
-        abstract val actualType: KtType
+        val expectedType: KtType
+        val actualType: KtType
     }
 
-    abstract class DelegateUsesExtensionPropertyTypeParameterError : KtFirDiagnostic<KtProperty>() {
+    interface DelegateUsesExtensionPropertyTypeParameterError : KtFirDiagnostic<KtProperty> {
         override val diagnosticClass get() = DelegateUsesExtensionPropertyTypeParameterError::class
-        abstract val usedTypeParameter: KtTypeParameterSymbol
+        val usedTypeParameter: KtTypeParameterSymbol
     }
 
-    abstract class DelegateUsesExtensionPropertyTypeParameterWarning : KtFirDiagnostic<KtProperty>() {
+    interface DelegateUsesExtensionPropertyTypeParameterWarning : KtFirDiagnostic<KtProperty> {
         override val diagnosticClass get() = DelegateUsesExtensionPropertyTypeParameterWarning::class
-        abstract val usedTypeParameter: KtTypeParameterSymbol
+        val usedTypeParameter: KtTypeParameterSymbol
     }
 
-    abstract class InitializerTypeMismatch : KtFirDiagnostic<KtProperty>() {
+    interface InitializerTypeMismatch : KtFirDiagnostic<KtProperty> {
         override val diagnosticClass get() = InitializerTypeMismatch::class
-        abstract val expectedType: KtType
-        abstract val actualType: KtType
-        abstract val isMismatchDueToNullability: Boolean
+        val expectedType: KtType
+        val actualType: KtType
+        val isMismatchDueToNullability: Boolean
     }
 
-    abstract class GetterVisibilityDiffersFromPropertyVisibility : KtFirDiagnostic<KtModifierListOwner>() {
+    interface GetterVisibilityDiffersFromPropertyVisibility : KtFirDiagnostic<KtModifierListOwner> {
         override val diagnosticClass get() = GetterVisibilityDiffersFromPropertyVisibility::class
     }
 
-    abstract class SetterVisibilityInconsistentWithPropertyVisibility : KtFirDiagnostic<KtModifierListOwner>() {
+    interface SetterVisibilityInconsistentWithPropertyVisibility : KtFirDiagnostic<KtModifierListOwner> {
         override val diagnosticClass get() = SetterVisibilityInconsistentWithPropertyVisibility::class
     }
 
-    abstract class WrongSetterReturnType : KtFirDiagnostic<KtTypeReference>() {
+    interface WrongSetterReturnType : KtFirDiagnostic<KtTypeReference> {
         override val diagnosticClass get() = WrongSetterReturnType::class
     }
 
-    abstract class WrongGetterReturnType : KtFirDiagnostic<KtTypeReference>() {
+    interface WrongGetterReturnType : KtFirDiagnostic<KtTypeReference> {
         override val diagnosticClass get() = WrongGetterReturnType::class
-        abstract val expectedType: KtType
-        abstract val actualType: KtType
+        val expectedType: KtType
+        val actualType: KtType
     }
 
-    abstract class AccessorForDelegatedProperty : KtFirDiagnostic<KtPropertyAccessor>() {
+    interface AccessorForDelegatedProperty : KtFirDiagnostic<KtPropertyAccessor> {
         override val diagnosticClass get() = AccessorForDelegatedProperty::class
     }
 
-    abstract class PropertyInitializerWithExplicitFieldDeclaration : KtFirDiagnostic<KtExpression>() {
+    interface PropertyInitializerWithExplicitFieldDeclaration : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = PropertyInitializerWithExplicitFieldDeclaration::class
     }
 
-    abstract class PropertyFieldDeclarationMissingInitializer : KtFirDiagnostic<KtBackingField>() {
+    interface PropertyFieldDeclarationMissingInitializer : KtFirDiagnostic<KtBackingField> {
         override val diagnosticClass get() = PropertyFieldDeclarationMissingInitializer::class
     }
 
-    abstract class LateinitPropertyFieldDeclarationWithInitializer : KtFirDiagnostic<KtBackingField>() {
+    interface LateinitPropertyFieldDeclarationWithInitializer : KtFirDiagnostic<KtBackingField> {
         override val diagnosticClass get() = LateinitPropertyFieldDeclarationWithInitializer::class
     }
 
-    abstract class LateinitFieldInValProperty : KtFirDiagnostic<KtBackingField>() {
+    interface LateinitFieldInValProperty : KtFirDiagnostic<KtBackingField> {
         override val diagnosticClass get() = LateinitFieldInValProperty::class
     }
 
-    abstract class LateinitNullableBackingField : KtFirDiagnostic<KtBackingField>() {
+    interface LateinitNullableBackingField : KtFirDiagnostic<KtBackingField> {
         override val diagnosticClass get() = LateinitNullableBackingField::class
     }
 
-    abstract class BackingFieldForDelegatedProperty : KtFirDiagnostic<KtBackingField>() {
+    interface BackingFieldForDelegatedProperty : KtFirDiagnostic<KtBackingField> {
         override val diagnosticClass get() = BackingFieldForDelegatedProperty::class
     }
 
-    abstract class PropertyMustHaveGetter : KtFirDiagnostic<KtProperty>() {
+    interface PropertyMustHaveGetter : KtFirDiagnostic<KtProperty> {
         override val diagnosticClass get() = PropertyMustHaveGetter::class
     }
 
-    abstract class PropertyMustHaveSetter : KtFirDiagnostic<KtProperty>() {
+    interface PropertyMustHaveSetter : KtFirDiagnostic<KtProperty> {
         override val diagnosticClass get() = PropertyMustHaveSetter::class
     }
 
-    abstract class ExplicitBackingFieldInInterface : KtFirDiagnostic<KtBackingField>() {
+    interface ExplicitBackingFieldInInterface : KtFirDiagnostic<KtBackingField> {
         override val diagnosticClass get() = ExplicitBackingFieldInInterface::class
     }
 
-    abstract class ExplicitBackingFieldInAbstractProperty : KtFirDiagnostic<KtBackingField>() {
+    interface ExplicitBackingFieldInAbstractProperty : KtFirDiagnostic<KtBackingField> {
         override val diagnosticClass get() = ExplicitBackingFieldInAbstractProperty::class
     }
 
-    abstract class ExplicitBackingFieldInExtension : KtFirDiagnostic<KtBackingField>() {
+    interface ExplicitBackingFieldInExtension : KtFirDiagnostic<KtBackingField> {
         override val diagnosticClass get() = ExplicitBackingFieldInExtension::class
     }
 
-    abstract class RedundantExplicitBackingField : KtFirDiagnostic<KtBackingField>() {
+    interface RedundantExplicitBackingField : KtFirDiagnostic<KtBackingField> {
         override val diagnosticClass get() = RedundantExplicitBackingField::class
     }
 
-    abstract class AbstractPropertyInPrimaryConstructorParameters : KtFirDiagnostic<KtModifierListOwner>() {
+    interface AbstractPropertyInPrimaryConstructorParameters : KtFirDiagnostic<KtModifierListOwner> {
         override val diagnosticClass get() = AbstractPropertyInPrimaryConstructorParameters::class
     }
 
-    abstract class LocalVariableWithTypeParametersWarning : KtFirDiagnostic<KtProperty>() {
+    interface LocalVariableWithTypeParametersWarning : KtFirDiagnostic<KtProperty> {
         override val diagnosticClass get() = LocalVariableWithTypeParametersWarning::class
     }
 
-    abstract class LocalVariableWithTypeParameters : KtFirDiagnostic<KtProperty>() {
+    interface LocalVariableWithTypeParameters : KtFirDiagnostic<KtProperty> {
         override val diagnosticClass get() = LocalVariableWithTypeParameters::class
     }
 
-    abstract class ExplicitTypeArgumentsInPropertyAccess : KtFirDiagnostic<KtExpression>() {
+    interface ExplicitTypeArgumentsInPropertyAccess : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = ExplicitTypeArgumentsInPropertyAccess::class
     }
 
-    abstract class LateinitIntrinsicCallOnNonLiteral : KtFirDiagnostic<PsiElement>() {
+    interface LateinitIntrinsicCallOnNonLiteral : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = LateinitIntrinsicCallOnNonLiteral::class
     }
 
-    abstract class LateinitIntrinsicCallOnNonLateinit : KtFirDiagnostic<PsiElement>() {
+    interface LateinitIntrinsicCallOnNonLateinit : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = LateinitIntrinsicCallOnNonLateinit::class
     }
 
-    abstract class LateinitIntrinsicCallInInlineFunction : KtFirDiagnostic<PsiElement>() {
+    interface LateinitIntrinsicCallInInlineFunction : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = LateinitIntrinsicCallInInlineFunction::class
     }
 
-    abstract class LateinitIntrinsicCallOnNonAccessibleProperty : KtFirDiagnostic<PsiElement>() {
+    interface LateinitIntrinsicCallOnNonAccessibleProperty : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = LateinitIntrinsicCallOnNonAccessibleProperty::class
-        abstract val declaration: KtSymbol
+        val declaration: KtSymbol
     }
 
-    abstract class LocalExtensionProperty : KtFirDiagnostic<PsiElement>() {
+    interface LocalExtensionProperty : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = LocalExtensionProperty::class
     }
 
-    abstract class ExpectedDeclarationWithBody : KtFirDiagnostic<KtDeclaration>() {
+    interface ExpectedDeclarationWithBody : KtFirDiagnostic<KtDeclaration> {
         override val diagnosticClass get() = ExpectedDeclarationWithBody::class
     }
 
-    abstract class ExpectedClassConstructorDelegationCall : KtFirDiagnostic<KtConstructorDelegationCall>() {
+    interface ExpectedClassConstructorDelegationCall : KtFirDiagnostic<KtConstructorDelegationCall> {
         override val diagnosticClass get() = ExpectedClassConstructorDelegationCall::class
     }
 
-    abstract class ExpectedClassConstructorPropertyParameter : KtFirDiagnostic<KtParameter>() {
+    interface ExpectedClassConstructorPropertyParameter : KtFirDiagnostic<KtParameter> {
         override val diagnosticClass get() = ExpectedClassConstructorPropertyParameter::class
     }
 
-    abstract class ExpectedEnumConstructor : KtFirDiagnostic<KtConstructor<*>>() {
+    interface ExpectedEnumConstructor : KtFirDiagnostic<KtConstructor<*>> {
         override val diagnosticClass get() = ExpectedEnumConstructor::class
     }
 
-    abstract class ExpectedEnumEntryWithBody : KtFirDiagnostic<KtEnumEntry>() {
+    interface ExpectedEnumEntryWithBody : KtFirDiagnostic<KtEnumEntry> {
         override val diagnosticClass get() = ExpectedEnumEntryWithBody::class
     }
 
-    abstract class ExpectedPropertyInitializer : KtFirDiagnostic<KtExpression>() {
+    interface ExpectedPropertyInitializer : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = ExpectedPropertyInitializer::class
     }
 
-    abstract class ExpectedDelegatedProperty : KtFirDiagnostic<KtExpression>() {
+    interface ExpectedDelegatedProperty : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = ExpectedDelegatedProperty::class
     }
 
-    abstract class ExpectedLateinitProperty : KtFirDiagnostic<KtModifierListOwner>() {
+    interface ExpectedLateinitProperty : KtFirDiagnostic<KtModifierListOwner> {
         override val diagnosticClass get() = ExpectedLateinitProperty::class
     }
 
-    abstract class SupertypeInitializedInExpectedClass : KtFirDiagnostic<PsiElement>() {
+    interface SupertypeInitializedInExpectedClass : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = SupertypeInitializedInExpectedClass::class
     }
 
-    abstract class ExpectedPrivateDeclaration : KtFirDiagnostic<KtModifierListOwner>() {
+    interface ExpectedPrivateDeclaration : KtFirDiagnostic<KtModifierListOwner> {
         override val diagnosticClass get() = ExpectedPrivateDeclaration::class
     }
 
-    abstract class ExpectedExternalDeclaration : KtFirDiagnostic<KtModifierListOwner>() {
+    interface ExpectedExternalDeclaration : KtFirDiagnostic<KtModifierListOwner> {
         override val diagnosticClass get() = ExpectedExternalDeclaration::class
     }
 
-    abstract class ExpectedTailrecFunction : KtFirDiagnostic<KtModifierListOwner>() {
+    interface ExpectedTailrecFunction : KtFirDiagnostic<KtModifierListOwner> {
         override val diagnosticClass get() = ExpectedTailrecFunction::class
     }
 
-    abstract class ImplementationByDelegationInExpectClass : KtFirDiagnostic<KtDelegatedSuperTypeEntry>() {
+    interface ImplementationByDelegationInExpectClass : KtFirDiagnostic<KtDelegatedSuperTypeEntry> {
         override val diagnosticClass get() = ImplementationByDelegationInExpectClass::class
     }
 
-    abstract class ActualTypeAliasNotToClass : KtFirDiagnostic<KtTypeAlias>() {
+    interface ActualTypeAliasNotToClass : KtFirDiagnostic<KtTypeAlias> {
         override val diagnosticClass get() = ActualTypeAliasNotToClass::class
     }
 
-    abstract class ActualTypeAliasToClassWithDeclarationSiteVariance : KtFirDiagnostic<KtTypeAlias>() {
+    interface ActualTypeAliasToClassWithDeclarationSiteVariance : KtFirDiagnostic<KtTypeAlias> {
         override val diagnosticClass get() = ActualTypeAliasToClassWithDeclarationSiteVariance::class
     }
 
-    abstract class ActualTypeAliasWithUseSiteVariance : KtFirDiagnostic<KtTypeAlias>() {
+    interface ActualTypeAliasWithUseSiteVariance : KtFirDiagnostic<KtTypeAlias> {
         override val diagnosticClass get() = ActualTypeAliasWithUseSiteVariance::class
     }
 
-    abstract class ActualTypeAliasWithComplexSubstitution : KtFirDiagnostic<KtTypeAlias>() {
+    interface ActualTypeAliasWithComplexSubstitution : KtFirDiagnostic<KtTypeAlias> {
         override val diagnosticClass get() = ActualTypeAliasWithComplexSubstitution::class
     }
 
-    abstract class ActualFunctionWithDefaultArguments : KtFirDiagnostic<PsiElement>() {
+    interface ActualFunctionWithDefaultArguments : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = ActualFunctionWithDefaultArguments::class
     }
 
-    abstract class ActualAnnotationConflictingDefaultArgumentValue : KtFirDiagnostic<PsiElement>() {
+    interface ActualAnnotationConflictingDefaultArgumentValue : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = ActualAnnotationConflictingDefaultArgumentValue::class
-        abstract val parameter: KtVariableLikeSymbol
+        val parameter: KtVariableLikeSymbol
     }
 
-    abstract class ExpectedFunctionSourceWithDefaultArgumentsNotFound : KtFirDiagnostic<PsiElement>() {
+    interface ExpectedFunctionSourceWithDefaultArgumentsNotFound : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = ExpectedFunctionSourceWithDefaultArgumentsNotFound::class
     }
 
-    abstract class NoActualForExpect : KtFirDiagnostic<KtNamedDeclaration>() {
+    interface NoActualForExpect : KtFirDiagnostic<KtNamedDeclaration> {
         override val diagnosticClass get() = NoActualForExpect::class
-        abstract val declaration: KtSymbol
-        abstract val module: FirModuleData
-        abstract val compatibility: Map<ExpectActualCompatibility<FirBasedSymbol<*>>, List<KtSymbol>>
+        val declaration: KtSymbol
+        val module: FirModuleData
+        val compatibility: Map<ExpectActualCompatibility<FirBasedSymbol<*>>, List<KtSymbol>>
     }
 
-    abstract class ActualWithoutExpect : KtFirDiagnostic<KtNamedDeclaration>() {
+    interface ActualWithoutExpect : KtFirDiagnostic<KtNamedDeclaration> {
         override val diagnosticClass get() = ActualWithoutExpect::class
-        abstract val declaration: KtSymbol
-        abstract val compatibility: Map<ExpectActualCompatibility<FirBasedSymbol<*>>, List<KtSymbol>>
+        val declaration: KtSymbol
+        val compatibility: Map<ExpectActualCompatibility<FirBasedSymbol<*>>, List<KtSymbol>>
     }
 
-    abstract class AmbiguousActuals : KtFirDiagnostic<KtNamedDeclaration>() {
+    interface AmbiguousActuals : KtFirDiagnostic<KtNamedDeclaration> {
         override val diagnosticClass get() = AmbiguousActuals::class
-        abstract val declaration: KtSymbol
-        abstract val candidates: List<KtSymbol>
+        val declaration: KtSymbol
+        val candidates: List<KtSymbol>
     }
 
-    abstract class AmbiguousExpects : KtFirDiagnostic<KtNamedDeclaration>() {
+    interface AmbiguousExpects : KtFirDiagnostic<KtNamedDeclaration> {
         override val diagnosticClass get() = AmbiguousExpects::class
-        abstract val declaration: KtSymbol
-        abstract val modules: List<FirModuleData>
+        val declaration: KtSymbol
+        val modules: List<FirModuleData>
     }
 
-    abstract class NoActualClassMemberForExpectedClass : KtFirDiagnostic<KtNamedDeclaration>() {
+    interface NoActualClassMemberForExpectedClass : KtFirDiagnostic<KtNamedDeclaration> {
         override val diagnosticClass get() = NoActualClassMemberForExpectedClass::class
-        abstract val declaration: KtSymbol
-        abstract val members: List<Pair<KtSymbol, Map<Incompatible<FirBasedSymbol<*>>, List<KtSymbol>>>>
+        val declaration: KtSymbol
+        val members: List<Pair<KtSymbol, Map<Incompatible<FirBasedSymbol<*>>, List<KtSymbol>>>>
     }
 
-    abstract class ActualMissing : KtFirDiagnostic<KtNamedDeclaration>() {
+    interface ActualMissing : KtFirDiagnostic<KtNamedDeclaration> {
         override val diagnosticClass get() = ActualMissing::class
     }
 
-    abstract class InitializerRequiredForDestructuringDeclaration : KtFirDiagnostic<KtDestructuringDeclaration>() {
+    interface InitializerRequiredForDestructuringDeclaration : KtFirDiagnostic<KtDestructuringDeclaration> {
         override val diagnosticClass get() = InitializerRequiredForDestructuringDeclaration::class
     }
 
-    abstract class ComponentFunctionMissing : KtFirDiagnostic<PsiElement>() {
+    interface ComponentFunctionMissing : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = ComponentFunctionMissing::class
-        abstract val missingFunctionName: Name
-        abstract val destructingType: KtType
+        val missingFunctionName: Name
+        val destructingType: KtType
     }
 
-    abstract class ComponentFunctionAmbiguity : KtFirDiagnostic<PsiElement>() {
+    interface ComponentFunctionAmbiguity : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = ComponentFunctionAmbiguity::class
-        abstract val functionWithAmbiguityName: Name
-        abstract val candidates: List<KtSymbol>
+        val functionWithAmbiguityName: Name
+        val candidates: List<KtSymbol>
     }
 
-    abstract class ComponentFunctionOnNullable : KtFirDiagnostic<KtExpression>() {
+    interface ComponentFunctionOnNullable : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = ComponentFunctionOnNullable::class
-        abstract val componentFunctionName: Name
+        val componentFunctionName: Name
     }
 
-    abstract class ComponentFunctionReturnTypeMismatch : KtFirDiagnostic<KtExpression>() {
+    interface ComponentFunctionReturnTypeMismatch : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = ComponentFunctionReturnTypeMismatch::class
-        abstract val componentFunctionName: Name
-        abstract val destructingType: KtType
-        abstract val expectedType: KtType
+        val componentFunctionName: Name
+        val destructingType: KtType
+        val expectedType: KtType
     }
 
-    abstract class UninitializedVariable : KtFirDiagnostic<KtExpression>() {
+    interface UninitializedVariable : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = UninitializedVariable::class
-        abstract val variable: KtVariableSymbol
+        val variable: KtVariableSymbol
     }
 
-    abstract class UninitializedParameter : KtFirDiagnostic<KtSimpleNameExpression>() {
+    interface UninitializedParameter : KtFirDiagnostic<KtSimpleNameExpression> {
         override val diagnosticClass get() = UninitializedParameter::class
-        abstract val parameter: KtSymbol
+        val parameter: KtSymbol
     }
 
-    abstract class UninitializedEnumEntry : KtFirDiagnostic<KtExpression>() {
+    interface UninitializedEnumEntry : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = UninitializedEnumEntry::class
-        abstract val enumEntry: KtSymbol
+        val enumEntry: KtSymbol
     }
 
-    abstract class UninitializedEnumCompanion : KtFirDiagnostic<KtExpression>() {
+    interface UninitializedEnumCompanion : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = UninitializedEnumCompanion::class
-        abstract val enumClass: KtClassLikeSymbol
+        val enumClass: KtClassLikeSymbol
     }
 
-    abstract class ValReassignment : KtFirDiagnostic<KtExpression>() {
+    interface ValReassignment : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = ValReassignment::class
-        abstract val variable: KtVariableLikeSymbol
+        val variable: KtVariableLikeSymbol
     }
 
-    abstract class ValReassignmentViaBackingFieldError : KtFirDiagnostic<KtExpression>() {
+    interface ValReassignmentViaBackingFieldError : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = ValReassignmentViaBackingFieldError::class
-        abstract val property: KtVariableSymbol
+        val property: KtVariableSymbol
     }
 
-    abstract class ValReassignmentViaBackingFieldWarning : KtFirDiagnostic<KtExpression>() {
+    interface ValReassignmentViaBackingFieldWarning : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = ValReassignmentViaBackingFieldWarning::class
-        abstract val property: KtVariableSymbol
+        val property: KtVariableSymbol
     }
 
-    abstract class CapturedValInitialization : KtFirDiagnostic<KtExpression>() {
+    interface CapturedValInitialization : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = CapturedValInitialization::class
-        abstract val property: KtVariableSymbol
+        val property: KtVariableSymbol
     }
 
-    abstract class CapturedMemberValInitialization : KtFirDiagnostic<KtExpression>() {
+    interface CapturedMemberValInitialization : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = CapturedMemberValInitialization::class
-        abstract val property: KtVariableSymbol
+        val property: KtVariableSymbol
     }
 
-    abstract class SetterProjectedOut : KtFirDiagnostic<KtBinaryExpression>() {
+    interface SetterProjectedOut : KtFirDiagnostic<KtBinaryExpression> {
         override val diagnosticClass get() = SetterProjectedOut::class
-        abstract val property: KtVariableSymbol
+        val property: KtVariableSymbol
     }
 
-    abstract class WrongInvocationKind : KtFirDiagnostic<PsiElement>() {
+    interface WrongInvocationKind : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = WrongInvocationKind::class
-        abstract val declaration: KtSymbol
-        abstract val requiredRange: EventOccurrencesRange
-        abstract val actualRange: EventOccurrencesRange
+        val declaration: KtSymbol
+        val requiredRange: EventOccurrencesRange
+        val actualRange: EventOccurrencesRange
     }
 
-    abstract class LeakedInPlaceLambda : KtFirDiagnostic<PsiElement>() {
+    interface LeakedInPlaceLambda : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = LeakedInPlaceLambda::class
-        abstract val lambda: KtSymbol
+        val lambda: KtSymbol
     }
 
-    abstract class WrongImpliesCondition : KtFirDiagnostic<PsiElement>() {
+    interface WrongImpliesCondition : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = WrongImpliesCondition::class
     }
 
-    abstract class VariableWithNoTypeNoInitializer : KtFirDiagnostic<KtVariableDeclaration>() {
+    interface VariableWithNoTypeNoInitializer : KtFirDiagnostic<KtVariableDeclaration> {
         override val diagnosticClass get() = VariableWithNoTypeNoInitializer::class
     }
 
-    abstract class InitializationBeforeDeclaration : KtFirDiagnostic<KtExpression>() {
+    interface InitializationBeforeDeclaration : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = InitializationBeforeDeclaration::class
-        abstract val property: KtSymbol
+        val property: KtSymbol
     }
 
-    abstract class UnreachableCode : KtFirDiagnostic<KtElement>() {
+    interface UnreachableCode : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = UnreachableCode::class
-        abstract val reachable: List<PsiElement>
-        abstract val unreachable: List<PsiElement>
+        val reachable: List<PsiElement>
+        val unreachable: List<PsiElement>
     }
 
-    abstract class SenselessComparison : KtFirDiagnostic<KtExpression>() {
+    interface SenselessComparison : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = SenselessComparison::class
-        abstract val expression: KtExpression
-        abstract val compareResult: Boolean
+        val expression: KtExpression
+        val compareResult: Boolean
     }
 
-    abstract class SenselessNullInWhen : KtFirDiagnostic<KtElement>() {
+    interface SenselessNullInWhen : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = SenselessNullInWhen::class
     }
 
-    abstract class TypecheckerHasRunIntoRecursiveProblem : KtFirDiagnostic<KtExpression>() {
+    interface TypecheckerHasRunIntoRecursiveProblem : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = TypecheckerHasRunIntoRecursiveProblem::class
     }
 
-    abstract class UnsafeCall : KtFirDiagnostic<PsiElement>() {
+    interface UnsafeCall : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = UnsafeCall::class
-        abstract val receiverType: KtType
-        abstract val receiverExpression: KtExpression?
+        val receiverType: KtType
+        val receiverExpression: KtExpression?
     }
 
-    abstract class UnsafeImplicitInvokeCall : KtFirDiagnostic<PsiElement>() {
+    interface UnsafeImplicitInvokeCall : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = UnsafeImplicitInvokeCall::class
-        abstract val receiverType: KtType
+        val receiverType: KtType
     }
 
-    abstract class UnsafeInfixCall : KtFirDiagnostic<KtExpression>() {
+    interface UnsafeInfixCall : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = UnsafeInfixCall::class
-        abstract val receiverExpression: KtExpression
-        abstract val operator: String
-        abstract val argumentExpression: KtExpression
+        val receiverExpression: KtExpression
+        val operator: String
+        val argumentExpression: KtExpression
     }
 
-    abstract class UnsafeOperatorCall : KtFirDiagnostic<KtExpression>() {
+    interface UnsafeOperatorCall : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = UnsafeOperatorCall::class
-        abstract val receiverExpression: KtExpression
-        abstract val operator: String
-        abstract val argumentExpression: KtExpression
+        val receiverExpression: KtExpression
+        val operator: String
+        val argumentExpression: KtExpression
     }
 
-    abstract class IteratorOnNullable : KtFirDiagnostic<KtExpression>() {
+    interface IteratorOnNullable : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = IteratorOnNullable::class
     }
 
-    abstract class UnnecessarySafeCall : KtFirDiagnostic<PsiElement>() {
+    interface UnnecessarySafeCall : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = UnnecessarySafeCall::class
-        abstract val receiverType: KtType
+        val receiverType: KtType
     }
 
-    abstract class SafeCallWillChangeNullability : KtFirDiagnostic<KtSafeQualifiedExpression>() {
+    interface SafeCallWillChangeNullability : KtFirDiagnostic<KtSafeQualifiedExpression> {
         override val diagnosticClass get() = SafeCallWillChangeNullability::class
     }
 
-    abstract class UnexpectedSafeCall : KtFirDiagnostic<PsiElement>() {
+    interface UnexpectedSafeCall : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = UnexpectedSafeCall::class
     }
 
-    abstract class UnnecessaryNotNullAssertion : KtFirDiagnostic<KtExpression>() {
+    interface UnnecessaryNotNullAssertion : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = UnnecessaryNotNullAssertion::class
-        abstract val receiverType: KtType
+        val receiverType: KtType
     }
 
-    abstract class NotNullAssertionOnLambdaExpression : KtFirDiagnostic<KtExpression>() {
+    interface NotNullAssertionOnLambdaExpression : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = NotNullAssertionOnLambdaExpression::class
     }
 
-    abstract class NotNullAssertionOnCallableReference : KtFirDiagnostic<KtExpression>() {
+    interface NotNullAssertionOnCallableReference : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = NotNullAssertionOnCallableReference::class
     }
 
-    abstract class UselessElvis : KtFirDiagnostic<KtBinaryExpression>() {
+    interface UselessElvis : KtFirDiagnostic<KtBinaryExpression> {
         override val diagnosticClass get() = UselessElvis::class
-        abstract val receiverType: KtType
+        val receiverType: KtType
     }
 
-    abstract class UselessElvisRightIsNull : KtFirDiagnostic<KtBinaryExpression>() {
+    interface UselessElvisRightIsNull : KtFirDiagnostic<KtBinaryExpression> {
         override val diagnosticClass get() = UselessElvisRightIsNull::class
     }
 
-    abstract class CannotCheckForErased : KtFirDiagnostic<PsiElement>() {
+    interface CannotCheckForErased : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = CannotCheckForErased::class
-        abstract val type: KtType
+        val type: KtType
     }
 
-    abstract class CastNeverSucceeds : KtFirDiagnostic<KtBinaryExpressionWithTypeRHS>() {
+    interface CastNeverSucceeds : KtFirDiagnostic<KtBinaryExpressionWithTypeRHS> {
         override val diagnosticClass get() = CastNeverSucceeds::class
     }
 
-    abstract class UselessCast : KtFirDiagnostic<KtBinaryExpressionWithTypeRHS>() {
+    interface UselessCast : KtFirDiagnostic<KtBinaryExpressionWithTypeRHS> {
         override val diagnosticClass get() = UselessCast::class
     }
 
-    abstract class UncheckedCast : KtFirDiagnostic<KtBinaryExpressionWithTypeRHS>() {
+    interface UncheckedCast : KtFirDiagnostic<KtBinaryExpressionWithTypeRHS> {
         override val diagnosticClass get() = UncheckedCast::class
-        abstract val originalType: KtType
-        abstract val targetType: KtType
+        val originalType: KtType
+        val targetType: KtType
     }
 
-    abstract class UselessIsCheck : KtFirDiagnostic<KtElement>() {
+    interface UselessIsCheck : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = UselessIsCheck::class
-        abstract val compileTimeCheckResult: Boolean
+        val compileTimeCheckResult: Boolean
     }
 
-    abstract class IsEnumEntry : KtFirDiagnostic<KtTypeReference>() {
+    interface IsEnumEntry : KtFirDiagnostic<KtTypeReference> {
         override val diagnosticClass get() = IsEnumEntry::class
     }
 
-    abstract class EnumEntryAsType : KtFirDiagnostic<KtTypeReference>() {
+    interface EnumEntryAsType : KtFirDiagnostic<KtTypeReference> {
         override val diagnosticClass get() = EnumEntryAsType::class
     }
 
-    abstract class ExpectedCondition : KtFirDiagnostic<KtWhenCondition>() {
+    interface ExpectedCondition : KtFirDiagnostic<KtWhenCondition> {
         override val diagnosticClass get() = ExpectedCondition::class
     }
 
-    abstract class NoElseInWhen : KtFirDiagnostic<KtWhenExpression>() {
+    interface NoElseInWhen : KtFirDiagnostic<KtWhenExpression> {
         override val diagnosticClass get() = NoElseInWhen::class
-        abstract val missingWhenCases: List<WhenMissingCase>
+        val missingWhenCases: List<WhenMissingCase>
     }
 
-    abstract class NonExhaustiveWhenStatement : KtFirDiagnostic<KtWhenExpression>() {
+    interface NonExhaustiveWhenStatement : KtFirDiagnostic<KtWhenExpression> {
         override val diagnosticClass get() = NonExhaustiveWhenStatement::class
-        abstract val type: String
-        abstract val missingWhenCases: List<WhenMissingCase>
+        val type: String
+        val missingWhenCases: List<WhenMissingCase>
     }
 
-    abstract class InvalidIfAsExpression : KtFirDiagnostic<KtIfExpression>() {
+    interface InvalidIfAsExpression : KtFirDiagnostic<KtIfExpression> {
         override val diagnosticClass get() = InvalidIfAsExpression::class
     }
 
-    abstract class ElseMisplacedInWhen : KtFirDiagnostic<KtWhenEntry>() {
+    interface ElseMisplacedInWhen : KtFirDiagnostic<KtWhenEntry> {
         override val diagnosticClass get() = ElseMisplacedInWhen::class
     }
 
-    abstract class IllegalDeclarationInWhenSubject : KtFirDiagnostic<KtElement>() {
+    interface IllegalDeclarationInWhenSubject : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = IllegalDeclarationInWhenSubject::class
-        abstract val illegalReason: String
+        val illegalReason: String
     }
 
-    abstract class CommaInWhenConditionWithoutArgument : KtFirDiagnostic<PsiElement>() {
+    interface CommaInWhenConditionWithoutArgument : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = CommaInWhenConditionWithoutArgument::class
     }
 
-    abstract class DuplicateLabelInWhen : KtFirDiagnostic<KtElement>() {
+    interface DuplicateLabelInWhen : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = DuplicateLabelInWhen::class
     }
 
-    abstract class ConfusingBranchConditionError : KtFirDiagnostic<PsiElement>() {
+    interface ConfusingBranchConditionError : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = ConfusingBranchConditionError::class
     }
 
-    abstract class ConfusingBranchConditionWarning : KtFirDiagnostic<PsiElement>() {
+    interface ConfusingBranchConditionWarning : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = ConfusingBranchConditionWarning::class
     }
 
-    abstract class TypeParameterIsNotAnExpression : KtFirDiagnostic<KtSimpleNameExpression>() {
+    interface TypeParameterIsNotAnExpression : KtFirDiagnostic<KtSimpleNameExpression> {
         override val diagnosticClass get() = TypeParameterIsNotAnExpression::class
-        abstract val typeParameter: KtTypeParameterSymbol
+        val typeParameter: KtTypeParameterSymbol
     }
 
-    abstract class TypeParameterOnLhsOfDot : KtFirDiagnostic<KtSimpleNameExpression>() {
+    interface TypeParameterOnLhsOfDot : KtFirDiagnostic<KtSimpleNameExpression> {
         override val diagnosticClass get() = TypeParameterOnLhsOfDot::class
-        abstract val typeParameter: KtTypeParameterSymbol
+        val typeParameter: KtTypeParameterSymbol
     }
 
-    abstract class NoCompanionObject : KtFirDiagnostic<KtExpression>() {
+    interface NoCompanionObject : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = NoCompanionObject::class
-        abstract val klass: KtClassLikeSymbol
+        val klass: KtClassLikeSymbol
     }
 
-    abstract class ExpressionExpectedPackageFound : KtFirDiagnostic<KtExpression>() {
+    interface ExpressionExpectedPackageFound : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = ExpressionExpectedPackageFound::class
     }
 
-    abstract class ErrorInContractDescription : KtFirDiagnostic<KtElement>() {
+    interface ErrorInContractDescription : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = ErrorInContractDescription::class
-        abstract val reason: String
+        val reason: String
     }
 
-    abstract class ContractNotAllowed : KtFirDiagnostic<KtElement>() {
+    interface ContractNotAllowed : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = ContractNotAllowed::class
-        abstract val reason: String
+        val reason: String
     }
 
-    abstract class NoGetMethod : KtFirDiagnostic<KtArrayAccessExpression>() {
+    interface NoGetMethod : KtFirDiagnostic<KtArrayAccessExpression> {
         override val diagnosticClass get() = NoGetMethod::class
     }
 
-    abstract class NoSetMethod : KtFirDiagnostic<KtArrayAccessExpression>() {
+    interface NoSetMethod : KtFirDiagnostic<KtArrayAccessExpression> {
         override val diagnosticClass get() = NoSetMethod::class
     }
 
-    abstract class IteratorMissing : KtFirDiagnostic<KtExpression>() {
+    interface IteratorMissing : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = IteratorMissing::class
     }
 
-    abstract class HasNextMissing : KtFirDiagnostic<KtExpression>() {
+    interface HasNextMissing : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = HasNextMissing::class
     }
 
-    abstract class NextMissing : KtFirDiagnostic<KtExpression>() {
+    interface NextMissing : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = NextMissing::class
     }
 
-    abstract class HasNextFunctionNoneApplicable : KtFirDiagnostic<KtExpression>() {
+    interface HasNextFunctionNoneApplicable : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = HasNextFunctionNoneApplicable::class
-        abstract val candidates: List<KtSymbol>
+        val candidates: List<KtSymbol>
     }
 
-    abstract class NextNoneApplicable : KtFirDiagnostic<KtExpression>() {
+    interface NextNoneApplicable : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = NextNoneApplicable::class
-        abstract val candidates: List<KtSymbol>
+        val candidates: List<KtSymbol>
     }
 
-    abstract class DelegateSpecialFunctionMissing : KtFirDiagnostic<KtExpression>() {
+    interface DelegateSpecialFunctionMissing : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = DelegateSpecialFunctionMissing::class
-        abstract val expectedFunctionSignature: String
-        abstract val delegateType: KtType
-        abstract val description: String
+        val expectedFunctionSignature: String
+        val delegateType: KtType
+        val description: String
     }
 
-    abstract class DelegateSpecialFunctionAmbiguity : KtFirDiagnostic<KtExpression>() {
+    interface DelegateSpecialFunctionAmbiguity : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = DelegateSpecialFunctionAmbiguity::class
-        abstract val expectedFunctionSignature: String
-        abstract val candidates: List<KtSymbol>
+        val expectedFunctionSignature: String
+        val candidates: List<KtSymbol>
     }
 
-    abstract class DelegateSpecialFunctionNoneApplicable : KtFirDiagnostic<KtExpression>() {
+    interface DelegateSpecialFunctionNoneApplicable : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = DelegateSpecialFunctionNoneApplicable::class
-        abstract val expectedFunctionSignature: String
-        abstract val candidates: List<KtSymbol>
+        val expectedFunctionSignature: String
+        val candidates: List<KtSymbol>
     }
 
-    abstract class DelegateSpecialFunctionReturnTypeMismatch : KtFirDiagnostic<KtExpression>() {
+    interface DelegateSpecialFunctionReturnTypeMismatch : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = DelegateSpecialFunctionReturnTypeMismatch::class
-        abstract val delegateFunction: String
-        abstract val expectedType: KtType
-        abstract val actualType: KtType
+        val delegateFunction: String
+        val expectedType: KtType
+        val actualType: KtType
     }
 
-    abstract class UnderscoreIsReserved : KtFirDiagnostic<PsiElement>() {
+    interface UnderscoreIsReserved : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = UnderscoreIsReserved::class
     }
 
-    abstract class UnderscoreUsageWithoutBackticks : KtFirDiagnostic<PsiElement>() {
+    interface UnderscoreUsageWithoutBackticks : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = UnderscoreUsageWithoutBackticks::class
     }
 
-    abstract class ResolvedToUnderscoreNamedCatchParameter : KtFirDiagnostic<KtNameReferenceExpression>() {
+    interface ResolvedToUnderscoreNamedCatchParameter : KtFirDiagnostic<KtNameReferenceExpression> {
         override val diagnosticClass get() = ResolvedToUnderscoreNamedCatchParameter::class
     }
 
-    abstract class InvalidCharacters : KtFirDiagnostic<KtNamedDeclaration>() {
+    interface InvalidCharacters : KtFirDiagnostic<KtNamedDeclaration> {
         override val diagnosticClass get() = InvalidCharacters::class
-        abstract val message: String
+        val message: String
     }
 
-    abstract class DangerousCharacters : KtFirDiagnostic<KtNamedDeclaration>() {
+    interface DangerousCharacters : KtFirDiagnostic<KtNamedDeclaration> {
         override val diagnosticClass get() = DangerousCharacters::class
-        abstract val characters: String
+        val characters: String
     }
 
-    abstract class EqualityNotApplicable : KtFirDiagnostic<KtBinaryExpression>() {
+    interface EqualityNotApplicable : KtFirDiagnostic<KtBinaryExpression> {
         override val diagnosticClass get() = EqualityNotApplicable::class
-        abstract val operator: String
-        abstract val leftType: KtType
-        abstract val rightType: KtType
+        val operator: String
+        val leftType: KtType
+        val rightType: KtType
     }
 
-    abstract class EqualityNotApplicableWarning : KtFirDiagnostic<KtBinaryExpression>() {
+    interface EqualityNotApplicableWarning : KtFirDiagnostic<KtBinaryExpression> {
         override val diagnosticClass get() = EqualityNotApplicableWarning::class
-        abstract val operator: String
-        abstract val leftType: KtType
-        abstract val rightType: KtType
+        val operator: String
+        val leftType: KtType
+        val rightType: KtType
     }
 
-    abstract class IncompatibleEnumComparisonError : KtFirDiagnostic<KtElement>() {
+    interface IncompatibleEnumComparisonError : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = IncompatibleEnumComparisonError::class
-        abstract val leftType: KtType
-        abstract val rightType: KtType
+        val leftType: KtType
+        val rightType: KtType
     }
 
-    abstract class IncompatibleEnumComparison : KtFirDiagnostic<KtElement>() {
+    interface IncompatibleEnumComparison : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = IncompatibleEnumComparison::class
-        abstract val leftType: KtType
-        abstract val rightType: KtType
+        val leftType: KtType
+        val rightType: KtType
     }
 
-    abstract class ForbiddenIdentityEquals : KtFirDiagnostic<KtElement>() {
+    interface ForbiddenIdentityEquals : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = ForbiddenIdentityEquals::class
-        abstract val leftType: KtType
-        abstract val rightType: KtType
+        val leftType: KtType
+        val rightType: KtType
     }
 
-    abstract class ForbiddenIdentityEqualsWarning : KtFirDiagnostic<KtElement>() {
+    interface ForbiddenIdentityEqualsWarning : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = ForbiddenIdentityEqualsWarning::class
-        abstract val leftType: KtType
-        abstract val rightType: KtType
+        val leftType: KtType
+        val rightType: KtType
     }
 
-    abstract class DeprecatedIdentityEquals : KtFirDiagnostic<KtElement>() {
+    interface DeprecatedIdentityEquals : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = DeprecatedIdentityEquals::class
-        abstract val leftType: KtType
-        abstract val rightType: KtType
+        val leftType: KtType
+        val rightType: KtType
     }
 
-    abstract class ImplicitBoxingInIdentityEquals : KtFirDiagnostic<KtElement>() {
+    interface ImplicitBoxingInIdentityEquals : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = ImplicitBoxingInIdentityEquals::class
-        abstract val leftType: KtType
-        abstract val rightType: KtType
+        val leftType: KtType
+        val rightType: KtType
     }
 
-    abstract class IncDecShouldNotReturnUnit : KtFirDiagnostic<KtExpression>() {
+    interface IncDecShouldNotReturnUnit : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = IncDecShouldNotReturnUnit::class
     }
 
-    abstract class AssignmentOperatorShouldReturnUnit : KtFirDiagnostic<KtExpression>() {
+    interface AssignmentOperatorShouldReturnUnit : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = AssignmentOperatorShouldReturnUnit::class
-        abstract val functionSymbol: KtFunctionLikeSymbol
-        abstract val operator: String
+        val functionSymbol: KtFunctionLikeSymbol
+        val operator: String
     }
 
-    abstract class PropertyAsOperator : KtFirDiagnostic<PsiElement>() {
+    interface PropertyAsOperator : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = PropertyAsOperator::class
-        abstract val property: KtVariableSymbol
+        val property: KtVariableSymbol
     }
 
-    abstract class DslScopeViolation : KtFirDiagnostic<PsiElement>() {
+    interface DslScopeViolation : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = DslScopeViolation::class
-        abstract val calleeSymbol: KtSymbol
+        val calleeSymbol: KtSymbol
     }
 
-    abstract class ToplevelTypealiasesOnly : KtFirDiagnostic<KtTypeAlias>() {
+    interface ToplevelTypealiasesOnly : KtFirDiagnostic<KtTypeAlias> {
         override val diagnosticClass get() = ToplevelTypealiasesOnly::class
     }
 
-    abstract class RecursiveTypealiasExpansion : KtFirDiagnostic<KtElement>() {
+    interface RecursiveTypealiasExpansion : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = RecursiveTypealiasExpansion::class
     }
 
-    abstract class TypealiasShouldExpandToClass : KtFirDiagnostic<KtElement>() {
+    interface TypealiasShouldExpandToClass : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = TypealiasShouldExpandToClass::class
-        abstract val expandedType: KtType
+        val expandedType: KtType
     }
 
-    abstract class RedundantVisibilityModifier : KtFirDiagnostic<KtModifierListOwner>() {
+    interface RedundantVisibilityModifier : KtFirDiagnostic<KtModifierListOwner> {
         override val diagnosticClass get() = RedundantVisibilityModifier::class
     }
 
-    abstract class RedundantModalityModifier : KtFirDiagnostic<KtModifierListOwner>() {
+    interface RedundantModalityModifier : KtFirDiagnostic<KtModifierListOwner> {
         override val diagnosticClass get() = RedundantModalityModifier::class
     }
 
-    abstract class RedundantReturnUnitType : KtFirDiagnostic<KtTypeReference>() {
+    interface RedundantReturnUnitType : KtFirDiagnostic<KtTypeReference> {
         override val diagnosticClass get() = RedundantReturnUnitType::class
     }
 
-    abstract class RedundantExplicitType : KtFirDiagnostic<PsiElement>() {
+    interface RedundantExplicitType : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = RedundantExplicitType::class
     }
 
-    abstract class RedundantSingleExpressionStringTemplate : KtFirDiagnostic<PsiElement>() {
+    interface RedundantSingleExpressionStringTemplate : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = RedundantSingleExpressionStringTemplate::class
     }
 
-    abstract class CanBeVal : KtFirDiagnostic<KtDeclaration>() {
+    interface CanBeVal : KtFirDiagnostic<KtDeclaration> {
         override val diagnosticClass get() = CanBeVal::class
     }
 
-    abstract class CanBeReplacedWithOperatorAssignment : KtFirDiagnostic<KtExpression>() {
+    interface CanBeReplacedWithOperatorAssignment : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = CanBeReplacedWithOperatorAssignment::class
     }
 
-    abstract class RedundantCallOfConversionMethod : KtFirDiagnostic<PsiElement>() {
+    interface RedundantCallOfConversionMethod : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = RedundantCallOfConversionMethod::class
     }
 
-    abstract class ArrayEqualityOperatorCanBeReplacedWithEquals : KtFirDiagnostic<KtExpression>() {
+    interface ArrayEqualityOperatorCanBeReplacedWithEquals : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = ArrayEqualityOperatorCanBeReplacedWithEquals::class
     }
 
-    abstract class EmptyRange : KtFirDiagnostic<PsiElement>() {
+    interface EmptyRange : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = EmptyRange::class
     }
 
-    abstract class RedundantSetterParameterType : KtFirDiagnostic<PsiElement>() {
+    interface RedundantSetterParameterType : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = RedundantSetterParameterType::class
     }
 
-    abstract class UnusedVariable : KtFirDiagnostic<KtNamedDeclaration>() {
+    interface UnusedVariable : KtFirDiagnostic<KtNamedDeclaration> {
         override val diagnosticClass get() = UnusedVariable::class
     }
 
-    abstract class AssignedValueIsNeverRead : KtFirDiagnostic<PsiElement>() {
+    interface AssignedValueIsNeverRead : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = AssignedValueIsNeverRead::class
     }
 
-    abstract class VariableInitializerIsRedundant : KtFirDiagnostic<PsiElement>() {
+    interface VariableInitializerIsRedundant : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = VariableInitializerIsRedundant::class
     }
 
-    abstract class VariableNeverRead : KtFirDiagnostic<KtNamedDeclaration>() {
+    interface VariableNeverRead : KtFirDiagnostic<KtNamedDeclaration> {
         override val diagnosticClass get() = VariableNeverRead::class
     }
 
-    abstract class UselessCallOnNotNull : KtFirDiagnostic<PsiElement>() {
+    interface UselessCallOnNotNull : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = UselessCallOnNotNull::class
     }
 
-    abstract class ReturnNotAllowed : KtFirDiagnostic<KtReturnExpression>() {
+    interface ReturnNotAllowed : KtFirDiagnostic<KtReturnExpression> {
         override val diagnosticClass get() = ReturnNotAllowed::class
     }
 
-    abstract class NotAFunctionLabel : KtFirDiagnostic<KtReturnExpression>() {
+    interface NotAFunctionLabel : KtFirDiagnostic<KtReturnExpression> {
         override val diagnosticClass get() = NotAFunctionLabel::class
     }
 
-    abstract class ReturnInFunctionWithExpressionBody : KtFirDiagnostic<KtReturnExpression>() {
+    interface ReturnInFunctionWithExpressionBody : KtFirDiagnostic<KtReturnExpression> {
         override val diagnosticClass get() = ReturnInFunctionWithExpressionBody::class
     }
 
-    abstract class NoReturnInFunctionWithBlockBody : KtFirDiagnostic<KtDeclarationWithBody>() {
+    interface NoReturnInFunctionWithBlockBody : KtFirDiagnostic<KtDeclarationWithBody> {
         override val diagnosticClass get() = NoReturnInFunctionWithBlockBody::class
     }
 
-    abstract class AnonymousInitializerInInterface : KtFirDiagnostic<KtAnonymousInitializer>() {
+    interface AnonymousInitializerInInterface : KtFirDiagnostic<KtAnonymousInitializer> {
         override val diagnosticClass get() = AnonymousInitializerInInterface::class
     }
 
-    abstract class UsageIsNotInlinable : KtFirDiagnostic<KtElement>() {
+    interface UsageIsNotInlinable : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = UsageIsNotInlinable::class
-        abstract val parameter: KtSymbol
+        val parameter: KtSymbol
     }
 
-    abstract class NonLocalReturnNotAllowed : KtFirDiagnostic<KtElement>() {
+    interface NonLocalReturnNotAllowed : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = NonLocalReturnNotAllowed::class
-        abstract val parameter: KtSymbol
+        val parameter: KtSymbol
     }
 
-    abstract class NotYetSupportedInInline : KtFirDiagnostic<KtDeclaration>() {
+    interface NotYetSupportedInInline : KtFirDiagnostic<KtDeclaration> {
         override val diagnosticClass get() = NotYetSupportedInInline::class
-        abstract val message: String
+        val message: String
     }
 
-    abstract class NothingToInline : KtFirDiagnostic<KtDeclaration>() {
+    interface NothingToInline : KtFirDiagnostic<KtDeclaration> {
         override val diagnosticClass get() = NothingToInline::class
     }
 
-    abstract class NullableInlineParameter : KtFirDiagnostic<KtDeclaration>() {
+    interface NullableInlineParameter : KtFirDiagnostic<KtDeclaration> {
         override val diagnosticClass get() = NullableInlineParameter::class
-        abstract val parameter: KtSymbol
-        abstract val function: KtSymbol
+        val parameter: KtSymbol
+        val function: KtSymbol
     }
 
-    abstract class RecursionInInline : KtFirDiagnostic<KtElement>() {
+    interface RecursionInInline : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = RecursionInInline::class
-        abstract val symbol: KtSymbol
+        val symbol: KtSymbol
     }
 
-    abstract class NonPublicCallFromPublicInline : KtFirDiagnostic<KtElement>() {
+    interface NonPublicCallFromPublicInline : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = NonPublicCallFromPublicInline::class
-        abstract val inlineDeclaration: KtSymbol
-        abstract val referencedDeclaration: KtSymbol
+        val inlineDeclaration: KtSymbol
+        val referencedDeclaration: KtSymbol
     }
 
-    abstract class ProtectedConstructorCallFromPublicInline : KtFirDiagnostic<KtElement>() {
+    interface ProtectedConstructorCallFromPublicInline : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = ProtectedConstructorCallFromPublicInline::class
-        abstract val inlineDeclaration: KtSymbol
-        abstract val referencedDeclaration: KtSymbol
+        val inlineDeclaration: KtSymbol
+        val referencedDeclaration: KtSymbol
     }
 
-    abstract class ProtectedCallFromPublicInlineError : KtFirDiagnostic<KtElement>() {
+    interface ProtectedCallFromPublicInlineError : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = ProtectedCallFromPublicInlineError::class
-        abstract val inlineDeclaration: KtSymbol
-        abstract val referencedDeclaration: KtSymbol
+        val inlineDeclaration: KtSymbol
+        val referencedDeclaration: KtSymbol
     }
 
-    abstract class ProtectedCallFromPublicInline : KtFirDiagnostic<KtElement>() {
+    interface ProtectedCallFromPublicInline : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = ProtectedCallFromPublicInline::class
-        abstract val inlineDeclaration: KtSymbol
-        abstract val referencedDeclaration: KtSymbol
+        val inlineDeclaration: KtSymbol
+        val referencedDeclaration: KtSymbol
     }
 
-    abstract class PrivateClassMemberFromInline : KtFirDiagnostic<KtElement>() {
+    interface PrivateClassMemberFromInline : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = PrivateClassMemberFromInline::class
-        abstract val inlineDeclaration: KtSymbol
-        abstract val referencedDeclaration: KtSymbol
+        val inlineDeclaration: KtSymbol
+        val referencedDeclaration: KtSymbol
     }
 
-    abstract class SuperCallFromPublicInline : KtFirDiagnostic<KtElement>() {
+    interface SuperCallFromPublicInline : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = SuperCallFromPublicInline::class
-        abstract val symbol: KtSymbol
+        val symbol: KtSymbol
     }
 
-    abstract class DeclarationCantBeInlined : KtFirDiagnostic<KtDeclaration>() {
+    interface DeclarationCantBeInlined : KtFirDiagnostic<KtDeclaration> {
         override val diagnosticClass get() = DeclarationCantBeInlined::class
     }
 
-    abstract class OverrideByInline : KtFirDiagnostic<KtDeclaration>() {
+    interface OverrideByInline : KtFirDiagnostic<KtDeclaration> {
         override val diagnosticClass get() = OverrideByInline::class
     }
 
-    abstract class NonInternalPublishedApi : KtFirDiagnostic<KtElement>() {
+    interface NonInternalPublishedApi : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = NonInternalPublishedApi::class
     }
 
-    abstract class InvalidDefaultFunctionalParameterForInline : KtFirDiagnostic<KtElement>() {
+    interface InvalidDefaultFunctionalParameterForInline : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = InvalidDefaultFunctionalParameterForInline::class
-        abstract val defaultValue: KtExpression
-        abstract val parameter: KtSymbol
+        val defaultValue: KtExpression
+        val parameter: KtSymbol
     }
 
-    abstract class ReifiedTypeParameterInOverride : KtFirDiagnostic<KtElement>() {
+    interface ReifiedTypeParameterInOverride : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = ReifiedTypeParameterInOverride::class
     }
 
-    abstract class InlinePropertyWithBackingField : KtFirDiagnostic<KtDeclaration>() {
+    interface InlinePropertyWithBackingField : KtFirDiagnostic<KtDeclaration> {
         override val diagnosticClass get() = InlinePropertyWithBackingField::class
     }
 
-    abstract class IllegalInlineParameterModifier : KtFirDiagnostic<KtElement>() {
+    interface IllegalInlineParameterModifier : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = IllegalInlineParameterModifier::class
     }
 
-    abstract class InlineSuspendFunctionTypeUnsupported : KtFirDiagnostic<KtParameter>() {
+    interface InlineSuspendFunctionTypeUnsupported : KtFirDiagnostic<KtParameter> {
         override val diagnosticClass get() = InlineSuspendFunctionTypeUnsupported::class
     }
 
-    abstract class RedundantInlineSuspendFunctionType : KtFirDiagnostic<KtElement>() {
+    interface RedundantInlineSuspendFunctionType : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = RedundantInlineSuspendFunctionType::class
     }
 
-    abstract class InefficientEqualsOverridingInValueClass : KtFirDiagnostic<KtNamedFunction>() {
+    interface InefficientEqualsOverridingInValueClass : KtFirDiagnostic<KtNamedFunction> {
         override val diagnosticClass get() = InefficientEqualsOverridingInValueClass::class
-        abstract val type: KtType
+        val type: KtType
     }
 
-    abstract class CannotAllUnderImportFromSingleton : KtFirDiagnostic<KtImportDirective>() {
+    interface CannotAllUnderImportFromSingleton : KtFirDiagnostic<KtImportDirective> {
         override val diagnosticClass get() = CannotAllUnderImportFromSingleton::class
-        abstract val objectName: Name
+        val objectName: Name
     }
 
-    abstract class PackageCannotBeImported : KtFirDiagnostic<KtImportDirective>() {
+    interface PackageCannotBeImported : KtFirDiagnostic<KtImportDirective> {
         override val diagnosticClass get() = PackageCannotBeImported::class
     }
 
-    abstract class CannotBeImported : KtFirDiagnostic<KtImportDirective>() {
+    interface CannotBeImported : KtFirDiagnostic<KtImportDirective> {
         override val diagnosticClass get() = CannotBeImported::class
-        abstract val name: Name
+        val name: Name
     }
 
-    abstract class ConflictingImport : KtFirDiagnostic<KtImportDirective>() {
+    interface ConflictingImport : KtFirDiagnostic<KtImportDirective> {
         override val diagnosticClass get() = ConflictingImport::class
-        abstract val name: Name
+        val name: Name
     }
 
-    abstract class OperatorRenamedOnImport : KtFirDiagnostic<KtImportDirective>() {
+    interface OperatorRenamedOnImport : KtFirDiagnostic<KtImportDirective> {
         override val diagnosticClass get() = OperatorRenamedOnImport::class
     }
 
-    abstract class IllegalSuspendFunctionCall : KtFirDiagnostic<PsiElement>() {
+    interface IllegalSuspendFunctionCall : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = IllegalSuspendFunctionCall::class
-        abstract val suspendCallable: KtSymbol
+        val suspendCallable: KtSymbol
     }
 
-    abstract class IllegalSuspendPropertyAccess : KtFirDiagnostic<PsiElement>() {
+    interface IllegalSuspendPropertyAccess : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = IllegalSuspendPropertyAccess::class
-        abstract val suspendCallable: KtSymbol
+        val suspendCallable: KtSymbol
     }
 
-    abstract class NonLocalSuspensionPoint : KtFirDiagnostic<PsiElement>() {
+    interface NonLocalSuspensionPoint : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = NonLocalSuspensionPoint::class
     }
 
-    abstract class IllegalRestrictedSuspendingFunctionCall : KtFirDiagnostic<PsiElement>() {
+    interface IllegalRestrictedSuspendingFunctionCall : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = IllegalRestrictedSuspendingFunctionCall::class
     }
 
-    abstract class NonModifierFormForBuiltInSuspend : KtFirDiagnostic<PsiElement>() {
+    interface NonModifierFormForBuiltInSuspend : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = NonModifierFormForBuiltInSuspend::class
     }
 
-    abstract class ModifierFormForNonBuiltInSuspend : KtFirDiagnostic<PsiElement>() {
+    interface ModifierFormForNonBuiltInSuspend : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = ModifierFormForNonBuiltInSuspend::class
     }
 
-    abstract class ModifierFormForNonBuiltInSuspendFunError : KtFirDiagnostic<PsiElement>() {
+    interface ModifierFormForNonBuiltInSuspendFunError : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = ModifierFormForNonBuiltInSuspendFunError::class
     }
 
-    abstract class ModifierFormForNonBuiltInSuspendFunWarning : KtFirDiagnostic<PsiElement>() {
+    interface ModifierFormForNonBuiltInSuspendFunWarning : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = ModifierFormForNonBuiltInSuspendFunWarning::class
     }
 
-    abstract class ReturnForBuiltInSuspend : KtFirDiagnostic<KtReturnExpression>() {
+    interface ReturnForBuiltInSuspend : KtFirDiagnostic<KtReturnExpression> {
         override val diagnosticClass get() = ReturnForBuiltInSuspend::class
     }
 
-    abstract class RedundantLabelWarning : KtFirDiagnostic<KtLabelReferenceExpression>() {
+    interface RedundantLabelWarning : KtFirDiagnostic<KtLabelReferenceExpression> {
         override val diagnosticClass get() = RedundantLabelWarning::class
     }
 
-    abstract class ConflictingJvmDeclarations : KtFirDiagnostic<PsiElement>() {
+    interface ConflictingJvmDeclarations : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = ConflictingJvmDeclarations::class
     }
 
-    abstract class OverrideCannotBeStatic : KtFirDiagnostic<PsiElement>() {
+    interface OverrideCannotBeStatic : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = OverrideCannotBeStatic::class
     }
 
-    abstract class JvmStaticNotInObjectOrClassCompanion : KtFirDiagnostic<PsiElement>() {
+    interface JvmStaticNotInObjectOrClassCompanion : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = JvmStaticNotInObjectOrClassCompanion::class
     }
 
-    abstract class JvmStaticNotInObjectOrCompanion : KtFirDiagnostic<PsiElement>() {
+    interface JvmStaticNotInObjectOrCompanion : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = JvmStaticNotInObjectOrCompanion::class
     }
 
-    abstract class JvmStaticOnNonPublicMember : KtFirDiagnostic<PsiElement>() {
+    interface JvmStaticOnNonPublicMember : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = JvmStaticOnNonPublicMember::class
     }
 
-    abstract class JvmStaticOnConstOrJvmField : KtFirDiagnostic<PsiElement>() {
+    interface JvmStaticOnConstOrJvmField : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = JvmStaticOnConstOrJvmField::class
     }
 
-    abstract class JvmStaticOnExternalInInterface : KtFirDiagnostic<PsiElement>() {
+    interface JvmStaticOnExternalInInterface : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = JvmStaticOnExternalInInterface::class
     }
 
-    abstract class InapplicableJvmName : KtFirDiagnostic<PsiElement>() {
+    interface InapplicableJvmName : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = InapplicableJvmName::class
     }
 
-    abstract class IllegalJvmName : KtFirDiagnostic<PsiElement>() {
+    interface IllegalJvmName : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = IllegalJvmName::class
     }
 
-    abstract class FunctionDelegateMemberNameClash : KtFirDiagnostic<PsiElement>() {
+    interface FunctionDelegateMemberNameClash : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = FunctionDelegateMemberNameClash::class
     }
 
-    abstract class ValueClassWithoutJvmInlineAnnotation : KtFirDiagnostic<PsiElement>() {
+    interface ValueClassWithoutJvmInlineAnnotation : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = ValueClassWithoutJvmInlineAnnotation::class
     }
 
-    abstract class JvmInlineWithoutValueClass : KtFirDiagnostic<PsiElement>() {
+    interface JvmInlineWithoutValueClass : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = JvmInlineWithoutValueClass::class
     }
 
-    abstract class JavaTypeMismatch : KtFirDiagnostic<KtExpression>() {
+    interface JavaTypeMismatch : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = JavaTypeMismatch::class
-        abstract val expectedType: KtType
-        abstract val actualType: KtType
+        val expectedType: KtType
+        val actualType: KtType
     }
 
-    abstract class UpperBoundCannotBeArray : KtFirDiagnostic<PsiElement>() {
+    interface UpperBoundCannotBeArray : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = UpperBoundCannotBeArray::class
     }
 
-    abstract class StrictfpOnClass : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface StrictfpOnClass : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = StrictfpOnClass::class
     }
 
-    abstract class SynchronizedOnAbstract : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface SynchronizedOnAbstract : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = SynchronizedOnAbstract::class
     }
 
-    abstract class SynchronizedInInterface : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface SynchronizedInInterface : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = SynchronizedInInterface::class
     }
 
-    abstract class SynchronizedOnInline : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface SynchronizedOnInline : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = SynchronizedOnInline::class
     }
 
-    abstract class SynchronizedOnSuspendError : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface SynchronizedOnSuspendError : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = SynchronizedOnSuspendError::class
     }
 
-    abstract class SynchronizedOnSuspendWarning : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface SynchronizedOnSuspendWarning : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = SynchronizedOnSuspendWarning::class
     }
 
-    abstract class OverloadsWithoutDefaultArguments : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface OverloadsWithoutDefaultArguments : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = OverloadsWithoutDefaultArguments::class
     }
 
-    abstract class OverloadsAbstract : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface OverloadsAbstract : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = OverloadsAbstract::class
     }
 
-    abstract class OverloadsInterface : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface OverloadsInterface : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = OverloadsInterface::class
     }
 
-    abstract class OverloadsLocal : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface OverloadsLocal : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = OverloadsLocal::class
     }
 
-    abstract class OverloadsAnnotationClassConstructorError : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface OverloadsAnnotationClassConstructorError : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = OverloadsAnnotationClassConstructorError::class
     }
 
-    abstract class OverloadsAnnotationClassConstructorWarning : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface OverloadsAnnotationClassConstructorWarning : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = OverloadsAnnotationClassConstructorWarning::class
     }
 
-    abstract class OverloadsPrivate : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface OverloadsPrivate : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = OverloadsPrivate::class
     }
 
-    abstract class DeprecatedJavaAnnotation : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface DeprecatedJavaAnnotation : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = DeprecatedJavaAnnotation::class
-        abstract val kotlinName: FqName
+        val kotlinName: FqName
     }
 
-    abstract class JvmPackageNameCannotBeEmpty : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface JvmPackageNameCannotBeEmpty : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = JvmPackageNameCannotBeEmpty::class
     }
 
-    abstract class JvmPackageNameMustBeValidName : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface JvmPackageNameMustBeValidName : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = JvmPackageNameMustBeValidName::class
     }
 
-    abstract class JvmPackageNameNotSupportedInFilesWithClasses : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface JvmPackageNameNotSupportedInFilesWithClasses : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = JvmPackageNameNotSupportedInFilesWithClasses::class
     }
 
-    abstract class PositionedValueArgumentForJavaAnnotation : KtFirDiagnostic<KtExpression>() {
+    interface PositionedValueArgumentForJavaAnnotation : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = PositionedValueArgumentForJavaAnnotation::class
     }
 
-    abstract class RedundantRepeatableAnnotation : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface RedundantRepeatableAnnotation : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = RedundantRepeatableAnnotation::class
-        abstract val kotlinRepeatable: FqName
-        abstract val javaRepeatable: FqName
+        val kotlinRepeatable: FqName
+        val javaRepeatable: FqName
     }
 
-    abstract class LocalJvmRecord : KtFirDiagnostic<PsiElement>() {
+    interface LocalJvmRecord : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = LocalJvmRecord::class
     }
 
-    abstract class NonFinalJvmRecord : KtFirDiagnostic<PsiElement>() {
+    interface NonFinalJvmRecord : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = NonFinalJvmRecord::class
     }
 
-    abstract class EnumJvmRecord : KtFirDiagnostic<PsiElement>() {
+    interface EnumJvmRecord : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = EnumJvmRecord::class
     }
 
-    abstract class JvmRecordWithoutPrimaryConstructorParameters : KtFirDiagnostic<PsiElement>() {
+    interface JvmRecordWithoutPrimaryConstructorParameters : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = JvmRecordWithoutPrimaryConstructorParameters::class
     }
 
-    abstract class NonDataClassJvmRecord : KtFirDiagnostic<PsiElement>() {
+    interface NonDataClassJvmRecord : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = NonDataClassJvmRecord::class
     }
 
-    abstract class JvmRecordNotValParameter : KtFirDiagnostic<PsiElement>() {
+    interface JvmRecordNotValParameter : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = JvmRecordNotValParameter::class
     }
 
-    abstract class JvmRecordNotLastVarargParameter : KtFirDiagnostic<PsiElement>() {
+    interface JvmRecordNotLastVarargParameter : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = JvmRecordNotLastVarargParameter::class
     }
 
-    abstract class InnerJvmRecord : KtFirDiagnostic<PsiElement>() {
+    interface InnerJvmRecord : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = InnerJvmRecord::class
     }
 
-    abstract class FieldInJvmRecord : KtFirDiagnostic<PsiElement>() {
+    interface FieldInJvmRecord : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = FieldInJvmRecord::class
     }
 
-    abstract class DelegationByInJvmRecord : KtFirDiagnostic<PsiElement>() {
+    interface DelegationByInJvmRecord : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = DelegationByInJvmRecord::class
     }
 
-    abstract class JvmRecordExtendsClass : KtFirDiagnostic<PsiElement>() {
+    interface JvmRecordExtendsClass : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = JvmRecordExtendsClass::class
-        abstract val superType: KtType
+        val superType: KtType
     }
 
-    abstract class IllegalJavaLangRecordSupertype : KtFirDiagnostic<PsiElement>() {
+    interface IllegalJavaLangRecordSupertype : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = IllegalJavaLangRecordSupertype::class
     }
 
-    abstract class JvmDefaultInDeclaration : KtFirDiagnostic<KtElement>() {
+    interface JvmDefaultInDeclaration : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = JvmDefaultInDeclaration::class
-        abstract val annotation: String
+        val annotation: String
     }
 
-    abstract class JvmDefaultWithCompatibilityInDeclaration : KtFirDiagnostic<KtElement>() {
+    interface JvmDefaultWithCompatibilityInDeclaration : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = JvmDefaultWithCompatibilityInDeclaration::class
     }
 
-    abstract class JvmDefaultWithCompatibilityNotOnInterface : KtFirDiagnostic<KtElement>() {
+    interface JvmDefaultWithCompatibilityNotOnInterface : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = JvmDefaultWithCompatibilityNotOnInterface::class
     }
 
-    abstract class ExternalDeclarationCannotBeAbstract : KtFirDiagnostic<KtDeclaration>() {
+    interface ExternalDeclarationCannotBeAbstract : KtFirDiagnostic<KtDeclaration> {
         override val diagnosticClass get() = ExternalDeclarationCannotBeAbstract::class
     }
 
-    abstract class ExternalDeclarationCannotHaveBody : KtFirDiagnostic<KtDeclaration>() {
+    interface ExternalDeclarationCannotHaveBody : KtFirDiagnostic<KtDeclaration> {
         override val diagnosticClass get() = ExternalDeclarationCannotHaveBody::class
     }
 
-    abstract class ExternalDeclarationInInterface : KtFirDiagnostic<KtDeclaration>() {
+    interface ExternalDeclarationInInterface : KtFirDiagnostic<KtDeclaration> {
         override val diagnosticClass get() = ExternalDeclarationInInterface::class
     }
 
-    abstract class ExternalDeclarationCannotBeInlined : KtFirDiagnostic<KtDeclaration>() {
+    interface ExternalDeclarationCannotBeInlined : KtFirDiagnostic<KtDeclaration> {
         override val diagnosticClass get() = ExternalDeclarationCannotBeInlined::class
     }
 
-    abstract class NonSourceRepeatedAnnotation : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface NonSourceRepeatedAnnotation : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = NonSourceRepeatedAnnotation::class
     }
 
-    abstract class RepeatedAnnotationWithContainer : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface RepeatedAnnotationWithContainer : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = RepeatedAnnotationWithContainer::class
-        abstract val name: ClassId
-        abstract val explicitContainerName: ClassId
+        val name: ClassId
+        val explicitContainerName: ClassId
     }
 
-    abstract class RepeatableContainerMustHaveValueArrayError : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface RepeatableContainerMustHaveValueArrayError : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = RepeatableContainerMustHaveValueArrayError::class
-        abstract val container: ClassId
-        abstract val annotation: ClassId
+        val container: ClassId
+        val annotation: ClassId
     }
 
-    abstract class RepeatableContainerMustHaveValueArrayWarning : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface RepeatableContainerMustHaveValueArrayWarning : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = RepeatableContainerMustHaveValueArrayWarning::class
-        abstract val container: ClassId
-        abstract val annotation: ClassId
+        val container: ClassId
+        val annotation: ClassId
     }
 
-    abstract class RepeatableContainerHasNonDefaultParameterError : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface RepeatableContainerHasNonDefaultParameterError : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = RepeatableContainerHasNonDefaultParameterError::class
-        abstract val container: ClassId
-        abstract val nonDefault: Name
+        val container: ClassId
+        val nonDefault: Name
     }
 
-    abstract class RepeatableContainerHasNonDefaultParameterWarning : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface RepeatableContainerHasNonDefaultParameterWarning : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = RepeatableContainerHasNonDefaultParameterWarning::class
-        abstract val container: ClassId
-        abstract val nonDefault: Name
+        val container: ClassId
+        val nonDefault: Name
     }
 
-    abstract class RepeatableContainerHasShorterRetentionError : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface RepeatableContainerHasShorterRetentionError : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = RepeatableContainerHasShorterRetentionError::class
-        abstract val container: ClassId
-        abstract val retention: String
-        abstract val annotation: ClassId
-        abstract val annotationRetention: String
+        val container: ClassId
+        val retention: String
+        val annotation: ClassId
+        val annotationRetention: String
     }
 
-    abstract class RepeatableContainerHasShorterRetentionWarning : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface RepeatableContainerHasShorterRetentionWarning : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = RepeatableContainerHasShorterRetentionWarning::class
-        abstract val container: ClassId
-        abstract val retention: String
-        abstract val annotation: ClassId
-        abstract val annotationRetention: String
+        val container: ClassId
+        val retention: String
+        val annotation: ClassId
+        val annotationRetention: String
     }
 
-    abstract class RepeatableContainerTargetSetNotASubsetError : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface RepeatableContainerTargetSetNotASubsetError : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = RepeatableContainerTargetSetNotASubsetError::class
-        abstract val container: ClassId
-        abstract val annotation: ClassId
+        val container: ClassId
+        val annotation: ClassId
     }
 
-    abstract class RepeatableContainerTargetSetNotASubsetWarning : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface RepeatableContainerTargetSetNotASubsetWarning : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = RepeatableContainerTargetSetNotASubsetWarning::class
-        abstract val container: ClassId
-        abstract val annotation: ClassId
+        val container: ClassId
+        val annotation: ClassId
     }
 
-    abstract class RepeatableAnnotationHasNestedClassNamedContainerError : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface RepeatableAnnotationHasNestedClassNamedContainerError : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = RepeatableAnnotationHasNestedClassNamedContainerError::class
     }
 
-    abstract class RepeatableAnnotationHasNestedClassNamedContainerWarning : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface RepeatableAnnotationHasNestedClassNamedContainerWarning : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = RepeatableAnnotationHasNestedClassNamedContainerWarning::class
     }
 
-    abstract class SuspensionPointInsideCriticalSection : KtFirDiagnostic<PsiElement>() {
+    interface SuspensionPointInsideCriticalSection : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = SuspensionPointInsideCriticalSection::class
-        abstract val function: KtCallableSymbol
+        val function: KtCallableSymbol
     }
 
-    abstract class InapplicableJvmField : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface InapplicableJvmField : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = InapplicableJvmField::class
-        abstract val message: String
+        val message: String
     }
 
-    abstract class InapplicableJvmFieldWarning : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface InapplicableJvmFieldWarning : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = InapplicableJvmFieldWarning::class
-        abstract val message: String
+        val message: String
     }
 
-    abstract class JvmSyntheticOnDelegate : KtFirDiagnostic<KtAnnotationEntry>() {
+    interface JvmSyntheticOnDelegate : KtFirDiagnostic<KtAnnotationEntry> {
         override val diagnosticClass get() = JvmSyntheticOnDelegate::class
     }
 
-    abstract class SubclassCantCallCompanionProtectedNonStatic : KtFirDiagnostic<PsiElement>() {
+    interface SubclassCantCallCompanionProtectedNonStatic : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = SubclassCantCallCompanionProtectedNonStatic::class
     }
 
-    abstract class ConcurrentHashMapContainsOperatorError : KtFirDiagnostic<PsiElement>() {
+    interface ConcurrentHashMapContainsOperatorError : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = ConcurrentHashMapContainsOperatorError::class
     }
 
-    abstract class ConcurrentHashMapContainsOperatorWarning : KtFirDiagnostic<PsiElement>() {
+    interface ConcurrentHashMapContainsOperatorWarning : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = ConcurrentHashMapContainsOperatorWarning::class
     }
 
-    abstract class SpreadOnSignaturePolymorphicCallError : KtFirDiagnostic<PsiElement>() {
+    interface SpreadOnSignaturePolymorphicCallError : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = SpreadOnSignaturePolymorphicCallError::class
     }
 
-    abstract class SpreadOnSignaturePolymorphicCallWarning : KtFirDiagnostic<PsiElement>() {
+    interface SpreadOnSignaturePolymorphicCallWarning : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = SpreadOnSignaturePolymorphicCallWarning::class
     }
 
-    abstract class JavaSamInterfaceConstructorReference : KtFirDiagnostic<PsiElement>() {
+    interface JavaSamInterfaceConstructorReference : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = JavaSamInterfaceConstructorReference::class
     }
 
-    abstract class ImplementingFunctionInterface : KtFirDiagnostic<KtClassOrObject>() {
+    interface ImplementingFunctionInterface : KtFirDiagnostic<KtClassOrObject> {
         override val diagnosticClass get() = ImplementingFunctionInterface::class
     }
 
-    abstract class OverridingExternalFunWithOptionalParams : KtFirDiagnostic<KtElement>() {
+    interface OverridingExternalFunWithOptionalParams : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = OverridingExternalFunWithOptionalParams::class
     }
 
-    abstract class OverridingExternalFunWithOptionalParamsWithFake : KtFirDiagnostic<KtElement>() {
+    interface OverridingExternalFunWithOptionalParamsWithFake : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = OverridingExternalFunWithOptionalParamsWithFake::class
-        abstract val function: KtFunctionLikeSymbol
+        val function: KtFunctionLikeSymbol
     }
 
-    abstract class CallToDefinedExternallyFromNonExternalDeclaration : KtFirDiagnostic<PsiElement>() {
+    interface CallToDefinedExternallyFromNonExternalDeclaration : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = CallToDefinedExternallyFromNonExternalDeclaration::class
     }
 
-    abstract class ExternalClassConstructorPropertyParameter : KtFirDiagnostic<KtParameter>() {
+    interface ExternalClassConstructorPropertyParameter : KtFirDiagnostic<KtParameter> {
         override val diagnosticClass get() = ExternalClassConstructorPropertyParameter::class
     }
 
-    abstract class ExternalEnumEntryWithBody : KtFirDiagnostic<KtElement>() {
+    interface ExternalEnumEntryWithBody : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = ExternalEnumEntryWithBody::class
     }
 
-    abstract class ExternalAnonymousInitializer : KtFirDiagnostic<KtAnonymousInitializer>() {
+    interface ExternalAnonymousInitializer : KtFirDiagnostic<KtAnonymousInitializer> {
         override val diagnosticClass get() = ExternalAnonymousInitializer::class
     }
 
-    abstract class ExternalDelegation : KtFirDiagnostic<KtElement>() {
+    interface ExternalDelegation : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = ExternalDelegation::class
     }
 
-    abstract class ExternalDelegatedConstructorCall : KtFirDiagnostic<KtElement>() {
+    interface ExternalDelegatedConstructorCall : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = ExternalDelegatedConstructorCall::class
     }
 
-    abstract class WrongBodyOfExternalDeclaration : KtFirDiagnostic<KtElement>() {
+    interface WrongBodyOfExternalDeclaration : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = WrongBodyOfExternalDeclaration::class
     }
 
-    abstract class WrongInitializerOfExternalDeclaration : KtFirDiagnostic<KtElement>() {
+    interface WrongInitializerOfExternalDeclaration : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = WrongInitializerOfExternalDeclaration::class
     }
 
-    abstract class WrongDefaultValueForExternalFunParameter : KtFirDiagnostic<KtElement>() {
+    interface WrongDefaultValueForExternalFunParameter : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = WrongDefaultValueForExternalFunParameter::class
     }
 
-    abstract class NestedExternalDeclaration : KtFirDiagnostic<KtExpression>() {
+    interface NestedExternalDeclaration : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = NestedExternalDeclaration::class
     }
 
-    abstract class WrongExternalDeclaration : KtFirDiagnostic<KtExpression>() {
+    interface WrongExternalDeclaration : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = WrongExternalDeclaration::class
-        abstract val classKind: String
+        val classKind: String
     }
 
-    abstract class NestedClassInExternalInterface : KtFirDiagnostic<KtExpression>() {
+    interface NestedClassInExternalInterface : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = NestedClassInExternalInterface::class
     }
 
-    abstract class ExternalTypeExtendsNonExternalType : KtFirDiagnostic<KtElement>() {
+    interface ExternalTypeExtendsNonExternalType : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = ExternalTypeExtendsNonExternalType::class
     }
 
-    abstract class InlineExternalDeclaration : KtFirDiagnostic<KtDeclaration>() {
+    interface InlineExternalDeclaration : KtFirDiagnostic<KtDeclaration> {
         override val diagnosticClass get() = InlineExternalDeclaration::class
     }
 
-    abstract class EnumClassInExternalDeclarationWarning : KtFirDiagnostic<KtDeclaration>() {
+    interface EnumClassInExternalDeclarationWarning : KtFirDiagnostic<KtDeclaration> {
         override val diagnosticClass get() = EnumClassInExternalDeclarationWarning::class
     }
 
-    abstract class InlineClassInExternalDeclarationWarning : KtFirDiagnostic<KtElement>() {
+    interface InlineClassInExternalDeclarationWarning : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = InlineClassInExternalDeclarationWarning::class
     }
 
-    abstract class InlineClassInExternalDeclaration : KtFirDiagnostic<KtElement>() {
+    interface InlineClassInExternalDeclaration : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = InlineClassInExternalDeclaration::class
     }
 
-    abstract class ExtensionFunctionInExternalDeclaration : KtFirDiagnostic<KtElement>() {
+    interface ExtensionFunctionInExternalDeclaration : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = ExtensionFunctionInExternalDeclaration::class
     }
 
-    abstract class NonAbstractMemberOfExternalInterface : KtFirDiagnostic<KtExpression>() {
+    interface NonAbstractMemberOfExternalInterface : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = NonAbstractMemberOfExternalInterface::class
     }
 
-    abstract class NonExternalDeclarationInInappropriateFile : KtFirDiagnostic<KtElement>() {
+    interface NonExternalDeclarationInInappropriateFile : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = NonExternalDeclarationInInappropriateFile::class
-        abstract val type: KtType
+        val type: KtType
     }
 
-    abstract class CannotCheckForExternalInterface : KtFirDiagnostic<KtElement>() {
+    interface CannotCheckForExternalInterface : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = CannotCheckForExternalInterface::class
-        abstract val targetType: KtType
+        val targetType: KtType
     }
 
-    abstract class UncheckedCastToExternalInterface : KtFirDiagnostic<KtElement>() {
+    interface UncheckedCastToExternalInterface : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = UncheckedCastToExternalInterface::class
-        abstract val sourceType: KtType
-        abstract val targetType: KtType
+        val sourceType: KtType
+        val targetType: KtType
     }
 
-    abstract class ExternalInterfaceAsClassLiteral : KtFirDiagnostic<KtElement>() {
+    interface ExternalInterfaceAsClassLiteral : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = ExternalInterfaceAsClassLiteral::class
     }
 
-    abstract class JsExternalInheritorsOnly : KtFirDiagnostic<KtDeclaration>() {
+    interface JsExternalInheritorsOnly : KtFirDiagnostic<KtDeclaration> {
         override val diagnosticClass get() = JsExternalInheritorsOnly::class
-        abstract val parent: KtClassLikeSymbol
-        abstract val kid: KtClassLikeSymbol
+        val parent: KtClassLikeSymbol
+        val kid: KtClassLikeSymbol
     }
 
-    abstract class JsExternalArgument : KtFirDiagnostic<KtExpression>() {
+    interface JsExternalArgument : KtFirDiagnostic<KtExpression> {
         override val diagnosticClass get() = JsExternalArgument::class
-        abstract val argType: KtType
+        val argType: KtType
     }
 
-    abstract class NestedJsExport : KtFirDiagnostic<KtElement>() {
+    interface NestedJsExport : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = NestedJsExport::class
     }
 
-    abstract class WrongExportedDeclaration : KtFirDiagnostic<KtElement>() {
+    interface WrongExportedDeclaration : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = WrongExportedDeclaration::class
-        abstract val kind: String
+        val kind: String
     }
 
-    abstract class NonExportableType : KtFirDiagnostic<KtElement>() {
+    interface NonExportableType : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = NonExportableType::class
-        abstract val kind: String
-        abstract val type: KtType
+        val kind: String
+        val type: KtType
     }
 
-    abstract class NonConsumableExportedIdentifier : KtFirDiagnostic<KtElement>() {
+    interface NonConsumableExportedIdentifier : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = NonConsumableExportedIdentifier::class
-        abstract val name: String
+        val name: String
     }
 
-    abstract class DelegationByDynamic : KtFirDiagnostic<KtElement>() {
+    interface DelegationByDynamic : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = DelegationByDynamic::class
     }
 
-    abstract class SpreadOperatorInDynamicCall : KtFirDiagnostic<KtElement>() {
+    interface SpreadOperatorInDynamicCall : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = SpreadOperatorInDynamicCall::class
     }
 
-    abstract class WrongOperationWithDynamic : KtFirDiagnostic<KtElement>() {
+    interface WrongOperationWithDynamic : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = WrongOperationWithDynamic::class
-        abstract val operation: String
+        val operation: String
     }
 
-    abstract class Syntax : KtFirDiagnostic<PsiElement>() {
+    interface Syntax : KtFirDiagnostic<PsiElement> {
         override val diagnosticClass get() = Syntax::class
-        abstract val message: String
+        val message: String
     }
 
 }
diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnosticsImpl.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnosticsImpl.kt
index 45d5d7507b5..98e9b0b1404 100644
--- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnosticsImpl.kt
+++ b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnosticsImpl.kt
@@ -92,4220 +92,4220 @@ import org.jetbrains.kotlin.types.Variance
 
 internal class UnsupportedImpl(
     override val unsupported: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.Unsupported(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.Unsupported
 
 internal class UnsupportedFeatureImpl(
     override val unsupportedFeature: Pair<LanguageFeature, LanguageVersionSettings>,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.UnsupportedFeature(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.UnsupportedFeature
 
 internal class NewInferenceErrorImpl(
     override val error: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NewInferenceError(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.NewInferenceError
 
 internal class OtherErrorImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.OtherError(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.OtherError
 
 internal class IllegalConstExpressionImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.IllegalConstExpression(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.IllegalConstExpression
 
 internal class IllegalUnderscoreImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.IllegalUnderscore(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.IllegalUnderscore
 
 internal class ExpressionExpectedImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ExpressionExpected(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.ExpressionExpected
 
 internal class AssignmentInExpressionContextImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.AssignmentInExpressionContext(), KtAbstractFirDiagnostic<KtBinaryExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtBinaryExpression>(firDiagnostic, token), KtFirDiagnostic.AssignmentInExpressionContext
 
 internal class BreakOrContinueOutsideALoopImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.BreakOrContinueOutsideALoop(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.BreakOrContinueOutsideALoop
 
 internal class NotALoopLabelImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NotALoopLabel(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.NotALoopLabel
 
 internal class BreakOrContinueJumpsAcrossFunctionBoundaryImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.BreakOrContinueJumpsAcrossFunctionBoundary(), KtAbstractFirDiagnostic<KtExpressionWithLabel>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpressionWithLabel>(firDiagnostic, token), KtFirDiagnostic.BreakOrContinueJumpsAcrossFunctionBoundary
 
 internal class VariableExpectedImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.VariableExpected(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.VariableExpected
 
 internal class DelegationInInterfaceImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.DelegationInInterface(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.DelegationInInterface
 
 internal class DelegationNotToInterfaceImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.DelegationNotToInterface(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.DelegationNotToInterface
 
 internal class NestedClassNotAllowedImpl(
     override val declaration: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NestedClassNotAllowed(), KtAbstractFirDiagnostic<KtNamedDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtNamedDeclaration>(firDiagnostic, token), KtFirDiagnostic.NestedClassNotAllowed
 
 internal class IncorrectCharacterLiteralImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.IncorrectCharacterLiteral(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.IncorrectCharacterLiteral
 
 internal class EmptyCharacterLiteralImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.EmptyCharacterLiteral(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.EmptyCharacterLiteral
 
 internal class TooManyCharactersInCharacterLiteralImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.TooManyCharactersInCharacterLiteral(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.TooManyCharactersInCharacterLiteral
 
 internal class IllegalEscapeImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.IllegalEscape(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.IllegalEscape
 
 internal class IntLiteralOutOfRangeImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.IntLiteralOutOfRange(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.IntLiteralOutOfRange
 
 internal class FloatLiteralOutOfRangeImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.FloatLiteralOutOfRange(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.FloatLiteralOutOfRange
 
 internal class WrongLongSuffixImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.WrongLongSuffix(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.WrongLongSuffix
 
 internal class UnsignedLiteralWithoutDeclarationsOnClasspathImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.UnsignedLiteralWithoutDeclarationsOnClasspath(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.UnsignedLiteralWithoutDeclarationsOnClasspath
 
 internal class DivisionByZeroImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.DivisionByZero(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.DivisionByZero
 
 internal class ValOrVarOnLoopParameterImpl(
     override val valOrVar: KtKeywordToken,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ValOrVarOnLoopParameter(), KtAbstractFirDiagnostic<KtParameter>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtParameter>(firDiagnostic, token), KtFirDiagnostic.ValOrVarOnLoopParameter
 
 internal class ValOrVarOnFunParameterImpl(
     override val valOrVar: KtKeywordToken,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ValOrVarOnFunParameter(), KtAbstractFirDiagnostic<KtParameter>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtParameter>(firDiagnostic, token), KtFirDiagnostic.ValOrVarOnFunParameter
 
 internal class ValOrVarOnCatchParameterImpl(
     override val valOrVar: KtKeywordToken,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ValOrVarOnCatchParameter(), KtAbstractFirDiagnostic<KtParameter>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtParameter>(firDiagnostic, token), KtFirDiagnostic.ValOrVarOnCatchParameter
 
 internal class ValOrVarOnSecondaryConstructorParameterImpl(
     override val valOrVar: KtKeywordToken,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ValOrVarOnSecondaryConstructorParameter(), KtAbstractFirDiagnostic<KtParameter>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtParameter>(firDiagnostic, token), KtFirDiagnostic.ValOrVarOnSecondaryConstructorParameter
 
 internal class InvisibleSetterImpl(
     override val property: KtVariableSymbol,
     override val visibility: Visibility,
     override val callableId: CallableId,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.InvisibleSetter(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.InvisibleSetter
 
 internal class InvisibleReferenceImpl(
     override val reference: KtSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.InvisibleReference(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.InvisibleReference
 
 internal class UnresolvedReferenceImpl(
     override val reference: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.UnresolvedReference(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.UnresolvedReference
 
 internal class UnresolvedLabelImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.UnresolvedLabel(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.UnresolvedLabel
 
 internal class DeserializationErrorImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.DeserializationError(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.DeserializationError
 
 internal class ErrorFromJavaResolutionImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ErrorFromJavaResolution(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.ErrorFromJavaResolution
 
 internal class MissingStdlibClassImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.MissingStdlibClass(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.MissingStdlibClass
 
 internal class NoThisImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NoThis(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.NoThis
 
 internal class DeprecationErrorImpl(
     override val reference: KtSymbol,
     override val message: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.DeprecationError(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.DeprecationError
 
 internal class DeprecationImpl(
     override val reference: KtSymbol,
     override val message: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.Deprecation(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.Deprecation
 
 internal class TypealiasExpansionDeprecationErrorImpl(
     override val alias: KtSymbol,
     override val reference: KtSymbol,
     override val message: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.TypealiasExpansionDeprecationError(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.TypealiasExpansionDeprecationError
 
 internal class TypealiasExpansionDeprecationImpl(
     override val alias: KtSymbol,
     override val reference: KtSymbol,
     override val message: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.TypealiasExpansionDeprecation(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.TypealiasExpansionDeprecation
 
 internal class ApiNotAvailableImpl(
     override val sinceKotlinVersion: ApiVersion,
     override val currentVersion: ApiVersion,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ApiNotAvailable(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.ApiNotAvailable
 
 internal class UnresolvedReferenceWrongReceiverImpl(
     override val candidates: List<KtSymbol>,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.UnresolvedReferenceWrongReceiver(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.UnresolvedReferenceWrongReceiver
 
 internal class UnresolvedImportImpl(
     override val reference: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.UnresolvedImport(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.UnresolvedImport
 
 internal class CreatingAnInstanceOfAbstractClassImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.CreatingAnInstanceOfAbstractClass(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.CreatingAnInstanceOfAbstractClass
 
 internal class FunctionCallExpectedImpl(
     override val functionName: String,
     override val hasValueParameters: Boolean,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.FunctionCallExpected(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.FunctionCallExpected
 
 internal class IllegalSelectorImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.IllegalSelector(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.IllegalSelector
 
 internal class NoReceiverAllowedImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NoReceiverAllowed(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.NoReceiverAllowed
 
 internal class FunctionExpectedImpl(
     override val expression: String,
     override val type: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.FunctionExpected(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.FunctionExpected
 
 internal class ResolutionToClassifierImpl(
     override val classSymbol: KtClassLikeSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ResolutionToClassifier(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.ResolutionToClassifier
 
 internal class AmbiguousAlteredAssignImpl(
     override val altererNames: List<String?>,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.AmbiguousAlteredAssign(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.AmbiguousAlteredAssign
 
 internal class ForbiddenBinaryModImpl(
     override val forbiddenFunction: KtSymbol,
     override val suggestedFunction: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ForbiddenBinaryMod(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.ForbiddenBinaryMod
 
 internal class DeprecatedBinaryModImpl(
     override val forbiddenFunction: KtSymbol,
     override val suggestedFunction: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.DeprecatedBinaryMod(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.DeprecatedBinaryMod
 
 internal class SuperIsNotAnExpressionImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.SuperIsNotAnExpression(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.SuperIsNotAnExpression
 
 internal class SuperNotAvailableImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.SuperNotAvailable(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.SuperNotAvailable
 
 internal class AbstractSuperCallImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.AbstractSuperCall(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.AbstractSuperCall
 
 internal class AbstractSuperCallWarningImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.AbstractSuperCallWarning(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.AbstractSuperCallWarning
 
 internal class InstanceAccessBeforeSuperCallImpl(
     override val target: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.InstanceAccessBeforeSuperCall(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.InstanceAccessBeforeSuperCall
 
 internal class SuperCallWithDefaultParametersImpl(
     override val name: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.SuperCallWithDefaultParameters(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.SuperCallWithDefaultParameters
 
 internal class InterfaceCantCallDefaultMethodViaSuperImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.InterfaceCantCallDefaultMethodViaSuper(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.InterfaceCantCallDefaultMethodViaSuper
 
 internal class NotASupertypeImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NotASupertype(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.NotASupertype
 
 internal class TypeArgumentsRedundantInSuperQualifierImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.TypeArgumentsRedundantInSuperQualifier(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.TypeArgumentsRedundantInSuperQualifier
 
 internal class SuperclassNotAccessibleFromInterfaceImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.SuperclassNotAccessibleFromInterface(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.SuperclassNotAccessibleFromInterface
 
 internal class QualifiedSupertypeExtendedByOtherSupertypeImpl(
     override val otherSuperType: KtSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.QualifiedSupertypeExtendedByOtherSupertype(), KtAbstractFirDiagnostic<KtTypeReference>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeReference>(firDiagnostic, token), KtFirDiagnostic.QualifiedSupertypeExtendedByOtherSupertype
 
 internal class SupertypeInitializedInInterfaceImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.SupertypeInitializedInInterface(), KtAbstractFirDiagnostic<KtTypeReference>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeReference>(firDiagnostic, token), KtFirDiagnostic.SupertypeInitializedInInterface
 
 internal class InterfaceWithSuperclassImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.InterfaceWithSuperclass(), KtAbstractFirDiagnostic<KtTypeReference>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeReference>(firDiagnostic, token), KtFirDiagnostic.InterfaceWithSuperclass
 
 internal class FinalSupertypeImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.FinalSupertype(), KtAbstractFirDiagnostic<KtTypeReference>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeReference>(firDiagnostic, token), KtFirDiagnostic.FinalSupertype
 
 internal class ClassCannotBeExtendedDirectlyImpl(
     override val classSymbol: KtClassLikeSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ClassCannotBeExtendedDirectly(), KtAbstractFirDiagnostic<KtTypeReference>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeReference>(firDiagnostic, token), KtFirDiagnostic.ClassCannotBeExtendedDirectly
 
 internal class SupertypeIsExtensionFunctionTypeImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.SupertypeIsExtensionFunctionType(), KtAbstractFirDiagnostic<KtTypeReference>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeReference>(firDiagnostic, token), KtFirDiagnostic.SupertypeIsExtensionFunctionType
 
 internal class SingletonInSupertypeImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.SingletonInSupertype(), KtAbstractFirDiagnostic<KtTypeReference>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeReference>(firDiagnostic, token), KtFirDiagnostic.SingletonInSupertype
 
 internal class NullableSupertypeImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NullableSupertype(), KtAbstractFirDiagnostic<KtTypeReference>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeReference>(firDiagnostic, token), KtFirDiagnostic.NullableSupertype
 
 internal class ManyClassesInSupertypeListImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ManyClassesInSupertypeList(), KtAbstractFirDiagnostic<KtTypeReference>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeReference>(firDiagnostic, token), KtFirDiagnostic.ManyClassesInSupertypeList
 
 internal class SupertypeAppearsTwiceImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.SupertypeAppearsTwice(), KtAbstractFirDiagnostic<KtTypeReference>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeReference>(firDiagnostic, token), KtFirDiagnostic.SupertypeAppearsTwice
 
 internal class ClassInSupertypeForEnumImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ClassInSupertypeForEnum(), KtAbstractFirDiagnostic<KtTypeReference>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeReference>(firDiagnostic, token), KtFirDiagnostic.ClassInSupertypeForEnum
 
 internal class SealedSupertypeImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.SealedSupertype(), KtAbstractFirDiagnostic<KtTypeReference>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeReference>(firDiagnostic, token), KtFirDiagnostic.SealedSupertype
 
 internal class SealedSupertypeInLocalClassImpl(
     override val declarationType: String,
     override val sealedClassKind: ClassKind,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.SealedSupertypeInLocalClass(), KtAbstractFirDiagnostic<KtTypeReference>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeReference>(firDiagnostic, token), KtFirDiagnostic.SealedSupertypeInLocalClass
 
 internal class SealedInheritorInDifferentPackageImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.SealedInheritorInDifferentPackage(), KtAbstractFirDiagnostic<KtTypeReference>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeReference>(firDiagnostic, token), KtFirDiagnostic.SealedInheritorInDifferentPackage
 
 internal class SealedInheritorInDifferentModuleImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.SealedInheritorInDifferentModule(), KtAbstractFirDiagnostic<KtTypeReference>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeReference>(firDiagnostic, token), KtFirDiagnostic.SealedInheritorInDifferentModule
 
 internal class ClassInheritsJavaSealedClassImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ClassInheritsJavaSealedClass(), KtAbstractFirDiagnostic<KtTypeReference>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeReference>(firDiagnostic, token), KtFirDiagnostic.ClassInheritsJavaSealedClass
 
 internal class SupertypeNotAClassOrInterfaceImpl(
     override val reason: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.SupertypeNotAClassOrInterface(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.SupertypeNotAClassOrInterface
 
 internal class CyclicInheritanceHierarchyImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.CyclicInheritanceHierarchy(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.CyclicInheritanceHierarchy
 
 internal class ExpandedTypeCannotBeInheritedImpl(
     override val type: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ExpandedTypeCannotBeInherited(), KtAbstractFirDiagnostic<KtTypeReference>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeReference>(firDiagnostic, token), KtFirDiagnostic.ExpandedTypeCannotBeInherited
 
 internal class ProjectionInImmediateArgumentToSupertypeImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ProjectionInImmediateArgumentToSupertype(), KtAbstractFirDiagnostic<KtModifierListOwner>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtModifierListOwner>(firDiagnostic, token), KtFirDiagnostic.ProjectionInImmediateArgumentToSupertype
 
 internal class InconsistentTypeParameterValuesImpl(
     override val typeParameter: KtTypeParameterSymbol,
     override val type: KtClassLikeSymbol,
     override val bounds: List<KtType>,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.InconsistentTypeParameterValues(), KtAbstractFirDiagnostic<KtClass>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtClass>(firDiagnostic, token), KtFirDiagnostic.InconsistentTypeParameterValues
 
 internal class InconsistentTypeParameterBoundsImpl(
     override val typeParameter: KtTypeParameterSymbol,
     override val type: KtClassLikeSymbol,
     override val bounds: List<KtType>,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.InconsistentTypeParameterBounds(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.InconsistentTypeParameterBounds
 
 internal class AmbiguousSuperImpl(
     override val candidates: List<KtType>,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.AmbiguousSuper(), KtAbstractFirDiagnostic<KtSuperExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtSuperExpression>(firDiagnostic, token), KtFirDiagnostic.AmbiguousSuper
 
 internal class WrongMultipleInheritanceImpl(
     override val symbol: KtCallableSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.WrongMultipleInheritance(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.WrongMultipleInheritance
 
 internal class ConstructorInObjectImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ConstructorInObject(), KtAbstractFirDiagnostic<KtDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtDeclaration>(firDiagnostic, token), KtFirDiagnostic.ConstructorInObject
 
 internal class ConstructorInInterfaceImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ConstructorInInterface(), KtAbstractFirDiagnostic<KtDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtDeclaration>(firDiagnostic, token), KtFirDiagnostic.ConstructorInInterface
 
 internal class NonPrivateConstructorInEnumImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NonPrivateConstructorInEnum(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.NonPrivateConstructorInEnum
 
 internal class NonPrivateOrProtectedConstructorInSealedImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NonPrivateOrProtectedConstructorInSealed(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.NonPrivateOrProtectedConstructorInSealed
 
 internal class CyclicConstructorDelegationCallImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.CyclicConstructorDelegationCall(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.CyclicConstructorDelegationCall
 
 internal class PrimaryConstructorDelegationCallExpectedImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.PrimaryConstructorDelegationCallExpected(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.PrimaryConstructorDelegationCallExpected
 
 internal class SupertypeNotInitializedImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.SupertypeNotInitialized(), KtAbstractFirDiagnostic<KtTypeReference>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeReference>(firDiagnostic, token), KtFirDiagnostic.SupertypeNotInitialized
 
 internal class SupertypeInitializedWithoutPrimaryConstructorImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.SupertypeInitializedWithoutPrimaryConstructor(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.SupertypeInitializedWithoutPrimaryConstructor
 
 internal class DelegationSuperCallInEnumConstructorImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.DelegationSuperCallInEnumConstructor(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.DelegationSuperCallInEnumConstructor
 
 internal class PrimaryConstructorRequiredForDataClassImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.PrimaryConstructorRequiredForDataClass(), KtAbstractFirDiagnostic<KtNamedDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtNamedDeclaration>(firDiagnostic, token), KtFirDiagnostic.PrimaryConstructorRequiredForDataClass
 
 internal class ExplicitDelegationCallRequiredImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ExplicitDelegationCallRequired(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.ExplicitDelegationCallRequired
 
 internal class SealedClassConstructorCallImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.SealedClassConstructorCall(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.SealedClassConstructorCall
 
 internal class DataClassWithoutParametersImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.DataClassWithoutParameters(), KtAbstractFirDiagnostic<KtPrimaryConstructor>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtPrimaryConstructor>(firDiagnostic, token), KtFirDiagnostic.DataClassWithoutParameters
 
 internal class DataClassVarargParameterImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.DataClassVarargParameter(), KtAbstractFirDiagnostic<KtParameter>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtParameter>(firDiagnostic, token), KtFirDiagnostic.DataClassVarargParameter
 
 internal class DataClassNotPropertyParameterImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.DataClassNotPropertyParameter(), KtAbstractFirDiagnostic<KtParameter>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtParameter>(firDiagnostic, token), KtFirDiagnostic.DataClassNotPropertyParameter
 
 internal class AnnotationArgumentKclassLiteralOfTypeParameterErrorImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.AnnotationArgumentKclassLiteralOfTypeParameterError(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.AnnotationArgumentKclassLiteralOfTypeParameterError
 
 internal class AnnotationArgumentMustBeConstImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.AnnotationArgumentMustBeConst(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.AnnotationArgumentMustBeConst
 
 internal class AnnotationArgumentMustBeEnumConstImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.AnnotationArgumentMustBeEnumConst(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.AnnotationArgumentMustBeEnumConst
 
 internal class AnnotationArgumentMustBeKclassLiteralImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.AnnotationArgumentMustBeKclassLiteral(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.AnnotationArgumentMustBeKclassLiteral
 
 internal class AnnotationClassMemberImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.AnnotationClassMember(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.AnnotationClassMember
 
 internal class AnnotationParameterDefaultValueMustBeConstantImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.AnnotationParameterDefaultValueMustBeConstant(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.AnnotationParameterDefaultValueMustBeConstant
 
 internal class InvalidTypeOfAnnotationMemberImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.InvalidTypeOfAnnotationMember(), KtAbstractFirDiagnostic<KtTypeReference>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeReference>(firDiagnostic, token), KtFirDiagnostic.InvalidTypeOfAnnotationMember
 
 internal class LocalAnnotationClassErrorImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.LocalAnnotationClassError(), KtAbstractFirDiagnostic<KtClassOrObject>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtClassOrObject>(firDiagnostic, token), KtFirDiagnostic.LocalAnnotationClassError
 
 internal class MissingValOnAnnotationParameterImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.MissingValOnAnnotationParameter(), KtAbstractFirDiagnostic<KtParameter>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtParameter>(firDiagnostic, token), KtFirDiagnostic.MissingValOnAnnotationParameter
 
 internal class NonConstValUsedInConstantExpressionImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NonConstValUsedInConstantExpression(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.NonConstValUsedInConstantExpression
 
 internal class CycleInAnnotationParameterErrorImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.CycleInAnnotationParameterError(), KtAbstractFirDiagnostic<KtParameter>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtParameter>(firDiagnostic, token), KtFirDiagnostic.CycleInAnnotationParameterError
 
 internal class CycleInAnnotationParameterWarningImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.CycleInAnnotationParameterWarning(), KtAbstractFirDiagnostic<KtParameter>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtParameter>(firDiagnostic, token), KtFirDiagnostic.CycleInAnnotationParameterWarning
 
 internal class AnnotationClassConstructorCallImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.AnnotationClassConstructorCall(), KtAbstractFirDiagnostic<KtCallExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtCallExpression>(firDiagnostic, token), KtFirDiagnostic.AnnotationClassConstructorCall
 
 internal class NotAnAnnotationClassImpl(
     override val annotationName: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NotAnAnnotationClass(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.NotAnAnnotationClass
 
 internal class NullableTypeOfAnnotationMemberImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NullableTypeOfAnnotationMember(), KtAbstractFirDiagnostic<KtTypeReference>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeReference>(firDiagnostic, token), KtFirDiagnostic.NullableTypeOfAnnotationMember
 
 internal class VarAnnotationParameterImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.VarAnnotationParameter(), KtAbstractFirDiagnostic<KtParameter>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtParameter>(firDiagnostic, token), KtFirDiagnostic.VarAnnotationParameter
 
 internal class SupertypesForAnnotationClassImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.SupertypesForAnnotationClass(), KtAbstractFirDiagnostic<KtClass>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtClass>(firDiagnostic, token), KtFirDiagnostic.SupertypesForAnnotationClass
 
 internal class AnnotationUsedAsAnnotationArgumentImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.AnnotationUsedAsAnnotationArgument(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.AnnotationUsedAsAnnotationArgument
 
 internal class IllegalKotlinVersionStringValueImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.IllegalKotlinVersionStringValue(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.IllegalKotlinVersionStringValue
 
 internal class NewerVersionInSinceKotlinImpl(
     override val specifiedVersion: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NewerVersionInSinceKotlin(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.NewerVersionInSinceKotlin
 
 internal class DeprecatedSinceKotlinWithUnorderedVersionsImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.DeprecatedSinceKotlinWithUnorderedVersions(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.DeprecatedSinceKotlinWithUnorderedVersions
 
 internal class DeprecatedSinceKotlinWithoutArgumentsImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.DeprecatedSinceKotlinWithoutArguments(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.DeprecatedSinceKotlinWithoutArguments
 
 internal class DeprecatedSinceKotlinWithoutDeprecatedImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.DeprecatedSinceKotlinWithoutDeprecated(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.DeprecatedSinceKotlinWithoutDeprecated
 
 internal class DeprecatedSinceKotlinWithDeprecatedLevelImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.DeprecatedSinceKotlinWithDeprecatedLevel(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.DeprecatedSinceKotlinWithDeprecatedLevel
 
 internal class DeprecatedSinceKotlinOutsideKotlinSubpackageImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.DeprecatedSinceKotlinOutsideKotlinSubpackage(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.DeprecatedSinceKotlinOutsideKotlinSubpackage
 
 internal class OverrideDeprecationImpl(
     override val overridenSymbol: KtSymbol,
     override val deprecationInfo: DeprecationInfo,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.OverrideDeprecation(), KtAbstractFirDiagnostic<KtNamedDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtNamedDeclaration>(firDiagnostic, token), KtFirDiagnostic.OverrideDeprecation
 
 internal class AnnotationOnSuperclassErrorImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.AnnotationOnSuperclassError(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.AnnotationOnSuperclassError
 
 internal class AnnotationOnSuperclassWarningImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.AnnotationOnSuperclassWarning(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.AnnotationOnSuperclassWarning
 
 internal class RestrictedRetentionForExpressionAnnotationErrorImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.RestrictedRetentionForExpressionAnnotationError(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.RestrictedRetentionForExpressionAnnotationError
 
 internal class RestrictedRetentionForExpressionAnnotationWarningImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.RestrictedRetentionForExpressionAnnotationWarning(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.RestrictedRetentionForExpressionAnnotationWarning
 
 internal class WrongAnnotationTargetImpl(
     override val actualTarget: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.WrongAnnotationTarget(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.WrongAnnotationTarget
 
 internal class WrongAnnotationTargetWithUseSiteTargetImpl(
     override val actualTarget: String,
     override val useSiteTarget: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.WrongAnnotationTargetWithUseSiteTarget(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.WrongAnnotationTargetWithUseSiteTarget
 
 internal class InapplicableTargetOnPropertyImpl(
     override val useSiteDescription: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.InapplicableTargetOnProperty(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.InapplicableTargetOnProperty
 
 internal class InapplicableTargetOnPropertyWarningImpl(
     override val useSiteDescription: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.InapplicableTargetOnPropertyWarning(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.InapplicableTargetOnPropertyWarning
 
 internal class InapplicableTargetPropertyImmutableImpl(
     override val useSiteDescription: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.InapplicableTargetPropertyImmutable(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.InapplicableTargetPropertyImmutable
 
 internal class InapplicableTargetPropertyHasNoDelegateImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.InapplicableTargetPropertyHasNoDelegate(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.InapplicableTargetPropertyHasNoDelegate
 
 internal class InapplicableTargetPropertyHasNoBackingFieldImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.InapplicableTargetPropertyHasNoBackingField(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.InapplicableTargetPropertyHasNoBackingField
 
 internal class InapplicableParamTargetImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.InapplicableParamTarget(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.InapplicableParamTarget
 
 internal class RedundantAnnotationTargetImpl(
     override val useSiteDescription: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.RedundantAnnotationTarget(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.RedundantAnnotationTarget
 
 internal class InapplicableFileTargetImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.InapplicableFileTarget(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.InapplicableFileTarget
 
 internal class RepeatedAnnotationImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.RepeatedAnnotation(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.RepeatedAnnotation
 
 internal class RepeatedAnnotationWarningImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.RepeatedAnnotationWarning(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.RepeatedAnnotationWarning
 
 internal class NotAClassImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NotAClass(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.NotAClass
 
 internal class WrongExtensionFunctionTypeImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.WrongExtensionFunctionType(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.WrongExtensionFunctionType
 
 internal class WrongExtensionFunctionTypeWarningImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.WrongExtensionFunctionTypeWarning(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.WrongExtensionFunctionTypeWarning
 
 internal class AnnotationInWhereClauseErrorImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.AnnotationInWhereClauseError(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.AnnotationInWhereClauseError
 
 internal class PluginAnnotationAmbiguityImpl(
     override val typeFromCompilerPhase: KtType,
     override val typeFromTypesPhase: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.PluginAnnotationAmbiguity(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.PluginAnnotationAmbiguity
 
 internal class AmbiguousAnnotationArgumentImpl(
     override val symbols: List<KtSymbol>,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.AmbiguousAnnotationArgument(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.AmbiguousAnnotationArgument
 
 internal class VolatileOnValueImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.VolatileOnValue(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.VolatileOnValue
 
 internal class VolatileOnDelegateImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.VolatileOnDelegate(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.VolatileOnDelegate
 
 internal class WrongJsQualifierImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.WrongJsQualifier(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.WrongJsQualifier
 
 internal class JsModuleProhibitedOnVarImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.JsModuleProhibitedOnVar(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.JsModuleProhibitedOnVar
 
 internal class JsModuleProhibitedOnNonNativeImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.JsModuleProhibitedOnNonNative(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.JsModuleProhibitedOnNonNative
 
 internal class NestedJsModuleProhibitedImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NestedJsModuleProhibited(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.NestedJsModuleProhibited
 
 internal class RuntimeAnnotationNotSupportedImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.RuntimeAnnotationNotSupported(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.RuntimeAnnotationNotSupported
 
 internal class RuntimeAnnotationOnExternalDeclarationImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.RuntimeAnnotationOnExternalDeclaration(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.RuntimeAnnotationOnExternalDeclaration
 
 internal class NativeAnnotationsAllowedOnlyOnMemberOrExtensionFunImpl(
     override val type: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NativeAnnotationsAllowedOnlyOnMemberOrExtensionFun(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.NativeAnnotationsAllowedOnlyOnMemberOrExtensionFun
 
 internal class NativeIndexerKeyShouldBeStringOrNumberImpl(
     override val kind: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NativeIndexerKeyShouldBeStringOrNumber(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.NativeIndexerKeyShouldBeStringOrNumber
 
 internal class NativeIndexerWrongParameterCountImpl(
     override val parametersCount: Int,
     override val kind: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NativeIndexerWrongParameterCount(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.NativeIndexerWrongParameterCount
 
 internal class NativeIndexerCanNotHaveDefaultArgumentsImpl(
     override val kind: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NativeIndexerCanNotHaveDefaultArguments(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.NativeIndexerCanNotHaveDefaultArguments
 
 internal class NativeGetterReturnTypeShouldBeNullableImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NativeGetterReturnTypeShouldBeNullable(), KtAbstractFirDiagnostic<KtDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtDeclaration>(firDiagnostic, token), KtFirDiagnostic.NativeGetterReturnTypeShouldBeNullable
 
 internal class NativeSetterWrongReturnTypeImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NativeSetterWrongReturnType(), KtAbstractFirDiagnostic<KtDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtDeclaration>(firDiagnostic, token), KtFirDiagnostic.NativeSetterWrongReturnType
 
 internal class JsNameIsNotOnAllAccessorsImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.JsNameIsNotOnAllAccessors(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.JsNameIsNotOnAllAccessors
 
 internal class JsNameProhibitedForNamedNativeImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.JsNameProhibitedForNamedNative(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.JsNameProhibitedForNamedNative
 
 internal class JsNameProhibitedForOverrideImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.JsNameProhibitedForOverride(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.JsNameProhibitedForOverride
 
 internal class JsNameOnPrimaryConstructorProhibitedImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.JsNameOnPrimaryConstructorProhibited(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.JsNameOnPrimaryConstructorProhibited
 
 internal class JsNameOnAccessorAndPropertyImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.JsNameOnAccessorAndProperty(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.JsNameOnAccessorAndProperty
 
 internal class JsNameProhibitedForExtensionPropertyImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.JsNameProhibitedForExtensionProperty(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.JsNameProhibitedForExtensionProperty
 
 internal class OptInUsageImpl(
     override val optInMarkerFqName: FqName,
     override val message: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.OptInUsage(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.OptInUsage
 
 internal class OptInUsageErrorImpl(
     override val optInMarkerFqName: FqName,
     override val message: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.OptInUsageError(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.OptInUsageError
 
 internal class OptInOverrideImpl(
     override val optInMarkerFqName: FqName,
     override val message: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.OptInOverride(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.OptInOverride
 
 internal class OptInOverrideErrorImpl(
     override val optInMarkerFqName: FqName,
     override val message: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.OptInOverrideError(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.OptInOverrideError
 
 internal class OptInIsNotEnabledImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.OptInIsNotEnabled(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.OptInIsNotEnabled
 
 internal class OptInCanOnlyBeUsedAsAnnotationImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.OptInCanOnlyBeUsedAsAnnotation(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.OptInCanOnlyBeUsedAsAnnotation
 
 internal class OptInMarkerCanOnlyBeUsedAsAnnotationOrArgumentInOptInImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.OptInMarkerCanOnlyBeUsedAsAnnotationOrArgumentInOptIn(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.OptInMarkerCanOnlyBeUsedAsAnnotationOrArgumentInOptIn
 
 internal class OptInWithoutArgumentsImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.OptInWithoutArguments(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.OptInWithoutArguments
 
 internal class OptInArgumentIsNotMarkerImpl(
     override val notMarkerFqName: FqName,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.OptInArgumentIsNotMarker(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.OptInArgumentIsNotMarker
 
 internal class OptInMarkerWithWrongTargetImpl(
     override val target: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.OptInMarkerWithWrongTarget(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.OptInMarkerWithWrongTarget
 
 internal class OptInMarkerWithWrongRetentionImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.OptInMarkerWithWrongRetention(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.OptInMarkerWithWrongRetention
 
 internal class OptInMarkerOnWrongTargetImpl(
     override val target: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.OptInMarkerOnWrongTarget(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.OptInMarkerOnWrongTarget
 
 internal class OptInMarkerOnOverrideImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.OptInMarkerOnOverride(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.OptInMarkerOnOverride
 
 internal class OptInMarkerOnOverrideWarningImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.OptInMarkerOnOverrideWarning(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.OptInMarkerOnOverrideWarning
 
 internal class SubclassOptInInapplicableImpl(
     override val target: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.SubclassOptInInapplicable(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.SubclassOptInInapplicable
 
 internal class ExposedTypealiasExpandedTypeImpl(
     override val elementVisibility: EffectiveVisibility,
     override val restrictingDeclaration: KtSymbol,
     override val restrictingVisibility: EffectiveVisibility,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ExposedTypealiasExpandedType(), KtAbstractFirDiagnostic<KtNamedDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtNamedDeclaration>(firDiagnostic, token), KtFirDiagnostic.ExposedTypealiasExpandedType
 
 internal class ExposedFunctionReturnTypeImpl(
     override val elementVisibility: EffectiveVisibility,
     override val restrictingDeclaration: KtSymbol,
     override val restrictingVisibility: EffectiveVisibility,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ExposedFunctionReturnType(), KtAbstractFirDiagnostic<KtNamedDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtNamedDeclaration>(firDiagnostic, token), KtFirDiagnostic.ExposedFunctionReturnType
 
 internal class ExposedReceiverTypeImpl(
     override val elementVisibility: EffectiveVisibility,
     override val restrictingDeclaration: KtSymbol,
     override val restrictingVisibility: EffectiveVisibility,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ExposedReceiverType(), KtAbstractFirDiagnostic<KtTypeReference>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeReference>(firDiagnostic, token), KtFirDiagnostic.ExposedReceiverType
 
 internal class ExposedPropertyTypeImpl(
     override val elementVisibility: EffectiveVisibility,
     override val restrictingDeclaration: KtSymbol,
     override val restrictingVisibility: EffectiveVisibility,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ExposedPropertyType(), KtAbstractFirDiagnostic<KtNamedDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtNamedDeclaration>(firDiagnostic, token), KtFirDiagnostic.ExposedPropertyType
 
 internal class ExposedPropertyTypeInConstructorErrorImpl(
     override val elementVisibility: EffectiveVisibility,
     override val restrictingDeclaration: KtSymbol,
     override val restrictingVisibility: EffectiveVisibility,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ExposedPropertyTypeInConstructorError(), KtAbstractFirDiagnostic<KtNamedDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtNamedDeclaration>(firDiagnostic, token), KtFirDiagnostic.ExposedPropertyTypeInConstructorError
 
 internal class ExposedPropertyTypeInConstructorWarningImpl(
     override val elementVisibility: EffectiveVisibility,
     override val restrictingDeclaration: KtSymbol,
     override val restrictingVisibility: EffectiveVisibility,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ExposedPropertyTypeInConstructorWarning(), KtAbstractFirDiagnostic<KtNamedDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtNamedDeclaration>(firDiagnostic, token), KtFirDiagnostic.ExposedPropertyTypeInConstructorWarning
 
 internal class ExposedParameterTypeImpl(
     override val elementVisibility: EffectiveVisibility,
     override val restrictingDeclaration: KtSymbol,
     override val restrictingVisibility: EffectiveVisibility,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ExposedParameterType(), KtAbstractFirDiagnostic<KtParameter>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtParameter>(firDiagnostic, token), KtFirDiagnostic.ExposedParameterType
 
 internal class ExposedSuperInterfaceImpl(
     override val elementVisibility: EffectiveVisibility,
     override val restrictingDeclaration: KtSymbol,
     override val restrictingVisibility: EffectiveVisibility,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ExposedSuperInterface(), KtAbstractFirDiagnostic<KtTypeReference>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeReference>(firDiagnostic, token), KtFirDiagnostic.ExposedSuperInterface
 
 internal class ExposedSuperClassImpl(
     override val elementVisibility: EffectiveVisibility,
     override val restrictingDeclaration: KtSymbol,
     override val restrictingVisibility: EffectiveVisibility,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ExposedSuperClass(), KtAbstractFirDiagnostic<KtTypeReference>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeReference>(firDiagnostic, token), KtFirDiagnostic.ExposedSuperClass
 
 internal class ExposedTypeParameterBoundImpl(
     override val elementVisibility: EffectiveVisibility,
     override val restrictingDeclaration: KtSymbol,
     override val restrictingVisibility: EffectiveVisibility,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ExposedTypeParameterBound(), KtAbstractFirDiagnostic<KtTypeReference>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeReference>(firDiagnostic, token), KtFirDiagnostic.ExposedTypeParameterBound
 
 internal class InapplicableInfixModifierImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.InapplicableInfixModifier(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.InapplicableInfixModifier
 
 internal class RepeatedModifierImpl(
     override val modifier: KtModifierKeywordToken,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.RepeatedModifier(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.RepeatedModifier
 
 internal class RedundantModifierImpl(
     override val redundantModifier: KtModifierKeywordToken,
     override val conflictingModifier: KtModifierKeywordToken,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.RedundantModifier(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.RedundantModifier
 
 internal class DeprecatedModifierImpl(
     override val deprecatedModifier: KtModifierKeywordToken,
     override val actualModifier: KtModifierKeywordToken,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.DeprecatedModifier(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.DeprecatedModifier
 
 internal class DeprecatedModifierPairImpl(
     override val deprecatedModifier: KtModifierKeywordToken,
     override val conflictingModifier: KtModifierKeywordToken,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.DeprecatedModifierPair(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.DeprecatedModifierPair
 
 internal class DeprecatedModifierForTargetImpl(
     override val deprecatedModifier: KtModifierKeywordToken,
     override val target: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.DeprecatedModifierForTarget(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.DeprecatedModifierForTarget
 
 internal class RedundantModifierForTargetImpl(
     override val redundantModifier: KtModifierKeywordToken,
     override val target: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.RedundantModifierForTarget(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.RedundantModifierForTarget
 
 internal class IncompatibleModifiersImpl(
     override val modifier1: KtModifierKeywordToken,
     override val modifier2: KtModifierKeywordToken,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.IncompatibleModifiers(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.IncompatibleModifiers
 
 internal class RedundantOpenInInterfaceImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.RedundantOpenInInterface(), KtAbstractFirDiagnostic<KtModifierListOwner>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtModifierListOwner>(firDiagnostic, token), KtFirDiagnostic.RedundantOpenInInterface
 
 internal class WrongModifierTargetImpl(
     override val modifier: KtModifierKeywordToken,
     override val target: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.WrongModifierTarget(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.WrongModifierTarget
 
 internal class OperatorModifierRequiredImpl(
     override val functionSymbol: KtFunctionLikeSymbol,
     override val name: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.OperatorModifierRequired(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.OperatorModifierRequired
 
 internal class InfixModifierRequiredImpl(
     override val functionSymbol: KtFunctionLikeSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.InfixModifierRequired(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.InfixModifierRequired
 
 internal class WrongModifierContainingDeclarationImpl(
     override val modifier: KtModifierKeywordToken,
     override val target: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.WrongModifierContainingDeclaration(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.WrongModifierContainingDeclaration
 
 internal class DeprecatedModifierContainingDeclarationImpl(
     override val modifier: KtModifierKeywordToken,
     override val target: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.DeprecatedModifierContainingDeclaration(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.DeprecatedModifierContainingDeclaration
 
 internal class InapplicableOperatorModifierImpl(
     override val message: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.InapplicableOperatorModifier(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.InapplicableOperatorModifier
 
 internal class NoExplicitVisibilityInApiModeImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NoExplicitVisibilityInApiMode(), KtAbstractFirDiagnostic<KtDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtDeclaration>(firDiagnostic, token), KtFirDiagnostic.NoExplicitVisibilityInApiMode
 
 internal class NoExplicitVisibilityInApiModeWarningImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NoExplicitVisibilityInApiModeWarning(), KtAbstractFirDiagnostic<KtDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtDeclaration>(firDiagnostic, token), KtFirDiagnostic.NoExplicitVisibilityInApiModeWarning
 
 internal class NoExplicitReturnTypeInApiModeImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NoExplicitReturnTypeInApiMode(), KtAbstractFirDiagnostic<KtDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtDeclaration>(firDiagnostic, token), KtFirDiagnostic.NoExplicitReturnTypeInApiMode
 
 internal class NoExplicitReturnTypeInApiModeWarningImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NoExplicitReturnTypeInApiModeWarning(), KtAbstractFirDiagnostic<KtDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtDeclaration>(firDiagnostic, token), KtFirDiagnostic.NoExplicitReturnTypeInApiModeWarning
 
 internal class ValueClassNotTopLevelImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ValueClassNotTopLevel(), KtAbstractFirDiagnostic<KtDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtDeclaration>(firDiagnostic, token), KtFirDiagnostic.ValueClassNotTopLevel
 
 internal class ValueClassNotFinalImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ValueClassNotFinal(), KtAbstractFirDiagnostic<KtDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtDeclaration>(firDiagnostic, token), KtFirDiagnostic.ValueClassNotFinal
 
 internal class AbsenceOfPrimaryConstructorForValueClassImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.AbsenceOfPrimaryConstructorForValueClass(), KtAbstractFirDiagnostic<KtDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtDeclaration>(firDiagnostic, token), KtFirDiagnostic.AbsenceOfPrimaryConstructorForValueClass
 
 internal class InlineClassConstructorWrongParametersSizeImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.InlineClassConstructorWrongParametersSize(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.InlineClassConstructorWrongParametersSize
 
 internal class ValueClassEmptyConstructorImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ValueClassEmptyConstructor(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.ValueClassEmptyConstructor
 
 internal class ValueClassConstructorNotFinalReadOnlyParameterImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ValueClassConstructorNotFinalReadOnlyParameter(), KtAbstractFirDiagnostic<KtParameter>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtParameter>(firDiagnostic, token), KtFirDiagnostic.ValueClassConstructorNotFinalReadOnlyParameter
 
 internal class PropertyWithBackingFieldInsideValueClassImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.PropertyWithBackingFieldInsideValueClass(), KtAbstractFirDiagnostic<KtProperty>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtProperty>(firDiagnostic, token), KtFirDiagnostic.PropertyWithBackingFieldInsideValueClass
 
 internal class DelegatedPropertyInsideValueClassImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.DelegatedPropertyInsideValueClass(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.DelegatedPropertyInsideValueClass
 
 internal class ValueClassHasInapplicableParameterTypeImpl(
     override val type: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ValueClassHasInapplicableParameterType(), KtAbstractFirDiagnostic<KtTypeReference>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeReference>(firDiagnostic, token), KtFirDiagnostic.ValueClassHasInapplicableParameterType
 
 internal class ValueClassCannotImplementInterfaceByDelegationImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ValueClassCannotImplementInterfaceByDelegation(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.ValueClassCannotImplementInterfaceByDelegation
 
 internal class ValueClassCannotExtendClassesImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ValueClassCannotExtendClasses(), KtAbstractFirDiagnostic<KtTypeReference>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeReference>(firDiagnostic, token), KtFirDiagnostic.ValueClassCannotExtendClasses
 
 internal class ValueClassCannotBeRecursiveImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ValueClassCannotBeRecursive(), KtAbstractFirDiagnostic<KtTypeReference>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeReference>(firDiagnostic, token), KtFirDiagnostic.ValueClassCannotBeRecursive
 
 internal class MultiFieldValueClassPrimaryConstructorDefaultParameterImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.MultiFieldValueClassPrimaryConstructorDefaultParameter(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.MultiFieldValueClassPrimaryConstructorDefaultParameter
 
 internal class SecondaryConstructorWithBodyInsideValueClassImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.SecondaryConstructorWithBodyInsideValueClass(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.SecondaryConstructorWithBodyInsideValueClass
 
 internal class ReservedMemberInsideValueClassImpl(
     override val name: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ReservedMemberInsideValueClass(), KtAbstractFirDiagnostic<KtFunction>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtFunction>(firDiagnostic, token), KtFirDiagnostic.ReservedMemberInsideValueClass
 
 internal class TypeArgumentOnTypedValueClassEqualsImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.TypeArgumentOnTypedValueClassEquals(), KtAbstractFirDiagnostic<KtTypeReference>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeReference>(firDiagnostic, token), KtFirDiagnostic.TypeArgumentOnTypedValueClassEquals
 
 internal class InnerClassInsideValueClassImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.InnerClassInsideValueClass(), KtAbstractFirDiagnostic<KtDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtDeclaration>(firDiagnostic, token), KtFirDiagnostic.InnerClassInsideValueClass
 
 internal class ValueClassCannotBeCloneableImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ValueClassCannotBeCloneable(), KtAbstractFirDiagnostic<KtDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtDeclaration>(firDiagnostic, token), KtFirDiagnostic.ValueClassCannotBeCloneable
 
 internal class AnnotationOnIllegalMultiFieldValueClassTypedTargetImpl(
     override val name: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.AnnotationOnIllegalMultiFieldValueClassTypedTarget(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.AnnotationOnIllegalMultiFieldValueClassTypedTarget
 
 internal class NoneApplicableImpl(
     override val candidates: List<KtSymbol>,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NoneApplicable(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.NoneApplicable
 
 internal class InapplicableCandidateImpl(
     override val candidate: KtSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.InapplicableCandidate(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.InapplicableCandidate
 
 internal class TypeMismatchImpl(
     override val expectedType: KtType,
     override val actualType: KtType,
     override val isMismatchDueToNullability: Boolean,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.TypeMismatch(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.TypeMismatch
 
 internal class TypeInferenceOnlyInputTypesErrorImpl(
     override val typeParameter: KtTypeParameterSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.TypeInferenceOnlyInputTypesError(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.TypeInferenceOnlyInputTypesError
 
 internal class ThrowableTypeMismatchImpl(
     override val actualType: KtType,
     override val isMismatchDueToNullability: Boolean,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ThrowableTypeMismatch(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.ThrowableTypeMismatch
 
 internal class ConditionTypeMismatchImpl(
     override val actualType: KtType,
     override val isMismatchDueToNullability: Boolean,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ConditionTypeMismatch(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.ConditionTypeMismatch
 
 internal class ArgumentTypeMismatchImpl(
     override val expectedType: KtType,
     override val actualType: KtType,
     override val isMismatchDueToNullability: Boolean,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ArgumentTypeMismatch(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.ArgumentTypeMismatch
 
 internal class NullForNonnullTypeImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NullForNonnullType(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.NullForNonnullType
 
 internal class InapplicableLateinitModifierImpl(
     override val reason: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.InapplicableLateinitModifier(), KtAbstractFirDiagnostic<KtModifierListOwner>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtModifierListOwner>(firDiagnostic, token), KtFirDiagnostic.InapplicableLateinitModifier
 
 internal class VarargOutsideParenthesesImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.VarargOutsideParentheses(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.VarargOutsideParentheses
 
 internal class NamedArgumentsNotAllowedImpl(
     override val forbiddenNamedArgumentsTarget: ForbiddenNamedArgumentsTarget,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NamedArgumentsNotAllowed(), KtAbstractFirDiagnostic<KtValueArgument>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtValueArgument>(firDiagnostic, token), KtFirDiagnostic.NamedArgumentsNotAllowed
 
 internal class NonVarargSpreadImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NonVarargSpread(), KtAbstractFirDiagnostic<LeafPsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<LeafPsiElement>(firDiagnostic, token), KtFirDiagnostic.NonVarargSpread
 
 internal class ArgumentPassedTwiceImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ArgumentPassedTwice(), KtAbstractFirDiagnostic<KtValueArgument>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtValueArgument>(firDiagnostic, token), KtFirDiagnostic.ArgumentPassedTwice
 
 internal class TooManyArgumentsImpl(
     override val function: KtCallableSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.TooManyArguments(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.TooManyArguments
 
 internal class NoValueForParameterImpl(
     override val violatedParameter: KtSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NoValueForParameter(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.NoValueForParameter
 
 internal class NamedParameterNotFoundImpl(
     override val name: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NamedParameterNotFound(), KtAbstractFirDiagnostic<KtValueArgument>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtValueArgument>(firDiagnostic, token), KtFirDiagnostic.NamedParameterNotFound
 
 internal class NameForAmbiguousParameterImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NameForAmbiguousParameter(), KtAbstractFirDiagnostic<KtValueArgument>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtValueArgument>(firDiagnostic, token), KtFirDiagnostic.NameForAmbiguousParameter
 
 internal class AssignmentTypeMismatchImpl(
     override val expectedType: KtType,
     override val actualType: KtType,
     override val isMismatchDueToNullability: Boolean,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.AssignmentTypeMismatch(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.AssignmentTypeMismatch
 
 internal class ResultTypeMismatchImpl(
     override val expectedType: KtType,
     override val actualType: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ResultTypeMismatch(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.ResultTypeMismatch
 
 internal class ManyLambdaExpressionArgumentsImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ManyLambdaExpressionArguments(), KtAbstractFirDiagnostic<KtValueArgument>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtValueArgument>(firDiagnostic, token), KtFirDiagnostic.ManyLambdaExpressionArguments
 
 internal class NewInferenceNoInformationForParameterImpl(
     override val name: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NewInferenceNoInformationForParameter(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.NewInferenceNoInformationForParameter
 
 internal class SpreadOfNullableImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.SpreadOfNullable(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.SpreadOfNullable
 
 internal class AssigningSingleElementToVarargInNamedFormFunctionErrorImpl(
     override val expectedArrayType: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.AssigningSingleElementToVarargInNamedFormFunctionError(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.AssigningSingleElementToVarargInNamedFormFunctionError
 
 internal class AssigningSingleElementToVarargInNamedFormFunctionWarningImpl(
     override val expectedArrayType: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.AssigningSingleElementToVarargInNamedFormFunctionWarning(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.AssigningSingleElementToVarargInNamedFormFunctionWarning
 
 internal class AssigningSingleElementToVarargInNamedFormAnnotationErrorImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.AssigningSingleElementToVarargInNamedFormAnnotationError(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.AssigningSingleElementToVarargInNamedFormAnnotationError
 
 internal class AssigningSingleElementToVarargInNamedFormAnnotationWarningImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.AssigningSingleElementToVarargInNamedFormAnnotationWarning(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.AssigningSingleElementToVarargInNamedFormAnnotationWarning
 
 internal class RedundantSpreadOperatorInNamedFormInAnnotationImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.RedundantSpreadOperatorInNamedFormInAnnotation(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.RedundantSpreadOperatorInNamedFormInAnnotation
 
 internal class RedundantSpreadOperatorInNamedFormInFunctionImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.RedundantSpreadOperatorInNamedFormInFunction(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.RedundantSpreadOperatorInNamedFormInFunction
 
 internal class InferenceUnsuccessfulForkImpl(
     override val message: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.InferenceUnsuccessfulFork(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.InferenceUnsuccessfulFork
 
 internal class OverloadResolutionAmbiguityImpl(
     override val candidates: List<KtSymbol>,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.OverloadResolutionAmbiguity(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.OverloadResolutionAmbiguity
 
 internal class AssignOperatorAmbiguityImpl(
     override val candidates: List<KtSymbol>,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.AssignOperatorAmbiguity(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.AssignOperatorAmbiguity
 
 internal class IteratorAmbiguityImpl(
     override val candidates: List<KtSymbol>,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.IteratorAmbiguity(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.IteratorAmbiguity
 
 internal class HasNextFunctionAmbiguityImpl(
     override val candidates: List<KtSymbol>,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.HasNextFunctionAmbiguity(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.HasNextFunctionAmbiguity
 
 internal class NextAmbiguityImpl(
     override val candidates: List<KtSymbol>,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NextAmbiguity(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.NextAmbiguity
 
 internal class AmbiguousFunctionTypeKindImpl(
     override val kinds: List<FunctionTypeKind>,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.AmbiguousFunctionTypeKind(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.AmbiguousFunctionTypeKind
 
 internal class NoContextReceiverImpl(
     override val contextReceiverRepresentation: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NoContextReceiver(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.NoContextReceiver
 
 internal class MultipleArgumentsApplicableForContextReceiverImpl(
     override val contextReceiverRepresentation: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.MultipleArgumentsApplicableForContextReceiver(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.MultipleArgumentsApplicableForContextReceiver
 
 internal class AmbiguousCallWithImplicitContextReceiverImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.AmbiguousCallWithImplicitContextReceiver(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.AmbiguousCallWithImplicitContextReceiver
 
 internal class UnsupportedContextualDeclarationCallImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.UnsupportedContextualDeclarationCall(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.UnsupportedContextualDeclarationCall
 
 internal class RecursionInImplicitTypesImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.RecursionInImplicitTypes(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.RecursionInImplicitTypes
 
 internal class InferenceErrorImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.InferenceError(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.InferenceError
 
 internal class ProjectionOnNonClassTypeArgumentImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ProjectionOnNonClassTypeArgument(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.ProjectionOnNonClassTypeArgument
 
 internal class UpperBoundViolatedImpl(
     override val expectedUpperBound: KtType,
     override val actualUpperBound: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.UpperBoundViolated(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.UpperBoundViolated
 
 internal class UpperBoundViolatedInTypealiasExpansionImpl(
     override val expectedUpperBound: KtType,
     override val actualUpperBound: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.UpperBoundViolatedInTypealiasExpansion(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.UpperBoundViolatedInTypealiasExpansion
 
 internal class TypeArgumentsNotAllowedImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.TypeArgumentsNotAllowed(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.TypeArgumentsNotAllowed
 
 internal class WrongNumberOfTypeArgumentsImpl(
     override val expectedCount: Int,
     override val classifier: KtClassLikeSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.WrongNumberOfTypeArguments(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.WrongNumberOfTypeArguments
 
 internal class NoTypeArgumentsOnRhsImpl(
     override val expectedCount: Int,
     override val classifier: KtClassLikeSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NoTypeArgumentsOnRhs(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.NoTypeArgumentsOnRhs
 
 internal class OuterClassArgumentsRequiredImpl(
     override val outer: KtClassLikeSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.OuterClassArgumentsRequired(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.OuterClassArgumentsRequired
 
 internal class TypeParametersInObjectImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.TypeParametersInObject(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.TypeParametersInObject
 
 internal class TypeParametersInAnonymousObjectImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.TypeParametersInAnonymousObject(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.TypeParametersInAnonymousObject
 
 internal class IllegalProjectionUsageImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.IllegalProjectionUsage(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.IllegalProjectionUsage
 
 internal class TypeParametersInEnumImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.TypeParametersInEnum(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.TypeParametersInEnum
 
 internal class ConflictingProjectionImpl(
     override val type: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ConflictingProjection(), KtAbstractFirDiagnostic<KtTypeProjection>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeProjection>(firDiagnostic, token), KtFirDiagnostic.ConflictingProjection
 
 internal class ConflictingProjectionInTypealiasExpansionImpl(
     override val type: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ConflictingProjectionInTypealiasExpansion(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.ConflictingProjectionInTypealiasExpansion
 
 internal class RedundantProjectionImpl(
     override val type: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.RedundantProjection(), KtAbstractFirDiagnostic<KtTypeProjection>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeProjection>(firDiagnostic, token), KtFirDiagnostic.RedundantProjection
 
 internal class VarianceOnTypeParameterNotAllowedImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.VarianceOnTypeParameterNotAllowed(), KtAbstractFirDiagnostic<KtTypeParameter>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeParameter>(firDiagnostic, token), KtFirDiagnostic.VarianceOnTypeParameterNotAllowed
 
 internal class CatchParameterWithDefaultValueImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.CatchParameterWithDefaultValue(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.CatchParameterWithDefaultValue
 
 internal class ReifiedTypeInCatchClauseImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ReifiedTypeInCatchClause(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.ReifiedTypeInCatchClause
 
 internal class TypeParameterInCatchClauseImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.TypeParameterInCatchClause(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.TypeParameterInCatchClause
 
 internal class GenericThrowableSubclassImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.GenericThrowableSubclass(), KtAbstractFirDiagnostic<KtTypeParameter>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeParameter>(firDiagnostic, token), KtFirDiagnostic.GenericThrowableSubclass
 
 internal class InnerClassOfGenericThrowableSubclassImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.InnerClassOfGenericThrowableSubclass(), KtAbstractFirDiagnostic<KtClassOrObject>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtClassOrObject>(firDiagnostic, token), KtFirDiagnostic.InnerClassOfGenericThrowableSubclass
 
 internal class KclassWithNullableTypeParameterInSignatureImpl(
     override val typeParameter: KtTypeParameterSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.KclassWithNullableTypeParameterInSignature(), KtAbstractFirDiagnostic<KtNamedDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtNamedDeclaration>(firDiagnostic, token), KtFirDiagnostic.KclassWithNullableTypeParameterInSignature
 
 internal class TypeParameterAsReifiedImpl(
     override val typeParameter: KtTypeParameterSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.TypeParameterAsReified(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.TypeParameterAsReified
 
 internal class TypeParameterAsReifiedArrayErrorImpl(
     override val typeParameter: KtTypeParameterSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.TypeParameterAsReifiedArrayError(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.TypeParameterAsReifiedArrayError
 
 internal class TypeParameterAsReifiedArrayWarningImpl(
     override val typeParameter: KtTypeParameterSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.TypeParameterAsReifiedArrayWarning(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.TypeParameterAsReifiedArrayWarning
 
 internal class ReifiedTypeForbiddenSubstitutionImpl(
     override val type: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ReifiedTypeForbiddenSubstitution(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.ReifiedTypeForbiddenSubstitution
 
 internal class DefinitelyNonNullableAsReifiedImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.DefinitelyNonNullableAsReified(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.DefinitelyNonNullableAsReified
 
 internal class FinalUpperBoundImpl(
     override val type: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.FinalUpperBound(), KtAbstractFirDiagnostic<KtTypeReference>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeReference>(firDiagnostic, token), KtFirDiagnostic.FinalUpperBound
 
 internal class UpperBoundIsExtensionFunctionTypeImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.UpperBoundIsExtensionFunctionType(), KtAbstractFirDiagnostic<KtTypeReference>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeReference>(firDiagnostic, token), KtFirDiagnostic.UpperBoundIsExtensionFunctionType
 
 internal class BoundsNotAllowedIfBoundedByTypeParameterImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.BoundsNotAllowedIfBoundedByTypeParameter(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.BoundsNotAllowedIfBoundedByTypeParameter
 
 internal class OnlyOneClassBoundAllowedImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.OnlyOneClassBoundAllowed(), KtAbstractFirDiagnostic<KtTypeReference>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeReference>(firDiagnostic, token), KtFirDiagnostic.OnlyOneClassBoundAllowed
 
 internal class RepeatedBoundImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.RepeatedBound(), KtAbstractFirDiagnostic<KtTypeReference>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeReference>(firDiagnostic, token), KtFirDiagnostic.RepeatedBound
 
 internal class ConflictingUpperBoundsImpl(
     override val typeParameter: KtTypeParameterSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ConflictingUpperBounds(), KtAbstractFirDiagnostic<KtNamedDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtNamedDeclaration>(firDiagnostic, token), KtFirDiagnostic.ConflictingUpperBounds
 
 internal class NameInConstraintIsNotATypeParameterImpl(
     override val typeParameterName: Name,
     override val typeParametersOwner: KtSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NameInConstraintIsNotATypeParameter(), KtAbstractFirDiagnostic<KtSimpleNameExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtSimpleNameExpression>(firDiagnostic, token), KtFirDiagnostic.NameInConstraintIsNotATypeParameter
 
 internal class BoundOnTypeAliasParameterNotAllowedImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.BoundOnTypeAliasParameterNotAllowed(), KtAbstractFirDiagnostic<KtTypeReference>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeReference>(firDiagnostic, token), KtFirDiagnostic.BoundOnTypeAliasParameterNotAllowed
 
 internal class ReifiedTypeParameterNoInlineImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ReifiedTypeParameterNoInline(), KtAbstractFirDiagnostic<KtTypeParameter>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeParameter>(firDiagnostic, token), KtFirDiagnostic.ReifiedTypeParameterNoInline
 
 internal class TypeParametersNotAllowedImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.TypeParametersNotAllowed(), KtAbstractFirDiagnostic<KtDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtDeclaration>(firDiagnostic, token), KtFirDiagnostic.TypeParametersNotAllowed
 
 internal class TypeParameterOfPropertyNotUsedInReceiverImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.TypeParameterOfPropertyNotUsedInReceiver(), KtAbstractFirDiagnostic<KtTypeParameter>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeParameter>(firDiagnostic, token), KtFirDiagnostic.TypeParameterOfPropertyNotUsedInReceiver
 
 internal class ReturnTypeMismatchImpl(
     override val expectedType: KtType,
     override val actualType: KtType,
     override val targetFunction: KtSymbol,
     override val isMismatchDueToNullability: Boolean,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ReturnTypeMismatch(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.ReturnTypeMismatch
 
 internal class ImplicitNothingReturnTypeImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ImplicitNothingReturnType(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.ImplicitNothingReturnType
 
 internal class ImplicitNothingPropertyTypeImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ImplicitNothingPropertyType(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.ImplicitNothingPropertyType
 
 internal class CyclicGenericUpperBoundImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.CyclicGenericUpperBound(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.CyclicGenericUpperBound
 
 internal class DeprecatedTypeParameterSyntaxImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.DeprecatedTypeParameterSyntax(), KtAbstractFirDiagnostic<KtDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtDeclaration>(firDiagnostic, token), KtFirDiagnostic.DeprecatedTypeParameterSyntax
 
 internal class MisplacedTypeParameterConstraintsImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.MisplacedTypeParameterConstraints(), KtAbstractFirDiagnostic<KtTypeParameter>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeParameter>(firDiagnostic, token), KtFirDiagnostic.MisplacedTypeParameterConstraints
 
 internal class DynamicSupertypeImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.DynamicSupertype(), KtAbstractFirDiagnostic<KtTypeReference>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeReference>(firDiagnostic, token), KtFirDiagnostic.DynamicSupertype
 
 internal class DynamicUpperBoundImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.DynamicUpperBound(), KtAbstractFirDiagnostic<KtTypeReference>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeReference>(firDiagnostic, token), KtFirDiagnostic.DynamicUpperBound
 
 internal class DynamicReceiverNotAllowedImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.DynamicReceiverNotAllowed(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.DynamicReceiverNotAllowed
 
 internal class IncompatibleTypesImpl(
     override val typeA: KtType,
     override val typeB: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.IncompatibleTypes(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.IncompatibleTypes
 
 internal class IncompatibleTypesWarningImpl(
     override val typeA: KtType,
     override val typeB: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.IncompatibleTypesWarning(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.IncompatibleTypesWarning
 
 internal class TypeVarianceConflictErrorImpl(
     override val typeParameter: KtTypeParameterSymbol,
     override val typeParameterVariance: Variance,
     override val variance: Variance,
     override val containingType: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.TypeVarianceConflictError(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.TypeVarianceConflictError
 
 internal class TypeVarianceConflictInExpandedTypeImpl(
     override val typeParameter: KtTypeParameterSymbol,
     override val typeParameterVariance: Variance,
     override val variance: Variance,
     override val containingType: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.TypeVarianceConflictInExpandedType(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.TypeVarianceConflictInExpandedType
 
 internal class SmartcastImpossibleImpl(
     override val desiredType: KtType,
     override val subject: KtExpression,
     override val description: String,
     override val isCastToNotNull: Boolean,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.SmartcastImpossible(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.SmartcastImpossible
 
 internal class RedundantNullableImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.RedundantNullable(), KtAbstractFirDiagnostic<KtTypeReference>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeReference>(firDiagnostic, token), KtFirDiagnostic.RedundantNullable
 
 internal class PlatformClassMappedToKotlinImpl(
     override val kotlinClass: FqName,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.PlatformClassMappedToKotlin(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.PlatformClassMappedToKotlin
 
 internal class InferredTypeVariableIntoEmptyIntersectionErrorImpl(
     override val typeVariableDescription: String,
     override val incompatibleTypes: List<KtType>,
     override val description: String,
     override val causingTypes: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.InferredTypeVariableIntoEmptyIntersectionError(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.InferredTypeVariableIntoEmptyIntersectionError
 
 internal class InferredTypeVariableIntoEmptyIntersectionWarningImpl(
     override val typeVariableDescription: String,
     override val incompatibleTypes: List<KtType>,
     override val description: String,
     override val causingTypes: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.InferredTypeVariableIntoEmptyIntersectionWarning(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.InferredTypeVariableIntoEmptyIntersectionWarning
 
 internal class InferredTypeVariableIntoPossibleEmptyIntersectionImpl(
     override val typeVariableDescription: String,
     override val incompatibleTypes: List<KtType>,
     override val description: String,
     override val causingTypes: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.InferredTypeVariableIntoPossibleEmptyIntersection(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.InferredTypeVariableIntoPossibleEmptyIntersection
 
 internal class IncorrectLeftComponentOfIntersectionImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.IncorrectLeftComponentOfIntersection(), KtAbstractFirDiagnostic<KtTypeReference>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeReference>(firDiagnostic, token), KtFirDiagnostic.IncorrectLeftComponentOfIntersection
 
 internal class IncorrectRightComponentOfIntersectionImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.IncorrectRightComponentOfIntersection(), KtAbstractFirDiagnostic<KtTypeReference>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeReference>(firDiagnostic, token), KtFirDiagnostic.IncorrectRightComponentOfIntersection
 
 internal class NullableOnDefinitelyNotNullableImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NullableOnDefinitelyNotNullable(), KtAbstractFirDiagnostic<KtTypeReference>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeReference>(firDiagnostic, token), KtFirDiagnostic.NullableOnDefinitelyNotNullable
 
 internal class ExtensionInClassReferenceNotAllowedImpl(
     override val referencedDeclaration: KtCallableSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ExtensionInClassReferenceNotAllowed(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.ExtensionInClassReferenceNotAllowed
 
 internal class CallableReferenceLhsNotAClassImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.CallableReferenceLhsNotAClass(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.CallableReferenceLhsNotAClass
 
 internal class CallableReferenceToAnnotationConstructorImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.CallableReferenceToAnnotationConstructor(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.CallableReferenceToAnnotationConstructor
 
 internal class ClassLiteralLhsNotAClassImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ClassLiteralLhsNotAClass(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.ClassLiteralLhsNotAClass
 
 internal class NullableTypeInClassLiteralLhsImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NullableTypeInClassLiteralLhs(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.NullableTypeInClassLiteralLhs
 
 internal class ExpressionOfNullableTypeInClassLiteralLhsImpl(
     override val lhsType: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ExpressionOfNullableTypeInClassLiteralLhs(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.ExpressionOfNullableTypeInClassLiteralLhs
 
 internal class NothingToOverrideImpl(
     override val declaration: KtCallableSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NothingToOverride(), KtAbstractFirDiagnostic<KtModifierListOwner>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtModifierListOwner>(firDiagnostic, token), KtFirDiagnostic.NothingToOverride
 
 internal class CannotOverrideInvisibleMemberImpl(
     override val overridingMember: KtCallableSymbol,
     override val baseMember: KtCallableSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.CannotOverrideInvisibleMember(), KtAbstractFirDiagnostic<KtNamedDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtNamedDeclaration>(firDiagnostic, token), KtFirDiagnostic.CannotOverrideInvisibleMember
 
 internal class DataClassOverrideConflictImpl(
     override val overridingMember: KtCallableSymbol,
     override val baseMember: KtCallableSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.DataClassOverrideConflict(), KtAbstractFirDiagnostic<KtClassOrObject>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtClassOrObject>(firDiagnostic, token), KtFirDiagnostic.DataClassOverrideConflict
 
 internal class CannotWeakenAccessPrivilegeImpl(
     override val overridingVisibility: Visibility,
     override val overridden: KtCallableSymbol,
     override val containingClassName: Name,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.CannotWeakenAccessPrivilege(), KtAbstractFirDiagnostic<KtModifierListOwner>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtModifierListOwner>(firDiagnostic, token), KtFirDiagnostic.CannotWeakenAccessPrivilege
 
 internal class CannotChangeAccessPrivilegeImpl(
     override val overridingVisibility: Visibility,
     override val overridden: KtCallableSymbol,
     override val containingClassName: Name,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.CannotChangeAccessPrivilege(), KtAbstractFirDiagnostic<KtModifierListOwner>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtModifierListOwner>(firDiagnostic, token), KtFirDiagnostic.CannotChangeAccessPrivilege
 
 internal class OverridingFinalMemberImpl(
     override val overriddenDeclaration: KtCallableSymbol,
     override val containingClassName: Name,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.OverridingFinalMember(), KtAbstractFirDiagnostic<KtNamedDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtNamedDeclaration>(firDiagnostic, token), KtFirDiagnostic.OverridingFinalMember
 
 internal class ReturnTypeMismatchOnInheritanceImpl(
     override val conflictingDeclaration1: KtCallableSymbol,
     override val conflictingDeclaration2: KtCallableSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ReturnTypeMismatchOnInheritance(), KtAbstractFirDiagnostic<KtClassOrObject>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtClassOrObject>(firDiagnostic, token), KtFirDiagnostic.ReturnTypeMismatchOnInheritance
 
 internal class PropertyTypeMismatchOnInheritanceImpl(
     override val conflictingDeclaration1: KtCallableSymbol,
     override val conflictingDeclaration2: KtCallableSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.PropertyTypeMismatchOnInheritance(), KtAbstractFirDiagnostic<KtClassOrObject>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtClassOrObject>(firDiagnostic, token), KtFirDiagnostic.PropertyTypeMismatchOnInheritance
 
 internal class VarTypeMismatchOnInheritanceImpl(
     override val conflictingDeclaration1: KtCallableSymbol,
     override val conflictingDeclaration2: KtCallableSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.VarTypeMismatchOnInheritance(), KtAbstractFirDiagnostic<KtClassOrObject>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtClassOrObject>(firDiagnostic, token), KtFirDiagnostic.VarTypeMismatchOnInheritance
 
 internal class ReturnTypeMismatchByDelegationImpl(
     override val delegateDeclaration: KtCallableSymbol,
     override val baseDeclaration: KtCallableSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ReturnTypeMismatchByDelegation(), KtAbstractFirDiagnostic<KtClassOrObject>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtClassOrObject>(firDiagnostic, token), KtFirDiagnostic.ReturnTypeMismatchByDelegation
 
 internal class PropertyTypeMismatchByDelegationImpl(
     override val delegateDeclaration: KtCallableSymbol,
     override val baseDeclaration: KtCallableSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.PropertyTypeMismatchByDelegation(), KtAbstractFirDiagnostic<KtClassOrObject>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtClassOrObject>(firDiagnostic, token), KtFirDiagnostic.PropertyTypeMismatchByDelegation
 
 internal class VarOverriddenByValByDelegationImpl(
     override val delegateDeclaration: KtCallableSymbol,
     override val baseDeclaration: KtCallableSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.VarOverriddenByValByDelegation(), KtAbstractFirDiagnostic<KtClassOrObject>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtClassOrObject>(firDiagnostic, token), KtFirDiagnostic.VarOverriddenByValByDelegation
 
 internal class ConflictingInheritedMembersImpl(
     override val owner: KtClassLikeSymbol,
     override val conflictingDeclarations: List<KtCallableSymbol>,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ConflictingInheritedMembers(), KtAbstractFirDiagnostic<KtClassOrObject>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtClassOrObject>(firDiagnostic, token), KtFirDiagnostic.ConflictingInheritedMembers
 
 internal class AbstractMemberNotImplementedImpl(
     override val classOrObject: KtClassLikeSymbol,
     override val missingDeclaration: KtCallableSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.AbstractMemberNotImplemented(), KtAbstractFirDiagnostic<KtClassOrObject>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtClassOrObject>(firDiagnostic, token), KtFirDiagnostic.AbstractMemberNotImplemented
 
 internal class AbstractClassMemberNotImplementedImpl(
     override val classOrObject: KtClassLikeSymbol,
     override val missingDeclaration: KtCallableSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.AbstractClassMemberNotImplemented(), KtAbstractFirDiagnostic<KtClassOrObject>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtClassOrObject>(firDiagnostic, token), KtFirDiagnostic.AbstractClassMemberNotImplemented
 
 internal class InvisibleAbstractMemberFromSuperErrorImpl(
     override val classOrObject: KtClassLikeSymbol,
     override val invisibleDeclaration: KtCallableSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.InvisibleAbstractMemberFromSuperError(), KtAbstractFirDiagnostic<KtClassOrObject>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtClassOrObject>(firDiagnostic, token), KtFirDiagnostic.InvisibleAbstractMemberFromSuperError
 
 internal class InvisibleAbstractMemberFromSuperWarningImpl(
     override val classOrObject: KtClassLikeSymbol,
     override val invisibleDeclaration: KtCallableSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.InvisibleAbstractMemberFromSuperWarning(), KtAbstractFirDiagnostic<KtClassOrObject>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtClassOrObject>(firDiagnostic, token), KtFirDiagnostic.InvisibleAbstractMemberFromSuperWarning
 
 internal class AmbiguousAnonymousTypeInferredImpl(
     override val superTypes: List<KtType>,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.AmbiguousAnonymousTypeInferred(), KtAbstractFirDiagnostic<KtDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtDeclaration>(firDiagnostic, token), KtFirDiagnostic.AmbiguousAnonymousTypeInferred
 
 internal class ManyImplMemberNotImplementedImpl(
     override val classOrObject: KtClassLikeSymbol,
     override val missingDeclaration: KtCallableSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ManyImplMemberNotImplemented(), KtAbstractFirDiagnostic<KtClassOrObject>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtClassOrObject>(firDiagnostic, token), KtFirDiagnostic.ManyImplMemberNotImplemented
 
 internal class ManyInterfacesMemberNotImplementedImpl(
     override val classOrObject: KtClassLikeSymbol,
     override val missingDeclaration: KtCallableSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ManyInterfacesMemberNotImplemented(), KtAbstractFirDiagnostic<KtClassOrObject>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtClassOrObject>(firDiagnostic, token), KtFirDiagnostic.ManyInterfacesMemberNotImplemented
 
 internal class OverridingFinalMemberByDelegationImpl(
     override val delegatedDeclaration: KtCallableSymbol,
     override val overriddenDeclaration: KtCallableSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.OverridingFinalMemberByDelegation(), KtAbstractFirDiagnostic<KtClassOrObject>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtClassOrObject>(firDiagnostic, token), KtFirDiagnostic.OverridingFinalMemberByDelegation
 
 internal class DelegatedMemberHidesSupertypeOverrideImpl(
     override val delegatedDeclaration: KtCallableSymbol,
     override val overriddenDeclaration: KtCallableSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.DelegatedMemberHidesSupertypeOverride(), KtAbstractFirDiagnostic<KtClassOrObject>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtClassOrObject>(firDiagnostic, token), KtFirDiagnostic.DelegatedMemberHidesSupertypeOverride
 
 internal class ReturnTypeMismatchOnOverrideImpl(
     override val function: KtCallableSymbol,
     override val superFunction: KtCallableSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ReturnTypeMismatchOnOverride(), KtAbstractFirDiagnostic<KtNamedDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtNamedDeclaration>(firDiagnostic, token), KtFirDiagnostic.ReturnTypeMismatchOnOverride
 
 internal class PropertyTypeMismatchOnOverrideImpl(
     override val property: KtCallableSymbol,
     override val superProperty: KtCallableSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.PropertyTypeMismatchOnOverride(), KtAbstractFirDiagnostic<KtNamedDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtNamedDeclaration>(firDiagnostic, token), KtFirDiagnostic.PropertyTypeMismatchOnOverride
 
 internal class VarTypeMismatchOnOverrideImpl(
     override val variable: KtCallableSymbol,
     override val superVariable: KtCallableSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.VarTypeMismatchOnOverride(), KtAbstractFirDiagnostic<KtNamedDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtNamedDeclaration>(firDiagnostic, token), KtFirDiagnostic.VarTypeMismatchOnOverride
 
 internal class VarOverriddenByValImpl(
     override val overridingDeclaration: KtCallableSymbol,
     override val overriddenDeclaration: KtCallableSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.VarOverriddenByVal(), KtAbstractFirDiagnostic<KtNamedDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtNamedDeclaration>(firDiagnostic, token), KtFirDiagnostic.VarOverriddenByVal
 
 internal class VarImplementedByInheritedValErrorImpl(
     override val classOrObject: KtClassLikeSymbol,
     override val overridingDeclaration: KtCallableSymbol,
     override val overriddenDeclaration: KtCallableSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.VarImplementedByInheritedValError(), KtAbstractFirDiagnostic<KtNamedDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtNamedDeclaration>(firDiagnostic, token), KtFirDiagnostic.VarImplementedByInheritedValError
 
 internal class VarImplementedByInheritedValWarningImpl(
     override val classOrObject: KtClassLikeSymbol,
     override val overridingDeclaration: KtCallableSymbol,
     override val overriddenDeclaration: KtCallableSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.VarImplementedByInheritedValWarning(), KtAbstractFirDiagnostic<KtNamedDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtNamedDeclaration>(firDiagnostic, token), KtFirDiagnostic.VarImplementedByInheritedValWarning
 
 internal class NonFinalMemberInFinalClassImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NonFinalMemberInFinalClass(), KtAbstractFirDiagnostic<KtNamedDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtNamedDeclaration>(firDiagnostic, token), KtFirDiagnostic.NonFinalMemberInFinalClass
 
 internal class NonFinalMemberInObjectImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NonFinalMemberInObject(), KtAbstractFirDiagnostic<KtNamedDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtNamedDeclaration>(firDiagnostic, token), KtFirDiagnostic.NonFinalMemberInObject
 
 internal class VirtualMemberHiddenImpl(
     override val declared: KtCallableSymbol,
     override val overriddenContainer: KtClassLikeSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.VirtualMemberHidden(), KtAbstractFirDiagnostic<KtNamedDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtNamedDeclaration>(firDiagnostic, token), KtFirDiagnostic.VirtualMemberHidden
 
 internal class ManyCompanionObjectsImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ManyCompanionObjects(), KtAbstractFirDiagnostic<KtObjectDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtObjectDeclaration>(firDiagnostic, token), KtFirDiagnostic.ManyCompanionObjects
 
 internal class ConflictingOverloadsImpl(
     override val conflictingOverloads: List<KtSymbol>,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ConflictingOverloads(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.ConflictingOverloads
 
 internal class RedeclarationImpl(
     override val conflictingDeclarations: List<KtSymbol>,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.Redeclaration(), KtAbstractFirDiagnostic<KtNamedDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtNamedDeclaration>(firDiagnostic, token), KtFirDiagnostic.Redeclaration
 
 internal class PackageOrClassifierRedeclarationImpl(
     override val conflictingDeclarations: List<KtSymbol>,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.PackageOrClassifierRedeclaration(), KtAbstractFirDiagnostic<KtNamedDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtNamedDeclaration>(firDiagnostic, token), KtFirDiagnostic.PackageOrClassifierRedeclaration
 
 internal class MethodOfAnyImplementedInInterfaceImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.MethodOfAnyImplementedInInterface(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.MethodOfAnyImplementedInInterface
 
 internal class LocalObjectNotAllowedImpl(
     override val objectName: Name,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.LocalObjectNotAllowed(), KtAbstractFirDiagnostic<KtNamedDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtNamedDeclaration>(firDiagnostic, token), KtFirDiagnostic.LocalObjectNotAllowed
 
 internal class LocalInterfaceNotAllowedImpl(
     override val interfaceName: Name,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.LocalInterfaceNotAllowed(), KtAbstractFirDiagnostic<KtNamedDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtNamedDeclaration>(firDiagnostic, token), KtFirDiagnostic.LocalInterfaceNotAllowed
 
 internal class AbstractFunctionInNonAbstractClassImpl(
     override val function: KtCallableSymbol,
     override val containingClass: KtClassLikeSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.AbstractFunctionInNonAbstractClass(), KtAbstractFirDiagnostic<KtFunction>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtFunction>(firDiagnostic, token), KtFirDiagnostic.AbstractFunctionInNonAbstractClass
 
 internal class AbstractFunctionWithBodyImpl(
     override val function: KtCallableSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.AbstractFunctionWithBody(), KtAbstractFirDiagnostic<KtFunction>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtFunction>(firDiagnostic, token), KtFirDiagnostic.AbstractFunctionWithBody
 
 internal class NonAbstractFunctionWithNoBodyImpl(
     override val function: KtCallableSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NonAbstractFunctionWithNoBody(), KtAbstractFirDiagnostic<KtFunction>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtFunction>(firDiagnostic, token), KtFirDiagnostic.NonAbstractFunctionWithNoBody
 
 internal class PrivateFunctionWithNoBodyImpl(
     override val function: KtCallableSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.PrivateFunctionWithNoBody(), KtAbstractFirDiagnostic<KtFunction>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtFunction>(firDiagnostic, token), KtFirDiagnostic.PrivateFunctionWithNoBody
 
 internal class NonMemberFunctionNoBodyImpl(
     override val function: KtCallableSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NonMemberFunctionNoBody(), KtAbstractFirDiagnostic<KtFunction>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtFunction>(firDiagnostic, token), KtFirDiagnostic.NonMemberFunctionNoBody
 
 internal class FunctionDeclarationWithNoNameImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.FunctionDeclarationWithNoName(), KtAbstractFirDiagnostic<KtFunction>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtFunction>(firDiagnostic, token), KtFirDiagnostic.FunctionDeclarationWithNoName
 
 internal class AnonymousFunctionWithNameImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.AnonymousFunctionWithName(), KtAbstractFirDiagnostic<KtFunction>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtFunction>(firDiagnostic, token), KtFirDiagnostic.AnonymousFunctionWithName
 
 internal class AnonymousFunctionParameterWithDefaultValueImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.AnonymousFunctionParameterWithDefaultValue(), KtAbstractFirDiagnostic<KtParameter>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtParameter>(firDiagnostic, token), KtFirDiagnostic.AnonymousFunctionParameterWithDefaultValue
 
 internal class UselessVarargOnParameterImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.UselessVarargOnParameter(), KtAbstractFirDiagnostic<KtParameter>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtParameter>(firDiagnostic, token), KtFirDiagnostic.UselessVarargOnParameter
 
 internal class MultipleVarargParametersImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.MultipleVarargParameters(), KtAbstractFirDiagnostic<KtParameter>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtParameter>(firDiagnostic, token), KtFirDiagnostic.MultipleVarargParameters
 
 internal class ForbiddenVarargParameterTypeImpl(
     override val varargParameterType: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ForbiddenVarargParameterType(), KtAbstractFirDiagnostic<KtParameter>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtParameter>(firDiagnostic, token), KtFirDiagnostic.ForbiddenVarargParameterType
 
 internal class ValueParameterWithNoTypeAnnotationImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ValueParameterWithNoTypeAnnotation(), KtAbstractFirDiagnostic<KtParameter>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtParameter>(firDiagnostic, token), KtFirDiagnostic.ValueParameterWithNoTypeAnnotation
 
 internal class CannotInferParameterTypeImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.CannotInferParameterType(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.CannotInferParameterType
 
 internal class NoTailCallsFoundImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NoTailCallsFound(), KtAbstractFirDiagnostic<KtNamedFunction>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtNamedFunction>(firDiagnostic, token), KtFirDiagnostic.NoTailCallsFound
 
 internal class TailrecOnVirtualMemberErrorImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.TailrecOnVirtualMemberError(), KtAbstractFirDiagnostic<KtNamedFunction>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtNamedFunction>(firDiagnostic, token), KtFirDiagnostic.TailrecOnVirtualMemberError
 
 internal class NonTailRecursiveCallImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NonTailRecursiveCall(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.NonTailRecursiveCall
 
 internal class TailRecursionInTryIsNotSupportedImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.TailRecursionInTryIsNotSupported(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.TailRecursionInTryIsNotSupported
 
 internal class DataObjectCustomEqualsOrHashCodeImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.DataObjectCustomEqualsOrHashCode(), KtAbstractFirDiagnostic<KtNamedFunction>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtNamedFunction>(firDiagnostic, token), KtFirDiagnostic.DataObjectCustomEqualsOrHashCode
 
 internal class FunInterfaceConstructorReferenceImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.FunInterfaceConstructorReference(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.FunInterfaceConstructorReference
 
 internal class FunInterfaceWrongCountOfAbstractMembersImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.FunInterfaceWrongCountOfAbstractMembers(), KtAbstractFirDiagnostic<KtClass>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtClass>(firDiagnostic, token), KtFirDiagnostic.FunInterfaceWrongCountOfAbstractMembers
 
 internal class FunInterfaceCannotHaveAbstractPropertiesImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.FunInterfaceCannotHaveAbstractProperties(), KtAbstractFirDiagnostic<KtDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtDeclaration>(firDiagnostic, token), KtFirDiagnostic.FunInterfaceCannotHaveAbstractProperties
 
 internal class FunInterfaceAbstractMethodWithTypeParametersImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.FunInterfaceAbstractMethodWithTypeParameters(), KtAbstractFirDiagnostic<KtDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtDeclaration>(firDiagnostic, token), KtFirDiagnostic.FunInterfaceAbstractMethodWithTypeParameters
 
 internal class FunInterfaceAbstractMethodWithDefaultValueImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.FunInterfaceAbstractMethodWithDefaultValue(), KtAbstractFirDiagnostic<KtDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtDeclaration>(firDiagnostic, token), KtFirDiagnostic.FunInterfaceAbstractMethodWithDefaultValue
 
 internal class FunInterfaceWithSuspendFunctionImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.FunInterfaceWithSuspendFunction(), KtAbstractFirDiagnostic<KtDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtDeclaration>(firDiagnostic, token), KtFirDiagnostic.FunInterfaceWithSuspendFunction
 
 internal class AbstractPropertyInNonAbstractClassImpl(
     override val property: KtCallableSymbol,
     override val containingClass: KtClassLikeSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.AbstractPropertyInNonAbstractClass(), KtAbstractFirDiagnostic<KtModifierListOwner>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtModifierListOwner>(firDiagnostic, token), KtFirDiagnostic.AbstractPropertyInNonAbstractClass
 
 internal class PrivatePropertyInInterfaceImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.PrivatePropertyInInterface(), KtAbstractFirDiagnostic<KtProperty>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtProperty>(firDiagnostic, token), KtFirDiagnostic.PrivatePropertyInInterface
 
 internal class AbstractPropertyWithInitializerImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.AbstractPropertyWithInitializer(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.AbstractPropertyWithInitializer
 
 internal class PropertyInitializerInInterfaceImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.PropertyInitializerInInterface(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.PropertyInitializerInInterface
 
 internal class PropertyWithNoTypeNoInitializerImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.PropertyWithNoTypeNoInitializer(), KtAbstractFirDiagnostic<KtProperty>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtProperty>(firDiagnostic, token), KtFirDiagnostic.PropertyWithNoTypeNoInitializer
 
 internal class MustBeInitializedImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.MustBeInitialized(), KtAbstractFirDiagnostic<KtProperty>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtProperty>(firDiagnostic, token), KtFirDiagnostic.MustBeInitialized
 
 internal class MustBeInitializedWarningImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.MustBeInitializedWarning(), KtAbstractFirDiagnostic<KtProperty>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtProperty>(firDiagnostic, token), KtFirDiagnostic.MustBeInitializedWarning
 
 internal class MustBeInitializedOrBeFinalImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.MustBeInitializedOrBeFinal(), KtAbstractFirDiagnostic<KtProperty>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtProperty>(firDiagnostic, token), KtFirDiagnostic.MustBeInitializedOrBeFinal
 
 internal class MustBeInitializedOrBeFinalWarningImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.MustBeInitializedOrBeFinalWarning(), KtAbstractFirDiagnostic<KtProperty>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtProperty>(firDiagnostic, token), KtFirDiagnostic.MustBeInitializedOrBeFinalWarning
 
 internal class MustBeInitializedOrBeAbstractImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.MustBeInitializedOrBeAbstract(), KtAbstractFirDiagnostic<KtProperty>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtProperty>(firDiagnostic, token), KtFirDiagnostic.MustBeInitializedOrBeAbstract
 
 internal class MustBeInitializedOrBeAbstractWarningImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.MustBeInitializedOrBeAbstractWarning(), KtAbstractFirDiagnostic<KtProperty>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtProperty>(firDiagnostic, token), KtFirDiagnostic.MustBeInitializedOrBeAbstractWarning
 
 internal class MustBeInitializedOrFinalOrAbstractImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.MustBeInitializedOrFinalOrAbstract(), KtAbstractFirDiagnostic<KtProperty>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtProperty>(firDiagnostic, token), KtFirDiagnostic.MustBeInitializedOrFinalOrAbstract
 
 internal class MustBeInitializedOrFinalOrAbstractWarningImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.MustBeInitializedOrFinalOrAbstractWarning(), KtAbstractFirDiagnostic<KtProperty>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtProperty>(firDiagnostic, token), KtFirDiagnostic.MustBeInitializedOrFinalOrAbstractWarning
 
 internal class ExtensionPropertyMustHaveAccessorsOrBeAbstractImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ExtensionPropertyMustHaveAccessorsOrBeAbstract(), KtAbstractFirDiagnostic<KtProperty>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtProperty>(firDiagnostic, token), KtFirDiagnostic.ExtensionPropertyMustHaveAccessorsOrBeAbstract
 
 internal class UnnecessaryLateinitImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.UnnecessaryLateinit(), KtAbstractFirDiagnostic<KtProperty>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtProperty>(firDiagnostic, token), KtFirDiagnostic.UnnecessaryLateinit
 
 internal class BackingFieldInInterfaceImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.BackingFieldInInterface(), KtAbstractFirDiagnostic<KtProperty>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtProperty>(firDiagnostic, token), KtFirDiagnostic.BackingFieldInInterface
 
 internal class ExtensionPropertyWithBackingFieldImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ExtensionPropertyWithBackingField(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.ExtensionPropertyWithBackingField
 
 internal class PropertyInitializerNoBackingFieldImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.PropertyInitializerNoBackingField(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.PropertyInitializerNoBackingField
 
 internal class AbstractDelegatedPropertyImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.AbstractDelegatedProperty(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.AbstractDelegatedProperty
 
 internal class DelegatedPropertyInInterfaceImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.DelegatedPropertyInInterface(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.DelegatedPropertyInInterface
 
 internal class AbstractPropertyWithGetterImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.AbstractPropertyWithGetter(), KtAbstractFirDiagnostic<KtPropertyAccessor>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtPropertyAccessor>(firDiagnostic, token), KtFirDiagnostic.AbstractPropertyWithGetter
 
 internal class AbstractPropertyWithSetterImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.AbstractPropertyWithSetter(), KtAbstractFirDiagnostic<KtPropertyAccessor>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtPropertyAccessor>(firDiagnostic, token), KtFirDiagnostic.AbstractPropertyWithSetter
 
 internal class PrivateSetterForAbstractPropertyImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.PrivateSetterForAbstractProperty(), KtAbstractFirDiagnostic<KtModifierListOwner>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtModifierListOwner>(firDiagnostic, token), KtFirDiagnostic.PrivateSetterForAbstractProperty
 
 internal class PrivateSetterForOpenPropertyImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.PrivateSetterForOpenProperty(), KtAbstractFirDiagnostic<KtModifierListOwner>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtModifierListOwner>(firDiagnostic, token), KtFirDiagnostic.PrivateSetterForOpenProperty
 
 internal class ValWithSetterImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ValWithSetter(), KtAbstractFirDiagnostic<KtPropertyAccessor>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtPropertyAccessor>(firDiagnostic, token), KtFirDiagnostic.ValWithSetter
 
 internal class ConstValNotTopLevelOrObjectImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ConstValNotTopLevelOrObject(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.ConstValNotTopLevelOrObject
 
 internal class ConstValWithGetterImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ConstValWithGetter(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.ConstValWithGetter
 
 internal class ConstValWithDelegateImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ConstValWithDelegate(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.ConstValWithDelegate
 
 internal class TypeCantBeUsedForConstValImpl(
     override val constValType: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.TypeCantBeUsedForConstVal(), KtAbstractFirDiagnostic<KtProperty>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtProperty>(firDiagnostic, token), KtFirDiagnostic.TypeCantBeUsedForConstVal
 
 internal class ConstValWithoutInitializerImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ConstValWithoutInitializer(), KtAbstractFirDiagnostic<KtProperty>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtProperty>(firDiagnostic, token), KtFirDiagnostic.ConstValWithoutInitializer
 
 internal class ConstValWithNonConstInitializerImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ConstValWithNonConstInitializer(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.ConstValWithNonConstInitializer
 
 internal class WrongSetterParameterTypeImpl(
     override val expectedType: KtType,
     override val actualType: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.WrongSetterParameterType(), KtAbstractFirDiagnostic<KtTypeReference>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeReference>(firDiagnostic, token), KtFirDiagnostic.WrongSetterParameterType
 
 internal class DelegateUsesExtensionPropertyTypeParameterErrorImpl(
     override val usedTypeParameter: KtTypeParameterSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.DelegateUsesExtensionPropertyTypeParameterError(), KtAbstractFirDiagnostic<KtProperty>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtProperty>(firDiagnostic, token), KtFirDiagnostic.DelegateUsesExtensionPropertyTypeParameterError
 
 internal class DelegateUsesExtensionPropertyTypeParameterWarningImpl(
     override val usedTypeParameter: KtTypeParameterSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.DelegateUsesExtensionPropertyTypeParameterWarning(), KtAbstractFirDiagnostic<KtProperty>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtProperty>(firDiagnostic, token), KtFirDiagnostic.DelegateUsesExtensionPropertyTypeParameterWarning
 
 internal class InitializerTypeMismatchImpl(
     override val expectedType: KtType,
     override val actualType: KtType,
     override val isMismatchDueToNullability: Boolean,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.InitializerTypeMismatch(), KtAbstractFirDiagnostic<KtProperty>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtProperty>(firDiagnostic, token), KtFirDiagnostic.InitializerTypeMismatch
 
 internal class GetterVisibilityDiffersFromPropertyVisibilityImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.GetterVisibilityDiffersFromPropertyVisibility(), KtAbstractFirDiagnostic<KtModifierListOwner>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtModifierListOwner>(firDiagnostic, token), KtFirDiagnostic.GetterVisibilityDiffersFromPropertyVisibility
 
 internal class SetterVisibilityInconsistentWithPropertyVisibilityImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.SetterVisibilityInconsistentWithPropertyVisibility(), KtAbstractFirDiagnostic<KtModifierListOwner>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtModifierListOwner>(firDiagnostic, token), KtFirDiagnostic.SetterVisibilityInconsistentWithPropertyVisibility
 
 internal class WrongSetterReturnTypeImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.WrongSetterReturnType(), KtAbstractFirDiagnostic<KtTypeReference>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeReference>(firDiagnostic, token), KtFirDiagnostic.WrongSetterReturnType
 
 internal class WrongGetterReturnTypeImpl(
     override val expectedType: KtType,
     override val actualType: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.WrongGetterReturnType(), KtAbstractFirDiagnostic<KtTypeReference>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeReference>(firDiagnostic, token), KtFirDiagnostic.WrongGetterReturnType
 
 internal class AccessorForDelegatedPropertyImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.AccessorForDelegatedProperty(), KtAbstractFirDiagnostic<KtPropertyAccessor>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtPropertyAccessor>(firDiagnostic, token), KtFirDiagnostic.AccessorForDelegatedProperty
 
 internal class PropertyInitializerWithExplicitFieldDeclarationImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.PropertyInitializerWithExplicitFieldDeclaration(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.PropertyInitializerWithExplicitFieldDeclaration
 
 internal class PropertyFieldDeclarationMissingInitializerImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.PropertyFieldDeclarationMissingInitializer(), KtAbstractFirDiagnostic<KtBackingField>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtBackingField>(firDiagnostic, token), KtFirDiagnostic.PropertyFieldDeclarationMissingInitializer
 
 internal class LateinitPropertyFieldDeclarationWithInitializerImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.LateinitPropertyFieldDeclarationWithInitializer(), KtAbstractFirDiagnostic<KtBackingField>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtBackingField>(firDiagnostic, token), KtFirDiagnostic.LateinitPropertyFieldDeclarationWithInitializer
 
 internal class LateinitFieldInValPropertyImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.LateinitFieldInValProperty(), KtAbstractFirDiagnostic<KtBackingField>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtBackingField>(firDiagnostic, token), KtFirDiagnostic.LateinitFieldInValProperty
 
 internal class LateinitNullableBackingFieldImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.LateinitNullableBackingField(), KtAbstractFirDiagnostic<KtBackingField>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtBackingField>(firDiagnostic, token), KtFirDiagnostic.LateinitNullableBackingField
 
 internal class BackingFieldForDelegatedPropertyImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.BackingFieldForDelegatedProperty(), KtAbstractFirDiagnostic<KtBackingField>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtBackingField>(firDiagnostic, token), KtFirDiagnostic.BackingFieldForDelegatedProperty
 
 internal class PropertyMustHaveGetterImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.PropertyMustHaveGetter(), KtAbstractFirDiagnostic<KtProperty>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtProperty>(firDiagnostic, token), KtFirDiagnostic.PropertyMustHaveGetter
 
 internal class PropertyMustHaveSetterImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.PropertyMustHaveSetter(), KtAbstractFirDiagnostic<KtProperty>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtProperty>(firDiagnostic, token), KtFirDiagnostic.PropertyMustHaveSetter
 
 internal class ExplicitBackingFieldInInterfaceImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ExplicitBackingFieldInInterface(), KtAbstractFirDiagnostic<KtBackingField>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtBackingField>(firDiagnostic, token), KtFirDiagnostic.ExplicitBackingFieldInInterface
 
 internal class ExplicitBackingFieldInAbstractPropertyImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ExplicitBackingFieldInAbstractProperty(), KtAbstractFirDiagnostic<KtBackingField>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtBackingField>(firDiagnostic, token), KtFirDiagnostic.ExplicitBackingFieldInAbstractProperty
 
 internal class ExplicitBackingFieldInExtensionImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ExplicitBackingFieldInExtension(), KtAbstractFirDiagnostic<KtBackingField>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtBackingField>(firDiagnostic, token), KtFirDiagnostic.ExplicitBackingFieldInExtension
 
 internal class RedundantExplicitBackingFieldImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.RedundantExplicitBackingField(), KtAbstractFirDiagnostic<KtBackingField>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtBackingField>(firDiagnostic, token), KtFirDiagnostic.RedundantExplicitBackingField
 
 internal class AbstractPropertyInPrimaryConstructorParametersImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.AbstractPropertyInPrimaryConstructorParameters(), KtAbstractFirDiagnostic<KtModifierListOwner>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtModifierListOwner>(firDiagnostic, token), KtFirDiagnostic.AbstractPropertyInPrimaryConstructorParameters
 
 internal class LocalVariableWithTypeParametersWarningImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.LocalVariableWithTypeParametersWarning(), KtAbstractFirDiagnostic<KtProperty>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtProperty>(firDiagnostic, token), KtFirDiagnostic.LocalVariableWithTypeParametersWarning
 
 internal class LocalVariableWithTypeParametersImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.LocalVariableWithTypeParameters(), KtAbstractFirDiagnostic<KtProperty>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtProperty>(firDiagnostic, token), KtFirDiagnostic.LocalVariableWithTypeParameters
 
 internal class ExplicitTypeArgumentsInPropertyAccessImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ExplicitTypeArgumentsInPropertyAccess(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.ExplicitTypeArgumentsInPropertyAccess
 
 internal class LateinitIntrinsicCallOnNonLiteralImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.LateinitIntrinsicCallOnNonLiteral(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.LateinitIntrinsicCallOnNonLiteral
 
 internal class LateinitIntrinsicCallOnNonLateinitImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.LateinitIntrinsicCallOnNonLateinit(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.LateinitIntrinsicCallOnNonLateinit
 
 internal class LateinitIntrinsicCallInInlineFunctionImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.LateinitIntrinsicCallInInlineFunction(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.LateinitIntrinsicCallInInlineFunction
 
 internal class LateinitIntrinsicCallOnNonAccessiblePropertyImpl(
     override val declaration: KtSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.LateinitIntrinsicCallOnNonAccessibleProperty(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.LateinitIntrinsicCallOnNonAccessibleProperty
 
 internal class LocalExtensionPropertyImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.LocalExtensionProperty(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.LocalExtensionProperty
 
 internal class ExpectedDeclarationWithBodyImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ExpectedDeclarationWithBody(), KtAbstractFirDiagnostic<KtDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtDeclaration>(firDiagnostic, token), KtFirDiagnostic.ExpectedDeclarationWithBody
 
 internal class ExpectedClassConstructorDelegationCallImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ExpectedClassConstructorDelegationCall(), KtAbstractFirDiagnostic<KtConstructorDelegationCall>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtConstructorDelegationCall>(firDiagnostic, token), KtFirDiagnostic.ExpectedClassConstructorDelegationCall
 
 internal class ExpectedClassConstructorPropertyParameterImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ExpectedClassConstructorPropertyParameter(), KtAbstractFirDiagnostic<KtParameter>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtParameter>(firDiagnostic, token), KtFirDiagnostic.ExpectedClassConstructorPropertyParameter
 
 internal class ExpectedEnumConstructorImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ExpectedEnumConstructor(), KtAbstractFirDiagnostic<KtConstructor<*>>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtConstructor<*>>(firDiagnostic, token), KtFirDiagnostic.ExpectedEnumConstructor
 
 internal class ExpectedEnumEntryWithBodyImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ExpectedEnumEntryWithBody(), KtAbstractFirDiagnostic<KtEnumEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtEnumEntry>(firDiagnostic, token), KtFirDiagnostic.ExpectedEnumEntryWithBody
 
 internal class ExpectedPropertyInitializerImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ExpectedPropertyInitializer(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.ExpectedPropertyInitializer
 
 internal class ExpectedDelegatedPropertyImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ExpectedDelegatedProperty(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.ExpectedDelegatedProperty
 
 internal class ExpectedLateinitPropertyImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ExpectedLateinitProperty(), KtAbstractFirDiagnostic<KtModifierListOwner>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtModifierListOwner>(firDiagnostic, token), KtFirDiagnostic.ExpectedLateinitProperty
 
 internal class SupertypeInitializedInExpectedClassImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.SupertypeInitializedInExpectedClass(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.SupertypeInitializedInExpectedClass
 
 internal class ExpectedPrivateDeclarationImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ExpectedPrivateDeclaration(), KtAbstractFirDiagnostic<KtModifierListOwner>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtModifierListOwner>(firDiagnostic, token), KtFirDiagnostic.ExpectedPrivateDeclaration
 
 internal class ExpectedExternalDeclarationImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ExpectedExternalDeclaration(), KtAbstractFirDiagnostic<KtModifierListOwner>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtModifierListOwner>(firDiagnostic, token), KtFirDiagnostic.ExpectedExternalDeclaration
 
 internal class ExpectedTailrecFunctionImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ExpectedTailrecFunction(), KtAbstractFirDiagnostic<KtModifierListOwner>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtModifierListOwner>(firDiagnostic, token), KtFirDiagnostic.ExpectedTailrecFunction
 
 internal class ImplementationByDelegationInExpectClassImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ImplementationByDelegationInExpectClass(), KtAbstractFirDiagnostic<KtDelegatedSuperTypeEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtDelegatedSuperTypeEntry>(firDiagnostic, token), KtFirDiagnostic.ImplementationByDelegationInExpectClass
 
 internal class ActualTypeAliasNotToClassImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ActualTypeAliasNotToClass(), KtAbstractFirDiagnostic<KtTypeAlias>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeAlias>(firDiagnostic, token), KtFirDiagnostic.ActualTypeAliasNotToClass
 
 internal class ActualTypeAliasToClassWithDeclarationSiteVarianceImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ActualTypeAliasToClassWithDeclarationSiteVariance(), KtAbstractFirDiagnostic<KtTypeAlias>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeAlias>(firDiagnostic, token), KtFirDiagnostic.ActualTypeAliasToClassWithDeclarationSiteVariance
 
 internal class ActualTypeAliasWithUseSiteVarianceImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ActualTypeAliasWithUseSiteVariance(), KtAbstractFirDiagnostic<KtTypeAlias>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeAlias>(firDiagnostic, token), KtFirDiagnostic.ActualTypeAliasWithUseSiteVariance
 
 internal class ActualTypeAliasWithComplexSubstitutionImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ActualTypeAliasWithComplexSubstitution(), KtAbstractFirDiagnostic<KtTypeAlias>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeAlias>(firDiagnostic, token), KtFirDiagnostic.ActualTypeAliasWithComplexSubstitution
 
 internal class ActualFunctionWithDefaultArgumentsImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ActualFunctionWithDefaultArguments(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.ActualFunctionWithDefaultArguments
 
 internal class ActualAnnotationConflictingDefaultArgumentValueImpl(
     override val parameter: KtVariableLikeSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ActualAnnotationConflictingDefaultArgumentValue(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.ActualAnnotationConflictingDefaultArgumentValue
 
 internal class ExpectedFunctionSourceWithDefaultArgumentsNotFoundImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ExpectedFunctionSourceWithDefaultArgumentsNotFound(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.ExpectedFunctionSourceWithDefaultArgumentsNotFound
 
 internal class NoActualForExpectImpl(
     override val declaration: KtSymbol,
     override val module: FirModuleData,
     override val compatibility: Map<ExpectActualCompatibility<FirBasedSymbol<*>>, List<KtSymbol>>,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NoActualForExpect(), KtAbstractFirDiagnostic<KtNamedDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtNamedDeclaration>(firDiagnostic, token), KtFirDiagnostic.NoActualForExpect
 
 internal class ActualWithoutExpectImpl(
     override val declaration: KtSymbol,
     override val compatibility: Map<ExpectActualCompatibility<FirBasedSymbol<*>>, List<KtSymbol>>,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ActualWithoutExpect(), KtAbstractFirDiagnostic<KtNamedDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtNamedDeclaration>(firDiagnostic, token), KtFirDiagnostic.ActualWithoutExpect
 
 internal class AmbiguousActualsImpl(
     override val declaration: KtSymbol,
     override val candidates: List<KtSymbol>,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.AmbiguousActuals(), KtAbstractFirDiagnostic<KtNamedDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtNamedDeclaration>(firDiagnostic, token), KtFirDiagnostic.AmbiguousActuals
 
 internal class AmbiguousExpectsImpl(
     override val declaration: KtSymbol,
     override val modules: List<FirModuleData>,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.AmbiguousExpects(), KtAbstractFirDiagnostic<KtNamedDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtNamedDeclaration>(firDiagnostic, token), KtFirDiagnostic.AmbiguousExpects
 
 internal class NoActualClassMemberForExpectedClassImpl(
     override val declaration: KtSymbol,
     override val members: List<Pair<KtSymbol, Map<Incompatible<FirBasedSymbol<*>>, List<KtSymbol>>>>,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NoActualClassMemberForExpectedClass(), KtAbstractFirDiagnostic<KtNamedDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtNamedDeclaration>(firDiagnostic, token), KtFirDiagnostic.NoActualClassMemberForExpectedClass
 
 internal class ActualMissingImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ActualMissing(), KtAbstractFirDiagnostic<KtNamedDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtNamedDeclaration>(firDiagnostic, token), KtFirDiagnostic.ActualMissing
 
 internal class InitializerRequiredForDestructuringDeclarationImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.InitializerRequiredForDestructuringDeclaration(), KtAbstractFirDiagnostic<KtDestructuringDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtDestructuringDeclaration>(firDiagnostic, token), KtFirDiagnostic.InitializerRequiredForDestructuringDeclaration
 
 internal class ComponentFunctionMissingImpl(
     override val missingFunctionName: Name,
     override val destructingType: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ComponentFunctionMissing(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.ComponentFunctionMissing
 
 internal class ComponentFunctionAmbiguityImpl(
     override val functionWithAmbiguityName: Name,
     override val candidates: List<KtSymbol>,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ComponentFunctionAmbiguity(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.ComponentFunctionAmbiguity
 
 internal class ComponentFunctionOnNullableImpl(
     override val componentFunctionName: Name,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ComponentFunctionOnNullable(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.ComponentFunctionOnNullable
 
 internal class ComponentFunctionReturnTypeMismatchImpl(
     override val componentFunctionName: Name,
     override val destructingType: KtType,
     override val expectedType: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ComponentFunctionReturnTypeMismatch(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.ComponentFunctionReturnTypeMismatch
 
 internal class UninitializedVariableImpl(
     override val variable: KtVariableSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.UninitializedVariable(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.UninitializedVariable
 
 internal class UninitializedParameterImpl(
     override val parameter: KtSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.UninitializedParameter(), KtAbstractFirDiagnostic<KtSimpleNameExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtSimpleNameExpression>(firDiagnostic, token), KtFirDiagnostic.UninitializedParameter
 
 internal class UninitializedEnumEntryImpl(
     override val enumEntry: KtSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.UninitializedEnumEntry(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.UninitializedEnumEntry
 
 internal class UninitializedEnumCompanionImpl(
     override val enumClass: KtClassLikeSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.UninitializedEnumCompanion(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.UninitializedEnumCompanion
 
 internal class ValReassignmentImpl(
     override val variable: KtVariableLikeSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ValReassignment(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.ValReassignment
 
 internal class ValReassignmentViaBackingFieldErrorImpl(
     override val property: KtVariableSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ValReassignmentViaBackingFieldError(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.ValReassignmentViaBackingFieldError
 
 internal class ValReassignmentViaBackingFieldWarningImpl(
     override val property: KtVariableSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ValReassignmentViaBackingFieldWarning(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.ValReassignmentViaBackingFieldWarning
 
 internal class CapturedValInitializationImpl(
     override val property: KtVariableSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.CapturedValInitialization(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.CapturedValInitialization
 
 internal class CapturedMemberValInitializationImpl(
     override val property: KtVariableSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.CapturedMemberValInitialization(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.CapturedMemberValInitialization
 
 internal class SetterProjectedOutImpl(
     override val property: KtVariableSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.SetterProjectedOut(), KtAbstractFirDiagnostic<KtBinaryExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtBinaryExpression>(firDiagnostic, token), KtFirDiagnostic.SetterProjectedOut
 
 internal class WrongInvocationKindImpl(
     override val declaration: KtSymbol,
     override val requiredRange: EventOccurrencesRange,
     override val actualRange: EventOccurrencesRange,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.WrongInvocationKind(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.WrongInvocationKind
 
 internal class LeakedInPlaceLambdaImpl(
     override val lambda: KtSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.LeakedInPlaceLambda(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.LeakedInPlaceLambda
 
 internal class WrongImpliesConditionImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.WrongImpliesCondition(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.WrongImpliesCondition
 
 internal class VariableWithNoTypeNoInitializerImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.VariableWithNoTypeNoInitializer(), KtAbstractFirDiagnostic<KtVariableDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtVariableDeclaration>(firDiagnostic, token), KtFirDiagnostic.VariableWithNoTypeNoInitializer
 
 internal class InitializationBeforeDeclarationImpl(
     override val property: KtSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.InitializationBeforeDeclaration(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.InitializationBeforeDeclaration
 
 internal class UnreachableCodeImpl(
     override val reachable: List<PsiElement>,
     override val unreachable: List<PsiElement>,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.UnreachableCode(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.UnreachableCode
 
 internal class SenselessComparisonImpl(
     override val expression: KtExpression,
     override val compareResult: Boolean,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.SenselessComparison(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.SenselessComparison
 
 internal class SenselessNullInWhenImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.SenselessNullInWhen(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.SenselessNullInWhen
 
 internal class TypecheckerHasRunIntoRecursiveProblemImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.TypecheckerHasRunIntoRecursiveProblem(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.TypecheckerHasRunIntoRecursiveProblem
 
 internal class UnsafeCallImpl(
     override val receiverType: KtType,
     override val receiverExpression: KtExpression?,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.UnsafeCall(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.UnsafeCall
 
 internal class UnsafeImplicitInvokeCallImpl(
     override val receiverType: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.UnsafeImplicitInvokeCall(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.UnsafeImplicitInvokeCall
 
 internal class UnsafeInfixCallImpl(
     override val receiverExpression: KtExpression,
     override val operator: String,
     override val argumentExpression: KtExpression,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.UnsafeInfixCall(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.UnsafeInfixCall
 
 internal class UnsafeOperatorCallImpl(
     override val receiverExpression: KtExpression,
     override val operator: String,
     override val argumentExpression: KtExpression,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.UnsafeOperatorCall(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.UnsafeOperatorCall
 
 internal class IteratorOnNullableImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.IteratorOnNullable(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.IteratorOnNullable
 
 internal class UnnecessarySafeCallImpl(
     override val receiverType: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.UnnecessarySafeCall(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.UnnecessarySafeCall
 
 internal class SafeCallWillChangeNullabilityImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.SafeCallWillChangeNullability(), KtAbstractFirDiagnostic<KtSafeQualifiedExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtSafeQualifiedExpression>(firDiagnostic, token), KtFirDiagnostic.SafeCallWillChangeNullability
 
 internal class UnexpectedSafeCallImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.UnexpectedSafeCall(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.UnexpectedSafeCall
 
 internal class UnnecessaryNotNullAssertionImpl(
     override val receiverType: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.UnnecessaryNotNullAssertion(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.UnnecessaryNotNullAssertion
 
 internal class NotNullAssertionOnLambdaExpressionImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NotNullAssertionOnLambdaExpression(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.NotNullAssertionOnLambdaExpression
 
 internal class NotNullAssertionOnCallableReferenceImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NotNullAssertionOnCallableReference(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.NotNullAssertionOnCallableReference
 
 internal class UselessElvisImpl(
     override val receiverType: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.UselessElvis(), KtAbstractFirDiagnostic<KtBinaryExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtBinaryExpression>(firDiagnostic, token), KtFirDiagnostic.UselessElvis
 
 internal class UselessElvisRightIsNullImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.UselessElvisRightIsNull(), KtAbstractFirDiagnostic<KtBinaryExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtBinaryExpression>(firDiagnostic, token), KtFirDiagnostic.UselessElvisRightIsNull
 
 internal class CannotCheckForErasedImpl(
     override val type: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.CannotCheckForErased(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.CannotCheckForErased
 
 internal class CastNeverSucceedsImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.CastNeverSucceeds(), KtAbstractFirDiagnostic<KtBinaryExpressionWithTypeRHS>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtBinaryExpressionWithTypeRHS>(firDiagnostic, token), KtFirDiagnostic.CastNeverSucceeds
 
 internal class UselessCastImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.UselessCast(), KtAbstractFirDiagnostic<KtBinaryExpressionWithTypeRHS>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtBinaryExpressionWithTypeRHS>(firDiagnostic, token), KtFirDiagnostic.UselessCast
 
 internal class UncheckedCastImpl(
     override val originalType: KtType,
     override val targetType: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.UncheckedCast(), KtAbstractFirDiagnostic<KtBinaryExpressionWithTypeRHS>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtBinaryExpressionWithTypeRHS>(firDiagnostic, token), KtFirDiagnostic.UncheckedCast
 
 internal class UselessIsCheckImpl(
     override val compileTimeCheckResult: Boolean,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.UselessIsCheck(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.UselessIsCheck
 
 internal class IsEnumEntryImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.IsEnumEntry(), KtAbstractFirDiagnostic<KtTypeReference>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeReference>(firDiagnostic, token), KtFirDiagnostic.IsEnumEntry
 
 internal class EnumEntryAsTypeImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.EnumEntryAsType(), KtAbstractFirDiagnostic<KtTypeReference>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeReference>(firDiagnostic, token), KtFirDiagnostic.EnumEntryAsType
 
 internal class ExpectedConditionImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ExpectedCondition(), KtAbstractFirDiagnostic<KtWhenCondition>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtWhenCondition>(firDiagnostic, token), KtFirDiagnostic.ExpectedCondition
 
 internal class NoElseInWhenImpl(
     override val missingWhenCases: List<WhenMissingCase>,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NoElseInWhen(), KtAbstractFirDiagnostic<KtWhenExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtWhenExpression>(firDiagnostic, token), KtFirDiagnostic.NoElseInWhen
 
 internal class NonExhaustiveWhenStatementImpl(
     override val type: String,
     override val missingWhenCases: List<WhenMissingCase>,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NonExhaustiveWhenStatement(), KtAbstractFirDiagnostic<KtWhenExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtWhenExpression>(firDiagnostic, token), KtFirDiagnostic.NonExhaustiveWhenStatement
 
 internal class InvalidIfAsExpressionImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.InvalidIfAsExpression(), KtAbstractFirDiagnostic<KtIfExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtIfExpression>(firDiagnostic, token), KtFirDiagnostic.InvalidIfAsExpression
 
 internal class ElseMisplacedInWhenImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ElseMisplacedInWhen(), KtAbstractFirDiagnostic<KtWhenEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtWhenEntry>(firDiagnostic, token), KtFirDiagnostic.ElseMisplacedInWhen
 
 internal class IllegalDeclarationInWhenSubjectImpl(
     override val illegalReason: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.IllegalDeclarationInWhenSubject(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.IllegalDeclarationInWhenSubject
 
 internal class CommaInWhenConditionWithoutArgumentImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.CommaInWhenConditionWithoutArgument(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.CommaInWhenConditionWithoutArgument
 
 internal class DuplicateLabelInWhenImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.DuplicateLabelInWhen(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.DuplicateLabelInWhen
 
 internal class ConfusingBranchConditionErrorImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ConfusingBranchConditionError(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.ConfusingBranchConditionError
 
 internal class ConfusingBranchConditionWarningImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ConfusingBranchConditionWarning(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.ConfusingBranchConditionWarning
 
 internal class TypeParameterIsNotAnExpressionImpl(
     override val typeParameter: KtTypeParameterSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.TypeParameterIsNotAnExpression(), KtAbstractFirDiagnostic<KtSimpleNameExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtSimpleNameExpression>(firDiagnostic, token), KtFirDiagnostic.TypeParameterIsNotAnExpression
 
 internal class TypeParameterOnLhsOfDotImpl(
     override val typeParameter: KtTypeParameterSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.TypeParameterOnLhsOfDot(), KtAbstractFirDiagnostic<KtSimpleNameExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtSimpleNameExpression>(firDiagnostic, token), KtFirDiagnostic.TypeParameterOnLhsOfDot
 
 internal class NoCompanionObjectImpl(
     override val klass: KtClassLikeSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NoCompanionObject(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.NoCompanionObject
 
 internal class ExpressionExpectedPackageFoundImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ExpressionExpectedPackageFound(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.ExpressionExpectedPackageFound
 
 internal class ErrorInContractDescriptionImpl(
     override val reason: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ErrorInContractDescription(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.ErrorInContractDescription
 
 internal class ContractNotAllowedImpl(
     override val reason: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ContractNotAllowed(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.ContractNotAllowed
 
 internal class NoGetMethodImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NoGetMethod(), KtAbstractFirDiagnostic<KtArrayAccessExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtArrayAccessExpression>(firDiagnostic, token), KtFirDiagnostic.NoGetMethod
 
 internal class NoSetMethodImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NoSetMethod(), KtAbstractFirDiagnostic<KtArrayAccessExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtArrayAccessExpression>(firDiagnostic, token), KtFirDiagnostic.NoSetMethod
 
 internal class IteratorMissingImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.IteratorMissing(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.IteratorMissing
 
 internal class HasNextMissingImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.HasNextMissing(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.HasNextMissing
 
 internal class NextMissingImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NextMissing(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.NextMissing
 
 internal class HasNextFunctionNoneApplicableImpl(
     override val candidates: List<KtSymbol>,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.HasNextFunctionNoneApplicable(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.HasNextFunctionNoneApplicable
 
 internal class NextNoneApplicableImpl(
     override val candidates: List<KtSymbol>,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NextNoneApplicable(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.NextNoneApplicable
 
 internal class DelegateSpecialFunctionMissingImpl(
     override val expectedFunctionSignature: String,
     override val delegateType: KtType,
     override val description: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.DelegateSpecialFunctionMissing(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.DelegateSpecialFunctionMissing
 
 internal class DelegateSpecialFunctionAmbiguityImpl(
     override val expectedFunctionSignature: String,
     override val candidates: List<KtSymbol>,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.DelegateSpecialFunctionAmbiguity(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.DelegateSpecialFunctionAmbiguity
 
 internal class DelegateSpecialFunctionNoneApplicableImpl(
     override val expectedFunctionSignature: String,
     override val candidates: List<KtSymbol>,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.DelegateSpecialFunctionNoneApplicable(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.DelegateSpecialFunctionNoneApplicable
 
 internal class DelegateSpecialFunctionReturnTypeMismatchImpl(
     override val delegateFunction: String,
     override val expectedType: KtType,
     override val actualType: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.DelegateSpecialFunctionReturnTypeMismatch(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.DelegateSpecialFunctionReturnTypeMismatch
 
 internal class UnderscoreIsReservedImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.UnderscoreIsReserved(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.UnderscoreIsReserved
 
 internal class UnderscoreUsageWithoutBackticksImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.UnderscoreUsageWithoutBackticks(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.UnderscoreUsageWithoutBackticks
 
 internal class ResolvedToUnderscoreNamedCatchParameterImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ResolvedToUnderscoreNamedCatchParameter(), KtAbstractFirDiagnostic<KtNameReferenceExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtNameReferenceExpression>(firDiagnostic, token), KtFirDiagnostic.ResolvedToUnderscoreNamedCatchParameter
 
 internal class InvalidCharactersImpl(
     override val message: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.InvalidCharacters(), KtAbstractFirDiagnostic<KtNamedDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtNamedDeclaration>(firDiagnostic, token), KtFirDiagnostic.InvalidCharacters
 
 internal class DangerousCharactersImpl(
     override val characters: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.DangerousCharacters(), KtAbstractFirDiagnostic<KtNamedDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtNamedDeclaration>(firDiagnostic, token), KtFirDiagnostic.DangerousCharacters
 
 internal class EqualityNotApplicableImpl(
     override val operator: String,
     override val leftType: KtType,
     override val rightType: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.EqualityNotApplicable(), KtAbstractFirDiagnostic<KtBinaryExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtBinaryExpression>(firDiagnostic, token), KtFirDiagnostic.EqualityNotApplicable
 
 internal class EqualityNotApplicableWarningImpl(
     override val operator: String,
     override val leftType: KtType,
     override val rightType: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.EqualityNotApplicableWarning(), KtAbstractFirDiagnostic<KtBinaryExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtBinaryExpression>(firDiagnostic, token), KtFirDiagnostic.EqualityNotApplicableWarning
 
 internal class IncompatibleEnumComparisonErrorImpl(
     override val leftType: KtType,
     override val rightType: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.IncompatibleEnumComparisonError(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.IncompatibleEnumComparisonError
 
 internal class IncompatibleEnumComparisonImpl(
     override val leftType: KtType,
     override val rightType: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.IncompatibleEnumComparison(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.IncompatibleEnumComparison
 
 internal class ForbiddenIdentityEqualsImpl(
     override val leftType: KtType,
     override val rightType: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ForbiddenIdentityEquals(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.ForbiddenIdentityEquals
 
 internal class ForbiddenIdentityEqualsWarningImpl(
     override val leftType: KtType,
     override val rightType: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ForbiddenIdentityEqualsWarning(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.ForbiddenIdentityEqualsWarning
 
 internal class DeprecatedIdentityEqualsImpl(
     override val leftType: KtType,
     override val rightType: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.DeprecatedIdentityEquals(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.DeprecatedIdentityEquals
 
 internal class ImplicitBoxingInIdentityEqualsImpl(
     override val leftType: KtType,
     override val rightType: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ImplicitBoxingInIdentityEquals(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.ImplicitBoxingInIdentityEquals
 
 internal class IncDecShouldNotReturnUnitImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.IncDecShouldNotReturnUnit(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.IncDecShouldNotReturnUnit
 
 internal class AssignmentOperatorShouldReturnUnitImpl(
     override val functionSymbol: KtFunctionLikeSymbol,
     override val operator: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.AssignmentOperatorShouldReturnUnit(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.AssignmentOperatorShouldReturnUnit
 
 internal class PropertyAsOperatorImpl(
     override val property: KtVariableSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.PropertyAsOperator(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.PropertyAsOperator
 
 internal class DslScopeViolationImpl(
     override val calleeSymbol: KtSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.DslScopeViolation(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.DslScopeViolation
 
 internal class ToplevelTypealiasesOnlyImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ToplevelTypealiasesOnly(), KtAbstractFirDiagnostic<KtTypeAlias>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeAlias>(firDiagnostic, token), KtFirDiagnostic.ToplevelTypealiasesOnly
 
 internal class RecursiveTypealiasExpansionImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.RecursiveTypealiasExpansion(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.RecursiveTypealiasExpansion
 
 internal class TypealiasShouldExpandToClassImpl(
     override val expandedType: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.TypealiasShouldExpandToClass(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.TypealiasShouldExpandToClass
 
 internal class RedundantVisibilityModifierImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.RedundantVisibilityModifier(), KtAbstractFirDiagnostic<KtModifierListOwner>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtModifierListOwner>(firDiagnostic, token), KtFirDiagnostic.RedundantVisibilityModifier
 
 internal class RedundantModalityModifierImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.RedundantModalityModifier(), KtAbstractFirDiagnostic<KtModifierListOwner>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtModifierListOwner>(firDiagnostic, token), KtFirDiagnostic.RedundantModalityModifier
 
 internal class RedundantReturnUnitTypeImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.RedundantReturnUnitType(), KtAbstractFirDiagnostic<KtTypeReference>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtTypeReference>(firDiagnostic, token), KtFirDiagnostic.RedundantReturnUnitType
 
 internal class RedundantExplicitTypeImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.RedundantExplicitType(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.RedundantExplicitType
 
 internal class RedundantSingleExpressionStringTemplateImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.RedundantSingleExpressionStringTemplate(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.RedundantSingleExpressionStringTemplate
 
 internal class CanBeValImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.CanBeVal(), KtAbstractFirDiagnostic<KtDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtDeclaration>(firDiagnostic, token), KtFirDiagnostic.CanBeVal
 
 internal class CanBeReplacedWithOperatorAssignmentImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.CanBeReplacedWithOperatorAssignment(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.CanBeReplacedWithOperatorAssignment
 
 internal class RedundantCallOfConversionMethodImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.RedundantCallOfConversionMethod(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.RedundantCallOfConversionMethod
 
 internal class ArrayEqualityOperatorCanBeReplacedWithEqualsImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ArrayEqualityOperatorCanBeReplacedWithEquals(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.ArrayEqualityOperatorCanBeReplacedWithEquals
 
 internal class EmptyRangeImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.EmptyRange(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.EmptyRange
 
 internal class RedundantSetterParameterTypeImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.RedundantSetterParameterType(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.RedundantSetterParameterType
 
 internal class UnusedVariableImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.UnusedVariable(), KtAbstractFirDiagnostic<KtNamedDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtNamedDeclaration>(firDiagnostic, token), KtFirDiagnostic.UnusedVariable
 
 internal class AssignedValueIsNeverReadImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.AssignedValueIsNeverRead(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.AssignedValueIsNeverRead
 
 internal class VariableInitializerIsRedundantImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.VariableInitializerIsRedundant(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.VariableInitializerIsRedundant
 
 internal class VariableNeverReadImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.VariableNeverRead(), KtAbstractFirDiagnostic<KtNamedDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtNamedDeclaration>(firDiagnostic, token), KtFirDiagnostic.VariableNeverRead
 
 internal class UselessCallOnNotNullImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.UselessCallOnNotNull(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.UselessCallOnNotNull
 
 internal class ReturnNotAllowedImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ReturnNotAllowed(), KtAbstractFirDiagnostic<KtReturnExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtReturnExpression>(firDiagnostic, token), KtFirDiagnostic.ReturnNotAllowed
 
 internal class NotAFunctionLabelImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NotAFunctionLabel(), KtAbstractFirDiagnostic<KtReturnExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtReturnExpression>(firDiagnostic, token), KtFirDiagnostic.NotAFunctionLabel
 
 internal class ReturnInFunctionWithExpressionBodyImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ReturnInFunctionWithExpressionBody(), KtAbstractFirDiagnostic<KtReturnExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtReturnExpression>(firDiagnostic, token), KtFirDiagnostic.ReturnInFunctionWithExpressionBody
 
 internal class NoReturnInFunctionWithBlockBodyImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NoReturnInFunctionWithBlockBody(), KtAbstractFirDiagnostic<KtDeclarationWithBody>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtDeclarationWithBody>(firDiagnostic, token), KtFirDiagnostic.NoReturnInFunctionWithBlockBody
 
 internal class AnonymousInitializerInInterfaceImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.AnonymousInitializerInInterface(), KtAbstractFirDiagnostic<KtAnonymousInitializer>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnonymousInitializer>(firDiagnostic, token), KtFirDiagnostic.AnonymousInitializerInInterface
 
 internal class UsageIsNotInlinableImpl(
     override val parameter: KtSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.UsageIsNotInlinable(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.UsageIsNotInlinable
 
 internal class NonLocalReturnNotAllowedImpl(
     override val parameter: KtSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NonLocalReturnNotAllowed(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.NonLocalReturnNotAllowed
 
 internal class NotYetSupportedInInlineImpl(
     override val message: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NotYetSupportedInInline(), KtAbstractFirDiagnostic<KtDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtDeclaration>(firDiagnostic, token), KtFirDiagnostic.NotYetSupportedInInline
 
 internal class NothingToInlineImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NothingToInline(), KtAbstractFirDiagnostic<KtDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtDeclaration>(firDiagnostic, token), KtFirDiagnostic.NothingToInline
 
 internal class NullableInlineParameterImpl(
     override val parameter: KtSymbol,
     override val function: KtSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NullableInlineParameter(), KtAbstractFirDiagnostic<KtDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtDeclaration>(firDiagnostic, token), KtFirDiagnostic.NullableInlineParameter
 
 internal class RecursionInInlineImpl(
     override val symbol: KtSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.RecursionInInline(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.RecursionInInline
 
 internal class NonPublicCallFromPublicInlineImpl(
     override val inlineDeclaration: KtSymbol,
     override val referencedDeclaration: KtSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NonPublicCallFromPublicInline(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.NonPublicCallFromPublicInline
 
 internal class ProtectedConstructorCallFromPublicInlineImpl(
     override val inlineDeclaration: KtSymbol,
     override val referencedDeclaration: KtSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ProtectedConstructorCallFromPublicInline(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.ProtectedConstructorCallFromPublicInline
 
 internal class ProtectedCallFromPublicInlineErrorImpl(
     override val inlineDeclaration: KtSymbol,
     override val referencedDeclaration: KtSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ProtectedCallFromPublicInlineError(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.ProtectedCallFromPublicInlineError
 
 internal class ProtectedCallFromPublicInlineImpl(
     override val inlineDeclaration: KtSymbol,
     override val referencedDeclaration: KtSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ProtectedCallFromPublicInline(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.ProtectedCallFromPublicInline
 
 internal class PrivateClassMemberFromInlineImpl(
     override val inlineDeclaration: KtSymbol,
     override val referencedDeclaration: KtSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.PrivateClassMemberFromInline(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.PrivateClassMemberFromInline
 
 internal class SuperCallFromPublicInlineImpl(
     override val symbol: KtSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.SuperCallFromPublicInline(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.SuperCallFromPublicInline
 
 internal class DeclarationCantBeInlinedImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.DeclarationCantBeInlined(), KtAbstractFirDiagnostic<KtDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtDeclaration>(firDiagnostic, token), KtFirDiagnostic.DeclarationCantBeInlined
 
 internal class OverrideByInlineImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.OverrideByInline(), KtAbstractFirDiagnostic<KtDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtDeclaration>(firDiagnostic, token), KtFirDiagnostic.OverrideByInline
 
 internal class NonInternalPublishedApiImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NonInternalPublishedApi(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.NonInternalPublishedApi
 
 internal class InvalidDefaultFunctionalParameterForInlineImpl(
     override val defaultValue: KtExpression,
     override val parameter: KtSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.InvalidDefaultFunctionalParameterForInline(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.InvalidDefaultFunctionalParameterForInline
 
 internal class ReifiedTypeParameterInOverrideImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ReifiedTypeParameterInOverride(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.ReifiedTypeParameterInOverride
 
 internal class InlinePropertyWithBackingFieldImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.InlinePropertyWithBackingField(), KtAbstractFirDiagnostic<KtDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtDeclaration>(firDiagnostic, token), KtFirDiagnostic.InlinePropertyWithBackingField
 
 internal class IllegalInlineParameterModifierImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.IllegalInlineParameterModifier(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.IllegalInlineParameterModifier
 
 internal class InlineSuspendFunctionTypeUnsupportedImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.InlineSuspendFunctionTypeUnsupported(), KtAbstractFirDiagnostic<KtParameter>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtParameter>(firDiagnostic, token), KtFirDiagnostic.InlineSuspendFunctionTypeUnsupported
 
 internal class RedundantInlineSuspendFunctionTypeImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.RedundantInlineSuspendFunctionType(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.RedundantInlineSuspendFunctionType
 
 internal class InefficientEqualsOverridingInValueClassImpl(
     override val type: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.InefficientEqualsOverridingInValueClass(), KtAbstractFirDiagnostic<KtNamedFunction>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtNamedFunction>(firDiagnostic, token), KtFirDiagnostic.InefficientEqualsOverridingInValueClass
 
 internal class CannotAllUnderImportFromSingletonImpl(
     override val objectName: Name,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.CannotAllUnderImportFromSingleton(), KtAbstractFirDiagnostic<KtImportDirective>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtImportDirective>(firDiagnostic, token), KtFirDiagnostic.CannotAllUnderImportFromSingleton
 
 internal class PackageCannotBeImportedImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.PackageCannotBeImported(), KtAbstractFirDiagnostic<KtImportDirective>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtImportDirective>(firDiagnostic, token), KtFirDiagnostic.PackageCannotBeImported
 
 internal class CannotBeImportedImpl(
     override val name: Name,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.CannotBeImported(), KtAbstractFirDiagnostic<KtImportDirective>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtImportDirective>(firDiagnostic, token), KtFirDiagnostic.CannotBeImported
 
 internal class ConflictingImportImpl(
     override val name: Name,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ConflictingImport(), KtAbstractFirDiagnostic<KtImportDirective>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtImportDirective>(firDiagnostic, token), KtFirDiagnostic.ConflictingImport
 
 internal class OperatorRenamedOnImportImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.OperatorRenamedOnImport(), KtAbstractFirDiagnostic<KtImportDirective>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtImportDirective>(firDiagnostic, token), KtFirDiagnostic.OperatorRenamedOnImport
 
 internal class IllegalSuspendFunctionCallImpl(
     override val suspendCallable: KtSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.IllegalSuspendFunctionCall(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.IllegalSuspendFunctionCall
 
 internal class IllegalSuspendPropertyAccessImpl(
     override val suspendCallable: KtSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.IllegalSuspendPropertyAccess(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.IllegalSuspendPropertyAccess
 
 internal class NonLocalSuspensionPointImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NonLocalSuspensionPoint(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.NonLocalSuspensionPoint
 
 internal class IllegalRestrictedSuspendingFunctionCallImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.IllegalRestrictedSuspendingFunctionCall(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.IllegalRestrictedSuspendingFunctionCall
 
 internal class NonModifierFormForBuiltInSuspendImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NonModifierFormForBuiltInSuspend(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.NonModifierFormForBuiltInSuspend
 
 internal class ModifierFormForNonBuiltInSuspendImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ModifierFormForNonBuiltInSuspend(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.ModifierFormForNonBuiltInSuspend
 
 internal class ModifierFormForNonBuiltInSuspendFunErrorImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ModifierFormForNonBuiltInSuspendFunError(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.ModifierFormForNonBuiltInSuspendFunError
 
 internal class ModifierFormForNonBuiltInSuspendFunWarningImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ModifierFormForNonBuiltInSuspendFunWarning(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.ModifierFormForNonBuiltInSuspendFunWarning
 
 internal class ReturnForBuiltInSuspendImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ReturnForBuiltInSuspend(), KtAbstractFirDiagnostic<KtReturnExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtReturnExpression>(firDiagnostic, token), KtFirDiagnostic.ReturnForBuiltInSuspend
 
 internal class RedundantLabelWarningImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.RedundantLabelWarning(), KtAbstractFirDiagnostic<KtLabelReferenceExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtLabelReferenceExpression>(firDiagnostic, token), KtFirDiagnostic.RedundantLabelWarning
 
 internal class ConflictingJvmDeclarationsImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ConflictingJvmDeclarations(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.ConflictingJvmDeclarations
 
 internal class OverrideCannotBeStaticImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.OverrideCannotBeStatic(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.OverrideCannotBeStatic
 
 internal class JvmStaticNotInObjectOrClassCompanionImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.JvmStaticNotInObjectOrClassCompanion(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.JvmStaticNotInObjectOrClassCompanion
 
 internal class JvmStaticNotInObjectOrCompanionImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.JvmStaticNotInObjectOrCompanion(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.JvmStaticNotInObjectOrCompanion
 
 internal class JvmStaticOnNonPublicMemberImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.JvmStaticOnNonPublicMember(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.JvmStaticOnNonPublicMember
 
 internal class JvmStaticOnConstOrJvmFieldImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.JvmStaticOnConstOrJvmField(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.JvmStaticOnConstOrJvmField
 
 internal class JvmStaticOnExternalInInterfaceImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.JvmStaticOnExternalInInterface(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.JvmStaticOnExternalInInterface
 
 internal class InapplicableJvmNameImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.InapplicableJvmName(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.InapplicableJvmName
 
 internal class IllegalJvmNameImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.IllegalJvmName(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.IllegalJvmName
 
 internal class FunctionDelegateMemberNameClashImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.FunctionDelegateMemberNameClash(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.FunctionDelegateMemberNameClash
 
 internal class ValueClassWithoutJvmInlineAnnotationImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ValueClassWithoutJvmInlineAnnotation(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.ValueClassWithoutJvmInlineAnnotation
 
 internal class JvmInlineWithoutValueClassImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.JvmInlineWithoutValueClass(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.JvmInlineWithoutValueClass
 
 internal class JavaTypeMismatchImpl(
     override val expectedType: KtType,
     override val actualType: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.JavaTypeMismatch(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.JavaTypeMismatch
 
 internal class UpperBoundCannotBeArrayImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.UpperBoundCannotBeArray(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.UpperBoundCannotBeArray
 
 internal class StrictfpOnClassImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.StrictfpOnClass(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.StrictfpOnClass
 
 internal class SynchronizedOnAbstractImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.SynchronizedOnAbstract(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.SynchronizedOnAbstract
 
 internal class SynchronizedInInterfaceImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.SynchronizedInInterface(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.SynchronizedInInterface
 
 internal class SynchronizedOnInlineImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.SynchronizedOnInline(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.SynchronizedOnInline
 
 internal class SynchronizedOnSuspendErrorImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.SynchronizedOnSuspendError(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.SynchronizedOnSuspendError
 
 internal class SynchronizedOnSuspendWarningImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.SynchronizedOnSuspendWarning(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.SynchronizedOnSuspendWarning
 
 internal class OverloadsWithoutDefaultArgumentsImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.OverloadsWithoutDefaultArguments(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.OverloadsWithoutDefaultArguments
 
 internal class OverloadsAbstractImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.OverloadsAbstract(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.OverloadsAbstract
 
 internal class OverloadsInterfaceImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.OverloadsInterface(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.OverloadsInterface
 
 internal class OverloadsLocalImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.OverloadsLocal(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.OverloadsLocal
 
 internal class OverloadsAnnotationClassConstructorErrorImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.OverloadsAnnotationClassConstructorError(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.OverloadsAnnotationClassConstructorError
 
 internal class OverloadsAnnotationClassConstructorWarningImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.OverloadsAnnotationClassConstructorWarning(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.OverloadsAnnotationClassConstructorWarning
 
 internal class OverloadsPrivateImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.OverloadsPrivate(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.OverloadsPrivate
 
 internal class DeprecatedJavaAnnotationImpl(
     override val kotlinName: FqName,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.DeprecatedJavaAnnotation(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.DeprecatedJavaAnnotation
 
 internal class JvmPackageNameCannotBeEmptyImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.JvmPackageNameCannotBeEmpty(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.JvmPackageNameCannotBeEmpty
 
 internal class JvmPackageNameMustBeValidNameImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.JvmPackageNameMustBeValidName(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.JvmPackageNameMustBeValidName
 
 internal class JvmPackageNameNotSupportedInFilesWithClassesImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.JvmPackageNameNotSupportedInFilesWithClasses(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.JvmPackageNameNotSupportedInFilesWithClasses
 
 internal class PositionedValueArgumentForJavaAnnotationImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.PositionedValueArgumentForJavaAnnotation(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.PositionedValueArgumentForJavaAnnotation
 
 internal class RedundantRepeatableAnnotationImpl(
     override val kotlinRepeatable: FqName,
     override val javaRepeatable: FqName,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.RedundantRepeatableAnnotation(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.RedundantRepeatableAnnotation
 
 internal class LocalJvmRecordImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.LocalJvmRecord(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.LocalJvmRecord
 
 internal class NonFinalJvmRecordImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NonFinalJvmRecord(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.NonFinalJvmRecord
 
 internal class EnumJvmRecordImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.EnumJvmRecord(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.EnumJvmRecord
 
 internal class JvmRecordWithoutPrimaryConstructorParametersImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.JvmRecordWithoutPrimaryConstructorParameters(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.JvmRecordWithoutPrimaryConstructorParameters
 
 internal class NonDataClassJvmRecordImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NonDataClassJvmRecord(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.NonDataClassJvmRecord
 
 internal class JvmRecordNotValParameterImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.JvmRecordNotValParameter(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.JvmRecordNotValParameter
 
 internal class JvmRecordNotLastVarargParameterImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.JvmRecordNotLastVarargParameter(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.JvmRecordNotLastVarargParameter
 
 internal class InnerJvmRecordImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.InnerJvmRecord(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.InnerJvmRecord
 
 internal class FieldInJvmRecordImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.FieldInJvmRecord(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.FieldInJvmRecord
 
 internal class DelegationByInJvmRecordImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.DelegationByInJvmRecord(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.DelegationByInJvmRecord
 
 internal class JvmRecordExtendsClassImpl(
     override val superType: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.JvmRecordExtendsClass(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.JvmRecordExtendsClass
 
 internal class IllegalJavaLangRecordSupertypeImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.IllegalJavaLangRecordSupertype(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.IllegalJavaLangRecordSupertype
 
 internal class JvmDefaultInDeclarationImpl(
     override val annotation: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.JvmDefaultInDeclaration(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.JvmDefaultInDeclaration
 
 internal class JvmDefaultWithCompatibilityInDeclarationImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.JvmDefaultWithCompatibilityInDeclaration(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.JvmDefaultWithCompatibilityInDeclaration
 
 internal class JvmDefaultWithCompatibilityNotOnInterfaceImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.JvmDefaultWithCompatibilityNotOnInterface(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.JvmDefaultWithCompatibilityNotOnInterface
 
 internal class ExternalDeclarationCannotBeAbstractImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ExternalDeclarationCannotBeAbstract(), KtAbstractFirDiagnostic<KtDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtDeclaration>(firDiagnostic, token), KtFirDiagnostic.ExternalDeclarationCannotBeAbstract
 
 internal class ExternalDeclarationCannotHaveBodyImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ExternalDeclarationCannotHaveBody(), KtAbstractFirDiagnostic<KtDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtDeclaration>(firDiagnostic, token), KtFirDiagnostic.ExternalDeclarationCannotHaveBody
 
 internal class ExternalDeclarationInInterfaceImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ExternalDeclarationInInterface(), KtAbstractFirDiagnostic<KtDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtDeclaration>(firDiagnostic, token), KtFirDiagnostic.ExternalDeclarationInInterface
 
 internal class ExternalDeclarationCannotBeInlinedImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ExternalDeclarationCannotBeInlined(), KtAbstractFirDiagnostic<KtDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtDeclaration>(firDiagnostic, token), KtFirDiagnostic.ExternalDeclarationCannotBeInlined
 
 internal class NonSourceRepeatedAnnotationImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NonSourceRepeatedAnnotation(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.NonSourceRepeatedAnnotation
 
 internal class RepeatedAnnotationWithContainerImpl(
     override val name: ClassId,
     override val explicitContainerName: ClassId,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.RepeatedAnnotationWithContainer(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.RepeatedAnnotationWithContainer
 
 internal class RepeatableContainerMustHaveValueArrayErrorImpl(
     override val container: ClassId,
     override val annotation: ClassId,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.RepeatableContainerMustHaveValueArrayError(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.RepeatableContainerMustHaveValueArrayError
 
 internal class RepeatableContainerMustHaveValueArrayWarningImpl(
     override val container: ClassId,
     override val annotation: ClassId,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.RepeatableContainerMustHaveValueArrayWarning(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.RepeatableContainerMustHaveValueArrayWarning
 
 internal class RepeatableContainerHasNonDefaultParameterErrorImpl(
     override val container: ClassId,
     override val nonDefault: Name,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.RepeatableContainerHasNonDefaultParameterError(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.RepeatableContainerHasNonDefaultParameterError
 
 internal class RepeatableContainerHasNonDefaultParameterWarningImpl(
     override val container: ClassId,
     override val nonDefault: Name,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.RepeatableContainerHasNonDefaultParameterWarning(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.RepeatableContainerHasNonDefaultParameterWarning
 
 internal class RepeatableContainerHasShorterRetentionErrorImpl(
     override val container: ClassId,
     override val retention: String,
     override val annotation: ClassId,
     override val annotationRetention: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.RepeatableContainerHasShorterRetentionError(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.RepeatableContainerHasShorterRetentionError
 
 internal class RepeatableContainerHasShorterRetentionWarningImpl(
     override val container: ClassId,
     override val retention: String,
     override val annotation: ClassId,
     override val annotationRetention: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.RepeatableContainerHasShorterRetentionWarning(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.RepeatableContainerHasShorterRetentionWarning
 
 internal class RepeatableContainerTargetSetNotASubsetErrorImpl(
     override val container: ClassId,
     override val annotation: ClassId,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.RepeatableContainerTargetSetNotASubsetError(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.RepeatableContainerTargetSetNotASubsetError
 
 internal class RepeatableContainerTargetSetNotASubsetWarningImpl(
     override val container: ClassId,
     override val annotation: ClassId,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.RepeatableContainerTargetSetNotASubsetWarning(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.RepeatableContainerTargetSetNotASubsetWarning
 
 internal class RepeatableAnnotationHasNestedClassNamedContainerErrorImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.RepeatableAnnotationHasNestedClassNamedContainerError(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.RepeatableAnnotationHasNestedClassNamedContainerError
 
 internal class RepeatableAnnotationHasNestedClassNamedContainerWarningImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.RepeatableAnnotationHasNestedClassNamedContainerWarning(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.RepeatableAnnotationHasNestedClassNamedContainerWarning
 
 internal class SuspensionPointInsideCriticalSectionImpl(
     override val function: KtCallableSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.SuspensionPointInsideCriticalSection(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.SuspensionPointInsideCriticalSection
 
 internal class InapplicableJvmFieldImpl(
     override val message: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.InapplicableJvmField(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.InapplicableJvmField
 
 internal class InapplicableJvmFieldWarningImpl(
     override val message: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.InapplicableJvmFieldWarning(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.InapplicableJvmFieldWarning
 
 internal class JvmSyntheticOnDelegateImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.JvmSyntheticOnDelegate(), KtAbstractFirDiagnostic<KtAnnotationEntry>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnnotationEntry>(firDiagnostic, token), KtFirDiagnostic.JvmSyntheticOnDelegate
 
 internal class SubclassCantCallCompanionProtectedNonStaticImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.SubclassCantCallCompanionProtectedNonStatic(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.SubclassCantCallCompanionProtectedNonStatic
 
 internal class ConcurrentHashMapContainsOperatorErrorImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ConcurrentHashMapContainsOperatorError(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.ConcurrentHashMapContainsOperatorError
 
 internal class ConcurrentHashMapContainsOperatorWarningImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ConcurrentHashMapContainsOperatorWarning(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.ConcurrentHashMapContainsOperatorWarning
 
 internal class SpreadOnSignaturePolymorphicCallErrorImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.SpreadOnSignaturePolymorphicCallError(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.SpreadOnSignaturePolymorphicCallError
 
 internal class SpreadOnSignaturePolymorphicCallWarningImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.SpreadOnSignaturePolymorphicCallWarning(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.SpreadOnSignaturePolymorphicCallWarning
 
 internal class JavaSamInterfaceConstructorReferenceImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.JavaSamInterfaceConstructorReference(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.JavaSamInterfaceConstructorReference
 
 internal class ImplementingFunctionInterfaceImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ImplementingFunctionInterface(), KtAbstractFirDiagnostic<KtClassOrObject>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtClassOrObject>(firDiagnostic, token), KtFirDiagnostic.ImplementingFunctionInterface
 
 internal class OverridingExternalFunWithOptionalParamsImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.OverridingExternalFunWithOptionalParams(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.OverridingExternalFunWithOptionalParams
 
 internal class OverridingExternalFunWithOptionalParamsWithFakeImpl(
     override val function: KtFunctionLikeSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.OverridingExternalFunWithOptionalParamsWithFake(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.OverridingExternalFunWithOptionalParamsWithFake
 
 internal class CallToDefinedExternallyFromNonExternalDeclarationImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.CallToDefinedExternallyFromNonExternalDeclaration(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.CallToDefinedExternallyFromNonExternalDeclaration
 
 internal class ExternalClassConstructorPropertyParameterImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ExternalClassConstructorPropertyParameter(), KtAbstractFirDiagnostic<KtParameter>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtParameter>(firDiagnostic, token), KtFirDiagnostic.ExternalClassConstructorPropertyParameter
 
 internal class ExternalEnumEntryWithBodyImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ExternalEnumEntryWithBody(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.ExternalEnumEntryWithBody
 
 internal class ExternalAnonymousInitializerImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ExternalAnonymousInitializer(), KtAbstractFirDiagnostic<KtAnonymousInitializer>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtAnonymousInitializer>(firDiagnostic, token), KtFirDiagnostic.ExternalAnonymousInitializer
 
 internal class ExternalDelegationImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ExternalDelegation(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.ExternalDelegation
 
 internal class ExternalDelegatedConstructorCallImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ExternalDelegatedConstructorCall(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.ExternalDelegatedConstructorCall
 
 internal class WrongBodyOfExternalDeclarationImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.WrongBodyOfExternalDeclaration(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.WrongBodyOfExternalDeclaration
 
 internal class WrongInitializerOfExternalDeclarationImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.WrongInitializerOfExternalDeclaration(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.WrongInitializerOfExternalDeclaration
 
 internal class WrongDefaultValueForExternalFunParameterImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.WrongDefaultValueForExternalFunParameter(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.WrongDefaultValueForExternalFunParameter
 
 internal class NestedExternalDeclarationImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NestedExternalDeclaration(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.NestedExternalDeclaration
 
 internal class WrongExternalDeclarationImpl(
     override val classKind: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.WrongExternalDeclaration(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.WrongExternalDeclaration
 
 internal class NestedClassInExternalInterfaceImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NestedClassInExternalInterface(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.NestedClassInExternalInterface
 
 internal class ExternalTypeExtendsNonExternalTypeImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ExternalTypeExtendsNonExternalType(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.ExternalTypeExtendsNonExternalType
 
 internal class InlineExternalDeclarationImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.InlineExternalDeclaration(), KtAbstractFirDiagnostic<KtDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtDeclaration>(firDiagnostic, token), KtFirDiagnostic.InlineExternalDeclaration
 
 internal class EnumClassInExternalDeclarationWarningImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.EnumClassInExternalDeclarationWarning(), KtAbstractFirDiagnostic<KtDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtDeclaration>(firDiagnostic, token), KtFirDiagnostic.EnumClassInExternalDeclarationWarning
 
 internal class InlineClassInExternalDeclarationWarningImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.InlineClassInExternalDeclarationWarning(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.InlineClassInExternalDeclarationWarning
 
 internal class InlineClassInExternalDeclarationImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.InlineClassInExternalDeclaration(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.InlineClassInExternalDeclaration
 
 internal class ExtensionFunctionInExternalDeclarationImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ExtensionFunctionInExternalDeclaration(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.ExtensionFunctionInExternalDeclaration
 
 internal class NonAbstractMemberOfExternalInterfaceImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NonAbstractMemberOfExternalInterface(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.NonAbstractMemberOfExternalInterface
 
 internal class NonExternalDeclarationInInappropriateFileImpl(
     override val type: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NonExternalDeclarationInInappropriateFile(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.NonExternalDeclarationInInappropriateFile
 
 internal class CannotCheckForExternalInterfaceImpl(
     override val targetType: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.CannotCheckForExternalInterface(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.CannotCheckForExternalInterface
 
 internal class UncheckedCastToExternalInterfaceImpl(
     override val sourceType: KtType,
     override val targetType: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.UncheckedCastToExternalInterface(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.UncheckedCastToExternalInterface
 
 internal class ExternalInterfaceAsClassLiteralImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.ExternalInterfaceAsClassLiteral(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.ExternalInterfaceAsClassLiteral
 
 internal class JsExternalInheritorsOnlyImpl(
     override val parent: KtClassLikeSymbol,
     override val kid: KtClassLikeSymbol,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.JsExternalInheritorsOnly(), KtAbstractFirDiagnostic<KtDeclaration>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtDeclaration>(firDiagnostic, token), KtFirDiagnostic.JsExternalInheritorsOnly
 
 internal class JsExternalArgumentImpl(
     override val argType: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.JsExternalArgument(), KtAbstractFirDiagnostic<KtExpression>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtExpression>(firDiagnostic, token), KtFirDiagnostic.JsExternalArgument
 
 internal class NestedJsExportImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NestedJsExport(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.NestedJsExport
 
 internal class WrongExportedDeclarationImpl(
     override val kind: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.WrongExportedDeclaration(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.WrongExportedDeclaration
 
 internal class NonExportableTypeImpl(
     override val kind: String,
     override val type: KtType,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NonExportableType(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.NonExportableType
 
 internal class NonConsumableExportedIdentifierImpl(
     override val name: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.NonConsumableExportedIdentifier(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.NonConsumableExportedIdentifier
 
 internal class DelegationByDynamicImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.DelegationByDynamic(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.DelegationByDynamic
 
 internal class SpreadOperatorInDynamicCallImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.SpreadOperatorInDynamicCall(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.SpreadOperatorInDynamicCall
 
 internal class WrongOperationWithDynamicImpl(
     override val operation: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.WrongOperationWithDynamic(), KtAbstractFirDiagnostic<KtElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.WrongOperationWithDynamic
 
 internal class SyntaxImpl(
     override val message: String,
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: KtLifetimeToken,
-) : KtFirDiagnostic.Syntax(), KtAbstractFirDiagnostic<PsiElement>
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<PsiElement>(firDiagnostic, token), KtFirDiagnostic.Syntax