From dd30462fd1b07068c7bd3f9115e43e7611c2ce08 Mon Sep 17 00:00:00 2001 From: Natalia Ukhorskaya Date: Fri, 23 Oct 2015 11:59:33 +0300 Subject: [PATCH] Support smart step into for inline function arguments --- .../stepping/KotlinLambdaMethodFilter.kt | 59 ++++++++++--------- .../KotlinLambdaSmartStepIntoTarget.kt | 14 ++--- .../stepping/KotlinSmartStepIntoHandler.kt | 31 +++++++--- .../stepping/KotlinSteppingCommandProvider.kt | 10 ++-- .../smartStepInto/inlinedFunLiteral.kt | 2 +- .../inlinedFunctionalExpression.kt | 7 +++ .../outs/smartStepIntoInlinedFunLiteral.out | 13 ++++ ...artStepIntoInlinedFunctionalExpression.out | 13 ++++ .../custom/smartStepIntoInlinedFunLiteral.kt | 45 ++++++++++++++ ...martStepIntoInlinedFunctionalExpression.kt | 45 ++++++++++++++ .../idea/debugger/KotlinDebuggerTestBase.kt | 15 +++-- .../debugger/KotlinSteppingTestGenerated.java | 12 ++++ .../debugger/SmartStepIntoTestGenerated.java | 6 ++ 13 files changed, 213 insertions(+), 59 deletions(-) create mode 100644 idea/testData/debugger/smartStepInto/inlinedFunctionalExpression.kt create mode 100644 idea/testData/debugger/tinyApp/outs/smartStepIntoInlinedFunLiteral.out create mode 100644 idea/testData/debugger/tinyApp/outs/smartStepIntoInlinedFunctionalExpression.out create mode 100644 idea/testData/debugger/tinyApp/src/stepping/custom/smartStepIntoInlinedFunLiteral.kt create mode 100644 idea/testData/debugger/tinyApp/src/stepping/custom/smartStepIntoInlinedFunctionalExpression.kt diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinLambdaMethodFilter.kt b/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinLambdaMethodFilter.kt index 417423ae7b1..c2a26ebf396 100644 --- a/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinLambdaMethodFilter.kt +++ b/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinLambdaMethodFilter.kt @@ -19,55 +19,58 @@ package org.jetbrains.kotlin.idea.debugger.stepping import com.intellij.debugger.SourcePosition import com.intellij.debugger.engine.BreakpointStepMethodFilter import com.intellij.debugger.engine.DebugProcessImpl -import com.intellij.debugger.engine.LambdaMethodFilter -import com.intellij.openapi.util.text.StringUtil -import com.intellij.psi.PsiElementFactory import com.intellij.util.Range import com.sun.jdi.Location -import org.jetbrains.kotlin.idea.util.application.runReadAction +import org.jetbrains.kotlin.idea.core.refactoring.isMultiLine +import org.jetbrains.kotlin.idea.debugger.isInsideInlineArgument import org.jetbrains.kotlin.psi.KtBlockExpression -import org.jetbrains.kotlin.psi.KtFunctionLiteralExpression +import org.jetbrains.kotlin.psi.KtFunction import org.jetbrains.kotlin.util.OperatorNameConventions public class KotlinLambdaMethodFilter( - lambda: KtFunctionLiteralExpression, - private val myCallingExpressionLines: Range + private val lambda: KtFunction, + private val myCallingExpressionLines: Range, + private val isInline: Boolean ): BreakpointStepMethodFilter { private val myFirstStatementPosition: SourcePosition? private val myLastStatementLine: Int init { - var firstStatementPosition: SourcePosition? = null - var lastStatementPosition: SourcePosition? = null - val body = lambda.getBodyExpression()!! - val statements = body.getStatements() - if (statements.isNotEmpty()) { - firstStatementPosition = SourcePosition.createFromElement(statements.first()) - if (firstStatementPosition != null) { - val lastStatement = statements.last() - lastStatementPosition = SourcePosition.createFromOffset(firstStatementPosition.getFile(), lastStatement.getTextRange().getEndOffset()) + if (lambda.isMultiLine()) { + var firstStatementPosition: SourcePosition? = null + var lastStatementPosition: SourcePosition? = null + val body = lambda.bodyExpression as KtBlockExpression + val statements = body.statements + if (statements.isNotEmpty()) { + firstStatementPosition = SourcePosition.createFromElement(statements.first()) + if (firstStatementPosition != null) { + val lastStatement = statements.last() + lastStatementPosition = SourcePosition.createFromOffset(firstStatementPosition.file, lastStatement.textRange.endOffset) + } } + myFirstStatementPosition = firstStatementPosition + myLastStatementLine = if (lastStatementPosition != null) lastStatementPosition.line else -1 + } + else { + myFirstStatementPosition = SourcePosition.createFromElement(lambda) + myLastStatementLine = myFirstStatementPosition!!.line } - myFirstStatementPosition = firstStatementPosition - myLastStatementLine = if (lastStatementPosition != null) lastStatementPosition.getLine() else -1 } - override fun getBreakpointPosition(): SourcePosition? { - return myFirstStatementPosition - } - - override fun getLastStatementLine(): Int { - return myLastStatementLine - } + override fun getBreakpointPosition() = myFirstStatementPosition + override fun getLastStatementLine() = myLastStatementLine override fun locationMatches(process: DebugProcessImpl, location: Location): Boolean { val method = location.method() + + if (isInline) { + return isInsideInlineArgument(lambda, location, process) + } + return isLambdaName(method.name()) } - override fun getCallingExpressionLines(): Range? { - return myCallingExpressionLines - } + override fun getCallingExpressionLines() = if (isInline) Range(0, 999) else myCallingExpressionLines companion object { public fun isLambdaName(name: String?): Boolean { diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinLambdaSmartStepIntoTarget.kt b/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinLambdaSmartStepIntoTarget.kt index 9ac0210d57c..3de3e135263 100644 --- a/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinLambdaSmartStepIntoTarget.kt +++ b/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinLambdaSmartStepIntoTarget.kt @@ -16,27 +16,23 @@ package org.jetbrains.kotlin.idea.debugger.stepping -import com.intellij.debugger.actions.MethodSmartStepTarget import com.intellij.debugger.actions.SmartStepTarget -import com.intellij.psi.PsiElement -import com.intellij.psi.PsiMethod import com.intellij.util.Range import org.jetbrains.kotlin.descriptors.DeclarationDescriptor import org.jetbrains.kotlin.idea.KotlinIcons import org.jetbrains.kotlin.name.Name -import org.jetbrains.kotlin.psi.KtElement -import org.jetbrains.kotlin.psi.KtFunctionLiteralExpression +import org.jetbrains.kotlin.psi.KtFunction import org.jetbrains.kotlin.util.OperatorNameConventions -import javax.swing.Icon public class KotlinLambdaSmartStepTarget( label: String, - highlightElement: KtFunctionLiteralExpression, - lines: Range + highlightElement: KtFunction, + lines: Range, + val isInline: Boolean ): SmartStepTarget(label, highlightElement, true, lines) { override fun getIcon() = KotlinIcons.LAMBDA - fun getLambda() = getHighlightElement() as KtFunctionLiteralExpression + fun getLambda() = getHighlightElement() as KtFunction companion object { fun calcLabel(descriptor: DeclarationDescriptor, paramName: Name): String { diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinSmartStepIntoHandler.kt b/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinSmartStepIntoHandler.kt index ed4a9cb566e..3ef1fd1d64a 100644 --- a/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinSmartStepIntoHandler.kt +++ b/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinSmartStepIntoHandler.kt @@ -66,20 +66,33 @@ public class KotlinSmartStepIntoHandler : JvmSmartStepIntoHandler() { element.accept(object: KtTreeVisitorVoid() { override fun visitFunctionLiteralExpression(expression: KtFunctionLiteralExpression) { - val context = expression.analyze() - val resolvedCall = expression.getParentCall(context).getResolvedCall(context) - if (resolvedCall != null && !InlineUtil.isInline(resolvedCall.getResultingDescriptor())) { - val arguments = resolvedCall.getValueArguments() + recordFunctionLiteral(expression.functionLiteral) + } + + override fun visitNamedFunction(function: KtNamedFunction) { + if (!recordFunctionLiteral(function)) { + super.visitNamedFunction(function) + } + } + + private fun recordFunctionLiteral(function: KtFunction): Boolean { + val context = function.analyze() + val resolvedCall = function.getParentCall(context).getResolvedCall(context) + if (resolvedCall != null) { + val arguments = resolvedCall.valueArguments for ((param, argument) in arguments) { - if (argument.getArguments().any { it.getArgumentExpression() == expression}) { - val label = KotlinLambdaSmartStepTarget.calcLabel(resolvedCall.getResultingDescriptor(), param.getName()) - result.add(KotlinLambdaSmartStepTarget(label, expression, lines)) - break + if (argument.arguments.any { getArgumentExpression(it) == function }) { + val label = KotlinLambdaSmartStepTarget.calcLabel(resolvedCall.resultingDescriptor, param.name) + result.add(KotlinLambdaSmartStepTarget(label, function, lines, InlineUtil.isInline(resolvedCall.resultingDescriptor))) + return true } } } + return false } + private fun getArgumentExpression(it: ValueArgument) = (it.getArgumentExpression() as? KtFunctionLiteralExpression)?.functionLiteral ?: it.getArgumentExpression() + override fun visitObjectLiteralExpression(expression: KtObjectLiteralExpression) { // skip calls in object declarations } @@ -181,7 +194,7 @@ public class KotlinSmartStepIntoHandler : JvmSmartStepIntoHandler() { override fun createMethodFilter(stepTarget: SmartStepTarget?): MethodFilter? { return when (stepTarget) { is KotlinMethodSmartStepTarget -> KotlinBasicStepMethodFilter(stepTarget.resolvedElement, stepTarget.getCallingExpressionLines()!!) - is KotlinLambdaSmartStepTarget -> KotlinLambdaMethodFilter(stepTarget.getLambda(), stepTarget.getCallingExpressionLines()!! ) + is KotlinLambdaSmartStepTarget -> KotlinLambdaMethodFilter(stepTarget.getLambda(), stepTarget.getCallingExpressionLines()!!, stepTarget.isInline) else -> super.createMethodFilter(stepTarget) } } diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinSteppingCommandProvider.kt b/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinSteppingCommandProvider.kt index 64c20e5089a..80d8b1bb78c 100644 --- a/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinSteppingCommandProvider.kt +++ b/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinSteppingCommandProvider.kt @@ -38,6 +38,7 @@ import org.jetbrains.kotlin.idea.util.DebuggerUtils import org.jetbrains.kotlin.psi.* import org.jetbrains.kotlin.psi.psiUtil.endOffset import org.jetbrains.kotlin.psi.psiUtil.getParentOfType +import org.jetbrains.kotlin.psi.psiUtil.parents import org.jetbrains.kotlin.psi.psiUtil.startOffset import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall import org.jetbrains.kotlin.resolve.inline.InlineUtil @@ -68,7 +69,7 @@ public class KotlinSteppingCommandProvider: JvmSteppingCommandProvider() { val file = sourcePosition.file as? KtFile ?: return null if (sourcePosition.line < 0) return null - val containingFunction = sourcePosition.elementAt.getParentOfType(false) ?: return null + val containingFunction = sourcePosition.elementAt.parents.firstOrNull { it is KtNamedFunction && !it.isLocal } ?: return null val startLineNumber = containingFunction.getLineNumber(true) val endLineNumber = containingFunction.getLineNumber(false) @@ -221,12 +222,13 @@ public class KotlinSteppingCommandProvider: JvmSteppingCommandProvider() { private fun getInlineArgumentsIfAny(inlineFunctionCalls: List): List { return inlineFunctionCalls.flatMap { it.valueArguments - .map { it.getArgumentExpression() } - .filterIsInstance() - .map { it.functionLiteral } + .map { getArgumentExpression(it) } + .filterIsInstance() } } + private fun getArgumentExpression(it: ValueArgument) = (it.getArgumentExpression() as? KtFunctionLiteralExpression)?.functionLiteral ?: it.getArgumentExpression() + private fun getInlineFunctionCallsIfAny(sourcePosition: SourcePosition): List { val file = sourcePosition.file as? KtFile ?: return emptyList() val lineNumber = sourcePosition.line diff --git a/idea/testData/debugger/smartStepInto/inlinedFunLiteral.kt b/idea/testData/debugger/smartStepInto/inlinedFunLiteral.kt index d70aa96be26..85737e91b00 100644 --- a/idea/testData/debugger/smartStepInto/inlinedFunLiteral.kt +++ b/idea/testData/debugger/smartStepInto/inlinedFunLiteral.kt @@ -4,4 +4,4 @@ fun foo() { inline fun f1(f: () -> Unit) {} -// EXISTS: f1(() -> Unit) \ No newline at end of file +// EXISTS: f1(() -> Unit), f1: f.invoke() \ No newline at end of file diff --git a/idea/testData/debugger/smartStepInto/inlinedFunctionalExpression.kt b/idea/testData/debugger/smartStepInto/inlinedFunctionalExpression.kt new file mode 100644 index 00000000000..a83bb79f1e6 --- /dev/null +++ b/idea/testData/debugger/smartStepInto/inlinedFunctionalExpression.kt @@ -0,0 +1,7 @@ +fun foo() { + f1(fun () { }) +} + +inline fun f1(f: () -> Unit) {} + +// EXISTS: f1(() -> Unit), f1: f.invoke() \ No newline at end of file diff --git a/idea/testData/debugger/tinyApp/outs/smartStepIntoInlinedFunLiteral.out b/idea/testData/debugger/tinyApp/outs/smartStepIntoInlinedFunLiteral.out new file mode 100644 index 00000000000..62f5592e325 --- /dev/null +++ b/idea/testData/debugger/tinyApp/outs/smartStepIntoInlinedFunLiteral.out @@ -0,0 +1,13 @@ +LineBreakpoint created at smartStepIntoInlinedFunLiteral.kt:6 +!JDK_HOME!\bin\java -agentlib:jdwp=transport=dt_socket,address=!HOST_NAME!:!HOST_PORT!,suspend=y,server=n -Dfile.encoding=!FILE_ENCODING! -classpath !OUTPUT_PATH!;!KOTLIN_RUNTIME!;!CUSTOM_LIBRARY!;!RT_JAR! smartStepIntoInlinedFunLiteral.SmartStepIntoInlinedFunLiteralKt +Connected to the target VM, address: '!HOST_NAME!:PORT_NAME!', transport: 'socket' +smartStepIntoInlinedFunLiteral.kt:6 +smartStepIntoInlinedFunLiteral.kt:9 +smartStepIntoInlinedFunLiteral.kt:10 +smartStepIntoInlinedFunLiteral.kt:13 +smartStepIntoInlinedFunLiteral.kt:14 +smartStepIntoInlinedFunLiteral.kt:18 +smartStepIntoInlinedFunLiteral.kt:20 +Disconnected from the target VM, address: '!HOST_NAME!:PORT_NAME!', transport: 'socket' + +Process finished with exit code 0 diff --git a/idea/testData/debugger/tinyApp/outs/smartStepIntoInlinedFunctionalExpression.out b/idea/testData/debugger/tinyApp/outs/smartStepIntoInlinedFunctionalExpression.out new file mode 100644 index 00000000000..4b4042927c3 --- /dev/null +++ b/idea/testData/debugger/tinyApp/outs/smartStepIntoInlinedFunctionalExpression.out @@ -0,0 +1,13 @@ +LineBreakpoint created at smartStepIntoInlinedFunctionalExpression.kt:6 +!JDK_HOME!\bin\java -agentlib:jdwp=transport=dt_socket,address=!HOST_NAME!:!HOST_PORT!,suspend=y,server=n -Dfile.encoding=!FILE_ENCODING! -classpath !OUTPUT_PATH!;!KOTLIN_RUNTIME!;!CUSTOM_LIBRARY!;!RT_JAR! smartStepIntoInlinedFunctionalExpression.SmartStepIntoInlinedFunctionalExpressionKt +Connected to the target VM, address: '!HOST_NAME!:PORT_NAME!', transport: 'socket' +smartStepIntoInlinedFunctionalExpression.kt:6 +smartStepIntoInlinedFunctionalExpression.kt:9 +smartStepIntoInlinedFunctionalExpression.kt:10 +smartStepIntoInlinedFunctionalExpression.kt:13 +smartStepIntoInlinedFunctionalExpression.kt:14 +smartStepIntoInlinedFunctionalExpression.kt:18 +smartStepIntoInlinedFunctionalExpression.kt:20 +Disconnected from the target VM, address: '!HOST_NAME!:PORT_NAME!', transport: 'socket' + +Process finished with exit code 0 diff --git a/idea/testData/debugger/tinyApp/src/stepping/custom/smartStepIntoInlinedFunLiteral.kt b/idea/testData/debugger/tinyApp/src/stepping/custom/smartStepIntoInlinedFunLiteral.kt new file mode 100644 index 00000000000..b33c3c491b9 --- /dev/null +++ b/idea/testData/debugger/tinyApp/src/stepping/custom/smartStepIntoInlinedFunLiteral.kt @@ -0,0 +1,45 @@ +package smartStepIntoInlinedFunLiteral + +fun main(args: Array) { + val array = arrayOf(1, 2) + //Breakpoint! + val myClass = MyClass() + + // smart step into f2.invoke(), one-line lambda + myClass.f1 { test() } + .f2 { test() } + + // smart step into map.invoke(), multiline lambda + array.map { + it *2 + } + + // smart step into filter.invoke() + array.map { it * 2 } + .filter { + it > 2 + } +} + +class MyClass { + inline fun f1(f1Param: () -> Unit): MyClass { + test() + f1Param() + return this + } + + inline fun f2(f1Param: () -> Unit): MyClass { + test() + f1Param() + return this + } +} + +fun test() {} + +// STEP_OVER: 1 +// SMART_STEP_INTO_BY_INDEX: 4 +// STEP_OVER: 1 +// SMART_STEP_INTO_BY_INDEX: 2 +// STEP_OVER: 1 +// SMART_STEP_INTO_BY_INDEX: 4 \ No newline at end of file diff --git a/idea/testData/debugger/tinyApp/src/stepping/custom/smartStepIntoInlinedFunctionalExpression.kt b/idea/testData/debugger/tinyApp/src/stepping/custom/smartStepIntoInlinedFunctionalExpression.kt new file mode 100644 index 00000000000..2522e4afd04 --- /dev/null +++ b/idea/testData/debugger/tinyApp/src/stepping/custom/smartStepIntoInlinedFunctionalExpression.kt @@ -0,0 +1,45 @@ +package smartStepIntoInlinedFunctionalExpression + +fun main(args: Array) { + val array = arrayOf(1, 2) + //Breakpoint! + val myClass = MyClass() + + // smart step into f2.invoke(), one-line lambda + myClass.f1(fun () { test() }) + .f2(fun () { test() }) + + // smart step into map.invoke(), multiline lambda + array.map(fun (it): Int { + return it * 2 + }) + + // smart step into filter.invoke() + array.map(fun (it): Int { return it * 2 }) + .filter(fun (it): Boolean { + return it > 2 + }) +} + +class MyClass { + inline fun f1(f1Param: () -> Unit): MyClass { + test() + f1Param() + return this + } + + inline fun f2(f1Param: () -> Unit): MyClass { + test() + f1Param() + return this + } +} + +fun test() {} + +// STEP_OVER: 1 +// SMART_STEP_INTO_BY_INDEX: 4 +// STEP_OVER: 1 +// SMART_STEP_INTO_BY_INDEX: 2 +// STEP_OVER: 1 +// SMART_STEP_INTO_BY_INDEX: 4 \ No newline at end of file diff --git a/idea/tests/org/jetbrains/kotlin/idea/debugger/KotlinDebuggerTestBase.kt b/idea/tests/org/jetbrains/kotlin/idea/debugger/KotlinDebuggerTestBase.kt index e77f7622b80..dd938e4eb81 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/debugger/KotlinDebuggerTestBase.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/debugger/KotlinDebuggerTestBase.kt @@ -27,7 +27,6 @@ import com.intellij.debugger.impl.DebuggerContextImpl import com.intellij.debugger.impl.PositionUtil import com.intellij.debugger.settings.DebuggerSettings import com.intellij.debugger.ui.breakpoints.BreakpointManager -import com.intellij.debugger.ui.breakpoints.LineBreakpoint import com.intellij.execution.process.ProcessOutputTypes import com.intellij.openapi.application.ModalityState import com.intellij.openapi.roots.JdkOrderEntry @@ -43,6 +42,8 @@ import com.intellij.xdebugger.breakpoints.XBreakpoint import com.intellij.xdebugger.breakpoints.XBreakpointProperties import com.intellij.xdebugger.breakpoints.XBreakpointType import com.intellij.xdebugger.breakpoints.XLineBreakpointType +import com.sun.jdi.request.StepRequest +import org.jetbrains.kotlin.idea.core.refactoring.getLineNumber import org.jetbrains.kotlin.idea.debugger.breakpoints.KotlinFieldBreakpoint import org.jetbrains.kotlin.idea.debugger.breakpoints.KotlinFieldBreakpointType import org.jetbrains.kotlin.idea.debugger.stepping.* @@ -162,6 +163,7 @@ abstract class KotlinDebuggerTestBase : KotlinDebuggerTestCase() { } when { + !line.startsWith("//") -> return line.startsWith("// STEP_INTO: ") -> repeat("// STEP_INTO: ") { stepInto(this) } line.startsWith("// STEP_OUT: ") -> repeat("// STEP_OUT: ") { doStepOut() } line.startsWith("// STEP_OVER: ") -> repeat("// STEP_OVER: ") { doStepOver() } @@ -188,14 +190,11 @@ abstract class KotlinDebuggerTestBase : KotlinDebuggerTestCase() { } private fun createSmartStepIntoFilters(): List { - val breakpointManager = DebuggerManagerEx.getInstanceEx(getProject())?.getBreakpointManager() - val breakpoint = breakpointManager?.getBreakpoints()?.first { it is LineBreakpoint } - - val line = (breakpoint as LineBreakpoint).getLineIndex() + val contextElement = ContextUtil.getContextElement(evaluationContext)!! + val line = runReadAction { contextElement.getLineNumber() } return runReadAction { - val containingFile = breakpoint.getPsiFile() - if (containingFile == null) throw AssertionError("Couldn't find file for breakpoint at the line $line") + val containingFile = contextElement.containingFile val position = MockSourcePosition(_file = containingFile, _line = line) @@ -204,7 +203,7 @@ abstract class KotlinDebuggerTestBase : KotlinDebuggerTestCase() { stepTargets.filterIsInstance().map { stepTarget -> when (stepTarget) { - is KotlinLambdaSmartStepTarget -> KotlinLambdaMethodFilter(stepTarget.getLambda(), stepTarget.getCallingExpressionLines()!!) + is KotlinLambdaSmartStepTarget -> KotlinLambdaMethodFilter(stepTarget.getLambda(), stepTarget.getCallingExpressionLines()!!, stepTarget.isInline) is KotlinMethodSmartStepTarget -> KotlinBasicStepMethodFilter(stepTarget.resolvedElement, stepTarget.getCallingExpressionLines()!!) is MethodSmartStepTarget -> BasicStepMethodFilter(stepTarget.getMethod(), stepTarget.getCallingExpressionLines()) else -> null diff --git a/idea/tests/org/jetbrains/kotlin/idea/debugger/KotlinSteppingTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/debugger/KotlinSteppingTestGenerated.java index 1a99732d59d..9df446e1e18 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/debugger/KotlinSteppingTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/debugger/KotlinSteppingTestGenerated.java @@ -523,6 +523,18 @@ public class KotlinSteppingTestGenerated extends AbstractKotlinSteppingTest { doCustomTest(fileName); } + @TestMetadata("smartStepIntoInlinedFunLiteral.kt") + public void testSmartStepIntoInlinedFunLiteral() throws Exception { + String fileName = JetTestUtils.navigationMetadata("idea/testData/debugger/tinyApp/src/stepping/custom/smartStepIntoInlinedFunLiteral.kt"); + doCustomTest(fileName); + } + + @TestMetadata("smartStepIntoInlinedFunctionalExpression.kt") + public void testSmartStepIntoInlinedFunctionalExpression() throws Exception { + String fileName = JetTestUtils.navigationMetadata("idea/testData/debugger/tinyApp/src/stepping/custom/smartStepIntoInlinedFunctionalExpression.kt"); + doCustomTest(fileName); + } + @TestMetadata("stepIntoStdlibInlineFun2step.kt") public void testStepIntoStdlibInlineFun2step() throws Exception { String fileName = JetTestUtils.navigationMetadata("idea/testData/debugger/tinyApp/src/stepping/custom/stepIntoStdlibInlineFun2step.kt"); diff --git a/idea/tests/org/jetbrains/kotlin/idea/debugger/SmartStepIntoTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/debugger/SmartStepIntoTestGenerated.java index b4981a07a3b..16f649365ed 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/debugger/SmartStepIntoTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/debugger/SmartStepIntoTestGenerated.java @@ -125,6 +125,12 @@ public class SmartStepIntoTestGenerated extends AbstractSmartStepIntoTest { doTest(fileName); } + @TestMetadata("inlinedFunctionalExpression.kt") + public void testInlinedFunctionalExpression() throws Exception { + String fileName = JetTestUtils.navigationMetadata("idea/testData/debugger/smartStepInto/inlinedFunctionalExpression.kt"); + doTest(fileName); + } + @TestMetadata("invoke.kt") public void testInvoke() throws Exception { String fileName = JetTestUtils.navigationMetadata("idea/testData/debugger/smartStepInto/invoke.kt");