[FIR-TEST] Add new testdata generated after changes in previous commit

compiler/testData/diagnostics/tests/operatorRem/DeprecatedModAssignOperatorConventions.fir.kt

@@ -0,0 +1,43 @@
+// !LANGUAGE: -ProhibitOperatorMod
+// !WITH_NEW_INFERENCE
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+class OldAndNew {
+    operator fun modAssign(x: Int) {}
+    operator fun remAssign(x: Int) {}
+}
+
+class OnlyOld {
+    operator fun modAssign(x: Int) {}
+}
+
+class OnlyNew {
+    operator fun remAssign(x: Int) {}
+}
+
+class Sample
+
+operator fun Sample.modAssign(x: Int) {}
+operator fun Sample.remAssign(x: Int) {}
+
+class ModAndRemAssign {
+    operator fun mod(x: Int): ModAndRemAssign = ModAndRemAssign()
+    operator fun remAssign(x: Int) {}
+}
+
+fun test() {
+    val oldAndNew = OldAndNew()
+    oldAndNew %= 1
+
+    val onlyOld = OnlyOld()
+    <!INAPPLICABLE_CANDIDATE!>onlyOld %= 1<!>
+
+    val onlyNew = OnlyNew()
+    onlyNew %= 1
+
+    val sample = Sample()
+    sample %= 1
+
+    var modAndRemAssign = ModAndRemAssign()
+    modAndRemAssign %= 1
+}

compiler/testData/diagnostics/tests/operatorRem/DeprecatedModOperatorConventions.fir.kt

@@ -0,0 +1,37 @@
+// !LANGUAGE: -ProhibitOperatorMod
+// !WITH_NEW_INFERENCE
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+class OldAndNew {
+    operator fun mod(x: Int) {}
+    operator fun rem(x: Int) {}
+}
+
+class OnlyOld {
+    operator fun mod(x: Int) {}
+}
+
+class OnlyNew {
+    operator fun rem(x: Int) {}
+}
+
+class Sample
+
+operator fun Sample.mod(x: Int) {}
+operator fun Sample.rem(x: Int) {}
+
+class IntAndUnit {
+    operator fun mod(x: Int) = 0
+    operator fun rem(x: Int): Int = 0
+}
+
+fun test() {
+    OldAndNew() % 1
+    OnlyOld() <!INAPPLICABLE_CANDIDATE!>%<!> 1
+    OnlyNew() % 1
+    Sample() % 1
+
+    takeInt(IntAndUnit() % 1)
+}
+
+fun takeInt(x: Int) {}

compiler/testData/diagnostics/tests/operatorRem/deprecatedModConvention.fir.kt

@@ -0,0 +1,38 @@
+// !LANGUAGE: -ProhibitOperatorMod
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+object ModAndRem {
+    operator fun mod(x: Int) {}
+    operator fun rem(x: Int) {}
+}
+
+object OldMod {
+    operator fun mod(x: Int) {}
+}
+
+object ModAndRemExtension
+operator fun ModAndRemExtension.mod(x: Int) {}
+operator fun ModAndRemExtension.rem(x: Int) {}
+
+object ModExtension
+operator fun ModExtension.mod(x: Int) {}
+
+object ModMemberAndRemExtension {
+    operator fun mod(x: Int) {}
+}
+
+operator fun ModMemberAndRemExtension.rem(x: Int) {}
+
+fun foo() {
+    ModAndRem % 1
+    OldMod <!INAPPLICABLE_CANDIDATE!>%<!> 1
+
+    ModAndRemExtension % 1
+
+    ModExtension <!INAPPLICABLE_CANDIDATE!>%<!> 1
+
+    ModMemberAndRemExtension % 1
+
+    OldMod.mod(1)
+    ModExtension.mod(1)
+}

compiler/testData/diagnostics/tests/operatorRem/doNotResolveToInapplicableRem.fir.kt

