<component name="ProjectRunConfigurationManager">
  <configuration default="false" name="Generate Compiler Arguments Copy" type="GradleRunConfiguration" factoryName="Gradle" folderName="Generators">
    <ExternalSystemSettings>
      <option name="executionName" />
      <option name="externalProjectPath" value="$PROJECT_DIR$/generators" />
      <option name="externalSystemIdString" value="GRADLE" />
      <option name="scriptParameters" value="" />

                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) {

        val parameters = classifier.declaredTypeParameters
        val arguments = type.arguments

        if ((defaultType.isFunctionType && arguments.size > BuiltInFunctionArity.BIG_ARITY) || defaultType.isKFunctionType) {
            writeGenericArguments(sw, arguments.take(1), parameters.take(1), mode)
            return
        }

        writeGenericArguments(sw, arguments, parameters, mode)
    }

        }

        val typeParameters = descriptor.typeConstructor.parameters
        val type = if (typeParameters.size == builder.arguments.size) {
            val projections = builder.arguments.mapIndexed { index, arg ->
                when (arg) {
                    is KtStarTypeProjection -> StarProjectionImpl(typeParameters[index])

                KtCompilerPluginDiagnostic0Impl(it as KtPsiSimpleDiagnostic, token)
            }
            is KtDiagnosticFactory1<*> -> KtFirDiagnostic1Creator<Any?> { // Type argument specified because of KT-55281
                KtCompilerPluginDiagnostic1Impl(
                    it as KtPsiDiagnosticWithParameters1<*>,
                    token,
                    convertArgument(it.a, this)

            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() {

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)

        val ktExpression = expression.getParentOfType<KtExpression>(false) ?: return null
        val parentExpression = if (ktExpression.parent is KtLabeledExpression) {
            // lambda -> labeled expression -> lambda argument (value argument)
            ktExpression.parent.parent
        } else {
            ktExpression.parent
        }

        // Unwrap specific expressions
        when (ktExpression) {