KT-38027 Support Code Vision feature in Kotlin

2020-04-30 11:58:50 +02:00
parent 4c8f9e4e06
commit b08f501aac
30 changed files with 2531 additions and 3 deletions
@@ -0,0 +1,17 @@
+// MODE: inheritors
+
+<# block [ 2 Inheritors] #>
+abstract class SomeClass {
+<# block [     1 Override] #>
+    open fun someFun() = ""
+<# block [     2 Implementations] #>
+    abstract fun someAbstractFun()
+}
+
+class DerivedClassA : SomeClass {
+    override fun someFun() = "overridden"
+    override fun someAbstractFun() = "overridden"
+}
+class DerivedClassB : SomeClass {
+    override fun someAbstractFun() = "overridden"
+}
@@ -0,0 +1,16 @@
+// MODE: inheritors
+
+<# block [ 4 Inheritors] #>
+open class SomeClass {
+    class NestedDerivedClass: SomeClass() {} // <== (1): nested class
+}
+<# block [ 1 Inheritor] #>
+open class DerivedClass : SomeClass {} // <== (2): direct derived one
+class AnotherDerivedClass : SomeClass {} // <== (3): yet another derived one
+class DerivedDerivedClass : DerivedClass { // <== (): indirect inheritor of SomeClass
+    fun main() {
+        val someClassInstance = object : SomeClass() { // <== (4): anonymous derived one
+            val somethingHere = ""
+        }
+    }
+}
@@ -0,0 +1,17 @@
+// MODE: usages
+
+<# block [ 1 Usage] #>
+abstract class SomeClass {
+<# block [     3 Usages] #>
+    abstract fun someFun(): String
+    fun someOtherFun() = someFun() // <== (1): delegation from another method
+    val someProperty = someFun() // <== (2): property initializer
+}
+
+fun main() {
+    val instance = object: SomeClass {
+<# block [         1 Usage] #>
+        override fun someFun(): String {} // <== (): used below
+    }
+    instance.someFun() <== (3): call on an instance
+}
@@ -0,0 +1,23 @@
+// MODE: inheritors
+
+<# block [ 1 Inheritor] #>
+abstract class SomeClass {
+<# block [     1 Override] #>
+    abstract val someAbstractProperty: Int
+<# block [     2 Overrides] #>
+    open val nonAbstractProperty: Int = 10
+    open val notToBeOverriddenProperty: Int = 10
+}
+
+<# block [ 1 Inheritor] #>
+open class DerivedClassA : SomeClass() {
+    override val someAbstractProperty: Int = 5
+<# block [     1 Override] #>
+    override val nonAbstractProperty: Int = 15 // NOTE that DerivedClassB overrides both getter and setter but counted once
+}
+
+class DerivedClassB : DerivedClassA() {
+    override var nonAbstractProperty: Int = 15
+        get() = 20
+        set(value) {field = value / 2}
+}
@@ -0,0 +1,13 @@
+// MODE: usages
+
+<# block [ 1 Usage] #>
+interface SomeClass {
+<# block [     3 Usages] #>
+    var someProperty = "initialized"
+    fun someFun() = "it's " + someProperty // <== (1): reference from expression
+}
+
+fun main() {
+    val instance = object: SomeClass {}
+    val someString = instance.someProperty // <== (2): getter call
+    instance.someProperty = "anotherValue" // <== (3): setter call
@@ -0,0 +1,11 @@
+// MODE: usages
+
+<# block [ 5 Usages] #>
+open class SomeClass {}
+class SomeOtherClass : SomeClass {} // <== (1): class extension
+class SomeYetOtherClass : SomeClass { // <== (2): class extension
+<# block [     1 Usage] #>
+    fun acceptsClass(param: SomeClass) {} // <== (3): parameter type
+    fun returnsInterface(): SomeClass {} // <== (4): return type
+    fun main() = acceptsClass(object : SomeClass {}) // <== (5): anonymous class instance
+}
@@ -0,0 +1,12 @@
+// MODE: usages
+
+<# block [ 3 Usages] #>
+fun function(param: String): Int = 1
+<# block [ 1 Usage] #>
+fun higherOrderFun(s: String, param: (String) -> Int) = param(s)
+
+fun main() {
+    function("someString")
+    val functionRef = ::function
+    higherOrderFun("someString", ::function)
+}
@@ -0,0 +1,16 @@
+// MODE: inheritors
+
+<# block [ 1 Implementation] #>
+interface SomeInterface {
+<# block [     2 Implementations] #>
+    fun interfaceMethodA()
+}
+<# block [ 1 Inheritor] #>
+open class SomeClass : SomeInterface {
+<# block [     1 Override] #>
+    override fun interfaceMethodA() {} // <== (1)
+}
+
+class SomeDerivedClass : SomeClass() {
+    override fun interfaceMethodA() {} // <== (2)
+}
@@ -0,0 +1,9 @@
+// MODE: inheritors
+
+<# block [ 3 Implementations] #>
+interface SomeInterface {}
+interface SomeOtherInterface : SomeInterface {} // <== (1): interface extension
+class SomeClass : SomeInterface { // <== (2): interface implementation
+    fun acceptsInterface(param: SomeInterface) {}
+    fun main() = acceptsInterface(object : SomeInterface {}) // <== (3): anonymous class instance
+}
@@ -0,0 +1,17 @@
+// MODE: usages
+
+<# block [ 1 Usage] #>
+interface SomeInterface {
+<# block [     3 Usages] #>
+    fun someFun(): String
+    fun someOtherFun() = someFun() // <== (1): delegation from another interface method
+    val someProperty = someFun() // <== (2): property initializer
+}
+
+fun main() {
+    val instance = object: SomeInterface {
+<# block [         1 Usage] #>
+        override fun someFun(): String {} // <== (): used below
+    }
+    instance.someFun() <== (3): call on an instance
+}
@@ -0,0 +1,11 @@
+// MODE: inheritors
+
+<# block [ 1 Implementation] #>
+interface SomeInterface {
+<# block [     1 Override] #>
+    fun interfaceMethodA() = 10
+}
+
+class SomeClass : SomeInterface {
+    override fun interfaceMethodA() = 20 // <== (1)
+}
@@ -0,0 +1,11 @@
+// MODE: inheritors
+
+<# block [ 1 Implementation] #>
+interface SomeInterface {
+<# block [     1 Override] #>
+    open val interfaceProperty: String
+}
+
+class SomeClass : SomeInterface {
+    override val interfaceProperty: String = "overridden" // <== (1)
+}
@@ -0,0 +1,12 @@
+// MODE: usages
+
+<# block [ 1 Usage] #>
+interface SomeInterface {
+<# block [     2 Usages] #>
+    val someProperty = "initialized"
+    fun someFun() = "it's " + someProperty // <== (1):
+}
+
+fun main() {
+    val instance = object: SomeInterface {}
+    val someString = instance.someProperty // <== (2): call on an instance
@@ -0,0 +1,11 @@
+// MODE: usages
+
+<# block [ 5 Usages] #>
+interface SomeInterface {}
+interface SomeOtherInterface : SomeInterface {} // <== (1): interface extension
+class SomeClass : SomeInterface { // <== (2): interface implementation
+<# block [     1 Usage] #>
+    fun acceptsInterface(param: SomeInterface) {} // <== (3): parameter type
+    fun returnsInterface(): SomeInterface {} // <== (4): return type
+    fun main() = acceptsInterface(object : SomeInterface {}) // <== (5): anonymous class instance
+}
@@ -0,0 +1,18 @@
+// MODE: usages-&-inheritors
+// USAGES-LIMIT: 3
+// INHERITORS-LIMIT: 2
+
+<# block [ 3+ Usages   2+ Inheritors] #>
+open class SomeClass {
+    class NestedDerivedClass: SomeClass() {} // <== (1): nested class
+}
+<# block [ 1 Usage   1 Inheritor] #>
+open class DerivedClass : SomeClass {} // <== (2): direct derived one
+class AnotherDerivedClass : SomeClass {} // <== (3): yet another derived one
+class DerivedDerivedClass : DerivedClass { // <== (): indirect inheritor of SomeClass
+    fun main() {
+        val someClassInstance = object : SomeClass() // { <== (4): anonymous derived one
+            val somethingHere = ""
+        }
+    }
+}
@@ -0,0 +1,16 @@
+// MODE: usages-&-inheritors
+
+<# block [ 4 Usages   4 Inheritors] #>
+open class SomeClass {
+    class NestedDerivedClass: SomeClass() {} // <== (1): nested class
+}
+<# block [ 1 Usage   1 Inheritor] #>
+open class DerivedClass : SomeClass {} // <== (2): direct derived one
+class AnotherDerivedClass : SomeClass {} // <== (3): yet another derived one
+class DerivedDerivedClass : DerivedClass { // <== (): indirect inheritor of SomeClass
+    fun main() {
+        val someClassInstance = object : SomeClass() { // <== (4): anonymous derived one
+            val somethingHere = ""
+        }
+    }
+}