FIR IDE: Enable ReplaceInfixOrOperatorCallFix for

UNSAFE_IMPLICIT_INVOKE_CALL.

idea/idea-fir/src/org/jetbrains/kotlin/idea/quickfix/MainKtQuickFixRegistrar.kt

@@ -111,6 +111,7 @@ class MainKtQuickFixRegistrar : KtQuickFixRegistrar() {
         registerApplicator(ReplaceCallFixFactories.unsafeCallFactory)
         registerApplicator(ReplaceCallFixFactories.unsafeInfixCallFactory)
         registerApplicator(ReplaceCallFixFactories.unsafeOperatorCallFactory)
+        registerApplicator(ReplaceCallFixFactories.unsafeImplicitInvokeCallFactory)
         registerApplicator(AddExclExclCallFixFactories.unsafeCallFactory)
         registerApplicator(AddExclExclCallFixFactories.unsafeInfixCallFactory)
         registerApplicator(AddExclExclCallFixFactories.unsafeOperatorCallFactory)

idea/idea-fir/src/org/jetbrains/kotlin/idea/quickfix/fixes/ReplaceCallFixFactories.kt

@@ -66,6 +66,26 @@ object ReplaceCallFixFactories {
             listOf(ReplaceInfixOrOperatorCallFix(target, shouldHaveNotNullType(target), diagnostic.operator))
         }
 
+    val unsafeImplicitInvokeCallFactory =
+        diagnosticFixFactory<KtFirDiagnostic.UnsafeImplicitInvokeCall> { diagnostic ->
+            val target = diagnostic.psi as? KtNameReferenceExpression ?: return@diagnosticFixFactory emptyList()
+
+            val callExpression = target.parent as? KtCallExpression ?: return@diagnosticFixFactory emptyList()
+            val qualifiedExpression = callExpression.parent as? KtQualifiedExpression
+            if (qualifiedExpression == null) {
+                // TODO: This matches FE 1.0 behavior (see ReplaceInfixOrOperatorCallFixFactory.kt) but we should be able to do the fix
+                // when the call is a qualified expression. We just need to make sure to pass any extension receiver as an argument, e.g.:
+                //
+                //   fun test(exec: (String.() -> Unit)?) = "".exec()  // Can be fixed to exec?.invoke("")
+                //
+                // This should be differentiated from this case without an extension receiver:
+                //
+                //   class A(val exec: (() -> Unit)?)
+                //   fun test(a: A) = a.exec()  // Can be fixed to a.exec?.invoke()
+                listOf(ReplaceInfixOrOperatorCallFix(callExpression, shouldHaveNotNullType(callExpression)))
+            } else emptyList()
+        }
+
     private fun KtAnalysisSession.shouldHaveNotNullType(expression: KtExpression): Boolean {
         // This function is used to determine if we may need to add an elvis operator after the safe call. For example, to replace
         // `s.length` in `val x: Int = s.length` with a safe call, it should be replaced with `s.length ?: <caret>`.

idea/testData/quickfix/nullables/unsafeInfixCall/unsafeInvoke.fir.kt.after

@@ -0,0 +1,3 @@
+// "Replace with safe (?.) call" "true"
+
+fun foo(exec: (() -> Unit)?) = exec?.invoke() ?: <caret>

idea/testData/quickfix/nullables/unsafeInfixCall/unsafeInvoke.kt

@@ -1,5 +1,3 @@
 // "Replace with safe (?.) call" "true"
 
-fun foo(exec: (() -> Unit)?) = exec<caret>()
-
-/* IGNORE_FIR */
+fun foo(exec: (() -> Unit)?) = exec<caret>()

idea/testData/quickfix/nullables/unsafeInfixCall/unsafeInvoke.kt.after

@@ -1,5 +1,3 @@
 // "Replace with safe (?.) call" "true"
 
-fun foo(exec: (() -> Unit)?) = exec?.invoke()
-
-/* IGNORE_FIR */
+fun foo(exec: (() -> Unit)?) = exec?.invoke()

idea/testData/quickfix/replaceInfixOrOperatorCall/assignmentCallExpression.kt

@@ -5,6 +5,4 @@ fun bar() {
     val fff: (() -> Int)? = { 1 }
     var i: Int = 1
     i = fff<caret>()
-}
-
-/* IGNORE_FIR */
+}

idea/testData/quickfix/replaceInfixOrOperatorCall/assignmentCallExpression.kt.after

@@ -5,6 +5,4 @@ fun bar() {
     val fff: (() -> Int)? = { 1 }
     var i: Int = 1
     i = fff?.invoke() ?: <caret>
-}
-
-/* IGNORE_FIR */
+}

idea/testData/quickfix/replaceInfixOrOperatorCall/callExpression.kt

@@ -6,6 +6,4 @@ fun foo() {}
 fun bar() {
     val fff: (() -> Unit)? = ::foo
     <caret>fff()
-}
-
-/* IGNORE_FIR */
+}

idea/testData/quickfix/replaceInfixOrOperatorCall/callExpression.kt.after

@@ -6,6 +6,4 @@ fun foo() {}
 fun bar() {
     val fff: (() -> Unit)? = ::foo
     fff?.invoke()
-}
-
-/* IGNORE_FIR */
+}