Extract Function: Add test data

idea/testData/refactoring/extractFunction/controlFlow/conditionalJumps/conditionalBreakWithIf.kt

@@ -0,0 +1,11 @@
+// NEXT_SIBLING:
+fun foo(a: Int): Int {
+    val b: Int = 1
+    for (n in 1..a) {
+        <selection>if (a + b > 0) break
+        println(a - b)
+        if (a - b > 0) break
+        println(a + b)</selection>
+    }
+    return 1
+}

idea/testData/refactoring/extractFunction/controlFlow/conditionalJumps/conditionalBreakWithIf.kt.after

@@ -0,0 +1,16 @@
+// NEXT_SIBLING:
+fun b(a: Int, b: Int): Boolean {
+    if (a + b > 0) return true
+    println(a - b)
+    if (a - b > 0) return true
+    println(a + b)
+    return false
+}
+
+fun foo(a: Int): Int {
+    val b: Int = 1
+    for (n in 1..a) {
+        if (b(a, b)) break
+    }
+    return 1
+}

idea/testData/refactoring/extractFunction/controlFlow/conditionalJumps/conditionalBreakWithIfElse.kt

@@ -0,0 +1,13 @@
+// NEXT_SIBLING:
+fun foo(a: Int): Int {
+    val b: Int = 1
+    for (n in 1..a) {
+        <selection>if (a + b > 0) break
+        else {
+            println(a - b)
+            if (a - b > 0) break else println(a + b)
+        }
+        </selection>
+    }
+    return 1
+}

idea/testData/refactoring/extractFunction/controlFlow/conditionalJumps/conditionalBreakWithIfElse.kt.after

@@ -0,0 +1,18 @@
+// NEXT_SIBLING:
+fun b(a: Int, b: Int): Boolean {
+    if (a + b > 0) return true
+    else {
+        println(a - b)
+        if (a - b > 0) return true else println(a + b)
+    }
+    return false
+}
+
+fun foo(a: Int): Int {
+    val b: Int = 1
+    for (n in 1..a) {
+        if (b(a, b)) break
+        
+    }
+    return 1
+}

idea/testData/refactoring/extractFunction/controlFlow/conditionalJumps/conditionalBreakWithWhen.kt

@@ -0,0 +1,12 @@
+// NEXT_SIBLING:
+fun foo(a: Int): Int {
+    val b: Int = 1
+    for (n in 1..a) {
+        <selection>when {
+            a + b > 0 -> break
+            a - b > 0 -> break
+            else -> println(0)
+        }</selection>
+    }
+    return 1
+}

idea/testData/refactoring/extractFunction/controlFlow/conditionalJumps/conditionalBreakWithWhen.kt.after

@@ -0,0 +1,17 @@
+// NEXT_SIBLING:
+fun b(a: Int, b: Int): Boolean {
+    when {
+        a + b > 0 -> return true
+        a - b > 0 -> return true
+        else -> println(0)
+    }
+    return false
+}
+
+fun foo(a: Int): Int {
+    val b: Int = 1
+    for (n in 1..a) {
+        if (b(a, b)) break
+    }
+    return 1
+}

idea/testData/refactoring/extractFunction/controlFlow/conditionalJumps/conditionalReturnWithIf.kt

@@ -0,0 +1,7 @@
+// NEXT_SIBLING:
+fun foo(a: Int): Int {
+    val b: Int = 1
+    <selection>if (a + b > 0) return 0
+    println(a - b)</selection>
+    return 1
+}

idea/testData/refactoring/extractFunction/controlFlow/conditionalJumps/conditionalReturnWithIf.kt.after

@@ -0,0 +1,12 @@
+// NEXT_SIBLING:
+fun b(a: Int, b: Int): Boolean {
+    if (a + b > 0) return true
+    println(a - b)
+    return false
+}
+
+fun foo(a: Int): Int {
+    val b: Int = 1
+    if (b(a, b)) return 0
+    return 1
+}

