Extract Function: Add test data

idea/testData/refactoring/extractFunction/basic/malformedExpression.kt

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

idea/testData/refactoring/extractFunction/basic/malformedExpression.kt.conflicts

@@ -0,0 +1 @@
+Cannot perform refactoring without an expression

idea/testData/refactoring/extractFunction/basic/malformedStatements.kt

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

idea/testData/refactoring/extractFunction/basic/malformedStatements.kt.conflicts

@@ -0,0 +1 @@
+Cannot perform refactoring without an expression

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

idea/testData/refactoring/extractFunction/parameters/extractSuper/labeledSuperPropertyCall.kt

@@ -0,0 +1,12 @@
+public open class Z {
+    val z: Int = 0
+}
+
+// NEXT_SIBLING:
+public class A(): Z() {
+    var a: Int = 1
+
+    fun foo(): Int {
+        <selection>return a + super<Z>@A.z</selection>
+    }
+}

idea/testData/refactoring/extractFunction/parameters/extractSuper/labeledSuperPropertyCall.kt.conflicts

@@ -0,0 +1 @@
+Cannot extract super-call

idea/testData/refactoring/extractFunction/parameters/extractSuper/superFunctionCall.kt

@@ -0,0 +1,15 @@
+public open class Z {
+    fun zzz() {
+
+    }
+}
+
+// NEXT_SIBLING:
+public class A(): Z() {
+    var a: Int = 1
+
+    fun foo(): Int {
+        <selection>super.zzz()
+        return a + 1</selection>
+    }
+}

idea/testData/refactoring/extractFunction/parameters/extractSuper/superFunctionCall.kt.conflicts

@@ -0,0 +1 @@
+Cannot extract super-call

idea/testData/refactoring/extractFunction/parameters/extractSuper/superLabeledFunctionCall.kt

@@ -0,0 +1,15 @@
+public open class Z {
+    fun zzz() {
+
+    }
+}
+
+// NEXT_SIBLING:
+public class A(): Z() {
+    var a: Int = 1
+
+    fun foo(): Int {
+        <selection>super@A.zzz()
+        return a + 1</selection>
+    }
+}

idea/testData/refactoring/extractFunction/parameters/extractSuper/superLabeledFunctionCall.kt.conflicts

@@ -0,0 +1 @@
+Cannot extract super-call

idea/testData/refactoring/extractFunction/parameters/extractSuper/superPropertyCall.kt

@@ -0,0 +1,12 @@
+public open class Z {
+    val z: Int = 0
+}
+
+// NEXT_SIBLING:
+public class A(): Z() {
+    var a: Int = 1
+
+    fun foo(): Int {
+        <selection>return a + super.z</selection>
+    }
+}

idea/testData/refactoring/extractFunction/parameters/extractSuper/superPropertyCall.kt.conflicts

@@ -0,0 +1 @@
+Cannot extract super-call

idea/testData/refactoring/extractFunction/parameters/extractThis/explicitLabeledThisInMember.kt

@@ -0,0 +1,16 @@
+public open class Z {
+    val z: Int = 0
+}
+
+// NEXT_SIBLING:
+public class A(): Z() {
+    var a: Int = 1
+
+    public inner class B(): Z() {
+        var b: Int = 1
+
+        fun foo(): Int {
+            return <selection>this@A.a + this@B.b + this@A.z + this@B.z</selection>
+        }
+    }
+}

idea/testData/refactoring/extractFunction/parameters/extractThis/explicitLabeledThisInMember.kt.after

@@ -0,0 +1,20 @@
+public open class Z {
+    val z: Int = 0
+}
+
+// NEXT_SIBLING:
+fun i(a1: A, b1: A.B): Int {
+    return a1.a + b1.b + a1.z + b1.z
+}
+
+public class A(): Z() {
+    var a: Int = 1
+
+    public inner class B(): Z() {
+        var b: Int = 1
+
+        fun foo(): Int {
+            return i(this@A, this@B)
+        }
+    }
+}

idea/testData/refactoring/extractFunction/parameters/extractThis/explicitThisInExtension.kt

@@ -0,0 +1,6 @@
+class Z(val a: Int)
+
+// NEXT_SIBLING:
+fun Z.foo(): Int {
+    return <selection>this.a</selection> + 1
+}

idea/testData/refactoring/extractFunction/parameters/extractThis/explicitThisInExtension.kt.after

@@ -0,0 +1,10 @@
+class Z(val a: Int)
+
+// NEXT_SIBLING:
+fun Z.i(): Int {
+    return a
+}
+
+fun Z.foo(): Int {
+    return i() + 1
+}

idea/testData/refactoring/extractFunction/parameters/extractThis/explicitThisInMember.kt

@@ -0,0 +1,16 @@
+public open class Z {
+    val z: Int = 0
+}
+
+// NEXT_SIBLING:
+public class A(): Z() {
+    var a: Int = 1
+
+    public inner class B(): Z() {
+        var b: Int = 1
+
+        fun foo(): Int {
+            return <selection>a + this.b + this.z</selection>
+        }
+    }
+}

idea/testData/refactoring/extractFunction/parameters/extractThis/explicitThisInMember.kt.after

