[analysis api] rename KtSignature -> KtCallableSignature

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

@@ -504,7 +504,7 @@ internal class KtFe10CallResolver(
         }
     }
 
-    private fun createSignature(symbol: KtSymbol, resultingDescriptor: CallableDescriptor): KtSignature<*>? {
+    private fun createSignature(symbol: KtSymbol, resultingDescriptor: CallableDescriptor): KtCallableSignature<*>? {
         val returnType = if (resultingDescriptor is ValueParameterDescriptor && resultingDescriptor.isVararg) {
             val arrayType = resultingDescriptor.returnType ?: return null
             val primitiveArrayElementType = KotlinBuiltIns.getPrimitiveArrayElementType(arrayType)

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

@@ -369,7 +369,7 @@ internal class KtSymbolByFirBuilder constructor(
             }
         }
 
-        fun buildCallableSignature(firSymbol: FirCallableSymbol<*>): KtSignature<KtCallableSymbol> {
+        fun buildCallableSignature(firSymbol: FirCallableSymbol<*>): KtCallableSignature<KtCallableSymbol> {
             return when (firSymbol) {
                 is FirPropertyAccessorSymbol ->  with(analysisSession) { buildPropertyAccessorSymbol(firSymbol).asSignature() }
                 is FirFunctionSymbol<*> -> functionLikeBuilder.buildFunctionLikeSignature(firSymbol)

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

@@ -303,7 +303,7 @@ internal class KtFirCallResolver(
             dispatchReceiver: FirExpression,
             extensionReceiver: FirExpression,
             explicitReceiverKind: ExplicitReceiverKind
-        ): KtPartiallyAppliedSymbol<KtCallableSymbol, KtSignature<KtCallableSymbol>> {
+        ): KtPartiallyAppliedSymbol<KtCallableSymbol, KtCallableSignature<KtCallableSymbol>> {
             isImplicitInvoke = true
             val explicitReceiverPsi = when (psi) {
                 is KtQualifiedExpression -> (psi.selectorExpression as KtCallExpression).calleeExpression
@@ -688,7 +688,7 @@ internal class KtFirCallResolver(
     }
 
     @OptIn(SymbolInternals::class)
-    private fun FirCallableSymbol<*>.toKtSignature(): KtSignature<KtCallableSymbol> =
+    private fun FirCallableSymbol<*>.toKtSignature(): KtCallableSignature<KtCallableSymbol> =
         firSymbolBuilder.callableBuilder.buildCallableSignature(this)
 
     @OptIn(SymbolInternals::class)

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

@@ -0,0 +1,13 @@
+/*
+ * 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.fir.components
+
+import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSession
+import org.jetbrains.kotlin.analysis.api.impl.base.components.AbstractKtSignatureSubsitutorImpl
+
+internal class KtFirSignatureSubsitutor(
+    override val analysisSession: KtFirAnalysisSession
+) : AbstractKtSignatureSubsitutorImpl(), KtFirAnalysisSessionComponent

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/scopes/KtFirDelegatingTypeScope.kt

@@ -13,7 +13,7 @@ import org.jetbrains.kotlin.analysis.api.scopes.KtScopeNameFilter
 import org.jetbrains.kotlin.analysis.api.scopes.KtTypeScope
 import org.jetbrains.kotlin.analysis.api.symbols.KtClassifierSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtConstructorSymbol
-import org.jetbrains.kotlin.analysis.api.symbols.KtSignature
+import org.jetbrains.kotlin.analysis.api.symbols.KtCallableSignature
 import org.jetbrains.kotlin.fir.scopes.FirContainingNamesAwareScope
 import org.jetbrains.kotlin.name.Name
 
@@ -36,7 +36,7 @@ internal open class KtFirDelegatingTypeScope(
         firScope.getClassifierNames()
     }
 
-    override fun getCallableSignatures(nameFilter: KtScopeNameFilter): Sequence<KtSignature<*>> = withValidityAssertion {
+    override fun getCallableSignatures(nameFilter: KtScopeNameFilter): Sequence<KtCallableSignature<*>> = withValidityAssertion {
         firScope.getCallableSignatures(getPossibleCallableNames().filter(nameFilter), builder)
     }
 

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/scopes/firScopeUtils.kt

@@ -4,7 +4,7 @@ import org.jetbrains.kotlin.analysis.api.fir.KtSymbolByFirBuilder
 import org.jetbrains.kotlin.analysis.api.symbols.KtCallableSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtClassifierSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtConstructorSymbol
-import org.jetbrains.kotlin.analysis.api.symbols.KtSignature
+import org.jetbrains.kotlin.analysis.api.symbols.KtCallableSignature
 import org.jetbrains.kotlin.fir.isSubstitutionOverride
 import org.jetbrains.kotlin.fir.scopes.FirScope
 import org.jetbrains.kotlin.fir.scopes.processClassifiersByName
@@ -37,7 +37,7 @@ internal fun FirScope.getCallableSymbols(callableNames: Collection<Name>, builde
 
 internal fun FirScope.getCallableSignatures(callableNames: Collection<Name>, builder: KtSymbolByFirBuilder) = sequence {
     callableNames.forEach { name ->
-        val signatures = mutableListOf<KtSignature<*>>()
+        val signatures = mutableListOf<KtCallableSignature<*>>()
         processFunctionsByName(name) { firSymbol ->
             signatures.add(builder.functionLikeBuilder.buildFunctionLikeSignature(firSymbol))
         }

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

@@ -12,13 +12,13 @@ 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> {
+    override fun <S : KtCallableSymbol> substitute(signature: KtCallableSignature<S>, substitutor: KtSubstitutor): KtCallableSignature<S> {
         return when (signature) {
             is KtFunctionLikeSignature -> {
-                substitute(signature as KtFunctionLikeSignature<KtFunctionLikeSymbol>, substitutor) as KtSignature<S>
+                substitute(signature as KtFunctionLikeSignature<KtFunctionLikeSymbol>, substitutor) as KtCallableSignature<S>
             }
             is KtVariableLikeSignature -> {
-                substitute(signature as KtVariableLikeSignature<KtVariableLikeSymbol>, substitutor) as KtSignature<S>
+                substitute(signature as KtVariableLikeSignature<KtVariableLikeSymbol>, substitutor) as KtCallableSignature<S>
             }
         }
     }
@@ -50,7 +50,7 @@ abstract class AbstractKtSignatureSubsitutorImpl : KtSignatureSubsitutor() {
 
 
     @Suppress("UNCHECKED_CAST")
-    override fun <S : KtCallableSymbol> substitute(symbol: S, substitutor: KtSubstitutor): KtSignature<S> {
+    override fun <S : KtCallableSymbol> substitute(symbol: S, substitutor: KtSubstitutor): KtCallableSignature<S> {
         return when (symbol) {
             is KtFunctionLikeSymbol -> substitute(symbol, substitutor)
             is KtVariableLikeSymbol -> substitute(symbol, substitutor)
@@ -77,7 +77,7 @@ abstract class AbstractKtSignatureSubsitutorImpl : KtSignatureSubsitutor() {
         )
     }
 
-    override fun <S : KtCallableSymbol> asSignature(symbol: S): KtSignature<S> {
+    override fun <S : KtCallableSymbol> asSignature(symbol: S): KtCallableSignature<S> {
         return when (symbol) {
             is KtFunctionLikeSymbol -> asSignature(symbol)
             is KtVariableLikeSymbol -> asSignature(symbol)

analysis/analysis-api-impl-base/src/org/jetbrains/kotlin/analysis/api/impl/base/scopes/KtCompositeTypeScope.kt

@@ -37,7 +37,7 @@ class KtCompositeTypeScope(
     }
 
 
-    override fun getCallableSignatures(nameFilter: KtScopeNameFilter): Sequence<KtSignature<*>> = withValidityAssertion {
+    override fun getCallableSignatures(nameFilter: KtScopeNameFilter): Sequence<KtCallableSignature<*>> = withValidityAssertion {
         sequence {
             subScopes.forEach { yieldAll(it.getCallableSignatures(nameFilter)) }
         }

analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/calls/KtCall.kt

@@ -147,7 +147,7 @@ public class KtGenericTypeQualifier(
  * properties, the missing information is the type of access (read, write, or compound access) to this property. For functions, the missing
  * information is the value arguments for the call.
  */
-public class KtPartiallyAppliedSymbol<out S : KtCallableSymbol, out C : KtSignature<S>>(
+public class KtPartiallyAppliedSymbol<out S : KtCallableSymbol, out C : KtCallableSignature<S>>(
     private val _signature: C,
     private val _dispatchReceiver: KtReceiverValue?,
     private val _extensionReceiver: KtReceiverValue?,
@@ -171,7 +171,7 @@ public class KtPartiallyAppliedSymbol<out S : KtCallableSymbol, out C : KtSignat
     public val extensionReceiver: KtReceiverValue? get() = withValidityAssertion { _extensionReceiver }
 }
 
-public val <S : KtCallableSymbol, C : KtSignature<S>> KtPartiallyAppliedSymbol<S, C>.symbol: S get() = signature.symbol
+public val <S : KtCallableSymbol, C : KtCallableSignature<S>> KtPartiallyAppliedSymbol<S, C>.symbol: S get() = signature.symbol
 
 /**
  * A synthetic call to assert an expression is not null. For example
@@ -191,11 +191,11 @@ public class KtCheckNotNullCall(
 /**
  * A call to a function, or a simple/compound access to a property.
  */
-public sealed class KtCallableMemberCall<S : KtCallableSymbol, C : KtSignature<S>> : KtCall() {
+public sealed class KtCallableMemberCall<S : KtCallableSymbol, C : KtCallableSignature<S>> : KtCall() {
     public abstract val partiallyAppliedSymbol: KtPartiallyAppliedSymbol<S, C>
 }
 
-public val <S : KtCallableSymbol, C : KtSignature<S>> KtCallableMemberCall<S, C>.symbol: S get() = partiallyAppliedSymbol.symbol
+public val <S : KtCallableSymbol, C : KtCallableSignature<S>> KtCallableMemberCall<S, C>.symbol: S get() = partiallyAppliedSymbol.symbol
 
 public sealed class KtFunctionCall<S : KtFunctionLikeSymbol>(
     private val _argumentMapping: LinkedHashMap<KtExpression, KtVariableLikeSignature<KtValueParameterSymbol>>,

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

@@ -11,9 +11,9 @@ import org.jetbrains.kotlin.analysis.api.types.KtSubstitutor
 
 public abstract class KtSignatureSubsitutor : KtAnalysisSessionComponent() {
     public abstract fun <S : KtCallableSymbol> substitute(
-        signature: KtSignature<S>,
+        signature: KtCallableSignature<S>,
         substitutor: KtSubstitutor
-    ): KtSignature<S>
+    ): KtCallableSignature<S>
 
     public abstract fun <S : KtFunctionLikeSymbol> substitute(
         signature: KtFunctionLikeSignature<S>,
@@ -25,13 +25,13 @@ public abstract class KtSignatureSubsitutor : KtAnalysisSessionComponent() {
         substitutor: KtSubstitutor
     ): KtVariableLikeSignature<S>
 
-    public abstract fun <S : KtCallableSymbol> substitute(symbol: S, substitutor: KtSubstitutor): KtSignature<S>
+    public abstract fun <S : KtCallableSymbol> substitute(symbol: S, substitutor: KtSubstitutor): KtCallableSignature<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 : KtCallableSymbol> asSignature(symbol: S): KtCallableSignature<S>
 
     public abstract fun <S : KtFunctionLikeSymbol> asSignature(symbol: S): KtFunctionLikeSignature<S>
 
@@ -44,7 +44,7 @@ public interface KtSignatureSubsitutorMixIn : KtAnalysisSessionMixIn {
      *
      * @see KtSubstitutor.substituteOrSelf
      */
-    public fun <S : KtCallableSymbol> KtSignature<S>.substitute(substitutor: KtSubstitutor): KtSignature<S> =
+    public fun <S : KtCallableSymbol> KtCallableSignature<S>.substitute(substitutor: KtSubstitutor): KtCallableSignature<S> =
         withValidityAssertion { analysisSession.substitutionProvider.substitute(this, substitutor) }
 
     /**
@@ -68,7 +68,7 @@ public interface KtSignatureSubsitutorMixIn : KtAnalysisSessionMixIn {
      *
      * @see KtSubstitutor.substituteOrSelf
      */
-    public fun <S : KtCallableSymbol> S.substitute(substitutor: KtSubstitutor): KtSignature<S> =
+    public fun <S : KtCallableSymbol> S.substitute(substitutor: KtSubstitutor): KtCallableSignature<S> =
         withValidityAssertion { analysisSession.substitutionProvider.substitute(this, substitutor) }
 
     /**
@@ -88,19 +88,19 @@ public interface KtSignatureSubsitutorMixIn : KtAnalysisSessionMixIn {
         withValidityAssertion { analysisSession.substitutionProvider.substitute(this, substitutor) }
 
     /**
-     * Creates a new [KtSignature] by given symbol and leave all types intact
+     * Creates a new [KtCallableSignature] by given symbol and leave all types intact
      */
-    public fun <S : KtCallableSymbol> S.asSignature(): KtSignature<S> =
+    public fun <S : KtCallableSymbol> S.asSignature(): KtCallableSignature<S> =
         withValidityAssertion { analysisSession.substitutionProvider.asSignature(this) }
 
     /**
-     * Creates a new [KtSignature] by given symbol and leave all types intact
+     * Creates a new [KtCallableSignature] 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
+     * Creates a new [KtCallableSignature] 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/scopes/KtTypeScope.kt

@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.analysis.api.scopes
 import org.jetbrains.kotlin.analysis.api.symbols.KtCallableSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtClassifierSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtConstructorSymbol
-import org.jetbrains.kotlin.analysis.api.symbols.KtSignature
+import org.jetbrains.kotlin.analysis.api.symbols.KtCallableSignature
 
 
 public interface KtTypeScope : KtScopeLike {
@@ -16,7 +16,7 @@ public interface KtTypeScope : KtScopeLike {
     /**
      * Return a sequence of [KtCallableSymbol] which current scope contain if declaration name matches [nameFilter]
      */
-    public fun getCallableSignatures(nameFilter: KtScopeNameFilter = { true }): Sequence<KtSignature<*>>
+    public fun getCallableSignatures(nameFilter: KtScopeNameFilter = { true }): Sequence<KtCallableSignature<*>>
 
     /**
      * Return a sequence of [KtClassifierSymbol] which current scope contain if declaration name matches [nameFilter]

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

@@ -27,9 +27,9 @@ import org.jetbrains.kotlin.utils.addToStdlib.runIf
  * }
  * ```
  *
- * Equality of [KtSignature] is derived from its content.
+ * Equality of [KtCallableSignature] is derived from its content.
  */
-public sealed class KtSignature<out S : KtCallableSymbol> : KtLifetimeOwner {
+public sealed class KtCallableSignature<out S : KtCallableSymbol> : KtLifetimeOwner {
     /**
      * The original symbol for this signature.
      */
@@ -57,7 +57,7 @@ public data class KtFunctionLikeSignature<out S : KtFunctionLikeSymbol>(
     private val _returnType: KtType,
     private val _receiverType: KtType?,
     private val _valueParameters: List<KtVariableLikeSignature<KtValueParameterSymbol>>,
-) : KtSignature<S>() {
+) : KtCallableSignature<S>() {
     override val token: KtLifetimeToken
         get() = _symbol.token
     override val symbol: S
@@ -81,7 +81,7 @@ public data class KtVariableLikeSignature<out S : KtVariableLikeSymbol>(
     private val _symbol: S,
     private val _returnType: KtType,
     private val _receiverType: KtType?,
-) : KtSignature<S>() {
+) : KtCallableSignature<S>() {
     override val token: KtLifetimeToken
         get() = _symbol.token
     override val symbol: S