@@ -0,0 +1,14 @@
+// !LANGUAGE: -ProhibitOperatorMod
+// !WITH_NEW_INFERENCE
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+object OldMod {
+    operator fun mod(x: Int) {}
+}
+
+object RemExtension
+operator fun RemExtension.rem(x: Int) {}
+
+fun foo() {
+    OldMod <!INAPPLICABLE_CANDIDATE!>%<!> 123
+}

compiler/testData/diagnostics/tests/operatorRem/errorOnExplicitModCall.fir.kt

@@ -0,0 +1,3 @@
+fun test() {
+    1.mod(3)
+}

compiler/testData/diagnostics/tests/operatorRem/forbiddenModOperatorConvention.fir.kt

@@ -0,0 +1,32 @@
+// !LANGUAGE: +ProhibitOperatorMod
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+object ModAndRem {
+    operator fun mod(x: Int) {}
+    operator fun rem(x: Int) {}
+
+    operator fun modAssign(x: Int) {}
+    operator fun remAssign(x: Int) {}
+}
+
+object JustMod {
+    operator fun mod(x: Int) {}
+    operator fun modAssign(x: Int) {}
+}
+
+fun foo() {
+    ModAndRem % 1
+    ModAndRem.mod(1)
+    ModAndRem.rem(1)
+
+    JustMod <!UNRESOLVED_REFERENCE!>%<!> 1
+    JustMod.mod(1)
+
+    val r = ModAndRem
+    r %= 1
+    r.remAssign(1)
+
+    val m = JustMod
+    <!UNRESOLVED_REFERENCE!>m %= 1<!>
+    m.modAssign(1)
+}

compiler/testData/diagnostics/tests/operatorRem/modWithRemAssign.fir.kt

@@ -0,0 +1,17 @@
+// !LANGUAGE: -ProhibitOperatorMod
+// !DIAGNOSTICS: -UNUSED_PARAMETER, -EXTENSION_SHADOWED_BY_MEMBER
+
+class ModAndRemAssign {
+    operator fun mod(x: Int) = ModAndRemAssign()
+    operator fun mod(x: String) = ModAndRemAssign()
+    operator fun modAssign(x: String) {}
+    operator fun remAssign(x: Int) {}
+}
+
+operator fun ModAndRemAssign.mod(x: String) = ModAndRemAssign()
+operator fun ModAndRemAssign.modAssign(x: String) {}
+
+fun test() {
+    val modAndRemAssign = ModAndRemAssign()
+    modAndRemAssign %= 1
+}

compiler/testData/diagnostics/tests/operatorRem/noDeprecatedModConventionWithoutFeature.fir.kt

@@ -0,0 +1,38 @@
+// !LANGUAGE: -OperatorRem
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+object ModAndRem {
+    operator fun mod(x: Int) {}
+    operator fun rem(x: Int) {}
+}
+
+object OldMod {
+    operator fun mod(x: Int) {}
+}
+
+object ModAndRemExtension
+operator fun ModAndRemExtension.mod(x: Int) {}
+operator fun ModAndRemExtension.rem(x: Int) {}
+
+object ModExtension
+operator fun ModExtension.mod(x: Int) {}
+
+object ModMemberAndRemExtension {
+    operator fun mod(x: Int) {}
+}
+
+operator fun ModMemberAndRemExtension.rem(x: Int) {}
+
+fun foo() {
+    ModAndRem % 1
+    OldMod <!INAPPLICABLE_CANDIDATE!>%<!> 1
+
+    ModAndRemExtension % 1
+
+    ModExtension <!INAPPLICABLE_CANDIDATE!>%<!> 1
+
+    ModMemberAndRemExtension % 1
+
+    OldMod.mod(1)
+    ModExtension.mod(1)
+}

compiler/testData/diagnostics/tests/operatorRem/noOperatorRemFeature.fir.kt

