diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt index fcf83fc1503..b6c7d616c0d 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt @@ -26,6 +26,8 @@ import org.jetbrains.kotlin.descriptors.ClassDescriptor import org.jetbrains.kotlin.descriptors.ModuleDescriptor import org.jetbrains.kotlin.descriptors.ScriptDescriptor import org.jetbrains.kotlin.diagnostics.Diagnostic +import org.jetbrains.kotlin.diagnostics.DiagnosticReporter +import org.jetbrains.kotlin.diagnostics.DiagnosticReporterFactory import org.jetbrains.kotlin.diagnostics.DiagnosticSink import org.jetbrains.kotlin.idea.MainFunctionDetector import org.jetbrains.kotlin.load.java.components.JavaDeprecationSettings @@ -69,6 +71,7 @@ class GenerationState private constructor( val jvmBackendClassResolver: JvmBackendClassResolver, val isIrBackend: Boolean, val ignoreErrors: Boolean, + val diagnosticReporter: DiagnosticReporter, ) { class Builder( private val project: Project, @@ -122,12 +125,17 @@ class GenerationState private constructor( fun ignoreErrors(v: Boolean): Builder = apply { ignoreErrors = v } + var diagnosticReporter: DiagnosticReporter? = null + fun diagnosticReporter(v: DiagnosticReporter) = + apply { diagnosticReporter = v } + fun build() = GenerationState( project, builderFactory, module, bindingContext, files, configuration, generateDeclaredClassFilter, codegenFactory, targetId, moduleName, outDirectory, onIndependentPartCompilationEnd, wantsDiagnostics, - jvmBackendClassResolver, isIrBackend, ignoreErrors + jvmBackendClassResolver, isIrBackend, ignoreErrors, + diagnosticReporter ?: DiagnosticReporterFactory.createReporter() ) } diff --git a/compiler/frontend.common/src/org/jetbrains/kotlin/KtSourceElement.kt b/compiler/frontend.common/src/org/jetbrains/kotlin/KtSourceElement.kt index df1c4306d4b..fd605c83a89 100644 --- a/compiler/frontend.common/src/org/jetbrains/kotlin/KtSourceElement.kt +++ b/compiler/frontend.common/src/org/jetbrains/kotlin/KtSourceElement.kt @@ -190,7 +190,7 @@ sealed class KtFakeSourceElementKind : KtSourceElementKind() { object ParameterNameAnnotationCall : KtFakeSourceElementKind() } -abstract class AbstractKtSourceElement { +sealed class AbstractKtSourceElement { abstract val startOffset: Int abstract val endOffset: Int } 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 new file mode 100644 index 00000000000..84ae79c9195 --- /dev/null +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/KtErrorsJvm.kt @@ -0,0 +1,53 @@ +/* + * 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/KtErrors.kt b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/KtErrors.kt new file mode 100644 index 00000000000..ea532af46d4 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/KtErrors.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 + +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 new file mode 100644 index 00000000000..be61579162e --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/KtDefaultErrorMessages.kt @@ -0,0 +1,30 @@ +/* + * 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.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 + +class KtDefaultErrorMessages { + companion object { + + 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) + } + } +} \ 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 new file mode 100644 index 00000000000..1946799d5de --- /dev/null +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/KtDiagnosticReporterWithImplicitIrBasedContext.kt @@ -0,0 +1,63 @@ +/* + * 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 + +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.util.file + +class KtDiagnosticReporterWithImplicitIrBasedContext( + val diagnosticReporter: DiagnosticReporter, + val languageVersionSettings: LanguageVersionSettings +) : DiagnosticReporter() { + override fun report(diagnostic: KtDiagnostic?, context: DiagnosticContext) = diagnosticReporter.report(diagnostic, context) + + fun at(irElement: IrElement, containingIrFile: IrFile): DiagnosticContextOverIr = + DiagnosticContextOverIr(irElement, containingIrFile) + + 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 { + TODO("Not yet implemented") + } + + override val languageVersionSettings: LanguageVersionSettings + get() = this@KtDiagnosticReporterWithImplicitIrBasedContext.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) } + } + } +} + diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/Utils.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/Utils.kt index 219d607b7a2..902146b4cde 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/Utils.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/Utils.kt @@ -16,8 +16,16 @@ package org.jetbrains.kotlin.backend.common +import org.jetbrains.kotlin.AbstractKtSourceElement +import org.jetbrains.kotlin.KtOffsetsOnlySourceElement +import org.jetbrains.kotlin.KtRealPsiSourceElement +import org.jetbrains.kotlin.KtSourceElement +import org.jetbrains.kotlin.backend.common.psi.PsiSourceManager import org.jetbrains.kotlin.ir.IrElement +import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET +import org.jetbrains.kotlin.ir.declarations.IrDeclaration import org.jetbrains.kotlin.ir.declarations.IrFile +import org.jetbrains.kotlin.ir.util.render fun CommonBackendContext.reportWarning(message: String, irFile: IrFile?, irElement: IrElement) { report(irElement, irFile, message, false) @@ -28,3 +36,13 @@ fun MutableList.push(element: E) = this.add(element) fun MutableList.pop() = this.removeAt(size - 1) fun MutableList.peek(): E? = if (size == 0) null else this[size - 1] + +fun findKtSourceElement(irElement: IrElement, irDeclaration: IrDeclaration): KtSourceElement { + val psiElement = PsiSourceManager.findPsiElement(irElement, irDeclaration) + ?: throw AssertionError("No PsiElement found for '${irElement.render()}'") + return KtRealPsiSourceElement(psiElement) +} + +fun IrElement.sourceElement(): AbstractKtSourceElement? = + if (startOffset != UNDEFINED_OFFSET) KtOffsetsOnlySourceElement(this.startOffset, this.endOffset) + else null diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/psi/PsiErrorBuilder.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/psi/PsiErrorBuilder.kt deleted file mode 100644 index 87a6393339c..00000000000 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/psi/PsiErrorBuilder.kt +++ /dev/null @@ -1,72 +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.backend.common.psi - -import com.intellij.psi.PsiElement -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.util.render -import kotlin.reflect.KClass - -class PsiErrorBuilder(private val diagnosticSink: DiagnosticSink) { - fun at(irDeclaration: IrDeclaration, psiElementClass: KClass): Location = - Location( - PsiSourceManager.findPsiElement(irDeclaration, psiElementClass) - ?: throw AssertionError("No ${psiElementClass.simpleName} found for '${irDeclaration.render()}'") - ) - - fun at(irDeclaration: IrDeclaration): Location = - Location( - PsiSourceManager.findPsiElement(irDeclaration) - ?: throw AssertionError("No PsiElement found for '${irDeclaration.render()}'") - ) - - fun at(psiElement: E) = Location(psiElement) - - fun at(irElement: IrElement, irDeclaration: IrDeclaration, psiElementClass: KClass): Location = - Location( - PsiSourceManager.findPsiElement(irElement, irDeclaration, psiElementClass) - ?: throw AssertionError("No ${psiElementClass.simpleName} found for '${irElement.render()}'") - ) - - fun at(irElement: IrElement, irDeclaration: IrDeclaration): Location = - Location( - PsiSourceManager.findPsiElement(irElement, irDeclaration) - ?: throw AssertionError("No PsiElement found for '${irElement.render()}'") - ) - - fun at(irElement: IrElement, irFile: IrFile, psiElementClass: KClass): Location = - Location( - PsiSourceManager.findPsiElement(irElement, irFile, psiElementClass) - ?: throw AssertionError("No ${psiElementClass.simpleName} found for '${irElement.render()}'") - ) - - fun at(irElement: IrElement, irFile: IrFile): Location = - Location( - PsiSourceManager.findPsiElement(irElement, irFile) - ?: throw AssertionError("No PsiElement found for '${irElement.render()}'") - ) - - inner class Location(private val psiElement: E) { - fun report(diagnosticFactory: DiagnosticFactory0) { - diagnosticSink.report(diagnosticFactory.on(psiElement)) - } - - fun report(diagnosticFactory: DiagnosticFactory1, a: A) { - diagnosticSink.report(diagnosticFactory.on(psiElement, a)) - } - - fun report(diagnosticFactory: DiagnosticFactory2, a: A, b: B) { - diagnosticSink.report(diagnosticFactory.on(psiElement, a, b)) - } - - fun report(diagnosticFactory: DiagnosticFactory3, a: A, b: B, c: C) { - diagnosticSink.report(diagnosticFactory.on(psiElement, a, b, c)) - } - } -} diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmBackendContext.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmBackendContext.kt index 7aed65485b8..b974b5bdd1d 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmBackendContext.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmBackendContext.kt @@ -5,12 +5,12 @@ package org.jetbrains.kotlin.backend.jvm +import org.jetbrains.kotlin.KtDiagnosticReporterWithImplicitIrBasedContext import org.jetbrains.kotlin.backend.common.CommonBackendContext import org.jetbrains.kotlin.backend.common.DefaultMapping import org.jetbrains.kotlin.backend.common.Mapping import org.jetbrains.kotlin.backend.common.ir.Ir import org.jetbrains.kotlin.backend.common.phaser.PhaseConfig -import org.jetbrains.kotlin.backend.common.psi.PsiErrorBuilder import org.jetbrains.kotlin.backend.jvm.caches.BridgeLoweringCache import org.jetbrains.kotlin.backend.jvm.caches.CollectionStubComputer import org.jetbrains.kotlin.backend.jvm.codegen.ClassCodegen @@ -71,7 +71,7 @@ class JvmBackendContext( override val mapping: Mapping = DefaultMapping() - val psiErrorBuilder = PsiErrorBuilder(state.diagnostics) + val ktDiagnosticReporter = KtDiagnosticReporterWithImplicitIrBasedContext(state.diagnosticReporter, state.languageVersionSettings) override val ir = JvmIr(irModuleFragment, this.symbolTable) 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 c7ae3e56bb3..cb4b624c4a4 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,6 +5,7 @@ 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,6 +32,7 @@ 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.ir.IrElement import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.declarations.impl.IrFunctionImpl @@ -913,7 +915,7 @@ class ExpressionCodegen( private fun generateGlobalReturnFlagIfPossible(expression: IrExpression, label: String) { if (state.isInlineDisabled) { - context.psiErrorBuilder.at(expression, irFunction).report(Errors.NON_LOCAL_RETURN_IN_DISABLED_INLINE) + context.ktDiagnosticReporter.at(expression, irFunction).report(KtErrors.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 78a060d991e..c36914d8549 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,6 +16,7 @@ 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 @@ -26,7 +27,6 @@ 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.ErrorsJvm.* 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.psiErrorBuilder.at(reportErrorsOn, containingFile).report(TYPEOF_EXTENSION_FUNCTION_TYPE) + context.ktDiagnosticReporter.at(reportErrorsOn, containingFile).report(KtErrors.TYPEOF_EXTENSION_FUNCTION_TYPE) } else if (type.annotations.any { !it.symbol.owner.constructedClass.isSpecialAnnotation() }) { - context.psiErrorBuilder.at(reportErrorsOn, containingFile).report(TYPEOF_ANNOTATED_TYPE) + context.ktDiagnosticReporter.at(reportErrorsOn, containingFile).report(KtErrors.TYPEOF_ANNOTATED_TYPE) } } @@ -131,11 +131,11 @@ class IrInlineIntrinsicsSupport( hasEqualFqName(JvmSymbols.RAW_TYPE_ANNOTATION_FQ_NAME) override fun reportSuspendTypeUnsupported() { - context.psiErrorBuilder.at(reportErrorsOn, containingFile).report(TYPEOF_SUSPEND_TYPE) + context.ktDiagnosticReporter.at(reportErrorsOn, containingFile).report(KtErrors.TYPEOF_SUSPEND_TYPE) } override fun reportNonReifiedTypeParameterWithRecursiveBoundUnsupported(typeParameterName: Name) { - context.psiErrorBuilder.at(reportErrorsOn, containingFile) - .report(TYPEOF_NON_REIFIED_TYPE_PARAMETER_WITH_RECURSIVE_BOUND, typeParameterName.asString()) + context.ktDiagnosticReporter.at(reportErrorsOn, containingFile) + .report(KtErrors.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 46c4a8ca180..70d90623428 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,6 +14,7 @@ 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 @@ -127,9 +128,9 @@ class IrSourceCompilerForInline( // TODO: Find a way to avoid using PSI here override fun reportSuspensionPointInsideMonitor(stackTraceElement: String) { - codegen.context.psiErrorBuilder + codegen.context.ktDiagnosticReporter .at(callElement.symbol.owner as IrDeclaration) - .report(SUSPENSION_POINT_INSIDE_MONITOR, stackTraceElement) + .report(KtErrors.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 bfe95d5c2d2..96c0924345b 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 @@ -5,12 +5,11 @@ package org.jetbrains.kotlin.backend.jvm.codegen -import com.intellij.psi.PsiElement import org.jetbrains.kotlin.backend.common.psi.PsiSourceManager import org.jetbrains.kotlin.backend.jvm.JvmBackendContext import org.jetbrains.kotlin.backend.jvm.JvmLoweredDeclarationOrigin import org.jetbrains.kotlin.descriptors.DescriptorVisibilities -import org.jetbrains.kotlin.diagnostics.DiagnosticFactory1 +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.isFakeOverride @@ -89,7 +88,7 @@ class JvmSignatureClashDetector( realMethodsCount == 0 && (fakeOverridesCount > 1 || specialOverridesCount > 1) -> if (irClass.origin != JvmLoweredDeclarationOrigin.DEFAULT_IMPLS) { reportJvmSignatureClash( - ErrorsJvm.CONFLICTING_INHERITED_JVM_DECLARATIONS, + KtErrorsJvm.CONFLICTING_INHERITED_JVM_DECLARATIONS, listOf(irClass), conflictingJvmDeclarationsData ) @@ -102,7 +101,7 @@ class JvmSignatureClashDetector( methods.any { DescriptorVisibilities.isPrivate(it.visibility) } ) { reportJvmSignatureClash( - ErrorsJvm.CONFLICTING_JVM_DECLARATIONS, + KtErrorsJvm.CONFLICTING_JVM_DECLARATIONS, methods, conflictingJvmDeclarationsData ) @@ -112,7 +111,7 @@ class JvmSignatureClashDetector( else -> if (irClass.origin != JvmLoweredDeclarationOrigin.DEFAULT_IMPLS) { reportJvmSignatureClash( - ErrorsJvm.ACCIDENTAL_OVERRIDE, + KtErrorsJvm.ACCIDENTAL_OVERRIDE, methods.filter { !it.isFakeOverride && !it.isSpecialOverride() }, conflictingJvmDeclarationsData ) @@ -130,7 +129,7 @@ class JvmSignatureClashDetector( type.internalName, classOrigin, predefinedSignature, methods.map { it.getJvmDeclarationOrigin() } + JvmDeclarationOrigin(JvmDeclarationOriginKind.OTHER, null, null) ) - reportJvmSignatureClash(ErrorsJvm.ACCIDENTAL_OVERRIDE, methods, conflictingJvmDeclarationsData) + reportJvmSignatureClash(KtErrorsJvm.ACCIDENTAL_OVERRIDE, methods, conflictingJvmDeclarationsData) } } @@ -138,28 +137,21 @@ class JvmSignatureClashDetector( for ((rawSignature, fields) in fieldsBySignature) { if (fields.size <= 1) continue val conflictingJvmDeclarationsData = getConflictingJvmDeclarationsData(classOrigin, rawSignature, fields) - reportJvmSignatureClash(ErrorsJvm.CONFLICTING_JVM_DECLARATIONS, fields, conflictingJvmDeclarationsData) + reportJvmSignatureClash(KtErrorsJvm.CONFLICTING_JVM_DECLARATIONS, fields, conflictingJvmDeclarationsData) } } private fun reportJvmSignatureClash( - diagnosticFactory1: DiagnosticFactory1, + diagnosticFactory1: KtDiagnosticFactory1, irDeclarations: Collection, conflictingJvmDeclarationsData: ConflictingJvmDeclarationsData ) { - val psiElements = irDeclarations.mapNotNullTo(LinkedHashSet()) { it.getElementForDiagnostics() } - for (psiElement in psiElements) { - context.psiErrorBuilder.at(psiElement) + for (irDeclaration in irDeclarations) { + context.ktDiagnosticReporter.at(irDeclaration) .report(diagnosticFactory1, conflictingJvmDeclarationsData) } } - private fun IrDeclaration.findPsiElement(): PsiElement? = PsiSourceManager.findPsiElement(this) - - private fun IrDeclaration.getElementForDiagnostics(): PsiElement? = - findPsiElement() - ?: irClass.findPsiElement() - private fun getConflictingJvmDeclarationsData( classOrigin: JvmDeclarationOrigin, rawSignature: RawSignature,