[FIR] Fix and simplify FirUnsupportedArrayLiteralChecker

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUnsupportedArrayLiteralChecker.kt

@@ -14,13 +14,15 @@ import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
 import org.jetbrains.kotlin.fir.declarations.impl.FirPrimaryConstructor
 import org.jetbrains.kotlin.fir.declarations.utils.isCompanion
-import org.jetbrains.kotlin.fir.expressions.*
+import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
+import org.jetbrains.kotlin.fir.expressions.FirArrayLiteral
+import org.jetbrains.kotlin.fir.expressions.FirFunctionCall
 import org.jetbrains.kotlin.fir.types.resolvedType
 import org.jetbrains.kotlin.fir.types.toRegularClassSymbol
 
 object FirUnsupportedArrayLiteralChecker : FirArrayLiteralChecker() {
     override fun check(expression: FirArrayLiteral, context: CheckerContext, reporter: DiagnosticReporter) {
-        if (!isInsideAnnotationCall(expression, context) &&
+        if (!isInsideAnnotationCall(context) &&
             (context.callsOrAssignments.isNotEmpty() || !isInsideAnnotationClass(context))
         ) {
             reporter.reportOn(
@@ -32,42 +34,12 @@ object FirUnsupportedArrayLiteralChecker : FirArrayLiteralChecker() {
         }
     }
 
-    private fun isInsideAnnotationCall(expression: FirArrayLiteral, context: CheckerContext): Boolean {
+    private fun isInsideAnnotationCall(context: CheckerContext): Boolean = context.callsOrAssignments.asReversed().any {
-        context.callsOrAssignments.lastOrNull()?.let {
+        when (it) {
-            val arguments = when (it) {
+            is FirFunctionCall -> it.resolvedType.toRegularClassSymbol(context.session)?.classKind == ClassKind.ANNOTATION_CLASS
-                is FirFunctionCall ->
+            is FirAnnotationCall -> true
-                    if (it.resolvedType.toRegularClassSymbol(context.session)?.classKind == ClassKind.ANNOTATION_CLASS) {
+            else -> false
-                        it.arguments
-                    } else {
-                        return false
-                    }
-                is FirAnnotationCall -> it.arguments
-                else -> return false
-            }
-
-            return arguments.any { argument ->
-                val unwrappedArguments =
-                    if (argument is FirVarargArgumentsExpression) {
-                        argument.arguments.map { arg -> arg.unwrapArgument() }
-                    } else {
-                        listOf(argument.unwrapArgument())
-                    }
-
-                for (unwrapped in unwrappedArguments) {
-                    if (unwrapped == expression ||
-                        (unwrapped is FirErrorExpression && unwrapped.expression == expression) ||
-                        unwrapped is FirArrayLiteral &&
-                        unwrapped.arguments.any { arrayLiteralElement -> arrayLiteralElement.unwrapArgument() == expression }
-                    ) {
-                        return@any true
-                    }
-                }
-
-                return@any false
-            }
         }
-
-        return false
     }
 
     private fun isInsideAnnotationClass(context: CheckerContext): Boolean {

compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/standaloneInExpression.fir.kt

@@ -1,18 +0,0 @@
-annotation class AnnE(val i: String)
-
-enum class MyEnum {
-    A
-}
-
-@AnnE(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>"1" + MyEnum.A<!>)
-class Test
-
-@AnnE(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>"1" + MyEnum::class<!>)
-class Test2
-
-@AnnE(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>"1" + AnnE("23")<!>)
-class Test3
-
-@AnnE(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>"1" + <!UNSUPPORTED!>arrayOf("23", "34")<!><!>)
-class Test4
-

compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/standaloneInExpression.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 annotation class AnnE(val i: String)
 
 enum class MyEnum {

compiler/testData/diagnostics/tests/annotations/dontReportWarningAboutChangingExecutionOrderForVararg.fir.kt

@@ -4,7 +4,7 @@ annotation class Anno(vararg val x: String, val y: String)
 @Anno(x = <!ARGUMENT_TYPE_MISMATCH!>[["a", "b"], ["a", "b"]]<!>, y = "a")
 fun foo1() {}
 
-@Anno(x = <!ARGUMENT_TYPE_MISMATCH!>[[<!UNSUPPORTED!>["a"]<!>]]<!>, y = "b")
+@Anno(x = <!ARGUMENT_TYPE_MISMATCH!>[[["a"]]]<!>, y = "b")
 fun foo11() {}
 
 @Anno(x = ["a", "b"], y = "a")

compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/array.fir.kt

@@ -6,7 +6,7 @@ annotation class Ann(val i: IntArray)
 @Ann(intArrayOf(i2))
 @Ann(<!NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION!>intArrayOf(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>i3<!>)<!>)
 @Ann(<!NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION!>intArrayOf(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>i<!>, i2, <!ANNOTATION_ARGUMENT_MUST_BE_CONST!>i3<!>)<!>)
-@Ann(<!NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION!>intArrayOf(<!ARGUMENT_TYPE_MISMATCH, NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION, UNSUPPORTED!>intArrayOf(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>i<!>, i2, <!ANNOTATION_ARGUMENT_MUST_BE_CONST!>i3<!>)<!>)<!>)
+@Ann(<!NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION!>intArrayOf(<!ARGUMENT_TYPE_MISMATCH, NON_CONST_VAL_USED_IN_CONSTANT_EXPRESSION!>intArrayOf(<!ANNOTATION_ARGUMENT_MUST_BE_CONST!>i<!>, i2, <!ANNOTATION_ARGUMENT_MUST_BE_CONST!>i3<!>)<!>)<!>)
 class Test
 
 var i = 1