KT-1633 support completion of named function parameters

annotations/com/intellij/patterns/annotations.xml

@@ -1,6 +1,17 @@
 <root>
+  <item
+      name='com.intellij.patterns.PlatformPatterns com.intellij.patterns.PsiElementPattern.Capture&lt;T&gt; psiElement(java.lang.Class&lt;T&gt;)'>
+    <annotation name='org.jetbrains.annotations.NotNull'/>
+  </item>
   <item
       name='com.intellij.patterns.PlatformPatterns com.intellij.patterns.PsiElementPattern.Capture&lt;com.intellij.psi.PsiElement&gt; psiElement()'>
     <annotation name='org.jetbrains.annotations.NotNull'/>
   </item>
+  <item
+      name='com.intellij.patterns.PlatformPatterns com.intellij.patterns.PsiElementPattern.Capture&lt;com.intellij.psi.PsiElement&gt; psiElement(com.intellij.psi.tree.IElementType)'>
+    <annotation name='org.jetbrains.annotations.NotNull'/>
+  </item>
+  <item name='com.intellij.patterns.PsiElementPattern Self withElementType(com.intellij.psi.tree.IElementType)'>
+    <annotation name='org.jetbrains.annotations.NotNull'/>
+  </item>
 </root>

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<T: PsiElement>(
         strict : Boolean = false, vararg parentClasses : Class<T>, predicate: (T) -> Boolean

idea/src/META-INF/plugin.xml

@@ -209,7 +209,10 @@
     <completion.contributor language="jet" id="JetExtensionFunctionReceiverContributor" order="after JetPackagesContributor"
                             implementationClass="org.jetbrains.jet.plugin.completion.JetExtensionReceiverTypeContributor"/>
 
-    <completion.contributor language="jet" id="JetCompletionContributor" order="after JetExtensionFunctionReceiverContributor"
+    <completion.contributor language="jet" id="KotlinNamedParametersContributor" order="after JetExtensionFunctionReceiverContributor"
+                            implementationClass="org.jetbrains.jet.plugin.completion.KotlinNamedParametersContributor"/>
+
+    <completion.contributor language="jet" id="JetCompletionContributor" order="after KotlinNamedParametersContributor"
                             implementationClass="org.jetbrains.jet.plugin.completion.JetCompletionContributor"/>
 
     <completion.contributor language="jet" implementationClass="org.jetbrains.jet.plugin.liveTemplates.JetLiveTemplateCompletionContributor"

idea/src/org/jetbrains/jet/plugin/completion/JetCompletionCharFilter.kt

@@ -56,8 +56,20 @@ public open class JetCompletionCharFilter() : CharFilter() {
             return null
         }
 
+        fun checkFinishCompletionForEqual(): Result? {
+            if (c == '=') {
+                val currentItem = lookup.getCurrentItem()
+                if (currentItem != null && (currentItem.getObject() is KotlinNamedParametersContributor.NamedParameterLookupObject)) {
+                    return Result.SELECT_ITEM_AND_FINISH_LOOKUP
+                }
+            }
+
+            return null
+        }
+
         return checkHideLookupForRangeOperator() ?:
                checkFinishCompletionForOpenBrace() ?:
+               checkFinishCompletionForEqual() ?:
                null
     }
 }

idea/src/org/jetbrains/jet/plugin/completion/KotlinNamedParametersContributor.kt

