[analysis api] fix Analysis API contracts violation

2022-06-07 13:27:33 +02:00
parent c2558521cf
commit a16a01bf37
116 changed files with 666 additions and 555 deletions
@@ -11,6 +11,7 @@ import org.jetbrains.kotlin.analysis.api.descriptors.components.*
 import org.jetbrains.kotlin.analysis.api.impl.base.components.KtAnalysisScopeProviderImpl
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbolProvider
 import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken
+import org.jetbrains.kotlin.analysis.api.lifetime.withValidityAssertion
 import org.jetbrains.kotlin.analysis.project.structure.KtModule
 import org.jetbrains.kotlin.analysis.project.structure.getKtModule
 import org.jetbrains.kotlin.psi.KtElement
@@ -56,7 +57,8 @@ class KtFe10AnalysisSession(
    override val analysisScopeProviderImpl: KtAnalysisScopeProvider = KtAnalysisScopeProviderImpl(this, token)
    override val referenceResolveProviderImpl: KtReferenceResolveProvider = KtFe10ReferenceResolveProvider(this)

-    override fun createContextDependentCopy(originalKtFile: KtFile, elementToReanalyze: KtElement): KtAnalysisSession {
-        return KtFe10AnalysisSession(elementToReanalyze, token)
-    }
+    override fun createContextDependentCopy(originalKtFile: KtFile, elementToReanalyze: KtElement): KtAnalysisSession =
+        withValidityAssertion {
+            KtFe10AnalysisSession(elementToReanalyze, token)
+        }
 }
@@ -27,7 +27,7 @@ internal class KtFe10CompletionCandidateChecker(
        originalFile: KtFile,
        nameExpression: KtSimpleNameExpression,
        possibleExplicitReceiver: KtExpression?
-    ): KtExtensionApplicabilityResult = withValidityAssertion {
+    ): KtExtensionApplicabilityResult {
        throw NotImplementedError("Method is not implemented for FE 1.0")
    }
 }
