diff --git a/idea/idea-fir/src/org/jetbrains/kotlin/idea/fir/highlighter/KotlinHighLevelDiagnosticHighlightingPass.kt b/idea/idea-fir/src/org/jetbrains/kotlin/idea/fir/highlighter/KotlinHighLevelDiagnosticHighlightingPass.kt index c633c2d8ca0..c3d381d9634 100644 --- a/idea/idea-fir/src/org/jetbrains/kotlin/idea/fir/highlighter/KotlinHighLevelDiagnosticHighlightingPass.kt +++ b/idea/idea-fir/src/org/jetbrains/kotlin/idea/fir/highlighter/KotlinHighLevelDiagnosticHighlightingPass.kt @@ -24,6 +24,7 @@ import com.intellij.openapi.progress.ProgressIndicator import com.intellij.openapi.project.Project import com.intellij.psi.PsiFile import org.jetbrains.kotlin.diagnostics.Severity +import org.jetbrains.kotlin.idea.frontend.api.KtAnalysisSession import org.jetbrains.kotlin.idea.frontend.api.analyze import org.jetbrains.kotlin.idea.frontend.api.diagnostics.KtDiagnostic import org.jetbrains.kotlin.idea.frontend.api.diagnostics.KtDiagnosticWithPsi @@ -48,16 +49,19 @@ class KotlinHighLevelDiagnosticHighlightingPass( } } - private fun addDiagnostic(diagnostic: KtDiagnosticWithPsi) { - val fixes = service().getQuickFixesFor(diagnostic as KtFirDiagnostic) - annotationHolder.runAnnotatorWithContext(diagnostic.psi) { element, annotator -> - annotationHolder.newAnnotation(diagnostic.getHighlightSeverity(), diagnostic.getMessageToRender()) - .addFixes(fixes) - .create() + private fun KtAnalysisSession.addDiagnostic(diagnostic: KtDiagnosticWithPsi<*>) { + val fixes = with(service()) { getQuickFixesFor(diagnostic as KtFirDiagnostic) } + annotationHolder.runAnnotatorWithContext(diagnostic.psi) { _, _ -> + diagnostic.textRanges.forEach { range -> + annotationHolder.newAnnotation(diagnostic.getHighlightSeverity(), diagnostic.getMessageToRender()) + .addFixes(fixes) + .range(range) + .create() + } } } - private fun KtDiagnosticWithPsi.getHighlightSeverity() = when (severity) { + private fun KtDiagnosticWithPsi<*>.getHighlightSeverity() = when (severity) { Severity.INFO -> HighlightSeverity.INFORMATION Severity.ERROR -> HighlightSeverity.ERROR Severity.WARNING -> HighlightSeverity.WARNING diff --git a/idea/idea-fir/src/org/jetbrains/kotlin/idea/quickfix/KtQuickFixService.kt b/idea/idea-fir/src/org/jetbrains/kotlin/idea/quickfix/KtQuickFixService.kt index 78eb52664e6..8749c503256 100644 --- a/idea/idea-fir/src/org/jetbrains/kotlin/idea/quickfix/KtQuickFixService.kt +++ b/idea/idea-fir/src/org/jetbrains/kotlin/idea/quickfix/KtQuickFixService.kt @@ -7,13 +7,15 @@ package org.jetbrains.kotlin.idea.quickfix import com.intellij.codeInsight.intention.IntentionAction import com.intellij.openapi.extensions.ExtensionPointName +import org.jetbrains.kotlin.idea.frontend.api.KtAnalysisSession +import org.jetbrains.kotlin.idea.frontend.api.diagnostics.KtDiagnosticWithPsi import org.jetbrains.kotlin.idea.frontend.api.fir.diagnostics.KtFirDiagnostic class KtQuickFixService { private val list = KtQuickFixesList.createCombined(KtQuickFixRegistrar.allQuickFixesList()) - fun getQuickFixesFor(diagnostic: KtFirDiagnostic): List = - list.getQuickFixesFor(diagnostic) + fun KtAnalysisSession.getQuickFixesFor(diagnostic: KtDiagnosticWithPsi<*>): List = + with(list) { getQuickFixesFor(diagnostic) } } abstract class KtQuickFixRegistrar { diff --git a/idea/idea-fir/src/org/jetbrains/kotlin/idea/quickfix/KtQuickFixesList.kt b/idea/idea-fir/src/org/jetbrains/kotlin/idea/quickfix/KtQuickFixesList.kt index 1287431e1ab..d216b510e4e 100644 --- a/idea/idea-fir/src/org/jetbrains/kotlin/idea/quickfix/KtQuickFixesList.kt +++ b/idea/idea-fir/src/org/jetbrains/kotlin/idea/quickfix/KtQuickFixesList.kt @@ -6,9 +6,9 @@ package org.jetbrains.kotlin.idea.quickfix import com.intellij.codeInsight.intention.IntentionAction -import org.jetbrains.kotlin.idea.fir.low.level.api.annotations.PrivateForInline +import com.intellij.psi.PsiElement +import org.jetbrains.kotlin.idea.frontend.api.KtAnalysisSession import org.jetbrains.kotlin.idea.frontend.api.diagnostics.KtDiagnosticWithPsi -import org.jetbrains.kotlin.idea.frontend.api.fir.diagnostics.KtFirDiagnostic import kotlin.reflect.KClass @RequiresOptIn @@ -16,9 +16,9 @@ annotation class ForKtQuickFixesListBuilder() class KtQuickFixesListBuilder private constructor() { - val quickFixes = mutableMapOf, MutableList>() + val quickFixes = mutableMapOf>, MutableList>() - inline fun register(quickFixFactory: QuickFixFactory) { + inline fun > register(quickFixFactory: QuickFixFactory) { quickFixes.getOrPut(D::class) { mutableListOf() }.add(quickFixFactory) } @@ -30,17 +30,22 @@ class KtQuickFixesListBuilder private constructor() { } } -class KtQuickFixesList @ForKtQuickFixesListBuilder constructor(private val quickFixes: Map, List>) { - fun getQuickFixesFor(diagnostic: KtDiagnosticWithPsi): List { +class KtQuickFixesList @ForKtQuickFixesListBuilder constructor(private val quickFixes: Map>, List>) { + fun KtAnalysisSession.getQuickFixesFor(diagnostic: KtDiagnosticWithPsi<*>): List { val factories = quickFixes[diagnostic.diagnosticClass] ?: return emptyList() - return factories.mapNotNull { it.createQuickFix(diagnostic) } + return factories.flatMap { createQuickFixes(it, diagnostic) } } - private fun QuickFixFactory.createQuickFix( - diagnostic: KtDiagnosticWithPsi - ) = when (this) { - is QuickFixesPsiBasedFactory -> createQuickFix(diagnostic.psi) - else -> error("Unsupported QuickFixFactory $this") + @Suppress("UNCHECKED_CAST") + private fun KtAnalysisSession.createQuickFixes( + quickFixFactory: QuickFixFactory, + diagnostic: KtDiagnosticWithPsi + ): List = when (quickFixFactory) { + is QuickFixesPsiBasedFactory<*> -> quickFixFactory.createQuickFix(diagnostic.psi) + is QuickFixesHLApiBasedFactory<*, *> -> with(quickFixFactory as QuickFixesHLApiBasedFactory>) { + createQuickFix(diagnostic) + } + else -> error("Unsupported QuickFixFactory $quickFixFactory") } companion object { diff --git a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/KtAnalysisSession.kt b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/KtAnalysisSession.kt index 81957c512f1..58962276c6a 100644 --- a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/KtAnalysisSession.kt +++ b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/KtAnalysisSession.kt @@ -85,7 +85,7 @@ abstract class KtAnalysisSession(final override val token: ValidityToken) : Vali fun KtElement.getDiagnostics(): Collection = diagnosticProvider.getDiagnosticsForElement(this) - fun KtFile.collectDiagnosticsForFile(): Collection = diagnosticProvider.collectDiagnosticsForFile(this) + fun KtFile.collectDiagnosticsForFile(): Collection> = diagnosticProvider.collectDiagnosticsForFile(this) fun KtSymbolWithKind.getContainingSymbol(): KtSymbolWithKind? = containingDeclarationProvider.getContainingDeclaration(this) diff --git a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/components/KtDiagnosticProvider.kt b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/components/KtDiagnosticProvider.kt index 8382ea505f8..045d09f02ff 100644 --- a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/components/KtDiagnosticProvider.kt +++ b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/components/KtDiagnosticProvider.kt @@ -10,6 +10,6 @@ import org.jetbrains.kotlin.psi.KtElement import org.jetbrains.kotlin.psi.KtFile abstract class KtDiagnosticProvider : KtAnalysisSessionComponent() { - abstract fun getDiagnosticsForElement(element: KtElement): Collection - abstract fun collectDiagnosticsForFile(ktFile: KtFile): Collection + abstract fun getDiagnosticsForElement(element: KtElement): Collection> + abstract fun collectDiagnosticsForFile(ktFile: KtFile): Collection> } diff --git a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/diagnostics/KtDiagnostic.kt b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/diagnostics/KtDiagnostic.kt index 7b630d693b4..76bd5e9cb9f 100644 --- a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/diagnostics/KtDiagnostic.kt +++ b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/diagnostics/KtDiagnostic.kt @@ -18,10 +18,10 @@ interface KtDiagnostic : ValidityTokenOwner { val defaultMessage: String } -interface KtDiagnosticWithPsi : KtDiagnostic { - val psi: PsiElement +interface KtDiagnosticWithPsi : KtDiagnostic { + val psi: PSI val textRanges: Collection - val diagnosticClass: KClass + val diagnosticClass: KClass> } class KtNonBoundToPsiErrorDiagnostic( diff --git a/idea/idea-frontend-fir/idea-frontend-fir-generator/src/org/jetbrains/kotlin/idea/frontend/api/fir/generator/rendererrs/KtDiagnosticClassImplementationRenderer.kt b/idea/idea-frontend-fir/idea-frontend-fir-generator/src/org/jetbrains/kotlin/idea/frontend/api/fir/generator/rendererrs/KtDiagnosticClassImplementationRenderer.kt index 1021846ff34..76e56d62951 100644 --- a/idea/idea-frontend-fir/idea-frontend-fir-generator/src/org/jetbrains/kotlin/idea/frontend/api/fir/generator/rendererrs/KtDiagnosticClassImplementationRenderer.kt +++ b/idea/idea-frontend-fir/idea-frontend-fir-generator/src/org/jetbrains/kotlin/idea/frontend/api/fir/generator/rendererrs/KtDiagnosticClassImplementationRenderer.kt @@ -31,9 +31,11 @@ object KtDiagnosticClassImplementationRenderer : AbstractDiagnosticsDataClassRen withIndent { printParameters(diagnostic) } - inBracketsWithIndent(") : KtFirDiagnostic.${diagnostic.className}(), KtAbstractFirDiagnostic") { + print(") : KtFirDiagnostic.${diagnostic.className}(), KtAbstractFirDiagnostic<") + printTypeWithShortNames(diagnostic.original.psiType) + print(">") + inBracketsWithIndent { println("override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic)") - printOverridePsiProperty(diagnostic) } } @@ -45,19 +47,6 @@ object KtDiagnosticClassImplementationRenderer : AbstractDiagnosticsDataClassRen println("override val token: ValidityToken,") } - private fun SmartPrinter.printOverridePsiProperty(diagnostic: HLDiagnostic) { - print("override val psi: ") - printTypeWithShortNames(diagnostic.original.psiType) - withIndent { - print(" get() = super.psi") - if (diagnostic.original.psiType.classifier != PsiElement::class) { - print(" as ") - printTypeWithShortNames(diagnostic.original.psiType) - } - } - println() - } - private fun SmartPrinter.printParameter(parameter: HLDiagnosticParameter) { print("override val ${parameter.name}: ") printTypeWithShortNames(parameter.type) diff --git a/idea/idea-frontend-fir/idea-frontend-fir-generator/src/org/jetbrains/kotlin/idea/frontend/api/fir/generator/rendererrs/KtDiagnosticClassRenderer.kt b/idea/idea-frontend-fir/idea-frontend-fir-generator/src/org/jetbrains/kotlin/idea/frontend/api/fir/generator/rendererrs/KtDiagnosticClassRenderer.kt index 41575ba1b38..c165cbf5b72 100644 --- a/idea/idea-frontend-fir/idea-frontend-fir-generator/src/org/jetbrains/kotlin/idea/frontend/api/fir/generator/rendererrs/KtDiagnosticClassRenderer.kt +++ b/idea/idea-frontend-fir/idea-frontend-fir-generator/src/org/jetbrains/kotlin/idea/frontend/api/fir/generator/rendererrs/KtDiagnosticClassRenderer.kt @@ -19,7 +19,7 @@ object KtDiagnosticClassRenderer : AbstractDiagnosticsDataClassRenderer() { } private fun SmartPrinter.printDiagnosticClasses(diagnosticList: HLDiagnosticList) { - inBracketsWithIndent("sealed class KtFirDiagnostic : KtDiagnosticWithPsi") { + inBracketsWithIndent("sealed class KtFirDiagnostic : KtDiagnosticWithPsi") { for (diagnostic in diagnosticList.diagnostics) { printDiagnosticClass(diagnostic) println() @@ -28,21 +28,15 @@ object KtDiagnosticClassRenderer : AbstractDiagnosticsDataClassRenderer() { } private fun SmartPrinter.printDiagnosticClass(diagnostic: HLDiagnostic) { - inBracketsWithIndent("abstract class ${diagnostic.className} : KtFirDiagnostic()") { + print("abstract class ${diagnostic.className} : KtFirDiagnostic<") + printTypeWithShortNames(diagnostic.original.psiType) + print(">()") + inBracketsWithIndent { println("override val diagnosticClass get() = ${diagnostic.className}::class") - printPsiParameter(diagnostic) printDiagnosticParameters(diagnostic) } } - private fun SmartPrinter.printPsiParameter(diagnostic: HLDiagnostic) { - if (diagnostic.original.psiType.classifier != PsiElement::class) { - print("abstract override val psi: ") - printTypeWithShortNames(diagnostic.original.psiType) - println() - } - } - private fun SmartPrinter.printDiagnosticParameters(diagnostic: HLDiagnostic) { diagnostic.parameters.forEach { parameter -> print("abstract val ${parameter.name}: ") @@ -58,5 +52,6 @@ object KtDiagnosticClassRenderer : AbstractDiagnosticsDataClassRenderer() { override val defaultImports = listOf( "org.jetbrains.kotlin.idea.frontend.api.diagnostics.KtDiagnosticWithPsi", + "com.intellij.psi.PsiElement", ) } \ No newline at end of file diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirAnalysisSessionComponent.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirAnalysisSessionComponent.kt index f9a3977a0a1..855336e6705 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirAnalysisSessionComponent.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirAnalysisSessionComponent.kt @@ -21,7 +21,7 @@ internal interface KtFirAnalysisSessionComponent { val firResolveState get() = analysisSession.firResolveState fun ConeKotlinType.asKtType() = analysisSession.firSymbolBuilder.buildKtType(this) - fun FirPsiDiagnostic<*>.asKtDiagnostic(): KtDiagnosticWithPsi = + fun FirPsiDiagnostic<*>.asKtDiagnostic(): KtDiagnosticWithPsi<*> = (analysisSession.diagnosticProvider as KtFirDiagnosticProvider).firDiagnosticAsKtDiagnostic(this) fun ConeDiagnostic.asKtDiagnostic(source: FirSourceElement): KtDiagnostic? = diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirDiagnosticProvider.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirDiagnosticProvider.kt index 69836ad1c06..6c5feacdf23 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirDiagnosticProvider.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirDiagnosticProvider.kt @@ -26,18 +26,18 @@ internal class KtFirDiagnosticProvider( override val analysisSession: KtFirAnalysisSession, override val token: ValidityToken, ) : KtDiagnosticProvider(), KtFirAnalysisSessionComponent { - override fun getDiagnosticsForElement(element: KtElement): Collection = withValidityAssertion { + override fun getDiagnosticsForElement(element: KtElement): Collection> = withValidityAssertion { element.getDiagnostics(firResolveState).map { it.asKtDiagnostic() } } - override fun collectDiagnosticsForFile(ktFile: KtFile): Collection = + override fun collectDiagnosticsForFile(ktFile: KtFile): Collection> = ktFile.collectDiagnosticsForFile(firResolveState).map { it.asKtDiagnostic() } - fun firDiagnosticAsKtDiagnostic(diagnostic: FirPsiDiagnostic<*>): KtDiagnosticWithPsi { + fun firDiagnosticAsKtDiagnostic(diagnostic: FirPsiDiagnostic<*>): KtDiagnosticWithPsi<*> { return KT_DIAGNOSTIC_CONVERTER.convert(analysisSession, diagnostic as FirDiagnostic<*>) } - fun coneDiagnosticAsKtDiagnostic(coneDiagnostic: ConeDiagnostic, source: FirSourceElement): KtDiagnosticWithPsi? { + fun coneDiagnosticAsKtDiagnostic(coneDiagnostic: ConeDiagnostic, source: FirSourceElement): KtDiagnosticWithPsi<*>? { val firDiagnostic = coneDiagnostic.toFirDiagnostic(source) ?: return null check(firDiagnostic is FirPsiDiagnostic<*>) return firDiagnosticAsKtDiagnostic(firDiagnostic) diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/DiagnosticConverter.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/DiagnosticConverter.kt index 02bc79c1429..19c46559b79 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/DiagnosticConverter.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/DiagnosticConverter.kt @@ -12,23 +12,23 @@ import org.jetbrains.kotlin.idea.frontend.api.fir.KtFirAnalysisSession internal interface KtFirDiagnosticCreator internal fun interface KtFirDiagnostic0Creator : KtFirDiagnosticCreator { - fun KtFirAnalysisSession.create(diagnostic: FirSimpleDiagnostic<*>): KtFirDiagnostic + fun KtFirAnalysisSession.create(diagnostic: FirSimpleDiagnostic<*>): KtFirDiagnostic<*> } internal fun interface KtFirDiagnostic1Creator : KtFirDiagnosticCreator { - fun KtFirAnalysisSession.create(diagnostic: FirDiagnosticWithParameters1<*, A>): KtFirDiagnostic + fun KtFirAnalysisSession.create(diagnostic: FirDiagnosticWithParameters1<*, A>): KtFirDiagnostic<*> } internal fun interface KtFirDiagnostic2Creator : KtFirDiagnosticCreator { - fun KtFirAnalysisSession.create(diagnostic: FirDiagnosticWithParameters2<*, A, B>): KtFirDiagnostic + fun KtFirAnalysisSession.create(diagnostic: FirDiagnosticWithParameters2<*, A, B>): KtFirDiagnostic<*> } internal fun interface KtFirDiagnostic3Creator : KtFirDiagnosticCreator { - fun KtFirAnalysisSession.create(diagnostic: FirDiagnosticWithParameters3<*, A, B, C>): KtFirDiagnostic + fun KtFirAnalysisSession.create(diagnostic: FirDiagnosticWithParameters3<*, A, B, C>): KtFirDiagnostic<*> } internal class KtDiagnosticConverter(private val conversions: Map, KtFirDiagnosticCreator>) { - fun convert(analysisSession: KtFirAnalysisSession, diagnostic: FirDiagnostic<*>): KtFirDiagnostic { + fun convert(analysisSession: KtFirAnalysisSession, diagnostic: FirDiagnostic<*>): KtFirDiagnostic<*> { val creator = conversions[diagnostic.factory] ?: error("No conversion was found for ${diagnostic.factory}") diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtAbstractFirDiagnostic.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtAbstractFirDiagnostic.kt index 85773383b8f..7b52e7fb501 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtAbstractFirDiagnostic.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtAbstractFirDiagnostic.kt @@ -15,7 +15,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirPsiDiagnostic import org.jetbrains.kotlin.idea.frontend.api.diagnostics.KtDiagnostic import org.jetbrains.kotlin.idea.frontend.api.diagnostics.KtDiagnosticWithPsi -internal interface KtAbstractFirDiagnostic : KtDiagnosticWithPsi { +internal interface KtAbstractFirDiagnostic : KtDiagnosticWithPsi { val firDiagnostic: FirPsiDiagnostic<*> override val factoryName: String @@ -34,8 +34,9 @@ internal interface KtAbstractFirDiagnostic : KtDiagnosticWithPsi { override val textRanges: Collection get() = firDiagnostic.textRanges - override val psi: PsiElement - get() = firDiagnostic.psiElement + @Suppress("UNCHECKED_CAST") + override val psi: PSI + get() = firDiagnostic.psiElement as PSI override val severity: Severity get() = firDiagnostic.severity diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnostics.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnostics.kt index bc65708881b..631c68a02b4 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnostics.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnostics.kt @@ -17,6 +17,7 @@ import org.jetbrains.kotlin.idea.frontend.api.symbols.KtVariableSymbol import org.jetbrains.kotlin.idea.frontend.api.types.KtType import org.jetbrains.kotlin.lexer.KtModifierKeywordToken import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.psi.KtCallableDeclaration import org.jetbrains.kotlin.psi.KtClassOrObject import org.jetbrains.kotlin.psi.KtDeclaration import org.jetbrains.kotlin.psi.KtDestructuringDeclaration @@ -35,710 +36,656 @@ import org.jetbrains.kotlin.psi.KtTypeReference * DO NOT MODIFY IT MANUALLY */ -sealed class KtFirDiagnostic : KtDiagnosticWithPsi { - abstract class Syntax : KtFirDiagnostic() { +sealed class KtFirDiagnostic : KtDiagnosticWithPsi { + abstract class Syntax : KtFirDiagnostic() { override val diagnosticClass get() = Syntax::class } - abstract class OtherError : KtFirDiagnostic() { + abstract class OtherError : KtFirDiagnostic() { override val diagnosticClass get() = OtherError::class } - abstract class IllegalConstExpression : KtFirDiagnostic() { + abstract class IllegalConstExpression : KtFirDiagnostic() { override val diagnosticClass get() = IllegalConstExpression::class } - abstract class IllegalUnderscore : KtFirDiagnostic() { + abstract class IllegalUnderscore : KtFirDiagnostic() { override val diagnosticClass get() = IllegalUnderscore::class } - abstract class ExpressionRequired : KtFirDiagnostic() { + abstract class ExpressionRequired : KtFirDiagnostic() { override val diagnosticClass get() = ExpressionRequired::class } - abstract class BreakOrContinueOutsideALoop : KtFirDiagnostic() { + abstract class BreakOrContinueOutsideALoop : KtFirDiagnostic() { override val diagnosticClass get() = BreakOrContinueOutsideALoop::class } - abstract class NotALoopLabel : KtFirDiagnostic() { + abstract class NotALoopLabel : KtFirDiagnostic() { override val diagnosticClass get() = NotALoopLabel::class } - abstract class VariableExpected : KtFirDiagnostic() { + abstract class VariableExpected : KtFirDiagnostic() { override val diagnosticClass get() = VariableExpected::class } - abstract class ReturnNotAllowed : KtFirDiagnostic() { + abstract class ReturnNotAllowed : KtFirDiagnostic() { override val diagnosticClass get() = ReturnNotAllowed::class } - abstract class DelegationInInterface : KtFirDiagnostic() { + abstract class DelegationInInterface : KtFirDiagnostic() { override val diagnosticClass get() = DelegationInInterface::class } - abstract class Hidden : KtFirDiagnostic() { + abstract class Hidden : KtFirDiagnostic() { override val diagnosticClass get() = Hidden::class abstract val hidden: KtSymbol } - abstract class UnresolvedReference : KtFirDiagnostic() { + abstract class UnresolvedReference : KtFirDiagnostic() { override val diagnosticClass get() = UnresolvedReference::class abstract val reference: String } - abstract class UnresolvedLabel : KtFirDiagnostic() { + abstract class UnresolvedLabel : KtFirDiagnostic() { override val diagnosticClass get() = UnresolvedLabel::class } - abstract class DeserializationError : KtFirDiagnostic() { + abstract class DeserializationError : KtFirDiagnostic() { override val diagnosticClass get() = DeserializationError::class } - abstract class ErrorFromJavaResolution : KtFirDiagnostic() { + abstract class ErrorFromJavaResolution : KtFirDiagnostic() { override val diagnosticClass get() = ErrorFromJavaResolution::class } - abstract class UnknownCallableKind : KtFirDiagnostic() { + abstract class UnknownCallableKind : KtFirDiagnostic() { override val diagnosticClass get() = UnknownCallableKind::class } - abstract class MissingStdlibClass : KtFirDiagnostic() { + abstract class MissingStdlibClass : KtFirDiagnostic() { override val diagnosticClass get() = MissingStdlibClass::class } - abstract class NoThis : KtFirDiagnostic() { + abstract class NoThis : KtFirDiagnostic() { override val diagnosticClass get() = NoThis::class } - abstract class SuperIsNotAnExpression : KtFirDiagnostic() { + abstract class SuperIsNotAnExpression : KtFirDiagnostic() { override val diagnosticClass get() = SuperIsNotAnExpression::class } - abstract class SuperNotAvailable : KtFirDiagnostic() { + abstract class SuperNotAvailable : KtFirDiagnostic() { override val diagnosticClass get() = SuperNotAvailable::class } - abstract class AbstractSuperCall : KtFirDiagnostic() { + abstract class AbstractSuperCall : KtFirDiagnostic() { override val diagnosticClass get() = AbstractSuperCall::class } - abstract class InstanceAccessBeforeSuperCall : KtFirDiagnostic() { + abstract class InstanceAccessBeforeSuperCall : KtFirDiagnostic() { override val diagnosticClass get() = InstanceAccessBeforeSuperCall::class abstract val target: String } - abstract class TypeParameterAsSupertype : KtFirDiagnostic() { + abstract class TypeParameterAsSupertype : KtFirDiagnostic() { override val diagnosticClass get() = TypeParameterAsSupertype::class } - abstract class EnumAsSupertype : KtFirDiagnostic() { + abstract class EnumAsSupertype : KtFirDiagnostic() { override val diagnosticClass get() = EnumAsSupertype::class } - abstract class RecursionInSupertypes : KtFirDiagnostic() { + abstract class RecursionInSupertypes : KtFirDiagnostic() { override val diagnosticClass get() = RecursionInSupertypes::class } - abstract class NotASupertype : KtFirDiagnostic() { + abstract class NotASupertype : KtFirDiagnostic() { override val diagnosticClass get() = NotASupertype::class } - abstract class SuperclassNotAccessibleFromInterface : KtFirDiagnostic() { + abstract class SuperclassNotAccessibleFromInterface : KtFirDiagnostic() { override val diagnosticClass get() = SuperclassNotAccessibleFromInterface::class } - abstract class QualifiedSupertypeExtendedByOtherSupertype : KtFirDiagnostic() { + abstract class QualifiedSupertypeExtendedByOtherSupertype : KtFirDiagnostic() { override val diagnosticClass get() = QualifiedSupertypeExtendedByOtherSupertype::class abstract val otherSuperType: KtClassLikeSymbol } - abstract class SupertypeInitializedInInterface : KtFirDiagnostic() { + abstract class SupertypeInitializedInInterface : KtFirDiagnostic() { override val diagnosticClass get() = SupertypeInitializedInInterface::class } - abstract class InterfaceWithSuperclass : KtFirDiagnostic() { + abstract class InterfaceWithSuperclass : KtFirDiagnostic() { override val diagnosticClass get() = InterfaceWithSuperclass::class } - abstract class ClassInSupertypeForEnum : KtFirDiagnostic() { + abstract class ClassInSupertypeForEnum : KtFirDiagnostic() { override val diagnosticClass get() = ClassInSupertypeForEnum::class } - abstract class SealedSupertype : KtFirDiagnostic() { + abstract class SealedSupertype : KtFirDiagnostic() { override val diagnosticClass get() = SealedSupertype::class } - abstract class SealedSupertypeInLocalClass : KtFirDiagnostic() { + abstract class SealedSupertypeInLocalClass : KtFirDiagnostic() { override val diagnosticClass get() = SealedSupertypeInLocalClass::class } - abstract class ConstructorInObject : KtFirDiagnostic() { + abstract class ConstructorInObject : KtFirDiagnostic() { override val diagnosticClass get() = ConstructorInObject::class - abstract override val psi: KtDeclaration } - abstract class ConstructorInInterface : KtFirDiagnostic() { + abstract class ConstructorInInterface : KtFirDiagnostic() { override val diagnosticClass get() = ConstructorInInterface::class - abstract override val psi: KtDeclaration } - abstract class NonPrivateConstructorInEnum : KtFirDiagnostic() { + abstract class NonPrivateConstructorInEnum : KtFirDiagnostic() { override val diagnosticClass get() = NonPrivateConstructorInEnum::class } - abstract class NonPrivateConstructorInSealed : KtFirDiagnostic() { + abstract class NonPrivateConstructorInSealed : KtFirDiagnostic() { override val diagnosticClass get() = NonPrivateConstructorInSealed::class } - abstract class CyclicConstructorDelegationCall : KtFirDiagnostic() { + abstract class CyclicConstructorDelegationCall : KtFirDiagnostic() { override val diagnosticClass get() = CyclicConstructorDelegationCall::class } - abstract class PrimaryConstructorDelegationCallExpected : KtFirDiagnostic() { + abstract class PrimaryConstructorDelegationCallExpected : KtFirDiagnostic() { override val diagnosticClass get() = PrimaryConstructorDelegationCallExpected::class } - abstract class SupertypeInitializedWithoutPrimaryConstructor : KtFirDiagnostic() { + abstract class SupertypeInitializedWithoutPrimaryConstructor : KtFirDiagnostic() { override val diagnosticClass get() = SupertypeInitializedWithoutPrimaryConstructor::class } - abstract class DelegationSuperCallInEnumConstructor : KtFirDiagnostic() { + abstract class DelegationSuperCallInEnumConstructor : KtFirDiagnostic() { override val diagnosticClass get() = DelegationSuperCallInEnumConstructor::class } - abstract class PrimaryConstructorRequiredForDataClass : KtFirDiagnostic() { + abstract class PrimaryConstructorRequiredForDataClass : KtFirDiagnostic() { override val diagnosticClass get() = PrimaryConstructorRequiredForDataClass::class } - abstract class ExplicitDelegationCallRequired : KtFirDiagnostic() { + abstract class ExplicitDelegationCallRequired : KtFirDiagnostic() { override val diagnosticClass get() = ExplicitDelegationCallRequired::class } - abstract class SealedClassConstructorCall : KtFirDiagnostic() { + abstract class SealedClassConstructorCall : KtFirDiagnostic() { override val diagnosticClass get() = SealedClassConstructorCall::class } - abstract class AnnotationArgumentKclassLiteralOfTypeParameterError : KtFirDiagnostic() { + abstract class AnnotationArgumentKclassLiteralOfTypeParameterError : KtFirDiagnostic() { override val diagnosticClass get() = AnnotationArgumentKclassLiteralOfTypeParameterError::class - abstract override val psi: KtExpression } - abstract class AnnotationArgumentMustBeConst : KtFirDiagnostic() { + abstract class AnnotationArgumentMustBeConst : KtFirDiagnostic() { override val diagnosticClass get() = AnnotationArgumentMustBeConst::class - abstract override val psi: KtExpression } - abstract class AnnotationArgumentMustBeEnumConst : KtFirDiagnostic() { + abstract class AnnotationArgumentMustBeEnumConst : KtFirDiagnostic() { override val diagnosticClass get() = AnnotationArgumentMustBeEnumConst::class - abstract override val psi: KtExpression } - abstract class AnnotationArgumentMustBeKclassLiteral : KtFirDiagnostic() { + abstract class AnnotationArgumentMustBeKclassLiteral : KtFirDiagnostic() { override val diagnosticClass get() = AnnotationArgumentMustBeKclassLiteral::class - abstract override val psi: KtExpression } - abstract class AnnotationClassMember : KtFirDiagnostic() { + abstract class AnnotationClassMember : KtFirDiagnostic() { override val diagnosticClass get() = AnnotationClassMember::class } - abstract class AnnotationParameterDefaultValueMustBeConstant : KtFirDiagnostic() { + abstract class AnnotationParameterDefaultValueMustBeConstant : KtFirDiagnostic() { override val diagnosticClass get() = AnnotationParameterDefaultValueMustBeConstant::class - abstract override val psi: KtExpression } - abstract class InvalidTypeOfAnnotationMember : KtFirDiagnostic() { + abstract class InvalidTypeOfAnnotationMember : KtFirDiagnostic() { override val diagnosticClass get() = InvalidTypeOfAnnotationMember::class - abstract override val psi: KtTypeReference } - abstract class LocalAnnotationClassError : KtFirDiagnostic() { + abstract class LocalAnnotationClassError : KtFirDiagnostic() { override val diagnosticClass get() = LocalAnnotationClassError::class - abstract override val psi: KtClassOrObject } - abstract class MissingValOnAnnotationParameter : KtFirDiagnostic() { + abstract class MissingValOnAnnotationParameter : KtFirDiagnostic() { override val diagnosticClass get() = MissingValOnAnnotationParameter::class - abstract override val psi: KtParameter } - abstract class NonConstValUsedInConstantExpression : KtFirDiagnostic() { + abstract class NonConstValUsedInConstantExpression : KtFirDiagnostic() { override val diagnosticClass get() = NonConstValUsedInConstantExpression::class - abstract override val psi: KtExpression } - abstract class NotAnAnnotationClass : KtFirDiagnostic() { + abstract class NotAnAnnotationClass : KtFirDiagnostic() { override val diagnosticClass get() = NotAnAnnotationClass::class abstract val annotationName: String } - abstract class NullableTypeOfAnnotationMember : KtFirDiagnostic() { + abstract class NullableTypeOfAnnotationMember : KtFirDiagnostic() { override val diagnosticClass get() = NullableTypeOfAnnotationMember::class - abstract override val psi: KtTypeReference } - abstract class VarAnnotationParameter : KtFirDiagnostic() { + abstract class VarAnnotationParameter : KtFirDiagnostic() { override val diagnosticClass get() = VarAnnotationParameter::class - abstract override val psi: KtParameter } - abstract class ExposedTypealiasExpandedType : KtFirDiagnostic() { + abstract class ExposedTypealiasExpandedType : KtFirDiagnostic() { override val diagnosticClass get() = ExposedTypealiasExpandedType::class - abstract override val psi: KtNamedDeclaration abstract val elementVisibility: Visibility abstract val restrictingDeclaration: KtSymbol abstract val restrictingVisibility: Visibility } - abstract class ExposedFunctionReturnType : KtFirDiagnostic() { + abstract class ExposedFunctionReturnType : KtFirDiagnostic() { override val diagnosticClass get() = ExposedFunctionReturnType::class - abstract override val psi: KtNamedDeclaration abstract val elementVisibility: Visibility abstract val restrictingDeclaration: KtSymbol abstract val restrictingVisibility: Visibility } - abstract class ExposedReceiverType : KtFirDiagnostic() { + abstract class ExposedReceiverType : KtFirDiagnostic() { override val diagnosticClass get() = ExposedReceiverType::class - abstract override val psi: KtTypeReference abstract val elementVisibility: Visibility abstract val restrictingDeclaration: KtSymbol abstract val restrictingVisibility: Visibility } - abstract class ExposedPropertyType : KtFirDiagnostic() { + abstract class ExposedPropertyType : KtFirDiagnostic() { override val diagnosticClass get() = ExposedPropertyType::class - abstract override val psi: KtNamedDeclaration abstract val elementVisibility: Visibility abstract val restrictingDeclaration: KtSymbol abstract val restrictingVisibility: Visibility } - abstract class ExposedParameterType : KtFirDiagnostic() { + abstract class ExposedParameterType : KtFirDiagnostic() { override val diagnosticClass get() = ExposedParameterType::class - abstract override val psi: KtParameter abstract val elementVisibility: Visibility abstract val restrictingDeclaration: KtSymbol abstract val restrictingVisibility: Visibility } - abstract class ExposedSuperInterface : KtFirDiagnostic() { + abstract class ExposedSuperInterface : KtFirDiagnostic() { override val diagnosticClass get() = ExposedSuperInterface::class - abstract override val psi: KtTypeReference abstract val elementVisibility: Visibility abstract val restrictingDeclaration: KtSymbol abstract val restrictingVisibility: Visibility } - abstract class ExposedSuperClass : KtFirDiagnostic() { + abstract class ExposedSuperClass : KtFirDiagnostic() { override val diagnosticClass get() = ExposedSuperClass::class - abstract override val psi: KtTypeReference abstract val elementVisibility: Visibility abstract val restrictingDeclaration: KtSymbol abstract val restrictingVisibility: Visibility } - abstract class ExposedTypeParameterBound : KtFirDiagnostic() { + abstract class ExposedTypeParameterBound : KtFirDiagnostic() { override val diagnosticClass get() = ExposedTypeParameterBound::class - abstract override val psi: KtTypeReference abstract val elementVisibility: Visibility abstract val restrictingDeclaration: KtSymbol abstract val restrictingVisibility: Visibility } - abstract class InapplicableInfixModifier : KtFirDiagnostic() { + abstract class InapplicableInfixModifier : KtFirDiagnostic() { override val diagnosticClass get() = InapplicableInfixModifier::class abstract val modifier: String } - abstract class RepeatedModifier : KtFirDiagnostic() { + abstract class RepeatedModifier : KtFirDiagnostic() { override val diagnosticClass get() = RepeatedModifier::class abstract val modifier: KtModifierKeywordToken } - abstract class RedundantModifier : KtFirDiagnostic() { + abstract class RedundantModifier : KtFirDiagnostic() { override val diagnosticClass get() = RedundantModifier::class abstract val redundantModifier: KtModifierKeywordToken abstract val conflictingModifier: KtModifierKeywordToken } - abstract class DeprecatedModifierPair : KtFirDiagnostic() { + abstract class DeprecatedModifierPair : KtFirDiagnostic() { override val diagnosticClass get() = DeprecatedModifierPair::class abstract val deprecatedModifier: KtModifierKeywordToken abstract val conflictingModifier: KtModifierKeywordToken } - abstract class IncompatibleModifiers : KtFirDiagnostic() { + abstract class IncompatibleModifiers : KtFirDiagnostic() { override val diagnosticClass get() = IncompatibleModifiers::class abstract val modifier1: KtModifierKeywordToken abstract val modifier2: KtModifierKeywordToken } - abstract class RedundantOpenInInterface : KtFirDiagnostic() { + abstract class RedundantOpenInInterface : KtFirDiagnostic() { override val diagnosticClass get() = RedundantOpenInInterface::class - abstract override val psi: KtModifierListOwner } - abstract class NoneApplicable : KtFirDiagnostic() { + abstract class NoneApplicable : KtFirDiagnostic() { override val diagnosticClass get() = NoneApplicable::class abstract val candidates: List } - abstract class InapplicableCandidate : KtFirDiagnostic() { + abstract class InapplicableCandidate : KtFirDiagnostic() { override val diagnosticClass get() = InapplicableCandidate::class abstract val candidate: KtSymbol } - abstract class InapplicableLateinitModifier : KtFirDiagnostic() { + abstract class InapplicableLateinitModifier : KtFirDiagnostic() { override val diagnosticClass get() = InapplicableLateinitModifier::class abstract val reason: String } - abstract class Ambiguity : KtFirDiagnostic() { + abstract class Ambiguity : KtFirDiagnostic() { override val diagnosticClass get() = Ambiguity::class abstract val candidates: List } - abstract class AssignOperatorAmbiguity : KtFirDiagnostic() { + abstract class AssignOperatorAmbiguity : KtFirDiagnostic() { override val diagnosticClass get() = AssignOperatorAmbiguity::class abstract val candidates: List } - abstract class TypeMismatch : KtFirDiagnostic() { + abstract class TypeMismatch : KtFirDiagnostic() { override val diagnosticClass get() = TypeMismatch::class abstract val expectedType: KtType abstract val actualType: KtType } - abstract class RecursionInImplicitTypes : KtFirDiagnostic() { + abstract class RecursionInImplicitTypes : KtFirDiagnostic() { override val diagnosticClass get() = RecursionInImplicitTypes::class } - abstract class InferenceError : KtFirDiagnostic() { + abstract class InferenceError : KtFirDiagnostic() { override val diagnosticClass get() = InferenceError::class } - abstract class ProjectionOnNonClassTypeArgument : KtFirDiagnostic() { + abstract class ProjectionOnNonClassTypeArgument : KtFirDiagnostic() { override val diagnosticClass get() = ProjectionOnNonClassTypeArgument::class } - abstract class UpperBoundViolated : KtFirDiagnostic() { + abstract class UpperBoundViolated : KtFirDiagnostic() { override val diagnosticClass get() = UpperBoundViolated::class abstract val typeParameter: KtTypeParameterSymbol abstract val violatedType: KtType } - abstract class TypeArgumentsNotAllowed : KtFirDiagnostic() { + abstract class TypeArgumentsNotAllowed : KtFirDiagnostic() { override val diagnosticClass get() = TypeArgumentsNotAllowed::class } - abstract class WrongNumberOfTypeArguments : KtFirDiagnostic() { + abstract class WrongNumberOfTypeArguments : KtFirDiagnostic() { override val diagnosticClass get() = WrongNumberOfTypeArguments::class abstract val expectedCount: Int abstract val classifier: KtClassLikeSymbol } - abstract class NoTypeForTypeParameter : KtFirDiagnostic() { + abstract class NoTypeForTypeParameter : KtFirDiagnostic() { override val diagnosticClass get() = NoTypeForTypeParameter::class } - abstract class TypeParametersInObject : KtFirDiagnostic() { + abstract class TypeParametersInObject : KtFirDiagnostic() { override val diagnosticClass get() = TypeParametersInObject::class } - abstract class IllegalProjectionUsage : KtFirDiagnostic() { + abstract class IllegalProjectionUsage : KtFirDiagnostic() { override val diagnosticClass get() = IllegalProjectionUsage::class } - abstract class TypeParametersInEnum : KtFirDiagnostic() { + abstract class TypeParametersInEnum : KtFirDiagnostic() { override val diagnosticClass get() = TypeParametersInEnum::class } - abstract class ConflictingProjection : KtFirDiagnostic() { + abstract class ConflictingProjection : KtFirDiagnostic() { override val diagnosticClass get() = ConflictingProjection::class abstract val type: String } - abstract class VarianceOnTypeParameterNotAllowed : KtFirDiagnostic() { + abstract class VarianceOnTypeParameterNotAllowed : KtFirDiagnostic() { override val diagnosticClass get() = VarianceOnTypeParameterNotAllowed::class } - abstract class ReturnTypeMismatchOnOverride : KtFirDiagnostic() { + abstract class ReturnTypeMismatchOnOverride : KtFirDiagnostic() { override val diagnosticClass get() = ReturnTypeMismatchOnOverride::class - abstract val returnType: String + abstract val function: KtSymbol abstract val superFunction: KtSymbol } - abstract class PropertyTypeMismatchOnOverride : KtFirDiagnostic() { + abstract class PropertyTypeMismatchOnOverride : KtFirDiagnostic() { override val diagnosticClass get() = PropertyTypeMismatchOnOverride::class - abstract val propertyType: String + abstract val property: KtSymbol abstract val targetProperty: KtSymbol } - abstract class VarTypeMismatchOnOverride : KtFirDiagnostic() { + abstract class VarTypeMismatchOnOverride : KtFirDiagnostic() { override val diagnosticClass get() = VarTypeMismatchOnOverride::class - abstract val variableType: String + abstract val variable: KtSymbol abstract val targetVariable: KtSymbol } - abstract class ManyCompanionObjects : KtFirDiagnostic() { + abstract class ManyCompanionObjects : KtFirDiagnostic() { override val diagnosticClass get() = ManyCompanionObjects::class } - abstract class ConflictingOverloads : KtFirDiagnostic() { + abstract class ConflictingOverloads : KtFirDiagnostic() { override val diagnosticClass get() = ConflictingOverloads::class abstract val conflictingOverloads: String } - abstract class Redeclaration : KtFirDiagnostic() { + abstract class Redeclaration : KtFirDiagnostic() { override val diagnosticClass get() = Redeclaration::class abstract val conflictingDeclaration: String } - abstract class AnyMethodImplementedInInterface : KtFirDiagnostic() { + abstract class AnyMethodImplementedInInterface : KtFirDiagnostic() { override val diagnosticClass get() = AnyMethodImplementedInInterface::class } - abstract class LocalObjectNotAllowed : KtFirDiagnostic() { + abstract class LocalObjectNotAllowed : KtFirDiagnostic() { override val diagnosticClass get() = LocalObjectNotAllowed::class - abstract override val psi: KtNamedDeclaration abstract val objectName: Name } - abstract class LocalInterfaceNotAllowed : KtFirDiagnostic() { + abstract class LocalInterfaceNotAllowed : KtFirDiagnostic() { override val diagnosticClass get() = LocalInterfaceNotAllowed::class - abstract override val psi: KtNamedDeclaration abstract val interfaceName: Name } - abstract class AbstractFunctionInNonAbstractClass : KtFirDiagnostic() { + abstract class AbstractFunctionInNonAbstractClass : KtFirDiagnostic() { override val diagnosticClass get() = AbstractFunctionInNonAbstractClass::class - abstract override val psi: KtFunction abstract val function: KtSymbol abstract val containingClass: KtSymbol } - abstract class AbstractFunctionWithBody : KtFirDiagnostic() { + abstract class AbstractFunctionWithBody : KtFirDiagnostic() { override val diagnosticClass get() = AbstractFunctionWithBody::class - abstract override val psi: KtFunction abstract val function: KtSymbol } - abstract class NonAbstractFunctionWithNoBody : KtFirDiagnostic() { + abstract class NonAbstractFunctionWithNoBody : KtFirDiagnostic() { override val diagnosticClass get() = NonAbstractFunctionWithNoBody::class - abstract override val psi: KtFunction abstract val function: KtSymbol } - abstract class PrivateFunctionWithNoBody : KtFirDiagnostic() { + abstract class PrivateFunctionWithNoBody : KtFirDiagnostic() { override val diagnosticClass get() = PrivateFunctionWithNoBody::class - abstract override val psi: KtFunction abstract val function: KtSymbol } - abstract class NonMemberFunctionNoBody : KtFirDiagnostic() { + abstract class NonMemberFunctionNoBody : KtFirDiagnostic() { override val diagnosticClass get() = NonMemberFunctionNoBody::class - abstract override val psi: KtFunction abstract val function: KtSymbol } - abstract class FunctionDeclarationWithNoName : KtFirDiagnostic() { + abstract class FunctionDeclarationWithNoName : KtFirDiagnostic() { override val diagnosticClass get() = FunctionDeclarationWithNoName::class - abstract override val psi: KtFunction } - abstract class AnonymousFunctionParameterWithDefaultValue : KtFirDiagnostic() { + abstract class AnonymousFunctionParameterWithDefaultValue : KtFirDiagnostic() { override val diagnosticClass get() = AnonymousFunctionParameterWithDefaultValue::class - abstract override val psi: KtParameter } - abstract class UselessVarargOnParameter : KtFirDiagnostic() { + abstract class UselessVarargOnParameter : KtFirDiagnostic() { override val diagnosticClass get() = UselessVarargOnParameter::class - abstract override val psi: KtParameter } - abstract class AbstractPropertyInNonAbstractClass : KtFirDiagnostic() { + abstract class AbstractPropertyInNonAbstractClass : KtFirDiagnostic() { override val diagnosticClass get() = AbstractPropertyInNonAbstractClass::class - abstract override val psi: KtModifierListOwner abstract val property: KtSymbol abstract val containingClass: KtSymbol } - abstract class PrivatePropertyInInterface : KtFirDiagnostic() { + abstract class PrivatePropertyInInterface : KtFirDiagnostic() { override val diagnosticClass get() = PrivatePropertyInInterface::class - abstract override val psi: KtProperty } - abstract class AbstractPropertyWithInitializer : KtFirDiagnostic() { + abstract class AbstractPropertyWithInitializer : KtFirDiagnostic() { override val diagnosticClass get() = AbstractPropertyWithInitializer::class - abstract override val psi: KtExpression } - abstract class PropertyInitializerInInterface : KtFirDiagnostic() { + abstract class PropertyInitializerInInterface : KtFirDiagnostic() { override val diagnosticClass get() = PropertyInitializerInInterface::class - abstract override val psi: KtExpression } - abstract class PropertyWithNoTypeNoInitializer : KtFirDiagnostic() { + abstract class PropertyWithNoTypeNoInitializer : KtFirDiagnostic() { override val diagnosticClass get() = PropertyWithNoTypeNoInitializer::class - abstract override val psi: KtProperty } - abstract class AbstractDelegatedProperty : KtFirDiagnostic() { + abstract class AbstractDelegatedProperty : KtFirDiagnostic() { override val diagnosticClass get() = AbstractDelegatedProperty::class - abstract override val psi: KtPropertyDelegate } - abstract class DelegatedPropertyInInterface : KtFirDiagnostic() { + abstract class DelegatedPropertyInInterface : KtFirDiagnostic() { override val diagnosticClass get() = DelegatedPropertyInInterface::class - abstract override val psi: KtPropertyDelegate } - abstract class AbstractPropertyWithGetter : KtFirDiagnostic() { + abstract class AbstractPropertyWithGetter : KtFirDiagnostic() { override val diagnosticClass get() = AbstractPropertyWithGetter::class - abstract override val psi: KtPropertyAccessor } - abstract class AbstractPropertyWithSetter : KtFirDiagnostic() { + abstract class AbstractPropertyWithSetter : KtFirDiagnostic() { override val diagnosticClass get() = AbstractPropertyWithSetter::class - abstract override val psi: KtPropertyAccessor } - abstract class PrivateSetterForAbstractProperty : KtFirDiagnostic() { + abstract class PrivateSetterForAbstractProperty : KtFirDiagnostic() { override val diagnosticClass get() = PrivateSetterForAbstractProperty::class } - abstract class PrivateSetterForOpenProperty : KtFirDiagnostic() { + abstract class PrivateSetterForOpenProperty : KtFirDiagnostic() { override val diagnosticClass get() = PrivateSetterForOpenProperty::class } - abstract class ExpectedPrivateDeclaration : KtFirDiagnostic() { + abstract class ExpectedPrivateDeclaration : KtFirDiagnostic() { override val diagnosticClass get() = ExpectedPrivateDeclaration::class - abstract override val psi: KtModifierListOwner } - abstract class ExpectedDeclarationWithBody : KtFirDiagnostic() { + abstract class ExpectedDeclarationWithBody : KtFirDiagnostic() { override val diagnosticClass get() = ExpectedDeclarationWithBody::class - abstract override val psi: KtDeclaration } - abstract class ExpectedPropertyInitializer : KtFirDiagnostic() { + abstract class ExpectedPropertyInitializer : KtFirDiagnostic() { override val diagnosticClass get() = ExpectedPropertyInitializer::class - abstract override val psi: KtExpression } - abstract class ExpectedDelegatedProperty : KtFirDiagnostic() { + abstract class ExpectedDelegatedProperty : KtFirDiagnostic() { override val diagnosticClass get() = ExpectedDelegatedProperty::class - abstract override val psi: KtPropertyDelegate } - abstract class InitializerRequiredForDestructuringDeclaration : KtFirDiagnostic() { + abstract class InitializerRequiredForDestructuringDeclaration : KtFirDiagnostic() { override val diagnosticClass get() = InitializerRequiredForDestructuringDeclaration::class - abstract override val psi: KtDestructuringDeclaration } - abstract class ComponentFunctionMissing : KtFirDiagnostic() { + abstract class ComponentFunctionMissing : KtFirDiagnostic() { override val diagnosticClass get() = ComponentFunctionMissing::class abstract val missingFunctionName: Name abstract val destructingType: KtType } - abstract class ComponentFunctionAmbiguity : KtFirDiagnostic() { + abstract class ComponentFunctionAmbiguity : KtFirDiagnostic() { override val diagnosticClass get() = ComponentFunctionAmbiguity::class abstract val functionWithAmbiguityName: Name abstract val candidates: List } - abstract class UninitializedVariable : KtFirDiagnostic() { + abstract class UninitializedVariable : KtFirDiagnostic() { override val diagnosticClass get() = UninitializedVariable::class abstract val variable: KtVariableSymbol } - abstract class WrongInvocationKind : KtFirDiagnostic() { + abstract class WrongInvocationKind : KtFirDiagnostic() { override val diagnosticClass get() = WrongInvocationKind::class abstract val declaration: KtSymbol abstract val requiredRange: EventOccurrencesRange abstract val actualRange: EventOccurrencesRange } - abstract class LeakedInPlaceLambda : KtFirDiagnostic() { + abstract class LeakedInPlaceLambda : KtFirDiagnostic() { override val diagnosticClass get() = LeakedInPlaceLambda::class abstract val lambda: KtSymbol } - abstract class WrongImpliesCondition : KtFirDiagnostic() { + abstract class WrongImpliesCondition : KtFirDiagnostic() { override val diagnosticClass get() = WrongImpliesCondition::class } - abstract class RedundantVisibilityModifier : KtFirDiagnostic() { + abstract class RedundantVisibilityModifier : KtFirDiagnostic() { override val diagnosticClass get() = RedundantVisibilityModifier::class - abstract override val psi: KtModifierListOwner } - abstract class RedundantModalityModifier : KtFirDiagnostic() { + abstract class RedundantModalityModifier : KtFirDiagnostic() { override val diagnosticClass get() = RedundantModalityModifier::class - abstract override val psi: KtModifierListOwner } - abstract class RedundantReturnUnitType : KtFirDiagnostic() { + abstract class RedundantReturnUnitType : KtFirDiagnostic() { override val diagnosticClass get() = RedundantReturnUnitType::class - abstract override val psi: PsiTypeElement } - abstract class RedundantExplicitType : KtFirDiagnostic() { + abstract class RedundantExplicitType : KtFirDiagnostic() { override val diagnosticClass get() = RedundantExplicitType::class } - abstract class RedundantSingleExpressionStringTemplate : KtFirDiagnostic() { + abstract class RedundantSingleExpressionStringTemplate : KtFirDiagnostic() { override val diagnosticClass get() = RedundantSingleExpressionStringTemplate::class } - abstract class CanBeVal : KtFirDiagnostic() { + abstract class CanBeVal : KtFirDiagnostic() { override val diagnosticClass get() = CanBeVal::class - abstract override val psi: KtDeclaration } - abstract class CanBeReplacedWithOperatorAssignment : KtFirDiagnostic() { + abstract class CanBeReplacedWithOperatorAssignment : KtFirDiagnostic() { override val diagnosticClass get() = CanBeReplacedWithOperatorAssignment::class - abstract override val psi: KtExpression } - abstract class RedundantCallOfConversionMethod : KtFirDiagnostic() { + abstract class RedundantCallOfConversionMethod : KtFirDiagnostic() { override val diagnosticClass get() = RedundantCallOfConversionMethod::class } - abstract class ArrayEqualityOperatorCanBeReplacedWithEquals : KtFirDiagnostic() { + abstract class ArrayEqualityOperatorCanBeReplacedWithEquals : KtFirDiagnostic() { override val diagnosticClass get() = ArrayEqualityOperatorCanBeReplacedWithEquals::class - abstract override val psi: KtExpression } - abstract class EmptyRange : KtFirDiagnostic() { + abstract class EmptyRange : KtFirDiagnostic() { override val diagnosticClass get() = EmptyRange::class } - abstract class RedundantSetterParameterType : KtFirDiagnostic() { + abstract class RedundantSetterParameterType : KtFirDiagnostic() { override val diagnosticClass get() = RedundantSetterParameterType::class } - abstract class UnusedVariable : KtFirDiagnostic() { + abstract class UnusedVariable : KtFirDiagnostic() { override val diagnosticClass get() = UnusedVariable::class - abstract override val psi: KtNamedDeclaration } - abstract class AssignedValueIsNeverRead : KtFirDiagnostic() { + abstract class AssignedValueIsNeverRead : KtFirDiagnostic() { override val diagnosticClass get() = AssignedValueIsNeverRead::class } - abstract class VariableInitializerIsRedundant : KtFirDiagnostic() { + abstract class VariableInitializerIsRedundant : KtFirDiagnostic() { override val diagnosticClass get() = VariableInitializerIsRedundant::class } - abstract class VariableNeverRead : KtFirDiagnostic() { + abstract class VariableNeverRead : KtFirDiagnostic() { override val diagnosticClass get() = VariableNeverRead::class - abstract override val psi: KtNamedDeclaration } - abstract class UselessCallOnNotNull : KtFirDiagnostic() { + abstract class UselessCallOnNotNull : KtFirDiagnostic() { override val diagnosticClass get() = UselessCallOnNotNull::class } diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnosticsImpl.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnosticsImpl.kt index 5271354068b..2e00c1aec3d 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnosticsImpl.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnosticsImpl.kt @@ -19,6 +19,7 @@ import org.jetbrains.kotlin.idea.frontend.api.symbols.KtVariableSymbol import org.jetbrains.kotlin.idea.frontend.api.types.KtType import org.jetbrains.kotlin.lexer.KtModifierKeywordToken import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.psi.KtCallableDeclaration import org.jetbrains.kotlin.psi.KtClassOrObject import org.jetbrains.kotlin.psi.KtDeclaration import org.jetbrains.kotlin.psi.KtDestructuringDeclaration @@ -40,462 +41,405 @@ import org.jetbrains.kotlin.psi.KtTypeReference internal class SyntaxImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.Syntax(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.Syntax(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class OtherErrorImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.OtherError(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.OtherError(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class IllegalConstExpressionImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.IllegalConstExpression(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.IllegalConstExpression(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class IllegalUnderscoreImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.IllegalUnderscore(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.IllegalUnderscore(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class ExpressionRequiredImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.ExpressionRequired(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.ExpressionRequired(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class BreakOrContinueOutsideALoopImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.BreakOrContinueOutsideALoop(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.BreakOrContinueOutsideALoop(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class NotALoopLabelImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.NotALoopLabel(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.NotALoopLabel(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class VariableExpectedImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.VariableExpected(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.VariableExpected(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class ReturnNotAllowedImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.ReturnNotAllowed(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.ReturnNotAllowed(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class DelegationInInterfaceImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.DelegationInInterface(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.DelegationInInterface(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class HiddenImpl( override val hidden: KtSymbol, firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.Hidden(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.Hidden(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class UnresolvedReferenceImpl( override val reference: String, firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.UnresolvedReference(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.UnresolvedReference(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class UnresolvedLabelImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.UnresolvedLabel(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.UnresolvedLabel(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class DeserializationErrorImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.DeserializationError(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.DeserializationError(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class ErrorFromJavaResolutionImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.ErrorFromJavaResolution(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.ErrorFromJavaResolution(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class UnknownCallableKindImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.UnknownCallableKind(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.UnknownCallableKind(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class MissingStdlibClassImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.MissingStdlibClass(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.MissingStdlibClass(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class NoThisImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.NoThis(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.NoThis(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class SuperIsNotAnExpressionImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.SuperIsNotAnExpression(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.SuperIsNotAnExpression(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class SuperNotAvailableImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.SuperNotAvailable(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.SuperNotAvailable(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class AbstractSuperCallImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.AbstractSuperCall(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.AbstractSuperCall(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class InstanceAccessBeforeSuperCallImpl( override val target: String, firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.InstanceAccessBeforeSuperCall(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.InstanceAccessBeforeSuperCall(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class TypeParameterAsSupertypeImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.TypeParameterAsSupertype(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.TypeParameterAsSupertype(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class EnumAsSupertypeImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.EnumAsSupertype(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.EnumAsSupertype(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class RecursionInSupertypesImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.RecursionInSupertypes(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.RecursionInSupertypes(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class NotASupertypeImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.NotASupertype(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.NotASupertype(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class SuperclassNotAccessibleFromInterfaceImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.SuperclassNotAccessibleFromInterface(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.SuperclassNotAccessibleFromInterface(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class QualifiedSupertypeExtendedByOtherSupertypeImpl( override val otherSuperType: KtClassLikeSymbol, firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.QualifiedSupertypeExtendedByOtherSupertype(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.QualifiedSupertypeExtendedByOtherSupertype(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class SupertypeInitializedInInterfaceImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.SupertypeInitializedInInterface(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.SupertypeInitializedInInterface(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class InterfaceWithSuperclassImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.InterfaceWithSuperclass(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.InterfaceWithSuperclass(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class ClassInSupertypeForEnumImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.ClassInSupertypeForEnum(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.ClassInSupertypeForEnum(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class SealedSupertypeImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.SealedSupertype(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.SealedSupertype(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class SealedSupertypeInLocalClassImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.SealedSupertypeInLocalClass(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.SealedSupertypeInLocalClass(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class ConstructorInObjectImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.ConstructorInObject(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.ConstructorInObject(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtDeclaration get() = super.psi as KtDeclaration } internal class ConstructorInInterfaceImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.ConstructorInInterface(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.ConstructorInInterface(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtDeclaration get() = super.psi as KtDeclaration } internal class NonPrivateConstructorInEnumImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.NonPrivateConstructorInEnum(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.NonPrivateConstructorInEnum(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class NonPrivateConstructorInSealedImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.NonPrivateConstructorInSealed(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.NonPrivateConstructorInSealed(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class CyclicConstructorDelegationCallImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.CyclicConstructorDelegationCall(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.CyclicConstructorDelegationCall(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class PrimaryConstructorDelegationCallExpectedImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.PrimaryConstructorDelegationCallExpected(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.PrimaryConstructorDelegationCallExpected(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class SupertypeInitializedWithoutPrimaryConstructorImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.SupertypeInitializedWithoutPrimaryConstructor(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.SupertypeInitializedWithoutPrimaryConstructor(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class DelegationSuperCallInEnumConstructorImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.DelegationSuperCallInEnumConstructor(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.DelegationSuperCallInEnumConstructor(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class PrimaryConstructorRequiredForDataClassImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.PrimaryConstructorRequiredForDataClass(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.PrimaryConstructorRequiredForDataClass(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class ExplicitDelegationCallRequiredImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.ExplicitDelegationCallRequired(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.ExplicitDelegationCallRequired(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class SealedClassConstructorCallImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.SealedClassConstructorCall(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.SealedClassConstructorCall(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class AnnotationArgumentKclassLiteralOfTypeParameterErrorImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.AnnotationArgumentKclassLiteralOfTypeParameterError(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.AnnotationArgumentKclassLiteralOfTypeParameterError(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtExpression get() = super.psi as KtExpression } internal class AnnotationArgumentMustBeConstImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.AnnotationArgumentMustBeConst(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.AnnotationArgumentMustBeConst(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtExpression get() = super.psi as KtExpression } internal class AnnotationArgumentMustBeEnumConstImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.AnnotationArgumentMustBeEnumConst(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.AnnotationArgumentMustBeEnumConst(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtExpression get() = super.psi as KtExpression } internal class AnnotationArgumentMustBeKclassLiteralImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.AnnotationArgumentMustBeKclassLiteral(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.AnnotationArgumentMustBeKclassLiteral(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtExpression get() = super.psi as KtExpression } internal class AnnotationClassMemberImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.AnnotationClassMember(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.AnnotationClassMember(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class AnnotationParameterDefaultValueMustBeConstantImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.AnnotationParameterDefaultValueMustBeConstant(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.AnnotationParameterDefaultValueMustBeConstant(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtExpression get() = super.psi as KtExpression } internal class InvalidTypeOfAnnotationMemberImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.InvalidTypeOfAnnotationMember(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.InvalidTypeOfAnnotationMember(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtTypeReference get() = super.psi as KtTypeReference } internal class LocalAnnotationClassErrorImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.LocalAnnotationClassError(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.LocalAnnotationClassError(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtClassOrObject get() = super.psi as KtClassOrObject } internal class MissingValOnAnnotationParameterImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.MissingValOnAnnotationParameter(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.MissingValOnAnnotationParameter(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtParameter get() = super.psi as KtParameter } internal class NonConstValUsedInConstantExpressionImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.NonConstValUsedInConstantExpression(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.NonConstValUsedInConstantExpression(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtExpression get() = super.psi as KtExpression } internal class NotAnAnnotationClassImpl( override val annotationName: String, firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.NotAnAnnotationClass(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.NotAnAnnotationClass(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class NullableTypeOfAnnotationMemberImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.NullableTypeOfAnnotationMember(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.NullableTypeOfAnnotationMember(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtTypeReference get() = super.psi as KtTypeReference } internal class VarAnnotationParameterImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.VarAnnotationParameter(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.VarAnnotationParameter(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtParameter get() = super.psi as KtParameter } internal class ExposedTypealiasExpandedTypeImpl( @@ -504,9 +448,8 @@ internal class ExposedTypealiasExpandedTypeImpl( override val restrictingVisibility: Visibility, firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.ExposedTypealiasExpandedType(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.ExposedTypealiasExpandedType(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtNamedDeclaration get() = super.psi as KtNamedDeclaration } internal class ExposedFunctionReturnTypeImpl( @@ -515,9 +458,8 @@ internal class ExposedFunctionReturnTypeImpl( override val restrictingVisibility: Visibility, firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.ExposedFunctionReturnType(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.ExposedFunctionReturnType(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtNamedDeclaration get() = super.psi as KtNamedDeclaration } internal class ExposedReceiverTypeImpl( @@ -526,9 +468,8 @@ internal class ExposedReceiverTypeImpl( override val restrictingVisibility: Visibility, firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.ExposedReceiverType(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.ExposedReceiverType(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtTypeReference get() = super.psi as KtTypeReference } internal class ExposedPropertyTypeImpl( @@ -537,9 +478,8 @@ internal class ExposedPropertyTypeImpl( override val restrictingVisibility: Visibility, firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.ExposedPropertyType(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.ExposedPropertyType(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtNamedDeclaration get() = super.psi as KtNamedDeclaration } internal class ExposedParameterTypeImpl( @@ -548,9 +488,8 @@ internal class ExposedParameterTypeImpl( override val restrictingVisibility: Visibility, firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.ExposedParameterType(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.ExposedParameterType(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtParameter get() = super.psi as KtParameter } internal class ExposedSuperInterfaceImpl( @@ -559,9 +498,8 @@ internal class ExposedSuperInterfaceImpl( override val restrictingVisibility: Visibility, firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.ExposedSuperInterface(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.ExposedSuperInterface(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtTypeReference get() = super.psi as KtTypeReference } internal class ExposedSuperClassImpl( @@ -570,9 +508,8 @@ internal class ExposedSuperClassImpl( override val restrictingVisibility: Visibility, firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.ExposedSuperClass(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.ExposedSuperClass(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtTypeReference get() = super.psi as KtTypeReference } internal class ExposedTypeParameterBoundImpl( @@ -581,27 +518,24 @@ internal class ExposedTypeParameterBoundImpl( override val restrictingVisibility: Visibility, firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.ExposedTypeParameterBound(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.ExposedTypeParameterBound(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtTypeReference get() = super.psi as KtTypeReference } internal class InapplicableInfixModifierImpl( override val modifier: String, firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.InapplicableInfixModifier(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.InapplicableInfixModifier(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class RepeatedModifierImpl( override val modifier: KtModifierKeywordToken, firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.RepeatedModifier(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.RepeatedModifier(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class RedundantModifierImpl( @@ -609,9 +543,8 @@ internal class RedundantModifierImpl( override val conflictingModifier: KtModifierKeywordToken, firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.RedundantModifier(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.RedundantModifier(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class DeprecatedModifierPairImpl( @@ -619,9 +552,8 @@ internal class DeprecatedModifierPairImpl( override val conflictingModifier: KtModifierKeywordToken, firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.DeprecatedModifierPair(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.DeprecatedModifierPair(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class IncompatibleModifiersImpl( @@ -629,62 +561,55 @@ internal class IncompatibleModifiersImpl( override val modifier2: KtModifierKeywordToken, firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.IncompatibleModifiers(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.IncompatibleModifiers(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class RedundantOpenInInterfaceImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.RedundantOpenInInterface(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.RedundantOpenInInterface(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtModifierListOwner get() = super.psi as KtModifierListOwner } internal class NoneApplicableImpl( override val candidates: List, firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.NoneApplicable(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.NoneApplicable(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class InapplicableCandidateImpl( override val candidate: KtSymbol, firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.InapplicableCandidate(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.InapplicableCandidate(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class InapplicableLateinitModifierImpl( override val reason: String, firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.InapplicableLateinitModifier(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.InapplicableLateinitModifier(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class AmbiguityImpl( override val candidates: List, firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.Ambiguity(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.Ambiguity(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class AssignOperatorAmbiguityImpl( override val candidates: List, firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.AssignOperatorAmbiguity(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.AssignOperatorAmbiguity(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class TypeMismatchImpl( @@ -692,33 +617,29 @@ internal class TypeMismatchImpl( override val actualType: KtType, firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.TypeMismatch(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.TypeMismatch(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class RecursionInImplicitTypesImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.RecursionInImplicitTypes(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.RecursionInImplicitTypes(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class InferenceErrorImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.InferenceError(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.InferenceError(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class ProjectionOnNonClassTypeArgumentImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.ProjectionOnNonClassTypeArgument(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.ProjectionOnNonClassTypeArgument(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class UpperBoundViolatedImpl( @@ -726,17 +647,15 @@ internal class UpperBoundViolatedImpl( override val violatedType: KtType, firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.UpperBoundViolated(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.UpperBoundViolated(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class TypeArgumentsNotAllowedImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.TypeArgumentsNotAllowed(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.TypeArgumentsNotAllowed(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class WrongNumberOfTypeArgumentsImpl( @@ -744,140 +663,124 @@ internal class WrongNumberOfTypeArgumentsImpl( override val classifier: KtClassLikeSymbol, firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.WrongNumberOfTypeArguments(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.WrongNumberOfTypeArguments(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class NoTypeForTypeParameterImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.NoTypeForTypeParameter(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.NoTypeForTypeParameter(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class TypeParametersInObjectImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.TypeParametersInObject(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.TypeParametersInObject(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class IllegalProjectionUsageImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.IllegalProjectionUsage(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.IllegalProjectionUsage(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class TypeParametersInEnumImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.TypeParametersInEnum(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.TypeParametersInEnum(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class ConflictingProjectionImpl( override val type: String, firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.ConflictingProjection(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.ConflictingProjection(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class VarianceOnTypeParameterNotAllowedImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.VarianceOnTypeParameterNotAllowed(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.VarianceOnTypeParameterNotAllowed(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class ReturnTypeMismatchOnOverrideImpl( - override val returnType: String, + override val function: KtSymbol, override val superFunction: KtSymbol, firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.ReturnTypeMismatchOnOverride(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.ReturnTypeMismatchOnOverride(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class PropertyTypeMismatchOnOverrideImpl( - override val propertyType: String, + override val property: KtSymbol, override val targetProperty: KtSymbol, firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.PropertyTypeMismatchOnOverride(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.PropertyTypeMismatchOnOverride(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class VarTypeMismatchOnOverrideImpl( - override val variableType: String, + override val variable: KtSymbol, override val targetVariable: KtSymbol, firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.VarTypeMismatchOnOverride(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.VarTypeMismatchOnOverride(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class ManyCompanionObjectsImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.ManyCompanionObjects(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.ManyCompanionObjects(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class ConflictingOverloadsImpl( override val conflictingOverloads: String, firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.ConflictingOverloads(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.ConflictingOverloads(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class RedeclarationImpl( override val conflictingDeclaration: String, firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.Redeclaration(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.Redeclaration(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class AnyMethodImplementedInInterfaceImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.AnyMethodImplementedInInterface(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.AnyMethodImplementedInInterface(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class LocalObjectNotAllowedImpl( override val objectName: Name, firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.LocalObjectNotAllowed(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.LocalObjectNotAllowed(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtNamedDeclaration get() = super.psi as KtNamedDeclaration } internal class LocalInterfaceNotAllowedImpl( override val interfaceName: Name, firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.LocalInterfaceNotAllowed(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.LocalInterfaceNotAllowed(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtNamedDeclaration get() = super.psi as KtNamedDeclaration } internal class AbstractFunctionInNonAbstractClassImpl( @@ -885,69 +788,61 @@ internal class AbstractFunctionInNonAbstractClassImpl( override val containingClass: KtSymbol, firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.AbstractFunctionInNonAbstractClass(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.AbstractFunctionInNonAbstractClass(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtFunction get() = super.psi as KtFunction } internal class AbstractFunctionWithBodyImpl( override val function: KtSymbol, firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.AbstractFunctionWithBody(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.AbstractFunctionWithBody(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtFunction get() = super.psi as KtFunction } internal class NonAbstractFunctionWithNoBodyImpl( override val function: KtSymbol, firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.NonAbstractFunctionWithNoBody(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.NonAbstractFunctionWithNoBody(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtFunction get() = super.psi as KtFunction } internal class PrivateFunctionWithNoBodyImpl( override val function: KtSymbol, firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.PrivateFunctionWithNoBody(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.PrivateFunctionWithNoBody(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtFunction get() = super.psi as KtFunction } internal class NonMemberFunctionNoBodyImpl( override val function: KtSymbol, firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.NonMemberFunctionNoBody(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.NonMemberFunctionNoBody(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtFunction get() = super.psi as KtFunction } internal class FunctionDeclarationWithNoNameImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.FunctionDeclarationWithNoName(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.FunctionDeclarationWithNoName(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtFunction get() = super.psi as KtFunction } internal class AnonymousFunctionParameterWithDefaultValueImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.AnonymousFunctionParameterWithDefaultValue(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.AnonymousFunctionParameterWithDefaultValue(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtParameter get() = super.psi as KtParameter } internal class UselessVarargOnParameterImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.UselessVarargOnParameter(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.UselessVarargOnParameter(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtParameter get() = super.psi as KtParameter } internal class AbstractPropertyInNonAbstractClassImpl( @@ -955,129 +850,113 @@ internal class AbstractPropertyInNonAbstractClassImpl( override val containingClass: KtSymbol, firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.AbstractPropertyInNonAbstractClass(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.AbstractPropertyInNonAbstractClass(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtModifierListOwner get() = super.psi as KtModifierListOwner } internal class PrivatePropertyInInterfaceImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.PrivatePropertyInInterface(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.PrivatePropertyInInterface(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtProperty get() = super.psi as KtProperty } internal class AbstractPropertyWithInitializerImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.AbstractPropertyWithInitializer(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.AbstractPropertyWithInitializer(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtExpression get() = super.psi as KtExpression } internal class PropertyInitializerInInterfaceImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.PropertyInitializerInInterface(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.PropertyInitializerInInterface(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtExpression get() = super.psi as KtExpression } internal class PropertyWithNoTypeNoInitializerImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.PropertyWithNoTypeNoInitializer(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.PropertyWithNoTypeNoInitializer(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtProperty get() = super.psi as KtProperty } internal class AbstractDelegatedPropertyImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.AbstractDelegatedProperty(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.AbstractDelegatedProperty(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtPropertyDelegate get() = super.psi as KtPropertyDelegate } internal class DelegatedPropertyInInterfaceImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.DelegatedPropertyInInterface(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.DelegatedPropertyInInterface(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtPropertyDelegate get() = super.psi as KtPropertyDelegate } internal class AbstractPropertyWithGetterImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.AbstractPropertyWithGetter(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.AbstractPropertyWithGetter(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtPropertyAccessor get() = super.psi as KtPropertyAccessor } internal class AbstractPropertyWithSetterImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.AbstractPropertyWithSetter(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.AbstractPropertyWithSetter(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtPropertyAccessor get() = super.psi as KtPropertyAccessor } internal class PrivateSetterForAbstractPropertyImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.PrivateSetterForAbstractProperty(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.PrivateSetterForAbstractProperty(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class PrivateSetterForOpenPropertyImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.PrivateSetterForOpenProperty(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.PrivateSetterForOpenProperty(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class ExpectedPrivateDeclarationImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.ExpectedPrivateDeclaration(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.ExpectedPrivateDeclaration(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtModifierListOwner get() = super.psi as KtModifierListOwner } internal class ExpectedDeclarationWithBodyImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.ExpectedDeclarationWithBody(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.ExpectedDeclarationWithBody(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtDeclaration get() = super.psi as KtDeclaration } internal class ExpectedPropertyInitializerImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.ExpectedPropertyInitializer(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.ExpectedPropertyInitializer(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtExpression get() = super.psi as KtExpression } internal class ExpectedDelegatedPropertyImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.ExpectedDelegatedProperty(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.ExpectedDelegatedProperty(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtPropertyDelegate get() = super.psi as KtPropertyDelegate } internal class InitializerRequiredForDestructuringDeclarationImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.InitializerRequiredForDestructuringDeclaration(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.InitializerRequiredForDestructuringDeclaration(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtDestructuringDeclaration get() = super.psi as KtDestructuringDeclaration } internal class ComponentFunctionMissingImpl( @@ -1085,9 +964,8 @@ internal class ComponentFunctionMissingImpl( override val destructingType: KtType, firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.ComponentFunctionMissing(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.ComponentFunctionMissing(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class ComponentFunctionAmbiguityImpl( @@ -1095,18 +973,16 @@ internal class ComponentFunctionAmbiguityImpl( override val candidates: List, firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.ComponentFunctionAmbiguity(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.ComponentFunctionAmbiguity(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class UninitializedVariableImpl( override val variable: KtVariableSymbol, firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.UninitializedVariable(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.UninitializedVariable(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class WrongInvocationKindImpl( @@ -1115,153 +991,134 @@ internal class WrongInvocationKindImpl( override val actualRange: EventOccurrencesRange, firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.WrongInvocationKind(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.WrongInvocationKind(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class LeakedInPlaceLambdaImpl( override val lambda: KtSymbol, firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.LeakedInPlaceLambda(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.LeakedInPlaceLambda(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class WrongImpliesConditionImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.WrongImpliesCondition(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.WrongImpliesCondition(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class RedundantVisibilityModifierImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.RedundantVisibilityModifier(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.RedundantVisibilityModifier(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtModifierListOwner get() = super.psi as KtModifierListOwner } internal class RedundantModalityModifierImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.RedundantModalityModifier(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.RedundantModalityModifier(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtModifierListOwner get() = super.psi as KtModifierListOwner } internal class RedundantReturnUnitTypeImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.RedundantReturnUnitType(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.RedundantReturnUnitType(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiTypeElement get() = super.psi as PsiTypeElement } internal class RedundantExplicitTypeImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.RedundantExplicitType(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.RedundantExplicitType(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class RedundantSingleExpressionStringTemplateImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.RedundantSingleExpressionStringTemplate(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.RedundantSingleExpressionStringTemplate(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class CanBeValImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.CanBeVal(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.CanBeVal(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtDeclaration get() = super.psi as KtDeclaration } internal class CanBeReplacedWithOperatorAssignmentImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.CanBeReplacedWithOperatorAssignment(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.CanBeReplacedWithOperatorAssignment(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtExpression get() = super.psi as KtExpression } internal class RedundantCallOfConversionMethodImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.RedundantCallOfConversionMethod(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.RedundantCallOfConversionMethod(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class ArrayEqualityOperatorCanBeReplacedWithEqualsImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.ArrayEqualityOperatorCanBeReplacedWithEquals(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.ArrayEqualityOperatorCanBeReplacedWithEquals(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtExpression get() = super.psi as KtExpression } internal class EmptyRangeImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.EmptyRange(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.EmptyRange(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class RedundantSetterParameterTypeImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.RedundantSetterParameterType(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.RedundantSetterParameterType(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class UnusedVariableImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.UnusedVariable(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.UnusedVariable(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtNamedDeclaration get() = super.psi as KtNamedDeclaration } internal class AssignedValueIsNeverReadImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.AssignedValueIsNeverRead(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.AssignedValueIsNeverRead(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class VariableInitializerIsRedundantImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.VariableInitializerIsRedundant(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.VariableInitializerIsRedundant(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi } internal class VariableNeverReadImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.VariableNeverRead(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.VariableNeverRead(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: KtNamedDeclaration get() = super.psi as KtNamedDeclaration } internal class UselessCallOnNotNullImpl( firDiagnostic: FirPsiDiagnostic<*>, override val token: ValidityToken, -) : KtFirDiagnostic.UselessCallOnNotNull(), KtAbstractFirDiagnostic { +) : KtFirDiagnostic.UselessCallOnNotNull(), KtAbstractFirDiagnostic { override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic) - override val psi: PsiElement get() = super.psi }