Inline refactoring: should remove redundant Unit

#KT-19443 Fixed

idea/testData/refactoring/inline/function/EmptyFunction.kt.after

@@ -2,9 +2,9 @@ fun <T> doIt(p: () -> T): T = TODO()
 
 fun g(p: String?) {
 
-    p?.let { Unit }
+    p?.let { }
 }
 
 fun h() = Unit
 
-fun x() = doIt { Unit }
+fun x() = doIt { }

idea/testData/refactoring/inline/function/NullableUnitReturnType.kt

@@ -0,0 +1,16 @@
+fun <T> doIt(p: () -> T): T = p()
+fun Any.doDo() = Unit
+
+abstract class A {
+    abstract fun a()
+}
+
+fun foo<caret>() {
+    null?.doDo()
+}
+
+class B : A() {
+    override fun a() = doIt {
+        foo()
+    }
+}

idea/testData/refactoring/inline/function/NullableUnitReturnType.kt.after

@@ -0,0 +1,13 @@
+fun <T> doIt(p: () -> T): T = p()
+fun Any.doDo() = Unit
+
+abstract class A {
+    abstract fun a()
+}
+
+class B : A() {
+    override fun a() = doIt {
+        null?.doDo()
+        Unit
+    }
+}

idea/testData/refactoring/inline/function/NullableUnitReturnType2.kt

@@ -0,0 +1,16 @@
+fun <T> doIt(p: () -> T): T = p()
+fun Any.doDo() = Unit
+
+abstract class A {
+    abstract fun a()
+}
+
+fun foo<caret>() {
+    1.let { it.let { it.let { it.let { null?.doDo() } } } }
+}
+
+class B : A() {
+    override fun a() = doIt {
+        foo()
+    }
+}

idea/testData/refactoring/inline/function/NullableUnitReturnType2.kt.after

@@ -0,0 +1,13 @@
+fun <T> doIt(p: () -> T): T = p()
+fun Any.doDo() = Unit
+
+abstract class A {
+    abstract fun a()
+}
+
+class B : A() {
+    override fun a() = doIt {
+        1.let { it.let { it.let { it.let { null?.doDo() } } } }
+        Unit
+    }
+}

idea/testData/refactoring/inline/function/NullableUnitReturnType3.kt

@@ -0,0 +1,14 @@
+fun <T> doIt(p: () -> T): T = p()
+fun Any.doDo() = Unit
+
+abstract class A {
+    abstract fun a()
+}
+
+fun foo<caret>(): Unit = doIt {
+    1.let { it.let { it.let { it.let { null?.doDo() } } } }
+}
+
+class B : A() {
+    override fun a() = foo()
+}

idea/testData/refactoring/inline/function/NullableUnitReturnType3.kt.after

@@ -0,0 +1,12 @@
+fun <T> doIt(p: () -> T): T = p()
+fun Any.doDo() = Unit
+
+abstract class A {
+    abstract fun a()
+}
+
+class B : A() {
+    override fun a() = doIt {
+        1.let<Int, Unit> { it.let { it.let { it.let { null?.doDo() } } } }
+    }
+}

idea/testData/refactoring/inline/function/UnitReturnType.kt.after

@@ -9,7 +9,6 @@ class C {
         p?.let {
             println(3)
             println(4)
-            Unit
         }
 
         if (other != null) {
@@ -26,6 +25,5 @@ class C {
     fun x() = doIt {
         println(9)
         println(10)
-        Unit
     }
 }

idea/testData/refactoring/inline/function/UnitReturnType3.kt

@@ -0,0 +1,12 @@
+class C {
+    fun <caret>f(p1: Int, p2: Int) {
+        println(p1)
+        nonUnit(p2)
+    }
+
+    fun nonUnit(p: Int): Int = p
+
+    fun <T> doIt(p: () -> T): T = TODO()
+
+    fun x() = doIt<Unit> { f(9, 10) }
+}

idea/testData/refactoring/inline/function/UnitReturnType3.kt.after

@@ -0,0 +1,11 @@
+class C {
+
+    fun nonUnit(p: Int): Int = p
+
+    fun <T> doIt(p: () -> T): T = TODO()
+
+    fun x() = doIt<Unit> {
+        println(9)
+        nonUnit(10)
+    }
+}

idea/testData/refactoring/inline/function/UnitReturnType4.kt

@@ -0,0 +1,16 @@
+fun <T> doIt(p: () -> T): T = p()
+fun Any.doDo() = Unit
+
+abstract class A {
+    abstract fun a()
+}
+
+fun foo<caret>() {
+    1.let { it.let { it.let { it.let { it?.doDo() } } } }
+}
+
+class B : A() {
+    override fun a() = doIt {
+        foo()
+    }
+}

idea/testData/refactoring/inline/function/UnitReturnType4.kt.after

@@ -0,0 +1,12 @@
+fun <T> doIt(p: () -> T): T = p()
+fun Any.doDo() = Unit
+
+abstract class A {
+    abstract fun a()
+}
+
+class B : A() {
+    override fun a() = doIt {
+        1.let { it.let { it.let { it.let { it?.doDo() } } } }
+    }
+}