From 7f07890f6a94f715396ab33054eb78c602436358 Mon Sep 17 00:00:00 2001 From: Valentin Kipyatkov Date: Mon, 15 Aug 2016 19:17:33 +0300 Subject: [PATCH] KT-13298 Suggest names for overridden properties / functions in completion #KT-13298 Fixed --- .../idea/completion/BasicCompletionSession.kt | 23 +++++--- .../idea/completion/OverridesCompletion.kt | 57 +++++++++++++------ .../basic/common/override/AfterFunKeyword.kt | 27 +++++++++ .../basic/common/override/AfterValKeyword.kt | 23 ++++++++ .../AfterValKeywordInConstructorParameter.kt | 19 +++++++ .../basic/common/override/AfterVarKeyword.kt | 24 ++++++++ .../override/NoOverrideAfterFunKeyword.kt | 10 ++++ .../testData/basic/common/override/Simple.kt | 12 ++-- .../basic/override/AfterFunKeyword.kt | 9 +++ .../basic/override/AfterFunKeyword.kt.after | 11 ++++ .../AfterFunKeywordKeepModifiersBefore.kt | 6 ++ ...fterFunKeywordKeepModifiersBefore.kt.after | 8 +++ .../basic/override/AfterValKeyword.kt | 9 +++ .../basic/override/AfterValKeyword.kt.after | 10 ++++ .../AfterValKeywordInConstructorParameter.kt | 8 +++ ...rValKeywordInConstructorParameter.kt.after | 10 ++++ .../basic/override/ImplementFunction.kt.after | 2 +- .../test/JSBasicCompletionTestGenerated.java | 30 ++++++++++ .../test/JvmBasicCompletionTestGenerated.java | 30 ++++++++++ .../BasicCompletionHandlerTestGenerated.java | 24 ++++++++ 20 files changed, 319 insertions(+), 33 deletions(-) create mode 100644 idea/idea-completion/testData/basic/common/override/AfterFunKeyword.kt create mode 100644 idea/idea-completion/testData/basic/common/override/AfterValKeyword.kt create mode 100644 idea/idea-completion/testData/basic/common/override/AfterValKeywordInConstructorParameter.kt create mode 100644 idea/idea-completion/testData/basic/common/override/AfterVarKeyword.kt create mode 100644 idea/idea-completion/testData/basic/common/override/NoOverrideAfterFunKeyword.kt create mode 100644 idea/idea-completion/testData/handlers/basic/override/AfterFunKeyword.kt create mode 100644 idea/idea-completion/testData/handlers/basic/override/AfterFunKeyword.kt.after create mode 100644 idea/idea-completion/testData/handlers/basic/override/AfterFunKeywordKeepModifiersBefore.kt create mode 100644 idea/idea-completion/testData/handlers/basic/override/AfterFunKeywordKeepModifiersBefore.kt.after create mode 100644 idea/idea-completion/testData/handlers/basic/override/AfterValKeyword.kt create mode 100644 idea/idea-completion/testData/handlers/basic/override/AfterValKeyword.kt.after create mode 100644 idea/idea-completion/testData/handlers/basic/override/AfterValKeywordInConstructorParameter.kt create mode 100644 idea/idea-completion/testData/handlers/basic/override/AfterValKeywordInConstructorParameter.kt.after diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/BasicCompletionSession.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/BasicCompletionSession.kt index d96c018802d..028c8f871c5 100644 --- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/BasicCompletionSession.kt +++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/BasicCompletionSession.kt @@ -174,7 +174,7 @@ class BasicCompletionSession( override fun doComplete() { val declaration = isStartOfExtensionReceiverFor() if (declaration != null) { - completeDeclarationNameFromUnresolved(declaration) + completeDeclarationNameFromUnresolvedOrOverride(declaration) // no auto-popup on typing after "val", "var" and "fun" because it's likely the name of the declaration which is being typed by user if (parameters.invocationCount == 0) { @@ -379,7 +379,7 @@ class BasicCompletionSession( "override" -> { collector.addElement(lookupElement) - OverridesCompletion(collector, basicLookupElementFactory).complete(position) + OverridesCompletion(collector, basicLookupElementFactory).complete(position, declaration = null) } "class" -> { @@ -436,7 +436,7 @@ class BasicCompletionSession( KEYWORDS_ONLY.doComplete() - completeDeclarationNameFromUnresolved(declaration) + completeDeclarationNameFromUnresolvedOrOverride(declaration) when (declaration) { is KtParameter -> @@ -536,12 +536,17 @@ class BasicCompletionSession( } } - private fun completeDeclarationNameFromUnresolved(declaration: KtNamedDeclaration) { - val referenceScope = referenceScope(declaration) ?: return - val originalScope = toFromOriginalFileMapper.toOriginalFile(referenceScope) ?: return - val afterOffset = if (referenceScope is KtBlockExpression) parameters.offset else null - val descriptor = bindingContext[BindingContext.DECLARATION_TO_DESCRIPTOR, declaration] - FromUnresolvedNamesCompletion(collector, prefixMatcher).addNameSuggestions(originalScope, afterOffset, descriptor) + private fun completeDeclarationNameFromUnresolvedOrOverride(declaration: KtNamedDeclaration) { + if (declaration is KtCallableDeclaration && declaration.hasModifier(KtTokens.OVERRIDE_KEYWORD)) { + OverridesCompletion(collector, basicLookupElementFactory).complete(position, declaration) + } + else { + val referenceScope = referenceScope(declaration) ?: return + val originalScope = toFromOriginalFileMapper.toOriginalFile(referenceScope) ?: return + val afterOffset = if (referenceScope is KtBlockExpression) parameters.offset else null + val descriptor = bindingContext[BindingContext.DECLARATION_TO_DESCRIPTOR, declaration] + FromUnresolvedNamesCompletion(collector, prefixMatcher).addNameSuggestions(originalScope, afterOffset, descriptor) + } } private fun referenceScope(declaration: KtNamedDeclaration): KtElement? { diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/OverridesCompletion.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/OverridesCompletion.kt index 2aeb0a82a6d..3e51407a88f 100644 --- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/OverridesCompletion.kt +++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/OverridesCompletion.kt @@ -24,25 +24,20 @@ import com.intellij.icons.AllIcons import com.intellij.psi.PsiDocumentManager import com.intellij.psi.PsiElement import com.intellij.ui.RowIcon -import org.jetbrains.kotlin.descriptors.ClassDescriptor -import org.jetbrains.kotlin.descriptors.FunctionDescriptor -import org.jetbrains.kotlin.descriptors.Modality -import org.jetbrains.kotlin.descriptors.PropertyDescriptor +import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.idea.KotlinDescriptorIconProvider import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde import org.jetbrains.kotlin.idea.completion.handlers.indexOfSkippingSpace +import org.jetbrains.kotlin.idea.core.ShortenReferences import org.jetbrains.kotlin.idea.core.completion.DeclarationLookupObject +import org.jetbrains.kotlin.idea.core.moveCaret +import org.jetbrains.kotlin.idea.core.moveCaretIntoGeneratedElement import org.jetbrains.kotlin.idea.core.overrideImplement.OverrideMembersHandler import org.jetbrains.kotlin.idea.core.overrideImplement.generateMember import org.jetbrains.kotlin.idea.core.replaced -import org.jetbrains.kotlin.idea.core.moveCaret -import org.jetbrains.kotlin.idea.core.moveCaretIntoGeneratedElement import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers -import org.jetbrains.kotlin.idea.core.ShortenReferences -import org.jetbrains.kotlin.psi.KtClassOrObject -import org.jetbrains.kotlin.psi.KtNamedDeclaration -import org.jetbrains.kotlin.psi.KtPrimaryConstructor -import org.jetbrains.kotlin.psi.KtPsiFactory +import org.jetbrains.kotlin.lexer.KtTokens +import org.jetbrains.kotlin.psi.* import org.jetbrains.kotlin.psi.psiUtil.endOffset import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType @@ -55,7 +50,7 @@ class OverridesCompletion( modifiers = emptySet() } - fun complete(position: PsiElement) { + fun complete(position: PsiElement, declaration: KtCallableDeclaration?) { val isConstructorParameter = position.getNonStrictParentOfType() != null val classOrObject = position.getNonStrictParentOfType() ?: return @@ -63,9 +58,10 @@ class OverridesCompletion( val members = OverrideMembersHandler(isConstructorParameter).collectMembersToGenerate(classOrObject) for (memberObject in members) { - if (isConstructorParameter && memberObject.descriptor !is PropertyDescriptor) continue - val descriptor = memberObject.descriptor + if (declaration != null && !canOverride(descriptor, declaration)) continue + if (isConstructorParameter && descriptor !is PropertyDescriptor) continue + var lookupElement = lookupElementFactory.createLookupElement(descriptor) var text = "override " + PRESENTATION_RENDERER.render(descriptor) @@ -88,7 +84,7 @@ class OverridesCompletion( val baseClassIcon = KotlinDescriptorIconProvider.getIcon(baseClass, baseClassDeclaration, 0) lookupElement = object : LookupElementDecorator(lookupElement) { - override fun getLookupString() = "override" + override fun getLookupString() = if (declaration == null) "override" else delegate.lookupString // don't use "override" as lookup string when already in the name of declaration override fun getAllLookupStrings() = setOf(lookupString, delegate.lookupString) override fun renderElement(presentation: LookupElementPresentation) { @@ -102,8 +98,16 @@ class OverridesCompletion( } override fun handleInsert(context: InsertionContext) { - val chars = context.document.charsSequence - val dummyMemberText = if (isConstructorParameter) "override val dummy: Dummy ,@" else "override fun dummy() {}" + val dummyMemberHead = when { + declaration != null -> "" + isConstructorParameter -> "override val " + else -> "override fun " + } + val dummyMemberTail = when { + isConstructorParameter || declaration is KtProperty -> "dummy: Dummy ,@" + else -> "dummy() {}" + } + val dummyMemberText = dummyMemberHead + dummyMemberTail context.document.replaceString(context.startOffset, context.tailOffset, dummyMemberText) val psiDocumentManager = PsiDocumentManager.getInstance(context.project) @@ -124,6 +128,7 @@ class OverridesCompletion( psiDocumentManager.doPostponedOperationsAndUnblockDocument(context.document) val offset = insertedMember.endOffset + val chars = context.document.charsSequence val commaOffset = chars.indexOfSkippingSpace(',', offset)!! val atCharOffset = chars.indexOfSkippingSpace('@', commaOffset + 1)!! context.document.deleteString(offset, atCharOffset + 1) @@ -141,4 +146,22 @@ class OverridesCompletion( collector.addElement(lookupElement) } } + + private fun canOverride(descriptorToOverride: CallableMemberDescriptor, declaration: KtCallableDeclaration): Boolean { + when (declaration) { + is KtFunction -> return descriptorToOverride is FunctionDescriptor + + is KtValVarKeywordOwner -> { + if (descriptorToOverride !is PropertyDescriptor) return false + if (declaration.valOrVarKeyword?.node?.elementType == KtTokens.VAL_KEYWORD) { + return !descriptorToOverride.isVar + } + else { + return true // var can override either var or val + } + } + + else -> return false + } + } } \ No newline at end of file diff --git a/idea/idea-completion/testData/basic/common/override/AfterFunKeyword.kt b/idea/idea-completion/testData/basic/common/override/AfterFunKeyword.kt new file mode 100644 index 00000000000..4be42734a18 --- /dev/null +++ b/idea/idea-completion/testData/basic/common/override/AfterFunKeyword.kt @@ -0,0 +1,27 @@ +interface I { + fun foo() + val someVal: Int + var someVar: Int +} + +class Base1 { + protected open fun bar(){} +} + +open class Base2 : Base1() { +} + +class A : Base2(), I { + fun x() { + unresolved1(unresolved2) + } + + override fun +} + +// EXIST: { itemText: "override fun bar() {...}", lookupString: "bar", tailText: null, typeText: "Base1", attributes: "" } +// EXIST: { itemText: "override fun foo() {...}", lookupString: "foo", tailText: null, typeText: "I", attributes: "bold" } +// EXIST: { itemText: "override operator fun equals(other: Any?): Boolean {...}", lookupString: "equals", tailText: null, typeText: "Any", attributes: "" } +// EXIST: { itemText: "override fun hashCode(): Int {...}", lookupString: "hashCode", tailText: null, typeText: "Any", attributes: "" } +// EXIST: { itemText: "override fun toString(): String {...}", lookupString: "toString", tailText: null, typeText: "Any", attributes: "" } +// NOTHING_ELSE diff --git a/idea/idea-completion/testData/basic/common/override/AfterValKeyword.kt b/idea/idea-completion/testData/basic/common/override/AfterValKeyword.kt new file mode 100644 index 00000000000..44dd5c763b2 --- /dev/null +++ b/idea/idea-completion/testData/basic/common/override/AfterValKeyword.kt @@ -0,0 +1,23 @@ +interface I { + fun foo() + val someVal: Int + var someVar: Int +} + +class Base1 { + protected open fun bar(){} +} + +open class Base2 : Base1() { +} + +class A : Base2(), I { + fun x() { + unresolved1(unresolved2) + } + + override val +} + +// EXIST: { itemText: "override val someVal: Int", lookupString: "someVal", tailText: null, typeText: "I", attributes: "bold" } +// NOTHING_ELSE diff --git a/idea/idea-completion/testData/basic/common/override/AfterValKeywordInConstructorParameter.kt b/idea/idea-completion/testData/basic/common/override/AfterValKeywordInConstructorParameter.kt new file mode 100644 index 00000000000..db4105fab1b --- /dev/null +++ b/idea/idea-completion/testData/basic/common/override/AfterValKeywordInConstructorParameter.kt @@ -0,0 +1,19 @@ +interface I { + fun foo() + val someVal: Int + var someVar: Int +} + +class Base1 { + protected open fun bar(){} + open val fromBase: String = "" +} + +open class Base2 : Base1() { +} + +class A(override val ) : Base2(), I + +// EXIST: { itemText: "override val someVal: Int", tailText: null, typeText: "I", attributes: "bold" } +// EXIST: { itemText: "override val fromBase: String", tailText: null, typeText: "Base1", attributes: "" } +// NOTHING_ELSE diff --git a/idea/idea-completion/testData/basic/common/override/AfterVarKeyword.kt b/idea/idea-completion/testData/basic/common/override/AfterVarKeyword.kt new file mode 100644 index 00000000000..5cd79e74394 --- /dev/null +++ b/idea/idea-completion/testData/basic/common/override/AfterVarKeyword.kt @@ -0,0 +1,24 @@ +interface I { + fun foo() + val someVal: Int + var someVar: Int +} + +class Base1 { + protected open fun bar(){} +} + +open class Base2 : Base1() { +} + +class A : Base2(), I { + fun x() { + unresolved1(unresolved2) + } + + override var +} + +// EXIST: { itemText: "override val someVal: Int", lookupString: "someVal", tailText: null, typeText: "I", attributes: "bold" } +// EXIST: { itemText: "override var someVar: Int", lookupString: "someVar", tailText: null, typeText: "I", attributes: "bold" } +// NOTHING_ELSE diff --git a/idea/idea-completion/testData/basic/common/override/NoOverrideAfterFunKeyword.kt b/idea/idea-completion/testData/basic/common/override/NoOverrideAfterFunKeyword.kt new file mode 100644 index 00000000000..7240bd2067e --- /dev/null +++ b/idea/idea-completion/testData/basic/common/override/NoOverrideAfterFunKeyword.kt @@ -0,0 +1,10 @@ +interface I { + fun ov_foo() +} + +class A : I { + override fun ov +} + +// ABSENT: override +// EXIST: { itemText: "override fun ov_foo() {...}", allLookupStrings: "ov_foo", tailText: null, typeText: "I", attributes: "bold" } diff --git a/idea/idea-completion/testData/basic/common/override/Simple.kt b/idea/idea-completion/testData/basic/common/override/Simple.kt index d298cb13e3c..c98c57be1c5 100644 --- a/idea/idea-completion/testData/basic/common/override/Simple.kt +++ b/idea/idea-completion/testData/basic/common/override/Simple.kt @@ -16,9 +16,9 @@ class A : Base2(), I { } // EXIST: { lookupString: "override", itemText: "override" } -// EXIST: { itemText: "override fun bar() {...}", lookupString: "override", tailText: null, typeText: "Base1", attributes: "" } -// EXIST: { itemText: "override operator fun equals(other: Any?): Boolean {...}", lookupString: "override", tailText: null, typeText: "Any", attributes: "" } -// EXIST: { itemText: "override fun foo() {...}", lookupString: "override", tailText: null, typeText: "I", attributes: "bold" } -// EXIST: { itemText: "override fun hashCode(): Int {...}", lookupString: "override", tailText: null, typeText: "Any", attributes: "" } -// EXIST: { itemText: "override val someVal: Int", lookupString: "override", tailText: null, typeText: "I", attributes: "bold" } -// EXIST: { itemText: "override var someVar: Int", lookupString: "override", tailText: null, typeText: "I", attributes: "bold" } +// EXIST: { itemText: "override fun bar() {...}", lookupString: "override", allLookupStrings: "bar, override", tailText: null, typeText: "Base1", attributes: "" } +// EXIST: { itemText: "override operator fun equals(other: Any?): Boolean {...}", lookupString: "override", allLookupStrings: "equals, override", tailText: null, typeText: "Any", attributes: "" } +// EXIST: { itemText: "override fun foo() {...}", lookupString: "override", allLookupStrings: "foo, override", tailText: null, typeText: "I", attributes: "bold" } +// EXIST: { itemText: "override fun hashCode(): Int {...}", lookupString: "override", allLookupStrings: "hashCode, override", tailText: null, typeText: "Any", attributes: "" } +// EXIST: { itemText: "override val someVal: Int", lookupString: "override", allLookupStrings: "override, someVal", tailText: null, typeText: "I", attributes: "bold" } +// EXIST: { itemText: "override var someVar: Int", lookupString: "override", allLookupStrings: "override, someVar", tailText: null, typeText: "I", attributes: "bold" } diff --git a/idea/idea-completion/testData/handlers/basic/override/AfterFunKeyword.kt b/idea/idea-completion/testData/handlers/basic/override/AfterFunKeyword.kt new file mode 100644 index 00000000000..de78c6d10c3 --- /dev/null +++ b/idea/idea-completion/testData/handlers/basic/override/AfterFunKeyword.kt @@ -0,0 +1,9 @@ +interface I { + fun foo(p: Int) +} + +class A : I { + override fun f +} + +// ELEMENT_TEXT: "override fun foo(p: Int) {...}" diff --git a/idea/idea-completion/testData/handlers/basic/override/AfterFunKeyword.kt.after b/idea/idea-completion/testData/handlers/basic/override/AfterFunKeyword.kt.after new file mode 100644 index 00000000000..02cbc389f9c --- /dev/null +++ b/idea/idea-completion/testData/handlers/basic/override/AfterFunKeyword.kt.after @@ -0,0 +1,11 @@ +interface I { + fun foo(p: Int) +} + +class A : I { + override fun foo(p: Int) { + TODO("not implemented") //To change body of created functions use File | Settings | File Templates. + } +} + +// ELEMENT_TEXT: "override fun foo(p: Int) {...}" diff --git a/idea/idea-completion/testData/handlers/basic/override/AfterFunKeywordKeepModifiersBefore.kt b/idea/idea-completion/testData/handlers/basic/override/AfterFunKeywordKeepModifiersBefore.kt new file mode 100644 index 00000000000..d1a0a588971 --- /dev/null +++ b/idea/idea-completion/testData/handlers/basic/override/AfterFunKeywordKeepModifiersBefore.kt @@ -0,0 +1,6 @@ +class A { + @Deprecated("") // it is deprecated + public override fun e +} + +// ELEMENT_TEXT: "override operator fun equals(other: Any?): Boolean {...}" diff --git a/idea/idea-completion/testData/handlers/basic/override/AfterFunKeywordKeepModifiersBefore.kt.after b/idea/idea-completion/testData/handlers/basic/override/AfterFunKeywordKeepModifiersBefore.kt.after new file mode 100644 index 00000000000..0216d9dca4d --- /dev/null +++ b/idea/idea-completion/testData/handlers/basic/override/AfterFunKeywordKeepModifiersBefore.kt.after @@ -0,0 +1,8 @@ +class A { + @Deprecated("") // it is deprecated + public override fun equals(other: Any?): Boolean { + return super.equals(other) + } +} + +// ELEMENT_TEXT: "override operator fun equals(other: Any?): Boolean {...}" diff --git a/idea/idea-completion/testData/handlers/basic/override/AfterValKeyword.kt b/idea/idea-completion/testData/handlers/basic/override/AfterValKeyword.kt new file mode 100644 index 00000000000..82dd137e89e --- /dev/null +++ b/idea/idea-completion/testData/handlers/basic/override/AfterValKeyword.kt @@ -0,0 +1,9 @@ +interface I { + val someVal: String? +} + +class A : I { + override val +} + +// ELEMENT_TEXT: "override val someVal: String?" diff --git a/idea/idea-completion/testData/handlers/basic/override/AfterValKeyword.kt.after b/idea/idea-completion/testData/handlers/basic/override/AfterValKeyword.kt.after new file mode 100644 index 00000000000..14b57b1755e --- /dev/null +++ b/idea/idea-completion/testData/handlers/basic/override/AfterValKeyword.kt.after @@ -0,0 +1,10 @@ +interface I { + val someVal: String? +} + +class A : I { + override val someVal: String? + get() = throw UnsupportedOperationException() +} + +// ELEMENT_TEXT: "override val someVal: String?" diff --git a/idea/idea-completion/testData/handlers/basic/override/AfterValKeywordInConstructorParameter.kt b/idea/idea-completion/testData/handlers/basic/override/AfterValKeywordInConstructorParameter.kt new file mode 100644 index 00000000000..2b0c03128c2 --- /dev/null +++ b/idea/idea-completion/testData/handlers/basic/override/AfterValKeywordInConstructorParameter.kt @@ -0,0 +1,8 @@ +interface I { + val someVal: java.io.File? +} + +class A(override val s) : I { +} + +// ELEMENT_TEXT: "override val someVal: File?" diff --git a/idea/idea-completion/testData/handlers/basic/override/AfterValKeywordInConstructorParameter.kt.after b/idea/idea-completion/testData/handlers/basic/override/AfterValKeywordInConstructorParameter.kt.after new file mode 100644 index 00000000000..d341a84ed25 --- /dev/null +++ b/idea/idea-completion/testData/handlers/basic/override/AfterValKeywordInConstructorParameter.kt.after @@ -0,0 +1,10 @@ +import java.io.File + +interface I { + val someVal: java.io.File? +} + +class A(override val someVal: File?) : I { +} + +// ELEMENT_TEXT: "override val someVal: File?" diff --git a/idea/idea-completion/testData/handlers/basic/override/ImplementFunction.kt.after b/idea/idea-completion/testData/handlers/basic/override/ImplementFunction.kt.after index fb847c321be..02cbc389f9c 100644 --- a/idea/idea-completion/testData/handlers/basic/override/ImplementFunction.kt.after +++ b/idea/idea-completion/testData/handlers/basic/override/ImplementFunction.kt.after @@ -4,7 +4,7 @@ interface I { class A : I { override fun foo(p: Int) { - TODO("not implemented") //To change body of created functions use File | Settings | File Templates. + TODO("not implemented") //To change body of created functions use File | Settings | File Templates. } } diff --git a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/JSBasicCompletionTestGenerated.java b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/JSBasicCompletionTestGenerated.java index c8a118d1b56..25cc68d2531 100644 --- a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/JSBasicCompletionTestGenerated.java +++ b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/JSBasicCompletionTestGenerated.java @@ -1913,6 +1913,30 @@ public class JSBasicCompletionTestGenerated extends AbstractJSBasicCompletionTes @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) public static class Override extends AbstractJSBasicCompletionTest { + @TestMetadata("AfterFunKeyword.kt") + public void testAfterFunKeyword() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/override/AfterFunKeyword.kt"); + doTest(fileName); + } + + @TestMetadata("AfterValKeyword.kt") + public void testAfterValKeyword() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/override/AfterValKeyword.kt"); + doTest(fileName); + } + + @TestMetadata("AfterValKeywordInConstructorParameter.kt") + public void testAfterValKeywordInConstructorParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/override/AfterValKeywordInConstructorParameter.kt"); + doTest(fileName); + } + + @TestMetadata("AfterVarKeyword.kt") + public void testAfterVarKeyword() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/override/AfterVarKeyword.kt"); + doTest(fileName); + } + public void testAllFilesPresentInOverride() throws Exception { KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/idea-completion/testData/basic/common/override"), Pattern.compile("^(.+)\\.kt$"), true); } @@ -1935,6 +1959,12 @@ public class JSBasicCompletionTestGenerated extends AbstractJSBasicCompletionTes doTest(fileName); } + @TestMetadata("NoOverrideAfterFunKeyword.kt") + public void testNoOverrideAfterFunKeyword() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/override/NoOverrideAfterFunKeyword.kt"); + doTest(fileName); + } + @TestMetadata("PreferImplementToOverride.kt") public void testPreferImplementToOverride() throws Exception { String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/override/PreferImplementToOverride.kt"); diff --git a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/JvmBasicCompletionTestGenerated.java b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/JvmBasicCompletionTestGenerated.java index 4bf88c6d769..12f1509442f 100644 --- a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/JvmBasicCompletionTestGenerated.java +++ b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/JvmBasicCompletionTestGenerated.java @@ -1913,6 +1913,30 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) public static class Override extends AbstractJvmBasicCompletionTest { + @TestMetadata("AfterFunKeyword.kt") + public void testAfterFunKeyword() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/override/AfterFunKeyword.kt"); + doTest(fileName); + } + + @TestMetadata("AfterValKeyword.kt") + public void testAfterValKeyword() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/override/AfterValKeyword.kt"); + doTest(fileName); + } + + @TestMetadata("AfterValKeywordInConstructorParameter.kt") + public void testAfterValKeywordInConstructorParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/override/AfterValKeywordInConstructorParameter.kt"); + doTest(fileName); + } + + @TestMetadata("AfterVarKeyword.kt") + public void testAfterVarKeyword() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/override/AfterVarKeyword.kt"); + doTest(fileName); + } + public void testAllFilesPresentInOverride() throws Exception { KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/idea-completion/testData/basic/common/override"), Pattern.compile("^(.+)\\.kt$"), true); } @@ -1935,6 +1959,12 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT doTest(fileName); } + @TestMetadata("NoOverrideAfterFunKeyword.kt") + public void testNoOverrideAfterFunKeyword() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/override/NoOverrideAfterFunKeyword.kt"); + doTest(fileName); + } + @TestMetadata("PreferImplementToOverride.kt") public void testPreferImplementToOverride() throws Exception { String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/basic/common/override/PreferImplementToOverride.kt"); diff --git a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/handlers/BasicCompletionHandlerTestGenerated.java b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/handlers/BasicCompletionHandlerTestGenerated.java index 76b7a65f1f3..1365870a580 100644 --- a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/handlers/BasicCompletionHandlerTestGenerated.java +++ b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/handlers/BasicCompletionHandlerTestGenerated.java @@ -426,6 +426,30 @@ public class BasicCompletionHandlerTestGenerated extends AbstractBasicCompletion @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) public static class Override extends AbstractBasicCompletionHandlerTest { + @TestMetadata("AfterFunKeyword.kt") + public void testAfterFunKeyword() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/handlers/basic/override/AfterFunKeyword.kt"); + doTest(fileName); + } + + @TestMetadata("AfterFunKeywordKeepModifiersBefore.kt") + public void testAfterFunKeywordKeepModifiersBefore() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/handlers/basic/override/AfterFunKeywordKeepModifiersBefore.kt"); + doTest(fileName); + } + + @TestMetadata("AfterValKeyword.kt") + public void testAfterValKeyword() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/handlers/basic/override/AfterValKeyword.kt"); + doTest(fileName); + } + + @TestMetadata("AfterValKeywordInConstructorParameter.kt") + public void testAfterValKeywordInConstructorParameter() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("idea/idea-completion/testData/handlers/basic/override/AfterValKeywordInConstructorParameter.kt"); + doTest(fileName); + } + public void testAllFilesPresentInOverride() throws Exception { KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/override"), Pattern.compile("^(.+)\\.kt$"), true); }