Call chain --> Sequence: take termination into account

Related to KT-15476

idea/src/org/jetbrains/kotlin/idea/inspections/collections/ConvertCallChainIntoSequenceInspection.kt

@@ -23,6 +23,7 @@ import org.jetbrains.kotlin.psi.psiUtil.anyDescendantOfType
 import org.jetbrains.kotlin.psi.psiUtil.siblings
 import org.jetbrains.kotlin.psi.psiUtil.startOffset
 import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
+import org.jetbrains.kotlin.types.KotlinType
 
 class ConvertCallChainIntoSequenceInspection : AbstractKotlinInspection() {
     override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean) =
@@ -54,8 +55,7 @@ private class ConvertCallChainIntoSequenceFix : LocalQuickFix {
         val lastCall = calls.lastOrNull() ?: return
         val first = firstCall.parent as? KtQualifiedExpression ?: return
         val last = lastCall.parent as? KtQualifiedExpression ?: return
-        val next = last.parent as? KtQualifiedExpression
-        val nextType = next?.getCallableDescriptor()?.returnType
+        val endWithTermination = lastCall.isTermination()
 
         val psiFactory = KtPsiFactory(expression)
         val dot = buildString {
@@ -76,11 +76,7 @@ private class ConvertCallChainIntoSequenceFix : LocalQuickFix {
         )
         firstCommentSaver.restore(firstReplaced)
 
-        val nextDescriptor = next?.getCallableDescriptor()
-        if (nextDescriptor == null
-            || !nextDescriptor.fqNameSafe.asString().startsWith("kotlin.sequences.")
-            || nextDescriptor.returnType != nextType
-        ) {
+        if (!endWithTermination) {
             val lastCommentSaver = CommentSaver(last)
             val lastReplaced = last.replace(
                 psiFactory.buildExpression {
@@ -100,9 +96,10 @@ private fun KtQualifiedExpression.findTarget(): Pair<KtQualifiedExpression, KtCa
     val calls = collectCallExpression()
     if (calls.isEmpty()) return null
 
+    val receiverType = (calls.last().parent as? KtQualifiedExpression)?.receiverExpression?.getCallableDescriptor()?.returnType
+    if (receiverType?.isCollection() != true) return null
+
     val qualified = calls.first().parent as? KtQualifiedExpression ?: return null
-    val fqName = qualified.getCallableDescriptor()?.returnType?.constructor?.declarationDescriptor?.fqNameSafe
-    if (fqName != KotlinBuiltIns.FQ_NAMES.list) return null
     return qualified to calls.last()
 }
 
@@ -121,20 +118,28 @@ private fun KtQualifiedExpression.collectCallExpression(): List<KtCallExpression
 
     val transformationCalls = calls
         .asSequence()
-        .dropWhile { !it.isTransformation() }
-        .takeWhile { it.isTransformation() && !it.hasReturn() }
+        .dropWhile { !it.isTransformationOrTermination() }
+        .takeWhile { it.isTransformationOrTermination() && !it.hasReturn() }
         .toList()
     if (transformationCalls.size < 2) return emptyList()
 
     return transformationCalls
 }
 
+private fun KotlinType.isCollection(): Boolean =
+    constructor.declarationDescriptor?.fqNameSafe == KotlinBuiltIns.FQ_NAMES.collection || constructor.supertypes.any { it.isCollection() }
+
 private fun KtCallExpression.hasReturn(): Boolean = valueArguments.any { arg ->
     arg.anyDescendantOfType<KtReturnExpression> { it.labelQualifier == null }
 }
 
-private fun KtCallExpression.isTransformation(): Boolean {
-    val fqName = transformations[calleeExpression?.text] ?: return false
+private fun KtCallExpression.isTransformationOrTermination(): Boolean {
+    val fqName = transformationAndTerminations[calleeExpression?.text] ?: return false
+    return fqName == getCallableDescriptor()?.fqNameSafe
+}
+
+private fun KtCallExpression.isTermination(): Boolean {
+    val fqName = terminations[calleeExpression?.text] ?: return false
     return fqName == getCallableDescriptor()?.fqNameSafe
 }
 
@@ -167,5 +172,76 @@ private val transformations = listOf(
     "take",
     "takeWhile",
     "windowed",
+    "withIndex",
     "zipWithNext"
 ).associate { it to FqName("kotlin.collections.$it") }
+
+private val terminations = listOf(
+    "all",
+    "any",
+    "asIterable",
+    "asSequence",
+    "associate",
+    "associateBy",
+    "associateByTo",
+    "associateTo",
+    "average",
+    "contains",
+    "count",
+    "elementAt",
+    "elementAtOrElse",
+    "elementAtOrNull",
+    "filterIndexedTo",
+    "filterIsInstanceTo",
+    "filterNotNullTo",
+    "filterNotTo",
+    "filterTo",
+    "find",
+    "findLast",
+    "first",
+    "firstOrNull",
+    "fold",
+    "foldIndexed",
+    "groupBy",
+    "groupByTo",
+    "groupingBy",
+    "indexOf",
+    "indexOfFirst",
+    "indexOfLast",
+    "joinTo",
+    "joinToString",
+    "last",
+    "lastIndexOf",
+    "lastOrNull",
+    "mapIndexedNotNullTo",
+    "mapIndexedTo",
+    "mapNotNullTo",
+    "mapTo",
+    "max",
+    "maxBy",
+    "maxWith",
+    "min",
+    "minBy",
+    "minWith",
+    "none",
+    "partition",
+    "reduce",
+    "reduceIndexed",
+    "single",
+    "singleOrNull",
+    "sum",
+    "sumBy",
+    "sumByDouble",
+    "toCollection",
+    "toHashSet",
+    "toList",
+    "toMutableList",
+    "toMutableSet",
+    "toSet",
+    "toSortedSet"
+).associate {
+    val pkg = if (it in listOf("contains", "indexOf", "lastIndexOf")) "kotlin.collections.List" else "kotlin.collections"
+    it to FqName("$pkg.$it")
+}
+
+private val transformationAndTerminations = transformations + terminations

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/allTransformations.kt

@@ -1,6 +1,6 @@
 // WITH_RUNTIME
 
-fun test(list: List<Int>): List<Pair<List<Int>, List<Int>>> {
+fun test(list: List<Int>): List<Pair<IndexedValue<List<Int>>, IndexedValue<List<Int>>>> {
     return list
             .<caret>chunked(1)
             .distinct()
@@ -30,6 +30,7 @@ fun test(list: List<Int>): List<Pair<List<Int>, List<Int>>> {
             .take(1)
             .takeWhile { true }
             .windowed(1, 1, true)
+            .withIndex()
             .zipWithNext()
             .zipWithNext { a, b -> a }
 }

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/allTransformations.kt.after

@@ -1,6 +1,6 @@
 // WITH_RUNTIME
 
-fun test(list: List<Int>): List<Pair<List<Int>, List<Int>>> {
+fun test(list: List<Int>): List<Pair<IndexedValue<List<Int>>, IndexedValue<List<Int>>>> {
     return list
             .asSequence()
             .chunked(1)
@@ -31,6 +31,7 @@ fun test(list: List<Int>): List<Pair<List<Int>, List<Int>>> {
             .take(1)
             .takeWhile { true }
             .windowed(1, 1, true)
+            .withIndex()
             .zipWithNext()
             .zipWithNext { a, b -> a }
             .toList()

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/mutableList.kt

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(): List<Int> {
+    return mutableListOf(1, 2, 3).<caret>filter { it > 1 }.map { it * 2 }
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/mutableList.kt.after

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(): List<Int> {
+    return mutableListOf(1, 2, 3).asSequence().filter { it > 1 }.map { it * 2 }.toList()
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/mutableSet.kt

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(): List<Int> {
+    return mutableSetOf(1, 2, 3).<caret>filter { it > 1 }.map { it * 2 }
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/mutableSet.kt.after

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(): List<Int> {
+    return mutableSetOf(1, 2, 3).asSequence().filter { it > 1 }.map { it * 2 }.toList()
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/noTargetCallChain2.kt

@@ -2,5 +2,8 @@
 // WITH_RUNTIME
 
 fun test(list: List<Int>): List<Int> {
-    return list.filter { it > 2 }.dropLast(1).<caret>filter { it > 2 }
+    return list
+        .filter { it > 2 }
+        .dropLast(1)
+        .<caret>filter { it > 2 }
 }

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/noTargetCallChain3.kt

@@ -4,7 +4,6 @@
 fun test(list: List<Int>): List<Int> {
     return list
             .reversed()
-            .map { it + 1 }
             .<caret>map { it + 1 }
             .dropLast(1)
             .takeLast(2)

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/set.kt

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(): List<Int> {
+    return setOf(1, 2, 3).<caret>filter { it > 1 }.map { it * 2 }
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/set.kt.after

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(): List<Int> {
+    return setOf(1, 2, 3).asSequence().filter { it > 1 }.map { it * 2 }.toList()
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination.kt

@@ -1,8 +0,0 @@
-// WITH_RUNTIME
-
-fun test(): Int {
-    return listOf(1, 2, 3)
-            .<caret>filter { it > 1 }
-            .map { it * 2 }
-            .sum()
-}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination.kt.after

@@ -1,9 +0,0 @@
-// WITH_RUNTIME
-
-fun test(): Int {
-    return listOf(1, 2, 3)
-            .asSequence()
-            .filter { it > 1 }
-            .map { it * 2 }
-            .sum()
-}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/all.kt

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val all: Boolean = list.<caret>filter { it > 1 }.all { true }
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/all.kt.after

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val all: Boolean = list.asSequence().filter { it > 1 }.all { true }
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/any.kt

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val any: Boolean = list.<caret>filter { it > 1 }.any()
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/any.kt.after

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val any: Boolean = list.asSequence().filter { it > 1 }.any()
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/asIterable.kt

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val asIterable: Iterable<Int> = list.<caret>filter { it > 1 }.asIterable()
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/asIterable.kt.after

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val asIterable: Iterable<Int> = list.asSequence().filter { it > 1 }.asIterable()
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/asSequence.kt

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val asSequence: Sequence<Int> = list.<caret>filter { it > 1 }.asSequence()
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/asSequence.kt.after

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val asSequence: Sequence<Int> = list.asSequence().filter { it > 1 }.asSequence()
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/assosiate.kt

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val associate: Map<Int, Int> = list.<caret>filter { it > 1 }.associate { it to it }
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/assosiate.kt.after

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val associate: Map<Int, Int> = list.asSequence().filter { it > 1 }.associate { it to it }
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/assosiateBy.kt

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val associateBy: Map<Int, Int> = list.<caret>filter { it > 1 }.associateBy { it }
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/assosiateBy.kt.after

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val associateBy: Map<Int, Int> = list.asSequence().filter { it > 1 }.associateBy { it }
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/assosiateByTo.kt

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val associateByTo = list.<caret>filter { it > 1 }.associateByTo(mutableMapOf()) { it }
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/assosiateByTo.kt.after

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val associateByTo = list.asSequence().filter { it > 1 }.associateByTo(mutableMapOf()) { it }
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/assosiateTo.kt

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val associateTo: MutableMap<Int, Int> = list.<caret>filter { it > 1 }.associateTo(mutableMapOf()) { it to it }
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/assosiateTo.kt.after

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val associateTo: MutableMap<Int, Int> = list.asSequence().filter { it > 1 }.associateTo(mutableMapOf()) { it to it }
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/average.kt

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val average: Double = list.<caret>filter { it > 1 }.average()
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/average.kt.after

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val average: Double = list.asSequence().filter { it > 1 }.average()
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/contains.kt

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val contains: Boolean = list.<caret>filter { it > 1 }.contains(1)
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/contains.kt.after

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val contains: Boolean = list.asSequence().filter { it > 1 }.contains(1)
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/count.kt

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val count: Int = list.<caret>filter { it > 1 }.count()
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/count.kt.after

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val count: Int = list.asSequence().filter { it > 1 }.count()
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/elementAt.kt

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val elementAt = list.<caret>filter { it > 1 }.elementAt(1)
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/elementAt.kt.after

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val elementAt = list.asSequence().filter { it > 1 }.elementAt(1)
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/elementAtOrElse.kt

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val elementAtOrElse: Int = list.<caret>filter { it > 1 }.elementAtOrElse(1) { 1 }
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/elementAtOrElse.kt.after

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val elementAtOrElse: Int = list.asSequence().filter { it > 1 }.elementAtOrElse(1) { 1 }
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/elementAtOrNull.kt

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val elementAtOrNull: Int? = list.<caret>filter { it > 1 }.elementAtOrNull(1)
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/elementAtOrNull.kt.after

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val elementAtOrNull: Int? = list.asSequence().filter { it > 1 }.elementAtOrNull(1)
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/filterIndexedTo.kt

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val filterIndexedTo: MutableList<Int> = list.<caret>filter { it > 1 }.filterIndexedTo(mutableListOf()) { index, it -> true }
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/filterIndexedTo.kt.after

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val filterIndexedTo: MutableList<Int> = list.asSequence().filter { it > 1 }.filterIndexedTo(mutableListOf()) { index, it -> true }
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/filterIsInstanceTo.kt

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val filterIsInstanceTo = list.<caret>filter { it > 1 }.filterIsInstanceTo(mutableListOf<Int>())
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/filterIsInstanceTo.kt.after

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val filterIsInstanceTo = list.asSequence().filter { it > 1 }.filterIsInstanceTo(mutableListOf<Int>())
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/filterNotNullTo.kt

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val filterNotNullTo: MutableList<Int> = list.<caret>filter { it > 1 }.filterNotNullTo(mutableListOf())
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/filterNotNullTo.kt.after

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val filterNotNullTo: MutableList<Int> = list.asSequence().filter { it > 1 }.filterNotNullTo(mutableListOf())
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/filterNotTo.kt

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val filterNotTo: MutableList<Int> = list.<caret>filter { it > 1 }.filterNotTo(mutableListOf()) { true }
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/filterNotTo.kt.after

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val filterNotTo: MutableList<Int> = list.asSequence().filter { it > 1 }.filterNotTo(mutableListOf()) { true }
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/filterTo.kt

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val filterTo: MutableList<Int> = list.<caret>filter { it > 1 }.filterTo(mutableListOf()) { true }
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/filterTo.kt.after

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val filterTo: MutableList<Int> = list.asSequence().filter { it > 1 }.filterTo(mutableListOf()) { true }
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/find.kt

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val find: Int? = list.<caret>filter { it > 1 }.find { true }
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/find.kt.after

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val find: Int? = list.asSequence().filter { it > 1 }.find { true }
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/findLast.kt

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val findLast: Int? = list.<caret>filter { it > 1 }.findLast { true }
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/findLast.kt.after

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val findLast: Int? = list.asSequence().filter { it > 1 }.findLast { true }
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/first.kt

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val first: Int = list.<caret>filter { it > 1 }.first()
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/first.kt.after

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val first: Int = list.asSequence().filter { it > 1 }.first()
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/firstOrNull.kt

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val firstOrNull: Int? = list.<caret>filter { it > 1 }.firstOrNull()
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/firstOrNull.kt.after

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val firstOrNull: Int? = list.asSequence().filter { it > 1 }.firstOrNull()
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/fold.kt

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val fold: Int = list.<caret>filter { it > 1 }.fold(0) { acc, i -> acc + i }
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/fold.kt.after

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val fold: Int = list.asSequence().filter { it > 1 }.fold(0) { acc, i -> acc + i }
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/foldIndexed.kt

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val foldIndexed = list.<caret>filter { it > 1 }.foldIndexed(0) { index, acc, i -> acc + i }
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/foldIndexed.kt.after

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val foldIndexed = list.asSequence().filter { it > 1 }.foldIndexed(0) { index, acc, i -> acc + i }
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/forEach.kt

@@ -0,0 +1,6 @@
+// PROBLEM: none
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val forEach: Unit = list.<caret>filter { it > 1 }.forEach { }
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/forEachIndexed.kt

@@ -0,0 +1,6 @@
+// PROBLEM: none
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val forEachIndexed: Unit = list.<caret>filter { it > 1 }.forEachIndexed { index, i -> }
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/groupBy.kt

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val groupBy = list.<caret>filter { it > 1 }.groupBy { it }
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/groupBy.kt.after

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val groupBy = list.asSequence().filter { it > 1 }.groupBy { it }
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/groupByTo.kt

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val groupByTo: MutableMap<Int, MutableList<Int>> = list.<caret>filter { it > 1 }.groupByTo(mutableMapOf()) { it }
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/groupByTo.kt.after

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val groupByTo: MutableMap<Int, MutableList<Int>> = list.asSequence().filter { it > 1 }.groupByTo(mutableMapOf()) { it }
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/groupingBy.kt

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val groupingBy: Grouping<Int, Int> = list.<caret>filter { it > 1 }.groupingBy { it }
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/groupingBy.kt.after

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val groupingBy: Grouping<Int, Int> = list.asSequence().filter { it > 1 }.groupingBy { it }
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/indexOf.kt

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val indexOf: Int = list.<caret>filter { it > 1 }.indexOf(1)
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/indexOf.kt.after

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val indexOf: Int = list.asSequence().filter { it > 1 }.indexOf(1)
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/indexOfFirst.kt

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val indexOfFirst: Int = list.<caret>filter { it > 1 }.indexOfFirst { true }
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/indexOfFirst.kt.after

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val indexOfFirst: Int = list.asSequence().filter { it > 1 }.indexOfFirst { true }
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/indexOfLast.kt

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val indexOfLast: Int = list.<caret>filter { it > 1 }.indexOfLast { true }
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/indexOfLast.kt.after

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val indexOfLast: Int = list.asSequence().filter { it > 1 }.indexOfLast { true }
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/joinTo.kt

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val joinTo: StringBuilder = list.<caret>filter { it > 1 }.joinTo(StringBuilder())
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/joinTo.kt.after

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val joinTo: StringBuilder = list.asSequence().filter { it > 1 }.joinTo(StringBuilder())
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/joinToString.kt

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val joinToString: String = list.<caret>filter { it > 1 }.joinToString()
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/joinToString.kt.after

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val joinToString: String = list.asSequence().filter { it > 1 }.joinToString()
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/last.kt

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val last: Int = list.<caret>filter { it > 1 }.last()
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/last.kt.after

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val last: Int = list.asSequence().filter { it > 1 }.last()
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/lastIndexOf.kt

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val lastIndexOf: Int = list.<caret>filter { it > 1 }.lastIndexOf(1)
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/lastIndexOf.kt.after

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val lastIndexOf: Int = list.asSequence().filter { it > 1 }.lastIndexOf(1)
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/lastOrNull.kt

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val lastOrNull = list.<caret>filter { it > 1 }.lastOrNull()
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/lastOrNull.kt.after

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val lastOrNull = list.asSequence().filter { it > 1 }.lastOrNull()
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/mapIndexedNotNullTo.kt

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val mapIndexedNotNullTo: MutableList<Int> = list.<caret>filter { it > 1 }.mapIndexedNotNullTo(mutableListOf()) { index, i -> i }
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/mapIndexedNotNullTo.kt.after

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val mapIndexedNotNullTo: MutableList<Int> = list.asSequence().filter { it > 1 }.mapIndexedNotNullTo(mutableListOf()) { index, i -> i }
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/mapIndexedTo.kt

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val mapIndexedTo: MutableList<Int> = list.<caret>filter { it > 1 }.mapIndexedTo(mutableListOf()) { index, i -> i }
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/mapIndexedTo.kt.after

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val mapIndexedTo: MutableList<Int> = list.asSequence().filter { it > 1 }.mapIndexedTo(mutableListOf()) { index, i -> i }
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/mapNotNullTo.kt

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val mapNotNullTo: MutableList<Int> = list.<caret>filter { it > 1 }.mapNotNullTo(mutableListOf()) { it }
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/mapNotNullTo.kt.after

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val mapNotNullTo: MutableList<Int> = list.asSequence().filter { it > 1 }.mapNotNullTo(mutableListOf()) { it }
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/mapTo.kt

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val mapTo: MutableList<Int> = list.<caret>filter { it > 1 }.mapTo(mutableListOf()) { it }
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/mapTo.kt.after

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val mapTo: MutableList<Int> = list.asSequence().filter { it > 1 }.mapTo(mutableListOf()) { it }
+}

idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination/max.kt

@@ -0,0 +1,5 @@
+// WITH_RUNTIME
+
+fun test(list: List<Int>) {
+    val max: Int? = list.<caret>filter { it > 1 }.max()
+}