Prohibit assigning single elements into varargs in named form

#KT-20588 Fixed
 #KT-20589 Fixed

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

@@ -664,7 +664,9 @@ public interface Errors {
     DiagnosticFactory0<KtExpression> NO_RECEIVER_ALLOWED = DiagnosticFactory0.create(ERROR);
 
     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> 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);
 
     // Call resolution
 

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

@@ -780,7 +780,9 @@ public class DefaultErrorMessages {
         MAP.put(MISSING_RECEIVER, "A receiver of type {0} is required", RENDER_TYPE);
         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(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(CREATING_AN_INSTANCE_OF_ABSTRACT_CLASS, "Cannot create an instance of an abstract class");
 

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

@@ -6,9 +6,13 @@
 package org.jetbrains.kotlin.resolve.calls.checkers
 
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.config.LanguageFeature
+import org.jetbrains.kotlin.config.LanguageFeature.AssigningArraysToVarargsInNamedFormInAnnotations
+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
+import org.jetbrains.kotlin.diagnostics.Errors.ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION
+import org.jetbrains.kotlin.diagnostics.Errors.ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_ERROR
 import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.psi.ValueArgument
 import org.jetbrains.kotlin.resolve.calls.callResolverUtil.isArrayOrArrayLiteral
@@ -18,6 +22,18 @@ import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
 import org.jetbrains.kotlin.resolve.descriptorUtil.isParameterOfAnnotation
 
 class AssigningNamedArgumentToVarargChecker : CallChecker {
+    companion object {
+        private val migrationDiagnosticsForFunction = MigrationDiagnostics(
+            ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION,
+            ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_ERROR
+        )
+
+        private val migrationDiagnosticsForAnnotation = MigrationDiagnostics(
+            Errors.ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_ANNOTATION,
+            Errors.ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_ANNOTATION_ERROR
+        )
+    }
+
     override fun check(resolvedCall: ResolvedCall<*>, reportOn: PsiElement, context: CallCheckerContext) {
         for ((parameterDescriptor, resolvedArgument) in resolvedCall.valueArguments) {
             for (argument in resolvedArgument.arguments) {
@@ -31,7 +47,7 @@ class AssigningNamedArgumentToVarargChecker : CallChecker {
         parameterDescriptor: ValueParameterDescriptor,
         context: ResolutionContext<*>
     ) {
-        if (!context.languageVersionSettings.supportsFeature(LanguageFeature.AssigningArraysToVarargsInNamedFormInAnnotations)) return
+        if (!context.languageVersionSettings.supportsFeature(AssigningArraysToVarargsInNamedFormInAnnotations)) return
 
         if (!argument.isNamed()) return
         if (!parameterDescriptor.isVararg) return
@@ -50,12 +66,19 @@ class AssigningNamedArgumentToVarargChecker : CallChecker {
         argumentExpression: KtExpression,
         context: ResolutionContext<*>
     ) {
+        fun report(onlyWarning: Boolean = false) {
+            reportMigrationDiagnostic(migrationDiagnosticsForAnnotation, context, onlyWarning) { diagnostic ->
+                context.trace.report(diagnostic.on(argumentExpression))
+            }
+        }
+
         if (isArrayOrArrayLiteral(argument, context.trace)) {
             if (argument.hasSpread()) {
-                context.trace.report(Errors.ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_ANNOTATION.on(argumentExpression))
+                // We want to make calls @Foo(value = [A]) and @Foo(value = *[A]) equivalent
+                report(onlyWarning = true)
             }
         } else {
-            context.trace.report(Errors.ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_ANNOTATION.on(argumentExpression))
+            report()
         }
     }
 
@@ -66,14 +89,27 @@ class AssigningNamedArgumentToVarargChecker : CallChecker {
         parameterDescriptor: ValueParameterDescriptor
     ) {
         if (!argument.hasSpread()) {
-            context.trace.report(
-                Errors.ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION.on(
-                    argumentExpression,
-                    parameterDescriptor.type
-                )
-            )
+            reportMigrationDiagnostic(migrationDiagnosticsForFunction, context) { diagnostic ->
+                context.trace.report(diagnostic.on(argumentExpression, parameterDescriptor.type))
+            }
         }
     }
 
     private fun ValueArgument.hasSpread() = getSpreadElement() != null
-}
+
+    private inline fun <T : DiagnosticFactory<*>> reportMigrationDiagnostic(
+        migrationDiagnostics: MigrationDiagnostics<T>,
+        context: ResolutionContext<*>,
+        onlyWarning: Boolean = false,
+        report: (T) -> Unit
+    ) {
+        val (warning, error) = migrationDiagnostics
+        if (!onlyWarning && context.languageVersionSettings.supportsFeature(ProhibitAssigningSingleElementsToVarargsInNamedForm)) {
+            report(error)
+        } else {
+            report(warning)
+        }
+    }
+}
+
+private data class MigrationDiagnostics<T : DiagnosticFactory<*>>(val warning: T, val error: T)