@@ -0,0 +1,36 @@
+// !LANGUAGE: -OperatorRem
+// !DIAGNOSTICS: -UNUSED_PARAMETER, -UNUSED_VARIABLE, -EXTENSION_SHADOWED_BY_MEMBER
+
+class Foo {
+    operator fun rem(x: Int): Foo = Foo()
+}
+
+class Bar {
+    operator fun remAssign(x: Int) {}
+}
+
+class Baz {
+    companion object {
+        operator fun rem(x: Int) {}
+        operator fun Int.rem(x: Int) {}
+    }
+}
+
+operator fun Baz.rem(x: Int) {}
+
+fun local() {
+    operator fun Int.rem(x: Int) {}
+    operator fun String.remAssign(x: Int) {}
+}
+
+fun noOverflow() {
+    (-1).mod(5)
+}
+
+fun builtIns(b: Byte, s: Short) {
+    var a = 1 % 2
+    a %= 3
+    1.mod(2)
+    b % s
+    1.0 % 2.0
+}

compiler/testData/diagnostics/tests/operatorRem/noWarningForModFromBuiltinsWhenApi1_0_after.fir.kt

@@ -0,0 +1,48 @@
+// !LANGUAGE: +ProhibitOperatorMod
+// !WITH_NEW_INFERENCE
+// !API_VERSION: 1.0
+// !DIAGNOSTICS: -UNUSED_PARAMETER, -UNUSED_VARIABLE, -EXTENSION_SHADOWED_BY_MEMBER
+
+class Foo {
+    operator fun rem(x: Int): Foo = Foo()
+}
+
+class Bar {
+    operator fun remAssign(x: Int) {}
+}
+
+class Baz {
+    companion object {
+        operator fun rem(x: Int) {}
+        operator fun Int.rem(x: Int) {}
+    }
+}
+
+operator fun Baz.rem(x: Int) {}
+
+fun local() {
+    operator fun Int.rem(x: Int) {}
+    operator fun String.remAssign(x: Int) {}
+}
+
+class WithMod {
+    operator fun mod(other: WithMod) = this
+
+    fun test() {
+        val a = this <!INAPPLICABLE_CANDIDATE!>%<!> this
+        var b = this.mod(this)
+        <!UNRESOLVED_REFERENCE!>b %= this<!>
+    }
+}
+
+fun noOverflow() {
+    (-1).mod(5)
+}
+
+fun builtIns(b: Byte, s: Short) {
+    var a = 1 % 2
+    a %= 3
+    1.mod(2)
+    b % s
+    1.0 % 2.0
+}

compiler/testData/diagnostics/tests/operatorRem/noWarningForModFromBuiltinsWhenApi1_0_before.fir.kt

@@ -0,0 +1,48 @@
+// !LANGUAGE: -ProhibitOperatorMod
+// !WITH_NEW_INFERENCE
+// !API_VERSION: 1.0
+// !DIAGNOSTICS: -UNUSED_PARAMETER, -UNUSED_VARIABLE, -EXTENSION_SHADOWED_BY_MEMBER
+
+class Foo {
+    operator fun rem(x: Int): Foo = Foo()
+}
+
+class Bar {
+    operator fun remAssign(x: Int) {}
+}
+
+class Baz {
+    companion object {
+        operator fun rem(x: Int) {}
+        operator fun Int.rem(x: Int) {}
+    }
+}
+
+operator fun Baz.rem(x: Int) {}
+
+fun local() {
+    operator fun Int.rem(x: Int) {}
+    operator fun String.remAssign(x: Int) {}
+}
+
+class WithMod {
+    operator fun mod(other: WithMod) = this
+
+    fun test() {
+        val a = this <!INAPPLICABLE_CANDIDATE!>%<!> this
+        var b = this.mod(this)
+        <!UNRESOLVED_REFERENCE!>b %= this<!>
+    }
+}
+
+fun noOverflow() {
+    (-1).mod(5)
+}
+
+fun builtIns(b: Byte, s: Short) {
+    var a = 1 % 2
+    a %= 3
+    1.mod(2)
+    b % s
+    1.0 % 2.0
+}

compiler/testData/diagnostics/tests/operatorRem/numberRemConversions.fir.kt

