Stepping: skip methods deleting to static method call of DefaultImpl.

Support smart step into interface methods with implementation
 #KT-4803 Fixed

idea/testData/debugger/tinyApp/src/forTests/MyJavaClass.java

@@ -11,4 +11,8 @@ public class MyJavaClass {
     public String testNotNullFun() {
        return "a";
     }
+
+    public static int staticFun(Object s) {
+        return 1;
+    }
 }

idea/testData/debugger/tinyApp/src/stepping/custom/smartStepIntoInterfaceImpl.kt

@@ -0,0 +1,155 @@
+package smartStepIntoInterfaceImpl
+
+import forTests.MyJavaClass
+
+interface I {
+    // without params
+    fun foo() {
+        val a = 1
+    }
+
+    // default param
+    fun foo(a: Int, b: Int = 1) {
+        val a = 1
+    }
+
+    // checkParamNotNull
+    fun foo(a: String) {
+        val a = 1
+    }
+
+    fun fooOverride() {
+        val a = 1
+    }
+
+    fun staticCallInOverride(s: String) = 1
+}
+
+class IImpl: I {
+    // super call in override (step into doesn't work)
+    override fun fooOverride() {
+        return super.fooOverride()
+    }
+
+    // java static call
+    fun staticCall(s: String): Int {
+        return MyJavaClass.staticFun(s)
+    }
+
+    // java static call in override
+    override fun staticCallInOverride(s: String): Int {
+        return MyJavaClass.staticFun(s)
+    }
+}
+
+class IImpl2: I {
+    // java static call in override with this param (step into doesn't work)
+    override fun staticCallInOverride(s: String): Int {
+        return MyJavaClass.staticFun(this)
+    }
+}
+
+object Obj: I {
+    @JvmStatic private fun staticFun(s: String): Int  {
+        return 1
+    }
+
+    // kotlin static call
+    fun staticCall(s: String): Int {
+        return staticFun(s)
+    }
+
+    // kotlin static call in override
+    override fun staticCallInOverride(s: String): Int {
+        return staticFun(s)
+    }
+}
+
+object Obj2: I {
+    @JvmStatic private fun staticFun(s: Obj2): Int  {
+        return 1
+    }
+
+    // kotlin static call in override with this param (step into doesn't work)
+    override fun staticCallInOverride(s: String): Int {
+        return staticFun(this)
+    }
+}
+
+fun barI() = IImpl()
+
+fun main(args: Array<String>) {
+    testSmartStepInto()
+    testStepInto()
+}
+
+fun testSmartStepInto() {
+    // TODO First time - doesn't work: should be smartStepIntoInterfaceImpl.kt:8 between smartStepIntoInterfaceImpl.kt:90 and 95
+    // SMART_STEP_INTO_BY_INDEX: 2
+    //Breakpoint!
+    barI().foo()
+
+    // SMART_STEP_INTO_BY_INDEX: 2
+    // RESUME: 1
+    //Breakpoint!
+    barI().foo()
+
+    // SMART_STEP_INTO_BY_INDEX: 2
+    // RESUME: 1
+    //Breakpoint!
+    barI().foo(1)
+
+    // SMART_STEP_INTO_BY_INDEX: 2
+    // RESUME: 1
+    //Breakpoint!
+    barI().foo(1, 2)
+
+    // SMART_STEP_INTO_BY_INDEX: 2
+    // RESUME: 1
+    //Breakpoint!
+    barI().foo("a")
+}
+
+fun testStepInto() {
+    val ii = IImpl()
+
+    // TODO: should be smartStepIntoInterfaceImpl.kt:31 instead of smartStepIntoInterfaceImpl.kt:22
+    // STEP_INTO: 1
+    // RESUME: 1
+    //Breakpoint!
+    ii.fooOverride()
+
+    // STEP_INTO: 1
+    // RESUME: 1
+    //Breakpoint!
+    ii.staticCall("a")
+
+    // STEP_INTO: 1
+    // RESUME: 1
+    //Breakpoint!
+    ii.staticCallInOverride("a")
+
+    val ii2 = IImpl2()
+
+    // TODO: should be smartStepIntoInterfaceImpl.kt:48 instead of MyJavaClass.java:16
+    // STEP_INTO: 1
+    // RESUME: 1
+    //Breakpoint!
+    ii2.staticCallInOverride("a")
+
+    // STEP_INTO: 1
+    // RESUME: 1
+    //Breakpoint!
+    Obj.staticCall("a")
+
+    // STEP_INTO: 1
+    // RESUME: 1
+    //Breakpoint!
+    Obj.staticCallInOverride("a")
+
+    // TODO: should be smartStepIntoInterfaceImpl.kt:75 instead of smartStepIntoInterfaceImpl.kt:70
+    // STEP_INTO: 1
+    // RESUME: 1
+    //Breakpoint!
+    Obj2.staticCallInOverride("a")
+}

idea/testData/debugger/tinyApp/src/stepping/custom/syntheticProvider.kt

@@ -0,0 +1,59 @@
+package syntheticProvider
+
+interface I {
+    fun manyInts(i: Int, i2: Int, i3: Int, i4: Int): Int {
+        return i
+    }
+
+    fun manyLongs(i: Long, i2: Long, i3: Long, i4: Long): Long {
+        return i
+    }
+
+    fun manyDouble(i: Double, i2: Double, i3: Double, i4: Double): Double {
+        return i
+    }
+
+    fun manyFloat(i: Float, i2: Float, i3: Float, i4: Float): Float {
+        return i
+    }
+
+    fun manyObject(i: Any, i2: Any, i3: Any, i4: Any): Any {
+        return i
+    }
+
+    fun void() {
+        val a = 1
+    }
+}
+
+class IImpl: I
+
+fun main(args: Array<String>) {
+    val i = IImpl()
+    i.manyInts(1, 1, 1, 1)
+
+    // STEP_INTO: 1
+    // RESUME: 1
+    //Breakpoint!
+    i.manyInts(1, 1, 1, 1)
+    // STEP_INTO: 1
+    // RESUME: 1
+    //Breakpoint!
+    i.manyLongs(1, 1, 1, 1)
+    // STEP_INTO: 1
+    // RESUME: 1
+    //Breakpoint!
+    i.manyDouble(1.0, 1.0, 1.0, 1.0)
+    // STEP_INTO: 1
+    // RESUME: 1
+    //Breakpoint!
+    i.manyFloat(1.0f, 1.0f, 1.0f, 1.0f)
+    // STEP_INTO: 1
+    // RESUME: 1
+    //Breakpoint!
+    i.manyObject(1, 1, 1, 1)
+    // STEP_INTO: 1
+    // RESUME: 1
+    //Breakpoint!
+    i.void()
+}

idea/testData/debugger/tinyApp/src/stepping/stepInto/traits.kt

@@ -10,11 +10,11 @@ fun main(args: Array<String>) {
 
     val o = object: MyInterface {
         override fun inInterfaceOverride(): Int {
-            return super.inInterfaceOverride()
+            return 1
         }
 
         override val propInInterfaceOverride: Int
-            get() = super.propInInterfaceOverride
+            get() = 1
     }
     o.inInterface()
     o.propInInterface