Errors.DELEGATE_SPECIAL_FUNCTION_NONE_APPLICABLE,
            Errors.DELEGATE_PD_METHOD_NONE_APPLICABLE,
        )

        private val DiagnosticFactoryForDeprecation<*, *, *>.factories: Array<DiagnosticFactoryWithPsiElement<*, *>>
            get() = arrayOf(warningFactory, errorFactory)
    }

    override val token: KtLifetimeToken
        get() = analysisSession.token

                    is FirNamedFunctionSymbol -> {
                        // arrayOf call with a single vararg argument.
                        if (resolvedSymbol.callableId.asSingleFqName() in ArrayFqNames.ARRAY_CALL_FQ_NAMES)
                            argumentList.arguments.singleOrNull()?.convertConstantExpression(builder)
                                ?: KtArrayAnnotationValue(emptyList(), sourcePsi, token)

 * and the argument, are compile-time constant as well.
 */
internal object FirCompileTimeConstantEvaluator {
    // TODO: Handle boolean operators, class reference, array, annotation values, etc.
    fun evaluate(
        fir: FirElement?,
        mode: KtConstantEvaluationMode,
    ): FirLiteralExpression<*>? =
        when (fir) {
            is FirPropertyAccessExpression -> {

            // used iff the qualified expression is.
            is KtQualifiedExpression ->
                parent.receiverExpression == child || (parent.selectorExpression == child && isUsed(parent))

            // Array accesses use both receiver and index.
            is KtArrayAccessExpression ->
                child in parent.indexExpressions || parent.arrayExpression == child

            substitutedType.varargElementType().asKtType()
        else
            substitutedType.asKtType()
    }

    /**
     * Expected type of the indexing parameter in array access, for example, in the following code:
     * ```
     * val map = mapOf<Int, String>()
     * map[k] = v
     * ```
     * `k` is indexing parameter and its expected type is `Int`.
     */

      <replaceConfiguration name="new String[0]" text="new String[0]" recursive="false" caseInsensitive="true" type="JAVA" reformatAccordingToStyle="true" shortenFQN="true" replacement="com.intellij.util.ArrayUtil.EMPTY_STRING_ARRAY" />

        get() {
            val sourcePsi = when {
                // array type for vararg parameters is not present in the code, so no need to handle it
                delegatedTypeRef?.source?.kind == KtFakeSourceElementKind.ArrayTypeFromVarargParameter -> null

                // but the array's underlying type is present with a fake source, and needs to be handled

    if (analysisContext.builtIns.areSameArrayTypeIgnoringProjections(containingArrayType, constantType)) {
        // If an element in the array has the same type as the containing array, it's a spread component that needs
        // to be expanded here. (It should have the array element type instead.)
        (constantValue as ArrayValue).value.expandArrayAnnotationValue(containingArrayType, analysisContext)
    } else {

  }

  @Test
  @TestMetadata("array_arrayOfNulls.kt")
  public void testArray_arrayOfNulls() {
    runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/array_arrayOfNulls.kt");
  }

  @Test
  @TestMetadata("assignmentExpressionTarget.kt")
  public void testAssignmentExpressionTarget() {

          <value>
            <array>
              <option value="$PROJECT_DIR$/js/js.tests/build/node/{out,out-min,out-per-module,out-per-module-min}/codegen/{boxInline,irBoxInline,firBoxInline,firEs6BoxInline}/$TEST_DATA_FILE$_v5.js" />
            </array>
          </value>
        </entry>
        <entry key="$PROJECT_DIR$/compiler/testData/debug">
          <value>
            <array>