idea/testData/refactoring/extractFunction/controlFlow/conditionalJumps/conditionalReturnWithIfElse.kt

@@ -0,0 +1,8 @@
+// NEXT_SIBLING:
+fun foo(a: Int): Int {
+    val b: Int = 1
+    <selection>if (a + b > 0) return 0
+    else if (a - b < 0) println(a - b)
+    else println(0)</selection>
+    return 1
+}

idea/testData/refactoring/extractFunction/controlFlow/conditionalJumps/conditionalReturnWithIfElse.kt.after

@@ -0,0 +1,13 @@
+// NEXT_SIBLING:
+fun b(a: Int, b: Int): Boolean {
+    if (a + b > 0) return true
+    else if (a - b < 0) println(a - b)
+    else println(0)
+    return false
+}
+
+fun foo(a: Int): Int {
+    val b: Int = 1
+    if (b(a, b)) return 0
+    return 1
+}

idea/testData/refactoring/extractFunction/controlFlow/conditionalJumps/conditionalReturnWithWhen.kt

@@ -0,0 +1,11 @@
+// NEXT_SIBLING:
+fun foo(a: Int): Int {
+    val b: Int = 1
+    <selection>when (a + b) {
+        0 -> return 0
+        1 -> println(1)
+        else -> println(2)
+    }
+    </selection>
+    return 1
+}

idea/testData/refactoring/extractFunction/controlFlow/conditionalJumps/conditionalReturnWithWhen.kt.after

@@ -0,0 +1,16 @@
+// NEXT_SIBLING:
+fun b(a: Int, b: Int): Boolean {
+    when (a + b) {
+        0 -> return true
+        1 -> println(1)
+        else -> println(2)
+    }
+    return false
+}
+
+fun foo(a: Int): Int {
+    val b: Int = 1
+    if (b(a, b)) return 0
+    
+    return 1
+}

idea/testData/refactoring/extractFunction/controlFlow/conditionalJumps/unconditionalBreakWithIf.kt

@@ -0,0 +1,10 @@
+// NEXT_SIBLING:
+fun foo(a: Int): Int {
+    val b: Int = 1
+    for (n in 1..a) {
+        <selection>if (a + b > 0) break
+        println(a - b)
+        break</selection>
+    }
+    return 1
+}

idea/testData/refactoring/extractFunction/controlFlow/conditionalJumps/unconditionalBreakWithIf.kt.after

@@ -0,0 +1,15 @@
+// NEXT_SIBLING:
+fun unit(a: Int, b: Int) {
+    if (a + b > 0) return
+    println(a - b)
+    return
+}
+
+fun foo(a: Int): Int {
+    val b: Int = 1
+    for (n in 1..a) {
+        unit(a, b)
+        break
+    }
+    return 1
+}

idea/testData/refactoring/extractFunction/controlFlow/conditionalJumps/unconditionalBreakWithIfElse.kt

@@ -0,0 +1,12 @@
+// NEXT_SIBLING:
+fun foo(a: Int): Int {
+    val b: Int = 1
+    for (n in 1..a) {
+        <selection>if (a + b > 0) break
+        else {
+            println(a - b)
+            break
+        }</selection>
+    }
+    return 1
+}

idea/testData/refactoring/extractFunction/controlFlow/conditionalJumps/unconditionalBreakWithIfElse.kt.after

@@ -0,0 +1,17 @@
+// NEXT_SIBLING:
+fun unit(a: Int, b: Int) {
+    if (a + b > 0) return
+    else {
+        println(a - b)
+        return
+    }
+}
+
+fun foo(a: Int): Int {
+    val b: Int = 1
+    for (n in 1..a) {
+        unit(a, b)
+        break
+    }
+    return 1
+}

idea/testData/refactoring/extractFunction/controlFlow/conditionalJumps/unconditionalBreakWithWhen.kt

