"Change return type for enclosing fix" now handles TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH correctly #KT-14063 Fixed

idea/ide-common/src/org/jetbrains/kotlin/idea/core/quickfix/QuickFixUtil.java

@@ -121,13 +121,23 @@ public class QuickFixUtil {
         return null;
     }
 
+    // Returns true iff parent's value always or sometimes is evaluable to child's value, e.g.
+    // parent = (x), child = x;
+    // parent = if (...) x else y, child = x;
+    // parent = y.x, child = x
     public static boolean canEvaluateTo(KtExpression parent, KtExpression child) {
         if (parent == null || child == null) {
             return false;
         }
         while (parent != child) {
-            if (child.getParent() instanceof KtParenthesizedExpression) {
+            PsiElement childParent = child.getParent();
-                child = (KtExpression) child.getParent();
+            if (childParent instanceof KtParenthesizedExpression) {
+                child = (KtExpression) childParent;
+                continue;
+            }
+            if (childParent instanceof KtDotQualifiedExpression &&
+                (child instanceof KtCallExpression || child instanceof KtDotQualifiedExpression)) {
+                child = (KtExpression) childParent;
                 continue;
             }
             child = getParentIfForBranch(child);

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

@@ -58,29 +58,36 @@ class QuickFixFactoryForTypeMismatchError : KotlinIntentionActionsFactory() {
 
         val expectedType: KotlinType
         val expressionType: KotlinType?
-        if (diagnostic.factory === Errors.TYPE_MISMATCH) {
+        when (diagnostic.factory) {
-            val diagnosticWithParameters = Errors.TYPE_MISMATCH.cast(diagnostic)
+            Errors.TYPE_MISMATCH -> {
-            expectedType = diagnosticWithParameters.a
+                val diagnosticWithParameters = Errors.TYPE_MISMATCH.cast(diagnostic)
-            expressionType = diagnosticWithParameters.b
+                expectedType = diagnosticWithParameters.a
-        }
+                expressionType = diagnosticWithParameters.b
-        else if (diagnostic.factory === Errors.NULL_FOR_NONNULL_TYPE) {
+            }
-            val diagnosticWithParameters = Errors.NULL_FOR_NONNULL_TYPE.cast(diagnostic)
+            Errors.NULL_FOR_NONNULL_TYPE -> {
-            expectedType = diagnosticWithParameters.a
+                val diagnosticWithParameters = Errors.NULL_FOR_NONNULL_TYPE.cast(diagnostic)
-            expressionType = expectedType.makeNullable()
+                expectedType = diagnosticWithParameters.a
-        }
+                expressionType = expectedType.makeNullable()
-        else if (diagnostic.factory === Errors.CONSTANT_EXPECTED_TYPE_MISMATCH) {
+            }
-            val diagnosticWithParameters = Errors.CONSTANT_EXPECTED_TYPE_MISMATCH.cast(diagnostic)
+            Errors.TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH -> {
-            expectedType = diagnosticWithParameters.b
+                val diagnosticWithParameters = Errors.TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH.cast(diagnostic)
-            expressionType = context.getType(diagnosticElement)
+                expectedType = diagnosticWithParameters.a
-            if (expressionType == null) {
+                expressionType = diagnosticWithParameters.b
-                LOG.error("No type inferred: " + diagnosticElement.text)
+            }
+            Errors.CONSTANT_EXPECTED_TYPE_MISMATCH -> {
+                val diagnosticWithParameters = Errors.CONSTANT_EXPECTED_TYPE_MISMATCH.cast(diagnostic)
+                expectedType = diagnosticWithParameters.b
+                expressionType = context.getType(diagnosticElement)
+                if (expressionType == null) {
+                    LOG.error("No type inferred: " + diagnosticElement.text)
+                    return emptyList()
+                }
+            }
+            else -> {
+                LOG.error("Unexpected diagnostic: " + DefaultErrorMessages.render(diagnostic))
                 return emptyList()
             }
         }
-        else {
-            LOG.error("Unexpected diagnostic: " + DefaultErrorMessages.render(diagnostic))
-            return emptyList()
-        }
 
         if (expressionType.isPrimitiveNumberType() && expectedType.isPrimitiveNumberType()) {
             var wrongPrimitiveLiteralFix: WrongPrimitiveLiteralFix? = null

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

@@ -332,6 +332,7 @@ class QuickFixRegistrar : QuickFixContributor {
         TYPE_MISMATCH.registerFactory(factoryForTypeMismatchError)
         NULL_FOR_NONNULL_TYPE.registerFactory(factoryForTypeMismatchError)
         CONSTANT_EXPECTED_TYPE_MISMATCH.registerFactory(factoryForTypeMismatchError)
+        TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH.registerFactory(factoryForTypeMismatchError)
 
         SMARTCAST_IMPOSSIBLE.registerFactory(SmartCastImpossibleExclExclFixFactory)
         SMARTCAST_IMPOSSIBLE.registerFactory(CastExpressionFix.SmartCastImpossibleFactory)

idea/testData/quickfix/typeMismatch/changeReturnTypeForTypeInference.kt

@@ -0,0 +1,6 @@
+// "Change return type of enclosing function 'test2' to 'List<Any>'" "true"
+// WITH_RUNTIME
+
+fun test2(ss: List<Any>) {
+    return ss.map { it }<caret>
+}

idea/testData/quickfix/typeMismatch/changeReturnTypeForTypeInference.kt.after

@@ -0,0 +1,6 @@
+// "Change return type of enclosing function 'test2' to 'List<Any>'" "true"
+// WITH_RUNTIME
+
+fun test2(ss: List<Any>): List<Any> {
+    return ss.map { it }<caret>
+}

idea/testData/quickfix/typeMismatch/changeReturnTypeForTypeMismatch.kt

@@ -0,0 +1,6 @@
+// "Change return type of enclosing function 'test1' to 'Int'" "true"
+// WITH_RUNTIME
+
+fun test1(ss: List<Any>) {
+    return ss.map { it }.size<caret>
+}

idea/testData/quickfix/typeMismatch/changeReturnTypeForTypeMismatch.kt.after

@@ -0,0 +1,6 @@
+// "Change return type of enclosing function 'test1' to 'Int'" "true"
+// WITH_RUNTIME
+
+fun test1(ss: List<Any>): Int {
+    return ss.map { it }.size<caret>
+}

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

@@ -9006,6 +9006,18 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest {
             doTest(fileName);
         }
 
+        @TestMetadata("changeReturnTypeForTypeInference.kt")
+        public void testChangeReturnTypeForTypeInference() throws Exception {
+            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/quickfix/typeMismatch/changeReturnTypeForTypeInference.kt");
+            doTest(fileName);
+        }
+
+        @TestMetadata("changeReturnTypeForTypeMismatch.kt")
+        public void testChangeReturnTypeForTypeMismatch() throws Exception {
+            String fileName = KotlinTestUtils.navigationMetadata("idea/testData/quickfix/typeMismatch/changeReturnTypeForTypeMismatch.kt");
+            doTest(fileName);
+        }
+
         @TestMetadata("changeReturnTypeNoFqNameForAnonymousObject.kt")
         public void testChangeReturnTypeNoFqNameForAnonymousObject() throws Exception {
             String fileName = KotlinTestUtils.navigationMetadata("idea/testData/quickfix/typeMismatch/changeReturnTypeNoFqNameForAnonymousObject.kt");