[tests] Add code examples from exploration of KT-22004

compiler/testData/diagnostics/tests/overload/noConflictingOverloadsWithDeprecatedHidden/ConstructorsInMemberScope.fir.kt

@@ -0,0 +1,289 @@
+// DIAGNOSTICS: -CONFLICTING_JVM_DECLARATIONS, -MISPLACED_TYPE_PARAMETER_CONSTRAINTS
+
+class MemberScope {
+
+
+    class TestBasic {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor()
+        constructor()
+    }
+
+
+    class TestIdenticalPrimaryAndSecondaryConstructorsA constructor() {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor() : this()
+    }
+
+    class TestIdenticalPrimaryAndSecondaryConstructorsB() {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor() : this()
+    }
+
+
+    class TestIdenticalDelegatedPrimaryConstructorCalls constructor(placeholder: UserKlass) {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor() : this(UserKlass())
+        constructor() : this(UserKlass())
+    }
+
+
+    open class SuperConstructorSource constructor(placeholder: UserKlass)
+    class TestIdenticalDelegatedSuperConstructorCalls: SuperConstructorSource {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor() : super(UserKlass())
+        constructor() : super(UserKlass())
+    }
+
+
+    class TestIdenticalValueParameters {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: UserKlass)
+        constructor(arg: UserKlass)
+    }
+
+    class TestDifferentlyNamedValueParameters {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(argA: UserKlass)
+        constructor(argB: UserKlass)
+    }
+
+    class TestTypeAliasedValueParameterTypes {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: UserKlass)
+        constructor(arg: SameUserKlass)
+    }
+
+    class TestTypeAliasedValueParameterTypesReverse {
+        constructor(arg: UserKlass)
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: SameUserKlass)
+    }
+
+
+    class TestMultipleIdenticalValueParameters {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg1: UserKlassA, arg2: UserKlassB)
+        constructor(arg1: UserKlassA, arg2: UserKlassB)
+    }
+
+    class TestMultipleDifferentlyNamedValueParametersA {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg1: UserKlassA, arg2A: UserKlassB)
+        constructor(arg1: UserKlassA, arg2B: UserKlassB)
+    }
+
+    class TestMultipleDifferentlyNamedValueParametersB {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg1A: UserKlassA, arg2A: UserKlassB)
+        constructor(arg1B: UserKlassA, arg2B: UserKlassB)
+    }
+
+    class TestMultipleTypeAliasedValueParameterTypesA {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg1: UserKlassA, arg2: UserKlassB)
+        constructor(arg1: UserKlassA, arg2: SameUserKlassB)
+    }
+
+    class TestMultipleTypeAliasedValueParameterTypesAReverse {
+        constructor(arg1: UserKlassA, arg2: UserKlassB)
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg1: UserKlassA, arg2: SameUserKlassB)
+    }
+
+    class TestMultipleTypeAliasedValueParameterTypesB {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg1: UserKlassA, arg2: UserKlassB)
+        constructor(arg1: SameUserKlassA, arg2: SameUserKlassB)
+    }
+
+    class TestMultipleTypeAliasedValueParameterTypesBReverse {
+        constructor(arg1: UserKlassA, arg2: UserKlassB)
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg1: SameUserKlassA, arg2: SameUserKlassB)
+    }
+
+
+    class TestValueParameterWithIdenticalDefaultArguments {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: UserKlass = defaultArgument)
+        constructor(arg: UserKlass = defaultArgument)
+    }
+
+    class TestDifferencesInValueParameterDefaultArgumentsPresence {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: UserKlass = defaultArgument)
+        constructor(arg: UserKlass)
+    }
+
+    class TestDifferencesInValueParameterDefaultArgumentsPresenceReverse {
+        constructor(arg: UserKlass = defaultArgument)
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: UserKlass)
+    }
+
+    class TestValueParameterWithDifferentDefaultArguments {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: UserKlass = defaultArgumentA)
+        constructor(arg: UserKlass = defaultArgumentB)
+    }
+
+    class TestValueParameterWithAliasedDefaultArguments {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: UserKlass = defaultArgument)
+        constructor(arg: UserKlass = sameDefaultArgument)
+    }
+
+    class TestValueParameterWithAliasedDefaultArgumentsReverse {
+        constructor(arg: UserKlass = defaultArgument)
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: UserKlass = sameDefaultArgument)
+    }
+
+
+    class TestIdenticalTypeParametersA<T> {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor()
+        constructor()
+    }
+
+    class TestIdenticalTypeParametersB<T> {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: T)
+        constructor(arg: T)
+    }
+
+    class TestIdenticalTypeParametersC<T> {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: Invariant<T>)
+        constructor(arg: Invariant<T>)
+    }
+
+
+    class TestMultipleIdenticalTypeParameters<T1, T2> {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor()
+        constructor()
+    }
+
+
+    class TestTypeParameterWithIdenticalUpperBoundsA<T: UserInterface> {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor()
+        constructor()
+    }
+
+    class TestTypeParameterWithIdenticalUpperBoundsB<T: UserInterface> {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: T)
+        constructor(arg: T)
+    }
+
+    class TestTypeParameterWithIdenticalUpperBoundsC<T: UserInterface> {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: Invariant<T>)
+        constructor(arg: Invariant<T>)
+    }
+
+
+    class TestTypeParameterWithMultipleIdenticalUpperBoundsAA<T> where T: UserInterfaceA, T: UserInterfaceB {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor()
+        constructor()
+    }
+
+    class TestTypeParameterWithMultipleIdenticalUpperBoundsAB<T> where T: UserInterfaceA, T: UserInterfaceB {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: T)
+        constructor(arg: T)
+    }
+
+    class TestTypeParameterWithMultipleIdenticalUpperBoundsAC<T> where T: UserInterfaceA, T: UserInterfaceB {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: Invariant<T>)
+        constructor(arg: Invariant<T>)
+    }
+
+    class TestTypeParameterWithMultipleIdenticalUpperBoundsBA<T: UserInterfaceA> where T: UserInterfaceB {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor()
+        constructor()
+    }
+
+    class TestTypeParameterWithMultipleIdenticalUpperBoundsBB<T: UserInterfaceA> where T: UserInterfaceB {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: T)
+        constructor(arg: T)
+    }
+
+    class TestTypeParameterWithMultipleIdenticalUpperBoundsBC<T: UserInterfaceA> where T: UserInterfaceB {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: Invariant<T>)
+        constructor(arg: Invariant<T>)
+    }
+
+
+    class TestIdenticalPrivateVisibility {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) private constructor()
+        private constructor()
+    }
+
+    class TestIdenticalInternalVisibility {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal constructor()
+        internal constructor()
+    }
+
+    open class TestIdenticalProtectedVisibility {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) protected constructor()
+        protected constructor()
+    }
+
+    class TestDifferencesInPrivateAndPublicVisibilities {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) private constructor()
+        public constructor()
+    }
+
+    class TestDifferencesInPrivateAndPublicVisibilitiesReverse {
+        private constructor()
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) public constructor()
+    }
+
+    class TestDifferencesInInternalAndPublicVisibilities {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal constructor()
+        public constructor()
+    }
+
+    class TestDifferencesInInternalAndPublicVisibilitiesReverse {
+        internal constructor()
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) public constructor()
+    }
+
+    open class TestDifferencesInProtectedAndPublicVisibilities {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) protected constructor()
+        public constructor()
+    }
+
+    open class TestDifferencesInProtectedAndPublicVisibilitiesReverse {
+        protected constructor()
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) public constructor()
+    }
+
+    class TestDifferencesInPrivateAndInternalVisibilities {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) private constructor()
+        internal constructor()
+    }
+
+    class TestDifferencesInPrivateAndInternalVisibilitiesReverse {
+        private constructor()
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal constructor()
+    }
+
+    open class TestDifferencesInProtectedAndPrivateVisibilities {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) protected constructor()
+        private constructor()
+    }
+
+    open class TestDifferencesInProtectedAndPrivateVisibilitiesReverse {
+        protected constructor()
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) private constructor()
+    }
+
+    open class TestDifferencesInProtectedAndInternalVisibilities {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) protected constructor()
+        internal constructor()
+    }
+
+    open class TestDifferencesInProtectedAndInternalVisibilitiesReverse {
+        protected constructor()
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal constructor()
+    }
+
+
+}
+
+
+open class Invariant<T>
+
+
+class UserKlass
+class UserKlassA
+class UserKlassB
+typealias SameUserKlass = UserKlass
+typealias SameUserKlassA = UserKlassA
+typealias SameUserKlassB = UserKlassB
+
+
+val defaultArgument = UserKlass()
+val defaultArgumentA = UserKlass()
+val defaultArgumentB = UserKlass()
+val sameDefaultArgument = defaultArgument
+
+
+interface UserInterface
+interface UserInterfaceA
+interface UserInterfaceB

compiler/testData/diagnostics/tests/overload/noConflictingOverloadsWithDeprecatedHidden/ConstructorsInMemberScope.kt

@@ -0,0 +1,289 @@
+// DIAGNOSTICS: -CONFLICTING_JVM_DECLARATIONS, -MISPLACED_TYPE_PARAMETER_CONSTRAINTS
+
+class MemberScope {
+
+
+    class TestBasic {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!>
+        <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+
+
+    class TestIdenticalPrimaryAndSecondaryConstructorsA <!CONFLICTING_OVERLOADS!>constructor()<!> {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!> : this()
+    }
+
+    class TestIdenticalPrimaryAndSecondaryConstructorsB<!CONFLICTING_OVERLOADS!>()<!> {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!> : this()
+    }
+
+
+    class TestIdenticalDelegatedPrimaryConstructorCalls constructor(placeholder: UserKlass) {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!> : this(UserKlass())
+        <!CONFLICTING_OVERLOADS!>constructor()<!> : this(UserKlass())
+    }
+
+
+    open class SuperConstructorSource constructor(placeholder: UserKlass)
+    class TestIdenticalDelegatedSuperConstructorCalls: SuperConstructorSource {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!> : super(UserKlass())
+        <!CONFLICTING_OVERLOADS!>constructor()<!> : super(UserKlass())
+    }
+
+
+    class TestIdenticalValueParameters {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass)<!>
+        <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass)<!>
+    }
+
+    class TestDifferentlyNamedValueParameters {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(argA: UserKlass)<!>
+        <!CONFLICTING_OVERLOADS!>constructor(argB: UserKlass)<!>
+    }
+
+    class TestTypeAliasedValueParameterTypes {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass)<!>
+        <!CONFLICTING_OVERLOADS!>constructor(arg: SameUserKlass)<!>
+    }
+
+    class TestTypeAliasedValueParameterTypesReverse {
+        <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass)<!>
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: SameUserKlass)<!>
+    }
+
+
+    class TestMultipleIdenticalValueParameters {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg1: UserKlassA, arg2: UserKlassB)<!>
+        <!CONFLICTING_OVERLOADS!>constructor(arg1: UserKlassA, arg2: UserKlassB)<!>
+    }
+
+    class TestMultipleDifferentlyNamedValueParametersA {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg1: UserKlassA, arg2A: UserKlassB)<!>
+        <!CONFLICTING_OVERLOADS!>constructor(arg1: UserKlassA, arg2B: UserKlassB)<!>
+    }
+
+    class TestMultipleDifferentlyNamedValueParametersB {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg1A: UserKlassA, arg2A: UserKlassB)<!>
+        <!CONFLICTING_OVERLOADS!>constructor(arg1B: UserKlassA, arg2B: UserKlassB)<!>
+    }
+
+    class TestMultipleTypeAliasedValueParameterTypesA {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg1: UserKlassA, arg2: UserKlassB)<!>
+        <!CONFLICTING_OVERLOADS!>constructor(arg1: UserKlassA, arg2: SameUserKlassB)<!>
+    }
+
+    class TestMultipleTypeAliasedValueParameterTypesAReverse {
+        <!CONFLICTING_OVERLOADS!>constructor(arg1: UserKlassA, arg2: UserKlassB)<!>
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg1: UserKlassA, arg2: SameUserKlassB)<!>
+    }
+
+    class TestMultipleTypeAliasedValueParameterTypesB {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg1: UserKlassA, arg2: UserKlassB)<!>
+        <!CONFLICTING_OVERLOADS!>constructor(arg1: SameUserKlassA, arg2: SameUserKlassB)<!>
+    }
+
+    class TestMultipleTypeAliasedValueParameterTypesBReverse {
+        <!CONFLICTING_OVERLOADS!>constructor(arg1: UserKlassA, arg2: UserKlassB)<!>
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg1: SameUserKlassA, arg2: SameUserKlassB)<!>
+    }
+
+
+    class TestValueParameterWithIdenticalDefaultArguments {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass = defaultArgument)<!>
+        <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass = defaultArgument)<!>
+    }
+
+    class TestDifferencesInValueParameterDefaultArgumentsPresence {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass = defaultArgument)<!>
+        <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass)<!>
+    }
+
+    class TestDifferencesInValueParameterDefaultArgumentsPresenceReverse {
+        <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass = defaultArgument)<!>
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass)<!>
+    }
+
+    class TestValueParameterWithDifferentDefaultArguments {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass = defaultArgumentA)<!>
+        <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass = defaultArgumentB)<!>
+    }
+
+    class TestValueParameterWithAliasedDefaultArguments {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass = defaultArgument)<!>
+        <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass = sameDefaultArgument)<!>
+    }
+
+    class TestValueParameterWithAliasedDefaultArgumentsReverse {
+        <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass = defaultArgument)<!>
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass = sameDefaultArgument)<!>
+    }
+
+
+    class TestIdenticalTypeParametersA<T> {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!>
+        <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+
+    class TestIdenticalTypeParametersB<T> {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+        <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+    }
+
+    class TestIdenticalTypeParametersC<T> {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+        <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+    }
+
+
+    class TestMultipleIdenticalTypeParameters<T1, T2> {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!>
+        <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+
+
+    class TestTypeParameterWithIdenticalUpperBoundsA<T: UserInterface> {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!>
+        <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+
+    class TestTypeParameterWithIdenticalUpperBoundsB<T: UserInterface> {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+        <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+    }
+
+    class TestTypeParameterWithIdenticalUpperBoundsC<T: UserInterface> {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+        <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+    }
+
+
+    class TestTypeParameterWithMultipleIdenticalUpperBoundsAA<T> where T: UserInterfaceA, T: UserInterfaceB {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!>
+        <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+
+    class TestTypeParameterWithMultipleIdenticalUpperBoundsAB<T> where T: UserInterfaceA, T: UserInterfaceB {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+        <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+    }
+
+    class TestTypeParameterWithMultipleIdenticalUpperBoundsAC<T> where T: UserInterfaceA, T: UserInterfaceB {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+        <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+    }
+
+    class TestTypeParameterWithMultipleIdenticalUpperBoundsBA<T: UserInterfaceA> where T: UserInterfaceB {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!>
+        <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+
+    class TestTypeParameterWithMultipleIdenticalUpperBoundsBB<T: UserInterfaceA> where T: UserInterfaceB {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+        <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+    }
+
+    class TestTypeParameterWithMultipleIdenticalUpperBoundsBC<T: UserInterfaceA> where T: UserInterfaceB {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+        <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+    }
+
+
+    class TestIdenticalPrivateVisibility {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) private <!CONFLICTING_OVERLOADS!>constructor()<!>
+        private <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+
+    class TestIdenticalInternalVisibility {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal <!CONFLICTING_OVERLOADS!>constructor()<!>
+        internal <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+
+    open class TestIdenticalProtectedVisibility {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) protected <!CONFLICTING_OVERLOADS!>constructor()<!>
+        protected <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+
+    class TestDifferencesInPrivateAndPublicVisibilities {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) private <!CONFLICTING_OVERLOADS!>constructor()<!>
+        public <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+
+    class TestDifferencesInPrivateAndPublicVisibilitiesReverse {
+        private <!CONFLICTING_OVERLOADS!>constructor()<!>
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) public <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+
+    class TestDifferencesInInternalAndPublicVisibilities {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal <!CONFLICTING_OVERLOADS!>constructor()<!>
+        public <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+
+    class TestDifferencesInInternalAndPublicVisibilitiesReverse {
+        internal <!CONFLICTING_OVERLOADS!>constructor()<!>
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) public <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+
+    open class TestDifferencesInProtectedAndPublicVisibilities {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) protected <!CONFLICTING_OVERLOADS!>constructor()<!>
+        public <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+
+    open class TestDifferencesInProtectedAndPublicVisibilitiesReverse {
+        protected <!CONFLICTING_OVERLOADS!>constructor()<!>
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) public <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+
+    class TestDifferencesInPrivateAndInternalVisibilities {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) private <!CONFLICTING_OVERLOADS!>constructor()<!>
+        internal <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+
+    class TestDifferencesInPrivateAndInternalVisibilitiesReverse {
+        private <!CONFLICTING_OVERLOADS!>constructor()<!>
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+
+    open class TestDifferencesInProtectedAndPrivateVisibilities {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) protected <!CONFLICTING_OVERLOADS!>constructor()<!>
+        private <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+
+    open class TestDifferencesInProtectedAndPrivateVisibilitiesReverse {
+        protected <!CONFLICTING_OVERLOADS!>constructor()<!>
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) private <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+
+    open class TestDifferencesInProtectedAndInternalVisibilities {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) protected <!CONFLICTING_OVERLOADS!>constructor()<!>
+        internal <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+
+    open class TestDifferencesInProtectedAndInternalVisibilitiesReverse {
+        protected <!CONFLICTING_OVERLOADS!>constructor()<!>
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+
+
+}
+
+
+open class Invariant<T>
+
+
+class UserKlass
+class UserKlassA
+class UserKlassB
+typealias SameUserKlass = UserKlass
+typealias SameUserKlassA = UserKlassA
+typealias SameUserKlassB = UserKlassB
+
+
+val defaultArgument = UserKlass()
+val defaultArgumentA = UserKlass()
+val defaultArgumentB = UserKlass()
+val sameDefaultArgument = defaultArgument
+
+
+interface UserInterface
+interface UserInterfaceA
+interface UserInterfaceB

compiler/testData/diagnostics/tests/overload/noConflictingOverloadsWithDeprecatedHidden/ConstructorsInPackage.fir.kt

@@ -0,0 +1,286 @@
+// DIAGNOSTICS: -CONFLICTING_JVM_DECLARATIONS, -MISPLACED_TYPE_PARAMETER_CONSTRAINTS
+
+package pkg
+
+
+class TestBasic {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor()
+    constructor()
+}
+
+
+class TestIdenticalPrimaryAndSecondaryConstructorsA constructor() {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor() : this()
+}
+
+class TestIdenticalPrimaryAndSecondaryConstructorsB() {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor() : this()
+}
+
+
+class TestIdenticalDelegatedPrimaryConstructorCalls constructor(placeholder: UserKlass) {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor() : this(UserKlass())
+    constructor() : this(UserKlass())
+}
+
+
+open class SuperConstructorSource constructor(placeholder: UserKlass)
+class TestIdenticalDelegatedSuperConstructorCalls: SuperConstructorSource {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor() : super(UserKlass())
+    constructor() : super(UserKlass())
+}
+
+
+class TestIdenticalValueParameters {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: UserKlass)
+    constructor(arg: UserKlass)
+}
+
+class TestDifferentlyNamedValueParameters {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(argA: UserKlass)
+    constructor(argB: UserKlass)
+}
+
+class TestTypeAliasedValueParameterTypes {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: UserKlass)
+    constructor(arg: SameUserKlass)
+}
+
+class TestTypeAliasedValueParameterTypesReverse {
+    constructor(arg: UserKlass)
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: SameUserKlass)
+}
+
+
+class TestMultipleIdenticalValueParameters {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg1: UserKlassA, arg2: UserKlassB)
+    constructor(arg1: UserKlassA, arg2: UserKlassB)
+}
+
+class TestMultipleDifferentlyNamedValueParametersA {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg1: UserKlassA, arg2A: UserKlassB)
+    constructor(arg1: UserKlassA, arg2B: UserKlassB)
+}
+
+class TestMultipleDifferentlyNamedValueParametersB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg1A: UserKlassA, arg2A: UserKlassB)
+    constructor(arg1B: UserKlassA, arg2B: UserKlassB)
+}
+
+class TestMultipleTypeAliasedValueParameterTypesA {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg1: UserKlassA, arg2: UserKlassB)
+    constructor(arg1: UserKlassA, arg2: SameUserKlassB)
+}
+
+class TestMultipleTypeAliasedValueParameterTypesAReverse {
+    constructor(arg1: UserKlassA, arg2: UserKlassB)
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg1: UserKlassA, arg2: SameUserKlassB)
+}
+
+class TestMultipleTypeAliasedValueParameterTypesB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg1: UserKlassA, arg2: UserKlassB)
+    constructor(arg1: SameUserKlassA, arg2: SameUserKlassB)
+}
+
+class TestMultipleTypeAliasedValueParameterTypesBReverse {
+    constructor(arg1: UserKlassA, arg2: UserKlassB)
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg1: SameUserKlassA, arg2: SameUserKlassB)
+}
+
+
+class TestValueParameterWithIdenticalDefaultArguments {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: UserKlass = defaultArgument)
+    constructor(arg: UserKlass = defaultArgument)
+}
+
+class TestDifferencesInValueParameterDefaultArgumentsPresence {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: UserKlass = defaultArgument)
+    constructor(arg: UserKlass)
+}
+
+class TestDifferencesInValueParameterDefaultArgumentsPresenceReverse {
+    constructor(arg: UserKlass = defaultArgument)
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: UserKlass)
+}
+
+class TestValueParameterWithDifferentDefaultArguments {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: UserKlass = defaultArgumentA)
+    constructor(arg: UserKlass = defaultArgumentB)
+}
+
+class TestValueParameterWithAliasedDefaultArguments {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: UserKlass = defaultArgument)
+    constructor(arg: UserKlass = sameDefaultArgument)
+}
+
+class TestValueParameterWithAliasedDefaultArgumentsReverse {
+    constructor(arg: UserKlass = defaultArgument)
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: UserKlass = sameDefaultArgument)
+}
+
+
+class TestIdenticalTypeParametersA<T> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor()
+    constructor()
+}
+
+class TestIdenticalTypeParametersB<T> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: T)
+    constructor(arg: T)
+}
+
+class TestIdenticalTypeParametersC<T> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: Invariant<T>)
+    constructor(arg: Invariant<T>)
+}
+
+
+class TestMultipleIdenticalTypeParameters<T1, T2> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor()
+    constructor()
+}
+
+
+class TestTypeParameterWithIdenticalUpperBoundsA<T: UserInterface> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor()
+    constructor()
+}
+
+class TestTypeParameterWithIdenticalUpperBoundsB<T: UserInterface> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: T)
+    constructor(arg: T)
+}
+
+class TestTypeParameterWithIdenticalUpperBoundsC<T: UserInterface> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: Invariant<T>)
+    constructor(arg: Invariant<T>)
+}
+
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsAA<T> where T: UserInterfaceA, T: UserInterfaceB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor()
+    constructor()
+}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsAB<T> where T: UserInterfaceA, T: UserInterfaceB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: T)
+    constructor(arg: T)
+}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsAC<T> where T: UserInterfaceA, T: UserInterfaceB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: Invariant<T>)
+    constructor(arg: Invariant<T>)
+}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsBA<T: UserInterfaceA> where T: UserInterfaceB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor()
+    constructor()
+}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsBB<T: UserInterfaceA> where T: UserInterfaceB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: T)
+    constructor(arg: T)
+}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsBC<T: UserInterfaceA> where T: UserInterfaceB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: Invariant<T>)
+    constructor(arg: Invariant<T>)
+}
+
+
+class TestIdenticalPrivateVisibility {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) private constructor()
+    private constructor()
+}
+
+class TestIdenticalInternalVisibility {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal constructor()
+    internal constructor()
+}
+
+open class TestIdenticalProtectedVisibility {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) protected constructor()
+    protected constructor()
+}
+
+class TestDifferencesInPrivateAndPublicVisibilities {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) private constructor()
+    public constructor()
+}
+
+class TestDifferencesInPrivateAndPublicVisibilitiesReverse {
+    private constructor()
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) public constructor()
+}
+
+class TestDifferencesInInternalAndPublicVisibilities {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal constructor()
+    public constructor()
+}
+
+class TestDifferencesInInternalAndPublicVisibilitiesReverse {
+    internal constructor()
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) public constructor()
+}
+
+open class TestDifferencesInProtectedAndPublicVisibilities {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) protected constructor()
+    public constructor()
+}
+
+open class TestDifferencesInProtectedAndPublicVisibilitiesReverse {
+    protected constructor()
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) public constructor()
+}
+
+class TestDifferencesInPrivateAndInternalVisibilities {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) private constructor()
+    internal constructor()
+}
+
+class TestDifferencesInPrivateAndInternalVisibilitiesReverse {
+    private constructor()
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal constructor()
+}
+
+open class TestDifferencesInProtectedAndPrivateVisibilities {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) protected constructor()
+    private constructor()
+}
+
+open class TestDifferencesInProtectedAndPrivateVisibilitiesReverse {
+    protected constructor()
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) private constructor()
+}
+
+open class TestDifferencesInProtectedAndInternalVisibilities {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) protected constructor()
+    internal constructor()
+}
+
+open class TestDifferencesInProtectedAndInternalVisibilitiesReverse {
+    protected constructor()
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal constructor()
+}
+
+
+open class Invariant<T>
+
+
+class UserKlass
+class UserKlassA
+class UserKlassB
+typealias SameUserKlass = UserKlass
+typealias SameUserKlassA = UserKlassA
+typealias SameUserKlassB = UserKlassB
+
+
+val defaultArgument = UserKlass()
+val defaultArgumentA = UserKlass()
+val defaultArgumentB = UserKlass()
+val sameDefaultArgument = defaultArgument
+
+
+interface UserInterface
+interface UserInterfaceA
+interface UserInterfaceB

compiler/testData/diagnostics/tests/overload/noConflictingOverloadsWithDeprecatedHidden/ConstructorsInPackage.kt

@@ -0,0 +1,286 @@
+// DIAGNOSTICS: -CONFLICTING_JVM_DECLARATIONS, -MISPLACED_TYPE_PARAMETER_CONSTRAINTS
+
+package pkg
+
+
+class TestBasic {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!>
+    <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+
+
+class TestIdenticalPrimaryAndSecondaryConstructorsA <!CONFLICTING_OVERLOADS!>constructor()<!> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!> : this()
+}
+
+class TestIdenticalPrimaryAndSecondaryConstructorsB<!CONFLICTING_OVERLOADS!>()<!> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!> : this()
+}
+
+
+class TestIdenticalDelegatedPrimaryConstructorCalls constructor(placeholder: UserKlass) {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!> : this(UserKlass())
+    <!CONFLICTING_OVERLOADS!>constructor()<!> : this(UserKlass())
+}
+
+
+open class SuperConstructorSource constructor(placeholder: UserKlass)
+class TestIdenticalDelegatedSuperConstructorCalls: SuperConstructorSource {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!> : super(UserKlass())
+    <!CONFLICTING_OVERLOADS!>constructor()<!> : super(UserKlass())
+}
+
+
+class TestIdenticalValueParameters {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass)<!>
+    <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass)<!>
+}
+
+class TestDifferentlyNamedValueParameters {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(argA: UserKlass)<!>
+    <!CONFLICTING_OVERLOADS!>constructor(argB: UserKlass)<!>
+}
+
+class TestTypeAliasedValueParameterTypes {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass)<!>
+    <!CONFLICTING_OVERLOADS!>constructor(arg: SameUserKlass)<!>
+}
+
+class TestTypeAliasedValueParameterTypesReverse {
+    <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass)<!>
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: SameUserKlass)<!>
+}
+
+
+class TestMultipleIdenticalValueParameters {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg1: UserKlassA, arg2: UserKlassB)<!>
+    <!CONFLICTING_OVERLOADS!>constructor(arg1: UserKlassA, arg2: UserKlassB)<!>
+}
+
+class TestMultipleDifferentlyNamedValueParametersA {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg1: UserKlassA, arg2A: UserKlassB)<!>
+    <!CONFLICTING_OVERLOADS!>constructor(arg1: UserKlassA, arg2B: UserKlassB)<!>
+}
+
+class TestMultipleDifferentlyNamedValueParametersB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg1A: UserKlassA, arg2A: UserKlassB)<!>
+    <!CONFLICTING_OVERLOADS!>constructor(arg1B: UserKlassA, arg2B: UserKlassB)<!>
+}
+
+class TestMultipleTypeAliasedValueParameterTypesA {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg1: UserKlassA, arg2: UserKlassB)<!>
+    <!CONFLICTING_OVERLOADS!>constructor(arg1: UserKlassA, arg2: SameUserKlassB)<!>
+}
+
+class TestMultipleTypeAliasedValueParameterTypesAReverse {
+    <!CONFLICTING_OVERLOADS!>constructor(arg1: UserKlassA, arg2: UserKlassB)<!>
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg1: UserKlassA, arg2: SameUserKlassB)<!>
+}
+
+class TestMultipleTypeAliasedValueParameterTypesB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg1: UserKlassA, arg2: UserKlassB)<!>
+    <!CONFLICTING_OVERLOADS!>constructor(arg1: SameUserKlassA, arg2: SameUserKlassB)<!>
+}
+
+class TestMultipleTypeAliasedValueParameterTypesBReverse {
+    <!CONFLICTING_OVERLOADS!>constructor(arg1: UserKlassA, arg2: UserKlassB)<!>
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg1: SameUserKlassA, arg2: SameUserKlassB)<!>
+}
+
+
+class TestValueParameterWithIdenticalDefaultArguments {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass = defaultArgument)<!>
+    <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass = defaultArgument)<!>
+}
+
+class TestDifferencesInValueParameterDefaultArgumentsPresence {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass = defaultArgument)<!>
+    <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass)<!>
+}
+
+class TestDifferencesInValueParameterDefaultArgumentsPresenceReverse {
+    <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass = defaultArgument)<!>
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass)<!>
+}
+
+class TestValueParameterWithDifferentDefaultArguments {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass = defaultArgumentA)<!>
+    <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass = defaultArgumentB)<!>
+}
+
+class TestValueParameterWithAliasedDefaultArguments {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass = defaultArgument)<!>
+    <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass = sameDefaultArgument)<!>
+}
+
+class TestValueParameterWithAliasedDefaultArgumentsReverse {
+    <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass = defaultArgument)<!>
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass = sameDefaultArgument)<!>
+}
+
+
+class TestIdenticalTypeParametersA<T> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!>
+    <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+
+class TestIdenticalTypeParametersB<T> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+    <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+}
+
+class TestIdenticalTypeParametersC<T> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+    <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+}
+
+
+class TestMultipleIdenticalTypeParameters<T1, T2> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!>
+    <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+
+
+class TestTypeParameterWithIdenticalUpperBoundsA<T: UserInterface> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!>
+    <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+
+class TestTypeParameterWithIdenticalUpperBoundsB<T: UserInterface> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+    <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+}
+
+class TestTypeParameterWithIdenticalUpperBoundsC<T: UserInterface> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+    <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+}
+
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsAA<T> where T: UserInterfaceA, T: UserInterfaceB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!>
+    <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsAB<T> where T: UserInterfaceA, T: UserInterfaceB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+    <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsAC<T> where T: UserInterfaceA, T: UserInterfaceB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+    <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsBA<T: UserInterfaceA> where T: UserInterfaceB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!>
+    <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsBB<T: UserInterfaceA> where T: UserInterfaceB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+    <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsBC<T: UserInterfaceA> where T: UserInterfaceB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+    <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+}
+
+
+class TestIdenticalPrivateVisibility {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) private <!CONFLICTING_OVERLOADS!>constructor()<!>
+    private <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+
+class TestIdenticalInternalVisibility {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal <!CONFLICTING_OVERLOADS!>constructor()<!>
+    internal <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+
+open class TestIdenticalProtectedVisibility {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) protected <!CONFLICTING_OVERLOADS!>constructor()<!>
+    protected <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+
+class TestDifferencesInPrivateAndPublicVisibilities {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) private <!CONFLICTING_OVERLOADS!>constructor()<!>
+    public <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+
+class TestDifferencesInPrivateAndPublicVisibilitiesReverse {
+    private <!CONFLICTING_OVERLOADS!>constructor()<!>
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) public <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+
+class TestDifferencesInInternalAndPublicVisibilities {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal <!CONFLICTING_OVERLOADS!>constructor()<!>
+    public <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+
+class TestDifferencesInInternalAndPublicVisibilitiesReverse {
+    internal <!CONFLICTING_OVERLOADS!>constructor()<!>
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) public <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+
+open class TestDifferencesInProtectedAndPublicVisibilities {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) protected <!CONFLICTING_OVERLOADS!>constructor()<!>
+    public <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+
+open class TestDifferencesInProtectedAndPublicVisibilitiesReverse {
+    protected <!CONFLICTING_OVERLOADS!>constructor()<!>
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) public <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+
+class TestDifferencesInPrivateAndInternalVisibilities {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) private <!CONFLICTING_OVERLOADS!>constructor()<!>
+    internal <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+
+class TestDifferencesInPrivateAndInternalVisibilitiesReverse {
+    private <!CONFLICTING_OVERLOADS!>constructor()<!>
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+
+open class TestDifferencesInProtectedAndPrivateVisibilities {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) protected <!CONFLICTING_OVERLOADS!>constructor()<!>
+    private <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+
+open class TestDifferencesInProtectedAndPrivateVisibilitiesReverse {
+    protected <!CONFLICTING_OVERLOADS!>constructor()<!>
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) private <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+
+open class TestDifferencesInProtectedAndInternalVisibilities {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) protected <!CONFLICTING_OVERLOADS!>constructor()<!>
+    internal <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+
+open class TestDifferencesInProtectedAndInternalVisibilitiesReverse {
+    protected <!CONFLICTING_OVERLOADS!>constructor()<!>
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+
+
+open class Invariant<T>
+
+
+class UserKlass
+class UserKlassA
+class UserKlassB
+typealias SameUserKlass = UserKlass
+typealias SameUserKlassA = UserKlassA
+typealias SameUserKlassB = UserKlassB
+
+
+val defaultArgument = UserKlass()
+val defaultArgumentA = UserKlass()
+val defaultArgumentB = UserKlass()
+val sameDefaultArgument = defaultArgument
+
+
+interface UserInterface
+interface UserInterfaceA
+interface UserInterfaceB

compiler/testData/diagnostics/tests/overload/noConflictingOverloadsWithDeprecatedHidden/ConstructorsOnTopLevel.fir.kt

@@ -0,0 +1,284 @@
+// DIAGNOSTICS: -CONFLICTING_JVM_DECLARATIONS, -MISPLACED_TYPE_PARAMETER_CONSTRAINTS
+
+
+class TestBasic {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor()
+    constructor()
+}
+
+
+class TestIdenticalPrimaryAndSecondaryConstructorsA constructor() {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor() : this()
+}
+
+class TestIdenticalPrimaryAndSecondaryConstructorsB() {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor() : this()
+}
+
+
+class TestIdenticalDelegatedPrimaryConstructorCalls constructor(placeholder: UserKlass) {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor() : this(UserKlass())
+    constructor() : this(UserKlass())
+}
+
+
+open class SuperConstructorSource constructor(placeholder: UserKlass)
+class TestIdenticalDelegatedSuperConstructorCalls: SuperConstructorSource {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor() : super(UserKlass())
+    constructor() : super(UserKlass())
+}
+
+
+class TestIdenticalValueParameters {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: UserKlass)
+    constructor(arg: UserKlass)
+}
+
+class TestDifferentlyNamedValueParameters {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(argA: UserKlass)
+    constructor(argB: UserKlass)
+}
+
+class TestTypeAliasedValueParameterTypes {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: UserKlass)
+    constructor(arg: SameUserKlass)
+}
+
+class TestTypeAliasedValueParameterTypesReverse {
+    constructor(arg: UserKlass)
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: SameUserKlass)
+}
+
+
+class TestMultipleIdenticalValueParameters {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg1: UserKlassA, arg2: UserKlassB)
+    constructor(arg1: UserKlassA, arg2: UserKlassB)
+}
+
+class TestMultipleDifferentlyNamedValueParametersA {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg1: UserKlassA, arg2A: UserKlassB)
+    constructor(arg1: UserKlassA, arg2B: UserKlassB)
+}
+
+class TestMultipleDifferentlyNamedValueParametersB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg1A: UserKlassA, arg2A: UserKlassB)
+    constructor(arg1B: UserKlassA, arg2B: UserKlassB)
+}
+
+class TestMultipleTypeAliasedValueParameterTypesA {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg1: UserKlassA, arg2: UserKlassB)
+    constructor(arg1: UserKlassA, arg2: SameUserKlassB)
+}
+
+class TestMultipleTypeAliasedValueParameterTypesAReverse {
+    constructor(arg1: UserKlassA, arg2: UserKlassB)
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg1: UserKlassA, arg2: SameUserKlassB)
+}
+
+class TestMultipleTypeAliasedValueParameterTypesB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg1: UserKlassA, arg2: UserKlassB)
+    constructor(arg1: SameUserKlassA, arg2: SameUserKlassB)
+}
+
+class TestMultipleTypeAliasedValueParameterTypesBReverse {
+    constructor(arg1: UserKlassA, arg2: UserKlassB)
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg1: SameUserKlassA, arg2: SameUserKlassB)
+}
+
+
+class TestValueParameterWithIdenticalDefaultArguments {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: UserKlass = defaultArgument)
+    constructor(arg: UserKlass = defaultArgument)
+}
+
+class TestDifferencesInValueParameterDefaultArgumentsPresence {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: UserKlass = defaultArgument)
+    constructor(arg: UserKlass)
+}
+
+class TestDifferencesInValueParameterDefaultArgumentsPresenceReverse {
+    constructor(arg: UserKlass = defaultArgument)
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: UserKlass)
+}
+
+class TestValueParameterWithDifferentDefaultArguments {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: UserKlass = defaultArgumentA)
+    constructor(arg: UserKlass = defaultArgumentB)
+}
+
+class TestValueParameterWithAliasedDefaultArguments {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: UserKlass = defaultArgument)
+    constructor(arg: UserKlass = sameDefaultArgument)
+}
+
+class TestValueParameterWithAliasedDefaultArgumentsReverse {
+    constructor(arg: UserKlass = defaultArgument)
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: UserKlass = sameDefaultArgument)
+}
+
+
+class TestIdenticalTypeParametersA<T> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor()
+    constructor()
+}
+
+class TestIdenticalTypeParametersB<T> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: T)
+    constructor(arg: T)
+}
+
+class TestIdenticalTypeParametersC<T> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: Invariant<T>)
+    constructor(arg: Invariant<T>)
+}
+
+
+class TestMultipleIdenticalTypeParameters<T1, T2> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor()
+    constructor()
+}
+
+
+class TestTypeParameterWithIdenticalUpperBoundsA<T: UserInterface> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor()
+    constructor()
+}
+
+class TestTypeParameterWithIdenticalUpperBoundsB<T: UserInterface> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: T)
+    constructor(arg: T)
+}
+
+class TestTypeParameterWithIdenticalUpperBoundsC<T: UserInterface> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: Invariant<T>)
+    constructor(arg: Invariant<T>)
+}
+
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsAA<T> where T: UserInterfaceA, T: UserInterfaceB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor()
+    constructor()
+}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsAB<T> where T: UserInterfaceA, T: UserInterfaceB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: T)
+    constructor(arg: T)
+}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsAC<T> where T: UserInterfaceA, T: UserInterfaceB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: Invariant<T>)
+    constructor(arg: Invariant<T>)
+}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsBA<T: UserInterfaceA> where T: UserInterfaceB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor()
+    constructor()
+}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsBB<T: UserInterfaceA> where T: UserInterfaceB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: T)
+    constructor(arg: T)
+}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsBC<T: UserInterfaceA> where T: UserInterfaceB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: Invariant<T>)
+    constructor(arg: Invariant<T>)
+}
+
+
+class TestIdenticalPrivateVisibility {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) private constructor()
+    private constructor()
+}
+
+class TestIdenticalInternalVisibility {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal constructor()
+    internal constructor()
+}
+
+open class TestIdenticalProtectedVisibility {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) protected constructor()
+    protected constructor()
+}
+
+class TestDifferencesInPrivateAndPublicVisibilities {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) private constructor()
+    public constructor()
+}
+
+class TestDifferencesInPrivateAndPublicVisibilitiesReverse {
+    private constructor()
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) public constructor()
+}
+
+class TestDifferencesInInternalAndPublicVisibilities {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal constructor()
+    public constructor()
+}
+
+class TestDifferencesInInternalAndPublicVisibilitiesReverse {
+    internal constructor()
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) public constructor()
+}
+
+open class TestDifferencesInProtectedAndPublicVisibilities {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) protected constructor()
+    public constructor()
+}
+
+open class TestDifferencesInProtectedAndPublicVisibilitiesReverse {
+    protected constructor()
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) public constructor()
+}
+
+class TestDifferencesInPrivateAndInternalVisibilities {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) private constructor()
+    internal constructor()
+}
+
+class TestDifferencesInPrivateAndInternalVisibilitiesReverse {
+    private constructor()
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal constructor()
+}
+
+open class TestDifferencesInProtectedAndPrivateVisibilities {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) protected constructor()
+    private constructor()
+}
+
+open class TestDifferencesInProtectedAndPrivateVisibilitiesReverse {
+    protected constructor()
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) private constructor()
+}
+
+open class TestDifferencesInProtectedAndInternalVisibilities {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) protected constructor()
+    internal constructor()
+}
+
+open class TestDifferencesInProtectedAndInternalVisibilitiesReverse {
+    protected constructor()
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal constructor()
+}
+
+
+open class Invariant<T>
+
+
+class UserKlass
+class UserKlassA
+class UserKlassB
+typealias SameUserKlass = UserKlass
+typealias SameUserKlassA = UserKlassA
+typealias SameUserKlassB = UserKlassB
+
+
+val defaultArgument = UserKlass()
+val defaultArgumentA = UserKlass()
+val defaultArgumentB = UserKlass()
+val sameDefaultArgument = defaultArgument
+
+
+interface UserInterface
+interface UserInterfaceA
+interface UserInterfaceB

compiler/testData/diagnostics/tests/overload/noConflictingOverloadsWithDeprecatedHidden/ConstructorsOnTopLevel.kt

@@ -0,0 +1,284 @@
+// DIAGNOSTICS: -CONFLICTING_JVM_DECLARATIONS, -MISPLACED_TYPE_PARAMETER_CONSTRAINTS
+
+
+class TestBasic {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!>
+    <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+
+
+class TestIdenticalPrimaryAndSecondaryConstructorsA <!CONFLICTING_OVERLOADS!>constructor()<!> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!> : this()
+}
+
+class TestIdenticalPrimaryAndSecondaryConstructorsB<!CONFLICTING_OVERLOADS!>()<!> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!> : this()
+}
+
+
+class TestIdenticalDelegatedPrimaryConstructorCalls constructor(placeholder: UserKlass) {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!> : this(UserKlass())
+    <!CONFLICTING_OVERLOADS!>constructor()<!> : this(UserKlass())
+}
+
+
+open class SuperConstructorSource constructor(placeholder: UserKlass)
+class TestIdenticalDelegatedSuperConstructorCalls: SuperConstructorSource {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!> : super(UserKlass())
+    <!CONFLICTING_OVERLOADS!>constructor()<!> : super(UserKlass())
+}
+
+
+class TestIdenticalValueParameters {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass)<!>
+    <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass)<!>
+}
+
+class TestDifferentlyNamedValueParameters {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(argA: UserKlass)<!>
+    <!CONFLICTING_OVERLOADS!>constructor(argB: UserKlass)<!>
+}
+
+class TestTypeAliasedValueParameterTypes {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass)<!>
+    <!CONFLICTING_OVERLOADS!>constructor(arg: SameUserKlass)<!>
+}
+
+class TestTypeAliasedValueParameterTypesReverse {
+    <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass)<!>
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: SameUserKlass)<!>
+}
+
+
+class TestMultipleIdenticalValueParameters {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg1: UserKlassA, arg2: UserKlassB)<!>
+    <!CONFLICTING_OVERLOADS!>constructor(arg1: UserKlassA, arg2: UserKlassB)<!>
+}
+
+class TestMultipleDifferentlyNamedValueParametersA {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg1: UserKlassA, arg2A: UserKlassB)<!>
+    <!CONFLICTING_OVERLOADS!>constructor(arg1: UserKlassA, arg2B: UserKlassB)<!>
+}
+
+class TestMultipleDifferentlyNamedValueParametersB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg1A: UserKlassA, arg2A: UserKlassB)<!>
+    <!CONFLICTING_OVERLOADS!>constructor(arg1B: UserKlassA, arg2B: UserKlassB)<!>
+}
+
+class TestMultipleTypeAliasedValueParameterTypesA {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg1: UserKlassA, arg2: UserKlassB)<!>
+    <!CONFLICTING_OVERLOADS!>constructor(arg1: UserKlassA, arg2: SameUserKlassB)<!>
+}
+
+class TestMultipleTypeAliasedValueParameterTypesAReverse {
+    <!CONFLICTING_OVERLOADS!>constructor(arg1: UserKlassA, arg2: UserKlassB)<!>
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg1: UserKlassA, arg2: SameUserKlassB)<!>
+}
+
+class TestMultipleTypeAliasedValueParameterTypesB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg1: UserKlassA, arg2: UserKlassB)<!>
+    <!CONFLICTING_OVERLOADS!>constructor(arg1: SameUserKlassA, arg2: SameUserKlassB)<!>
+}
+
+class TestMultipleTypeAliasedValueParameterTypesBReverse {
+    <!CONFLICTING_OVERLOADS!>constructor(arg1: UserKlassA, arg2: UserKlassB)<!>
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg1: SameUserKlassA, arg2: SameUserKlassB)<!>
+}
+
+
+class TestValueParameterWithIdenticalDefaultArguments {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass = defaultArgument)<!>
+    <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass = defaultArgument)<!>
+}
+
+class TestDifferencesInValueParameterDefaultArgumentsPresence {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass = defaultArgument)<!>
+    <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass)<!>
+}
+
+class TestDifferencesInValueParameterDefaultArgumentsPresenceReverse {
+    <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass = defaultArgument)<!>
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass)<!>
+}
+
+class TestValueParameterWithDifferentDefaultArguments {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass = defaultArgumentA)<!>
+    <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass = defaultArgumentB)<!>
+}
+
+class TestValueParameterWithAliasedDefaultArguments {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass = defaultArgument)<!>
+    <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass = sameDefaultArgument)<!>
+}
+
+class TestValueParameterWithAliasedDefaultArgumentsReverse {
+    <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass = defaultArgument)<!>
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass = sameDefaultArgument)<!>
+}
+
+
+class TestIdenticalTypeParametersA<T> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!>
+    <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+
+class TestIdenticalTypeParametersB<T> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+    <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+}
+
+class TestIdenticalTypeParametersC<T> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+    <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+}
+
+
+class TestMultipleIdenticalTypeParameters<T1, T2> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!>
+    <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+
+
+class TestTypeParameterWithIdenticalUpperBoundsA<T: UserInterface> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!>
+    <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+
+class TestTypeParameterWithIdenticalUpperBoundsB<T: UserInterface> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+    <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+}
+
+class TestTypeParameterWithIdenticalUpperBoundsC<T: UserInterface> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+    <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+}
+
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsAA<T> where T: UserInterfaceA, T: UserInterfaceB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!>
+    <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsAB<T> where T: UserInterfaceA, T: UserInterfaceB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+    <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsAC<T> where T: UserInterfaceA, T: UserInterfaceB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+    <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsBA<T: UserInterfaceA> where T: UserInterfaceB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!>
+    <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsBB<T: UserInterfaceA> where T: UserInterfaceB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+    <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsBC<T: UserInterfaceA> where T: UserInterfaceB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+    <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+}
+
+
+class TestIdenticalPrivateVisibility {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) private <!CONFLICTING_OVERLOADS!>constructor()<!>
+    private <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+
+class TestIdenticalInternalVisibility {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal <!CONFLICTING_OVERLOADS!>constructor()<!>
+    internal <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+
+open class TestIdenticalProtectedVisibility {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) protected <!CONFLICTING_OVERLOADS!>constructor()<!>
+    protected <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+
+class TestDifferencesInPrivateAndPublicVisibilities {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) private <!CONFLICTING_OVERLOADS!>constructor()<!>
+    public <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+
+class TestDifferencesInPrivateAndPublicVisibilitiesReverse {
+    private <!CONFLICTING_OVERLOADS!>constructor()<!>
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) public <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+
+class TestDifferencesInInternalAndPublicVisibilities {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal <!CONFLICTING_OVERLOADS!>constructor()<!>
+    public <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+
+class TestDifferencesInInternalAndPublicVisibilitiesReverse {
+    internal <!CONFLICTING_OVERLOADS!>constructor()<!>
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) public <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+
+open class TestDifferencesInProtectedAndPublicVisibilities {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) protected <!CONFLICTING_OVERLOADS!>constructor()<!>
+    public <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+
+open class TestDifferencesInProtectedAndPublicVisibilitiesReverse {
+    protected <!CONFLICTING_OVERLOADS!>constructor()<!>
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) public <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+
+class TestDifferencesInPrivateAndInternalVisibilities {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) private <!CONFLICTING_OVERLOADS!>constructor()<!>
+    internal <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+
+class TestDifferencesInPrivateAndInternalVisibilitiesReverse {
+    private <!CONFLICTING_OVERLOADS!>constructor()<!>
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+
+open class TestDifferencesInProtectedAndPrivateVisibilities {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) protected <!CONFLICTING_OVERLOADS!>constructor()<!>
+    private <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+
+open class TestDifferencesInProtectedAndPrivateVisibilitiesReverse {
+    protected <!CONFLICTING_OVERLOADS!>constructor()<!>
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) private <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+
+open class TestDifferencesInProtectedAndInternalVisibilities {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) protected <!CONFLICTING_OVERLOADS!>constructor()<!>
+    internal <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+
+open class TestDifferencesInProtectedAndInternalVisibilitiesReverse {
+    protected <!CONFLICTING_OVERLOADS!>constructor()<!>
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+
+
+open class Invariant<T>
+
+
+class UserKlass
+class UserKlassA
+class UserKlassB
+typealias SameUserKlass = UserKlass
+typealias SameUserKlassA = UserKlassA
+typealias SameUserKlassB = UserKlassB
+
+
+val defaultArgument = UserKlass()
+val defaultArgumentA = UserKlass()
+val defaultArgumentB = UserKlass()
+val sameDefaultArgument = defaultArgument
+
+
+interface UserInterface
+interface UserInterfaceA
+interface UserInterfaceB

compiler/testData/diagnostics/tests/overload/noConflictingOverloadsWithDeprecatedHidden/DifferentDeprecationLevels.fir.kt

@@ -0,0 +1,8 @@
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.WARNING) fun TestWarning()<!> {}
+<!CONFLICTING_OVERLOADS!>fun TestWarning()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.ERROR) fun TestError()<!> {}
+<!CONFLICTING_OVERLOADS!>fun TestError()<!> {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestHidden() {}
+fun TestHidden() {}

compiler/testData/diagnostics/tests/overload/noConflictingOverloadsWithDeprecatedHidden/DifferentDeprecationLevels.kt

@@ -0,0 +1,8 @@
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.WARNING) fun TestWarning()<!> {}
+<!CONFLICTING_OVERLOADS!>fun TestWarning()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.ERROR) fun TestError()<!> {}
+<!CONFLICTING_OVERLOADS!>fun TestError()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestHidden()<!> {}
+<!CONFLICTING_OVERLOADS!>fun TestHidden()<!> {}

compiler/testData/diagnostics/tests/overload/noConflictingOverloadsWithDeprecatedHidden/FunctionsAndConstructorsInMemberScope.fir.kt

@@ -0,0 +1,436 @@
+// DIAGNOSTICS: -NOTHING_TO_INLINE, -NO_TAIL_CALLS_FOUND, -MISPLACED_TYPE_PARAMETER_CONSTRAINTS
+
+
+class MemberScope {
+
+
+    class TestBasic {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor()
+    }
+    fun TestBasic() {}
+
+    class TestBasicReverse {
+        constructor()
+    }
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestBasicReverse() {}
+
+
+    class TestIdenticalReturnTypes {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor()
+    }
+    fun TestIdenticalReturnTypes(): TestIdenticalReturnTypes = TestIdenticalReturnTypes()
+
+    class TestIdenticalReturnTypesReverse {
+        constructor()
+    }
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestIdenticalReturnTypesReverse(): TestIdenticalReturnTypesReverse = TestIdenticalReturnTypesReverse()
+
+
+    class TestFunctionWithReifiedTypeParameterVsConstructorA<T> {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor()
+    }
+    inline fun <reified T> TestFunctionWithReifiedTypeParameterVsConstructorA() {}
+
+    class TestFunctionWithReifiedTypeParameterVsConstructorAReverse<T> {
+        constructor()
+    }
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> TestFunctionWithReifiedTypeParameterVsConstructorAReverse() {}
+
+    class TestFunctionWithReifiedTypeParameterVsConstructorB<T> {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: T)
+    }
+    inline fun <reified T> TestFunctionWithReifiedTypeParameterVsConstructorB(arg: T) {}
+
+    class TestFunctionWithReifiedTypeParameterVsConstructorBReverse<T> {
+        constructor(arg: T)
+    }
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> TestFunctionWithReifiedTypeParameterVsConstructorBReverse(arg: T) {}
+
+    class TestFunctionWithReifiedTypeParameterVsConstructorC<T> {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: Invariant<T>)
+    }
+    inline fun <reified T> TestFunctionWithReifiedTypeParameterVsConstructorC(arg: Invariant<T>) {}
+
+    class TestFunctionWithReifiedTypeParameterVsConstructorCReverse<T> {
+        constructor(arg: Invariant<T>)
+    }
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> TestFunctionWithReifiedTypeParameterVsConstructorCReverse(arg: Invariant<T>) {}
+
+
+    class TestInlineFunctionVsConstructor {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor()
+    }
+    inline fun TestInlineFunctionVsConstructor() {}
+
+    class TestInlineFunctionVsConstructorReverse {
+        constructor()
+    }
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun TestInlineFunctionVsConstructorReverse() {}
+
+
+    class TestTailrecFunctionVsConstructor {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor()
+    }
+    tailrec fun TestTailrecFunctionVsConstructor() {}
+
+    class TestTailrecFunctionVsConstructorReverse {
+        constructor()
+    }
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) tailrec fun TestTailrecFunctionVsConstructorReverse() {}
+
+
+    class TestFunctionVsPrimaryConstructor @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor()
+    fun TestFunctionVsPrimaryConstructor() {}
+
+    class TestFunctionVsPrimaryConstructorReverse constructor() {}
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestFunctionVsPrimaryConstructorReverse() {}
+
+
+    class TestFunctionVsDelegatedPrimaryConstructorCall constructor(placeholder: UserKlass) {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor() : this(UserKlass())
+    }
+    fun TestFunctionVsDelegatedPrimaryConstructorCall() {}
+
+    class TestFunctionVsDelegatedPrimaryConstructorCallReverse constructor(placeholder: UserKlass) {
+        constructor() : this(UserKlass())
+    }
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestFunctionVsDelegatedPrimaryConstructorCallReverse() {}
+
+
+    open class SuperConstructorSource constructor(placeholder: UserKlass)
+
+    class TestFunctionVsDelegatedSuperConstructorCall: SuperConstructorSource {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor() : super(UserKlass())
+    }
+    fun TestFunctionVsDelegatedSuperConstructorCall() {}
+
+    class TestFunctionVsDelegatedSuperConstructorCallReverse: SuperConstructorSource {
+        constructor() : super(UserKlass())
+    }
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestFunctionVsDelegatedSuperConstructorCallReverse() {}
+
+
+    class TestIdenticalValueParameters {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: UserKlass)
+    }
+    fun TestIdenticalValueParameters(arg: UserKlass) {}
+
+    class TestIdenticalValueParametersReverse {
+        constructor(arg: UserKlass)
+    }
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestIdenticalValueParametersReverse(arg: UserKlass) {}
+
+    class TestDifferentlyNamedValueParameters {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(argA: UserKlass)
+    }
+    fun TestDifferentlyNamedValueParameters(argB: UserKlass) {}
+
+    class TestDifferentlyNamedValueParametersReverse {
+        constructor(argA: UserKlass)
+    }
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestDifferentlyNamedValueParametersReverse(argB: UserKlass) {}
+
+    class TestTypeAliasedValueParameterTypesA {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: UserKlass)
+    }
+    fun TestTypeAliasedValueParameterTypesA(arg: SameUserKlass) {}
+
+    class TestTypeAliasedValueParameterTypesAReverse {
+        constructor(arg: UserKlass)
+    }
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestTypeAliasedValueParameterTypesAReverse(arg: SameUserKlass) {}
+
+    class TestTypeAliasedValueParameterTypesB {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: SameUserKlass)
+    }
+    fun TestTypeAliasedValueParameterTypesB(arg: UserKlass) {}
+
+    class TestTypeAliasedValueParameterTypesBReverse {
+        constructor(arg: SameUserKlass)
+    }
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestTypeAliasedValueParameterTypesBReverse(arg: UserKlass) {}
+
+
+    class TestMultipleIdenticalValueParameters {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg1: UserKlassA, arg2: UserKlassB)
+    }
+    fun TestMultipleIdenticalValueParameters(arg1: UserKlassA, arg2: UserKlassB) {}
+
+    class TestMultipleIdenticalValueParametersReverse {
+        constructor(arg1: UserKlassA, arg2: UserKlassB)
+    }
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestMultipleIdenticalValueParametersReverse(arg1: UserKlassA, arg2: UserKlassB) {}
+
+    class TestMultipleDifferentlyNamedValueParametersA {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg1: UserKlassA, arg2A: UserKlassB)
+    }
+    fun TestMultipleDifferentlyNamedValueParametersA(arg1: UserKlassA, arg2B: UserKlassB) {}
+
+    class TestMultipleDifferentlyNamedValueParametersAReverse {
+        constructor(arg1: UserKlassA, arg2A: UserKlassB)
+    }
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestMultipleDifferentlyNamedValueParametersAReverse(arg1: UserKlassA, arg2B: UserKlassB) {}
+
+    class TestMultipleDifferentlyNamedValueParametersB {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg1A: UserKlassA, arg2A: UserKlassB)
+    }
+    fun TestMultipleDifferentlyNamedValueParametersB(arg1B: UserKlassA, arg2B: UserKlassB) {}
+
+    class TestMultipleDifferentlyNamedValueParametersBReverse {
+        constructor(arg1A: UserKlassA, arg2A: UserKlassB)
+    }
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestMultipleDifferentlyNamedValueParametersBReverse(arg1B: UserKlassA, arg2B: UserKlassB) {}
+
+    class TestMultipleTypeAliasedValueParameterTypesA {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg1: UserKlassA, arg2: SameUserKlassB)
+    }
+    fun TestMultipleTypeAliasedValueParameterTypesA(arg1: UserKlassA, arg2: SameUserKlassB) {}
+
+    class TestMultipleTypeAliasedValueParameterTypesAReverse {
+        constructor(arg1: UserKlassA, arg2: SameUserKlassB)
+    }
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestMultipleTypeAliasedValueParameterTypesAReverse(arg1: UserKlassA, arg2: SameUserKlassB) {}
+
+    class TestMultipleTypeAliasedValueParameterTypesB {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg1: SameUserKlassA, arg2: SameUserKlassB)
+    }
+    fun TestMultipleTypeAliasedValueParameterTypesB(arg1: SameUserKlassA, arg2: SameUserKlassB) {}
+
+    class TestMultipleTypeAliasedValueParameterTypesBReverse {
+        constructor(arg1: SameUserKlassA, arg2: SameUserKlassB)
+    }
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestMultipleTypeAliasedValueParameterTypesBReverse(arg1: SameUserKlassA, arg2: SameUserKlassB) {}
+
+
+    class TestIdenticalTypeParametersA<T> {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor()
+    }
+    fun <T> TestIdenticalTypeParametersA() {}
+
+    class TestIdenticalTypeParametersAReverse<T> {
+        constructor()
+    }
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> TestIdenticalTypeParametersAReverse() {}
+
+    class TestIdenticalTypeParametersB<T> {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: T)
+    }
+    fun <T> TestIdenticalTypeParametersB(arg: T) {}
+
+    class TestIdenticalTypeParametersBReverse<T> {
+        constructor(arg: T)
+    }
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> TestIdenticalTypeParametersBReverse(arg: T) {}
+
+    class TestIdenticalTypeParametersC<T> {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: Invariant<T>)
+    }
+    fun <T> TestIdenticalTypeParametersC(arg: Invariant<T>) {}
+
+    class TestIdenticalTypeParametersCReverse<T> {
+        constructor(arg: Invariant<T>)
+    }
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> TestIdenticalTypeParametersCReverse(arg: Invariant<T>) {}
+
+
+    class TestMultipleIdenticalTypeParameters<T1, T2> {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor()
+    }
+    fun <T1, T2> TestMultipleIdenticalTypeParameters() {}
+
+    class TestMultipleIdenticalTypeParametersReverse<T1, T2> {
+        constructor()
+    }
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T1, T2> TestMultipleIdenticalTypeParametersReverse() {}
+
+
+    class TestTypeParameterWithIdenticalUpperBoundsA<T: UserInterface> {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor()
+    }
+    fun <T: UserInterface> TestTypeParameterWithIdenticalUpperBoundsA() {}
+
+    class TestTypeParameterWithIdenticalUpperBoundsAReverse<T: UserInterface> {
+        constructor()
+    }
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> TestTypeParameterWithIdenticalUpperBoundsAReverse() {}
+
+    class TestTypeParameterWithIdenticalUpperBoundsB<T: UserInterface> {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: T)
+    }
+    fun <T: UserInterface> TestTypeParameterWithIdenticalUpperBoundsB(arg: T) {}
+
+    class TestTypeParameterWithIdenticalUpperBoundsBReverse<T: UserInterface> {
+        constructor(arg: T)
+    }
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> TestTypeParameterWithIdenticalUpperBoundsBReverse(arg: T) {}
+
+    class TestTypeParameterWithIdenticalUpperBoundsC<T: UserInterface> {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: Invariant<T>)
+    }
+    fun <T: UserInterface> TestTypeParameterWithIdenticalUpperBoundsC(arg: Invariant<T>) {}
+
+    class TestTypeParameterWithIdenticalUpperBoundsCReverse<T: UserInterface> {
+        constructor(arg: Invariant<T>)
+    }
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> TestTypeParameterWithIdenticalUpperBoundsCReverse(arg: Invariant<T>) {}
+
+
+    class TestTypeParameterWithMultipleIdenticalUpperBoundsAA<T> where T: UserInterfaceA, T: UserInterfaceB {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor()
+    }
+    fun <T> TestTypeParameterWithMultipleIdenticalUpperBoundsAA() where T: UserInterfaceA, T: UserInterfaceB {}
+
+    class TestTypeParameterWithMultipleIdenticalUpperBoundsAAReverse<T> where T: UserInterfaceA, T: UserInterfaceB {
+        constructor()
+    }
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> TestTypeParameterWithMultipleIdenticalUpperBoundsAAReverse() where T: UserInterfaceA, T: UserInterfaceB {}
+
+    class TestTypeParameterWithMultipleIdenticalUpperBoundsAB<T> where T: UserInterfaceA, T: UserInterfaceB {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: T)
+    }
+    fun <T> TestTypeParameterWithMultipleIdenticalUpperBoundsAB(arg: T) where T: UserInterfaceA, T: UserInterfaceB {}
+
+    class TestTypeParameterWithMultipleIdenticalUpperBoundsABReverse<T> where T: UserInterfaceA, T: UserInterfaceB {
+        constructor(arg: T)
+    }
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> TestTypeParameterWithMultipleIdenticalUpperBoundsABReverse(arg: T) where T: UserInterfaceA, T: UserInterfaceB {}
+
+    class TestTypeParameterWithMultipleIdenticalUpperBoundsAC<T> where T: UserInterfaceA, T: UserInterfaceB {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: Invariant<T>)
+    }
+    fun <T> TestTypeParameterWithMultipleIdenticalUpperBoundsAC(arg: Invariant<T>) where T: UserInterfaceA, T: UserInterfaceB {}
+
+    class TestTypeParameterWithMultipleIdenticalUpperBoundsACReverse<T> where T: UserInterfaceA, T: UserInterfaceB {
+        constructor(arg: Invariant<T>)
+    }
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> TestTypeParameterWithMultipleIdenticalUpperBoundsACReverse(arg: Invariant<T>) where T: UserInterfaceA, T: UserInterfaceB {}
+
+    class TestTypeParameterWithMultipleIdenticalUpperBoundsBA<T: UserInterfaceA> where T: UserInterfaceB {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor()
+    }
+    fun <T: UserInterfaceA> TestTypeParameterWithMultipleIdenticalUpperBoundsBA() where T: UserInterfaceB {}
+
+    class TestTypeParameterWithMultipleIdenticalUpperBoundsBAReverse<T: UserInterfaceA> where T: UserInterfaceB {
+        constructor()
+    }
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> TestTypeParameterWithMultipleIdenticalUpperBoundsBAReverse() where T: UserInterfaceB {}
+
+    class TestTypeParameterWithMultipleIdenticalUpperBoundsBB<T: UserInterfaceA> where T: UserInterfaceB {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: T)
+    }
+    fun <T: UserInterfaceA> TestTypeParameterWithMultipleIdenticalUpperBoundsBB(arg: T) where T: UserInterfaceB {}
+
+    class TestTypeParameterWithMultipleIdenticalUpperBoundsBBReverse<T: UserInterfaceA> where T: UserInterfaceB {
+        constructor(arg: T)
+    }
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> TestTypeParameterWithMultipleIdenticalUpperBoundsBBReverse(arg: T) where T: UserInterfaceB {}
+
+    class TestTypeParameterWithMultipleIdenticalUpperBoundsBC<T: UserInterfaceA> where T: UserInterfaceB {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: Invariant<T>)
+    }
+    fun <T: UserInterfaceA> TestTypeParameterWithMultipleIdenticalUpperBoundsBC(arg: Invariant<T>) where T: UserInterfaceB {}
+
+    class TestTypeParameterWithMultipleIdenticalUpperBoundsBCReverse<T: UserInterfaceA> where T: UserInterfaceB {
+        constructor(arg: Invariant<T>)
+    }
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> TestTypeParameterWithMultipleIdenticalUpperBoundsBCReverse(arg: Invariant<T>) where T: UserInterfaceB {}
+
+
+    class TestIdenticalPrivateVisibility {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) private constructor()
+    }
+    private fun TestIdenticalPrivateVisibility() {}
+
+    class TestIdenticalPrivateVisibilityReverse {
+        private constructor()
+    }
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) private fun TestIdenticalPrivateVisibilityReverse() {}
+
+    class TestIdenticalInternalVisibility {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal constructor()
+    }
+    internal fun TestIdenticalInternalVisibility() {}
+
+    class TestIdenticalInternalVisibilityReverse {
+        internal constructor()
+    }
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal fun TestIdenticalInternalVisibilityReverse() {}
+
+    class TestDifferencesInPrivateAndPublicVisibilitiesA {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) private constructor()
+    }
+    public fun TestDifferencesInPrivateAndPublicVisibilitiesA() {}
+
+    class TestDifferencesInPrivateAndPublicVisibilitiesAReverse {
+        private constructor()
+    }
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) public fun TestDifferencesInPrivateAndPublicVisibilitiesAReverse() {}
+
+    class TestDifferencesInPrivateAndPublicVisibilitiesB {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) public constructor()
+    }
+    private fun TestDifferencesInPrivateAndPublicVisibilitiesB() {}
+
+    class TestDifferencesInPrivateAndPublicVisibilitiesBReverse {
+        public constructor()
+    }
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) private fun TestDifferencesInPrivateAndPublicVisibilitiesBReverse() {}
+
+    class TestDifferencesInInternalAndPublicVisibilitiesA {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal constructor()
+    }
+    public fun TestDifferencesInInternalAndPublicVisibilitiesA() {}
+
+    class TestDifferencesInInternalAndPublicVisibilitiesAReverse {
+        internal constructor()
+    }
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) public fun TestDifferencesInInternalAndPublicVisibilitiesAReverse() {}
+
+    class TestDifferencesInInternalAndPublicVisibilitiesB {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) public constructor()
+    }
+    internal fun TestDifferencesInInternalAndPublicVisibilitiesB() {}
+
+    class TestDifferencesInInternalAndPublicVisibilitiesBReverse {
+        public constructor()
+    }
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal fun TestDifferencesInInternalAndPublicVisibilitiesBReverse() {}
+
+    class TestDifferencesInPrivateAndInternalVisibilitiesA {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) private constructor()
+    }
+    internal fun TestDifferencesInPrivateAndInternalVisibilitiesA() {}
+
+    class TestDifferencesInPrivateAndInternalVisibilitiesAReverse {
+        private constructor()
+    }
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal fun TestDifferencesInPrivateAndInternalVisibilitiesAReverse() {}
+
+    class TestDifferencesInPrivateAndInternalVisibilitiesB {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal constructor()
+    }
+    private fun TestDifferencesInPrivateAndInternalVisibilitiesB() {}
+
+    class TestDifferencesInPrivateAndInternalVisibilitiesBReverse {
+        internal constructor()
+    }
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) private fun TestDifferencesInPrivateAndInternalVisibilitiesBReverse() {}
+
+
+}
+
+
+open class Invariant<T>
+
+
+class UserKlass
+class UserKlassA
+class UserKlassB
+typealias SameUserKlass = UserKlass
+typealias SameUserKlassA = UserKlassA
+typealias SameUserKlassB = UserKlassB
+
+
+interface UserInterface
+interface UserInterfaceA
+interface UserInterfaceB

compiler/testData/diagnostics/tests/overload/noConflictingOverloadsWithDeprecatedHidden/FunctionsAndConstructorsInMemberScope.kt

@@ -0,0 +1,436 @@
+// DIAGNOSTICS: -NOTHING_TO_INLINE, -NO_TAIL_CALLS_FOUND, -MISPLACED_TYPE_PARAMETER_CONSTRAINTS
+
+
+class MemberScope {
+
+
+    class TestBasic {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+    <!CONFLICTING_OVERLOADS!>fun TestBasic()<!> {}
+
+    class TestBasicReverse {
+        <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestBasicReverse()<!> {}
+
+
+    class TestIdenticalReturnTypes {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+    <!CONFLICTING_OVERLOADS!>fun TestIdenticalReturnTypes(): TestIdenticalReturnTypes<!> = TestIdenticalReturnTypes()
+
+    class TestIdenticalReturnTypesReverse {
+        <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestIdenticalReturnTypesReverse(): TestIdenticalReturnTypesReverse<!> = TestIdenticalReturnTypesReverse()
+
+
+    class TestFunctionWithReifiedTypeParameterVsConstructorA<T> {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+    <!CONFLICTING_OVERLOADS!>inline fun <reified T> TestFunctionWithReifiedTypeParameterVsConstructorA()<!> {}
+
+    class TestFunctionWithReifiedTypeParameterVsConstructorAReverse<T> {
+        <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> TestFunctionWithReifiedTypeParameterVsConstructorAReverse()<!> {}
+
+    class TestFunctionWithReifiedTypeParameterVsConstructorB<T> {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+    }
+    <!CONFLICTING_OVERLOADS!>inline fun <reified T> TestFunctionWithReifiedTypeParameterVsConstructorB(arg: T)<!> {}
+
+    class TestFunctionWithReifiedTypeParameterVsConstructorBReverse<T> {
+        <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+    }
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> TestFunctionWithReifiedTypeParameterVsConstructorBReverse(arg: T)<!> {}
+
+    class TestFunctionWithReifiedTypeParameterVsConstructorC<T> {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+    }
+    <!CONFLICTING_OVERLOADS!>inline fun <reified T> TestFunctionWithReifiedTypeParameterVsConstructorC(arg: Invariant<T>)<!> {}
+
+    class TestFunctionWithReifiedTypeParameterVsConstructorCReverse<T> {
+        <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+    }
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> TestFunctionWithReifiedTypeParameterVsConstructorCReverse(arg: Invariant<T>)<!> {}
+
+
+    class TestInlineFunctionVsConstructor {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+    <!CONFLICTING_OVERLOADS!>inline fun TestInlineFunctionVsConstructor()<!> {}
+
+    class TestInlineFunctionVsConstructorReverse {
+        <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun TestInlineFunctionVsConstructorReverse()<!> {}
+
+
+    class TestTailrecFunctionVsConstructor {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+    <!CONFLICTING_OVERLOADS!>tailrec fun TestTailrecFunctionVsConstructor()<!> {}
+
+    class TestTailrecFunctionVsConstructorReverse {
+        <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) tailrec fun TestTailrecFunctionVsConstructorReverse()<!> {}
+
+
+    class TestFunctionVsPrimaryConstructor @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!>
+    <!CONFLICTING_OVERLOADS!>fun TestFunctionVsPrimaryConstructor()<!> {}
+
+    class TestFunctionVsPrimaryConstructorReverse <!CONFLICTING_OVERLOADS!>constructor()<!> {}
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestFunctionVsPrimaryConstructorReverse()<!> {}
+
+
+    class TestFunctionVsDelegatedPrimaryConstructorCall constructor(placeholder: UserKlass) {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!> : this(UserKlass())
+    }
+    <!CONFLICTING_OVERLOADS!>fun TestFunctionVsDelegatedPrimaryConstructorCall()<!> {}
+
+    class TestFunctionVsDelegatedPrimaryConstructorCallReverse constructor(placeholder: UserKlass) {
+        <!CONFLICTING_OVERLOADS!>constructor()<!> : this(UserKlass())
+    }
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestFunctionVsDelegatedPrimaryConstructorCallReverse()<!> {}
+
+
+    open class SuperConstructorSource constructor(placeholder: UserKlass)
+
+    class TestFunctionVsDelegatedSuperConstructorCall: SuperConstructorSource {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!> : super(UserKlass())
+    }
+    <!CONFLICTING_OVERLOADS!>fun TestFunctionVsDelegatedSuperConstructorCall()<!> {}
+
+    class TestFunctionVsDelegatedSuperConstructorCallReverse: SuperConstructorSource {
+        <!CONFLICTING_OVERLOADS!>constructor()<!> : super(UserKlass())
+    }
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestFunctionVsDelegatedSuperConstructorCallReverse()<!> {}
+
+
+    class TestIdenticalValueParameters {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass)<!>
+    }
+    <!CONFLICTING_OVERLOADS!>fun TestIdenticalValueParameters(arg: UserKlass)<!> {}
+
+    class TestIdenticalValueParametersReverse {
+        <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass)<!>
+    }
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestIdenticalValueParametersReverse(arg: UserKlass)<!> {}
+
+    class TestDifferentlyNamedValueParameters {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(argA: UserKlass)<!>
+    }
+    <!CONFLICTING_OVERLOADS!>fun TestDifferentlyNamedValueParameters(argB: UserKlass)<!> {}
+
+    class TestDifferentlyNamedValueParametersReverse {
+        <!CONFLICTING_OVERLOADS!>constructor(argA: UserKlass)<!>
+    }
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestDifferentlyNamedValueParametersReverse(argB: UserKlass)<!> {}
+
+    class TestTypeAliasedValueParameterTypesA {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass)<!>
+    }
+    <!CONFLICTING_OVERLOADS!>fun TestTypeAliasedValueParameterTypesA(arg: SameUserKlass)<!> {}
+
+    class TestTypeAliasedValueParameterTypesAReverse {
+        <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass)<!>
+    }
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestTypeAliasedValueParameterTypesAReverse(arg: SameUserKlass)<!> {}
+
+    class TestTypeAliasedValueParameterTypesB {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: SameUserKlass)<!>
+    }
+    <!CONFLICTING_OVERLOADS!>fun TestTypeAliasedValueParameterTypesB(arg: UserKlass)<!> {}
+
+    class TestTypeAliasedValueParameterTypesBReverse {
+        <!CONFLICTING_OVERLOADS!>constructor(arg: SameUserKlass)<!>
+    }
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestTypeAliasedValueParameterTypesBReverse(arg: UserKlass)<!> {}
+
+
+    class TestMultipleIdenticalValueParameters {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg1: UserKlassA, arg2: UserKlassB)<!>
+    }
+    <!CONFLICTING_OVERLOADS!>fun TestMultipleIdenticalValueParameters(arg1: UserKlassA, arg2: UserKlassB)<!> {}
+
+    class TestMultipleIdenticalValueParametersReverse {
+        <!CONFLICTING_OVERLOADS!>constructor(arg1: UserKlassA, arg2: UserKlassB)<!>
+    }
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestMultipleIdenticalValueParametersReverse(arg1: UserKlassA, arg2: UserKlassB)<!> {}
+
+    class TestMultipleDifferentlyNamedValueParametersA {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg1: UserKlassA, arg2A: UserKlassB)<!>
+    }
+    <!CONFLICTING_OVERLOADS!>fun TestMultipleDifferentlyNamedValueParametersA(arg1: UserKlassA, arg2B: UserKlassB)<!> {}
+
+    class TestMultipleDifferentlyNamedValueParametersAReverse {
+        <!CONFLICTING_OVERLOADS!>constructor(arg1: UserKlassA, arg2A: UserKlassB)<!>
+    }
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestMultipleDifferentlyNamedValueParametersAReverse(arg1: UserKlassA, arg2B: UserKlassB)<!> {}
+
+    class TestMultipleDifferentlyNamedValueParametersB {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg1A: UserKlassA, arg2A: UserKlassB)<!>
+    }
+    <!CONFLICTING_OVERLOADS!>fun TestMultipleDifferentlyNamedValueParametersB(arg1B: UserKlassA, arg2B: UserKlassB)<!> {}
+
+    class TestMultipleDifferentlyNamedValueParametersBReverse {
+        <!CONFLICTING_OVERLOADS!>constructor(arg1A: UserKlassA, arg2A: UserKlassB)<!>
+    }
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestMultipleDifferentlyNamedValueParametersBReverse(arg1B: UserKlassA, arg2B: UserKlassB)<!> {}
+
+    class TestMultipleTypeAliasedValueParameterTypesA {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg1: UserKlassA, arg2: SameUserKlassB)<!>
+    }
+    <!CONFLICTING_OVERLOADS!>fun TestMultipleTypeAliasedValueParameterTypesA(arg1: UserKlassA, arg2: SameUserKlassB)<!> {}
+
+    class TestMultipleTypeAliasedValueParameterTypesAReverse {
+        <!CONFLICTING_OVERLOADS!>constructor(arg1: UserKlassA, arg2: SameUserKlassB)<!>
+    }
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestMultipleTypeAliasedValueParameterTypesAReverse(arg1: UserKlassA, arg2: SameUserKlassB)<!> {}
+
+    class TestMultipleTypeAliasedValueParameterTypesB {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg1: SameUserKlassA, arg2: SameUserKlassB)<!>
+    }
+    <!CONFLICTING_OVERLOADS!>fun TestMultipleTypeAliasedValueParameterTypesB(arg1: SameUserKlassA, arg2: SameUserKlassB)<!> {}
+
+    class TestMultipleTypeAliasedValueParameterTypesBReverse {
+        <!CONFLICTING_OVERLOADS!>constructor(arg1: SameUserKlassA, arg2: SameUserKlassB)<!>
+    }
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestMultipleTypeAliasedValueParameterTypesBReverse(arg1: SameUserKlassA, arg2: SameUserKlassB)<!> {}
+
+
+    class TestIdenticalTypeParametersA<T> {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+    <!CONFLICTING_OVERLOADS!>fun <T> TestIdenticalTypeParametersA()<!> {}
+
+    class TestIdenticalTypeParametersAReverse<T> {
+        <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> TestIdenticalTypeParametersAReverse()<!> {}
+
+    class TestIdenticalTypeParametersB<T> {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+    }
+    <!CONFLICTING_OVERLOADS!>fun <T> TestIdenticalTypeParametersB(arg: T)<!> {}
+
+    class TestIdenticalTypeParametersBReverse<T> {
+        <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+    }
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> TestIdenticalTypeParametersBReverse(arg: T)<!> {}
+
+    class TestIdenticalTypeParametersC<T> {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+    }
+    <!CONFLICTING_OVERLOADS!>fun <T> TestIdenticalTypeParametersC(arg: Invariant<T>)<!> {}
+
+    class TestIdenticalTypeParametersCReverse<T> {
+        <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+    }
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> TestIdenticalTypeParametersCReverse(arg: Invariant<T>)<!> {}
+
+
+    class TestMultipleIdenticalTypeParameters<T1, T2> {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+    <!CONFLICTING_OVERLOADS!>fun <T1, T2> TestMultipleIdenticalTypeParameters()<!> {}
+
+    class TestMultipleIdenticalTypeParametersReverse<T1, T2> {
+        <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T1, T2> TestMultipleIdenticalTypeParametersReverse()<!> {}
+
+
+    class TestTypeParameterWithIdenticalUpperBoundsA<T: UserInterface> {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+    <!CONFLICTING_OVERLOADS!>fun <T: UserInterface> TestTypeParameterWithIdenticalUpperBoundsA()<!> {}
+
+    class TestTypeParameterWithIdenticalUpperBoundsAReverse<T: UserInterface> {
+        <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> TestTypeParameterWithIdenticalUpperBoundsAReverse()<!> {}
+
+    class TestTypeParameterWithIdenticalUpperBoundsB<T: UserInterface> {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+    }
+    <!CONFLICTING_OVERLOADS!>fun <T: UserInterface> TestTypeParameterWithIdenticalUpperBoundsB(arg: T)<!> {}
+
+    class TestTypeParameterWithIdenticalUpperBoundsBReverse<T: UserInterface> {
+        <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+    }
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> TestTypeParameterWithIdenticalUpperBoundsBReverse(arg: T)<!> {}
+
+    class TestTypeParameterWithIdenticalUpperBoundsC<T: UserInterface> {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+    }
+    <!CONFLICTING_OVERLOADS!>fun <T: UserInterface> TestTypeParameterWithIdenticalUpperBoundsC(arg: Invariant<T>)<!> {}
+
+    class TestTypeParameterWithIdenticalUpperBoundsCReverse<T: UserInterface> {
+        <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+    }
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> TestTypeParameterWithIdenticalUpperBoundsCReverse(arg: Invariant<T>)<!> {}
+
+
+    class TestTypeParameterWithMultipleIdenticalUpperBoundsAA<T> where T: UserInterfaceA, T: UserInterfaceB {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+    <!CONFLICTING_OVERLOADS!>fun <T> TestTypeParameterWithMultipleIdenticalUpperBoundsAA()<!> where T: UserInterfaceA, T: UserInterfaceB {}
+
+    class TestTypeParameterWithMultipleIdenticalUpperBoundsAAReverse<T> where T: UserInterfaceA, T: UserInterfaceB {
+        <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> TestTypeParameterWithMultipleIdenticalUpperBoundsAAReverse()<!> where T: UserInterfaceA, T: UserInterfaceB {}
+
+    class TestTypeParameterWithMultipleIdenticalUpperBoundsAB<T> where T: UserInterfaceA, T: UserInterfaceB {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+    }
+    <!CONFLICTING_OVERLOADS!>fun <T> TestTypeParameterWithMultipleIdenticalUpperBoundsAB(arg: T)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+
+    class TestTypeParameterWithMultipleIdenticalUpperBoundsABReverse<T> where T: UserInterfaceA, T: UserInterfaceB {
+        <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+    }
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> TestTypeParameterWithMultipleIdenticalUpperBoundsABReverse(arg: T)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+
+    class TestTypeParameterWithMultipleIdenticalUpperBoundsAC<T> where T: UserInterfaceA, T: UserInterfaceB {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+    }
+    <!CONFLICTING_OVERLOADS!>fun <T> TestTypeParameterWithMultipleIdenticalUpperBoundsAC(arg: Invariant<T>)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+
+    class TestTypeParameterWithMultipleIdenticalUpperBoundsACReverse<T> where T: UserInterfaceA, T: UserInterfaceB {
+        <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+    }
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> TestTypeParameterWithMultipleIdenticalUpperBoundsACReverse(arg: Invariant<T>)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+
+    class TestTypeParameterWithMultipleIdenticalUpperBoundsBA<T: UserInterfaceA> where T: UserInterfaceB {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+    <!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceA> TestTypeParameterWithMultipleIdenticalUpperBoundsBA()<!> where T: UserInterfaceB {}
+
+    class TestTypeParameterWithMultipleIdenticalUpperBoundsBAReverse<T: UserInterfaceA> where T: UserInterfaceB {
+        <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> TestTypeParameterWithMultipleIdenticalUpperBoundsBAReverse()<!> where T: UserInterfaceB {}
+
+    class TestTypeParameterWithMultipleIdenticalUpperBoundsBB<T: UserInterfaceA> where T: UserInterfaceB {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+    }
+    <!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceA> TestTypeParameterWithMultipleIdenticalUpperBoundsBB(arg: T)<!> where T: UserInterfaceB {}
+
+    class TestTypeParameterWithMultipleIdenticalUpperBoundsBBReverse<T: UserInterfaceA> where T: UserInterfaceB {
+        <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+    }
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> TestTypeParameterWithMultipleIdenticalUpperBoundsBBReverse(arg: T)<!> where T: UserInterfaceB {}
+
+    class TestTypeParameterWithMultipleIdenticalUpperBoundsBC<T: UserInterfaceA> where T: UserInterfaceB {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+    }
+    <!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceA> TestTypeParameterWithMultipleIdenticalUpperBoundsBC(arg: Invariant<T>)<!> where T: UserInterfaceB {}
+
+    class TestTypeParameterWithMultipleIdenticalUpperBoundsBCReverse<T: UserInterfaceA> where T: UserInterfaceB {
+        <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+    }
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> TestTypeParameterWithMultipleIdenticalUpperBoundsBCReverse(arg: Invariant<T>)<!> where T: UserInterfaceB {}
+
+
+    class TestIdenticalPrivateVisibility {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) private <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+    <!CONFLICTING_OVERLOADS!>private fun TestIdenticalPrivateVisibility()<!> {}
+
+    class TestIdenticalPrivateVisibilityReverse {
+        private <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) private fun TestIdenticalPrivateVisibilityReverse()<!> {}
+
+    class TestIdenticalInternalVisibility {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+    <!CONFLICTING_OVERLOADS!>internal fun TestIdenticalInternalVisibility()<!> {}
+
+    class TestIdenticalInternalVisibilityReverse {
+        internal <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal fun TestIdenticalInternalVisibilityReverse()<!> {}
+
+    class TestDifferencesInPrivateAndPublicVisibilitiesA {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) private <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+    <!CONFLICTING_OVERLOADS!>public fun TestDifferencesInPrivateAndPublicVisibilitiesA()<!> {}
+
+    class TestDifferencesInPrivateAndPublicVisibilitiesAReverse {
+        private <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) public fun TestDifferencesInPrivateAndPublicVisibilitiesAReverse()<!> {}
+
+    class TestDifferencesInPrivateAndPublicVisibilitiesB {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) public <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+    <!CONFLICTING_OVERLOADS!>private fun TestDifferencesInPrivateAndPublicVisibilitiesB()<!> {}
+
+    class TestDifferencesInPrivateAndPublicVisibilitiesBReverse {
+        public <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) private fun TestDifferencesInPrivateAndPublicVisibilitiesBReverse()<!> {}
+
+    class TestDifferencesInInternalAndPublicVisibilitiesA {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+    <!CONFLICTING_OVERLOADS!>public fun TestDifferencesInInternalAndPublicVisibilitiesA()<!> {}
+
+    class TestDifferencesInInternalAndPublicVisibilitiesAReverse {
+        internal <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) public fun TestDifferencesInInternalAndPublicVisibilitiesAReverse()<!> {}
+
+    class TestDifferencesInInternalAndPublicVisibilitiesB {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) public <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+    <!CONFLICTING_OVERLOADS!>internal fun TestDifferencesInInternalAndPublicVisibilitiesB()<!> {}
+
+    class TestDifferencesInInternalAndPublicVisibilitiesBReverse {
+        public <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal fun TestDifferencesInInternalAndPublicVisibilitiesBReverse()<!> {}
+
+    class TestDifferencesInPrivateAndInternalVisibilitiesA {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) private <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+    <!CONFLICTING_OVERLOADS!>internal fun TestDifferencesInPrivateAndInternalVisibilitiesA()<!> {}
+
+    class TestDifferencesInPrivateAndInternalVisibilitiesAReverse {
+        private <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal fun TestDifferencesInPrivateAndInternalVisibilitiesAReverse()<!> {}
+
+    class TestDifferencesInPrivateAndInternalVisibilitiesB {
+        @Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+    <!CONFLICTING_OVERLOADS!>private fun TestDifferencesInPrivateAndInternalVisibilitiesB()<!> {}
+
+    class TestDifferencesInPrivateAndInternalVisibilitiesBReverse {
+        internal <!CONFLICTING_OVERLOADS!>constructor()<!>
+    }
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) private fun TestDifferencesInPrivateAndInternalVisibilitiesBReverse()<!> {}
+
+
+}
+
+
+open class Invariant<T>
+
+
+class UserKlass
+class UserKlassA
+class UserKlassB
+typealias SameUserKlass = UserKlass
+typealias SameUserKlassA = UserKlassA
+typealias SameUserKlassB = UserKlassB
+
+
+interface UserInterface
+interface UserInterfaceA
+interface UserInterfaceB

compiler/testData/diagnostics/tests/overload/noConflictingOverloadsWithDeprecatedHidden/FunctionsAndConstructorsInPackage.fir.kt

@@ -0,0 +1,432 @@
+// DIAGNOSTICS: -NOTHING_TO_INLINE, -NO_TAIL_CALLS_FOUND, -MISPLACED_TYPE_PARAMETER_CONSTRAINTS
+
+package pkg
+
+
+class TestBasic {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor()
+}
+fun TestBasic() {}
+
+class TestBasicReverse {
+    constructor()
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestBasicReverse() {}
+
+
+class TestIdenticalReturnTypes {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor()
+}
+fun TestIdenticalReturnTypes(): TestIdenticalReturnTypes = TestIdenticalReturnTypes()
+
+class TestIdenticalReturnTypesReverse {
+    constructor()
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestIdenticalReturnTypesReverse(): TestIdenticalReturnTypesReverse = TestIdenticalReturnTypesReverse()
+
+
+class TestFunctionWithReifiedTypeParameterVsConstructorA<T> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor()
+}
+inline fun <reified T> TestFunctionWithReifiedTypeParameterVsConstructorA() {}
+
+class TestFunctionWithReifiedTypeParameterVsConstructorAReverse<T> {
+    constructor()
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> TestFunctionWithReifiedTypeParameterVsConstructorAReverse() {}
+
+class TestFunctionWithReifiedTypeParameterVsConstructorB<T> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: T)
+}
+inline fun <reified T> TestFunctionWithReifiedTypeParameterVsConstructorB(arg: T) {}
+
+class TestFunctionWithReifiedTypeParameterVsConstructorBReverse<T> {
+    constructor(arg: T)
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> TestFunctionWithReifiedTypeParameterVsConstructorBReverse(arg: T) {}
+
+class TestFunctionWithReifiedTypeParameterVsConstructorC<T> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: Invariant<T>)
+}
+inline fun <reified T> TestFunctionWithReifiedTypeParameterVsConstructorC(arg: Invariant<T>) {}
+
+class TestFunctionWithReifiedTypeParameterVsConstructorCReverse<T> {
+    constructor(arg: Invariant<T>)
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> TestFunctionWithReifiedTypeParameterVsConstructorCReverse(arg: Invariant<T>) {}
+
+
+class TestInlineFunctionVsConstructor {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor()
+}
+inline fun TestInlineFunctionVsConstructor() {}
+
+class TestInlineFunctionVsConstructorReverse {
+    constructor()
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun TestInlineFunctionVsConstructorReverse() {}
+
+
+class TestTailrecFunctionVsConstructor {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor()
+}
+tailrec fun TestTailrecFunctionVsConstructor() {}
+
+class TestTailrecFunctionVsConstructorReverse {
+    constructor()
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) tailrec fun TestTailrecFunctionVsConstructorReverse() {}
+
+
+class TestFunctionVsPrimaryConstructor @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor()
+fun TestFunctionVsPrimaryConstructor() {}
+
+class TestFunctionVsPrimaryConstructorReverse constructor() {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestFunctionVsPrimaryConstructorReverse() {}
+
+
+class TestFunctionVsDelegatedPrimaryConstructorCall constructor(placeholder: UserKlass) {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor() : this(UserKlass())
+}
+fun TestFunctionVsDelegatedPrimaryConstructorCall() {}
+
+class TestFunctionVsDelegatedPrimaryConstructorCallReverse constructor(placeholder: UserKlass) {
+    constructor() : this(UserKlass())
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestFunctionVsDelegatedPrimaryConstructorCallReverse() {}
+
+
+open class SuperConstructorSource constructor(placeholder: UserKlass)
+
+class TestFunctionVsDelegatedSuperConstructorCall: SuperConstructorSource {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor() : super(UserKlass())
+}
+fun TestFunctionVsDelegatedSuperConstructorCall() {}
+
+class TestFunctionVsDelegatedSuperConstructorCallReverse: SuperConstructorSource {
+    constructor() : super(UserKlass())
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestFunctionVsDelegatedSuperConstructorCallReverse() {}
+
+
+class TestIdenticalValueParameters {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: UserKlass)
+}
+fun TestIdenticalValueParameters(arg: UserKlass) {}
+
+class TestIdenticalValueParametersReverse {
+    constructor(arg: UserKlass)
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestIdenticalValueParametersReverse(arg: UserKlass) {}
+
+class TestDifferentlyNamedValueParameters {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(argA: UserKlass)
+}
+fun TestDifferentlyNamedValueParameters(argB: UserKlass) {}
+
+class TestDifferentlyNamedValueParametersReverse {
+    constructor(argA: UserKlass)
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestDifferentlyNamedValueParametersReverse(argB: UserKlass) {}
+
+class TestTypeAliasedValueParameterTypesA {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: UserKlass)
+}
+fun TestTypeAliasedValueParameterTypesA(arg: SameUserKlass) {}
+
+class TestTypeAliasedValueParameterTypesAReverse {
+    constructor(arg: UserKlass)
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestTypeAliasedValueParameterTypesAReverse(arg: SameUserKlass) {}
+
+class TestTypeAliasedValueParameterTypesB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: SameUserKlass)
+}
+fun TestTypeAliasedValueParameterTypesB(arg: UserKlass) {}
+
+class TestTypeAliasedValueParameterTypesBReverse {
+    constructor(arg: SameUserKlass)
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestTypeAliasedValueParameterTypesBReverse(arg: UserKlass) {}
+
+
+class TestMultipleIdenticalValueParameters {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg1: UserKlassA, arg2: UserKlassB)
+}
+fun TestMultipleIdenticalValueParameters(arg1: UserKlassA, arg2: UserKlassB) {}
+
+class TestMultipleIdenticalValueParametersReverse {
+    constructor(arg1: UserKlassA, arg2: UserKlassB)
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestMultipleIdenticalValueParametersReverse(arg1: UserKlassA, arg2: UserKlassB) {}
+
+class TestMultipleDifferentlyNamedValueParametersA {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg1: UserKlassA, arg2A: UserKlassB)
+}
+fun TestMultipleDifferentlyNamedValueParametersA(arg1: UserKlassA, arg2B: UserKlassB) {}
+
+class TestMultipleDifferentlyNamedValueParametersAReverse {
+    constructor(arg1: UserKlassA, arg2A: UserKlassB)
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestMultipleDifferentlyNamedValueParametersAReverse(arg1: UserKlassA, arg2B: UserKlassB) {}
+
+class TestMultipleDifferentlyNamedValueParametersB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg1A: UserKlassA, arg2A: UserKlassB)
+}
+fun TestMultipleDifferentlyNamedValueParametersB(arg1B: UserKlassA, arg2B: UserKlassB) {}
+
+class TestMultipleDifferentlyNamedValueParametersBReverse {
+    constructor(arg1A: UserKlassA, arg2A: UserKlassB)
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestMultipleDifferentlyNamedValueParametersBReverse(arg1B: UserKlassA, arg2B: UserKlassB) {}
+
+class TestMultipleTypeAliasedValueParameterTypesA {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg1: UserKlassA, arg2: SameUserKlassB)
+}
+fun TestMultipleTypeAliasedValueParameterTypesA(arg1: UserKlassA, arg2: SameUserKlassB) {}
+
+class TestMultipleTypeAliasedValueParameterTypesAReverse {
+    constructor(arg1: UserKlassA, arg2: SameUserKlassB)
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestMultipleTypeAliasedValueParameterTypesAReverse(arg1: UserKlassA, arg2: SameUserKlassB) {}
+
+class TestMultipleTypeAliasedValueParameterTypesB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg1: SameUserKlassA, arg2: SameUserKlassB)
+}
+fun TestMultipleTypeAliasedValueParameterTypesB(arg1: SameUserKlassA, arg2: SameUserKlassB) {}
+
+class TestMultipleTypeAliasedValueParameterTypesBReverse {
+    constructor(arg1: SameUserKlassA, arg2: SameUserKlassB)
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestMultipleTypeAliasedValueParameterTypesBReverse(arg1: SameUserKlassA, arg2: SameUserKlassB) {}
+
+
+class TestIdenticalTypeParametersA<T> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor()
+}
+fun <T> TestIdenticalTypeParametersA() {}
+
+class TestIdenticalTypeParametersAReverse<T> {
+    constructor()
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> TestIdenticalTypeParametersAReverse() {}
+
+class TestIdenticalTypeParametersB<T> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: T)
+}
+fun <T> TestIdenticalTypeParametersB(arg: T) {}
+
+class TestIdenticalTypeParametersBReverse<T> {
+    constructor(arg: T)
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> TestIdenticalTypeParametersBReverse(arg: T) {}
+
+class TestIdenticalTypeParametersC<T> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: Invariant<T>)
+}
+fun <T> TestIdenticalTypeParametersC(arg: Invariant<T>) {}
+
+class TestIdenticalTypeParametersCReverse<T> {
+    constructor(arg: Invariant<T>)
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> TestIdenticalTypeParametersCReverse(arg: Invariant<T>) {}
+
+
+class TestMultipleIdenticalTypeParameters<T1, T2> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor()
+}
+fun <T1, T2> TestMultipleIdenticalTypeParameters() {}
+
+class TestMultipleIdenticalTypeParametersReverse<T1, T2> {
+    constructor()
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T1, T2> TestMultipleIdenticalTypeParametersReverse() {}
+
+
+class TestTypeParameterWithIdenticalUpperBoundsA<T: UserInterface> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor()
+}
+fun <T: UserInterface> TestTypeParameterWithIdenticalUpperBoundsA() {}
+
+class TestTypeParameterWithIdenticalUpperBoundsAReverse<T: UserInterface> {
+    constructor()
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> TestTypeParameterWithIdenticalUpperBoundsAReverse() {}
+
+class TestTypeParameterWithIdenticalUpperBoundsB<T: UserInterface> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: T)
+}
+fun <T: UserInterface> TestTypeParameterWithIdenticalUpperBoundsB(arg: T) {}
+
+class TestTypeParameterWithIdenticalUpperBoundsBReverse<T: UserInterface> {
+    constructor(arg: T)
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> TestTypeParameterWithIdenticalUpperBoundsBReverse(arg: T) {}
+
+class TestTypeParameterWithIdenticalUpperBoundsC<T: UserInterface> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: Invariant<T>)
+}
+fun <T: UserInterface> TestTypeParameterWithIdenticalUpperBoundsC(arg: Invariant<T>) {}
+
+class TestTypeParameterWithIdenticalUpperBoundsCReverse<T: UserInterface> {
+    constructor(arg: Invariant<T>)
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> TestTypeParameterWithIdenticalUpperBoundsCReverse(arg: Invariant<T>) {}
+
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsAA<T> where T: UserInterfaceA, T: UserInterfaceB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor()
+}
+fun <T> TestTypeParameterWithMultipleIdenticalUpperBoundsAA() where T: UserInterfaceA, T: UserInterfaceB {}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsAAReverse<T> where T: UserInterfaceA, T: UserInterfaceB {
+    constructor()
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> TestTypeParameterWithMultipleIdenticalUpperBoundsAAReverse() where T: UserInterfaceA, T: UserInterfaceB {}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsAB<T> where T: UserInterfaceA, T: UserInterfaceB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: T)
+}
+fun <T> TestTypeParameterWithMultipleIdenticalUpperBoundsAB(arg: T) where T: UserInterfaceA, T: UserInterfaceB {}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsABReverse<T> where T: UserInterfaceA, T: UserInterfaceB {
+    constructor(arg: T)
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> TestTypeParameterWithMultipleIdenticalUpperBoundsABReverse(arg: T) where T: UserInterfaceA, T: UserInterfaceB {}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsAC<T> where T: UserInterfaceA, T: UserInterfaceB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: Invariant<T>)
+}
+fun <T> TestTypeParameterWithMultipleIdenticalUpperBoundsAC(arg: Invariant<T>) where T: UserInterfaceA, T: UserInterfaceB {}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsACReverse<T> where T: UserInterfaceA, T: UserInterfaceB {
+    constructor(arg: Invariant<T>)
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> TestTypeParameterWithMultipleIdenticalUpperBoundsACReverse(arg: Invariant<T>) where T: UserInterfaceA, T: UserInterfaceB {}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsBA<T: UserInterfaceA> where T: UserInterfaceB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor()
+}
+fun <T: UserInterfaceA> TestTypeParameterWithMultipleIdenticalUpperBoundsBA() where T: UserInterfaceB {}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsBAReverse<T: UserInterfaceA> where T: UserInterfaceB {
+    constructor()
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> TestTypeParameterWithMultipleIdenticalUpperBoundsBAReverse() where T: UserInterfaceB {}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsBB<T: UserInterfaceA> where T: UserInterfaceB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: T)
+}
+fun <T: UserInterfaceA> TestTypeParameterWithMultipleIdenticalUpperBoundsBB(arg: T) where T: UserInterfaceB {}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsBBReverse<T: UserInterfaceA> where T: UserInterfaceB {
+    constructor(arg: T)
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> TestTypeParameterWithMultipleIdenticalUpperBoundsBBReverse(arg: T) where T: UserInterfaceB {}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsBC<T: UserInterfaceA> where T: UserInterfaceB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: Invariant<T>)
+}
+fun <T: UserInterfaceA> TestTypeParameterWithMultipleIdenticalUpperBoundsBC(arg: Invariant<T>) where T: UserInterfaceB {}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsBCReverse<T: UserInterfaceA> where T: UserInterfaceB {
+    constructor(arg: Invariant<T>)
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> TestTypeParameterWithMultipleIdenticalUpperBoundsBCReverse(arg: Invariant<T>) where T: UserInterfaceB {}
+
+
+class TestIdenticalPrivateVisibility {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) private constructor()
+}
+private fun TestIdenticalPrivateVisibility() {}
+
+class TestIdenticalPrivateVisibilityReverse {
+    private constructor()
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) private fun TestIdenticalPrivateVisibilityReverse() {}
+
+class TestIdenticalInternalVisibility {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal constructor()
+}
+internal fun TestIdenticalInternalVisibility() {}
+
+class TestIdenticalInternalVisibilityReverse {
+    internal constructor()
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal fun TestIdenticalInternalVisibilityReverse() {}
+
+class TestDifferencesInPrivateAndPublicVisibilitiesA {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) private constructor()
+}
+public fun TestDifferencesInPrivateAndPublicVisibilitiesA() {}
+
+class TestDifferencesInPrivateAndPublicVisibilitiesAReverse {
+    private constructor()
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) public fun TestDifferencesInPrivateAndPublicVisibilitiesAReverse() {}
+
+class TestDifferencesInPrivateAndPublicVisibilitiesB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) public constructor()
+}
+private fun TestDifferencesInPrivateAndPublicVisibilitiesB() {}
+
+class TestDifferencesInPrivateAndPublicVisibilitiesBReverse {
+    public constructor()
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) private fun TestDifferencesInPrivateAndPublicVisibilitiesBReverse() {}
+
+class TestDifferencesInInternalAndPublicVisibilitiesA {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal constructor()
+}
+public fun TestDifferencesInInternalAndPublicVisibilitiesA() {}
+
+class TestDifferencesInInternalAndPublicVisibilitiesAReverse {
+    internal constructor()
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) public fun TestDifferencesInInternalAndPublicVisibilitiesAReverse() {}
+
+class TestDifferencesInInternalAndPublicVisibilitiesB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) public constructor()
+}
+internal fun TestDifferencesInInternalAndPublicVisibilitiesB() {}
+
+class TestDifferencesInInternalAndPublicVisibilitiesBReverse {
+    public constructor()
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal fun TestDifferencesInInternalAndPublicVisibilitiesBReverse() {}
+
+class TestDifferencesInPrivateAndInternalVisibilitiesA {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) private constructor()
+}
+internal fun TestDifferencesInPrivateAndInternalVisibilitiesA() {}
+
+class TestDifferencesInPrivateAndInternalVisibilitiesAReverse {
+    private constructor()
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal fun TestDifferencesInPrivateAndInternalVisibilitiesAReverse() {}
+
+class TestDifferencesInPrivateAndInternalVisibilitiesB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal constructor()
+}
+private fun TestDifferencesInPrivateAndInternalVisibilitiesB() {}
+
+class TestDifferencesInPrivateAndInternalVisibilitiesBReverse {
+    internal constructor()
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) private fun TestDifferencesInPrivateAndInternalVisibilitiesBReverse() {}
+
+
+open class Invariant<T>
+
+
+class UserKlass
+class UserKlassA
+class UserKlassB
+typealias SameUserKlass = UserKlass
+typealias SameUserKlassA = UserKlassA
+typealias SameUserKlassB = UserKlassB
+
+
+interface UserInterface
+interface UserInterfaceA
+interface UserInterfaceB

compiler/testData/diagnostics/tests/overload/noConflictingOverloadsWithDeprecatedHidden/FunctionsAndConstructorsInPackage.kt

@@ -0,0 +1,432 @@
+// DIAGNOSTICS: -NOTHING_TO_INLINE, -NO_TAIL_CALLS_FOUND, -MISPLACED_TYPE_PARAMETER_CONSTRAINTS
+
+package pkg
+
+
+class TestBasic {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>fun TestBasic()<!> {}
+
+class TestBasicReverse {
+    <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestBasicReverse()<!> {}
+
+
+class TestIdenticalReturnTypes {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>fun TestIdenticalReturnTypes(): TestIdenticalReturnTypes<!> = TestIdenticalReturnTypes()
+
+class TestIdenticalReturnTypesReverse {
+    <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestIdenticalReturnTypesReverse(): TestIdenticalReturnTypesReverse<!> = TestIdenticalReturnTypesReverse()
+
+
+class TestFunctionWithReifiedTypeParameterVsConstructorA<T> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>inline fun <reified T> TestFunctionWithReifiedTypeParameterVsConstructorA()<!> {}
+
+class TestFunctionWithReifiedTypeParameterVsConstructorAReverse<T> {
+    <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> TestFunctionWithReifiedTypeParameterVsConstructorAReverse()<!> {}
+
+class TestFunctionWithReifiedTypeParameterVsConstructorB<T> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+}
+<!CONFLICTING_OVERLOADS!>inline fun <reified T> TestFunctionWithReifiedTypeParameterVsConstructorB(arg: T)<!> {}
+
+class TestFunctionWithReifiedTypeParameterVsConstructorBReverse<T> {
+    <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> TestFunctionWithReifiedTypeParameterVsConstructorBReverse(arg: T)<!> {}
+
+class TestFunctionWithReifiedTypeParameterVsConstructorC<T> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+}
+<!CONFLICTING_OVERLOADS!>inline fun <reified T> TestFunctionWithReifiedTypeParameterVsConstructorC(arg: Invariant<T>)<!> {}
+
+class TestFunctionWithReifiedTypeParameterVsConstructorCReverse<T> {
+    <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> TestFunctionWithReifiedTypeParameterVsConstructorCReverse(arg: Invariant<T>)<!> {}
+
+
+class TestInlineFunctionVsConstructor {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>inline fun TestInlineFunctionVsConstructor()<!> {}
+
+class TestInlineFunctionVsConstructorReverse {
+    <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun TestInlineFunctionVsConstructorReverse()<!> {}
+
+
+class TestTailrecFunctionVsConstructor {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>tailrec fun TestTailrecFunctionVsConstructor()<!> {}
+
+class TestTailrecFunctionVsConstructorReverse {
+    <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) tailrec fun TestTailrecFunctionVsConstructorReverse()<!> {}
+
+
+class TestFunctionVsPrimaryConstructor @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!>
+<!CONFLICTING_OVERLOADS!>fun TestFunctionVsPrimaryConstructor()<!> {}
+
+class TestFunctionVsPrimaryConstructorReverse <!CONFLICTING_OVERLOADS!>constructor()<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestFunctionVsPrimaryConstructorReverse()<!> {}
+
+
+class TestFunctionVsDelegatedPrimaryConstructorCall constructor(placeholder: UserKlass) {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!> : this(UserKlass())
+}
+<!CONFLICTING_OVERLOADS!>fun TestFunctionVsDelegatedPrimaryConstructorCall()<!> {}
+
+class TestFunctionVsDelegatedPrimaryConstructorCallReverse constructor(placeholder: UserKlass) {
+    <!CONFLICTING_OVERLOADS!>constructor()<!> : this(UserKlass())
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestFunctionVsDelegatedPrimaryConstructorCallReverse()<!> {}
+
+
+open class SuperConstructorSource constructor(placeholder: UserKlass)
+
+class TestFunctionVsDelegatedSuperConstructorCall: SuperConstructorSource {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!> : super(UserKlass())
+}
+<!CONFLICTING_OVERLOADS!>fun TestFunctionVsDelegatedSuperConstructorCall()<!> {}
+
+class TestFunctionVsDelegatedSuperConstructorCallReverse: SuperConstructorSource {
+    <!CONFLICTING_OVERLOADS!>constructor()<!> : super(UserKlass())
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestFunctionVsDelegatedSuperConstructorCallReverse()<!> {}
+
+
+class TestIdenticalValueParameters {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass)<!>
+}
+<!CONFLICTING_OVERLOADS!>fun TestIdenticalValueParameters(arg: UserKlass)<!> {}
+
+class TestIdenticalValueParametersReverse {
+    <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass)<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestIdenticalValueParametersReverse(arg: UserKlass)<!> {}
+
+class TestDifferentlyNamedValueParameters {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(argA: UserKlass)<!>
+}
+<!CONFLICTING_OVERLOADS!>fun TestDifferentlyNamedValueParameters(argB: UserKlass)<!> {}
+
+class TestDifferentlyNamedValueParametersReverse {
+    <!CONFLICTING_OVERLOADS!>constructor(argA: UserKlass)<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestDifferentlyNamedValueParametersReverse(argB: UserKlass)<!> {}
+
+class TestTypeAliasedValueParameterTypesA {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass)<!>
+}
+<!CONFLICTING_OVERLOADS!>fun TestTypeAliasedValueParameterTypesA(arg: SameUserKlass)<!> {}
+
+class TestTypeAliasedValueParameterTypesAReverse {
+    <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass)<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestTypeAliasedValueParameterTypesAReverse(arg: SameUserKlass)<!> {}
+
+class TestTypeAliasedValueParameterTypesB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: SameUserKlass)<!>
+}
+<!CONFLICTING_OVERLOADS!>fun TestTypeAliasedValueParameterTypesB(arg: UserKlass)<!> {}
+
+class TestTypeAliasedValueParameterTypesBReverse {
+    <!CONFLICTING_OVERLOADS!>constructor(arg: SameUserKlass)<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestTypeAliasedValueParameterTypesBReverse(arg: UserKlass)<!> {}
+
+
+class TestMultipleIdenticalValueParameters {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg1: UserKlassA, arg2: UserKlassB)<!>
+}
+<!CONFLICTING_OVERLOADS!>fun TestMultipleIdenticalValueParameters(arg1: UserKlassA, arg2: UserKlassB)<!> {}
+
+class TestMultipleIdenticalValueParametersReverse {
+    <!CONFLICTING_OVERLOADS!>constructor(arg1: UserKlassA, arg2: UserKlassB)<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestMultipleIdenticalValueParametersReverse(arg1: UserKlassA, arg2: UserKlassB)<!> {}
+
+class TestMultipleDifferentlyNamedValueParametersA {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg1: UserKlassA, arg2A: UserKlassB)<!>
+}
+<!CONFLICTING_OVERLOADS!>fun TestMultipleDifferentlyNamedValueParametersA(arg1: UserKlassA, arg2B: UserKlassB)<!> {}
+
+class TestMultipleDifferentlyNamedValueParametersAReverse {
+    <!CONFLICTING_OVERLOADS!>constructor(arg1: UserKlassA, arg2A: UserKlassB)<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestMultipleDifferentlyNamedValueParametersAReverse(arg1: UserKlassA, arg2B: UserKlassB)<!> {}
+
+class TestMultipleDifferentlyNamedValueParametersB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg1A: UserKlassA, arg2A: UserKlassB)<!>
+}
+<!CONFLICTING_OVERLOADS!>fun TestMultipleDifferentlyNamedValueParametersB(arg1B: UserKlassA, arg2B: UserKlassB)<!> {}
+
+class TestMultipleDifferentlyNamedValueParametersBReverse {
+    <!CONFLICTING_OVERLOADS!>constructor(arg1A: UserKlassA, arg2A: UserKlassB)<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestMultipleDifferentlyNamedValueParametersBReverse(arg1B: UserKlassA, arg2B: UserKlassB)<!> {}
+
+class TestMultipleTypeAliasedValueParameterTypesA {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg1: UserKlassA, arg2: SameUserKlassB)<!>
+}
+<!CONFLICTING_OVERLOADS!>fun TestMultipleTypeAliasedValueParameterTypesA(arg1: UserKlassA, arg2: SameUserKlassB)<!> {}
+
+class TestMultipleTypeAliasedValueParameterTypesAReverse {
+    <!CONFLICTING_OVERLOADS!>constructor(arg1: UserKlassA, arg2: SameUserKlassB)<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestMultipleTypeAliasedValueParameterTypesAReverse(arg1: UserKlassA, arg2: SameUserKlassB)<!> {}
+
+class TestMultipleTypeAliasedValueParameterTypesB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg1: SameUserKlassA, arg2: SameUserKlassB)<!>
+}
+<!CONFLICTING_OVERLOADS!>fun TestMultipleTypeAliasedValueParameterTypesB(arg1: SameUserKlassA, arg2: SameUserKlassB)<!> {}
+
+class TestMultipleTypeAliasedValueParameterTypesBReverse {
+    <!CONFLICTING_OVERLOADS!>constructor(arg1: SameUserKlassA, arg2: SameUserKlassB)<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestMultipleTypeAliasedValueParameterTypesBReverse(arg1: SameUserKlassA, arg2: SameUserKlassB)<!> {}
+
+
+class TestIdenticalTypeParametersA<T> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>fun <T> TestIdenticalTypeParametersA()<!> {}
+
+class TestIdenticalTypeParametersAReverse<T> {
+    <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> TestIdenticalTypeParametersAReverse()<!> {}
+
+class TestIdenticalTypeParametersB<T> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+}
+<!CONFLICTING_OVERLOADS!>fun <T> TestIdenticalTypeParametersB(arg: T)<!> {}
+
+class TestIdenticalTypeParametersBReverse<T> {
+    <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> TestIdenticalTypeParametersBReverse(arg: T)<!> {}
+
+class TestIdenticalTypeParametersC<T> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+}
+<!CONFLICTING_OVERLOADS!>fun <T> TestIdenticalTypeParametersC(arg: Invariant<T>)<!> {}
+
+class TestIdenticalTypeParametersCReverse<T> {
+    <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> TestIdenticalTypeParametersCReverse(arg: Invariant<T>)<!> {}
+
+
+class TestMultipleIdenticalTypeParameters<T1, T2> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>fun <T1, T2> TestMultipleIdenticalTypeParameters()<!> {}
+
+class TestMultipleIdenticalTypeParametersReverse<T1, T2> {
+    <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T1, T2> TestMultipleIdenticalTypeParametersReverse()<!> {}
+
+
+class TestTypeParameterWithIdenticalUpperBoundsA<T: UserInterface> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterface> TestTypeParameterWithIdenticalUpperBoundsA()<!> {}
+
+class TestTypeParameterWithIdenticalUpperBoundsAReverse<T: UserInterface> {
+    <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> TestTypeParameterWithIdenticalUpperBoundsAReverse()<!> {}
+
+class TestTypeParameterWithIdenticalUpperBoundsB<T: UserInterface> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+}
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterface> TestTypeParameterWithIdenticalUpperBoundsB(arg: T)<!> {}
+
+class TestTypeParameterWithIdenticalUpperBoundsBReverse<T: UserInterface> {
+    <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> TestTypeParameterWithIdenticalUpperBoundsBReverse(arg: T)<!> {}
+
+class TestTypeParameterWithIdenticalUpperBoundsC<T: UserInterface> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+}
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterface> TestTypeParameterWithIdenticalUpperBoundsC(arg: Invariant<T>)<!> {}
+
+class TestTypeParameterWithIdenticalUpperBoundsCReverse<T: UserInterface> {
+    <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> TestTypeParameterWithIdenticalUpperBoundsCReverse(arg: Invariant<T>)<!> {}
+
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsAA<T> where T: UserInterfaceA, T: UserInterfaceB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>fun <T> TestTypeParameterWithMultipleIdenticalUpperBoundsAA()<!> where T: UserInterfaceA, T: UserInterfaceB {}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsAAReverse<T> where T: UserInterfaceA, T: UserInterfaceB {
+    <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> TestTypeParameterWithMultipleIdenticalUpperBoundsAAReverse()<!> where T: UserInterfaceA, T: UserInterfaceB {}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsAB<T> where T: UserInterfaceA, T: UserInterfaceB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+}
+<!CONFLICTING_OVERLOADS!>fun <T> TestTypeParameterWithMultipleIdenticalUpperBoundsAB(arg: T)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsABReverse<T> where T: UserInterfaceA, T: UserInterfaceB {
+    <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> TestTypeParameterWithMultipleIdenticalUpperBoundsABReverse(arg: T)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsAC<T> where T: UserInterfaceA, T: UserInterfaceB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+}
+<!CONFLICTING_OVERLOADS!>fun <T> TestTypeParameterWithMultipleIdenticalUpperBoundsAC(arg: Invariant<T>)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsACReverse<T> where T: UserInterfaceA, T: UserInterfaceB {
+    <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> TestTypeParameterWithMultipleIdenticalUpperBoundsACReverse(arg: Invariant<T>)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsBA<T: UserInterfaceA> where T: UserInterfaceB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceA> TestTypeParameterWithMultipleIdenticalUpperBoundsBA()<!> where T: UserInterfaceB {}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsBAReverse<T: UserInterfaceA> where T: UserInterfaceB {
+    <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> TestTypeParameterWithMultipleIdenticalUpperBoundsBAReverse()<!> where T: UserInterfaceB {}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsBB<T: UserInterfaceA> where T: UserInterfaceB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+}
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceA> TestTypeParameterWithMultipleIdenticalUpperBoundsBB(arg: T)<!> where T: UserInterfaceB {}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsBBReverse<T: UserInterfaceA> where T: UserInterfaceB {
+    <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> TestTypeParameterWithMultipleIdenticalUpperBoundsBBReverse(arg: T)<!> where T: UserInterfaceB {}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsBC<T: UserInterfaceA> where T: UserInterfaceB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+}
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceA> TestTypeParameterWithMultipleIdenticalUpperBoundsBC(arg: Invariant<T>)<!> where T: UserInterfaceB {}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsBCReverse<T: UserInterfaceA> where T: UserInterfaceB {
+    <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> TestTypeParameterWithMultipleIdenticalUpperBoundsBCReverse(arg: Invariant<T>)<!> where T: UserInterfaceB {}
+
+
+class TestIdenticalPrivateVisibility {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) private <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>private fun TestIdenticalPrivateVisibility()<!> {}
+
+class TestIdenticalPrivateVisibilityReverse {
+    private <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) private fun TestIdenticalPrivateVisibilityReverse()<!> {}
+
+class TestIdenticalInternalVisibility {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>internal fun TestIdenticalInternalVisibility()<!> {}
+
+class TestIdenticalInternalVisibilityReverse {
+    internal <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal fun TestIdenticalInternalVisibilityReverse()<!> {}
+
+class TestDifferencesInPrivateAndPublicVisibilitiesA {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) private <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>public fun TestDifferencesInPrivateAndPublicVisibilitiesA()<!> {}
+
+class TestDifferencesInPrivateAndPublicVisibilitiesAReverse {
+    private <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) public fun TestDifferencesInPrivateAndPublicVisibilitiesAReverse()<!> {}
+
+class TestDifferencesInPrivateAndPublicVisibilitiesB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) public <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>private fun TestDifferencesInPrivateAndPublicVisibilitiesB()<!> {}
+
+class TestDifferencesInPrivateAndPublicVisibilitiesBReverse {
+    public <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) private fun TestDifferencesInPrivateAndPublicVisibilitiesBReverse()<!> {}
+
+class TestDifferencesInInternalAndPublicVisibilitiesA {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>public fun TestDifferencesInInternalAndPublicVisibilitiesA()<!> {}
+
+class TestDifferencesInInternalAndPublicVisibilitiesAReverse {
+    internal <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) public fun TestDifferencesInInternalAndPublicVisibilitiesAReverse()<!> {}
+
+class TestDifferencesInInternalAndPublicVisibilitiesB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) public <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>internal fun TestDifferencesInInternalAndPublicVisibilitiesB()<!> {}
+
+class TestDifferencesInInternalAndPublicVisibilitiesBReverse {
+    public <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal fun TestDifferencesInInternalAndPublicVisibilitiesBReverse()<!> {}
+
+class TestDifferencesInPrivateAndInternalVisibilitiesA {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) private <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>internal fun TestDifferencesInPrivateAndInternalVisibilitiesA()<!> {}
+
+class TestDifferencesInPrivateAndInternalVisibilitiesAReverse {
+    private <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal fun TestDifferencesInPrivateAndInternalVisibilitiesAReverse()<!> {}
+
+class TestDifferencesInPrivateAndInternalVisibilitiesB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>private fun TestDifferencesInPrivateAndInternalVisibilitiesB()<!> {}
+
+class TestDifferencesInPrivateAndInternalVisibilitiesBReverse {
+    internal <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) private fun TestDifferencesInPrivateAndInternalVisibilitiesBReverse()<!> {}
+
+
+open class Invariant<T>
+
+
+class UserKlass
+class UserKlassA
+class UserKlassB
+typealias SameUserKlass = UserKlass
+typealias SameUserKlassA = UserKlassA
+typealias SameUserKlassB = UserKlassB
+
+
+interface UserInterface
+interface UserInterfaceA
+interface UserInterfaceB

compiler/testData/diagnostics/tests/overload/noConflictingOverloadsWithDeprecatedHidden/FunctionsAndConstructorsOnTopLevel.fir.kt

@@ -0,0 +1,430 @@
+// DIAGNOSTICS: -NOTHING_TO_INLINE, -NO_TAIL_CALLS_FOUND, -MISPLACED_TYPE_PARAMETER_CONSTRAINTS
+
+
+class TestBasic {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor()
+}
+fun TestBasic() {}
+
+class TestBasicReverse {
+    constructor()
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestBasicReverse() {}
+
+
+class TestIdenticalReturnTypes {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor()
+}
+fun TestIdenticalReturnTypes(): TestIdenticalReturnTypes = TestIdenticalReturnTypes()
+
+class TestIdenticalReturnTypesReverse {
+    constructor()
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestIdenticalReturnTypesReverse(): TestIdenticalReturnTypesReverse = TestIdenticalReturnTypesReverse()
+
+
+class TestFunctionWithReifiedTypeParameterVsConstructorA<T> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor()
+}
+inline fun <reified T> TestFunctionWithReifiedTypeParameterVsConstructorA() {}
+
+class TestFunctionWithReifiedTypeParameterVsConstructorAReverse<T> {
+    constructor()
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> TestFunctionWithReifiedTypeParameterVsConstructorAReverse() {}
+
+class TestFunctionWithReifiedTypeParameterVsConstructorB<T> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: T)
+}
+inline fun <reified T> TestFunctionWithReifiedTypeParameterVsConstructorB(arg: T) {}
+
+class TestFunctionWithReifiedTypeParameterVsConstructorBReverse<T> {
+    constructor(arg: T)
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> TestFunctionWithReifiedTypeParameterVsConstructorBReverse(arg: T) {}
+
+class TestFunctionWithReifiedTypeParameterVsConstructorC<T> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: Invariant<T>)
+}
+inline fun <reified T> TestFunctionWithReifiedTypeParameterVsConstructorC(arg: Invariant<T>) {}
+
+class TestFunctionWithReifiedTypeParameterVsConstructorCReverse<T> {
+    constructor(arg: Invariant<T>)
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> TestFunctionWithReifiedTypeParameterVsConstructorCReverse(arg: Invariant<T>) {}
+
+
+class TestInlineFunctionVsConstructor {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor()
+}
+inline fun TestInlineFunctionVsConstructor() {}
+
+class TestInlineFunctionVsConstructorReverse {
+    constructor()
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun TestInlineFunctionVsConstructorReverse() {}
+
+
+class TestTailrecFunctionVsConstructor {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor()
+}
+tailrec fun TestTailrecFunctionVsConstructor() {}
+
+class TestTailrecFunctionVsConstructorReverse {
+    constructor()
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) tailrec fun TestTailrecFunctionVsConstructorReverse() {}
+
+
+class TestFunctionVsPrimaryConstructor @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor()
+fun TestFunctionVsPrimaryConstructor() {}
+
+class TestFunctionVsPrimaryConstructorReverse constructor() {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestFunctionVsPrimaryConstructorReverse() {}
+
+
+class TestFunctionVsDelegatedPrimaryConstructorCall constructor(placeholder: UserKlass) {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor() : this(UserKlass())
+}
+fun TestFunctionVsDelegatedPrimaryConstructorCall() {}
+
+class TestFunctionVsDelegatedPrimaryConstructorCallReverse constructor(placeholder: UserKlass) {
+    constructor() : this(UserKlass())
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestFunctionVsDelegatedPrimaryConstructorCallReverse() {}
+
+
+open class SuperConstructorSource constructor(placeholder: UserKlass)
+
+class TestFunctionVsDelegatedSuperConstructorCall: SuperConstructorSource {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor() : super(UserKlass())
+}
+fun TestFunctionVsDelegatedSuperConstructorCall() {}
+
+class TestFunctionVsDelegatedSuperConstructorCallReverse: SuperConstructorSource {
+    constructor() : super(UserKlass())
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestFunctionVsDelegatedSuperConstructorCallReverse() {}
+
+
+class TestIdenticalValueParameters {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: UserKlass)
+}
+fun TestIdenticalValueParameters(arg: UserKlass) {}
+
+class TestIdenticalValueParametersReverse {
+    constructor(arg: UserKlass)
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestIdenticalValueParametersReverse(arg: UserKlass) {}
+
+class TestDifferentlyNamedValueParameters {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(argA: UserKlass)
+}
+fun TestDifferentlyNamedValueParameters(argB: UserKlass) {}
+
+class TestDifferentlyNamedValueParametersReverse {
+    constructor(argA: UserKlass)
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestDifferentlyNamedValueParametersReverse(argB: UserKlass) {}
+
+class TestTypeAliasedValueParameterTypesA {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: UserKlass)
+}
+fun TestTypeAliasedValueParameterTypesA(arg: SameUserKlass) {}
+
+class TestTypeAliasedValueParameterTypesAReverse {
+    constructor(arg: UserKlass)
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestTypeAliasedValueParameterTypesAReverse(arg: SameUserKlass) {}
+
+class TestTypeAliasedValueParameterTypesB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: SameUserKlass)
+}
+fun TestTypeAliasedValueParameterTypesB(arg: UserKlass) {}
+
+class TestTypeAliasedValueParameterTypesBReverse {
+    constructor(arg: SameUserKlass)
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestTypeAliasedValueParameterTypesBReverse(arg: UserKlass) {}
+
+
+class TestMultipleIdenticalValueParameters {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg1: UserKlassA, arg2: UserKlassB)
+}
+fun TestMultipleIdenticalValueParameters(arg1: UserKlassA, arg2: UserKlassB) {}
+
+class TestMultipleIdenticalValueParametersReverse {
+    constructor(arg1: UserKlassA, arg2: UserKlassB)
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestMultipleIdenticalValueParametersReverse(arg1: UserKlassA, arg2: UserKlassB) {}
+
+class TestMultipleDifferentlyNamedValueParametersA {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg1: UserKlassA, arg2A: UserKlassB)
+}
+fun TestMultipleDifferentlyNamedValueParametersA(arg1: UserKlassA, arg2B: UserKlassB) {}
+
+class TestMultipleDifferentlyNamedValueParametersAReverse {
+    constructor(arg1: UserKlassA, arg2A: UserKlassB)
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestMultipleDifferentlyNamedValueParametersAReverse(arg1: UserKlassA, arg2B: UserKlassB) {}
+
+class TestMultipleDifferentlyNamedValueParametersB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg1A: UserKlassA, arg2A: UserKlassB)
+}
+fun TestMultipleDifferentlyNamedValueParametersB(arg1B: UserKlassA, arg2B: UserKlassB) {}
+
+class TestMultipleDifferentlyNamedValueParametersBReverse {
+    constructor(arg1A: UserKlassA, arg2A: UserKlassB)
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestMultipleDifferentlyNamedValueParametersBReverse(arg1B: UserKlassA, arg2B: UserKlassB) {}
+
+class TestMultipleTypeAliasedValueParameterTypesA {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg1: UserKlassA, arg2: SameUserKlassB)
+}
+fun TestMultipleTypeAliasedValueParameterTypesA(arg1: UserKlassA, arg2: SameUserKlassB) {}
+
+class TestMultipleTypeAliasedValueParameterTypesAReverse {
+    constructor(arg1: UserKlassA, arg2: SameUserKlassB)
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestMultipleTypeAliasedValueParameterTypesAReverse(arg1: UserKlassA, arg2: SameUserKlassB) {}
+
+class TestMultipleTypeAliasedValueParameterTypesB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg1: SameUserKlassA, arg2: SameUserKlassB)
+}
+fun TestMultipleTypeAliasedValueParameterTypesB(arg1: SameUserKlassA, arg2: SameUserKlassB) {}
+
+class TestMultipleTypeAliasedValueParameterTypesBReverse {
+    constructor(arg1: SameUserKlassA, arg2: SameUserKlassB)
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestMultipleTypeAliasedValueParameterTypesBReverse(arg1: SameUserKlassA, arg2: SameUserKlassB) {}
+
+
+class TestIdenticalTypeParametersA<T> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor()
+}
+fun <T> TestIdenticalTypeParametersA() {}
+
+class TestIdenticalTypeParametersAReverse<T> {
+    constructor()
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> TestIdenticalTypeParametersAReverse() {}
+
+class TestIdenticalTypeParametersB<T> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: T)
+}
+fun <T> TestIdenticalTypeParametersB(arg: T) {}
+
+class TestIdenticalTypeParametersBReverse<T> {
+    constructor(arg: T)
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> TestIdenticalTypeParametersBReverse(arg: T) {}
+
+class TestIdenticalTypeParametersC<T> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: Invariant<T>)
+}
+fun <T> TestIdenticalTypeParametersC(arg: Invariant<T>) {}
+
+class TestIdenticalTypeParametersCReverse<T> {
+    constructor(arg: Invariant<T>)
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> TestIdenticalTypeParametersCReverse(arg: Invariant<T>) {}
+
+
+class TestMultipleIdenticalTypeParameters<T1, T2> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor()
+}
+fun <T1, T2> TestMultipleIdenticalTypeParameters() {}
+
+class TestMultipleIdenticalTypeParametersReverse<T1, T2> {
+    constructor()
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T1, T2> TestMultipleIdenticalTypeParametersReverse() {}
+
+
+class TestTypeParameterWithIdenticalUpperBoundsA<T: UserInterface> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor()
+}
+fun <T: UserInterface> TestTypeParameterWithIdenticalUpperBoundsA() {}
+
+class TestTypeParameterWithIdenticalUpperBoundsAReverse<T: UserInterface> {
+    constructor()
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> TestTypeParameterWithIdenticalUpperBoundsAReverse() {}
+
+class TestTypeParameterWithIdenticalUpperBoundsB<T: UserInterface> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: T)
+}
+fun <T: UserInterface> TestTypeParameterWithIdenticalUpperBoundsB(arg: T) {}
+
+class TestTypeParameterWithIdenticalUpperBoundsBReverse<T: UserInterface> {
+    constructor(arg: T)
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> TestTypeParameterWithIdenticalUpperBoundsBReverse(arg: T) {}
+
+class TestTypeParameterWithIdenticalUpperBoundsC<T: UserInterface> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: Invariant<T>)
+}
+fun <T: UserInterface> TestTypeParameterWithIdenticalUpperBoundsC(arg: Invariant<T>) {}
+
+class TestTypeParameterWithIdenticalUpperBoundsCReverse<T: UserInterface> {
+    constructor(arg: Invariant<T>)
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> TestTypeParameterWithIdenticalUpperBoundsCReverse(arg: Invariant<T>) {}
+
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsAA<T> where T: UserInterfaceA, T: UserInterfaceB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor()
+}
+fun <T> TestTypeParameterWithMultipleIdenticalUpperBoundsAA() where T: UserInterfaceA, T: UserInterfaceB {}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsAAReverse<T> where T: UserInterfaceA, T: UserInterfaceB {
+    constructor()
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> TestTypeParameterWithMultipleIdenticalUpperBoundsAAReverse() where T: UserInterfaceA, T: UserInterfaceB {}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsAB<T> where T: UserInterfaceA, T: UserInterfaceB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: T)
+}
+fun <T> TestTypeParameterWithMultipleIdenticalUpperBoundsAB(arg: T) where T: UserInterfaceA, T: UserInterfaceB {}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsABReverse<T> where T: UserInterfaceA, T: UserInterfaceB {
+    constructor(arg: T)
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> TestTypeParameterWithMultipleIdenticalUpperBoundsABReverse(arg: T) where T: UserInterfaceA, T: UserInterfaceB {}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsAC<T> where T: UserInterfaceA, T: UserInterfaceB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: Invariant<T>)
+}
+fun <T> TestTypeParameterWithMultipleIdenticalUpperBoundsAC(arg: Invariant<T>) where T: UserInterfaceA, T: UserInterfaceB {}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsACReverse<T> where T: UserInterfaceA, T: UserInterfaceB {
+    constructor(arg: Invariant<T>)
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> TestTypeParameterWithMultipleIdenticalUpperBoundsACReverse(arg: Invariant<T>) where T: UserInterfaceA, T: UserInterfaceB {}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsBA<T: UserInterfaceA> where T: UserInterfaceB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor()
+}
+fun <T: UserInterfaceA> TestTypeParameterWithMultipleIdenticalUpperBoundsBA() where T: UserInterfaceB {}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsBAReverse<T: UserInterfaceA> where T: UserInterfaceB {
+    constructor()
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> TestTypeParameterWithMultipleIdenticalUpperBoundsBAReverse() where T: UserInterfaceB {}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsBB<T: UserInterfaceA> where T: UserInterfaceB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: T)
+}
+fun <T: UserInterfaceA> TestTypeParameterWithMultipleIdenticalUpperBoundsBB(arg: T) where T: UserInterfaceB {}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsBBReverse<T: UserInterfaceA> where T: UserInterfaceB {
+    constructor(arg: T)
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> TestTypeParameterWithMultipleIdenticalUpperBoundsBBReverse(arg: T) where T: UserInterfaceB {}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsBC<T: UserInterfaceA> where T: UserInterfaceB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) constructor(arg: Invariant<T>)
+}
+fun <T: UserInterfaceA> TestTypeParameterWithMultipleIdenticalUpperBoundsBC(arg: Invariant<T>) where T: UserInterfaceB {}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsBCReverse<T: UserInterfaceA> where T: UserInterfaceB {
+    constructor(arg: Invariant<T>)
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> TestTypeParameterWithMultipleIdenticalUpperBoundsBCReverse(arg: Invariant<T>) where T: UserInterfaceB {}
+
+
+class TestIdenticalPrivateVisibility {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) private constructor()
+}
+private fun TestIdenticalPrivateVisibility() {}
+
+class TestIdenticalPrivateVisibilityReverse {
+    private constructor()
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) private fun TestIdenticalPrivateVisibilityReverse() {}
+
+class TestIdenticalInternalVisibility {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal constructor()
+}
+internal fun TestIdenticalInternalVisibility() {}
+
+class TestIdenticalInternalVisibilityReverse {
+    internal constructor()
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal fun TestIdenticalInternalVisibilityReverse() {}
+
+class TestDifferencesInPrivateAndPublicVisibilitiesA {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) private constructor()
+}
+public fun TestDifferencesInPrivateAndPublicVisibilitiesA() {}
+
+class TestDifferencesInPrivateAndPublicVisibilitiesAReverse {
+    private constructor()
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) public fun TestDifferencesInPrivateAndPublicVisibilitiesAReverse() {}
+
+class TestDifferencesInPrivateAndPublicVisibilitiesB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) public constructor()
+}
+private fun TestDifferencesInPrivateAndPublicVisibilitiesB() {}
+
+class TestDifferencesInPrivateAndPublicVisibilitiesBReverse {
+    public constructor()
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) private fun TestDifferencesInPrivateAndPublicVisibilitiesBReverse() {}
+
+class TestDifferencesInInternalAndPublicVisibilitiesA {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal constructor()
+}
+public fun TestDifferencesInInternalAndPublicVisibilitiesA() {}
+
+class TestDifferencesInInternalAndPublicVisibilitiesAReverse {
+    internal constructor()
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) public fun TestDifferencesInInternalAndPublicVisibilitiesAReverse() {}
+
+class TestDifferencesInInternalAndPublicVisibilitiesB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) public constructor()
+}
+internal fun TestDifferencesInInternalAndPublicVisibilitiesB() {}
+
+class TestDifferencesInInternalAndPublicVisibilitiesBReverse {
+    public constructor()
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal fun TestDifferencesInInternalAndPublicVisibilitiesBReverse() {}
+
+class TestDifferencesInPrivateAndInternalVisibilitiesA {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) private constructor()
+}
+internal fun TestDifferencesInPrivateAndInternalVisibilitiesA() {}
+
+class TestDifferencesInPrivateAndInternalVisibilitiesAReverse {
+    private constructor()
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal fun TestDifferencesInPrivateAndInternalVisibilitiesAReverse() {}
+
+class TestDifferencesInPrivateAndInternalVisibilitiesB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal constructor()
+}
+private fun TestDifferencesInPrivateAndInternalVisibilitiesB() {}
+
+class TestDifferencesInPrivateAndInternalVisibilitiesBReverse {
+    internal constructor()
+}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) private fun TestDifferencesInPrivateAndInternalVisibilitiesBReverse() {}
+
+
+open class Invariant<T>
+
+
+class UserKlass
+class UserKlassA
+class UserKlassB
+typealias SameUserKlass = UserKlass
+typealias SameUserKlassA = UserKlassA
+typealias SameUserKlassB = UserKlassB
+
+
+interface UserInterface
+interface UserInterfaceA
+interface UserInterfaceB

compiler/testData/diagnostics/tests/overload/noConflictingOverloadsWithDeprecatedHidden/FunctionsAndConstructorsOnTopLevel.kt

@@ -0,0 +1,430 @@
+// DIAGNOSTICS: -NOTHING_TO_INLINE, -NO_TAIL_CALLS_FOUND, -MISPLACED_TYPE_PARAMETER_CONSTRAINTS
+
+
+class TestBasic {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>fun TestBasic()<!> {}
+
+class TestBasicReverse {
+    <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestBasicReverse()<!> {}
+
+
+class TestIdenticalReturnTypes {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>fun TestIdenticalReturnTypes(): TestIdenticalReturnTypes<!> = TestIdenticalReturnTypes()
+
+class TestIdenticalReturnTypesReverse {
+    <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestIdenticalReturnTypesReverse(): TestIdenticalReturnTypesReverse<!> = TestIdenticalReturnTypesReverse()
+
+
+class TestFunctionWithReifiedTypeParameterVsConstructorA<T> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>inline fun <reified T> TestFunctionWithReifiedTypeParameterVsConstructorA()<!> {}
+
+class TestFunctionWithReifiedTypeParameterVsConstructorAReverse<T> {
+    <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> TestFunctionWithReifiedTypeParameterVsConstructorAReverse()<!> {}
+
+class TestFunctionWithReifiedTypeParameterVsConstructorB<T> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+}
+<!CONFLICTING_OVERLOADS!>inline fun <reified T> TestFunctionWithReifiedTypeParameterVsConstructorB(arg: T)<!> {}
+
+class TestFunctionWithReifiedTypeParameterVsConstructorBReverse<T> {
+    <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> TestFunctionWithReifiedTypeParameterVsConstructorBReverse(arg: T)<!> {}
+
+class TestFunctionWithReifiedTypeParameterVsConstructorC<T> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+}
+<!CONFLICTING_OVERLOADS!>inline fun <reified T> TestFunctionWithReifiedTypeParameterVsConstructorC(arg: Invariant<T>)<!> {}
+
+class TestFunctionWithReifiedTypeParameterVsConstructorCReverse<T> {
+    <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> TestFunctionWithReifiedTypeParameterVsConstructorCReverse(arg: Invariant<T>)<!> {}
+
+
+class TestInlineFunctionVsConstructor {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>inline fun TestInlineFunctionVsConstructor()<!> {}
+
+class TestInlineFunctionVsConstructorReverse {
+    <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun TestInlineFunctionVsConstructorReverse()<!> {}
+
+
+class TestTailrecFunctionVsConstructor {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>tailrec fun TestTailrecFunctionVsConstructor()<!> {}
+
+class TestTailrecFunctionVsConstructorReverse {
+    <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) tailrec fun TestTailrecFunctionVsConstructorReverse()<!> {}
+
+
+class TestFunctionVsPrimaryConstructor @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!>
+<!CONFLICTING_OVERLOADS!>fun TestFunctionVsPrimaryConstructor()<!> {}
+
+class TestFunctionVsPrimaryConstructorReverse <!CONFLICTING_OVERLOADS!>constructor()<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestFunctionVsPrimaryConstructorReverse()<!> {}
+
+
+class TestFunctionVsDelegatedPrimaryConstructorCall constructor(placeholder: UserKlass) {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!> : this(UserKlass())
+}
+<!CONFLICTING_OVERLOADS!>fun TestFunctionVsDelegatedPrimaryConstructorCall()<!> {}
+
+class TestFunctionVsDelegatedPrimaryConstructorCallReverse constructor(placeholder: UserKlass) {
+    <!CONFLICTING_OVERLOADS!>constructor()<!> : this(UserKlass())
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestFunctionVsDelegatedPrimaryConstructorCallReverse()<!> {}
+
+
+open class SuperConstructorSource constructor(placeholder: UserKlass)
+
+class TestFunctionVsDelegatedSuperConstructorCall: SuperConstructorSource {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!> : super(UserKlass())
+}
+<!CONFLICTING_OVERLOADS!>fun TestFunctionVsDelegatedSuperConstructorCall()<!> {}
+
+class TestFunctionVsDelegatedSuperConstructorCallReverse: SuperConstructorSource {
+    <!CONFLICTING_OVERLOADS!>constructor()<!> : super(UserKlass())
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestFunctionVsDelegatedSuperConstructorCallReverse()<!> {}
+
+
+class TestIdenticalValueParameters {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass)<!>
+}
+<!CONFLICTING_OVERLOADS!>fun TestIdenticalValueParameters(arg: UserKlass)<!> {}
+
+class TestIdenticalValueParametersReverse {
+    <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass)<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestIdenticalValueParametersReverse(arg: UserKlass)<!> {}
+
+class TestDifferentlyNamedValueParameters {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(argA: UserKlass)<!>
+}
+<!CONFLICTING_OVERLOADS!>fun TestDifferentlyNamedValueParameters(argB: UserKlass)<!> {}
+
+class TestDifferentlyNamedValueParametersReverse {
+    <!CONFLICTING_OVERLOADS!>constructor(argA: UserKlass)<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestDifferentlyNamedValueParametersReverse(argB: UserKlass)<!> {}
+
+class TestTypeAliasedValueParameterTypesA {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass)<!>
+}
+<!CONFLICTING_OVERLOADS!>fun TestTypeAliasedValueParameterTypesA(arg: SameUserKlass)<!> {}
+
+class TestTypeAliasedValueParameterTypesAReverse {
+    <!CONFLICTING_OVERLOADS!>constructor(arg: UserKlass)<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestTypeAliasedValueParameterTypesAReverse(arg: SameUserKlass)<!> {}
+
+class TestTypeAliasedValueParameterTypesB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: SameUserKlass)<!>
+}
+<!CONFLICTING_OVERLOADS!>fun TestTypeAliasedValueParameterTypesB(arg: UserKlass)<!> {}
+
+class TestTypeAliasedValueParameterTypesBReverse {
+    <!CONFLICTING_OVERLOADS!>constructor(arg: SameUserKlass)<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestTypeAliasedValueParameterTypesBReverse(arg: UserKlass)<!> {}
+
+
+class TestMultipleIdenticalValueParameters {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg1: UserKlassA, arg2: UserKlassB)<!>
+}
+<!CONFLICTING_OVERLOADS!>fun TestMultipleIdenticalValueParameters(arg1: UserKlassA, arg2: UserKlassB)<!> {}
+
+class TestMultipleIdenticalValueParametersReverse {
+    <!CONFLICTING_OVERLOADS!>constructor(arg1: UserKlassA, arg2: UserKlassB)<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestMultipleIdenticalValueParametersReverse(arg1: UserKlassA, arg2: UserKlassB)<!> {}
+
+class TestMultipleDifferentlyNamedValueParametersA {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg1: UserKlassA, arg2A: UserKlassB)<!>
+}
+<!CONFLICTING_OVERLOADS!>fun TestMultipleDifferentlyNamedValueParametersA(arg1: UserKlassA, arg2B: UserKlassB)<!> {}
+
+class TestMultipleDifferentlyNamedValueParametersAReverse {
+    <!CONFLICTING_OVERLOADS!>constructor(arg1: UserKlassA, arg2A: UserKlassB)<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestMultipleDifferentlyNamedValueParametersAReverse(arg1: UserKlassA, arg2B: UserKlassB)<!> {}
+
+class TestMultipleDifferentlyNamedValueParametersB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg1A: UserKlassA, arg2A: UserKlassB)<!>
+}
+<!CONFLICTING_OVERLOADS!>fun TestMultipleDifferentlyNamedValueParametersB(arg1B: UserKlassA, arg2B: UserKlassB)<!> {}
+
+class TestMultipleDifferentlyNamedValueParametersBReverse {
+    <!CONFLICTING_OVERLOADS!>constructor(arg1A: UserKlassA, arg2A: UserKlassB)<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestMultipleDifferentlyNamedValueParametersBReverse(arg1B: UserKlassA, arg2B: UserKlassB)<!> {}
+
+class TestMultipleTypeAliasedValueParameterTypesA {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg1: UserKlassA, arg2: SameUserKlassB)<!>
+}
+<!CONFLICTING_OVERLOADS!>fun TestMultipleTypeAliasedValueParameterTypesA(arg1: UserKlassA, arg2: SameUserKlassB)<!> {}
+
+class TestMultipleTypeAliasedValueParameterTypesAReverse {
+    <!CONFLICTING_OVERLOADS!>constructor(arg1: UserKlassA, arg2: SameUserKlassB)<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestMultipleTypeAliasedValueParameterTypesAReverse(arg1: UserKlassA, arg2: SameUserKlassB)<!> {}
+
+class TestMultipleTypeAliasedValueParameterTypesB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg1: SameUserKlassA, arg2: SameUserKlassB)<!>
+}
+<!CONFLICTING_OVERLOADS!>fun TestMultipleTypeAliasedValueParameterTypesB(arg1: SameUserKlassA, arg2: SameUserKlassB)<!> {}
+
+class TestMultipleTypeAliasedValueParameterTypesBReverse {
+    <!CONFLICTING_OVERLOADS!>constructor(arg1: SameUserKlassA, arg2: SameUserKlassB)<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun TestMultipleTypeAliasedValueParameterTypesBReverse(arg1: SameUserKlassA, arg2: SameUserKlassB)<!> {}
+
+
+class TestIdenticalTypeParametersA<T> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>fun <T> TestIdenticalTypeParametersA()<!> {}
+
+class TestIdenticalTypeParametersAReverse<T> {
+    <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> TestIdenticalTypeParametersAReverse()<!> {}
+
+class TestIdenticalTypeParametersB<T> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+}
+<!CONFLICTING_OVERLOADS!>fun <T> TestIdenticalTypeParametersB(arg: T)<!> {}
+
+class TestIdenticalTypeParametersBReverse<T> {
+    <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> TestIdenticalTypeParametersBReverse(arg: T)<!> {}
+
+class TestIdenticalTypeParametersC<T> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+}
+<!CONFLICTING_OVERLOADS!>fun <T> TestIdenticalTypeParametersC(arg: Invariant<T>)<!> {}
+
+class TestIdenticalTypeParametersCReverse<T> {
+    <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> TestIdenticalTypeParametersCReverse(arg: Invariant<T>)<!> {}
+
+
+class TestMultipleIdenticalTypeParameters<T1, T2> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>fun <T1, T2> TestMultipleIdenticalTypeParameters()<!> {}
+
+class TestMultipleIdenticalTypeParametersReverse<T1, T2> {
+    <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T1, T2> TestMultipleIdenticalTypeParametersReverse()<!> {}
+
+
+class TestTypeParameterWithIdenticalUpperBoundsA<T: UserInterface> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterface> TestTypeParameterWithIdenticalUpperBoundsA()<!> {}
+
+class TestTypeParameterWithIdenticalUpperBoundsAReverse<T: UserInterface> {
+    <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> TestTypeParameterWithIdenticalUpperBoundsAReverse()<!> {}
+
+class TestTypeParameterWithIdenticalUpperBoundsB<T: UserInterface> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+}
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterface> TestTypeParameterWithIdenticalUpperBoundsB(arg: T)<!> {}
+
+class TestTypeParameterWithIdenticalUpperBoundsBReverse<T: UserInterface> {
+    <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> TestTypeParameterWithIdenticalUpperBoundsBReverse(arg: T)<!> {}
+
+class TestTypeParameterWithIdenticalUpperBoundsC<T: UserInterface> {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+}
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterface> TestTypeParameterWithIdenticalUpperBoundsC(arg: Invariant<T>)<!> {}
+
+class TestTypeParameterWithIdenticalUpperBoundsCReverse<T: UserInterface> {
+    <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> TestTypeParameterWithIdenticalUpperBoundsCReverse(arg: Invariant<T>)<!> {}
+
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsAA<T> where T: UserInterfaceA, T: UserInterfaceB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>fun <T> TestTypeParameterWithMultipleIdenticalUpperBoundsAA()<!> where T: UserInterfaceA, T: UserInterfaceB {}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsAAReverse<T> where T: UserInterfaceA, T: UserInterfaceB {
+    <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> TestTypeParameterWithMultipleIdenticalUpperBoundsAAReverse()<!> where T: UserInterfaceA, T: UserInterfaceB {}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsAB<T> where T: UserInterfaceA, T: UserInterfaceB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+}
+<!CONFLICTING_OVERLOADS!>fun <T> TestTypeParameterWithMultipleIdenticalUpperBoundsAB(arg: T)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsABReverse<T> where T: UserInterfaceA, T: UserInterfaceB {
+    <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> TestTypeParameterWithMultipleIdenticalUpperBoundsABReverse(arg: T)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsAC<T> where T: UserInterfaceA, T: UserInterfaceB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+}
+<!CONFLICTING_OVERLOADS!>fun <T> TestTypeParameterWithMultipleIdenticalUpperBoundsAC(arg: Invariant<T>)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsACReverse<T> where T: UserInterfaceA, T: UserInterfaceB {
+    <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> TestTypeParameterWithMultipleIdenticalUpperBoundsACReverse(arg: Invariant<T>)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsBA<T: UserInterfaceA> where T: UserInterfaceB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceA> TestTypeParameterWithMultipleIdenticalUpperBoundsBA()<!> where T: UserInterfaceB {}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsBAReverse<T: UserInterfaceA> where T: UserInterfaceB {
+    <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> TestTypeParameterWithMultipleIdenticalUpperBoundsBAReverse()<!> where T: UserInterfaceB {}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsBB<T: UserInterfaceA> where T: UserInterfaceB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+}
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceA> TestTypeParameterWithMultipleIdenticalUpperBoundsBB(arg: T)<!> where T: UserInterfaceB {}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsBBReverse<T: UserInterfaceA> where T: UserInterfaceB {
+    <!CONFLICTING_OVERLOADS!>constructor(arg: T)<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> TestTypeParameterWithMultipleIdenticalUpperBoundsBBReverse(arg: T)<!> where T: UserInterfaceB {}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsBC<T: UserInterfaceA> where T: UserInterfaceB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+}
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceA> TestTypeParameterWithMultipleIdenticalUpperBoundsBC(arg: Invariant<T>)<!> where T: UserInterfaceB {}
+
+class TestTypeParameterWithMultipleIdenticalUpperBoundsBCReverse<T: UserInterfaceA> where T: UserInterfaceB {
+    <!CONFLICTING_OVERLOADS!>constructor(arg: Invariant<T>)<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> TestTypeParameterWithMultipleIdenticalUpperBoundsBCReverse(arg: Invariant<T>)<!> where T: UserInterfaceB {}
+
+
+class TestIdenticalPrivateVisibility {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) private <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>private fun TestIdenticalPrivateVisibility()<!> {}
+
+class TestIdenticalPrivateVisibilityReverse {
+    private <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) private fun TestIdenticalPrivateVisibilityReverse()<!> {}
+
+class TestIdenticalInternalVisibility {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>internal fun TestIdenticalInternalVisibility()<!> {}
+
+class TestIdenticalInternalVisibilityReverse {
+    internal <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal fun TestIdenticalInternalVisibilityReverse()<!> {}
+
+class TestDifferencesInPrivateAndPublicVisibilitiesA {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) private <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>public fun TestDifferencesInPrivateAndPublicVisibilitiesA()<!> {}
+
+class TestDifferencesInPrivateAndPublicVisibilitiesAReverse {
+    private <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) public fun TestDifferencesInPrivateAndPublicVisibilitiesAReverse()<!> {}
+
+class TestDifferencesInPrivateAndPublicVisibilitiesB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) public <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>private fun TestDifferencesInPrivateAndPublicVisibilitiesB()<!> {}
+
+class TestDifferencesInPrivateAndPublicVisibilitiesBReverse {
+    public <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) private fun TestDifferencesInPrivateAndPublicVisibilitiesBReverse()<!> {}
+
+class TestDifferencesInInternalAndPublicVisibilitiesA {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>public fun TestDifferencesInInternalAndPublicVisibilitiesA()<!> {}
+
+class TestDifferencesInInternalAndPublicVisibilitiesAReverse {
+    internal <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) public fun TestDifferencesInInternalAndPublicVisibilitiesAReverse()<!> {}
+
+class TestDifferencesInInternalAndPublicVisibilitiesB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) public <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>internal fun TestDifferencesInInternalAndPublicVisibilitiesB()<!> {}
+
+class TestDifferencesInInternalAndPublicVisibilitiesBReverse {
+    public <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal fun TestDifferencesInInternalAndPublicVisibilitiesBReverse()<!> {}
+
+class TestDifferencesInPrivateAndInternalVisibilitiesA {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) private <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>internal fun TestDifferencesInPrivateAndInternalVisibilitiesA()<!> {}
+
+class TestDifferencesInPrivateAndInternalVisibilitiesAReverse {
+    private <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal fun TestDifferencesInPrivateAndInternalVisibilitiesAReverse()<!> {}
+
+class TestDifferencesInPrivateAndInternalVisibilitiesB {
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>private fun TestDifferencesInPrivateAndInternalVisibilitiesB()<!> {}
+
+class TestDifferencesInPrivateAndInternalVisibilitiesBReverse {
+    internal <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) private fun TestDifferencesInPrivateAndInternalVisibilitiesBReverse()<!> {}
+
+
+open class Invariant<T>
+
+
+class UserKlass
+class UserKlassA
+class UserKlassB
+typealias SameUserKlass = UserKlass
+typealias SameUserKlassA = UserKlassA
+typealias SameUserKlassB = UserKlassB
+
+
+interface UserInterface
+interface UserInterfaceA
+interface UserInterfaceB

compiler/testData/diagnostics/tests/overload/noConflictingOverloadsWithDeprecatedHidden/FunctionsInMemberScope.fir.kt

@@ -0,0 +1,500 @@
+// DIAGNOSTICS: -MISPLACED_TYPE_PARAMETER_CONSTRAINTS, -NOTHING_TO_INLINE, -NO_TAIL_CALLS_FOUND
+
+
+class MemberScope {
+
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testBasic() {}
+    fun testBasic() {}
+
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testIdenticalReturnTypes(): UserKlass = UserKlass()
+    fun testIdenticalReturnTypes(): UserKlass = UserKlass()
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testDifferencesInReturnTypePresence(): Unit {}
+    fun testDifferencesInReturnTypePresence() {}
+
+    fun testDifferencesInReturnTypePresenceReverse(): Unit {}
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testDifferencesInReturnTypePresenceReverse() {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testDifferentReturnTypes(): UserKlassA = UserKlassA()
+    fun testDifferentReturnTypes(): UserKlassB = UserKlassB()
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesA(): Invariant<UserKlass> = Invariant()
+    fun testVarianceDifferentReturnTypesA(): Invariant<out UserKlass> = Invariant()
+
+    fun testVarianceDifferentReturnTypesAReverse(): Invariant<UserKlass> = Invariant()
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesAReverse(): Invariant<out UserKlass> = Invariant()
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesB(): Invariant<UserKlass> = Invariant()
+    fun testVarianceDifferentReturnTypesB(): Invariant<in UserKlass> = Invariant()
+
+    fun testVarianceDifferentReturnTypesBReverse(): Invariant<UserKlass> = Invariant()
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesBReverse(): Invariant<in UserKlass> = Invariant()
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesC(): Invariant<UserKlass> = Invariant()
+    fun testVarianceDifferentReturnTypesC(): Invariant<*> = Invariant<UserKlass>()
+
+    fun testVarianceDifferentReturnTypesCReverse(): Invariant<UserKlass> = Invariant()
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesCReverse(): Invariant<*> = Invariant<UserKlass>()
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesD(): Invariant<out UserKlass> = Invariant()
+    fun testVarianceDifferentReturnTypesD(): Invariant<*> = Invariant<UserKlass>()
+
+    fun testVarianceDifferentReturnTypesDReverse(): Invariant<out UserKlass> = Invariant()
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesDReverse(): Invariant<*> = Invariant<UserKlass>()
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesE(): Invariant<in UserKlass> = Invariant()
+    fun testVarianceDifferentReturnTypesE(): Invariant<*> = Invariant<UserKlass>()
+
+    fun testVarianceDifferentReturnTypesEReverse(): Invariant<in UserKlass> = Invariant()
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesEReverse(): Invariant<*> = Invariant<UserKlass>()
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesF(): Invariant<out UserKlass> = Invariant()
+    fun testVarianceDifferentReturnTypesF(): Invariant<in UserKlass> = Invariant()
+
+    fun testVarianceDifferentReturnTypesFReverse(): Invariant<out UserKlass> = Invariant()
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesFReverse(): Invariant<in UserKlass> = Invariant()
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testTypeAliasedReturnTypes(): UserKlass = UserKlass()
+    fun testTypeAliasedReturnTypes(): SameUserKlass = UserKlass()
+
+    fun testTypeAliasedReturnTypesReverse(): UserKlass = UserKlass()
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testTypeAliasedReturnTypesReverse(): SameUserKlass = UserKlass()
+
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun UserKlass.testIdenticalExtensionReceivers() {}
+    fun UserKlass.testIdenticalExtensionReceivers() {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun UserKlass.testTypeAliasedExtensionReceivers() {}
+    fun SameUserKlass.testTypeAliasedExtensionReceivers() {}
+
+    fun UserKlass.testTypeAliasedExtensionReceiversReverse() {}
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun SameUserKlass.testTypeAliasedExtensionReceiversReverse() {}
+
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testIdenticalValueParameters(arg: UserKlass) {}
+    fun testIdenticalValueParameters(arg: UserKlass) {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testDifferentlyNamedValueParameters(argA: UserKlass) {}
+    fun testDifferentlyNamedValueParameters(argB: UserKlass) {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testTypeAliasedValueParameterTypes(arg: UserKlass) {}
+    fun testTypeAliasedValueParameterTypes(arg: SameUserKlass) {}
+
+    fun testTypeAliasedValueParameterTypesReverse(arg: UserKlass) {}
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testTypeAliasedValueParameterTypesReverse(arg: SameUserKlass) {}
+
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testMultipleIdenticalValueParameters(arg1: UserKlassA, arg2: UserKlassB) {}
+    fun testMultipleIdenticalValueParameters(arg1: UserKlassA, arg2: UserKlassB) {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testMultipleDifferentlyNamedValueParametersA(arg1: UserKlassA, arg2A: UserKlassB) {}
+    fun testMultipleDifferentlyNamedValueParametersA(arg1: UserKlassA, arg2B: UserKlassB) {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testMultipleDifferentlyNamedValueParametersB(arg1A: UserKlassA, arg2A: UserKlassB) {}
+    fun testMultipleDifferentlyNamedValueParametersB(arg1B: UserKlassA, arg2B: UserKlassB) {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testMultipleTypeAliasedValueParameterTypesA(arg1: UserKlassA, arg2: UserKlassB) {}
+    fun testMultipleTypeAliasedValueParameterTypesA(arg1: UserKlassA, arg2: SameUserKlassB) {}
+
+    fun testMultipleTypeAliasedValueParameterTypesAReverse(arg1: UserKlassA, arg2: UserKlassB) {}
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testMultipleTypeAliasedValueParameterTypesAReverse(arg1: UserKlassA, arg2: SameUserKlassB) {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testMultipleTypeAliasedValueParameterTypesB(arg1: UserKlassA, arg2: UserKlassB) {}
+    fun testMultipleTypeAliasedValueParameterTypesB(arg1: SameUserKlassA, arg2: SameUserKlassB) {}
+
+    fun testMultipleTypeAliasedValueParameterTypesBReverse(arg1: UserKlassA, arg2: UserKlassB) {}
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testMultipleTypeAliasedValueParameterTypesBReverse(arg1: SameUserKlassA, arg2: SameUserKlassB) {}
+
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testValueParameterWithIdenticalDefaultArguments(arg: UserKlass = defaultArgument) {}
+    fun testValueParameterWithIdenticalDefaultArguments(arg: UserKlass = defaultArgument) {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testDifferencesInValueParameterDefaultArgumentsPresence(arg: UserKlass = defaultArgument) {}
+    fun testDifferencesInValueParameterDefaultArgumentsPresence(arg: UserKlass) {}
+
+    fun testDifferencesInValueParameterDefaultArgumentsPresenceReverse(arg: UserKlass = defaultArgument) {}
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testDifferencesInValueParameterDefaultArgumentsPresenceReverse(arg: UserKlass) {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testValueParameterWithDifferentDefaultArguments(arg: UserKlass = defaultArgumentA) {}
+    fun testValueParameterWithDifferentDefaultArguments(arg: UserKlass = defaultArgumentB) {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testValueParameterWithAliasedDefaultArguments(arg: UserKlass = defaultArgument) {}
+    fun testValueParameterWithAliasedDefaultArguments(arg: UserKlass = sameDefaultArgument) {}
+
+    fun testValueParameterWithAliasedDefaultArgumentsReverse(arg: UserKlass = defaultArgument) {}
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testValueParameterWithAliasedDefaultArgumentsReverse(arg: UserKlass = sameDefaultArgument) {}
+
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testIdenticalTypeParametersA() {}
+    fun <T> testIdenticalTypeParametersA() {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testIdenticalTypeParametersB(arg: T) {}
+    fun <T> testIdenticalTypeParametersB(arg: T) {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testIdenticalTypeParametersC(arg: Invariant<T>) {}
+    fun <T> testIdenticalTypeParametersC(arg: Invariant<T>) {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <TA> testDifferentlyNamedTypeParametersA() {}
+    fun <TB> testDifferentlyNamedTypeParametersA() {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <TA> testDifferentlyNamedTypeParametersB(arg: TA) {}
+    fun <TB> testDifferentlyNamedTypeParametersB(arg: TB) {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <TA> testDifferentlyNamedTypeParametersC(arg: Invariant<TA>) {}
+    fun <TB> testDifferentlyNamedTypeParametersC(arg: Invariant<TB>) {}
+
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T1, T2> testMultipleIdenticalTypeParameters() {}
+    fun <T1, T2> testMultipleIdenticalTypeParameters() {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T1, T2A> testMultipleDifferentlyNamedTypeParametersA() {}
+    fun <T1, T2B> testMultipleDifferentlyNamedTypeParametersA() {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T1A, T2A> testMultipleDifferentlyNamedTypeParametersB() {}
+    fun <T1B, T2B> testMultipleDifferentlyNamedTypeParametersB() {}
+
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> testTypeParameterWithIdenticalUpperBoundsA() {}
+    fun <T: UserInterface> testTypeParameterWithIdenticalUpperBoundsA() {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> testTypeParameterWithIdenticalUpperBoundsB(arg: T) {}
+    fun <T: UserInterface> testTypeParameterWithIdenticalUpperBoundsB(arg: T) {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> testTypeParameterWithIdenticalUpperBoundsC(arg: Invariant<T>) {}
+    fun <T: UserInterface> testTypeParameterWithIdenticalUpperBoundsC(arg: Invariant<T>) {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> testDifferencesInTypeParameterUpperBoundsPresence() {}
+    fun <T> testDifferencesInTypeParameterUpperBoundsPresence() {}
+
+    fun <T: UserInterface> testDifferencesInTypeParameterUpperBoundsPresenceReverse() {}
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testDifferencesInTypeParameterUpperBoundsPresenceReverse() {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithDifferentUpperBounds() {}
+    fun <T: UserInterfaceB> testTypeParameterWithDifferentUpperBounds() {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsA() {}
+    fun <T: Invariant<out UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsA() {}
+
+    fun <T: Invariant<UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsAReverse() {}
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<out UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsAReverse() {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsB() {}
+    fun <T: Invariant<in UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsB() {}
+
+    fun <T: Invariant<UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsBReverse() {}
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<in UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsBReverse() {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsC() {}
+    fun <T: Invariant<*>> testTypeParameterWithVarianceDifferentUpperBoundsC() {}
+
+    fun <T: Invariant<UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsCReverse() {}
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<*>> testTypeParameterWithVarianceDifferentUpperBoundsCReverse() {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<out UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsD() {}
+    fun <T: Invariant<*>> testTypeParameterWithVarianceDifferentUpperBoundsD() {}
+
+    fun <T: Invariant<out UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsDReverse() {}
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<*>> testTypeParameterWithVarianceDifferentUpperBoundsDReverse() {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<in UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsE() {}
+    fun <T: Invariant<*>> testTypeParameterWithVarianceDifferentUpperBoundsE() {}
+
+    fun <T: Invariant<in UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsEReverse() {}
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<*>> testTypeParameterWithVarianceDifferentUpperBoundsEReverse() {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<out UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsF() {}
+    fun <T: Invariant<in UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsF() {}
+
+    fun <T: Invariant<out UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsFReverse() {}
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<in UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsFReverse() {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> testTypeParameterWithTypeAliasedUpperBoundsA() {}
+    fun <T: SameUserInterface> testTypeParameterWithTypeAliasedUpperBoundsA() {}
+
+    fun <T: UserInterface> testTypeParameterWithTypeAliasedUpperBoundsAReverse() {}
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterface> testTypeParameterWithTypeAliasedUpperBoundsAReverse() {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> testTypeParameterWithTypeAliasedUpperBoundsB(arg: T) {}
+    fun <T: SameUserInterface> testTypeParameterWithTypeAliasedUpperBoundsB(arg: T) {}
+
+    fun <T: UserInterface> testTypeParameterWithTypeAliasedUpperBoundsBReverse(arg: T) {}
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterface> testTypeParameterWithTypeAliasedUpperBoundsBReverse(arg: T) {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> testTypeParameterWithTypeAliasedUpperBoundsC(arg: Invariant<T>) {}
+    fun <T: SameUserInterface> testTypeParameterWithTypeAliasedUpperBoundsC(arg: Invariant<T>) {}
+
+    fun <T: UserInterface> testTypeParameterWithTypeAliasedUpperBoundsCReverse(arg: Invariant<T>) {}
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterface> testTypeParameterWithTypeAliasedUpperBoundsCReverse(arg: Invariant<T>) {}
+
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleIdenticalUpperBoundsAA() where T: UserInterfaceA, T: UserInterfaceB {}
+    fun <T> testTypeParameterWithMultipleIdenticalUpperBoundsAA() where T: UserInterfaceA, T: UserInterfaceB {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleIdenticalUpperBoundsAB(arg: T) where T: UserInterfaceA, T: UserInterfaceB {}
+    fun <T> testTypeParameterWithMultipleIdenticalUpperBoundsAB(arg: T) where T: UserInterfaceA, T: UserInterfaceB {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleIdenticalUpperBoundsAC(arg: Invariant<T>) where T: UserInterfaceA, T: UserInterfaceB {}
+    fun <T> testTypeParameterWithMultipleIdenticalUpperBoundsAC(arg: Invariant<T>) where T: UserInterfaceA, T: UserInterfaceB {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleIdenticalUpperBoundsBA() where T: UserInterfaceB {}
+    fun <T: UserInterfaceA> testTypeParameterWithMultipleIdenticalUpperBoundsBA() where T: UserInterfaceB {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleIdenticalUpperBoundsBB(arg: T) where T: UserInterfaceB {}
+    fun <T: UserInterfaceA> testTypeParameterWithMultipleIdenticalUpperBoundsBB(arg: T) where T: UserInterfaceB {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleIdenticalUpperBoundsBC(arg: Invariant<T>) where T: UserInterfaceB {}
+    fun <T: UserInterfaceA> testTypeParameterWithMultipleIdenticalUpperBoundsBC(arg: Invariant<T>) where T: UserInterfaceB {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testDifferencesInTypeParameterMultipleUpperBoundsPresenceA() where T: UserInterfaceA, T: UserInterfaceB {}
+    fun <T> testDifferencesInTypeParameterMultipleUpperBoundsPresenceA() where T: UserInterfaceA {}
+
+    fun <T: UserInterfaceA> testDifferencesInTypeParameterMultipleUpperBoundsPresenceB() where T: UserInterfaceB {}
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testDifferencesInTypeParameterMultipleUpperBoundsPresenceB() {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleDifferentUpperBoundsAA() where T: UserInterfaceA, T: UserInterfaceB {}
+    fun <T> testTypeParameterWithMultipleDifferentUpperBoundsAA() where T: UserInterfaceA, T: UserInterfaceC {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleDifferentUpperBoundsAB() where T: UserInterfaceB {}
+    fun <T: UserInterfaceA> testTypeParameterWithMultipleDifferentUpperBoundsAB() where T: UserInterfaceC {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceB> testTypeParameterWithMultipleDifferentUpperBoundsAC() where T: UserInterfaceA {}
+    fun <T: UserInterfaceC> testTypeParameterWithMultipleDifferentUpperBoundsAC() where T: UserInterfaceA {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleDifferentUpperBoundsBA() where T: UserInterfaceA, T: UserInterfaceB {}
+    fun <T> testTypeParameterWithMultipleDifferentUpperBoundsBA() where T: UserInterfaceC, T: UserInterfaceD {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleDifferentUpperBoundsBB() where T: UserInterfaceB {}
+    fun <T: UserInterfaceC> testTypeParameterWithMultipleDifferentUpperBoundsBB() where T: UserInterfaceD {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAAA() where T: UserInterfaceA, T: UserInterfaceB {}
+    fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAAA() where T: UserInterfaceA, T: SameUserInterfaceB {}
+
+    fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAAAReverse() where T: UserInterfaceA, T: UserInterfaceB {}
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAAAReverse() where T: UserInterfaceA, T: SameUserInterfaceB {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAAB(arg: T) where T: UserInterfaceA, T: UserInterfaceB {}
+    fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAAB(arg: T) where T: UserInterfaceA, T: SameUserInterfaceB {}
+
+    fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAABReverse(arg: T) where T: UserInterfaceA, T: UserInterfaceB {}
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAABReverse(arg: T) where T: UserInterfaceA, T: SameUserInterfaceB {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAAC(arg: Invariant<T>) where T: UserInterfaceA, T: UserInterfaceB {}
+    fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAAC(arg: Invariant<T>) where T: UserInterfaceA, T: SameUserInterfaceB {}
+
+    fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAACReverse(arg: Invariant<T>) where T: UserInterfaceA, T: UserInterfaceB {}
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAACReverse(arg: Invariant<T>) where T: UserInterfaceA, T: SameUserInterfaceB {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABA() where T: UserInterfaceB {}
+    fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABA() where T: SameUserInterfaceB {}
+
+    fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABAReverse() where T: UserInterfaceB {}
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABAReverse() where T: SameUserInterfaceB {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABB(arg: T) where T: UserInterfaceB {}
+    fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABB(arg: T) where T: SameUserInterfaceB {}
+
+    fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABBReverse(arg: T) where T: UserInterfaceB {}
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABBReverse(arg: T) where T: SameUserInterfaceB {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABC(arg: Invariant<T>) where T: UserInterfaceB {}
+    fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABC(arg: Invariant<T>) where T: SameUserInterfaceB {}
+
+    fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABCReverse(arg: Invariant<T>) where T: UserInterfaceB {}
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABCReverse(arg: Invariant<T>) where T: SameUserInterfaceB {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACA() where T: UserInterfaceA {}
+    fun <T: SameUserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACA() where T: UserInterfaceA {}
+
+    fun <T: UserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACAReverse() where T: UserInterfaceA {}
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACAReverse() where T: UserInterfaceA {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACB(arg: T) where T: UserInterfaceA {}
+    fun <T: SameUserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACB(arg: T) where T: UserInterfaceA {}
+
+    fun <T: UserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACBReverse(arg: T) where T: UserInterfaceA {}
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACBReverse(arg: T) where T: UserInterfaceA {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACC(arg: Invariant<T>) where T: UserInterfaceA {}
+    fun <T: SameUserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACC(arg: Invariant<T>) where T: UserInterfaceA {}
+
+    fun <T: UserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACCReverse(arg: Invariant<T>) where T: UserInterfaceA {}
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACCReverse(arg: Invariant<T>) where T: UserInterfaceA {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBAA() where T: UserInterfaceA, T: UserInterfaceB {}
+    fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBAA() where T: SameUserInterfaceA, T: SameUserInterfaceB {}
+
+    fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBAAReverse() where T: UserInterfaceA, T: UserInterfaceB {}
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBAAReverse() where T: SameUserInterfaceA, T: SameUserInterfaceB {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBAB(arg: T) where T: UserInterfaceA, T: UserInterfaceB {}
+    fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBAB(arg: T) where T: SameUserInterfaceA, T: SameUserInterfaceB {}
+
+    fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBABReverse(arg: T) where T: UserInterfaceA, T: UserInterfaceB {}
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBABReverse(arg: T) where T: SameUserInterfaceA, T: SameUserInterfaceB {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBAC(arg: Invariant<T>) where T: UserInterfaceA, T: UserInterfaceB {}
+    fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBAC(arg: Invariant<T>) where T: SameUserInterfaceA, T: SameUserInterfaceB {}
+
+    fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBACReverse(arg: Invariant<T>) where T: UserInterfaceA, T: UserInterfaceB {}
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBACReverse(arg: Invariant<T>) where T: SameUserInterfaceA, T: SameUserInterfaceB {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBA() where T: UserInterfaceB {}
+    fun <T: SameUserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBA() where T: SameUserInterfaceB {}
+
+    fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBAReverse() where T: UserInterfaceB {}
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBAReverse() where T: SameUserInterfaceB {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBB(arg: T) where T: UserInterfaceB {}
+    fun <T: SameUserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBB(arg: T) where T: SameUserInterfaceB {}
+
+    fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBBReverse(arg: T) where T: UserInterfaceB {}
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBBReverse(arg: T) where T: SameUserInterfaceB {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBC(arg: Invariant<T>) where T: UserInterfaceB {}
+    fun <T: SameUserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBC(arg: Invariant<T>) where T: SameUserInterfaceB {}
+
+    fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBCReverse(arg: Invariant<T>) where T: UserInterfaceB {}
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBCReverse(arg: Invariant<T>) where T: SameUserInterfaceB {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleShuffledUpperBoundsAA() where T: UserInterfaceA, T: UserInterfaceB {}
+    fun <T> testTypeParameterWithMultipleShuffledUpperBoundsAA() where T: UserInterfaceB, T: UserInterfaceA {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleShuffledUpperBoundsAB(arg: T) where T: UserInterfaceA, T: UserInterfaceB {}
+    fun <T> testTypeParameterWithMultipleShuffledUpperBoundsAB(arg: T) where T: UserInterfaceB, T: UserInterfaceA {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleShuffledUpperBoundsAC(arg: Invariant<T>) where T: UserInterfaceA, T: UserInterfaceB {}
+    fun <T> testTypeParameterWithMultipleShuffledUpperBoundsAC(arg: Invariant<T>) where T: UserInterfaceB, T: UserInterfaceA {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleShuffledUpperBoundsBA() where T: UserInterfaceB {}
+    fun <T: UserInterfaceB> testTypeParameterWithMultipleShuffledUpperBoundsBA() where T: UserInterfaceA {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleShuffledUpperBoundsBB(arg: T) where T: UserInterfaceB {}
+    fun <T: UserInterfaceB> testTypeParameterWithMultipleShuffledUpperBoundsBB(arg: T) where T: UserInterfaceA {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleShuffledUpperBoundsBC(arg: Invariant<T>) where T: UserInterfaceB {}
+    fun <T: UserInterfaceB> testTypeParameterWithMultipleShuffledUpperBoundsBC(arg: Invariant<T>) where T: UserInterfaceA {}
+
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> testIdenticalReifiedTypeParameterA() {}
+    inline fun <reified T> testIdenticalReifiedTypeParameterA() {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> testIdenticalReifiedTypeParameterB(arg: T) {}
+    inline fun <reified T> testIdenticalReifiedTypeParameterB(arg: T) {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> testIdenticalReifiedTypeParameterC(arg: Invariant<T>) {}
+    inline fun <reified T> testIdenticalReifiedTypeParameterC(arg: Invariant<T>) {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> testDifferencesInReifiedBehaviorOfTypeParameterA() {}
+    inline fun <T> testDifferencesInReifiedBehaviorOfTypeParameterA() {}
+
+    inline fun <reified T> testDifferencesInReifiedBehaviorOfTypeParameterAReverse() {}
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <T> testDifferencesInReifiedBehaviorOfTypeParameterAReverse() {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> testDifferencesInReifiedBehaviorOfTypeParameterB(arg: T) {}
+    inline fun <T> testDifferencesInReifiedBehaviorOfTypeParameterB(arg: T) {}
+
+    inline fun <reified T> testDifferencesInReifiedBehaviorOfTypeParameterBReverse(arg: T) {}
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <T> testDifferencesInReifiedBehaviorOfTypeParameterBReverse(arg: T) {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> testDifferencesInReifiedBehaviorOfTypeParameterC(arg: Invariant<T>) {}
+    inline fun <T> testDifferencesInReifiedBehaviorOfTypeParameterC(arg: Invariant<T>) {}
+
+    inline fun <reified T> testDifferencesInReifiedBehaviorOfTypeParameterCReverse(arg: Invariant<T>) {}
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <T> testDifferencesInReifiedBehaviorOfTypeParameterCReverse(arg: Invariant<T>) {}
+
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun testIdenticalPresenceOfInlineModifier() {}
+    inline fun testIdenticalPresenceOfInlineModifier() {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun testDifferencesInInlineModifierPresence() {}
+    fun testDifferencesInInlineModifierPresence() {}
+
+    inline fun testDifferencesInInlineModifierPresenceReverse() {}
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testDifferencesInInlineModifierPresenceReverse() {}
+
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) infix fun UserKlass.testIdenticalPresenceOfInfixModifier(arg: UserKlass) {}
+    infix fun UserKlass.testIdenticalPresenceOfInfixModifier(arg: UserKlass) {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) infix fun UserKlass.testDifferencesInInfixModifierPresence(arg: UserKlass) {}
+    fun UserKlass.testDifferencesInInfixModifierPresence(arg: UserKlass) {}
+
+    infix fun UserKlass.testDifferencesInInfixModifierPresenceReverse(arg: UserKlass) {}
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun UserKlass.testDifferencesInInfixModifierPresenceReverse(arg: UserKlass) {}
+
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) operator fun UserKlassA.unaryPlus() {}
+    operator fun UserKlassA.unaryPlus() {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) operator fun UserKlassB.unaryPlus() {}
+    fun UserKlassB.unaryPlus() {}
+
+    operator fun UserKlassB.unaryMinus() {}
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun UserKlassB.unaryMinus() {}
+
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) tailrec fun testIdenticalPresenceOfTailrecModifier() {}
+    tailrec fun testIdenticalPresenceOfTailrecModifier() {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) tailrec fun testDifferencesInTailrecModifierPresence() {}
+    fun testDifferencesInTailrecModifierPresence() {}
+
+    tailrec fun testDifferencesInTailrecModifierPresenceReverse() {}
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testDifferencesInTailrecModifierPresenceReverse() {}
+
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) private fun testIdenticalPrivateVisibility() {}
+    private fun testIdenticalPrivateVisibility() {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal fun testIdenticalInternalVisibility() {}
+    internal fun testIdenticalInternalVisibility() {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) private fun testDifferencesInPrivateAndPublicVisibilities() {}
+    public fun testDifferencesInPrivateAndPublicVisibilities() {}
+
+    private fun testDifferencesInPrivateAndPublicVisibilitiesReverse() {}
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) public fun testDifferencesInPrivateAndPublicVisibilitiesReverse() {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal fun testDifferencesInInternalAndPublicVisibilities() {}
+    public fun testDifferencesInInternalAndPublicVisibilities() {}
+
+    internal fun testDifferencesInInternalAndPublicVisibilitiesReverse() {}
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) public fun testDifferencesInInternalAndPublicVisibilitiesReverse() {}
+
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) private fun testDifferencesInPrivateAndInternalVisibilities() {}
+    internal fun testDifferencesInPrivateAndInternalVisibilities() {}
+
+    private fun testDifferencesInPrivateAndInternalVisibilitiesReverse() {}
+    @Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal fun testDifferencesInPrivateAndInternalVisibilitiesReverse() {}
+
+
+}
+
+
+open class Invariant<T>
+
+
+class UserKlass
+class UserKlassA
+class UserKlassB
+typealias SameUserKlass = UserKlass
+typealias SameUserKlassA = UserKlassA
+typealias SameUserKlassB = UserKlassB
+
+
+val defaultArgument = UserKlass()
+val defaultArgumentA = UserKlass()
+val defaultArgumentB = UserKlass()
+val sameDefaultArgument = defaultArgument
+
+
+interface UserInterface
+interface UserInterfaceA
+interface UserInterfaceB
+interface UserInterfaceC
+interface UserInterfaceD
+typealias SameUserInterface = UserInterface
+typealias SameUserInterfaceA = UserInterfaceA
+typealias SameUserInterfaceB = UserInterfaceB

compiler/testData/diagnostics/tests/overload/noConflictingOverloadsWithDeprecatedHidden/FunctionsInMemberScope.kt

@@ -0,0 +1,500 @@
+// DIAGNOSTICS: -MISPLACED_TYPE_PARAMETER_CONSTRAINTS, -NOTHING_TO_INLINE, -NO_TAIL_CALLS_FOUND
+
+
+class MemberScope {
+
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testBasic()<!> {}
+    <!CONFLICTING_OVERLOADS!>fun testBasic()<!> {}
+
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testIdenticalReturnTypes(): UserKlass<!> = UserKlass()
+    <!CONFLICTING_OVERLOADS!>fun testIdenticalReturnTypes(): UserKlass<!> = UserKlass()
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testDifferencesInReturnTypePresence(): Unit<!> {}
+    <!CONFLICTING_OVERLOADS!>fun testDifferencesInReturnTypePresence()<!> {}
+
+    <!CONFLICTING_OVERLOADS!>fun testDifferencesInReturnTypePresenceReverse(): Unit<!> {}
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testDifferencesInReturnTypePresenceReverse()<!> {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testDifferentReturnTypes(): UserKlassA<!> = UserKlassA()
+    <!CONFLICTING_OVERLOADS!>fun testDifferentReturnTypes(): UserKlassB<!> = UserKlassB()
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesA(): Invariant<UserKlass><!> = Invariant()
+    <!CONFLICTING_OVERLOADS!>fun testVarianceDifferentReturnTypesA(): Invariant<out UserKlass><!> = Invariant()
+
+    <!CONFLICTING_OVERLOADS!>fun testVarianceDifferentReturnTypesAReverse(): Invariant<UserKlass><!> = Invariant()
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesAReverse(): Invariant<out UserKlass><!> = Invariant()
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesB(): Invariant<UserKlass><!> = Invariant()
+    <!CONFLICTING_OVERLOADS!>fun testVarianceDifferentReturnTypesB(): Invariant<in UserKlass><!> = Invariant()
+
+    <!CONFLICTING_OVERLOADS!>fun testVarianceDifferentReturnTypesBReverse(): Invariant<UserKlass><!> = Invariant()
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesBReverse(): Invariant<in UserKlass><!> = Invariant()
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesC(): Invariant<UserKlass><!> = Invariant()
+    <!CONFLICTING_OVERLOADS!>fun testVarianceDifferentReturnTypesC(): Invariant<*><!> = Invariant<UserKlass>()
+
+    <!CONFLICTING_OVERLOADS!>fun testVarianceDifferentReturnTypesCReverse(): Invariant<UserKlass><!> = Invariant()
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesCReverse(): Invariant<*><!> = Invariant<UserKlass>()
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesD(): Invariant<out UserKlass><!> = Invariant()
+    <!CONFLICTING_OVERLOADS!>fun testVarianceDifferentReturnTypesD(): Invariant<*><!> = Invariant<UserKlass>()
+
+    <!CONFLICTING_OVERLOADS!>fun testVarianceDifferentReturnTypesDReverse(): Invariant<out UserKlass><!> = Invariant()
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesDReverse(): Invariant<*><!> = Invariant<UserKlass>()
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesE(): Invariant<in UserKlass><!> = Invariant()
+    <!CONFLICTING_OVERLOADS!>fun testVarianceDifferentReturnTypesE(): Invariant<*><!> = Invariant<UserKlass>()
+
+    <!CONFLICTING_OVERLOADS!>fun testVarianceDifferentReturnTypesEReverse(): Invariant<in UserKlass><!> = Invariant()
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesEReverse(): Invariant<*><!> = Invariant<UserKlass>()
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesF(): Invariant<out UserKlass><!> = Invariant()
+    <!CONFLICTING_OVERLOADS!>fun testVarianceDifferentReturnTypesF(): Invariant<in UserKlass><!> = Invariant()
+
+    <!CONFLICTING_OVERLOADS!>fun testVarianceDifferentReturnTypesFReverse(): Invariant<out UserKlass><!> = Invariant()
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesFReverse(): Invariant<in UserKlass><!> = Invariant()
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testTypeAliasedReturnTypes(): UserKlass<!> = UserKlass()
+    <!CONFLICTING_OVERLOADS!>fun testTypeAliasedReturnTypes(): SameUserKlass<!> = UserKlass()
+
+    <!CONFLICTING_OVERLOADS!>fun testTypeAliasedReturnTypesReverse(): UserKlass<!> = UserKlass()
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testTypeAliasedReturnTypesReverse(): SameUserKlass<!> = UserKlass()
+
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun UserKlass.testIdenticalExtensionReceivers()<!> {}
+    <!CONFLICTING_OVERLOADS!>fun UserKlass.testIdenticalExtensionReceivers()<!> {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun UserKlass.testTypeAliasedExtensionReceivers()<!> {}
+    <!CONFLICTING_OVERLOADS!>fun SameUserKlass.testTypeAliasedExtensionReceivers()<!> {}
+
+    <!CONFLICTING_OVERLOADS!>fun UserKlass.testTypeAliasedExtensionReceiversReverse()<!> {}
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun SameUserKlass.testTypeAliasedExtensionReceiversReverse()<!> {}
+
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testIdenticalValueParameters(arg: UserKlass)<!> {}
+    <!CONFLICTING_OVERLOADS!>fun testIdenticalValueParameters(arg: UserKlass)<!> {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testDifferentlyNamedValueParameters(argA: UserKlass)<!> {}
+    <!CONFLICTING_OVERLOADS!>fun testDifferentlyNamedValueParameters(argB: UserKlass)<!> {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testTypeAliasedValueParameterTypes(arg: UserKlass)<!> {}
+    <!CONFLICTING_OVERLOADS!>fun testTypeAliasedValueParameterTypes(arg: SameUserKlass)<!> {}
+
+    <!CONFLICTING_OVERLOADS!>fun testTypeAliasedValueParameterTypesReverse(arg: UserKlass)<!> {}
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testTypeAliasedValueParameterTypesReverse(arg: SameUserKlass)<!> {}
+
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testMultipleIdenticalValueParameters(arg1: UserKlassA, arg2: UserKlassB)<!> {}
+    <!CONFLICTING_OVERLOADS!>fun testMultipleIdenticalValueParameters(arg1: UserKlassA, arg2: UserKlassB)<!> {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testMultipleDifferentlyNamedValueParametersA(arg1: UserKlassA, arg2A: UserKlassB)<!> {}
+    <!CONFLICTING_OVERLOADS!>fun testMultipleDifferentlyNamedValueParametersA(arg1: UserKlassA, arg2B: UserKlassB)<!> {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testMultipleDifferentlyNamedValueParametersB(arg1A: UserKlassA, arg2A: UserKlassB)<!> {}
+    <!CONFLICTING_OVERLOADS!>fun testMultipleDifferentlyNamedValueParametersB(arg1B: UserKlassA, arg2B: UserKlassB)<!> {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testMultipleTypeAliasedValueParameterTypesA(arg1: UserKlassA, arg2: UserKlassB)<!> {}
+    <!CONFLICTING_OVERLOADS!>fun testMultipleTypeAliasedValueParameterTypesA(arg1: UserKlassA, arg2: SameUserKlassB)<!> {}
+
+    <!CONFLICTING_OVERLOADS!>fun testMultipleTypeAliasedValueParameterTypesAReverse(arg1: UserKlassA, arg2: UserKlassB)<!> {}
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testMultipleTypeAliasedValueParameterTypesAReverse(arg1: UserKlassA, arg2: SameUserKlassB)<!> {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testMultipleTypeAliasedValueParameterTypesB(arg1: UserKlassA, arg2: UserKlassB)<!> {}
+    <!CONFLICTING_OVERLOADS!>fun testMultipleTypeAliasedValueParameterTypesB(arg1: SameUserKlassA, arg2: SameUserKlassB)<!> {}
+
+    <!CONFLICTING_OVERLOADS!>fun testMultipleTypeAliasedValueParameterTypesBReverse(arg1: UserKlassA, arg2: UserKlassB)<!> {}
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testMultipleTypeAliasedValueParameterTypesBReverse(arg1: SameUserKlassA, arg2: SameUserKlassB)<!> {}
+
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testValueParameterWithIdenticalDefaultArguments(arg: UserKlass = defaultArgument)<!> {}
+    <!CONFLICTING_OVERLOADS!>fun testValueParameterWithIdenticalDefaultArguments(arg: UserKlass = defaultArgument)<!> {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testDifferencesInValueParameterDefaultArgumentsPresence(arg: UserKlass = defaultArgument)<!> {}
+    <!CONFLICTING_OVERLOADS!>fun testDifferencesInValueParameterDefaultArgumentsPresence(arg: UserKlass)<!> {}
+
+    <!CONFLICTING_OVERLOADS!>fun testDifferencesInValueParameterDefaultArgumentsPresenceReverse(arg: UserKlass = defaultArgument)<!> {}
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testDifferencesInValueParameterDefaultArgumentsPresenceReverse(arg: UserKlass)<!> {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testValueParameterWithDifferentDefaultArguments(arg: UserKlass = defaultArgumentA)<!> {}
+    <!CONFLICTING_OVERLOADS!>fun testValueParameterWithDifferentDefaultArguments(arg: UserKlass = defaultArgumentB)<!> {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testValueParameterWithAliasedDefaultArguments(arg: UserKlass = defaultArgument)<!> {}
+    <!CONFLICTING_OVERLOADS!>fun testValueParameterWithAliasedDefaultArguments(arg: UserKlass = sameDefaultArgument)<!> {}
+
+    <!CONFLICTING_OVERLOADS!>fun testValueParameterWithAliasedDefaultArgumentsReverse(arg: UserKlass = defaultArgument)<!> {}
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testValueParameterWithAliasedDefaultArgumentsReverse(arg: UserKlass = sameDefaultArgument)<!> {}
+
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testIdenticalTypeParametersA()<!> {}
+    <!CONFLICTING_OVERLOADS!>fun <T> testIdenticalTypeParametersA()<!> {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testIdenticalTypeParametersB(arg: T)<!> {}
+    <!CONFLICTING_OVERLOADS!>fun <T> testIdenticalTypeParametersB(arg: T)<!> {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testIdenticalTypeParametersC(arg: Invariant<T>)<!> {}
+    <!CONFLICTING_OVERLOADS!>fun <T> testIdenticalTypeParametersC(arg: Invariant<T>)<!> {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <TA> testDifferentlyNamedTypeParametersA()<!> {}
+    <!CONFLICTING_OVERLOADS!>fun <TB> testDifferentlyNamedTypeParametersA()<!> {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <TA> testDifferentlyNamedTypeParametersB(arg: TA)<!> {}
+    <!CONFLICTING_OVERLOADS!>fun <TB> testDifferentlyNamedTypeParametersB(arg: TB)<!> {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <TA> testDifferentlyNamedTypeParametersC(arg: Invariant<TA>)<!> {}
+    <!CONFLICTING_OVERLOADS!>fun <TB> testDifferentlyNamedTypeParametersC(arg: Invariant<TB>)<!> {}
+
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T1, T2> testMultipleIdenticalTypeParameters()<!> {}
+    <!CONFLICTING_OVERLOADS!>fun <T1, T2> testMultipleIdenticalTypeParameters()<!> {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T1, T2A> testMultipleDifferentlyNamedTypeParametersA()<!> {}
+    <!CONFLICTING_OVERLOADS!>fun <T1, T2B> testMultipleDifferentlyNamedTypeParametersA()<!> {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T1A, T2A> testMultipleDifferentlyNamedTypeParametersB()<!> {}
+    <!CONFLICTING_OVERLOADS!>fun <T1B, T2B> testMultipleDifferentlyNamedTypeParametersB()<!> {}
+
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> testTypeParameterWithIdenticalUpperBoundsA()<!> {}
+    <!CONFLICTING_OVERLOADS!>fun <T: UserInterface> testTypeParameterWithIdenticalUpperBoundsA()<!> {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> testTypeParameterWithIdenticalUpperBoundsB(arg: T)<!> {}
+    <!CONFLICTING_OVERLOADS!>fun <T: UserInterface> testTypeParameterWithIdenticalUpperBoundsB(arg: T)<!> {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> testTypeParameterWithIdenticalUpperBoundsC(arg: Invariant<T>)<!> {}
+    <!CONFLICTING_OVERLOADS!>fun <T: UserInterface> testTypeParameterWithIdenticalUpperBoundsC(arg: Invariant<T>)<!> {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> testDifferencesInTypeParameterUpperBoundsPresence()<!> {}
+    <!CONFLICTING_OVERLOADS!>fun <T> testDifferencesInTypeParameterUpperBoundsPresence()<!> {}
+
+    <!CONFLICTING_OVERLOADS!>fun <T: UserInterface> testDifferencesInTypeParameterUpperBoundsPresenceReverse()<!> {}
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testDifferencesInTypeParameterUpperBoundsPresenceReverse()<!> {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithDifferentUpperBounds()<!> {}
+    <!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceB> testTypeParameterWithDifferentUpperBounds()<!> {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsA()<!> {}
+    <!CONFLICTING_OVERLOADS!>fun <T: Invariant<out UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsA()<!> {}
+
+    <!CONFLICTING_OVERLOADS!>fun <T: Invariant<UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsAReverse()<!> {}
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<out UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsAReverse()<!> {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsB()<!> {}
+    <!CONFLICTING_OVERLOADS!>fun <T: Invariant<in UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsB()<!> {}
+
+    <!CONFLICTING_OVERLOADS!>fun <T: Invariant<UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsBReverse()<!> {}
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<in UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsBReverse()<!> {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsC()<!> {}
+    <!CONFLICTING_OVERLOADS!>fun <T: Invariant<*>> testTypeParameterWithVarianceDifferentUpperBoundsC()<!> {}
+
+    <!CONFLICTING_OVERLOADS!>fun <T: Invariant<UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsCReverse()<!> {}
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<*>> testTypeParameterWithVarianceDifferentUpperBoundsCReverse()<!> {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<out UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsD()<!> {}
+    <!CONFLICTING_OVERLOADS!>fun <T: Invariant<*>> testTypeParameterWithVarianceDifferentUpperBoundsD()<!> {}
+
+    <!CONFLICTING_OVERLOADS!>fun <T: Invariant<out UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsDReverse()<!> {}
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<*>> testTypeParameterWithVarianceDifferentUpperBoundsDReverse()<!> {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<in UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsE()<!> {}
+    <!CONFLICTING_OVERLOADS!>fun <T: Invariant<*>> testTypeParameterWithVarianceDifferentUpperBoundsE()<!> {}
+
+    <!CONFLICTING_OVERLOADS!>fun <T: Invariant<in UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsEReverse()<!> {}
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<*>> testTypeParameterWithVarianceDifferentUpperBoundsEReverse()<!> {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<out UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsF()<!> {}
+    <!CONFLICTING_OVERLOADS!>fun <T: Invariant<in UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsF()<!> {}
+
+    <!CONFLICTING_OVERLOADS!>fun <T: Invariant<out UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsFReverse()<!> {}
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<in UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsFReverse()<!> {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> testTypeParameterWithTypeAliasedUpperBoundsA()<!> {}
+    <!CONFLICTING_OVERLOADS!>fun <T: SameUserInterface> testTypeParameterWithTypeAliasedUpperBoundsA()<!> {}
+
+    <!CONFLICTING_OVERLOADS!>fun <T: UserInterface> testTypeParameterWithTypeAliasedUpperBoundsAReverse()<!> {}
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterface> testTypeParameterWithTypeAliasedUpperBoundsAReverse()<!> {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> testTypeParameterWithTypeAliasedUpperBoundsB(arg: T)<!> {}
+    <!CONFLICTING_OVERLOADS!>fun <T: SameUserInterface> testTypeParameterWithTypeAliasedUpperBoundsB(arg: T)<!> {}
+
+    <!CONFLICTING_OVERLOADS!>fun <T: UserInterface> testTypeParameterWithTypeAliasedUpperBoundsBReverse(arg: T)<!> {}
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterface> testTypeParameterWithTypeAliasedUpperBoundsBReverse(arg: T)<!> {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> testTypeParameterWithTypeAliasedUpperBoundsC(arg: Invariant<T>)<!> {}
+    <!CONFLICTING_OVERLOADS!>fun <T: SameUserInterface> testTypeParameterWithTypeAliasedUpperBoundsC(arg: Invariant<T>)<!> {}
+
+    <!CONFLICTING_OVERLOADS!>fun <T: UserInterface> testTypeParameterWithTypeAliasedUpperBoundsCReverse(arg: Invariant<T>)<!> {}
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterface> testTypeParameterWithTypeAliasedUpperBoundsCReverse(arg: Invariant<T>)<!> {}
+
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleIdenticalUpperBoundsAA()<!> where T: UserInterfaceA, T: UserInterfaceB {}
+    <!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleIdenticalUpperBoundsAA()<!> where T: UserInterfaceA, T: UserInterfaceB {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleIdenticalUpperBoundsAB(arg: T)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+    <!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleIdenticalUpperBoundsAB(arg: T)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleIdenticalUpperBoundsAC(arg: Invariant<T>)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+    <!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleIdenticalUpperBoundsAC(arg: Invariant<T>)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleIdenticalUpperBoundsBA()<!> where T: UserInterfaceB {}
+    <!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceA> testTypeParameterWithMultipleIdenticalUpperBoundsBA()<!> where T: UserInterfaceB {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleIdenticalUpperBoundsBB(arg: T)<!> where T: UserInterfaceB {}
+    <!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceA> testTypeParameterWithMultipleIdenticalUpperBoundsBB(arg: T)<!> where T: UserInterfaceB {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleIdenticalUpperBoundsBC(arg: Invariant<T>)<!> where T: UserInterfaceB {}
+    <!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceA> testTypeParameterWithMultipleIdenticalUpperBoundsBC(arg: Invariant<T>)<!> where T: UserInterfaceB {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testDifferencesInTypeParameterMultipleUpperBoundsPresenceA()<!> where T: UserInterfaceA, T: UserInterfaceB {}
+    <!CONFLICTING_OVERLOADS!>fun <T> testDifferencesInTypeParameterMultipleUpperBoundsPresenceA()<!> where T: UserInterfaceA {}
+
+    <!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceA> testDifferencesInTypeParameterMultipleUpperBoundsPresenceB()<!> where T: UserInterfaceB {}
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testDifferencesInTypeParameterMultipleUpperBoundsPresenceB()<!> {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleDifferentUpperBoundsAA()<!> where T: UserInterfaceA, T: UserInterfaceB {}
+    <!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleDifferentUpperBoundsAA()<!> where T: UserInterfaceA, T: UserInterfaceC {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleDifferentUpperBoundsAB()<!> where T: UserInterfaceB {}
+    <!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceA> testTypeParameterWithMultipleDifferentUpperBoundsAB()<!> where T: UserInterfaceC {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceB> testTypeParameterWithMultipleDifferentUpperBoundsAC()<!> where T: UserInterfaceA {}
+    <!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceC> testTypeParameterWithMultipleDifferentUpperBoundsAC()<!> where T: UserInterfaceA {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleDifferentUpperBoundsBA()<!> where T: UserInterfaceA, T: UserInterfaceB {}
+    <!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleDifferentUpperBoundsBA()<!> where T: UserInterfaceC, T: UserInterfaceD {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleDifferentUpperBoundsBB()<!> where T: UserInterfaceB {}
+    <!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceC> testTypeParameterWithMultipleDifferentUpperBoundsBB()<!> where T: UserInterfaceD {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAAA()<!> where T: UserInterfaceA, T: UserInterfaceB {}
+    <!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAAA()<!> where T: UserInterfaceA, T: SameUserInterfaceB {}
+
+    <!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAAAReverse()<!> where T: UserInterfaceA, T: UserInterfaceB {}
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAAAReverse()<!> where T: UserInterfaceA, T: SameUserInterfaceB {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAAB(arg: T)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+    <!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAAB(arg: T)<!> where T: UserInterfaceA, T: SameUserInterfaceB {}
+
+    <!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAABReverse(arg: T)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAABReverse(arg: T)<!> where T: UserInterfaceA, T: SameUserInterfaceB {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAAC(arg: Invariant<T>)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+    <!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAAC(arg: Invariant<T>)<!> where T: UserInterfaceA, T: SameUserInterfaceB {}
+
+    <!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAACReverse(arg: Invariant<T>)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAACReverse(arg: Invariant<T>)<!> where T: UserInterfaceA, T: SameUserInterfaceB {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABA()<!> where T: UserInterfaceB {}
+    <!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABA()<!> where T: SameUserInterfaceB {}
+
+    <!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABAReverse()<!> where T: UserInterfaceB {}
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABAReverse()<!> where T: SameUserInterfaceB {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABB(arg: T)<!> where T: UserInterfaceB {}
+    <!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABB(arg: T)<!> where T: SameUserInterfaceB {}
+
+    <!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABBReverse(arg: T)<!> where T: UserInterfaceB {}
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABBReverse(arg: T)<!> where T: SameUserInterfaceB {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABC(arg: Invariant<T>)<!> where T: UserInterfaceB {}
+    <!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABC(arg: Invariant<T>)<!> where T: SameUserInterfaceB {}
+
+    <!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABCReverse(arg: Invariant<T>)<!> where T: UserInterfaceB {}
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABCReverse(arg: Invariant<T>)<!> where T: SameUserInterfaceB {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACA()<!> where T: UserInterfaceA {}
+    <!CONFLICTING_OVERLOADS!>fun <T: SameUserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACA()<!> where T: UserInterfaceA {}
+
+    <!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACAReverse()<!> where T: UserInterfaceA {}
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACAReverse()<!> where T: UserInterfaceA {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACB(arg: T)<!> where T: UserInterfaceA {}
+    <!CONFLICTING_OVERLOADS!>fun <T: SameUserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACB(arg: T)<!> where T: UserInterfaceA {}
+
+    <!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACBReverse(arg: T)<!> where T: UserInterfaceA {}
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACBReverse(arg: T)<!> where T: UserInterfaceA {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACC(arg: Invariant<T>)<!> where T: UserInterfaceA {}
+    <!CONFLICTING_OVERLOADS!>fun <T: SameUserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACC(arg: Invariant<T>)<!> where T: UserInterfaceA {}
+
+    <!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACCReverse(arg: Invariant<T>)<!> where T: UserInterfaceA {}
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACCReverse(arg: Invariant<T>)<!> where T: UserInterfaceA {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBAA()<!> where T: UserInterfaceA, T: UserInterfaceB {}
+    <!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBAA()<!> where T: SameUserInterfaceA, T: SameUserInterfaceB {}
+
+    <!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBAAReverse()<!> where T: UserInterfaceA, T: UserInterfaceB {}
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBAAReverse()<!> where T: SameUserInterfaceA, T: SameUserInterfaceB {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBAB(arg: T)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+    <!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBAB(arg: T)<!> where T: SameUserInterfaceA, T: SameUserInterfaceB {}
+
+    <!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBABReverse(arg: T)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBABReverse(arg: T)<!> where T: SameUserInterfaceA, T: SameUserInterfaceB {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBAC(arg: Invariant<T>)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+    <!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBAC(arg: Invariant<T>)<!> where T: SameUserInterfaceA, T: SameUserInterfaceB {}
+
+    <!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBACReverse(arg: Invariant<T>)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBACReverse(arg: Invariant<T>)<!> where T: SameUserInterfaceA, T: SameUserInterfaceB {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBA()<!> where T: UserInterfaceB {}
+    <!CONFLICTING_OVERLOADS!>fun <T: SameUserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBA()<!> where T: SameUserInterfaceB {}
+
+    <!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBAReverse()<!> where T: UserInterfaceB {}
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBAReverse()<!> where T: SameUserInterfaceB {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBB(arg: T)<!> where T: UserInterfaceB {}
+    <!CONFLICTING_OVERLOADS!>fun <T: SameUserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBB(arg: T)<!> where T: SameUserInterfaceB {}
+
+    <!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBBReverse(arg: T)<!> where T: UserInterfaceB {}
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBBReverse(arg: T)<!> where T: SameUserInterfaceB {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBC(arg: Invariant<T>)<!> where T: UserInterfaceB {}
+    <!CONFLICTING_OVERLOADS!>fun <T: SameUserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBC(arg: Invariant<T>)<!> where T: SameUserInterfaceB {}
+
+    <!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBCReverse(arg: Invariant<T>)<!> where T: UserInterfaceB {}
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBCReverse(arg: Invariant<T>)<!> where T: SameUserInterfaceB {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleShuffledUpperBoundsAA()<!> where T: UserInterfaceA, T: UserInterfaceB {}
+    <!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleShuffledUpperBoundsAA()<!> where T: UserInterfaceB, T: UserInterfaceA {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleShuffledUpperBoundsAB(arg: T)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+    <!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleShuffledUpperBoundsAB(arg: T)<!> where T: UserInterfaceB, T: UserInterfaceA {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleShuffledUpperBoundsAC(arg: Invariant<T>)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+    <!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleShuffledUpperBoundsAC(arg: Invariant<T>)<!> where T: UserInterfaceB, T: UserInterfaceA {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleShuffledUpperBoundsBA()<!> where T: UserInterfaceB {}
+    <!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceB> testTypeParameterWithMultipleShuffledUpperBoundsBA()<!> where T: UserInterfaceA {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleShuffledUpperBoundsBB(arg: T)<!> where T: UserInterfaceB {}
+    <!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceB> testTypeParameterWithMultipleShuffledUpperBoundsBB(arg: T)<!> where T: UserInterfaceA {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleShuffledUpperBoundsBC(arg: Invariant<T>)<!> where T: UserInterfaceB {}
+    <!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceB> testTypeParameterWithMultipleShuffledUpperBoundsBC(arg: Invariant<T>)<!> where T: UserInterfaceA {}
+
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> testIdenticalReifiedTypeParameterA()<!> {}
+    <!CONFLICTING_OVERLOADS!>inline fun <reified T> testIdenticalReifiedTypeParameterA()<!> {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> testIdenticalReifiedTypeParameterB(arg: T)<!> {}
+    <!CONFLICTING_OVERLOADS!>inline fun <reified T> testIdenticalReifiedTypeParameterB(arg: T)<!> {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> testIdenticalReifiedTypeParameterC(arg: Invariant<T>)<!> {}
+    <!CONFLICTING_OVERLOADS!>inline fun <reified T> testIdenticalReifiedTypeParameterC(arg: Invariant<T>)<!> {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> testDifferencesInReifiedBehaviorOfTypeParameterA()<!> {}
+    <!CONFLICTING_OVERLOADS!>inline fun <T> testDifferencesInReifiedBehaviorOfTypeParameterA()<!> {}
+
+    <!CONFLICTING_OVERLOADS!>inline fun <reified T> testDifferencesInReifiedBehaviorOfTypeParameterAReverse()<!> {}
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <T> testDifferencesInReifiedBehaviorOfTypeParameterAReverse()<!> {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> testDifferencesInReifiedBehaviorOfTypeParameterB(arg: T)<!> {}
+    <!CONFLICTING_OVERLOADS!>inline fun <T> testDifferencesInReifiedBehaviorOfTypeParameterB(arg: T)<!> {}
+
+    <!CONFLICTING_OVERLOADS!>inline fun <reified T> testDifferencesInReifiedBehaviorOfTypeParameterBReverse(arg: T)<!> {}
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <T> testDifferencesInReifiedBehaviorOfTypeParameterBReverse(arg: T)<!> {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> testDifferencesInReifiedBehaviorOfTypeParameterC(arg: Invariant<T>)<!> {}
+    <!CONFLICTING_OVERLOADS!>inline fun <T> testDifferencesInReifiedBehaviorOfTypeParameterC(arg: Invariant<T>)<!> {}
+
+    <!CONFLICTING_OVERLOADS!>inline fun <reified T> testDifferencesInReifiedBehaviorOfTypeParameterCReverse(arg: Invariant<T>)<!> {}
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <T> testDifferencesInReifiedBehaviorOfTypeParameterCReverse(arg: Invariant<T>)<!> {}
+
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun testIdenticalPresenceOfInlineModifier()<!> {}
+    <!CONFLICTING_OVERLOADS!>inline fun testIdenticalPresenceOfInlineModifier()<!> {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun testDifferencesInInlineModifierPresence()<!> {}
+    <!CONFLICTING_OVERLOADS!>fun testDifferencesInInlineModifierPresence()<!> {}
+
+    <!CONFLICTING_OVERLOADS!>inline fun testDifferencesInInlineModifierPresenceReverse()<!> {}
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testDifferencesInInlineModifierPresenceReverse()<!> {}
+
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) infix fun UserKlass.testIdenticalPresenceOfInfixModifier(arg: UserKlass)<!> {}
+    <!CONFLICTING_OVERLOADS!>infix fun UserKlass.testIdenticalPresenceOfInfixModifier(arg: UserKlass)<!> {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) infix fun UserKlass.testDifferencesInInfixModifierPresence(arg: UserKlass)<!> {}
+    <!CONFLICTING_OVERLOADS!>fun UserKlass.testDifferencesInInfixModifierPresence(arg: UserKlass)<!> {}
+
+    <!CONFLICTING_OVERLOADS!>infix fun UserKlass.testDifferencesInInfixModifierPresenceReverse(arg: UserKlass)<!> {}
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun UserKlass.testDifferencesInInfixModifierPresenceReverse(arg: UserKlass)<!> {}
+
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) operator fun UserKlassA.unaryPlus()<!> {}
+    <!CONFLICTING_OVERLOADS!>operator fun UserKlassA.unaryPlus()<!> {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) operator fun UserKlassB.unaryPlus()<!> {}
+    <!CONFLICTING_OVERLOADS!>fun UserKlassB.unaryPlus()<!> {}
+
+    <!CONFLICTING_OVERLOADS!>operator fun UserKlassB.unaryMinus()<!> {}
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun UserKlassB.unaryMinus()<!> {}
+
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) tailrec fun testIdenticalPresenceOfTailrecModifier()<!> {}
+    <!CONFLICTING_OVERLOADS!>tailrec fun testIdenticalPresenceOfTailrecModifier()<!> {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) tailrec fun testDifferencesInTailrecModifierPresence()<!> {}
+    <!CONFLICTING_OVERLOADS!>fun testDifferencesInTailrecModifierPresence()<!> {}
+
+    <!CONFLICTING_OVERLOADS!>tailrec fun testDifferencesInTailrecModifierPresenceReverse()<!> {}
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testDifferencesInTailrecModifierPresenceReverse()<!> {}
+
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) private fun testIdenticalPrivateVisibility()<!> {}
+    <!CONFLICTING_OVERLOADS!>private fun testIdenticalPrivateVisibility()<!> {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal fun testIdenticalInternalVisibility()<!> {}
+    <!CONFLICTING_OVERLOADS!>internal fun testIdenticalInternalVisibility()<!> {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) private fun testDifferencesInPrivateAndPublicVisibilities()<!> {}
+    <!CONFLICTING_OVERLOADS!>public fun testDifferencesInPrivateAndPublicVisibilities()<!> {}
+
+    <!CONFLICTING_OVERLOADS!>private fun testDifferencesInPrivateAndPublicVisibilitiesReverse()<!> {}
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) public fun testDifferencesInPrivateAndPublicVisibilitiesReverse()<!> {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal fun testDifferencesInInternalAndPublicVisibilities()<!> {}
+    <!CONFLICTING_OVERLOADS!>public fun testDifferencesInInternalAndPublicVisibilities()<!> {}
+
+    <!CONFLICTING_OVERLOADS!>internal fun testDifferencesInInternalAndPublicVisibilitiesReverse()<!> {}
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) public fun testDifferencesInInternalAndPublicVisibilitiesReverse()<!> {}
+
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) private fun testDifferencesInPrivateAndInternalVisibilities()<!> {}
+    <!CONFLICTING_OVERLOADS!>internal fun testDifferencesInPrivateAndInternalVisibilities()<!> {}
+
+    <!CONFLICTING_OVERLOADS!>private fun testDifferencesInPrivateAndInternalVisibilitiesReverse()<!> {}
+    <!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal fun testDifferencesInPrivateAndInternalVisibilitiesReverse()<!> {}
+
+
+}
+
+
+open class Invariant<T>
+
+
+class UserKlass
+class UserKlassA
+class UserKlassB
+typealias SameUserKlass = UserKlass
+typealias SameUserKlassA = UserKlassA
+typealias SameUserKlassB = UserKlassB
+
+
+val defaultArgument = UserKlass()
+val defaultArgumentA = UserKlass()
+val defaultArgumentB = UserKlass()
+val sameDefaultArgument = defaultArgument
+
+
+interface UserInterface
+interface UserInterfaceA
+interface UserInterfaceB
+interface UserInterfaceC
+interface UserInterfaceD
+typealias SameUserInterface = UserInterface
+typealias SameUserInterfaceA = UserInterfaceA
+typealias SameUserInterfaceB = UserInterfaceB

compiler/testData/diagnostics/tests/overload/noConflictingOverloadsWithDeprecatedHidden/FunctionsInPackage.fir.kt

@@ -0,0 +1,496 @@
+// DIAGNOSTICS: -MISPLACED_TYPE_PARAMETER_CONSTRAINTS, -NOTHING_TO_INLINE, -NO_TAIL_CALLS_FOUND
+
+package pkg
+
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testBasic() {}
+fun testBasic() {}
+
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testIdenticalReturnTypes(): UserKlass = UserKlass()
+fun testIdenticalReturnTypes(): UserKlass = UserKlass()
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testDifferencesInReturnTypePresence(): Unit {}
+fun testDifferencesInReturnTypePresence() {}
+
+fun testDifferencesInReturnTypePresenceReverse(): Unit {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testDifferencesInReturnTypePresenceReverse() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testDifferentReturnTypes(): UserKlassA = UserKlassA()
+fun testDifferentReturnTypes(): UserKlassB = UserKlassB()
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesA(): Invariant<UserKlass> = Invariant()
+fun testVarianceDifferentReturnTypesA(): Invariant<out UserKlass> = Invariant()
+
+fun testVarianceDifferentReturnTypesAReverse(): Invariant<UserKlass> = Invariant()
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesAReverse(): Invariant<out UserKlass> = Invariant()
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesB(): Invariant<UserKlass> = Invariant()
+fun testVarianceDifferentReturnTypesB(): Invariant<in UserKlass> = Invariant()
+
+fun testVarianceDifferentReturnTypesBReverse(): Invariant<UserKlass> = Invariant()
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesBReverse(): Invariant<in UserKlass> = Invariant()
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesC(): Invariant<UserKlass> = Invariant()
+fun testVarianceDifferentReturnTypesC(): Invariant<*> = Invariant<UserKlass>()
+
+fun testVarianceDifferentReturnTypesCReverse(): Invariant<UserKlass> = Invariant()
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesCReverse(): Invariant<*> = Invariant<UserKlass>()
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesD(): Invariant<out UserKlass> = Invariant()
+fun testVarianceDifferentReturnTypesD(): Invariant<*> = Invariant<UserKlass>()
+
+fun testVarianceDifferentReturnTypesDReverse(): Invariant<out UserKlass> = Invariant()
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesDReverse(): Invariant<*> = Invariant<UserKlass>()
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesE(): Invariant<in UserKlass> = Invariant()
+fun testVarianceDifferentReturnTypesE(): Invariant<*> = Invariant<UserKlass>()
+
+fun testVarianceDifferentReturnTypesEReverse(): Invariant<in UserKlass> = Invariant()
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesEReverse(): Invariant<*> = Invariant<UserKlass>()
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesF(): Invariant<out UserKlass> = Invariant()
+fun testVarianceDifferentReturnTypesF(): Invariant<in UserKlass> = Invariant()
+
+fun testVarianceDifferentReturnTypesFReverse(): Invariant<out UserKlass> = Invariant()
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesFReverse(): Invariant<in UserKlass> = Invariant()
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testTypeAliasedReturnTypes(): UserKlass = UserKlass()
+fun testTypeAliasedReturnTypes(): SameUserKlass = UserKlass()
+
+fun testTypeAliasedReturnTypesReverse(): UserKlass = UserKlass()
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testTypeAliasedReturnTypesReverse(): SameUserKlass = UserKlass()
+
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun UserKlass.testIdenticalExtensionReceivers() {}
+fun UserKlass.testIdenticalExtensionReceivers() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun UserKlass.testTypeAliasedExtensionReceivers() {}
+fun SameUserKlass.testTypeAliasedExtensionReceivers() {}
+
+fun UserKlass.testTypeAliasedExtensionReceiversReverse() {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun SameUserKlass.testTypeAliasedExtensionReceiversReverse() {}
+
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testIdenticalValueParameters(arg: UserKlass) {}
+fun testIdenticalValueParameters(arg: UserKlass) {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testDifferentlyNamedValueParameters(argA: UserKlass) {}
+fun testDifferentlyNamedValueParameters(argB: UserKlass) {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testTypeAliasedValueParameterTypes(arg: UserKlass) {}
+fun testTypeAliasedValueParameterTypes(arg: SameUserKlass) {}
+
+fun testTypeAliasedValueParameterTypesReverse(arg: UserKlass) {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testTypeAliasedValueParameterTypesReverse(arg: SameUserKlass) {}
+
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testMultipleIdenticalValueParameters(arg1: UserKlassA, arg2: UserKlassB) {}
+fun testMultipleIdenticalValueParameters(arg1: UserKlassA, arg2: UserKlassB) {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testMultipleDifferentlyNamedValueParametersA(arg1: UserKlassA, arg2A: UserKlassB) {}
+fun testMultipleDifferentlyNamedValueParametersA(arg1: UserKlassA, arg2B: UserKlassB) {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testMultipleDifferentlyNamedValueParametersB(arg1A: UserKlassA, arg2A: UserKlassB) {}
+fun testMultipleDifferentlyNamedValueParametersB(arg1B: UserKlassA, arg2B: UserKlassB) {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testMultipleTypeAliasedValueParameterTypesA(arg1: UserKlassA, arg2: UserKlassB) {}
+fun testMultipleTypeAliasedValueParameterTypesA(arg1: UserKlassA, arg2: SameUserKlassB) {}
+
+fun testMultipleTypeAliasedValueParameterTypesAReverse(arg1: UserKlassA, arg2: UserKlassB) {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testMultipleTypeAliasedValueParameterTypesAReverse(arg1: UserKlassA, arg2: SameUserKlassB) {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testMultipleTypeAliasedValueParameterTypesB(arg1: UserKlassA, arg2: UserKlassB) {}
+fun testMultipleTypeAliasedValueParameterTypesB(arg1: SameUserKlassA, arg2: SameUserKlassB) {}
+
+fun testMultipleTypeAliasedValueParameterTypesBReverse(arg1: UserKlassA, arg2: UserKlassB) {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testMultipleTypeAliasedValueParameterTypesBReverse(arg1: SameUserKlassA, arg2: SameUserKlassB) {}
+
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testValueParameterWithIdenticalDefaultArguments(arg: UserKlass = defaultArgument) {}
+fun testValueParameterWithIdenticalDefaultArguments(arg: UserKlass = defaultArgument) {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testDifferencesInValueParameterDefaultArgumentsPresence(arg: UserKlass = defaultArgument) {}
+fun testDifferencesInValueParameterDefaultArgumentsPresence(arg: UserKlass) {}
+
+fun testDifferencesInValueParameterDefaultArgumentsPresenceReverse(arg: UserKlass = defaultArgument) {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testDifferencesInValueParameterDefaultArgumentsPresenceReverse(arg: UserKlass) {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testValueParameterWithDifferentDefaultArguments(arg: UserKlass = defaultArgumentA) {}
+fun testValueParameterWithDifferentDefaultArguments(arg: UserKlass = defaultArgumentB) {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testValueParameterWithAliasedDefaultArguments(arg: UserKlass = defaultArgument) {}
+fun testValueParameterWithAliasedDefaultArguments(arg: UserKlass = sameDefaultArgument) {}
+
+fun testValueParameterWithAliasedDefaultArgumentsReverse(arg: UserKlass = defaultArgument) {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testValueParameterWithAliasedDefaultArgumentsReverse(arg: UserKlass = sameDefaultArgument) {}
+
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testIdenticalTypeParametersA() {}
+fun <T> testIdenticalTypeParametersA() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testIdenticalTypeParametersB(arg: T) {}
+fun <T> testIdenticalTypeParametersB(arg: T) {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testIdenticalTypeParametersC(arg: Invariant<T>) {}
+fun <T> testIdenticalTypeParametersC(arg: Invariant<T>) {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <TA> testDifferentlyNamedTypeParametersA() {}
+fun <TB> testDifferentlyNamedTypeParametersA() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <TA> testDifferentlyNamedTypeParametersB(arg: TA) {}
+fun <TB> testDifferentlyNamedTypeParametersB(arg: TB) {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <TA> testDifferentlyNamedTypeParametersC(arg: Invariant<TA>) {}
+fun <TB> testDifferentlyNamedTypeParametersC(arg: Invariant<TB>) {}
+
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T1, T2> testMultipleIdenticalTypeParameters() {}
+fun <T1, T2> testMultipleIdenticalTypeParameters() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T1, T2A> testMultipleDifferentlyNamedTypeParametersA() {}
+fun <T1, T2B> testMultipleDifferentlyNamedTypeParametersA() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T1A, T2A> testMultipleDifferentlyNamedTypeParametersB() {}
+fun <T1B, T2B> testMultipleDifferentlyNamedTypeParametersB() {}
+
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> testTypeParameterWithIdenticalUpperBoundsA() {}
+fun <T: UserInterface> testTypeParameterWithIdenticalUpperBoundsA() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> testTypeParameterWithIdenticalUpperBoundsB(arg: T) {}
+fun <T: UserInterface> testTypeParameterWithIdenticalUpperBoundsB(arg: T) {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> testTypeParameterWithIdenticalUpperBoundsC(arg: Invariant<T>) {}
+fun <T: UserInterface> testTypeParameterWithIdenticalUpperBoundsC(arg: Invariant<T>) {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> testDifferencesInTypeParameterUpperBoundsPresence() {}
+fun <T> testDifferencesInTypeParameterUpperBoundsPresence() {}
+
+fun <T: UserInterface> testDifferencesInTypeParameterUpperBoundsPresenceReverse() {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testDifferencesInTypeParameterUpperBoundsPresenceReverse() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithDifferentUpperBounds() {}
+fun <T: UserInterfaceB> testTypeParameterWithDifferentUpperBounds() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsA() {}
+fun <T: Invariant<out UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsA() {}
+
+fun <T: Invariant<UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsAReverse() {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<out UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsAReverse() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsB() {}
+fun <T: Invariant<in UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsB() {}
+
+fun <T: Invariant<UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsBReverse() {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<in UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsBReverse() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsC() {}
+fun <T: Invariant<*>> testTypeParameterWithVarianceDifferentUpperBoundsC() {}
+
+fun <T: Invariant<UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsCReverse() {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<*>> testTypeParameterWithVarianceDifferentUpperBoundsCReverse() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<out UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsD() {}
+fun <T: Invariant<*>> testTypeParameterWithVarianceDifferentUpperBoundsD() {}
+
+fun <T: Invariant<out UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsDReverse() {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<*>> testTypeParameterWithVarianceDifferentUpperBoundsDReverse() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<in UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsE() {}
+fun <T: Invariant<*>> testTypeParameterWithVarianceDifferentUpperBoundsE() {}
+
+fun <T: Invariant<in UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsEReverse() {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<*>> testTypeParameterWithVarianceDifferentUpperBoundsEReverse() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<out UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsF() {}
+fun <T: Invariant<in UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsF() {}
+
+fun <T: Invariant<out UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsFReverse() {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<in UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsFReverse() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> testTypeParameterWithTypeAliasedUpperBoundsA() {}
+fun <T: SameUserInterface> testTypeParameterWithTypeAliasedUpperBoundsA() {}
+
+fun <T: UserInterface> testTypeParameterWithTypeAliasedUpperBoundsAReverse() {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterface> testTypeParameterWithTypeAliasedUpperBoundsAReverse() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> testTypeParameterWithTypeAliasedUpperBoundsB(arg: T) {}
+fun <T: SameUserInterface> testTypeParameterWithTypeAliasedUpperBoundsB(arg: T) {}
+
+fun <T: UserInterface> testTypeParameterWithTypeAliasedUpperBoundsBReverse(arg: T) {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterface> testTypeParameterWithTypeAliasedUpperBoundsBReverse(arg: T) {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> testTypeParameterWithTypeAliasedUpperBoundsC(arg: Invariant<T>) {}
+fun <T: SameUserInterface> testTypeParameterWithTypeAliasedUpperBoundsC(arg: Invariant<T>) {}
+
+fun <T: UserInterface> testTypeParameterWithTypeAliasedUpperBoundsCReverse(arg: Invariant<T>) {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterface> testTypeParameterWithTypeAliasedUpperBoundsCReverse(arg: Invariant<T>) {}
+
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleIdenticalUpperBoundsAA() where T: UserInterfaceA, T: UserInterfaceB {}
+fun <T> testTypeParameterWithMultipleIdenticalUpperBoundsAA() where T: UserInterfaceA, T: UserInterfaceB {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleIdenticalUpperBoundsAB(arg: T) where T: UserInterfaceA, T: UserInterfaceB {}
+fun <T> testTypeParameterWithMultipleIdenticalUpperBoundsAB(arg: T) where T: UserInterfaceA, T: UserInterfaceB {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleIdenticalUpperBoundsAC(arg: Invariant<T>) where T: UserInterfaceA, T: UserInterfaceB {}
+fun <T> testTypeParameterWithMultipleIdenticalUpperBoundsAC(arg: Invariant<T>) where T: UserInterfaceA, T: UserInterfaceB {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleIdenticalUpperBoundsBA() where T: UserInterfaceB {}
+fun <T: UserInterfaceA> testTypeParameterWithMultipleIdenticalUpperBoundsBA() where T: UserInterfaceB {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleIdenticalUpperBoundsBB(arg: T) where T: UserInterfaceB {}
+fun <T: UserInterfaceA> testTypeParameterWithMultipleIdenticalUpperBoundsBB(arg: T) where T: UserInterfaceB {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleIdenticalUpperBoundsBC(arg: Invariant<T>) where T: UserInterfaceB {}
+fun <T: UserInterfaceA> testTypeParameterWithMultipleIdenticalUpperBoundsBC(arg: Invariant<T>) where T: UserInterfaceB {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testDifferencesInTypeParameterMultipleUpperBoundsPresenceA() where T: UserInterfaceA, T: UserInterfaceB {}
+fun <T> testDifferencesInTypeParameterMultipleUpperBoundsPresenceA() where T: UserInterfaceA {}
+
+fun <T: UserInterfaceA> testDifferencesInTypeParameterMultipleUpperBoundsPresenceB() where T: UserInterfaceB {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testDifferencesInTypeParameterMultipleUpperBoundsPresenceB() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleDifferentUpperBoundsAA() where T: UserInterfaceA, T: UserInterfaceB {}
+fun <T> testTypeParameterWithMultipleDifferentUpperBoundsAA() where T: UserInterfaceA, T: UserInterfaceC {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleDifferentUpperBoundsAB() where T: UserInterfaceB {}
+fun <T: UserInterfaceA> testTypeParameterWithMultipleDifferentUpperBoundsAB() where T: UserInterfaceC {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceB> testTypeParameterWithMultipleDifferentUpperBoundsAC() where T: UserInterfaceA {}
+fun <T: UserInterfaceC> testTypeParameterWithMultipleDifferentUpperBoundsAC() where T: UserInterfaceA {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleDifferentUpperBoundsBA() where T: UserInterfaceA, T: UserInterfaceB {}
+fun <T> testTypeParameterWithMultipleDifferentUpperBoundsBA() where T: UserInterfaceC, T: UserInterfaceD {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleDifferentUpperBoundsBB() where T: UserInterfaceB {}
+fun <T: UserInterfaceC> testTypeParameterWithMultipleDifferentUpperBoundsBB() where T: UserInterfaceD {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAAA() where T: UserInterfaceA, T: UserInterfaceB {}
+fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAAA() where T: UserInterfaceA, T: SameUserInterfaceB {}
+
+fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAAAReverse() where T: UserInterfaceA, T: UserInterfaceB {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAAAReverse() where T: UserInterfaceA, T: SameUserInterfaceB {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAAB(arg: T) where T: UserInterfaceA, T: UserInterfaceB {}
+fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAAB(arg: T) where T: UserInterfaceA, T: SameUserInterfaceB {}
+
+fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAABReverse(arg: T) where T: UserInterfaceA, T: UserInterfaceB {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAABReverse(arg: T) where T: UserInterfaceA, T: SameUserInterfaceB {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAAC(arg: Invariant<T>) where T: UserInterfaceA, T: UserInterfaceB {}
+fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAAC(arg: Invariant<T>) where T: UserInterfaceA, T: SameUserInterfaceB {}
+
+fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAACReverse(arg: Invariant<T>) where T: UserInterfaceA, T: UserInterfaceB {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAACReverse(arg: Invariant<T>) where T: UserInterfaceA, T: SameUserInterfaceB {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABA() where T: UserInterfaceB {}
+fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABA() where T: SameUserInterfaceB {}
+
+fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABAReverse() where T: UserInterfaceB {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABAReverse() where T: SameUserInterfaceB {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABB(arg: T) where T: UserInterfaceB {}
+fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABB(arg: T) where T: SameUserInterfaceB {}
+
+fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABBReverse(arg: T) where T: UserInterfaceB {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABBReverse(arg: T) where T: SameUserInterfaceB {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABC(arg: Invariant<T>) where T: UserInterfaceB {}
+fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABC(arg: Invariant<T>) where T: SameUserInterfaceB {}
+
+fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABCReverse(arg: Invariant<T>) where T: UserInterfaceB {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABCReverse(arg: Invariant<T>) where T: SameUserInterfaceB {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACA() where T: UserInterfaceA {}
+fun <T: SameUserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACA() where T: UserInterfaceA {}
+
+fun <T: UserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACAReverse() where T: UserInterfaceA {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACAReverse() where T: UserInterfaceA {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACB(arg: T) where T: UserInterfaceA {}
+fun <T: SameUserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACB(arg: T) where T: UserInterfaceA {}
+
+fun <T: UserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACBReverse(arg: T) where T: UserInterfaceA {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACBReverse(arg: T) where T: UserInterfaceA {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACC(arg: Invariant<T>) where T: UserInterfaceA {}
+fun <T: SameUserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACC(arg: Invariant<T>) where T: UserInterfaceA {}
+
+fun <T: UserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACCReverse(arg: Invariant<T>) where T: UserInterfaceA {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACCReverse(arg: Invariant<T>) where T: UserInterfaceA {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBAA() where T: UserInterfaceA, T: UserInterfaceB {}
+fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBAA() where T: SameUserInterfaceA, T: SameUserInterfaceB {}
+
+fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBAAReverse() where T: UserInterfaceA, T: UserInterfaceB {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBAAReverse() where T: SameUserInterfaceA, T: SameUserInterfaceB {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBAB(arg: T) where T: UserInterfaceA, T: UserInterfaceB {}
+fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBAB(arg: T) where T: SameUserInterfaceA, T: SameUserInterfaceB {}
+
+fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBABReverse(arg: T) where T: UserInterfaceA, T: UserInterfaceB {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBABReverse(arg: T) where T: SameUserInterfaceA, T: SameUserInterfaceB {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBAC(arg: Invariant<T>) where T: UserInterfaceA, T: UserInterfaceB {}
+fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBAC(arg: Invariant<T>) where T: SameUserInterfaceA, T: SameUserInterfaceB {}
+
+fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBACReverse(arg: Invariant<T>) where T: UserInterfaceA, T: UserInterfaceB {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBACReverse(arg: Invariant<T>) where T: SameUserInterfaceA, T: SameUserInterfaceB {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBA() where T: UserInterfaceB {}
+fun <T: SameUserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBA() where T: SameUserInterfaceB {}
+
+fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBAReverse() where T: UserInterfaceB {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBAReverse() where T: SameUserInterfaceB {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBB(arg: T) where T: UserInterfaceB {}
+fun <T: SameUserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBB(arg: T) where T: SameUserInterfaceB {}
+
+fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBBReverse(arg: T) where T: UserInterfaceB {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBBReverse(arg: T) where T: SameUserInterfaceB {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBC(arg: Invariant<T>) where T: UserInterfaceB {}
+fun <T: SameUserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBC(arg: Invariant<T>) where T: SameUserInterfaceB {}
+
+fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBCReverse(arg: Invariant<T>) where T: UserInterfaceB {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBCReverse(arg: Invariant<T>) where T: SameUserInterfaceB {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleShuffledUpperBoundsAA() where T: UserInterfaceA, T: UserInterfaceB {}
+fun <T> testTypeParameterWithMultipleShuffledUpperBoundsAA() where T: UserInterfaceB, T: UserInterfaceA {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleShuffledUpperBoundsAB(arg: T) where T: UserInterfaceA, T: UserInterfaceB {}
+fun <T> testTypeParameterWithMultipleShuffledUpperBoundsAB(arg: T) where T: UserInterfaceB, T: UserInterfaceA {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleShuffledUpperBoundsAC(arg: Invariant<T>) where T: UserInterfaceA, T: UserInterfaceB {}
+fun <T> testTypeParameterWithMultipleShuffledUpperBoundsAC(arg: Invariant<T>) where T: UserInterfaceB, T: UserInterfaceA {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleShuffledUpperBoundsBA() where T: UserInterfaceB {}
+fun <T: UserInterfaceB> testTypeParameterWithMultipleShuffledUpperBoundsBA() where T: UserInterfaceA {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleShuffledUpperBoundsBB(arg: T) where T: UserInterfaceB {}
+fun <T: UserInterfaceB> testTypeParameterWithMultipleShuffledUpperBoundsBB(arg: T) where T: UserInterfaceA {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleShuffledUpperBoundsBC(arg: Invariant<T>) where T: UserInterfaceB {}
+fun <T: UserInterfaceB> testTypeParameterWithMultipleShuffledUpperBoundsBC(arg: Invariant<T>) where T: UserInterfaceA {}
+
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> testIdenticalReifiedTypeParameterA() {}
+inline fun <reified T> testIdenticalReifiedTypeParameterA() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> testIdenticalReifiedTypeParameterB(arg: T) {}
+inline fun <reified T> testIdenticalReifiedTypeParameterB(arg: T) {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> testIdenticalReifiedTypeParameterC(arg: Invariant<T>) {}
+inline fun <reified T> testIdenticalReifiedTypeParameterC(arg: Invariant<T>) {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> testDifferencesInReifiedBehaviorOfTypeParameterA() {}
+inline fun <T> testDifferencesInReifiedBehaviorOfTypeParameterA() {}
+
+inline fun <reified T> testDifferencesInReifiedBehaviorOfTypeParameterAReverse() {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <T> testDifferencesInReifiedBehaviorOfTypeParameterAReverse() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> testDifferencesInReifiedBehaviorOfTypeParameterB(arg: T) {}
+inline fun <T> testDifferencesInReifiedBehaviorOfTypeParameterB(arg: T) {}
+
+inline fun <reified T> testDifferencesInReifiedBehaviorOfTypeParameterBReverse(arg: T) {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <T> testDifferencesInReifiedBehaviorOfTypeParameterBReverse(arg: T) {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> testDifferencesInReifiedBehaviorOfTypeParameterC(arg: Invariant<T>) {}
+inline fun <T> testDifferencesInReifiedBehaviorOfTypeParameterC(arg: Invariant<T>) {}
+
+inline fun <reified T> testDifferencesInReifiedBehaviorOfTypeParameterCReverse(arg: Invariant<T>) {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <T> testDifferencesInReifiedBehaviorOfTypeParameterCReverse(arg: Invariant<T>) {}
+
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun testIdenticalPresenceOfInlineModifier() {}
+inline fun testIdenticalPresenceOfInlineModifier() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun testDifferencesInInlineModifierPresence() {}
+fun testDifferencesInInlineModifierPresence() {}
+
+inline fun testDifferencesInInlineModifierPresenceReverse() {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testDifferencesInInlineModifierPresenceReverse() {}
+
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) infix fun UserKlass.testIdenticalPresenceOfInfixModifier(arg: UserKlass) {}
+infix fun UserKlass.testIdenticalPresenceOfInfixModifier(arg: UserKlass) {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) infix fun UserKlass.testDifferencesInInfixModifierPresence(arg: UserKlass) {}
+fun UserKlass.testDifferencesInInfixModifierPresence(arg: UserKlass) {}
+
+infix fun UserKlass.testDifferencesInInfixModifierPresenceReverse(arg: UserKlass) {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun UserKlass.testDifferencesInInfixModifierPresenceReverse(arg: UserKlass) {}
+
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) operator fun UserKlassA.unaryPlus() {}
+operator fun UserKlassA.unaryPlus() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) operator fun UserKlassB.unaryPlus() {}
+fun UserKlassB.unaryPlus() {}
+
+operator fun UserKlassB.unaryMinus() {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun UserKlassB.unaryMinus() {}
+
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) tailrec fun testIdenticalPresenceOfTailrecModifier() {}
+tailrec fun testIdenticalPresenceOfTailrecModifier() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) tailrec fun testDifferencesInTailrecModifierPresence() {}
+fun testDifferencesInTailrecModifierPresence() {}
+
+tailrec fun testDifferencesInTailrecModifierPresenceReverse() {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testDifferencesInTailrecModifierPresenceReverse() {}
+
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) private fun testIdenticalPrivateVisibility() {}
+private fun testIdenticalPrivateVisibility() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal fun testIdenticalInternalVisibility() {}
+internal fun testIdenticalInternalVisibility() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) private fun testDifferencesInPrivateAndPublicVisibilities() {}
+public fun testDifferencesInPrivateAndPublicVisibilities() {}
+
+private fun testDifferencesInPrivateAndPublicVisibilitiesReverse() {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) public fun testDifferencesInPrivateAndPublicVisibilitiesReverse() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal fun testDifferencesInInternalAndPublicVisibilities() {}
+public fun testDifferencesInInternalAndPublicVisibilities() {}
+
+internal fun testDifferencesInInternalAndPublicVisibilitiesReverse() {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) public fun testDifferencesInInternalAndPublicVisibilitiesReverse() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) private fun testDifferencesInPrivateAndInternalVisibilities() {}
+internal fun testDifferencesInPrivateAndInternalVisibilities() {}
+
+private fun testDifferencesInPrivateAndInternalVisibilitiesReverse() {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal fun testDifferencesInPrivateAndInternalVisibilitiesReverse() {}
+
+
+open class Invariant<T>
+
+
+class UserKlass
+class UserKlassA
+class UserKlassB
+typealias SameUserKlass = UserKlass
+typealias SameUserKlassA = UserKlassA
+typealias SameUserKlassB = UserKlassB
+
+
+val defaultArgument = UserKlass()
+val defaultArgumentA = UserKlass()
+val defaultArgumentB = UserKlass()
+val sameDefaultArgument = defaultArgument
+
+
+interface UserInterface
+interface UserInterfaceA
+interface UserInterfaceB
+interface UserInterfaceC
+interface UserInterfaceD
+typealias SameUserInterface = UserInterface
+typealias SameUserInterfaceA = UserInterfaceA
+typealias SameUserInterfaceB = UserInterfaceB

compiler/testData/diagnostics/tests/overload/noConflictingOverloadsWithDeprecatedHidden/FunctionsInPackage.kt

@@ -0,0 +1,496 @@
+// DIAGNOSTICS: -MISPLACED_TYPE_PARAMETER_CONSTRAINTS, -NOTHING_TO_INLINE, -NO_TAIL_CALLS_FOUND
+
+package pkg
+
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testBasic()<!> {}
+<!CONFLICTING_OVERLOADS!>fun testBasic()<!> {}
+
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testIdenticalReturnTypes(): UserKlass<!> = UserKlass()
+<!CONFLICTING_OVERLOADS!>fun testIdenticalReturnTypes(): UserKlass<!> = UserKlass()
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testDifferencesInReturnTypePresence(): Unit<!> {}
+<!CONFLICTING_OVERLOADS!>fun testDifferencesInReturnTypePresence()<!> {}
+
+<!CONFLICTING_OVERLOADS!>fun testDifferencesInReturnTypePresenceReverse(): Unit<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testDifferencesInReturnTypePresenceReverse()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testDifferentReturnTypes(): UserKlassA<!> = UserKlassA()
+<!CONFLICTING_OVERLOADS!>fun testDifferentReturnTypes(): UserKlassB<!> = UserKlassB()
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesA(): Invariant<UserKlass><!> = Invariant()
+<!CONFLICTING_OVERLOADS!>fun testVarianceDifferentReturnTypesA(): Invariant<out UserKlass><!> = Invariant()
+
+<!CONFLICTING_OVERLOADS!>fun testVarianceDifferentReturnTypesAReverse(): Invariant<UserKlass><!> = Invariant()
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesAReverse(): Invariant<out UserKlass><!> = Invariant()
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesB(): Invariant<UserKlass><!> = Invariant()
+<!CONFLICTING_OVERLOADS!>fun testVarianceDifferentReturnTypesB(): Invariant<in UserKlass><!> = Invariant()
+
+<!CONFLICTING_OVERLOADS!>fun testVarianceDifferentReturnTypesBReverse(): Invariant<UserKlass><!> = Invariant()
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesBReverse(): Invariant<in UserKlass><!> = Invariant()
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesC(): Invariant<UserKlass><!> = Invariant()
+<!CONFLICTING_OVERLOADS!>fun testVarianceDifferentReturnTypesC(): Invariant<*><!> = Invariant<UserKlass>()
+
+<!CONFLICTING_OVERLOADS!>fun testVarianceDifferentReturnTypesCReverse(): Invariant<UserKlass><!> = Invariant()
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesCReverse(): Invariant<*><!> = Invariant<UserKlass>()
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesD(): Invariant<out UserKlass><!> = Invariant()
+<!CONFLICTING_OVERLOADS!>fun testVarianceDifferentReturnTypesD(): Invariant<*><!> = Invariant<UserKlass>()
+
+<!CONFLICTING_OVERLOADS!>fun testVarianceDifferentReturnTypesDReverse(): Invariant<out UserKlass><!> = Invariant()
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesDReverse(): Invariant<*><!> = Invariant<UserKlass>()
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesE(): Invariant<in UserKlass><!> = Invariant()
+<!CONFLICTING_OVERLOADS!>fun testVarianceDifferentReturnTypesE(): Invariant<*><!> = Invariant<UserKlass>()
+
+<!CONFLICTING_OVERLOADS!>fun testVarianceDifferentReturnTypesEReverse(): Invariant<in UserKlass><!> = Invariant()
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesEReverse(): Invariant<*><!> = Invariant<UserKlass>()
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesF(): Invariant<out UserKlass><!> = Invariant()
+<!CONFLICTING_OVERLOADS!>fun testVarianceDifferentReturnTypesF(): Invariant<in UserKlass><!> = Invariant()
+
+<!CONFLICTING_OVERLOADS!>fun testVarianceDifferentReturnTypesFReverse(): Invariant<out UserKlass><!> = Invariant()
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesFReverse(): Invariant<in UserKlass><!> = Invariant()
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testTypeAliasedReturnTypes(): UserKlass<!> = UserKlass()
+<!CONFLICTING_OVERLOADS!>fun testTypeAliasedReturnTypes(): SameUserKlass<!> = UserKlass()
+
+<!CONFLICTING_OVERLOADS!>fun testTypeAliasedReturnTypesReverse(): UserKlass<!> = UserKlass()
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testTypeAliasedReturnTypesReverse(): SameUserKlass<!> = UserKlass()
+
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun UserKlass.testIdenticalExtensionReceivers()<!> {}
+<!CONFLICTING_OVERLOADS!>fun UserKlass.testIdenticalExtensionReceivers()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun UserKlass.testTypeAliasedExtensionReceivers()<!> {}
+<!CONFLICTING_OVERLOADS!>fun SameUserKlass.testTypeAliasedExtensionReceivers()<!> {}
+
+<!CONFLICTING_OVERLOADS!>fun UserKlass.testTypeAliasedExtensionReceiversReverse()<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun SameUserKlass.testTypeAliasedExtensionReceiversReverse()<!> {}
+
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testIdenticalValueParameters(arg: UserKlass)<!> {}
+<!CONFLICTING_OVERLOADS!>fun testIdenticalValueParameters(arg: UserKlass)<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testDifferentlyNamedValueParameters(argA: UserKlass)<!> {}
+<!CONFLICTING_OVERLOADS!>fun testDifferentlyNamedValueParameters(argB: UserKlass)<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testTypeAliasedValueParameterTypes(arg: UserKlass)<!> {}
+<!CONFLICTING_OVERLOADS!>fun testTypeAliasedValueParameterTypes(arg: SameUserKlass)<!> {}
+
+<!CONFLICTING_OVERLOADS!>fun testTypeAliasedValueParameterTypesReverse(arg: UserKlass)<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testTypeAliasedValueParameterTypesReverse(arg: SameUserKlass)<!> {}
+
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testMultipleIdenticalValueParameters(arg1: UserKlassA, arg2: UserKlassB)<!> {}
+<!CONFLICTING_OVERLOADS!>fun testMultipleIdenticalValueParameters(arg1: UserKlassA, arg2: UserKlassB)<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testMultipleDifferentlyNamedValueParametersA(arg1: UserKlassA, arg2A: UserKlassB)<!> {}
+<!CONFLICTING_OVERLOADS!>fun testMultipleDifferentlyNamedValueParametersA(arg1: UserKlassA, arg2B: UserKlassB)<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testMultipleDifferentlyNamedValueParametersB(arg1A: UserKlassA, arg2A: UserKlassB)<!> {}
+<!CONFLICTING_OVERLOADS!>fun testMultipleDifferentlyNamedValueParametersB(arg1B: UserKlassA, arg2B: UserKlassB)<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testMultipleTypeAliasedValueParameterTypesA(arg1: UserKlassA, arg2: UserKlassB)<!> {}
+<!CONFLICTING_OVERLOADS!>fun testMultipleTypeAliasedValueParameterTypesA(arg1: UserKlassA, arg2: SameUserKlassB)<!> {}
+
+<!CONFLICTING_OVERLOADS!>fun testMultipleTypeAliasedValueParameterTypesAReverse(arg1: UserKlassA, arg2: UserKlassB)<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testMultipleTypeAliasedValueParameterTypesAReverse(arg1: UserKlassA, arg2: SameUserKlassB)<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testMultipleTypeAliasedValueParameterTypesB(arg1: UserKlassA, arg2: UserKlassB)<!> {}
+<!CONFLICTING_OVERLOADS!>fun testMultipleTypeAliasedValueParameterTypesB(arg1: SameUserKlassA, arg2: SameUserKlassB)<!> {}
+
+<!CONFLICTING_OVERLOADS!>fun testMultipleTypeAliasedValueParameterTypesBReverse(arg1: UserKlassA, arg2: UserKlassB)<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testMultipleTypeAliasedValueParameterTypesBReverse(arg1: SameUserKlassA, arg2: SameUserKlassB)<!> {}
+
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testValueParameterWithIdenticalDefaultArguments(arg: UserKlass = defaultArgument)<!> {}
+<!CONFLICTING_OVERLOADS!>fun testValueParameterWithIdenticalDefaultArguments(arg: UserKlass = defaultArgument)<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testDifferencesInValueParameterDefaultArgumentsPresence(arg: UserKlass = defaultArgument)<!> {}
+<!CONFLICTING_OVERLOADS!>fun testDifferencesInValueParameterDefaultArgumentsPresence(arg: UserKlass)<!> {}
+
+<!CONFLICTING_OVERLOADS!>fun testDifferencesInValueParameterDefaultArgumentsPresenceReverse(arg: UserKlass = defaultArgument)<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testDifferencesInValueParameterDefaultArgumentsPresenceReverse(arg: UserKlass)<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testValueParameterWithDifferentDefaultArguments(arg: UserKlass = defaultArgumentA)<!> {}
+<!CONFLICTING_OVERLOADS!>fun testValueParameterWithDifferentDefaultArguments(arg: UserKlass = defaultArgumentB)<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testValueParameterWithAliasedDefaultArguments(arg: UserKlass = defaultArgument)<!> {}
+<!CONFLICTING_OVERLOADS!>fun testValueParameterWithAliasedDefaultArguments(arg: UserKlass = sameDefaultArgument)<!> {}
+
+<!CONFLICTING_OVERLOADS!>fun testValueParameterWithAliasedDefaultArgumentsReverse(arg: UserKlass = defaultArgument)<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testValueParameterWithAliasedDefaultArgumentsReverse(arg: UserKlass = sameDefaultArgument)<!> {}
+
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testIdenticalTypeParametersA()<!> {}
+<!CONFLICTING_OVERLOADS!>fun <T> testIdenticalTypeParametersA()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testIdenticalTypeParametersB(arg: T)<!> {}
+<!CONFLICTING_OVERLOADS!>fun <T> testIdenticalTypeParametersB(arg: T)<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testIdenticalTypeParametersC(arg: Invariant<T>)<!> {}
+<!CONFLICTING_OVERLOADS!>fun <T> testIdenticalTypeParametersC(arg: Invariant<T>)<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <TA> testDifferentlyNamedTypeParametersA()<!> {}
+<!CONFLICTING_OVERLOADS!>fun <TB> testDifferentlyNamedTypeParametersA()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <TA> testDifferentlyNamedTypeParametersB(arg: TA)<!> {}
+<!CONFLICTING_OVERLOADS!>fun <TB> testDifferentlyNamedTypeParametersB(arg: TB)<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <TA> testDifferentlyNamedTypeParametersC(arg: Invariant<TA>)<!> {}
+<!CONFLICTING_OVERLOADS!>fun <TB> testDifferentlyNamedTypeParametersC(arg: Invariant<TB>)<!> {}
+
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T1, T2> testMultipleIdenticalTypeParameters()<!> {}
+<!CONFLICTING_OVERLOADS!>fun <T1, T2> testMultipleIdenticalTypeParameters()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T1, T2A> testMultipleDifferentlyNamedTypeParametersA()<!> {}
+<!CONFLICTING_OVERLOADS!>fun <T1, T2B> testMultipleDifferentlyNamedTypeParametersA()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T1A, T2A> testMultipleDifferentlyNamedTypeParametersB()<!> {}
+<!CONFLICTING_OVERLOADS!>fun <T1B, T2B> testMultipleDifferentlyNamedTypeParametersB()<!> {}
+
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> testTypeParameterWithIdenticalUpperBoundsA()<!> {}
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterface> testTypeParameterWithIdenticalUpperBoundsA()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> testTypeParameterWithIdenticalUpperBoundsB(arg: T)<!> {}
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterface> testTypeParameterWithIdenticalUpperBoundsB(arg: T)<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> testTypeParameterWithIdenticalUpperBoundsC(arg: Invariant<T>)<!> {}
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterface> testTypeParameterWithIdenticalUpperBoundsC(arg: Invariant<T>)<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> testDifferencesInTypeParameterUpperBoundsPresence()<!> {}
+<!CONFLICTING_OVERLOADS!>fun <T> testDifferencesInTypeParameterUpperBoundsPresence()<!> {}
+
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterface> testDifferencesInTypeParameterUpperBoundsPresenceReverse()<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testDifferencesInTypeParameterUpperBoundsPresenceReverse()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithDifferentUpperBounds()<!> {}
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceB> testTypeParameterWithDifferentUpperBounds()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsA()<!> {}
+<!CONFLICTING_OVERLOADS!>fun <T: Invariant<out UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsA()<!> {}
+
+<!CONFLICTING_OVERLOADS!>fun <T: Invariant<UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsAReverse()<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<out UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsAReverse()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsB()<!> {}
+<!CONFLICTING_OVERLOADS!>fun <T: Invariant<in UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsB()<!> {}
+
+<!CONFLICTING_OVERLOADS!>fun <T: Invariant<UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsBReverse()<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<in UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsBReverse()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsC()<!> {}
+<!CONFLICTING_OVERLOADS!>fun <T: Invariant<*>> testTypeParameterWithVarianceDifferentUpperBoundsC()<!> {}
+
+<!CONFLICTING_OVERLOADS!>fun <T: Invariant<UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsCReverse()<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<*>> testTypeParameterWithVarianceDifferentUpperBoundsCReverse()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<out UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsD()<!> {}
+<!CONFLICTING_OVERLOADS!>fun <T: Invariant<*>> testTypeParameterWithVarianceDifferentUpperBoundsD()<!> {}
+
+<!CONFLICTING_OVERLOADS!>fun <T: Invariant<out UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsDReverse()<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<*>> testTypeParameterWithVarianceDifferentUpperBoundsDReverse()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<in UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsE()<!> {}
+<!CONFLICTING_OVERLOADS!>fun <T: Invariant<*>> testTypeParameterWithVarianceDifferentUpperBoundsE()<!> {}
+
+<!CONFLICTING_OVERLOADS!>fun <T: Invariant<in UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsEReverse()<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<*>> testTypeParameterWithVarianceDifferentUpperBoundsEReverse()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<out UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsF()<!> {}
+<!CONFLICTING_OVERLOADS!>fun <T: Invariant<in UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsF()<!> {}
+
+<!CONFLICTING_OVERLOADS!>fun <T: Invariant<out UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsFReverse()<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<in UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsFReverse()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> testTypeParameterWithTypeAliasedUpperBoundsA()<!> {}
+<!CONFLICTING_OVERLOADS!>fun <T: SameUserInterface> testTypeParameterWithTypeAliasedUpperBoundsA()<!> {}
+
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterface> testTypeParameterWithTypeAliasedUpperBoundsAReverse()<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterface> testTypeParameterWithTypeAliasedUpperBoundsAReverse()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> testTypeParameterWithTypeAliasedUpperBoundsB(arg: T)<!> {}
+<!CONFLICTING_OVERLOADS!>fun <T: SameUserInterface> testTypeParameterWithTypeAliasedUpperBoundsB(arg: T)<!> {}
+
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterface> testTypeParameterWithTypeAliasedUpperBoundsBReverse(arg: T)<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterface> testTypeParameterWithTypeAliasedUpperBoundsBReverse(arg: T)<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> testTypeParameterWithTypeAliasedUpperBoundsC(arg: Invariant<T>)<!> {}
+<!CONFLICTING_OVERLOADS!>fun <T: SameUserInterface> testTypeParameterWithTypeAliasedUpperBoundsC(arg: Invariant<T>)<!> {}
+
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterface> testTypeParameterWithTypeAliasedUpperBoundsCReverse(arg: Invariant<T>)<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterface> testTypeParameterWithTypeAliasedUpperBoundsCReverse(arg: Invariant<T>)<!> {}
+
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleIdenticalUpperBoundsAA()<!> where T: UserInterfaceA, T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleIdenticalUpperBoundsAA()<!> where T: UserInterfaceA, T: UserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleIdenticalUpperBoundsAB(arg: T)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleIdenticalUpperBoundsAB(arg: T)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleIdenticalUpperBoundsAC(arg: Invariant<T>)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleIdenticalUpperBoundsAC(arg: Invariant<T>)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleIdenticalUpperBoundsBA()<!> where T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceA> testTypeParameterWithMultipleIdenticalUpperBoundsBA()<!> where T: UserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleIdenticalUpperBoundsBB(arg: T)<!> where T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceA> testTypeParameterWithMultipleIdenticalUpperBoundsBB(arg: T)<!> where T: UserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleIdenticalUpperBoundsBC(arg: Invariant<T>)<!> where T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceA> testTypeParameterWithMultipleIdenticalUpperBoundsBC(arg: Invariant<T>)<!> where T: UserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testDifferencesInTypeParameterMultipleUpperBoundsPresenceA()<!> where T: UserInterfaceA, T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T> testDifferencesInTypeParameterMultipleUpperBoundsPresenceA()<!> where T: UserInterfaceA {}
+
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceA> testDifferencesInTypeParameterMultipleUpperBoundsPresenceB()<!> where T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testDifferencesInTypeParameterMultipleUpperBoundsPresenceB()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleDifferentUpperBoundsAA()<!> where T: UserInterfaceA, T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleDifferentUpperBoundsAA()<!> where T: UserInterfaceA, T: UserInterfaceC {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleDifferentUpperBoundsAB()<!> where T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceA> testTypeParameterWithMultipleDifferentUpperBoundsAB()<!> where T: UserInterfaceC {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceB> testTypeParameterWithMultipleDifferentUpperBoundsAC()<!> where T: UserInterfaceA {}
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceC> testTypeParameterWithMultipleDifferentUpperBoundsAC()<!> where T: UserInterfaceA {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleDifferentUpperBoundsBA()<!> where T: UserInterfaceA, T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleDifferentUpperBoundsBA()<!> where T: UserInterfaceC, T: UserInterfaceD {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleDifferentUpperBoundsBB()<!> where T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceC> testTypeParameterWithMultipleDifferentUpperBoundsBB()<!> where T: UserInterfaceD {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAAA()<!> where T: UserInterfaceA, T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAAA()<!> where T: UserInterfaceA, T: SameUserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAAAReverse()<!> where T: UserInterfaceA, T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAAAReverse()<!> where T: UserInterfaceA, T: SameUserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAAB(arg: T)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAAB(arg: T)<!> where T: UserInterfaceA, T: SameUserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAABReverse(arg: T)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAABReverse(arg: T)<!> where T: UserInterfaceA, T: SameUserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAAC(arg: Invariant<T>)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAAC(arg: Invariant<T>)<!> where T: UserInterfaceA, T: SameUserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAACReverse(arg: Invariant<T>)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAACReverse(arg: Invariant<T>)<!> where T: UserInterfaceA, T: SameUserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABA()<!> where T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABA()<!> where T: SameUserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABAReverse()<!> where T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABAReverse()<!> where T: SameUserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABB(arg: T)<!> where T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABB(arg: T)<!> where T: SameUserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABBReverse(arg: T)<!> where T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABBReverse(arg: T)<!> where T: SameUserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABC(arg: Invariant<T>)<!> where T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABC(arg: Invariant<T>)<!> where T: SameUserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABCReverse(arg: Invariant<T>)<!> where T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABCReverse(arg: Invariant<T>)<!> where T: SameUserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACA()<!> where T: UserInterfaceA {}
+<!CONFLICTING_OVERLOADS!>fun <T: SameUserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACA()<!> where T: UserInterfaceA {}
+
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACAReverse()<!> where T: UserInterfaceA {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACAReverse()<!> where T: UserInterfaceA {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACB(arg: T)<!> where T: UserInterfaceA {}
+<!CONFLICTING_OVERLOADS!>fun <T: SameUserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACB(arg: T)<!> where T: UserInterfaceA {}
+
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACBReverse(arg: T)<!> where T: UserInterfaceA {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACBReverse(arg: T)<!> where T: UserInterfaceA {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACC(arg: Invariant<T>)<!> where T: UserInterfaceA {}
+<!CONFLICTING_OVERLOADS!>fun <T: SameUserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACC(arg: Invariant<T>)<!> where T: UserInterfaceA {}
+
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACCReverse(arg: Invariant<T>)<!> where T: UserInterfaceA {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACCReverse(arg: Invariant<T>)<!> where T: UserInterfaceA {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBAA()<!> where T: UserInterfaceA, T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBAA()<!> where T: SameUserInterfaceA, T: SameUserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBAAReverse()<!> where T: UserInterfaceA, T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBAAReverse()<!> where T: SameUserInterfaceA, T: SameUserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBAB(arg: T)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBAB(arg: T)<!> where T: SameUserInterfaceA, T: SameUserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBABReverse(arg: T)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBABReverse(arg: T)<!> where T: SameUserInterfaceA, T: SameUserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBAC(arg: Invariant<T>)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBAC(arg: Invariant<T>)<!> where T: SameUserInterfaceA, T: SameUserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBACReverse(arg: Invariant<T>)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBACReverse(arg: Invariant<T>)<!> where T: SameUserInterfaceA, T: SameUserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBA()<!> where T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T: SameUserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBA()<!> where T: SameUserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBAReverse()<!> where T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBAReverse()<!> where T: SameUserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBB(arg: T)<!> where T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T: SameUserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBB(arg: T)<!> where T: SameUserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBBReverse(arg: T)<!> where T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBBReverse(arg: T)<!> where T: SameUserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBC(arg: Invariant<T>)<!> where T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T: SameUserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBC(arg: Invariant<T>)<!> where T: SameUserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBCReverse(arg: Invariant<T>)<!> where T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBCReverse(arg: Invariant<T>)<!> where T: SameUserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleShuffledUpperBoundsAA()<!> where T: UserInterfaceA, T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleShuffledUpperBoundsAA()<!> where T: UserInterfaceB, T: UserInterfaceA {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleShuffledUpperBoundsAB(arg: T)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleShuffledUpperBoundsAB(arg: T)<!> where T: UserInterfaceB, T: UserInterfaceA {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleShuffledUpperBoundsAC(arg: Invariant<T>)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleShuffledUpperBoundsAC(arg: Invariant<T>)<!> where T: UserInterfaceB, T: UserInterfaceA {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleShuffledUpperBoundsBA()<!> where T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceB> testTypeParameterWithMultipleShuffledUpperBoundsBA()<!> where T: UserInterfaceA {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleShuffledUpperBoundsBB(arg: T)<!> where T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceB> testTypeParameterWithMultipleShuffledUpperBoundsBB(arg: T)<!> where T: UserInterfaceA {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleShuffledUpperBoundsBC(arg: Invariant<T>)<!> where T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceB> testTypeParameterWithMultipleShuffledUpperBoundsBC(arg: Invariant<T>)<!> where T: UserInterfaceA {}
+
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> testIdenticalReifiedTypeParameterA()<!> {}
+<!CONFLICTING_OVERLOADS!>inline fun <reified T> testIdenticalReifiedTypeParameterA()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> testIdenticalReifiedTypeParameterB(arg: T)<!> {}
+<!CONFLICTING_OVERLOADS!>inline fun <reified T> testIdenticalReifiedTypeParameterB(arg: T)<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> testIdenticalReifiedTypeParameterC(arg: Invariant<T>)<!> {}
+<!CONFLICTING_OVERLOADS!>inline fun <reified T> testIdenticalReifiedTypeParameterC(arg: Invariant<T>)<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> testDifferencesInReifiedBehaviorOfTypeParameterA()<!> {}
+<!CONFLICTING_OVERLOADS!>inline fun <T> testDifferencesInReifiedBehaviorOfTypeParameterA()<!> {}
+
+<!CONFLICTING_OVERLOADS!>inline fun <reified T> testDifferencesInReifiedBehaviorOfTypeParameterAReverse()<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <T> testDifferencesInReifiedBehaviorOfTypeParameterAReverse()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> testDifferencesInReifiedBehaviorOfTypeParameterB(arg: T)<!> {}
+<!CONFLICTING_OVERLOADS!>inline fun <T> testDifferencesInReifiedBehaviorOfTypeParameterB(arg: T)<!> {}
+
+<!CONFLICTING_OVERLOADS!>inline fun <reified T> testDifferencesInReifiedBehaviorOfTypeParameterBReverse(arg: T)<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <T> testDifferencesInReifiedBehaviorOfTypeParameterBReverse(arg: T)<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> testDifferencesInReifiedBehaviorOfTypeParameterC(arg: Invariant<T>)<!> {}
+<!CONFLICTING_OVERLOADS!>inline fun <T> testDifferencesInReifiedBehaviorOfTypeParameterC(arg: Invariant<T>)<!> {}
+
+<!CONFLICTING_OVERLOADS!>inline fun <reified T> testDifferencesInReifiedBehaviorOfTypeParameterCReverse(arg: Invariant<T>)<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <T> testDifferencesInReifiedBehaviorOfTypeParameterCReverse(arg: Invariant<T>)<!> {}
+
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun testIdenticalPresenceOfInlineModifier()<!> {}
+<!CONFLICTING_OVERLOADS!>inline fun testIdenticalPresenceOfInlineModifier()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun testDifferencesInInlineModifierPresence()<!> {}
+<!CONFLICTING_OVERLOADS!>fun testDifferencesInInlineModifierPresence()<!> {}
+
+<!CONFLICTING_OVERLOADS!>inline fun testDifferencesInInlineModifierPresenceReverse()<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testDifferencesInInlineModifierPresenceReverse()<!> {}
+
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) infix fun UserKlass.testIdenticalPresenceOfInfixModifier(arg: UserKlass)<!> {}
+<!CONFLICTING_OVERLOADS!>infix fun UserKlass.testIdenticalPresenceOfInfixModifier(arg: UserKlass)<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) infix fun UserKlass.testDifferencesInInfixModifierPresence(arg: UserKlass)<!> {}
+<!CONFLICTING_OVERLOADS!>fun UserKlass.testDifferencesInInfixModifierPresence(arg: UserKlass)<!> {}
+
+<!CONFLICTING_OVERLOADS!>infix fun UserKlass.testDifferencesInInfixModifierPresenceReverse(arg: UserKlass)<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun UserKlass.testDifferencesInInfixModifierPresenceReverse(arg: UserKlass)<!> {}
+
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) operator fun UserKlassA.unaryPlus()<!> {}
+<!CONFLICTING_OVERLOADS!>operator fun UserKlassA.unaryPlus()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) operator fun UserKlassB.unaryPlus()<!> {}
+<!CONFLICTING_OVERLOADS!>fun UserKlassB.unaryPlus()<!> {}
+
+<!CONFLICTING_OVERLOADS!>operator fun UserKlassB.unaryMinus()<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun UserKlassB.unaryMinus()<!> {}
+
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) tailrec fun testIdenticalPresenceOfTailrecModifier()<!> {}
+<!CONFLICTING_OVERLOADS!>tailrec fun testIdenticalPresenceOfTailrecModifier()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) tailrec fun testDifferencesInTailrecModifierPresence()<!> {}
+<!CONFLICTING_OVERLOADS!>fun testDifferencesInTailrecModifierPresence()<!> {}
+
+<!CONFLICTING_OVERLOADS!>tailrec fun testDifferencesInTailrecModifierPresenceReverse()<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testDifferencesInTailrecModifierPresenceReverse()<!> {}
+
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) private fun testIdenticalPrivateVisibility()<!> {}
+<!CONFLICTING_OVERLOADS!>private fun testIdenticalPrivateVisibility()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal fun testIdenticalInternalVisibility()<!> {}
+<!CONFLICTING_OVERLOADS!>internal fun testIdenticalInternalVisibility()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) private fun testDifferencesInPrivateAndPublicVisibilities()<!> {}
+<!CONFLICTING_OVERLOADS!>public fun testDifferencesInPrivateAndPublicVisibilities()<!> {}
+
+<!CONFLICTING_OVERLOADS!>private fun testDifferencesInPrivateAndPublicVisibilitiesReverse()<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) public fun testDifferencesInPrivateAndPublicVisibilitiesReverse()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal fun testDifferencesInInternalAndPublicVisibilities()<!> {}
+<!CONFLICTING_OVERLOADS!>public fun testDifferencesInInternalAndPublicVisibilities()<!> {}
+
+<!CONFLICTING_OVERLOADS!>internal fun testDifferencesInInternalAndPublicVisibilitiesReverse()<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) public fun testDifferencesInInternalAndPublicVisibilitiesReverse()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) private fun testDifferencesInPrivateAndInternalVisibilities()<!> {}
+<!CONFLICTING_OVERLOADS!>internal fun testDifferencesInPrivateAndInternalVisibilities()<!> {}
+
+<!CONFLICTING_OVERLOADS!>private fun testDifferencesInPrivateAndInternalVisibilitiesReverse()<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal fun testDifferencesInPrivateAndInternalVisibilitiesReverse()<!> {}
+
+
+open class Invariant<T>
+
+
+class UserKlass
+class UserKlassA
+class UserKlassB
+typealias SameUserKlass = UserKlass
+typealias SameUserKlassA = UserKlassA
+typealias SameUserKlassB = UserKlassB
+
+
+val defaultArgument = UserKlass()
+val defaultArgumentA = UserKlass()
+val defaultArgumentB = UserKlass()
+val sameDefaultArgument = defaultArgument
+
+
+interface UserInterface
+interface UserInterfaceA
+interface UserInterfaceB
+interface UserInterfaceC
+interface UserInterfaceD
+typealias SameUserInterface = UserInterface
+typealias SameUserInterfaceA = UserInterfaceA
+typealias SameUserInterfaceB = UserInterfaceB

compiler/testData/diagnostics/tests/overload/noConflictingOverloadsWithDeprecatedHidden/FunctionsOnTopLevel.fir.kt

@@ -0,0 +1,494 @@
+// DIAGNOSTICS: -MISPLACED_TYPE_PARAMETER_CONSTRAINTS, -NOTHING_TO_INLINE, -NO_TAIL_CALLS_FOUND
+
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testBasic() {}
+fun testBasic() {}
+
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testIdenticalReturnTypes(): UserKlass = UserKlass()
+fun testIdenticalReturnTypes(): UserKlass = UserKlass()
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testDifferencesInReturnTypePresence(): Unit {}
+fun testDifferencesInReturnTypePresence() {}
+
+fun testDifferencesInReturnTypePresenceReverse(): Unit {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testDifferencesInReturnTypePresenceReverse() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testDifferentReturnTypes(): UserKlassA = UserKlassA()
+fun testDifferentReturnTypes(): UserKlassB = UserKlassB()
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesA(): Invariant<UserKlass> = Invariant()
+fun testVarianceDifferentReturnTypesA(): Invariant<out UserKlass> = Invariant()
+
+fun testVarianceDifferentReturnTypesAReverse(): Invariant<UserKlass> = Invariant()
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesAReverse(): Invariant<out UserKlass> = Invariant()
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesB(): Invariant<UserKlass> = Invariant()
+fun testVarianceDifferentReturnTypesB(): Invariant<in UserKlass> = Invariant()
+
+fun testVarianceDifferentReturnTypesBReverse(): Invariant<UserKlass> = Invariant()
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesBReverse(): Invariant<in UserKlass> = Invariant()
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesC(): Invariant<UserKlass> = Invariant()
+fun testVarianceDifferentReturnTypesC(): Invariant<*> = Invariant<UserKlass>()
+
+fun testVarianceDifferentReturnTypesCReverse(): Invariant<UserKlass> = Invariant()
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesCReverse(): Invariant<*> = Invariant<UserKlass>()
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesD(): Invariant<out UserKlass> = Invariant()
+fun testVarianceDifferentReturnTypesD(): Invariant<*> = Invariant<UserKlass>()
+
+fun testVarianceDifferentReturnTypesDReverse(): Invariant<out UserKlass> = Invariant()
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesDReverse(): Invariant<*> = Invariant<UserKlass>()
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesE(): Invariant<in UserKlass> = Invariant()
+fun testVarianceDifferentReturnTypesE(): Invariant<*> = Invariant<UserKlass>()
+
+fun testVarianceDifferentReturnTypesEReverse(): Invariant<in UserKlass> = Invariant()
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesEReverse(): Invariant<*> = Invariant<UserKlass>()
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesF(): Invariant<out UserKlass> = Invariant()
+fun testVarianceDifferentReturnTypesF(): Invariant<in UserKlass> = Invariant()
+
+fun testVarianceDifferentReturnTypesFReverse(): Invariant<out UserKlass> = Invariant()
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesFReverse(): Invariant<in UserKlass> = Invariant()
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testTypeAliasedReturnTypes(): UserKlass = UserKlass()
+fun testTypeAliasedReturnTypes(): SameUserKlass = UserKlass()
+
+fun testTypeAliasedReturnTypesReverse(): UserKlass = UserKlass()
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testTypeAliasedReturnTypesReverse(): SameUserKlass = UserKlass()
+
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun UserKlass.testIdenticalExtensionReceivers() {}
+fun UserKlass.testIdenticalExtensionReceivers() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun UserKlass.testTypeAliasedExtensionReceivers() {}
+fun SameUserKlass.testTypeAliasedExtensionReceivers() {}
+
+fun UserKlass.testTypeAliasedExtensionReceiversReverse() {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun SameUserKlass.testTypeAliasedExtensionReceiversReverse() {}
+
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testIdenticalValueParameters(arg: UserKlass) {}
+fun testIdenticalValueParameters(arg: UserKlass) {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testDifferentlyNamedValueParameters(argA: UserKlass) {}
+fun testDifferentlyNamedValueParameters(argB: UserKlass) {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testTypeAliasedValueParameterTypes(arg: UserKlass) {}
+fun testTypeAliasedValueParameterTypes(arg: SameUserKlass) {}
+
+fun testTypeAliasedValueParameterTypesReverse(arg: UserKlass) {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testTypeAliasedValueParameterTypesReverse(arg: SameUserKlass) {}
+
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testMultipleIdenticalValueParameters(arg1: UserKlassA, arg2: UserKlassB) {}
+fun testMultipleIdenticalValueParameters(arg1: UserKlassA, arg2: UserKlassB) {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testMultipleDifferentlyNamedValueParametersA(arg1: UserKlassA, arg2A: UserKlassB) {}
+fun testMultipleDifferentlyNamedValueParametersA(arg1: UserKlassA, arg2B: UserKlassB) {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testMultipleDifferentlyNamedValueParametersB(arg1A: UserKlassA, arg2A: UserKlassB) {}
+fun testMultipleDifferentlyNamedValueParametersB(arg1B: UserKlassA, arg2B: UserKlassB) {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testMultipleTypeAliasedValueParameterTypesA(arg1: UserKlassA, arg2: UserKlassB) {}
+fun testMultipleTypeAliasedValueParameterTypesA(arg1: UserKlassA, arg2: SameUserKlassB) {}
+
+fun testMultipleTypeAliasedValueParameterTypesAReverse(arg1: UserKlassA, arg2: UserKlassB) {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testMultipleTypeAliasedValueParameterTypesAReverse(arg1: UserKlassA, arg2: SameUserKlassB) {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testMultipleTypeAliasedValueParameterTypesB(arg1: UserKlassA, arg2: UserKlassB) {}
+fun testMultipleTypeAliasedValueParameterTypesB(arg1: SameUserKlassA, arg2: SameUserKlassB) {}
+
+fun testMultipleTypeAliasedValueParameterTypesBReverse(arg1: UserKlassA, arg2: UserKlassB) {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testMultipleTypeAliasedValueParameterTypesBReverse(arg1: SameUserKlassA, arg2: SameUserKlassB) {}
+
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testValueParameterWithIdenticalDefaultArguments(arg: UserKlass = defaultArgument) {}
+fun testValueParameterWithIdenticalDefaultArguments(arg: UserKlass = defaultArgument) {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testDifferencesInValueParameterDefaultArgumentsPresence(arg: UserKlass = defaultArgument) {}
+fun testDifferencesInValueParameterDefaultArgumentsPresence(arg: UserKlass) {}
+
+fun testDifferencesInValueParameterDefaultArgumentsPresenceReverse(arg: UserKlass = defaultArgument) {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testDifferencesInValueParameterDefaultArgumentsPresenceReverse(arg: UserKlass) {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testValueParameterWithDifferentDefaultArguments(arg: UserKlass = defaultArgumentA) {}
+fun testValueParameterWithDifferentDefaultArguments(arg: UserKlass = defaultArgumentB) {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testValueParameterWithAliasedDefaultArguments(arg: UserKlass = defaultArgument) {}
+fun testValueParameterWithAliasedDefaultArguments(arg: UserKlass = sameDefaultArgument) {}
+
+fun testValueParameterWithAliasedDefaultArgumentsReverse(arg: UserKlass = defaultArgument) {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testValueParameterWithAliasedDefaultArgumentsReverse(arg: UserKlass = sameDefaultArgument) {}
+
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testIdenticalTypeParametersA() {}
+fun <T> testIdenticalTypeParametersA() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testIdenticalTypeParametersB(arg: T) {}
+fun <T> testIdenticalTypeParametersB(arg: T) {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testIdenticalTypeParametersC(arg: Invariant<T>) {}
+fun <T> testIdenticalTypeParametersC(arg: Invariant<T>) {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <TA> testDifferentlyNamedTypeParametersA() {}
+fun <TB> testDifferentlyNamedTypeParametersA() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <TA> testDifferentlyNamedTypeParametersB(arg: TA) {}
+fun <TB> testDifferentlyNamedTypeParametersB(arg: TB) {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <TA> testDifferentlyNamedTypeParametersC(arg: Invariant<TA>) {}
+fun <TB> testDifferentlyNamedTypeParametersC(arg: Invariant<TB>) {}
+
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T1, T2> testMultipleIdenticalTypeParameters() {}
+fun <T1, T2> testMultipleIdenticalTypeParameters() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T1, T2A> testMultipleDifferentlyNamedTypeParametersA() {}
+fun <T1, T2B> testMultipleDifferentlyNamedTypeParametersA() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T1A, T2A> testMultipleDifferentlyNamedTypeParametersB() {}
+fun <T1B, T2B> testMultipleDifferentlyNamedTypeParametersB() {}
+
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> testTypeParameterWithIdenticalUpperBoundsA() {}
+fun <T: UserInterface> testTypeParameterWithIdenticalUpperBoundsA() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> testTypeParameterWithIdenticalUpperBoundsB(arg: T) {}
+fun <T: UserInterface> testTypeParameterWithIdenticalUpperBoundsB(arg: T) {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> testTypeParameterWithIdenticalUpperBoundsC(arg: Invariant<T>) {}
+fun <T: UserInterface> testTypeParameterWithIdenticalUpperBoundsC(arg: Invariant<T>) {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> testDifferencesInTypeParameterUpperBoundsPresence() {}
+fun <T> testDifferencesInTypeParameterUpperBoundsPresence() {}
+
+fun <T: UserInterface> testDifferencesInTypeParameterUpperBoundsPresenceReverse() {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testDifferencesInTypeParameterUpperBoundsPresenceReverse() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithDifferentUpperBounds() {}
+fun <T: UserInterfaceB> testTypeParameterWithDifferentUpperBounds() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsA() {}
+fun <T: Invariant<out UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsA() {}
+
+fun <T: Invariant<UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsAReverse() {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<out UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsAReverse() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsB() {}
+fun <T: Invariant<in UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsB() {}
+
+fun <T: Invariant<UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsBReverse() {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<in UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsBReverse() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsC() {}
+fun <T: Invariant<*>> testTypeParameterWithVarianceDifferentUpperBoundsC() {}
+
+fun <T: Invariant<UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsCReverse() {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<*>> testTypeParameterWithVarianceDifferentUpperBoundsCReverse() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<out UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsD() {}
+fun <T: Invariant<*>> testTypeParameterWithVarianceDifferentUpperBoundsD() {}
+
+fun <T: Invariant<out UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsDReverse() {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<*>> testTypeParameterWithVarianceDifferentUpperBoundsDReverse() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<in UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsE() {}
+fun <T: Invariant<*>> testTypeParameterWithVarianceDifferentUpperBoundsE() {}
+
+fun <T: Invariant<in UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsEReverse() {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<*>> testTypeParameterWithVarianceDifferentUpperBoundsEReverse() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<out UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsF() {}
+fun <T: Invariant<in UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsF() {}
+
+fun <T: Invariant<out UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsFReverse() {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<in UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsFReverse() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> testTypeParameterWithTypeAliasedUpperBoundsA() {}
+fun <T: SameUserInterface> testTypeParameterWithTypeAliasedUpperBoundsA() {}
+
+fun <T: UserInterface> testTypeParameterWithTypeAliasedUpperBoundsAReverse() {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterface> testTypeParameterWithTypeAliasedUpperBoundsAReverse() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> testTypeParameterWithTypeAliasedUpperBoundsB(arg: T) {}
+fun <T: SameUserInterface> testTypeParameterWithTypeAliasedUpperBoundsB(arg: T) {}
+
+fun <T: UserInterface> testTypeParameterWithTypeAliasedUpperBoundsBReverse(arg: T) {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterface> testTypeParameterWithTypeAliasedUpperBoundsBReverse(arg: T) {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> testTypeParameterWithTypeAliasedUpperBoundsC(arg: Invariant<T>) {}
+fun <T: SameUserInterface> testTypeParameterWithTypeAliasedUpperBoundsC(arg: Invariant<T>) {}
+
+fun <T: UserInterface> testTypeParameterWithTypeAliasedUpperBoundsCReverse(arg: Invariant<T>) {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterface> testTypeParameterWithTypeAliasedUpperBoundsCReverse(arg: Invariant<T>) {}
+
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleIdenticalUpperBoundsAA() where T: UserInterfaceA, T: UserInterfaceB {}
+fun <T> testTypeParameterWithMultipleIdenticalUpperBoundsAA() where T: UserInterfaceA, T: UserInterfaceB {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleIdenticalUpperBoundsAB(arg: T) where T: UserInterfaceA, T: UserInterfaceB {}
+fun <T> testTypeParameterWithMultipleIdenticalUpperBoundsAB(arg: T) where T: UserInterfaceA, T: UserInterfaceB {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleIdenticalUpperBoundsAC(arg: Invariant<T>) where T: UserInterfaceA, T: UserInterfaceB {}
+fun <T> testTypeParameterWithMultipleIdenticalUpperBoundsAC(arg: Invariant<T>) where T: UserInterfaceA, T: UserInterfaceB {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleIdenticalUpperBoundsBA() where T: UserInterfaceB {}
+fun <T: UserInterfaceA> testTypeParameterWithMultipleIdenticalUpperBoundsBA() where T: UserInterfaceB {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleIdenticalUpperBoundsBB(arg: T) where T: UserInterfaceB {}
+fun <T: UserInterfaceA> testTypeParameterWithMultipleIdenticalUpperBoundsBB(arg: T) where T: UserInterfaceB {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleIdenticalUpperBoundsBC(arg: Invariant<T>) where T: UserInterfaceB {}
+fun <T: UserInterfaceA> testTypeParameterWithMultipleIdenticalUpperBoundsBC(arg: Invariant<T>) where T: UserInterfaceB {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testDifferencesInTypeParameterMultipleUpperBoundsPresenceA() where T: UserInterfaceA, T: UserInterfaceB {}
+fun <T> testDifferencesInTypeParameterMultipleUpperBoundsPresenceA() where T: UserInterfaceA {}
+
+fun <T: UserInterfaceA> testDifferencesInTypeParameterMultipleUpperBoundsPresenceB() where T: UserInterfaceB {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testDifferencesInTypeParameterMultipleUpperBoundsPresenceB() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleDifferentUpperBoundsAA() where T: UserInterfaceA, T: UserInterfaceB {}
+fun <T> testTypeParameterWithMultipleDifferentUpperBoundsAA() where T: UserInterfaceA, T: UserInterfaceC {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleDifferentUpperBoundsAB() where T: UserInterfaceB {}
+fun <T: UserInterfaceA> testTypeParameterWithMultipleDifferentUpperBoundsAB() where T: UserInterfaceC {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceB> testTypeParameterWithMultipleDifferentUpperBoundsAC() where T: UserInterfaceA {}
+fun <T: UserInterfaceC> testTypeParameterWithMultipleDifferentUpperBoundsAC() where T: UserInterfaceA {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleDifferentUpperBoundsBA() where T: UserInterfaceA, T: UserInterfaceB {}
+fun <T> testTypeParameterWithMultipleDifferentUpperBoundsBA() where T: UserInterfaceC, T: UserInterfaceD {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleDifferentUpperBoundsBB() where T: UserInterfaceB {}
+fun <T: UserInterfaceC> testTypeParameterWithMultipleDifferentUpperBoundsBB() where T: UserInterfaceD {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAAA() where T: UserInterfaceA, T: UserInterfaceB {}
+fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAAA() where T: UserInterfaceA, T: SameUserInterfaceB {}
+
+fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAAAReverse() where T: UserInterfaceA, T: UserInterfaceB {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAAAReverse() where T: UserInterfaceA, T: SameUserInterfaceB {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAAB(arg: T) where T: UserInterfaceA, T: UserInterfaceB {}
+fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAAB(arg: T) where T: UserInterfaceA, T: SameUserInterfaceB {}
+
+fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAABReverse(arg: T) where T: UserInterfaceA, T: UserInterfaceB {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAABReverse(arg: T) where T: UserInterfaceA, T: SameUserInterfaceB {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAAC(arg: Invariant<T>) where T: UserInterfaceA, T: UserInterfaceB {}
+fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAAC(arg: Invariant<T>) where T: UserInterfaceA, T: SameUserInterfaceB {}
+
+fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAACReverse(arg: Invariant<T>) where T: UserInterfaceA, T: UserInterfaceB {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAACReverse(arg: Invariant<T>) where T: UserInterfaceA, T: SameUserInterfaceB {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABA() where T: UserInterfaceB {}
+fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABA() where T: SameUserInterfaceB {}
+
+fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABAReverse() where T: UserInterfaceB {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABAReverse() where T: SameUserInterfaceB {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABB(arg: T) where T: UserInterfaceB {}
+fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABB(arg: T) where T: SameUserInterfaceB {}
+
+fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABBReverse(arg: T) where T: UserInterfaceB {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABBReverse(arg: T) where T: SameUserInterfaceB {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABC(arg: Invariant<T>) where T: UserInterfaceB {}
+fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABC(arg: Invariant<T>) where T: SameUserInterfaceB {}
+
+fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABCReverse(arg: Invariant<T>) where T: UserInterfaceB {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABCReverse(arg: Invariant<T>) where T: SameUserInterfaceB {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACA() where T: UserInterfaceA {}
+fun <T: SameUserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACA() where T: UserInterfaceA {}
+
+fun <T: UserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACAReverse() where T: UserInterfaceA {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACAReverse() where T: UserInterfaceA {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACB(arg: T) where T: UserInterfaceA {}
+fun <T: SameUserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACB(arg: T) where T: UserInterfaceA {}
+
+fun <T: UserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACBReverse(arg: T) where T: UserInterfaceA {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACBReverse(arg: T) where T: UserInterfaceA {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACC(arg: Invariant<T>) where T: UserInterfaceA {}
+fun <T: SameUserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACC(arg: Invariant<T>) where T: UserInterfaceA {}
+
+fun <T: UserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACCReverse(arg: Invariant<T>) where T: UserInterfaceA {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACCReverse(arg: Invariant<T>) where T: UserInterfaceA {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBAA() where T: UserInterfaceA, T: UserInterfaceB {}
+fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBAA() where T: SameUserInterfaceA, T: SameUserInterfaceB {}
+
+fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBAAReverse() where T: UserInterfaceA, T: UserInterfaceB {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBAAReverse() where T: SameUserInterfaceA, T: SameUserInterfaceB {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBAB(arg: T) where T: UserInterfaceA, T: UserInterfaceB {}
+fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBAB(arg: T) where T: SameUserInterfaceA, T: SameUserInterfaceB {}
+
+fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBABReverse(arg: T) where T: UserInterfaceA, T: UserInterfaceB {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBABReverse(arg: T) where T: SameUserInterfaceA, T: SameUserInterfaceB {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBAC(arg: Invariant<T>) where T: UserInterfaceA, T: UserInterfaceB {}
+fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBAC(arg: Invariant<T>) where T: SameUserInterfaceA, T: SameUserInterfaceB {}
+
+fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBACReverse(arg: Invariant<T>) where T: UserInterfaceA, T: UserInterfaceB {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBACReverse(arg: Invariant<T>) where T: SameUserInterfaceA, T: SameUserInterfaceB {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBA() where T: UserInterfaceB {}
+fun <T: SameUserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBA() where T: SameUserInterfaceB {}
+
+fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBAReverse() where T: UserInterfaceB {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBAReverse() where T: SameUserInterfaceB {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBB(arg: T) where T: UserInterfaceB {}
+fun <T: SameUserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBB(arg: T) where T: SameUserInterfaceB {}
+
+fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBBReverse(arg: T) where T: UserInterfaceB {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBBReverse(arg: T) where T: SameUserInterfaceB {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBC(arg: Invariant<T>) where T: UserInterfaceB {}
+fun <T: SameUserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBC(arg: Invariant<T>) where T: SameUserInterfaceB {}
+
+fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBCReverse(arg: Invariant<T>) where T: UserInterfaceB {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBCReverse(arg: Invariant<T>) where T: SameUserInterfaceB {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleShuffledUpperBoundsAA() where T: UserInterfaceA, T: UserInterfaceB {}
+fun <T> testTypeParameterWithMultipleShuffledUpperBoundsAA() where T: UserInterfaceB, T: UserInterfaceA {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleShuffledUpperBoundsAB(arg: T) where T: UserInterfaceA, T: UserInterfaceB {}
+fun <T> testTypeParameterWithMultipleShuffledUpperBoundsAB(arg: T) where T: UserInterfaceB, T: UserInterfaceA {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleShuffledUpperBoundsAC(arg: Invariant<T>) where T: UserInterfaceA, T: UserInterfaceB {}
+fun <T> testTypeParameterWithMultipleShuffledUpperBoundsAC(arg: Invariant<T>) where T: UserInterfaceB, T: UserInterfaceA {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleShuffledUpperBoundsBA() where T: UserInterfaceB {}
+fun <T: UserInterfaceB> testTypeParameterWithMultipleShuffledUpperBoundsBA() where T: UserInterfaceA {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleShuffledUpperBoundsBB(arg: T) where T: UserInterfaceB {}
+fun <T: UserInterfaceB> testTypeParameterWithMultipleShuffledUpperBoundsBB(arg: T) where T: UserInterfaceA {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleShuffledUpperBoundsBC(arg: Invariant<T>) where T: UserInterfaceB {}
+fun <T: UserInterfaceB> testTypeParameterWithMultipleShuffledUpperBoundsBC(arg: Invariant<T>) where T: UserInterfaceA {}
+
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> testIdenticalReifiedTypeParameterA() {}
+inline fun <reified T> testIdenticalReifiedTypeParameterA() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> testIdenticalReifiedTypeParameterB(arg: T) {}
+inline fun <reified T> testIdenticalReifiedTypeParameterB(arg: T) {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> testIdenticalReifiedTypeParameterC(arg: Invariant<T>) {}
+inline fun <reified T> testIdenticalReifiedTypeParameterC(arg: Invariant<T>) {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> testDifferencesInReifiedBehaviorOfTypeParameterA() {}
+inline fun <T> testDifferencesInReifiedBehaviorOfTypeParameterA() {}
+
+inline fun <reified T> testDifferencesInReifiedBehaviorOfTypeParameterAReverse() {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <T> testDifferencesInReifiedBehaviorOfTypeParameterAReverse() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> testDifferencesInReifiedBehaviorOfTypeParameterB(arg: T) {}
+inline fun <T> testDifferencesInReifiedBehaviorOfTypeParameterB(arg: T) {}
+
+inline fun <reified T> testDifferencesInReifiedBehaviorOfTypeParameterBReverse(arg: T) {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <T> testDifferencesInReifiedBehaviorOfTypeParameterBReverse(arg: T) {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> testDifferencesInReifiedBehaviorOfTypeParameterC(arg: Invariant<T>) {}
+inline fun <T> testDifferencesInReifiedBehaviorOfTypeParameterC(arg: Invariant<T>) {}
+
+inline fun <reified T> testDifferencesInReifiedBehaviorOfTypeParameterCReverse(arg: Invariant<T>) {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <T> testDifferencesInReifiedBehaviorOfTypeParameterCReverse(arg: Invariant<T>) {}
+
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun testIdenticalPresenceOfInlineModifier() {}
+inline fun testIdenticalPresenceOfInlineModifier() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun testDifferencesInInlineModifierPresence() {}
+fun testDifferencesInInlineModifierPresence() {}
+
+inline fun testDifferencesInInlineModifierPresenceReverse() {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testDifferencesInInlineModifierPresenceReverse() {}
+
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) infix fun UserKlass.testIdenticalPresenceOfInfixModifier(arg: UserKlass) {}
+infix fun UserKlass.testIdenticalPresenceOfInfixModifier(arg: UserKlass) {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) infix fun UserKlass.testDifferencesInInfixModifierPresence(arg: UserKlass) {}
+fun UserKlass.testDifferencesInInfixModifierPresence(arg: UserKlass) {}
+
+infix fun UserKlass.testDifferencesInInfixModifierPresenceReverse(arg: UserKlass) {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun UserKlass.testDifferencesInInfixModifierPresenceReverse(arg: UserKlass) {}
+
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) operator fun UserKlassA.unaryPlus() {}
+operator fun UserKlassA.unaryPlus() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) operator fun UserKlassB.unaryPlus() {}
+fun UserKlassB.unaryPlus() {}
+
+operator fun UserKlassB.unaryMinus() {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun UserKlassB.unaryMinus() {}
+
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) tailrec fun testIdenticalPresenceOfTailrecModifier() {}
+tailrec fun testIdenticalPresenceOfTailrecModifier() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) tailrec fun testDifferencesInTailrecModifierPresence() {}
+fun testDifferencesInTailrecModifierPresence() {}
+
+tailrec fun testDifferencesInTailrecModifierPresenceReverse() {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testDifferencesInTailrecModifierPresenceReverse() {}
+
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) private fun testIdenticalPrivateVisibility() {}
+private fun testIdenticalPrivateVisibility() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal fun testIdenticalInternalVisibility() {}
+internal fun testIdenticalInternalVisibility() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) private fun testDifferencesInPrivateAndPublicVisibilities() {}
+public fun testDifferencesInPrivateAndPublicVisibilities() {}
+
+private fun testDifferencesInPrivateAndPublicVisibilitiesReverse() {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) public fun testDifferencesInPrivateAndPublicVisibilitiesReverse() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal fun testDifferencesInInternalAndPublicVisibilities() {}
+public fun testDifferencesInInternalAndPublicVisibilities() {}
+
+internal fun testDifferencesInInternalAndPublicVisibilitiesReverse() {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) public fun testDifferencesInInternalAndPublicVisibilitiesReverse() {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) private fun testDifferencesInPrivateAndInternalVisibilities() {}
+internal fun testDifferencesInPrivateAndInternalVisibilities() {}
+
+private fun testDifferencesInPrivateAndInternalVisibilitiesReverse() {}
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal fun testDifferencesInPrivateAndInternalVisibilitiesReverse() {}
+
+
+open class Invariant<T>
+
+
+class UserKlass
+class UserKlassA
+class UserKlassB
+typealias SameUserKlass = UserKlass
+typealias SameUserKlassA = UserKlassA
+typealias SameUserKlassB = UserKlassB
+
+
+val defaultArgument = UserKlass()
+val defaultArgumentA = UserKlass()
+val defaultArgumentB = UserKlass()
+val sameDefaultArgument = defaultArgument
+
+
+interface UserInterface
+interface UserInterfaceA
+interface UserInterfaceB
+interface UserInterfaceC
+interface UserInterfaceD
+typealias SameUserInterface = UserInterface
+typealias SameUserInterfaceA = UserInterfaceA
+typealias SameUserInterfaceB = UserInterfaceB

compiler/testData/diagnostics/tests/overload/noConflictingOverloadsWithDeprecatedHidden/FunctionsOnTopLevel.kt

@@ -0,0 +1,494 @@
+// DIAGNOSTICS: -MISPLACED_TYPE_PARAMETER_CONSTRAINTS, -NOTHING_TO_INLINE, -NO_TAIL_CALLS_FOUND
+
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testBasic()<!> {}
+<!CONFLICTING_OVERLOADS!>fun testBasic()<!> {}
+
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testIdenticalReturnTypes(): UserKlass<!> = UserKlass()
+<!CONFLICTING_OVERLOADS!>fun testIdenticalReturnTypes(): UserKlass<!> = UserKlass()
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testDifferencesInReturnTypePresence(): Unit<!> {}
+<!CONFLICTING_OVERLOADS!>fun testDifferencesInReturnTypePresence()<!> {}
+
+<!CONFLICTING_OVERLOADS!>fun testDifferencesInReturnTypePresenceReverse(): Unit<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testDifferencesInReturnTypePresenceReverse()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testDifferentReturnTypes(): UserKlassA<!> = UserKlassA()
+<!CONFLICTING_OVERLOADS!>fun testDifferentReturnTypes(): UserKlassB<!> = UserKlassB()
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesA(): Invariant<UserKlass><!> = Invariant()
+<!CONFLICTING_OVERLOADS!>fun testVarianceDifferentReturnTypesA(): Invariant<out UserKlass><!> = Invariant()
+
+<!CONFLICTING_OVERLOADS!>fun testVarianceDifferentReturnTypesAReverse(): Invariant<UserKlass><!> = Invariant()
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesAReverse(): Invariant<out UserKlass><!> = Invariant()
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesB(): Invariant<UserKlass><!> = Invariant()
+<!CONFLICTING_OVERLOADS!>fun testVarianceDifferentReturnTypesB(): Invariant<in UserKlass><!> = Invariant()
+
+<!CONFLICTING_OVERLOADS!>fun testVarianceDifferentReturnTypesBReverse(): Invariant<UserKlass><!> = Invariant()
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesBReverse(): Invariant<in UserKlass><!> = Invariant()
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesC(): Invariant<UserKlass><!> = Invariant()
+<!CONFLICTING_OVERLOADS!>fun testVarianceDifferentReturnTypesC(): Invariant<*><!> = Invariant<UserKlass>()
+
+<!CONFLICTING_OVERLOADS!>fun testVarianceDifferentReturnTypesCReverse(): Invariant<UserKlass><!> = Invariant()
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesCReverse(): Invariant<*><!> = Invariant<UserKlass>()
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesD(): Invariant<out UserKlass><!> = Invariant()
+<!CONFLICTING_OVERLOADS!>fun testVarianceDifferentReturnTypesD(): Invariant<*><!> = Invariant<UserKlass>()
+
+<!CONFLICTING_OVERLOADS!>fun testVarianceDifferentReturnTypesDReverse(): Invariant<out UserKlass><!> = Invariant()
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesDReverse(): Invariant<*><!> = Invariant<UserKlass>()
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesE(): Invariant<in UserKlass><!> = Invariant()
+<!CONFLICTING_OVERLOADS!>fun testVarianceDifferentReturnTypesE(): Invariant<*><!> = Invariant<UserKlass>()
+
+<!CONFLICTING_OVERLOADS!>fun testVarianceDifferentReturnTypesEReverse(): Invariant<in UserKlass><!> = Invariant()
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesEReverse(): Invariant<*><!> = Invariant<UserKlass>()
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesF(): Invariant<out UserKlass><!> = Invariant()
+<!CONFLICTING_OVERLOADS!>fun testVarianceDifferentReturnTypesF(): Invariant<in UserKlass><!> = Invariant()
+
+<!CONFLICTING_OVERLOADS!>fun testVarianceDifferentReturnTypesFReverse(): Invariant<out UserKlass><!> = Invariant()
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testVarianceDifferentReturnTypesFReverse(): Invariant<in UserKlass><!> = Invariant()
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testTypeAliasedReturnTypes(): UserKlass<!> = UserKlass()
+<!CONFLICTING_OVERLOADS!>fun testTypeAliasedReturnTypes(): SameUserKlass<!> = UserKlass()
+
+<!CONFLICTING_OVERLOADS!>fun testTypeAliasedReturnTypesReverse(): UserKlass<!> = UserKlass()
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testTypeAliasedReturnTypesReverse(): SameUserKlass<!> = UserKlass()
+
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun UserKlass.testIdenticalExtensionReceivers()<!> {}
+<!CONFLICTING_OVERLOADS!>fun UserKlass.testIdenticalExtensionReceivers()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun UserKlass.testTypeAliasedExtensionReceivers()<!> {}
+<!CONFLICTING_OVERLOADS!>fun SameUserKlass.testTypeAliasedExtensionReceivers()<!> {}
+
+<!CONFLICTING_OVERLOADS!>fun UserKlass.testTypeAliasedExtensionReceiversReverse()<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun SameUserKlass.testTypeAliasedExtensionReceiversReverse()<!> {}
+
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testIdenticalValueParameters(arg: UserKlass)<!> {}
+<!CONFLICTING_OVERLOADS!>fun testIdenticalValueParameters(arg: UserKlass)<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testDifferentlyNamedValueParameters(argA: UserKlass)<!> {}
+<!CONFLICTING_OVERLOADS!>fun testDifferentlyNamedValueParameters(argB: UserKlass)<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testTypeAliasedValueParameterTypes(arg: UserKlass)<!> {}
+<!CONFLICTING_OVERLOADS!>fun testTypeAliasedValueParameterTypes(arg: SameUserKlass)<!> {}
+
+<!CONFLICTING_OVERLOADS!>fun testTypeAliasedValueParameterTypesReverse(arg: UserKlass)<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testTypeAliasedValueParameterTypesReverse(arg: SameUserKlass)<!> {}
+
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testMultipleIdenticalValueParameters(arg1: UserKlassA, arg2: UserKlassB)<!> {}
+<!CONFLICTING_OVERLOADS!>fun testMultipleIdenticalValueParameters(arg1: UserKlassA, arg2: UserKlassB)<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testMultipleDifferentlyNamedValueParametersA(arg1: UserKlassA, arg2A: UserKlassB)<!> {}
+<!CONFLICTING_OVERLOADS!>fun testMultipleDifferentlyNamedValueParametersA(arg1: UserKlassA, arg2B: UserKlassB)<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testMultipleDifferentlyNamedValueParametersB(arg1A: UserKlassA, arg2A: UserKlassB)<!> {}
+<!CONFLICTING_OVERLOADS!>fun testMultipleDifferentlyNamedValueParametersB(arg1B: UserKlassA, arg2B: UserKlassB)<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testMultipleTypeAliasedValueParameterTypesA(arg1: UserKlassA, arg2: UserKlassB)<!> {}
+<!CONFLICTING_OVERLOADS!>fun testMultipleTypeAliasedValueParameterTypesA(arg1: UserKlassA, arg2: SameUserKlassB)<!> {}
+
+<!CONFLICTING_OVERLOADS!>fun testMultipleTypeAliasedValueParameterTypesAReverse(arg1: UserKlassA, arg2: UserKlassB)<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testMultipleTypeAliasedValueParameterTypesAReverse(arg1: UserKlassA, arg2: SameUserKlassB)<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testMultipleTypeAliasedValueParameterTypesB(arg1: UserKlassA, arg2: UserKlassB)<!> {}
+<!CONFLICTING_OVERLOADS!>fun testMultipleTypeAliasedValueParameterTypesB(arg1: SameUserKlassA, arg2: SameUserKlassB)<!> {}
+
+<!CONFLICTING_OVERLOADS!>fun testMultipleTypeAliasedValueParameterTypesBReverse(arg1: UserKlassA, arg2: UserKlassB)<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testMultipleTypeAliasedValueParameterTypesBReverse(arg1: SameUserKlassA, arg2: SameUserKlassB)<!> {}
+
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testValueParameterWithIdenticalDefaultArguments(arg: UserKlass = defaultArgument)<!> {}
+<!CONFLICTING_OVERLOADS!>fun testValueParameterWithIdenticalDefaultArguments(arg: UserKlass = defaultArgument)<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testDifferencesInValueParameterDefaultArgumentsPresence(arg: UserKlass = defaultArgument)<!> {}
+<!CONFLICTING_OVERLOADS!>fun testDifferencesInValueParameterDefaultArgumentsPresence(arg: UserKlass)<!> {}
+
+<!CONFLICTING_OVERLOADS!>fun testDifferencesInValueParameterDefaultArgumentsPresenceReverse(arg: UserKlass = defaultArgument)<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testDifferencesInValueParameterDefaultArgumentsPresenceReverse(arg: UserKlass)<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testValueParameterWithDifferentDefaultArguments(arg: UserKlass = defaultArgumentA)<!> {}
+<!CONFLICTING_OVERLOADS!>fun testValueParameterWithDifferentDefaultArguments(arg: UserKlass = defaultArgumentB)<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testValueParameterWithAliasedDefaultArguments(arg: UserKlass = defaultArgument)<!> {}
+<!CONFLICTING_OVERLOADS!>fun testValueParameterWithAliasedDefaultArguments(arg: UserKlass = sameDefaultArgument)<!> {}
+
+<!CONFLICTING_OVERLOADS!>fun testValueParameterWithAliasedDefaultArgumentsReverse(arg: UserKlass = defaultArgument)<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testValueParameterWithAliasedDefaultArgumentsReverse(arg: UserKlass = sameDefaultArgument)<!> {}
+
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testIdenticalTypeParametersA()<!> {}
+<!CONFLICTING_OVERLOADS!>fun <T> testIdenticalTypeParametersA()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testIdenticalTypeParametersB(arg: T)<!> {}
+<!CONFLICTING_OVERLOADS!>fun <T> testIdenticalTypeParametersB(arg: T)<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testIdenticalTypeParametersC(arg: Invariant<T>)<!> {}
+<!CONFLICTING_OVERLOADS!>fun <T> testIdenticalTypeParametersC(arg: Invariant<T>)<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <TA> testDifferentlyNamedTypeParametersA()<!> {}
+<!CONFLICTING_OVERLOADS!>fun <TB> testDifferentlyNamedTypeParametersA()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <TA> testDifferentlyNamedTypeParametersB(arg: TA)<!> {}
+<!CONFLICTING_OVERLOADS!>fun <TB> testDifferentlyNamedTypeParametersB(arg: TB)<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <TA> testDifferentlyNamedTypeParametersC(arg: Invariant<TA>)<!> {}
+<!CONFLICTING_OVERLOADS!>fun <TB> testDifferentlyNamedTypeParametersC(arg: Invariant<TB>)<!> {}
+
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T1, T2> testMultipleIdenticalTypeParameters()<!> {}
+<!CONFLICTING_OVERLOADS!>fun <T1, T2> testMultipleIdenticalTypeParameters()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T1, T2A> testMultipleDifferentlyNamedTypeParametersA()<!> {}
+<!CONFLICTING_OVERLOADS!>fun <T1, T2B> testMultipleDifferentlyNamedTypeParametersA()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T1A, T2A> testMultipleDifferentlyNamedTypeParametersB()<!> {}
+<!CONFLICTING_OVERLOADS!>fun <T1B, T2B> testMultipleDifferentlyNamedTypeParametersB()<!> {}
+
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> testTypeParameterWithIdenticalUpperBoundsA()<!> {}
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterface> testTypeParameterWithIdenticalUpperBoundsA()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> testTypeParameterWithIdenticalUpperBoundsB(arg: T)<!> {}
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterface> testTypeParameterWithIdenticalUpperBoundsB(arg: T)<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> testTypeParameterWithIdenticalUpperBoundsC(arg: Invariant<T>)<!> {}
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterface> testTypeParameterWithIdenticalUpperBoundsC(arg: Invariant<T>)<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> testDifferencesInTypeParameterUpperBoundsPresence()<!> {}
+<!CONFLICTING_OVERLOADS!>fun <T> testDifferencesInTypeParameterUpperBoundsPresence()<!> {}
+
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterface> testDifferencesInTypeParameterUpperBoundsPresenceReverse()<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testDifferencesInTypeParameterUpperBoundsPresenceReverse()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithDifferentUpperBounds()<!> {}
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceB> testTypeParameterWithDifferentUpperBounds()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsA()<!> {}
+<!CONFLICTING_OVERLOADS!>fun <T: Invariant<out UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsA()<!> {}
+
+<!CONFLICTING_OVERLOADS!>fun <T: Invariant<UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsAReverse()<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<out UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsAReverse()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsB()<!> {}
+<!CONFLICTING_OVERLOADS!>fun <T: Invariant<in UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsB()<!> {}
+
+<!CONFLICTING_OVERLOADS!>fun <T: Invariant<UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsBReverse()<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<in UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsBReverse()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsC()<!> {}
+<!CONFLICTING_OVERLOADS!>fun <T: Invariant<*>> testTypeParameterWithVarianceDifferentUpperBoundsC()<!> {}
+
+<!CONFLICTING_OVERLOADS!>fun <T: Invariant<UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsCReverse()<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<*>> testTypeParameterWithVarianceDifferentUpperBoundsCReverse()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<out UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsD()<!> {}
+<!CONFLICTING_OVERLOADS!>fun <T: Invariant<*>> testTypeParameterWithVarianceDifferentUpperBoundsD()<!> {}
+
+<!CONFLICTING_OVERLOADS!>fun <T: Invariant<out UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsDReverse()<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<*>> testTypeParameterWithVarianceDifferentUpperBoundsDReverse()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<in UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsE()<!> {}
+<!CONFLICTING_OVERLOADS!>fun <T: Invariant<*>> testTypeParameterWithVarianceDifferentUpperBoundsE()<!> {}
+
+<!CONFLICTING_OVERLOADS!>fun <T: Invariant<in UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsEReverse()<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<*>> testTypeParameterWithVarianceDifferentUpperBoundsEReverse()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<out UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsF()<!> {}
+<!CONFLICTING_OVERLOADS!>fun <T: Invariant<in UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsF()<!> {}
+
+<!CONFLICTING_OVERLOADS!>fun <T: Invariant<out UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsFReverse()<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: Invariant<in UserInterface>> testTypeParameterWithVarianceDifferentUpperBoundsFReverse()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> testTypeParameterWithTypeAliasedUpperBoundsA()<!> {}
+<!CONFLICTING_OVERLOADS!>fun <T: SameUserInterface> testTypeParameterWithTypeAliasedUpperBoundsA()<!> {}
+
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterface> testTypeParameterWithTypeAliasedUpperBoundsAReverse()<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterface> testTypeParameterWithTypeAliasedUpperBoundsAReverse()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> testTypeParameterWithTypeAliasedUpperBoundsB(arg: T)<!> {}
+<!CONFLICTING_OVERLOADS!>fun <T: SameUserInterface> testTypeParameterWithTypeAliasedUpperBoundsB(arg: T)<!> {}
+
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterface> testTypeParameterWithTypeAliasedUpperBoundsBReverse(arg: T)<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterface> testTypeParameterWithTypeAliasedUpperBoundsBReverse(arg: T)<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterface> testTypeParameterWithTypeAliasedUpperBoundsC(arg: Invariant<T>)<!> {}
+<!CONFLICTING_OVERLOADS!>fun <T: SameUserInterface> testTypeParameterWithTypeAliasedUpperBoundsC(arg: Invariant<T>)<!> {}
+
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterface> testTypeParameterWithTypeAliasedUpperBoundsCReverse(arg: Invariant<T>)<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterface> testTypeParameterWithTypeAliasedUpperBoundsCReverse(arg: Invariant<T>)<!> {}
+
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleIdenticalUpperBoundsAA()<!> where T: UserInterfaceA, T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleIdenticalUpperBoundsAA()<!> where T: UserInterfaceA, T: UserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleIdenticalUpperBoundsAB(arg: T)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleIdenticalUpperBoundsAB(arg: T)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleIdenticalUpperBoundsAC(arg: Invariant<T>)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleIdenticalUpperBoundsAC(arg: Invariant<T>)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleIdenticalUpperBoundsBA()<!> where T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceA> testTypeParameterWithMultipleIdenticalUpperBoundsBA()<!> where T: UserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleIdenticalUpperBoundsBB(arg: T)<!> where T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceA> testTypeParameterWithMultipleIdenticalUpperBoundsBB(arg: T)<!> where T: UserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleIdenticalUpperBoundsBC(arg: Invariant<T>)<!> where T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceA> testTypeParameterWithMultipleIdenticalUpperBoundsBC(arg: Invariant<T>)<!> where T: UserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testDifferencesInTypeParameterMultipleUpperBoundsPresenceA()<!> where T: UserInterfaceA, T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T> testDifferencesInTypeParameterMultipleUpperBoundsPresenceA()<!> where T: UserInterfaceA {}
+
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceA> testDifferencesInTypeParameterMultipleUpperBoundsPresenceB()<!> where T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testDifferencesInTypeParameterMultipleUpperBoundsPresenceB()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleDifferentUpperBoundsAA()<!> where T: UserInterfaceA, T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleDifferentUpperBoundsAA()<!> where T: UserInterfaceA, T: UserInterfaceC {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleDifferentUpperBoundsAB()<!> where T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceA> testTypeParameterWithMultipleDifferentUpperBoundsAB()<!> where T: UserInterfaceC {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceB> testTypeParameterWithMultipleDifferentUpperBoundsAC()<!> where T: UserInterfaceA {}
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceC> testTypeParameterWithMultipleDifferentUpperBoundsAC()<!> where T: UserInterfaceA {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleDifferentUpperBoundsBA()<!> where T: UserInterfaceA, T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleDifferentUpperBoundsBA()<!> where T: UserInterfaceC, T: UserInterfaceD {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleDifferentUpperBoundsBB()<!> where T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceC> testTypeParameterWithMultipleDifferentUpperBoundsBB()<!> where T: UserInterfaceD {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAAA()<!> where T: UserInterfaceA, T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAAA()<!> where T: UserInterfaceA, T: SameUserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAAAReverse()<!> where T: UserInterfaceA, T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAAAReverse()<!> where T: UserInterfaceA, T: SameUserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAAB(arg: T)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAAB(arg: T)<!> where T: UserInterfaceA, T: SameUserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAABReverse(arg: T)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAABReverse(arg: T)<!> where T: UserInterfaceA, T: SameUserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAAC(arg: Invariant<T>)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAAC(arg: Invariant<T>)<!> where T: UserInterfaceA, T: SameUserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAACReverse(arg: Invariant<T>)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsAACReverse(arg: Invariant<T>)<!> where T: UserInterfaceA, T: SameUserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABA()<!> where T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABA()<!> where T: SameUserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABAReverse()<!> where T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABAReverse()<!> where T: SameUserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABB(arg: T)<!> where T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABB(arg: T)<!> where T: SameUserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABBReverse(arg: T)<!> where T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABBReverse(arg: T)<!> where T: SameUserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABC(arg: Invariant<T>)<!> where T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABC(arg: Invariant<T>)<!> where T: SameUserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABCReverse(arg: Invariant<T>)<!> where T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsABCReverse(arg: Invariant<T>)<!> where T: SameUserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACA()<!> where T: UserInterfaceA {}
+<!CONFLICTING_OVERLOADS!>fun <T: SameUserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACA()<!> where T: UserInterfaceA {}
+
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACAReverse()<!> where T: UserInterfaceA {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACAReverse()<!> where T: UserInterfaceA {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACB(arg: T)<!> where T: UserInterfaceA {}
+<!CONFLICTING_OVERLOADS!>fun <T: SameUserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACB(arg: T)<!> where T: UserInterfaceA {}
+
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACBReverse(arg: T)<!> where T: UserInterfaceA {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACBReverse(arg: T)<!> where T: UserInterfaceA {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACC(arg: Invariant<T>)<!> where T: UserInterfaceA {}
+<!CONFLICTING_OVERLOADS!>fun <T: SameUserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACC(arg: Invariant<T>)<!> where T: UserInterfaceA {}
+
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACCReverse(arg: Invariant<T>)<!> where T: UserInterfaceA {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterfaceB> testTypeParameterWithMultipleTypeAliasedUpperBoundsACCReverse(arg: Invariant<T>)<!> where T: UserInterfaceA {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBAA()<!> where T: UserInterfaceA, T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBAA()<!> where T: SameUserInterfaceA, T: SameUserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBAAReverse()<!> where T: UserInterfaceA, T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBAAReverse()<!> where T: SameUserInterfaceA, T: SameUserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBAB(arg: T)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBAB(arg: T)<!> where T: SameUserInterfaceA, T: SameUserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBABReverse(arg: T)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBABReverse(arg: T)<!> where T: SameUserInterfaceA, T: SameUserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBAC(arg: Invariant<T>)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBAC(arg: Invariant<T>)<!> where T: SameUserInterfaceA, T: SameUserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBACReverse(arg: Invariant<T>)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleTypeAliasedUpperBoundsBACReverse(arg: Invariant<T>)<!> where T: SameUserInterfaceA, T: SameUserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBA()<!> where T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T: SameUserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBA()<!> where T: SameUserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBAReverse()<!> where T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBAReverse()<!> where T: SameUserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBB(arg: T)<!> where T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T: SameUserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBB(arg: T)<!> where T: SameUserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBBReverse(arg: T)<!> where T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBBReverse(arg: T)<!> where T: SameUserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBC(arg: Invariant<T>)<!> where T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T: SameUserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBC(arg: Invariant<T>)<!> where T: SameUserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBCReverse(arg: Invariant<T>)<!> where T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: SameUserInterfaceA> testTypeParameterWithMultipleTypeAliasedUpperBoundsBBCReverse(arg: Invariant<T>)<!> where T: SameUserInterfaceB {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleShuffledUpperBoundsAA()<!> where T: UserInterfaceA, T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleShuffledUpperBoundsAA()<!> where T: UserInterfaceB, T: UserInterfaceA {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleShuffledUpperBoundsAB(arg: T)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleShuffledUpperBoundsAB(arg: T)<!> where T: UserInterfaceB, T: UserInterfaceA {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T> testTypeParameterWithMultipleShuffledUpperBoundsAC(arg: Invariant<T>)<!> where T: UserInterfaceA, T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T> testTypeParameterWithMultipleShuffledUpperBoundsAC(arg: Invariant<T>)<!> where T: UserInterfaceB, T: UserInterfaceA {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleShuffledUpperBoundsBA()<!> where T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceB> testTypeParameterWithMultipleShuffledUpperBoundsBA()<!> where T: UserInterfaceA {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleShuffledUpperBoundsBB(arg: T)<!> where T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceB> testTypeParameterWithMultipleShuffledUpperBoundsBB(arg: T)<!> where T: UserInterfaceA {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun <T: UserInterfaceA> testTypeParameterWithMultipleShuffledUpperBoundsBC(arg: Invariant<T>)<!> where T: UserInterfaceB {}
+<!CONFLICTING_OVERLOADS!>fun <T: UserInterfaceB> testTypeParameterWithMultipleShuffledUpperBoundsBC(arg: Invariant<T>)<!> where T: UserInterfaceA {}
+
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> testIdenticalReifiedTypeParameterA()<!> {}
+<!CONFLICTING_OVERLOADS!>inline fun <reified T> testIdenticalReifiedTypeParameterA()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> testIdenticalReifiedTypeParameterB(arg: T)<!> {}
+<!CONFLICTING_OVERLOADS!>inline fun <reified T> testIdenticalReifiedTypeParameterB(arg: T)<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> testIdenticalReifiedTypeParameterC(arg: Invariant<T>)<!> {}
+<!CONFLICTING_OVERLOADS!>inline fun <reified T> testIdenticalReifiedTypeParameterC(arg: Invariant<T>)<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> testDifferencesInReifiedBehaviorOfTypeParameterA()<!> {}
+<!CONFLICTING_OVERLOADS!>inline fun <T> testDifferencesInReifiedBehaviorOfTypeParameterA()<!> {}
+
+<!CONFLICTING_OVERLOADS!>inline fun <reified T> testDifferencesInReifiedBehaviorOfTypeParameterAReverse()<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <T> testDifferencesInReifiedBehaviorOfTypeParameterAReverse()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> testDifferencesInReifiedBehaviorOfTypeParameterB(arg: T)<!> {}
+<!CONFLICTING_OVERLOADS!>inline fun <T> testDifferencesInReifiedBehaviorOfTypeParameterB(arg: T)<!> {}
+
+<!CONFLICTING_OVERLOADS!>inline fun <reified T> testDifferencesInReifiedBehaviorOfTypeParameterBReverse(arg: T)<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <T> testDifferencesInReifiedBehaviorOfTypeParameterBReverse(arg: T)<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <reified T> testDifferencesInReifiedBehaviorOfTypeParameterC(arg: Invariant<T>)<!> {}
+<!CONFLICTING_OVERLOADS!>inline fun <T> testDifferencesInReifiedBehaviorOfTypeParameterC(arg: Invariant<T>)<!> {}
+
+<!CONFLICTING_OVERLOADS!>inline fun <reified T> testDifferencesInReifiedBehaviorOfTypeParameterCReverse(arg: Invariant<T>)<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun <T> testDifferencesInReifiedBehaviorOfTypeParameterCReverse(arg: Invariant<T>)<!> {}
+
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun testIdenticalPresenceOfInlineModifier()<!> {}
+<!CONFLICTING_OVERLOADS!>inline fun testIdenticalPresenceOfInlineModifier()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) inline fun testDifferencesInInlineModifierPresence()<!> {}
+<!CONFLICTING_OVERLOADS!>fun testDifferencesInInlineModifierPresence()<!> {}
+
+<!CONFLICTING_OVERLOADS!>inline fun testDifferencesInInlineModifierPresenceReverse()<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testDifferencesInInlineModifierPresenceReverse()<!> {}
+
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) infix fun UserKlass.testIdenticalPresenceOfInfixModifier(arg: UserKlass)<!> {}
+<!CONFLICTING_OVERLOADS!>infix fun UserKlass.testIdenticalPresenceOfInfixModifier(arg: UserKlass)<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) infix fun UserKlass.testDifferencesInInfixModifierPresence(arg: UserKlass)<!> {}
+<!CONFLICTING_OVERLOADS!>fun UserKlass.testDifferencesInInfixModifierPresence(arg: UserKlass)<!> {}
+
+<!CONFLICTING_OVERLOADS!>infix fun UserKlass.testDifferencesInInfixModifierPresenceReverse(arg: UserKlass)<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun UserKlass.testDifferencesInInfixModifierPresenceReverse(arg: UserKlass)<!> {}
+
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) operator fun UserKlassA.unaryPlus()<!> {}
+<!CONFLICTING_OVERLOADS!>operator fun UserKlassA.unaryPlus()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) operator fun UserKlassB.unaryPlus()<!> {}
+<!CONFLICTING_OVERLOADS!>fun UserKlassB.unaryPlus()<!> {}
+
+<!CONFLICTING_OVERLOADS!>operator fun UserKlassB.unaryMinus()<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun UserKlassB.unaryMinus()<!> {}
+
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) tailrec fun testIdenticalPresenceOfTailrecModifier()<!> {}
+<!CONFLICTING_OVERLOADS!>tailrec fun testIdenticalPresenceOfTailrecModifier()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) tailrec fun testDifferencesInTailrecModifierPresence()<!> {}
+<!CONFLICTING_OVERLOADS!>fun testDifferencesInTailrecModifierPresence()<!> {}
+
+<!CONFLICTING_OVERLOADS!>tailrec fun testDifferencesInTailrecModifierPresenceReverse()<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) fun testDifferencesInTailrecModifierPresenceReverse()<!> {}
+
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) private fun testIdenticalPrivateVisibility()<!> {}
+<!CONFLICTING_OVERLOADS!>private fun testIdenticalPrivateVisibility()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal fun testIdenticalInternalVisibility()<!> {}
+<!CONFLICTING_OVERLOADS!>internal fun testIdenticalInternalVisibility()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) private fun testDifferencesInPrivateAndPublicVisibilities()<!> {}
+<!CONFLICTING_OVERLOADS!>public fun testDifferencesInPrivateAndPublicVisibilities()<!> {}
+
+<!CONFLICTING_OVERLOADS!>private fun testDifferencesInPrivateAndPublicVisibilitiesReverse()<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) public fun testDifferencesInPrivateAndPublicVisibilitiesReverse()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal fun testDifferencesInInternalAndPublicVisibilities()<!> {}
+<!CONFLICTING_OVERLOADS!>public fun testDifferencesInInternalAndPublicVisibilities()<!> {}
+
+<!CONFLICTING_OVERLOADS!>internal fun testDifferencesInInternalAndPublicVisibilitiesReverse()<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) public fun testDifferencesInInternalAndPublicVisibilitiesReverse()<!> {}
+
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) private fun testDifferencesInPrivateAndInternalVisibilities()<!> {}
+<!CONFLICTING_OVERLOADS!>internal fun testDifferencesInPrivateAndInternalVisibilities()<!> {}
+
+<!CONFLICTING_OVERLOADS!>private fun testDifferencesInPrivateAndInternalVisibilitiesReverse()<!> {}
+<!CONFLICTING_OVERLOADS!>@Deprecated(message = "", level = DeprecationLevel.HIDDEN) internal fun testDifferencesInPrivateAndInternalVisibilitiesReverse()<!> {}
+
+
+open class Invariant<T>
+
+
+class UserKlass
+class UserKlassA
+class UserKlassB
+typealias SameUserKlass = UserKlass
+typealias SameUserKlassA = UserKlassA
+typealias SameUserKlassB = UserKlassB
+
+
+val defaultArgument = UserKlass()
+val defaultArgumentA = UserKlass()
+val defaultArgumentB = UserKlass()
+val sameDefaultArgument = defaultArgument
+
+
+interface UserInterface
+interface UserInterfaceA
+interface UserInterfaceB
+interface UserInterfaceC
+interface UserInterfaceD
+typealias SameUserInterface = UserInterface
+typealias SameUserInterfaceA = UserInterfaceA
+typealias SameUserInterfaceB = UserInterfaceB

compiler/testData/diagnostics/tests/overload/noConflictingOverloadsWithDeprecatedHidden/NoHiddenTransitivityFromClassifierToConstructor.kt

@@ -0,0 +1,19 @@
+// FIR_IDENTICAL
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN)
+class <!CONFLICTING_OVERLOADS!>KlassA<!>
+<!CONFLICTING_OVERLOADS!>fun KlassA()<!> {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN)
+class KlassB<!CONFLICTING_OVERLOADS!>()<!>
+<!CONFLICTING_OVERLOADS!>fun KlassB()<!> {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN)
+class KlassC <!CONFLICTING_OVERLOADS!>constructor()<!>
+<!CONFLICTING_OVERLOADS!>fun KlassC()<!> {}
+
+@Deprecated(message = "", level = DeprecationLevel.HIDDEN)
+class KlassD {
+    <!CONFLICTING_OVERLOADS!>constructor()<!>
+}
+<!CONFLICTING_OVERLOADS!>fun KlassD()<!> {}