Disallow named arguments for Java methods

Since they don't have stable names: they're (sometimes) loaded from the
bytecode, which (sometimes) doesn't contain parameter names

compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java

@@ -321,6 +321,7 @@ public interface Errors {
     DiagnosticFactory0<JetReferenceExpression> ARGUMENT_PASSED_TWICE = DiagnosticFactory0.create(ERROR);
     DiagnosticFactory1<JetReferenceExpression, JetReferenceExpression> NAMED_PARAMETER_NOT_FOUND =
             DiagnosticFactory1.create(ERROR, FOR_UNRESOLVED_REFERENCE);
+    DiagnosticFactory0<PsiElement> NAMED_ARGUMENTS_NOT_ALLOWED = DiagnosticFactory0.create(ERROR);
 
     DiagnosticFactory0<JetExpression> VARARG_OUTSIDE_PARENTHESES = DiagnosticFactory0.create(ERROR);
     DiagnosticFactory0<LeafPsiElement> NON_VARARG_SPREAD = DiagnosticFactory0.create(ERROR);

compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/rendering/DefaultErrorMessages.java

@@ -107,6 +107,7 @@ public class DefaultErrorMessages {
         MAP.put(MIXING_NAMED_AND_POSITIONED_ARGUMENTS, "Mixing named and positioned arguments is not allowed");
         MAP.put(ARGUMENT_PASSED_TWICE, "An argument is already passed for this parameter");
         MAP.put(NAMED_PARAMETER_NOT_FOUND, "Cannot find a parameter with this name: {0}", ELEMENT_TEXT);
+        MAP.put(NAMED_ARGUMENTS_NOT_ALLOWED, "Named arguments are not allowed for non-Kotlin functions");
         MAP.put(VARARG_OUTSIDE_PARENTHESES, "Passing value as a vararg is only allowed inside a parenthesized argument list");
         MAP.put(NON_VARARG_SPREAD, "The spread operator (*foo) may only be applied in a vararg position");
 

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ValueArgumentsToParametersMapper.java

@@ -25,14 +25,19 @@ import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
 import org.jetbrains.jet.lang.descriptors.ReceiverParameterDescriptor;
 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.psi.Call;
+import org.jetbrains.jet.lang.psi.JetExpression;
+import org.jetbrains.jet.lang.psi.JetSimpleNameExpression;
+import org.jetbrains.jet.lang.psi.ValueArgument;
 import org.jetbrains.jet.lang.resolve.calls.model.*;
 import org.jetbrains.jet.lang.resolve.calls.tasks.TracingStrategy;
 import org.jetbrains.jet.lang.resolve.calls.util.CallMaker;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue;
 
-import java.util.*;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
 
 import static org.jetbrains.jet.lang.diagnostics.Errors.*;
 import static org.jetbrains.jet.lang.resolve.BindingContext.REFERENCE_TARGET;
@@ -150,6 +155,9 @@ import static org.jetbrains.jet.lang.resolve.calls.ValueArgumentsToParametersMap
 
                 JetSimpleNameExpression nameReference = argument.getArgumentName().getReferenceExpression();
                 ValueParameterDescriptor valueParameterDescriptor = parameterByName.get(nameReference.getReferencedNameAsName());
+                if (!candidateCall.getCandidateDescriptor().hasStableParameterNames()) {
+                    report(NAMED_ARGUMENTS_NOT_ALLOWED.on(nameReference));
+                }
                 if (valueParameterDescriptor == null) {
                     report(NAMED_PARAMETER_NOT_FOUND.on(nameReference, nameReference));
                     unmappedArguments.add(argument);

compiler/testData/diagnostics/tests/namedArguments/disallowForJavaMethods.kt

@@ -0,0 +1,27 @@
+// FILE: JavaSuperClass.java
+
+class JavaSuperClass {
+    void foo(int javaName) {}
+
+    void multipleParameters(int first, long second, String third) {}
+}
+
+// FILE: 1.kt
+
+fun directInvocation() = JavaSuperClass().foo(<!NAMED_ARGUMENTS_NOT_ALLOWED!>javaName<!> = 1)
+
+open class KotlinSubClass : JavaSuperClass()
+
+fun viaFakeOverride() = KotlinSubClass().foo(<!NAMED_ARGUMENTS_NOT_ALLOWED!>javaName<!> = 2)
+
+class KotlinSubSubClass : KotlinSubClass() {
+    override fun foo(kotlinName: Int) {}
+}
+
+fun viaRealOverride() = KotlinSubSubClass().foo(kotlinName = 3)
+
+
+fun unresolvedParameter() = JavaSuperClass().foo(<!NAMED_ARGUMENTS_NOT_ALLOWED, NAMED_PARAMETER_NOT_FOUND!>nonexistentName<!> = 4<!NO_VALUE_FOR_PARAMETER!>)<!>
+
+
+fun multipleParameters() = JavaSuperClass().multipleParameters(<!NAMED_ARGUMENTS_NOT_ALLOWED!>first<!> = 1, <!NAMED_ARGUMENTS_NOT_ALLOWED!>second<!> = 2L, <!NAMED_ARGUMENTS_NOT_ALLOWED!>third<!> = "3")

compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java

@@ -33,7 +33,7 @@ import org.jetbrains.jet.checkers.AbstractJetDiagnosticsTest;
 @InnerTestClasses({JetDiagnosticsTestGenerated.Tests.class, JetDiagnosticsTestGenerated.Script.class, JetDiagnosticsTestGenerated.TailRecursion.class})
 public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest {
     @TestMetadata("compiler/testData/diagnostics/tests")
-    @InnerTestClasses({Tests.Annotations.class, Tests.BackingField.class, Tests.CallableReference.class, Tests.Cast.class, Tests.CheckArguments.class, Tests.ClassObjects.class, Tests.ControlFlowAnalysis.class, Tests.ControlStructures.class, Tests.DataClasses.class, Tests.DataFlow.class, Tests.DataFlowInfoTraversal.class, Tests.DeclarationChecks.class, Tests.DelegatedProperty.class, Tests.Deparenthesize.class, Tests.Enum.class, Tests.Evaluate.class, Tests.Extensions.class, Tests.FunctionLiterals.class, Tests.Generics.class, Tests.IncompleteCode.class, Tests.Inference.class, Tests.Infos.class, Tests.Inline.class, Tests.Inner.class, Tests.J_k.class, Tests.Jdk_annotations.class, Tests.Library.class, Tests.NullabilityAndAutoCasts.class, Tests.NullableTypes.class, Tests.Numbers.class, Tests.Objects.class, Tests.OperatorsOverloading.class, Tests.Overload.class, Tests.Override.class, Tests.Recovery.class, Tests.Redeclarations.class, Tests.Regressions.class, Tests.Resolve.class, Tests.Scopes.class, Tests.SenselessComparison.class, Tests.Shadowing.class, Tests.SmartCasts.class, Tests.Substitutions.class, Tests.Subtyping.class, Tests.Suppress.class, Tests.ThisAndSuper.class, Tests.Unit.class, Tests.Varargs.class, Tests.When.class})
+    @InnerTestClasses({Tests.Annotations.class, Tests.BackingField.class, Tests.CallableReference.class, Tests.Cast.class, Tests.CheckArguments.class, Tests.ClassObjects.class, Tests.ControlFlowAnalysis.class, Tests.ControlStructures.class, Tests.DataClasses.class, Tests.DataFlow.class, Tests.DataFlowInfoTraversal.class, Tests.DeclarationChecks.class, Tests.DelegatedProperty.class, Tests.Deparenthesize.class, Tests.Enum.class, Tests.Evaluate.class, Tests.Extensions.class, Tests.FunctionLiterals.class, Tests.Generics.class, Tests.IncompleteCode.class, Tests.Inference.class, Tests.Infos.class, Tests.Inline.class, Tests.Inner.class, Tests.J_k.class, Tests.Jdk_annotations.class, Tests.Library.class, Tests.NamedArguments.class, Tests.NullabilityAndAutoCasts.class, Tests.NullableTypes.class, Tests.Numbers.class, Tests.Objects.class, Tests.OperatorsOverloading.class, Tests.Overload.class, Tests.Override.class, Tests.Recovery.class, Tests.Redeclarations.class, Tests.Regressions.class, Tests.Resolve.class, Tests.Scopes.class, Tests.SenselessComparison.class, Tests.Shadowing.class, Tests.SmartCasts.class, Tests.Substitutions.class, Tests.Subtyping.class, Tests.Suppress.class, Tests.ThisAndSuper.class, Tests.Unit.class, Tests.Varargs.class, Tests.When.class})
     public static class Tests extends AbstractJetDiagnosticsTest {
         @TestMetadata("Abstract.kt")
         public void testAbstract() throws Exception {
@@ -309,11 +309,6 @@ public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest {
             doTest("compiler/testData/diagnostics/tests/MultipleBounds.kt");
         }
         
-        @TestMetadata("NamedArgumentsAndDefaultValues.kt")
-        public void testNamedArgumentsAndDefaultValues() throws Exception {
-            doTest("compiler/testData/diagnostics/tests/NamedArgumentsAndDefaultValues.kt");
-        }
-        
         @TestMetadata("Nullability.kt")
         public void testNullability() throws Exception {
             doTest("compiler/testData/diagnostics/tests/Nullability.kt");
@@ -4765,6 +4760,24 @@ public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest {
             
         }
         
+        @TestMetadata("compiler/testData/diagnostics/tests/namedArguments")
+        public static class NamedArguments extends AbstractJetDiagnosticsTest {
+            public void testAllFilesPresentInNamedArguments() throws Exception {
+                JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.TestsPackage", new File("compiler/testData/diagnostics/tests/namedArguments"), Pattern.compile("^(.+)\\.kt$"), true);
+            }
+            
+            @TestMetadata("disallowForJavaMethods.kt")
+            public void testDisallowForJavaMethods() throws Exception {
+                doTest("compiler/testData/diagnostics/tests/namedArguments/disallowForJavaMethods.kt");
+            }
+            
+            @TestMetadata("namedArgumentsAndDefaultValues.kt")
+            public void testNamedArgumentsAndDefaultValues() throws Exception {
+                doTest("compiler/testData/diagnostics/tests/namedArguments/namedArgumentsAndDefaultValues.kt");
+            }
+            
+        }
+        
         @TestMetadata("compiler/testData/diagnostics/tests/nullabilityAndAutoCasts")
         public static class NullabilityAndAutoCasts extends AbstractJetDiagnosticsTest {
             public void testAllFilesPresentInNullabilityAndAutoCasts() throws Exception {
@@ -7012,6 +7025,7 @@ public class JetDiagnosticsTestGenerated extends AbstractJetDiagnosticsTest {
             suite.addTestSuite(J_k.class);
             suite.addTest(Jdk_annotations.innerSuite());
             suite.addTestSuite(Library.class);
+            suite.addTestSuite(NamedArguments.class);
             suite.addTestSuite(NullabilityAndAutoCasts.class);
             suite.addTestSuite(NullableTypes.class);
             suite.addTestSuite(Numbers.class);

idea/src/org/jetbrains/jet/plugin/search/declarationsSearch/classInheritorsSearch.kt

@@ -18,12 +18,10 @@ package org.jetbrains.jet.plugin.search.declarationsSearch
 
 import com.intellij.psi.PsiClass
 import com.intellij.util.Query
-import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.psi.PsiModifier
 import com.intellij.psi.PsiAnonymousClass
 import org.jetbrains.jet.lang.psi.JetClassOrObject
 import org.jetbrains.jet.asJava.LightClassUtil
-import com.intellij.psi.search.searches.DirectClassInheritorsSearch
 import com.intellij.psi.PsiElement
 import com.intellij.psi.search.searches.ClassInheritorsSearch
 import com.intellij.util.EmptyQuery
@@ -37,11 +35,11 @@ public fun HierarchySearchRequest<PsiElement>.searchInheritors(): Query<PsiClass
     if (psiClass == null) return EmptyQuery.getEmptyQuery()
 
     return ClassInheritorsSearch.search(
-            aClass = psiClass,
-            scope = searchScope,
-            checkDeep = searchDeeply,
-            checkInheritance = true,
-            includeAnonymous = true
+            psiClass,
+            searchScope,
+            searchDeeply,
+            /* checkInheritance = */ true,
+            /* includeAnonymous = */ true
     )
 }
 

idea/src/org/jetbrains/jet/plugin/search/declarationsSearch/overridersSearch.kt

@@ -25,13 +25,8 @@ import com.intellij.util.Query
 import com.intellij.psi.search.GlobalSearchScope
 import java.util.HashMap
 import org.jetbrains.jet.lang.psi.psiUtil.*
-import org.jetbrains.jet.lang.psi.JetNamedFunction
 import java.util.Collections
-import org.jetbrains.jet.asJava.LightClassUtil
-import org.jetbrains.jet.lang.psi.JetProperty
-import org.jetbrains.jet.lang.psi.JetPropertyAccessor
 import com.intellij.psi.PsiClass
-import org.jetbrains.jet.lang.psi.JetParameter
 import com.intellij.psi.util.TypeConversionUtil
 import com.intellij.psi.PsiSubstitutor
 import com.intellij.psi.util.MethodSignatureUtil
@@ -40,8 +35,6 @@ import com.intellij.psi.JavaPsiFacade
 import com.intellij.psi.search.searches.DirectClassInheritorsSearch
 import com.intellij.util.EmptyQuery
 import com.intellij.util.MergeQuery
-import com.intellij.util.UniqueResultsQuery
-import com.intellij.util.containers.ContainerUtil
 import org.jetbrains.jet.asJava.toLightMethods
 
 fun PsiElement.isOverridableElement(): Boolean = when (this) {
@@ -76,10 +69,10 @@ public object KotlinPsiMethodOverridersSearch : HierarchySearch<PsiMethod>(PsiMe
         val classTraverser = object : HierarchyTraverser<PsiClass> {
             override fun nextElements(current: PsiClass): Iterable<PsiClass> =
                     DirectClassInheritorsSearch.search(
-                            aClass = current,
-                            scope = GlobalSearchScope.allScope(current.getProject()),
-                            checkInheritance = true,
-                            includeAnonymous = true
+                            current,
+                            GlobalSearchScope.allScope(current.getProject()),
+                            /* checkInheritance = */ true,
+                            /* includeAnonymous = */ true
                     )
 
             override fun shouldDescend(element: PsiClass): Boolean =

idea/tests/org/jetbrains/jet/plugin/refactoring/move/AbstractJetMoveTest.kt

@@ -51,7 +51,6 @@ import com.intellij.refactoring.move.moveFilesOrDirectories.MoveFilesOrDirectori
 import com.intellij.refactoring.move.MoveHandler
 import org.jetbrains.jet.getString
 import org.jetbrains.jet.getNullableString
-import org.jetbrains.jet.lang.psi.JetClassOrObject
 import org.jetbrains.jet.plugin.refactoring.move.moveTopLevelDeclarations.MoveKotlinTopLevelDeclarationsProcessor
 import org.jetbrains.jet.plugin.refactoring.move.moveTopLevelDeclarations.MoveKotlinTopLevelDeclarationsOptions
 import org.jetbrains.jet.lang.psi.JetNamedDeclaration
@@ -240,11 +239,11 @@ enum class MoveAction {
                 val targetFile = config.getString("targetFile")
 
                 MoveHandler.doMove(
-                        project = project,
-                        elements = array(mainFile),
-                        targetContainer = PsiManager.getInstance(project).findFile(rootDir.findFileByRelativePath(targetFile)!!)!!,
-                        dataContext = null,
-                        callback = null
+                        project,
+                        array(mainFile),
+                        PsiManager.getInstance(project).findFile(rootDir.findFileByRelativePath(targetFile)!!)!!,
+                        /* dataContext = */ null,
+                        /* callback = */ null
                 )
             }
         }

js/js.translator/src/org/jetbrains/k2js/translate/context/UsageTracker.kt

@@ -55,7 +55,7 @@ class UsageTracker(
     }
 
     private fun captureIfNeed(descriptor: CallableDescriptor?) {
-        if (descriptor == null || isCaptured(descriptor) || isAncestor(containingDescriptor, descriptor, strict = true)) return
+        if (descriptor == null || isCaptured(descriptor) || isAncestor(containingDescriptor, descriptor, /* strict = */ true)) return
 
         parent?.captureIfNeed(descriptor)