@@ -31,36 +31,32 @@ internal class KtFe10DiagnosticProvider(
        get() = analysisSession.token

    override fun getDiagnosticsForElement(element: KtElement, filter: KtDiagnosticCheckerFilter): Collection<KtDiagnosticWithPsi<*>> {
-        withValidityAssertion {
-            val bindingContext = analysisContext.analyze(element, AnalysisMode.PARTIAL_WITH_DIAGNOSTICS)
-            val diagnostics = bindingContext.diagnostics.forElement(element)
-            return diagnostics.map { KtFe10Diagnostic(it, token) }
-        }
+        val bindingContext = analysisContext.analyze(element, AnalysisMode.PARTIAL_WITH_DIAGNOSTICS)
+        val diagnostics = bindingContext.diagnostics.forElement(element)
+        return diagnostics.map { KtFe10Diagnostic(it, token) }
    }

    override fun collectDiagnosticsForFile(ktFile: KtFile, filter: KtDiagnosticCheckerFilter): Collection<KtDiagnosticWithPsi<*>> {
-        withValidityAssertion {
-            val bindingContext = analysisContext.analyze(ktFile)
-            val result = mutableListOf<KtDiagnosticWithPsi<*>>()
-            for (diagnostic in bindingContext.diagnostics) {
-                if (diagnostic.psiFile == ktFile) {
-                    result += KtFe10Diagnostic(diagnostic, token)
-                }
+        val bindingContext = analysisContext.analyze(ktFile)
+        val result = mutableListOf<KtDiagnosticWithPsi<*>>()
+        for (diagnostic in bindingContext.diagnostics) {
+            if (diagnostic.psiFile == ktFile) {
+                result += KtFe10Diagnostic(diagnostic, token)
            }
-            return result
        }
+        return result
    }
 }

 internal class KtFe10Diagnostic(private val diagnostic: Diagnostic, override val token: KtLifetimeToken) : KtDiagnosticWithPsi<PsiElement> {
    override val severity: Severity
-        get() = diagnostic.severity
+        get() = withValidityAssertion { diagnostic.severity }

    override val factoryName: String
-        get() = diagnostic.factory.name
+        get() = withValidityAssertion { diagnostic.factory.name }

    override val defaultMessage: String
-        get() {
+        get() = withValidityAssertion {
            @Suppress("UNCHECKED_CAST")
            val factory = diagnostic.factory as DiagnosticFactory<UnboundDiagnostic>?
            return factory?.defaultRenderer?.render(diagnostic)
@@ -69,11 +65,11 @@ internal class KtFe10Diagnostic(private val diagnostic: Diagnostic, override val
        }

    override val psi: PsiElement
-        get() = diagnostic.psiElement
+        get() = withValidityAssertion { diagnostic.psiElement }

    override val textRanges: Collection<TextRange>
-        get() = diagnostic.textRanges
+        get() = withValidityAssertion { diagnostic.textRanges }

    override val diagnosticClass: KClass<out KtDiagnosticWithPsi<PsiElement>>
-        get() = KtFe10Diagnostic::class
+        get() = withValidityAssertion { KtFe10Diagnostic::class }
 }
@@ -27,7 +27,7 @@ internal class KtFe10ExpressionInfoProvider(
    override val token: KtLifetimeToken
        get() = analysisSession.token

-    override fun getReturnExpressionTargetSymbol(returnExpression: KtReturnExpression): KtCallableSymbol? = withValidityAssertion {
+    override fun getReturnExpressionTargetSymbol(returnExpression: KtReturnExpression): KtCallableSymbol? {
        val bindingContext = analysisContext.analyze(returnExpression, AnalysisMode.PARTIAL)
        val targetLabel = returnExpression.getTargetLabel()
            ?: return returnExpression.parentOfType<KtNamedFunction>()
@@ -36,7 +36,7 @@ internal class KtFe10ExpressionInfoProvider(
        return with(analysisSession) { labelTarget.getSymbol() as? KtCallableSymbol }
    }

-    override fun getWhenMissingCases(whenExpression: KtWhenExpression): List<WhenMissingCase> = withValidityAssertion {
+    override fun getWhenMissingCases(whenExpression: KtWhenExpression): List<WhenMissingCase>  {
        val bindingContext = analysisContext.analyze(whenExpression)
        return WhenChecker.getMissingCases(whenExpression, bindingContext)
    }
@@ -13,7 +13,6 @@ import org.jetbrains.kotlin.analysis.api.descriptors.components.base.Fe10KtAnaly
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtType
 import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
-import org.jetbrains.kotlin.analysis.api.lifetime.withValidityAssertion
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.diagnostics.Errors
 import org.jetbrains.kotlin.lexer.KtTokens
@@ -28,10 +27,10 @@ import org.jetbrains.kotlin.resolve.calls.util.getResolvedCall
 import org.jetbrains.kotlin.resolve.calls.util.getType
 import org.jetbrains.kotlin.resolve.sam.SamConstructorDescriptor
 import org.jetbrains.kotlin.resolve.sam.getFunctionTypeForAbstractMethod
-import org.jetbrains.kotlin.types.error.ErrorTypeKind
-import org.jetbrains.kotlin.types.error.ErrorUtils
 import org.jetbrains.kotlin.types.TypeUtils
 import org.jetbrains.kotlin.types.checker.intersectWrappedTypes
+import org.jetbrains.kotlin.types.error.ErrorTypeKind
+import org.jetbrains.kotlin.types.error.ErrorUtils
 import org.jetbrains.kotlin.types.typeUtil.makeNullable

 class KtFe10ExpressionTypeProvider(
@@ -49,7 +48,7 @@ class KtFe10ExpressionTypeProvider(
    override val token: KtLifetimeToken
        get() = analysisSession.token

-    override fun getKtExpressionType(expression: KtExpression): KtType? = withValidityAssertion {
+    override fun getKtExpressionType(expression: KtExpression): KtType? {
        // Not sure if it's safe enough. In theory, some annotations on expressions might change its type
        val unwrapped = expression.unwrapParenthesesLabelsAndAnnotations() as? KtExpression ?: return null
        if (unwrapped.getParentOfTypes(false, *NON_EXPRESSION_CONTAINERS) != null) {
@@ -66,7 +65,7 @@ class KtFe10ExpressionTypeProvider(
        return kotlinType.toKtType(analysisContext)
    }

-    override fun getReturnTypeForKtDeclaration(declaration: KtDeclaration): KtType = withValidityAssertion {
+    override fun getReturnTypeForKtDeclaration(declaration: KtDeclaration): KtType {
        // Handle callable declarations with explicit return type first
        if (declaration is KtCallableDeclaration) {
            val typeReference = declaration.typeReference
@@ -134,7 +133,7 @@ class KtFe10ExpressionTypeProvider(
        return analysisContext.builtIns.unitType.toKtType(analysisContext)
    }

-    override fun getFunctionalTypeForKtFunction(declaration: KtFunction): KtType = withValidityAssertion {
+    override fun getFunctionalTypeForKtFunction(declaration: KtFunction): KtType {
        val analysisMode = if (declaration.hasDeclaredReturnType()) AnalysisMode.PARTIAL else AnalysisMode.FULL
        val bindingContext = analysisContext.analyze(declaration, analysisMode)
        val functionDescriptor = bindingContext[BindingContext.FUNCTION, declaration]
@@ -155,7 +154,7 @@ class KtFe10ExpressionTypeProvider(
            .toKtType(analysisContext)
    }

-    override fun getExpectedType(expression: PsiElement): KtType? = withValidityAssertion {
+    override fun getExpectedType(expression: PsiElement): KtType? {
        val ktExpression = expression.getParentOfType<KtExpression>(false) ?: return null
        val parentExpression = ktExpression.parent

@@ -222,7 +221,7 @@ class KtFe10ExpressionTypeProvider(
        }
    }

-    override fun isDefinitelyNull(expression: KtExpression): Boolean = withValidityAssertion {
+    override fun isDefinitelyNull(expression: KtExpression): Boolean {
        val unwrapped = expression.unwrapParenthesesLabelsAndAnnotations() as? KtElement ?: return false
        val bindingContext = analysisContext.analyze(expression, AnalysisMode.PARTIAL)

@@ -239,7 +238,7 @@ class KtFe10ExpressionTypeProvider(
        return false
    }

-    override fun isDefinitelyNotNull(expression: KtExpression): Boolean = withValidityAssertion {
+    override fun isDefinitelyNotNull(expression: KtExpression): Boolean {
        val ktExpression = expression as? KtExpression ?: return false
        val bindingContext = analysisContext.analyze(ktExpression)

@@ -36,7 +36,7 @@ internal class KtFe10InheritorsProvider(
            .mapNotNull { it.toKtClassifierSymbol(analysisContext) as? KtNamedClassOrObjectSymbol }
    }

-    override fun getEnumEntries(classSymbol: KtNamedClassOrObjectSymbol): List<KtEnumEntrySymbol> = withValidityAssertion {
+    override fun getEnumEntries(classSymbol: KtNamedClassOrObjectSymbol): List<KtEnumEntrySymbol> {
        val enumDescriptor = getSymbolDescriptor(classSymbol) as? ClassDescriptor ?: return emptyList()
        if (enumDescriptor.kind != ClassKind.ENUM_CLASS) {
            return emptyList()
@@ -24,7 +24,7 @@ internal class KtFe10JvmTypeMapper(

    private val typeMapper by lazy { KtFe10JvmTypeMapperContext(analysisContext.resolveSession) }

-    override fun mapTypeToJvmType(type: KtType, mode: TypeMappingMode): Type = withValidityAssertion {
+    override fun mapTypeToJvmType(type: KtType, mode: TypeMappingMode): Type {
        val kotlinType = (type as KtFe10Type).type
        return typeMapper.mapType(kotlinType, mode)
    }
@@ -28,7 +28,7 @@ internal class KtFe10OverrideInfoProvider(
    override val token: KtLifetimeToken
        get() = analysisSession.token

-    override fun isVisible(memberSymbol: KtCallableSymbol, classSymbol: KtClassOrObjectSymbol): Boolean = withValidityAssertion {
+    override fun isVisible(memberSymbol: KtCallableSymbol, classSymbol: KtClassOrObjectSymbol): Boolean  {
        val memberDescriptor = getSymbolDescriptor(memberSymbol) as? DeclarationDescriptorWithVisibility ?: return false
        val classDescriptor = getSymbolDescriptor(classSymbol) ?: return false
        return isVisibleWithAnyReceiver(memberDescriptor, classDescriptor, analysisSession.analysisContext.languageVersionSettings)
@@ -37,17 +37,17 @@ internal class KtFe10OverrideInfoProvider(
    override fun getImplementationStatus(
        memberSymbol: KtCallableSymbol,
        parentClassSymbol: KtClassOrObjectSymbol
-    ): ImplementationStatus? = withValidityAssertion {
+    ): ImplementationStatus?  {
        throw NotImplementedError("Method is not implemented for FE 1.0")
    }

-    override fun getOriginalOverriddenSymbol(symbol: KtCallableSymbol): KtCallableSymbol? = withValidityAssertion {
+    override fun getOriginalOverriddenSymbol(symbol: KtCallableSymbol): KtCallableSymbol?  {
        val callableDescriptor = getSymbolDescriptor(symbol) as? CallableMemberDescriptor ?: return null
        val originalCallableDescriptor = callableDescriptor.findOriginalTopMostOverriddenDescriptors().firstOrNull() ?: return null
        return originalCallableDescriptor.toKtCallableSymbol(analysisContext)
    }

-    override fun getOriginalContainingClassForOverride(symbol: KtCallableSymbol): KtClassOrObjectSymbol? = withValidityAssertion {
+    override fun getOriginalContainingClassForOverride(symbol: KtCallableSymbol): KtClassOrObjectSymbol?  {
        val callableDescriptor = getSymbolDescriptor(symbol) as? CallableMemberDescriptor ?: return null
        val originalCallableDescriptor = callableDescriptor.findOriginalTopMostOverriddenDescriptors().firstOrNull() ?: return null
        val containingClassDescriptor = originalCallableDescriptor.containingDeclaration as? ClassDescriptor ?: return null
@@ -19,7 +19,6 @@ import org.jetbrains.kotlin.analysis.api.descriptors.utils.KtFe10JvmTypeMapperCo
 import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
 import org.jetbrains.kotlin.analysis.api.types.KtTypeMappingMode
-import org.jetbrains.kotlin.analysis.api.lifetime.withValidityAssertion
 import org.jetbrains.kotlin.codegen.signature.BothSignatureWriter
 import org.jetbrains.kotlin.load.kotlin.TypeMappingMode
 import org.jetbrains.kotlin.load.kotlin.getOptimalModeForReturnType
@@ -41,7 +40,7 @@ internal class KtFe10PsiTypeProvider(
        useSitePosition: PsiElement,
        mode: KtTypeMappingMode,
        isAnnotationMethod: Boolean,
-    ): PsiType? = withValidityAssertion {
+    ): PsiType? {
        val kotlinType = (type as KtFe10Type).type

        if (kotlinType.isError || kotlinType.arguments.any { !it.isStarProjection && it.type.isError }) {
@@ -25,7 +25,7 @@ internal class KtFe10SamResolver(
    override val token: KtLifetimeToken
        get() = analysisSession.token

-    override fun getSamConstructor(ktClassLikeSymbol: KtClassLikeSymbol): KtSamConstructorSymbol? = withValidityAssertion {
+    override fun getSamConstructor(ktClassLikeSymbol: KtClassLikeSymbol): KtSamConstructorSymbol?  {
        val descriptor = getSymbolDescriptor(ktClassLikeSymbol)
        if (descriptor is ClassDescriptor && getSingleAbstractMethodOrNull(descriptor) != null) {
            val constructorDescriptor = createSamConstructorFunction(
@@ -11,7 +11,10 @@ import org.jetbrains.kotlin.analysis.api.components.KtScopeContext
 import org.jetbrains.kotlin.analysis.api.components.KtScopeProvider
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
 import org.jetbrains.kotlin.analysis.api.descriptors.components.base.Fe10KtAnalysisSessionComponent
-import org.jetbrains.kotlin.analysis.api.descriptors.scopes.*
+import org.jetbrains.kotlin.analysis.api.descriptors.scopes.KtFe10FileScope
+import org.jetbrains.kotlin.analysis.api.descriptors.scopes.KtFe10PackageScope
+import org.jetbrains.kotlin.analysis.api.descriptors.scopes.KtFe10ScopeLexical
+import org.jetbrains.kotlin.analysis.api.descriptors.scopes.KtFe10ScopeMember
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.KtFe10FileSymbol
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.KtFe10PackageSymbol
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.base.KtFe10Symbol
@@ -21,16 +24,16 @@ import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.bas
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.KtFe10PsiSymbol
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.getResolutionScope
 import org.jetbrains.kotlin.analysis.api.descriptors.types.base.KtFe10Type
-import org.jetbrains.kotlin.analysis.api.impl.base.scopes.KtEmptyScope
 import org.jetbrains.kotlin.analysis.api.impl.base.scopes.KtCompositeScope
-import org.jetbrains.kotlin.analysis.api.scopes.*
+import org.jetbrains.kotlin.analysis.api.impl.base.scopes.KtEmptyScope
+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.symbols.KtFileSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtPackageSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolWithMembers
-import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
-import org.jetbrains.kotlin.analysis.api.lifetime.withValidityAssertion
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.incremental.components.LookupLocation
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
@@ -55,21 +58,21 @@ internal class KtFe10ScopeProvider(
    override val token: KtLifetimeToken
        get() = analysisSession.token

-    override fun getMemberScope(classSymbol: KtSymbolWithMembers): KtScope = withValidityAssertion {
+    override fun getMemberScope(classSymbol: KtSymbolWithMembers): KtScope {
        val descriptor = getDescriptor<ClassDescriptor>(classSymbol)
            ?: return getEmptyScope()

        return KtFe10ScopeMember(descriptor.unsubstitutedMemberScope, analysisContext)
    }

-    override fun getDeclaredMemberScope(classSymbol: KtSymbolWithMembers): KtScope = withValidityAssertion {
+    override fun getDeclaredMemberScope(classSymbol: KtSymbolWithMembers): KtScope {
        val descriptor = getDescriptor<ClassDescriptor>(classSymbol)
            ?: return getEmptyScope()

        return KtFe10ScopeMember(DeclaredMemberScope(descriptor), analysisContext)
    }

-    override fun getDelegatedMemberScope(classSymbol: KtSymbolWithMembers): KtScope = withValidityAssertion {
+    override fun getDelegatedMemberScope(classSymbol: KtSymbolWithMembers): KtScope  {
        val descriptor = getDescriptor<ClassDescriptor>(classSymbol)
            ?: return getEmptyScope()

@@ -151,21 +154,21 @@ internal class KtFe10ScopeProvider(

    }

-    override fun getStaticMemberScope(symbol: KtSymbolWithMembers): KtScope = withValidityAssertion {
+    override fun getStaticMemberScope(symbol: KtSymbolWithMembers): KtScope {
        val descriptor = getDescriptor<ClassDescriptor>(symbol) ?: return getEmptyScope()
        return KtFe10ScopeMember(descriptor.staticScope, analysisContext)
    }

-    override fun getEmptyScope(): KtScope = withValidityAssertion {
-        KtEmptyScope(token)
+    override fun getEmptyScope(): KtScope {
+        return KtEmptyScope(token)
    }

-    override fun getFileScope(fileSymbol: KtFileSymbol): KtScope = withValidityAssertion {
+    override fun getFileScope(fileSymbol: KtFileSymbol): KtScope {
        require(fileSymbol is KtFe10FileSymbol)
        return KtFe10FileScope(fileSymbol.psi, analysisContext, token)
    }

-    override fun getPackageScope(packageSymbol: KtPackageSymbol): KtScope = withValidityAssertion {
+    override fun getPackageScope(packageSymbol: KtPackageSymbol): KtScope {
        require(packageSymbol is KtFe10PackageSymbol)
        val packageFragments = analysisContext.resolveSession.packageFragmentProvider.packageFragments(packageSymbol.fqName)
        val scopeDescription = "Compound scope for package \"${packageSymbol.fqName}\""
@@ -173,28 +176,28 @@ internal class KtFe10ScopeProvider(
        return KtFe10PackageScope(chainedScope, packageSymbol, analysisContext)
    }

-    override fun getCompositeScope(subScopes: List<KtScope>): KtScope = withValidityAssertion {
+    override fun getCompositeScope(subScopes: List<KtScope>): KtScope {
        return KtCompositeScope(subScopes, token)
    }

-    override fun getTypeScope(type: KtType): KtScope = withValidityAssertion {
+    override fun getTypeScope(type: KtType): KtScope {
        require(type is KtFe10Type)
        return KtFe10ScopeMember(type.type.memberScope, analysisContext)
    }

-    override fun getScopeContextForPosition(originalFile: KtFile, positionInFakeFile: KtElement): KtScopeContext = withValidityAssertion {
+    override fun getScopeContextForPosition(originalFile: KtFile, positionInFakeFile: KtElement): KtScopeContext {
        val elementToAnalyze = positionInFakeFile.containingNonLocalDeclaration() ?: originalFile
        val bindingContext = analysisContext.analyze(elementToAnalyze)

        val lexicalScope = positionInFakeFile.getResolutionScope(bindingContext)
        if (lexicalScope != null) {
            val compositeScope = KtCompositeScope(listOf(KtFe10ScopeLexical(lexicalScope, analysisContext)), token)
-            return KtScopeContext(compositeScope, collectImplicitReceivers(lexicalScope))
+            return KtScopeContext(compositeScope, collectImplicitReceivers(lexicalScope), token)
        }

        val fileScope = analysisContext.resolveSession.fileScopeProvider.getFileResolutionScope(originalFile)
        val compositeScope = KtCompositeScope(listOf(KtFe10ScopeLexical(fileScope, analysisContext)), token)
-        return KtScopeContext(compositeScope, collectImplicitReceivers(fileScope))
+        return KtScopeContext(compositeScope, collectImplicitReceivers(fileScope), token)
    }

    private inline fun <reified T : DeclarationDescriptor> getDescriptor(symbol: KtSymbol): T? {
@@ -14,7 +14,6 @@ import org.jetbrains.kotlin.analysis.api.descriptors.components.base.Fe10KtAnaly
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtType
 import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
-import org.jetbrains.kotlin.analysis.api.lifetime.withValidityAssertion
 import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.calls.smartcasts.ExplicitSmartCasts
@@ -28,22 +27,20 @@ internal class KtFe10SmartCastProvider(
        get() = analysisSession.token

    override fun getSmartCastedInfo(expression: KtExpression): KtSmartCastInfo? {
-        withValidityAssertion {
-            val bindingContext = analysisContext.analyze(expression)
-            val stableSmartCasts = bindingContext[BindingContext.SMARTCAST, expression]
-            val unstableSmartCasts = bindingContext[BindingContext.UNSTABLE_SMARTCAST, expression]
+        val bindingContext = analysisContext.analyze(expression)
+        val stableSmartCasts = bindingContext[BindingContext.SMARTCAST, expression]
+        val unstableSmartCasts = bindingContext[BindingContext.UNSTABLE_SMARTCAST, expression]

-            return when {
-                stableSmartCasts != null -> {
-                    val type = stableSmartCasts.getKtType() ?: return null
-                    KtSmartCastInfo(type, true, token)
-                }
-                unstableSmartCasts != null -> {
-                    val type = unstableSmartCasts.getKtType() ?: return null
-                    KtSmartCastInfo(type, false, token)
-                }
-                else -> null
+        return when {
+            stableSmartCasts != null -> {
+                val type = stableSmartCasts.getKtType() ?: return null
+                KtSmartCastInfo(type, true, token)
            }
+            unstableSmartCasts != null -> {
+                val type = unstableSmartCasts.getKtType() ?: return null
+                KtSmartCastInfo(type, false, token)
+            }
+            else -> null
        }
    }

@@ -55,13 +52,11 @@ internal class KtFe10SmartCastProvider(
    }

    override fun getImplicitReceiverSmartCast(expression: KtExpression): Collection<KtImplicitReceiverSmartCast> {
-        withValidityAssertion {
-            val bindingContext = analysisContext.analyze(expression)
-            val smartCasts = bindingContext[BindingContext.IMPLICIT_RECEIVER_SMARTCAST, expression] ?: return emptyList()
-            return smartCasts.receiverTypes.map { (_, type) ->
-                val kind = KtImplicitReceiverSmartCastKind.DISPATCH // TODO provide precise kind
-                KtImplicitReceiverSmartCast(type.toKtType(analysisContext), kind, token)
-            }
+        val bindingContext = analysisContext.analyze(expression)
+        val smartCasts = bindingContext[BindingContext.IMPLICIT_RECEIVER_SMARTCAST, expression] ?: return emptyList()
+        return smartCasts.receiverTypes.map { (_, type) ->
+            val kind = KtImplicitReceiverSmartCastKind.DISPATCH // TODO provide precise kind
+            KtImplicitReceiverSmartCast(type.toKtType(analysisContext), kind, token)
        }
    }
 }
@@ -11,7 +11,6 @@ import org.jetbrains.kotlin.analysis.api.descriptors.components.base.Fe10KtAnaly
 import org.jetbrains.kotlin.analysis.api.descriptors.types.base.KtFe10Type
 import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
-import org.jetbrains.kotlin.analysis.api.lifetime.withValidityAssertion

 internal class KtFe10SubtypingComponent(
    override val analysisSession: KtFe10AnalysisSession
@@ -19,13 +18,13 @@ internal class KtFe10SubtypingComponent(
    override val token: KtLifetimeToken
        get() = analysisSession.token

-    override fun isEqualTo(first: KtType, second: KtType): Boolean = withValidityAssertion {
+    override fun isEqualTo(first: KtType, second: KtType): Boolean {
        require(first is KtFe10Type)
        require(second is KtFe10Type)
        return analysisContext.resolveSession.kotlinTypeCheckerOfOwnerModule.equalTypes(first.type, second.type)
    }

-    override fun isSubTypeOf(subType: KtType, superType: KtType): Boolean = withValidityAssertion {
+    override fun isSubTypeOf(subType: KtType, superType: KtType): Boolean {
        require(subType is KtFe10Type)
        require(superType is KtFe10Type)
        val typeChecker = analysisContext.resolveSession.kotlinTypeCheckerOfOwnerModule
@@ -10,11 +10,10 @@ import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
 import org.jetbrains.kotlin.analysis.api.descriptors.components.base.Fe10KtAnalysisSessionComponent
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.getSymbolDescriptor
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtCallableSymbol
+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.symbols.KtSymbol
-import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken
-import org.jetbrains.kotlin.analysis.api.lifetime.withValidityAssertion
 import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.resolve.descriptorUtil.getSuperClassOrAny
@@ -66,19 +65,19 @@ internal class KtFe10SymbolDeclarationOverridesProvider(
        return overriddenDescriptors
    }

-    override fun isSubClassOf(subClass: KtClassOrObjectSymbol, superClass: KtClassOrObjectSymbol): Boolean = withValidityAssertion {
+    override fun isSubClassOf(subClass: KtClassOrObjectSymbol, superClass: KtClassOrObjectSymbol): Boolean {
        val subClassDescriptor = getSymbolDescriptor(subClass) as? ClassDescriptor ?: return false
        val superClassDescriptor = getSymbolDescriptor(superClass) as? ClassDescriptor ?: return false
        return subClassDescriptor.isSubclassOf(superClassDescriptor)
    }

-    override fun isDirectSubClassOf(subClass: KtClassOrObjectSymbol, superClass: KtClassOrObjectSymbol): Boolean = withValidityAssertion {
+    override fun isDirectSubClassOf(subClass: KtClassOrObjectSymbol, superClass: KtClassOrObjectSymbol): Boolean {
        val subClassDescriptor = getSymbolDescriptor(subClass) as? ClassDescriptor ?: return false
        val superClassDescriptor = getSymbolDescriptor(superClass) as? ClassDescriptor ?: return false
        return subClassDescriptor.getSuperClassOrAny() == superClassDescriptor
    }

-    override fun getIntersectionOverriddenSymbols(symbol: KtCallableSymbol): Collection<KtCallableSymbol> = withValidityAssertion {
+    override fun getIntersectionOverriddenSymbols(symbol: KtCallableSymbol): Collection<KtCallableSymbol> {
        throw NotImplementedError("Method is not implemented for FE 1.0")
    }
 }
@@ -12,9 +12,8 @@ import org.jetbrains.kotlin.analysis.api.descriptors.symbols.KtFe10PackageSymbol
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtClassSymbol
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtSymbol
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.*
-import org.jetbrains.kotlin.analysis.api.symbols.*
 import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken
-import org.jetbrains.kotlin.analysis.api.lifetime.withValidityAssertion
+import org.jetbrains.kotlin.analysis.api.symbols.*
 import org.jetbrains.kotlin.descriptors.findClassAcrossModuleDependencies
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
@@ -31,11 +30,11 @@ internal class KtFe10SymbolProvider(
    override val ROOT_PACKAGE_SYMBOL: KtPackageSymbol
        get() = KtFe10PackageSymbol(FqName.ROOT, analysisContext)

-    override fun getFileSymbol(psi: KtFile): KtFileSymbol = withValidityAssertion {
+    override fun getFileSymbol(psi: KtFile): KtFileSymbol {
        return KtFe10FileSymbol(psi, analysisContext)
    }

-    override fun getParameterSymbol(psi: KtParameter): KtVariableLikeSymbol = withValidityAssertion {
+    override fun getParameterSymbol(psi: KtParameter): KtVariableLikeSymbol {
        return when {
            psi.isFunctionTypeParameter -> error("Function type parameters are not supported in getParameterSymbol()")
            psi.isLoopParameter -> KtFe10PsiLoopParameterLocalVariableSymbol(psi, analysisContext)
@@ -43,7 +42,7 @@ internal class KtFe10SymbolProvider(
        }
    }

-    override fun getFunctionLikeSymbol(psi: KtNamedFunction): KtFunctionLikeSymbol = withValidityAssertion {
+    override fun getFunctionLikeSymbol(psi: KtNamedFunction): KtFunctionLikeSymbol {
        return if (psi.hasBody() && (psi.funKeyword == null || psi.nameIdentifier == null)) {
            getAnonymousFunctionSymbol(psi)
        } else {
@@ -51,31 +50,31 @@ internal class KtFe10SymbolProvider(
        }
    }

-    override fun getConstructorSymbol(psi: KtConstructor<*>): KtConstructorSymbol = withValidityAssertion {
+    override fun getConstructorSymbol(psi: KtConstructor<*>): KtConstructorSymbol {
        return KtFe10PsiConstructorSymbol(psi, analysisContext)
    }

-    override fun getTypeParameterSymbol(psi: KtTypeParameter): KtTypeParameterSymbol = withValidityAssertion {
+    override fun getTypeParameterSymbol(psi: KtTypeParameter): KtTypeParameterSymbol {
        return KtFe10PsiTypeParameterSymbol(psi, analysisContext)
    }

-    override fun getTypeAliasSymbol(psi: KtTypeAlias): KtTypeAliasSymbol = withValidityAssertion {
+    override fun getTypeAliasSymbol(psi: KtTypeAlias): KtTypeAliasSymbol {
        return KtFe10PsiTypeAliasSymbol(psi, analysisContext)
    }

-    override fun getEnumEntrySymbol(psi: KtEnumEntry): KtEnumEntrySymbol = withValidityAssertion {
+    override fun getEnumEntrySymbol(psi: KtEnumEntry): KtEnumEntrySymbol {
        return KtFe10PsiEnumEntrySymbol(psi, analysisContext)
    }

-    override fun getAnonymousFunctionSymbol(psi: KtNamedFunction): KtAnonymousFunctionSymbol = withValidityAssertion {
+    override fun getAnonymousFunctionSymbol(psi: KtNamedFunction): KtAnonymousFunctionSymbol {
        return KtFe10PsiAnonymousFunctionSymbol(psi, analysisContext)
    }

-    override fun getAnonymousFunctionSymbol(psi: KtFunctionLiteral): KtAnonymousFunctionSymbol = withValidityAssertion {
+    override fun getAnonymousFunctionSymbol(psi: KtFunctionLiteral): KtAnonymousFunctionSymbol {
        return KtFe10PsiLiteralAnonymousFunctionSymbol(psi, analysisContext)
    }

-    override fun getVariableSymbol(psi: KtProperty): KtVariableSymbol = withValidityAssertion {
+    override fun getVariableSymbol(psi: KtProperty): KtVariableSymbol {
        return if (psi.isLocal) {
            KtFe10PsiLocalVariableSymbol(psi, analysisContext)
        } else {
@@ -83,11 +82,11 @@ internal class KtFe10SymbolProvider(
        }
    }

-    override fun getAnonymousObjectSymbol(psi: KtObjectLiteralExpression): KtAnonymousObjectSymbol = withValidityAssertion {
+    override fun getAnonymousObjectSymbol(psi: KtObjectLiteralExpression): KtAnonymousObjectSymbol {
        return KtFe10PsiAnonymousObjectSymbol(psi.objectDeclaration, analysisContext)
    }

-    override fun getClassOrObjectSymbol(psi: KtClassOrObject): KtClassOrObjectSymbol = withValidityAssertion {
+    override fun getClassOrObjectSymbol(psi: KtClassOrObject): KtClassOrObjectSymbol {
        return if (psi is KtObjectDeclaration && psi.isObjectLiteral()) {
            KtFe10PsiAnonymousObjectSymbol(psi, analysisContext)
        } else {
@@ -95,7 +94,7 @@ internal class KtFe10SymbolProvider(
        }
    }

-    override fun getNamedClassOrObjectSymbol(psi: KtClassOrObject): KtNamedClassOrObjectSymbol? = withValidityAssertion {
+    override fun getNamedClassOrObjectSymbol(psi: KtClassOrObject): KtNamedClassOrObjectSymbol? {
        if (psi is KtEnumEntry || psi.nameIdentifier == null) {
            return null
        }
@@ -103,7 +102,7 @@ internal class KtFe10SymbolProvider(
        return KtFe10PsiNamedClassOrObjectSymbol(psi, analysisContext)
    }

-    override fun getPropertyAccessorSymbol(psi: KtPropertyAccessor): KtPropertyAccessorSymbol = withValidityAssertion {
+    override fun getPropertyAccessorSymbol(psi: KtPropertyAccessor): KtPropertyAccessorSymbol {
        return if (psi.isGetter) {
            KtFe10PsiPropertyGetterSymbol(psi, analysisContext)
        } else {
@@ -111,16 +110,16 @@ internal class KtFe10SymbolProvider(
        }
    }

-    override fun getClassInitializerSymbol(psi: KtClassInitializer): KtClassInitializerSymbol = withValidityAssertion {
+    override fun getClassInitializerSymbol(psi: KtClassInitializer): KtClassInitializerSymbol {
        return KtFe10PsiClassInitializerSymbol(psi, analysisContext)
    }

-    override fun getClassOrObjectSymbolByClassId(classId: ClassId): KtClassOrObjectSymbol? = withValidityAssertion {
+    override fun getClassOrObjectSymbolByClassId(classId: ClassId): KtClassOrObjectSymbol? {
        val descriptor = analysisContext.resolveSession.moduleDescriptor.findClassAcrossModuleDependencies(classId) ?: return null
        return descriptor.toKtClassSymbol(analysisContext)
    }

-    override fun getTopLevelCallableSymbols(packageFqName: FqName, name: Name): Sequence<KtSymbol> = withValidityAssertion {
+    override fun getTopLevelCallableSymbols(packageFqName: FqName, name: Name): Sequence<KtSymbol> {
        val packageViewDescriptor = analysisContext.resolveSession.moduleDescriptor.getPackage(packageFqName)
        return packageViewDescriptor.memberScope.getContributedDescriptors(DescriptorKindFilter.ALL, nameFilter = { it == name })
            .asSequence()
@@ -21,12 +21,13 @@ import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken
 import org.jetbrains.kotlin.analysis.api.types.KtClassType
 import org.jetbrains.kotlin.analysis.api.types.KtTypeNullability
 import org.jetbrains.kotlin.analysis.api.types.KtTypeParameterType
-import org.jetbrains.kotlin.analysis.api.lifetime.withValidityAssertion
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
-import org.jetbrains.kotlin.types.*
-import org.jetbrains.kotlin.types.error.ErrorType
+import org.jetbrains.kotlin.types.SimpleType
+import org.jetbrains.kotlin.types.StarProjectionImpl
+import org.jetbrains.kotlin.types.TypeProjectionImpl
+import org.jetbrains.kotlin.types.TypeUtils
 import org.jetbrains.kotlin.types.error.ErrorTypeKind
 import org.jetbrains.kotlin.types.error.ErrorUtils
 import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
@@ -37,7 +38,7 @@ internal class KtFe10TypeCreator(
    override val token: KtLifetimeToken
        get() = analysisSession.token

-    override fun buildClassType(builder: KtClassTypeBuilder): KtClassType = withValidityAssertion {
+    override fun buildClassType(builder: KtClassTypeBuilder): KtClassType {
        val descriptor: ClassDescriptor? = when (builder) {
            is KtClassTypeBuilder.ByClassId -> {
                val fqName = builder.classId.asSingleFqName()
@@ -73,7 +74,7 @@ internal class KtFe10TypeCreator(
        return KtFe10UsualClassType(typeWithNullability as SimpleType, descriptor, analysisContext)
    }

-    override fun buildTypeParameterType(builder: KtTypeParameterTypeBuilder): KtTypeParameterType = withValidityAssertion {
+    override fun buildTypeParameterType(builder: KtTypeParameterTypeBuilder): KtTypeParameterType {
        val descriptor = when (builder) {
            is KtTypeParameterTypeBuilder.BySymbol -> {
                getSymbolDescriptor(builder.symbol) as? TypeParameterDescriptor
@@ -11,7 +11,6 @@ import org.jetbrains.kotlin.analysis.api.descriptors.components.base.Fe10KtAnaly
 import org.jetbrains.kotlin.analysis.api.descriptors.types.base.KtFe10Type
 import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken
 import org.jetbrains.kotlin.analysis.api.types.KtType
-import org.jetbrains.kotlin.analysis.api.lifetime.withValidityAssertion
 import org.jetbrains.kotlin.builtins.functions.FunctionClassKind
 import org.jetbrains.kotlin.builtins.getFunctionalClassKind
 import org.jetbrains.kotlin.load.java.sam.JavaSingleAbstractMethodUtils
@@ -26,7 +25,7 @@ internal class KtFe10TypeInfoProvider(
    override val token: KtLifetimeToken
        get() = analysisSession.token

-    override fun isFunctionalInterfaceType(type: KtType): Boolean = withValidityAssertion {
+    override fun isFunctionalInterfaceType(type: KtType): Boolean {
        require(type is KtFe10Type)
        return JavaSingleAbstractMethodUtils.isSamType(type.type)
    }
@@ -36,7 +35,7 @@ internal class KtFe10TypeInfoProvider(
        return type.type.constructor.declarationDescriptor?.getFunctionalClassKind()
    }

-    override fun canBeNull(type: KtType): Boolean = withValidityAssertion {
+    override fun canBeNull(type: KtType): Boolean {
        require(type is KtFe10Type)
        return TypeUtils.isNullableType(type.type)
    }
@@ -65,39 +65,39 @@ internal class KtFe10TypeProvider(
    override val token: KtLifetimeToken
        get() = analysisSession.token

-    override val builtinTypes: KtBuiltinTypes by cached { KtFe10BuiltinTypes(analysisContext) }
+    override val builtinTypes: KtBuiltinTypes by lazy(LazyThreadSafetyMode.PUBLICATION) { KtFe10BuiltinTypes(analysisContext) }

-    override fun approximateToSuperPublicDenotableType(type: KtType): KtType? = withValidityAssertion {
+    override fun approximateToSuperPublicDenotableType(type: KtType): KtType?  {
        require(type is KtFe10Type)
        return typeApproximator.approximateToSuperType(type.type, PublicApproximatorConfiguration)?.toKtType(analysisContext)
    }

-    override fun buildSelfClassType(symbol: KtNamedClassOrObjectSymbol): KtType = withValidityAssertion {
+    override fun buildSelfClassType(symbol: KtNamedClassOrObjectSymbol): KtType  {
        val kotlinType = (getSymbolDescriptor(symbol) as? ClassDescriptor)?.defaultType
            ?: ErrorUtils.createErrorType(ErrorTypeKind.UNRESOLVED_CLASS_TYPE, symbol.nameOrAnonymous.toString())

        return kotlinType.toKtType(analysisContext)
    }

-    override fun commonSuperType(types: Collection<KtType>): KtType = withValidityAssertion {
+    override fun commonSuperType(types: Collection<KtType>): KtType  {
        val kotlinTypes = types.map { (it as KtFe10Type).type }
        return CommonSupertypes.commonSupertype(kotlinTypes).toKtType(analysisContext)
    }

-    override fun getKtType(ktTypeReference: KtTypeReference): KtType = withValidityAssertion {
+    override fun getKtType(ktTypeReference: KtTypeReference): KtType  {
        val bindingContext = analysisContext.analyze(ktTypeReference, AnalysisMode.PARTIAL)
        val kotlinType = bindingContext[BindingContext.TYPE, ktTypeReference]
            ?: ErrorUtils.createErrorType(ErrorTypeKind.UNRESOLVED_TYPE, ktTypeReference.text)
        return kotlinType.toKtType(analysisContext)
    }

-    override fun getReceiverTypeForDoubleColonExpression(expression: KtDoubleColonExpression): KtType? = withValidityAssertion {
+    override fun getReceiverTypeForDoubleColonExpression(expression: KtDoubleColonExpression): KtType?  {
        val bindingContext = analysisContext.analyze(expression, AnalysisMode.PARTIAL)
        val lhs = bindingContext[BindingContext.DOUBLE_COLON_LHS, expression] ?: return null
        return lhs.type.toKtType(analysisContext)
    }

-    override fun withNullability(type: KtType, newNullability: KtTypeNullability): KtType = withValidityAssertion {
+    override fun withNullability(type: KtType, newNullability: KtTypeNullability): KtType  {
        require(type is KtFe10Type)
        return type.type.makeNullableAsSpecified(newNullability == KtTypeNullability.NULLABLE).toKtType(analysisContext)
    }
@@ -125,7 +125,6 @@ internal class KtFe10TypeProvider(
    }

    override fun getDispatchReceiverType(symbol: KtCallableSymbol): KtType? {
-        assertIsValidAndAccessible()
        require(symbol is KtFe10Symbol)

        val descriptor = when (symbol) {
@@ -12,10 +12,9 @@ import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
 import org.jetbrains.kotlin.analysis.api.descriptors.components.base.Fe10KtAnalysisSessionComponent
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.getSymbolDescriptor
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.psiBased.base.getResolutionScope
+import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken
 import org.jetbrains.kotlin.analysis.api.symbols.KtFileSymbol
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolWithVisibility
-import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken
-import org.jetbrains.kotlin.analysis.api.lifetime.withValidityAssertion
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptorWithVisibility
 import org.jetbrains.kotlin.descriptors.DescriptorVisibilityUtils.isVisible
 import org.jetbrains.kotlin.descriptors.Visibilities
@@ -39,7 +38,7 @@ internal class KtFe10VisibilityChecker(
        useSiteFile: KtFileSymbol,
        position: PsiElement,
        receiverExpression: KtExpression?
-    ): Boolean = withValidityAssertion {
+    ): Boolean {
        if (candidateSymbol.visibility == Visibilities.Public) {
            return true
        }
@@ -25,7 +25,7 @@ internal class KtFe10FileSymbol(
        get() = withValidityAssertion { file }

    override val annotationsObject: Annotations
-        get() = analysisContext.resolveSession.getFileAnnotations(file)
+        get() = withValidityAssertion { analysisContext.resolveSession.getFileAnnotations(file) }

    override val origin: KtSymbolOrigin
        get() = withValidityAssertion { if (file.isCompiled) KtSymbolOrigin.LIBRARY else KtSymbolOrigin.SOURCE }
@@ -58,7 +58,7 @@ internal class KtFe10DescFunctionSymbol private constructor(
        get() = withValidityAssertion { descriptor is JavaCallableMemberDescriptor && DescriptorUtils.isStaticDeclaration(descriptor) }

    override val isBuiltinFunctionInvoke: Boolean
-        get() = callableIdIfNonLocal in kotlinFunctionInvokeCallableIds
+        get() = withValidityAssertion { callableIdIfNonLocal in kotlinFunctionInvokeCallableIds }

    override val valueParameters: List<KtValueParameterSymbol>
        get() = withValidityAssertion { descriptor.valueParameters.map { KtFe10DescValueParameterSymbol(it, analysisContext) } }
@@ -38,7 +38,7 @@ internal class KtFe10DescSyntheticFieldSymbol(
        }

    override val annotationsObject: Annotations
-        get() = descriptor.annotations
+        get() = withValidityAssertion { descriptor.annotations }

    override val returnType: KtType
        get() = withValidityAssertion { descriptor.propertyDescriptor.type.toKtType(analysisContext) }
@@ -25,7 +25,7 @@ class KtFe10ReceiverParameterSymbol(
    override val descriptor: ReceiverParameterDescriptor
        get() = withValidityAssertion { _descriptor }

-    override fun createPointer(): KtSymbolPointer<KtSymbol> {
+    override fun createPointer(): KtSymbolPointer<KtSymbol> = withValidityAssertion {
        TODO("Not yet implemented")
    }
 }
@@ -21,10 +21,10 @@ internal interface KtFe10DescSymbol<T : DeclarationDescriptor> : KtFe10Symbol, K
    val descriptor: T

    override val annotationsObject: Annotations
-        get() = descriptor.annotations
+        get() = withValidityAssertion { descriptor.annotations }

    val source: SourceElement
-        get() {
+        get() = withValidityAssertion {
            val descriptor = this.descriptor
            if (descriptor is CallableMemberDescriptor && descriptor.kind == CallableMemberDescriptor.Kind.FAKE_OVERRIDE) {
                val firstOverridden = descriptor.overriddenDescriptors.firstOrNull()
@@ -33,7 +33,7 @@ class KtFe10PsiClassInitializerSymbol(
    override val symbolKind: KtSymbolKind
        get() = withValidityAssertion { KtSymbolKind.CLASS_MEMBER }

-    override fun createPointer(): KtSymbolPointer<KtClassInitializerSymbol> {
+    override fun createPointer(): KtSymbolPointer<KtClassInitializerSymbol> = withValidityAssertion {
        return KtPsiBasedSymbolPointer.createForSymbolFromSource(this) ?: KtFe10NeverRestoringSymbolPointer()
    }
 }
@@ -64,7 +64,7 @@ internal class KtFe10PsiFunctionSymbol(
        get() = withValidityAssertion { false }

    override val isBuiltinFunctionInvoke: Boolean
-        get() = callableIdIfNonLocal in kotlinFunctionInvokeCallableIds
+        get() = withValidityAssertion { callableIdIfNonLocal in kotlinFunctionInvokeCallableIds }

    override val valueParameters: List<KtValueParameterSymbol>
        get() = withValidityAssertion { psi.valueParameters.map { KtFe10PsiValueParameterSymbol(it, analysisContext) } }
@@ -18,7 +18,7 @@ internal interface KtFe10PsiSymbol<P : KtElement, D : DeclarationDescriptor> : K
    val descriptor: D?

    override val annotationsObject: Annotations
-        get() = descriptor?.annotations ?: Annotations.EMPTY
+        get() = withValidityAssertion { descriptor?.annotations ?: Annotations.EMPTY }

    override val origin: KtSymbolOrigin
        get() = withValidityAssertion { psi.ktSymbolOrigin }
@@ -55,7 +55,12 @@ internal class KtFe10FunctionalType(
        get() = withValidityAssertion { type.getReturnTypeFromFunctionType().toKtType(analysisContext) }

    override val classId: ClassId
-        get() = ClassId(descriptor.functionKind.packageFqName, descriptor.functionKind.numberedClassName(descriptor.arity))
+        get() = withValidityAssertion {
+            ClassId(
+                descriptor.functionKind.packageFqName,
+                descriptor.functionKind.numberedClassName(descriptor.arity)
+            )
+        }

    override val classSymbol: KtClassLikeSymbol
        get() = withValidityAssertion { KtFe10DescNamedClassOrObjectSymbol(descriptor, analysisContext) }