[Analysis API] optimize RAM consumption in KtLifetimeOwner's

- remove `token` field ^KTIJ-22749
2023-02-03 13:04:35 +01:00
parent e0c23dae47
commit a9b4f77196
45 changed files with 110 additions and 109 deletions
@@ -9,7 +9,9 @@ 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.KtStarTypeProjection
+import org.jetbrains.kotlin.analysis.api.KtTypeArgumentWithVariance
+import org.jetbrains.kotlin.analysis.api.KtTypeProjection
 import org.jetbrains.kotlin.analysis.api.fir.symbols.*
 import org.jetbrains.kotlin.analysis.api.fir.types.*
 import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken
@@ -26,13 +28,16 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.util.withFirEntry
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.withFirSymbolEntry
 import org.jetbrains.kotlin.analysis.providers.createPackageProvider
 import org.jetbrains.kotlin.analysis.utils.errors.buildErrorWithAttachment
-import org.jetbrains.kotlin.fir.*
+import org.jetbrains.kotlin.fir.FirElement
+import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.impl.FirFieldImpl
 import org.jetbrains.kotlin.fir.declarations.impl.FirOuterClassTypeParameterRef
 import org.jetbrains.kotlin.fir.diagnostics.ConeCannotInferParameterType
 import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic
 import org.jetbrains.kotlin.fir.java.declarations.FirJavaField
+import org.jetbrains.kotlin.fir.originalForSubstitutionOverride
+import org.jetbrains.kotlin.fir.originalIfFakeOverride
 import org.jetbrains.kotlin.fir.renderer.FirRenderer
 import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeUnmatchedTypeArgumentsError
 import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeUnresolvedError
@@ -98,7 +103,7 @@ internal class KtSymbolByFirBuilder constructor(
    }

    fun buildEnumEntrySymbol(firSymbol: FirEnumEntrySymbol) =
-        symbolsCache.cache(firSymbol) { KtFirEnumEntrySymbol(firSymbol, firResolveSession, token, this) }
+        symbolsCache.cache(firSymbol) { KtFirEnumEntrySymbol(firSymbol, firResolveSession, this) }

    fun buildFileSymbol(firSymbol: FirFileSymbol) = filesCache.cache(firSymbol) { KtFirFileSymbol(firSymbol, firResolveSession, token) }

