diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/CallableBuilder.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/CallableBuilder.kt index 9d5b9eef370..7a4c9a8e500 100644 --- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/CallableBuilder.kt +++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/CallableBuilder.kt @@ -37,7 +37,6 @@ import org.jetbrains.kotlin.resolve.scopes.JetScope import org.jetbrains.kotlin.types.* import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.idea.util.ShortenReferences -import org.jetbrains.kotlin.idea.refactoring.JetNameSuggester import kotlin.properties.Delegates import java.util.LinkedHashSet import java.util.Collections @@ -46,13 +45,10 @@ import java.util.ArrayList import java.util.Properties import org.jetbrains.kotlin.idea.caches.resolve.analyzeFullyAndGetResult import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils -import org.jetbrains.kotlin.idea.refactoring.EmptyValidator -import org.jetbrains.kotlin.idea.refactoring.CollectingValidator import com.intellij.psi.PsiWhiteSpace import com.intellij.psi.PsiElement import org.jetbrains.kotlin.lexer.JetTokens import org.jetbrains.kotlin.idea.util.application.runWriteAction -import org.jetbrains.kotlin.idea.refactoring.isMultiLine import org.jetbrains.kotlin.types.checker.JetTypeChecker import com.intellij.psi.SmartPointerManager import org.jetbrains.kotlin.descriptors.impl.SimpleFunctionDescriptorImpl @@ -69,6 +65,18 @@ import org.jetbrains.kotlin.psi.psiUtil.siblings import org.jetbrains.kotlin.idea.util.isUnit import com.intellij.openapi.editor.ScrollType import org.jetbrains.kotlin.psi.psiUtil.isAncestor +import org.jetbrains.kotlin.load.java.descriptors.JavaClassDescriptor +import com.intellij.psi.PsiClass +import com.intellij.codeInsight.daemon.impl.quickfix.CreateFromUsageUtils +import com.intellij.psi.PsiMethod +import com.intellij.openapi.fileEditor.OpenFileDescriptor +import com.intellij.psi.codeStyle.JavaCodeStyleManager +import com.intellij.psi.PsiModifier +import org.jetbrains.kotlin.resolve.scopes.ChainedScope +import org.jetbrains.kotlin.resolve.scopes.WritableScopeImpl +import org.jetbrains.kotlin.resolve.scopes.RedeclarationHandler +import org.jetbrains.kotlin.resolve.scopes.WritableScope +import org.jetbrains.kotlin.idea.refactoring.* private val TYPE_PARAMETER_LIST_VARIABLE_NAME = "typeParameterList" private val TEMPLATE_FROM_USAGE_FUNCTION_BODY = "New Kotlin Function Body.kt" @@ -228,7 +236,10 @@ class CallableBuilder(val config: CallableBuilderConfiguration) { receiverClassDescriptor = placement.receiverTypeCandidate.theType.getConstructor().getDeclarationDescriptor() as? ClassDescriptor val classDeclaration = receiverClassDescriptor?.let { DescriptorToSourceUtils.classDescriptorToDeclaration(it) } - containingElement = if (config.isExtension) config.currentFile else classDeclaration as JetElement + containingElement = when { + !config.isExtension && classDeclaration is JetElement -> classDeclaration + else -> config.currentFile + } } else -> throw IllegalArgumentException("Unexpected placement: $placement") } @@ -243,12 +254,7 @@ class CallableBuilder(val config: CallableBuilderConfiguration) { containingFileEditor = config.currentEditor!! } - val scope = if (config.isExtension || receiverClassDescriptor == null) { - currentFileModule.getPackage(config.currentFile.getPackageFqName())!!.getMemberScope() - } - else { - (receiverClassDescriptor as ClassDescriptorWithResolutionScopes).getScopeForMemberDeclarationResolution() - } + val scope = getDeclarationScope() receiverTypeCandidate = receiverType?.let { TypeCandidate(it, scope) } @@ -297,6 +303,41 @@ class CallableBuilder(val config: CallableBuilderConfiguration) { mandatoryTypeParametersAsCandidates.forEach { it.render(typeParameterNameMap, fakeFunction) } } + private fun getDeclarationScope(): JetScope { + if (config.isExtension || receiverClassDescriptor == null) { + return currentFileModule.getPackage(config.currentFile.getPackageFqName())!!.getMemberScope() + } + + if (receiverClassDescriptor is ClassDescriptorWithResolutionScopes) { + return receiverClassDescriptor.getScopeForMemberDeclarationResolution() + } + + assert (receiverClassDescriptor is JavaClassDescriptor, "Unexpected receiver class: ${receiverClassDescriptor}") + + val typeParamScope = with( + WritableScopeImpl( + JetScope.Empty, + receiverClassDescriptor, + RedeclarationHandler.DO_NOTHING, + "Scope with type parameters for ${receiverClassDescriptor.getName()}" + ) + ) { + receiverClassDescriptor.getTypeConstructor().getParameters().forEach { addClassifierDescriptor(it) } + changeLockLevel(WritableScope.LockLevel.READING) + } + + val projections = receiverClassDescriptor.getTypeConstructor().getParameters() + .map { TypeProjectionImpl(it.getDefaultType()) } + val memberScope = receiverClassDescriptor.getMemberScope(projections) + + return ChainedScope( + receiverClassDescriptor, + "Classifier resolution scope: ${receiverClassDescriptor.getName()}", + typeParamScope, + memberScope + ) + } + private fun collectSubstitutionsForReceiverTypeParameters( receiverType: JetType?, result: MutableMap @@ -715,6 +756,38 @@ class CallableBuilder(val config: CallableBuilderConfiguration) { typeRef.replace(fullyQualifiedReceiverTypeRef) } + private fun transformToJavaMemberIfApplicable(declaration: JetNamedDeclaration): Boolean { + if (config.isExtension || receiverClassDescriptor !is JavaClassDescriptor) return false + + val targetClass = DescriptorToSourceUtils.classDescriptorToDeclaration(receiverClassDescriptor) as? PsiClass + if (targetClass == null || !targetClass.canRefactor()) return false + + val project = declaration.getProject() + + val newJavaMethod: PsiMethod = when (declaration) { + is JetNamedFunction -> { + val method = createJavaMethod(declaration, targetClass) + + val modifierList = method.getModifierList() + modifierList.setModifierProperty(PsiModifier.STATIC, false) + modifierList.setModifierProperty(PsiModifier.FINAL, false) + + method + } + else -> return false + } + + declaration.delete() + + JavaCodeStyleManager.getInstance(project).shortenClassReferences(newJavaMethod); + + val descriptor = OpenFileDescriptor(project, targetClass.getContainingFile().getVirtualFile()) + val targetEditor = FileEditorManager.getInstance(project).openTextEditor(descriptor, true) + CreateFromUsageUtils.setupEditor(newJavaMethod, targetEditor) + + return true + } + private fun setupEditor(declaration: JetNamedDeclaration) { val caretModel = containingFileEditor.getCaretModel() @@ -812,12 +885,13 @@ class CallableBuilder(val config: CallableBuilderConfiguration) { if (callElement != null) { setupCallTypeArguments(callElement, expression?.currentTypeParameters ?: Collections.emptyList()) } - - // change short type names to fully qualified ones (to be shortened below) - setupTypeReferencesForShortening(newDeclaration, elementsToShorten, parameterTypeExpressions) } - setupEditor(newDeclaration) + if (!transformToJavaMemberIfApplicable(newDeclaration)) { + // change short type names to fully qualified ones (to be shortened below) + setupTypeReferencesForShortening(newDeclaration, elementsToShorten, parameterTypeExpressions) + setupEditor(newDeclaration) + } onFinish() } diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/jetRefactoringUtil.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/jetRefactoringUtil.kt index 7971059ddcf..0ea470323d7 100644 --- a/idea/src/org/jetbrains/kotlin/idea/refactoring/jetRefactoringUtil.kt +++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/jetRefactoringUtil.kt @@ -75,9 +75,18 @@ import org.jetbrains.kotlin.psi.psiUtil.parents import com.intellij.refactoring.util.RefactoringUIUtil import com.intellij.psi.PsiMember import org.jetbrains.kotlin.idea.caches.resolve.getJavaMemberDescriptor +import com.intellij.psi.PsiElementFactory +import com.intellij.psi.PsiModifier +import com.intellij.psi.PsiTypeParameterList +import com.intellij.refactoring.changeSignature.ChangeSignatureUtil +import com.intellij.psi.PsiModifierList +import org.jetbrains.kotlin.asJava.LightClassUtil import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind import org.jetbrains.kotlin.resolve.OverridingUtil +import com.intellij.lang.java.JavaLanguage +import com.intellij.psi.PsiClass +import com.intellij.codeInsight.daemon.impl.quickfix.CreateFromUsageUtils fun PsiElement.getAndRemoveCopyableUserData(key: Key): T? { val data = getCopyableUserData(key) @@ -410,12 +419,72 @@ public fun comparePossiblyOverridingDescriptors(currentDescriptor: DeclarationDe } public fun PsiElement.canRefactor(): Boolean { - return when (this) { - is PsiPackage -> + return when { + this is PsiPackage -> getDirectories().any { it.canRefactor() } - is JetElement, is PsiDirectory -> + this is JetElement, + this is PsiMember && getLanguage() == JavaLanguage.INSTANCE, + this is PsiDirectory -> isWritable() && ProjectRootsUtil.isInProjectSource(this) else -> false } } + +private fun copyModifierListItems(from: PsiModifierList, to: PsiModifierList, withPsiModifiers: Boolean = true) { + if (withPsiModifiers) { + for (modifier in PsiModifier.MODIFIERS) { + if (from.hasExplicitModifier(modifier)) { + to.setModifierProperty(modifier, true) + } + } + } + for (annotation in from.getAnnotations()) { + to.addAnnotation(annotation.getQualifiedName()) + } +} + +public fun createJavaMethod(function: JetNamedFunction, targetClass: PsiClass): PsiMethod { + val template = LightClassUtil.getLightClassMethod(function) + ?: throw AssertionError("Can't generate light method: ${JetPsiUtil.getElementTextWithContext(function)}") + + val factory = PsiElementFactory.SERVICE.getInstance(template.getProject()) + val method = targetClass.add(factory.createMethod(template.getName(), template.getReturnType())) as PsiMethod + + copyModifierListItems(template.getModifierList(), method.getModifierList()) + + val templateTypeParamList = template.getTypeParameterList() + if (templateTypeParamList != null) { + val targetTypeParamList = method.addAfter(factory.createTypeParameterList(), method.getModifierList()) as PsiTypeParameterList + val newTypeParams = templateTypeParamList.getTypeParameters() + .map { factory.createTypeParameter(it.getName(), it.getExtendsList().getReferencedTypes()) } + ChangeSignatureUtil.synchronizeList( + targetTypeParamList, + newTypeParams, + { it.getTypeParameters().toList() }, + BooleanArray(newTypeParams.size()) + ) + } + + val targetParamList = method.getParameterList() + val newParams = template.getParameterList().getParameters().map { + val param = factory.createParameter(it.getName(), it.getType()) + copyModifierListItems(it.getModifierList(), param.getModifierList()) + param + } + ChangeSignatureUtil.synchronizeList( + targetParamList, + newParams, + { it.getParameters().toList() }, + BooleanArray(newParams.size()) + ) + + if (template.getModifierList().hasModifierProperty(PsiModifier.ABSTRACT) || targetClass.isInterface()) { + method.getBody().delete() + } + else { + CreateFromUsageUtils.setupMethodBody(method) + } + + return method +} diff --git a/idea/testData/quickfix/createFromUsage/createClass/callExpression/callWithJavaClassReceiver.before.Main.kt b/idea/testData/quickfix/createFromUsage/createClass/callExpression/callWithJavaClassReceiver.before.Main.kt index b16a7f12470..ba9ea1b1a4a 100644 --- a/idea/testData/quickfix/createFromUsage/createClass/callExpression/callWithJavaClassReceiver.before.Main.kt +++ b/idea/testData/quickfix/createFromUsage/createClass/callExpression/callWithJavaClassReceiver.before.Main.kt @@ -1,5 +1,6 @@ // "Create class 'Foo'" "false" // ACTION: Create extension function 'Foo' +// ACTION: Create function 'Foo' // ACTION: Convert to expression body // ERROR: Unresolved reference: Foo diff --git a/idea/testData/quickfix/createFromUsage/createFunction/call/extensionFunOnGroovyType.after.kt b/idea/testData/quickfix/createFromUsage/createFunction/call/extensionFunOnGroovyType.after.kt new file mode 100644 index 00000000000..647e5a7298b --- /dev/null +++ b/idea/testData/quickfix/createFromUsage/createFunction/call/extensionFunOnGroovyType.after.kt @@ -0,0 +1,10 @@ +// "Create extension function 'foo'" "true" +// ERROR: Unresolved reference: foo + +fun test(): Int { + return A().foo() +} + +fun A.foo(): Int { + throw UnsupportedOperationException("not implemented") //To change body of created functions use File | Settings | File Templates. +} diff --git a/idea/testData/quickfix/createFromUsage/createFunction/call/extensionFunOnGroovyType.before.Main.kt b/idea/testData/quickfix/createFromUsage/createFunction/call/extensionFunOnGroovyType.before.Main.kt new file mode 100644 index 00000000000..56834ef55dd --- /dev/null +++ b/idea/testData/quickfix/createFromUsage/createFunction/call/extensionFunOnGroovyType.before.Main.kt @@ -0,0 +1,6 @@ +// "Create extension function 'foo'" "true" +// ERROR: Unresolved reference: foo + +fun test(): Int { + return A().foo() +} \ No newline at end of file diff --git a/idea/testData/quickfix/createFromUsage/createFunction/call/extensionFunOnGroovyType.before.data.Sample.groovy b/idea/testData/quickfix/createFromUsage/createFunction/call/extensionFunOnGroovyType.before.data.Sample.groovy new file mode 100644 index 00000000000..1b4568a8f26 --- /dev/null +++ b/idea/testData/quickfix/createFromUsage/createFunction/call/extensionFunOnGroovyType.before.data.Sample.groovy @@ -0,0 +1,3 @@ +class A { + +} \ No newline at end of file diff --git a/idea/testData/quickfix/createFromUsage/createFunction/call/extensionFunOnJavaType.after.kt b/idea/testData/quickfix/createFromUsage/createFunction/call/extensionFunOnJavaType.after.kt new file mode 100644 index 00000000000..6dc384f5e87 --- /dev/null +++ b/idea/testData/quickfix/createFromUsage/createFunction/call/extensionFunOnJavaType.after.kt @@ -0,0 +1,10 @@ +// "Create extension function 'foo'" "true" +// ERROR: Unresolved reference: foo + +fun test(): Int? { + return A().foo(1, "2") +} + +fun A.foo(i: Int, s: String): Int? { + throw UnsupportedOperationException("not implemented") //To change body of created functions use File | Settings | File Templates. +} diff --git a/idea/testData/quickfix/createFromUsage/createFunction/call/extensionFunOnJavaType.before.Main.kt b/idea/testData/quickfix/createFromUsage/createFunction/call/extensionFunOnJavaType.before.Main.kt new file mode 100644 index 00000000000..b8f6018d077 --- /dev/null +++ b/idea/testData/quickfix/createFromUsage/createFunction/call/extensionFunOnJavaType.before.Main.kt @@ -0,0 +1,6 @@ +// "Create extension function 'foo'" "true" +// ERROR: Unresolved reference: foo + +fun test(): Int? { + return A().foo(1, "2") +} \ No newline at end of file diff --git a/idea/testData/quickfix/createFromUsage/createFunction/call/extensionFunOnJavaType.before.data.Sample.java b/idea/testData/quickfix/createFromUsage/createFunction/call/extensionFunOnJavaType.before.data.Sample.java new file mode 100644 index 00000000000..1b4568a8f26 --- /dev/null +++ b/idea/testData/quickfix/createFromUsage/createFunction/call/extensionFunOnJavaType.before.data.Sample.java @@ -0,0 +1,3 @@ +class A { + +} \ No newline at end of file diff --git a/idea/testData/quickfix/createFromUsage/createFunction/call/funOnGroovyType.before.Main.kt b/idea/testData/quickfix/createFromUsage/createFunction/call/funOnGroovyType.before.Main.kt new file mode 100644 index 00000000000..cc11b1fdc31 --- /dev/null +++ b/idea/testData/quickfix/createFromUsage/createFunction/call/funOnGroovyType.before.Main.kt @@ -0,0 +1,8 @@ +// "Create function 'foo'" "false" +// ACTION: Convert to expression body +// ACTION: Create extension function 'foo' +// ERROR: Unresolved reference: foo + +fun test(): Int { + return A().foo() +} \ No newline at end of file diff --git a/idea/testData/quickfix/createFromUsage/createFunction/call/funOnGroovyType.before.data.Sample.groovy b/idea/testData/quickfix/createFromUsage/createFunction/call/funOnGroovyType.before.data.Sample.groovy new file mode 100644 index 00000000000..1b4568a8f26 --- /dev/null +++ b/idea/testData/quickfix/createFromUsage/createFunction/call/funOnGroovyType.before.data.Sample.groovy @@ -0,0 +1,3 @@ +class A { + +} \ No newline at end of file diff --git a/idea/testData/quickfix/createFromUsage/createFunction/call/funOnJavaInterface.after.data.Sample.java b/idea/testData/quickfix/createFromUsage/createFunction/call/funOnJavaInterface.after.data.Sample.java new file mode 100644 index 00000000000..3f916a37756 --- /dev/null +++ b/idea/testData/quickfix/createFromUsage/createFunction/call/funOnJavaInterface.after.data.Sample.java @@ -0,0 +1,7 @@ +import org.jetbrains.annotations.Nullable; + +interface A { + + @Nullable + U foo(U u, T t); +} \ No newline at end of file diff --git a/idea/testData/quickfix/createFromUsage/createFunction/call/funOnJavaInterface.after.kt b/idea/testData/quickfix/createFromUsage/createFunction/call/funOnJavaInterface.after.kt new file mode 100644 index 00000000000..3165148c7be --- /dev/null +++ b/idea/testData/quickfix/createFromUsage/createFunction/call/funOnJavaInterface.after.kt @@ -0,0 +1,7 @@ +// "Create function 'foo'" "true" +// ERROR: Unresolved reference: foo + +fun test(a: A): Int? { + return a.foo(1, "2") +} + diff --git a/idea/testData/quickfix/createFromUsage/createFunction/call/funOnJavaInterface.before.Main.kt b/idea/testData/quickfix/createFromUsage/createFunction/call/funOnJavaInterface.before.Main.kt new file mode 100644 index 00000000000..860c2f3b15d --- /dev/null +++ b/idea/testData/quickfix/createFromUsage/createFunction/call/funOnJavaInterface.before.Main.kt @@ -0,0 +1,6 @@ +// "Create function 'foo'" "true" +// ERROR: Unresolved reference: foo + +fun test(a: A): Int? { + return a.foo(1, "2") +} \ No newline at end of file diff --git a/idea/testData/quickfix/createFromUsage/createFunction/call/funOnJavaInterface.before.data.Sample.java b/idea/testData/quickfix/createFromUsage/createFunction/call/funOnJavaInterface.before.data.Sample.java new file mode 100644 index 00000000000..84e5f4303b8 --- /dev/null +++ b/idea/testData/quickfix/createFromUsage/createFunction/call/funOnJavaInterface.before.data.Sample.java @@ -0,0 +1,3 @@ +interface A { + +} \ No newline at end of file diff --git a/idea/testData/quickfix/createFromUsage/createFunction/call/funOnJavaType.after.data.Sample.java b/idea/testData/quickfix/createFromUsage/createFunction/call/funOnJavaType.after.data.Sample.java new file mode 100644 index 00000000000..bf04bee22bf --- /dev/null +++ b/idea/testData/quickfix/createFromUsage/createFunction/call/funOnJavaType.after.data.Sample.java @@ -0,0 +1,10 @@ +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +class A { + + @Nullable + public Integer foo(int i, @NotNull String s) { + return null; + } +} \ No newline at end of file diff --git a/idea/testData/quickfix/createFromUsage/createFunction/call/funOnJavaType.after.kt b/idea/testData/quickfix/createFromUsage/createFunction/call/funOnJavaType.after.kt index c7ea6761851..d0ceab6ef7b 100644 --- a/idea/testData/quickfix/createFromUsage/createFunction/call/funOnJavaType.after.kt +++ b/idea/testData/quickfix/createFromUsage/createFunction/call/funOnJavaType.after.kt @@ -1,10 +1,7 @@ -// "Create extension function 'foo'" "true" +// "Create function 'foo'" "true" // ERROR: Unresolved reference: foo -fun test(): Int { +fun test(): Int? { return A().foo(1, "2") } -fun A.foo(i: Int, s: String): Int { - throw UnsupportedOperationException("not implemented") //To change body of created functions use File | Settings | File Templates. -} diff --git a/idea/testData/quickfix/createFromUsage/createFunction/call/funOnJavaType.before.Main.kt b/idea/testData/quickfix/createFromUsage/createFunction/call/funOnJavaType.before.Main.kt index d5e667f721f..cfb52a9b892 100644 --- a/idea/testData/quickfix/createFromUsage/createFunction/call/funOnJavaType.before.Main.kt +++ b/idea/testData/quickfix/createFromUsage/createFunction/call/funOnJavaType.before.Main.kt @@ -1,6 +1,6 @@ -// "Create extension function 'foo'" "true" +// "Create function 'foo'" "true" // ERROR: Unresolved reference: foo -fun test(): Int { +fun test(): Int? { return A().foo(1, "2") } \ No newline at end of file diff --git a/idea/testData/quickfix/createFromUsage/createFunction/call/genericFunOnJavaType.after.data.Sample.java b/idea/testData/quickfix/createFromUsage/createFunction/call/genericFunOnJavaType.after.data.Sample.java new file mode 100644 index 00000000000..0eea3e96cac --- /dev/null +++ b/idea/testData/quickfix/createFromUsage/createFunction/call/genericFunOnJavaType.after.data.Sample.java @@ -0,0 +1,6 @@ +class A { + + public U foo(U u, T t) { + return null; + } +} \ No newline at end of file diff --git a/idea/testData/quickfix/createFromUsage/createFunction/call/genericFunOnJavaType.after.kt b/idea/testData/quickfix/createFromUsage/createFunction/call/genericFunOnJavaType.after.kt new file mode 100644 index 00000000000..d4e1910e254 --- /dev/null +++ b/idea/testData/quickfix/createFromUsage/createFunction/call/genericFunOnJavaType.after.kt @@ -0,0 +1,7 @@ +// "Create function 'foo'" "true" +// ERROR: Unresolved reference: foo + +fun test(): Int { + return A().foo(1, "2") +} + diff --git a/idea/testData/quickfix/createFromUsage/createFunction/call/genericFunOnJavaType.before.Main.kt b/idea/testData/quickfix/createFromUsage/createFunction/call/genericFunOnJavaType.before.Main.kt new file mode 100644 index 00000000000..f2d82be2d67 --- /dev/null +++ b/idea/testData/quickfix/createFromUsage/createFunction/call/genericFunOnJavaType.before.Main.kt @@ -0,0 +1,6 @@ +// "Create function 'foo'" "true" +// ERROR: Unresolved reference: foo + +fun test(): Int { + return A().foo(1, "2") +} \ No newline at end of file diff --git a/idea/testData/quickfix/createFromUsage/createFunction/call/genericFunOnJavaType.before.data.Sample.java b/idea/testData/quickfix/createFromUsage/createFunction/call/genericFunOnJavaType.before.data.Sample.java new file mode 100644 index 00000000000..1b4568a8f26 --- /dev/null +++ b/idea/testData/quickfix/createFromUsage/createFunction/call/genericFunOnJavaType.before.data.Sample.java @@ -0,0 +1,3 @@ +class A { + +} \ No newline at end of file diff --git a/idea/tests/org/jetbrains/kotlin/idea/quickfix/QuickFixMultiFileTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/quickfix/QuickFixMultiFileTestGenerated.java index a89ce326d92..7ccc94b56b4 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/quickfix/QuickFixMultiFileTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/quickfix/QuickFixMultiFileTestGenerated.java @@ -319,12 +319,42 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/call"), Pattern.compile("^(\\w+)\\.before\\.Main\\.kt$"), true); } + @TestMetadata("extensionFunOnGroovyType.before.Main.kt") + public void testExtensionFunOnGroovyType() throws Exception { + String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createFunction/call/extensionFunOnGroovyType.before.Main.kt"); + doTestWithExtraFile(fileName); + } + + @TestMetadata("extensionFunOnJavaType.before.Main.kt") + public void testExtensionFunOnJavaType() throws Exception { + String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createFunction/call/extensionFunOnJavaType.before.Main.kt"); + doTestWithExtraFile(fileName); + } + + @TestMetadata("funOnGroovyType.before.Main.kt") + public void testFunOnGroovyType() throws Exception { + String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createFunction/call/funOnGroovyType.before.Main.kt"); + doTestWithExtraFile(fileName); + } + + @TestMetadata("funOnJavaInterface.before.Main.kt") + public void testFunOnJavaInterface() throws Exception { + String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createFunction/call/funOnJavaInterface.before.Main.kt"); + doTestWithExtraFile(fileName); + } + @TestMetadata("funOnJavaType.before.Main.kt") public void testFunOnJavaType() throws Exception { String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createFunction/call/funOnJavaType.before.Main.kt"); doTestWithExtraFile(fileName); } + @TestMetadata("genericFunOnJavaType.before.Main.kt") + public void testGenericFunOnJavaType() throws Exception { + String fileName = JetTestUtils.navigationMetadata("idea/testData/quickfix/createFromUsage/createFunction/call/genericFunOnJavaType.before.Main.kt"); + doTestWithExtraFile(fileName); + } + } }