@@ -0,0 +1,15 @@
+// NEXT_SIBLING:
+fun foo(a: Int): Int {
+    val b: Int = 1
+    for (n in 1..a) {
+        <selection>when {
+            a + b > 0 -> break
+            a - b > 0 -> break
+            else -> {
+                println(0)
+                break
+            }
+        }</selection>
+    }
+    return 1
+}

idea/testData/refactoring/extractFunction/controlFlow/conditionalJumps/unconditionalBreakWithWhen.kt.after

@@ -0,0 +1,20 @@
+// NEXT_SIBLING:
+fun unit(a: Int, b: Int) {
+    when {
+        a + b > 0 -> return
+        a - b > 0 -> return
+        else -> {
+            println(0)
+            return
+        }
+    }
+}
+
+fun foo(a: Int): Int {
+    val b: Int = 1
+    for (n in 1..a) {
+        unit(a, b)
+        break
+    }
+    return 1
+}

idea/testData/refactoring/extractFunction/controlFlow/default/defaultCF.kt

@@ -0,0 +1,9 @@
+// NEXT_SIBLING:
+fun foo(a: Int) {
+    val b: Int = 1
+
+    <selection>if(a > 0) {
+        println(a)
+    }
+    println(b)</selection>
+}

idea/testData/refactoring/extractFunction/controlFlow/default/defaultCF.kt.after

@@ -0,0 +1,13 @@
+// NEXT_SIBLING:
+fun unit(a: Int, b: Int) {
+    if (a > 0) {
+        println(a)
+    }
+    println(b)
+}
+
+fun foo(a: Int) {
+    val b: Int = 1
+
+    unit(a, b)
+}

idea/testData/refactoring/extractFunction/controlFlow/default/defaultCFWithJumps.kt

@@ -0,0 +1,12 @@
+// NEXT_SIBLING:
+fun foo(a: Int) {
+    val b: Int = 1
+
+    <selection>var t = a
+    while(t > 0) {
+        if (t == 2) continue
+        println(t)
+        if (t == 1) break
+        t--
+    }</selection>
+}

idea/testData/refactoring/extractFunction/controlFlow/default/defaultCFWithJumps.kt.after

@@ -0,0 +1,16 @@
+// NEXT_SIBLING:
+fun unit(a: Int) {
+    var t = a
+    while (t > 0) {
+        if (t == 2) continue
+        println(t)
+        if (t == 1) break
+        t--
+    }
+}
+
+fun foo(a: Int) {
+    val b: Int = 1
+
+    unit(a)
+}

idea/testData/refactoring/extractFunction/controlFlow/definiteReturns/definiteReturnWithIf.kt

@@ -0,0 +1,7 @@
+// NEXT_SIBLING:
+fun foo(a: Int): Int {
+    val b: Int = 1
+    <selection>if (a + b > 0) return 1
+    else if (a - b < 0) return 2
+    else return b</selection>
+}

idea/testData/refactoring/extractFunction/controlFlow/definiteReturns/definiteReturnWithIf.kt.after

@@ -0,0 +1,11 @@
+// NEXT_SIBLING:
+fun i(a: Int, b: Int): Int {
+    if (a + b > 0) return 1
+    else if (a - b < 0) return 2
+    else return b
+}
+
+fun foo(a: Int): Int {
+    val b: Int = 1
+    return i(a, b)
+}

idea/testData/refactoring/extractFunction/controlFlow/definiteReturns/definiteReturnWithWhen.kt

@@ -0,0 +1,9 @@
+// NEXT_SIBLING:
+fun foo(a: Int): Int {
+    val b: Int = 1
+    <selection>when (a + b) {
+        0 -> return b
+        1 -> return -b
+        else -> return a - b
+    }</selection>
+}

idea/testData/refactoring/extractFunction/controlFlow/definiteReturns/definiteReturnWithWhen.kt.after

@@ -0,0 +1,13 @@
+// NEXT_SIBLING:
+fun i(a: Int, b: Int): Int {
+    when (a + b) {
+        0 -> return b
+        1 -> return -b
+        else -> return a - b
+    }
+}
+
+fun foo(a: Int): Int {
+    val b: Int = 1
+    return i(a, b)
+}

