Report JVM signature clashes from JVM_IR

Also:

* Do not rename public ABI fields
This includes backing fields for const, lateinit, @JvmField properties,
and instance fields for objects.

* FAKE_OVERRIDE declarations for static members of parent Java classes
Required to report cases when a Kotlin function accidentally overrides
Java class member.

compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt

@@ -185,7 +185,7 @@ class GenerationState private constructor(
 
     val diagnostics: DiagnosticSink get() = extraJvmDiagnosticsTrace
     val collectedExtraJvmDiagnostics: Diagnostics = LazyJvmDiagnostics {
-        duplicateSignatureFactory.reportDiagnostics()
+        duplicateSignatureFactory?.reportDiagnostics()
         extraJvmDiagnosticsTrace.bindingContext.diagnostics
     }
 
@@ -221,7 +221,7 @@ class GenerationState private constructor(
     val mappingsClassesForWhenByEnum: MappingsClassesForWhenByEnum = MappingsClassesForWhenByEnum(this)
     val jvmRuntimeTypes: JvmRuntimeTypes = JvmRuntimeTypes(module, configuration.languageVersionSettings)
     val factory: ClassFileFactory
-    private lateinit var duplicateSignatureFactory: BuilderFactoryForDuplicateSignatureDiagnostics
+    private var duplicateSignatureFactory: BuilderFactoryForDuplicateSignatureDiagnostics? = null
 
     val scriptSpecific = ForScript()
 
@@ -284,11 +284,16 @@ class GenerationState private constructor(
                         it
                 },
                 {
-                    BuilderFactoryForDuplicateSignatureDiagnostics(
-                        it, this.bindingContext, diagnostics, this.moduleName, this.languageVersionSettings,
-                        shouldGenerate = { !shouldOnlyCollectSignatures(it) },
-                        mapAsmMethod = if (isIrBackend) { descriptor: FunctionDescriptor -> irBasedMapAsmMethod(descriptor) } else null
-                    ).apply { duplicateSignatureFactory = this }
+                    // In IR backend, we have more precise information about classes and methods we are going to generate,
+                    // and report signature conflict errors in JvmSignatureClashTracker.
+                    if (isIrBackend)
+                        it
+                    else
+                        BuilderFactoryForDuplicateSignatureDiagnostics(
+                            it, this.bindingContext, diagnostics, this.moduleName, this.languageVersionSettings,
+                            shouldGenerate = { origin -> !shouldOnlyCollectSignatures(origin) },
+                            mapAsmMethod = if (isIrBackend) { descriptor: FunctionDescriptor -> irBasedMapAsmMethod(descriptor) } else null
+                        ).apply { duplicateSignatureFactory = this }
                 },
                 { BuilderFactoryForDuplicateClassNameDiagnostics(it, diagnostics) },
                 {

compiler/fir/fir2ir/tests/org/jetbrains/kotlin/fir/Fir2IrTextTestGenerated.java

@@ -131,6 +131,11 @@ public class Fir2IrTextTestGenerated extends AbstractFir2IrTextTest {
             runTest("compiler/testData/ir/irText/classes/enumWithSecondaryCtor.kt");
         }
 
+        @TestMetadata("fakeOverridesForJavaStaticMembers.kt")
+        public void testFakeOverridesForJavaStaticMembers() throws Exception {
+            runTest("compiler/testData/ir/irText/classes/fakeOverridesForJavaStaticMembers.kt");
+        }
+
         @TestMetadata("implicitNotNullOnDelegatedImplementation.kt")
         public void testImplicitNotNullOnDelegatedImplementation() throws Exception {
             runTest("compiler/testData/ir/irText/classes/implicitNotNullOnDelegatedImplementation.kt");

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/jvmSignature/JvmMethodGenericSignature.java

@@ -22,6 +22,7 @@ import org.jetbrains.org.objectweb.asm.Type;
 import org.jetbrains.org.objectweb.asm.commons.Method;
 
 import java.util.List;
+import java.util.Objects;
 
 public class JvmMethodGenericSignature extends JvmMethodSignature {
     private final String genericsSignature;
@@ -47,8 +48,7 @@ public class JvmMethodGenericSignature extends JvmMethodSignature {
 
         JvmMethodGenericSignature that = (JvmMethodGenericSignature) o;
 
-        return super.equals(that) &&
-               (genericsSignature == null ? that.genericsSignature == null : genericsSignature.equals(that.genericsSignature));
+        return super.equals(that) && Objects.equals(genericsSignature, that.genericsSignature);
     }
 
     @Override

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmGeneratorExtensions.kt

@@ -7,10 +7,7 @@ package org.jetbrains.kotlin.backend.jvm
 
 import org.jetbrains.kotlin.backend.common.ir.createParameterDeclarations
 import org.jetbrains.kotlin.codegen.SamType
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
-import org.jetbrains.kotlin.descriptors.PropertyDescriptor
-import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
-import org.jetbrains.kotlin.descriptors.Visibility
+import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.annotations.FilteredAnnotations
 import org.jetbrains.kotlin.ir.builders.declarations.buildClass
 import org.jetbrains.kotlin.ir.declarations.IrClass
@@ -18,12 +15,14 @@ import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
 import org.jetbrains.kotlin.load.java.JvmAnnotationNames
 import org.jetbrains.kotlin.load.java.descriptors.JavaCallableMemberDescriptor
 import org.jetbrains.kotlin.load.java.descriptors.JavaClassDescriptor
+import org.jetbrains.kotlin.load.java.descriptors.getParentJavaStaticClassScope
 import org.jetbrains.kotlin.load.java.sam.JavaSingleAbstractMethodUtils
 import org.jetbrains.kotlin.load.java.typeEnhancement.hasEnhancedNullability
 import org.jetbrains.kotlin.load.kotlin.JvmPackagePartSource
 import org.jetbrains.kotlin.psi2ir.generators.GeneratorExtensions
 import org.jetbrains.kotlin.resolve.jvm.JvmClassName
 import org.jetbrains.kotlin.resolve.jvm.annotations.hasJvmFieldAnnotation
+import org.jetbrains.kotlin.resolve.scopes.MemberScope
 import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedContainerSource
 import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.types.typeUtil.replaceAnnotations
@@ -92,4 +91,7 @@ class JvmGeneratorExtensions(private val generateFacades: Boolean = true) : Gene
 
         companion object Instance : JvmEnhancedNullability()
     }
+
+    override fun getParentClassStaticScope(descriptor: ClassDescriptor): MemberScope? =
+        descriptor.getParentJavaStaticClassScope()
 }

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/ClassCodegen.kt

@@ -18,6 +18,7 @@ import org.jetbrains.kotlin.codegen.inline.ReifiedTypeParametersUsages
 import org.jetbrains.kotlin.codegen.inline.SourceMapper
 import org.jetbrains.kotlin.codegen.serialization.JvmSerializationBindings
 import org.jetbrains.kotlin.codegen.serialization.JvmSerializerExtension
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.ir.builders.declarations.buildFun
@@ -40,8 +41,7 @@ import org.jetbrains.kotlin.resolve.jvm.annotations.JVM_SYNTHETIC_ANNOTATION_FQ_
 import org.jetbrains.kotlin.resolve.jvm.annotations.TRANSIENT_ANNOTATION_FQ_NAME
 import org.jetbrains.kotlin.resolve.jvm.annotations.VOLATILE_ANNOTATION_FQ_NAME
 import org.jetbrains.kotlin.resolve.jvm.checkers.JvmSimpleNameBacktickChecker
-import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin
-import org.jetbrains.kotlin.resolve.jvm.diagnostics.OtherOrigin
+import org.jetbrains.kotlin.resolve.jvm.diagnostics.*
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmClassSignature
 import org.jetbrains.kotlin.serialization.DescriptorSerializer
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
@@ -68,6 +68,9 @@ open class ClassCodegen protected constructor(
 
     val reifiedTypeParametersUsages = ReifiedTypeParametersUsages()
 
+    private val jvmSignatureClashDetector = JvmSignatureClashDetector(irClass, type, context)
+    private lateinit var classOrigin: JvmDeclarationOrigin
+
     open fun createClassBuilder(): ClassBuilder {
         // The descriptor associated with an IrClass is never modified in lowerings, so it
         // doesn't reflect the state of the lowered class. To make the diagnostics work we
@@ -75,13 +78,24 @@ open class ClassCodegen protected constructor(
         // TODO: Migrate class builders away from descriptors
         val descriptor = WrappedClassDescriptor()
         descriptor.bind(irClass)
+        classOrigin = getClassOrigin(descriptor)
         return state.factory.newVisitor(
-            OtherOrigin(descriptor.psiElement, descriptor),
+            classOrigin,
             type,
             irClass.fileParent.loadSourceFilesInfo()
         )
     }
 
+    private fun getClassOrigin(descriptor: ClassDescriptor): JvmDeclarationOrigin {
+        val psiElement = context.psiSourceManager.findPsiElement(irClass)
+        return when (irClass.origin) {
+            IrDeclarationOrigin.FILE_CLASS ->
+                JvmDeclarationOrigin(JvmDeclarationOriginKind.PACKAGE_PART, psiElement, descriptor)
+            else ->
+                OtherOrigin(psiElement, descriptor)
+        }
+    }
+
     private var sourceMapper: DefaultSourceMapper? = null
 
     private val serializerExtension = JvmSerializerExtension(visitor.serializationBindings, state, typeMapper)
@@ -287,6 +301,8 @@ open class ClassCodegen protected constructor(
             SourceMapper.flushToClassBuilder(it, visitor)
         }
 
+        jvmSignatureClashDetector.reportErrors(classOrigin)
+
         visitor.done()
     }
 
@@ -341,6 +357,8 @@ open class ClassCodegen protected constructor(
             fieldSignature, (field.initializer?.expression as? IrConst<*>)?.value
         )
 
+        jvmSignatureClashDetector.trackField(field, RawSignature(fieldName, fieldType.descriptor, MemberKind.FIELD))
+
         object : AnnotationCodegen(this@ClassCodegen, context) {
             override fun visitAnnotation(descr: String?, visible: Boolean): AnnotationVisitor {
                 return fv.visitAnnotation(descr, visible)
@@ -358,8 +376,9 @@ open class ClassCodegen protected constructor(
     }
 
     private fun generateMethod(method: IrFunction) {
-        if (method.origin == IrDeclarationOrigin.FAKE_OVERRIDE) return
+        jvmSignatureClashDetector.trackMethod(method)
 
+        if (method.origin == IrDeclarationOrigin.FAKE_OVERRIDE) return
         val signature = FunctionCodegen(method, this).generate().asmMethod
 
         when (val metadata = method.metadata) {

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/JvmSignatureClashDetector.kt

@@ -0,0 +1,194 @@
+/*
+ * Copyright 2010-2020 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.jvm.codegen
+
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.backend.jvm.JvmBackendContext
+import org.jetbrains.kotlin.backend.jvm.JvmLoweredDeclarationOrigin
+import org.jetbrains.kotlin.diagnostics.DiagnosticFactory1
+import org.jetbrains.kotlin.ir.declarations.*
+import org.jetbrains.kotlin.ir.util.isFakeOverride
+import org.jetbrains.kotlin.resolve.jvm.diagnostics.*
+import org.jetbrains.kotlin.utils.SmartSet
+import org.jetbrains.org.objectweb.asm.Type
+
+class JvmSignatureClashDetector(
+    private val irClass: IrClass,
+    private val type: Type,
+    private val context: JvmBackendContext
+) {
+    private val methodsBySignature = HashMap<RawSignature, MutableSet<IrFunction>>()
+    private val fieldsBySignature = HashMap<RawSignature, MutableSet<IrField>>()
+
+    fun trackField(irField: IrField, rawSignature: RawSignature) {
+        fieldsBySignature.getOrPut(rawSignature) { SmartSet.create() }.add(irField)
+    }
+
+    fun trackMethod(irFunction: IrFunction) {
+        if (irFunction is IrSimpleFunction && irFunction.isFakeOverride && irFunction.dispatchReceiverParameter != null) {
+            for (overriddenFunction in getOverriddenFunctions(irFunction)) {
+                trackMethod(irFunction, mapRawSignature(overriddenFunction))
+            }
+        } else {
+            trackMethod(irFunction, mapRawSignature(irFunction))
+        }
+    }
+
+    private fun mapRawSignature(irFunction: IrFunction): RawSignature {
+        val jvmSignature = context.methodSignatureMapper.mapSignatureSkipGeneric(irFunction)
+        return RawSignature(jvmSignature.asmMethod.name, jvmSignature.asmMethod.descriptor, MemberKind.METHOD)
+    }
+
+    private fun trackMethod(irFunction: IrFunction, rawSignature: RawSignature) {
+        methodsBySignature.getOrPut(rawSignature) { SmartSet.create() }.add(irFunction)
+    }
+
+    private fun getOverriddenFunctions(irFunction: IrSimpleFunction): Set<IrFunction> {
+        val result = HashSet<IrFunction>()
+        collectOverridesOf(irFunction, result)
+        return result
+    }
+
+    private fun collectOverridesOf(irFunction: IrSimpleFunction, result: MutableSet<IrFunction>) {
+        for (overriddenSymbol in irFunction.overriddenSymbols) {
+            collectOverridesTree(overriddenSymbol.owner, result)
+        }
+    }
+
+    private fun collectOverridesTree(irFunction: IrSimpleFunction, visited: MutableSet<IrFunction>) {
+        if (!visited.add(irFunction)) return
+        collectOverridesOf(irFunction, visited)
+    }
+
+    private fun IrFunction.isSpecialOverride(): Boolean =
+        origin in SPECIAL_BRIDGES_AND_OVERRIDES
+
+    fun reportErrors(classOrigin: JvmDeclarationOrigin) {
+        // Class IFoo$DefaultImpls has conflicting signatures if and only if corresponding interface IFoo has conflicting signatures.
+        // Do not report these diagnostics twice.
+        if (irClass.origin == JvmLoweredDeclarationOrigin.DEFAULT_IMPLS) return
+
+        reportMethodSignatureConflicts(classOrigin)
+        reportPredefinedMethodSignatureConflicts(classOrigin)
+        reportFieldSignatureConflicts(classOrigin)
+    }
+
+    private fun reportMethodSignatureConflicts(classOrigin: JvmDeclarationOrigin) {
+        for ((rawSignature, methods) in methodsBySignature) {
+            if (methods.size <= 1) continue
+
+            val fakeOverridesCount = methods.count { it.isFakeOverride }
+            val specialOverridesCount = methods.count { it.isSpecialOverride() }
+            val realMethodsCount = methods.size - fakeOverridesCount - specialOverridesCount
+
+            val conflictingJvmDeclarationsData = getConflictingJvmDeclarationsData(classOrigin, rawSignature, methods)
+
+            when {
+                realMethodsCount == 0 && (fakeOverridesCount > 1 || specialOverridesCount > 1) ->
+                    reportJvmSignatureClash(
+                        ErrorsJvm.CONFLICTING_INHERITED_JVM_DECLARATIONS,
+                        listOf(irClass),
+                        conflictingJvmDeclarationsData
+                    )
+
+                fakeOverridesCount == 0 && specialOverridesCount == 0 ->
+                    reportJvmSignatureClash(
+                        ErrorsJvm.CONFLICTING_JVM_DECLARATIONS,
+                        methods,
+                        conflictingJvmDeclarationsData
+                    )
+
+                else ->
+                    reportJvmSignatureClash(
+                        ErrorsJvm.ACCIDENTAL_OVERRIDE,
+                        methods.filter { !it.isFakeOverride && !it.isSpecialOverride() },
+                        conflictingJvmDeclarationsData
+                    )
+            }
+        }
+    }
+
+    private fun reportPredefinedMethodSignatureConflicts(classOrigin: JvmDeclarationOrigin) {
+        for (predefinedSignature in PREDEFINED_SIGNATURES) {
+            val knownMethods = methodsBySignature[predefinedSignature] ?: continue
+            val methods = knownMethods.filter { !it.isFakeOverride && !it.isSpecialOverride() }
+            if (methods.isEmpty()) continue
+            val conflictingJvmDeclarationsData = ConflictingJvmDeclarationsData(
+                type.internalName, classOrigin, predefinedSignature,
+                methods.map { it.getJvmDeclarationOrigin() } + JvmDeclarationOrigin(JvmDeclarationOriginKind.OTHER, null, null)
+            )
+            reportJvmSignatureClash(ErrorsJvm.ACCIDENTAL_OVERRIDE, methods, conflictingJvmDeclarationsData)
+        }
+    }
+
+    private fun reportFieldSignatureConflicts(classOrigin: JvmDeclarationOrigin) {
+        for ((rawSignature, fields) in fieldsBySignature) {
+            if (fields.size <= 1) continue
+            val conflictingJvmDeclarationsData = getConflictingJvmDeclarationsData(classOrigin, rawSignature, fields)
+            reportJvmSignatureClash(ErrorsJvm.CONFLICTING_JVM_DECLARATIONS, fields, conflictingJvmDeclarationsData)
+        }
+    }
+
+    private fun reportJvmSignatureClash(
+        diagnosticFactory1: DiagnosticFactory1<PsiElement, ConflictingJvmDeclarationsData>,
+        irDeclarations: Collection<IrDeclaration>,
+        conflictingJvmDeclarationsData: ConflictingJvmDeclarationsData
+    ) {
+        val psiElements = irDeclarations.mapNotNullTo(HashSet()) { it.getElementForDiagnostics() }
+        for (psiElement in psiElements) {
+            context.psiErrorBuilder.at(psiElement)
+                .report(diagnosticFactory1, conflictingJvmDeclarationsData)
+        }
+    }
+
+    private fun IrDeclaration.findPsiElement() = context.psiSourceManager.findPsiElement(this)
+
+    private fun IrDeclaration.getElementForDiagnostics(): PsiElement? =
+        findPsiElement()
+            ?: irClass.findPsiElement()
+
+    private fun getConflictingJvmDeclarationsData(
+        classOrigin: JvmDeclarationOrigin,
+        rawSignature: RawSignature,
+        methods: Collection<IrDeclaration>
+    ): ConflictingJvmDeclarationsData =
+        ConflictingJvmDeclarationsData(
+            type.internalName,
+            classOrigin,
+            rawSignature,
+            methods.map { it.getJvmDeclarationOrigin() }
+        )
+
+    private fun IrDeclaration.getJvmDeclarationOrigin(): JvmDeclarationOrigin {
+        // It looks like 'JvmDeclarationOriginKind' is not really used in error reporting.
+        // However, if needed, we can provide more meaningful information regarding function origin.
+        return JvmDeclarationOrigin(
+            JvmDeclarationOriginKind.OTHER,
+            context.psiSourceManager.findPsiElement(this),
+            descriptor
+        )
+    }
+
+    companion object {
+        val SPECIAL_BRIDGES_AND_OVERRIDES = setOf(
+            IrDeclarationOrigin.BRIDGE,
+            IrDeclarationOrigin.BRIDGE_SPECIAL,
+            IrDeclarationOrigin.IR_BUILTINS_STUB,
+            JvmLoweredDeclarationOrigin.TO_ARRAY,
+            JvmLoweredDeclarationOrigin.DEFAULT_IMPLS_BRIDGE,
+            JvmLoweredDeclarationOrigin.DEFAULT_IMPLS_BRIDGE_TO_SYNTHETIC
+        )
+
+        val PREDEFINED_SIGNATURES = listOf(
+            RawSignature("getClass", "()Ljava/lang/Class;", MemberKind.METHOD),
+            RawSignature("notify", "()V", MemberKind.METHOD),
+            RawSignature("notifyAll", "()V", MemberKind.METHOD),
+            RawSignature("wait", "()V", MemberKind.METHOD),
+            RawSignature("wait", "(J)V", MemberKind.METHOD),
+            RawSignature("wait", "(JI)V", MemberKind.METHOD)
+        )
+    }
+}

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/RenameFieldsLowering.kt

@@ -48,15 +48,14 @@ private class RenameFieldsLowering(val context: CommonBackendContext) : FileLowe
             if (fields.size < 2) continue
 
             var count = 0
-            // We never rename JvmField properties, since they are public ABI. Therefore we consider the JvmField-annotated property first,
-            // in order to make sure it'll claim its original name.
+            // We never rename fields that are part of public ABI (backing fields of const, lateinit, and JvmField properties).
+            // Therefore we consider such fields first, in order to make sure it'll claim its original name.
             // If there are non-static and static (moved from companion) fields with the same name, we try to make static properties retain
             // their original names first, since this is what the old JVM backend did. However this can easily be changed without any
             // major binary compatibility consequences (modulo access to private members via Java reflection).
             for (field in fields.sortedBy {
                 when {
-                    // TODO: also do not rename const properties
-                    it.isJvmField -> 0
+                    it.isPublicAbi() -> 0
                     it.isStatic -> 1
                     else -> 2
                 }
@@ -65,8 +64,7 @@ private class RenameFieldsLowering(val context: CommonBackendContext) : FileLowe
                 val newName = if (count == 0) oldName else Name.identifier(oldName.asString() + "$$count")
                 count++
 
-                // TODO: check visibility instead of annotation
-                if (field.isJvmField) continue
+                if (field.isPublicAbi()) continue
 
                 newNames[field] = newName
             }
@@ -78,6 +76,14 @@ private class RenameFieldsLowering(val context: CommonBackendContext) : FileLowe
         irFile.transform(FieldAccessTransformer(renamer.newSymbols), null)
     }
 
+    private fun IrField.isPublicAbi(): Boolean {
+        if (!visibility.isPublicAPI) return false
+        val correspondingProperty = correspondingPropertySymbol?.owner
+        return isJvmField ||
+                origin == IrDeclarationOrigin.FIELD_FOR_OBJECT_INSTANCE ||
+                correspondingProperty != null && (correspondingProperty.isLateinit || correspondingProperty.isConst)
+    }
+
     private val IrField.isJvmField: Boolean
         get() = hasAnnotation(JvmAbi.JVM_FIELD_ANNOTATION_FQ_NAME)
 }

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/PsiErrorBuilder.kt

@@ -30,6 +30,8 @@ class PsiErrorBuilder(
                 ?: 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)

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/PsiSourceManager.kt

@@ -19,8 +19,6 @@ package org.jetbrains.kotlin.psi2ir
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiFile
 import com.intellij.psi.util.PsiTreeUtil
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptorWithSource
-import org.jetbrains.kotlin.diagnostics.DiagnosticFactory0
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.SourceManager
 import org.jetbrains.kotlin.ir.SourceRangeInfo
@@ -28,7 +26,6 @@ import org.jetbrains.kotlin.ir.declarations.IrDeclaration
 import org.jetbrains.kotlin.ir.declarations.IrFile
 import org.jetbrains.kotlin.ir.util.fileOrNull
 import org.jetbrains.kotlin.psi.KtFile
-import org.jetbrains.kotlin.psi.psiUtil.endOffset
 import java.util.*
 import kotlin.reflect.KClass
 
@@ -78,7 +75,7 @@ class PsiSourceManager : SourceManager {
         fun findPsiElement(irElement: IrElement): PsiElement? {
             var psiElement = fileViewProvider.findElementAt(irElement.startOffset)
             while (psiElement != null) {
-                if (psiElement.endOffset == irElement.endOffset) break
+                if (irElement.endOffset == psiElement.textRange?.endOffset) break
                 psiElement = psiElement.parent
             }
             return psiElement

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ClassGenerator.kt

@@ -26,7 +26,6 @@ import org.jetbrains.kotlin.ir.expressions.mapValueParameters
 import org.jetbrains.kotlin.ir.expressions.putTypeArguments
 import org.jetbrains.kotlin.ir.expressions.typeParametersCount
 import org.jetbrains.kotlin.ir.util.declareSimpleFunctionWithOverrides
-import org.jetbrains.kotlin.ir.util.fields
 import org.jetbrains.kotlin.ir.util.properties
 import org.jetbrains.kotlin.ir.util.referenceFunction
 import org.jetbrains.kotlin.psi.KtClassOrObject
@@ -47,12 +46,12 @@ import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.DelegationResolver
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.descriptorUtil.propertyIfAccessor
+import org.jetbrains.kotlin.resolve.descriptorUtil.setSingleOverridden
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
 import org.jetbrains.kotlin.resolve.scopes.MemberScope
 import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.types.TypeProjectionImpl
 import org.jetbrains.kotlin.types.TypeSubstitutor
-import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 import org.jetbrains.kotlin.utils.newHashMapWithExpectedSize
 
 class ClassGenerator(
@@ -144,18 +143,44 @@ class ClassGenerator(
     private fun KtEnumEntry.hasMemberDeclarations() = declarations.isNotEmpty()
 
     private fun generateFakeOverrideMemberDeclarations(irClass: IrClass, ktClassOrObject: KtPureClassOrObject) {
-        irClass.descriptor.unsubstitutedMemberScope.getContributedDescriptors()
-            .mapNotNull {
-                it.safeAs<CallableMemberDescriptor>().takeIf { memberDescriptor ->
-                    memberDescriptor?.kind == CallableMemberDescriptor.Kind.FAKE_OVERRIDE
-                }
+        val classDescriptor = irClass.descriptor
+
+        classDescriptor.unsubstitutedMemberScope.getContributedDescriptors()
+            .filterIsInstance<CallableMemberDescriptor>()
+            .filter {
+                it.kind == CallableMemberDescriptor.Kind.FAKE_OVERRIDE
             }
             .sortedByRenderer()
             .forEach { fakeOverride ->
                 declarationGenerator.generateFakeOverrideDeclaration(fakeOverride, ktClassOrObject)?.let { irClass.declarations.add(it) }
             }
+
+        context.extensions.getParentClassStaticScope(classDescriptor)?.run {
+            getContributedDescriptors()
+                .filterIsInstance<FunctionDescriptor>()
+                .filter {
+                    Visibilities.isVisibleIgnoringReceiver(it, classDescriptor)
+                }
+                .sortedByRenderer()
+                .forEach { parentStaticMember ->
+                    val fakeOverride = createFakeOverrideDescriptorForParentStaticMember(classDescriptor, parentStaticMember)
+                    declarationGenerator.generateFakeOverrideDeclaration(fakeOverride, ktClassOrObject)?.let {
+                        irClass.declarations.add(it)
+                    }
+                }
+        }
     }
 
+    private fun createFakeOverrideDescriptorForParentStaticMember(
+        classDescriptor: ClassDescriptor,
+        parentStaticMember: FunctionDescriptor
+    ): FunctionDescriptor =
+        parentStaticMember.copy(
+            classDescriptor, parentStaticMember.modality, parentStaticMember.visibility, CallableMemberDescriptor.Kind.FAKE_OVERRIDE, false
+        ).apply {
+            setSingleOverridden(parentStaticMember)
+        }
+
     private fun generateMembersDeclaredInSupertypeList(irClass: IrClass, ktClassOrObject: KtClassOrObject) {
         val ktSuperTypeList = ktClassOrObject.getSuperTypeList() ?: return
         var delegateNumber = 0

compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/GeneratorExtensions.kt

@@ -5,10 +5,12 @@
 
 package org.jetbrains.kotlin.psi2ir.generators
 
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.ir.util.StubGeneratorExtensions
+import org.jetbrains.kotlin.resolve.scopes.MemberScope
 import org.jetbrains.kotlin.types.KotlinType
 
 open class GeneratorExtensions : StubGeneratorExtensions() {
@@ -37,4 +39,5 @@ open class GeneratorExtensions : StubGeneratorExtensions() {
         companion object Instance : EnhancedNullability()
     }
 
+    open fun getParentClassStaticScope(descriptor: ClassDescriptor): MemberScope? = null
 }

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/WrappedDescriptors.kt

@@ -1055,13 +1055,9 @@ open class WrappedFieldDescriptor(
 
     override val isDelegated get() = false
 
-    override fun getBackingField(): FieldDescriptor? {
-        TODO("not implemented")
-    }
-
-    override fun getDelegateField(): FieldDescriptor? {
-        TODO("not implemented")
-    }
+    // Following functions are used in error reporting when rendering annotations on properties
+    override fun getBackingField(): FieldDescriptor? = null // TODO
+    override fun getDelegateField(): FieldDescriptor? = null // TODO
 
     override fun <V : Any?> getUserData(key: CallableDescriptor.UserDataKey<V>?): V? = null
 }

compiler/testData/codegen/box/multiplatform/expectClassInJvmMultifileFacade.kt

@@ -1,5 +1,6 @@
 // !LANGUAGE: +MultiPlatformProjects
 // TARGET_BACKEND: JVM
+// IGNORE_BACKEND_FIR: JVM_IR
 // WITH_RUNTIME
 // FILE: common.kt
 

compiler/testData/codegen/box/multiplatform/optionalExpectation.kt

@@ -1,6 +1,7 @@
 // !LANGUAGE: +MultiPlatformProjects
 // !USE_EXPERIMENTAL: kotlin.ExperimentalMultiplatform
 // IGNORE_BACKEND: NATIVE
+// IGNORE_BACKEND_FIR: JVM_IR
 // WITH_RUNTIME
 // MODULE: library
 // FILE: expected.kt

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/accidentalOverrideFromGrandparent.kt

@@ -0,0 +1,14 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+interface Foo<X> {
+    fun foo(x: X)
+}
+
+open class FooImpl : Foo<String> {
+    override fun foo(x: String) {
+    }
+}
+
+open class FooImpl2 : FooImpl() {
+    <!ACCIDENTAL_OVERRIDE!>fun foo(x: Any)<!> {
+    }
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/accidentalOverrideFromGrandparent.txt

@@ -0,0 +1,25 @@
+package
+
+public interface Foo</*0*/ X> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun foo(/*0*/ x: X): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class FooImpl : Foo<kotlin.String> {
+    public constructor FooImpl()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ fun foo(/*0*/ x: kotlin.String): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public open class FooImpl2 : FooImpl {
+    public constructor FooImpl2()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final fun foo(/*0*/ x: kotlin.Any): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ x: kotlin.String): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/classFunctionOverriddenByProperty.kt

@@ -0,0 +1,8 @@
+open class B {
+    fun getX() = 1
+}
+
+class C : B() {
+    val x: Int
+        <!ACCIDENTAL_OVERRIDE!>get()<!> = 1
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/classFunctionOverriddenByProperty.txt

@@ -0,0 +1,18 @@
+package
+
+public open class B {
+    public constructor B()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final fun getX(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class C : B {
+    public constructor C()
+    public final val x: kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final override /*1*/ /*fake_override*/ fun getX(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/classFunctionOverriddenByPropertyInConstructor.kt

@@ -0,0 +1,5 @@
+open class B {
+    fun getX() = 1
+}
+
+class C(<!ACCIDENTAL_OVERRIDE!>val x: Int<!>) : B()

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/classFunctionOverriddenByPropertyInConstructor.txt

@@ -0,0 +1,18 @@
+package
+
+public open class B {
+    public constructor B()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final fun getX(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class C : B {
+    public constructor C(/*0*/ x: kotlin.Int)
+    public final val x: kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final override /*1*/ /*fake_override*/ fun getX(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/classFunctionOverriddenByPropertyNoGetter.kt

@@ -0,0 +1,7 @@
+open class B {
+    fun getX() = 1
+}
+
+class C : B() {
+    <!ACCIDENTAL_OVERRIDE!>val x: Int<!> = 1
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/classFunctionOverriddenByPropertyNoGetter.txt

@@ -0,0 +1,18 @@
+package
+
+public open class B {
+    public constructor B()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final fun getX(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class C : B {
+    public constructor C()
+    public final val x: kotlin.Int = 1
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final override /*1*/ /*fake_override*/ fun getX(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/classPropertyOverriddenByFunction.kt

@@ -0,0 +1,8 @@
+open class B {
+    val x: Int
+        get() = 1
+}
+
+class C : B() {
+    <!ACCIDENTAL_OVERRIDE!>fun getX()<!> = 1
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/classPropertyOverriddenByFunction.txt

@@ -0,0 +1,18 @@
+package
+
+public open class B {
+    public constructor B()
+    public final val x: kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class C : B {
+    public constructor C()
+    public final override /*1*/ /*fake_override*/ val x: kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final fun getX(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/defaultFunction.kt

@@ -0,0 +1,9 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+open class Base {
+    open fun `foo$default`(d: Derived, i: Int, mask: Int, mh: Any) {}
+}
+
+class Derived : Base() {
+    <!ACCIDENTAL_OVERRIDE!>fun foo(i: Int = 0)<!> {}
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/defaultFunction.txt

@@ -0,0 +1,18 @@
+package
+
+public open class Base {
+    public constructor Base()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun `foo$default`(/*0*/ d: Derived, /*1*/ i: kotlin.Int, /*2*/ mask: kotlin.Int, /*3*/ mh: kotlin.Any): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class Derived : Base {
+    public constructor Derived()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final fun foo(/*0*/ i: kotlin.Int = ...): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun `foo$default`(/*0*/ d: Derived, /*1*/ i: kotlin.Int, /*2*/ mask: kotlin.Int, /*3*/ mh: kotlin.Any): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/delegatedFunctionOverriddenByProperty_ir.kt

@@ -0,0 +1,10 @@
+// TARGET_BACKEND: JVM_IR
+interface B {
+    fun getX() = 1
+}
+
+interface D {
+    val x: Int
+}
+
+class C(d: D) : D by <!ACCIDENTAL_OVERRIDE!>d<!>, B

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/delegatedFunctionOverriddenByProperty_ir.txt

@@ -0,0 +1,24 @@
+package
+
+public interface B {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun getX(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class C : D, B {
+    public constructor C(/*0*/ d: D)
+    public open override /*1*/ /*delegation*/ val x: kotlin.Int
+    public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun getX(): kotlin.Int
+    public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface D {
+    public abstract val x: kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/delegatedFunctionOverriddenByProperty_old.kt

@@ -0,0 +1,10 @@
+// TARGET_BACKEND: JVM_OLD
+interface B {
+    fun getX() = 1
+}
+
+interface D {
+    val x: Int
+}
+
+class <!CONFLICTING_INHERITED_JVM_DECLARATIONS, CONFLICTING_JVM_DECLARATIONS!>C(d: D)<!> : D by d, B

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/delegatedFunctionOverriddenByProperty_old.txt

@@ -0,0 +1,24 @@
+package
+
+public interface B {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun getX(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class C : D, B {
+    public constructor C(/*0*/ d: D)
+    public open override /*1*/ /*delegation*/ val x: kotlin.Int
+    public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun getX(): kotlin.Int
+    public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface D {
+    public abstract val x: kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/genericClassFunction.kt

@@ -0,0 +1,9 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+open class B {
+    fun foo(l: List<String>) {}
+}
+
+class C : B() {
+    <!ACCIDENTAL_OVERRIDE!>fun foo(l: List<Int>)<!> {}
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/genericClassFunction.txt

@@ -0,0 +1,18 @@
+package
+
+public open class B {
+    public constructor B()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final fun foo(/*0*/ l: kotlin.collections.List<kotlin.String>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class C : B {
+    public constructor C()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final fun foo(/*0*/ l: kotlin.collections.List<kotlin.Int>): kotlin.Unit
+    public final override /*1*/ /*fake_override*/ fun foo(/*0*/ l: kotlin.collections.List<kotlin.String>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/overridesNothing_ir.kt

@@ -0,0 +1,8 @@
+// TARGET_BACKEND: JVM_IR
+interface B {
+    fun getX() = 1
+}
+
+class C : B {
+    <!ACCIDENTAL_OVERRIDE!><!NOTHING_TO_OVERRIDE!>override<!> val x<!> = 1
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/overridesNothing_ir.txt

@@ -0,0 +1,17 @@
+package
+
+public interface B {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun getX(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class C : B {
+    public constructor C()
+    public open val x: kotlin.Int = 1
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun getX(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/overridesNothing_old.kt

@@ -0,0 +1,8 @@
+// TARGET_BACKEND: JVM_IR
+interface B {
+    fun getX() = 1
+}
+
+class C : B {
+    <!ACCIDENTAL_OVERRIDE!><!NOTHING_TO_OVERRIDE!>override<!> val x<!> = 1
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/overridesNothing_old.txt

@@ -0,0 +1,17 @@
+package
+
+public interface B {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun getX(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class C : B {
+    public constructor C()
+    public open val x: kotlin.Int = 1
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun getX(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/privateClassFunctionOverriddenByProperty.kt

@@ -0,0 +1,8 @@
+open class B {
+    private fun getX() = 1
+}
+
+class C : B() {
+    val x: Int
+        get() = 1
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/privateClassFunctionOverriddenByProperty.txt

@@ -0,0 +1,18 @@
+package
+
+public open class B {
+    public constructor B()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    private final fun getX(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class C : B {
+    public constructor C()
+    public final val x: kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    invisible_fake final override /*1*/ /*fake_override*/ fun getX(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/traitFunctionOverriddenByPropertyNoImpl.kt

@@ -0,0 +1,8 @@
+interface T {
+    fun getX(): Int
+}
+
+abstract class C : T {
+    val x: Int
+        <!ACCIDENTAL_OVERRIDE!>get()<!> = 1
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/traitFunctionOverriddenByPropertyNoImpl.txt

@@ -0,0 +1,17 @@
+package
+
+public abstract class C : T {
+    public constructor C()
+    public final val x: kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract override /*1*/ /*fake_override*/ fun getX(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface T {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun getX(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/traitFunctionOverriddenByProperty_ir.kt

@@ -0,0 +1,9 @@
+// TARGET_BACKEND: JVM_IR
+interface T {
+    fun getX() = 1
+}
+
+class C : T {
+    val x: Int
+        <!ACCIDENTAL_OVERRIDE!>get()<!> = 1
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/traitFunctionOverriddenByProperty_ir.txt

@@ -0,0 +1,17 @@
+package
+
+public final class C : T {
+    public constructor C()
+    public final val x: kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun getX(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface T {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun getX(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/traitFunctionOverriddenByProperty_old.kt

@@ -0,0 +1,9 @@
+// TARGET_BACKEND: JVM_OLD
+interface T {
+    fun getX() = 1
+}
+
+class <!CONFLICTING_JVM_DECLARATIONS!>C<!> : T {
+    val x: Int
+        <!ACCIDENTAL_OVERRIDE, CONFLICTING_JVM_DECLARATIONS!>get()<!> = 1
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/traitFunctionOverriddenByProperty_old.txt

@@ -0,0 +1,17 @@
+package
+
+public final class C : T {
+    public constructor C()
+    public final val x: kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun getX(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface T {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun getX(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/traitPropertyOverriddenByFunctionNoImpl.kt

@@ -0,0 +1,7 @@
+interface T {
+    val x: Int
+}
+
+abstract class C : T {
+    <!ACCIDENTAL_OVERRIDE!>fun getX()<!> = 1
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/traitPropertyOverriddenByFunctionNoImpl.txt

@@ -0,0 +1,17 @@
+package
+
+public abstract class C : T {
+    public constructor C()
+    public abstract override /*1*/ /*fake_override*/ val x: kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final fun getX(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface T {
+    public abstract val x: kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/traitPropertyOverriddenByFunction_ir.kt

@@ -0,0 +1,9 @@
+// TARGET_BACKEND: JVM_IR
+interface T {
+    val x: Int
+        get() = 1
+}
+
+class C : T {
+    <!ACCIDENTAL_OVERRIDE!>fun getX()<!> = 1
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/traitPropertyOverriddenByFunction_ir.txt

@@ -0,0 +1,17 @@
+package
+
+public final class C : T {
+    public constructor C()
+    public open override /*1*/ /*fake_override*/ val x: kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final fun getX(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface T {
+    public open val x: kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/traitPropertyOverriddenByFunction_old.kt

@@ -0,0 +1,9 @@
+// TARGET_BACKEND: JVM_OLD
+interface T {
+    val x: Int
+        get() = 1
+}
+
+class <!CONFLICTING_JVM_DECLARATIONS!>C<!> : T {
+    <!ACCIDENTAL_OVERRIDE, CONFLICTING_JVM_DECLARATIONS!>fun getX()<!> = 1
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/traitPropertyOverriddenByFunction_old.txt

@@ -0,0 +1,17 @@
+package
+
+public final class C : T {
+    public constructor C()
+    public open override /*1*/ /*fake_override*/ val x: kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final fun getX(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface T {
+    public open val x: kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/bridges/class_ir.kt

@@ -0,0 +1,12 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// TARGET_BACKEND: JVM_IR
+
+open class B<T> {
+    open fun foo(t: T) {}
+}
+
+class C : B<String>() {
+    override fun foo(t: String) {}
+
+    <!ACCIDENTAL_OVERRIDE!>fun foo(o: Any)<!> {}
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/bridges/class_ir.txt

@@ -0,0 +1,18 @@
+package
+
+public open class B</*0*/ T> {
+    public constructor B</*0*/ T>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ t: T): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class C : B<kotlin.String> {
+    public constructor C()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final fun foo(/*0*/ o: kotlin.Any): kotlin.Unit
+    public open override /*1*/ fun foo(/*0*/ t: kotlin.String): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/bridges/class_old.kt

@@ -0,0 +1,12 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// TARGET_BACKEND: JVM_OLD
+
+open class B<T> {
+    open fun foo(t: T) {}
+}
+
+class <!CONFLICTING_JVM_DECLARATIONS!>C<!> : B<String>() {
+    override fun foo(t: String) {}
+
+    <!CONFLICTING_JVM_DECLARATIONS!>fun foo(o: Any)<!> {}
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/bridges/class_old.txt

@@ -0,0 +1,18 @@
+package
+
+public open class B</*0*/ T> {
+    public constructor B</*0*/ T>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ t: T): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class C : B<kotlin.String> {
+    public constructor C()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final fun foo(/*0*/ o: kotlin.Any): kotlin.Unit
+    public open override /*1*/ fun foo(/*0*/ t: kotlin.String): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/bridges/fakeOverrideTrait_ir.kt

@@ -0,0 +1,10 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// TARGET_BACKEND: JVM_IR
+
+interface B<T> {
+    fun foo(t: T) {}
+}
+
+class C : B<String> {
+    <!ACCIDENTAL_OVERRIDE!>fun foo(o: Any)<!> {}
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/bridges/fakeOverrideTrait_ir.txt

@@ -0,0 +1,17 @@
+package
+
+public interface B</*0*/ T> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ t: T): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class C : B<kotlin.String> {
+    public constructor C()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final fun foo(/*0*/ o: kotlin.Any): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ t: kotlin.String): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/bridges/fakeOverrideTrait_old.kt

@@ -0,0 +1,10 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// TARGET_BACKEND: JVM_OLD
+
+interface B<T> {
+    fun foo(t: T) {}
+}
+
+class <!CONFLICTING_JVM_DECLARATIONS!>C<!> : B<String> {
+    <!ACCIDENTAL_OVERRIDE, CONFLICTING_JVM_DECLARATIONS!>fun foo(o: Any)<!> {}
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/bridges/fakeOverrideTrait_old.txt

@@ -0,0 +1,17 @@
+package
+
+public interface B</*0*/ T> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ t: T): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class C : B<kotlin.String> {
+    public constructor C()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final fun foo(/*0*/ o: kotlin.Any): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ t: kotlin.String): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/bridges/trait_ir.kt

@@ -0,0 +1,12 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// TARGET_BACKEND: JVM_IR
+
+interface B<T> {
+    fun foo(t: T) {}
+}
+
+class C : B<String> {
+    override fun foo(t: String) {}
+
+    <!ACCIDENTAL_OVERRIDE!>fun foo(o: Any)<!> {}
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/bridges/trait_ir.txt

@@ -0,0 +1,17 @@
+package
+
+public interface B</*0*/ T> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ t: T): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class C : B<kotlin.String> {
+    public constructor C()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final fun foo(/*0*/ o: kotlin.Any): kotlin.Unit
+    public open override /*1*/ fun foo(/*0*/ t: kotlin.String): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/bridges/trait_old.kt

@@ -0,0 +1,12 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// TARGET_BACKEND: JVM_OLD
+
+interface B<T> {
+    fun foo(t: T) {}
+}
+
+class <!CONFLICTING_JVM_DECLARATIONS!>C<!> : B<String> {
+    override fun foo(t: String) {}
+
+    <!CONFLICTING_JVM_DECLARATIONS!>fun foo(o: Any)<!> {}
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/bridges/trait_old.txt

@@ -0,0 +1,17 @@
+package
+
+public interface B</*0*/ T> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ t: T): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class C : B<kotlin.String> {
+    public constructor C()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final fun foo(/*0*/ o: kotlin.Any): kotlin.Unit
+    public open override /*1*/ fun foo(/*0*/ t: kotlin.String): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/caseInProperties.kt

@@ -0,0 +1,2 @@
+<!CONFLICTING_JVM_DECLARATIONS!>val aa<!> = 1
+<!CONFLICTING_JVM_DECLARATIONS!>val Aa<!> = 1

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/caseInProperties.txt

@@ -0,0 +1,4 @@
+package
+
+public val Aa: kotlin.Int = 1
+public val aa: kotlin.Int = 1

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/clashFromInterfaceAndSuperClass_ir.kt

@@ -0,0 +1,20 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// TARGET_BACKEND: JVM_IR
+
+public open class A<T> {
+    fun foo(x: T) = "O"
+    fun foo(x: A<T>) = "K"
+}
+
+interface C<E> {
+    fun foo(x: E): String
+    fun foo(x: A<E>): String
+}
+
+interface D {
+    fun foo(x: A<String>): String
+}
+
+class <!CONFLICTING_INHERITED_JVM_DECLARATIONS!>B1<!> : A<A<String>>(), D
+
+interface <!CONFLICTING_INHERITED_JVM_DECLARATIONS!>B2<!> : C<A<String>>, D

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/clashFromInterfaceAndSuperClass_ir.txt

@@ -0,0 +1,42 @@
+package
+
+public open class A</*0*/ T> {
+    public constructor A</*0*/ T>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final fun foo(/*0*/ x: A<T>): kotlin.String
+    public final fun foo(/*0*/ x: T): kotlin.String
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class B1 : A<A<kotlin.String>>, D {
+    public constructor B1()
+    public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final override /*1*/ /*fake_override*/ fun foo(/*0*/ x: A<A<kotlin.String>>): kotlin.String
+    public final override /*2*/ /*fake_override*/ fun foo(/*0*/ x: A<kotlin.String>): kotlin.String
+    public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface B2 : C<A<kotlin.String>>, D {
+    public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract override /*1*/ /*fake_override*/ fun foo(/*0*/ x: A<A<kotlin.String>>): kotlin.String
+    public abstract override /*2*/ /*fake_override*/ fun foo(/*0*/ x: A<kotlin.String>): kotlin.String
+    public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface C</*0*/ E> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun foo(/*0*/ x: A<E>): kotlin.String
+    public abstract fun foo(/*0*/ x: E): kotlin.String
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface D {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun foo(/*0*/ x: A<kotlin.String>): kotlin.String
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/clashFromInterfaceAndSuperClass_old.kt

@@ -0,0 +1,20 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// TARGET_BACKEND: JVM_OLD
+
+public open class A<T> {
+    fun foo(x: T) = "O"
+    fun foo(x: A<T>) = "K"
+}
+
+interface C<E> {
+    fun foo(x: E): String
+    fun foo(x: A<E>): String
+}
+
+interface D {
+    fun foo(x: A<String>): String
+}
+
+class <!CONFLICTING_INHERITED_JVM_DECLARATIONS!>B1<!> : A<A<String>>(), D
+
+interface <!CONFLICTING_INHERITED_JVM_DECLARATIONS, CONFLICTING_INHERITED_JVM_DECLARATIONS!>B2<!> : C<A<String>>, D

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/clashFromInterfaceAndSuperClass_old.txt

@@ -0,0 +1,42 @@
+package
+
+public open class A</*0*/ T> {
+    public constructor A</*0*/ T>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final fun foo(/*0*/ x: A<T>): kotlin.String
+    public final fun foo(/*0*/ x: T): kotlin.String
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class B1 : A<A<kotlin.String>>, D {
+    public constructor B1()
+    public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final override /*1*/ /*fake_override*/ fun foo(/*0*/ x: A<A<kotlin.String>>): kotlin.String
+    public final override /*2*/ /*fake_override*/ fun foo(/*0*/ x: A<kotlin.String>): kotlin.String
+    public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface B2 : C<A<kotlin.String>>, D {
+    public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract override /*1*/ /*fake_override*/ fun foo(/*0*/ x: A<A<kotlin.String>>): kotlin.String
+    public abstract override /*2*/ /*fake_override*/ fun foo(/*0*/ x: A<kotlin.String>): kotlin.String
+    public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface C</*0*/ E> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun foo(/*0*/ x: A<E>): kotlin.String
+    public abstract fun foo(/*0*/ x: E): kotlin.String
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface D {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun foo(/*0*/ x: A<kotlin.String>): kotlin.String
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/collections.kt

@@ -0,0 +1,4 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+<!CONFLICTING_JVM_DECLARATIONS!>fun foo(s: List<String>)<!> {}
+<!CONFLICTING_JVM_DECLARATIONS!>fun foo(s: MutableList<String>)<!> {}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/collections.txt

@@ -0,0 +1,4 @@
+package
+
+public fun foo(/*0*/ s: kotlin.collections.List<kotlin.String>): kotlin.Unit
+public fun foo(/*0*/ s: kotlin.collections.MutableList<kotlin.String>): kotlin.Unit

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/delegateToTwoTraits_ir.kt

@@ -0,0 +1,15 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// TARGET_BACKEND: JVM_IR
+
+interface Foo<T> {
+    fun foo(l: List<T>)
+}
+
+interface Bar<T> {
+    fun foo(l: List<T>)
+}
+
+class Baz(f: Foo<String>, b: Bar<Int>) :
+    Foo<String> by <!CONFLICTING_JVM_DECLARATIONS!>f<!>,
+    Bar<Int> by <!CONFLICTING_JVM_DECLARATIONS!>b<!> {
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/delegateToTwoTraits_ir.txt

@@ -0,0 +1,24 @@
+package
+
+public interface Bar</*0*/ T> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun foo(/*0*/ l: kotlin.collections.List<T>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class Baz : Foo<kotlin.String>, Bar<kotlin.Int> {
+    public constructor Baz(/*0*/ f: Foo<kotlin.String>, /*1*/ b: Bar<kotlin.Int>)
+    public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*delegation*/ fun foo(/*0*/ l: kotlin.collections.List<kotlin.Int>): kotlin.Unit
+    public open override /*1*/ /*delegation*/ fun foo(/*0*/ l: kotlin.collections.List<kotlin.String>): kotlin.Unit
+    public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface Foo</*0*/ T> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun foo(/*0*/ l: kotlin.collections.List<T>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/delegateToTwoTraits_old.kt

@@ -0,0 +1,15 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// TARGET_BACKEND: JVM_OLD
+
+interface Foo<T> {
+    fun foo(l: List<T>)
+}
+
+interface Bar<T> {
+    fun foo(l: List<T>)
+}
+
+class <!CONFLICTING_JVM_DECLARATIONS!>Baz(f: Foo<String>, b: Bar<Int>)<!> :
+    Foo<String> by f,
+    Bar<Int> by b {
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/delegateToTwoTraits_old.txt

@@ -0,0 +1,24 @@
+package
+
+public interface Bar</*0*/ T> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun foo(/*0*/ l: kotlin.collections.List<T>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class Baz : Foo<kotlin.String>, Bar<kotlin.Int> {
+    public constructor Baz(/*0*/ f: Foo<kotlin.String>, /*1*/ b: Bar<kotlin.Int>)
+    public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*delegation*/ fun foo(/*0*/ l: kotlin.collections.List<kotlin.Int>): kotlin.Unit
+    public open override /*1*/ /*delegation*/ fun foo(/*0*/ l: kotlin.collections.List<kotlin.String>): kotlin.Unit
+    public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface Foo</*0*/ T> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun foo(/*0*/ l: kotlin.collections.List<T>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/delegationAndOwnMethod_ir.kt

@@ -0,0 +1,10 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// TARGET_BACKEND: JVM_IR
+
+interface Foo<T> {
+    fun foo(l: List<T>)
+}
+
+class Bar(f: Foo<String>): Foo<String> by <!CONFLICTING_JVM_DECLARATIONS!>f<!> {
+    <!CONFLICTING_JVM_DECLARATIONS!>fun foo(l: List<Int>)<!> {}
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/delegationAndOwnMethod_ir.txt

@@ -0,0 +1,17 @@
+package
+
+public final class Bar : Foo<kotlin.String> {
+    public constructor Bar(/*0*/ f: Foo<kotlin.String>)
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final fun foo(/*0*/ l: kotlin.collections.List<kotlin.Int>): kotlin.Unit
+    public open override /*1*/ /*delegation*/ fun foo(/*0*/ l: kotlin.collections.List<kotlin.String>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface Foo</*0*/ T> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun foo(/*0*/ l: kotlin.collections.List<T>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/delegationAndOwnMethod_old.kt

@@ -0,0 +1,10 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// TARGET_BACKEND: JVM_OLD
+
+interface Foo<T> {
+    fun foo(l: List<T>)
+}
+
+class <!CONFLICTING_JVM_DECLARATIONS!>Bar(f: Foo<String>)<!>: Foo<String> by f {
+    <!CONFLICTING_JVM_DECLARATIONS!>fun foo(l: List<Int>)<!> {}
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/delegationAndOwnMethod_old.txt

@@ -0,0 +1,17 @@
+package
+
+public final class Bar : Foo<kotlin.String> {
+    public constructor Bar(/*0*/ f: Foo<kotlin.String>)
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final fun foo(/*0*/ l: kotlin.collections.List<kotlin.Int>): kotlin.Unit
+    public open override /*1*/ /*delegation*/ fun foo(/*0*/ l: kotlin.collections.List<kotlin.String>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface Foo</*0*/ T> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun foo(/*0*/ l: kotlin.collections.List<T>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/delegationToTraitImplAndOwnMethod_ir.kt

@@ -0,0 +1,16 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// TARGET_BACKEND: JVM_IR
+
+interface Foo<T> {
+    fun foo(l: List<T>) {
+
+    }
+}
+
+class Bar(f: Foo<String>): Foo<String> by <!CONFLICTING_JVM_DECLARATIONS!>f<!> {
+    <!CONFLICTING_JVM_DECLARATIONS!>fun foo(l: List<Int>)<!> {}
+}
+
+class BarOther(f: Foo<String>): Foo<String> by f {
+    override fun foo(l: List<String>) {}
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/delegationToTraitImplAndOwnMethod_ir.txt

@@ -0,0 +1,25 @@
+package
+
+public final class Bar : Foo<kotlin.String> {
+    public constructor Bar(/*0*/ f: Foo<kotlin.String>)
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final fun foo(/*0*/ l: kotlin.collections.List<kotlin.Int>): kotlin.Unit
+    public open override /*1*/ /*delegation*/ fun foo(/*0*/ l: kotlin.collections.List<kotlin.String>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class BarOther : Foo<kotlin.String> {
+    public constructor BarOther(/*0*/ f: Foo<kotlin.String>)
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ fun foo(/*0*/ l: kotlin.collections.List<kotlin.String>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface Foo</*0*/ T> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ l: kotlin.collections.List<T>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/delegationToTraitImplAndOwnMethod_old.kt

@@ -0,0 +1,16 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// TARGET_BACKEND: JVM_OLD
+
+interface Foo<T> {
+    fun foo(l: List<T>) {
+
+    }
+}
+
+class <!CONFLICTING_JVM_DECLARATIONS!>Bar(f: Foo<String>)<!>: Foo<String> by f {
+    <!CONFLICTING_JVM_DECLARATIONS!>fun foo(l: List<Int>)<!> {}
+}
+
+class BarOther(f: Foo<String>): Foo<String> by f {
+    override fun foo(l: List<String>) {}
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/delegationToTraitImplAndOwnMethod_old.txt

@@ -0,0 +1,25 @@
+package
+
+public final class Bar : Foo<kotlin.String> {
+    public constructor Bar(/*0*/ f: Foo<kotlin.String>)
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final fun foo(/*0*/ l: kotlin.collections.List<kotlin.Int>): kotlin.Unit
+    public open override /*1*/ /*delegation*/ fun foo(/*0*/ l: kotlin.collections.List<kotlin.String>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class BarOther : Foo<kotlin.String> {
+    public constructor BarOther(/*0*/ f: Foo<kotlin.String>)
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ fun foo(/*0*/ l: kotlin.collections.List<kotlin.String>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface Foo</*0*/ T> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ l: kotlin.collections.List<T>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/extensionProperties.kt

@@ -0,0 +1,7 @@
+class G<T>
+
+val <T> G<T>.foo: Int
+    <!CONFLICTING_JVM_DECLARATIONS!>get()<!> = 1
+
+val G<String>.foo: Int
+    <!CONFLICTING_JVM_DECLARATIONS!>get()<!> = 1

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/extensionProperties.txt

@@ -0,0 +1,11 @@
+package
+
+public val </*0*/ T> G<T>.foo: kotlin.Int
+public val G<kotlin.String>.foo: kotlin.Int
+
+public final class G</*0*/ T> {
+    public constructor G</*0*/ T>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/genericType.kt

@@ -0,0 +1,6 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+class G<T>
+
+<!CONFLICTING_JVM_DECLARATIONS!>fun foo(x: G<String>): G<Int><!> {null!!}
+<!CONFLICTING_JVM_DECLARATIONS!>fun foo(x: G<Int>): G<String><!> {null!!}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/genericType.txt

@@ -0,0 +1,11 @@
+package
+
+public fun foo(/*0*/ x: G<kotlin.Int>): G<kotlin.String>
+public fun foo(/*0*/ x: G<kotlin.String>): G<kotlin.Int>
+
+public final class G</*0*/ T> {
+    public constructor G</*0*/ T>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/inheritFromTwoTraits_ir.kt

@@ -0,0 +1,13 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// TARGET_BACKEND: JVM_IR
+
+interface Foo<T> {
+    fun foo(l: List<T>) {}
+}
+
+interface Bar<T> {
+    fun foo(l: List<T>) {}
+}
+
+class <!CONFLICTING_INHERITED_JVM_DECLARATIONS!>Baz()<!>: Foo<String>, Bar<Int> {
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/inheritFromTwoTraits_ir.txt

@@ -0,0 +1,24 @@
+package
+
+public interface Bar</*0*/ T> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ l: kotlin.collections.List<T>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class Baz : Foo<kotlin.String>, Bar<kotlin.Int> {
+    public constructor Baz()
+    public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ l: kotlin.collections.List<kotlin.Int>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ l: kotlin.collections.List<kotlin.String>): kotlin.Unit
+    public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface Foo</*0*/ T> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ l: kotlin.collections.List<T>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/inheritFromTwoTraits_old.kt

@@ -0,0 +1,13 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// TARGET_BACKEND: JVM_OLD
+
+interface Foo<T> {
+    fun foo(l: List<T>) {}
+}
+
+interface Bar<T> {
+    fun foo(l: List<T>) {}
+}
+
+class <!CONFLICTING_INHERITED_JVM_DECLARATIONS, CONFLICTING_JVM_DECLARATIONS!>Baz()<!>: Foo<String>, Bar<Int> {
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/inheritFromTwoTraits_old.txt

@@ -0,0 +1,24 @@
+package
+
+public interface Bar</*0*/ T> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ l: kotlin.collections.List<T>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class Baz : Foo<kotlin.String>, Bar<kotlin.Int> {
+    public constructor Baz()
+    public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ l: kotlin.collections.List<kotlin.Int>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ l: kotlin.collections.List<kotlin.String>): kotlin.Unit
+    public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface Foo</*0*/ T> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ l: kotlin.collections.List<T>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/kotlinAndJavaCollections.kt

@@ -0,0 +1,4 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER -PLATFORM_CLASS_MAPPED_TO_KOTLIN
+
+<!CONFLICTING_JVM_DECLARATIONS!>fun foo(s: List<String>)<!> {}
+<!CONFLICTING_JVM_DECLARATIONS!>fun foo(s: java.util.List<String>)<!> {}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/kotlinAndJavaCollections.txt

@@ -0,0 +1,4 @@
+package
+
+public fun foo(/*0*/ s: java.util.List<kotlin.String>): kotlin.Unit
+public fun foo(/*0*/ s: kotlin.collections.List<kotlin.String>): kotlin.Unit

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/nullableType.kt

@@ -0,0 +1,4 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+<!CONFLICTING_JVM_DECLARATIONS!>fun foo(x: String)<!> {}
+<!CONFLICTING_JVM_DECLARATIONS!>fun foo(x: String?)<!> {}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/nullableType.txt

@@ -0,0 +1,4 @@
+package
+
+public fun foo(/*0*/ x: kotlin.String): kotlin.Unit
+public fun foo(/*0*/ x: kotlin.String?): kotlin.Unit

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/superTraitAndDelegationToTraitImpl_ir.kt

@@ -0,0 +1,14 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// TARGET_BACKEND: JVM_IR
+
+interface A<T> {
+    fun foo(l: List<T>)
+}
+
+interface B {
+    fun foo(l: List<Int>) {}
+}
+
+class C(f: A<String>): A<String> by <!ACCIDENTAL_OVERRIDE!>f<!>, B
+
+<!DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE!>class D<!>(f: A<Int>): A<Int> by f, B

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/superTraitAndDelegationToTraitImpl_ir.txt

@@ -0,0 +1,32 @@
+package
+
+public interface A</*0*/ T> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun foo(/*0*/ l: kotlin.collections.List<T>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface B {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ l: kotlin.collections.List<kotlin.Int>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class C : A<kotlin.String>, B {
+    public constructor C(/*0*/ f: A<kotlin.String>)
+    public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ l: kotlin.collections.List<kotlin.Int>): kotlin.Unit
+    public open override /*1*/ /*delegation*/ fun foo(/*0*/ l: kotlin.collections.List<kotlin.String>): kotlin.Unit
+    public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class D : A<kotlin.Int>, B {
+    public constructor D(/*0*/ f: A<kotlin.Int>)
+    public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*2*/ /*delegation*/ fun foo(/*0*/ l: kotlin.collections.List<kotlin.Int>): kotlin.Unit
+    public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/superTraitAndDelegationToTraitImpl_old.kt

@@ -0,0 +1,14 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// TARGET_BACKEND: JVM_OLD
+
+interface A<T> {
+    fun foo(l: List<T>)
+}
+
+interface B {
+    fun foo(l: List<Int>) {}
+}
+
+class <!CONFLICTING_INHERITED_JVM_DECLARATIONS, CONFLICTING_JVM_DECLARATIONS!>C(f: A<String>)<!>: A<String> by f, B
+
+<!DELEGATED_MEMBER_HIDES_SUPERTYPE_OVERRIDE!>class D<!>(f: A<Int>): A<Int> by f, B

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/superTraitAndDelegationToTraitImpl_old.txt

@@ -0,0 +1,32 @@
+package
+
+public interface A</*0*/ T> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun foo(/*0*/ l: kotlin.collections.List<T>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface B {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ l: kotlin.collections.List<kotlin.Int>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class C : A<kotlin.String>, B {
+    public constructor C(/*0*/ f: A<kotlin.String>)
+    public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ l: kotlin.collections.List<kotlin.Int>): kotlin.Unit
+    public open override /*1*/ /*delegation*/ fun foo(/*0*/ l: kotlin.collections.List<kotlin.String>): kotlin.Unit
+    public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class D : A<kotlin.Int>, B {
+    public constructor D(/*0*/ f: A<kotlin.Int>)
+    public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*2*/ /*delegation*/ fun foo(/*0*/ l: kotlin.collections.List<kotlin.Int>): kotlin.Unit
+    public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/twoTraitsAndOwnFunction_ir.kt

@@ -0,0 +1,14 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// TARGET_BACKEND: JVM_IR
+
+interface Foo<T> {
+    fun foo(l: List<T>) {}
+}
+
+interface Bar<T> {
+    fun foo(l: List<T>) {}
+}
+
+class Baz(): Foo<String>, Bar<Int> {
+    <!ACCIDENTAL_OVERRIDE!>fun foo(l: List<Long>)<!> {}
+}

compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/twoTraitsAndOwnFunction_ir.txt

@@ -0,0 +1,25 @@
+package
+
+public interface Bar</*0*/ T> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ l: kotlin.collections.List<T>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class Baz : Foo<kotlin.String>, Bar<kotlin.Int> {
+    public constructor Baz()
+    public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ l: kotlin.collections.List<kotlin.Int>): kotlin.Unit
+    public final fun foo(/*0*/ l: kotlin.collections.List<kotlin.Long>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun foo(/*0*/ l: kotlin.collections.List<kotlin.String>): kotlin.Unit
+    public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public interface Foo</*0*/ T> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open fun foo(/*0*/ l: kotlin.collections.List<T>): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}