@@ -0,0 +1,122 @@
+/*
+ * 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.completion
+
+import com.intellij.codeInsight.completion.CompletionContributor
+import com.intellij.codeInsight.completion.CompletionType
+import com.intellij.patterns.PlatformPatterns
+import org.jetbrains.jet.lang.psi.JetValueArgument
+import com.intellij.codeInsight.completion.CompletionProvider
+import com.intellij.util.ProcessingContext
+import com.intellij.codeInsight.completion.CompletionResultSet
+import com.intellij.codeInsight.completion.CompletionParameters
+import org.jetbrains.jet.lexer.JetTokens
+import com.intellij.psi.util.PsiTreeUtil
+import org.jetbrains.jet.lang.psi.JetCallElement
+import org.jetbrains.jet.plugin.references.JetReference
+import org.jetbrains.jet.lang.descriptors.FunctionDescriptor
+import com.intellij.codeInsight.lookup.LookupElementBuilder
+import org.jetbrains.jet.plugin.completion.KotlinNamedParametersContributor.NamedParameterLookupObject
+import org.jetbrains.jet.plugin.JetIcons
+import org.jetbrains.jet.lang.resolve.name.Name
+import org.jetbrains.jet.plugin.completion.weigher.addJetSorting
+import org.jetbrains.jet.plugin.quickfix.QuickFixUtil
+import org.jetbrains.jet.renderer.DescriptorRenderer
+import com.intellij.codeInsight.completion.InsertHandler
+import com.intellij.codeInsight.lookup.LookupElement
+import com.intellij.codeInsight.completion.InsertionContext
+import com.intellij.psi.filters.position.FilterPattern
+import com.intellij.psi.filters.AndFilter
+import org.jetbrains.jet.lang.psi.JetValueArgumentName
+import com.intellij.psi.filters.position.ParentElementFilter
+import com.intellij.psi.filters.OrFilter
+import com.intellij.psi.filters.ClassFilter
+import org.jetbrains.jet.plugin.util.FirstChildInParentFilter
+import org.jetbrains.jet.lang.psi.psiUtil.getCallNameExpression
+
+public class KotlinNamedParametersContributor : CompletionContributor() {
+    public class NamedParameterLookupObject(val name: Name) {}
+
+    private val InNamedParameterFilter = AndFilter(
+            LeafElementFilter(JetTokens.IDENTIFIER),
+            OrFilter(
+                    AndFilter(
+                            ParentElementFilter(ClassFilter(javaClass<JetValueArgument>()), 2),
+                            FirstChildInParentFilter(2)
+                    ),
+                    ParentElementFilter(ClassFilter(javaClass<JetValueArgumentName>()), 2)
+            )
+    );
+
+    {
+        extend(CompletionType.BASIC,
+               PlatformPatterns.psiElement().and(FilterPattern(InNamedParameterFilter)),
+               object : CompletionProvider<CompletionParameters>() {
+                   override fun addCompletions(parameters: CompletionParameters, context: ProcessingContext?, result: CompletionResultSet) {
+                       doParamsCompletion(parameters, result)
+                   }
+               })
+    }
+
+    fun doParamsCompletion(parameters: CompletionParameters, result: CompletionResultSet) {
+        val valueArgument = PsiTreeUtil.getParentOfType(parameters.getPosition(), javaClass<JetValueArgument>())!!
+
+        val callElement = PsiTreeUtil.getParentOfType(valueArgument, javaClass<JetCallElement>())
+        if (callElement == null) return
+
+        val callSimpleName = callElement.getCallNameExpression()
+        if (callSimpleName == null) return
+
+        val kotlinResultSet = result.addJetSorting(parameters)
+
+        val callReference = callSimpleName.getReference() as JetReference
+
+        val functionDescriptors = callReference.resolveToDescriptors().map { it as? FunctionDescriptor }.filterNotNull()
+
+        for (funDescriptor in functionDescriptors) {
+            val usedArguments = QuickFixUtil.getUsedParameters(callElement, valueArgument, funDescriptor)
+
+            for (parameter in funDescriptor.getValueParameters()) {
+                val name = parameter.getName().asString()
+                if (result.getPrefixMatcher().prefixMatches(name) && name !in usedArguments) {
+                    val lookupElementBuilder = LookupElementBuilder.create(NamedParameterLookupObject(parameter.getName()), "${name}")
+                            .withPresentableText("${name} = ")
+                            .withTailText("${DescriptorRenderer.SHORT_NAMES_IN_TYPES.renderType(parameter.getType())}")
+                            .withIcon(JetIcons.PARAMETER)
+                            .withInsertHandler(NamedParameterInsertHandler)
+
+                    kotlinResultSet.addElement(lookupElementBuilder)
+                }
+            }
+        }
+    }
+
+    private object NamedParameterInsertHandler : InsertHandler<LookupElement> {
+        override fun handleInsert(context: InsertionContext, item: LookupElement) {
+            val ch = context.getCompletionChar()
+            if (ch == '=' || ch == ' ') {
+                context.setAddCompletionChar(false)
+            }
+
+            val editor = context.getEditor()
+            val tailOffset = context.getTailOffset()
+
+            editor.getDocument().insertString(tailOffset, " = ")
+            editor.getCaretModel().moveToOffset(tailOffset + 3)
+        }
+    }
+}

idea/src/org/jetbrains/jet/plugin/completion/weigher/JetKindWeigher.java

@@ -25,6 +25,7 @@ import org.jetbrains.jet.lang.descriptors.PropertyDescriptor;
 import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.LocalVariableDescriptor;
 import org.jetbrains.jet.plugin.completion.JetLookupObject;
+import org.jetbrains.jet.plugin.completion.KotlinNamedParametersContributor;
 
 class JetKindWeigher extends LookupElementWeigher {
     JetKindWeigher() {
@@ -34,6 +35,7 @@ class JetKindWeigher extends LookupElementWeigher {
     private enum MyResult {
         localOrParameter,
         property,
+        namedParameter,
         probableKeyword,
         normal,
         packages
@@ -58,6 +60,9 @@ class JetKindWeigher extends LookupElementWeigher {
                 }
             }
         }
+        else if (object instanceof KotlinNamedParametersContributor.NamedParameterLookupObject) {
+            return MyResult.namedParameter;
+        }
         else if (object instanceof String) {
              return MyResult.probableKeyword;
         }

idea/src/org/jetbrains/jet/plugin/parameterInfo/JetFunctionParameterInfoHandler.java

@@ -34,6 +34,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.psi.*;
+import org.jetbrains.jet.lang.psi.psiUtil.PsiUtilPackage;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingContextUtils;
 import org.jetbrains.jet.lang.resolve.JetVisibilityChecker;
@@ -424,27 +425,10 @@ public class JetFunctionParameterInfoHandler implements ParameterInfoHandlerWith
 
     @Nullable
     private static JetSimpleNameExpression getCallSimpleNameExpression(JetValueArgumentList argumentList) {
-        if (!(argumentList.getParent() instanceof JetCallElement)) {
-            return null;
-        }
-
-        JetCallElement callExpression = (JetCallElement)argumentList.getParent();
-        JetExpression calleeExpression = callExpression.getCalleeExpression();
-        if (calleeExpression == null) {
-            return null;
-        }
-
-        if (calleeExpression instanceof JetSimpleNameExpression) {
-            return (JetSimpleNameExpression) calleeExpression;
-        }
-        else if (calleeExpression instanceof JetConstructorCalleeExpression) {
-            JetConstructorCalleeExpression constructorCalleeExpression = (JetConstructorCalleeExpression) calleeExpression;
-            if (constructorCalleeExpression.getConstructorReferenceExpression() instanceof JetSimpleNameExpression) {
-                return (JetSimpleNameExpression) constructorCalleeExpression.getConstructorReferenceExpression();
-            }
-        }
-
-        return null;
+        PsiElement argumentListParent = argumentList.getParent();
+        return (argumentListParent instanceof JetCallElement) ?
+               PsiUtilPackage.getCallNameExpression((JetCallElement) argumentListParent) :
+               null;
     }
 
     private static JetValueArgumentList findCallAndUpdateContext(UpdateParameterInfoContext context) {

idea/src/org/jetbrains/jet/plugin/quickfix/AddNameToArgumentFix.java

@@ -17,7 +17,6 @@
 package org.jetbrains.jet.plugin.quickfix;
 
 import com.google.common.collect.Lists;
-import com.google.common.collect.Sets;
 import com.intellij.codeInsight.intention.IntentionAction;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.command.CommandProcessor;
@@ -72,7 +71,7 @@ public class AddNameToArgumentFix extends JetIntentionAction<JetValueArgument> {
 
         CallableDescriptor callableDescriptor = resolvedCall.getResultingDescriptor();
         JetType type = context.get(BindingContext.EXPRESSION_TYPE, argument.getArgumentExpression());
-        Set<String> usedParameters = getUsedParameters(callElement, callableDescriptor);
+        Set<String> usedParameters = QuickFixUtil.getUsedParameters(callElement, null, callableDescriptor);
         List<String> names = Lists.newArrayList();
         for (ValueParameterDescriptor parameter: callableDescriptor.getValueParameters()) {
             String name = parameter.getName().asString();
@@ -84,27 +83,6 @@ public class AddNameToArgumentFix extends JetIntentionAction<JetValueArgument> {
         return names;
     }
 
-    @NotNull
-    private static Set<String> getUsedParameters(@NotNull JetCallElement callElement, @NotNull CallableDescriptor callableDescriptor) {
-        Set<String> 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";
-                usedParameters.add(name.getText());
-                isPositionalArgument = false;
-            }
-            else if (isPositionalArgument) {
-                ValueParameterDescriptor parameter = callableDescriptor.getValueParameters().get(idx);
-                usedParameters.add(parameter.getName().asString());
-                idx++;
-            }
-        }
-        return usedParameters;
-    }
-
     @Override
     protected void invoke(@NotNull Project project, Editor editor, JetFile file) {
         if (possibleNames.size() == 1 || editor == null || !editor.getComponent().isShowing()) {

idea/src/org/jetbrains/jet/plugin/quickfix/QuickFixUtil.java

@@ -16,6 +16,7 @@
 
 package org.jetbrains.jet.plugin.quickfix;
 
+import com.google.common.collect.Sets;
 import com.intellij.extapi.psi.ASTDelegatePsiElement;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiFile;
@@ -23,8 +24,10 @@ import com.intellij.psi.PsiWhiteSpace;
 import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.ReadOnly;
 import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor;
 import org.jetbrains.jet.lang.diagnostics.Diagnostic;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
@@ -37,6 +40,7 @@ import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache;
 import org.jetbrains.jet.plugin.references.BuiltInsReferenceResolver;
 
 import java.util.List;
+import java.util.Set;
 
 public class QuickFixUtil {
     private QuickFixUtil() {
@@ -196,4 +200,35 @@ public class QuickFixUtil {
             return returnExpression != null && canEvaluateTo(returnExpression.getReturnedExpression(), expression);
         }
     }
+
+    @ReadOnly
+    @NotNull
+    public static Set<String> getUsedParameters(
+            @NotNull JetCallElement callElement,
+            @Nullable JetValueArgument ignoreArgument,
+            @NotNull CallableDescriptor callableDescriptor
+    ) {
+        Set<String> 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;
+    }
 }

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)"
+    }
+}
+

idea/testData/completion/basic/common/namedParameters/AfterBrace.kt

@@ -0,0 +1,6 @@
+fun small(param: Int) {
+}
+
+fun test() = small(<caret>)
+
+// EXIST: {"lookupString":"param","tailText":"Int","itemText":"param = "}

idea/testData/completion/basic/common/namedParameters/AfterComma.kt

@@ -0,0 +1,7 @@
+fun small(first: Int, second: Int) {
+}
+
+fun test() = small(12, <caret>)
+
+// ABSENT: first
+// EXIST: second

idea/testData/completion/basic/common/namedParameters/CompactTypeNames.kt

@@ -0,0 +1,11 @@
+import java.util.ArrayList
+
+val paramTest = 12
+
+fun small(paramFirst: ArrayList<String>, paramSecond: Comparable<java.lang.RuntimeException>) {
+}
+
+fun test() = small(<caret>)
+
+// EXIST: {"lookupString":"paramSecond","tailText":"Comparable<RuntimeException>","itemText":"paramSecond = "}
+// EXIST: {"lookupString":"paramFirst","tailText":"ArrayList<String>","itemText":"paramFirst = "}

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<caret>)
+
+// EXIST: paramTest
+// ABSENT: {"lookupString":"paramFirst","tailText":"Int","itemText":"paramFirst = "}
+// ABSENT: paramSecond
+// NUMBER: 1

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<caret>)
+}
+
+// EXIST: nFirst
+// EXIST: nSecond
+// EXIST: nThird
+// EXIST: nLocal
+
+// todo - should exist
+// ABSENT: nClassParam
+// ABSENT: nClassField

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<caret>)
+}
+
+// EXIST: {"lookupString":"pFirst","tailText":"String?","itemText":"pFirst = "}
+// EXIST: {"lookupString":"pSecond","tailText":"Int","itemText":"pSecond = "}

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<caret>)
+}
+
+// ABSENT: paramFirst
+// EXIST: paramSecond
+// ABSENT: paramThird
+// EXIST: paramFourth
+

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<caret>)
+}
+
+// ABSENT: paramFirst
+// EXIST: {"lookupString":"paramSecond","tailText":"Int","itemText":"paramSecond = "}
+// ABSENT: paramThird
+// ABSENT: paramFourth

idea/testData/completion/basic/common/namedParameters/WithParameterExpression.kt

@@ -0,0 +1,12 @@
+val paramTest = 12
+
+fun small(paramFirst: Int, paramSecond: Int) {
+}
+
+fun test() = small(param<caret>First = 12)
+
+// EXIST: paramFirst
+// EXIST: paramSecond
+// ABSENT: paramTest
+
+// NUMBER: 2

idea/testData/completion/handlers/NamedParametersCompletion.kt

@@ -0,0 +1,6 @@
+fun foo(paramTest: Int = 12)
+
+fun test() {
+    // '=' is expected
+    foo(param<caret>)
+}

idea/testData/completion/handlers/NamedParametersCompletion.kt.after

@@ -0,0 +1,6 @@
+fun foo(paramTest: Int = 12)
+
+fun test() {
+    // '=' is expected
+    foo(paramTest = <caret>)
+}

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<caret>)
+}

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 = <caret>)
+}

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
+
+
+

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<caret>)
+}
+
+// ORDER: listLocalVal
+// ORDER: listParam
+// ORDER: listThisFileVal
+// ORDER: listImportedVal
+// ORDER: listMatch
+// ORDER: listNew
+// ORDER: listThisFileFun
+// ORDER: listImportedFun

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;
         }
     }

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;
         }
     }

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()

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");