From 360a5bf34821937bfc0f4604273e8dd7febbe247 Mon Sep 17 00:00:00 2001 From: Dmitry Gridin Date: Fri, 19 Jun 2020 18:16:27 +0700 Subject: [PATCH] Inline refactoring: improve resolve #KT-39705 Fixed #KT-19459 Fixed --- .../kotlin/idea/codeInliner/CodeInliner.kt | 8 ++- .../idea/codeInliner/CodeToInlineBuilder.kt | 58 +++++++++---------- .../ReplaceWithAnnotationAnalyzer.kt | 14 ++++- .../idea/refactoring/inline/inlineUtils.kt | 13 +++-- .../withInnerFunction.kt | 14 +++++ .../withInnerFunction.kt.after | 14 +++++ .../refactoring/inline/function/Kt19459.kt | 13 +++++ .../inline/function/Kt19459.kt.after | 11 ++++ .../ReferenceToCompanionInsideLambda.kt | 13 +++++ .../ReferenceToCompanionInsideLambda.kt.after | 12 ++++ .../ReferenceToCompanionInsideLambda2.kt | 16 +++++ ...ReferenceToCompanionInsideLambda2.kt.after | 13 +++++ .../ReferenceToReceiverInsideLambda.kt | 10 ++++ .../ReferenceToReceiverInsideLambda.kt.after | 7 +++ ...eToReceiverInsideLambdaWithExplicitThis.kt | 11 ++++ ...eiverInsideLambdaWithExplicitThis.kt.after | 8 +++ ...neAnonymousClassWithPrivateMethod.kt.after | 14 ++--- .../explicateTypeArgument/DeeperNestedCall.kt | 2 - .../DeeperNestedCall.kt.after | 4 +- .../DeeperNestedCall2.kt | 2 - .../DeeperNestedCall2.kt.after | 4 +- .../DeprecatedSymbolUsageFixSpecialTest.kt | 2 +- .../idea/quickfix/QuickFixTestGenerated.java | 5 ++ .../inline/InlineTestGenerated.java | 25 ++++++++ 24 files changed, 232 insertions(+), 61 deletions(-) create mode 100644 idea/testData/quickfix/deprecatedSymbolUsage/withInnerFunction.kt create mode 100644 idea/testData/quickfix/deprecatedSymbolUsage/withInnerFunction.kt.after create mode 100644 idea/testData/refactoring/inline/function/Kt19459.kt create mode 100644 idea/testData/refactoring/inline/function/Kt19459.kt.after create mode 100644 idea/testData/refactoring/inline/function/ReferenceToCompanionInsideLambda.kt create mode 100644 idea/testData/refactoring/inline/function/ReferenceToCompanionInsideLambda.kt.after create mode 100644 idea/testData/refactoring/inline/function/ReferenceToCompanionInsideLambda2.kt create mode 100644 idea/testData/refactoring/inline/function/ReferenceToCompanionInsideLambda2.kt.after create mode 100644 idea/testData/refactoring/inline/function/ReferenceToReceiverInsideLambda.kt create mode 100644 idea/testData/refactoring/inline/function/ReferenceToReceiverInsideLambda.kt.after create mode 100644 idea/testData/refactoring/inline/function/ReferenceToReceiverInsideLambdaWithExplicitThis.kt create mode 100644 idea/testData/refactoring/inline/function/ReferenceToReceiverInsideLambdaWithExplicitThis.kt.after diff --git a/idea/src/org/jetbrains/kotlin/idea/codeInliner/CodeInliner.kt b/idea/src/org/jetbrains/kotlin/idea/codeInliner/CodeInliner.kt index f5237a9f796..fa3dbaa5dad 100644 --- a/idea/src/org/jetbrains/kotlin/idea/codeInliner/CodeInliner.kt +++ b/idea/src/org/jetbrains/kotlin/idea/codeInliner/CodeInliner.kt @@ -537,9 +537,11 @@ class CodeInliner( } private fun removeExplicitTypeArguments(result: KtElement) { - result.collectDescendantsOfType(canGoInside = { !it[USER_CODE_KEY] }) { - RemoveExplicitTypeArgumentsIntention.isApplicableTo(it, approximateFlexible = true) - }.forEach { it.delete() } + for (typeArgumentList in result.collectDescendantsOfType(canGoInside = { !it[USER_CODE_KEY] })) { + if (RemoveExplicitTypeArgumentsIntention.isApplicableTo(typeArgumentList, approximateFlexible = true)) { + typeArgumentList.delete() + } + } } private fun simplifySpreadArrayOfArguments(result: KtElement) { diff --git a/idea/src/org/jetbrains/kotlin/idea/codeInliner/CodeToInlineBuilder.kt b/idea/src/org/jetbrains/kotlin/idea/codeInliner/CodeToInlineBuilder.kt index 0fc184f8b5a..986124efdcd 100644 --- a/idea/src/org/jetbrains/kotlin/idea/codeInliner/CodeToInlineBuilder.kt +++ b/idea/src/org/jetbrains/kotlin/idea/codeInliner/CodeToInlineBuilder.kt @@ -29,7 +29,6 @@ import org.jetbrains.kotlin.resolve.ImportedFromObjectCallableDescriptor import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall import org.jetbrains.kotlin.resolve.calls.model.isReallySuccess import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameOrNull -import org.jetbrains.kotlin.resolve.descriptorUtil.isCompanionObject import org.jetbrains.kotlin.resolve.descriptorUtil.isExtension import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode import org.jetbrains.kotlin.resolve.scopes.receivers.ImplicitReceiver @@ -50,14 +49,14 @@ class CodeToInlineBuilder( fun prepareCodeToInline( mainExpression: KtExpression?, statementsBefore: List, - analyze: () -> BindingContext, - reformat: Boolean + analyze: (KtExpression) -> BindingContext, + reformat: Boolean, ): CodeToInline { - var bindingContext = analyze() - val alwaysKeepMainExpression = when (val descriptor = mainExpression.getResolvedCall(bindingContext)?.resultingDescriptor) { - is PropertyDescriptor -> descriptor.getter?.isDefault == false - else -> false - } + val alwaysKeepMainExpression = + when (val descriptor = mainExpression?.getResolvedCall(analyze(mainExpression))?.resultingDescriptor) { + is PropertyDescriptor -> descriptor.getter?.isDefault == false + else -> false + } val codeToInline = MutableCodeToInline( mainExpression, @@ -66,14 +65,14 @@ class CodeToInlineBuilder( alwaysKeepMainExpression ) - bindingContext = insertExplicitTypeArguments(codeToInline, bindingContext, analyze) + insertExplicitTypeArguments(codeToInline, analyze) - processReferences(codeToInline, bindingContext, reformat) + processReferences(codeToInline, analyze, reformat) if (mainExpression != null) { val functionLiteralExpression = mainExpression.unpackFunctionLiteral(true) if (functionLiteralExpression != null) { - val functionLiteralParameterTypes = getParametersForFunctionLiteral(functionLiteralExpression, bindingContext) + val functionLiteralParameterTypes = getParametersForFunctionLiteral(functionLiteralExpression, analyze) if (functionLiteralParameterTypes != null) { codeToInline.addPostInsertionAction(mainExpression) { inlinedExpression -> addFunctionLiteralParameterTypes(functionLiteralParameterTypes, inlinedExpression) @@ -85,7 +84,11 @@ class CodeToInlineBuilder( return codeToInline.toNonMutable() } - private fun getParametersForFunctionLiteral(functionLiteralExpression: KtLambdaExpression, context: BindingContext): String? { + private fun getParametersForFunctionLiteral( + functionLiteralExpression: KtLambdaExpression, + analyze: (KtExpression) -> BindingContext + ): String? { + val context = analyze(functionLiteralExpression) val lambdaDescriptor = context.get(BindingContext.FUNCTION, functionLiteralExpression.functionLiteral) if (lambdaDescriptor == null || ErrorUtils.containsErrorTypeInParameters(lambdaDescriptor) || @@ -126,43 +129,36 @@ class CodeToInlineBuilder( } } - private fun insertExplicitTypeArguments( - codeToInline: MutableCodeToInline, - bindingContext: BindingContext, - analyze: () -> BindingContext - ): BindingContext { - val typeArgsToAdd = ArrayList>() - codeToInline.forEachDescendantOfType { + private fun insertExplicitTypeArguments(codeToInline: MutableCodeToInline, analyze: (KtExpression) -> BindingContext) { + val typeArgsToAdd = ArrayList>() + codeToInline.forEachDescendantOfType { + val expression = it.parent as? KtQualifiedExpression ?: it + val bindingContext = analyze(expression) if (InsertExplicitTypeArgumentsIntention.isApplicableTo(it, bindingContext)) { typeArgsToAdd.add(it to InsertExplicitTypeArgumentsIntention.createTypeArguments(it, bindingContext)!!) } } - if (typeArgsToAdd.isEmpty()) return bindingContext - + if (typeArgsToAdd.isEmpty()) return for ((callExpr, typeArgs) in typeArgsToAdd) { callExpr.addAfter(typeArgs, callExpr.calleeExpression) } - - // reanalyze expression - new usages of type parameters may be added - return analyze() } - private fun processReferences(codeToInline: MutableCodeToInline, bindingContext: BindingContext, reformat: Boolean) { + private fun processReferences(codeToInline: MutableCodeToInline, analyze: (KtExpression) -> BindingContext, reformat: Boolean) { val receiversToAdd = ArrayList>() val targetDispatchReceiverType = targetCallable.dispatchReceiverParameter?.value?.type val targetExtensionReceiverType = targetCallable.extensionReceiverParameter?.value?.type codeToInline.forEachDescendantOfType { expression -> - val target = bindingContext[BindingContext.REFERENCE_TARGET, expression] ?: return@forEachDescendantOfType + val bindingContext = analyze(expression) + val target = bindingContext[BindingContext.SHORT_REFERENCE_TO_COMPANION_OBJECT, expression] + ?: bindingContext[BindingContext.REFERENCE_TARGET, expression] + ?: return@forEachDescendantOfType //TODO: other types of references ('[]' etc) if (expression.canBeResolvedViaImport(target, bindingContext)) { - val importableFqName = if (target.isCompanionObject()) { - target.containingDeclaration?.importableFqName - } else { - target.importableFqName - } + val importableFqName = target.importableFqName if (importableFqName != null) { val lexicalScope = (expression.containingFile as? KtFile)?.getResolutionScope(bindingContext, resolutionFacade) diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/ReplaceWithAnnotationAnalyzer.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/ReplaceWithAnnotationAnalyzer.kt index 68f8427ddf7..9a9c9af8905 100644 --- a/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/ReplaceWithAnnotationAnalyzer.kt +++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/ReplaceWithAnnotationAnalyzer.kt @@ -21,6 +21,7 @@ import org.jetbrains.kotlin.idea.resolve.frontendService import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.FqNameUnsafe import org.jetbrains.kotlin.platform.TargetPlatform +import org.jetbrains.kotlin.psi.KtExpression import org.jetbrains.kotlin.psi.KtNameReferenceExpression import org.jetbrains.kotlin.psi.KtPsiFactory import org.jetbrains.kotlin.psi.KtUserType @@ -67,10 +68,17 @@ object ReplaceWithAnnotationAnalyzer { val expressionTypingServices = resolutionFacade.getFrontendService(module, ExpressionTypingServices::class.java) - fun analyzeExpression() = expression.analyzeInContext(scope, expressionTypingServices = expressionTypingServices) + fun analyzeExpression(ignore: KtExpression) = expression.analyzeInContext( + scope, + expressionTypingServices = expressionTypingServices + ) - return CodeToInlineBuilder(symbolDescriptor, resolutionFacade) - .prepareCodeToInline(expression, emptyList(), ::analyzeExpression, reformat) + return CodeToInlineBuilder(symbolDescriptor, resolutionFacade).prepareCodeToInline( + expression, + emptyList(), + ::analyzeExpression, + reformat + ) } fun analyzeClassifierReplacement( diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/inline/inlineUtils.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/inline/inlineUtils.kt index bdd58ae6565..1f5d19295ec 100644 --- a/idea/src/org/jetbrains/kotlin/idea/refactoring/inline/inlineUtils.kt +++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/inline/inlineUtils.kt @@ -20,13 +20,13 @@ import com.intellij.refactoring.util.CommonRefactoringUtil import com.intellij.refactoring.util.RefactoringMessageDialog import com.intellij.usageView.UsageInfo import org.jetbrains.kotlin.descriptors.CallableDescriptor +import org.jetbrains.kotlin.idea.KotlinBundle import org.jetbrains.kotlin.idea.analysis.analyzeInContext import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade import org.jetbrains.kotlin.idea.caches.resolve.unsafeResolveToDescriptor import org.jetbrains.kotlin.idea.codeInliner.CodeToInline import org.jetbrains.kotlin.idea.codeInliner.CodeToInlineBuilder import org.jetbrains.kotlin.idea.core.copied -import org.jetbrains.kotlin.idea.KotlinBundle import org.jetbrains.kotlin.idea.refactoring.move.ContainerChangeInfo import org.jetbrains.kotlin.idea.refactoring.move.ContainerInfo import org.jetbrains.kotlin.idea.refactoring.move.postProcessMoveUsages @@ -126,8 +126,9 @@ internal fun buildCodeToInline( else TypeUtils.NO_EXPECTED_TYPE - fun analyzeBodyCopy(): BindingContext = bodyCopy.analyzeInContext( - bodyOrInitializer.getResolutionScope(), + val scope by lazy { bodyOrInitializer.getResolutionScope() } + fun analyzeExpressionInContext(expression: KtExpression): BindingContext = expression.analyzeInContext( + scope = scope, contextExpression = bodyOrInitializer, expectedType = expectedType ) @@ -141,7 +142,7 @@ internal fun buildCodeToInline( val returnStatements = bodyCopy.collectDescendantsOfType { val function = it.getStrictParentOfType() if (function != null && function != declaration) return@collectDescendantsOfType false - it.getLabelName().let { it == null || it == declaration.name } + it.getLabelName().let { label -> label == null || label == declaration.name } } val lastReturn = statements.lastOrNull() as? KtReturnExpression @@ -166,10 +167,10 @@ internal fun buildCodeToInline( return builder.prepareCodeToInline( lastReturn?.returnedExpression, - statements.dropLast(returnStatements.size), ::analyzeBodyCopy, reformat = true + statements.dropLast(returnStatements.size), ::analyzeExpressionInContext, reformat = true ) } else { - return builder.prepareCodeToInline(bodyCopy, emptyList(), ::analyzeBodyCopy, reformat = true) + return builder.prepareCodeToInline(bodyCopy, emptyList(), ::analyzeExpressionInContext, reformat = true) } } diff --git a/idea/testData/quickfix/deprecatedSymbolUsage/withInnerFunction.kt b/idea/testData/quickfix/deprecatedSymbolUsage/withInnerFunction.kt new file mode 100644 index 00000000000..462d8739b5b --- /dev/null +++ b/idea/testData/quickfix/deprecatedSymbolUsage/withInnerFunction.kt @@ -0,0 +1,14 @@ +// "Replace with '{ this.bar }()'" "true" + +private class A { + val bar = 1 + + @Deprecated("t", ReplaceWith("{ this.bar }()")) + fun foooo() { + { bar }() + } +} + +private fun test(a: A) { + a.foooo() +} diff --git a/idea/testData/quickfix/deprecatedSymbolUsage/withInnerFunction.kt.after b/idea/testData/quickfix/deprecatedSymbolUsage/withInnerFunction.kt.after new file mode 100644 index 00000000000..fcd0db42db0 --- /dev/null +++ b/idea/testData/quickfix/deprecatedSymbolUsage/withInnerFunction.kt.after @@ -0,0 +1,14 @@ +// "Replace with '{ this.bar }()'" "true" + +private class A { + val bar = 1 + + @Deprecated("t", ReplaceWith("{ this.bar }()")) + fun foooo() { + { bar }() + } +} + +private fun test(a: A) { + { a.bar }() +} diff --git a/idea/testData/refactoring/inline/function/Kt19459.kt b/idea/testData/refactoring/inline/function/Kt19459.kt new file mode 100644 index 00000000000..f50b8fd61ef --- /dev/null +++ b/idea/testData/refactoring/inline/function/Kt19459.kt @@ -0,0 +1,13 @@ +private class A { + val bar = 1 + val parent: A + get() = null!! +} + +fun myrun(f: () -> T) = f() + +private fun A.foo() = myrun { bar } + +private fun test(a: A) { + a.foo() +} \ No newline at end of file diff --git a/idea/testData/refactoring/inline/function/Kt19459.kt.after b/idea/testData/refactoring/inline/function/Kt19459.kt.after new file mode 100644 index 00000000000..e136aa34f25 --- /dev/null +++ b/idea/testData/refactoring/inline/function/Kt19459.kt.after @@ -0,0 +1,11 @@ +private class A { + val bar = 1 + val parent: A + get() = null!! +} + +fun myrun(f: () -> T) = f() + +private fun test(a: A) { + myrun { a.bar } +} \ No newline at end of file diff --git a/idea/testData/refactoring/inline/function/ReferenceToCompanionInsideLambda.kt b/idea/testData/refactoring/inline/function/ReferenceToCompanionInsideLambda.kt new file mode 100644 index 00000000000..77e5848cb56 --- /dev/null +++ b/idea/testData/refactoring/inline/function/ReferenceToCompanionInsideLambda.kt @@ -0,0 +1,13 @@ +private class A { + fun foooo() { + { bar }() + } + + companion object { + const val bar = 4 + } +} + +private fun test(a: A) { + a.foooo() +} \ No newline at end of file diff --git a/idea/testData/refactoring/inline/function/ReferenceToCompanionInsideLambda.kt.after b/idea/testData/refactoring/inline/function/ReferenceToCompanionInsideLambda.kt.after new file mode 100644 index 00000000000..4de102f310c --- /dev/null +++ b/idea/testData/refactoring/inline/function/ReferenceToCompanionInsideLambda.kt.after @@ -0,0 +1,12 @@ +import A.Companion.bar + +private class A { + + companion object { + const val bar = 4 + } +} + +private fun test(a: A) { + { bar }() +} \ No newline at end of file diff --git a/idea/testData/refactoring/inline/function/ReferenceToCompanionInsideLambda2.kt b/idea/testData/refactoring/inline/function/ReferenceToCompanionInsideLambda2.kt new file mode 100644 index 00000000000..73776445ebf --- /dev/null +++ b/idea/testData/refactoring/inline/function/ReferenceToCompanionInsideLambda2.kt @@ -0,0 +1,16 @@ +package abc + +private class A { + fun foooo() { + { bar }() + } + + companion object { + const val bar = 4 + } +} + +private fun test(a: A) { + val bar = 42 + a.foooo() +} \ No newline at end of file diff --git a/idea/testData/refactoring/inline/function/ReferenceToCompanionInsideLambda2.kt.after b/idea/testData/refactoring/inline/function/ReferenceToCompanionInsideLambda2.kt.after new file mode 100644 index 00000000000..447aa7c1ebf --- /dev/null +++ b/idea/testData/refactoring/inline/function/ReferenceToCompanionInsideLambda2.kt.after @@ -0,0 +1,13 @@ +package abc + +private class A { + + companion object { + const val bar = 4 + } +} + +private fun test(a: A) { + val bar = 42 + { A.bar }() +} \ No newline at end of file diff --git a/idea/testData/refactoring/inline/function/ReferenceToReceiverInsideLambda.kt b/idea/testData/refactoring/inline/function/ReferenceToReceiverInsideLambda.kt new file mode 100644 index 00000000000..0984ce77733 --- /dev/null +++ b/idea/testData/refactoring/inline/function/ReferenceToReceiverInsideLambda.kt @@ -0,0 +1,10 @@ +private class A { + val bar = 1 + fun foooo() { + { bar }() + } +} + +private fun test(a: A) { + a.foooo() +} \ No newline at end of file diff --git a/idea/testData/refactoring/inline/function/ReferenceToReceiverInsideLambda.kt.after b/idea/testData/refactoring/inline/function/ReferenceToReceiverInsideLambda.kt.after new file mode 100644 index 00000000000..92522c7680b --- /dev/null +++ b/idea/testData/refactoring/inline/function/ReferenceToReceiverInsideLambda.kt.after @@ -0,0 +1,7 @@ +private class A { + val bar = 1 +} + +private fun test(a: A) { + { a.bar }() +} \ No newline at end of file diff --git a/idea/testData/refactoring/inline/function/ReferenceToReceiverInsideLambdaWithExplicitThis.kt b/idea/testData/refactoring/inline/function/ReferenceToReceiverInsideLambdaWithExplicitThis.kt new file mode 100644 index 00000000000..fd07c1b98d6 --- /dev/null +++ b/idea/testData/refactoring/inline/function/ReferenceToReceiverInsideLambdaWithExplicitThis.kt @@ -0,0 +1,11 @@ +private class A { + val bar = 1 + fun foooo() { + { this.bar }() + bar + } +} + +private fun test(a: A) { + a.foooo() +} \ No newline at end of file diff --git a/idea/testData/refactoring/inline/function/ReferenceToReceiverInsideLambdaWithExplicitThis.kt.after b/idea/testData/refactoring/inline/function/ReferenceToReceiverInsideLambdaWithExplicitThis.kt.after new file mode 100644 index 00000000000..814d7945ba5 --- /dev/null +++ b/idea/testData/refactoring/inline/function/ReferenceToReceiverInsideLambdaWithExplicitThis.kt.after @@ -0,0 +1,8 @@ +private class A { + val bar = 1 +} + +private fun test(a: A) { + { a.bar }() + a.bar +} \ No newline at end of file diff --git a/idea/testData/refactoring/inline/function/fromIntellij/InlineAnonymousClassWithPrivateMethod.kt.after b/idea/testData/refactoring/inline/function/fromIntellij/InlineAnonymousClassWithPrivateMethod.kt.after index db3cd39c2be..ea081d8e7c5 100644 --- a/idea/testData/refactoring/inline/function/fromIntellij/InlineAnonymousClassWithPrivateMethod.kt.after +++ b/idea/testData/refactoring/inline/function/fromIntellij/InlineAnonymousClassWithPrivateMethod.kt.after @@ -10,13 +10,13 @@ object Foo { internal object Bar { @JvmStatic fun main(args: Array) { bar(object : Runnable { - override fun run() { - doRun() - } + override fun run() { + doRun() + } - private fun doRun() { - // Woo-hoo - } - }) + private fun doRun() { + // Woo-hoo + } + }) } } \ No newline at end of file diff --git a/idea/testData/refactoring/inline/inlineVariableOrProperty/explicateTypeArgument/DeeperNestedCall.kt b/idea/testData/refactoring/inline/inlineVariableOrProperty/explicateTypeArgument/DeeperNestedCall.kt index e5eb02f8033..04d899c3945 100644 --- a/idea/testData/refactoring/inline/inlineVariableOrProperty/explicateTypeArgument/DeeperNestedCall.kt +++ b/idea/testData/refactoring/inline/inlineVariableOrProperty/explicateTypeArgument/DeeperNestedCall.kt @@ -1,5 +1,3 @@ -// COMPILER_ARGUMENTS: -XXLanguage:-NewInference - import java.util.ArrayList fun f() { diff --git a/idea/testData/refactoring/inline/inlineVariableOrProperty/explicateTypeArgument/DeeperNestedCall.kt.after b/idea/testData/refactoring/inline/inlineVariableOrProperty/explicateTypeArgument/DeeperNestedCall.kt.after index bc63b91db39..61c8ac98c56 100644 --- a/idea/testData/refactoring/inline/inlineVariableOrProperty/explicateTypeArgument/DeeperNestedCall.kt.after +++ b/idea/testData/refactoring/inline/inlineVariableOrProperty/explicateTypeArgument/DeeperNestedCall.kt.after @@ -1,7 +1,5 @@ -// COMPILER_ARGUMENTS: -XXLanguage:-NewInference - import java.util.ArrayList fun f() { - ArrayList(ArrayList(listOf())) + ArrayList(ArrayList(listOf())) } diff --git a/idea/testData/refactoring/inline/inlineVariableOrProperty/explicateTypeArgument/DeeperNestedCall2.kt b/idea/testData/refactoring/inline/inlineVariableOrProperty/explicateTypeArgument/DeeperNestedCall2.kt index b4af9fee862..6275df9394c 100644 --- a/idea/testData/refactoring/inline/inlineVariableOrProperty/explicateTypeArgument/DeeperNestedCall2.kt +++ b/idea/testData/refactoring/inline/inlineVariableOrProperty/explicateTypeArgument/DeeperNestedCall2.kt @@ -1,5 +1,3 @@ -// COMPILER_ARGUMENTS: -XXLanguage:-NewInference - fun foo(f: List) {} fun f() { diff --git a/idea/testData/refactoring/inline/inlineVariableOrProperty/explicateTypeArgument/DeeperNestedCall2.kt.after b/idea/testData/refactoring/inline/inlineVariableOrProperty/explicateTypeArgument/DeeperNestedCall2.kt.after index fcdacc128e3..64e212faf28 100644 --- a/idea/testData/refactoring/inline/inlineVariableOrProperty/explicateTypeArgument/DeeperNestedCall2.kt.after +++ b/idea/testData/refactoring/inline/inlineVariableOrProperty/explicateTypeArgument/DeeperNestedCall2.kt.after @@ -1,7 +1,5 @@ -// COMPILER_ARGUMENTS: -XXLanguage:-NewInference - fun foo(f: List) {} fun f() { - foo(ArrayList(listOf())) + foo(ArrayList(listOf())) } diff --git a/idea/tests/org/jetbrains/kotlin/idea/quickfix/DeprecatedSymbolUsageFixSpecialTest.kt b/idea/tests/org/jetbrains/kotlin/idea/quickfix/DeprecatedSymbolUsageFixSpecialTest.kt index 536996b9aaa..790fb5f2023 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/quickfix/DeprecatedSymbolUsageFixSpecialTest.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/quickfix/DeprecatedSymbolUsageFixSpecialTest.kt @@ -25,7 +25,7 @@ class DeprecatedSymbolUsageFixSpecialTest : KotlinLightCodeInsightFixtureTestCas override fun getProjectDescriptor() = ProjectDescriptorWithStdlibSources.INSTANCE fun testMemberInCompiledClass() { - doTest("matches(input)") + doTest("this.matches(input)") } fun testDefaultParameterValuesFromLibrary() { diff --git a/idea/tests/org/jetbrains/kotlin/idea/quickfix/QuickFixTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/quickfix/QuickFixTestGenerated.java index 9d993d23565..a40ba591bf2 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/quickfix/QuickFixTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/quickfix/QuickFixTestGenerated.java @@ -6445,6 +6445,11 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { runTest("idea/testData/quickfix/deprecatedSymbolUsage/usageInDerivedClassGeneric.kt"); } + @TestMetadata("withInnerFunction.kt") + public void testWithInnerFunction() throws Exception { + runTest("idea/testData/quickfix/deprecatedSymbolUsage/withInnerFunction.kt"); + } + @TestMetadata("idea/testData/quickfix/deprecatedSymbolUsage/argumentSideEffects") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) diff --git a/idea/tests/org/jetbrains/kotlin/idea/refactoring/inline/InlineTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/refactoring/inline/InlineTestGenerated.java index a2ffd75faa1..f48e6d359e5 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/refactoring/inline/InlineTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/refactoring/inline/InlineTestGenerated.java @@ -55,6 +55,11 @@ public class InlineTestGenerated extends AbstractInlineTest { runTest("idea/testData/refactoring/inline/function/InStringTemplates.kt"); } + @TestMetadata("Kt19459.kt") + public void testKt19459() throws Exception { + runTest("idea/testData/refactoring/inline/function/Kt19459.kt"); + } + @TestMetadata("LocalCapturing.kt") public void testLocalCapturing() throws Exception { runTest("idea/testData/refactoring/inline/function/LocalCapturing.kt"); @@ -85,6 +90,26 @@ public class InlineTestGenerated extends AbstractInlineTest { runTest("idea/testData/refactoring/inline/function/ReferenceReceiver.kt"); } + @TestMetadata("ReferenceToCompanionInsideLambda.kt") + public void testReferenceToCompanionInsideLambda() throws Exception { + runTest("idea/testData/refactoring/inline/function/ReferenceToCompanionInsideLambda.kt"); + } + + @TestMetadata("ReferenceToCompanionInsideLambda2.kt") + public void testReferenceToCompanionInsideLambda2() throws Exception { + runTest("idea/testData/refactoring/inline/function/ReferenceToCompanionInsideLambda2.kt"); + } + + @TestMetadata("ReferenceToReceiverInsideLambda.kt") + public void testReferenceToReceiverInsideLambda() throws Exception { + runTest("idea/testData/refactoring/inline/function/ReferenceToReceiverInsideLambda.kt"); + } + + @TestMetadata("ReferenceToReceiverInsideLambdaWithExplicitThis.kt") + public void testReferenceToReceiverInsideLambdaWithExplicitThis() throws Exception { + runTest("idea/testData/refactoring/inline/function/ReferenceToReceiverInsideLambdaWithExplicitThis.kt"); + } + @TestMetadata("ReturnNotInTheEnd.kt") public void testReturnNotInTheEnd() throws Exception { runTest("idea/testData/refactoring/inline/function/ReturnNotInTheEnd.kt");