Report IR errors via new diagnostic infrastructure

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()
             )
     }
 

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
 }

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<PsiElement, ConflictingJvmDeclarationsData>()
+    val CONFLICTING_INHERITED_JVM_DECLARATIONS by error1<PsiElement, ConflictingJvmDeclarationsData>()
+    val ACCIDENTAL_OVERRIDE by error1<PsiElement, ConflictingJvmDeclarationsData>()
+}
+
+class KtDefaultJvmErrorMessages {
+    companion object {
+
+        @JvmField
+        val CONFLICTING_JVM_DECLARATIONS_DATA = Renderer<ConflictingJvmDeclarationsData> {
+            val renderedDescriptors: List<DeclarationDescriptor?> =
+                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)
+        }
+    }
+}

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<PsiElement>()
+    val TYPEOF_SUSPEND_TYPE by error0<PsiElement>()
+    val TYPEOF_EXTENSION_FUNCTION_TYPE by error0<PsiElement>()
+    val TYPEOF_ANNOTATED_TYPE by error0<PsiElement>()
+    val TYPEOF_NON_REIFIED_TYPE_PARAMETER_WITH_RECURSIVE_BOUND by error1<PsiElement, String>()
+
+    val SUSPENSION_POINT_INSIDE_MONITOR by error1<PsiElement, String>()
+}

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)
+        }
+    }
+}

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 <A : Any> report(
+            factory: KtDiagnosticFactory1<A>,
+            a: A,
+            positioningStrategy: AbstractSourceElementPositioningStrategy? = null
+        ) {
+            sourceElement?.let { report(factory.on(it, a, positioningStrategy), this) }
+        }
+    }
+}
+

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 <E> MutableList<E>.push(element: E) = this.add(element)
 fun <E> MutableList<E>.pop() = this.removeAt(size - 1)
 
 fun <E> MutableList<E>.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

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/psi/PsiErrorBuilder.kt

@@ -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 <E : PsiElement> at(irDeclaration: IrDeclaration, psiElementClass: KClass<E>): Location<E> =
-        Location(
-            PsiSourceManager.findPsiElement(irDeclaration, psiElementClass)
-                ?: throw AssertionError("No ${psiElementClass.simpleName} found for '${irDeclaration.render()}'")
-        )
-
-    fun at(irDeclaration: IrDeclaration): Location<PsiElement> =
-        Location(
-            PsiSourceManager.findPsiElement(irDeclaration)
-                ?: throw AssertionError("No PsiElement found for '${irDeclaration.render()}'")
-        )
-
-    fun <E : PsiElement> at(psiElement: E) = Location(psiElement)
-
-    fun <E : PsiElement> at(irElement: IrElement, irDeclaration: IrDeclaration, psiElementClass: KClass<E>): Location<E> =
-        Location(
-            PsiSourceManager.findPsiElement(irElement, irDeclaration, psiElementClass)
-                ?: throw AssertionError("No ${psiElementClass.simpleName} found for '${irElement.render()}'")
-        )
-
-    fun at(irElement: IrElement, irDeclaration: IrDeclaration): Location<PsiElement> =
-        Location(
-            PsiSourceManager.findPsiElement(irElement, irDeclaration)
-                ?: throw AssertionError("No PsiElement found for '${irElement.render()}'")
-        )
-
-    fun <E : PsiElement> at(irElement: IrElement, irFile: IrFile, psiElementClass: KClass<E>): Location<E> =
-        Location(
-            PsiSourceManager.findPsiElement(irElement, irFile, psiElementClass)
-                ?: throw AssertionError("No ${psiElementClass.simpleName} found for '${irElement.render()}'")
-        )
-
-    fun at(irElement: IrElement, irFile: IrFile): Location<PsiElement> =
-        Location(
-            PsiSourceManager.findPsiElement(irElement, irFile)
-                ?: throw AssertionError("No PsiElement found for '${irElement.render()}'")
-        )
-
-    inner class Location<E : PsiElement>(private val psiElement: E) {
-        fun report(diagnosticFactory: DiagnosticFactory0<E>) {
-            diagnosticSink.report(diagnosticFactory.on(psiElement))
-        }
-
-        fun <A : Any> report(diagnosticFactory: DiagnosticFactory1<E, A>, a: A) {
-            diagnosticSink.report(diagnosticFactory.on(psiElement, a))
-        }
-
-        fun <A : Any, B : Any> report(diagnosticFactory: DiagnosticFactory2<E, A, B>, a: A, b: B) {
-            diagnosticSink.report(diagnosticFactory.on(psiElement, a, b))
-        }
-
-        fun <A : Any, B : Any, C : Any> report(diagnosticFactory: DiagnosticFactory3<E, A, B, C>, a: A, b: B, c: C) {
-            diagnosticSink.report(diagnosticFactory.on(psiElement, a, b, c))
-        }
-    }
-}

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)
 

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)

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)
+        context.ktDiagnosticReporter.at(reportErrorsOn, containingFile)
-            .report(TYPEOF_NON_REIFIED_TYPE_PARAMETER_WITH_RECURSIVE_BOUND, typeParameterName.asString())
+            .report(KtErrors.TYPEOF_NON_REIFIED_TYPE_PARAMETER_WITH_RECURSIVE_BOUND, typeParameterName.asString())
     }
 }

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)
     }
 }
 

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<PsiElement, ConflictingJvmDeclarationsData>,
+        diagnosticFactory1: KtDiagnosticFactory1<ConflictingJvmDeclarationsData>,
         irDeclarations: Collection<IrDeclaration>,
         conflictingJvmDeclarationsData: ConflictingJvmDeclarationsData
     ) {
-        val psiElements = irDeclarations.mapNotNullTo(LinkedHashSet()) { it.getElementForDiagnostics() }
+        for (irDeclaration in irDeclarations) {
-        for (psiElement in psiElements) {
+            context.ktDiagnosticReporter.at(irDeclaration)
-            context.psiErrorBuilder.at(psiElement)
                 .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,