@@ -145,15 +150,15 @@ internal class KtSymbolByFirBuilder constructor(
        }

        fun buildNamedClassOrObjectSymbol(symbol: FirRegularClassSymbol): KtFirNamedClassOrObjectSymbol {
-            return symbolsCache.cache(symbol) { KtFirNamedClassOrObjectSymbol(symbol, firResolveSession, token, this@KtSymbolByFirBuilder) }
+            return symbolsCache.cache(symbol) { KtFirNamedClassOrObjectSymbol(symbol, firResolveSession, this@KtSymbolByFirBuilder) }
        }

        fun buildAnonymousObjectSymbol(symbol: FirAnonymousObjectSymbol): KtAnonymousObjectSymbol {
-            return symbolsCache.cache(symbol) { KtFirAnonymousObjectSymbol(symbol, firResolveSession, token, this@KtSymbolByFirBuilder) }
+            return symbolsCache.cache(symbol) { KtFirAnonymousObjectSymbol(symbol, firResolveSession, this@KtSymbolByFirBuilder) }
        }

        fun buildTypeAliasSymbol(symbol: FirTypeAliasSymbol): KtFirTypeAliasSymbol {
-            return symbolsCache.cache(symbol) { KtFirTypeAliasSymbol(symbol, firResolveSession, token, this@KtSymbolByFirBuilder) }
+            return symbolsCache.cache(symbol) { KtFirTypeAliasSymbol(symbol, firResolveSession, this@KtSymbolByFirBuilder) }
        }

        fun buildTypeParameterSymbol(firSymbol: FirTypeParameterSymbol): KtFirTypeParameterSymbol {
@@ -161,7 +166,6 @@ internal class KtSymbolByFirBuilder constructor(
                KtFirTypeParameterSymbol(
                    firSymbol,
                    firResolveSession,
-                    token,
                    this@KtSymbolByFirBuilder
                )
            }
@@ -218,7 +222,7 @@ internal class KtSymbolByFirBuilder constructor(
            }

            check(firSymbol.origin != FirDeclarationOrigin.SamConstructor)
-            return symbolsCache.cache(firSymbol) { KtFirFunctionSymbol(firSymbol, firResolveSession, token, this@KtSymbolByFirBuilder) }
+            return symbolsCache.cache(firSymbol) { KtFirFunctionSymbol(firSymbol, firResolveSession, this@KtSymbolByFirBuilder) }
        }

        fun buildFunctionSignature(firSymbol: FirNamedFunctionSymbol): KtFunctionLikeSignature<KtFirFunctionSymbol> {
@@ -243,7 +247,6 @@ internal class KtSymbolByFirBuilder constructor(
                KtFirAnonymousFunctionSymbol(
                    firSymbol,
                    firResolveSession,
-                    token,
                    this@KtSymbolByFirBuilder
                )
            }
@@ -253,7 +256,7 @@ internal class KtSymbolByFirBuilder constructor(
            val originalFirSymbol = firSymbol.fir.originalConstructorIfTypeAlias?.symbol ?: firSymbol
            val unwrapped = originalFirSymbol.originalIfFakeOverride() ?: originalFirSymbol
            return symbolsCache.cache(unwrapped) {
-                KtFirConstructorSymbol(unwrapped, firResolveSession, token, this@KtSymbolByFirBuilder)
+                KtFirConstructorSymbol(unwrapped, firResolveSession, this@KtSymbolByFirBuilder)
            }
        }

@@ -263,7 +266,6 @@ internal class KtSymbolByFirBuilder constructor(
                KtFirSamConstructorSymbol(
                    firSymbol,
                    firResolveSession,
-                    token,
                    this@KtSymbolByFirBuilder
                )
            }
@@ -272,9 +274,9 @@ internal class KtSymbolByFirBuilder constructor(
        fun buildPropertyAccessorSymbol(firSymbol: FirPropertyAccessorSymbol): KtFunctionLikeSymbol {
            return symbolsCache.cache(firSymbol) {
                if (firSymbol.isGetter) {
-                    KtFirPropertyGetterSymbol(firSymbol, firResolveSession, token, this@KtSymbolByFirBuilder)
+                    KtFirPropertyGetterSymbol(firSymbol, firResolveSession, this@KtSymbolByFirBuilder)
                } else {
-                    KtFirPropertySetterSymbol(firSymbol, firResolveSession, token, this@KtSymbolByFirBuilder)
+                    KtFirPropertySetterSymbol(firSymbol, firResolveSession, this@KtSymbolByFirBuilder)
                }
            }
        }
@@ -319,7 +321,7 @@ internal class KtSymbolByFirBuilder constructor(
            }

            return symbolsCache.cache(firSymbol) {
-                KtFirKotlinPropertySymbol(firSymbol, firResolveSession, token, this@KtSymbolByFirBuilder)
+                KtFirKotlinPropertySymbol(firSymbol, firResolveSession, this@KtSymbolByFirBuilder)
            }
        }

@@ -335,31 +337,31 @@ internal class KtSymbolByFirBuilder constructor(
        fun buildLocalVariableSymbol(firSymbol: FirPropertySymbol): KtFirLocalVariableSymbol {
            checkRequirementForBuildingSymbol<KtFirLocalVariableSymbol>(firSymbol, firSymbol.isLocal)
            return symbolsCache.cache(firSymbol) {
-                KtFirLocalVariableSymbol(firSymbol, firResolveSession, token, this@KtSymbolByFirBuilder)
+                KtFirLocalVariableSymbol(firSymbol, firResolveSession, this@KtSymbolByFirBuilder)
            }
        }

        fun buildSyntheticJavaPropertySymbol(firSymbol: FirSyntheticPropertySymbol): KtFirSyntheticJavaPropertySymbol {
            return symbolsCache.cache(firSymbol) {
-                KtFirSyntheticJavaPropertySymbol(firSymbol, firResolveSession, token, this@KtSymbolByFirBuilder)
+                KtFirSyntheticJavaPropertySymbol(firSymbol, firResolveSession, this@KtSymbolByFirBuilder)
            }
        }

        fun buildValueParameterSymbol(firSymbol: FirValueParameterSymbol): KtValueParameterSymbol {
            return symbolsCache.cache(firSymbol) {
-                KtFirValueParameterSymbol(firSymbol, firResolveSession, token, this@KtSymbolByFirBuilder)
+                KtFirValueParameterSymbol(firSymbol, firResolveSession, this@KtSymbolByFirBuilder)
            }
        }


        fun buildFieldSymbol(firSymbol: FirFieldSymbol): KtFirJavaFieldSymbol {
            checkRequirementForBuildingSymbol<KtFirJavaFieldSymbol>(firSymbol, firSymbol.fir.isJavaFieldOrSubstitutionOverrideOfJavaField())
-            return symbolsCache.cache(firSymbol) { KtFirJavaFieldSymbol(firSymbol, firResolveSession, token, this@KtSymbolByFirBuilder) }
+            return symbolsCache.cache(firSymbol) { KtFirJavaFieldSymbol(firSymbol, firResolveSession, this@KtSymbolByFirBuilder) }
        }

        fun buildBackingFieldSymbol(firSymbol: FirBackingFieldSymbol): KtFirBackingFieldSymbol {
            return backingFieldCache.cache(firSymbol) {
-                KtFirBackingFieldSymbol(firSymbol, firResolveSession, token, this@KtSymbolByFirBuilder)
+                KtFirBackingFieldSymbol(firSymbol, firResolveSession, this@KtSymbolByFirBuilder)
            }
        }

@@ -409,7 +411,6 @@ internal class KtSymbolByFirBuilder constructor(
                KtFirPropertyGetterSymbol(
                    firSymbol,
                    firResolveSession,
-                    token,
                    this@KtSymbolByFirBuilder
                )
            }
@@ -421,7 +422,6 @@ internal class KtSymbolByFirBuilder constructor(
                KtFirPropertySetterSymbol(
                    firSymbol,
                    firResolveSession,
-                    token,
                    this@KtSymbolByFirBuilder
                )
            }
@@ -430,7 +430,7 @@ internal class KtSymbolByFirBuilder constructor(
        fun buildExtensionReceiverSymbol(firCallableSymbol: FirCallableSymbol<*>): KtReceiverParameterSymbol? {
            if (firCallableSymbol.fir.receiverParameter == null) return null
            return extensionReceiverSymbolsCache.cache(firCallableSymbol) {
-                KtFirReceiverParameterSymbol(firCallableSymbol, firResolveSession, token, this@KtSymbolByFirBuilder)
+                KtFirReceiverParameterSymbol(firCallableSymbol, firResolveSession, this@KtSymbolByFirBuilder)
            }
        }
    }
@@ -447,24 +447,24 @@ internal class KtSymbolByFirBuilder constructor(
                is ConeClassLikeTypeImpl -> {
                    when {
                        coneType.lookupTag.toSymbol(rootSession) == null -> {
-                            KtFirClassErrorType(coneType, ConeUnresolvedSymbolError(coneType.lookupTag.classId), token, this@KtSymbolByFirBuilder)
+                            KtFirClassErrorType(coneType, ConeUnresolvedSymbolError(coneType.lookupTag.classId), this@KtSymbolByFirBuilder)
                        }
-                        hasFunctionalClassId(coneType) -> KtFirFunctionalType(coneType, token, this@KtSymbolByFirBuilder)
-                        else -> KtFirUsualClassType(coneType, token, this@KtSymbolByFirBuilder)
+                        hasFunctionalClassId(coneType) -> KtFirFunctionalType(coneType, this@KtSymbolByFirBuilder)
+                        else -> KtFirUsualClassType(coneType, this@KtSymbolByFirBuilder)
                    }
                }
-                is ConeTypeParameterType -> KtFirTypeParameterType(coneType, token, this@KtSymbolByFirBuilder)
+                is ConeTypeParameterType -> KtFirTypeParameterType(coneType, this@KtSymbolByFirBuilder)
                is ConeErrorType -> when (val diagnostic = coneType.diagnostic) {
                    is ConeUnresolvedError, is ConeUnmatchedTypeArgumentsError ->
-                        KtFirClassErrorType(coneType, diagnostic, token, this@KtSymbolByFirBuilder)
-                    else -> KtFirTypeErrorType(coneType, token, this@KtSymbolByFirBuilder)
+                        KtFirClassErrorType(coneType, diagnostic, this@KtSymbolByFirBuilder)
+                    else -> KtFirTypeErrorType(coneType, this@KtSymbolByFirBuilder)
                }
-                is ConeDynamicType -> KtFirDynamicType(coneType, token, this@KtSymbolByFirBuilder)
-                is ConeFlexibleType -> KtFirFlexibleType(coneType, token, this@KtSymbolByFirBuilder)
-                is ConeIntersectionType -> KtFirIntersectionType(coneType, token, this@KtSymbolByFirBuilder)
-                is ConeDefinitelyNotNullType -> KtFirDefinitelyNotNullType(coneType, token, this@KtSymbolByFirBuilder)
-                is ConeCapturedType -> KtFirCapturedType(coneType, token, this@KtSymbolByFirBuilder)
-                is ConeIntegerLiteralConstantType -> KtFirIntegerLiteralType(coneType, token, this@KtSymbolByFirBuilder)
+                is ConeDynamicType -> KtFirDynamicType(coneType, this@KtSymbolByFirBuilder)
+                is ConeFlexibleType -> KtFirFlexibleType(coneType, this@KtSymbolByFirBuilder)
+                is ConeIntersectionType -> KtFirIntersectionType(coneType, this@KtSymbolByFirBuilder)
+                is ConeDefinitelyNotNullType -> KtFirDefinitelyNotNullType(coneType, this@KtSymbolByFirBuilder)
+                is ConeCapturedType -> KtFirCapturedType(coneType, this@KtSymbolByFirBuilder)
+                is ConeIntegerLiteralConstantType -> KtFirIntegerLiteralType(coneType, this@KtSymbolByFirBuilder)
                is ConeIntegerConstantOperatorType -> buildKtType(coneType.getApproximatedType())
                is ConeStubTypeForChainInference -> {
                    // TODO this is a temporary hack to prevent FIR IDE from crashing on builder inference, see KT-50916
@@ -472,7 +472,7 @@ internal class KtSymbolByFirBuilder constructor(
                    val typeParameterSymbol = typeVariable?.typeParameterSymbol ?: throwUnexpectedElementError(coneType)
                    val coneTypeParameterType = typeParameterSymbol.toConeType() as ConeTypeParameterType

-                    KtFirTypeParameterType(coneTypeParameterType, token, this@KtSymbolByFirBuilder)
+                    KtFirTypeParameterType(coneTypeParameterType, this@KtSymbolByFirBuilder)
                }

                is ConeTypeVariableType -> {
@@ -513,8 +513,8 @@ internal class KtSymbolByFirBuilder constructor(
        fun buildSubstitutor(substitutor: ConeSubstitutor): KtSubstitutor {
            if (substitutor == ConeSubstitutor.Empty) return KtSubstitutor.Empty(token)
            return when (substitutor) {
-                is ConeSubstitutorByMap -> KtFirMapBackedSubstitutor(substitutor, this@KtSymbolByFirBuilder, token)
-                else -> KtFirGenericSubstitutor(substitutor, this@KtSymbolByFirBuilder, token)
+                is ConeSubstitutorByMap -> KtFirMapBackedSubstitutor(substitutor, this@KtSymbolByFirBuilder)
+                else -> KtFirGenericSubstitutor(substitutor, this@KtSymbolByFirBuilder)
            }
        }
    }
@@ -8,8 +8,8 @@ package org.jetbrains.kotlin.analysis.api.fir.components
 import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.analysis.api.KtStarTypeProjection
-import org.jetbrains.kotlin.analysis.api.KtTypeProjection
 import org.jetbrains.kotlin.analysis.api.KtTypeArgumentWithVariance
+import org.jetbrains.kotlin.analysis.api.KtTypeProjection
 import org.jetbrains.kotlin.analysis.api.diagnostics.KtDiagnosticWithPsi
 import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSession
 import org.jetbrains.kotlin.analysis.api.fir.diagnostics.KT_DIAGNOSTIC_CONVERTER
@@ -108,8 +108,8 @@ internal interface KtFirAnalysisSessionComponent {
    fun ConeSubstitutor.toKtSubstitutor(): KtSubstitutor {
        return when (this) {
            ConeSubstitutor.Empty -> KtSubstitutor.Empty(analysisSession.token)
-            is ConeSubstitutorByMap -> KtFirMapBackedSubstitutor(this, analysisSession.firSymbolBuilder, analysisSession.token)
-            else -> KtFirGenericSubstitutor(this, analysisSession.firSymbolBuilder, analysisSession.token)
+            is ConeSubstitutorByMap -> KtFirMapBackedSubstitutor(this, analysisSession.firSymbolBuilder)
+            else -> KtFirGenericSubstitutor(this, analysisSession.firSymbolBuilder)
        }
    }
 }
@@ -43,6 +43,6 @@ internal class KtFirBuiltInTypes(
    override val NULLABLE_NOTHING: KtType by cachedBuiltin(builtinTypes.nullableNothingType)

    private fun cachedBuiltin(builtinTypeRef: FirImplicitBuiltinTypeRef): ValidityAwareCachedValue<KtFirUsualClassType> = cached {
-        KtFirUsualClassType(builtinTypeRef.type as ConeClassLikeTypeImpl, token, builder)
+        KtFirUsualClassType(builtinTypeRef.type as ConeClassLikeTypeImpl, builder)
    }
 }
@@ -89,7 +89,7 @@ internal class KtFirScopeProvider(
                )
            }?.applyIf(classSymbol is KtEnumEntrySymbol, ::EnumEntryContainingNamesAwareScope)
                ?: return@getOrPut getEmptyScope()
-            KtFirDelegatingScope(firScope, builder, token)
+            KtFirDelegatingScope(firScope, builder)
        }
    }

@@ -102,7 +102,7 @@ internal class KtFirScopeProvider(
                scopeSession,
            )
        } ?: return getEmptyScope()
-        return KtFirDelegatingScope(firScope, builder, token)
+        return KtFirDelegatingScope(firScope, builder)
    }

    override fun getDeclaredMemberScope(classSymbol: KtSymbolWithMembers): KtScope {
@@ -111,7 +111,7 @@ internal class KtFirScopeProvider(
                analysisSession.useSiteSession.declaredMemberScope(it)
            } ?: return@getOrPut getEmptyScope()

-            KtFirDelegatingScope(firScope, builder, token)
+            KtFirDelegatingScope(firScope, builder)
        }
    }