@@ -0,0 +1,20 @@
+public open class Z {
+    val z: Int = 0
+}
+
+// NEXT_SIBLING:
+fun i(a1: A, b1: A.B): Int {
+    return a1.a + b1.b + b1.z
+}
+
+public class A(): Z() {
+    var a: Int = 1
+
+    public inner class B(): Z() {
+        var b: Int = 1
+
+        fun foo(): Int {
+            return i(this@A, this)
+        }
+    }
+}

idea/testData/refactoring/extractFunction/parameters/extractThis/implicitAndExplicitLabeledThisInMember.kt

@@ -0,0 +1,16 @@
+public open class Z {
+    val z: Int = 0
+}
+
+// NEXT_SIBLING:
+public class A(): Z() {
+    var a: Int = 1
+
+    public inner class B(): Z() {
+        var b: Int = 1
+
+        fun foo(): Int {
+            return <selection>a + b + this@A.z + this@B.z</selection>
+        }
+    }
+}

idea/testData/refactoring/extractFunction/parameters/extractThis/implicitAndExplicitLabeledThisInMember.kt.after

@@ -0,0 +1,20 @@
+public open class Z {
+    val z: Int = 0
+}
+
+// NEXT_SIBLING:
+fun i(a1: A, b1: A.B): Int {
+    return a1.a + b1.b + a1.z + b1.z
+}
+
+public class A(): Z() {
+    var a: Int = 1
+
+    public inner class B(): Z() {
+        var b: Int = 1
+
+        fun foo(): Int {
+            return i(this@A, this@B)
+        }
+    }
+}

idea/testData/refactoring/extractFunction/parameters/extractThis/implicitAndExplicitThisInExtension.kt

@@ -0,0 +1,6 @@
+class Z(val a: Int)
+
+// NEXT_SIBLING:
+fun Z.foo(): Int {
+    return <selection>this.a + a</selection> + 1
+}

idea/testData/refactoring/extractFunction/parameters/extractThis/implicitAndExplicitThisInExtension.kt.after

@@ -0,0 +1,10 @@
+class Z(val a: Int)
+
+// NEXT_SIBLING:
+fun Z.i(): Int {
+    return a + a
+}
+
+fun Z.foo(): Int {
+    return i() + 1
+}

idea/testData/refactoring/extractFunction/parameters/extractThis/implicitThisInExtension.kt

@@ -0,0 +1,6 @@
+class Z(val a: Int)
+
+// NEXT_SIBLING:
+fun Z.foo(): Int {
+    return <selection>a</selection> + 1
+}

idea/testData/refactoring/extractFunction/parameters/extractThis/implicitThisInExtension.kt.after

@@ -0,0 +1,10 @@
+class Z(val a: Int)
+
+// NEXT_SIBLING:
+fun Z.i(): Int {
+    return a
+}
+
+fun Z.foo(): Int {
+    return i() + 1
+}

idea/testData/refactoring/extractFunction/parameters/extractThis/implicitThisInMember.kt

@@ -0,0 +1,16 @@
+public open class Z {
+    val z: Int = 0
+}
+
+// NEXT_SIBLING:
+public class A(): Z() {
+    var a: Int = 1
+
+    public inner class B(): Z() {
+        var b: Int = 1
+
+        fun foo(): Int {
+            return <selection>a + b + z</selection>
+        }
+    }
+}

idea/testData/refactoring/extractFunction/parameters/extractThis/implicitThisInMember.kt.after

@@ -0,0 +1,20 @@
+public open class Z {
+    val z: Int = 0
+}
+
+// NEXT_SIBLING:
+fun i(a1: A, b1: A.B): Int {
+    return a1.a + b1.b + b1.z
+}
+
+public class A(): Z() {
+    var a: Int = 1
+
+    public inner class B(): Z() {
+        var b: Int = 1
+
+        fun foo(): Int {
+            return i(this@A, this@B)
+        }
+    }
+}

idea/testData/refactoring/extractFunction/parameters/misc/classObject.kt

@@ -0,0 +1,15 @@
+// NEXT_SIBLING:
+class MyClass {
+    fun test(): Int {
+        <selection>coFun()
+        return coProp + 10</selection>
+    }
+
+    class object {
+        val coProp = 1
+
+        fun coFun() {
+
+        }
+    }
+}

idea/testData/refactoring/extractFunction/parameters/misc/classObject.kt.after

@@ -0,0 +1,19 @@
+// NEXT_SIBLING:
+fun i(): Int {
+    MyClass.coFun()
+    return MyClass.coProp + 10
+}
+
+class MyClass {
+    fun test(): Int {
+        return i()
+    }
+
+    class object {
+        val coProp = 1
+
+        fun coFun() {
+
+        }
+    }
+}

idea/testData/refactoring/extractFunction/parameters/misc/innerClassObject.kt

@@ -0,0 +1,19 @@
+// NEXT_SIBLING:
+class A {
+    class B {
+        fun test(): Int {
+            <selection>coFun()
+            return coProp + 10</selection>
+        }
+
+        class object {
+            val coProp = 1
+
+            fun coFun() {
+
+            }
+        }
+    }
+}
+
+

idea/testData/refactoring/extractFunction/parameters/misc/innerClassObject.kt.after

@@ -0,0 +1,23 @@
+// NEXT_SIBLING:
+fun i(): Int {
+    A.B.coFun()
+    return A.B.coProp + 10
+}
+
+class A {
+    class B {
+        fun test(): Int {
+            return i()
+        }
+
+        class object {
+            val coProp = 1
+
+            fun coFun() {
+
+            }
+        }
+    }
+}
+
+