Code refactorings in QuickFixWithDelegateFactory

idea/src/org/jetbrains/kotlin/idea/quickfix/KotlinIntentionActionFactoryWithDelegate.kt

@@ -30,17 +30,13 @@ import org.jetbrains.kotlin.utils.singletonOrEmptyList
 public abstract class KotlinIntentionActionFactoryWithDelegate<E : JetElement, D : Any> : JetIntentionActionsFactory() {
     protected abstract fun getElementOfInterest(diagnostic: Diagnostic): E?
 
-    protected open fun createQuickFix(
-            originalElementPointer: SmartPsiElementPointer<E>,
-            diagnostic: Diagnostic,
-            quickFixDataFactory: (SmartPsiElementPointer<E>) -> D?
-    ): QuickFixWithDelegateFactory? = null
+    protected open fun createQuickFix(diagnostic: Diagnostic, quickFixDataFactory: () -> D?): QuickFixWithDelegateFactory? = null
 
     protected open fun createQuickFixes(
             originalElementPointer: SmartPsiElementPointer<E>,
             diagnostic: Diagnostic,
-            quickFixDataFactory: (SmartPsiElementPointer<E>) -> D?
-    ): List<QuickFixWithDelegateFactory> = createQuickFix(originalElementPointer, diagnostic, quickFixDataFactory).singletonOrEmptyList()
+            quickFixDataFactory: () -> D?
+    ): List<QuickFixWithDelegateFactory> = createQuickFix(diagnostic, quickFixDataFactory).singletonOrEmptyList()
 
     protected abstract fun createQuickFixData(element: E, diagnostic: Diagnostic): D?
 
