diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/KtFe10AnalysisSession.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/KtFe10AnalysisSession.kt index 9e81cde20d8..81326a24a09 100644 --- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/KtFe10AnalysisSession.kt +++ b/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 { diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SignatureSubsitutor.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10SignatureSubsitutor.kt new file mode 100644 index 00000000000..bbb4532dc40 --- /dev/null +++ b/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 \ No newline at end of file diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/KtFirAnalysisSession.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/KtFirAnalysisSession.kt index 10573913814..2c587d28ab6 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/KtFirAnalysisSession.kt +++ b/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 ) diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/KtSymbolByFirBuilder.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/KtSymbolByFirBuilder.kt index cb54f82510a..d11e58e1669 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/KtSymbolByFirBuilder.kt +++ b/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 { 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 { 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) diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirCallResolver.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirCallResolver.kt index 3a4d6017579..a032142beb6 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirCallResolver.kt +++ b/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 } diff --git a/analysis/analysis-api-impl-base/src/org/jetbrains/kotlin/analysis/api/impl/base/components/AbstractKtSignatureSubsitutorImpl.kt b/analysis/analysis-api-impl-base/src/org/jetbrains/kotlin/analysis/api/impl/base/components/AbstractKtSignatureSubsitutorImpl.kt new file mode 100644 index 00000000000..8184e9fa520 --- /dev/null +++ b/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 substitute(signature: KtSignature, substitutor: KtSubstitutor): KtSignature { + return when (signature) { + is KtFunctionLikeSignature -> { + substitute(signature as KtFunctionLikeSignature, substitutor) as KtSignature + } + is KtVariableLikeSignature -> { + substitute(signature as KtVariableLikeSignature, substitutor) as KtSignature + } + } + } + + override fun substitute( + signature: KtVariableLikeSignature, + substitutor: KtSubstitutor + ): KtVariableLikeSignature { + if (substitutor is KtSubstitutor.Empty) return signature + return KtVariableLikeSignature( + signature.symbol, + substitutor.substituteOrSelf(signature.returnType), + signature.receiverType?.let { substitutor.substituteOrSelf(it) }, + ) + } + + override fun substitute( + signature: KtFunctionLikeSignature, + substitutor: KtSubstitutor + ): KtFunctionLikeSignature { + 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 substitute(symbol: S, substitutor: KtSubstitutor): KtSignature { + return when (symbol) { + is KtFunctionLikeSymbol -> substitute(symbol, substitutor) + is KtVariableLikeSymbol -> substitute(symbol, substitutor) + else -> unexpectedElementError("symbol", symbol) + } + } + + override fun substitute(symbol: S, substitutor: KtSubstitutor): KtFunctionLikeSignature { + 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 substitute(symbol: S, substitutor: KtSubstitutor): KtVariableLikeSignature { + if (substitutor is KtSubstitutor.Empty) return asSignature(symbol) + return KtVariableLikeSignature( + symbol, + substitutor.substituteOrSelf(symbol.returnType), + symbol.receiverType?.let { substitutor.substituteOrSelf(it) }, + ) + } + + override fun asSignature(symbol: S): KtSignature { + return when (symbol) { + is KtFunctionLikeSymbol -> asSignature(symbol) + is KtVariableLikeSymbol -> asSignature(symbol) + else -> unexpectedElementError("symbol", symbol) + } + } + + override fun asSignature(symbol: S): KtFunctionLikeSignature { + return KtFunctionLikeSignature(symbol, symbol.returnType, symbol.receiverType, symbol.valueParameters.map { asSignature(it) }) + } + + override fun asSignature(symbol: S): KtVariableLikeSignature { + return KtVariableLikeSignature(symbol, symbol.returnType, symbol.receiverType) + } +} \ No newline at end of file diff --git a/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/KtAnalysisSession.kt b/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/KtAnalysisSession.kt index 8699b4deaca..88b9db06af1 100644 --- a/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/KtAnalysisSession.kt +++ b/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 diff --git a/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/components/KtSignatureSubsitutor.kt b/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/components/KtSignatureSubsitutor.kt new file mode 100644 index 00000000000..fe3d19534d5 --- /dev/null +++ b/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 substitute( + signature: KtSignature, + substitutor: KtSubstitutor + ): KtSignature + + public abstract fun substitute( + signature: KtFunctionLikeSignature, + substitutor: KtSubstitutor + ): KtFunctionLikeSignature + + public abstract fun substitute( + signature: KtVariableLikeSignature, + substitutor: KtSubstitutor + ): KtVariableLikeSignature + + public abstract fun substitute(symbol: S, substitutor: KtSubstitutor): KtSignature + + public abstract fun substitute(symbol: S, substitutor: KtSubstitutor): KtFunctionLikeSignature + + public abstract fun substitute(symbol: S, substitutor: KtSubstitutor): KtVariableLikeSignature + + public abstract fun asSignature(symbol: S): KtSignature + + public abstract fun asSignature(symbol: S): KtFunctionLikeSignature + + public abstract fun asSignature(symbol: S): KtVariableLikeSignature +} + +public interface KtSignatureSubsitutorMixIn : KtAnalysisSessionMixIn { + /** + * Applies a [substitutor] to the given signature and return a new signature with substituted types. + * + * @see KtSubstitutor.substituteOrSelf + */ + public fun KtSignature.substitute(substitutor: KtSubstitutor): KtSignature = + 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 KtFunctionLikeSignature.substitute(substitutor: KtSubstitutor): KtFunctionLikeSignature = + 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 KtVariableLikeSignature.substitute(substitutor: KtSubstitutor): KtVariableLikeSignature = + 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.substitute(substitutor: KtSubstitutor): KtSignature = + 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.substitute(substitutor: KtSubstitutor): KtFunctionLikeSignature = + 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.substitute(substitutor: KtSubstitutor): KtVariableLikeSignature = + withValidityAssertion { analysisSession.substitutionProvider.substitute(this, substitutor) } + + /** + * Creates a new [KtSignature] by given symbol and leave all types intact + */ + public fun S.asSignature(): KtSignature = + withValidityAssertion { analysisSession.substitutionProvider.asSignature(this) } + + /** + * Creates a new [KtSignature] by given symbol and leave all types intact + */ + public fun S.asSignature(): KtFunctionLikeSignature = + withValidityAssertion { analysisSession.substitutionProvider.asSignature(this) } + + /** + * Creates a new [KtSignature] by given symbol and leave all types intact + */ + public fun S.asSignature(): KtVariableLikeSignature = + withValidityAssertion { analysisSession.substitutionProvider.asSignature(this) } +} diff --git a/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/symbols/KtSignature.kt b/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/symbols/KtSignature.kt index 60f8813818c..c8d47d33219 100644 --- a/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/symbols/KtSignature.kt +++ b/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/symbols/KtSignature.kt @@ -148,47 +148,3 @@ public data class KtVariableLikeSignature( } } } - -public fun S.toSignature(substitutor: KtSubstitutor = KtSubstitutor.Empty(token)): KtSignature { - 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.toSignature(substitutor: KtSubstitutor = KtSubstitutor.Empty(token)): KtVariableLikeSignature { - return KtVariableLikeSignature(this, returnType, receiverType).substitute(substitutor) -} - -/** - * Creates a signature with the same type as the given symbol. - */ -public fun S.toSignature(substitutor: KtSubstitutor = KtSubstitutor.Empty(token)): KtFunctionLikeSignature { - 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 , 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") - } -} \ No newline at end of file