idea/testData/refactoring/extractFunction/controlFlow/definiteReturns/singleDefiniteReturn.kt

@@ -0,0 +1,5 @@
+// NEXT_SIBLING:
+fun foo(a: Int): Int {
+    val b: Int = 1
+    <selection>return a + b</selection>
+}

idea/testData/refactoring/extractFunction/controlFlow/definiteReturns/singleDefiniteReturn.kt.after

@@ -0,0 +1,9 @@
+// NEXT_SIBLING:
+fun i(a: Int, b: Int): Int {
+    return a + b
+}
+
+fun foo(a: Int): Int {
+    val b: Int = 1
+    return i(a, b)
+}

idea/testData/refactoring/extractFunction/controlFlow/evaluateExpression/evalExprInIf.kt

@@ -0,0 +1,5 @@
+// NEXT_SIBLING:
+fun foo(a: Int): Int {
+    val b: Int = 1
+    return <selection>if (a + b > 0) 1 else if (a - b < 0) 2 else b </selection>
+}

idea/testData/refactoring/extractFunction/controlFlow/evaluateExpression/evalExprInIf.kt.after

@@ -0,0 +1,9 @@
+// NEXT_SIBLING:
+fun i(a: Int, b: Int): Int {
+    return if (a + b > 0) 1 else if (a - b < 0) 2 else b
+}
+
+fun foo(a: Int): Int {
+    val b: Int = 1
+    return i(a, b) 
+}

idea/testData/refactoring/extractFunction/controlFlow/evaluateExpression/evalExprInWhen.kt

@@ -0,0 +1,9 @@
+// NEXT_SIBLING:
+fun foo(a: Int): Int {
+    val b: Int = 1
+    return <selection>when (a + b) {
+        0 -> b
+        1 -> -b
+        else -> a - b
+    }</selection>
+}

idea/testData/refactoring/extractFunction/controlFlow/evaluateExpression/evalExprInWhen.kt.after

@@ -0,0 +1,13 @@
+// NEXT_SIBLING:
+fun i(a: Int, b: Int): Int {
+    return when (a + b) {
+        0 -> b
+        1 -> -b
+        else -> a - b
+    }
+}
+
+fun foo(a: Int): Int {
+    val b: Int = 1
+    return i(a, b)
+}

idea/testData/refactoring/extractFunction/controlFlow/evaluateExpression/simpleEvalExpr.kt

@@ -0,0 +1,5 @@
+// NEXT_SIBLING:
+fun foo(a: Int): Int {
+    val b: Int = 1
+    return <selection>a + b</selection>
+}

idea/testData/refactoring/extractFunction/controlFlow/evaluateExpression/simpleEvalExpr.kt.after

@@ -0,0 +1,9 @@
+// NEXT_SIBLING:
+fun i(a: Int, b: Int): Int {
+    return a + b
+}
+
+fun foo(a: Int): Int {
+    val b: Int = 1
+    return i(a, b)
+}

idea/testData/refactoring/extractFunction/controlFlow/outputValues/multipleOutputValues.kt

@@ -0,0 +1,12 @@
+// NEXT_SIBLING:
+fun foo(a: Int): Int {
+    var b: Int = 1
+    var c: Int = 1
+
+    <selection>b += a
+    c -= a
+    println(b)
+    println(c)</selection>
+
+    return b
+}

idea/testData/refactoring/extractFunction/controlFlow/outputValues/multipleOutputValues.kt.conflicts

@@ -0,0 +1 @@
+Selected code fragment has multiple output values: b c

idea/testData/refactoring/extractFunction/controlFlow/outputValues/multipleOutputValuesWithIf.kt

