From 63095f9ec9651eb7b7fa7a6138ac042d90173cb7 Mon Sep 17 00:00:00 2001 From: Valentin Kipyatkov Date: Mon, 13 Apr 2020 10:08:54 +0300 Subject: [PATCH] Handling of method references --- .../kotlin/idea/slicer/InflowSlicer.kt | 19 ++++++-- idea/testData/slicer/outflow/letResult.kt | 3 ++ .../slicer/outflow/letResult.results.txt | 45 ++++++++++++------- idea/testData/slicer/outflow/withResult.kt | 3 ++ .../slicer/outflow/withResult.results.txt | 45 ++++++++++++------- 5 files changed, 80 insertions(+), 35 deletions(-) diff --git a/idea/src/org/jetbrains/kotlin/idea/slicer/InflowSlicer.kt b/idea/src/org/jetbrains/kotlin/idea/slicer/InflowSlicer.kt index e53d4144857..918f37ca655 100644 --- a/idea/src/org/jetbrains/kotlin/idea/slicer/InflowSlicer.kt +++ b/idea/src/org/jetbrains/kotlin/idea/slicer/InflowSlicer.kt @@ -233,10 +233,23 @@ class InflowSlicer( val referencedDescriptor = bindingContext[BindingContext.REFERENCE_TARGET, callableRefExpr.callableReference] ?: return val referencedDeclaration = (referencedDescriptor as? DeclarationDescriptorWithSource)?.originalSource?.getPsi() ?: return - if (currentBehaviour is LambdaResultInflowBehaviour) { - referencedDeclaration.passToProcessor(mode.dropBehaviour()) + when (currentBehaviour) { + is LambdaResultInflowBehaviour -> { + referencedDeclaration.passToProcessor(mode.dropBehaviour()) + } + + is LambdaArgumentInflowBehaviour -> { + val parameter = (referencedDeclaration as? KtCallableDeclaration) + ?.valueParameters?.getOrNull(currentBehaviour.argumentIndex) + parameter?.passToProcessor(mode.dropBehaviour()) + } + + is LambdaReceiverInflowBehaviour -> { + val parameter = (referencedDeclaration as? KtCallableDeclaration) + ?.valueParameters?.getOrNull(0) + parameter?.passToProcessor(mode.dropBehaviour()) + } } - //TODO: LambdaArgumentInflowBehaviour } else -> return diff --git a/idea/testData/slicer/outflow/letResult.kt b/idea/testData/slicer/outflow/letResult.kt index 360d6045a19..beb347ab5ea 100644 --- a/idea/testData/slicer/outflow/letResult.kt +++ b/idea/testData/slicer/outflow/letResult.kt @@ -9,9 +9,12 @@ fun foo(p: String) { val it = "a" it } + + val v4 = p.let(::zoo) } fun bar(s: String) = s +fun zoo(s: String) = s inline fun T.let(block: (T) -> R): R { return block(this) diff --git a/idea/testData/slicer/outflow/letResult.results.txt b/idea/testData/slicer/outflow/letResult.results.txt index 37cc8f36c12..8494a2a5929 100644 --- a/idea/testData/slicer/outflow/letResult.results.txt +++ b/idea/testData/slicer/outflow/letResult.results.txt @@ -1,35 +1,48 @@ 3 fun foo(p: String) { 4 val v1 = p.let { value -> bar(value) } -16 (INLINE CALL let) inline fun T.let(block: (T) -> R): R { -17 (INLINE CALL let) return block(this) -16 (INLINE CALL let) [LAMBDA ARGUMENT IN] inline fun T.let(block: (T) -> R): R { +19 (INLINE CALL let) inline fun T.let(block: (T) -> R): R { +20 (INLINE CALL let) return block(this) +19 (INLINE CALL let) [LAMBDA ARGUMENT IN] inline fun T.let(block: (T) -> R): R { 4 [LAMBDA ARGUMENT IN] val v1 = p.let { value -> bar(value) } 4 val v1 = p.let { value -> bar(value) } 4 val v1 = p.let { value -> bar(value) } -14 fun bar(s: String) = s -14 fun bar(s: String) = s -14 fun bar(s: String) = s +16 fun bar(s: String) = s +16 fun bar(s: String) = s +16 fun bar(s: String) = s 4 val v1 = p.let { value -> bar(value) } 4 val v1 = p.let { value -> bar(value) } 4 [LAMBDA CALLS] val v1 = p.let { value -> bar(value) } -16 (INLINE CALL let) [LAMBDA CALLS] inline fun T.let(block: (T) -> R): R { -17 (INLINE CALL let) return block(this) +19 (INLINE CALL let) [LAMBDA CALLS] inline fun T.let(block: (T) -> R): R { +20 (INLINE CALL let) return block(this) 4 val v1 = p.let { value -> bar(value) } 4 val v1 = p.let { value -> bar(value) } 6 val v2 = p.let { it } -16 (INLINE CALL let) inline fun T.let(block: (T) -> R): R { -17 (INLINE CALL let) return block(this) -16 (INLINE CALL let) [LAMBDA ARGUMENT IN] inline fun T.let(block: (T) -> R): R { +19 (INLINE CALL let) inline fun T.let(block: (T) -> R): R { +20 (INLINE CALL let) return block(this) +19 (INLINE CALL let) [LAMBDA ARGUMENT IN] inline fun T.let(block: (T) -> R): R { 6 [LAMBDA ARGUMENT IN] val v2 = p.let { it } 6 val v2 = p.let { it } 6 val v2 = p.let { it } 6 [LAMBDA CALLS] val v2 = p.let { it } -16 (INLINE CALL let) [LAMBDA CALLS] inline fun T.let(block: (T) -> R): R { -17 (INLINE CALL let) return block(this) +19 (INLINE CALL let) [LAMBDA CALLS] inline fun T.let(block: (T) -> R): R { +20 (INLINE CALL let) return block(this) 6 val v2 = p.let { it } 6 val v2 = p.let { it } 8 val v3 = p.let { -16 (INLINE CALL let) inline fun T.let(block: (T) -> R): R { -17 (INLINE CALL let) return block(this) -16 (INLINE CALL let) [LAMBDA ARGUMENT IN] inline fun T.let(block: (T) -> R): R { +19 (INLINE CALL let) inline fun T.let(block: (T) -> R): R { +20 (INLINE CALL let) return block(this) +19 (INLINE CALL let) [LAMBDA ARGUMENT IN] inline fun T.let(block: (T) -> R): R { 8 [LAMBDA ARGUMENT IN] val v3 = p.let { +13 val v4 = p.let(::zoo) +19 (INLINE CALL let) inline fun T.let(block: (T) -> R): R { +20 (INLINE CALL let) return block(this) +19 (INLINE CALL let) [LAMBDA ARGUMENT IN] inline fun T.let(block: (T) -> R): R { +13 [LAMBDA ARGUMENT IN] val v4 = p.let(::zoo) +17 fun zoo(s: String) = s +17 fun zoo(s: String) = s +17 fun zoo(s: String) = s +13 [LAMBDA CALLS] val v4 = p.let(::zoo) +19 (INLINE CALL let) [LAMBDA CALLS] inline fun T.let(block: (T) -> R): R { +20 (INLINE CALL let) return block(this) +13 val v4 = p.let(::zoo) +13 val v4 = p.let(::zoo) diff --git a/idea/testData/slicer/outflow/withResult.kt b/idea/testData/slicer/outflow/withResult.kt index 573cdf4dd0d..7c682e9d61e 100644 --- a/idea/testData/slicer/outflow/withResult.kt +++ b/idea/testData/slicer/outflow/withResult.kt @@ -6,9 +6,12 @@ fun String.foo(p: String) { val v2 = with(p) { bar(this) } val v3 = with(p) { this@foo } + + val v4 = with(p, ::zoo) } fun bar(s: String) = s +fun zoo(s: String) = s inline fun with(receiver: T, block: T.() -> R): R { return receiver.block() diff --git a/idea/testData/slicer/outflow/withResult.results.txt b/idea/testData/slicer/outflow/withResult.results.txt index 76b1c366dc1..002a6421182 100644 --- a/idea/testData/slicer/outflow/withResult.results.txt +++ b/idea/testData/slicer/outflow/withResult.results.txt @@ -1,34 +1,47 @@ 3 fun String.foo(p: String) { 4 val v1 = with(p) { this } -13 (INLINE CALL with) inline fun with(receiver: T, block: T.() -> R): R { -14 (INLINE CALL with) return receiver.block() -13 (INLINE CALL with) [LAMBDA RECEIVER IN] inline fun with(receiver: T, block: T.() -> R): R { +16 (INLINE CALL with) inline fun with(receiver: T, block: T.() -> R): R { +17 (INLINE CALL with) return receiver.block() +16 (INLINE CALL with) [LAMBDA RECEIVER IN] inline fun with(receiver: T, block: T.() -> R): R { 4 [LAMBDA RECEIVER IN] val v1 = with(p) { this } 4 val v1 = with(p) { this } 4 val v1 = with(p) { this } 4 [LAMBDA CALLS] val v1 = with(p) { this } -13 (INLINE CALL with) [LAMBDA CALLS] inline fun with(receiver: T, block: T.() -> R): R { -14 (INLINE CALL with) return receiver.block() +16 (INLINE CALL with) [LAMBDA CALLS] inline fun with(receiver: T, block: T.() -> R): R { +17 (INLINE CALL with) return receiver.block() 4 val v1 = with(p) { this } 4 val v1 = with(p) { this } 6 val v2 = with(p) { bar(this) } -13 (INLINE CALL with) inline fun with(receiver: T, block: T.() -> R): R { -14 (INLINE CALL with) return receiver.block() -13 (INLINE CALL with) [LAMBDA RECEIVER IN] inline fun with(receiver: T, block: T.() -> R): R { +16 (INLINE CALL with) inline fun with(receiver: T, block: T.() -> R): R { +17 (INLINE CALL with) return receiver.block() +16 (INLINE CALL with) [LAMBDA RECEIVER IN] inline fun with(receiver: T, block: T.() -> R): R { 6 [LAMBDA RECEIVER IN] val v2 = with(p) { bar(this) } 6 val v2 = with(p) { bar(this) } -11 fun bar(s: String) = s -11 fun bar(s: String) = s -11 fun bar(s: String) = s +13 fun bar(s: String) = s +13 fun bar(s: String) = s +13 fun bar(s: String) = s 6 val v2 = with(p) { bar(this) } 6 val v2 = with(p) { bar(this) } 6 [LAMBDA CALLS] val v2 = with(p) { bar(this) } -13 (INLINE CALL with) [LAMBDA CALLS] inline fun with(receiver: T, block: T.() -> R): R { -14 (INLINE CALL with) return receiver.block() +16 (INLINE CALL with) [LAMBDA CALLS] inline fun with(receiver: T, block: T.() -> R): R { +17 (INLINE CALL with) return receiver.block() 6 val v2 = with(p) { bar(this) } 6 val v2 = with(p) { bar(this) } 8 val v3 = with(p) { this@foo } -13 (INLINE CALL with) inline fun with(receiver: T, block: T.() -> R): R { -14 (INLINE CALL with) return receiver.block() -13 (INLINE CALL with) [LAMBDA RECEIVER IN] inline fun with(receiver: T, block: T.() -> R): R { +16 (INLINE CALL with) inline fun with(receiver: T, block: T.() -> R): R { +17 (INLINE CALL with) return receiver.block() +16 (INLINE CALL with) [LAMBDA RECEIVER IN] inline fun with(receiver: T, block: T.() -> R): R { 8 [LAMBDA RECEIVER IN] val v3 = with(p) { this@foo } +10 val v4 = with(p, ::zoo) +16 (INLINE CALL with) inline fun with(receiver: T, block: T.() -> R): R { +17 (INLINE CALL with) return receiver.block() +16 (INLINE CALL with) [LAMBDA RECEIVER IN] inline fun with(receiver: T, block: T.() -> R): R { +10 [LAMBDA RECEIVER IN] val v4 = with(p, ::zoo) +14 fun zoo(s: String) = s +14 fun zoo(s: String) = s +14 fun zoo(s: String) = s +10 [LAMBDA CALLS] val v4 = with(p, ::zoo) +16 (INLINE CALL with) [LAMBDA CALLS] inline fun with(receiver: T, block: T.() -> R): R { +17 (INLINE CALL with) return receiver.block() +10 val v4 = with(p, ::zoo) +10 val v4 = with(p, ::zoo)