public val callableIdIfNonLocal: CallableId? get() = callableId

    /**
     * Applies a [substitutor] to the given signature and return a new signature with substituted types.
     *
     * @see KaSubstitutor.substitute
     */
    public abstract fun substitute(substitutor: KaSubstitutor): KaCallableSignature<S>

    abstract override fun equals(other: Any?): Boolean

     *
     * @see KaSubstitutor.substitute
     */
    public fun <S : KaFunctionLikeSymbol> S.substitute(substitutor: KaSubstitutor): KaFunctionLikeSignature<S> =
        withValidityAssertion { analysisSession.signatureSubstitutor.substitute(this, substitutor) }

    /**
     * Applies a [substitutor] to the given symbols and return a signature with substituted types.
     *

    /**
     * substitutes type parameters in a given type corresponding to internal mapping rules.
     *
     * @return substituted type if there was at least one substitution, [type] itself if there was no type parameter to substitute
     */
    public fun substitute(type: KaType): KaType = withValidityAssertion { substituteOrNull(type) ?: type }

    /**

        val actual = analyseForTest(declaration) {
            val substitutor = SubstitutionParser.parseSubstitutor(analysisSession, mainFile, declaration)
            val symbol = declaration.getSymbol() as KaCallableSymbol
            val type = symbol.returnType
            val substituted = substitutor.substitute(type)
            val substitutedOrNull = substitutor.substituteOrNull(type)

            prettyPrint {

        testServices.assertions.assertEquals(symbol.returnType.let(substitutor::substitute), signature.returnType)

        testServices.assertions.assertEquals(symbol.valueParameters.size, signature.valueParameters.size)

        for ((unsubstituted, substituted) in symbol.valueParameters.zip(signature.valueParameters)) {

package types

import (
	"go/token"
)

type substMap map[*TypeParam]Type

// makeSubstMap creates a new substitution map mapping tpars[i] to targs[i].
// If targs[i] is nil, tpars[i] is not substituted.
func makeSubstMap(tpars []*TypeParam, targs []Type) substMap {
	assert(len(tpars) == len(targs))
	proj := make(substMap, len(tpars))
	for i, tpar := range tpars {
		proj[tpar] = targs[i]
	}
	return proj
}

package types2

import (
	"cmd/compile/internal/syntax"
)

type substMap map[*TypeParam]Type

// makeSubstMap creates a new substitution map mapping tpars[i] to targs[i].
// If targs[i] is nil, tpars[i] is not substituted.
func makeSubstMap(tpars []*TypeParam, targs []Type) substMap {
	assert(len(tpars) == len(targs))
	proj := make(substMap, len(tpars))
	for i, tpar := range tpars {
		proj[tpar] = targs[i]
	}
	return proj
}

 */
public abstract class KaFunctionLikeSignature<out S : KaFunctionLikeSymbol> : KaCallableSignature<S>() {
    /**
     * The use-site-substituted value parameters.
     */
    public abstract val valueParameters: List<KaVariableLikeSignature<KaValueParameterSymbol>>

    abstract override fun substitute(substitutor: KaSubstitutor): KaFunctionLikeSignature<S>
}

     *
     * E.g., if we have `A.foo` overrides `B.foo` overrides `C.foo`, all two super declarations `B.foo`, `C.foo` will be returned
     *
     * Unwraps substituted overridden symbols

            val superClassSymbol = superClass.getClassOrObjectSymbol()!!
            val substitutor = createInheritanceTypeSubstitutor(baseClass.getClassOrObjectSymbol()!!, superClassSymbol)
            prettyPrint {
                appendLine("Substitutor: ${stringRepresentation(substitutor)}")
                if (substitutor != null) {
                    val functions = superClassSymbol.getDeclaredMemberScope().getAllSymbols()