}
            valueParameters.joinTo(this) { stringRepresentation(it) }
            append(")")
            append(": ${returnType.render()}")
        }
        is KaValueParameterSymbol -> "${if (isVararg) "vararg " else ""}$name: ${returnType.render()}"
        is KaTypeParameterSymbol -> this.nameOrAnonymous.asString()
        is KaVariableSymbol -> "${if (isVal) "val" else "var"} $name: ${returnType.render()}"

        val firSymbol = useSiteSession.symbolProvider.getTopLevelCallableSymbols(kotlinPackage, identifier).firstOrNull {
            /* choose (for byte array)
             * public fun byteArrayOf(vararg elements: kotlin.Byte): kotlin.ByteArray
             */
            (it as? FirFunctionSymbol<*>)?.fir?.valueParameters?.singleOrNull()?.isVararg == true
        } as? FirNamedFunctionSymbol ?: return null

    public fun KtExpression.getKtType(): KaType? = getKaType()

    /**
     * Returns the return type of the given [KtDeclaration] as [KaType].
     *
     * IMPORTANT: For `vararg foo: T` parameter returns full `Array<out T>` type (unlike
     * [KaValueParameterSymbol.returnType][org.jetbrains.kotlin.analysis.api.symbols.KaValueParameterSymbol.returnType],
     * which returns `T`).
     */

    }

    /**
     * Returns whether it is fine to shorten [firQualifiedAccess] or not.
     *
     * @param firQualifiedAccess FIR for the shortening target expression
     * @param calledSymbol The symbol referenced by the qualified access expression
     * @param expressionInScope An expression under the same scope as the shortening target expression
     *
     * The decision has two steps:

- [`KT-60820`](https://youtrack.jetbrains.com/issue/KT-60820) K1: Empty vararg value is inserted in serialized annotation call with expect default vararg value
- [`KT-58172`](https://youtrack.jetbrains.com/issue/KT-58172) Forbid `expect class A actual constructor`

    /**
     * Return a sequence of [KaCallableSymbol] which current scope contain, if declaration name present in [names]
     *
     * @see getCallableSymbols
     */
    public fun getCallableSymbols(vararg names: Name): Sequence<KaCallableSymbol> =
        getCallableSymbols(names.toList())

    /**

    /**
     * Return a sequence of [KaCallableSignature] which current scope contain if declaration, if declaration name present in [names]
     *
     * @see getCallableSignatures
     */
    public fun getCallableSignatures(vararg names: Name): Sequence<KaCallableSignature<*>> = withValidityAssertion {
        getCallableSignatures(names.toList())
    }

    /**

                            val resultMap = mutableMapOf<Name, FirExpression>()
                            resolvedArgumentMapping?.entries?.forEach { (arg, param) ->
                                resultMap[param.name] = arg
                            }

                            KaAnnotationApplicationValue(
                                KaAnnotationImpl(

    override fun readWriteAccessWithFullExpressionByResolve(assignment: KtBinaryExpression): Pair<ReferenceAccess, KtExpression> {
        // Various parts of the IJ plugin use the read/write access checker without being aware that it uses `analyze` under the hood. For
        // now, it makes more sense to allow analysis on EDT/from write actions here, as there are many such usages in the IJ plugin.
        return allowAnalysisOnEdt {

) : KaCallableMemberCall<S, KaFunctionLikeSignature<S>>() {

    /**
     * The mapping from argument to parameter declaration. In case of vararg parameters, multiple arguments may be mapped to the same
     * [KaValueParameterSymbol].
     */
    public val argumentMapping: LinkedHashMap<KtExpression, KaVariableLikeSignature<KaValueParameterSymbol>>