Allow use expression of array type as named argument for vararg

compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirOldFrontendDiagnosticsTestGenerated.java

@@ -23418,6 +23418,16 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
             runTest("compiler/testData/diagnostics/tests/varargs/AmbiguousVararg.kt");
         }
 
+        @TestMetadata("assignArrayToVararagInNamedForm_1_3.kt")
+        public void testAssignArrayToVararagInNamedForm_1_3() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/varargs/assignArrayToVararagInNamedForm_1_3.kt");
+        }
+
+        @TestMetadata("assignArrayToVararagInNamedForm_1_4.kt")
+        public void testAssignArrayToVararagInNamedForm_1_4() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/varargs/assignArrayToVararagInNamedForm_1_4.kt");
+        }
+
         @TestMetadata("assignNonConstSingleArrayElementAsVarargInAnnotation.kt")
         public void testAssignNonConstSingleArrayElementAsVarargInAnnotation() throws Exception {
             runTest("compiler/testData/diagnostics/tests/varargs/assignNonConstSingleArrayElementAsVarargInAnnotation.kt");

compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java

@@ -716,6 +716,7 @@ public interface Errors {
 
     DiagnosticFactory1<KtExpression, KotlinType> ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION = DiagnosticFactory1.create(WARNING);
     DiagnosticFactory1<KtExpression, KotlinType> ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_ERROR = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory0<KtExpression> REDUNDANT_SPREAD_OPERATOR_IN_NAMED_FORM_IN_FUNCTION = DiagnosticFactory0.create(WARNING);
     DiagnosticFactory0<KtExpression> ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_ANNOTATION = DiagnosticFactory0.create(WARNING);
     DiagnosticFactory0<KtExpression> ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_ANNOTATION_ERROR = DiagnosticFactory0.create(ERROR);
     DiagnosticFactory0<KtExpression> REDUNDANT_SPREAD_OPERATOR_IN_NAMED_FORM_IN_ANNOTATION = DiagnosticFactory0.create(WARNING);

compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java

@@ -842,6 +842,7 @@ public class DefaultErrorMessages {
         MAP.put(NO_RECEIVER_ALLOWED, "No receiver can be passed to this function or property");
         MAP.put(ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION, "Assigning single elements to varargs in named form is deprecated", TO_STRING);
         MAP.put(ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_ERROR, "Assigning single elements to varargs in named form is forbidden", TO_STRING);
+        MAP.put(REDUNDANT_SPREAD_OPERATOR_IN_NAMED_FORM_IN_FUNCTION, "Redundant spread (*) operator");
         MAP.put(ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_ANNOTATION, "Assigning single elements to varargs in named form is deprecated");
         MAP.put(ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_ANNOTATION_ERROR, "Assigning single elements to varargs in named form is forbidden");
         MAP.put(REDUNDANT_SPREAD_OPERATOR_IN_NAMED_FORM_IN_ANNOTATION, "Redundant spread (*) operator");

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolverUtil.kt

@@ -215,7 +215,10 @@ fun getEffectiveExpectedTypeForSingleArgument(
         return if (parameterDescriptor.varargElementType == null) DONT_CARE else parameterDescriptor.type
     }
 
-    if (arrayAssignmentToVarargInNamedFormInAnnotation(parameterDescriptor, argument, languageVersionSettings, trace)) {
+    if (
+        arrayAssignmentToVarargInNamedFormInAnnotation(parameterDescriptor, argument, languageVersionSettings, trace) ||
+        arrayAssignmentToVarargInNamedFormInFunction(parameterDescriptor, argument, languageVersionSettings, trace)
+    ) {
         return parameterDescriptor.type
     }
 
@@ -239,6 +242,17 @@ private fun arrayAssignmentToVarargInNamedFormInAnnotation(
     return argument.isNamed() && parameterDescriptor.isVararg && isArrayOrArrayLiteral(argument, trace)
 }
 
+private fun arrayAssignmentToVarargInNamedFormInFunction(
+    parameterDescriptor: ValueParameterDescriptor,
+    argument: ValueArgument,
+    languageVersionSettings: LanguageVersionSettings,
+    trace: BindingTrace
+): Boolean {
+    if (!languageVersionSettings.supportsFeature(LanguageFeature.AllowAssigningArrayElementsToVarargsInNamedFormForFunctions)) return false
+
+    return argument.isNamed() && parameterDescriptor.isVararg && isArrayOrArrayLiteral(argument, trace)
+}
+
 fun isArrayOrArrayLiteral(argument: ValueArgument, trace: BindingTrace): Boolean {
     val argumentExpression = argument.getArgumentExpression() ?: return false
     if (argumentExpression is KtCollectionLiteralExpression) return true

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/AssigningNamedArgumentToVarargChecker.kt

@@ -6,8 +6,7 @@
 package org.jetbrains.kotlin.resolve.calls.checkers
 
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.config.LanguageFeature.AssigningArraysToVarargsInNamedFormInAnnotations
+import org.jetbrains.kotlin.config.LanguageFeature.*
-import org.jetbrains.kotlin.config.LanguageFeature.ProhibitAssigningSingleElementsToVarargsInNamedForm
 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
 import org.jetbrains.kotlin.diagnostics.DiagnosticFactory
 import org.jetbrains.kotlin.diagnostics.Errors
@@ -84,9 +83,18 @@ class AssigningNamedArgumentToVarargChecker : CallChecker {
         context: ResolutionContext<*>,
         parameterDescriptor: ValueParameterDescriptor
     ) {
-        if (!argument.hasSpread()) {
+        if (
-            reportMigrationDiagnostic(migrationDiagnosticsForFunction, context) { diagnostic ->
+            context.languageVersionSettings.supportsFeature(AllowAssigningArrayElementsToVarargsInNamedFormForFunctions)
-                context.trace.report(diagnostic.on(argumentExpression, parameterDescriptor.type))
+            && isArrayOrArrayLiteral(argument, context.trace)
+        ) {
+            if (argument.hasSpread()) {
+                context.trace.report(Errors.REDUNDANT_SPREAD_OPERATOR_IN_NAMED_FORM_IN_FUNCTION.on(argumentExpression))
+            }
+        } else {
+            if (!argument.hasSpread()) {
+                reportMigrationDiagnostic(migrationDiagnosticsForFunction, context) { diagnostic ->
+                    context.trace.report(diagnostic.on(argumentExpression, parameterDescriptor.type))
+                }
             }
         }
     }
@@ -107,4 +115,7 @@ class AssigningNamedArgumentToVarargChecker : CallChecker {
     }
 }
 
-private data class MigrationDiagnostics<T : DiagnosticFactory<*>>(val warning: T, val error: T)
+private data class MigrationDiagnostics<T : DiagnosticFactory<*>>(val warning: T, val error: T)
+
+private val ResolutionContext<*>.isAssigningArrayEnabled: Boolean
+    get() = languageVersionSettings.supportsFeature(AllowAssigningArrayElementsToVarargsInNamedFormForFunctions)

compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/components/ArgumentsUtils.kt

@@ -52,7 +52,11 @@ val ReceiverValueWithSmartCastInfo.stableType: UnwrappedType
     }
 
 internal fun KotlinCallArgument.getExpectedType(parameter: ParameterDescriptor, languageVersionSettings: LanguageVersionSettings) =
-    if (this.isSpread || this.isArrayAssignedAsNamedArgumentInAnnotation(parameter, languageVersionSettings)) {
+    if (
+        this.isSpread ||
+        this.isArrayAssignedAsNamedArgumentInAnnotation(parameter, languageVersionSettings) ||
+        this.isArrayAssignedAsNamedArgumentInFunction(parameter, languageVersionSettings)
+    ) {
         parameter.type.unwrap()
     } else {
         parameter.safeAs<ValueParameterDescriptor>()?.varargElementType?.unwrap() ?: parameter.type.unwrap()
@@ -120,6 +124,17 @@ private fun KotlinCallArgument.isArrayAssignedAsNamedArgumentInAnnotation(
     return isParameterOfAnnotation(parameter) && this.isArrayOrArrayLiteral()
 }
 
+private fun KotlinCallArgument.isArrayAssignedAsNamedArgumentInFunction(
+    parameter: ParameterDescriptor,
+    languageVersionSettings: LanguageVersionSettings
+): Boolean {
+    if (!languageVersionSettings.supportsFeature(LanguageFeature.AllowAssigningArrayElementsToVarargsInNamedFormForFunctions)) return false
+
+    if (this.argumentName == null || !parameter.isVararg) return false
+
+    return this.isArrayOrArrayLiteral()
+}
+
 private fun KotlinCallArgument.isArrayOrArrayLiteral(): Boolean {
     if (this is CollectionLiteralKotlinCallArgument) return true
     if (this !is SimpleKotlinCallArgument) return false

compiler/testData/diagnostics/tests/varargs/assignArrayToVararagInNamedForm_1_3.fir.kt

@@ -0,0 +1,35 @@
+// !LANGUAGE: -AllowAssigningArrayElementsToVarargsInNamedFormForFunctions
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+@Retention(AnnotationRetention.SOURCE)
+@Target(AnnotationTarget.EXPRESSION)
+annotation class Ann(vararg val s: String, val x: Int)
+
+fun withVararg(vararg s: String) {}
+fun foo() {}
+
+fun test_fun(s: String, arr: Array<String>) {
+    <!INAPPLICABLE_CANDIDATE!>withVararg<!>(arr) // Error
+    withVararg(*arr) // OK
+    <!INAPPLICABLE_CANDIDATE!>withVararg<!>(s = arr) // Error
+    withVararg(s = *arr) // OK
+
+    withVararg(s) // OK
+    withVararg(s = s) // Error
+}
+
+fun test_ann(s: String, arr: Array<String>) {
+    @Ann([""], x = 1)
+    foo()
+    @Ann(*[""], x = 1)
+    foo()
+    @Ann(s = [""], x = 1)
+    foo()
+    @Ann(s = *[""], x = 1)
+    foo()
+
+    @Ann("", x = 1)
+    foo()
+    @Ann(s = "", x = 1)
+    foo()
+}

compiler/testData/diagnostics/tests/varargs/assignArrayToVararagInNamedForm_1_3.kt

@@ -0,0 +1,35 @@
+// !LANGUAGE: -AllowAssigningArrayElementsToVarargsInNamedFormForFunctions
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+@Retention(AnnotationRetention.SOURCE)
+@Target(AnnotationTarget.EXPRESSION)
+annotation class Ann(vararg val s: String, val x: Int)
+
+fun withVararg(vararg s: String) {}
+fun foo() {}
+
+fun test_fun(s: String, arr: Array<String>) {
+    withVararg(<!TYPE_MISMATCH!>arr<!>) // Error
+    withVararg(*arr) // OK
+    withVararg(s = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_ERROR, TYPE_MISMATCH!>arr<!>) // Error
+    withVararg(s = *arr) // OK
+
+    withVararg(s) // OK
+    withVararg(s = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_ERROR!>s<!>) // Error
+}
+
+fun test_ann(s: String, arr: Array<String>) {
+    @Ann(<!TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH, TYPE_MISMATCH!>[""]<!>, x = 1)
+    foo()
+    @Ann(*[""], x = 1)
+    foo()
+    @Ann(s = [""], x = 1)
+    foo()
+    @Ann(s = *<!REDUNDANT_SPREAD_OPERATOR_IN_NAMED_FORM_IN_ANNOTATION!>[""]<!>, x = 1)
+    foo()
+
+    @Ann("", x = 1)
+    foo()
+    @Ann(s = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_ANNOTATION_ERROR!>""<!>, x = 1)
+    foo()
+}

compiler/testData/diagnostics/tests/varargs/assignArrayToVararagInNamedForm_1_3.txt

@@ -0,0 +1,15 @@
+package
+
+public fun foo(): kotlin.Unit
+public fun test_ann(/*0*/ s: kotlin.String, /*1*/ arr: kotlin.Array<kotlin.String>): kotlin.Unit
+public fun test_fun(/*0*/ s: kotlin.String, /*1*/ arr: kotlin.Array<kotlin.String>): kotlin.Unit
+public fun withVararg(/*0*/ vararg s: kotlin.String /*kotlin.Array<out kotlin.String>*/): kotlin.Unit
+
+@kotlin.annotation.Retention(value = AnnotationRetention.SOURCE) @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.EXPRESSION}) public final annotation class Ann : kotlin.Annotation {
+    public constructor Ann(/*0*/ vararg s: kotlin.String /*kotlin.Array<out kotlin.String>*/, /*1*/ x: kotlin.Int)
+    public final val s: kotlin.Array<out kotlin.String>
+    public final val x: kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/tests/varargs/assignArrayToVararagInNamedForm_1_4.fir.kt

@@ -0,0 +1,36 @@
+// !LANGUAGE: +AllowAssigningArrayElementsToVarargsInNamedFormForFunctions
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// !WITH_NEW_INFERENCE
+
+@Retention(AnnotationRetention.SOURCE)
+@Target(AnnotationTarget.EXPRESSION)
+annotation class Ann(vararg val s: String, val x: Int)
+
+fun withVararg(vararg s: String) {}
+fun foo() {}
+
+fun test_fun(s: String, arr: Array<String>) {
+    <!INAPPLICABLE_CANDIDATE!>withVararg<!>(arr) // Error
+    withVararg(*arr) // OK
+    <!INAPPLICABLE_CANDIDATE!>withVararg<!>(s = arr) // OK
+    withVararg(s = *arr) // Warning
+
+    withVararg(s) // OK
+    withVararg(s = s) // Error
+}
+
+fun test_ann(s: String, arr: Array<String>) {
+    @Ann([""], x = 1)
+    foo()
+    @Ann(*[""], x = 1)
+    foo()
+    @Ann(s = [""], x = 1)
+    foo()
+    @Ann(s = *[""], x = 1)
+    foo()
+
+    @Ann("", x = 1)
+    foo()
+    @Ann(s = "", x = 1)
+    foo()
+}

compiler/testData/diagnostics/tests/varargs/assignArrayToVararagInNamedForm_1_4.kt

@@ -0,0 +1,36 @@
+// !LANGUAGE: +AllowAssigningArrayElementsToVarargsInNamedFormForFunctions
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// !WITH_NEW_INFERENCE
+
+@Retention(AnnotationRetention.SOURCE)
+@Target(AnnotationTarget.EXPRESSION)
+annotation class Ann(vararg val s: String, val x: Int)
+
+fun withVararg(vararg s: String) {}
+fun foo() {}
+
+fun test_fun(s: String, arr: Array<String>) {
+    withVararg(<!TYPE_MISMATCH!>arr<!>) // Error
+    withVararg(*arr) // OK
+    withVararg(s = arr) // OK
+    withVararg(s = *<!REDUNDANT_SPREAD_OPERATOR_IN_NAMED_FORM_IN_FUNCTION!>arr<!>) // Warning
+
+    withVararg(s) // OK
+    withVararg(s = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_ERROR!>s<!>) // Error
+}
+
+fun test_ann(s: String, arr: Array<String>) {
+    @Ann(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH, OI;TYPE_MISMATCH!>[""]<!>, x = 1)
+    foo()
+    @Ann(*[""], x = 1)
+    foo()
+    @Ann(s = [""], x = 1)
+    foo()
+    @Ann(s = *<!REDUNDANT_SPREAD_OPERATOR_IN_NAMED_FORM_IN_ANNOTATION!>[""]<!>, x = 1)
+    foo()
+
+    @Ann("", x = 1)
+    foo()
+    @Ann(s = <!ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_ANNOTATION_ERROR!>""<!>, x = 1)
+    foo()
+}

compiler/testData/diagnostics/tests/varargs/assignArrayToVararagInNamedForm_1_4.txt

@@ -0,0 +1,15 @@
+package
+
+public fun foo(): kotlin.Unit
+public fun test_ann(/*0*/ s: kotlin.String, /*1*/ arr: kotlin.Array<kotlin.String>): kotlin.Unit
+public fun test_fun(/*0*/ s: kotlin.String, /*1*/ arr: kotlin.Array<kotlin.String>): kotlin.Unit
+public fun withVararg(/*0*/ vararg s: kotlin.String /*kotlin.Array<out kotlin.String>*/): kotlin.Unit
+
+@kotlin.annotation.Retention(value = AnnotationRetention.SOURCE) @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.EXPRESSION}) public final annotation class Ann : kotlin.Annotation {
+    public constructor Ann(/*0*/ vararg s: kotlin.String /*kotlin.Array<out kotlin.String>*/, /*1*/ x: kotlin.Int)
+    public final val s: kotlin.Array<out kotlin.String>
+    public final val x: kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java

@@ -23500,6 +23500,16 @@ public class DiagnosticsTestGenerated extends AbstractDiagnosticsTest {
                 runTest("compiler/testData/diagnostics/tests/varargs/AmbiguousVararg.kt");
             }
 
+            @TestMetadata("assignArrayToVararagInNamedForm_1_3.kt")
+            public void testAssignArrayToVararagInNamedForm_1_3() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/varargs/assignArrayToVararagInNamedForm_1_3.kt");
+            }
+
+            @TestMetadata("assignArrayToVararagInNamedForm_1_4.kt")
+            public void testAssignArrayToVararagInNamedForm_1_4() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/varargs/assignArrayToVararagInNamedForm_1_4.kt");
+            }
+
             @TestMetadata("assignNonConstSingleArrayElementAsVarargInAnnotation.kt")
             public void testAssignNonConstSingleArrayElementAsVarargInAnnotation() throws Exception {
                 runTest("compiler/testData/diagnostics/tests/varargs/assignNonConstSingleArrayElementAsVarargInAnnotation.kt");

compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java

@@ -23420,6 +23420,16 @@ public class DiagnosticsUsingJavacTestGenerated extends AbstractDiagnosticsUsing
                 runTest("compiler/testData/diagnostics/tests/varargs/AmbiguousVararg.kt");
             }
 
+            @TestMetadata("assignArrayToVararagInNamedForm_1_3.kt")
+            public void testAssignArrayToVararagInNamedForm_1_3() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/varargs/assignArrayToVararagInNamedForm_1_3.kt");
+            }
+
+            @TestMetadata("assignArrayToVararagInNamedForm_1_4.kt")
+            public void testAssignArrayToVararagInNamedForm_1_4() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/varargs/assignArrayToVararagInNamedForm_1_4.kt");
+            }
+
             @TestMetadata("assignNonConstSingleArrayElementAsVarargInAnnotation.kt")
             public void testAssignNonConstSingleArrayElementAsVarargInAnnotation() throws Exception {
                 runTest("compiler/testData/diagnostics/tests/varargs/assignNonConstSingleArrayElementAsVarargInAnnotation.kt");

compiler/util/src/org/jetbrains/kotlin/config/LanguageVersionSettings.kt

@@ -117,6 +117,7 @@ enum class LanguageFeature(
     ProhibitProtectedCallFromInline(KOTLIN_1_4, kind = BUG_FIX),
     ProperFinally(KOTLIN_1_4, kind = BUG_FIX),
     ProhibitVarargAsArrayAfterSamArgument(KOTLIN_1_4, kind = BUG_FIX),
+    AllowAssigningArrayElementsToVarargsInNamedFormForFunctions(KOTLIN_1_4),
 
     ProperVisibilityForCompanionObjectInstanceField(sinceVersion = null, kind = BUG_FIX),
     // Temporarily disabled, see KT-27084/KT-22379