diff --git a/annotations/com/intellij/patterns/annotations.xml b/annotations/com/intellij/patterns/annotations.xml index 7a2165d4dcf..76384a6eb72 100644 --- a/annotations/com/intellij/patterns/annotations.xml +++ b/annotations/com/intellij/patterns/annotations.xml @@ -1,6 +1,17 @@ + + + + + + + + + \ No newline at end of file diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/psiUtil/jetPsiUtil.kt b/compiler/frontend/src/org/jetbrains/jet/lang/psi/psiUtil/jetPsiUtil.kt index e092dfd589e..8a05268a461 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/psiUtil/jetPsiUtil.kt +++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/psiUtil/jetPsiUtil.kt @@ -16,44 +16,34 @@ package org.jetbrains.jet.lang.psi.psiUtil +import org.jetbrains.jet.lang.psi.* import com.intellij.psi.PsiElement import com.intellij.psi.PsiFile import com.intellij.psi.util.PsiTreeUtil -import org.jetbrains.jet.lang.psi.JetDeclaration -import org.jetbrains.jet.lang.psi.JetClass -import org.jetbrains.jet.lang.psi.JetClassOrObject import org.jetbrains.jet.lexer.JetTokens import java.util.Collections import com.intellij.extapi.psi.StubBasedPsiElementBase -import org.jetbrains.jet.lang.psi.stubs.PsiJetClassOrObjectStub -import org.jetbrains.jet.lang.psi.JetFile -import org.jetbrains.jet.lang.psi.JetDotQualifiedExpression -import org.jetbrains.jet.lang.psi.JetSimpleNameExpression import java.util.ArrayList -import org.jetbrains.jet.lang.psi.JetElement -import org.jetbrains.jet.lang.psi.JetBlockExpression -import org.jetbrains.jet.lang.psi.JetPsiUtil -import org.jetbrains.jet.lang.psi.JetPsiFactory import kotlin.test.assertTrue import com.intellij.psi.search.SearchScope import com.intellij.psi.search.PsiSearchScopeUtil -import org.jetbrains.jet.lang.psi.JetClassBody -import org.jetbrains.jet.lang.psi.JetParameterList -import org.jetbrains.jet.lang.psi.JetObjectDeclaration -import org.jetbrains.jet.lang.psi.JetNamedFunction -import org.jetbrains.jet.lang.psi.JetProperty -import org.jetbrains.jet.lang.psi.JetCallableDeclaration -import org.jetbrains.jet.lang.psi.JetPropertyAccessor -import org.jetbrains.jet.lang.psi.JetParameter import com.intellij.psi.PsiParameterList import com.intellij.psi.PsiParameter -import org.jetbrains.jet.lang.psi.JetQualifiedExpression -import org.jetbrains.jet.lang.psi.JetUserType -import org.jetbrains.jet.lang.psi.JetCallExpression import com.intellij.psi.PsiPackage import com.intellij.psi.JavaDirectoryService import com.intellij.psi.PsiDirectory -import org.jetbrains.jet.lang.psi.JetModifierListOwner +import org.jetbrains.jet.lang.psi.stubs.PsiJetClassOrObjectStub + +public fun JetCallElement.getCallNameExpression(): JetSimpleNameExpression? { + val calleeExpression = getCalleeExpression() + if (calleeExpression == null) return null + + return when (calleeExpression) { + is JetSimpleNameExpression -> calleeExpression + is JetConstructorCalleeExpression -> calleeExpression.getConstructorReferenceExpression() as? JetSimpleNameExpression + else -> null + } +} public fun PsiElement.getParentByTypesAndPredicate( strict : Boolean = false, vararg parentClasses : Class, predicate: (T) -> Boolean diff --git a/idea/src/META-INF/plugin.xml b/idea/src/META-INF/plugin.xml index 91551ddd72f..c73148b46bf 100644 --- a/idea/src/META-INF/plugin.xml +++ b/idea/src/META-INF/plugin.xml @@ -209,7 +209,10 @@ - + + getUsedParameters( + @NotNull JetCallElement callElement, + @Nullable JetValueArgument ignoreArgument, + @NotNull CallableDescriptor callableDescriptor + ) { + Set usedParameters = Sets.newHashSet(); + boolean isPositionalArgument = true; + int idx = 0; + for (ValueArgument argument : callElement.getValueArguments()) { + if (argument.isNamed()) { + JetValueArgumentName name = argument.getArgumentName(); + assert name != null : "Named argument's name cannot be null"; + if (argument != ignoreArgument) { + usedParameters.add(name.getText()); + } + isPositionalArgument = false; + } + else if (isPositionalArgument) { + ValueParameterDescriptor parameter = callableDescriptor.getValueParameters().get(idx); + if (argument != ignoreArgument) { + usedParameters.add(parameter.getName().asString()); + } + idx++; + } + } + + return usedParameters; + } } diff --git a/idea/src/org/jetbrains/jet/plugin/util/psiFilters.kt b/idea/src/org/jetbrains/jet/plugin/util/psiFilters.kt new file mode 100644 index 00000000000..eb098708b11 --- /dev/null +++ b/idea/src/org/jetbrains/jet/plugin/util/psiFilters.kt @@ -0,0 +1,41 @@ +/* + * Copyright 2010-2014 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.plugin.util + +import com.intellij.psi.filters.position.PositionElementFilter +import com.intellij.psi.PsiElement +import com.intellij.psi.util.PsiTreeUtil + +public class FirstChildInParentFilter(val level: Int = 1) : PositionElementFilter() { + override fun isAcceptable(element: Any?, context: PsiElement?): Boolean { + if (!(element is PsiElement)) return false + + var parent: PsiElement? = element + for (i in 1..level) { + if (parent == null) break + parent = parent?.getContext() + } + + return (parent != null) && PsiTreeUtil.isAncestor(parent?.getFirstChild(), element, true) + } + + + override fun toString(): String { + return "firstChildInParent($level)" + } +} + diff --git a/idea/testData/completion/basic/common/namedParameters/AfterBrace.kt b/idea/testData/completion/basic/common/namedParameters/AfterBrace.kt new file mode 100644 index 00000000000..f7e60aff425 --- /dev/null +++ b/idea/testData/completion/basic/common/namedParameters/AfterBrace.kt @@ -0,0 +1,6 @@ +fun small(param: Int) { +} + +fun test() = small() + +// EXIST: {"lookupString":"param","tailText":"Int","itemText":"param = "} \ No newline at end of file diff --git a/idea/testData/completion/basic/common/namedParameters/AfterComma.kt b/idea/testData/completion/basic/common/namedParameters/AfterComma.kt new file mode 100644 index 00000000000..bbef0242e95 --- /dev/null +++ b/idea/testData/completion/basic/common/namedParameters/AfterComma.kt @@ -0,0 +1,7 @@ +fun small(first: Int, second: Int) { +} + +fun test() = small(12, ) + +// ABSENT: first +// EXIST: second \ No newline at end of file diff --git a/idea/testData/completion/basic/common/namedParameters/CompactTypeNames.kt b/idea/testData/completion/basic/common/namedParameters/CompactTypeNames.kt new file mode 100644 index 00000000000..4051aec5f1c --- /dev/null +++ b/idea/testData/completion/basic/common/namedParameters/CompactTypeNames.kt @@ -0,0 +1,11 @@ +import java.util.ArrayList + +val paramTest = 12 + +fun small(paramFirst: ArrayList, paramSecond: Comparable) { +} + +fun test() = small() + +// EXIST: {"lookupString":"paramSecond","tailText":"Comparable","itemText":"paramSecond = "} +// EXIST: {"lookupString":"paramFirst","tailText":"ArrayList","itemText":"paramFirst = "} \ No newline at end of file diff --git a/idea/testData/completion/basic/common/namedParameters/InParameterExpression.kt b/idea/testData/completion/basic/common/namedParameters/InParameterExpression.kt new file mode 100644 index 00000000000..376790fec2c --- /dev/null +++ b/idea/testData/completion/basic/common/namedParameters/InParameterExpression.kt @@ -0,0 +1,11 @@ +val paramTest = 12 + +fun small(paramFirst: Int, paramSecond: Int) { +} + +fun test() = small(paramFirst = param) + +// EXIST: paramTest +// ABSENT: {"lookupString":"paramFirst","tailText":"Int","itemText":"paramFirst = "} +// ABSENT: paramSecond +// NUMBER: 1 \ No newline at end of file diff --git a/idea/testData/completion/basic/common/namedParameters/NamedParametersFromOverloads.kt b/idea/testData/completion/basic/common/namedParameters/NamedParametersFromOverloads.kt new file mode 100644 index 00000000000..9251c69430a --- /dev/null +++ b/idea/testData/completion/basic/common/namedParameters/NamedParametersFromOverloads.kt @@ -0,0 +1,20 @@ +package test + +val nLocal = 12 + +class foo(nClassParam: String, val nClassField: String) +fun foo(nFirst: String) = 12 +fun foo(nSecond: String? = null, nThird: Int = 1) { } + +fun other() { + foo(n) +} + +// EXIST: nFirst +// EXIST: nSecond +// EXIST: nThird +// EXIST: nLocal + +// todo - should exist +// ABSENT: nClassParam +// ABSENT: nClassField \ No newline at end of file diff --git a/idea/testData/completion/basic/common/namedParameters/NamedParamsInConstructor.kt b/idea/testData/completion/basic/common/namedParameters/NamedParamsInConstructor.kt new file mode 100644 index 00000000000..e759db3d59f --- /dev/null +++ b/idea/testData/completion/basic/common/namedParameters/NamedParamsInConstructor.kt @@ -0,0 +1,10 @@ +package test + +class Foo(pFirst: String? = null, val pSecond: Int = 1) { } + +fun other() { + Foo(p) +} + +// EXIST: {"lookupString":"pFirst","tailText":"String?","itemText":"pFirst = "} +// EXIST: {"lookupString":"pSecond","tailText":"Int","itemText":"pSecond = "} \ No newline at end of file diff --git a/idea/testData/completion/basic/common/namedParameters/NoAlreadyUsedParameters.kt b/idea/testData/completion/basic/common/namedParameters/NoAlreadyUsedParameters.kt new file mode 100644 index 00000000000..d1fce8ccd54 --- /dev/null +++ b/idea/testData/completion/basic/common/namedParameters/NoAlreadyUsedParameters.kt @@ -0,0 +1,11 @@ +fun foo(paramFirst: String, paramSecond: String, paramThird: String, paramFourth: String) {} + +fun test() { + foo("str", paramThird = "test", param) +} + +// ABSENT: paramFirst +// EXIST: paramSecond +// ABSENT: paramThird +// EXIST: paramFourth + diff --git a/idea/testData/completion/basic/common/namedParameters/NoParamsFromUnapplicableOverload.kt b/idea/testData/completion/basic/common/namedParameters/NoParamsFromUnapplicableOverload.kt new file mode 100644 index 00000000000..0208ec5f0ce --- /dev/null +++ b/idea/testData/completion/basic/common/namedParameters/NoParamsFromUnapplicableOverload.kt @@ -0,0 +1,11 @@ +fun foo(paramFirst: Int, paramSecond: Int) = 12 +fun foo(paramThird: String, paramFourth: String) = 1 + +fun test() { + foo(12, param) +} + +// ABSENT: paramFirst +// EXIST: {"lookupString":"paramSecond","tailText":"Int","itemText":"paramSecond = "} +// ABSENT: paramThird +// ABSENT: paramFourth \ No newline at end of file diff --git a/idea/testData/completion/basic/common/namedParameters/WithParameterExpression.kt b/idea/testData/completion/basic/common/namedParameters/WithParameterExpression.kt new file mode 100644 index 00000000000..7ea28caec37 --- /dev/null +++ b/idea/testData/completion/basic/common/namedParameters/WithParameterExpression.kt @@ -0,0 +1,12 @@ +val paramTest = 12 + +fun small(paramFirst: Int, paramSecond: Int) { +} + +fun test() = small(paramFirst = 12) + +// EXIST: paramFirst +// EXIST: paramSecond +// ABSENT: paramTest + +// NUMBER: 2 \ No newline at end of file diff --git a/idea/testData/completion/handlers/NamedParametersCompletion.kt b/idea/testData/completion/handlers/NamedParametersCompletion.kt new file mode 100644 index 00000000000..1d8b7fc91ac --- /dev/null +++ b/idea/testData/completion/handlers/NamedParametersCompletion.kt @@ -0,0 +1,6 @@ +fun foo(paramTest: Int = 12) + +fun test() { + // '=' is expected + foo(param) +} diff --git a/idea/testData/completion/handlers/NamedParametersCompletion.kt.after b/idea/testData/completion/handlers/NamedParametersCompletion.kt.after new file mode 100644 index 00000000000..a8260104078 --- /dev/null +++ b/idea/testData/completion/handlers/NamedParametersCompletion.kt.after @@ -0,0 +1,6 @@ +fun foo(paramTest: Int = 12) + +fun test() { + // '=' is expected + foo(paramTest = ) +} diff --git a/idea/testData/completion/handlers/NamedParametersCompletionOnEqual.kt b/idea/testData/completion/handlers/NamedParametersCompletionOnEqual.kt new file mode 100644 index 00000000000..ee16b7079b6 --- /dev/null +++ b/idea/testData/completion/handlers/NamedParametersCompletionOnEqual.kt @@ -0,0 +1,8 @@ +val paramVal = 12 +fun foo(paramTest: Int = 12) +fun paramFun() {} + +fun test() { + // Type '=', completion should be finishied + foo(param) +} diff --git a/idea/testData/completion/handlers/NamedParametersCompletionOnEqual.kt.after b/idea/testData/completion/handlers/NamedParametersCompletionOnEqual.kt.after new file mode 100644 index 00000000000..33eaf1b2c4e --- /dev/null +++ b/idea/testData/completion/handlers/NamedParametersCompletionOnEqual.kt.after @@ -0,0 +1,8 @@ +val paramVal = 12 +fun foo(paramTest: Int = 12) +fun paramFun() {} + +fun test() { + // Type '=', completion should be finishied + foo(paramTest = ) +} diff --git a/idea/testData/completion/weighers/NamedParameters.Data.kt b/idea/testData/completion/weighers/NamedParameters.Data.kt new file mode 100644 index 00000000000..ec21a57ba99 --- /dev/null +++ b/idea/testData/completion/weighers/NamedParameters.Data.kt @@ -0,0 +1,10 @@ +package temp.test + +class Options(val listNew: Boolean, val listMatch: Boolean) { +} + +fun listImportedFun() = 12 +val listImportedVal = 11 + + + diff --git a/idea/testData/completion/weighers/NamedParameters.kt b/idea/testData/completion/weighers/NamedParameters.kt new file mode 100644 index 00000000000..815a2704cb1 --- /dev/null +++ b/idea/testData/completion/weighers/NamedParameters.kt @@ -0,0 +1,22 @@ +package test + +import temp.test.* + +val listThisFileVal = 12 +fun listThisFileFun() = 1 + +class ListThisFileClass {} + +fun test(listParam: Int) { + val listLocalVal = 12 + Options(list) +} + +// ORDER: listLocalVal +// ORDER: listParam +// ORDER: listThisFileVal +// ORDER: listImportedVal +// ORDER: listMatch +// ORDER: listNew +// ORDER: listThisFileFun +// ORDER: listImportedFun \ No newline at end of file diff --git a/idea/tests/org/jetbrains/jet/completion/JSBasicCompletionTestGenerated.java b/idea/tests/org/jetbrains/jet/completion/JSBasicCompletionTestGenerated.java index e186e308724..c672a3bd746 100644 --- a/idea/tests/org/jetbrains/jet/completion/JSBasicCompletionTestGenerated.java +++ b/idea/tests/org/jetbrains/jet/completion/JSBasicCompletionTestGenerated.java @@ -33,7 +33,7 @@ import org.jetbrains.jet.completion.AbstractJSBasicCompletionTest; @InnerTestClasses({JSBasicCompletionTestGenerated.Common.class, JSBasicCompletionTestGenerated.Js.class}) public class JSBasicCompletionTestGenerated extends AbstractJSBasicCompletionTest { @TestMetadata("idea/testData/completion/basic/common") - @InnerTestClasses({Common.Extensions.class}) + @InnerTestClasses({Common.Extensions.class, Common.NamedParameters.class}) public static class Common extends AbstractJSBasicCompletionTest { @TestMetadata("AfterFloatOnNewLine.kt") public void testAfterFloatOnNewLine() throws Exception { @@ -472,10 +472,64 @@ public class JSBasicCompletionTestGenerated extends AbstractJSBasicCompletionTes } + @TestMetadata("idea/testData/completion/basic/common/namedParameters") + public static class NamedParameters extends AbstractJSBasicCompletionTest { + @TestMetadata("AfterBrace.kt") + public void testAfterBrace() throws Exception { + doTest("idea/testData/completion/basic/common/namedParameters/AfterBrace.kt"); + } + + @TestMetadata("AfterComma.kt") + public void testAfterComma() throws Exception { + doTest("idea/testData/completion/basic/common/namedParameters/AfterComma.kt"); + } + + public void testAllFilesPresentInNamedParameters() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.TestsPackage", new File("idea/testData/completion/basic/common/namedParameters"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("CompactTypeNames.kt") + public void testCompactTypeNames() throws Exception { + doTest("idea/testData/completion/basic/common/namedParameters/CompactTypeNames.kt"); + } + + @TestMetadata("InParameterExpression.kt") + public void testInParameterExpression() throws Exception { + doTest("idea/testData/completion/basic/common/namedParameters/InParameterExpression.kt"); + } + + @TestMetadata("NamedParametersFromOverloads.kt") + public void testNamedParametersFromOverloads() throws Exception { + doTest("idea/testData/completion/basic/common/namedParameters/NamedParametersFromOverloads.kt"); + } + + @TestMetadata("NamedParamsInConstructor.kt") + public void testNamedParamsInConstructor() throws Exception { + doTest("idea/testData/completion/basic/common/namedParameters/NamedParamsInConstructor.kt"); + } + + @TestMetadata("NoAlreadyUsedParameters.kt") + public void testNoAlreadyUsedParameters() throws Exception { + doTest("idea/testData/completion/basic/common/namedParameters/NoAlreadyUsedParameters.kt"); + } + + @TestMetadata("NoParamsFromUnapplicableOverload.kt") + public void testNoParamsFromUnapplicableOverload() throws Exception { + doTest("idea/testData/completion/basic/common/namedParameters/NoParamsFromUnapplicableOverload.kt"); + } + + @TestMetadata("WithParameterExpression.kt") + public void testWithParameterExpression() throws Exception { + doTest("idea/testData/completion/basic/common/namedParameters/WithParameterExpression.kt"); + } + + } + public static Test innerSuite() { TestSuite suite = new TestSuite("Common"); suite.addTestSuite(Common.class); suite.addTestSuite(Extensions.class); + suite.addTestSuite(NamedParameters.class); return suite; } } diff --git a/idea/tests/org/jetbrains/jet/completion/JvmBasicCompletionTestGenerated.java b/idea/tests/org/jetbrains/jet/completion/JvmBasicCompletionTestGenerated.java index 5c38ccab329..a320890964a 100644 --- a/idea/tests/org/jetbrains/jet/completion/JvmBasicCompletionTestGenerated.java +++ b/idea/tests/org/jetbrains/jet/completion/JvmBasicCompletionTestGenerated.java @@ -33,7 +33,7 @@ import org.jetbrains.jet.completion.AbstractJvmBasicCompletionTest; @InnerTestClasses({JvmBasicCompletionTestGenerated.Common.class, JvmBasicCompletionTestGenerated.Java.class}) public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionTest { @TestMetadata("idea/testData/completion/basic/common") - @InnerTestClasses({Common.Extensions.class}) + @InnerTestClasses({Common.Extensions.class, Common.NamedParameters.class}) public static class Common extends AbstractJvmBasicCompletionTest { @TestMetadata("AfterFloatOnNewLine.kt") public void testAfterFloatOnNewLine() throws Exception { @@ -472,10 +472,64 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT } + @TestMetadata("idea/testData/completion/basic/common/namedParameters") + public static class NamedParameters extends AbstractJvmBasicCompletionTest { + @TestMetadata("AfterBrace.kt") + public void testAfterBrace() throws Exception { + doTest("idea/testData/completion/basic/common/namedParameters/AfterBrace.kt"); + } + + @TestMetadata("AfterComma.kt") + public void testAfterComma() throws Exception { + doTest("idea/testData/completion/basic/common/namedParameters/AfterComma.kt"); + } + + public void testAllFilesPresentInNamedParameters() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.TestsPackage", new File("idea/testData/completion/basic/common/namedParameters"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("CompactTypeNames.kt") + public void testCompactTypeNames() throws Exception { + doTest("idea/testData/completion/basic/common/namedParameters/CompactTypeNames.kt"); + } + + @TestMetadata("InParameterExpression.kt") + public void testInParameterExpression() throws Exception { + doTest("idea/testData/completion/basic/common/namedParameters/InParameterExpression.kt"); + } + + @TestMetadata("NamedParametersFromOverloads.kt") + public void testNamedParametersFromOverloads() throws Exception { + doTest("idea/testData/completion/basic/common/namedParameters/NamedParametersFromOverloads.kt"); + } + + @TestMetadata("NamedParamsInConstructor.kt") + public void testNamedParamsInConstructor() throws Exception { + doTest("idea/testData/completion/basic/common/namedParameters/NamedParamsInConstructor.kt"); + } + + @TestMetadata("NoAlreadyUsedParameters.kt") + public void testNoAlreadyUsedParameters() throws Exception { + doTest("idea/testData/completion/basic/common/namedParameters/NoAlreadyUsedParameters.kt"); + } + + @TestMetadata("NoParamsFromUnapplicableOverload.kt") + public void testNoParamsFromUnapplicableOverload() throws Exception { + doTest("idea/testData/completion/basic/common/namedParameters/NoParamsFromUnapplicableOverload.kt"); + } + + @TestMetadata("WithParameterExpression.kt") + public void testWithParameterExpression() throws Exception { + doTest("idea/testData/completion/basic/common/namedParameters/WithParameterExpression.kt"); + } + + } + public static Test innerSuite() { TestSuite suite = new TestSuite("Common"); suite.addTestSuite(Common.class); suite.addTestSuite(Extensions.class); + suite.addTestSuite(NamedParameters.class); return suite; } } diff --git a/idea/tests/org/jetbrains/jet/completion/handlers/BasicCompletionHandlerTest.kt b/idea/tests/org/jetbrains/jet/completion/handlers/BasicCompletionHandlerTest.kt index 7854263bf50..7f25c7a37fc 100644 --- a/idea/tests/org/jetbrains/jet/completion/handlers/BasicCompletionHandlerTest.kt +++ b/idea/tests/org/jetbrains/jet/completion/handlers/BasicCompletionHandlerTest.kt @@ -22,6 +22,10 @@ public class BasicCompletionHandlerTest : CompletionHandlerTestBase(){ fun testParamsFunction() = doTest() + fun testNamedParametersCompletion() = doTest() + + fun testNamedParametersCompletionOnEqual() = doTest(0, "paramTest", null, '=') + fun testInsertJavaClassImport() = doTest() fun testInsertVoidJavaMethod() = doTest() diff --git a/idea/tests/org/jetbrains/jet/completion/weighers/CompletionWeigherTestGenerated.java b/idea/tests/org/jetbrains/jet/completion/weighers/CompletionWeigherTestGenerated.java index e6e06259625..f7cb70c0ba7 100644 --- a/idea/tests/org/jetbrains/jet/completion/weighers/CompletionWeigherTestGenerated.java +++ b/idea/tests/org/jetbrains/jet/completion/weighers/CompletionWeigherTestGenerated.java @@ -71,6 +71,11 @@ public class CompletionWeigherTestGenerated extends AbstractCompletionWeigherTes doTest("idea/testData/completion/weighers/LocalsPropertiesKeywords.kt"); } + @TestMetadata("NamedParameters.kt") + public void testNamedParameters() throws Exception { + doTest("idea/testData/completion/weighers/NamedParameters.kt"); + } + @TestMetadata("ParametersBeforeKeywords.kt") public void testParametersBeforeKeywords() throws Exception { doTest("idea/testData/completion/weighers/ParametersBeforeKeywords.kt");