@@ -0,0 +1,15 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+fun fooInt(p: Int) = p
+fun fooLong(p: Long) = p
+fun fooByte(p: Byte) = p
+fun fooShort(p: Short) = p
+
+fun test() {
+    fooInt(1 % 1)
+    fooByte(1 % 1)
+    fooLong(1 % 1)
+    fooShort(1 % 1)
+}
+
+public operator fun Int.rem(other: Int): Int = 0

compiler/testData/diagnostics/tests/operatorRem/operatorRem.fir.kt

@@ -0,0 +1,15 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER, -UNUSED_VARIABLE
+
+class Foo {
+    operator fun rem(x: Int): Foo = Foo()
+}
+
+class Bar {
+    operator fun remAssign(x: Int) {}
+}
+
+fun baz() {
+    val f = Foo() % 1
+    val b = Bar()
+    b %= 1
+}

compiler/testData/diagnostics/tests/operatorRem/preferRemAsExtentionOverMod.fir.kt

@@ -0,0 +1,13 @@
+// !LANGUAGE: -ProhibitOperatorMod
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+class Foo {
+}
+operator fun Foo.mod(x: Int): Foo = Foo()
+operator fun Foo.rem(x: Int): Int = 0
+
+fun foo() {
+    takeInt(Foo() % 1)
+}
+
+fun takeInt(x: Int) {}

compiler/testData/diagnostics/tests/operatorRem/preferRemAsMemberOverMod.fir.kt

@@ -0,0 +1,13 @@
+// !LANGUAGE: -ProhibitOperatorMod
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+class Foo {
+    operator fun mod(x: Int): Foo = Foo()
+    operator fun rem(x: Int): Int = 0
+}
+
+fun foo() {
+    takeInt(Foo() % 1)
+}
+
+fun takeInt(x: Int) {}

compiler/testData/diagnostics/tests/operatorRem/preferRemFromCompanionObjectOverRem.fir.kt

@@ -0,0 +1,16 @@
+// !LANGUAGE: -ProhibitOperatorMod
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+class A {
+    companion object {
+        operator fun A.rem(x: Int) = 0
+    }
+
+    fun test() {
+        operator fun A.mod(x: Int) = ""
+
+        takeInt(A() % 123)
+    }
+}
+
+fun takeInt(x: Int) {}

compiler/testData/diagnostics/tests/operatorRem/preferRemOverModInLocalFunctions.fir.kt

@@ -0,0 +1,30 @@
+// !LANGUAGE: -ProhibitOperatorMod
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+object B
+
+class A {
+    operator fun B.rem(x: Int) = 0
+}
+
+fun test1() {
+    operator fun B.mod(x: Int) = ""
+
+    with(A()) {
+        takeInt(B % 10)
+    }
+}
+
+class C {
+    operator fun B.mod(x: Int) = ""
+}
+
+fun test2() {
+    operator fun B.rem(x: Int) = 0
+
+    with(C()) {
+        takeInt(B % 10)
+    }
+}
+
+fun takeInt(x: Int) {}

compiler/testData/diagnostics/tests/operatorRem/preferRemWithImplicitReceivers.fir.kt

@@ -0,0 +1,20 @@
+// !LANGUAGE: -ProhibitOperatorMod
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+class A {
+    operator fun Int.mod(s: String) = 4
+}
+
+class B {
+    operator fun Int.rem(s: String) = ""
+}
+
+fun test() {
+    with(B()) {
+        with(A()) {
+            <!INAPPLICABLE_CANDIDATE!>takeString<!>(1 % "")
+        }
+    }
+}
+
+fun takeString(s: String) {}

compiler/testData/diagnostics/tests/operatorRem/prefereRemAsExtensionOverMemberMod.fir.kt

@@ -0,0 +1,15 @@
+// !LANGUAGE: -ProhibitOperatorMod
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+class Foo {
+    operator fun mod(x: Int): Foo = Foo()
+}
+
+operator fun Foo.rem(x: Int): Int = 0
+
+
+fun foo() {
+    takeInt(Foo() % 1)
+}
+
+fun takeInt(x: Int) {}

compiler/testData/diagnostics/tests/operatorRem/remAndRemAssignAmbiguity.fir.kt