@@ -0,0 +1,16 @@
+// NEXT_SIBLING:
+fun foo(a: Int): Int {
+    var b: Int = 1
+    var c: Int = 1
+
+    <selection>if (a > 0) {
+        b += a
+    }
+    else {
+        c -= a
+    }
+    println(b)
+    println(c)</selection>
+
+    return b
+}

idea/testData/refactoring/extractFunction/controlFlow/outputValues/multipleOutputValuesWithIf.kt.conflicts

@@ -0,0 +1 @@
+Selected code fragment has multiple output values: b c

idea/testData/refactoring/extractFunction/controlFlow/outputValues/multipleOutputValuesWithWhen.kt

@@ -0,0 +1,18 @@
+// NEXT_SIBLING:
+fun foo(a: Int): Int {
+    var b: Int = 1
+    var c: Int = 1
+
+    <selection>when {
+        a > 0 -> {
+            b += a
+        }
+        else -> {
+            c -= a
+        }
+    }
+    println(b)
+    println(c)</selection>
+
+    return b
+}

idea/testData/refactoring/extractFunction/controlFlow/outputValues/multipleOutputValuesWithWhen.kt.conflicts

@@ -0,0 +1 @@
+Selected code fragment has multiple output values: b c

idea/testData/refactoring/extractFunction/controlFlow/outputValues/singleOutputValue.kt

@@ -0,0 +1,9 @@
+// NEXT_SIBLING:
+fun foo(a: Int): Int {
+    var b: Int = 1
+
+    <selection>b += a
+    println(b)</selection>
+
+    return b
+}

idea/testData/refactoring/extractFunction/controlFlow/outputValues/singleOutputValue.kt.after

@@ -0,0 +1,15 @@
+// NEXT_SIBLING:
+fun i(a: Int, b: Int): Int {
+    var b1 = b
+    b1 += a
+    println(b1)
+    return b1
+}
+
+fun foo(a: Int): Int {
+    var b: Int = 1
+
+    b = i(a, b)
+
+    return b
+}

idea/testData/refactoring/extractFunction/controlFlow/outputValues/singleOutputValueWithIf.kt

@@ -0,0 +1,11 @@
+// NEXT_SIBLING:
+fun foo(a: Int): Int {
+    var b: Int = 1
+
+    <selection>if (a > 0) {
+        b = b + 1
+    }
+    println(b)</selection>
+
+    return b
+}

idea/testData/refactoring/extractFunction/controlFlow/outputValues/singleOutputValueWithIf.kt.after

@@ -0,0 +1,17 @@
+// NEXT_SIBLING:
+fun i(a: Int, b: Int): Int {
+    var b1 = b
+    if (a > 0) {
+        b1 = b1 + 1
+    }
+    println(b1)
+    return b1
+}
+
+fun foo(a: Int): Int {
+    var b: Int = 1
+
+    b = i(a, b)
+
+    return b
+}

idea/testData/refactoring/extractFunction/controlFlow/outputValues/singleOutputValueWithIfElse.kt

@@ -0,0 +1,17 @@
+// NEXT_SIBLING:
+fun foo(a: Int): Int {
+    var b: Int = 1
+
+    <selection>if (a > 0) {
+        b = b + 1
+    }
+    else if (a < 0) {
+        b--
+    }
+    else {
+        b = a
+    }
+    println(b)</selection>
+
+    return b
+}

idea/testData/refactoring/extractFunction/controlFlow/outputValues/singleOutputValueWithIfElse.kt.after

@@ -0,0 +1,21 @@
+// NEXT_SIBLING:
+fun i(a: Int, b: Int): Int {
+    var b1 = b
+    if (a > 0) {
+        b1 = b1 + 1
+    } else if (a < 0) {
+        b1--
+    } else {
+        b1 = a
+    }
+    println(b1)
+    return b1
+}
+
+fun foo(a: Int): Int {
+    var b: Int = 1
+
+    b = i(a, b)
+
+    return b
+}

idea/testData/refactoring/extractFunction/controlFlow/outputValues/singleOutputValueWithWhen.kt

