[Analysis API] introduce API to work with signatures substitution

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/KtFe10AnalysisSession.kt

@@ -56,6 +56,7 @@ class KtFe10AnalysisSession(
     override val symbolInfoProviderImpl: KtSymbolInfoProvider = KtFe10SymbolInfoProvider(this)
     override val analysisScopeProviderImpl: KtAnalysisScopeProvider = KtAnalysisScopeProviderImpl(this, token)
     override val referenceResolveProviderImpl: KtReferenceResolveProvider = KtFe10ReferenceResolveProvider(this)
+    override val substitutionProviderImpl: KtSignatureSubsitutor = KtFe10SignatureSubsitutor(this)
 
     override fun createContextDependentCopy(originalKtFile: KtFile, elementToReanalyze: KtElement): KtAnalysisSession =
         withValidityAssertion {

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SignatureSubsitutor.kt

@@ -0,0 +1,14 @@
+/*
+ * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.descriptors.components
+
+import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
+import org.jetbrains.kotlin.analysis.api.descriptors.components.base.Fe10KtAnalysisSessionComponent
+import org.jetbrains.kotlin.analysis.api.impl.base.components.AbstractKtSignatureSubsitutorImpl
+
+internal class KtFe10SignatureSubsitutor(
+    override val analysisSession: KtFe10AnalysisSession
+) : AbstractKtSignatureSubsitutorImpl(), Fe10KtAnalysisSessionComponent

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/KtFirAnalysisSession.kt

@@ -26,6 +26,7 @@ import org.jetbrains.kotlin.fir.resolve.providers.symbolProvider
 import org.jetbrains.kotlin.platform.TargetPlatform
 import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.psi.KtFile
+
 @Suppress("AnalysisApiMissingLifetimeCheck")
 internal class KtFirAnalysisSession
 private constructor(
@@ -35,7 +36,7 @@ private constructor(
     private val mode: AnalysisSessionMode,
 ) : KtAnalysisSession(token) {
 
-    internal val firSymbolBuilder: KtSymbolByFirBuilder = KtSymbolByFirBuilder(firResolveSession, project, token)
+    internal val firSymbolBuilder: KtSymbolByFirBuilder = KtSymbolByFirBuilder(project, this, token)
 
     @Suppress("AnalysisApiMissingLifetimeCheck")
     override val useSiteModule: KtModule get() = firResolveSession.useSiteKtModule
@@ -102,6 +103,8 @@ private constructor(
 
     override val referenceResolveProviderImpl: KtReferenceResolveProvider = KtFirReferenceResolveProvider(this)
 
+    override val substitutionProviderImpl: KtSignatureSubsitutor = KtFirSignatureSubsitutor(this)
+
     @Suppress("AnalysisApiMissingLifetimeCheck")
     override fun createContextDependentCopy(originalKtFile: KtFile, elementToReanalyze: KtElement): KtAnalysisSession {
         check(mode == AnalysisSessionMode.REGULAR) {
@@ -118,7 +121,6 @@ private constructor(
         return KtFirAnalysisSession(
             project,
             contextFirResolveSession,
-            firSymbolBuilder.createReadOnlyCopy(contextFirResolveSession),
             token,
             AnalysisSessionMode.DEPENDENT_COPY
         )

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/KtSymbolByFirBuilder.kt

@@ -12,10 +12,8 @@ import com.intellij.util.containers.ContainerUtil
 import org.jetbrains.kotlin.analysis.api.*
 import org.jetbrains.kotlin.analysis.api.fir.symbols.*
 import org.jetbrains.kotlin.analysis.api.fir.types.*
-import org.jetbrains.kotlin.analysis.api.fir.utils.weakRef
-import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeOwner
-import org.jetbrains.kotlin.analysis.api.symbols.*
 import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken
+import org.jetbrains.kotlin.analysis.api.symbols.*
 import org.jetbrains.kotlin.analysis.api.types.KtSubstitutor
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.LLFirResolveSession
@@ -52,11 +50,12 @@ import kotlin.contracts.contract
 /**
  * Maps FirElement to KtSymbol & ConeType to KtType, thread safe
  */
-internal class KtSymbolByFirBuilder private constructor(
+internal class KtSymbolByFirBuilder constructor(
     private val project: Project,
-    private val firResolveSession: LLFirResolveSession,
+    private val analysisSession: KtFirAnalysisSession,
     val token: KtLifetimeToken,
 ) {
+    private val firResolveSession: LLFirResolveSession = analysisSession.firResolveSession
     private val firProvider get() = firResolveSession.useSiteFirSession.symbolProvider
     val rootSession: FirSession = firResolveSession.useSiteFirSession
 
@@ -191,7 +190,7 @@ internal class KtSymbolByFirBuilder private constructor(
         fun buildFunctionLikeSignature(fir: FirFunctionSymbol<*>): KtFunctionLikeSignature<KtFunctionLikeSymbol> {
             if (fir is FirNamedFunctionSymbol && fir.origin != FirDeclarationOrigin.SamConstructor)
                 return buildFunctionSignature(fir)
-            return buildFunctionLikeSymbol(fir).toSignature()
+            return with(analysisSession) { buildFunctionLikeSymbol(fir).asSignature() }
         }
 
         fun buildFunctionSymbol(firSymbol: FirNamedFunctionSymbol): KtFirFunctionSymbol {
@@ -282,7 +281,7 @@ internal class KtSymbolByFirBuilder private constructor(
             if (firSymbol is FirPropertySymbol && !firSymbol.isLocal && firSymbol !is FirSyntheticPropertySymbol) {
                 return buildPropertySignature(firSymbol)
             }
-            return buildVariableLikeSymbol(firSymbol).toSignature()
+            return with(analysisSession) { buildVariableLikeSymbol(firSymbol).asSignature() }
         }
 
         fun buildVariableSymbol(firSymbol: FirPropertySymbol): KtVariableSymbol {
@@ -372,7 +371,7 @@ internal class KtSymbolByFirBuilder private constructor(
 
         fun buildCallableSignature(firSymbol: FirCallableSymbol<*>): KtSignature<KtCallableSymbol> {
             return when (firSymbol) {
-                is FirPropertyAccessorSymbol -> buildPropertyAccessorSymbol(firSymbol).toSignature()
+                is FirPropertyAccessorSymbol ->  with(analysisSession) { buildPropertyAccessorSymbol(firSymbol).asSignature() }
                 is FirFunctionSymbol<*> -> functionLikeBuilder.buildFunctionLikeSignature(firSymbol)
                 is FirVariableSymbol<*> -> variableLikeBuilder.buildVariableLikeSignature(firSymbol)
                 else -> throwUnexpectedElementError(firSymbol)

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirCallResolver.kt

@@ -335,7 +335,7 @@ internal class KtFirCallResolver(
                 extensionReceiverValue = explicitReceiverValue
             }
             return KtPartiallyAppliedSymbol(
-                unsubstitutedKtSignature.substitute(substitutor),
+                with(analysisSession) { unsubstitutedKtSignature.substitute(substitutor) },
                 dispatchReceiverValue,
                 extensionReceiverValue,
             )
@@ -353,7 +353,7 @@ internal class KtFirCallResolver(
                 )
             } else {
                 KtPartiallyAppliedSymbol(
-                    unsubstitutedKtSignature.substitute(substitutor),
+                    with(analysisSession) { unsubstitutedKtSignature.substitute(substitutor) },
                     candidate.dispatchReceiverValue?.receiverExpression?.toKtReceiverValue(),
                     candidate.chosenExtensionReceiverValue?.receiverExpression?.toKtReceiverValue(),
                 )
@@ -368,7 +368,7 @@ internal class KtFirCallResolver(
                 createKtPartiallyAppliedSymbolForImplicitInvoke(fir.dispatchReceiver, fir.extensionReceiver, explicitReceiverKind)
             } else {
                 KtPartiallyAppliedSymbol(
-                    unsubstitutedKtSignature.substitute(substitutor),
+                    with(analysisSession) { unsubstitutedKtSignature.substitute(substitutor) },
                     fir.dispatchReceiver.toKtReceiverValue(),
                     fir.extensionReceiver.toKtReceiverValue()
                 )
@@ -624,7 +624,7 @@ internal class KtFirCallResolver(
         val substitutor = createConeSubstitutorFromTypeArguments() ?: return null
         val ktSignature = variableSymbol.toKtSignature()
         return KtPartiallyAppliedSymbol(
-            ktSignature.substitute(substitutor.toKtSubstitutor()),
+            with(analysisSession) { ktSignature.substitute(substitutor.toKtSubstitutor()) },
             dispatchReceiver.toKtReceiverValue(),
             extensionReceiver.toKtReceiverValue(),
         )
@@ -648,7 +648,7 @@ internal class KtFirCallResolver(
         }
         val ktSignature = operationSymbol.toKtSignature()
         return KtPartiallyAppliedSymbol(
-            ktSignature.substitute(substitutor.toKtSubstitutor()),
+            with(analysisSession) { ktSignature.substitute(substitutor.toKtSubstitutor()) },
             dispatchReceiverValue,
             extensionReceiverValue,
         )
@@ -868,7 +868,7 @@ internal class KtFirCallResolver(
                         listOf(
                             KtSimpleFunctionCall(
                                 KtPartiallyAppliedSymbol(
-                                    defaultArrayOfSymbol.toSignature(substitutor),
+                                    with(analysisSession) { defaultArrayOfSymbol.substitute(substitutor) },
                                     null,
                                     null,
                                 ),
@@ -887,7 +887,7 @@ internal class KtFirCallResolver(
         return KtSuccessCallInfo(
             KtSimpleFunctionCall(
                 KtPartiallyAppliedSymbol(
-                    arrayOfSymbol.toSignature(substitutor),
+                    with(analysisSession) { arrayOfSymbol.substitute(substitutor) },
                     null,
                     null,
                 ),
@@ -989,7 +989,11 @@ internal class KtFirCallResolver(
         val parameterSymbol = arrayOfCallSymbol.valueParameters.single()
 
         for (firExpression in argumentList.arguments) {
-            mapArgumentExpressionToParameter(firExpression, parameterSymbol.toSignature(substitutor), ktArgumentMapping)
+            mapArgumentExpressionToParameter(
+                firExpression,
+                with(analysisSession) { parameterSymbol.substitute(substitutor) },
+                ktArgumentMapping
+            )
         }
         return ktArgumentMapping
     }

analysis/analysis-api-impl-base/src/org/jetbrains/kotlin/analysis/api/impl/base/components/AbstractKtSignatureSubsitutorImpl.kt

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.impl.base.components
+
+import org.jetbrains.kotlin.analysis.api.components.KtSignatureSubsitutor
+import org.jetbrains.kotlin.analysis.api.symbols.*
+import org.jetbrains.kotlin.analysis.api.types.KtSubstitutor
+import org.jetbrains.kotlin.analysis.utils.errors.unexpectedElementError
+
+abstract class AbstractKtSignatureSubsitutorImpl : KtSignatureSubsitutor() {
+    @Suppress("UNCHECKED_CAST")
+    override fun <S : KtCallableSymbol> substitute(signature: KtSignature<S>, substitutor: KtSubstitutor): KtSignature<S> {
+        return when (signature) {
+            is KtFunctionLikeSignature -> {
+                substitute(signature as KtFunctionLikeSignature<KtFunctionLikeSymbol>, substitutor) as KtSignature<S>
+            }
+            is KtVariableLikeSignature -> {
+                substitute(signature as KtVariableLikeSignature<KtVariableLikeSymbol>, substitutor) as KtSignature<S>
+            }
+        }
+    }
+
+    override fun <S : KtVariableLikeSymbol> substitute(
+        signature: KtVariableLikeSignature<S>,
+        substitutor: KtSubstitutor
+    ): KtVariableLikeSignature<S> {
+        if (substitutor is KtSubstitutor.Empty) return signature
+        return KtVariableLikeSignature(
+            signature.symbol,
+            substitutor.substituteOrSelf(signature.returnType),
+            signature.receiverType?.let { substitutor.substituteOrSelf(it) },
+        )
+    }
+
+    override fun <S : KtFunctionLikeSymbol> substitute(
+        signature: KtFunctionLikeSignature<S>,
+        substitutor: KtSubstitutor
+    ): KtFunctionLikeSignature<S> {
+        if (substitutor is KtSubstitutor.Empty) return signature
+        return KtFunctionLikeSignature(
+            signature.symbol,
+            substitutor.substituteOrSelf(signature.returnType),
+            signature.receiverType?.let { substitutor.substituteOrSelf(it) },
+            signature.valueParameters.map { substitute(it, substitutor) }
+        )
+    }
+
+
+    @Suppress("UNCHECKED_CAST")
+    override fun <S : KtCallableSymbol> substitute(symbol: S, substitutor: KtSubstitutor): KtSignature<S> {
+        return when (symbol) {
+            is KtFunctionLikeSymbol -> substitute(symbol, substitutor)
+            is KtVariableLikeSymbol -> substitute(symbol, substitutor)
+            else -> unexpectedElementError("symbol", symbol)
+        }
+    }
+
+    override fun <S : KtFunctionLikeSymbol> substitute(symbol: S, substitutor: KtSubstitutor): KtFunctionLikeSignature<S> {
+        if (substitutor is KtSubstitutor.Empty) return asSignature(symbol)
+        return KtFunctionLikeSignature(
+            symbol,
+            substitutor.substituteOrSelf(symbol.returnType),
+            symbol.receiverType?.let { substitutor.substituteOrSelf(it) },
+            symbol.valueParameters.map { substitute(it, substitutor) }
+        )
+    }
+
+    override fun <S : KtVariableLikeSymbol> substitute(symbol: S, substitutor: KtSubstitutor): KtVariableLikeSignature<S> {
+        if (substitutor is KtSubstitutor.Empty) return asSignature(symbol)
+        return KtVariableLikeSignature(
+            symbol,
+            substitutor.substituteOrSelf(symbol.returnType),
+            symbol.receiverType?.let { substitutor.substituteOrSelf(it) },
+        )
+    }
+
+    override fun <S : KtCallableSymbol> asSignature(symbol: S): KtSignature<S> {
+        return when (symbol) {
+            is KtFunctionLikeSymbol -> asSignature(symbol)
+            is KtVariableLikeSymbol -> asSignature(symbol)
+            else -> unexpectedElementError("symbol", symbol)
+        }
+    }
+
+    override fun <S : KtFunctionLikeSymbol> asSignature(symbol: S): KtFunctionLikeSignature<S> {
+        return KtFunctionLikeSignature(symbol, symbol.returnType, symbol.receiverType, symbol.valueParameters.map { asSignature(it) })
+    }
+
+    override fun <S : KtVariableLikeSymbol> asSignature(symbol: S): KtVariableLikeSignature<S> {
+        return KtVariableLikeSignature(symbol, symbol.returnType, symbol.receiverType)
+    }
+}

analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/KtAnalysisSession.kt

@@ -7,11 +7,11 @@ package org.jetbrains.kotlin.analysis.api
 
 import org.jetbrains.kotlin.analysis.api.components.*
 import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeOwner
+import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbolProvider
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbolProviderMixIn
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
-import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken
 import org.jetbrains.kotlin.analysis.project.structure.KtModule
 import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.psi.KtFile
@@ -57,7 +57,8 @@ public abstract class KtAnalysisSession(final override val token: KtLifetimeToke
     KtMemberSymbolProviderMixin,
     KtInheritorsProviderMixIn,
     KtTypeCreatorMixIn,
-    KtAnalysisScopeProviderMixIn {
+    KtAnalysisScopeProviderMixIn,
+    KtSignatureSubsitutorMixIn {
 
     public abstract val useSiteModule: KtModule
 
@@ -143,6 +144,9 @@ public abstract class KtAnalysisSession(final override val token: KtLifetimeToke
     internal val referenceResolveProvider: KtReferenceResolveProvider get() = referenceResolveProviderImpl
     protected abstract val referenceResolveProviderImpl: KtReferenceResolveProvider
 
+    internal val substitutionProvider: KtSignatureSubsitutor get() = substitutionProviderImpl
+    protected abstract val substitutionProviderImpl: KtSignatureSubsitutor
+
     @PublishedApi
     internal val typesCreator: KtTypeCreator
         get() = typesCreatorImpl

analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/components/KtSignatureSubsitutor.kt

@@ -0,0 +1,107 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.analysis.api.components
+
+import org.jetbrains.kotlin.analysis.api.lifetime.withValidityAssertion
+import org.jetbrains.kotlin.analysis.api.symbols.*
+import org.jetbrains.kotlin.analysis.api.types.KtSubstitutor
+
+public abstract class KtSignatureSubsitutor : KtAnalysisSessionComponent() {
+    public abstract fun <S : KtCallableSymbol> substitute(
+        signature: KtSignature<S>,
+        substitutor: KtSubstitutor
+    ): KtSignature<S>
+
+    public abstract fun <S : KtFunctionLikeSymbol> substitute(
+        signature: KtFunctionLikeSignature<S>,
+        substitutor: KtSubstitutor
+    ): KtFunctionLikeSignature<S>
+
+    public abstract fun <S : KtVariableLikeSymbol> substitute(
+        signature: KtVariableLikeSignature<S>,
+        substitutor: KtSubstitutor
+    ): KtVariableLikeSignature<S>
+
+    public abstract fun <S : KtCallableSymbol> substitute(symbol: S, substitutor: KtSubstitutor): KtSignature<S>
+
+    public abstract fun <S : KtFunctionLikeSymbol> substitute(symbol: S, substitutor: KtSubstitutor): KtFunctionLikeSignature<S>
+
+    public abstract fun <S : KtVariableLikeSymbol> substitute(symbol: S, substitutor: KtSubstitutor): KtVariableLikeSignature<S>
+
+    public abstract fun <S : KtCallableSymbol> asSignature(symbol: S): KtSignature<S>
+
+    public abstract fun <S : KtFunctionLikeSymbol> asSignature(symbol: S): KtFunctionLikeSignature<S>
+
+    public abstract fun <S : KtVariableLikeSymbol> asSignature(symbol: S): KtVariableLikeSignature<S>
+}
+
+public interface KtSignatureSubsitutorMixIn : KtAnalysisSessionMixIn {
+    /**
+     * Applies a [substitutor] to the given signature and return a new signature with substituted types.
+     *
+     * @see KtSubstitutor.substituteOrSelf
+     */
+    public fun <S : KtCallableSymbol> KtSignature<S>.substitute(substitutor: KtSubstitutor): KtSignature<S> =
+        withValidityAssertion { analysisSession.substitutionProvider.substitute(this, substitutor) }
+
+    /**
+     * Applies a [substitutor]  to the given signature and return a new signature with substituted types.
+     *
+     * @see KtSubstitutor.substituteOrSelf
+     */
+    public fun <S : KtFunctionLikeSymbol> KtFunctionLikeSignature<S>.substitute(substitutor: KtSubstitutor): KtFunctionLikeSignature<S> =
+        withValidityAssertion { analysisSession.substitutionProvider.substitute(this, substitutor) }
+
+    /**
+     * Applies a [substitutor]  to the given signature and return a new signature with substituted types.
+     *
+     * @see KtSubstitutor.substituteOrSelf
+     */
+    public fun <S : KtVariableLikeSymbol> KtVariableLikeSignature<S>.substitute(substitutor: KtSubstitutor): KtVariableLikeSignature<S> =
+        withValidityAssertion { analysisSession.substitutionProvider.substitute(this, substitutor) }
+
+    /**
+     * Applies a [substitutor] to the given symbols and return a signature with substituted types.
+     *
+     * @see KtSubstitutor.substituteOrSelf
+     */
+    public fun <S : KtCallableSymbol> S.substitute(substitutor: KtSubstitutor): KtSignature<S> =
+        withValidityAssertion { analysisSession.substitutionProvider.substitute(this, substitutor) }
+
+    /**
+     * Applies a [substitutor] to the given symbols and return a signature with substituted types.
+     *
+     * @see KtSubstitutor.substituteOrSelf
+     */
+    public fun <S : KtFunctionSymbol> S.substitute(substitutor: KtSubstitutor): KtFunctionLikeSignature<S> =
+        withValidityAssertion { analysisSession.substitutionProvider.substitute(this, substitutor) }
+
+    /**
+     * Applies a [substitutor] to the given symbols and return a signature with substituted types.
+     *
+     * @see KtSubstitutor.substituteOrSelf
+     */
+    public fun <S : KtVariableLikeSymbol> S.substitute(substitutor: KtSubstitutor): KtVariableLikeSignature<S> =
+        withValidityAssertion { analysisSession.substitutionProvider.substitute(this, substitutor) }
+
+    /**
+     * Creates a new [KtSignature] by given symbol and leave all types intact
+     */
+    public fun <S : KtCallableSymbol> S.asSignature(): KtSignature<S> =
+        withValidityAssertion { analysisSession.substitutionProvider.asSignature(this) }
+
+    /**
+     * Creates a new [KtSignature] by given symbol and leave all types intact
+     */
+    public fun <S : KtFunctionLikeSymbol> S.asSignature(): KtFunctionLikeSignature<S> =
+        withValidityAssertion { analysisSession.substitutionProvider.asSignature(this) }
+
+    /**
+     * Creates a new [KtSignature] by given symbol and leave all types intact
+     */
+    public fun <S : KtVariableLikeSymbol> S.asSignature(): KtVariableLikeSignature<S> =
+        withValidityAssertion { analysisSession.substitutionProvider.asSignature(this) }
+}

analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/symbols/KtSignature.kt

@@ -148,47 +148,3 @@ public data class KtVariableLikeSignature<out S : KtVariableLikeSymbol>(
         }
     }
 }
-
-public fun <S : KtCallableSymbol> S.toSignature(substitutor: KtSubstitutor = KtSubstitutor.Empty(token)): KtSignature<S> {
-    return when (this) {
-        is KtVariableLikeSymbol -> toSignature(substitutor)
-        is KtFunctionLikeSymbol -> toSignature(substitutor)
-        else -> error("unexpected callable symbol $this")
-    }
-}
-
-/**
- * Creates a signature with the same type as the given symbol.
- */
-public fun <S : KtVariableLikeSymbol> S.toSignature(substitutor: KtSubstitutor = KtSubstitutor.Empty(token)): KtVariableLikeSignature<S> {
-    return KtVariableLikeSignature(this, returnType, receiverType).substitute(substitutor)
-}
-
-/**
- * Creates a signature with the same type as the given symbol.
- */
-public fun <S : KtFunctionLikeSymbol> S.toSignature(substitutor: KtSubstitutor = KtSubstitutor.Empty(token)): KtFunctionLikeSignature<S> {
-    return KtFunctionLikeSignature(this, returnType, receiverType, valueParameters.map { it.toSignature() }).substitute(substitutor)
-}
-
-/**
- * Applies a substitutor to the given signature and return a new signature with substituted types.
- */
-@Suppress("UNCHECKED_CAST")
-public fun <C : KtSignature<S>, S : KtCallableSymbol> C.substitute(substitutor: KtSubstitutor): C {
-    if (substitutor is KtSubstitutor.Empty) return this
-    return when (this) {
-        is KtFunctionLikeSignature<*> -> KtFunctionLikeSignature(
-            symbol,
-            substitutor.substituteOrSelf(returnType),
-            receiverType?.let { substitutor.substituteOrSelf(it) },
-            valueParameters.map { it.substitute(substitutor) }
-        ) as C
-        is KtVariableLikeSignature<*> -> KtVariableLikeSignature(
-            symbol,
-            substitutor.substituteOrSelf(returnType),
-            receiverType?.let { substitutor.substituteOrSelf(it) },
-        ) as C
-        else -> error("impossible since KtSignature is sealed")
-    }
-}