Add when support for USELESS_IS_CHECK quick fix, related to KT-18965

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

@@ -100,7 +100,7 @@ class QuickFixRegistrar : QuickFixContributor {
 
         USELESS_CAST.registerFactory(RemoveUselessCastFix)
 
-        USELESS_IS_CHECK.registerFactory(RemoveUselessIsCheckFix)
+        USELESS_IS_CHECK.registerFactory(RemoveUselessIsCheckFix, RemoveUselessIsCheckFixForWhen)
 
         WRONG_SETTER_PARAMETER_TYPE.registerFactory(ChangeAccessorTypeFix)
         WRONG_GETTER_RETURN_TYPE.registerFactory(ChangeAccessorTypeFix)

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

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2010-2017 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.openapi.editor.Editor
+import com.intellij.openapi.project.Project
+import com.intellij.psi.util.PsiTreeUtil
+import org.jetbrains.kotlin.diagnostics.Diagnostic
+import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
+
+class RemoveUselessIsCheckFixForWhen(element: KtWhenConditionIsPattern) : KotlinQuickFixAction<KtWhenConditionIsPattern>(element) {
+    override fun getFamilyName() = "Remove useless is check"
+
+    override fun getText(): String = familyName
+
+    override fun invoke(project: Project, editor: Editor?, file: KtFile) {
+        val condition = element ?: return
+        val whenEntry = condition.parent as KtWhenEntry
+        val whenExpression = whenEntry.parent as KtWhenExpression
+
+        if (condition.isNegated) {
+            condition.parent.delete()
+        } else {
+            whenExpression.entries.dropWhile { it != whenEntry }.forEach { it.delete() }
+            val newEntry = KtPsiFactory(project).createWhenEntry("else -> ${whenEntry.expression!!.text}")
+            whenExpression.addBefore(newEntry, whenExpression.closeBrace)
+        }
+    }
+
+    companion object : KotlinSingleIntentionActionFactory() {
+        override fun createAction(diagnostic: Diagnostic): KotlinQuickFixAction<KtWhenConditionIsPattern>? {
+            val expression = diagnostic.psiElement.getNonStrictParentOfType<KtWhenConditionIsPattern>() ?: return null
+            return RemoveUselessIsCheckFixForWhen(expression)
+        }
+    }
+}

idea/testData/quickfix/expressions/removeUselessIsCheckInWhen.kt

@@ -1,6 +1,11 @@
-// "Remove useless is check" "false"
-fun foo(a: String) {
-    when (1) {
-        <caret>is Int -> { }
+// "Remove useless is check" "true"
+interface Base
+interface Derived: Base
+
+fun foo(bar: Base):Int {
+    return when (bar) {
+        is Derived -> 0
+        <caret>is Base -> 42
+        else -> 1
     }
 }

idea/testData/quickfix/expressions/removeUselessIsCheckInWhen.kt.after

@@ -0,0 +1,10 @@
+// "Remove useless is check" "true"
+interface Base
+interface Derived: Base
+
+fun foo(bar: Base):Int {
+    return when (bar) {
+        is Derived -> 0
+        else -> 42
+    }
+}

idea/testData/quickfix/expressions/removeUselessIsCheckInWhenExpressionless.kt

@@ -0,0 +1,12 @@
+// "Remove useless is check" "true"
+
+interface Base
+interface Derived: Base
+
+fun foo(bar: Base):Int {
+    return when {
+        bar is Derived -> 0
+        bar <caret>is Base -> 42
+        else -> 1
+    }
+}

idea/testData/quickfix/expressions/removeUselessIsCheckInWhenExpressionless.kt.after

@@ -0,0 +1,12 @@
+// "Remove useless is check" "true"
+
+interface Base
+interface Derived: Base
+
+fun foo(bar: Base):Int {
+    return when {
+        bar is Derived -> 0
+        true -> 42
+        else -> 1
+    }
+}

idea/testData/quickfix/expressions/removeUselessIsCheckInWhenExpressionlessNegate.kt

@@ -0,0 +1,12 @@
+// "Remove useless is check" "true"
+
+interface Base
+interface Derived: Base
+
+fun foo(bar: Base):Int {
+    return when {
+        bar is Derived -> 0
+        bar <caret>!is Base -> 42
+        else -> 1
+    }
+}

idea/testData/quickfix/expressions/removeUselessIsCheckInWhenExpressionlessNegate.kt.after

@@ -0,0 +1,12 @@
+// "Remove useless is check" "true"
+
+interface Base
+interface Derived: Base
+
+fun foo(bar: Base):Int {
+    return when {
+        bar is Derived -> 0
+        false -> 42
+        else -> 1
+    }
+}

idea/testData/quickfix/expressions/removeUselessIsCheckInWhenNegate.kt

@@ -0,0 +1,11 @@
+// "Remove useless is check" "true"
+interface Base
+interface Derived: Base
+
+fun foo(bar: Base):Int {
+    return when (bar) {
+        is Derived -> 0
+        <caret>!is Base -> 42
+        else -> 1
+    }
+}

idea/testData/quickfix/expressions/removeUselessIsCheckInWhenNegate.kt.after

@@ -0,0 +1,10 @@
+// "Remove useless is check" "true"
+interface Base
+interface Derived: Base
+
+fun foo(bar: Base):Int {
+    return when (bar) {
+        is Derived -> 0
+        else -> 1
+    }
+}

idea/tests/org/jetbrains/kotlin/idea/quickfix/QuickFixTestGenerated.java

@@ -5789,6 +5789,24 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest {
             doTest(fileName);
         }
 
+        @TestMetadata("removeUselessIsCheckInWhenExpressionless.kt")
+        public void testRemoveUselessIsCheckInWhenExpressionless() throws Exception {
+            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/quickfix/expressions/removeUselessIsCheckInWhenExpressionless.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("removeUselessIsCheckInWhenExpressionlessNegate.kt")
+        public void testRemoveUselessIsCheckInWhenExpressionlessNegate() throws Exception {
+            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/quickfix/expressions/removeUselessIsCheckInWhenExpressionlessNegate.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("removeUselessIsCheckInWhenNegate.kt")
+        public void testRemoveUselessIsCheckInWhenNegate() throws Exception {
+            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/quickfix/expressions/removeUselessIsCheckInWhenNegate.kt");
+            doTest(fileName);
+        }
+
         @TestMetadata("removeUselessIsCheckNegate.kt")
         public void testRemoveUselessIsCheckNegate() throws Exception {
             String fileName = KotlinTestUtils.navigationMetadata("idea/testData/quickfix/expressions/removeUselessIsCheckNegate.kt");