}

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

  @Test
  @TestMetadata("listElement_mutableListOf.kt")
  public void testListElement_mutableListOf() {

        // to be expanded here. (It should have the array element type instead.)
        (constantValue as ArrayValue).value.expandArrayAnnotationValue(containingArrayType, analysisContext)
    } else {
        listOf(constantValue.toKtAnnotationValue(analysisContext))
    }
}

internal fun ConstantValue<*>.toKtAnnotationValue(analysisContext: Fe10AnalysisContext): KtAnnotationValue {
    val token = analysisContext.token

    useJUnitPlatform()
}.also { confugureFirPluginAnnotationsDependency(it) }

testsJar()

allprojects {
    tasks.withType<KotlinJvmCompile>().configureEach {
        compilerOptions.optIn.addAll(
            listOf(
                "org.jetbrains.kotlin.fir.symbols.SymbolInternals",
                "org.jetbrains.kotlin.analysis.api.lifetime.KtAllowProhibitedAnalyzeFromWriteAction"
            )
        )
    }
}

        val lexicalScope = positionInFakeFile.getResolutionScope(bindingContext)
        if (lexicalScope != null) {
            val compositeScope = KtCompositeScope.create(listOf(KtFe10ScopeLexical(lexicalScope, analysisContext)), token)
            return KtScopeContext(listOf(KtScopeWithKind(compositeScope, scopeKind, token)), collectImplicitReceivers(lexicalScope), token)
        }

    val intersectionOverriddenSymbolsOrSingle = when {
        symbol.origin == KtSymbolOrigin.INTERSECTION_OVERRIDE && symbol is KtCallableSymbol -> symbol.getIntersectionOverriddenSymbols()
        else -> listOf(symbol)
    }
    return intersectionOverriddenSymbolsOrSingle.mapNotNull { it.findPsiForReferenceResolve() }
}

private fun KtSymbol.findPsiForReferenceResolve(): PsiElement? {
    require(this is KtFirSymbol<*>)

    override val hasBody: Boolean
        get() = withValidityAssertion { false }

    override val valueParameters: List<KtValueParameterSymbol>
        get() = withValidityAssertion { listOf(parameter) }

    override val hasStableParameterNames: Boolean
        get() = withValidityAssertion { true }

    override val callableIdIfNonLocal: CallableId?

        get() = withValidityAssertion {
            if (descriptor.isDynamic()) {
                // For consistency with the K2 implementation, see `FirDynamicMembersStorage`
                return@withValidityAssertion listOf(KtFe10DynamicFunctionDescValueParameterSymbol(this))
            }
            descriptor.valueParameters.map { KtFe10DescValueParameterSymbol(it, analysisContext) }
        }

            if (labeledElement is FirErrorFunction) emptyList() else listOf(labeledElement.buildSymbol(symbolBuilder))
        } else emptyList()
    }

    private fun getSymbolsByFirFile(
        symbolBuilder: KtSymbolByFirBuilder,
        fir: FirFile
    ): List<KtSymbol> {
        return listOf(symbolBuilder.buildSymbol(fir.symbol))
    }

    private fun getSybmolsByTypeParameter(

        }

        if (bConstructor is IntersectionTypeConstructor) {
            return bConstructor.supertypes.all { areTypesCompatible(a, it) }
        }

        val intersectionType = intersectWrappedTypes(listOf(a, b))
        val intersectionTypeConstructor = intersectionType.constructor

        if (intersectionTypeConstructor is IntersectionTypeConstructor) {

): KtAnnotationApplicationWithArgumentsInfo {
    val arguments = findFromRawArguments(
        expectedEnumClass = expectedEnumClassId,
        nameMapper,
    ).ifNotEmpty {
        val token = builder.token

        listOf(
            KtNamedAnnotationValue(
                name = annotationParameterName,
                expression = KtArrayAnnotationValue(
                    values = map {