[FIR] Disallow operators not on functions

Introduce `NOT_FUNCTION_AS_OPERATOR` and use it instead of `PROPERTY_AS_OPERATOR`

^KT-65881 Fixed

Merge-request: KT-MR-14547

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

@@ -10,25 +10,25 @@ class A { }
 var a = A()
 
 val A.inc: I get() = I()
-fun useInc() { a<!PROPERTY_AS_OPERATOR, RESULT_TYPE_MISMATCH!>++<!> }
+fun useInc() { a<!NOT_FUNCTION_AS_OPERATOR, RESULT_TYPE_MISMATCH!>++<!> }
 
 val A.dec: I get() = I()
-fun useDec() { a<!PROPERTY_AS_OPERATOR, RESULT_TYPE_MISMATCH!>--<!> }
+fun useDec() { a<!NOT_FUNCTION_AS_OPERATOR, RESULT_TYPE_MISMATCH!>--<!> }
 
 val A.plusAssign: I get() = I()
-fun usePlusAssign() { a <!PROPERTY_AS_OPERATOR!>+=<!> 1 }
+fun usePlusAssign() { a <!NOT_FUNCTION_AS_OPERATOR!>+=<!> 1 }
 
 val A.minusAssign: I get() = I()
-fun useMinusAssign() { a <!PROPERTY_AS_OPERATOR!>-=<!> 1 }
+fun useMinusAssign() { a <!NOT_FUNCTION_AS_OPERATOR!>-=<!> 1 }
 
 val A.timesAssign: I get() = I()
-fun useTimesAssign() { a <!PROPERTY_AS_OPERATOR!>*=<!> 1 }
+fun useTimesAssign() { a <!NOT_FUNCTION_AS_OPERATOR!>*=<!> 1 }
 
 val A.divAssign: I get() = I()
-fun useDivAssign() { a <!PROPERTY_AS_OPERATOR!>/=<!> 1 }
+fun useDivAssign() { a <!NOT_FUNCTION_AS_OPERATOR!>/=<!> 1 }
 
 val A.remAssign: I get() = I()
-fun useRemAssign() { a <!PROPERTY_AS_OPERATOR!>%=<!> 1 }
+fun useRemAssign() { a <!NOT_FUNCTION_AS_OPERATOR!>%=<!> 1 }
 
 // operators over values
 
@@ -36,47 +36,47 @@ class E { }
 val e = E()
 
 val E.unaryPlus: I get() = I()
-val useUnaryPlus = <!PROPERTY_AS_OPERATOR!>+<!>e
+val useUnaryPlus = <!NOT_FUNCTION_AS_OPERATOR!>+<!>e
 
 val E.unaryMinus: I get() = I()
-val useUnaryMinus = <!PROPERTY_AS_OPERATOR!>-<!>e
+val useUnaryMinus = <!NOT_FUNCTION_AS_OPERATOR!>-<!>e
 
 val E.not: I get() = I()
-val useNot = <!PROPERTY_AS_OPERATOR!>!<!>e
+val useNot = <!NOT_FUNCTION_AS_OPERATOR!>!<!>e
 
 val E.plus: I get() = I()
-val usePlus = e <!PROPERTY_AS_OPERATOR!>+<!> 1
+val usePlus = e <!NOT_FUNCTION_AS_OPERATOR!>+<!> 1
 
 val E.minus: I get() = I()
-val useMinus = e <!PROPERTY_AS_OPERATOR!>-<!> 1
+val useMinus = e <!NOT_FUNCTION_AS_OPERATOR!>-<!> 1
 
 val E.times: I get() = I()
-val useTimes = e <!PROPERTY_AS_OPERATOR!>*<!> 1
+val useTimes = e <!NOT_FUNCTION_AS_OPERATOR!>*<!> 1
 
 val E.div: I get() = I()
-val useDiv = e <!PROPERTY_AS_OPERATOR!>/<!> 1
+val useDiv = e <!NOT_FUNCTION_AS_OPERATOR!>/<!> 1
 
 val E.rem: I get() = I()
-val useRem = e <!PROPERTY_AS_OPERATOR!>%<!> 1
+val useRem = e <!NOT_FUNCTION_AS_OPERATOR!>%<!> 1
 
 val E.get: I get() = I()
-val useGet = <!PROPERTY_AS_OPERATOR!>e[1]<!>
+val useGet = <!NOT_FUNCTION_AS_OPERATOR!>e[1]<!>
 
 val E.set: I get() = I()
-fun useSet() { <!PROPERTY_AS_OPERATOR!>e[1]<!> = 3 }
+fun useSet() { <!NOT_FUNCTION_AS_OPERATOR!>e[1]<!> = 3 }
 
 val E.contains: I get() = I()
-val useContains = 1 <!PROPERTY_AS_OPERATOR!>in<!> e
-val useNotContains = 1 <!PROPERTY_AS_OPERATOR, PROPERTY_AS_OPERATOR!>!in<!> e
+val useContains = 1 <!NOT_FUNCTION_AS_OPERATOR!>in<!> e
+val useNotContains = 1 <!NOT_FUNCTION_AS_OPERATOR, NOT_FUNCTION_AS_OPERATOR!>!in<!> e
 
 val E.invoke: I get() = I()
 val useInvoke = <!NONE_APPLICABLE!>e<!>()
 
 val E.rangeTo: I get() = I()
-val useRangeTo = e <!PROPERTY_AS_OPERATOR!>..<!> 3
+val useRangeTo = e <!NOT_FUNCTION_AS_OPERATOR!>..<!> 3
 
 val E.rangeUntil: I get() = I()
-val useRangeUntil = e <!PROPERTY_AS_OPERATOR!>..<<!> 3
+val useRangeUntil = e <!NOT_FUNCTION_AS_OPERATOR!>..<<!> 3
 
 val E.compareTo: I get() = I()
-val useCompareTo = e <!PROPERTY_AS_OPERATOR!>><!> 2
+val useCompareTo = e <!NOT_FUNCTION_AS_OPERATOR!>><!> 2

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

@@ -0,0 +1,23 @@
+// ISSUE: KT-59715
+
+class FunctionComponent {
+    val component1: () -> String = { "hello" }
+}
+
+class I {
+    operator fun invoke(): String = "hello"
+}
+
+class InvokeComponent {
+    val component1: I = I()
+}
+
+fun test_1(c: FunctionComponent) {
+    val (<!NOT_FUNCTION_AS_OPERATOR!>x<!>) = FunctionComponent()
+    val (<!NOT_FUNCTION_AS_OPERATOR!>y<!>) = c
+}
+
+fun test_2(c: InvokeComponent) {
+    val (<!NOT_FUNCTION_AS_OPERATOR!>x<!>) = FunctionComponent()
+    val (<!NOT_FUNCTION_AS_OPERATOR!>y<!>) = c
+}

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

@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 // ISSUE: KT-59715
 
 class FunctionComponent {