Analysis API: introduce KtSignature

2021-12-01 11:14:53 -08:00
parent 5802ab1342
commit e8f1af6140
2 changed files with 181 additions and 1 deletions
@@ -9,7 +9,10 @@ import com.intellij.openapi.project.Project
 import com.intellij.psi.JavaPsiFacade
 import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.util.containers.ContainerUtil
-import org.jetbrains.kotlin.analysis.api.*
+import org.jetbrains.kotlin.analysis.api.KtStarProjectionTypeArgument
+import org.jetbrains.kotlin.analysis.api.KtTypeArgument
+import org.jetbrains.kotlin.analysis.api.KtTypeArgumentWithVariance
+import org.jetbrains.kotlin.analysis.api.ValidityTokenOwner
 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
@@ -34,6 +37,7 @@ import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutorByMap
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
 import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterLookupTag
+import org.jetbrains.kotlin.fir.symbols.ensureResolved
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassifierSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
 import org.jetbrains.kotlin.fir.types.*
@@ -207,6 +211,12 @@ internal class KtSymbolByFirBuilder private constructor(
            }
        }

+        fun buildFunctionLikeSignature(fir: FirFunction): KtFunctionLikeSignature<KtFunctionLikeSymbol> {
+            if (fir is FirSimpleFunction && fir.origin != FirDeclarationOrigin.SamConstructor)
+                return buildFunctionSignature(fir)
+            return buildFunctionLikeSymbol(fir).toSignature()
+        }
+
        fun buildFunctionSymbol(fir: FirSimpleFunction): KtFirFunctionSymbol {
            fir.unwrapSubstitutionOverrideIfNeeded()?.let {
                return buildFunctionSymbol(it)
@@ -216,6 +226,23 @@ internal class KtSymbolByFirBuilder private constructor(
            return symbolsCache.cache(fir) { KtFirFunctionSymbol(fir, resolveState, token, this@KtSymbolByFirBuilder) }
        }

+        fun buildFunctionSignature(fir: FirSimpleFunction): KtFunctionLikeSignature<KtFirFunctionSymbol> {
+            fir.symbol.ensureResolved(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE)
+            val functionSymbol = buildFunctionSymbol(fir)
+            return KtFunctionLikeSignature(
+                functionSymbol,
+                typeBuilder.buildKtType(fir.returnTypeRef),
+                fir.receiverTypeRef?.let { typeBuilder.buildKtType(it) },
+                functionSymbol.valueParameters.zip(fir.valueParameters).map { (ktSymbol, fir) ->
+                    var type = fir.returnTypeRef.coneType
+                    if (fir.isVararg) {
+                        type = type.arrayElementType() ?: type
+                    }
+                    KtVariableLikeSignature(ktSymbol, typeBuilder.buildKtType(type), null)
+                }
+            )
+        }
+
        fun buildAnonymousFunctionSymbol(fir: FirAnonymousFunction): KtFirAnonymousFunctionSymbol {
            return symbolsCache.cache(fir) { KtFirAnonymousFunctionSymbol(fir, resolveState, token, this@KtSymbolByFirBuilder) }
        }
@@ -256,6 +283,11 @@ internal class KtSymbolByFirBuilder private constructor(
            }
        }

+        fun buildVariableLikeSignature(fir: FirVariable): KtVariableLikeSignature<KtVariableLikeSymbol> {
+            if (fir is FirProperty && !fir.isLocal && fir !is FirSyntheticProperty) return buildPropertySignature(fir)
+            return buildVariableLikeSymbol(fir).toSignature()
+        }
+
        fun buildVariableSymbol(fir: FirProperty): KtVariableSymbol {
            return when {
                fir.isLocal -> buildLocalVariableSymbol(fir)
@@ -277,6 +309,15 @@ internal class KtSymbolByFirBuilder private constructor(
            }
        }

+        fun buildPropertySignature(fir: FirProperty): KtVariableLikeSignature<KtVariableSymbol> {
+            fir.symbol.ensureResolved(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE)
+            return KtVariableLikeSignature(
+                buildPropertySymbol(fir),
+                typeBuilder.buildKtType(fir.returnTypeRef),
+                fir.receiverTypeRef?.let { typeBuilder.buildKtType(it) }
+            )
+        }
+
        fun buildLocalVariableSymbol(fir: FirProperty): KtFirLocalVariableSymbol {
            checkRequirementForBuildingSymbol<KtFirLocalVariableSymbol>(fir, fir.isLocal)
            return symbolsCache.cache(fir) {
@@ -331,6 +372,15 @@ internal class KtSymbolByFirBuilder private constructor(
            }
        }

+        fun buildCallableSignature(fir: FirCallableDeclaration): KtSignature<KtCallableSymbol> {
+            return when (fir) {
+                is FirPropertyAccessor -> buildPropertyAccessorSymbol(fir).toSignature()
+                is FirFunction -> functionLikeBuilder.buildFunctionLikeSignature(fir)
+                is FirVariable -> variableLikeBuilder.buildVariableLikeSignature(fir)
+                else -> throwUnexpectedElementError(fir)
+            }
+        }
+

        fun buildPropertyAccessorSymbol(fir: FirPropertyAccessor): KtPropertyAccessorSymbol {
            return when {