@@ -59,7 +55,7 @@ public abstract class KotlinIntentionActionFactoryWithDelegate<E : JetElement, D
         val actions: List<QuickFixWithDelegateFactory>
         try {
             actions = createQuickFixes(originalElementPointer, diagnostic) factory@ {
-                val element = it.element ?: return@factory null
+                val element = originalElementPointer.element ?: return@factory null
                 val diagnosticElement = diagnosticElementPointer.element ?: return@factory null
                 if (!diagnosticElement.isValid || !element.isValid) return@factory null
 

idea/src/org/jetbrains/kotlin/idea/quickfix/NullQuickFix.kt

@@ -1,37 +0,0 @@
-/*
- * Copyright 2010-2015 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.idea.quickfix
-
-import com.intellij.codeInsight.intention.IntentionAction
-import com.intellij.openapi.editor.Editor
-import com.intellij.openapi.project.Project
-import com.intellij.psi.PsiFile
-import org.jetbrains.annotations.NotNull
-
-public object NullQuickFix : IntentionAction {
-    override fun getText() = ""
-
-    override fun getFamilyName() = ""
-
-    override fun isAvailable(project: Project, editor: Editor?, file: PsiFile) = false
-
-    override fun startInWriteAction() = false
-
-    override fun invoke(@NotNull project: Project, editor: Editor?, file: PsiFile?) {
-        throw UnsupportedOperationException("invoke() shouldn't be called")
-    }
-}

idea/src/org/jetbrains/kotlin/idea/quickfix/QuickFixWithDelegateFactory.kt

@@ -21,10 +21,9 @@ import com.intellij.codeInsight.intention.LowPriorityAction
 import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiFile
-import org.jetbrains.annotations.NotNull
 
 public open class QuickFixWithDelegateFactory(
-        private val delegateFactory: () -> IntentionAction
+        private val delegateFactory: () -> IntentionAction?
 ) : IntentionAction {
     private val familyName: String
     private val text: String
@@ -32,25 +31,28 @@ public open class QuickFixWithDelegateFactory(
 
     init {
         val delegate = delegateFactory()
-        familyName = delegate.familyName
-        text = delegate.text
-        startInWriteAction = delegate.startInWriteAction()
+        familyName = delegate?.familyName ?: ""
+        text = delegate?.text ?: ""
+        startInWriteAction = delegate != null && delegate.startInWriteAction()
     }
 
     override fun getFamilyName() = familyName
 
     override fun getText() = text
 
-    override fun isAvailable(project: Project, editor: Editor?, file: PsiFile) =
-            delegateFactory().isAvailable(project, editor, file)
+    override fun isAvailable(project: Project, editor: Editor?, file: PsiFile): Boolean {
+        val action = delegateFactory() ?: return false
+        return action.isAvailable(project, editor, file)
+    }
 
     override fun startInWriteAction() = startInWriteAction
 
-    override fun invoke(@NotNull project: Project, editor: Editor?, file: PsiFile?) {
-        delegateFactory().invoke(project, editor, file)
+    override fun invoke(project: Project, editor: Editor?, file: PsiFile?) {
+        val action = delegateFactory() ?: return
+        action.invoke(project, editor, file)
     }
 }
 
 public class LowPriorityQuickFixWithDelegateFactory(
-        delegateFactory: () -> IntentionAction
+        delegateFactory: () -> IntentionAction?
 ): QuickFixWithDelegateFactory(delegateFactory), LowPriorityAction

idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateCallableMemberFromUsageFactory.kt

@@ -18,10 +18,9 @@ package org.jetbrains.kotlin.idea.quickfix.createFromUsage.createCallable
 
 import com.intellij.psi.SmartPsiElementPointer
 import org.jetbrains.kotlin.diagnostics.Diagnostic
-import org.jetbrains.kotlin.idea.quickfix.LowPriorityQuickFixWithDelegateFactory
-import org.jetbrains.kotlin.idea.quickfix.NullQuickFix
-import org.jetbrains.kotlin.idea.quickfix.QuickFixWithDelegateFactory
 import org.jetbrains.kotlin.idea.quickfix.KotlinIntentionActionFactoryWithDelegate
+import org.jetbrains.kotlin.idea.quickfix.LowPriorityQuickFixWithDelegateFactory
+import org.jetbrains.kotlin.idea.quickfix.QuickFixWithDelegateFactory
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.CallableInfo
 import org.jetbrains.kotlin.psi.JetElement
 import org.jetbrains.kotlin.utils.addToStdlib.singletonOrEmptyList
@@ -32,13 +31,13 @@ public abstract class CreateCallableMemberFromUsageFactory<E : JetElement>(
     private fun newCallableQuickFix(
             originalElementPointer: SmartPsiElementPointer<E>,
             lowPriority: Boolean,
-            quickFixDataFactory: (SmartPsiElementPointer<E>) -> List<CallableInfo>?,
+            quickFixDataFactory: () -> List<CallableInfo>?,
             quickFixFactory: (E, List<CallableInfo>) -> CreateCallableFromUsageFixBase<E>
     ): QuickFixWithDelegateFactory {
         val delegateFactory = {
-            val data = quickFixDataFactory(originalElementPointer).orEmpty()
+            val data = quickFixDataFactory().orEmpty()
             val originalElement = originalElementPointer.element
-            if (data.isNotEmpty() && originalElement != null) quickFixFactory(originalElement, data) else NullQuickFix
+            if (data.isNotEmpty() && originalElement != null) quickFixFactory(originalElement, data) else null
         }
         return if (lowPriority) LowPriorityQuickFixWithDelegateFactory(delegateFactory) else QuickFixWithDelegateFactory(delegateFactory)
     }
@@ -51,7 +50,7 @@ public abstract class CreateCallableMemberFromUsageFactory<E : JetElement>(
     override fun createQuickFixes(
             originalElementPointer: SmartPsiElementPointer<E>,
             diagnostic: Diagnostic,
-            quickFixDataFactory: (SmartPsiElementPointer<E>) -> List<CallableInfo>?
+            quickFixDataFactory: () -> List<CallableInfo>?
     ): List<QuickFixWithDelegateFactory> {
         val memberFix = newCallableQuickFix(originalElementPointer, false, quickFixDataFactory) { element, data ->
             CreateCallableFromUsageFix(element, data)

idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createClass/CreateClassFromUsageFactory.kt

@@ -18,9 +18,8 @@ package org.jetbrains.kotlin.idea.quickfix.createFromUsage.createClass
 
 import com.intellij.psi.SmartPsiElementPointer
 import org.jetbrains.kotlin.diagnostics.Diagnostic
-import org.jetbrains.kotlin.idea.quickfix.NullQuickFix
-import org.jetbrains.kotlin.idea.quickfix.QuickFixWithDelegateFactory
 import org.jetbrains.kotlin.idea.quickfix.KotlinIntentionActionFactoryWithDelegate
+import org.jetbrains.kotlin.idea.quickfix.QuickFixWithDelegateFactory
 import org.jetbrains.kotlin.psi.JetElement
 
 abstract class CreateClassFromUsageFactory<E : JetElement> : KotlinIntentionActionFactoryWithDelegate<E, ClassInfo>() {
@@ -29,17 +28,15 @@ abstract class CreateClassFromUsageFactory<E : JetElement> : KotlinIntentionActi
     override fun createQuickFixes(
             originalElementPointer: SmartPsiElementPointer<E>,
             diagnostic: Diagnostic,
-            quickFixDataFactory: (SmartPsiElementPointer<E>) -> ClassInfo?
+            quickFixDataFactory: () -> ClassInfo?
     ): List<QuickFixWithDelegateFactory> {
-        val originalElement = originalElementPointer.element ?: return emptyList()
+        val possibleClassKinds = getPossibleClassKinds(originalElementPointer.element ?: return emptyList(), diagnostic)
 
-        val classFixes = getPossibleClassKinds(originalElement, diagnostic).map { classKind ->
+        val classFixes = possibleClassKinds.map { classKind ->
             QuickFixWithDelegateFactory {
-                val currentElement = originalElementPointer.element
-                val data = quickFixDataFactory(originalElementPointer)
-                if (currentElement != null && data != null) {
-                    CreateClassFromUsageFix(originalElement, data.copy(kind = classKind))
-                } else NullQuickFix
+                val currentElement = originalElementPointer.element ?: return@QuickFixWithDelegateFactory null
+                val data = quickFixDataFactory() ?: return@QuickFixWithDelegateFactory null
+                CreateClassFromUsageFix(currentElement, data.copy(kind = classKind))
             }
         }
 

idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createVariable/CreateParameterFromUsageFactory.kt

@@ -16,12 +16,10 @@
 
 package org.jetbrains.kotlin.idea.quickfix.createFromUsage.createVariable
 
-import com.intellij.psi.SmartPsiElementPointer
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.diagnostics.Diagnostic
-import org.jetbrains.kotlin.idea.quickfix.NullQuickFix
-import org.jetbrains.kotlin.idea.quickfix.QuickFixWithDelegateFactory
 import org.jetbrains.kotlin.idea.quickfix.KotlinIntentionActionFactoryWithDelegate
+import org.jetbrains.kotlin.idea.quickfix.QuickFixWithDelegateFactory
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetParameterInfo
 import org.jetbrains.kotlin.psi.JetElement
 import org.jetbrains.kotlin.resolve.BindingContext
@@ -34,16 +32,16 @@ data class CreateParameterData<E : JetElement>(
 
 abstract class CreateParameterFromUsageFactory<E : JetElement>: KotlinIntentionActionFactoryWithDelegate<E, CreateParameterData<E>>() {
     override fun createQuickFix(
-            originalElementPointer: SmartPsiElementPointer<E>,
             diagnostic: Diagnostic,
-            quickFixDataFactory: (SmartPsiElementPointer<E>) -> CreateParameterData<E>?
+            quickFixDataFactory: () -> CreateParameterData<E>?
     ): QuickFixWithDelegateFactory? {
         return QuickFixWithDelegateFactory {
-            quickFixDataFactory(originalElementPointer)?.let { data ->
-                CreateParameterFromUsageFix(data.parameterInfo.callableDescriptor as FunctionDescriptor,
+            quickFixDataFactory()?.let { data ->
+                CreateParameterFromUsageFix(
+                        data.parameterInfo.callableDescriptor as FunctionDescriptor,
                         data.parameterInfo,
-                                            data.originalExpression)
-            } ?: NullQuickFix
+                        data.originalExpression)
+            }
         }
     }
 }