@@ -0,0 +1,16 @@
+// NEXT_SIBLING:
+fun foo(a: Int): Int {
+    var b: Int = 1
+
+    <selection> when {
+        a > 0 -> {
+            b = b + 1
+        }
+        a < 0 -> {
+            b = b - 1
+        }
+    }
+    println(b)</selection>
+
+    return b
+}

idea/testData/refactoring/extractFunction/controlFlow/outputValues/singleOutputValueWithWhen.kt.after

@@ -0,0 +1,22 @@
+// NEXT_SIBLING:
+fun i(a: Int, b: Int): Int {
+    var b1 = b
+    when {
+        a > 0 -> {
+            b1 = b1 + 1
+        }
+        a < 0 -> {
+            b1 = b1 - 1
+        }
+    }
+    println(b1)
+    return b1
+}
+
+fun foo(a: Int): Int {
+    var b: Int = 1
+
+    b = i(a, b)
+
+    return b
+}

idea/testData/refactoring/extractFunction/controlFlow/outputValues/singleOutputValueWithWhenElse.kt

@@ -0,0 +1,19 @@
+// NEXT_SIBLING:
+fun foo(a: Int): Int {
+    var b: Int = 1
+
+    <selection> when {
+        a > 0 -> {
+            b = b + 1
+        }
+        a < 0 -> {
+            b = b - 1
+        }
+        else -> {
+            b = a
+        }
+    }
+    println(b)</selection>
+
+    return b
+}

idea/testData/refactoring/extractFunction/controlFlow/outputValues/singleOutputValueWithWhenElse.kt.after

@@ -0,0 +1,25 @@
+// NEXT_SIBLING:
+fun i(a: Int, b: Int): Int {
+    var b1 = b
+    when {
+        a > 0 -> {
+            b1 = b1 + 1
+        }
+        a < 0 -> {
+            b1 = b1 - 1
+        }
+        else -> {
+            b1 = a
+        }
+    }
+    println(b1)
+    return b1
+}
+
+fun foo(a: Int): Int {
+    var b: Int = 1
+
+    b = i(a, b)
+
+    return b
+}

idea/testData/refactoring/extractFunction/controlFlow/unextractable/anonymousObject.kt

@@ -0,0 +1,15 @@
+trait Callable<T> {
+    fun call(): T
+}
+
+fun foo(a: Int): Int {
+    // NEXT_SIBLING:
+    val o = <selection>object: Callable<Int> {
+        val b: Int = 1
+
+        override fun call(): Int {
+            return a + b
+        }
+    }</selection>
+    return o.call()
+}

idea/testData/refactoring/extractFunction/controlFlow/unextractable/anonymousObject.kt.conflicts

@@ -0,0 +1 @@
+Cannot extract method since following types are not denotable in the target scope: foo.<no name provided>

idea/testData/refactoring/extractFunction/controlFlow/unextractable/evalExpressionWithReturn.kt

@@ -0,0 +1,7 @@
+// NEXT_SIBLING:
+fun foo(a: Int): Int {
+    val b: Int = 1
+
+    val t = <selection>if (a > 0) return a else a + b</selection>
+    return t
+}

idea/testData/refactoring/extractFunction/controlFlow/unextractable/evalExpressionWithReturn.kt.conflicts

@@ -0,0 +1 @@
+Selected code fragment has multiple exit points

idea/testData/refactoring/extractFunction/controlFlow/unextractable/evalExpressionWithThrow.kt

@@ -0,0 +1,7 @@
+// NEXT_SIBLING:
+fun foo(a: Int): Int {
+    val b: Int = 1
+
+    val t = <selection>if (a > 0) throw Exception("") else a + b</selection>
+    return t
+}

idea/testData/refactoring/extractFunction/controlFlow/unextractable/evalExpressionWithThrow.kt.conflicts

@@ -0,0 +1 @@
+Selected code fragment has multiple exit points

idea/testData/refactoring/extractFunction/controlFlow/unextractable/jumpsAndReturns.kt