@@ -134,14 +134,14 @@ internal class KtFirScopeProvider(
                } else null
            } ?: return@getOrPut getEmptyScope()

-            KtFirDelegatedMemberScope(firScope, token, builder)
+            KtFirDelegatedMemberScope(firScope, builder)
        }
    }

    override fun getFileScope(fileSymbol: KtFileSymbol): KtScope {
        return fileScopeCache.getOrPut(fileSymbol) {
            check(fileSymbol is KtFirFileSymbol) { "KtFirScopeProvider can only work with KtFirFileSymbol, but ${fileSymbol::class} was provided" }
-            KtFirFileScope(fileSymbol, token, builder)
+            KtFirFileScope(fileSymbol, builder)
        }
    }

@@ -208,10 +208,10 @@ internal class KtFirScopeProvider(

    private fun convertToKtScope(firScope: FirScope): KtScope {
        return when (firScope) {
-            is FirAbstractSimpleImportingScope -> KtFirNonStarImportingScope(firScope, builder, token)
-            is FirAbstractStarImportingScope -> KtFirStarImportingScope(firScope, builder, analysisSession.useSiteScopeDeclarationProvider, token)
+            is FirAbstractSimpleImportingScope -> KtFirNonStarImportingScope(firScope, builder)
+            is FirAbstractStarImportingScope -> KtFirStarImportingScope(firScope, builder, analysisSession.useSiteScopeDeclarationProvider)
            is FirPackageMemberScope -> createPackageScope(firScope.fqName)
-            is FirContainingNamesAwareScope -> KtFirDelegatingScope(firScope, builder, token)
+            is FirContainingNamesAwareScope -> KtFirDelegatingScope(firScope, builder)
            else -> TODO(firScope::class.toString())
        }
    }
@@ -221,7 +221,6 @@ internal class KtFirScopeProvider(
            fqName,
            project,
            builder,
-            token,
            analysisSession.useSiteAnalysisScope,
            analysisSession.useSiteScopeDeclarationProvider,
            analysisSession.targetPlatform
@@ -230,7 +229,7 @@ internal class KtFirScopeProvider(

    private fun convertToKtTypeScope(firScope: FirScope): KtTypeScope {
        return when (firScope) {
-            is FirContainingNamesAwareScope -> KtFirDelegatingTypeScope(firScope, builder, token)
+            is FirContainingNamesAwareScope -> KtFirDelegatingTypeScope(firScope, builder)
            else -> TODO(firScope::class.toString())
        }
    }
@@ -23,7 +23,7 @@ internal class KtFirScopeSubstitution(
    @OptIn(KtAnalysisApiInternals::class)
    override fun getDeclarationScope(scope: KtTypeScope): KtScope {
        return when (scope) {
-            is KtFirDelegatingTypeScope -> KtFirDelegatingScope(scope.firScope, analysisSession.firSymbolBuilder, token)
+            is KtFirDelegatingTypeScope -> KtFirDelegatingScope(scope.firScope, analysisSession.firSymbolBuilder)
            is KtCompositeTypeScope -> KtCompositeScope(scope.subScopes.map(::getDeclarationScope), token)
            else -> unexpectedElementError<KtTypeScope>(scope)
        }
@@ -30,6 +30,6 @@ internal class KtFirSubstitutorFactory(
        }

        val coneSubstitutor = ConeSubstitutorByMap(firSubstitution, analysisSession.useSiteSession)
-        return KtFirMapBackedSubstitutor(coneSubstitutor, analysisSession.firSymbolBuilder, token)
+        return KtFirMapBackedSubstitutor(coneSubstitutor, analysisSession.firSymbolBuilder)
    }
 }
@@ -6,18 +6,16 @@
 package org.jetbrains.kotlin.analysis.api.fir.scopes

 import org.jetbrains.kotlin.analysis.api.fir.KtSymbolByFirBuilder
+import org.jetbrains.kotlin.analysis.api.lifetime.withValidityAssertion
 import org.jetbrains.kotlin.analysis.api.scopes.KtScopeNameFilter
 import org.jetbrains.kotlin.analysis.api.symbols.KtCallableSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbolOrigin
-import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken
-import org.jetbrains.kotlin.analysis.api.lifetime.withValidityAssertion
 import org.jetbrains.kotlin.fir.scopes.FirContainingNamesAwareScope

 internal class KtFirDelegatedMemberScope(
    firScope: FirContainingNamesAwareScope,
-    token: KtLifetimeToken,
    builder: KtSymbolByFirBuilder
-) : KtFirDelegatingScope(firScope, builder, token) {
+) : KtFirDelegatingScope(firScope, builder) {

    override fun getCallableSymbols(nameFilter: KtScopeNameFilter): Sequence<KtCallableSymbol> = withValidityAssertion {
        return super.getCallableSymbols(nameFilter).filter { it.origin == KtSymbolOrigin.DELEGATED }
@@ -21,8 +21,9 @@ import org.jetbrains.kotlin.name.Name
 internal open class KtFirDelegatingScope(
    val firScope: FirContainingNamesAwareScope,
    private val builder: KtSymbolByFirBuilder,
-    final override val token: KtLifetimeToken
 ) : KtScope {
+    override val token: KtLifetimeToken get() = builder.token
+
    private val allNamesCached by cached {
        getPossibleCallableNames() + getPossibleClassifierNames()
    }
@@ -20,8 +20,9 @@ import org.jetbrains.kotlin.name.Name
 internal open class KtFirDelegatingTypeScope(
    val firScope: FirContainingNamesAwareScope,
    private val builder: KtSymbolByFirBuilder,
-    final override val token: KtLifetimeToken
 ) : KtTypeScope {
+    override val token: KtLifetimeToken get() = builder.token
+
    private val allNamesCached by cached {
        getPossibleCallableNames() + getPossibleClassifierNames()
    }
@@ -8,14 +8,14 @@ package org.jetbrains.kotlin.analysis.api.fir.scopes
 import org.jetbrains.kotlin.analysis.api.fir.KtSymbolByFirBuilder
 import org.jetbrains.kotlin.analysis.api.fir.symbols.KtFirFileSymbol
 import org.jetbrains.kotlin.analysis.api.fir.utils.cached
+import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken
+import org.jetbrains.kotlin.analysis.api.lifetime.withValidityAssertion
 import org.jetbrains.kotlin.analysis.api.scopes.KtScope
 import org.jetbrains.kotlin.analysis.api.scopes.KtScopeNameFilter
 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.KtPackageSymbol
-import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken
-import org.jetbrains.kotlin.analysis.api.lifetime.withValidityAssertion
 import org.jetbrains.kotlin.fir.declarations.FirProperty
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
@@ -24,9 +24,9 @@ import org.jetbrains.kotlin.name.Name

 internal class KtFirFileScope(
    private val owner: KtFirFileSymbol,
-    override val token: KtLifetimeToken,
    private val builder: KtSymbolByFirBuilder
 ) : KtScope {
+    override val token: KtLifetimeToken get() = builder.token

    private val allNamesCached by cached {
        _callableNames + _classifierNames
@@ -7,14 +7,14 @@ package org.jetbrains.kotlin.analysis.api.fir.scopes

 import org.jetbrains.kotlin.analysis.api.fir.KtSymbolByFirBuilder
 import org.jetbrains.kotlin.analysis.api.fir.utils.cached
+import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken
+import org.jetbrains.kotlin.analysis.api.lifetime.withValidityAssertion
 import org.jetbrains.kotlin.analysis.api.scopes.KtScope
 import org.jetbrains.kotlin.analysis.api.scopes.KtScopeNameFilter
 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.KtPackageSymbol
-import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken
-import org.jetbrains.kotlin.analysis.api.lifetime.withValidityAssertion
 import org.jetbrains.kotlin.fir.resolve.providers.symbolProvider
 import org.jetbrains.kotlin.fir.scopes.impl.FirAbstractSimpleImportingScope
 import org.jetbrains.kotlin.name.ClassId
@@ -23,8 +23,9 @@ import org.jetbrains.kotlin.name.Name
 internal class KtFirNonStarImportingScope(
    private val firScope: FirAbstractSimpleImportingScope,
    private val builder: KtSymbolByFirBuilder,
-    override val token: KtLifetimeToken,
 ) : KtScope {
+    override val token: KtLifetimeToken get() = builder.token
+
    private val imports: List<NonStarImport> by cached {
        buildList {
            firScope.simpleImports.values.forEach { imports ->
@@ -9,14 +9,14 @@ import com.intellij.openapi.project.Project
 import com.intellij.psi.JavaPsiFacade
 import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.analysis.api.fir.KtSymbolByFirBuilder
+import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken
+import org.jetbrains.kotlin.analysis.api.lifetime.withValidityAssertion
 import org.jetbrains.kotlin.analysis.api.scopes.KtScope
 import org.jetbrains.kotlin.analysis.api.scopes.KtScopeNameFilter
 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.KtPackageSymbol
-import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken
-import org.jetbrains.kotlin.analysis.api.lifetime.withValidityAssertion
 import org.jetbrains.kotlin.analysis.providers.KotlinDeclarationProvider
 import org.jetbrains.kotlin.analysis.providers.createPackageProvider
 import org.jetbrains.kotlin.fir.extensions.FirExtensionService
@@ -32,11 +32,12 @@ internal class KtFirPackageScope(
    private val fqName: FqName,
    private val project: Project,
    private val builder: KtSymbolByFirBuilder,
-    override val token: KtLifetimeToken,
    private val searchScope: GlobalSearchScope,
    private val declarationProvider: KotlinDeclarationProvider,
    private val targetPlatform: TargetPlatform,
 ) : KtScope {
+    override val token: KtLifetimeToken get() = builder.token
+
    private val packageProvider = project.createPackageProvider(searchScope)

    private val firScope: FirPackageMemberScope by lazy(LazyThreadSafetyMode.PUBLICATION) {
@@ -23,8 +23,8 @@ internal class KtFirStarImportingScope(
    private val firScope: FirAbstractStarImportingScope,
    private val builder: KtSymbolByFirBuilder,
    private val declarationProvider: KotlinDeclarationProvider,
-    override val token: KtLifetimeToken,
 ) : KtScope {
+    override val token: KtLifetimeToken get() = builder.token

    private val imports: List<StarImport> by cached {
        firScope.starImports.map { import ->
@@ -30,9 +30,9 @@ import org.jetbrains.kotlin.fir.symbols.impl.isExtension
 internal class KtFirAnonymousFunctionSymbol(
    override val firSymbol: FirAnonymousFunctionSymbol,
    override val firResolveSession: LLFirResolveSession,
-    override val token: KtLifetimeToken,
    private val builder: KtSymbolByFirBuilder,
 ) : KtAnonymousFunctionSymbol(), KtFirSymbol<FirAnonymousFunctionSymbol> {
+    override val token: KtLifetimeToken get() = builder.token

    override val psi: PsiElement? by cached { firSymbol.fir.findPsi(firSymbol.fir.moduleData.session) }

@@ -27,9 +27,9 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousObjectSymbol
 internal class KtFirAnonymousObjectSymbol(
    override val firSymbol: FirAnonymousObjectSymbol,
    override val firResolveSession: LLFirResolveSession,
-    override val token: KtLifetimeToken,
    private val builder: KtSymbolByFirBuilder,
 ) : KtAnonymousObjectSymbol(), KtFirSymbol<FirAnonymousObjectSymbol> {
+    override val token: KtLifetimeToken get() = builder.token
    override val psi: PsiElement? by cached { firSymbol.findPsi() }

    override val annotationsList by cached {
@@ -23,9 +23,9 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirBackingFieldSymbol
 internal class KtFirBackingFieldSymbol(
    override val firSymbol: FirBackingFieldSymbol,
    override val firResolveSession: LLFirResolveSession,
-    override val token: KtLifetimeToken,
    private val builder: KtSymbolByFirBuilder
 ) : KtBackingFieldSymbol(), KtFirSymbol<FirBackingFieldSymbol> {
+    override val token: KtLifetimeToken get() = builder.token
    override val origin: KtSymbolOrigin get() = withValidityAssertion { super<KtBackingFieldSymbol>.origin }

    override val annotationsList: KtAnnotationsList
@@ -34,9 +34,9 @@ import org.jetbrains.kotlin.name.ClassId
 internal class KtFirConstructorSymbol(
    override val firSymbol: FirConstructorSymbol,
    override val firResolveSession: LLFirResolveSession,
-    override val token: KtLifetimeToken,
    private val builder: KtSymbolByFirBuilder
 ) : KtConstructorSymbol(), KtFirSymbol<FirConstructorSymbol> {
+    override val token: KtLifetimeToken get() = builder.token
    override val psi: PsiElement? by cached { firSymbol.findPsi() }

    override val returnType: KtType get() = withValidityAssertion { firSymbol.returnType(builder) }
@@ -29,9 +29,9 @@ import org.jetbrains.kotlin.name.Name
 internal class KtFirEnumEntrySymbol(
    override val firSymbol: FirEnumEntrySymbol,
    override val firResolveSession: LLFirResolveSession,
-    override val token: KtLifetimeToken,
    private val builder: KtSymbolByFirBuilder
 ) : KtEnumEntrySymbol(), KtFirSymbol<FirEnumEntrySymbol> {
+    override val token: KtLifetimeToken get() = builder.token
    override val psi: PsiElement? by cached { firSymbol.findPsi() }

    override val annotationsList: KtAnnotationsList
@@ -45,9 +45,9 @@ import org.jetbrains.kotlin.name.Name
 internal class KtFirFunctionSymbol(
    override val firSymbol: FirNamedFunctionSymbol,
    override val firResolveSession: LLFirResolveSession,
-    override val token: KtLifetimeToken,
    private val builder: KtSymbolByFirBuilder
 ) : KtFunctionSymbol(), KtFirSymbol<FirNamedFunctionSymbol> {
+    override val token: KtLifetimeToken get() = builder.token
    override val psi: PsiElement? by cached { firSymbol.findPsi() }
    override val name: Name get() = withValidityAssertion { firSymbol.name }

@@ -32,9 +32,9 @@ import org.jetbrains.kotlin.name.Name
 internal class KtFirJavaFieldSymbol(
    override val firSymbol: FirFieldSymbol,
    override val firResolveSession: LLFirResolveSession,
-    override val token: KtLifetimeToken,
    private val builder: KtSymbolByFirBuilder
 ) : KtJavaFieldSymbol(), KtFirSymbol<FirFieldSymbol> {
+    override val token: KtLifetimeToken get() = builder.token
    override val psi: PsiElement? by cached { firSymbol.findPsi() }

    override val annotationsList: KtAnnotationsList
@@ -40,9 +40,9 @@ import org.jetbrains.kotlin.name.Name
 internal class KtFirKotlinPropertySymbol(
    override val firSymbol: FirPropertySymbol,
    override val firResolveSession: LLFirResolveSession,
-    override val token: KtLifetimeToken,
    private val builder: KtSymbolByFirBuilder
 ) : KtKotlinPropertySymbol(), KtFirSymbol<FirPropertySymbol> {
+    override val token: KtLifetimeToken get() = builder.token
    init {
        assert(!firSymbol.isLocal)
        check(firSymbol !is FirSyntheticPropertySymbol)
@@ -27,7 +27,6 @@ import org.jetbrains.kotlin.name.Name
 internal class KtFirLocalVariableSymbol(
    override val firSymbol: FirPropertySymbol,
    override val firResolveSession: LLFirResolveSession,
-    override val token: KtLifetimeToken,
    private val builder: KtSymbolByFirBuilder
 ) : KtLocalVariableSymbol(),
    KtFirSymbol<FirPropertySymbol> {
@@ -35,6 +34,7 @@ internal class KtFirLocalVariableSymbol(
        assert(firSymbol.isLocal)
    }

+    override val token: KtLifetimeToken get() = builder.token
    override val psi: PsiElement? by cached { firSymbol.findPsi() }

    override val annotationsList: KtAnnotationsList
@@ -38,9 +38,9 @@ import org.jetbrains.kotlin.name.Name
 internal class KtFirNamedClassOrObjectSymbol(
    override val firSymbol: FirRegularClassSymbol,
    override val firResolveSession: LLFirResolveSession,
-    override val token: KtLifetimeToken,
    private val builder: KtSymbolByFirBuilder
 ) : KtNamedClassOrObjectSymbol(), KtFirSymbol<FirRegularClassSymbol> {
+    override val token: KtLifetimeToken get() = builder.token
    override val psi: PsiElement? by cached { firSymbol.findPsi() }

    override val name: Name get() = withValidityAssertion { firSymbol.name }
@@ -9,9 +9,9 @@ import org.jetbrains.kotlin.analysis.api.components.KtOverrideInfoProvider
 import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSession
 import org.jetbrains.kotlin.analysis.api.fir.buildSymbol
 import org.jetbrains.kotlin.analysis.api.fir.components.KtFirAnalysisSessionComponent
+import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken
 import org.jetbrains.kotlin.analysis.api.symbols.KtCallableSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtClassOrObjectSymbol
-import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken
 import org.jetbrains.kotlin.fir.analysis.checkers.getImplementationStatus
 import org.jetbrains.kotlin.fir.analysis.checkers.isVisibleInClass
 import org.jetbrains.kotlin.fir.containingClassLookupTag
@@ -34,9 +34,9 @@ import org.jetbrains.kotlin.name.CallableId
 internal class KtFirPropertyGetterSymbol(
    override val firSymbol: FirPropertyAccessorSymbol,
    override val firResolveSession: LLFirResolveSession,
-    override val token: KtLifetimeToken,
    private val builder: KtSymbolByFirBuilder,
 ) : KtPropertyGetterSymbol(), KtFirSymbol<FirPropertyAccessorSymbol> {
+    override val token: KtLifetimeToken get() = builder.token
    init {
        require(firSymbol.isGetter)
    }
@@ -38,9 +38,9 @@ import org.jetbrains.kotlin.name.CallableId
 internal class KtFirPropertySetterSymbol(
    override val firSymbol: FirPropertyAccessorSymbol,
    override val firResolveSession: LLFirResolveSession,
-    override val token: KtLifetimeToken,
    private val builder: KtSymbolByFirBuilder,
 ) : KtPropertySetterSymbol(), KtFirSymbol<FirPropertyAccessorSymbol> {
+    override val token: KtLifetimeToken get() = builder.token

    init {
        require(firSymbol.isSetter)
@@ -27,9 +27,9 @@ import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 internal class KtFirReceiverParameterSymbol(
    val firSymbol: FirCallableSymbol<*>,
    val firResolveSession: LLFirResolveSession,
-    override val token: KtLifetimeToken,
    private val builder: KtSymbolByFirBuilder
 ) : KtReceiverParameterSymbol(), KtLifetimeOwner {
+    override val token: KtLifetimeToken get() = builder.token
    override val psi: PsiElement? by cached { firSymbol.fir.receiverParameter?.typeRef?.findPsi(firSymbol.fir.moduleData.session) }

    init {
@@ -33,9 +33,9 @@ import org.jetbrains.kotlin.name.Name
 internal class KtFirSamConstructorSymbol(
    override val firSymbol: FirNamedFunctionSymbol,
    override val firResolveSession: LLFirResolveSession,
-    override val token: KtLifetimeToken,
    private val builder: KtSymbolByFirBuilder
 ) : KtSamConstructorSymbol(), KtFirSymbol<FirNamedFunctionSymbol> {
+    override val token: KtLifetimeToken get() = builder.token
    override val psi: PsiElement? by cached { firSymbol.findPsi() }

    override val annotationsList: KtAnnotationsList
@@ -12,6 +12,8 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirFile
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.resolveToFirSymbolOfType
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.errorWithFirSpecificEntries
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.withFirSymbolEntry
+import org.jetbrains.kotlin.analysis.utils.errors.buildErrorWithAttachment
+import org.jetbrains.kotlin.analysis.utils.errors.withPsiEntry
 import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
 import org.jetbrains.kotlin.fir.declarations.fullyExpandedClass
 import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
@@ -20,8 +22,6 @@ import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.analysis.utils.errors.buildErrorWithAttachment
-import org.jetbrains.kotlin.analysis.utils.errors.withPsiEntry
 import org.jetbrains.kotlin.psi.psiUtil.isObjectLiteral

 internal class KtFirSymbolProvider(
@@ -36,9 +36,9 @@ import org.jetbrains.kotlin.name.Name
 internal class KtFirSyntheticJavaPropertySymbol(
    override val firSymbol: FirSyntheticPropertySymbol,
    override val firResolveSession: LLFirResolveSession,
-    override val token: KtLifetimeToken,
    private val builder: KtSymbolByFirBuilder
 ) : KtSyntheticJavaPropertySymbol(), KtFirSymbol<FirSyntheticPropertySymbol> {
+    override val token: KtLifetimeToken get() = builder.token
    override val psi: PsiElement? by cached { firSymbol.findPsi() }

    override val isVal: Boolean get() = withValidityAssertion { firSymbol.isVal }
@@ -33,9 +33,9 @@ import org.jetbrains.kotlin.name.Name
 internal class KtFirTypeAliasSymbol(
    override val firSymbol: FirTypeAliasSymbol,
    override val firResolveSession: LLFirResolveSession,
-    override val token: KtLifetimeToken,
    private val builder: KtSymbolByFirBuilder,
 ) : KtTypeAliasSymbol(), KtFirSymbol<FirTypeAliasSymbol> {
+    override val token: KtLifetimeToken get() = builder.token

    override val psi: PsiElement? by cached { firSymbol.findPsi() }
    override val name: Name get() = withValidityAssertion { firSymbol.name }
@@ -30,9 +30,9 @@ import org.jetbrains.kotlin.types.Variance
 internal class KtFirTypeParameterSymbol(
    override val firSymbol: FirTypeParameterSymbol,
    override val firResolveSession: LLFirResolveSession,
-    override val token: KtLifetimeToken,
    private val builder: KtSymbolByFirBuilder
 ) : KtTypeParameterSymbol(), KtFirSymbol<FirTypeParameterSymbol> {
+    override val token: KtLifetimeToken get() = builder.token
    override val psi: PsiElement? by cached { firSymbol.findPsi() }

    override val annotationsList: KtAnnotationsList
@@ -32,9 +32,9 @@ import org.jetbrains.kotlin.name.Name
 internal class KtFirValueParameterSymbol(
    override val firSymbol: FirValueParameterSymbol,
    override val firResolveSession: LLFirResolveSession,
-    override val token: KtLifetimeToken,
    private val builder: KtSymbolByFirBuilder
 ) : KtValueParameterSymbol(), KtFirSymbol<FirValueParameterSymbol> {
+    override val token: KtLifetimeToken get() = builder.token
    override val psi: PsiElement? by cached { firSymbol.findPsi() }

    override val name: Name get() = withValidityAssertion { firSymbol.name }
@@ -19,9 +19,9 @@ import org.jetbrains.kotlin.fir.types.renderForDebugging

 internal class KtFirCapturedType(
    override val coneType: ConeCapturedType,
-    override val token: KtLifetimeToken,
    private val builder: KtSymbolByFirBuilder,
 ) : KtCapturedType(), KtFirType {
+    override val token: KtLifetimeToken get() = builder.token
    override val nullability: KtTypeNullability get() = withValidityAssertion { coneType.nullability.asKtNullability() }

    override val projection: KtTypeProjection
@@ -27,9 +27,9 @@ import org.jetbrains.kotlin.fir.types.renderForDebugging
 internal class KtFirClassErrorType(
    override val coneType: ConeClassLikeType,
    private val coneDiagnostic: ConeDiagnostic,
-    override val token: KtLifetimeToken,
    private val builder: KtSymbolByFirBuilder,
 ) : KtClassErrorType(), KtFirType {
+    override val token: KtLifetimeToken get() = builder.token

    override val qualifiers: List<KtClassTypeQualifier> by cached {
        when (coneDiagnostic) {
@@ -18,9 +18,9 @@ import org.jetbrains.kotlin.fir.types.renderForDebugging

 internal class KtFirDefinitelyNotNullType(
    override val coneType: ConeDefinitelyNotNullType,
-    override val token: KtLifetimeToken,
    private val builder: KtSymbolByFirBuilder,
 ) : KtDefinitelyNotNullType(), KtFirType {
+    override val token: KtLifetimeToken get() = builder.token
    override val original: KtType = withValidityAssertion { builder.typeBuilder.buildKtType(this.coneType.original) }
    override val annotationsList: KtAnnotationsList by cached {
        KtFirAnnotationListForType.create(coneType, builder.rootSession, token)
@@ -18,9 +18,9 @@ import org.jetbrains.kotlin.fir.types.renderForDebugging

 internal class KtFirDynamicType(
    override val coneType: ConeDynamicType,
-    override val token: KtLifetimeToken,
    private val builder: KtSymbolByFirBuilder,
 ) : KtDynamicType(), KtFirType {
+    override val token: KtLifetimeToken get() = builder.token
    override val annotationsList: KtAnnotationsList by cached {
        KtFirAnnotationListForType.create(coneType, builder.rootSession, token)
    }
@@ -19,9 +19,9 @@ import org.jetbrains.kotlin.fir.types.renderForDebugging

 internal class KtFirFlexibleType(
    override val coneType: ConeFlexibleType,
-    override val token: KtLifetimeToken,
    private val builder: KtSymbolByFirBuilder,
 ) : KtFlexibleType(), KtFirType {
+    override val token: KtLifetimeToken get() = builder.token

    override val lowerBound: KtType get() = withValidityAssertion { builder.typeBuilder.buildKtType(coneType.lowerBound) }
    override val upperBound: KtType get() = withValidityAssertion { builder.typeBuilder.buildKtType(coneType.upperBound) }
@@ -23,16 +23,16 @@ import org.jetbrains.kotlin.analysis.api.types.KtFunctionalType
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.types.KtTypeNullability
 import org.jetbrains.kotlin.analysis.low.level.api.fir.util.errorWithFirSpecificEntries
-import org.jetbrains.kotlin.builtins.functions.FunctionTypeKind
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl
 import org.jetbrains.kotlin.name.ClassId

 internal class KtFirFunctionalType(
    override val coneType: ConeClassLikeTypeImpl,
-    override val token: KtLifetimeToken,
    private val builder: KtSymbolByFirBuilder,
 ) : KtFunctionalType(), KtFirType {
+    override val token: KtLifetimeToken get() = builder.token
+
    override val classId: ClassId get() = withValidityAssertion { coneType.lookupTag.classId }
    override val classSymbol: KtClassLikeSymbol by cached {
        builder.classifierBuilder.buildClassLikeSymbolByLookupTag(coneType.lookupTag)
@@ -19,9 +19,10 @@ import org.jetbrains.kotlin.fir.types.renderForDebugging

 internal class KtFirIntegerLiteralType(
    override val coneType: ConeIntegerLiteralConstantType,
-    override val token: KtLifetimeToken,
    private val builder: KtSymbolByFirBuilder,
 ) : KtIntegerLiteralType(), KtFirType {
+    override val token: KtLifetimeToken get() = builder.token
+
    override val isUnsigned: Boolean get() = withValidityAssertion { coneType.isUnsigned }

    override val value: Long get() = withValidityAssertion { coneType.value }
@@ -19,9 +19,10 @@ import org.jetbrains.kotlin.fir.types.renderForDebugging

 internal class KtFirIntersectionType(
    override val coneType: ConeIntersectionType,
-    override val token: KtLifetimeToken,
    private val builder: KtSymbolByFirBuilder,
 ) : KtIntersectionType(), KtFirType {
+    override val token: KtLifetimeToken get() = builder.token
+
    override val conjuncts: List<KtType> by cached {
        coneType.intersectedTypes.map { conjunct -> builder.typeBuilder.buildKtType(conjunct) }
    }
@@ -8,19 +8,19 @@ package org.jetbrains.kotlin.analysis.api.fir.types
 import org.jetbrains.kotlin.analysis.api.KtAnalysisApiInternals
 import org.jetbrains.kotlin.analysis.api.fir.KtSymbolByFirBuilder
 import org.jetbrains.kotlin.analysis.api.impl.base.KtMapBackedSubstitutor
-import org.jetbrains.kotlin.analysis.api.symbols.KtTypeParameterSymbol
 import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken
+import org.jetbrains.kotlin.analysis.api.lifetime.withValidityAssertion
+import org.jetbrains.kotlin.analysis.api.symbols.KtTypeParameterSymbol
 import org.jetbrains.kotlin.analysis.api.types.KtSubstitutor
 import org.jetbrains.kotlin.analysis.api.types.KtType
-import org.jetbrains.kotlin.analysis.api.lifetime.withValidityAssertion
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor
 import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutorByMap

 internal abstract class AbstractKtFirSubstitutor<T : ConeSubstitutor>(
    val substitutor: T,
    protected val builder: KtSymbolByFirBuilder,
-    override val token: KtLifetimeToken,
 ) : KtSubstitutor {
+    override val token: KtLifetimeToken get() = builder.token

    override fun substituteOrNull(type: KtType): KtType? = withValidityAssertion {
        require(type is KtFirType)
@@ -31,15 +31,13 @@ internal abstract class AbstractKtFirSubstitutor<T : ConeSubstitutor>(
 internal class KtFirGenericSubstitutor(
    substitutor: ConeSubstitutor,
    builder: KtSymbolByFirBuilder,
-    token: KtLifetimeToken
-) : AbstractKtFirSubstitutor<ConeSubstitutor>(substitutor, builder, token)
+) : AbstractKtFirSubstitutor<ConeSubstitutor>(substitutor, builder)

@OptIn(KtAnalysisApiInternals::class)
 internal class KtFirMapBackedSubstitutor(
    substitutor: ConeSubstitutorByMap,
    builder: KtSymbolByFirBuilder,
-    token: KtLifetimeToken
-) : AbstractKtFirSubstitutor<ConeSubstitutorByMap>(substitutor, builder, token), KtMapBackedSubstitutor {
+) : AbstractKtFirSubstitutor<ConeSubstitutorByMap>(substitutor, builder,), KtMapBackedSubstitutor {
    override fun getAsMap(): Map<KtTypeParameterSymbol, KtType> = withValidityAssertion {
        val result = mutableMapOf<KtTypeParameterSymbol, KtType>()
        for ((typeParameter, type) in substitutor.substitution) {
@@ -19,9 +19,9 @@ import org.jetbrains.kotlin.fir.types.renderForDebugging

 internal class KtFirTypeErrorType(
    override val coneType: ConeErrorType,
-    override val token: KtLifetimeToken,
    private val builder: KtSymbolByFirBuilder,
 ) : KtTypeErrorType(), KtFirType {
+    override val token: KtLifetimeToken get() = builder.token

    override val nullability: KtTypeNullability get() = withValidityAssertion { coneType.nullability.asKtNullability() }
    override val errorMessage: String get() = withValidityAssertion { coneType.diagnostic.reason }
@@ -21,9 +21,9 @@ import org.jetbrains.kotlin.name.Name

 internal class KtFirTypeParameterType(
    override val coneType: ConeTypeParameterType,
-    override val token: KtLifetimeToken,
    private val builder: KtSymbolByFirBuilder,
 ) : KtTypeParameterType(), KtFirType {
+    override val token: KtLifetimeToken get() = builder.token
    override val name: Name get() = withValidityAssertion { coneType.lookupTag.name }
    override val symbol: KtTypeParameterSymbol by cached {
        builder.classifierBuilder.buildTypeParameterSymbolByLookupTag(coneType.lookupTag)
@@ -23,9 +23,9 @@ import org.jetbrains.kotlin.name.ClassId

 internal class KtFirUsualClassType(
    override val coneType: ConeClassLikeTypeImpl,
-    override val token: KtLifetimeToken,
    private val builder: KtSymbolByFirBuilder,
 ) : KtUsualClassType(), KtFirType {
+    override val token: KtLifetimeToken get() = builder.token
    override val classId: ClassId get() = withValidityAssertion { coneType.lookupTag.classId }
    override val classSymbol: KtClassLikeSymbol
        get() = withValidityAssertion {