@@ -0,0 +1,12 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+object RemAndRemAssign {
+    operator fun rem(x: Int) = RemAndRemAssign
+}
+
+operator fun RemAndRemAssign.remAssign(x: Int) {}
+
+fun test() {
+    var c = RemAndRemAssign
+    <!ASSIGN_OPERATOR_AMBIGUITY!>c %= 1<!>
+}

compiler/testData/diagnostics/tests/operatorRem/remWithModAndModAssign.fir.kt

@@ -0,0 +1,17 @@
+// !LANGUAGE: -ProhibitOperatorMod
+// !DIAGNOSTICS: -UNUSED_PARAMETER, -EXTENSION_SHADOWED_BY_MEMBER
+
+class ModAndRemAssign {
+    operator fun mod(x: Int) = ModAndRemAssign()
+    operator fun mod(x: String) = ModAndRemAssign()
+    operator fun modAssign(x: String) {}
+    operator fun rem(x: Int) = ModAndRemAssign()
+}
+
+operator fun ModAndRemAssign.mod(x: String) = ModAndRemAssign()
+operator fun ModAndRemAssign.modAssign(x: String) {}
+
+fun test() {
+    var modAndRemAssign = ModAndRemAssign()
+    modAndRemAssign %= 1
+}

compiler/testData/diagnostics/tests/operatorRem/remWithModAssign.fir.kt

@@ -0,0 +1,12 @@
+// !LANGUAGE: -ProhibitOperatorMod
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+object RemAndModAssign {
+    operator fun modAssign(x: String) {}
+    operator fun rem(x: Int) = RemAndModAssign
+}
+
+fun test2() {
+    var c = RemAndModAssign
+    c %= 123
+}

compiler/testData/diagnostics/tests/operatorRem/resolveModIfRemIsHidden.fir.kt

@@ -0,0 +1,15 @@
+// !LANGUAGE: -ProhibitOperatorMod
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+object A {
+    @Deprecated("Use mod instead", ReplaceWith("mod"), DeprecationLevel.HIDDEN)
+    operator fun rem(x: Int) = 0
+
+    operator fun mod(x: Int) = ""
+}
+
+fun test() {
+    <!INAPPLICABLE_CANDIDATE!>takeString<!>(A % 123)
+}
+
+fun takeString(s: String) {}

compiler/testData/diagnostics/tests/operatorRem/resolveToModWhenNoOperatorRemFeature.fir.kt

@@ -0,0 +1,39 @@
+// !LANGUAGE: -OperatorRem
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+object ModAndRem {
+    operator fun mod(x: Int) = 0
+    operator fun rem(x: Int) = ""
+}
+
+object ModAssignAndRemAssign {
+    operator fun modAssign(x: String) {}
+    operator fun remAssign(x: Int) {}
+}
+
+object RemAndModAssign {
+    operator fun modAssign(x: Int) {}
+    operator fun rem(x: Int) = RemAndModAssign
+}
+
+object OnlyRem {
+    operator fun rem(x: Int) {}
+    operator fun remAssign(x: Int) {}
+}
+
+fun test() {
+    <!INAPPLICABLE_CANDIDATE!>takeInt<!>(ModAndRem % 1)
+
+    val c = ModAssignAndRemAssign
+    <!INAPPLICABLE_CANDIDATE!>c %= ""<!>
+
+    var c1 = RemAndModAssign
+    c1 %= 1
+
+    OnlyRem % 1
+
+    val c2 = OnlyRem
+    c2 %= 1
+}
+
+fun takeInt(x: Int) {}

compiler/testData/diagnostics/tests/operatorRem/warningOnExplicitModCall1_1.fir.kt

@@ -0,0 +1,5 @@
+// !API_VERSION: 1.1
+
+fun test() {
+    1.mod(3)
+}

compiler/testData/diagnostics/tests/operatorRem/warningOnExplicitModCall1_2.fir.kt

@@ -0,0 +1,5 @@
+// !API_VERSION: 1.2
+
+fun test() {
+    1.mod(3)
+}