diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/FirKotlinToJvmBytecodeCompiler.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/FirKotlinToJvmBytecodeCompiler.kt index abef519fc33..fa11f30aa50 100644 --- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/FirKotlinToJvmBytecodeCompiler.kt +++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/FirKotlinToJvmBytecodeCompiler.kt @@ -24,6 +24,7 @@ import org.jetbrains.kotlin.codegen.CodegenFactory import org.jetbrains.kotlin.codegen.state.GenerationState import org.jetbrains.kotlin.config.* import org.jetbrains.kotlin.diagnostics.DiagnosticReporterFactory +import org.jetbrains.kotlin.diagnostics.impl.BaseDiagnosticReporter import org.jetbrains.kotlin.fir.* import org.jetbrains.kotlin.fir.backend.Fir2IrResult import org.jetbrains.kotlin.fir.backend.jvm.FirJvmBackendClassResolver @@ -127,9 +128,14 @@ object FirKotlinToJvmBytecodeCompiler { if (!checkKotlinPackageUsage(moduleConfiguration, allSources)) return null - val firResult = runFrontend(allSources).also { + val diagnosticsReporter = DiagnosticReporterFactory.createReporter() + val firResult = runFrontend(allSources, diagnosticsReporter).also { performanceManager?.notifyAnalysisFinished() - } ?: return null + } + if (firResult == null) { + FirDiagnosticsCompilerResultsReporter.reportToCollector(diagnosticsReporter, messageCollector) + return null + } performanceManager?.notifyGenerationStarted() performanceManager?.notifyIRTranslationStarted() @@ -143,9 +149,12 @@ object FirKotlinToJvmBytecodeCompiler { allSources, fir2IrResult, extensions, - firResult.session + firResult.session, + diagnosticsReporter ) + FirDiagnosticsCompilerResultsReporter.reportToCollector(diagnosticsReporter, messageCollector) + performanceManager?.notifyIRGenerationFinished() performanceManager?.notifyGenerationFinished() ProgressIndicatorAndCompilationCanceledStatus.checkCanceled() @@ -159,7 +168,7 @@ object FirKotlinToJvmBytecodeCompiler { val fir: List ) - private fun CompilationContext.runFrontend(ktFiles: List): FirResult? { + private fun CompilationContext.runFrontend(ktFiles: List, diagnosticsReporter: BaseDiagnosticReporter): FirResult? { @Suppress("NAME_SHADOWING") var ktFiles = ktFiles val syntaxErrors = ktFiles.fold(false) { errorsFound, ktFile -> @@ -243,7 +252,6 @@ object FirKotlinToJvmBytecodeCompiler { val commonRawFir = commonSession?.buildFirFromKtFiles(commonKtFiles) val rawFir = session.buildFirFromKtFiles(ktFiles) - val diagnosticsReporter = DiagnosticReporterFactory.createReporter() commonSession?.apply { val (commonScopeSession, commonFir) = runResolution(commonRawFir!!) runCheckers(commonScopeSession, commonFir, diagnosticsReporter) @@ -252,9 +260,7 @@ object FirKotlinToJvmBytecodeCompiler { val (scopeSession, fir) = session.runResolution(rawFir) session.runCheckers(scopeSession, fir, diagnosticsReporter) - val hasErrors = FirDiagnosticsCompilerResultsReporter.reportToCollector(diagnosticsReporter, messageCollector) - - return if (syntaxErrors || hasErrors) null else FirResult(session, scopeSession, fir) + return if (syntaxErrors || diagnosticsReporter.hasErrors) null else FirResult(session, scopeSession, fir) } private fun CompilationContext.createComponentsForIncrementalCompilation( @@ -280,7 +286,8 @@ object FirKotlinToJvmBytecodeCompiler { ktFiles: List, fir2IrResult: Fir2IrResult, extensions: JvmGeneratorExtensionsImpl, - session: FirSession + session: FirSession, + diagnosticsReporter: BaseDiagnosticReporter ): GenerationState { val (moduleFragment, symbolTable, components) = fir2IrResult val dummyBindingContext = NoScopeRecordCliBindingTrace().bindingContext @@ -304,6 +311,8 @@ object FirKotlinToJvmBytecodeCompiler { true ).jvmBackendClassResolver( FirJvmBackendClassResolver(components) + ).diagnosticReporter( + diagnosticsReporter ).build() ProgressIndicatorAndCompilationCanceledStatus.checkCanceled() diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.kt index 34e9f456987..e38114c8ad5 100644 --- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.kt +++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.kt @@ -29,6 +29,7 @@ import org.jetbrains.kotlin.backend.jvm.JvmIrCodegenFactory import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys import org.jetbrains.kotlin.cli.common.checkKotlinPackageUsage import org.jetbrains.kotlin.cli.common.config.addKotlinSourceRoot +import org.jetbrains.kotlin.cli.common.fir.FirDiagnosticsCompilerResultsReporter import org.jetbrains.kotlin.cli.common.messages.AnalyzerWithCompilerReport import org.jetbrains.kotlin.cli.common.toLogger import org.jetbrains.kotlin.cli.jvm.config.* @@ -40,6 +41,7 @@ import org.jetbrains.kotlin.config.CommonConfigurationKeys import org.jetbrains.kotlin.config.CompilerConfiguration import org.jetbrains.kotlin.config.JVMConfigurationKeys import org.jetbrains.kotlin.config.languageVersionSettings +import org.jetbrains.kotlin.diagnostics.DiagnosticReporterFactory import org.jetbrains.kotlin.ir.backend.jvm.jvmResolveLibraries import org.jetbrains.kotlin.load.kotlin.ModuleVisibilityManager import org.jetbrains.kotlin.modules.Module @@ -332,6 +334,8 @@ object KotlinToJVMBytecodeCompiler { codegenFactory: CodegenFactory, backendInput: CodegenFactory.BackendInput, ): GenerationState { + val diagnosticsReporter = DiagnosticReporterFactory.createReporter() + val state = GenerationState.Builder( environment.project, ClassBuilderFactories.BINARIES, @@ -343,6 +347,7 @@ object KotlinToJVMBytecodeCompiler { .codegenFactory(codegenFactory) .withModule(module) .onIndependentPartCompilationEnd(createOutputFilesFlushingCallbackIfPossible(configuration)) + .diagnosticReporter(diagnosticsReporter) .build() ProgressIndicatorAndCompilationCanceledStatus.checkCanceled() @@ -370,6 +375,7 @@ object KotlinToJVMBytecodeCompiler { ), environment.messageCollector ) + FirDiagnosticsCompilerResultsReporter.reportToCollector(diagnosticsReporter, environment.messageCollector) ProgressIndicatorAndCompilationCanceledStatus.checkCanceled() return state diff --git a/compiler/frontend.common/src/org/jetbrains/kotlin/diagnostics/DiagnosticReporter.kt b/compiler/frontend.common/src/org/jetbrains/kotlin/diagnostics/DiagnosticReporter.kt index c8e50091994..e846e75b6ec 100644 --- a/compiler/frontend.common/src/org/jetbrains/kotlin/diagnostics/DiagnosticReporter.kt +++ b/compiler/frontend.common/src/org/jetbrains/kotlin/diagnostics/DiagnosticReporter.kt @@ -5,6 +5,7 @@ package org.jetbrains.kotlin.diagnostics +import org.jetbrains.kotlin.AbstractKtSourceElement import org.jetbrains.kotlin.config.LanguageVersionSettings interface DiagnosticContext { @@ -27,3 +28,44 @@ abstract class MutableDiagnosticContext : DiagnosticContext { abstract class DiagnosticReporter { abstract fun report(diagnostic: KtDiagnostic?, context: DiagnosticContext) } + +open class KtDiagnosticReporterWithContext( + val diagnosticReporter: DiagnosticReporter, + val languageVersionSettings: LanguageVersionSettings +) : DiagnosticReporter() { + override fun report(diagnostic: KtDiagnostic?, context: DiagnosticContext) = diagnosticReporter.report(diagnostic, context) + + fun at(sourceElement: AbstractKtSourceElement?, containingFilePath: String): DiagnosticContextImpl = + DiagnosticContextImpl(sourceElement, containingFilePath) + + open inner class DiagnosticContextImpl( + val sourceElement: AbstractKtSourceElement?, + override val containingFilePath: String + ) : DiagnosticContext { + + override fun isDiagnosticSuppressed(diagnostic: KtDiagnostic): Boolean { + return false +// TODO("Not yet implemented") + } + + override val languageVersionSettings: LanguageVersionSettings + get() = this@KtDiagnosticReporterWithContext.languageVersionSettings + + @OptIn(InternalDiagnosticFactoryMethod::class) + fun report( + factory: KtDiagnosticFactory0, + positioningStrategy: AbstractSourceElementPositioningStrategy? = null + ) { + sourceElement?.let { report(factory.on(it, positioningStrategy), this) } + } + + @OptIn(InternalDiagnosticFactoryMethod::class) + fun report( + factory: KtDiagnosticFactory1, + a: A, + positioningStrategy: AbstractSourceElementPositioningStrategy? = null + ) { + sourceElement?.let { report(factory.on(it, a, positioningStrategy), this) } + } + } +} \ No newline at end of file diff --git a/compiler/frontend.common/src/org/jetbrains/kotlin/diagnostics/impl/BaseDiagnosticReporter.kt b/compiler/frontend.common/src/org/jetbrains/kotlin/diagnostics/impl/BaseDiagnosticReporter.kt index b64d70a5a5a..3039ecd09be 100644 --- a/compiler/frontend.common/src/org/jetbrains/kotlin/diagnostics/impl/BaseDiagnosticReporter.kt +++ b/compiler/frontend.common/src/org/jetbrains/kotlin/diagnostics/impl/BaseDiagnosticReporter.kt @@ -11,4 +11,5 @@ import org.jetbrains.kotlin.diagnostics.KtDiagnostic abstract class BaseDiagnosticReporter : DiagnosticReporter() { abstract val diagnostics: List abstract val diagnosticsByFilePath: Map> + abstract val hasErrors: Boolean } diff --git a/compiler/frontend.common/src/org/jetbrains/kotlin/diagnostics/impl/DiagnosticReporterWithSuppress.kt b/compiler/frontend.common/src/org/jetbrains/kotlin/diagnostics/impl/DiagnosticReporterWithSuppress.kt index 25b3e1f214f..0caa49ee02b 100644 --- a/compiler/frontend.common/src/org/jetbrains/kotlin/diagnostics/impl/DiagnosticReporterWithSuppress.kt +++ b/compiler/frontend.common/src/org/jetbrains/kotlin/diagnostics/impl/DiagnosticReporterWithSuppress.kt @@ -7,6 +7,7 @@ package org.jetbrains.kotlin.diagnostics.impl import org.jetbrains.kotlin.diagnostics.DiagnosticContext import org.jetbrains.kotlin.diagnostics.KtDiagnostic +import org.jetbrains.kotlin.diagnostics.Severity class DiagnosticReporterWithSuppress : BaseDiagnosticReporter() { private val _diagnosticsByFilePath: MutableMap> = mutableMapOf() @@ -15,10 +16,17 @@ class DiagnosticReporterWithSuppress : BaseDiagnosticReporter() { override val diagnosticsByFilePath: Map> get() = _diagnosticsByFilePath + override var hasErrors = false + private set + override fun report(diagnostic: KtDiagnostic?, context: DiagnosticContext) { - if (diagnostic == null) return - if (!context.isDiagnosticSuppressed(diagnostic)) { - _diagnosticsByFilePath.getOrPut(context.containingFilePath) { mutableListOf() }.add(diagnostic) + if (diagnostic != null && !context.isDiagnosticSuppressed(diagnostic)) { + _diagnosticsByFilePath.getOrPut(context.containingFilePath) { mutableListOf() }.run { + add(diagnostic) + if (!hasErrors && diagnostic.severity == Severity.ERROR) { + hasErrors = true + } + } } } } diff --git a/compiler/frontend.common/src/org/jetbrains/kotlin/diagnostics/impl/SimpleDiagnosticReporter.kt b/compiler/frontend.common/src/org/jetbrains/kotlin/diagnostics/impl/SimpleDiagnosticReporter.kt index 55b3a25fe8b..8d241605bf2 100644 --- a/compiler/frontend.common/src/org/jetbrains/kotlin/diagnostics/impl/SimpleDiagnosticReporter.kt +++ b/compiler/frontend.common/src/org/jetbrains/kotlin/diagnostics/impl/SimpleDiagnosticReporter.kt @@ -7,6 +7,7 @@ package org.jetbrains.kotlin.diagnostics.impl import org.jetbrains.kotlin.diagnostics.DiagnosticContext import org.jetbrains.kotlin.diagnostics.KtDiagnostic +import org.jetbrains.kotlin.diagnostics.Severity class SimpleDiagnosticReporter : BaseDiagnosticReporter() { private val _diagnosticsByFilePath: MutableMap> = mutableMapOf() @@ -15,8 +16,17 @@ class SimpleDiagnosticReporter : BaseDiagnosticReporter() { override val diagnosticsByFilePath: Map> get() = _diagnosticsByFilePath + override var hasErrors = false + private set + override fun report(diagnostic: KtDiagnostic?, context: DiagnosticContext) { - if (diagnostic == null) return - _diagnosticsByFilePath.getOrPut(context.containingFilePath) { mutableListOf() }.add(diagnostic) + if (diagnostic != null) { + _diagnosticsByFilePath.getOrPut(context.containingFilePath) { mutableListOf() }.run { + add(diagnostic) + if (!hasErrors && diagnostic.severity == Severity.ERROR) { + hasErrors = true + } + } + } } } diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/JvmBackendErrors.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/JvmBackendErrors.kt new file mode 100644 index 00000000000..6a53e553457 --- /dev/null +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/JvmBackendErrors.kt @@ -0,0 +1,68 @@ +/* + * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.resolve.jvm.diagnostics + +import com.intellij.psi.PsiElement +import org.jetbrains.kotlin.descriptors.DeclarationDescriptor +import org.jetbrains.kotlin.diagnostics.KtDiagnosticFactoryToRendererMap +import org.jetbrains.kotlin.diagnostics.SourceElementPositioningStrategies.DECLARATION_SIGNATURE_OR_DEFAULT +import org.jetbrains.kotlin.diagnostics.error0 +import org.jetbrains.kotlin.diagnostics.error1 +import org.jetbrains.kotlin.diagnostics.rendering.* +import org.jetbrains.kotlin.diagnostics.rendering.CommonRenderers.STRING +import org.jetbrains.kotlin.resolve.MemberComparator +import org.jetbrains.kotlin.utils.join + +object JvmBackendErrors { + // TODO: slightly different errors of this type exist also in fir checkers, consider unifying + val CONFLICTING_JVM_DECLARATIONS by error1(DECLARATION_SIGNATURE_OR_DEFAULT) + val CONFLICTING_INHERITED_JVM_DECLARATIONS by error1(DECLARATION_SIGNATURE_OR_DEFAULT) + val ACCIDENTAL_OVERRIDE by error1(DECLARATION_SIGNATURE_OR_DEFAULT) + + val TYPEOF_SUSPEND_TYPE by error0() + val TYPEOF_EXTENSION_FUNCTION_TYPE by error0() + val TYPEOF_ANNOTATED_TYPE by error0() + val TYPEOF_NON_REIFIED_TYPE_PARAMETER_WITH_RECURSIVE_BOUND by error1() + + val SUSPENSION_POINT_INSIDE_MONITOR by error1() + + init { + RootDiagnosticRendererFactory.registerFactory(KtDefaultJvmErrorMessages) + } +} + +object KtDefaultJvmErrorMessages : BaseDiagnosticRendererFactory() { + + @JvmField + val CONFLICTING_JVM_DECLARATIONS_DATA = Renderer { + val renderedDescriptors: List = + it.signatureOrigins.mapNotNull( + JvmDeclarationOrigin::descriptor + ).sortedWith(MemberComparator.INSTANCE) + val renderingContext: RenderingContext = + RenderingContext.Impl(renderedDescriptors) + """ + The following declarations have the same JVM signature (${it.signature.name}${it.signature.desc}): + + """.trimIndent() + + join(renderedDescriptors.map { descriptor: DeclarationDescriptor? -> + " " + Renderers.WITHOUT_MODIFIERS.render( + descriptor!!, renderingContext + ) + }, "\n") + } + + override val MAP = KtDiagnosticFactoryToRendererMap("KT").also { map -> + map.put(JvmBackendErrors.CONFLICTING_JVM_DECLARATIONS, "Platform declaration clash: {0}", CONFLICTING_JVM_DECLARATIONS_DATA) + map.put(JvmBackendErrors.ACCIDENTAL_OVERRIDE, "Accidental override: {0}", CONFLICTING_JVM_DECLARATIONS_DATA) + map.put(JvmBackendErrors.CONFLICTING_INHERITED_JVM_DECLARATIONS, "Inherited platform declarations clash: {0}", CONFLICTING_JVM_DECLARATIONS_DATA) + map.put(JvmBackendErrors.TYPEOF_SUSPEND_TYPE, "Suspend functional types are not supported in typeOf") + map.put(JvmBackendErrors.TYPEOF_EXTENSION_FUNCTION_TYPE, "Extension function types are not supported in typeOf") + map.put(JvmBackendErrors.TYPEOF_ANNOTATED_TYPE, "Annotated types are not supported in typeOf") + map.put(JvmBackendErrors.TYPEOF_NON_REIFIED_TYPE_PARAMETER_WITH_RECURSIVE_BOUND, "Non-reified type parameters with recursive bounds are not supported yet: {0}", STRING) + map.put(JvmBackendErrors.SUSPENSION_POINT_INSIDE_MONITOR, "A suspension point at {0} is inside a critical section", STRING) + } +} diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/KtErrorsJvm.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/KtErrorsJvm.kt deleted file mode 100644 index 84ae79c9195..00000000000 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/KtErrorsJvm.kt +++ /dev/null @@ -1,53 +0,0 @@ -/* - * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors. - * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. - */ - -package org.jetbrains.kotlin.resolve.jvm.diagnostics - -import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.descriptors.DeclarationDescriptor -import org.jetbrains.kotlin.diagnostics.KtDiagnosticFactoryToRendererMap -import org.jetbrains.kotlin.diagnostics.error1 -import org.jetbrains.kotlin.diagnostics.rendering.Renderer -import org.jetbrains.kotlin.diagnostics.rendering.Renderers -import org.jetbrains.kotlin.diagnostics.rendering.RenderingContext -import org.jetbrains.kotlin.resolve.MemberComparator -import org.jetbrains.kotlin.utils.join - -object KtErrorsJvm { - // TODO: slightly different errors of this type exist also in fir checkers, consider unifying - val CONFLICTING_JVM_DECLARATIONS by error1() - val CONFLICTING_INHERITED_JVM_DECLARATIONS by error1() - val ACCIDENTAL_OVERRIDE by error1() -} - -class KtDefaultJvmErrorMessages { - companion object { - - @JvmField - val CONFLICTING_JVM_DECLARATIONS_DATA = Renderer { - val renderedDescriptors: List = - it.signatureOrigins.mapNotNull( - JvmDeclarationOrigin::descriptor - ).sortedWith(MemberComparator.INSTANCE) - val renderingContext: RenderingContext = - RenderingContext.Impl(renderedDescriptors) - """ - The following declarations have the same JVM signature (${it.signature.name}${it.signature.desc}): - - """.trimIndent() + - join(renderedDescriptors.map { descriptor: DeclarationDescriptor? -> - " " + Renderers.WITHOUT_MODIFIERS.render( - descriptor!!, renderingContext - ) - }, "\n") - } - - val MAP = KtDiagnosticFactoryToRendererMap("KT").also { map -> - map.put(KtErrorsJvm.CONFLICTING_JVM_DECLARATIONS, "Platform declaration clash: {0}", CONFLICTING_JVM_DECLARATIONS_DATA) - map.put(KtErrorsJvm.ACCIDENTAL_OVERRIDE, "Accidental override: {0}", CONFLICTING_JVM_DECLARATIONS_DATA) - map.put(KtErrorsJvm.CONFLICTING_INHERITED_JVM_DECLARATIONS, "Inherited platform declarations clash: {0}", CONFLICTING_JVM_DECLARATIONS_DATA) - } - } -} diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/BackendErrors.kt b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/BackendErrors.kt new file mode 100644 index 00000000000..905ed8d9c2e --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/BackendErrors.kt @@ -0,0 +1,19 @@ +/* + * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.diagnostics + +import com.intellij.psi.PsiElement +import org.jetbrains.kotlin.diagnostics.rendering.KtDefaultErrorMessages +import org.jetbrains.kotlin.diagnostics.rendering.RootDiagnosticRendererFactory + +object BackendErrors { + + val NON_LOCAL_RETURN_IN_DISABLED_INLINE by error0(SourceElementPositioningStrategies.DEFAULT) // need to reference SourceElementPositioningStrategies at least once to initialize properly + + init { + RootDiagnosticRendererFactory.registerFactory(KtDefaultErrorMessages) + } +} \ No newline at end of file diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/KtErrors.kt b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/KtErrors.kt deleted file mode 100644 index ea532af46d4..00000000000 --- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/KtErrors.kt +++ /dev/null @@ -1,19 +0,0 @@ -/* - * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors. - * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. - */ - -package org.jetbrains.kotlin.diagnostics - -import com.intellij.psi.PsiElement - -object KtErrors { - - val NON_LOCAL_RETURN_IN_DISABLED_INLINE by error0() - val TYPEOF_SUSPEND_TYPE by error0() - val TYPEOF_EXTENSION_FUNCTION_TYPE by error0() - val TYPEOF_ANNOTATED_TYPE by error0() - val TYPEOF_NON_REIFIED_TYPE_PARAMETER_WITH_RECURSIVE_BOUND by error1() - - val SUSPENSION_POINT_INSIDE_MONITOR by error1() -} \ No newline at end of file diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/KtDefaultErrorMessages.kt b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/KtDefaultErrorMessages.kt index be61579162e..849e6bbbce3 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/KtDefaultErrorMessages.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/KtDefaultErrorMessages.kt @@ -5,26 +5,13 @@ package org.jetbrains.kotlin.diagnostics.rendering -import org.jetbrains.kotlin.diagnostics.rendering.CommonRenderers.STRING import org.jetbrains.kotlin.diagnostics.KtDiagnosticFactoryToRendererMap -import org.jetbrains.kotlin.diagnostics.KtErrors.NON_LOCAL_RETURN_IN_DISABLED_INLINE -import org.jetbrains.kotlin.diagnostics.KtErrors.SUSPENSION_POINT_INSIDE_MONITOR -import org.jetbrains.kotlin.diagnostics.KtErrors.TYPEOF_ANNOTATED_TYPE -import org.jetbrains.kotlin.diagnostics.KtErrors.TYPEOF_EXTENSION_FUNCTION_TYPE -import org.jetbrains.kotlin.diagnostics.KtErrors.TYPEOF_NON_REIFIED_TYPE_PARAMETER_WITH_RECURSIVE_BOUND -import org.jetbrains.kotlin.diagnostics.KtErrors.TYPEOF_SUSPEND_TYPE +import org.jetbrains.kotlin.diagnostics.BackendErrors -class KtDefaultErrorMessages { - companion object { +object KtDefaultErrorMessages : BaseDiagnosticRendererFactory() { - val MAP = KtDiagnosticFactoryToRendererMap("KT").also { map -> - map.put(NON_LOCAL_RETURN_IN_DISABLED_INLINE, "Non-local returns are not allowed with inlining disabled") - map.put(TYPEOF_SUSPEND_TYPE, "Suspend functional types are not supported in typeOf") - map.put(TYPEOF_EXTENSION_FUNCTION_TYPE, "Extension function types are not supported in typeOf") - map.put(TYPEOF_ANNOTATED_TYPE, "Annotated types are not supported in typeOf") - map.put(TYPEOF_NON_REIFIED_TYPE_PARAMETER_WITH_RECURSIVE_BOUND, "Non-reified type parameters with recursive bounds are not supported yet: {0}", STRING) - - map.put(SUSPENSION_POINT_INSIDE_MONITOR, "A suspension point at {0} is inside a critical section", STRING) - } + override val MAP = KtDiagnosticFactoryToRendererMap("KT").also { map -> + map.put(BackendErrors.NON_LOCAL_RETURN_IN_DISABLED_INLINE, "Non-local returns are not allowed with inlining disabled") } -} \ No newline at end of file + +} diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/KtDiagnosticReporterWithImplicitIrBasedContext.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/KtDiagnosticReporterWithImplicitIrBasedContext.kt index 87e05713b51..454048d8672 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/KtDiagnosticReporterWithImplicitIrBasedContext.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/KtDiagnosticReporterWithImplicitIrBasedContext.kt @@ -5,64 +5,40 @@ package org.jetbrains.kotlin +import org.jetbrains.kotlin.backend.common.psi.PsiSourceManager import org.jetbrains.kotlin.backend.common.sourceElement import org.jetbrains.kotlin.config.LanguageVersionSettings import org.jetbrains.kotlin.diagnostics.* import org.jetbrains.kotlin.ir.IrElement import org.jetbrains.kotlin.ir.declarations.IrDeclaration import org.jetbrains.kotlin.ir.declarations.IrFile -import org.jetbrains.kotlin.ir.declarations.name import org.jetbrains.kotlin.ir.declarations.path import org.jetbrains.kotlin.ir.util.file class KtDiagnosticReporterWithImplicitIrBasedContext( - val diagnosticReporter: DiagnosticReporter, - val languageVersionSettings: LanguageVersionSettings -) : DiagnosticReporter() { - override fun report(diagnostic: KtDiagnostic?, context: DiagnosticContext) = diagnosticReporter.report(diagnostic, context) + diagnosticReporter: DiagnosticReporter, + languageVersionSettings: LanguageVersionSettings +) : KtDiagnosticReporterWithContext(diagnosticReporter, languageVersionSettings) { - fun at(irElement: IrElement, containingIrFile: IrFile): DiagnosticContextOverIr = - DiagnosticContextOverIr(irElement, containingIrFile) + fun at(irElement: IrElement, containingIrFile: IrFile): DiagnosticContextImpl = + at( + PsiSourceManager.findPsiElement(irElement, containingIrFile)?.let(::KtRealPsiSourceElement) + ?: irElement.sourceElement(), + containingIrFile.path + ) - fun at(irElement: IrElement, containingIrDeclaration: IrDeclaration): DiagnosticContextOverIr = - DiagnosticContextOverIr(irElement, containingIrDeclaration) - - fun at(irDeclaration: IrDeclaration): DiagnosticContextOverIr = - DiagnosticContextOverIr(irDeclaration, irDeclaration) - - @Suppress("UNUSED_PARAMETER") - inner class DiagnosticContextOverIr(irElement: IrElement, containingIrFile: IrFile) : DiagnosticContext { - - constructor(irElement: IrElement, containingIrDeclaration: IrDeclaration): this(irElement, containingIrDeclaration.file) - - val sourceElement = irElement.sourceElement() - - override fun isDiagnosticSuppressed(diagnostic: KtDiagnostic): Boolean { - return false -// TODO("Not yet implemented") - } - - override val languageVersionSettings: LanguageVersionSettings - get() = this@KtDiagnosticReporterWithImplicitIrBasedContext.languageVersionSettings - - override val containingFilePath: String = containingIrFile.path - - @OptIn(InternalDiagnosticFactoryMethod::class) - fun report( - factory: KtDiagnosticFactory0, - positioningStrategy: AbstractSourceElementPositioningStrategy? = null - ) { - sourceElement?.let { report(factory.on(it, positioningStrategy), this) } - } - - @OptIn(InternalDiagnosticFactoryMethod::class) - fun report( - factory: KtDiagnosticFactory1, - a: A, - positioningStrategy: AbstractSourceElementPositioningStrategy? = null - ) { - sourceElement?.let { report(factory.on(it, a, positioningStrategy), this) } - } + fun atFirstValidFrom(vararg irElements: IrElement, containingIrFile: IrFile): DiagnosticContextImpl { + require(irElements.isNotEmpty()) + val sourceElement = + irElements.firstNotNullOfOrNull { PsiSourceManager.findPsiElement(it, containingIrFile) }?.let(::KtRealPsiSourceElement) + ?: (irElements.find { it.startOffset >= 0 } ?: irElements.first()).sourceElement() + return at(sourceElement, containingIrFile.path) } + + fun at(irElement: IrElement, containingIrDeclaration: IrDeclaration): DiagnosticContextImpl = + at(irElement, containingIrDeclaration.file) + + fun at(irDeclaration: IrDeclaration): DiagnosticContextImpl = + at(irDeclaration, irDeclaration) } diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt index cb4b624c4a4..da6e7b5384a 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt @@ -5,7 +5,6 @@ package org.jetbrains.kotlin.backend.jvm.codegen -import org.jetbrains.kotlin.backend.common.findKtSourceElement import org.jetbrains.kotlin.backend.common.lower.BOUND_RECEIVER_PARAMETER import org.jetbrains.kotlin.backend.common.lower.LoweredStatementOrigins import org.jetbrains.kotlin.backend.jvm.* @@ -31,8 +30,7 @@ import org.jetbrains.kotlin.codegen.signature.BothSignatureWriter import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.config.languageVersionSettings import org.jetbrains.kotlin.descriptors.DescriptorVisibilities -import org.jetbrains.kotlin.diagnostics.Errors -import org.jetbrains.kotlin.diagnostics.KtErrors +import org.jetbrains.kotlin.diagnostics.BackendErrors import org.jetbrains.kotlin.ir.IrElement import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.declarations.impl.IrFunctionImpl @@ -915,7 +913,7 @@ class ExpressionCodegen( private fun generateGlobalReturnFlagIfPossible(expression: IrExpression, label: String) { if (state.isInlineDisabled) { - context.ktDiagnosticReporter.at(expression, irFunction).report(KtErrors.NON_LOCAL_RETURN_IN_DISABLED_INLINE) + context.ktDiagnosticReporter.at(expression, irFunction).report(BackendErrors.NON_LOCAL_RETURN_IN_DISABLED_INLINE) genThrow(mv, "java/lang/UnsupportedOperationException", "Non-local returns are not allowed with inlining disabled") } else { generateGlobalReturnFlag(mv, label) diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/IrInlineIntrinsicsSupport.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/IrInlineIntrinsicsSupport.kt index c36914d8549..381c91ffc0e 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/IrInlineIntrinsicsSupport.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/IrInlineIntrinsicsSupport.kt @@ -16,7 +16,6 @@ import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMap import org.jetbrains.kotlin.codegen.AsmUtil import org.jetbrains.kotlin.codegen.inline.ReifiedTypeInliner import org.jetbrains.kotlin.codegen.state.GenerationState -import org.jetbrains.kotlin.diagnostics.KtErrors import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.descriptors.toIrBasedKotlinType import org.jetbrains.kotlin.ir.expressions.IrExpression @@ -27,6 +26,7 @@ import org.jetbrains.kotlin.ir.util.* import org.jetbrains.kotlin.load.java.JvmAnnotationNames import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.resolve.jvm.AsmTypes.* +import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmBackendErrors import org.jetbrains.kotlin.types.KotlinType import org.jetbrains.kotlin.types.model.TypeParameterMarker import org.jetbrains.org.objectweb.asm.Type @@ -117,9 +117,9 @@ class IrInlineIntrinsicsSupport( override fun checkAnnotatedType(type: IrType) { if (type.hasAnnotation(StandardNames.FqNames.extensionFunctionType)) { - context.ktDiagnosticReporter.at(reportErrorsOn, containingFile).report(KtErrors.TYPEOF_EXTENSION_FUNCTION_TYPE) + context.ktDiagnosticReporter.at(reportErrorsOn, containingFile).report(JvmBackendErrors.TYPEOF_EXTENSION_FUNCTION_TYPE) } else if (type.annotations.any { !it.symbol.owner.constructedClass.isSpecialAnnotation() }) { - context.ktDiagnosticReporter.at(reportErrorsOn, containingFile).report(KtErrors.TYPEOF_ANNOTATED_TYPE) + context.ktDiagnosticReporter.at(reportErrorsOn, containingFile).report(JvmBackendErrors.TYPEOF_ANNOTATED_TYPE) } } @@ -131,11 +131,11 @@ class IrInlineIntrinsicsSupport( hasEqualFqName(JvmSymbols.RAW_TYPE_ANNOTATION_FQ_NAME) override fun reportSuspendTypeUnsupported() { - context.ktDiagnosticReporter.at(reportErrorsOn, containingFile).report(KtErrors.TYPEOF_SUSPEND_TYPE) + context.ktDiagnosticReporter.at(reportErrorsOn, containingFile).report(JvmBackendErrors.TYPEOF_SUSPEND_TYPE) } override fun reportNonReifiedTypeParameterWithRecursiveBoundUnsupported(typeParameterName: Name) { context.ktDiagnosticReporter.at(reportErrorsOn, containingFile) - .report(KtErrors.TYPEOF_NON_REIFIED_TYPE_PARAMETER_WITH_RECURSIVE_BOUND, typeParameterName.asString()) + .report(JvmBackendErrors.TYPEOF_NON_REIFIED_TYPE_PARAMETER_WITH_RECURSIVE_BOUND, typeParameterName.asString()) } } diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/IrSourceCompilerForInline.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/IrSourceCompilerForInline.kt index 70d90623428..4d8e77ee8b1 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/IrSourceCompilerForInline.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/IrSourceCompilerForInline.kt @@ -14,7 +14,6 @@ import org.jetbrains.kotlin.backend.jvm.ir.inlineScopeVisibility import org.jetbrains.kotlin.codegen.inline.* import org.jetbrains.kotlin.codegen.state.GenerationState import org.jetbrains.kotlin.diagnostics.DiagnosticUtils -import org.jetbrains.kotlin.diagnostics.KtErrors import org.jetbrains.kotlin.incremental.components.LocationInfo import org.jetbrains.kotlin.incremental.components.Position import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI @@ -28,7 +27,7 @@ import org.jetbrains.kotlin.ir.util.kotlinFqName import org.jetbrains.kotlin.ir.util.module import org.jetbrains.kotlin.ir.util.parentAsClass import org.jetbrains.kotlin.psi.doNotAnalyze -import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm.SUSPENSION_POINT_INSIDE_MONITOR +import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmBackendErrors import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature import org.jetbrains.org.objectweb.asm.Label import org.jetbrains.org.objectweb.asm.Type @@ -130,7 +129,7 @@ class IrSourceCompilerForInline( override fun reportSuspensionPointInsideMonitor(stackTraceElement: String) { codegen.context.ktDiagnosticReporter .at(callElement.symbol.owner as IrDeclaration) - .report(KtErrors.SUSPENSION_POINT_INSIDE_MONITOR, stackTraceElement) + .report(JvmBackendErrors.SUSPENSION_POINT_INSIDE_MONITOR, stackTraceElement) } } diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/JvmSignatureClashDetector.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/JvmSignatureClashDetector.kt index 96c0924345b..0ac3b7b8fa2 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/JvmSignatureClashDetector.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/JvmSignatureClashDetector.kt @@ -12,6 +12,7 @@ import org.jetbrains.kotlin.descriptors.DescriptorVisibilities import org.jetbrains.kotlin.diagnostics.KtDiagnosticFactory1 import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.descriptors.toIrBasedDescriptor +import org.jetbrains.kotlin.ir.util.file import org.jetbrains.kotlin.ir.util.isFakeOverride import org.jetbrains.kotlin.resolve.jvm.diagnostics.* import org.jetbrains.kotlin.utils.SmartSet @@ -88,7 +89,7 @@ class JvmSignatureClashDetector( realMethodsCount == 0 && (fakeOverridesCount > 1 || specialOverridesCount > 1) -> if (irClass.origin != JvmLoweredDeclarationOrigin.DEFAULT_IMPLS) { reportJvmSignatureClash( - KtErrorsJvm.CONFLICTING_INHERITED_JVM_DECLARATIONS, + JvmBackendErrors.CONFLICTING_INHERITED_JVM_DECLARATIONS, listOf(irClass), conflictingJvmDeclarationsData ) @@ -101,7 +102,7 @@ class JvmSignatureClashDetector( methods.any { DescriptorVisibilities.isPrivate(it.visibility) } ) { reportJvmSignatureClash( - KtErrorsJvm.CONFLICTING_JVM_DECLARATIONS, + JvmBackendErrors.CONFLICTING_JVM_DECLARATIONS, methods, conflictingJvmDeclarationsData ) @@ -111,7 +112,7 @@ class JvmSignatureClashDetector( else -> if (irClass.origin != JvmLoweredDeclarationOrigin.DEFAULT_IMPLS) { reportJvmSignatureClash( - KtErrorsJvm.ACCIDENTAL_OVERRIDE, + JvmBackendErrors.ACCIDENTAL_OVERRIDE, methods.filter { !it.isFakeOverride && !it.isSpecialOverride() }, conflictingJvmDeclarationsData ) @@ -129,7 +130,7 @@ class JvmSignatureClashDetector( type.internalName, classOrigin, predefinedSignature, methods.map { it.getJvmDeclarationOrigin() } + JvmDeclarationOrigin(JvmDeclarationOriginKind.OTHER, null, null) ) - reportJvmSignatureClash(KtErrorsJvm.ACCIDENTAL_OVERRIDE, methods, conflictingJvmDeclarationsData) + reportJvmSignatureClash(JvmBackendErrors.ACCIDENTAL_OVERRIDE, methods, conflictingJvmDeclarationsData) } } @@ -137,7 +138,7 @@ class JvmSignatureClashDetector( for ((rawSignature, fields) in fieldsBySignature) { if (fields.size <= 1) continue val conflictingJvmDeclarationsData = getConflictingJvmDeclarationsData(classOrigin, rawSignature, fields) - reportJvmSignatureClash(KtErrorsJvm.CONFLICTING_JVM_DECLARATIONS, fields, conflictingJvmDeclarationsData) + reportJvmSignatureClash(JvmBackendErrors.CONFLICTING_JVM_DECLARATIONS, fields, conflictingJvmDeclarationsData) } } @@ -147,7 +148,7 @@ class JvmSignatureClashDetector( conflictingJvmDeclarationsData: ConflictingJvmDeclarationsData ) { for (irDeclaration in irDeclarations) { - context.ktDiagnosticReporter.at(irDeclaration) + context.ktDiagnosticReporter.atFirstValidFrom(irDeclaration, irClass, containingIrFile = irDeclaration.file) .report(diagnosticFactory1, conflictingJvmDeclarationsData) } }