print("<ERROR TYPE REF>")
            }

            printCollection(namedValues, separator = ", ", prefix = "(", postfix = ")") { argument ->
                append(argument.name.render())
                append(" = ")
                renderConstantValueDebug(argument.expression, printer)
            }
        }
    }

    private fun renderConstantValueDebug(value: KtAnnotationValue, printer: PrettyPrinter) {

internal fun mapAnnotationParameters(annotation: FirAnnotation): Map<Name, FirExpression> {
    if (annotation is FirAnnotationCall && annotation.arguments.isEmpty()) return emptyMap()

    checkWithAttachment(annotation.resolved, { "By now the annotations argument mapping should have been resolved" }) {
        withFirEntry("annotation", annotation)
        withClassEntry("annotationTypeRef", annotation.annotationTypeRef)

            token,
        )
    }
    add(FirErrors.ANNOTATION_ARGUMENT_KCLASS_LITERAL_OF_TYPE_PARAMETER_ERROR) { firDiagnostic ->
        AnnotationArgumentKclassLiteralOfTypeParameterErrorImpl(
            firDiagnostic as KtPsiDiagnostic,
            token,
        )
    }
    add(FirErrors.ANNOTATION_ARGUMENT_MUST_BE_CONST) { firDiagnostic ->
        AnnotationArgumentMustBeConstImpl(

     * Maps [typeArguments] to the type parameters of [partiallyAppliedSymbol].
     *
     * If too many type arguments are provided, a mapping is still created. Extra type arguments are simply ignored. If this wasn't the
     * case, the resulting [KtCall] would contain no type arguments at all, which can cause problems later. If too few type arguments are

            }

            is FirVarargArgumentsExpression -> {
                // Vararg arguments may have multiple independent expressions associated.
                // Choose one to be the representative PSI value for the entire assembled argument.
                val (annotationValues, representativePsi) = arguments.convertVarargsExpression(builder)

        val result = LinkedHashMap<KtExpression, KtVariableLikeSignature<KtValueParameterSymbol>>()
        for ((parameter, arguments) in valueArguments) {
            val parameterSymbol = KtFe10DescValueParameterSymbol(parameter, analysisContext)

            for (argument in arguments.arguments) {
                val expression = argument.getArgumentExpression() ?: continue

            declarationDescriptor !in allowedTypeParameterDescriptors ||
                    declarationDescriptor.upperBounds.any { it.hasReferenceOtherThan(allowedTypeParameterDescriptors) }
        }
        else -> arguments.any { typeProjection ->
            // A star projection type (lazily) built by type parameter will be yet another type with a star projection,

/compiler/builtins-serializer/ "Kotlin Compiler Core" Simon.Ogorodnik
/compiler/cli/ "Kotlin Compiler Core" Simon.Ogorodnik
/compiler/cli/cli-js/ "Kotlin Common Backend" "Kotlin Wasm"
/compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/K2NativeCompilerArguments.kt "Kotlin Native"
/compiler/compiler.version/ "Kotlin Compiler Core" Simon.Ogorodnik
/compiler/compiler-runner/ "Kotlin Compiler Core" Simon.Ogorodnik

            fakeFirQualifiedAccess = buildFunctionCall {
                annotations.addAll(functionCall.annotations)

                /**
                 * It is important to avoid passing type arguments when they are implicit type arguments.
                 * For example,
                 *   package a.b.c
                 *   fun <T, E> foo(a: T, b: E) {}      // A
                 *   fun test() {

    return KtAnnotationApplicationWithArgumentsInfo(
        classId = toAnnotationClassId(builder.rootSession),
        psi = psi as? KtCallElement,
        useSiteTarget = useSiteTarget,
        arguments = arguments,
        index = index,
        constructorSymbolPointer = with(builder.analysisSession) { constructorSymbol?.createPointer() },
        token = builder.token,
    )
}