@@ -0,0 +1,11 @@
+// NEXT_SIBLING:
+fun foo(a: Int): Int {
+    val b: Int = 1
+    for (n in 1..a) {
+        <selection>if (a + b > 0) break
+        println(a - b)
+        if (a - b > 0) return 0
+        println(a + b)</selection>
+    }
+    return 1
+}

idea/testData/refactoring/extractFunction/controlFlow/unextractable/jumpsAndReturns.kt.conflicts

@@ -0,0 +1 @@
+Selected code fragment has multiple exit points

idea/testData/refactoring/extractFunction/controlFlow/unextractable/multipleJumps.kt

@@ -0,0 +1,11 @@
+// NEXT_SIBLING:
+fun foo(a: Int): Int {
+    val b: Int = 1
+    for (n in 1..a) {
+        <selection>if (a + b > 0) break
+        println(a - b)
+        if (a - b > 0) continue
+        println(a + b)</selection>
+    }
+    return 1
+}

idea/testData/refactoring/extractFunction/controlFlow/unextractable/multipleJumps.kt.conflicts

@@ -0,0 +1 @@
+Selected code fragment has multiple exit points

idea/testData/refactoring/extractFunction/controlFlow/unextractable/multipleReturnsWithDefault.kt

@@ -0,0 +1,10 @@
+// NEXT_SIBLING:
+fun foo(a: Int): Int {
+    val b: Int = 1
+
+    <selection>if (a > 0) return a
+    if (a < 0) return b
+    </selection>
+
+    return t
+}

idea/testData/refactoring/extractFunction/controlFlow/unextractable/multipleReturnsWithDefault.kt.conflicts

@@ -0,0 +1 @@
+Selected code fragment has multiple exit points

idea/testData/refactoring/extractFunction/controlFlow/unextractable/outputValueWithExpression.kt

@@ -0,0 +1,15 @@
+// NEXT_SIBLING:
+fun foo(a: Int): Int {
+    var b: Int = 1
+
+    val t = <selection>if (a > 0) {
+        b += a
+        b
+    }
+    else {
+        a
+    }</selection>
+    println(b)
+
+    return t
+}

idea/testData/refactoring/extractFunction/controlFlow/unextractable/outputValueWithExpression.kt.conflicts

@@ -0,0 +1 @@
+Selected code fragment has output values as well as alternative exit points

idea/testData/refactoring/extractFunction/controlFlow/unextractable/outputValueWithReturn.kt

@@ -0,0 +1,8 @@
+// NEXT_SIBLING:
+fun foo(a: Int): Int {
+    var b: Int = 1
+
+    <selection>b += a
+    println(b)
+    return b</selection>
+}

idea/testData/refactoring/extractFunction/controlFlow/unextractable/outputValueWithReturn.kt.conflicts

@@ -0,0 +1 @@
+Selected code fragment has output values as well as alternative exit points

idea/testData/refactoring/extractFunction/controlFlow/unextractable/outputValueWithThrow.kt

@@ -0,0 +1,9 @@
+// NEXT_SIBLING:
+fun foo(a: Int): Int {
+    var b: Int = 1
+
+    <selection>if (n == 10) throw Exception("")
+    b++</selection>
+
+    return b
+}

idea/testData/refactoring/extractFunction/controlFlow/unextractable/outputValueWithThrow.kt.conflicts

@@ -0,0 +1 @@
+Selected code fragment has output values as well as alternative exit points

idea/testData/refactoring/extractFunction/controlFlow/unextractable/variablesOutOfScope.kt

@@ -0,0 +1,6 @@
+// NEXT_SIBLING:
+fun foo(t: Int): Int {
+    <selection>val x = t + 1
+    if (x > 0) return x</selection>
+    return 0
+}

idea/testData/refactoring/extractFunction/controlFlow/unextractable/variablesOutOfScope.kt.conflicts

@@ -0,0 +1 @@
+Following declarations won't be available outside of extracted function body: x