[FIR] Add INAPPLICABLE_OPERATOR_MODIFIER diagnostic

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

@@ -1,15 +1,15 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 
 class Example {
-    operator fun plus(): String = ""
+    <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun plus(): String = ""
     operator fun unaryPlus(): Int = 0
 }
 
 class ExampleDeprecated {
-    operator fun plus(): String = ""
+    <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun plus(): String = ""
 }
 
-operator fun String.plus(): String = this
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun String.plus(): String = this
 operator fun String.unaryPlus(): Int = 0
 
 fun test() {
@@ -22,8 +22,8 @@ fun requireInt(n: Int) {}
 fun requireString(s: String) {}
 
 class Example2 {
-    operator fun plus() = this
-    operator fun minus() = this
+    <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun plus() = this
+    <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun minus() = this
 
     fun test() {
         <!INAPPLICABLE_CANDIDATE!>+<!>this

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

@@ -27,7 +27,7 @@ abstract class NotRange4() {
 }
 
 abstract class ImproperIterator3 {
-  abstract operator fun hasNext() : Int
+  abstract <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun hasNext() : Int
   abstract operator fun next() : Int
 }
 

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

@@ -16,8 +16,8 @@ fun testIncDec() {
 }
 
 class WrongIncDec() {
-  operator fun inc() : Int = 1
-  operator fun dec() : Int = 1
+  <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun inc() : Int = 1
+  <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun dec() : Int = 1
 }
 
 fun testWrongIncDec() {
@@ -29,8 +29,8 @@ fun testWrongIncDec() {
 }
 
 class UnitIncDec() {
-  operator fun inc() : Unit {}
-  operator fun dec() : Unit {}
+  <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun inc() : Unit {}
+  <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun dec() : Unit {}
 }
 
 fun testUnitIncDec() {

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

@@ -5,59 +5,59 @@ import kotlin.reflect.KProperty
 interface Example {
     operator fun plus(o: Example): Example
     operator fun div(o: Example): Example
-    operator fun plus(o: Example, s: String = ""): Example
-    operator fun minus(vararg o: Example): Example
-    operator fun plus(): Example
-    operator fun minus(): Example
+    <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun plus(o: Example, s: String = ""): Example
+    <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun minus(vararg o: Example): Example
+    <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun plus(): Example
+    <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun minus(): Example
 
     operator fun unaryPlus(): Example
     operator fun unaryMinus(): Example
 
-    operator fun unaryPlus(s: String = ""): Example
-    operator fun unaryMinus(o: Example)
+    <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun unaryPlus(s: String = ""): Example
+    <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun unaryMinus(o: Example)
 
     operator fun inc(): Example
-    operator fun dec(): Example?
+    <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun dec(): Example?
 
     operator fun plusAssign(n: Int)
-    operator fun minusAssign(n: Int): String
-    operator fun divAssign(n: Int, a: String = "")
-    operator fun modAssign(vararg n: Int)
+    <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun minusAssign(n: Int): String
+    <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun divAssign(n: Int, a: String = "")
+    <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun modAssign(vararg n: Int)
 
     operator fun compareTo(other: Example): Int
 
     override operator fun equals(other: Any?): Boolean
-    operator fun equals(a: String): Boolean
+    <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun equals(a: String): Boolean
 
     operator fun contains(n: Int): Boolean
-    operator fun contains(n: Int, s: String = ""): Boolean
+    <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun contains(n: Int, s: String = ""): Boolean
 
     operator fun invoke()
 
     operator fun get(n: Int)
     operator fun get(n: Int, n2: Int)
-    operator fun get()
+    <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun get()
 
     operator fun set(n: Int, v: Int)
     operator fun set(n: Int, n2: Int, v: Int)
-    operator fun set(v: Int)
+    <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun set(v: Int)
 
     operator fun rangeTo(o: Int)
-    operator fun rangeTo(o: Int, o2: Int)
-    operator fun rangeTo(vararg o: String)
+    <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun rangeTo(o: Int, o2: Int)
+    <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun rangeTo(vararg o: String)
 
     operator fun component1(): Int
-    operator fun component1(n: Int): Int
-    operator fun componentN(): Int
+    <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun component1(n: Int): Int
+    <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun componentN(): Int
 
     operator fun iterator(): String
-    operator fun iterator(n: Int): String
+    <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun iterator(n: Int): String
 
     operator fun next(): String
-    operator fun next(n: Int): String
+    <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun next(n: Int): String
 
     operator fun hasNext(): Boolean
-    operator fun hasNext(n: Int): String
+    <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun hasNext(n: Int): String
 
     infix fun i1(n: Int)
     <!INAPPLICABLE_INFIX_MODIFIER!>infix fun i1(n: Int, n2: Int)<!>
@@ -72,27 +72,27 @@ class OkDelegates {
 }
 
 class DelegatesWithErrors {
-    operator fun getValue(thisRef: Any?, prop: String): String = ""
-    operator fun setValue(thisRef: Any?, prop: String, value: String) {}
+    <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun getValue(thisRef: Any?, prop: String): String = ""
+    <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun setValue(thisRef: Any?, prop: String, value: String) {}
 
-    operator fun setValue(thisRef: Any?, prop: KProperty<*>, vararg n: Int) {}
-    operator fun setValue(thisRef: Any?, prop: KProperty<*>, f: Float = 0.0f) {}
+    <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun setValue(thisRef: Any?, prop: KProperty<*>, vararg n: Int) {}
+    <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun setValue(thisRef: Any?, prop: KProperty<*>, f: Float = 0.0f) {}
 
-    operator fun getValue(prop: KProperty<*>): String = ""
-    operator fun setValue(prop: KProperty<*>, value: String) {}
+    <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun getValue(prop: KProperty<*>): String = ""
+    <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun setValue(prop: KProperty<*>, value: String) {}
 }
 
 interface Example2 {
-    operator fun inc(s: String): Example
-    operator fun dec()
-    operator fun compareTo(vararg other: Example): Int
-    operator fun contains(vararg n: Int): Boolean
-    operator fun hasNext(): Int
+    <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun inc(s: String): Example
+    <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun dec()
+    <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun compareTo(vararg other: Example): Int
+    <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun contains(vararg n: Int): Boolean
+    <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun hasNext(): Int
 }
 
 interface Example3 {
-    operator fun compareTo(other: Example, s: String = ""): Int
-    operator fun contains(n: Int)
+    <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun compareTo(other: Example, s: String = ""): Int
+    <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun contains(n: Int)
 }
 
 
@@ -100,58 +100,58 @@ interface Example3 {
 
 operator fun Example.plus(o: Any): Example {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 operator fun Example.div(o: Example): Example {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
-operator fun Example.plus(o: Example, s: String = ""): Example {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
-operator fun Example.minus(vararg o: Example): Example {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
-operator fun Example.plus(): Example {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
-operator fun Example.minus(): Example {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun Example.plus(o: Example, s: String = ""): Example {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun Example.minus(vararg o: Example): Example {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun Example.plus(): Example {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun Example.minus(): Example {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 
 operator fun Example.unaryPlus(): Example {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 operator fun Example.unaryMinus(): Example {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 
-operator fun Example.unaryPlus(s: String = ""): Example {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
-operator fun Example.unaryMinus(o: Example) {}
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun Example.unaryPlus(s: String = ""): Example {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun Example.unaryMinus(o: Example) {}
 
 operator fun Example.inc(): Example {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
-operator fun Example.dec(): Example? {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun Example.dec(): Example? {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 
 operator fun Example.plusAssign(n: Int) {}
-operator fun Example.minusAssign(n: Int): String {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
-operator fun Example.divAssign(n: Int, a: String = "") {}
-operator fun Example.modAssign(vararg n: Int) {}
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun Example.minusAssign(n: Int): String {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun Example.divAssign(n: Int, a: String = "") {}
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun Example.modAssign(vararg n: Int) {}
 
 operator fun Example.compareTo(other: Example): Int {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 
-operator fun Example.equals(a: String): Boolean {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun Example.equals(a: String): Boolean {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 
 operator fun Example.contains(n: Int): Boolean {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
-operator fun Example.contains(n: Int, s: String = ""): Boolean {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun Example.contains(n: Int, s: String = ""): Boolean {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 
 operator fun Example.invoke() {}
 
 operator fun Example.get(n: Int) {}
 operator fun Example.get(n: Int, n2: Int) {}
-operator fun Example.get() {}
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun Example.get() {}
 
 operator fun Example.set(n: Int, v: Int) {}
 operator fun Example.set(n: Int, n2: Int, v: Int) {}
-operator fun Example.set(v: Int) {}
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun Example.set(v: Int) {}
 
 operator fun Example.rangeTo(o: Int) {}
-operator fun Example.rangeTo(o: Int, o2: Int) {}
-operator fun Example.rangeTo(vararg o: String) {}
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun Example.rangeTo(o: Int, o2: Int) {}
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun Example.rangeTo(vararg o: String) {}
 
 operator fun Example.component1(): Int {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
-operator fun Example.component1(n: Int): Int {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
-operator fun Example.componentN(): Int {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun Example.component1(n: Int): Int {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun Example.componentN(): Int {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 
 operator fun Example.iterator(): String {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
-operator fun Example.iterator(n: Int): String {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun Example.iterator(n: Int): String {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 
 operator fun Example.next(): String {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
-operator fun Example.next(n: Int): String {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun Example.next(n: Int): String {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 
 operator fun Example.hasNext(): Boolean {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
-operator fun Example.hasNext(n: Int): String {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun Example.hasNext(n: Int): String {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 
 infix fun Example.i1(n: Int) {}
 <!INAPPLICABLE_INFIX_MODIFIER!>infix fun Example.i1(n: Int, n2: Int) {}<!>
@@ -161,58 +161,58 @@ infix fun Example.i1(vararg n: Int) {}
 
 
 
-operator fun plus(o: String): Example {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
-operator fun div(o: Example): Example {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
-operator fun plus(o: Example, s: String = ""): Example {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
-operator fun minus(vararg o: Example): Example {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun plus(o: String): Example {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun div(o: Example): Example {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun plus(o: Example, s: String = ""): Example {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun minus(vararg o: Example): Example {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 
-operator fun unaryPlus(): Example {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
-operator fun unaryMinus(): Example {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun unaryPlus(): Example {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun unaryMinus(): Example {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 
-operator fun unaryPlus(s: String = ""): Example {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
-operator fun unaryMinus(o: Example) {}
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun unaryPlus(s: String = ""): Example {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun unaryMinus(o: Example) {}
 
-operator fun inc(): Example {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
-operator fun dec(): Example? {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun inc(): Example {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun dec(): Example? {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 
-operator fun plusAssign(n: Int) {}
-operator fun minusAssign(n: Int): String {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
-operator fun divAssign(n: Int, a: String = "") {}
-operator fun modAssign(vararg n: Int) {}
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun plusAssign(n: Int) {}
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun minusAssign(n: Int): String {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun divAssign(n: Int, a: String = "") {}
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun modAssign(vararg n: Int) {}
 
-operator fun compareTo(other: Example): Int {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun compareTo(other: Example): Int {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 
-operator fun equals(a: String): Boolean {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun equals(a: String): Boolean {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 
-operator fun contains(n: Int): Boolean {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
-operator fun contains(n: Int, s: String = ""): Boolean {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun contains(n: Int): Boolean {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun contains(n: Int, s: String = ""): Boolean {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 
-operator fun invoke() {}
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun invoke() {}
 
-operator fun get(n: Int) {}
-operator fun get(n: Int, n2: Int) {}
-operator fun get() {}
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun get(n: Int) {}
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun get(n: Int, n2: Int) {}
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun get() {}
 
-operator fun set(n: Int, v: Int) {}
-operator fun set(n: Int, n2: Int, v: Int) {}
-operator fun set(v: Int) {}
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun set(n: Int, v: Int) {}
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun set(n: Int, n2: Int, v: Int) {}
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun set(v: Int) {}
 
-operator fun rangeTo(o: Int) {}
-operator fun rangeTo(o: Int, o2: Int) {}
-operator fun rangeTo(vararg o: String) {}
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun rangeTo(o: Int) {}
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun rangeTo(o: Int, o2: Int) {}
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun rangeTo(vararg o: String) {}
 
-operator fun component1(): Int {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
-operator fun component1(n: Int): Int {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
-operator fun componentN(): Int {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun component1(): Int {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun component1(n: Int): Int {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun componentN(): Int {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 
-operator fun iterator(): String {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
-operator fun iterator(n: Int): String {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun iterator(): String {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun iterator(n: Int): String {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 
-operator fun next(): String {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
-operator fun next(n: Int): String {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun next(): String {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun next(n: Int): String {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 
-operator fun hasNext(): Boolean {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
-operator fun hasNext(n: Int): String {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun hasNext(): Boolean {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
+<!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun hasNext(n: Int): String {<!NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY!>}<!>
 
 <!INAPPLICABLE_INFIX_MODIFIER!>infix fun i1(n: Int) {}<!>
 <!INAPPLICABLE_INFIX_MODIFIER!>infix fun i1(n: Int, n2: Int) {}<!>

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

@@ -1,11 +0,0 @@
-class A {
-    operator fun A.minus(o: A) = o
-
-    operator fun A.add(o: A) = o
-    operator fun A.get(o: A) = o
-    operator fun A.invokee() {}
-}
-
-operator fun A.plus(o: A) = o
-operator fun A.component1() = 1
-operator fun A.componentN() = 1

compiler/testData/diagnostics/tests/OperatorsWithWrongNames.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 class A {
     operator fun A.minus(o: A) = o
 

compiler/testData/diagnostics/tests/checkArguments/arrayAccessSet.fir.kt

@@ -16,7 +16,7 @@ object D {
 }
 
 object Z {
-    operator fun set() {
+    <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun set() {
     }
 }
 

compiler/testData/diagnostics/tests/delegatedProperty/inference/noErrorsForImplicitConstraints.fir.kt

@@ -35,7 +35,7 @@ class MyProperty2<T, R> {
         throw Exception()
     }
 
-    operator fun setValue(i: Int) {
+    <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun setValue(i: Int) {
         println("set")
     }
 }

compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/provideDelegateOperatorDeclaration.fir.kt

@@ -1,32 +0,0 @@
-// !DIAGNOSTICS: -UNUSED_PARAMETER
-
-import kotlin.reflect.KProperty
-
-operator fun provideDelegate(x: Any?, p: KProperty<*>) {}
-
-operator fun Any.provideDelegate(x: Any?, p: KProperty<*>) {}
-
-operator fun Any.provideDelegate(x: Any?, p: Any) {}
-
-operator fun Any.provideDelegate(x: Any?, p: Int) {}
-
-class Host1 {
-    operator fun provideDelegate(x: Any?, p: KProperty<*>) {}
-}
-
-class Host2 {
-    operator fun Any.provideDelegate(x: Any?, p: KProperty<*>) {}
-}
-
-class Host3 {
-    operator fun provideDelegate(x: Any?, p: KProperty<*>, foo: Int) {}
-}
-
-class Host4 {
-    operator fun provideDelegate(x: Any?, p: KProperty<*>, foo: Int = 0) {}
-}
-
-class Host5 {
-    operator fun provideDelegate(x: Any?, p: KProperty<*>, vararg foo: Int) {}
-}
-

compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/provideDelegateOperatorDeclaration.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 
 import kotlin.reflect.KProperty

compiler/testData/diagnostics/tests/inline/binaryExpressions/assignment.fir.kt

@@ -2,7 +2,7 @@
 
 operator fun <T, U> Function1<T, U>.minusAssign(p: Function1<T, U>) {}
 
-inline operator fun <T, U> Function1<T, U>.modAssign(p: Function1<T, U>) = {
+inline <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun <T, U> Function1<T, U>.modAssign(p: Function1<T, U>) = {
     this += p
     p += this
 }
@@ -14,7 +14,7 @@ inline operator fun <T, U> Function1<T, U>.plusAssign(p: Function1<T, U>) {
 
 operator fun <T, U, V> @ExtensionFunctionType Function2<T, U, V>.minusAssign(ext : @ExtensionFunctionType Function2<T, U, V>) {}
 
-inline operator fun <T, U, V> @ExtensionFunctionType Function2<T, U, V>.modAssign(ext : @ExtensionFunctionType Function2<T, U, V>) = {
+inline <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun <T, U, V> @ExtensionFunctionType Function2<T, U, V>.modAssign(ext : @ExtensionFunctionType Function2<T, U, V>) = {
     this += ext
     ext += this
 }

compiler/testData/diagnostics/tests/operatorsOverloading/compareToNullable.fir.kt

@@ -1,7 +1,7 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 
 class C {
-    operator fun compareTo(c: C): Int? = null
+    <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun compareTo(c: C): Int? = null
 }
 
 fun test(c: C) {
@@ -9,4 +9,4 @@ fun test(c: C) {
     c <= c
     c >= c
     c > c
-}
+}

compiler/testData/diagnostics/tests/operatorsOverloading/kt1028.fir.kt

@@ -1,35 +0,0 @@
-//KT-1028 Wrong type checking for plusAssign
-package kt1028
-
-import java.util.*
-
-class event<T>()
-{
-    val callbacks = ArrayList< Function1<T, Unit> >() // Should be ArrayList<()->Unit>, bug posted
-
-    operator fun plusAssign(f : (T) -> Unit) = callbacks.add(f)
-    operator fun minusAssign(f : (T) -> Unit) = callbacks.remove(f)
-    fun call(value : T) { for(c in callbacks) c(value) }
-}
-
-class MouseMovedEventArgs()
-{
-    public val X : Int = 0
-}
-
-class Control()
-{
-    public val MouseMoved : event<MouseMovedEventArgs> = event<MouseMovedEventArgs>()
-
-    fun MoveMouse() = MouseMoved.call(MouseMovedEventArgs())
-}
-
-class Test()
-{
-    fun test()
-    {
-        val control = Control()
-        control.MouseMoved <!ASSIGNMENT_OPERATOR_SHOULD_RETURN_UNIT!>+=<!> { it.X } // here
-        control.MouseMoved.plusAssign( { it.X } ) // ok
-    }
-}

compiler/testData/diagnostics/tests/operatorsOverloading/kt1028.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 //KT-1028 Wrong type checking for plusAssign
 package kt1028
 

compiler/testData/diagnostics/tests/regressions/kt618.fir.kt

@@ -1,28 +0,0 @@
-package lol
-
-class B() {
-    operator fun plusAssign(other : B) : String {
-        return "s"
-    }
-    operator fun minusAssign(other : B) : String {
-        return "s"
-    }
-    operator fun remAssign(other : B) : String {
-        return "s"
-    }
-    operator fun divAssign(other : B) : String {
-        return "s"
-    }
-    operator fun timesAssign(other : B) : String {
-        return "s"
-    }
-}
-
-fun main() {
-    var c = B()
-    c <!ASSIGNMENT_OPERATOR_SHOULD_RETURN_UNIT!>+=<!> B()
-    c <!ASSIGNMENT_OPERATOR_SHOULD_RETURN_UNIT!>*=<!> B()
-    c <!ASSIGNMENT_OPERATOR_SHOULD_RETURN_UNIT!>/=<!> B()
-    c <!ASSIGNMENT_OPERATOR_SHOULD_RETURN_UNIT!>-=<!> B()
-    c <!ASSIGNMENT_OPERATOR_SHOULD_RETURN_UNIT!>%=<!> B()
-}

compiler/testData/diagnostics/tests/regressions/kt618.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 package lol
 
 class B() {

compiler/testData/diagnostics/tests/smartCasts/incDecToNull.fir.kt

@@ -1,10 +0,0 @@
-class IncDec {
-    operator fun inc(): Unit {}
-}
-
-fun foo(): IncDec {
-    var x = IncDec()
-    x = x<!INC_DEC_SHOULD_NOT_RETURN_UNIT!>++<!>
-    x<!INC_DEC_SHOULD_NOT_RETURN_UNIT!>++<!>
-    return x
-}

compiler/testData/diagnostics/tests/smartCasts/incDecToNull.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 class IncDec {
     <!INAPPLICABLE_OPERATOR_MODIFIER!>operator<!> fun inc(): Unit {}
 }